导语 |  在任意一门编程语言中，函数调用基本上都是非常常见的操作；我们都知道，函数是由调用栈实现的，不同的函数调用会切换上下文；但是，你是否好奇，对于一个函数调用而言，其底层到底是如何实现的呢？本文讲解了函数调用的底层逻辑实现。

一、汇编概述

既然要讲解函数调用的底层逻辑实现，那么汇编语言我们是绕不过的。
因此，首先来复习一下汇编相关的知识。
我们都知道，计算机只能读懂二进制指令，而汇编就是一组特定的字符，汇编的每一条语句都直接对应CPU的二进制指令，比如：mov rax，rdx就是我们常见的汇编指令。
汇编语言就是通过一条条的 助记符+操作数实现的，并且汇编指令经过汇编器（assemble，例如Linux下的as）转变为实际的CPU二进制指令。

（一）一个简单的汇编例子
上面讲的有些空洞，来看一个实际的例子：
  1. ; 将寄存器rsp的值存储到寄存器rbp中
  2. mov rbp, rsp
  4. ; 将四个字节的4存储到地址为rbp-4的栈上
  5. mov DWORD PTR [rbp-4], 4
  7. ; 将rsp的值减去16
  8. sub rsp, 16
需要注意的是：汇编语言是和实际底层的CPU息息相关的；上面的汇编格式使用的便是Intel的语法格式。
常见的汇编语言有两种截然不同的语法：

  • Intel格式：optcode destination，source，类似于语法int i=4。

  • AT&T格式：optcode source，destination，直观理解为move from source to destination。
若将上面的Intel汇编改写为AT&T汇编，则为：
  1. movq %rsp, %rbp
  2. movl $4, -4(%rbp)
  3. subq $16, %rsp
可以看到，AT&T汇编的另外一个特点是：有前缀和后缀。
比如：前缀%,$；后缀q，l等等。
这些前缀后缀有特殊的意思，后文会讲解，不同的格式侧重点不太一样。

（二）常用汇编指令
下面是一些非常常用的汇编指令，在后文中都会用到：
v2-be615e4ff314072d7e053f7d20f04f9d_720w.jpg

二、通用寄存器概述
对于汇编语言，仅仅了解其语法内容是远远不够的！
由于汇编语言和CPU是息息相关的，因此在硬件层面我们还需要关注CPU的通用寄存器。
在所有CPU体系架构中，每个寄存器通常都是有建议的使用方法的，而编译器也通常依照CPU架构的建议来使用这些寄存器，因而我们可以认为这些建议是强制性的。

（一）8086架构(16bit)
让我们把视线首先转移到8086
下图展示了在8086 CPU中的各个寄存器：
v2-865b696e31942909421bedbb86439d86_720w.jpg
主要包括下面几类寄存器：

  • 通用寄存器：均可用来存放地址和数据。

  • 指针和变量寄存器：用来存放，某一段内地址偏移量，用来形成操作数地址，主要用来再堆栈操作或者变址操作中使用。

  • 段寄存器：由于存储器空间是分段的，所以这些段寄存器则是每个段的首地址。

  • 指令指针：IP用来存放将要执行的下一条指令再现在代码段的偏移量，将这个偏移量+段寄存器中存放的基地址，就找到了下一条指令的地址。

  • 标志位寄存器：用来存放计算结果的特征，这些标志位常常被用作接下来程序运行的条件。

  • 8086处理器内部有8个16位的通用寄存器，也就是CPU内部的数据单元，分别是：AX、BX、CX、DX、SP、BP、SI、DI。
