前言

当我们调用函数的时候，参数是怎么传递给被调用方的，有想过这个问题吗？传递不同大小的参数对调用方式有影响吗？本文将带你探究这些问题，阅读本文需要对函数栈帧有一定的理解，并了解基本的汇编指令。

文章汇编代码：采用 GCC 8.3.1，对 C 代码使用 -Og 优化级别生成的可执行程序，再用 objdump -d 反汇编的结果。

下表为文章使用到的一些基本汇编操作：

函数名	参数	操作
mov	Src，Dest	Src -> Dest（寄存器之间）
mov	Src，(Dest)	Src -> Dest 存储的内存地址处
addq	Src，Dest	Dest = Dest + Src
subq	Src，Dest	Dest = Dest - Src
imulq	Src，Dest	Dest = Dest * Src

x86-64 中，4 字节操作后缀为 l，8 字节操作后缀为 q。

寄存器保存

如果参数比较小（4 or 8 bytes），在寄存器中可以放得下，那么前 6 个参数将被放在寄存器中（第一个在 %rdi，第二个在 %rsi，…），多的参数将被放在栈中保存。返回值存放在 %rax。

下图寄存器只能存放整数数据和指针，浮点数使用另外一组单独的寄存器。

存储参数

来看一段简单的代码：

// 一段简单让两数相乘的代码，写成这种形式，主要是尽量减少编译器优化
long mult2(long a, long b) {
    long t = a * b;
    return t;
}

void mult_store(long x, long y, long* dest) {
    long t = mult2(x, y);
    *dest = t;
}

00000000004004d2 <mult2>:
  # a in %rdi，b in %rsi
  4004d2:   mov    %rdi,%rax	# 把 a 移动到 %rax
  4004d5:   imul   %rsi,%rax	# a * b
  4004d9:   retq

00000000004004da <mult_store>:
  # x in %rdi，y in %rsi，dest in %rdx
  4004da:   push   %rbx
  4004db:   mov    %rdx,%rbx		# 保存 dest，下文后讲为什么要这么做
  4004de:   callq  4004d2 <mult2>	# 调用 mult2
  4004e3:   mov    %rax,(%rbx)		# 将 %rax 里面的返回值
  									# 移动到 %rbx 保存的 dest 指针指向的内存处
  4004e6:   pop    %rbx
  4004e7:   retq

保存参数

先看一段代码：

long incr(long* p, long val) {
    long x = *p;
    long y = x + val;
    *p = y;
    return x;
}

long call_incr(long x) {
    long v1 = 2048;
    long v2 = incr(&v1, 1024);
    return x + v2;
}

看了上面的代码，你可能会有这样的疑惑：函数的第一个参数保存在 %rdi，call_incr 的 x 存储在 %rdi 中，在调用 incr 时，该寄存器的值已经被修改了，后面又会使用到 x，那该怎么办呢？

编译器有两种策略：

一种是调用方保存，后续我还会使用的参数都会保存在特定寄存器中，不管被调用的函数是否会修改。

一种是被调用方保存，使用时先将保存参数的寄存器的值存储到特定的寄存器，返回前修改回原状态。

下图为保存参数的特定寄存器：

调用保存

被调用保存

上图寄存器分类只是一种约定，编译器并不一定遵守，编译器可能有自己的使用分类。GCC 并没遵守上述分类，并采用调用方保存的方案。

00000000004004d2 <incr>:
  # p in %rdi，val in %rsi
  4004d2:   mov    (%rdi),%rax    
  4004d5:   add    %rax,%rsi    
  4004d8:   mov    %rsi,(%rdi)    
  4004db:   retq       
    
00000000004004dc <call_incr>:
  # x in %rdi
  4004dc:   push   %rbx
  4004dd:   sub    $0x10,%rsp		# %rsp 为栈顶指针，减小意味着为 call_incr 开辟 16 字节栈帧
  4004e1:   mov    %rdi,%rbx		# 保存参数 x 到 %rbx
  4004e4:   movq   $0x800,0x8(%rsp) # 将 2024 存储到 %rsp + 8 处
  4004ed:   mov    $0x400,%esi    	# 将 1024 传到 %esi，即 %rsi 的低 32 位
  									# movq 指令比 mov 指令占用的字节多
  4004f2:   lea    0x8(%rsp),%rdi   # 把 v1 的地址传到 %rdi，可以看到传参顺序是从右到左
  4004f7:   callq  4004d2 <incr>    # 调用 incr，此时 %rax 保存的值为 v2
  4004fc:   add    %rbx,%rax		# 将 x + v2
  4004ff:   add    $0x10,%rsp    	# 销毁栈帧
  400503:   pop    %rbx
  400504:   retq

编译器优化

上面讨论的都是比较小的内置类型，那假如对象很大，寄存器放不下该怎么办？

下面介绍一种 C++ 对参数的优化方式，实际编译器并不一定会使用该方式。

class qgw {
    // 有默认构造函数、拷贝构造函数、析构函数等
    long a1;
    long a2;
    long a3;
} qgw;

void fun(qgw num);

int main() {
    qgw tmp;
    ...
    fun(tmp);
	return 0;
}

实际上，编译器可能创建一个临时变量，并修改函数的参数。转化结果可能为：

void fun(qgw& num);			// 修改参数为引用

int main() {
	qgw tmp;
    ...
    qgw __temp0;			// 创建临时对象
    __temp0.qgw::qgw(tmp);	// 调用拷贝构造
    fun(__temp0);
    __temp.qgw::~qgw();		// 销毁该临时对象
	return 0;
};