【c++】函数调用过程，4种调用约定

最新推荐文章于 2024-08-10 22:37:55 发布
最新推荐文章于 2024-08-10 22:37:55 发布
阅读量1k 收藏 6
点赞数 6
分类专栏： c++、STL 程序员自我修养
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zDavid_2018/article/details/96474689
版权

一、什么是栈

1.定义：

栈：数据结构中的栈，是一个容器，先进后出的属性；计算机系统中，栈是具有以上属性的动态内存区域，程序将数据压入栈，也可以从栈顶弹出，压栈使栈增大，出栈使栈减小，栈总是向下增长（由高地址向低地址）；

如图4G虚拟地址空间布局：

ZONE_DMA的范围是0~16M，该区域的物理页面专门供I/O设备的DMA使用。之所以需要单独管理DMA的物理页面，是因为DMA使用物理地址访问内存，不经过MMU，并且需要连续的缓冲区，所以为了能够提供物理上连续的缓冲区，必须从物理地址空间专门划分一段区域用于DMA。

ZONE_NORMAL的范围是16M~896M，该区域的物理页面是内核能够直接使用的。

ZONE_HIGHMEM的范围是896M~结束，该区域即为高端内存，内核不能直接使用。

2.栈的作用、栈中内容

栈，保存了一个函数调用所需要的维护的信息，被称作堆栈帧或活动记录。堆栈帧有如下内容：

（1）函数的返回地址和参数

（2）临时变量：函数内的非静态局部变量（static局部变量存放在.data或者.bss段）、编译时生成的其它临时变量

（3）保存上下文：包括函数调用前后需要保持不变的寄存器。

3.关于esp、ebp寄存器

在i386中，一个函数的活动记录用esp、ebp这两个寄存器划定范围。

esp寄存器始终指向栈顶部，同时也指向当前函数活动记录的顶部；ebp寄存器指向函数活动记录的一个固定位置。

ebp所指向的数据是调用该函数前ebp的值，这样在函数返回的时候，ebp就可以通过这个值恢复到调用前的值（我理解的就是栈帧回退） 。

4.几个汇编指令：

函数调用标准开头

（1）push ebp ：把ebp压入栈中（成为old ebp）

（2）mov ebp，esp   ：ebp=esp，即把ebp指向esp的位置，这是ebp指向栈顶，此时栈顶就是old ebp

（3）sub exp，xxx  ：在栈生分配xxx字节的临时空间

（4）push xxx ：如有必要，保存名为xxx的寄存器

函数调用标准结尾

（1）pop xxx ：如有必要，回复保存过得寄存器

（2）mov esp，ebp   ：esp=ebp，将esp指向ebp的位置，栈帧回退，回复esp同时回收局部变量空间

（3）pop ebp：从栈中恢复保存ebp的值，

（4）ret ：从栈中取得返回地址，并跳转到该位置

其他：

（1）call fun1 (0C31127h)：call相当于调用函数，这里重新设置了栈底ebp和栈顶esp

（2）add  esp，8   ：算数运算指令 加法

（3）lea ：装入有效地址

（参考汇编指令大全博客 https://blog.csdn.net/baishuiniyaonulia/article/details/78504758）

二、函数参数带入、栈帧开辟

0.函数参数带入

源代码：

int fun1(int a, int b)
{
	int c = a + b;
	return c;
}
 
int main()
{
	int a = fun1(10, 20);
 
	return 0;
}

 查看汇编代码：首先设置断点，在main开始处，启动调试（VS必须处于调试状态才能看到汇编指令窗口），在当程序运行到断点处停止时，依次点击调试->窗口->反汇编；英文显示为"Debug"下的"Windows"子菜单，选择"Disassembly"。

 汇编代码如下：

main函数

