!函数调用过程详尽分析-c 汇编

函数调用时栈的变化收藏

1．1 标准调用（__stdcall函数）

1．1．1 代码

#include

int __stdcall Callee(int param1,int param2)

{

int iV ar = param1;

return 10;

}

int main()

{

Callee(1,2);

return 0;

}

1．1．2 函数int main()

int main()

{

00411460 push ebp

00411461 mov ebp,esp

00411463 sub esp,0C0h

00411469 push ebx

0041146A push esi

0041146B push edi

0041146C lea edi,[ebp-0C0h]

00411472 mov ecx,30h

00411477 mov eax,0CCCCCCCCh

0041147C rep stos dword ptr es:[edi]

Callee(1,2);

0041147E push 2

00411480 push 1

00411482 call CrackFun (4111EAh)

【Jeffrey：在函数调用前先将参数从左到右入栈，然哈欧调用参数。】return 0;

00411487 xor eax,eax

}

00411489 pop edi

0041148A pop esi

0041148B pop ebx

0041148C add esp,0C0h

00411492 cmp ebp,esp

00411494 call @ILT+300(__RTC_CheckEsp) (411131h)

00411499 mov esp,ebp

0041149B pop ebp

0041149C ret

--- No source file -------------------------------------------------------------

......

004111E5 jmp Callee (411410h)

004111EA jmp Callee (411410h)

【Jeffrey：此时已经将函数的返回值地址压入栈中。】

004111EF int 3

004111F0 int 3

......

1．1．3 函数int __stdcall Callee(int param1,int param2)

int __stdcall Callee(int param1,int param2)

{

00411410 push ebp

00411411 mov ebp,esp

00411413 sub esp,0CCh

00411419 push ebx

0041141A push esi

0041141B push edi

【Jeffrey：在子函数入口处，依次将以上4个寄存器的值入栈。】

0041141C lea edi,[ebp-0CCh]

00411422 mov ecx,33h

00411427 mov eax,0CCCCCCCCh

0041142C rep stos dword ptr es:[edi]

int iV ar = param1;

0041142E mov eax,dword ptr [param1]

00411431 mov dword ptr [iV ar],eax

return 10;

00411434 mov eax,0Ah

【Jeffrey：函数返回值放在寄存器EAX中。】

}

00411439 pop edi

0041143A pop esi

0041143B pop ebx

0041143C mov esp,ebp

0041143E pop ebp

【Jeffrey：在函数返回前，将入口处入栈的寄存器逆次出栈。】

0041143F ret 8

【Jeffrey：标准调用中，函数返回前负责恢复堆栈信息，“8”为传入参数的大小。】--- No source file -------------------------------------------------------------

1．2 C调用（__cdecl函数）

1．2．1 代码

#include

int __cdecl Callee(int param1,int param2)

{

int iV ar = param1;

return 10;

}

int main()

{

Callee(1,2);

return 0;

}

1．2．2 函数int main()

int main()

{

004113D0 push ebp

004113D1 mov ebp,esp

004113D3 sub esp,0C0h

004113D9 push ebx

004113DA push esi

004113DB push edi

004113DC lea edi,[ebp-0C0h]

004113E2 mov ecx,30h

004113E7 mov eax,0CCCCCCCCh

004113EC rep stos dword ptr es:[edi]

Callee(1,2);

004113EE push 2

004113F0 push 1

004113F2 call Callee (411136h)

004113F7 add esp,8

【Jeffrey：函数返回后主调函数负责恢复堆栈信息。】return 0;

004113FA xor eax,eax

}

004113FC pop edi

004113FD pop esi

004113FE pop ebx

004113FF add esp,0C0h

00411405 cmp ebp,esp

00411407 call @ILT+300(__RTC_CheckEsp) (411131h)

0041140C mov esp,ebp

0041140E pop ebp

0041140F ret

--- No source file -------------------------------------------------------------

1．2．3 函数int __cedcl Callee(int param1,int param2)

int __cdecl Callee(int param1,int param2)