这些寄存器的作用主要是：暂存计算机过程中的数据。
另外，AX、BX、CX、DX这四个寄存器又可以分为两个8位的寄存器来使用，分别是AH、AL、BH、BL、CH、CL、DH、DL。
注意：其中H表示高位（high），L表示低位（low）的意思。
下面来看下控制单元：
IP寄存器就是指令指针寄存器（Instruction Pointer Register），指向代码段中下一条指令的位置；CPU会根据它不断地从内存的代码段中取出指令并加载到CPU的指令队列中，然后交给运算单元去执行。CS、DS、SS、ES这四个寄存器都是16位寄存器，用来存储进程的地址空间信息。
比如：

  • CS是代码段寄存器（Code Segment Register），通过它可以找到代码在内存中的位置。

  • DS是数据段寄存器（Data Segment Register），通过它可以找到数据在内存中的位置。

  • SS是栈寄存器（Stack Register），栈是程序运行过程所需要的一种数据结构，主要用于记录函数调用的关系。

  • ES是一个附加段寄存器（Extra Segment Register），当发现段寄存器不够用的时候，你可以考虑使用ES段寄存器。
如何根据上述段寄存器找到所需的地址呢？
CS和DS中都存放着一个段的起始地址，代码段的偏移值存放在IP寄存器中，而数据段的偏移值放在通用寄存器中；由于8086架构中总线地址是20位的，而段寄存器和IP寄存器以及通用寄存器都是16位的，所以为了得到20位的地址，先将段寄存器中起始地址左移4位，然后再加上偏移量，就得到了20位的地址；也正是由于偏移量是16位的，所以每个段最大的大小是64K的。
另外，对于20位的地址总线来说，能访问到的内存大小最多也就只有2^20=1MB。
如果计算得到某个要访问的地址是1MB+X，那么最后访问的是地址X，因为地址线只能发送低20位的。

  • 关于标志位
8086CPU设置了一个：16位标志寄存器PSW（也叫FR），其中规定了9个标志位，用来存放运算结果特征和控制CPU操作。
v2-e3147f8c46ebe582507c8b094087148c_720w.jpg
9个标志位可以分为两类大类：

  • 条件码
  • 控制标志位
其中条件码包括：

  • OF（Overflow Flag）溢出标志，溢出时为1，否则置0：标明一个溢出了的计算，如：结构和目标不匹配。
  • SF（Sign Flag）符号标志，结果为负时置1，否则置0。
  • ZF（Zero Flag）零标志，运算结果为0时置1，否则置0。
  • CF（Carry Flag）进位标志，进位时置1，否则置0；注意：Carry标志中存放计算后最右的位；
  • AF（Auxiliary carry Flag）辅助进位标志，记录运算时第3位（半个字节）产生的进位置。有进位时1，否则置0；
  • PF（Parity Flag）奇偶标志，结果操作数中1的个数为偶数时置1，否则置0；