int main()
{
00C31410  push        ebp  
00C31411  mov         ebp,esp  
00C31413  sub         esp,0CCh  
00C31419  push        ebx  
00C3141A  push        esi  
00C3141B  push        edi  
00C3141C  lea         edi,[ebp-0CCh]  
00C31422  mov         ecx,33h  
00C31427  mov         eax,0CCCCCCCCh  
00C3142C  rep stos    dword ptr es:[edi]  
	int a = fun1(10, 20);
00C3142E  push        14h  
00C31430  push        0Ah  
00C31432  call        fun1 (0C31127h)  
00C31437  add         esp,8  
00C3143A  mov         dword ptr [a],eax  
 
	return 0;
00C3143D  xor         eax,eax  
}
00C3143F  pop         edi  
00C31440  pop         esi  
00C31441  pop         ebx  
00C31442  add         esp,0CCh  
00C31448  cmp         ebp,esp  
00C3144A  call        __RTC_CheckEsp (0C3113Bh)  
00C3144F  mov         esp,ebp  
00C31451  pop         ebp  
00C31452  ret

 调试进入main函数栈帧，EBP = 0075FA14，  ESP = 0075F93C ，ebp作为栈底寄存器，esp为栈顶寄存器，栈顶栈底唯一标志着一个函数调用栈。

如图main栈帧：

 

将汇编代码执行到函数调用的地方，查看函数调用参数带入的指令。

	int a = fun1(10, 20);
00C3142E  push        14h  
00C31430  push        0Ah  
00C31432  call        fun1 (0C31127h)  
00C31437  add         esp,8  
00C3143A  mov         dword ptr [a],eax

首先观察这里的汇编代码，参数顺序是10，20，在这里汇编指令首先push 14h也就是20，再push 0Ah也就是10。从这里可以看出来，参数入栈的顺序是从右向左入栈的。

参数入栈示意图如图：

进入call fun

int fun1(int a, int b)
{
009813D0  push        ebp       //将main函数栈帧的栈底地址ebp入栈
009813D1  mov         ebp,esp   //将main函数栈顶地址赋给ebp寄存器，成为fun函数的栈底
009813D3  sub         esp,0CCh  //将main函数的栈顶地址esp减少0xc0，成为fun函数的栈顶
009813D9  push        ebx  
009813DA  push        esi  
009813DB  push        edi  
009813DC  lea         edi,[ebp-0CCh]  //将fun1函数的栈帧空间循环赋值为0xcccc cccc
009813E2  mov         ecx,33h  
009813E7  mov         eax,0CCCCCCCCh  
009813EC  rep stos    dword ptr es:[edi]  
	int c = a + b;
009813EE  mov         eax,dword ptr [a]  
009813F1  add         eax,dword ptr [b]  
009813F4  mov         dword ptr [c],eax  
	return c;
009813F7  mov         eax,dword ptr [c]  
}

 

函数堆栈调用开栈过程：

1.压入实参，自右向左

2.压入下一行指令地址

3.压入调用方函数的栈底地址（本例中为main的栈底esp）

4.调转到被调用方函数栈帧（本例中为 fun函数）

5.开辟被调用方函数所需要运行的空间（本例中fun函数所需空间位C0）

 

1.<=8KB参数的带入

接下来我们看看参数入栈会不会根据参数的大小而产生区别。

struct Tmp
{
    char a;
};//大小为1字节

int fun1(struct Tmp a, struct Tmp b)
{
    return 0；
}

int main()
{
    struct Tmp tmp1, tmp2;
    tmp1.a = 10;
    tmp2.a = 20;
    int a = fun1(tmp1,tmp2);
    return 0;
}

在这里我们给函数传入两个一字节大小的参数，观察其汇编码。

int a = fun1(tmp1,tmp2);
00991A46  movzx       eax,byte ptr [tmp2] 
00991A4A  push        eax 
00991A4B  movzx       ecx,byte ptr [tmp1] 
00991A4F  push        ecx 
00991A50  call        fun1 (09911E5h) 

在这里，我们看看，首先从tmp2中取出值，然后push，再从tmp2中取值，然后push，由此可见，一个字节的参数，采用的是利用push入栈的方式将参数带入。

我们修改代码，将Tmp结构体的大小改为4个字节，观察其入栈 方式

struct Tmp
{
    int a;
};//大小为4字节

int fun1(struct Tmp a, struct Tmp b)
{
    return 0;
}

