gnuarm and qemu

This tutorial explains compiling arm programs with gnuarm and porting it into qemu emulator.

Requirements: ( ubuntu linux )

1. gnuarm toolchain ( www.gnuarm.com )
2. qemu emulator ( sudo apt-get install qemu )

okie.. so here is the step

save the code in add.s

------------------------------------------

.text

start:

mov r0, #5 @r0 <----- 5

mov r1, #4 @r0 <----- 4

add r2, r1, r0

stop:

b stop @infinite loop to stop execution

------------------------------------------

.text is an assembler directive which says that the following section have to be assembled into the code section, rather than the .data section. So what is sections ?

So next is compiling the code with gnuarm toolchain.

arm-elf-as -o add.o add.s

this will assemble the code into an outputfile

arm-elf-ld -Ttext=0x0 -o add.elf add.o

-Ttext=0x0, specified that address should be assigned to the labels, such that the instructions were starting from address 0x0

arm-elf-nm add.elf

To view the address assigned for various labels.

The output file created by ld is in elf format. there are various formats available for storing executable code.

The elf format works fine when you have the os around.

Here we are going to run the program on a bare metal, we have to convert it into a simple binary format.

arm-elf-objcopy -O binary add.elf add.bin

to convert elf to binary format

ls -al add.bin

-rwxr-xr-x 1 akku akku 16 2010-05-24 10:17 add.bin

check the size it is 16bytes, 4 instructions ---> 4bytes ( 32 bit ) each

So we got the simple binary file which has to be flashed into the board.

So next is porting the binary file into qemu arm emulator

ARM processor on reset it will start executing from 0x0 ( whatever there is.. ram, rom, flash ).

On connex board 16MB flash is located at that address. So ARM executes instructions from 0x0 of the flash.

So we need a flash to use with qemu. For that we create a flash file and load it with full of zeros first.

dd if=/dev/zero of=flash.bin bs=4096 count=4096

add.bin file is copied into the beginning of this flash file

dd if=add.bin of=flash.bin bs=4096 conv=notrunc

this is equivalent of programming the bin file onto the flash memory.

Next start qemu

qemu-system-arm -M connex -pflash flash.bin -nographic -serial /dev/null

-M connex : specifies the machine connex to be emulated

-pflash : specifies that flash.bin represents the flash memory

-nographic : specifies that simulation of a graphic display is not required.

-serial /dev/null : specifies that serial port of the connex board is to be connected to /dev/null, so that the serial port data is discarded.

(qemu) info registers

check register R02 it will be 00000009

Referance:

http://www.bravegnu.org/gnu-eprog/hello-arm.html

living with ax4510 Board....

The board is based on the processor S3C4510B (ARM7TDMI).. So development requires 2 things...

1. Toolchain: to compile the code
2. Uploader: to upload the code

Toolchain: a collection of tools which produce end binary to run on a particular board.
cpp ----> gcc ----> as ----> ld
( cpp, gcc ) : Partially generated and downloaded source is compiled into executables

( as, ld ) : Existing executables are directly used (eg for ld:glibc/newlib ). May be h/w stds and std files for a board.

---------------------------------------------------
Two are required for porting other than u r C code.

1. Startup code : assembler code which does low-level hardware initialization and sets up such things as stack.
2. linker script : which will tell to the linker where to put which sections of your complied code

The function of the assembler startup file is to run the C program.The linker script explains to the linker where in the memory to put what.

Linker Script contains:
ENTRY : ENTRY( _startup ) means _startup as entry point, which is defined in the startup file and which is visible to linker as it is declared as global.

MEMORY:

MEMORY
   {
        RAM (rw) : ORIGIN = 0x40000200, LENGTH = (0x00002000 - 0x00000200 - 0x20 - 0x100)
   }

RAM as Read/Write region of memory with origin and length of different sections.

SECTIONS:
.text
.rodata for read-only data
.data read or write data
.bss for zero-initialized statically allocated variables.


References:
http://only.mawhrin.net/~alexey/prg/lpc2103/tutorial-hello/
http://www.cse.iitb.ac.in/~uday/courses/cs715-09/gcc-code-view.pdf