S3C2440-Bare Metal Edition-04 | ARM-THUMB Subroutine Calling Rules ATPCS

In the GPIO experiment, we first wrote an assembly program to operate the register to light up the LED. However, the readability and portability of assembly language are too poor, so we wrote the startup code, set the stack pointer SP, and then called the main function in C language to enter the world of C language. The C language accessed the control register and lit up the LED. The readability and portability of the program were greatly improved. So, have we ever thought about how to call the C language entry function main in assembly language?

In fact, for ARM processors, the rules for subroutine calls are formulated in the ARM instruction set assembler and the THUMB instruction set assembler - the ATPCS rules, which include:

• Register Usage Rules

• Data stack usage rules

• Parameter passing rules

1. Register usage rules

There are 16 registers R0-R15 in the ARM processor. Each register has a usage specified by the ATPCS rules and an alias specified according to its usage, as shown in the following table:

Summarized as follows:

• Parameters are passed and results are returned between subroutines through registers R0-R3;

• In the subroutine, local variables are saved through registers R4-R11;

• Register R12 is used as the scratch register between subroutines;

• Register R13 is used as a data stack pointer, pointing to the top of the stack;

• Register R14 is used as a link register to store the return address of the subroutine;

• Register R15 is used as the program counter;

2. Data stack usage rules

ATPCS stipulates that the data stack is of FD type (Full Descending), that is, the stack pointer points to the top element of the stack and grows in the direction of decreasing memory address. During operation, the data stack is 8-byte aligned, and the stmdb/ldmia batch memory access instructions are used to operate the FD data stack.

The FD type data stack operates specifically as follows:

• When saving content, first decrement the SP pointer and then save the data;

• When restoring data, first obtain the data and then increment the SP pointer;

3. Parameter passing rules

• When calling a function, if there are no more than 4 parameters, they are passed in sequence using R0-R3. If there are more than 4 parameters, the remaining parameters are passed through the data stack.

• When a function returns a result, it is passed in sequence using R0-R3;

Experiment - Experiment on passing parameters when calling functions in assembly

1. Purpose

Calling functions in assembly language and passing parameters.

2. Experimental content

The main function defines the parameters. If the passed parameter is 1, the first LED is turned on. If the passed parameter is 2, the second LED is turned on.

3. Experimental Code

3.1. Startup Code

@ brief: S3C2440 startup file

@ author: mculover666

.text

.global _start

_start:

@ Disable watchdog

LDR R0,=0x53000000

MOV R1,#0

STR R1,[R0]

@ Set the stack top pointer SP (start from Nand)

LDR SP,=4096

@ Call led_on with parameter 1 to turn on the first LED

LDR R0,=1

BL led_on

@ Pass parameter 100000, call delay, delay

LDR R0,=100000

BL delay

@ Call led_on with parameter 2 to turn on the second LED

LDR R0,=2

BL led_on

@ Program Pause

halt:

B halt

3.2.C code

void delay(volatile int xms)

{

while(xms--);

}

int led_on(int led)

{

if(led == 1)

{

/* Set the GPFCON register to configure the GPF4 pin as output mode*/

*(unsigned int *)0x56000050 &= ~(3<<(2*4));

*(unsigned int *)0x56000050 |= 1<<(2*4);

/* Set the GPF DAT register, GPF4 outputs low level, and lights up the LED */

*(unsigned int *)0x56000054 &= ~(1<<4);

}

else if(led == 2)

{

/* Set the GPFCON register to configure the GPF4 pin as output mode*/

*(unsigned int *)0x56000050 &= ~(3<<(2*5));

*(unsigned int *)0x56000050 |= 1<<(2*5);

/* Set the GPF DAT register, GPF4 outputs low level, and lights up the LED */

*(unsigned int *)0x56000054 &= ~(1<<5);

}

return 0;

}

3.3. Compilation

TARGET = led_blink

CFLAGS = -Wall # Output all warnings

$(TARGET).bin:$(TARGET).elf

arm-linux-objcopy -O binary -S $(TARGET).elf $(TARGET).bin

#Note: The startup file must be linked first

$(TARGET).elf:start.o $(TARGET).o

arm-linux-ld -Ttext 0 start.o $(TARGET).o -o $(TARGET).elf

$(TARGET).o:$(TARGET).c

arm-linux-gcc -c $(TARGET).c $(CFLAGS) -o $(TARGET).o

start.o:start.s

arm-linux-gcc -c start.s $(CFLAGS) -o start.o

clean:

rm -rf *.o *.elf *.bin

download_to_nand:

#Download to nand flash

oflash 0 1 0 0 0 $(TARGET).bin

4. Download and run

The program starts running and the first LED lights up:

After a delay of about 1s, the second LED is also lit:

5. Experimental Summary

Through this experiment, we have mastered the use of ATPCS rules in actual development. When calling the main function, we use the R0 register to pass parameters, which is summarized as follows:

• The subroutine calling rules in ARM processors are formulated by ATPCS, including register usage rules, data stack usage rules, and parameter passing rules;

• R0-R3 can pass parameters/results, R4-R11 can store local variables, R13 is the data stack pointer SP, and R14 stores the subroutine return address;

• The data stack in ATPCS is of FD type, i.e. full-decreasing type;

• In ATPCS, parameters are passed in sequence using R0-R3. If there are more than 4 parameters, the rest are passed using the data stack.