int main()
{
    struct Tmp tmp1, tmp2;
    tmp1.a = 10;
    tmp2.a = 20;
    int a = fun1(tmp1,tmp2);
    return 0;
}

 

观察其fun1函数调用的汇编码  

其汇编码和Tmp结构体为一个字节时候无异，说明在参数为4字节时候，函数参数依旧采用push入栈的方式带入。

  int a = fun1(tmp1,tmp2);
00EE365C  mov         eax,dword ptr [tmp2] 
00EE365F  push        eax 
00EE3660  mov         ecx,dword ptr [tmp1] 
00EE3663  push        ecx 
00EE3664  call        fun1 (0EE11E5h) 

接下来来看看Tmp结构体的大小为8字节时候的入栈方式

struct Tmp
{
    int a;
    int b;
};//大小为8字节

int fun1(struct Tmp a, struct Tmp b)
{
    return 0;
}

int main()
{
    struct Tmp tmp1, tmp2;
    tmp1.a = 10;
    tmp1.b = 15;
    tmp2.a = 20;
    tmp2.b = 25;
    int a = fun1(tmp1,tmp2);
    return 0;
}

fun1函数调用时候的汇编代码 

   int a = fun1(tmp1,tmp2);
002D366A  mov         eax,dword ptr [ebp-18h] 
002D366D  push        eax 
002D366E  mov         ecx,dword ptr [tmp2] 
002D3671  push        ecx 
002D3672  mov         edx,dword ptr [ebp-8] 
002D3675  push        edx 
002D3676  mov         eax,dword ptr [tmp1] 
002D3679  push        eax 
002D367A  call        fun1 (02D11E5h) 
当前的ebp值为0x0095FD60，那么ebp-18h是谁呢？我们来看看。
0x0095FD44  14 00 00 00  ....   tmp2.a                        ebp-1ch    tmp2
0x0095FD48  19 00 00 00  ....   tmp2.b                        ebp-18h
0x0095FD4C  cc cc cc cc  ????   缓冲层                        ebp-14h
0x0095FD50  cc cc cc cc  ????   缓冲层                        ebp-10h
0x0095FD54  0a 00 00 00  ....   tmp1.a                        ebp-0ch    tmp1
0x0095FD58  0f 00 00 00  ....   tmp1.b                        ebp-8
0x0095FD5C  cc cc cc cc  ????    vs编译器变量中间会有防止越界的缓冲层  ebp-4
0x0095FD60  b0 fd 95 00  ???.    ebp

首先push的是ebp-18h的四个字节,也就是tmp2.b，然后是tmp2地址上取四个字节，就是tmp2.a。再push的是ebp-8的四个字节也就是tmp1.b，然后是tmp1地址上取四个字节，也就是tmp1.a。由此可见，函数参数是8个字节的时候，依旧是利用push入栈的方式将参数传递。

2.>8KB的参数带入

再看看参数大小如果为12字节时候的参数传递方式。
struct Tmp
{
	int a;
	int b;
	int c;
};//大小为12字节

int fun1(struct Tmp a, struct Tmp b)
{
	return 0;
}

int main()
{
	struct Tmp tmp1, tmp2;
	tmp1.a = 10;
	tmp1.b = 15;
	tmp1.c = 16;
	tmp2.a = 20;
	tmp2.b = 25;
	tmp2.c = 26;
	int a = fun1(tmp1,tmp2);
	return 0;
}

 

利用调试，将查看函数调用时候的汇编码
	int a = fun1(tmp1,tmp2);
