基本的ATPCS规则

4.2.1  基本的ATPCS规则

基本ATPCS规定了在子程序调用时的一些基本规则，包括下面四方面的内容。

各寄存器的使用规则及其相应的名称。

数据栈的使用规则。

参数传递的规则。

子程序结果的返回规则。

1. 寄存器的使用规则及其相应的名称

寄存器的使用必须满足下面的规则。

子程序间通过寄存器R0～R3来传递参数，被调用的子程序在返回前无需恢复寄存器R0～R3的内容。

在子程序中，使用寄存器R4～R11保存局部变量，这时寄存器可以记作V1～V8。如果在子程序中用到了寄存器V1～V8中的某些寄存器，子程序进入时必须保存这些寄存器的值，在返回前必须恢复这些寄存器的值；对于子程序中没有用到的寄存器则不必进行这些操作。在Thumb程序中，通常只能使用寄存器R4～R7来保存局部变量。

寄存器R12用作子程序间的Scratch寄存器(用于保存SP， 在函数返回时使用该寄存器出栈)，记作IP。

寄存器R13用作数据栈指针，记作SP。在子程序中寄存器R13不能用作其他用途。寄存器SP在进入子程序时的值和退出子程序的值必须相等。

寄存器R14称为连接寄存器，记作LR。它用作保存子程序的返回地址。如果在子程序中保存了返回地址，寄存器R14则可以用作其他用途。

寄存器R15是程序计数器，记作PC。它不能用作其他用途。

ATPCS中的各寄存器在ARM编译器和汇编器中都是预定义的。

表4-1总结了在ATPCS中各寄存器的使用规则及其名称。

表4-1  寄存器的使用规则

寄存 器	别 名	特殊名称	使 用 规 则
R15		PC	程序计数器
R14		LR	连接寄存器
R13		SP	数据栈指针
R12		IP	子程序内部调用的Scratch寄存器
R11	V8		ARM状态局部变量寄存器8
R10	V7	Sl	ARM状态局部变量寄存器7 在支持数据检查的ATPCS 中为数据栈限制指针

(续表)

寄 存器	别名	特殊名称	使 用 规 则
R9	V6	SB	ARM状态局部变量寄存器6 在支持RWPI的ATPCS 中为静态基址寄存器
R8	V5		ARM状态局部变量寄存器5
R7	V4	WR	ARM状态局部变量寄存器4 Thumb状态工作寄存器
R6	V3		局部变量寄存器3
R5	V2		局部变量寄存器2
R4	V1		局部变量寄存器1
R3	A4		参数/结果/Scratch寄存器4
R2	A3		参数/结果/Scratch寄存器3
R1	A2		参数/结果/Scratch寄存器2
R0	A1		参数/结果/Scratch寄存器1

2. 数据栈的使用规则

栈指针是保存了栈顶地址的寄存器值。栈指针通常可以指向不同的位置。一般的，栈可以有以下四种数据栈。

FD：Full Descending

ED：Empty Descending

FA：Full Ascending

EA：Empty Ascending

当栈指针指向与栈顶元素时，称为Full栈。当栈指针指向与栈顶元素相邻的一个元素时，称为Empty栈。数据栈的增长方向也可以不同，当数据栈向内存减少的地址方向增长时，称为Descending栈；反之称为Ascending栈。ARM的ATPCS规定默认的数据栈为Full Descending(FD)类型，并且对数据栈的操作是8字节对齐的。

3. 参数传递的规则

根据参数个数是否固定可以将子程序参数传递规则分为以下两种。

(1) 参数个数可变的子程序参数传递规则

对于参数个数可变的子程序，但参数不超过四个时，可以使用寄存器R0～R3来传递参数；当参数超过四个时，还可以使用数据栈来传递参数。在传递参数时，将所有参数看作是存放在连续的内存单元中的字数据。然后，依次将各字数据传送到寄存器R0、R1、R2、R3中，如果参数多于四个，则将剩余的字数据传送到数据栈中，入栈的顺序与参数顺序相反，即最后一个字数据先入栈。