{

00411390 push ebp

00411391 mov ebp,esp

00411393 sub esp,0CCh

00411399 push ebx

0041139A push esi

0041139B push edi

0041139C lea edi,[ebp-0CCh]

004113A2 mov ecx,33h

004113A7 mov eax,0CCCCCCCCh

004113AC rep stos dword ptr es:[edi]

int iV ar = param1;

004113AE mov eax,dword ptr [param1]

004113B1 mov dword ptr [iV ar],eax

return 10;

004113B4 mov eax,0Ah

}

004113B9 pop edi

004113BA pop esi

004113BB pop ebx

004113BC mov esp,ebp

004113BE pop ebp

004113BF ret

【Jeffrey：C调用中，子函数不负责堆栈信息。】

--- No source file -------------------------------------------------------------

1．3 函数调用过程中栈数据的变化

本文来自CSDN博客，转载请标明出处：90a94a3143323968011c9265/Fy2007/archive/2007/04/01/1548248.aspx

浅谈c程序函数调用过程收藏

关键词：

栈区：就是一个内存地址空间，每调用一次函数就会在栈区为此函数分配一段空间（主要用于存储局部变量，

此段空间下面就直接定义为函数栈）

ebp :用于存放函数栈的栈顶地址

esp:用于存放此函数栈的栈底地址

注意：栈顶地址大于栈底地址，栈是从栈顶向栈底增长。即ebp-->esp;

下面我们分析如下代码例子，看看它的调用机制

#include

int fun(int c)

{

int d=c+1;

return d;

}

int main()

{

int a=1;

int b=fun(a);

return 0;

}

int a=1;

汇编代码：mov dword ptr [ebp-4],1

很显然，ebp是用作的了基址寄存器，注意ebp的值是不会变的，它会固定指向函数栈的栈顶，在这里ebp此时的值是0x0013FF80

int b=fun(a);

汇编代码：

mov eax,dword ptr [ebp-4]

push eax

call @ILT+0(fun) (00401005)

add esp,4

mov dword ptr [ebp-8],eax

注意前面两句，[ebp-4]显然是a的地址，这两句是将参数a压入esp指向的栈中（即栈底）在这里esp此时的值是0x0013FF2C（

即编译器给main函数局部变量分配的栈空间为0x0013FF80-0x0013FF2C=54H的栈空间）

当执行完了第二条指令之时esp的值减4H变为0x0013FF28,所以可以看出函数参数是被放在了main函数栈的下面，紧挨栈底。

然后系统自动继续将函数返回地址（即上面第四条语句的地址）压入栈中，此时esp的值0x0013FF24.

call指令调用fun函数，在fun函数开始执行自己代码之前会先执行如下代码（这在函数调用中是必须的）

push ebp

mov ebp,esp

sub esp,44h

push ebx

push esi

push edi

lea edi,[ebp-44h]

mov ecx,11h

mov eax,0CCCCCCCCh

rep stos dword ptr [edi]

具体工作如下：

现将main函数栈顶指针ebp压入栈中（这很重要，在函数返回时有用），此时esp为0x0013FF20，然后将此值再存入ebp中，

即下一个fun函数栈的栈顶。fun函数栈底则变为0x0013FF20-44h即,编译器为fun函数局部变量分配了44h的栈空间，

此时esp指向了0x0013FEDC。然后再将ebx,esi,edi中的值压入栈中（在这个简单的例子中，这些寄存器都没用到）然后esp减去CH，

变为了0x0013FED0。后面四条指令与我们分析的主题无直接关系，就不说了，而且在此例中无用。

下面将注意力放在fun函数是如何取参数的：

int d=c+1;

mov eax,dword ptr [ebp+8]

add eax,1

mov dword ptr [ebp-4],eax

从第一条指令可以看出fun函数的参数是在[ebp+8]位置的，即在fun函数栈顶的上面，这种机制可以很好的区分函数参数与局部

变量，之所以加8是因为在ebp的上面还有main函数返回地址。然后才是函数参数。

现在可以将注意力集中在fun函数是如何返回的：

返回代码如下：

mov eax,dword ptr [ebp-4]

pop edi

pop esi

pop ebx

mov esp,ebp

pop ebp

ret

第一条指令就是return d；将d的值保存在eax寄存器中。