008F3C58  sub         esp,0Ch     //给esp栈顶指针减少12
008F3C5B  mov         eax,esp     //将esp的值给eax寄存器
008F3C5D  mov         ecx,dword ptr [tmp2]  //将tmp.a的值写入ecx寄存器
008F3C60  mov         dword ptr [eax],ecx   //将ecx寄存器的值写入eax寄存器的地址
008F3C62  mov         edx,dword ptr [ebp-20h]  //将tmp.b的值写入edx寄存器
008F3C65  mov         dword ptr [eax+4],edx  //将edx寄存器的值写入eax寄存器的地址
008F3C68  mov         ecx,dword ptr [ebp-1Ch]  //将tmp.c的值写入ecx寄存器
008F3C6B  mov         dword ptr [eax+8],ecx  //将ecx寄存器的值写入eax寄存器的地址
008F3C6E  sub         esp,0Ch  
008F3C71  mov         edx,esp  
008F3C73  mov         eax,dword ptr [tmp1]  
008F3C76  mov         dword ptr [edx],eax  
008F3C78  mov         ecx,dword ptr [ebp-0Ch]  
008F3C7B  mov         dword ptr [edx+4],ecx  
008F3C7E  mov         eax,dword ptr [ebp-8]  
008F3C81  mov         dword ptr [edx+8],eax  
008F3C84  call        fun1 (08F11E5h)

 

从上面的汇编代码可以看出，在函数参数为12字节的时候，其参数带入方式和小于等于8字节的时候不同，在这里没有直接的push参数，而是先在main函数的栈顶向上移动12字节，然后将参数的数据拷贝到main函数栈顶开辟的内存中。其方式如图

 

三、函数返回值返回

1.<=8KB

返回值为4字节的时候

int fun1(int a, int b)

{

    int c = a + b;

    return c;

}

int main()

{   int a = 10;

    int b = 20;

    int c = fun1(a,b);

    return 0;

        }

 

        先运行到函数返回值代码处，查看汇编码

return c;

003413E7  mov         eax,dword ptr [c] 

 

接收返回值处查看汇编码

int c = fun1(a,b);

……

00343C44  call        fun1 (03411EAh) 

00343C49  add         esp,8 

00343C4C  mov         dword ptr [c],eax  //将eax寄存器的值写入到c的地址中，写入四字节

如汇编码可知，四字节的返回值利用寄存器带回，然后将寄存器的值写入到接受返回值的变量中

 

返回值为8字节的时候

struct Tmp

{

    int a;

    int b;

};//大小为8字节

 

struct Tmp fun1(int a, int b)

{

    struct Tmp c;

    c.a = a;

    c.b = b;

    return c;

}

int main()

{

    int a = 10;

    int b = 20;

            struct Tmp c;

    c = fun1(a,b);

    return 0;

}

先将代码运行到函数返回值出，查看其汇编代码

    return c;

00B7142A  mov         eax,dword ptr [c] 

00B7142D  mov         edx,dword ptr [ebp-8]

 

将代码运行到接收返回值处，查看其汇编代码

c = fun1(a,b);

……

00D63C44  call        fun1 (0D611EFh) 

00D63C49  add         esp,8 

00D63C4C  mov         dword ptr [c],eax 

00D63C52  mov         dword ptr [ebp-20h],edx

在接收返回值时候，将寄存器的值写入到接收返回值的变量中。

2.>8KB

struct Tmp
{
    int a;
    int b;
    int c;

};//大小为12字节

 struct Tmp __stdcall fun1(int a, int b)
{
    struct Tmp c;
    c.a = a;
    return c;

}
int main()
{
    int a = 10;
    int b = 20;
    struct Tmp c;
    c = fun1(a,b);
    return 0;
 }

  c = fun1(a,b);

00953C3C  mov         eax,dword ptr [b] 

00953C3F  push        eax 

00953C40  mov         ecx,dword ptr [a] 

00953C43  push        ecx 

00953C44  lea         edx,[ebp-0FCh] 

00953C4A  push        edx 

00953C4B  call        fun1 (09511F4h)  

从上面的汇编码可以看出来，当函数的返回值为12字节的时候，在参数入栈的最后还入栈了一个寄存器，该寄存器中存储的是一块位于main栈帧上的内存。

    return c;

00951A44  mov         eax,dword ptr [ebp+8] 

00951A47  mov         ecx,dword ptr [c] 

00951A4A  mov         dword ptr [eax],ecx 

00951A4C  mov         edx,dword ptr [ebp-0Ch] 

00951A4F  mov         dword ptr [eax+4],edx 

00951A52  mov         ecx,dword ptr [ebp-8] 

