转自:http://blog.chinaunix.net/uid-20718384-id-3418279.html
| . |
+-------------------------+
| 被调用者保存的寄存器现场 |
| EBX,ESI和EDI(根据需要) |
+-------------------------+
| 临时空间 |
+-------------------------+
| 局部变量#2 | [EBP - 8]
+-------------------------+
| 局部变量#1 | [EBP - 4]
+-------------------------+
EBP==>| 调用者的EBP |
+-------------------------+
| 返回地址 |
+-------------------------+
| 实际参数#1 | [EBP + 8]
+-------------------------+
| 实际参数#2 | [EBP + 12]
+-------------------------+
| 实际参数#3 | [EBP + 16]
+-------------------------+
| 调用者保存的寄存器现场 |
| EAX,ECX和EDX(根据需要)|
+-------------------------+
| : |
| . |
图 1
这是如下一个函数调用时的栈的内容:
int foo(int arg1, int arg2, int arg3);
ESP被foo使用来指示栈顶。EBP相当于一个“基准指针”。从main传递到foo的参数以及foo本身的局部变量都可以通过这个基准指针为参考,加上偏移量找到。
由于被调用者允许使用EAX,ECX和EDX寄存器,所以如果调用者希望保存这些寄存器的值,就必须在调用子函数之前显式地把他们保存在栈中。另一方面, 如果除了上面提到的几个寄存器,被调用者还想使用别的寄存器,比如EBX,ESI和EDI,那么,被调用者就必须在栈中保存这些被额外使用的寄存器,并在 调用返回前回复他们。也就是说,如果被调用者只使用约定的EAX,ECX和EDX寄存器,他们由调用者负责保存并回复,但如果被调用这还额外使用了别的寄 存器,则必须有他们自己保存并回复这些寄存器的值。
传递给foo的参数被压到栈中,最后一个参数先进栈,所以第一个参数是位于栈顶的。foo中声明的局部变量以及函数执行过程中需要用到的一些临时变量也都存在栈中。
小于等于4个字节的返回值会被保存到EAX中,如果大于4字节,小于8字节,那么EDX也会被用来保存返回值。如果返回值占用的空间还要大,那么调用者会向被调用者传递一个额外的参数,这个额外的参数指向将要保存返回值的地址。用C语言来说,就是函数调用:
x = foo(a, b, c);
被转化为:
foo(&x, a, b, c);
注意,这仅仅在返回值占用大于8个字节时才发生。有的编译器不用EDX保存返回值,所以当返回值大于4个字节时,就用这种转换。
当然,并不是所有函数调用都直接赋值给一个变量,还可能是直接参与到某个表达式的计算中,如:
m = foo(a, b, c) + foo(d, e, f);
有或者作为另外的函数的参数, 如:
fooo(foo(a, b, c), 3);
这些情况下,foo的返回值会被保存在一个临时变量中参加后续的运算,所以,foo(a, b, c)还是可以被转化成foo(&tmp, a, b, c)。
首先,main把EAX,ECX和EDX压栈。这是一个可选的步骤,只在这三个寄存器内容需要保留的时候执行此步骤。
接着,main把传递给foo的参数一一进栈,最后的参数最先进栈。例如,我们的函数调用是:
a = foo(12, 15, 18);
相应的汇编语言指令是:
push dword 18
push dword 15
push dword 12
最后,main用call指令调用子函数:
call foo
当call指令执行的时候,EIP指令指针寄存器的内容被压入栈中。因为EIP寄存器是指向main中的下一条指令,所以现在返回地址就在栈顶了。在call指令执行完之后,下一个执行周期将从名为foo的标记处开始。
图2展示了call指令完成后栈的内容。图2及后续图中的 粗线指示了函数调用前栈顶的位置。我们将会看到,当整个函数调用过程结束后,栈顶又回到了这个位置。
+-------------------------+
ESP==>| 返回地址 |
+-------------------------+
| 实际参数#1 = 12 |
+-------------------------+
| 实际参数#2 = 15 |
+-------------------------+
| 实际参数#3 = 18 |
+-------------------------+
| 调用者保存的寄存器现场 |
|EAX,ECX和EDX(根据需要) |
+=========================+
| : |
EBP==>| . |
图 2
被调用者在函数调用后的动作
首先foo必须建立它自己的栈帧。EBP寄存器现在正指向main的栈帧中的某个位置,这个值必须被保留,因此,EBP进栈。然后ESP的内容赋值给了 EBP。这使得函数的参数可以通过对EBP附加一个偏移量得到,而栈寄存器ESP便可以空出来做其他事情。如此一来,几乎所有的c函数都由如下两个指令开 始:
push ebp
mov ebp, esp
此时的栈入图3所示。在这个场景中,第一个参数的地址是EBP加8,因为main的EBP和返回地址各在栈中占了4个字节。
| |
+-------------------------+
ESP=EBP==>| main的EBP |
+-------------------------+
| 返回地址 |
+-------------------------+
| 实际参数#1 = 12 | [EBP + 8]
+-------------------------+
| 实际参数#2 = 15 | [EBP + 12]
+-------------------------+
| 实际参数#3 = 18 | [EBP + 16]
+-------------------------+
| 调用者保存的寄存器现场 |
|EAX,ECX和EDX(根据需要) |
+=========================+
| : |
图 3
sub esp, 20
现在,局部变量和临时存储都可以通过基准指针EBP加偏移量找到了。
最后,如果foo用到EBX,ESI和EDI寄存器,则它f必须在栈里保存它们。结果,现在的栈如图4所示。
+-------------------------+
ESP==>|被调用者保存的寄存器现场 |
|EBX,ESI和EDI(根据需要) |
+-------------------------+
| 临时空间 | [EBP - 20]
| |
+-------------------------+
| 局部变量#2 | [EBP - 8]
+-------------------------+
| 局部变量#1 | [EBP - 4]
+-------------------------+
EBP==>| main的EBP |
+-------------------------+
| 返回地址 |
+-------------------------+
| 实际参数#1 | [EBP + 8]
+-------------------------+
| 实际参数#2 | [EBP + 12]
+-------------------------+
| 实际参数#3 | [EBP + 16]
+-------------------------+
| 调用者保存的寄存器现场 |
|EAX,ECX和EDX(根据需要) |
+=========================+
| : |
函数foo的执行也许还会调用别的函数,甚至递归地调用foo本身。然而,只要EBP寄存器在这些子调用返回时被恢复,就可以继续用EBP加上偏移量的方式访问实际参数,局部变量和临时存储。
其次,foo必须恢复EBX,ESI和EDI寄存器的值。如果这些寄存器被修改,正如我们前面所说,我们会在foo执行开始时把它们的原始值压入栈中。如 果ESP寄存器指向如图4所示的正确位置,寄存器的原始值就可以出栈并恢复。可见,在foo函数的执行过程中正确地跟踪ESP是多么的重要————也就是 说,进栈和出栈操作的次数必须保持平衡。
这两步之后,我们不再需要foo的局部变量和临时存储了,我们可以通过下面的指令消除栈帧:
mov esp, ebp
pop ebp
其结果就是现在栈里的内容跟图2中所示的栈完全一样。现在可以执行返回指令了。从栈里弹出返回地址,赋值给EIP寄存器。栈如图5所示:
+-------------------------+
ESP==>| 实际参数#1 |
+-------------------------+
| 实际参数#2 |
+-------------------------+
| 实际参数#3 |
+-------------------------+
| 调用者保存的寄存器现场 |
|EAX,ECX和EDX(根据需要) |
+=========================+
| : |
EBP==>| . |
图 5
i386指令集有一条“leave”指令,它与上面提到的mov和pop指令所作的动作完全相同。所以,C函数通常以这样的指令结束:
leave
ret
调用者在返回后的动作
add esp, 12
如果在函数调用前,EAX,ECX和EDX寄存器的值被保存在栈中,调用者main函数现在可以把它们弹出。这个动作之后,栈顶就回到了我们开始整个函数调用过程前的位置,也就是图5中粗线的位置。
转自:http://hubeihuyanwei.blog.163.com/blog/static/28205284200821873911607/
long test(int a,int b)
{
a = a + 3 ;
b = b + 5 ;
return a + b;
}
int main(int argc, char* argv[])
{
printf("%d",test(10,90 ));
return 0 ;
}
先来看一个概貌
17 : {
00401070 push ebp
00401071 mov ebp,esp
00401073 sub esp,40h
00401076 push ebx
00401077 push esi
00401078 push edi
00401079 lea edi,[ebp-40h]
0040107C mov ecx,10h
00401081 mov eax,0CCCCCCCCh
00401086 rep stos dword ptr [edi]
18: printf("%d",test(10,90)) ;
00401088 push 5Ah
0040108A push 0Ah
0040108C call @ILT+0(test) (00401005 )
00401091 add esp,8
00401094 push eax
00401095 push offset string "%d" (0042201c )
0040109A call printf (004010d0 )
0040109F add esp,8
19: return 0 ;
004010A2 xor eax,eax
20 : }
下面来解释一下
开始进入Main函数 esp=0x12FF84 ebp=0x12FFC0
完成椭圆形框起来的部分
00401070 push ebp ebp的值入栈,保存现场(调用现场,从test函数看,如红线所示,即保存的0x12FF80用于从test函数堆栈返回到main函数)
00401071 mov ebp,esp 此时ebp=0x12FF80 此时ebp就是“当前函数堆栈”的基址 以便访问堆栈中的信息;还有就是从当前函数栈顶返回到栈底
00401073 sub esp,40h
函数使用的堆栈,默认64个字节,堆栈上就是16个横条(密集线部分)此时esp=0x12FF40
在上图中,上面密集线是test函数堆栈空间,下面是Main的堆栈空间 (补充,其实这个就叫做 Stack Frame)
00401076 push ebx
00401077 push esi
00401078 push edi 入栈
00401079 lea edi,[ebp-40h]
0040107C mov ecx,10h
00401081 mov eax,0CCCCCCCCh
00401086 rep stos dword ptr [edi]
初始化用于该函数的栈空间为0XCCCCCCCC 即从0x12FF40~0x12FF80所有的值均为0xCCCCCCCC
18: printf("%d",test(10,90));
00401088 push 5Ah 参数入栈 从右至左 先90 后10
0040108A push 0Ah
0040108C call @ILT+0(test) (00401005)
函数调用,转向eip 00401005
注意,此时仍入栈,入栈的是call test 指令下一条指令的地址00401091 下一条指令是add esp,8
@ILT+0(?test@@YAJHH@Z):
00401005 jmp test (00401020)
即转向被调函数test
9 : {
00401020 push ebp
00401021 mov ebp,esp
00401023 sub esp,40h
00401026 push ebx
00401027 push esi
00401028 push edi
00401029 lea edi,[ebp-40h]
0040102C mov ecx,10h
00401031 mov eax,0CCCCCCCCh
00401036 rep stos dword ptr [edi] //这些和上面一样
10: a = a + 3 ;
00401038 mov eax,dword ptr [ebp+8 ] //ebp=0x12FF24 加8 [0x12FF30]即取到了参数10
0040103B add eax,3
0040103E mov dword ptr [ebp+8 ],eax
11: b = b + 5 ;
00401041 mov ecx,dword ptr [ebp+0Ch]
00401044 add ecx,5
00401047 mov dword ptr [ebp+0Ch],ecx
12: return a + b ;
0040104A mov eax,dword ptr [ebp+8 ]
0040104D add eax,dword ptr [ebp+0Ch] //最后的结果保存在eax, 结果得以返回
13 : }
00401050 pop edi
00401051 pop esi
00401052 pop ebx
00401053 mov esp,ebp //esp指向0x12FF24, test函数的堆栈空间被放弃,从当前函数栈顶返回到栈底
00401055 pop ebp //此时ebp=0x12FF80, 恢复现场 esp=0x12FF28
00401056 ret ret负责栈顶0x12FF28之值00401091弹出到指令寄存器中,esp=0x12FF30
因为win32汇编一般用eax返回结果 所以如果最终结果不是在eax里面的话 还要把它放到eax
注意,从被调函数返回时,是弹出EBP,恢复堆栈到函数调用前的地址,弹出返回地址到EIP以继续执行程序。
从test函数返回,执行
00401091 add esp,8
清栈,清除两个压栈的参数10 90 调用者main负责
(所谓__cdecl调用由调用者负责恢复栈,调用者负责清理的只是入栈的参数,test函数自己的堆栈空间自己返回时自己已经清除,靠!一直理解错)
00401094 push eax 入栈,计算结果108入栈,即printf函数的参数之一入栈
00401095 push offset string "%d" (0042201c) 入栈,参数 "%d" 当然其实是%d的地址
0040109A call printf (004010d0) 函数调用 printf("%d",108) 因为printf函数时
0040109F add esp,8 清栈,清除参数 ("%d", 108)
19: return 0;
004010A2 xor eax,eax eax清零
20: }
main函数执行完毕 此时esp=0x12FF34 ebp=0x12FF80
004010A4 pop edi
004010A5 pop esi
004010A6 pop ebx
004010A7 add esp,40h //为啥不用mov esp, ebp? 是为了下面的比较
004010AA cmp ebp,esp //比较,若不同则调用chkesp抛出异常
004010AC call __chkesp (00401150)
004010B1 mov esp,ebp
004010B3 pop ebp //ESP=0X12FF84 EBP=0x12FFC0 尘归尘 土归土 一切都恢复最初的平静了 :)
004010B4 ret
另
1. 如果函数调用方式是__stdcall 不同之处在于
main函数call 后面没有了 add esp, 8
test函数最后一句 是 ret 8 (由test函数清栈, ret 8意思是执行ret后,esp+8)
2. 运行过程中0x12FF28 保存了指令地址 00401091是怎么保存的?
栈每个空间保存4个字节(粒度4字节) 例如下一个栈空间0x12FF2C保存参数10
因此
0x12FF28 0x12FF29 0x12FF2A 0x12FF2B
91 10 40 00
little-endian 认为其读的第一个字节为最小的那位上的数
3. char a[] = "abcde"
对局部字符数组变量(栈变量)赋值,是利用寄存器从全局数据内存区把字符串“abcde”拷贝到栈内存中的
4. int szNum[5] = { 1, 2, 3, 4, 5 }; 栈中是如何分布的?
00401798 mov dword ptr [ebp-14h],1
0040179F mov dword ptr [ebp-10h],2
004017A6 mov dword ptr [ebp-0Ch],3
004017AD mov dword ptr [ebp-8],4
004017B4 mov dword ptr [ebp-4],5
可以看出来 是从右边开始入栈,所以是 5 4 3 2 1 入栈
int *ptrA = (int*)(&szNum+1);
int *ptrB = (int*)((int)szNum + 1);
std::cout<< ptrA[-1] << *ptrB << std::endl;
结果如何?
28: int *ptrA = (int*)(&szNum+1);
004017BB lea eax,[ebp]
004017BE mov dword ptr [ebp-18h],eax
& szNum是指向数组指针;加1是加一个数组宽度;&szNum+1指向移动5个int单位之后的那个地方, 就是把EBP的地址赋给指针
ptrA[-1]是回退一个int*宽度,即ebp-4
29: int *ptrB = (int*)((int)szNum + 1);
004017C1 lea ecx,[ebp-13h]
004017C4 mov dword ptr [ebp-1Ch],ecx
如果上面是指针算术,那这里就是地址算术,只是首地址+1个字节的offset,即ebp-13h给指针
实际保存是这样的
01 00 00 00 02 00 00 00
ebp-14h ebp-13h ebp-10h
注意是int*类型的,最后获得的是 00 00 00 02
由于Little-endian, 实际上逻辑数是02000000 转换为十进制数就为33554432
最后输出533554432