关于编译型语言函数的调用(二)

最新推荐文章于 2023-02-17 13:31:46 发布

星江月

最新推荐文章于 2023-02-17 13:31:46 发布

阅读量1.5k

点赞数 1

分类专栏：计算机技术 Visual C++ 文章标签：函数调用汇编指令面向对象

本文链接：https://blog.csdn.net/prsniper/article/details/40653235

版权

计算机技术同时被 2 个专栏收录

86 篇文章 0 订阅

订阅专栏

Visual C++

86 篇文章 1 订阅

订阅专栏

接上文: 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的时候了,下文我们说最后一个函数的有关知识,裸函数!

星江月

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于编译型语言函数的调用(二)

接上文: http://blog.csdn.net/prsniper/article/details/40652451上文中提到的局部变量的地址,第一个是[ebp-4],由于32位内存对齐的原因,第二个是[ebp-8],对于VC7以上的版本,这个地址可能会不一样比如第一个可能是[ebp-8],第二个飞到[ebp-14],这是VS.NET的VC编译器在每个局部变量前后都加一个DW
复制链接

扫一扫