(2) 参数个数固定的子程序参数传递规则

对于参数个数固定的子程序，参数传递与参数个数可变的子程序参数传递的规则不同，如果系统包含浮点运算的硬件部件，浮点参数将按各个浮点参数按顺序处理和为每个浮点参数分配FP寄存器的规则传递。分配的方法是，满足该浮点参数需要的且编号最小的一组连续的FP寄存器中，第一个整数参数，通过寄存器R0～R3来传递，其他参数通过数据栈传递。

4. 子程序结果返回规则

子程序中结果返回的规则如下。

如果结果为一个32位的整数，可以通过寄存器返回。

如果结果为一个64位整数，可以通过寄存器R0和R1返回，依此类推。

如果结果为一个浮点数，可以通过浮点运算的寄存器F0、D0或S0返回。

如果结果为复合型的浮点数(如复数)，可以通过寄存器F0～FN或者D0～DN返回。

对于为数更多的结果，需要通过内存来传递。

 

4.2.2  C语言中内嵌汇编代码

在C程序中内嵌的汇编代码指令支持大部分的ARM和Thumb指令，不过其使用与汇编文件中的指令有些不同，主要存在以下几个方面的限制。

在使用物理寄存器时，不要使用过于复杂的C表达式，避免物理寄存器冲突。

不能直接向PC寄存器赋值，程序跳转要使用B或者BL指令。

R12和R13可能被编译器用来存放中间编译结果，计算表达式值时又能将R0到R3， R12及R14用于子程序调用，因此要避免直接使用这些物理寄存器。

一般不要直接指定物理寄存器，而是让编译器进行分配。

ARM汇编和C混合编程最简单的方法就是内联汇编(Inline Assemble)和嵌入式汇编(Embedded Assemble)。

内联汇编是指在C函数定义中使用__asm或者asm的方法，用法如下：

__asm
{
instruction[; instruction]
… …
[instruction]
}

或者

asm("instruction[; instruction]");

下面给出一个具体的示例用法：

#include<stdio.h>
void my_story(const char *src，char *dest)   ;函数定义，参数为一个常量字符指针src和一
                                    ;个变量字符指针dest，功能将src复制到dest
{
char ch;                            ;定义一个字符变量
__asm                           ;内嵌汇编代码标识
        {
        loop:                           ;循环体
            ldrb    ch，[src]，#1             ;ch=[src+1]
            strb    ch，[dest]，#1            ;[dest+1]=ch
            cmp ch，#0                   ;判断字符串是否结束，结束ch=0
            bne loop                    ;不为0，则跳转到loop继续循环
        }
}
int main()                          ;主函数
{
char *a="hello，arm";                    ;定义字符串常量a="hello，arm"
char b[64];                         ;定义字符串变量
my_strcpy(a，b);                     ;调用my_strcpy函数
printf("original:%s"，a);                    ;输出结果
printf("copyed:%s"，b);
return 0;                           ;返回
}

内联汇编的用法跟真实汇编之间有很大的区别，并且不支持Thumb。与内联汇编不同，嵌入式汇编具有真实汇编的所有特性，同时支持ARM和Thumb，但是不能直接引用C语言的变量定义，数据交换必须通过ATPCS进行。嵌入式汇编在形式上表现为独立定义的函数体，如下所示。

_asm int add(int i，int j)                   //定义嵌入式汇编
{
ADD R0，R0，R1                            //R0R0=R0+R1
    MOV PC，LR
}
void main()
{
    printf("12345+6789=%d\n"，add(12345，6789));
}

灵活使用内联汇编和嵌入式汇编，可以提高程序的效率。

4.2.3  从汇编程序中访问C程序变量

在C程序中声明的全局变量可以被汇编程序通过地址间接访问，具体访问方法如下。

使用IMPORT伪指令声明该全局变量。

使用LDR指令读取该全局变量的内存地址，通常该全局变量的内存地址值存放在程序的数据缓冲区中。