00951A55  mov         dword ptr [eax+8],ecx 

00951A58  mov         eax,dword ptr [ebp+8]

而在返回值的时候，先从ebp-8位置取值，去除的正好是参数入栈之后入栈的一块main函数栈帧上的地址，然后将返回的数据写入到该块内存上。

由此可见，当返回值大于8字节的时候是预先在调用方的栈帧上预留一块内存，作为函数返回值存储位置，最后返回值的时候，将返回值的数据写入到该段内存。大致结构如图

 

四、函数栈帧回退

函数栈帧的回退分为两步，一步是函数栈帧的回退，另一步时函数参数的清除。

函数栈帧回退汇编码如下

 

00EC13E0  pop         edi       将栈帧开辟时候入栈的寄存器出栈

00EC13E1  pop         esi 

00EC13E2  pop         ebx 

00EC13E3  mov         esp,ebp     让esp = ebp

00EC13E5  pop         ebp         让ebp等于栈帧开辟时候入栈的main栈帧，并将其出栈

00EC13E6  ret                     返回

 

经过上面的过程，栈帧就已经回退到了main函数，也就是调用方的栈帧。

下一步，函数参数的清除

00EC1484  call        _fun1 (0EC118Bh) 

00EC1489  add         esp,8    让esp+8清除参数内存

六、4种调用约定

1.定义：

（参考《程序员的自我修养》第10章）

何为调用约定？即调用方和被调用方对于函数的如何调用必须有一个明确的约定，只有双方都遵循这样的约定，函数才能被调用。

2.内容：

约定一般有如下几个方面：

（1）函数参数的传递顺序和方式：通过栈传递？使用寄存器传递？从右向左？从左向右？

（2）栈的维护方式：出栈由函数调用方完成？函数本身完成？

（3）名字修饰的策略：c语言中对于fun函数的声明： int _cdcel foo()

3.种类

1.cdecl为c/c++默认调用惯约定（书中将调用约定也叫调用惯例）

2.thiscall调用约定：为c++的一种特殊调用约定，用于对类成员函数的调用。

    VC里是this指针存放在ecx寄存器中，参数从右向左压栈；

   gcc中，thiscall和cdecl完全一样，只是将this看做是函数的第一个参数

 

David 's blog
关注
专栏目录
C++函数调用栈分布详解
dvlinker的技术专栏
10-27 6514
本文详细讲述C++函数调用时的栈分布情况。
C/C++函数的调用约定详解
热门推荐
dvlinker的技术专栏
06-19 1万+
本文详细讲述C/C++函数调用约定相关的内容。
c++函数调用约定
最新发布
m0_63564929的博客
08-10 953
函数调用约定（Calling Convention）指的是在函数调用时，参数的传递方式、函数返回值的处理方式以及调用者与被调用者之间如何维护堆栈等规则。不同的调用约定在这些方面有不同的实现方式，主要影响到函数的跨平台兼容性、性能优化以及编译器的行为。
C++函数的调用约定
ocfbnj的博客
10-28 726
C++函数的调用约定 文章目录C++函数的调用约定引入常见的调用约定__cdecl__stdcall__fastcall参考 引入 调用约定允许你指定被调函数和调用者之间传递参数和返回值的方式。不同的调用约定区别主要在于： 参数和返回值放置的位置。 参数传递的顺序。 调用前设置和调用后清理的工作，在调用者和被调用者之间如何分配。 并非所有约定都在所有支持的平台上可用，某些约定使用平台特定的实现。这篇文章描述的是x86平台。 在 x86 平台上，所有参数在传递时都将加宽到 32 位。 返回值也将加宽到 3
C/C++函数调用约定
sun的专栏
03-17 642
 关于 C/C++ 函数调用约定，大多数时候并不会影响程序逻辑，但遇到跨语言编程时，了解一下还是有好处的。VC 中默认调用是 __cdecl 方式，Windows API 使用 __stdcall 调用方式，在 DLL 导出函数中，为了跟 Windows API 保持一致，建议使用 __stdcall 方式。调用约定跟堆栈清除密切相关。如果写一个汇编函数，给 C/C++ 调用，在 __
