AArch64 学习 (二) 函数调用 (Function Call Convention)

Posted on In , Word count in article: 2.4k Reading time ≈ 9 mins.

本系列的第一篇 中介绍了 AArch64 的基础指令、进程内存布局以及基础栈操作 等。本文该系列的第二篇，主要聊聊函数调用，涉及到的就是 Function Call Convention. 初衷还是尽可能 “浅入深出” 地 got 到语言背后的本质，这不是一个手册，所以不是完备的.

1. 我们在聊函数调用的时候在聊什么？

至少我们应该把函数调用的几个问题搞清楚:

  1. 函数在汇编层是怎么调用的，本质是什么？
  2. 函数的参数怎么传？
  3. 返回值写到哪里？怎么传给 caller?
  4. 调用完之后，怎么返回到原来的位置？

Function Call Convention 其实就是回答这些问题的，接下里我们一一找到答案.

1.1. 函数调用本质是什么？

汇编层是没有函数的概念的，我们需要把函数映射到汇编层来，这样我们就知道了它的本质。其实执行一个程序，在汇编层来看就是不断的执行 CPU 指令，都执行完了，进程就结束了。从第一篇的例子其实可以看出，一个函数就是一个 label, 等于代码段中该函数第一条指令的位置。其实本质上函数调用，就是程序从代码段的某一条指令，跳转到另外一个地址上的指令去执行。稍微复杂点的 C 程序都不是从头执行到尾就结束了，会有条件判断，函数调用。函数调用和普通跳转不同的地方在于要处理传参、返回、以及寄存器的 backup 和恢复.

AArch64 提供给我们了一个 bl (branch with link) 指令，用来执行指定的函数。第一篇里，我们介绍了 cmp 以及 b.le/b.ge 等，‘b’ 在这两处都是 branch 跳转的意思.

只不过 bl 是跳转的函数地址上，bl 内部实现是这样的:

  1. 跳转之前会把函数调用后面地址 (也就是 bl 的下一条指令的地址) 存放到 LR (Link register) 中
  2. PC 被 bl 的参数替换，就是 PC 指向了 bl 的参数，通常是一个函数 label, 对应着一个地址
  3. 目标函数开始执行
  4. 目标函数执行完，调用 ret 指令，ret 会把 LR copy 回 PC
  5. 程序执行 PC, 也就是执行原来 bl 下一条指令了

1.2. AArch64 Call Convention 约定

  1. 把需要保存的寄存器值入栈，避免被即将调用的函数修改
  2. AArch64 中，X0-X7 8 个通用寄存器用来保存函数调用的前 8 个参数，超过 8 个的，通过入栈来传递.
  3. 返回值默认存入 X0 或者 X0 + X1 寄存器中
  4. 执行 bl 跳转，跳转到目标函数
  5. 目标函数如果有返回值，把返回值放入 X0, 然后执行 ret
  6. 取出返回值，然后出栈，恢复寄存器中的值

ps: 还有一种间接传递返回值的方式，该方式会使用 XR (X8) 进行间接的返回，后文会介绍这种 case.

2. 看一个简单函数调用例子

1
2
3
4
5
6
7
8
long add(long x, long y) {
    return x + y;
}

int main() {
    long z = add(1, 2);
    return 0;
}

