5.5 汇编语言：函数调用约定

函数是任何一门高级语言中必须要存在的，使用函数式编程可以让程序可读性更高，充分发挥了模块化设计思想的精髓，今天我将带大家一起来探索函数的实现机理，探索编译器到底是如何对函数这个关键字进行实现的，并使用汇编语言模拟实现函数编程中的参数传递调用规范等。
说到函数我们必须要提起调用约定这个名词，而调用约定离不开栈的支持，栈在内存中是一块特殊的存储空间，遵循先进后出原则，使用push与pop指令对栈空间执行数据压入和弹出操作。栈结构在内存中占用一段连续存储空间，通过esp与ebp这两个栈指针寄存器来保存当前栈起始地址与结束地址，每4个字节保存一个数据。
当栈顶指针esp小于栈底指针ebp时，就形成了栈帧，栈帧中可以寻址的数据有局部变量，函数返回地址，函数参数等。不同的两次函数调用，所形成的栈帧也不相同，当由一个函数进入另一个函数时，就会针对调用的函数开辟出其所需的栈空间，形成此函数的独有栈帧，而当调用结束时，则清除掉它所使用的栈空间，关闭栈帧，该过程通俗的讲叫做栈平衡。而如果栈在使用结束后没有恢复或过度恢复，则会造成栈的上溢或下溢，给程序带来致命错误。
一般情况下在Win32环境默认遵循的就是STDCALL，而在Win64环境下使用的则是FastCALL，在Linux系统上则遵循SystemV的约定，这里我整理了他们之间的异同点.

• CDECL：C/C++默认的调用约定，调用方平栈，不定参数的函数可以使用，参数通过堆栈传递.
  
• STDCALL：被调方平栈，不定参数的函数无法使用，参数默认全部通过堆栈传递.
  
• FASTCALL32：被调方平栈，不定参数的函数无法使用，前两个参数放入(ECX, EDX),剩下的参数压栈保存.
  
• FASTCALL64：被调方平栈，不定参数的函数无法使用，前四个参数放入(RCX, RDX, R8, R9),剩下的参数压栈保存.
  
• System V：类Linux系统默认约定，前八个参数放入(RDI,RSI, RDX, RCX, R8, R9),剩下的参数压栈保存.
  

首先先来写一段非函数版的堆栈使用案例，案例中模拟了编译器如何生成Main函数栈帧以及如何对栈帧初始化和使用的流程，笔者通过自己的理解写出了Debug版本的一段仿写代码。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   main PROC
11.     push ebp                   ; 保存栈底指针ebp
12.     mov ebp,esp                ; 调整当前栈底指针到栈顶
13.    
14.     sub esp,0e4h               ; 抬高栈顶esp开辟局部空间
15.    
16.     push ebx                   ; 保存寄存器
17.     push esi
18.     push edi
19.    
20.     lea edi,dword ptr [ ebp - 0e4h ]  ; 取出当前函数可用栈空间首地址
21.    
22.     mov ecx,39h                       ; 填充长度
23.     mov eax,0CCCCCCCCh                ; 填充四字节数据
24.     rep stosd                         ; 将当前函数局部空间填充初始值
25.    
26.     ; 使用当前函数可用局部空间
27.     xor eax,eax
28.    
29.     mov dword ptr [ ebp - 08h ],1
30.     mov dword ptr [ ebp - 014h ],2       ; 使用局部变量
31.     mov dword ptr [ ebp - 020h ],3
32.    
33.     mov eax,dword ptr [ ebp - 014h ]
34.     add eax,dword ptr [ ebp - 020h ]
35.    
36.     ; 如果指令影响了堆栈平衡,则需要平栈
37.     push 4                ; 此情况,由于入栈时没有修改过,平栈只需add esp,12
38.     push 5
39.     push 6                ; 如果代码没有自动平栈,则需要手动平
40.     add esp,12            ; 每个指令4字节 * 多少条影响
41.    
42.     push 10
43.     push 20
44.     push 30               ; 使用3条指令影响堆栈
45.     pop eax
46.     pop ebx               ; 弹出两条
47.     add esp,4             ; 修复堆栈时只需要平一个变量
48.    
49.     pop edi               ; 恢复寄存器
50.     pop esi
51.     pop ebx
52.    
53.     add esp,0e4h        ; 降低栈顶esp开辟的局部空间,局部空间被释放
54.    
55.     cmp ebp,esp         ; 检测堆栈是否平衡,不平衡则直接停机
56.     jne error
57.    
58.     pop ebp
59.     mov esp,ebp         ; 恢复基址指针
60.     int 3
61.   
62.   error:
63.     int 3
64.   
65.   main ENDP
66. END main