根据该数据的类型，使用相应的LDR指令读取该全局变量的值，使用相应的STR指令修改该全局变量的值。

各数据类型及其对应的LDR/STR指令如下。

对于无符号的char类型的变量通过指令LDRB/STRB来读写。

对于无符号的short类型的变量通过指令LDRH/STRH来读写。

对于int类型的变量通过指令LDR/STR来读写。

对于有符号的char类型的变量通过指令LDRSB来读取。

对于有符号的char类型的变量通过指令STRB来写入。

对于有符号的short类型的变量通过指令LDRSH来读取。

对于有符号的short类型的变量通过指令STRH来写入。

对于小于8个字节的结构型变量，可以通过一条LDM/STM指令来读写整个变量。

对于结构型变量的数据成员，可以使用相应的LDR/STM指令来访问，这时必须知道该数据成员相对于结构型变量开始地址的偏移量。

下面是一个汇编程序访问C程序全局变量的具体例子：

AREA    global_exp，CODE，READONLY
EXPORT  asmsub
IMPORT  globv           ;声明全局变量
asmsub
    LDR     r1，=globv           ;将内存地址读入到r1中
    LDR     r0，[r1]         ;将数据读入到r0中
    ADD     r0，r0，#2
    STR     r0，[r1]         ;修改后再将值赋给变量
    MOV pc，lr
    END

程序中，变量globv是在C程序中声明的全局变量，在汇编程序中首先使用IMPORT伪指令声明该变量，再将其内存地址读入到寄存器r1中，将其值读入到寄存器r0中，修改后再将寄存器r0的值赋给变量globv。

4.2.4  汇编代码中调用C函数

汇编代码中调用C函数，关键是解决参数传递和函数返回问题。

1. 参数传递问题

如果所传递的参数少于四个，则直接使用R0~R3来进行传递，如果参数多于四个，则必须使用栈来传递多余的参数。

2. 函数返回问题

因为在编译C函数的时候，编译器会自动在函数入口的地方加上现场保护的代码(如部分寄存器入栈，返回地址入栈等)，在函数出口的地方加入现场恢复的代码(即出栈代码)。

下面是来看汇编代码调用C函数中两个参数个数不同的例子。

例1. 参数个数为四个

asm_test1.asm代码如下：