后面三条POP分别对应前面三条push,注意三条pop之后，在fun函数栈底一端任务是完成了。

后面的mov指令将esp重新指向了0x0013FF20，此地址中的值正好是main函数栈的栈顶的地址。

然后执行POP ebp将ebp重新指向main函数栈顶。

注意ret返回指令不是这么简单的，是由硬件自动执行了隐藏的指令，我的分析是这样的：

在执行POP ebp之后，esp则正好指向了原来保存的main函数返回地址。即相当于这条指令：pop eip;

这就是整个调用过程了。

但是不要忘了esp还没有恢复原值呢！这时候esp的上面还有上次传参时保留的参数值a。所以这也就解释了前面第一段汇编代码的

add esp,4指令。这时整个调用过程才彻底结束！

本文来自CSDN博客，转载请标明出处：90a94a3143323968011c9265/tdd108158/archive/2010/04/16/5488557.aspx

通过汇编看调用协定收藏

调用函数的时候，有各种不同的调用约定。它们规定了参数的传送方式、参数是否可变，由谁来处理堆栈等。常用的调用约定有两种：C语言调用约定和Pascal语言调用约定。

可以在工程设置中设定自定义函数的调用规则，也可以在函数声明和定义的时候在函数名前加关键词或API宏定义(如_cdecl、__stdcall、__fastcall、WINAPI、APIENTRY等)明确表示函数的调用协定。

下面将分别说明各种调用协定的用法和意义，并附以相应的汇编代码分析。

1、C语言调用约定

采用C语言编程的时候，默认使用C/C++语言调用约定。也可以手工指定，这需要在函数声明时加上__cdecl关键字。采用本约定时，参数从右到左入栈，个数可变。由于函数体不能预先知道传进来的参数个数，因此采用本约定时必须由调用函数者负责堆栈清理。由于参数可变，此约定比较灵活，但是性能比较低。生成的代码中函数名有一个_(下划线)做前缀。

举例：

int __cdecl Add(int a, int b)

{

return (a + b);

}

函数调用：

Add(1, 2);

push 2

push 1

call @Add ;其实还有编译器用于定位函数的表达式这里把它省略了

add esp,8 ;清栈

函数体：

push ebp

mov ebp,esp

sub esp,40h ;函数使用的栈默认为40H(16*4),增加一个变量加4bytesWIN32下栈的粒度为4bytes。

push ebx

push esi

push edi

lea edi,[ebp-40h] ;初始化用于该函数的栈空间为0XCCCCCCCC

mov ecx,10h

mov eax,0CCCCCCCCh

rep stos dword ptr [edi]

return (a + b);

mov eax,dword ptr [ebp+8]

add eax,dword ptr [ebp+0Ch]

pop edi

pop esi

pop ebx

mov esp,ebp ;如果在此函数中对ESP进行操作，则会有add esp, 40h cmp esp,ebp call chkesp, 检查弹出的ESP指针是否和EBP相同，若不同则调用chkesp抛出异常

pop ebp

ret

下图指出了该函数的栈的使用情况:

2、Pascal语言调用约定

大部分的Windows API都采用Pascal语言调用约定。采用C语言编程的时候，如果要采用这种调用约定，需要在函数声明的时候加上__stdcall关键字。windows.h头文件中也定义了一个WINAPI的宏，起同样的作用。采用本约定时，参数从右到左入栈，个数固定。因此，函数体本身就能知道传进来的参数个数，可以用一条ret n指令直接清理堆栈。牺牲灵活性换来的，是性能的提高。生成的代码中函数名一个_(下划线)做前缀、一个@和参数总

字节数(十进制)作后缀(参数的个数乘以4)。WINAPI CALLBACK APIENTRY PASCAL 都是__stdcall的宏定义，而__pascal是一个废弃的关键词。

举例：

int __stdcall Add(int a, int b)

{

return (a + b);

}

函数的调用：

push 2

push 1

call _Add@8 ;这里使用了连接时使用的函数名

函数体：

;和__cdecl一样，最后一行如下：

ret 8 ;清栈

3、This调用约定