复制代码

5.1 CDECL

CDECL是C/C++中的一种默认调用约定（调用者平栈）。这种调用方式规定函数调用者在将参数压入栈中后，再将控制权转移到被调用函数，被调用函数通过栈顶指针ESP来访问这些参数。函数返回时，由调用者程序负责将堆栈平衡清除。CDECL调用约定的特点是简单易用，但相比于其他调用约定，由于栈平衡的操作需要在函数返回后再进行，因此在一些情况下可能会带来一些性能上的开销。
该调用方式在函数内不进行任何平衡参数操作，而是在退出函数后对esp执行加4操作，从而实现栈平衡。该约定会采用复写传播优化，将每次参数平衡的操作进行归并，在函数结束后一次性平衡栈顶指针esp，且不定参数函数也可使用此约定。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0cch
14.     push ebx
15.     push esi
16.     push edi
17.    
18.     lea edi,dword ptr [ ebp - 0cch ]     ; 初始化局部变量
19.     mov ecx,33h
20.     mov eax,0CCCCCCCCh
21.     rep stosd
23.     mov eax,dword ptr [ ebp + 08h ]       ; 第一个变量(传入参数1)
24.     add eax,dword ptr [ ebp + 0Ch ]       ; 第二个变量(传入参数2)
25.     add eax,dword ptr [ ebp + 10h ]       ; 第三个变量(传入参数3)
26.    
27.     mov dword ptr [ ebp - 08h ],eax       ; 将结果放入到局部变量
28.     mov eax,dword ptr [ ebp - 08h ]       ; 给eax寄存器返回
29.    
30.     pop edi
31.     pop esi
32.     pop ebx
33.     mov esp,ebp
34.     pop ebp
35.     ret
36.   function endp
38.   main PROC
39.     ; 单独调用并无优势
40.     push 3
41.     push 2
42.     push 1
43.     call function          ; __cdecl functin(1,2,3)
44.     add esp,12
45.    
46.     ; 连续调用则可体现出优势
47.     push 5
48.     push 4
49.     push 3
50.     call function          ; __cdecl function(3,4,5)
51.     mov ebx,eax
52.    
53.     push 6
54.     push 7
55.     push 8
56.     call function          ; __cdecl function(8,7,6)
57.     mov ecx,eax
58.    
59.     add esp,24             ; 一次性平两次栈
60.    
61.     int 3
62.   main ENDP
63. END main

复制代码

5.2 STDCALL