IMPORT c_test1                      ;声明c_test1函数
AREA TEST_ASM， CODE， READONLY   ；定义代码段TEST_ASM，属性只读
EXPORT asm_test1
1
str lr， [sp， #-4]!                      ;保存当前lr
ldr r0，=0x01                        ;第一个参数r0
ldr r1，=0x02                            ;第二个参数r1
ldr r2，=0x03                            ;第三个参数r2
ldr r3，=0x04                        ;第四个参数r3
bl c_test1                              ;调用C函数
LDR pc， [sp]， #4                    ;将lr装进pc，返回main函数
END

c_test1.c代码如下：

void c_test1(int a，int b，int c，int d)
{
        printk("c_test1:\n");               //输出结果到内核缓冲区
        printk("%0x %0x %0x %0x\n"，a，b，c，d);
}

main.c中的代码如下：
int main()
{
     asm_test1();                       //调用汇编程序
     for(;;);
}

程序说明：

程序从main函数开始执行，main调用了asm_test1，asm_test1调用了c_test1，最后从asm_test1返回main。这里面有两个函数：一个是用ARM汇编语言写的arm_test1.asm程序；另一个是用C语言写的c_test1.c程序。其中汇编程序asm_test1.asm调用了C函数c_test1.c。这里的参数个数没有超过四个，所以只用了R0~R3四个寄存器进行传递。这里请注意asm_test1.asm中"asm_test1"标记下第一行代码，在调用c_test1之前必须把当前的lr保存到堆栈。在调用完c_test1之后再把刚才保存在堆栈中的lr写入到pc中去，这样才能返回到main函数中。

例2. 参数个数大于四个

arm_test2.asm代码如下：

 IMPORT c_test2 ;声明c_test2函数
 AREA TEST_ASM， CODE， READONLY
 EXPORT arm_test2
t2
str lr， [sp， #-4]!      ;保存当前lr
ldr r0，=0x01            ;第一个参数r0
ldr r1，=0x02            ;第二个参数r1
ldr r2，=0x03            ;第三个参数r2
ldr r3，=0x04            ;第四个参数r3
ldr r4，=0x08
str r4，[sp，#-4]!        ;第八个参数，压入堆栈
ldr r4，=0x07
str r4，[sp，#-4]!        ;第七个参数，压入堆栈
ldr r4，=0x06
str r4，[sp，#-4]!        ;第六个参数，压入堆栈
ldr r4，=0x05
str r4，[sp，#-4]!        ;第五个参数，压入堆栈
bl c_test2              ;调用C函数
add sp， sp， #4      ;清除栈中第五个参数，执行完后sp指向第六个参数
add sp， sp， #4      ;清除栈中第六个参数，执行完后sp指向第七个参数
add sp， sp， #4      ;清除栈中第七个参数，执行完后sp指向第八个参数
add sp， sp， #4      ;清除栈中第八个参数，执行完后sp指向lr
ldr pc， [sp]，#4         ;将lr装进pc，返回main函数
 END

c_test2.c代码如下：

void c_test2(int a，int b，int c，int d，int e，int f，int g，int h)
{
       printk("c_test2_lots:\n");               //输出结果到内核缓冲区
       printk("%0x %0x %0x %0x %0x %0x %0x %0x\n"，
              a，b，c，d，e，f，g，h);
}

main.c代码如下：

int main()
{
     arm_test2();           //调用汇编程序
     for(;;);
}

程序说明：

这部分的代码和例1的代码大部分是相同的，主要区别在于参数的个数不同。这里的参数个数大于四个，需要使用堆栈来进行参数传递。第一个到第四个参数还是通过R0~R3四个寄存器进行传递的。第五个到第八个参数则是通过把其压入堆栈的方式进行传递，不过要注意第五个到第八个这四个入栈参数的入栈顺序，是以第八个参数、第七个参数、第六个参数、第五个参数的顺序入栈，出栈的顺序正好相反，依次为第五个参数、第六个参数、第七个参数、第八个参数。这里同样要注意调用汇编语言的开头保存好lr，以便在最后恢复pc，返回到main函数。

4.2.5  C语言代码中调用汇编函数

C语言中调用汇编函数所涉及的关键点也是参数传递和函数返回问题。

1. 参数传递

在编译时，编译器将会对C函数的实参使用R0~R3进行传递(如果超过四个参数，则其余的参数使用栈进行传递)，因此汇编函数可以直接使用R0~R3寄存器进行计算。

2. 函数返回

由于汇编代码是不经过编译器处理的代码，所以现场保护和返回都必须由程序员自己完成。通常情况下现场保护代码就是将本函数内用到的R4~R12寄存器压栈保护，并且将R14寄存器压栈保护，汇编函数返回时将栈中保护的数据弹出。

假设要设计一汇编函数，完成两整数相减(假设必须用R7和R8寄存器完成)，并在C函数中调用。设计代码如下：

;汇编代码文件
    ;asses.S
    EXPORT sub1 ;声明该函数
    … …
    AREA Init，CODE，READONLY
    ENTRY
    … …
sub1
    STMFD sp!，{r7-r8，lr};保存现场
    MOV R7，R0   ;通过R0，R1寄存器传送参数
    MOV R8，R1
    SUB R7，R8
    MOV R0，R7
    LDMFD sp!，{r7-r8，pc};返回
    … …
    END
    //C文件
    //main.c
    int sub1(int，int);//函数声明
    … …
    int Main(  )
    {
        int x=20，y=10;
        sub1(x，y) ;
    }
    … …

备注：其实在上面例子中可以不用保存LR寄存器，但是如果在此汇编函数中调用其他函数，就必须保存LR寄存器了。
====