The following documentation discusses cross-development with the ARM processors.

• GNUPro Toolkit features for ARM targets
• Compiler issues for ARM targets
• ABI summary for ARM targets
• The stack frame for ARM targets
• Assembler issues for ARM targets
• Linker issues for ARM targets
• Debugger issues for ARM targets
• Simulator issues for ARM
• Reducing code size on the ARM 7/7T

GNUPro Toolkit features for ARM targets

• GNUPro Instruction Set Simulator
• PID Series Evaluation board

SET PROOT=C:\cygnus\arm-<yymmdd>

SET PATH=%PROOT%\H-i386-cygwin32\BIN;%PATH%

SET INFOPATH=%PROOT%\info

REM Set TMPDIR to point to a ramdisk if you have one

SET TMPDIR=%PROOT%

• Command line options
• Assembler labels
• Linker script commands
• Section names

• GDB commands
• Assembler instructions and register names

1. Connect the serial port.

2. Test the serial connection.

(gdb) target rdi /dev/com3 

EmbeddedICE Manager (ADP, ARM7TDI) 2.02 (Advanced RISC Machines SDT 2.10) 

Connected to ARM RDI target. 

ARM7/7T-specific attributes
 

• Alignment within aggregates (structs and unions) is as above, with padding added if needed
• Aggregates have alignment equal to that of their most aligned member
• Aggregates have sizes which are a multiple of their alignment

Subroutine calls for ARM targets

The stack frame for ARM targets 

• The stack grows downwards from high addresses to low addresses.
• A leaf function need not allocate a stack frame if it does not need one.
• A frame pointer need not be allocated.
• The stack pointer shall always be aligned to 4 byte boundaries.
• The stack pointer always points to the lowest addressed word currently stored on the stack.

ARM stack frames for functions that take a fixed number of arguments

ARM stack frames for functions that take a variable number of arguments

C language calling conventions for ARM targets

Function return values for ARM targets

struct {int a:8, b:8, c:8, d:8;}

union {int i; char*p;}

struct {char A; char B; char c; char D;}

LargeType t;

t = func(arg);

LargeType t;

(void) func(&t,arg);

Assembler issues for ARM targets

Select processor variant.

Select architecture variant.

Only allow THUMB instructions.

Allow any instruction.

Select the v1.0 floating point architecture.

Select the v1.1 floating point architecture.

Don’t allow floating-point multiple instructions.

Don’t allow any floating-point instructions.

Mark the assembled code as supporting inter-working.

Mark the code as supporting the 26 bit variant of the ARM Procedure calling standard. This is the default.

Mark the code as supporting the 26 bit variant of the ARM Procedure calling standard.

Assemble code for a big endian CPU.

Assemble code for a little endian CPU. This is the default.

Assembler comments start with the @ (‘at’ symbol) and extend to the end of the line.

Register names for the ARM7/7T targets

Floating point support for ARM targets

Opcodes for ARM targets

Synthetic Instructions for ARM targets

The following code uses the ARM instruction set.

The following code uses the THUMB instruction set.

An alias for .thumb

An alias for .arm

The following code uses the THUMB instruction set, and should be assembled even if the target processor does not support THUMB instructions.

The following label is the name of function which has been encoded using THUMB instructions, rather than ARM instructions.

Start a literal pool.

ARM7/7T-specific assembler error messages

This instruction is misspelled or there is a syntax error somewhere.

An immediate value was specified that is too large for the instruction

Linker issues for ARM targets 

Linker script for ARM targets

# Linker script for ARM COFF.

# Based on i386coff.sc by Ian Taylor <ian@cygnus.com>.

test -z "$ENTRY" && ENTRY=_start

if test -z "${DATA_ADDR}"; then

if test "$LD_FLAG" = "N" || test "$LD_FLAG" = "n"; then

DATA_ADDR=.

fi

fi

cat <<EOF

OUTPUT_FORMAT("${OUTPUT_FORMAT}","${BIG_OUTPUT_FORMAT}","${LITTLE_OUTPUT_FORMAT}")

${LIB_SEARCH_DIRS}

ENTRY(${ENTRY})

SECTIONS