STDCALL 调用约定规定由被调用者负责将堆栈平衡清除。STDCALL是一种被调用者平栈的约定，这意味着，在函数调用过程中，被调用函数使用栈来存储传递的参数，并在函数返回之前移除这些参数，这种方式可以使调用代码更短小简洁。STDCALL与CDECL只在参数平衡上有所不同，其余部分都一样，但该约定不定参数函数无法使用。
通过以上分析发现_cdecl与_stdcall两者只在参数平衡上有所不同，其余部分都一样，但经过优化后_cdecl调用方式的函数在同一作用域内多次使用，会在效率上比_stdcall髙，这是因为_cdecl可以使用复写传播优化，而_stdcall的平栈都是在函数内部完成的，无法使用复写传播这种优化方式。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0cch
14.     push ebx
15.     push esi
16.     push edi
17.    
18.     lea edi,dword ptr [ ebp - 0cch ]     ; 初始化局部变量
19.     mov ecx,33h
20.     mov eax,0CCCCCCCCh
21.     rep stosd
23.     mov eax,dword ptr [ ebp + 08h ]       ; 第一个变量(传入参数1)
24.     add eax,dword ptr [ ebp + 0Ch ]       ; 第二个变量(传入参数2)
25.     add eax,dword ptr [ ebp + 10h ]       ; 第三个变量(传入参数3)
26.    
27.     mov dword ptr [ ebp - 08h ],eax       ; 将结果放入到局部变量
28.     mov eax,dword ptr [ ebp - 08h ]       ; 给eax寄存器返回
29.    
30.     pop edi
31.     pop esi
32.     pop ebx
33.     mov esp,ebp
34.     pop ebp
35.    
36.     ret 12                                ; 应用stdcall时,通过ret对目标平栈
37.   function endp
39.   main PROC
40.     push 3
41.     push 2
42.     push 1
43.     call function          ; __stdcall functin(1,2,3)
44.     mov ebx,eax            ; 获取返回值
45.    
46.     push 4
47.     push 5
48.     push 6
49.     call function          ; __stdcall function(6,5,4)
50.     mov ecx,eax            ; 获取返回值
51.    
52.     add ebx,ecx            ; 结果相加
53.     int 3
54.   main ENDP
55. END main

复制代码

5.3 FASTCALL

FASTCALL是一种针对寄存器的调用约定。它通常采用被调用者平衡堆栈的方式，类似于STDCALL调用约定。但是，FASTCALL约定规定函数的前两个参数在ECX和EDX寄存器中传递，节省了压入堆栈所需的指令。此外，函数使用堆栈来传递其他参数，并在返回之前使用类似于STDCALL约定的方式来平衡堆栈。
FASTCALL的优点是可以在发生大量参数传递时加快函数的处理速度，因为使用寄存器传递参数比使用堆栈传递参数更快。但是，由于FASTCALL约定使用的寄存器数量比CDECL和STDCALL约定多，因此它也有一些限制，例如不支持使用浮点数等实现中需要使用多个寄存器的数据类型。
FASTCALL效率最高，其他两种调用方式都是通过栈传递参数，唯独_fastcall可以利用寄存器传递参数，一般前两个或前四个参数用寄存器传递，其余参数传递则转换为栈传递，此约定不定参数函数无法使用。

• 对于32位来说使用ecx,edx传递前两个参数，后面的用堆栈传递。
  
• 对于64位则会使用RCX,RDX,R8,R9传递前四个参数，后面的用堆栈传递。
  

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0e4h
14.     push ebx
15.     push esi
16.     push edi
17.     push ecx
18.    
19.     lea edi,dword ptr [ ebp - 0e4h ]     ; 初始化局部变量
20.     mov ecx,39h
21.     mov eax,0CCCCCCCCh
22.     rep stosd
23.     pop ecx
24.    
25.     mov dword ptr [ ebp - 14h ],edx      ; 读入第二个参数放入局部变量
26.     mov dword ptr [ ebp - 8h ],ecx       ; 读入第一个参数放入局部变量
27.    
28.     mov eax,dword ptr [ ebp - 8h ]       ; 从局部变量内读入第一个参数
29.     add eax,dword ptr [ ebp - 14h ]      ; 从局部变量内读入第二个参数
30.    
31.     add eax,dword ptr [ ebp + 8h ]       ; 从堆栈中读入第三个参数
32.     add eax,dword ptr [ ebp + 0ch ]      ; 从堆栈中读入第四个参数
33.     add eax,dword ptr [ ebp + 10h ]      ; 从堆栈中读入第五个参数
34.     add eax,dword ptr [ ebp + 14h ]      ; 从堆栈中读入第六个参数
35.    
36.     mov dword ptr [ ebp - 20h ],eax      ; 将结果给第三个局部变量
37.     mov eax,dword ptr [ ebp - 20h ]      ; 返回数据
38.    
39.     pop edi
40.     pop esi
41.     pop ebx
42.     mov esp,ebp
43.     pop ebp
44.    
45.     ret 16                               ; 平栈
46.   function endp
48.   main PROC
49.     push 6
50.     push 5
51.     push 4
52.     push 3
53.     mov edx,2
54.     mov ecx,1         ; __fastcall function(1,2,3,4,5,6)
55.     call function     ; 调用函数
56.    
57.     int 3
58.   main ENDP
59. END main

