函数调用涉及到传参与返回值，下面就来看下 ARM 64 中，参数与返回值的传递机制。

1 整数型参数传递

这里的 整数型 并不单指 int 类型，或者 NSInteger 类型，而是指 任何 能够使用整数表示的数据类型，包括 char 、 BOOL 、指针等。

对于整数型参数，需要分成参数个数 <=8 个和 >8 个两种情形来看。

如果参数个数 <= 8 个，那么参数全部使用 Xn 寄存器传递 。

比如，一个函数的参数只有 4 个，那么就是用 X0 X1 X2 X3 寄存器传递。如果这个函数的参数为 8 个，那么就使用 X0 X1 X2 X3 X4 X5 X6 X7 寄存器传递。

换句话说，寄存器 X0~X7 就是用来在参数个数 <=8 个时，传递参数的。

// 1. 接受 4 个整型参数的函数
NSInteger add4(NSInteger zero, NSInteger one, NSInteger two, NSInteger three) {
    return zero + one + two + three;
}

@implementation ViewController

- (void)viewDidLoad {
    // 2. 调用函数 add4
    NSInteger result = add4(0, 1, 2, 3);
    NSLog(@"%ld", result);
}

@end

上面代码注释 1 定义了一个接受 4 个参数的函数 add4 .

代码注释 2 在 viewDidLoad 函数中调用了函数 add4 。

下面来看 viewDidLoad 函数的汇编代码:

// ARMAssemble`-[ViewController viewDidLoad]:
    ...
    0x102e142b0 <+28>: mov    x1, #0x1
   ...
    0x102e142bc <+40>: mov    x0, #0x0
    0x102e142c0 <+44>: mov    x2, #0x2
    0x102e142c4 <+48>: mov    x3, #0x3
    0x102e142c8 <+52>: bl     0x102e14000               ; add4 at ViewController.m:10
    ...

上面代码前面 4 行将参数写入了对应的寄存器，最后一行调用了函数 add4 。

函数 add4 的汇编代码如下:

