ARM汇编笔记（2）——函数调用规则

（本文所介绍的各个约定与32位arm Linux系统C语言toolchain一致）

1. 栈
栈保存着函数调用中的参数，寄存器上下文，局部变量。ARM中函数返回地址是寄存器上下文的一部分（lr），无需单列。
栈由高地址向低地址增长，也就是说push会导致栈顶指针指向较低的地址，而pop则相反。
同时约定了栈顶指针指向的是入栈的最后一个值的位置，而非下一个入栈位置。

2. 控制转移和寄存器上下文
高级语言的函数调用在arm汇编中通过bl和bxl指令来实现。
bl和bxl在执行时只做了两件事：1）pc值存入lr；2）更新pc。因此，诸如寄存器上下文保存和恢复等操作必须由被调用者完成。
被调用函数保存寄存器上下文时，只需保存自己将要使用的寄存器的值即可。r0~r3无需作为上下文进行保存。这里要注意的是如果被调用者同时也调用了其他函数的话必须保存lr（返回地址），因为lr将在内部的调用中被改写。
在函数返回时，如果lr被保存，将该值从内存中读出赋给pc即可；否则当前lr即为返回地址，直接bx lr。

3. 参数传递
参数的前4个字（32*4 bits）通过寄存器r0~r3来传递，多出的内容从栈上传递。对于小于一个字长度的参数（如char, short类型）也当作一个字来传。C语言中arm与x86相同，参数都是按照由右向左的顺序压栈，参数的退栈由调用者负责。

4. 返回值
对于返回值，如果大小在一个字以内直接存入r0即可。
若返回值大小大于一个字长度（比如一个结构体），则该函数实际上会被改写，例如：

typedef struct {
    int v1;
    int v2;
} data_t;

data_t test(int a, int b) {
    data_t r;
    r.v1 = a+b;
    r.v2 = a-b;
    return r;
}

test函数会在编译器内部被改写成：

void test(data_t *r, int a, int b) {
    r->v1 = a+b;
    r->v2 = a-b;
}

调用者的代码也会在编译器内部做相应调整。
这样一来，在汇编层，调用者会把分配好的data_t指针赋值给r0，然后再把a和b赋值给r1和r2。至于返回值，可以认为是void，也可以认为直接将data_t的指针返回了。

5. 实例

5.1 最简单的函数

int test(int a, int b) {
    return a + b;
}

汇编为

test:
add r0, r0, r1     ;test没有调用其它函数，所以不用保存lr的上下文
bx  lr             ;返回

5.2 调用其它函数

int test(int a, int b) {
    return a + b;
}

int test2(int a, int b, int c, int d) {
    int e = test(a+b, c-d);
    return a + b + e;
}

汇编为

test:
add r0, r0, r1
bx  lr

test2:
push   {r4, r5, lr}   ;保存寄存器上下文
mov    r4, r0         ;r4 = a
mov    r5, r1         ;r5 = b
add    r0, r0, r1     ;r0 = a + b
sub    r1, r2, r3     ;r1 = c - d
bl     test           ;调用test
mov    r2, r0         ;r2 = e
add    r0, r4, r5     ;r0 = a + b
add    r0, r0, r2     ;r0 = a + b + e
pop    {r4, r5, pc}   ;恢复寄存器上下文并返回

5.3 带有多于4个字的参数的函数及其调用

int test(int a, int b, int c, int d,
         int e, int f) {
    return a+b+c+d+e+f;
}

int test2() {
    return test(1,2,3,4,5,6);
}

汇编为

test:
add   r0, r0, r1     ;r0 = a+b
add   r0, r0, r2     ;r0 = a+b+c
add   r0, r0, r3     ;r0 = a+b+c+d
ldr   r1, [sp, #0]   ;r1 = e
ldr   r2, [sp, #4]   ;r2 = f
add   r0, r0, r1     ;r0 = a+b+c+d+e
add   r0, r0, r2     ;r0 = a+b+c+d+e+f
bx    lr             ;返回

test2:
push  {lr}           ;保存寄存器上下文
mov   r0, #5         ;r0 = 5
mov   r1, #6         ;r1 = 6
push  {r1, r0}       ;压栈，6在高地址5在低地址
mov   r0, #1         ;r0 = 1
mov   r1, #2         ;r1 = 2
mov   r2, #3         ;r2 = 3
mov   r3, #4         ;r3 = 4
bl    test           ;调用test
add   sp, sp, #8     ;退栈，释放之前为参数5和6分配的空间
pop   {pc}           ;恢复寄存器上下文并返回

5.4 结构体作为参数和返回值

typedef struct {
    int a;
    int b;
} data_t;

data_t test(data_t c) {
    return (data_t){c.a + c.b, c.a - c.b};
}

int test2(int a, int b) {
    data_t x = {a, b};
    data_t y = test(x);
    return y.a + y.b;
}

汇编为（经过一定优化）

test:
add   r3, r1, r2       ;r3 = c.a + c.b
str   r3, [r0]         ;r0->a = c.a + c.b
sub   r3, r1, r2       ;r3 = c.a - c.b
str   r3, [r0, #4]     ;r0->b = c.a - c.b
bx    lr               ;返回

test2:
push  {lr}             ;保存寄存器上下文
push  {r1, r0}         ;x = {a, b}
sub   sp, sp, #8       ;y = {    }
mov   r0, sp           ;r0 = &y
ldr   r1, [sp, #8]     ;r1 = x.a
ldr   r2, [sp, #12]    ;r2 = x.b
bl    test             ;调用test
ldr   r1, [r0]         ;r1 = y.a
ldr   r2, [r0, #4]     ;r2 = y.b
add   r0, r1, r2       ;r0 = y.a + y.b
add   sp, sp, #16      ;退栈，释放x和y的空间
pop   {pc}             ;恢复寄存器上下文并返回