复制代码

5.4 使用ESP寄存器寻址

编译器开启了O2优化模式选项，则为了提高程序执行效率，只要栈顶是稳定的，编译器编译时就不再使用ebp指针了，而是利用esp指针直接访问局部变量，这样可节省一个寄存器资源。
在程序编译时编译器会自动为我们计算ESP基地址与传入变量的参数偏移，使用esp寻址后，不必每次进入函数后都调整栈底ebp，从而减少了ebp的使用，因此可以有效提升程序执行效率。但如果在函数执行过程中esp发生了变化，再次访问变量就需要重新计算偏移了。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0ch
14.     push esi
15.    
16.     ; 动态计算出四个参数
17.     lea eax,dword ptr [ esp - 4h + 01ch ]    ; 计算参数1 [esp+18]
18.     lea ebx,dword ptr [ esp - 0h + 01ch ]    ; 计算参数2 [esp+1c]
19.     lea ecx,dword ptr [ esp + 4h + 01ch ]    ; 计算参数3 [esp+20]
20.     lea edx,dword ptr [ esp + 8h + 01ch ]    ; 计算参数4 [esp+24]
21.    
22.     ; 如果ESP被干扰则需要动态调整
23.     lea eax,dword ptr [ esp - 4h + 01ch ]          ; 当前参数1的地址
24.     push ebx
25.     push ecx                                       ; 指令让ESP被减去8
26.     lea eax,dword ptr [ esp - 4h + 01ch  + 8h ]    ; 此处需要+8h修正堆栈
27.    
28.     add esp,0ch
29.     pop esi
30.     mov esp,ebp
31.     pop ebp
32.     ret
33.   function endp
35.   main PROC
36.     push 5
37.     push 3
38.     push 4
39.     push 1
40.     call function
41.     int 3
42.   main ENDP
43. END main

复制代码

5.5 使用数组指针传值

这里我们以一维数组为例，二维数组的传递其实和一维数组是相通的，只不过在寻址方式上要使用二维数组的寻址公式，此外传递数组其实本质上就是传递指针，所以数组与指针的传递方式也是相通的。
使用汇编仿写数组传递方式，在main函数内我们动态开辟一块栈空间，并将数组元素依次排列在栈内，参数传递时通过lea eax,dword ptr [ ebp - 18h ]获取到数组栈地址空间，由于main函数并不会被释放所以它的栈也是稳定的，调用function函数时只需要将栈首地址通过push eax的方式传递给function函数内，并在函数内通过mov ecx,dword ptr [ ebp + 8h ]获取到函数基地址，通过比例因子定位栈空间。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0cch
14.     push ebx
15.     push esi
16.     push edi
17.     lea edi,dword ptr [ ebp - 0cch ]
18.     mov ecx,33h
19.     mov eax,0CCCCCCCCh
20.     rep stosd
21.    
22.     ; 检索数组第一个元素
23.     mov eax,1
24.     mov ecx,dword ptr [ ebp + 8h ]          ; 定位数组基地址
25.     mov edx,dword ptr [ ecx + eax * 4 ]     ; 定位元素
26.    
27.     ; 检索数组第二个元素
28.     mov eax,2
29.     mov ecx,dword ptr [ ebp + 8h ]
30.     mov edx,dword ptr [ ecx + eax * 4 ]
31.    
32.     pop edi
33.     pop esi
34.     pop ebx
35.     add esp,0cch
36.     mov esp,ebp
37.     pop ebp
38.     ret
39.   function ENDP
41.   main PROC
42.     push ebp
43.     mov ebp,esp
44.     sub esp,0dch
45.     push ebx
46.     push esi
47.     push edi
49.     lea edi,dword ptr [ ebp - 0dch ]
50.     mov ecx,37h
51.     mov eax,0CCCCCCCCh
52.     rep stosd
53.    
54.     mov dword ptr [ ebp - 18h ],1        ; 局部空间存储数组元素
55.     mov dword ptr [ ebp - 14h ],2
56.     mov dword ptr [ ebp - 10h ],3
57.     mov dword ptr [ ebp - 0ch ],4
58.     mov dword ptr [ ebp - 8h ],5
59.    
60.     push 5
61.     lea eax,dword ptr [ ebp - 18h ]      ; 取数组首地址并入栈
62.     push eax
63.     call function                        ; 调用函数 function(5,eax)
64.     add esp,8                            ; 平栈
66.     pop edi
67.     pop esi
68.     pop ebx
69.     add esp,0dch
70.     mov esp,ebp
71.     pop ebp
72.     ret
73.   main ENDP
74. END main