ARMAssemble`add4:
->  0x102e14000 <+0>:  sub    sp, sp, #0x20
    0x102e14004 <+4>:  str    x0, [sp, #0x18]
    0x102e14008 <+8>:  str    x1, [sp, #0x10]
    0x102e1400c <+12>: str    x2, [sp, #0x8]
    0x102e14010 <+16>: str    x3, [sp]
    ...

上面代码第 1 行分配栈空间，后面 4 行代码就将参数值存储到了对应的栈空间。

如果参数个数 > 8 个，那么寄存器 X0~X7 负责传递前 8 个参数，剩下的参数使用栈来传递 。

// 1. 定义接受 10 个参数的函数 add10
NSInteger add10(NSInteger zero, NSInteger one, NSInteger two, NSInteger three, NSInteger four, NSInteger five, NSInteger six, NSInteger seven, NSInteger eight, NSInteger nine) {
    return zero + one + two + three + four + five + six + seven + eight + nine;
}

@implementation ViewController

- (void)viewDidLoad {
    // 2. 调用 add10
    NSInteger result = add10(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
    NSLog(@"%ld", result);
}

@end

上面代码注释 1 定义了一个接受 10 个参数的函数 add10 。

代码注释 2 在 viewDidLoad 函数中调用了函数 add10 。

viewDidLoad 函数的汇编代码如下:

ARMAssemble`-[ViewController viewDidLoad]:
    0x10455c294 <+0>:   sub    sp, sp, #0x40
    ...
    0x10455c2b0 <+28>:  mov    x1, #0x1
    ...
    // 1. 存储第 9 个参数到栈中
    0x10455c2bc <+40>:  mov    x9, sp
    0x10455c2c0 <+44>:  mov    x8, #0x8
    0x10455c2c4 <+48>:  str    x8, [x9]
    // 2. 存储第 10 个参数到栈中
    0x10455c2c8 <+52>:  mov    x8, #0x9
    0x10455c2cc <+56>:  str    x8, [x9, #0x8]
    0x10455c2d0 <+60>:  mov    x0, #0x0
    0x10455c2d4 <+64>:  mov    x2, #0x2
    0x10455c2d8 <+68>:  mov    x3, #0x3
    0x10455c2dc <+72>:  mov    x4, #0x4
    0x10455c2e0 <+76>:  mov    x5, #0x5
    0x10455c2e4 <+80>:  mov    x6, #0x6
    0x10455c2e8 <+84>:  mov    x7, #0x7
    // 3. 调用函数 add10
    0x10455c2ec <+88>:  bl     0x10455c048               ; add10 at ViewController.m:14
  ...

上面代码注释 1 后 3 行代码将第 9 个参数存储到栈顶。

代码注释 2 后面 2 行代码将第 10 个参数存储到栈地址 (SP + 0X8) 处。

代码注释 3 调用函数 add10 。

函数 add10 的汇编代码如下:

ARMAssemble`add10:
->  0x10455c048 <+0>:   sub    sp, sp, #0x50
    // 1. 从主调函数栈中加载第 9 个参数到寄存器 X9
    0x10455c04c <+4>:   ldr    x9, [sp, #0x50]
    // 2. 从主调函数栈中加载第 10 个参数到寄存器 X8
    0x10455c050 <+8>:   ldr    x8, [sp, #0x58]
    // 3. 下面 8 条语句将对应的参数存储到对应的栈空间
    0x10455c054 <+12>:  str    x0, [sp, #0x48]
    0x10455c058 <+16>:  str    x1, [sp, #0x40]
    0x10455c05c <+20>:  str    x2, [sp, #0x38]
    0x10455c060 <+24>:  str    x3, [sp, #0x30]
    0x10455c064 <+28>:  str    x4, [sp, #0x28]
    0x10455c068 <+32>:  str    x5, [sp, #0x20]
    0x10455c06c <+36>:  str    x6, [sp, #0x18]
    0x10455c070 <+40>:  str    x7, [sp, #0x10]
    // 4. 将第 9 个参数存储到栈地址 SP + 0x8 处
    0x10455c074 <+44>:  str    x9, [sp, #0x8]
    // 5. 将第 10 个参数存储到栈顶
    0x10455c078 <+48>:  str    x8, [sp]

上面代码注释 1 从主调函数栈中加载第 9 个参数到寄存器 X9 。

代码注释 2 从主调函数栈中加载第 10 个参数到寄存器 X8 。

代码注释 3 后面 8 条语句将对应参数存储到对应栈空间。

代码注释 4 将第 9 个参数存储到栈地址 (SP + 0x8) 处。

代码注释 5 将第 10 个参数存储到栈顶。

2 浮点数参数

浮点数参数的传递和整数型参数类似:

如果参数个数 <= 8 个，那么参数全部使用 Dn 寄存器传递 。

如果参数个数 > 8 个，那么寄存器 D0~D7 负责传递前 8 个参数，剩下的参数使用栈传递 。

3 混合参数

混合参数是指参数中既有整数型参数，也有浮点数参数，那么参数传递规则会分别应用整数型规则和浮点数规则。

比如，如果一个函数有 10 个整数型参数， 10 个浮点数参数，那么参数规则应用如下:

首先应用整数型参数规则，由于参数个数超过了 8 个，前 8 个整数型参数由寄存器 X0~X7 传递，剩余参数使用栈传递。

然后应用浮点数参数规则，由于参数个数超过了 8 个，前 8 个浮点数参数由浮点数寄存器 D0~D7 传递，剩余参数使用栈传递。

// 1. 定义了接受 10 个整数型参数和 10 个浮点数参数的函数 hybrid
CGFloat hybrid(NSInteger zero, NSInteger one, CGFloat zerof, CGFloat onef, CGFloat twof, CGFloat threef, NSInteger two, NSInteger three, NSInteger four, NSInteger five, NSInteger six, NSInteger seven, NSInteger eight, NSInteger nine, CGFloat fourf, CGFloat fivef, CGFloat sixf, CGFloat sevenf, CGFloat eightf, CGFloat ninef) {
    return zero + one + two + three + four + five + six + seven + eight + nine + zerof + onef + twof + threef + fourf + fivef + sixf + sevenf + eightf + ninef;
}

@implementation ViewController

- (void)viewDidLoad {
    // 2. 调用 hybrid 函数，注意第 3 4 5 6个参数是浮点数
    CGFloat result = hybrid(0, 1, 0.0f, 1.0f, 2.0f, 3.0f, 2, 3, 4, 5, 6, 7, 8, 9, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f);
    NSLog(@"%f", result);
}

上面代码注释 1 定义了一个接受 10 个整数型参数和 10 个浮点数参数的函数 hybrid 。需要注意的是，第 3 4 5 6 个参数是浮点数而不是整型数。

代码注释 2 在 viewDidLoad 函数中调用函数 hybrid 。

viewDidLoad 函数的汇编码如下:

ARMAssemble`-[ViewController viewDidLoad]:
    0x10059c294 <+0>:   sub    sp, sp, #0x50
    ...
    0x10059c2b0 <+28>:  mov    x1, #0x1
    ...
    // 1. 存储整数型参数中第 9 个参数到栈顶
    0x10059c2bc <+40>:  mov    x8, sp
    0x10059c2c0 <+44>:  mov    x9, #0x8
    0x10059c2c4 <+48>:  str    x9, [x8]
    // 2. 存储整数型参数中第 10 个参数到栈地址 SP + 0x8
    0x10059c2c8 <+52>:  mov    x9, #0x9
    0x10059c2cc <+56>:  str    x9, [x8, #0x8]
    // 3. 存储浮点数参数中第 9 个参数到栈地址 SP + 0x10
    0x10059c2d0 <+60>:  fmov   d0, #8.00000000
    0x10059c2d4 <+64>:  str    d0, [x8, #0x10]
    // 4. 存储浮点数参数中第 10 个参数到栈地址 SP + 0x18
    0x10059c2d8 <+68>:  fmov   d0, #9.00000000
    0x10059c2dc <+72>:  str    d0, [x8, #0x18]
    // 5. 剩下 15 条语句存储对应参数到相应的寄存器
    0x10059c2e0 <+76>:  mov    x0, #0x0
    0x10059c2e4 <+80>:  fmov   d0, xzr
    0x10059c2e8 <+84>:  fmov   d1, #1.00000000
    0x10059c2ec <+88>:  fmov   d2, #2.00000000
    0x10059c2f0 <+92>:  fmov   d3, #3.00000000
    0x10059c2f4 <+96>:  mov    x2, #0x2
    0x10059c2f8 <+100>: mov    x3, #0x3
    0x10059c2fc <+104>: mov    x4, #0x4
    0x10059c300 <+108>: mov    x5, #0x5
    0x10059c304 <+112>: mov    x6, #0x6
    0x10059c308 <+116>: mov    x7, #0x7
    0x10059c30c <+120>: fmov   d4, #4.00000000
    0x10059c310 <+124>: fmov   d5, #5.00000000
    0x10059c314 <+128>: fmov   d6, #6.00000000
    0x10059c318 <+132>: fmov   d7, #7.00000000
    // 6. 调用函数 hybrid
    0x10059c31c <+136>: bl     0x10059c178               ; hybrid at ViewController.m:22

上面代码注释 1 存储整数型参数中第 9 个参数到栈顶。

代码注释 2 存储整数型参数中第 10 个参数到栈地址 (SP +0x8) 处。

代码注释 3 存储浮点数参数中第 9 个参数到栈地址 (SP + 0x10) 处。

代码注释 4 存储浮点数参数中第 10 个参数到站地址 (SP + 0x18) 处。

代码注释 5 后面的 15 条语句村出纳对应参数到对应的寄存器，需要注意的是第 2 条语句使用寄存器 X1 传递第 2 个整数型参数。其中的寄存器 xzr 是全 0 寄存器，也就是这个寄存器的值就是 0 。

代码注释 6 调用函数 hybrid 。

hybrid 函数汇编码如下:

ARMAssemble`hybrid:
->  0x10059c178 <+0>:   sub    sp, sp, #0xa0
    // 1. 从主调函数栈中获取整数型参数中第 9 个参数到寄存器 X11
    0x10059c17c <+4>:   ldr    x11, [sp, #0xa0]
    // 2. 从主调函数栈中获取整数型参数中第 10 个参数到寄存器 X10
    0x10059c180 <+8>:   ldr    x10, [sp, #0xa8]
    // 3. 从主调函数栈中获取浮点数参数中第 9 个参数到寄存器 X9
    0x10059c184 <+12>:  ldr    x9, [sp, #0xb0]
    // 4. 从主调函数栈中获取浮点数参数中第 10 个参数到寄存器 X8
    0x10059c188 <+16>:  ldr    x8, [sp, #0xb8]
    // 5. 后面 12 条语句将对应参数存储到对应的栈地址
    0x10059c18c <+20>:  str    x0, [sp, #0x98]
    0x10059c190 <+24>:  str    x1, [sp, #0x90]
    0x10059c194 <+28>:  str    d0, [sp, #0x88]
    0x10059c198 <+32>:  str    d1, [sp, #0x80]
    0x10059c19c <+36>:  str    d2, [sp, #0x78]
    0x10059c1a0 <+40>:  str    d3, [sp, #0x70]
    0x10059c1a4 <+44>:  str    x2, [sp, #0x68]
    0x10059c1a8 <+48>:  str    x3, [sp, #0x60]
    0x10059c1ac <+52>:  str    x4, [sp, #0x58]
    0x10059c1b0 <+56>:  str    x5, [sp, #0x50]
    0x10059c1b4 <+60>:  str    x6, [sp, #0x48]
    0x10059c1b8 <+64>:  str    x7, [sp, #0x40]
    // 6. 将整数型参数中第 9 个参数存储到栈地址 SP + 0x38
    0x10059c1bc <+68>:  str    x11, [sp, #0x38]
    // 7. 将整数型参数中第 10 个参数存储到栈地址 SP + 0x30
    0x10059c1c0 <+72>:  str    x10, [sp, #0x30]
    // 8. 后面 4 条语句继续存储浮点数参数到栈地址
    0x10059c1c4 <+76>:  str    d4, [sp, #0x28]
    0x10059c1c8 <+80>:  str    d5, [sp, #0x20]
    0x10059c1cc <+84>:  str    d6, [sp, #0x18]
    0x10059c1d0 <+88>:  str    d7, [sp, #0x10]
    // 9. 将浮点数参数中第 9 个参数存储到栈地址 SP + 0x8
    0x10059c1d4 <+92>:  str    x9, [sp, #0x8]
    // 10. 将浮点数参数中第 10 个参数存储到栈顶
    0x10059c1d8 <+96>:  str    x8, [sp]
    ...

上面代码注释 1 从主调函数栈中获取整数型参数中的第 9 个参数到寄存器 X11 。

代码注释 2 从主调函数栈中获取整数型参数中的第 10 个参数到寄存器 X10 。

代码注释 3 从主调函数栈中获取浮点数参数中的第 9 个参数到寄存器 X9 。

代码注释 4 从主调函数中获取浮点数参数中的第 10 个参数到寄存器 X8 。

代码注释 5 后面 12 条语句将对应参数存储到对应的栈地址。

代码注释 6 将整数型参数中第 9 个参数存储到栈地址 (SP + 0x38) 。

代码注释 7 将整数型参数中第 10 个参数存储到栈地址 (SP + 0x30) 。

代码注释 8 后面 4 条语句继续存储浮点数参数到栈地址。

代码注释 9 将浮点数参数中第 9 个参数存储到栈地址 (SP + 0x8) 。

代码注释 10 将浮点数参数中第 10 个参数存储到栈顶。

从上图中可以看到，函数 hybrid 中的参数和参数声明的顺序一样，越左边的参数越靠近栈中高地址。

4 结构体参数

结构体作为参数有 2 种情形。

4.1 HAF 结构体

第 1 种情形是 HFA(Homogeneous Float-point Aggregates) 结构体。这种结构体的成员全部是浮点数类型，且成员不超过 4 个。

在 iOS 中，典型的就是 CGRect 类型。

如果是 HFA 结构体，那么其成员都是通过寄存器 Dn 传递 。

@implementation ViewController

- (void)viewDidLoad {
    CGRect rect = CGRectMake(0.0f, 1.0f, 2.0f, 3.0f);
    // 1. CGRect 作为函数 adds 的参数传递
    CGFloat result = adds(rect);
    NSLog(@"%f", result);
}

@end

上面代码注释 1 将结构体 CGRect 作为参数，传递给函数 adds .

函数 viewDidLoad 的汇编码如下:

ARMAssemble`-[ViewController viewDidLoad]:
->  0x102dd82c4 <+0>:   sub    sp, sp, #0x50
    ...
    // 1. 将参数值加载到对应的 d0 d1 d2 d3 寄存器中进行传递
    0x102dd830c <+72>:  ldr    d0, [sp, #0x10]
    0x102dd8310 <+76>:  ldr    d1, [sp, #0x18]
    0x102dd8314 <+80>:  ldr    d2, [sp, #0x20]
    0x102dd8318 <+84>:  ldr    d3, [sp, #0x28]
    0x102dd831c <+88>:  bl     0x102dd8294               ; adds at ViewController.m:35
    ...

上面代码注释 1 就将 D0 D1 D2 D3 加载对应的参数值，进行传递。

4.2 非 HFA 结构体

第 2 种情形是非 HFA 结构体，也就是结构体成员不全都是浮点数类型，或者即使是浮点数类型，其成员个数也超过了 4 个。

如果非 HFA 结构体大小 <= 16 Bytes ，那么参数使用寄存器 Xn 传递 。

// 1. 定义非 HFA 结构体，大小正好是 16 Bytes
typedef struct {
    NSInteger one;
    CGFloat onef;
} Param;

@implementation ViewController

- (void)viewDidLoad {
    Param p;
    p.one = 1;
    p.onef = 1.0f;
    // 2. 使用非 HFA 结构体作为参数，调用函数 adds
    CGFloat result = adds(p);
    NSLog(@"%f", result);
}

@end

上面代码注释 1 定义了一个非 HFA 结构体，其大小正好是 16 Bytes 。

代码注释 2 使用这个结构体作为参数，调用函数 adds 。

函数 viewDidLoad 的汇编码如下:

ARMAssemble`-[ViewController viewDidLoad]:
->  0x1041602bc <+0>:   sub    sp, sp, #0x40
    ...
    0x1041602d8 <+28>:  mov    x8, #0x1
    ...
    // 1. 寄存器 X8 存储参数 1，存储到栈地址 SP + 0x10
    0x1041602e4 <+40>:  str    x8, [sp, #0x10]
    // 2. 下面 2 条指令将参数 1.0 存储到栈地址 SP + 0x18
    0x1041602e8 <+44>:  fmov   d0, #1.00000000
    0x1041602ec <+48>:  str    d0, [sp, #0x18]
    // 3. 下面 2 条指令将参数 1 1.0 加载到寄存器 X0 X1 进行传递
    0x1041602f0 <+52>:  ldr    x0, [sp, #0x10]
    0x1041602f4 <+56>:  ldr    x1, [sp, #0x18]
    // 4. 调用函数 adds
    0x1041602f8 <+60>:  bl     0x104160294               ; adds at ViewController.m:31

上面代码注释 1 将参数 1 存储到栈地址 (SP + 0x10) 。

代码注释 2 后面 2 条指令将参数 1.0 存储到栈地址 (SP + 0x18) 。

代码注释 3 后面 2 条指令将参数 1 1.0 加载到寄存器 X0 X1 进行传递。

代码注释 4 调用函数 adds 。

如果非 HFA 结构体的大小 > 16 Bytes ，那么主调函数会先将这个参数拷贝到一个内存区，然后将这个内存区的指针，作为参数传递 。

// 1. 定义非 HFA 结构体，大小为 32 Bytes
typedef struct {
    NSInteger one;
    CGFloat onef;
    NSInteger two;
    CGFloat twof;
} Param;

// 2. 定义函数 adds，接受一个非 HFA 结构体作为参数
CGFloat adds(Param p) {
    return p.one + p.onef + p.two + p.twof;
}
    

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    Param p;
    p.one = 1;
    p.onef = 1.0f;
    p.two = 2;
    p.twof = 2.0f;
    // 3. 调用 adds 函数
    CGFloat result = adds(p);
    NSLog(@"%f", result);
}

@end

上面代码注释 1 定义了一个非 HFA 结构体 Param ，大小为 32 Bytes 。

代码注释 2 定义了一个函数 adds ，接受非 HFA 结构作为参数。

代码注释 3 调用 adds 函数

函数 viewDidLoad 的汇编码如下:

ARMAssemble`-[ViewController viewDidLoad]:
    0x1025482dc <+0>:   sub    sp, sp, #0x80
    ...
    // 1. 寄存器 X29 执行栈地址 SP + 0x70
    0x1025482e4 <+8>:   add    x29, sp, #0x70
    ...
    0x1025482f8 <+28>:  mov    x8, #0x1
    ...
    // 2. 参数 1 存储到栈地址 X29 - 0x30 处
    0x102548304 <+40>:  stur   x8, [x29, #-0x30]
    // 3. 后面 2 条指令将参数 1.0 存储到栈地址 X29 - 0x28 处
    0x102548308 <+44>:  fmov   d0, #1.00000000
    0x10254830c <+48>:  stur   d0, [x29, #-0x28]
    // 4. 后面 2 条指令将参数 2 存储到栈地址 X29 - 0x20 处
    0x102548310 <+52>:  mov    x8, #0x2
    0x102548314 <+56>:  stur   x8, [x29, #-0x20]
    // 5. 后面 2 条指令将参数 2.0 存储到栈地址 X29 - 0x18 处
    0x102548318 <+60>:  fmov   d0, #2.00000000
    0x10254831c <+64>:  stur   d0, [x29, #-0x18]
    // 6. 将栈地址 X29 - 0x30 处的值加载到寄存器 Q0，也就是将参数 1 1.0 加载到寄存器 Q0
    0x102548320 <+68>:  ldur   q0, [x29, #-0x30]
    // 7. 寄存器 X0 指向栈地址 SP + 0x10，它最终作为参数传递
    0x102548324 <+72>:  add    x0, sp, #0x10
    // 8. 将寄存器 Q0 的值存储到栈地址 SP + 0x10，也就是将参数 1 1.0 存入到此处
    0x102548328 <+76>:  str    q0, [sp, #0x10]
    // 9. 将栈地址 X29 - 0x20 处的值加载到寄存器 Q0，也就是将参数 2 2.0 加载到寄存器 Q0
    0x10254832c <+80>:  ldur   q0, [x29, #-0x20]
    // 10. 将寄存器 Q0 的值存储到栈地址 SP + 0x20，也就是将参数 2 2.0 存储到粗出
    0x102548330 <+84>:  str    q0, [sp, #0x20]
    // 11. 调用函数 adds
    0x102548334 <+88>:  bl     0x102548294               ; adds at ViewController.m:33
    ...

上面代码注释 1 将寄存器 X29 指向栈地址 (SP + 0x70) 。

代码注释 2 将参数 1 存储到栈地址 (X29 - 0x30) 。

代码注释 3 后面 2 条指令将参数 1.0 存储到栈地址 (X29 - 0x28) 。

代码注释 4 后面 2 条指令将参数 2 存储到栈地址 (X29 - 0x20) 。

代码注释 5 后面 2 条指令将参数 2.0 存储到栈地址 (X29 - 0x18) 。

代码注释 2 3 4 5 本质上就是在栈空间创建结构体 Param ，然后为其成员变量赋值。

从上图看到， 结构体高地址成员，在栈内存中也处于高地址 。

代码注释 6 将栈地址 (X29 - 0x30) 的值存储到寄存器 Q0 。

寄存器 Q0 是一个 128bit 寄存器，可以存储 2 个 64bit 数据。换句话说，参数 1 1.0 被存储到寄存器 Q0 ，并且参数 1 在低 64bit ，参数 1.0 在高 64bit 。

有关 ARM 64 寄存器的介绍可以参看《一个搞懂 ARM 64 系列:寄存器》。

代码注释 7 将 X0 指向栈地址 (SP + 0x10) ，此时寄存器 X0 做为一块内存的指针，将作为参数传递给函数 adds 。

代码注释 8 将寄存器 Q0 的值存储到栈地址 (SP + 0x10) 。

代码注释 6 7 8 的最终效果为:

代码注释 9 将栈地址 (X29 - 0x20) 的值存储到寄存器 Q0 ，也就是将参数 2 2.0 存储到寄存器 Q0 。

代码注释 10 将寄存器 Q0 的值存储到栈地址 (SP + 0x20) 处。

代码注释 6 8 9 10 本质上将结构体 Param 进行了拷贝，拷贝到栈内存中新地址 (SP + 0x10) 处，此地址内存由寄存器 X0 引用。

此处使用寄存器 X0 传参，是因为没有其他整型参数要传递。

代码注释 11 调用函数 adds 。

5 返回值

返回值的传递规则比较简单。

要确定返回值如何传递，只需要假想， 如果这个返回值作为函数参数，将如何传递 。参数传递的方式，决定了返回值传递的方式。

如果返回值是一个整数型，假想它作为函数参数传递，根据规则，将使用寄存器 X0 传递，那么这个返回值就使用 X0 返回。

如果返回值是一个浮点数，假想它作为函数参数传递，根据规则，将使用寄存器 D0 传递，那么这个返回值就使用 D0 返回。

如果返回值是一个 HFA 结构体，假想它作为函数参数传递，根据规则，将使用寄存器 Dn 传递，那么这个返回值就使用 Dn 返回。

一个例子就是有函数返回 iOS 中的结构体 CGRect ，返回值最终使用寄存器 D0 D1 D2 D3 返回。

如果返回值是一个非 HFA 结构体，并且大小不超过 16 Bytes ，假想它作为参数传递，根据规则，将使用寄存器 Xn 传递，那么返回值就使用 Xn 返回。

如果返回值是一个非 HFA 结构体，并且大小超过了 16 Bytes ，假想它作为函数参数传递，根据规则，主调函数会先拷贝到一块内存区，将这块内存指针传递给被调函数，那么这个返回值也会由被调函数直接通过这个指针，写入主调函数预先开辟的内存中。 只是需要注意的是，指向这块内存区域的 X8 寄存器 。

// 1. 定义一个非 HFA 结构体，结构体大小为 32 Bytes
typedef struct {
    NSInteger one;
    CGFloat onef;
    NSInteger two;
    CGFloat twof;
} Param;

// 2. 定义函数 adds，它返回非 HFA 结构体 Param
Param adds(void) {
    Param p;
    p.one = 1f;
    p.onef = 1.0f;
    p.two = 2;
    p.twof = 2.0f;
    return p;
}

@implementation ViewController

- (void)viewDidLoad {
    // 3. 调用函数 adds
    Param result = adds();
    NSLog(@"%ld", result.one);
}

@end

代码注释 1 定义一个非 HFA 结构体，结构体大小 32 Bytes 。

代码注释 2 定义函数 adds ，它返回非 HFA 结构体 Param 。

代码注释 3 调用函数 adds 。

函数 viewDidLoad 的汇编码:

ARMAssemble`-[ViewController viewDidLoad]:
    0x104e1c2c8 <+0>:  sub    sp, sp, #0x50
    ...
    // 1. 寄存器 X8 指向栈地址 SP + 0x10，从 SP + 0x10 开始连续 4 个 64bit 区域用来接收返回值
    0x104e1c2ec <+36>: add    x8, sp, #0x10
    0x104e1c2f0 <+40>: bl     0x104e1c294               ; adds at ViewController.m:33
    ...

上面代码注释 1 将寄存器 X8 指向栈地址 (SP + 0x10) ，从 (SP + 0x10) 开始连续 4 个 64bit 内存区域用来接收返回值。

函数 adds 的汇编码:

ARMAssemble`adds:
    ...
    0x10212c29c <+8>:  mov    x9, #0x1
    ...
    // 1. 寄存器 X9 存储值 1，写入寄存器 X8 指向地址
    0x10212c2a8 <+20>: str    x9, [x8]
    // 2. 后面 2 条指令将 1.0 写入 X8 + 0x8 地址处
    0x10212c2ac <+24>: fmov   d0, #1.00000000
    0x10212c2b0 <+28>: str    d0, [x8, #0x8]
    // 3. 后面 2 条指令将 2 写入 X8 + 0x10 地址处
    0x10212c2b4 <+32>: mov    x9, #0x2
    0x10212c2b8 <+36>: str    x9, [x8, #0x10]
    // 4. 后面 2 条指令将 2.0 写入 X8 + 0x18 地址处
    0x10212c2bc <+40>: fmov   d0, #2.00000000
    0x10212c2c0 <+44>: str    d0, [x8, #0x18]
    0x10212c2c4 <+48>: ret   

上面代码注释 1 将寄存器 X9 存储值 1 ，写入寄存器 X8 指向地址。

代码注释 2 后面 2 条指令将 1.0 写入 (X8 + 0x8) 地址处。

代码注释 3 后面 2 条指令将 2 写入 (X8 + 0x10) 地址处。

代码注释 4 后面 2 条指令将 2.0 写入 (X8 + 0x18) 地址处。