关于编译型语言函数的调用(二)
接上文: http://blog.csdn.net/prsniper/article/details/40652451
上文中提到的局部变量的地址,第一个是[ebp-4],由于32位内存对齐的原因,第二个是[ebp-8],对于VC7以上的版本,这个地址可能会不一样
比如第一个可能是[ebp-8],第二个飞到[ebp-14],这是VS.NET的VC编译器在每个局部变量前后都加一个DWORD,值自然是0xCCCCCCCC
debug下如果函数结束后,这些DWORD的值不是0xCCCCCCCC那么说明代码意外的访问了不该访问的地方,即溢出
下面我们进入有返回值的,默认__cdecl约定的函数看看:
122: ret = fnDefaultCall(4, 5, 6, &var1); 0040136B lea eax,[ebp-14h] 0040136E push eax 0040136F push 6 00401371 push 5 00401373 push 4 00401375 call @ILT+0(fnDefaultCall) (00401005) 0040137A add esp,10h 0040137D mov dword ptr [ebp-18h],eax 123:有了前面的知识,调用简单了,传址吗,把地址装到eax,push到堆栈,等等
咦?这个eax传送到ret的地址,这不是变量没有初始化就使用吗?或者eax是ret的地址也就是ebp-14,这是怎么回事?
元芳说,VC中函数使用eax和edx作为返回值! 你要早这么说,我就了然了...
我们跟踪进去,看看它都做了什么勾当,关键在这几个地方
31: p = (int *)arg4; 004011CC mov eax,dword ptr [ebp+14h] 004011CF mov dword ptr [ebp-10h],eax 32: *p = 7; 004011D2 mov ecx,dword ptr [ebp-10h] 004011D5 mov dword ptr [ecx],7 33: 34: return 0; 004011DB xor eax,eax 35: } 004011DD pop edi首先传进来的DWORD是指针,汇编语言满天都是指针,相比高级语言的指针就少得多,vb等干脆就没有指针的概念,
C/C++则能兼容大部分汇编语言的功能,强制转换,那么接下来赋值就好理解了,*p = 7就是
move p的值到ecx, 再mov 7到[ecx]就是ecx指向的内存地址
如果是*(int *)arg4 = 7就是 mov ecx, [ebp+14h]再 mov [ecx], 7了,注意如果是 arg4 =7那就不一样就修改地址的值为7,而不是值为7了
后面return 0就是xor eax, 任何数xor自身都变0,eax作为返回值,如前面所说
执行完毕,main函数的var1=7;ret=0;
接下来,我们就要调用__stdcall的函数,这个东西古老的pascal就使用这种约定,然而要说明的一点是,所有的Windows API也使用这种约定
那么我们就一探究竟吧!
124: ret = fnStandardCall(8, 9, 10, &var1); 00401380 lea ecx,[ebp-14h] 00401383 push ecx 00401384 push 0Ah 00401386 push 9 00401388 push 8 0040138A call @ILT+20(fnStandardCall) (00401019) 0040138F mov dword ptr [ebp-18h],eax 125:从调用的指令一看,细心的你会立刻发现,这小姑娘身上好像少了点什么挂件,阿弥陀佛,罪过!罪过!
不错,前面函数调用结束后都有add esp,xxx把之前push的参数都弹出,这里却没有,真是奇哉怪也!
那么我们就跟踪进入阴暗的小巷,看看他都做了什么勾当!
37: int __stdcall fnStandardCall(int arg1, short arg2, char arg3, void *arg4)
38: {
00401200 push ebp
00401201 mov ebp,esp
00401203 sub esp,50h
00401206 push ebx
00401207 push esi
00401208 push edi
00401209 lea edi,[ebp-50h]
0040120C mov ecx,14h
00401211 mov eax,0CCCCCCCCh
00401216 rep stos dword ptr [edi]
39: int var1;
40: short var2;
41: char var3;
42: int *p;
43:
44: var1 = arg1;
00401218 mov eax,dword ptr [ebp+8]
0040121B mov dword ptr [ebp-4],eax
45: var2 = arg2;
0040121E mov cx,word ptr [ebp+0Ch]
00401222 mov word ptr [ebp-8],cx
46: var3 = arg3;
00401226 mov dl,byte ptr [ebp+10h]
00401229 mov byte ptr [ebp-0Ch],dl
47: p = (int *)arg4;
0040122C mov eax,dword ptr [ebp+14h]
0040122F mov dword ptr [ebp-10h],eax
48: *p = 11;
00401232 mov ecx,dword ptr [ebp-10h]
00401235 mov dword ptr [ecx],0Bh
49:
50: return 0;
0040123B xor eax,eax
51: }
0040123D pop edi
0040123E pop esi
0040123F pop ebx
00401240 mov esp,ebp
00401242 pop ebp
00401243 ret 10h上面的东西与默认的__cdecl约定一摸一样,曾泰说:恩师所言,丝毫不差!
最后是关键, 以前的ret, 变成了ret 10h,跑到这,或者说合并到这里了,元芳说: 事情的真相居然是这样!
这所谓的维护堆栈,不过是干完事,谁来清理现场而已嘛!
是这样,而不全然这么肤浅,比如API只要把参数传递进来,获取返回值即可,所以这是一种给调用者偷懒的约定.
那么接下来就是fastcall了,顾名思义应该是快速调用,怎么个快速法呢?看调用
125: 126: ret = fnFastCall(11, 12, 13, &var1); 00401392 lea edx,[ebp-14h] 00401395 push edx 00401396 push 0Dh 00401398 mov edx,0Ch 0040139D mov ecx,0Bh 004013A2 call @ILT+25(fnFastCall) (0040101e) 004013A7 mov dword ptr [ebp-18h],eax 127:乖乖呀,只有两个push,第一第二个参数直接传送的ecx和edx,其他的跟__stdcall一摸一样!
这不用push也可以吗? 这个问题应该这样问,为什么一定要push才可以呢!我们再跟踪看看详细的:
53: int __fastcall fnFastCall(int arg1, short arg2, char arg3, void *arg4)
54: {
00401260 push ebp
00401261 mov ebp,esp
00401263 sub esp,58h
00401266 push ebx
00401267 push esi
00401268 push edi
00401269 push ecx
0040126A lea edi,[ebp-58h]
0040126D mov ecx,16h
00401272 mov eax,0CCCCCCCCh
00401277 rep stos dword ptr [edi]
00401279 pop ecx
0040127A mov word ptr [ebp-8],dx
0040127E mov dword ptr [ebp-4],ecx
关键就在前面这几条指令,在创建函数临时堆栈时,编译器保护了这两个寄存器,然后自动创建两个局部变量把他们保存起来
所以说,编译器不是人,它不管这些!因而,C/C++的效率虽然高,正常的程序员写出来的程序比起汇编语言还是差一大截,除非内联汇编或者经过优化
以后我们讲到裸函数的时候再说这一点, 函数往后的代码就好理解了,与前面的几乎一模一样
65: 66: return 0; 004012A4 xor eax,eax 67: } 004012A6 pop edi 004012A7 pop esi 004012A8 pop ebx 004012A9 mov esp,ebp 004012AB pop ebp 004012AC ret 8注意后面的ret 8,因为后面直接恢复esp,因而过程中的push都静悄悄的被pop了
接着我们说thiscall,当调用一个类的成员变量时,自动传递了this指针,因而thiscall是隐式的声明
我们先看new一个对象的汇编指令:
128: pCall = new CCall(); 004013AA push 4 004013AC call operator new (004015b0) 004013B1 add esp,4 004013B4 mov dword ptr [ebp-20h],eax 004013B7 mov dword ptr [ebp-4],0 004013BE cmp dword ptr [ebp-20h],0 004013C2 je main+0A1h (004013d1) 004013C4 mov ecx,dword ptr [ebp-20h] 004013C7 call @ILT+35(CCall::CCall) (00401028) 004013CC mov dword ptr [ebp-2Ch],eax 004013CF jmp main+0A8h (004013d8) 004013D1 mov dword ptr [ebp-2Ch],0 004013D8 mov eax,dword ptr [ebp-2Ch] 004013DB mov dword ptr [ebp-1Ch],eax 004013DE mov dword ptr [ebp-4],0FFFFFFFFh 004013E5 mov ecx,dword ptr [ebp-1Ch] 004013E8 mov dword ptr [ebp-10h],ecx在这个级别, new 其实是一个函数. 而且可以看出,CCall的内存大小是四字节.
返回后保存到pCall即[ebp-20],这里突然冒出一句mov [ebp-4], 0,后面我们再说
然后判断返回的指针是否为NULL,cmp指令,如果为NULL跳转到0x004013d1,即mov dword ptr [ebp-2Ch],0这条
如果不为零继续执行
mov ecx,dword ptr [ebp-20h]
call @ILT+35(CCall::CCall) (00401028)
[ebp-20]就是pCall,call的是类的构造函数,哄哄,原来把this传送到了ecx里面,再跟踪看看构造函数
00401079 push ecx 0040107A lea edi,[ebp-44h] 0040107D mov ecx,11h 00401082 mov eax,0CCCCCCCCh 00401087 rep stos dword ptr [edi] 00401089 pop ecx 0040108A mov dword ptr [ebp-4],ecx 6: m_Var1 = 18; 0040108D mov eax,dword ptr [ebp-4] 00401090 mov dword ptr [eax],12h 7: } 00401096 mov eax,dword ptr [ebp-4]先把ecx(也就是thsi指针)保存,创建临时堆栈以后,创建一个临时变量代替ecx,即[ebp-4],因为m_Var1是第一个成员,类只占4个字节
所以直接传送到eax即[ebp-4],然后把ebp-4的值传送给eax,可以看出编译器绕了一大段弯子,这就是为什么以前谈游戏看法的时候
我尽可能的使用C语言,而不用C++的原因,此外可以看出,构造函数是有返回值的,返回值就是this!
回到调用代码,正常初始化后直接跳转,跳过new失败的这条
004013D1 mov dword ptr [ebp-2Ch],0
而后一大堆mov传来传去,eax就是返回值this,传给[ebp-2c],然后如果new失败[ebp-2c]又传进0,然后又传给eax,然后传给[ebp-1c]!!!
作为一个追求完美的技术人员,恨不得把微软千刀万剐!
看判断new返回值之前有个[ebp-4]赋值为0,此时再赋值为-1,然后又把[ebp-1c]传来传去的0传给ecx,再把ecx传给[ebp-10],无语了吧!
别看这么多飞来飞去,如果正常初始化执行成功,[ebp-10]就是类的指针,如果new失败则是0即NULL!
下面就是调用成员函数了:
129: ret = pCall->Call(15, 16, 17, &var1); 004013EB lea edx,[ebp-14h] 004013EE push edx 004013EF push 11h 004013F1 push 10h 004013F3 push 0Fh 004013F5 mov ecx,dword ptr [ebp-10h] 004013F8 call @ILT+30(CCall::Call) (00401023) 004013FD mov dword ptr [ebp-18h],eax同样this指针被传送到ecx,返回值保存在eax寄存器中.参数从右向左依次入栈. 堆栈成员函数自动清理
004010E9 push ecx 004010EA lea edi,[ebp-54h] 004010ED mov ecx,15h 004010F2 mov eax,0CCCCCCCCh 004010F7 rep stos dword ptr [edi] 004010F9 pop ecx 004010FA mov dword ptr [ebp-4],ecx 15: int var1; 16: short var2; 17: char var3; 18: int *p; 19: var1 = arg1; 004010FD mov eax,dword ptr [ebp+8] 00401100 mov dword ptr [ebp-8],eax 20: var2 = arg2; 00401103 mov cx,word ptr [ebp+0Ch] 00401107 mov word ptr [ebp-0Ch],cx 21: var3 = arg3; 0040110B mov dl,byte ptr [ebp+10h] 0040110E mov byte ptr [ebp-10h],dl 22: p = (int *)arg4; 00401111 mov eax,dword ptr [ebp+14h] 00401114 mov dword ptr [ebp-14h],eax 23: *p = m_Var1; 00401117 mov ecx,dword ptr [ebp-14h] 0040111A mov edx,dword ptr [ebp-4] 0040111D mov eax,dword ptr [edx] 0040111F mov dword ptr [ecx],eax 24: return 0; 00401121 xor eax,eax 25: }可以看出,仍然创建一个临时变量来保存ecx(就是[ebp-4]),然后以此引用成员变量,可见thiscall比起上面的各种调用约定都要啰嗦
都要慢, 不过这是面向对象对象的代价,开发和维护更简单,牺牲的就是执行效率,这个只能靠硬件性能来弥补;
同理,.NET开发和维护调试超级容易,容错能力极其强大,还牺牲了安全性,在dis#面前,源代码完全暴露...
那么又是int3的时候了,下文我们说最后一个函数的有关知识,裸函数!