__cdecl __fastcall与 __stdcall
sankt的专栏
05-03 2215
__cdecl __fastcall与 __stdcall 调用约定： __cdecl __fastcall与 __stdcall，三者都是调用约定(Calling convention)，它决定以下内容：1)函数参数的压栈顺序，2)由调用者还是被调用者把参数弹出栈，3)以及产生函数修饰名的方法。 1、__stdcall调用约定：函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存
CSAPP:函数调用过程（ebp，esp）
BAOLIANG196的博客
12-26 1462
#include <stdio.h>int func(int param1 ,int param2,int param3) { int var1 = param1; int var2 = param2; int var3 = param3; printf("var1=%d,var2=%d,var3=%d",var1,var2,var3);
C/C++函数调用的几种方式总结
09-04
在C/C++编程中，函数调用是程序执行的核心部分，不同的调用约定会影响函数的参数传递和堆栈清理方式。本文将详细讲解C/C++中常见的几种函数调用方式，包括stdcall、cdecl、fastcall、thiscall以及naked call。 1. ...
C++函数调用过程深入分析
08-11
函数调用的过程实际上也就是一个中断的过程，那么C++中到底是怎样实现一个函数的调用的呢？参数入栈、函数跳转、保护现场、回复现场等又是怎样实现的呢？本文将对函数调用的过程进行深入的分析和详细解释，并在VC ...
c/c++ 的常见4种函数调用约定 进阶知识你知道吗？
shenmingyi.blog.csdn.net
11-19 1181
前言： c/c++ 的函数调用约定？ 懵吗 我第一次听到是真懵 专门做了一些了解 记录一下 什么是函数调用约定： 就是对函数调用的一个约束和规定(规范)，描述了函数参数是怎么传递和由谁清除堆栈的。 也就以下3点： 1、参数传递的方式（是否采用寄存器传递参数、采用哪个寄存器传递参数、参数压桟的顺序等）； ps:参数的传递方式，最常见的是通过栈传递。函数的调用方将参数压入栈中，函数自己再从栈中将参数取出。 　对于有多个参数的函数，调用惯例要规定函数调用方将参数压栈的顺序，是从左往右还是从右往左。有些调用惯例还允
面试题：C++函数调用的过程？
jakelihua
06-10 756
在C++中，函数调用是指通过函数名称和参数来执行函数内部代码的过程。当程序调用一个函数时，CPU首先需要将函数的参数和返回地址等信息保存到栈空间中，并跳转到函数的入口处开始执行函数代码。当函数执行完毕后，程序又会从函数返回的地方继续执行。
__stdcall in c++ builder
weixin_33670786的博客
08-20 129
VC默认为__stdcall， BCB默认为__cdecl, Delphi默认为__fastcall。 由于BCB使用Delphi的VCL库， 所以也必须使用__fastcall。   关键字 调用规则 参数传递方向 返回 参数寄存器 堆栈的清除 __cdecl C调用规则 从右向左 EAX 无 调用者 __fastcall 寄存器 从左向右 EAX EAX、EBX、ECX 被调用...
【转】C/C++函数调用过程分析
weixin_33916256的博客
08-24 111
转自：here 这里以一个简单的C语言代码为例，来分析函数调用过程 代码： #include &lt;stdio.h&gt; int func(int param1 ,int param2,int param3) { int var1 = param1; int var2 = param2; int var3 = param3; ...
C++函数调用过程
m0_37857539的博客
03-16 1767
1、函数参数带回 2、函数栈帧开辟 3、函数返回值返回 4、函数栈帧回退 5、三种调用约定的区别
C++函数调用过程？
weixin_46319994的博客
03-17 283
C++函数调用过程？
C/C++函数调用约定与名称修饰解析
4. **thiscall**：这是C++特有的调用约定，主要用于成员函数调用，其中`this`指针通过一个特定的寄存器传递，其他参数则根据实现可能使用寄存器或堆栈。这种方式确保了`this`指针的正确传递，适用于对象方法。 函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值