【文档翻译】__cdecl/__stdcall/__fastcall?解开神秘的调用约定!

本文档译自 www.codeproject.com 的文章 "Calling Conventions Demystified",作者 Nemanja Trifunovic,原文参见此处


引言 - Introduction

在学习 Windows 编程的漫长、艰难而美妙的旅途中,你可能会对函数声明前出现的奇怪说明符感到好奇,比如 __cdecl__stdcall__fastcallWINAPI 等等。在阅读过 MSDN 或其他参考资料之后,你可能知道了这些说明符是用来为函数指定一种叫“调用约定”的东西。在这篇文章中,我会使用 Visual C++ 来向你解释不同的调用约定。我要强调的是,上面提到的说明符是微软特有的,如果你想编写可移植代码,就不应该使用它们。

那么,调用约定究竟是什么呢?当我们调用函数时,通常会将参数传递给它,并获得返回值。而调用约定就描述了参数是如何传递、值是如何从函数返回的。它还指定了函数名称的修饰方式。不过,编写优秀的 C/C++ 程序真的一定要了解调用约定吗?并不是。但是,它可能有助于调试。此外,如果要把 C/C++ 与汇编代码链接,那么这也有帮助。

要理解本文,你需要具备汇编编程的一些非常基本的知识。

无论使用哪种调用约定,都会发生以下情况:

  1. 所有参数都被扩展到 4 字节(除非特别说明,默认在 Win32 上),并放入内存的适当位置,这些位置通常在栈上。不过它们也可能被放在寄存器中,这便是通过调用约定指定的。
  2. 程序执行流会跳转到被调用函数的地址。
  3. 在函数内部,寄存器 ESI、EDI、EBX 和 EBP 的值被保存在栈上。执行这些操作的代码部分称为 function prolog,通常由编译器生成。
  4. 执行函数代码,并将返回值放入 EAX 寄存器中。
  5. 寄存器 ESI、EDI、EBX 和 EBP 的值从栈中恢复。执行此操作的代码段称为 function epilog,与 function prolog 一样,在大多数情况下,它由编译器生成。
  6. 参数从栈中移除。此操作称为清栈(stack cleanup),可以在被调用函数的内部执行,也可以由调用方执行,具体取决于所使用的调用约定。

作为调用约定的例子(不考虑 this),我们将使用一个简单的函数:

int sumExample (int a, int b)
{
    return a + b;
}

对这个函数的调用看起来像这样:

int c = sum (2, 3);

对于使用 __cdecl__stdcall__fastcall 的例子,我会把示例代码编译成 C 代码。本文后面提到的函数名修饰用的是 C 的修饰方法。C++ 的名称修饰方法超出了本文的讨论范围。


C 调用约定 - C calling convention (__cdecl)

这个约定是 C/C++ 的默认调用约定。如果项目被设置成使用其他的调用约定,我们也可以通过显式声明 __cdecl 来为某个函数指定:

int __cdecl sumExample (int a, int b);

__cdecl 调用约定的主要特点是:

  1. 参数将从右到左依次压入栈中。
  2. 由调用者执行清栈。
  3. 函数名用下划线字符 _ 作为前缀进行修饰。

现在,示例函数的调用看起来像这样:

; // 参数从右到左依次压入栈中
push        3    
push        2    

; // 调用函数
call        _sumExample 

; // 增加参数的总大小到 ESP 寄存器(向高位移动栈指针),以此来清理堆栈
add         esp,8 

; // 将 EAX 的返回值复制到局部变量 (int c)
mov         dword ptr [c],eax

被调用函数 sumExample 的内部如下所示:

; // function prolog
  push        ebp  
  mov         ebp,esp 
  sub         esp,0C0h 
  push        ebx  
  push        esi  
  push        edi  
  lea         edi,[ebp-0C0h] 
  mov         ecx,30h 
  mov         eax,0CCCCCCCCh 
  rep stos    dword ptr [edi] 
  
; //    return a + b;
  mov         eax,dword ptr [a] 
  add         eax,dword ptr [b] 

; // function epilog
  pop         edi  
  pop         esi  
  pop         ebx  
  mov         esp,ebp 
  pop         ebp  
  ret



标准调用约定 - Standard calling convention (__stdcall)

这个调用约定常常用在 Win32 API 的函数上。事实上,WINAPI 只是 __stdcall 的另一个名称。

#define WINAPI __stdcall

同样,可以为一个函数显式指定标准调用约定:

int __stdcall sumExample (int a, int b);

我们也可以使用编译器选项 /Gz 来给所有未显式声明约定的函数指定 __stdcall

__stdcall 调用约定的主要特点是:

  1. 参数将从右到左依次压入栈中。
  2. 由被调用的函数执行清栈。
  3. 函数名通过添加下划线 _@ 字符和所需的堆栈空间字节数来修饰。

调用示例如下:

; // 参数从右到左依次压入栈中
  push        3    
  push        2    
  
; // 调用函数
  call        _sumExample@8

; // 将 EAX 的返回值复制到局部变量 (int c)
  mov         dword ptr [c],eax

函数如下所示:

; // 此处是 function prolog (和 __cdecl 的例子一样,略过)

; //    return a + b;
  mov         eax,dword ptr [a] 
  add         eax,dword ptr [b] 

; // 此处是 function epilog (和 __cdecl 的例子一样,略过)

; // 清栈并返回控制流
  ret         8

因为栈由被调用的函数清理,所以通常 __stdcall 调用约定创建的可执行文件比 __cdecl 要小。因为在 __cdecl 中,必须为每个函数调用生成清栈的代码。另一方面,参数数量可变的函数(如 printf())必须使用 __cdecl,因为只有调用者知道函数调用中的参数数量;所以,也只有调用方才能执行清栈。


Fast 调用约定 - Fast calling convention (__fastcall)

__fastcall指出,只要有可能,参数就应该放在寄存器中,而不是栈中。这减少了函数调用的成本,因为使用寄存器的操作比使用堆栈的操作要快。

我们可以显式声明 __fastcall 来使用约定,如下所示:

int __fastcall sumExample (int a, int b);

我们也可以使用编译器选项 /Gr 来给所有未显式声明约定的函数指定 __fastcall

__fastcall 的主要特点是:

  1. 需要 32 位大小(及以下)的前两个函数参数被放入寄存器 ECX 和 EDX。其余的从右向左压入堆栈。
  2. 被调用的函数负责从堆栈中弹出参数。
  3. 函数名通过在开头添加 @ 字符并附加 @ 和参数所需的字节数(十进制)来修饰。

注意:Microsoft 保留在未来的编译器版本中更改传递参数的寄存器的权利。

调用例子如下:

; // 将参数放入寄存器 EDX 和 ECX 中
  mov         edx,3 
  mov         ecx,2 
  
; // 调用函数
  call        @fastcallSum@8
  
; // 从寄存器 EAX 拷贝返回值到局部变量 (int c)  
  mov         dword ptr [c],eax

函数内部:

; // function prolog
  push        ebp  
  mov         ebp,esp 
  sub         esp,0D8h 
  push        ebx  
  push        esi  
  push        edi  
  push        ecx  
  lea         edi,[ebp-0D8h] 
  mov         ecx,36h 
  mov         eax,0CCCCCCCCh 
  rep stos    dword ptr [edi] 
  pop         ecx  
  mov         dword ptr [ebp-14h],edx 
  mov         dword ptr [ebp-8],ecx 
; // return a + b;
  mov         eax,dword ptr [a] 
  add         eax,dword ptr [b] 
;// function epilog  
  pop         edi  
  pop         esi  
  pop         ebx  
  mov         esp,ebp 
  pop         ebp  
  ret

这个调用约定究竟和 __cdecl__stdcall 相比有多快呢?你可以自己寻找答案。通过声明不同的约定,再比较执行时间看看吧。我没有发现 __fastcall 比其他调用约定更快,不过你可能会得出不同的结论。


Thiscall - Thiscall

Thiscall 是调用 C++ 类成员函数的默认调用约定(参数数量可变的除外)。

这种约定的主要特点是:

  1. 参数将从右到左依次压入栈中。this被放在 ECX 寄存器中。
  2. 由被调用的函数执行清栈。

这个调用约定的例子有点不同。首先,代码被编译为 C++,而不是 C。其次,我们用一个带有成员函数的结构体,而不是用自由函数。

struct CSum
{
    int sum ( int a, int b) {return a+b;}
};

函数调用的汇编代码如下所示:

push        3
push        2
lea         ecx,[sumObj]
call        ?sum@CSum@@QAEHHH@Z            ; CSum::sum
mov         dword ptr [s4],eax

函数内部如下所示:

push        ebp
mov         ebp,esp
sub         esp,0CCh
push        ebx
push        esi
push        edi
push        ecx
lea         edi,[ebp-0CCh]
mov         ecx,33h
mov         eax,0CCCCCCCCh
rep stos    dword ptr [edi]
pop         ecx
mov         dword ptr [ebp-8],ecx
mov         eax,dword ptr [a]
add         eax,dword ptr [b]
pop         edi
pop         esi
pop         ebx
mov         esp,ebp
pop         ebp
ret         8

如果我们有一个成员函数使用可变数量参数会发生什么?在这种情况下,会使用 __cdeclthis 最后被压入栈。


总结 - Conclusion

长话短说,我们总结调用约定之间的主要区别:

  • __cdecl 是 C 和 C++ 程序的默认调用约定。这种调用约定的优点是,它允许使用具有可变数量参数的函数。缺点是它会创建更大的可执行文件。
  • __stdcall 多用于 Win32 API 函数。它不允许函数具有可变数量的参数。
  • __fastcall 尝试将参数放在寄存器中,而不是堆栈中,从而使函数调用更快。
  • Thscall 调用约定是不使用可变参数的 C++ 成员函数使用的默认调用约定。

在大多数情况下,这就是你需要了解的关于调用约定的全部内容。

热门相关:婚期一年   墨先生,乖乖娶我   豪门隐婚:老婆别闹了   试婚100天:夜少,宠上瘾   全系灵师:魔帝嗜宠兽神妃