用于C++中的非静态类成员函数，它只能被编译器使用，没有相应的关键字。在Intel IA32架构下，此调用约定跟PASCAL语言调用约定相同，只是另外通过ECX寄存器传送一个额外的参数—this指针。在函数中清理栈，不能在C中使用，没有C的换名规则，所以说类的非静态成员函数不能作为回调函数。

举例：

struct CSum

{

int Add(int a, int b)

{

return (a + b);

}

};

函数调用：

CSum sum;

sum.Add(1, 2);

push 2

push 1

lea ecx,[ebp-4] ;ecx存放了this指针

call ?Add@CSum@@QAEHHH@Z ;当重复定义一个类成员函数时，可以在输出框中得到该名字

函数体：

push ebp

mov ebp,esp

sub esp,44h ;多用了一个4bytes的空间用于存放this指针push ebx

push esi

push edi

push ecx

lea edi,[ebp-44h]

mov ecx,11h

mov eax,0CCCCCCCCh

rep stos dword ptr [edi]

pop ecx

mov dword ptr [ebp-4],ecx

return (a + b);

mov eax,dword ptr [ebp+8]

add eax,dword ptr [ebp+0Ch]

pop edi

pop esi

pop ebx

mov esp,ebp

pop ebp

ret 8 ;清栈

4、快速调用约定

这种调用约定用于对性能要求非常高的场合，关键字是__fastcall。它要求将参数放在寄存器中，以提高速度。在Intel IA32架构下，此调用约定将函数最左边两个大小小于4个字节（DWORD的大小）的参数放在ECX和EDX寄存器，其余规定同Pascal调用约定。生成的代码中函数名有一个@做前缀和一个@加上参数

总字节数(十进制)作后缀。

举例：

int __fastcall Add(int a, int b, int c)

{

return (a + b + c);

}

函数的调用：

Add(1, 2, 3);

push 3

mov edx, 2

mov ecx, 1

call @Add@8 ;这里使用了连接时使用的函数名

函数体：

push ebp

mov ebp,esp

sub esp,48h ;多使用了两个变量在[ebp-4]、[ebp-8]

push ebx

push esi

push edi

push ecx

lea edi,[ebp-48h]

mov ecx,12h

mov eax,0CCCCCCCCh

rep stos dword ptr [edi]

pop ecx

mov dword ptr [ebp-8],edx ;还是将edx,ecx的内容放在

mov dword ptr [ebp-4],ecx ;栈中似乎并没有提高速度

return (a + b + c);

mov eax,dword ptr [ebp-4]

add eax,dword ptr [ebp-8]

add eax,dword ptr [ebp+8]

pop edi

pop esi

pop ebx

mov esp,ebp

pop ebp

ret 4 ;清栈

5、裸调用约定

当嵌入式汇编程序员需要手工控制调用约定的时候，使用这种方法。它没有相应的关键字，但是有一个__declspec(naked)用来指定这种调用约定。它不能用于函数声明，只能用于函数定义，也就是说，它只能让编译器不要生成函数体中的堆栈管理代码，但是调用函数者依然需要前面的某种调用约定来生成调用函数的代码。此协定本人没用过，希望有高手补充。

本文参考：

90a94a3143323968011c9265/cpp/calling_conventions_demystified.asp

以及CSDN上众多网友的回答。

本文来自CSDN博客，转载请标明出处：90a94a3143323968011c9265/fengzi_zhu/archive/2003/05/01/14338.aspx

关于栈在函数调用中的作用收藏

环境：VC++6.0

用 C 语言写的函数，在调用时是怎么调用的，以前老说是通过栈实现的，但到底是怎么实现的，今天才搞清楚。

函数：

int fun(int x, int y)

{

int a;

char b;

a = 0;

b = 'c';

return 0;

}

void main()

{

fun(2,3);

}

反汇编后代码如下并逐行解释：

fun() 函数：

1: int fun(int x, int y)