复制代码

5.6 指向函数的指针

程序通过CALL指令跳转到函数首地址执行代码，既然是地址那就可以使用指针变量来存储函数的首地址，该指针变量被称作函数指针。
在编译时编译器为函数代码分配一段存储空间，这段存储空间的起始地址就是这个函数的指针，我们可以调用这个指针实现间接调用指针所指向的函数。

1. #include <iostream>
3. void __stdcall Show(int x, int y)
4. {
5.   printf("%d --> %d \n",x,y);
6. }
8. int __stdcall ShowPrint(int nShow, int nCount)
9. {
10.   int ref = nShow + nCount;
11.   return ref;
12. }
14. int main(int argc, char* argv[])
15. {
16.   // 空返回值调用
17.   void(__stdcall *pShow)(int,int) = Show;
18.   pShow(1,2);
20.   // 带参数调用返回
21.   int(__stdcall *pShowPrint)(int, int) = ShowPrint;
22.   int Ret = pShowPrint(2, 4);
23.   printf("返回值 = %d \n", Ret);
25.   return 0;
26. }

复制代码

首先我们使用汇编仿写ShowPrint函数以及该函数所对应的int(__stdcall *pShowPrint)(int, int)函数指针，看一下在汇编层面该如何实现这个功能。

1.   .386p
2.   .model flat,stdcall
3.   option casemap:none
5. include windows.inc
6. include kernel32.inc
7. includelib kernel32.lib
9. .code
10.   function PROC
11.     push ebp
12.     mov ebp,esp
13.     sub esp,0cch
14.     push ebx
15.     push esi
16.     push edi
17.     lea edi,dword ptr [ ebp - 0cch ]
18.     mov ecx,33h
19.     mov eax,0CCCCCCCCh
20.     rep stosd
21.    
22.     mov eax,dword ptr [ ebp + 4h ]    ; 此处+4得到的是返回后上一条指令地址
23.     mov eax,dword ptr [ ebp + 8h ]    ; 得到第一个堆栈传入参数地址
24.     mov ebx,dword ptr [ ebp + 0ch ]   ; 得到第二个堆栈传入参数地址
25.     add eax,ebx                       ; 递增并返回到EAX
26.    
27.     pop edi
28.     pop esi
29.     pop ebx
30.     add esp,0cch
31.     mov esp,ebp
32.     pop ebp
33.     ret
34.   function ENDP
36.   main PROC
37.     push ebp
38.     mov ebp,esp
39.     sub esp,0d8h
40.     push ebx
41.     push esi
42.     push edi
44.     lea edi,dword ptr [ ebp - 0d8h ]
45.     mov ecx,36h
46.     mov eax,0CCCCCCCCh
47.     rep stosd
48.    
49.     lea eax,function                     ; 获取函数指针
50.     mov dword ptr [ ebp - 8h ],eax       ; 将指针放入局部空间
51.    
52.     push 4
53.     push 2                               ; 传入参数
54.     call dword ptr [ ebp - 8h ]          ; 调用函数
55.     add esp,8                            ; 平栈
57.     pop edi
58.     pop esi
59.     pop ebx
60.     add esp,0d8h
61.     mov esp,ebp
62.     pop ebp
63.     ret
64.   main ENDP
65. END main

复制代码

本文作者： 王瑞
本文链接： https://www.lyshark.com/post/17fb1a42.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！