浅谈函数调用

关注公众号【高性能架构探索】,第一时间获取最新文章;公众号内回复【pdf】,免费获取经典书籍

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

一、汇编概述

既然要讲解函数调用的底层逻辑实现,那么汇编语言我们是绕不过的。

因此,首先来复习一下汇编相关的知识。

我们都知道,计算机只能读懂二进制指令,而汇编就是一组特定的字符,汇编的每一条语句都直接对应CPU的二进制指令,比如:mov rax,rdx就是我们常见的汇编指令。

汇编语言就是通过一条条的 助记符+操作数实现的,并且汇编指令经过汇编器(assemble,例如Linux下的as)转变为实际的CPU二进制指令。

(一)一个简单的汇编例子

上面讲的有些空洞,来看一个实际的例子:

; 将寄存器rsp的值存储到寄存器rbp中

需要注意的是:汇编语言是和实际底层的CPU息息相关的;上面的汇编格式使用的便是Intel的语法格式。

常见的汇编语言有两种截然不同的语法:

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

  • AT&T格式:optcode source,destination,直观理解为move from source to destination。

若将上面的Intel汇编改写为AT&T汇编,则为:

movq %rsp, %rbp

可以看到,AT&T汇编的另外一个特点是:有前缀和后缀。

比如:前缀%,$;后缀q,l等等。

这些前缀后缀有特殊的意思,后文会讲解,不同的格式侧重点不太一样。

(二)常用汇编指令

下面是一些非常常用的汇编指令,在后文中都会用到:

二、通用寄存器概述

对于汇编语言,仅仅了解其语法内容是远远不够的!

由于汇编语言和CPU是息息相关的,因此在硬件层面我们还需要关注CPU的通用寄存器。

在所有CPU体系架构中,每个寄存器通常都是有建议的使用方法的,而编译器也通常依照CPU架构的建议来使用这些寄存器,因而我们可以认为这些建议是强制性的。

(一)8086架构(16bit)

让我们把视线首先转移到8086

下图展示了在8086 CPU中的各个寄存器:

主要包括下面几类寄存器:

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

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

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

  • 指令指针: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操作。

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寄存器:

可以看到,为了使得运行在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平台下一些寄存器的调用特殊约定:

作为通用寄存器,过程调用中,调用者栈帧需要寄存器暂存数据,被调用者栈帧也需要寄存器暂存数据。

为防止调用过程中数据不会被破坏丢失,C/C++编译器遵守如下约定的规则:

当产生函数调用时,子函数内通常也会使用到通用寄存器,那么这些寄存器中之前保存的调用者(父函数)的值就会被覆盖!为了避免数据覆盖而导致从子函数返回时寄存器中的数据不可恢复,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位通用寄存器,各寄存器及用途如下所示:

从上面的表可以看到,除了扩展原来存在的通用寄存器,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位的名字,对于每个寄存器,我们还可以只使用它的一部分,并使用另一个新的名字:

下面这些寄存器可能也会需要用到其他寄存器:

  • 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架构。

(一)函数调用

子函数调用时,调用者与被调用者的栈帧结构如下图所示:

在子函数调用时,需要切换上下文使得当前调用栈进入到一个新的执行中:

  • 父函数将调用参数从后向前压栈:由函数调用者完成(上文中的Caller逻辑)。

  • 将返回地址压栈保存:call指令完成。

  • 跳转到子函数起始地址执行:call指令完成。

  • 子函数将父函数栈帧起始地址(%rpb)压栈:由函数被调用者完成(上文中的Callee逻辑);

  • 将%rbp的值设置为当前%rsp的值,即将%rbp指向子函数栈帧的起始地址:由函数被调用者完成(上文中的Callee逻辑),完成函数上下文的切换。

保存返回地址和保存上一栈帧的%rbp都是为了函数返回时,恢复父函数的栈帧结构(保存函数调用上下文)。

在使用高级语言进行函数调用时,由编译器自动完成上述整个流程;甚至对于”Caller Save”和“Callee Save”寄存器的保存和恢复,也都是由编译器自动完成的。

需要注意的是:父函数中进行参数压栈时,顺序是从后向前进行的(调用栈空间都是从大地址向小地址延伸,这一点刚好和堆空间相反)。

这一行为并不是固定的,是依赖于编译器的具体实现的。

至少在GCC中,使用的是从后向前的压栈方式,这种方式便于支持类似于printf(“%d,%d”,i,j) 这样的使用变长参数的函数调用。

以下面的函数为例:

void func() {}

对应的汇编为:

func():

在函数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中),之后就需要将栈的结构恢复到函数调用之差的状态,并跳转到父函数的返回地址处继续执行即可。

由于函数调用时已经保存了返回地址和父函数栈帧的起始地址,要恢复到子函数调用之前的父栈帧,我们只需要执行以下两条指令:

pop rbp

首先执行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才能到指定的位置获取到相应的参数。

比如下面的代码:

int square(int num) {

在main函数中调用square,参数i是如何传递到square中的?

上面的代码对应的汇编如下:

square(int):

通过上面的汇编,我们可以知道:

在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的值存在哪里。

下面让我们来详细看看这些约定、常见寄存器负责传递的参数以及一些作用(前文简要介绍了一些):

在上面的列表中:

  • 蓝色的是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语句:

int multiply(int j) {

对应的汇编语句如下:

multiply(int):

最前面和最后两条命令就是函数调用中的上下文切换,这个在前文中已经详细说明了。

函数的逻辑从第三条语句真正开始:

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循环的例子:

int add(int j) {

对应的汇编如下:

add(int):

从上面的汇编我们可以看到,入参j依旧是由寄存器edi传递,并存储在了内存[rbp-20]中。

随后两行分别初始化了参数ret:[rbp-4]、i:[rbp-8]。

紧接着,指令直接跳转至.L2处,首先比较了[rbp-8]和[rbp-20]中的值(即比较i和j):如果i<j则跳转至.L3处执行。

这里的判断是符合for循环的逻辑的:在进入for循环之前首先会判断一次条件。

.L3代码块是for循环的真正逻辑:

; ret += i;

其他控制结构的逻辑也是类似的,这里不再赘述了!


五、总结

本文首先简要复习了汇编以及通用寄存器相关的内容,随后进入到文章主题:函数调用。

关注公众号【高性能架构探索】,第一时间获取最新文章;公众号内回复【pdf】,免费获取计算机经典书籍

本文来自于作者公众号文章转载,链接:浅谈函数调用

在函数调用中讲述了函数调用中的调用和返回细节、上下文切换保护、函数传递等内容。

最后略微引申了函数中常见控制结构的底层实现。

原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/1231

关注公众号【高性能架构探索】,第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处!

(0)
上一篇 2022年11月1日 上午11:36
下一篇 2022年11月1日 上午11:58

相关推荐