{

/* We start at 0x8000 because gdb assumes it (see FRAME_CHAIN).

This is an artifact of the ARM Demon monitor using the bottom 32k

as workspace (shared with the FP instruction emulator if

present): */

.text ${RELOCATING+ 0x8000} : {

*(.init)

*(.text)

*(.glue_7t)

*(.glue_7)

*(.rdata)

${CONSTRUCTING+ ___CTOR_LIST__ = .; __CTOR_LIST__ = . ;

LONG (-1); *(.ctors); *(.ctor); LONG (0); }

${CONSTRUCTING+ ___DTOR_LIST__ = .; __DTOR_LIST__ = . ;

LONG (-1); *(.dtors); *(.dtor); LONG (0); }

*(.fini)

${RELOCATING+ etext = .;}

}

.data ${RELOCATING+${DATA_ADDR-0x40000 + (. & 0xfffc0fff)}} : {

${RELOCATING+ __data_start__ = . ;}

*(.data)

${RELOCATING+ __data_end__ = . ;}

${RELOCATING+ edata = .;}

${RELOCATING+ _edata = .;}

}

.bss ${RELOCATING+ SIZEOF(.data) + ADDR(.data)} :

{

${RELOCATING+ __bss_start__ = . ;}

*(.bss)

*(COMMON)

${RELOCATING+ __bss_end__ = . ;}

}

${RELOCATING+ end = .;}

${RELOCATING+ _end = .;}

${RELOCATING+ __end__ = .;}

.stab 0 ${RELOCATING+(NOLOAD)} :

{

[ .stab ]

}

.stabstr 0 ${RELOCATING+(NOLOAD)} :

{

[ .stabstr ]

}

}

EOF

Debugger issues for ARM targets

• Simulator

GDB's built-in software simulation of the ARM7 processor allows the debugging of programs compiled for the ARM7/7T without requiring any access to actual hardware. For this target the linker script sim.ldmust be specified at compilation. To activate this mode in GDB, type target sim and then load the code into the simulator by typing load and debug it in the normal fashion.
• Remote target board

For this target the linker script eval.ld must be specified at compilation. To connect to the target board in GDB, using the
target remote <devicename> command, where <devicename> will be a serial device such as /dev/ttya (UNIX) or com2 (Windows NT). Then load the code onto the target board by typing the load command. After being downloaded, the program can be executed.

Simulator issues for ARM targets

Reducing code size on the ARM 7/7T 

 

1. Create source code.

int main (void) { return 7 + thumb_func (7); }

Create the following sample source code and save it as thumb_tuff.c .

int thumb_func (int arg) { return arg + 7; }

2. Compile and link from source code.

Then compile the THUMB sample code with the following declaration.

THUMB-coff-gcc -g -c -O2 -mthumb-interwork THUMB_stuff.c

Then link with the following declaration.

arm-coff-gcc arm_stuff.o thumb_stuff.o -o program

The use of the -g and -O2 command line options are optional. They are used in the previous examples to make the output of the debugger easier to understand.

Run on the stand-alone Simulator for ARM 7/7T targets

C:\> arm-coff-gdb program 

GNU gdb 4.16-armT-970630 

Copyright 1997 Free Software Foundation, Inc.GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. 

Type "show copying" to see the conditions. This version of GDB is supported for customers of Cygnus Solutions. Type "show warranty" for details. This GDB was configured as "--host=i686-pc-linux-gnu 

--target=arm-acorn-coff"... 

(gdb) target sim 

Connected to the simulator. 

(gdb) load 

Loading section .text, size 0x8e8 lma 0x8000 

Loading section .data, size 0x2fc lma 0x408e8 

Start address 0x8000 

Transfer rate: 24352 bits in <1 sec. 

(gdb) break main 

Breakpoint 1 at 0x8048: file arm_stuff.c, line 2. 

(gdb) break thumb_func 

Breakpoint 2 at 0x8060: file thumb_stuff.c, line 1. 

(gdb) run 

Starting program: /elmo/scratchme/nickc/work/released/arm/gcc/tests/program 

Breakpoint 1, 0x8048 in main () at arm_stuff.c:2 

2 int main (void) { return 7 + thumb_func (7); } 

(gdb) disassemble 

Dump of assembler code for function main: 

0x803c <main>: mov ip, sp 

0x8040 <main+4>: stmdb sp!, {fp, ip, lr, pc} 

0x8044 <main+8>: sub fp, ip, #4 

0x8048 <main+12>: bl 0x8124 <__gccmain> 

0x804c <main+16>: mov r0, #7 

0x8050 <main+20>: bl 0x88b0 <__thumb_func_from_arm> 

0x8054 <main+24>: add r0, r0, #7 

0x8058 <main+28>: ldmdb fp, {fp, sp, lr} 

0x805c <main+32>: bx lr 

End of assembler dump. 

(gdb) continue 

Continuing. 

Breakpoint 2, thumb_func (arg=7) at thumb_stuff.c:1 

1 int thumb_func (int arg) { return 7 + arg; } 

(gdb) disassemble 

Dump of assembler code for function thumb_func: 

0x8060 <thumb_func>: 3007 add r0, #7 

0x8062 <thumb_func+2>: 4770 bx lr 

End of assembler dump. 

(gdb) quit 

The program is running. Quit anyway (and kill it)? (y or n) y