2: {

00401020 push ebp//把调用函数的栈帧地址进栈保护起来，寄存器EBP是用来保存当前执行函数的栈帧地址的，也就是当前函数控制栈的地址

00401021 mov ebp,esp//把栈顶地址放入EBP，也就是说现在进入了函数fun的控制栈

00401023 sub esp,48h// 给ESP减48H，即在栈中从EBP的地址向低地址方向空出48B的空间，这48H的空间用来存放函数fun的局部变量，因为有两个局部变量int a和char b，所以空出了8B的空间（如果函数中没有局部变量，则ESP应减去40H，这个40H 是VC++6.0的特点，各个编译器对此的处理都不同），一个int占4B，一个char也占4B（这是传说中的对齐），所以最后ESP要减去48H

00401026 push ebx//下面这三句没什么好说的，就是保护寄存器

00401027 push esi

00401028 push edi

00401029 lea edi,[ebp-48h]//把刚才栈中空出来的48B的有效地址加载到EDI中，一会儿初始化这段内存

0040102C mov ecx,12h//设定一会儿rep循环的次数为12H次

00401031 mov eax,0CCCCCCCCh//给EAX赋初值，0CCCCCCCCH表示该处内存无效

00401036 rep stos dword ptr [edi]//把那48B的空间的初值赋为全0CH

3: int a;

4: char b;

5: a = 0;

00401038 mov dword ptr [ebp-4],0//给局部变量a赋初值，在这儿可以看到a的地址是EBP-4，也就是EBP下面紧跟着的4B，也就是刚才48B中最高的4B

6: b = 'c';

0040103F mov byte ptr [ebp-8],63h//给局部变量b赋初值，b应该只有1B，所以在此指明了是byte ptr，但b占用的地址却是从EBP-8到EBP-5，而从EBP-7到EBP-5因为对齐（为了提高I/O效率），所以是没有用的

7: return 0;

00401043 xor eax,eax//返回值是在EAX中保存的，因为return 0所以这句把EAX 清0

8: }

00401045 pop edi//到此函数执行完，下面三句恢复刚才保护的寄存器的值00401046 pop esi

00401047 pop ebx

00401048 mov esp,ebp//清除局部变量的空间

0040104A pop ebp//恢复调用函数的栈帧地址

0040104B ret//恢复IP的内容

main() 函数：

10: void main()

11: {

00401050 push ebp

00401051 mov ebp,esp

00401053 sub esp,40h

00401056 push ebx

00401057 push esi

00401058 push edi

00401059 lea edi,[ebp-40h]//因为没有局部变量，所以为40H

0040105C mov ecx,10h

00401061 mov eax,0CCCCCCCCh

00401066 rep stos dword ptr [edi]

12: fun(2,3);

00401068 push 3//参数进栈，这是C语言调用约定的函数，参数从右往左进栈，并且用户自己把函数弹栈（00401071句干的就是参数弹栈的事儿）

0040106A push 2//参数进栈

0040106C call @ILT+5(fun) (0040100a)//把当前的IP进栈，并转向对fun的执行00401071 add esp,8//参数弹栈

13: }

00401074 pop edi

00401075 pop esi

00401076 pop ebx

00401077 add esp,40h

0040107A cmp ebp,esp

0040107C call __chkesp (004010a0)

00401081 mov esp,ebp

00401083 pop ebp

00401084 ret

由此可以看出函数调用到底是如何实现的。

我们可以看到参数都在EBP的正偏移处，而局部变量都在EBP的负偏移处，知道了这些也就理解了函数调用是如何实现的，同时我们也可以知道，如果fun函数中有一个局部的数组char c[256];这个数组的初始地址必然为EBP-4-4-256，而如果我们在操作数组越界而没有检查数组的边界时，我们会覆盖掉a的值和b的值，甚至上层函数的EBP的值，当然也有可能是返回地址的值。而如果我们可以计算的到某一个函数中缓冲区的起始地址，而这个函数没有对缓冲区边界的保护措施，我们就可以利用下标越界的方法来改变栈中保存的返回地址的值，让它等于我想要的地址，这样，在这个函数执行完时，就会跳转到我们的函数而不是调用它的函数了。

本文来自CSDN博客，转载请标明出处：90a94a3143323968011c9265/mm350670610/archive/2010/04/30/5542836.aspx

本文来源：https://www.bwwdw.com/article/q0wq.html