控制标志位包括：

  • DF（Direction Flag）方向标志，在串处理指令中控制信息的方向。

  • IF(Interrupt Flag）中断标志。

  • TF(Trap Flag）陷井标志。

（二）x86架构
接着，让我们步入32位机时代，来看看x86体系下的CPU寄存器：
v2-af5438058c917298c85ad4682cd47ab2_720w.jpg
可以看到，为了使得运行在8086架构上的程序在移到32位架构之后也能执行，32位架构对8086架构进行了兼容：

  • 通用寄存器从16位变成了32位，也就是8个32位的通用寄存器；但是为了保持兼容，仍然保留了16位和8位的使用方式，即：AH、AL等。

  • 指向下一条指令的指令指针寄存器也从16位变成了32位，被称为EIP，但是同样兼容16位的使用方式。

  • 段寄存器改动比较大：在32位架构中段寄存器还是16位，但是它不再表示段的起始地址，而是表示索引；32位架构中，引入了段描述符表，表格中的每一项都是段描述符（Segment Descriptor），记录了段在内存中的起始位置，而这张表则存放在内存的某个地址；那么，段寄存器中存的就是对应段在段表中的位置，称为选择子（selector）。

关于选择子：
先根据段寄存器拿到段的起始地址，再根据段寄存器中保存的选择子，找到对应的段描述符，然后从这个段描述符中取出这个段的起始地址；就相当于由之前的直接找到段起始地址变成了间接找到段起始地址；这样改变之后，段起始地址会变得很灵活。
但是这样就跟原来的8086架构不兼容了，因此为了兼容8086架构，32位架构中引入了实模式和保存模式：8086架构中的方式就称为实模式，32位这种模式就被称为保护模式。
当系统刚刚启动的时候，CPU是处于实模式的，这个时候和8086模式是兼容的；当需要更多内存时，进行一系列的操作，将其切换到保护模式，这样就能使用32位了。
模式可以理解为：CPU和操作系统的一起干活的模式：

  • 在实模式下，两者约定好了这些寄存器是干这个的，总线是这样的，内存访问是这样的。
  • 在保护模式下，两者约定好了这些寄存器是干那个的，总线是那样的，内存访问是那样的。
这样操作系统给CPU下命令，CPU按照约定好的，就能得到操作系统预料的结果，操作系统也按照约定好的，将一些数据结构，例如段描述符表放在一个约定好的地方，这样CPU就能找到。两者就可以配合工作了。
下面是x86平台下一些寄存器的调用特殊约定：
v2-c8d77e2eabf10b259184198df14b7917_720w.jpg
作为通用寄存器，过程调用中，调用者栈帧需要寄存器暂存数据，被调用者栈帧也需要寄存器暂存数据。
为防止调用过程中数据不会被破坏丢失，C/C++编译器遵守如下约定的规则：
v2-adf074c5893008cc66f4ea5629809f82_720w.jpg
当产生函数调用时，子函数内通常也会使用到通用寄存器，那么这些寄存器中之前保存的调用者(父函数）的值就会被覆盖！为了避免数据覆盖而导致从子函数返回时寄存器中的数据不可恢复，CPU 体系结构中就规定了通用寄存器的保存方式。
如果一个寄存器被标识为Caller Save， 那么在进行子函数调用前，就需要由调用者提前保存好这些寄存器的值，保存方法通常是把寄存器的值压入堆栈中，调用者保存完成后，在被调用者（子函数）中就可以随意覆盖这些寄存器的值了。
如果一个寄存被标识为Callee Save，那么在函数调用时，调用者就不必保存这些寄存器的值而直接进行子函数调用，进入子函数后，子函数在覆盖这些寄存器之前，需要先保存这些寄存器的值，即这些寄存器的值是由被调用者来保存和恢复的。
具体来讲：
当该函数是处于调用者角色时，如果该函数执行过程中产生的临时数据会已存
储在%eax，%edx，%ecx这些寄存器中，那么在其执行call指令之前会将这些寄存器的数据写入其栈帧内指定的内存区域，这个过程叫做调用者保存约定(Caller Save)。
当该函数是处于被调用者角色时，那么在其使用这些寄存器%ebx，%esp，%edi之前，那么该函数会保存这些寄存器中的信息到其栈帧指定的内存区域，这个过程叫被调用者保存约定；%eax总会被用作返回整数值。
%esp，%ebp总被分别用着指向当前栈帧的顶部和底部，主要用于在当前函数推出时，将他们还原为原始值；往往会在栈帧开始处保存上一个栈帧的ebp，而esp是全栈的栈顶指针，一直指向栈的顶部。
注：在x86-64架构下也是类似的约定！

（三）x86-64架构

  • 寄存器约定
最后就是我们目前主流的x86-64架构了；
对于x86-64架构，最常用的有16个64位通用寄存器，各寄存器及用途如下所示：
v2-307c308847011c63867b0335b71ba188_720w.jpg
从上面的表可以看到，除了扩展原来存在的通用寄存器，x64架构还引入了8个新的通用寄存器：r8-r15。
这些寄存器虽然都可以用，但是还是做了一些规定，如下：
函数返回值存放的寄存器：rax。

  • rax同时也用于乘法和除法指令中。在imul指令中，两个64位的乘法最多会产生128位的结果，需要rax与rdx共同存储乘法结果，在div指令中被除数是128位的，同样需要rax与rdx共同存储被除数
  • rsp是堆栈指针寄存器，通常会指向栈顶位置，堆栈的pop和push操作就是通过改变rsp的值即移动堆栈指针的位置来实现的。
  • rbp是栈帧指针，用于标识当前栈帧的起始位置。
  • %rdi，%rsi，%rdx，%rcx，%r8，%r9六个寄存器用于存储函数调用时的6个参数（如果有6个或6个以上参数的话）。
  • rbx被标识为 “miscellaneous registers”，属于通用性更为广泛的寄存器，编译器或汇编程序可以根据需要存储任何数据。
  • rbx、rbp、r12、r13、r14、r15：这些寄存器由被调用者负责保护，在返回的时候要恢复这些寄存器中原本的值。
同时，和上面x32架构类似这里也要区分Caller Save和Callee Save寄存器，即寄存器的值是由 调用者保存 还是由 被调用者保存。

  • 函数传参优化
在x32的时代，通用寄存器少，参数传递都是通过入栈（汇编指令push）实现的（当然也有使用寄存器传递的，比如著名的C++ this指针使用ecx寄存器传递，不过能用的寄存器毕竟不多），相对CPU寄存器来说，访问太慢，函数调用的效率就不高；
而在x86-64时代，寄存器数量多了，CPU就可以利用额外的寄存器rdi、rsi、rdx、rcx、r8、r9来存储参数！
寄存器传参的好处是速度快，减少了对内存的读写次数。
注：多于6个的参数，依然还是通过入栈实现传递。
因此在x86_64位机器上编程时，需要注意：

  • 为了效率尽量使用少于6个参数的函数。
  • 传递比较大的参数，尽量使用指针，因为寄存器只有64位。
注意：具体使用栈还是用寄存器传参数，这个不是编程语言决定的，而是编译器在编译生成CPU指令时决定的。如果编译器非要在x64架构CPU上使用线程栈来传参那也不是不行，这个对高级语言是无感知的。
（四）x86-64寄存器的向下兼容
上述的寄存器名字都是64位的名字，对于每个寄存器，我们还可以只使用它的一部分，并使用另一个新的名字：
image.png
下面这些寄存器可能也会需要用到其他寄存器：

  • 8个80位的x87寄存器（%st0~st7），用于浮点计算。
  • 8个64位的MMX寄存器，用于MMX指令（多媒体指令），这8个寄存器跟 x87寄存器在物理上是相同的寄存器。
  • 16个128位的SSE寄存器，用于SSE指令。
  • RIP指令寄存器，保存指令地址。
  • flags（rflags-64位，eflags-32位）寄存器。每个位用来标识一个状态。比如，这些标识符可能用于比较和跳转的指令。
和上面所述的x86架构类似，在x86-64架构下也存在实模式；更多关于 x86-64 处理器架构：
http://c.biancheng.net/view/3460.html
https://www.cnblogs.com/mazhimazhi/p/15236954.html
更多关于CPU寄存器历史见：
https://zhuanlan.zhihu.com/p/272135463

三、函数调用结构
上文简单复习了一下汇编和寄存器相关的内容。下面来正式来看看函数调用的底层是如何实现的！
注：这里的说明采用的是：

  • 编译器：GCC 12.1。
  • 优化级别为-O0。
  • 汇编指令为intel架构。

（一）函数调用
子函数调用时，调用者与被调用者的栈帧结构如下图所示：
image.png
在子函数调用时，需要切换上下文使得当前调用栈进入到一个新的执行中：

  • 父函数将调用参数从后向前压栈：由函数调用者完成（上文中的Caller逻辑）。
  • 将返回地址压栈保存：call指令完成。
  • 跳转到子函数起始地址执行：call指令完成。
  • 子函数将父函数栈帧起始地址（%rpb）压栈：由函数被调用者完成（上文中的Callee逻辑）；
  • 将%rbp的值设置为当前%rsp的值，即将%rbp指向子函数栈帧的起始地址：由函数被调用者完成（上文中的Callee逻辑），完成函数上下文的切换。
保存返回地址和保存上一栈帧的%rbp都是为了函数返回时，恢复父函数的栈帧结构（保存函数调用上下文）。
在使用高级语言进行函数调用时，由编译器自动完成上述整个流程；甚至对于”Caller Save”和“Callee Save”寄存器的保存和恢复，也都是由编译器自动完成的。
需要注意的是：父函数中进行参数压栈时，顺序是从后向前进行的（调用栈空间都是从大地址向小地址延伸，这一点刚好和堆空间相反）。
这一行为并不是固定的，是依赖于编译器的具体实现的。
至少在GCC中，使用的是从后向前的压栈方式，这种方式便于支持类似于printf(“%d，%d”，i，j) 这样的使用变长参数的函数调用。
以下面的函数为例：
  1. void func() {}
  3. void my_func() {
  4.     func();
  5. }
对应的汇编为：
  1. func():
  2.         push    rbp
  3.         mov     rbp, rsp
  4.         nop
  5.         pop     rbp
  6.         ret
  7. my_func():
  8.         push    rbp
  9.         mov     rbp, rsp
  10.         call    func()
  11.         nop
  12.         pop     rbp
  13.         ret
在函数my_func和func中：开始的两句就是由编译器默认生成的切换上下文语句（函数my_func中也存在这个语句是因为它最终也会被其他函数s调用）。
当my-func函数调用func函数时：

  • 首先，执行call指令，保存返回地址，并跳转至func函数起始地址（这里没有压栈调用参数是因为func入参为空）。
  • 随后，在func函数中，使用push rbp和mov rbp，rsp保存上下文，随后开始执行func函数中的逻辑。
  • 由于没有代码，且没有返回值，此次为nop指令。
  • 最后，恢复上下文，并返回（函数返回在下文中介绍）。
函数开头的push rbp和mov rbp，rsp又叫做函数的序言（prologue），几乎每个函数一开始都会该指令。
它和函数最后的pop rbp和ret（epilogue）起到维护函数的调用栈的作用。
接下来，顺理成章的我们来看一下函数的返回过程。
（二）函数返回
函数返回时，我们只需要得到函数的返回值（保存在%rax中），之后就需要将栈的结构恢复到函数调用之差的状态，并跳转到父函数的返回地址处继续执行即可。
由于函数调用时已经保存了返回地址和父函数栈帧的起始地址，要恢复到子函数调用之前的父栈帧，我们只需要执行以下两条指令：
  1. pop rbp
  2. ret
首先执行pop rbp指令，直接将调用栈地址恢复至调用函数之前的状态。
随后通过ret指令跳转至返回地址处并执行。
（三）数据参数传递

  • 函数参数传递概述
在函数调用中，另一个需要关注的便是函数参数的传递：入参传递以及返回值传递。
函数在计算的时候，存储数据的地方总共有三个：

  • 寄存器；
  • 内存：栈空间、堆（heap）空间、静态区。
  • 程序本身：只读的程序数据片段，比如int i=4，这个4存储于程序本身，在汇编里面又叫立即数（immediate number）。
知道了数据的存储地方，那么数据的传递就分为以下四个方面：

  • 从内存到寄存器；
  • 从寄存器到内存；
  • 从立即数到寄存器；
  • 从立即数到内存。
注意：数据不能从内存直接传递到内存，如果需要从内存传递到内存，要以寄存器为中介！
同时需要注意的是：数据是有大小的！
比如：一个word是两个字节（16bit），double words是四个字节（32bit），quadruple words是八个字节（64bit）。
所以传递数据的时候，要知道传递的数据大小：
Intel格式的汇编会在数据前面说明数据大小：比如 mov DWORD PTR [rbp-4]，4，意思是将一个4字节的4存储到栈上（地址为rbp-4）。
而AT&T格式是通过指令的后缀来说明，同样的指令为movl $4, -4(%rbp)；并且存储的地方，AT&T汇编是通过前缀来区别，比如%q前缀表示寄存器，$表示立即数，()表示内存。
学习了数据的传递方式之后，让我们看看函数的调用习惯。

  • 函数参数传递约定
之前我们简单学习了一下Caller和Callee的区别，在这里我们会深入的学习。
首先，什么是函数调用约定？
在Caller调用Callee时，要将参数(arguements)传递给Callee，一个函数可以接收多个参数，而Caller与Callee之间约定的每个参数的应该怎么传递就是调用习惯；这样，Callee才能到指定的位置获取到相应的参数。
比如下面的代码：
  1. int square(int num) {
  2.     return num * num;
  3. }
  5. int main() {
  6.     int i = 4;
  7.     int j = square(i);
  8. }
在main函数中调用square，参数i是如何传递到square中的？
上面的代码对应的汇编如下：
  1. square(int):
  2.         push    rbp
  3.         mov     rbp, rsp
  4.         mov     DWORD PTR [rbp-4], edi
  5.         mov     eax, DWORD PTR [rbp-4]
  6.         imul    eax, eax
  7.         pop     rbp
  8.         ret
  9. main:
  10.         push    rbp
  11.         mov     rbp, rsp
  12.         sub     rsp, 16
  13.         mov     DWORD PTR [rbp-4], 4
  14.         mov     eax, DWORD PTR [rbp-4]
  15.         mov     edi, eax
  16.         call    square(int)
  17.         mov     DWORD PTR [rbp-8], eax
  18.         mov     eax, 0
  19.         leave
  20.         ret
通过上面的汇编，我们可以知道：
在main里面，4先存到栈上（mov DWORD PTR [rbp-4]，4），然后存在edi里面（mov eax，DWORD PTR [rbp-4]、mov edi，eax），而sqaure函数直接就从edi里面读取4的值了！
这就说明：参数4是通过寄存器edi传给了callee (sqaure) 。
可能有同学会以为，从代码看，参数不是直接就传给了sqaure吗？实际上，在汇编中，这个变量i是不存在的，只有寄存器和内存，因此我们需要约定好入参i的值存在哪里。
下面让我们来详细看看这些约定、常见寄存器负责传递的参数以及一些作用（前文简要介绍了一些）：
image.png
在上面的列表中：

  • 蓝色的是callee-owned、绿色背景的是caller-owned。
  • callee-owned表明：callee可以自由地使用这些寄存器，覆盖已有的值；如果caller要使用这些寄存机，那么它在调用callee前，要把这些寄存器保存好；例如：如果寄存器%rax的值caller想要保留，那么在调用函数之前，caller需要赋值这个值到“安全”的地方。
  • caller-owned表明：如果callee要使用这些寄存器，那么它就要保存好这些寄存器的值，并且返回到caller的时候要将这些值恢复；caller-owned的寄存器通常用于caller需要在函数之间保留的局部状态。
  • 一共有六个通用的寄存器用于传递参数；按顺序传递需要通用寄存器传递的参数，如果通用寄存器使用完了，那么就使用栈来传递。
同时，如果函数返回比较大的对象，那么第一个参数rdi会用来传递存储这个对象的地址（这个地址是由caller分配的）。
有了这些基础，我们就更容易理解C++中的copy elision了。
相关阅读：

  • 深入理解C++中的move和forward
  • Copy/move elision: C++ 17 vs C++ 11

四、常见控制结构
在知道了函数参数是如何传递的之后，我们来更升一级。
下面根据具体代码来看一看我们经常使用的if、for、while等控制结构在底层是如何实现的。
if，while循环等控制结构，在汇编里面，都是基于判定语句，跳转语句实现的：做一个计算，检查相应的flag，然后根据flag的值确定要跳转到哪里。
比如下面的if语句：
  1. int multiply(int j) {
  2.     if (j > 6) {
  3.         return j*2;
  4.     } else {
  5.         return j*3;
  6.     }
  7. }
对应的汇编语句如下：
  1. multiply(int):
  2.         push    rbp
  3.         mov     rbp, rsp
  4.         mov     DWORD PTR [rbp-4], edi
  5.         cmp     DWORD PTR [rbp-4], 6
  6.         jle     .L2
  7.         mov     eax, DWORD PTR [rbp-4]
  8.         add     eax, eax
  9.         jmp     .L3
  10. .L2:
  11.         mov     edx, DWORD PTR [rbp-4]
  12.         mov     eax, edx
  13.         add     eax, eax
  14.         add     eax, edx
  15. .L3:
  16.         pop     rbp
  17.         ret
最前面和最后两条命令就是函数调用中的上下文切换，这个在前文中已经详细说明了。
函数的逻辑从第三条语句真正开始：
mov DWORD PTR [rbp-4]，edi表示将寄存器edi中的4个字节的值（DWORD PTR）移至 [rbp-4] 对应内存地址中。
这里和上面所讲述的参数传递的约定是保持一致的，因为我们的入参j是int类型，只有32位，因此使用的是edi寄存器来传递的参数。
随后，使用cmp指令将内存中的数和立即数6进行比较（即，j>6），此指令会改变标志寄存器%eflags的状态。
然后jle会利用标志寄存器%eflags中的状态进行跳转：

  • 如果j<=6，跳转至.L2。
  • 否则继续向下执行（对应j>6的场景）。
无论是向下执行还是跳转至.L2执行，最终两者都会执行至.L3并返回。
下面再来看一个for循环的例子：
  1. int add(int j) {
  2.     int ret = 0;
  3.     for (int i = 0; i < j; ++i) {
  4.         ret+= i;
  5.     }
  6.     return ret;
  7. }
对应的汇编如下：
  1. add(int):
  2.         push    rbp
  3.         mov     rbp, rsp
  4.         mov     DWORD PTR [rbp-20], edi
  5.         mov     DWORD PTR [rbp-4], 0
  6.         mov     DWORD PTR [rbp-8], 0
  7.         jmp     .L2
  8. .L3:
  9.         mov     eax, DWORD PTR [rbp-8]
  10.         add     DWORD PTR [rbp-4], eax
  11.         add     DWORD PTR [rbp-8], 1
  12. .L2:
  13.         mov     eax, DWORD PTR [rbp-8]
  14.         cmp     eax, DWORD PTR [rbp-20]
  15.         jl      .L3
  16.         mov     eax, DWORD PTR [rbp-4]
  17.         pop     rbp
  18.         ret
从上面的汇编我们可以看到，入参j依旧是由寄存器edi传递，并存储在了内存[rbp-20]中。
随后两行分别初始化了参数ret:[rbp-4]、i:[rbp-8]。
紧接着，指令直接跳转至.L2处，首先比较了[rbp-8]和[rbp-20]中的值（即比较i和j）：如果i<j则跳转至.L3处执行。
这里的判断是符合for循环的逻辑的：在进入for循环之前首先会判断一次条件。
.L3代码块是for循环的真正逻辑：
  1. ; ret += i;
  2. mov     eax, DWORD PTR [rbp-8]
  3. add     DWORD PTR [rbp-4], eax
  5. ; ++i
  6. add     DWORD PTR [rbp-8], 1
其他控制结构的逻辑也是类似的，这里不再赘述了！

五、总结
本文首先简要复习了汇编以及通用寄存器相关的内容，随后进入到文章主题：函数调用。在函数调用中讲述了函数调用中的调用和返回细节、上下文切换保护、函数传递等内容。最后略微引申了函数中常见控制结构的底层实现。

作者简介：
张凯，腾讯后台开发工程师。