对应的 AArch64 的汇编代码:
ps: 这里为了方便阅读，我把 add 函数调整到了 main 的后面，下同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
main:                                   // @main
  // 1. 分配 48 字节的栈空间, 使用情况见 step 11
  sub     sp, sp, #48                     // =48

  // 2. stp 和 str 类似, 区别是 stp 一次保存多个
  // 这里等于把 x29/FP => [sp + 32], x30/LR => [sp + 40]
  stp     x29, x30, [sp, #32]             // 16-byte Folded Spill

  // 3. x29 = sp + 32
  add     x29, sp, #32                    // =32

  // 4. w8 = 0, 然后存入后面能用到
  mov     w8, wzr

  // 5. x29-4 = sp+32-4 = sp + 28
  stur    wzr, [x29, #-4]

  // 6. 把字面量 1 和 2 放入 X0, X1, 作为入参传给 add
  mov     x0, #1
  mov     x1, #2

  // 7. 前面把 w8 置为 0, 这里相当于在 sp+12 位置保存了一个 0
  str     w8, [sp, #12]                   // 4-byte Folded Spill

  // 8. 函数调用
  bl      add(long, long)

  // 9. 把 X0 也就是返回值, 放入 sp + 16 中
  str     x0, [sp, #16]

  // 10. 因为 main 的返回值是 int, 4 字节, 所以用的是 w0, sp+12 前面我们知道保存的是 0
  // 所以这里相当于把 0 放入了 w0, 作为 main 函数的返回值
  ldr     w0, [sp, #12]                   // 4-byte Folded Reload

  // 11. 回顾一下分配的 48 字节栈空间的使用情况
  | sp + 40  |  LR (8 bytes)
  | sp + 32  |  FP (8 bytes)
  | sp + 24  |  0  (8 bytes, 低四位(sp + 28) 存放 0)
  | sp + 16  |  X0 (8 bytes)
  | sp + 8   |  0  (8 bytes, 低四位(sp + 28) 存放 0)
  | sp       |     (8 bytes, 为了16对齐, 多分配出来的)

  // 和 step2 操作相反, 恢复 X29, X30, 也就是 FP 和 LR 寄存器
  // 类似 ldr, ldp load 多个: X29 <= [sp + 32], X30 <= [sp + 40]
  ldp     x29, x30, [sp, #32]             // 16-byte Folded Reload

  // 释放栈空间
  add     sp, sp, #48                     // =48
  ret

add(long, long):                               // @add(long, long)
  // add 函数有两个 long 参数, 会占用栈空间, 分配 16 字节
  sub     sp, sp, #16                     // =16

  // X0 是第一个参数 x, 保存到 sp + 8
  str     x0, [sp, #8]
  // X1 是第二个参数 y, 保存到 sp 中
  str     x1, [sp]

  // 取出 x 和 y
  ldr     x8, [sp, #8]
  ldr     x9, [sp]

  // 相加, 把和放入 X0 中, 也是约定的返回值存放位置
  add     x0, x8, x9

  // 释放栈空间
  add     sp, sp, #16                     // =16
  // 返回
  ret

3. 参数超过 8 个参数，通过栈空间传递参数的例子

test 函数共有 10 个参数，为了保持简单，这里都使用 long 类型的.

1
2
3
4
5
6
7
8
9
long test(long n1, long n2, long n3, long n4, long n5,
          long n6, long n7, long n8, long n9, long n10) {
    return n1 + n2;
}

int main() {
    long z = test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    return 0;
}

我们先看一下函数调用的时候，栈的分配，下面是对应的 AArch64 的汇编代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
main:                                   // @main

  // 1. 这部分和上面例子非常类似, 不赘述了
  sub     sp, sp, #64                     // =64
  stp     x29, x30, [sp, #48]             // 16-byte Folded Spill
  add     x29, sp, #48                    // =48
  mov     w8, wzr
  stur    wzr, [x29, #-4]

  // 2. 前 8 个参数通过通用寄存器 X0-X8 传递
  mov     x0, #1
  mov     x1, #2
  mov     x2, #3
  mov     x3, #4
  mov     x4, #5
  mov     x5, #6
  mov     x6, #7
  mov     x7, #8

  // 3. 这三条指令相当于把第 9 个参数 #9 放入 [sp], 也就是栈顶的位置
  mov     x9, sp
  mov     x10, #9
  str     x10, [x9]

  // 4. 把第 10 个参数 #10 放到 [sp + 8], 也即是栈顶的下一个位置
  mov     x10, #10
  str     x10, [x9, #8]

  // 5. 此时栈的情况是这样的:
  | sp + 40  |
  | sp + 32  |
  | sp + 24  |
  | sp + 16  |  其他值
  | sp + 8   |  #10, 第 10 个参数
  | sp       |  #9, 第 9 个参数

  stur    w8, [x29, #-20]                 // 4-byte Folded Spill

  // 6. 执行函数调用
  bl      test(long, long, long, long, long, long, long, long, long, long)

  // 7. 也和前面例子非常类似, 不赘述
  stur    x0, [x29, #-16]
  ldur    w0, [x29, #-20]                 // 4-byte Folded Reload
  ldp     x29, x30, [sp, #48]             // 16-byte Folded Reload
  add     sp, sp, #64                     // =64
  ret

test(long, long, long, long, long, long, long, long, long, long): // @test(long, long, long, long, long, long, long, long, long, long)
  // 10个参数, 分配 80 字节的栈空间, 也是 16 的倍数
  sub     sp, sp, #80                     // =80

  // 结合上面第5步, 我们可以知道当前栈是这样的:
  // 前面 sp = sp - 80, 所以这里 main 函数栈相当于离栈顶 sp 又远了80, 需要 + 80
  ----main func----
  | sp + 40 + 80  |
  | sp + 32 + 80  |
  | sp + 24 + 80  |
  | sp + 16 + 80  |  其他值
  | sp + 8  + 80  |  #10, 第 10 个参数
  | sp      + 80  |  #9, 第 9 个参数
  ----test func----
  | sp +      72  |
  | sp +      64  |
  | sp +      56  |
  | sp +      48  |
  | sp +      40  |
  | sp +      32  |
  | sp +      24  |
  | sp +      16  |
  | sp +      8   |
  | sp            |
  -----------------

  // 这个初看有些奇怪, 一共分配了 80 自己的空间, 那这里的 sp + 80, 岂不是访问出界了啊?
  // 实际上是特意的, 根据前图, sp + 80 相当于访问到了 #9 所在的位置, 所以 x8 = #9
  // 同理 x9 实际访问到了 [sp, #88], 也就是 #10 所在的位置, 所以 x9 = #10
  // 这样就拿到了最后两个参数
  ldr     x8, [sp, #80]
  ldr     x9, [sp, #88]

  // 前 8 个参数, 逐个压入到栈中. 空余了 sp 和 sp + 8
  str     x0, [sp, #72]
  str     x1, [sp, #64]
  str     x2, [sp, #56]
  str     x3, [sp, #48]
  str     x4, [sp, #40]
  str     x5, [sp, #32]
  str     x6, [sp, #24]
  str     x7, [sp, #16]

  // 再把从前面函数栈中拿到的第 9、10 个参数入栈
  str     x8, [sp, #8]
  str     x9, [sp]

  // 此时 函数栈中的值是这样的:
  ----main func----
  | sp + 40 + 80  |
  | sp + 32 + 80  |
  | sp + 24 + 80  |
  | sp + 16 + 80  |
  | sp + 8  + 80  |  #10, 第 10 个参数
  | sp      + 80  |  #9, 第 9 个参数
  ----test func----
  | sp +      72  |  #1
  | sp +      64  |  #2
  | sp +      56  |  #3
  | sp +      48  |  #4
  | sp +      40  |  #5
  | sp +      32  |  #6
  | sp +      24  |  #7
  | sp +      16  |  #8
  | sp +      8   |  #9
  | sp            |  #10
  -----------------

  // 拿出 #1 和 #2, 相加的结果 3 放入 X0 作为返回值
  ldr     x8, [sp, #72]
  ldr     x9, [sp, #64]
  add     x0, x8, x9

  // 释放栈空间
  add     sp, sp, #80                     // =80
  ret

4. 总结一下函数调用的通用逻辑

  1. 调用前
    1. 可能会修改的寄存器先入栈保存
    2. 准备函数的参数，前 8 个参数参数放入 X0-X8
    3. 剩余参数入栈
  2. 使用 bl 调用目标函数
    1. 执行 bl 之前会把 bl 下一行指令的地址放入 lr 寄存器
    2. 从 X0-X9 拿到前 8 个参数，然后从上个函数栈的栈中取出剩余的参数
    3. 目标函数执行完，ret 的时候，会把 lr 寄存器的值 store 到 PC 寄存器
    4. 执行 pc 寄存器对应的地址，也就是前面 bl 下一行 (step 9 的指令)
  3. 调用后
    1. 恢复 1.1 中入栈的寄存器值，恢复调用前的状态