DLL中调用约定和名称修饰

调用约定(Calling Convention [kən’venʃ(ə)n])是指在程序设计语言中为了实现函数调用而建立的一种协议。这种协议规定了该语言的函数中的参数传送方式、参数是否可变和由谁来处理堆栈等问题。不同的语言定义了不同的调用约定。

在C++中,为了允许操作符重载和函数重载,C++编译器往往按照某种规则改写每一个入口点的符号名,以便允许同一个名字(具有不同的参数类型或者是不同的作用域)有多个用法,而不会打破现有的基于C的链接器。这项技术通常被称为名称改编(Name Mangling)或者名称修饰(Name Decoration)。许多C++编译器厂商选择了自己的名称修饰方案。

因此,为了使其它语言编写的模块(如Visual Basic应用程序、Pascal或Fortran的应用程序等)可以调用C/C++编写的DLL的函数,必须使用正确的调用约定来导出函数,并且不要让编译器对要导出的函数进行任何名称修饰。

一:调用约定(Calling Convention)

调用约定用来处理决定函数参数传送时入栈和出栈的顺序(由调用者还是被调用者把参数弹出栈),以及编译器用来识别函数名称的名称修饰约定等问题。在Microsoft VC++ 6.0中定义了下面几种调用约定,我们将结合汇编语言来一一分析它们:

1、cdecl cdecl是C/C++和MFC程序默认使用的调用约定,也可以在函数声明时加上cdecl关键字来手工指定。采用cdecl约定时,函数参数按照从右到左的顺序入栈,并且由调用函数者把参数弹出栈以清理堆栈。因此,实现可变参数的函数只能使用该调用约定。由于每一个使用cdecl约定的函数都要包含清理堆栈的代码,所以产生的可执行文件大小会比较大。cdecl可以写成_cdecl。

下面将通过一个具体实例来分析__cdecl约定:

在VC++中新建一个Win32 Console工程(一个简单的程序)。其代码如下:

#include "stdafx.h"
int __cdecl Add(int a, int b);         //函数的声明
int main(int argc, char* argv[])
{
     Add(1,2);            //函数的调用
}
int __cdecl Add(int a, int b){          //函数的定义
     return(a+b);
}

然后按F11运行调试,打开Disassembly窗口,查看汇编代码。

10: int main(int argc, char* argv[])
11: {
0040D430 push ebp
0040D431 mov ebp,esp
0040D433 sub esp,40h
0040D436 push ebx
0040D437 push esi
0040D438 push edi
0040D439 lea edi,[ebp-40h]
0040D43C mov ecx,10h
0040D441 mov eax,0CCCCCCCCh
0040D446 rep stos dword ptr [edi]
12: Add(1,2);
0040D448 push 2                      ;参数从右到左入栈,压入2
0040D44A push 1                      ;压入1
0040D44C call @ILT+0(Add) (00401005)          ;函数调用CALL
0040D451 add esp,8                 ;由函数调用清栈
13: }
0040D454   pop         edi
0040D455   pop         esi
0040D456   pop         ebx
0040D457   add         esp,40h
0040D45A   cmp         ebp,esp
0040D45C   call        __chkesp (0040d470)
0040D461   mov         esp,ebp
0040D463   pop         ebp
0040D464   ret

函数原型汇编代码

15: int __cdecl Add(int a, int b){
00401050 push ebp
00401051 mov ebp,esp
00401053 sub esp,40h
00401056 push ebx
00401057 push esi
00401058 push edi
00401059 lea edi,[ebp-40h]
0040105C mov ecx,10h
00401061 mov eax,0CCCCCCCCh
00401066 rep stos dword ptr [edi]
16: return(a+b);
00401068 mov eax,dword ptr [ebp+8]
0040106B add eax,dword ptr [ebp+0Ch]
17: }
0040106E pop edi
0040106F pop esi
00401070 pop ebx
00401071 mov esp,ebp
00401073 pop ebp
00401074 ret                         ;函数本身返回不做任何处理

2、stdcall stdcall调用约定用于调用Win32 API函数。采用stdcal约定时,函数参数按照从右到左的顺序入栈,被调用的函数在返回前清理传送参数的栈,函数参数个数固定。由于函数体本身知道传进来的参数个数,因此被调用的函数可以在返回前用一条ret n指令直接清理传递参数的堆栈。stdcall可以写成_stdcall。
还是那个例子,将cdecl约定换成stdcall,然后再运行调试:

10: int main(int argc, char* argv[])
11: {
0040D430 push ebp
0040D431 mov ebp,esp
0040D433 sub esp,40h
0040D436 push ebx
0040D437 push esi
0040D438 push edi
0040D439 lea edi,[ebp-40h]
0040D43C mov ecx,10h
0040D441 mov eax,0CCCCCCCCh
0040D446 rep stos dword ptr [edi]
12: Add(1,2);
0040D448 push 2                               ;参数从右到左入栈,压入2
0040D44A push 1                               ;压入1
0040D44C call @ILT+10(Add) (0040100f)            ;CALL函数后不做处理       
13:   }
0040D451   pop         edi
0040D452   pop         esi
0040D453   pop         ebx
0040D454   add         esp,40h
0040D457   cmp         ebp,esp
0040D459   call        __chkesp (0040d470)
0040D45E   mov         esp,ebp
0040D460   pop         ebp
0040D461   ret

函数原型汇编代码

15: int __stdcall Add(int a, int b){
00401050 push ebp
00401051 mov ebp,esp
00401053 sub esp,40h
00401056 push ebx
00401057 push esi
00401058 push edi
00401059 lea edi,[ebp-40h]
0040105C mov ecx,10h
00401061 mov eax,0CCCCCCCCh
00401066 rep stos dword ptr [edi]
16: return(a+b);
00401068 mov eax,dword ptr [ebp+8]
0040106B add eax,dword ptr [ebp+0Ch]
17: }
0040106E pop edi
0040106F pop esi
00401070 pop ebx
00401071 mov esp,ebp
00401073 pop ebp
00401074 ret 8                           ;清栈

3、fastcall fastcall约定用于对性能要求非常高的场合。fastcall约定将函数的从左边开始的两个大小不大于4个字节(DWORD)的参数分别放在ECX和EDX寄存器,其余的参数仍旧自右向左压栈传送,被调用的函数在返回前清理传送参数的堆栈。fastcall可以写成_fastcall。
同上个例子,把调用约定为__fastcall,函数参数个数增加2个:

10: int main(int argc, char* argv[])
11: {
0040D430 push ebp
0040D431 mov ebp,esp
0040D433 sub esp,40h
0040D436 push ebx
0040D437 push esi
0040D438 push edi
0040D439 lea edi,[ebp-40h]
0040D43C mov ecx,10h
0040D441 mov eax,0CCCCCCCCh
0040D446 rep stos dword ptr [edi]
12: Add(1,2,3,4);
0040D448 push 4
0040D44A push 3
0040D44C mov edx,2
0040D451 mov ecx,1
0040D456 call @ILT+35(Add) (00401028)
13: }
0040D45B pop edi
0040D45C pop esi
0040D45D pop ebx
0040D45E add esp,40h
0040D461 cmp ebp,esp
0040D463 call __chkesp (0040d470)
0040D468 mov esp,ebp
0040D46A pop ebp
0040D46B ret

函数原型汇编代码

15: int __fastcall Add(int a, int b, int c, int d){
0040D4B0 push ebp
0040D4B1 mov ebp,esp
0040D4B3 sub esp,48h
0040D4B6 push ebx
0040D4B7 push esi
0040D4B8 push edi
0040D4B9 push ecx
0040D4BA lea edi,[ebp-48h]
0040D4BD mov ecx,12h
0040D4C2 mov eax,0CCCCCCCCh
0040D4C7 rep stos dword ptr [edi]
0040D4C9 pop ecx
0040D4CA mov dword ptr [ebp-8],edx
0040D4CD mov dword ptr [ebp-4],ecx
16: return(a+b+c+d);
0040D4D0 mov eax,dword ptr [ebp-4]
0040D4D3 add eax,dword ptr [ebp-8]
0040D4D6 add eax,dword ptr [ebp+8]
0040D4D9 add eax,dword ptr [ebp+0Ch]
17: }
0040D4DC pop edi
0040D4DD pop esi
0040D4DE pop ebx
0040D4DF mov esp,ebp
0040D4E1 pop ebp
0040D4E2 ret 8               ;清栈

关键字cdecl、stdcall和fastcall可以直接加在要输出的函数前,也可以在编译环境的Setting…->C/C++->Code Generation项选择。它们对应的命令行参数分别为/Gd、/Gz和/Gr。缺省状态为/Gd,即cdecl。当加在输出函数前的关键字与编译环境中的选择不同时,直接加在输出函数前的关键字有效。

4、thiscall
thiscall调用约定是C++中的非静态类成员函数的默认调用约定。thiscall只能被编译器使用,没有相应的关键字,因此不能被程序员指定。采用thiscall约定时,函数参数按照从右到左的顺序入栈,被调用的函数在返回前清理传送参数的栈,只是另外通过ECX寄存器传送一个额外的参数:this指针。
这次的例子中将定义一个类,并在类中定义一个成员函数,代码如下:

15: int main(int argc, char* argv[])
16: {
0040D430 push ebp
0040D431 mov ebp,esp
0040D433 sub esp,44h
0040D436 push ebx
0040D437 push esi
0040D438 push edi
0040D439 lea edi,[ebp-44h]
0040D43C mov ecx,11h
0040D441 mov eax,0CCCCCCCCh
0040D446 rep stos dword ptr [edi]
17: cs s;
18: s.Add(1,2);
0040D448 push 2
0040D44A push 1
0040D44C lea ecx,[ebp-4]                            ;;ecx存放了this指针
0040D44F call @ILT+40(Add) (0040102d)
19: }
0040D454 pop edi
0040D455 pop esi
0040D456 pop ebx
0040D457 add esp,44h
0040D45A cmp ebp,esp
0040D45C call __chkesp (0040d470)
0040D461 mov esp,ebp
0040D463 pop ebp
0040D464 ret
6: class cs
7: {
8: public:
9: int Add(int a, int b)
10: {
0040D4B0 push ebp
0040D4B1 mov ebp,esp
0040D4B3 sub esp,44h                 ;多用了一个4bytes的空间用于存放this指针
0040D4B6 push ebx
0040D4B7 push esi
0040D4B8 push edi
0040D4B9 push ecx
0040D4BA lea edi,[ebp-44h]
0040D4BD mov ecx,11h
0040D4C2 mov eax,0CCCCCCCCh
0040D4C7 rep stos dword ptr [edi]
0040D4C9 pop ecx
0040D4CA mov dword ptr [ebp-4],ecx
11: return(a+b);
0040D4CD mov eax,dword ptr [ebp+8]
0040D4D0 add eax,dword ptr [ebp+0Ch]
12: }
0040D4D3 pop edi
0040D4D4 pop esi
0040D4D5 pop ebx
0040D4D6 mov esp,ebp
0040D4D8 pop ebp
0040D4D9 ret 8

5、naked属性
采用上面所述的四种调用约定的函数在进入函数时,编译器会产生代码来保存ESI、EDI、EBX、EBP寄存器中的值,退出函数时则产生代码恢复这些寄存器的内容。对于定义了naked属性的函数,编译器不会自动产生这样的代码,需要你手工使用内嵌汇编来控制函数实现中的堆栈管理。由于naked属性并不是类型修饰符,故必须和__declspec共同使用。下面的这段代码定义了一个使用了naked属性的函数及其实现:

__declspec (naked) func()
{
      int i;
      int j;
      _asm
      {
           push ebp
           mov ebp, esp
           sub esp, __LOCAL_SIZE
      }
      _asm
      {
           mov esp, ebp
           pop ebp
           ret
      }
}

naked属性与本节关系不大,具体请参考MSDN。
6、WINAPI
还有一个值得一提的是WINAPI宏,它可以被翻译成适当的调用约定以供函数使用。该宏定义于windef.h之中。下面是在windef.h中的部分内容:

#define CDECL             _cdecl
#define WINAPI            CDECL
#define CALLBACK        __stdcall
#define WINAPI            __stdcall
#define APIENTRY        WINAPI

由此可见,WINAPI、CALLBACK、APIENTRY等宏的作用。
二:名称修饰(Name Decoration)
C或C++函数在内部(编译和链接)通过修饰名(Decoration[dekə’reɪʃ(ə)n] Name)识别。函数的修饰名是编译器在编译函数定义或者原型时生成的字符串。编译器在创建.obj文件时对函数名称进行修饰。有些情况下使用函数的修饰名是必要的,如在模块定义文件里头指定输出C++重载函数、构造函数、析构函数,又如在汇编代码里调用C或C++函数等。
在VC++中,函数修饰名由编译类型(C或C++)、函数名、类名、调用约定、返回类型、参数等多种因素共同决定。下面分C编译、C++编译(非类成员函数)和C++类及其成员函数编译三种情况说明:
1、C编译时函数名称修饰

   当函数使用__cdecl调用约定时,编译器仅在原函数名前加上一个下划线前缀,格式为_functionname。例如:函数int __cdecl Add(int a, int b),输出后为:_Add。
   当函数使用__stdcall调用约定时,编译器在原函数名前加上一个下划线前缀,后面加上一个@符号和函数参数的字节数,格式为_functionname@number。例如:函数int __stdcall Add(int a, int b),输出后为:_Add@8。

   当函数是用__fastcall调用约定时,编译器在原函数名前加上一个@符号,后面是加一个@符号和函数参数的字节数,格式为@functionname@number。例如:函数int __fastcall Add(int a, int b),输出后为:@Add@8。
   以上改变均不会改变原函数名中的字符大小写。

2、C++编译时函数(非类成员函数)名称修饰
当函数使用__cdecl调用约定时,编译器进行以下工作:
1.以?标识函数名的开始,后跟函数名;
2.函数名后面以@@YA标识开始,后跟返回值和参数表;
3.当函数的返回值或者参数与C++类无关的时候,返回值和参数表以下列代号表示:

  B:   const
  D:  char
  E:   unsigned char
  F:   short
  G:   unsigned short
  H:   int
  I:    unsigned int
  J:    long
  K:   unsigned long
  M:   float
  N:   double
_N:   bool
PA:   指针(*,后面的代号表明指针类型,如果相同类型的指针连续出现,以0代替,一个0代表一次重复)
PB:   const指针
AA:   引用(&)
AB:   const引用
  U:   类或结构体
  V:   Interface(接口)
W4: enum
  X:   void

4.@@YA标识之后紧跟的是该函数的返回值类型,其后依次为参数的数据类型,指针标识在其所指数据类型前。当函数的返回值或者参数与C++类无关的时候,其处理符合本条规则,否则按照5、6规则处理;

   5.   当函数返回值为某个类或带有const性质的类的时候,返回值的命名为:?A/?B+V+类名+@@(不带加号)。当函数返回值为某个类的指针/引用或者带有const性质的类的指针/引用的时候,返回值的命名为:PA/AA或者PB/AB+V+类名+@@(不带加号);
   6.   函数参数为某个类的时候,并且该参数所使用的类曾经出现过的话(也就是与函数返回值所使用的类相同或者与前一个参数使用的类相同),则该参数类型格式为:V+1+@(不带加号)。如果该参数所使用的类没有出现过的话,则该参数类型格式为:V+类名+@@(不带加号)。函数参数为某个类的指针/引用或者带有const性质指针/引用的时候,则该参数类型格式是在上述格式的基础上在V前面加上代表指针/引用类型或者带有const性质指针/引用类型的标识符(PA/AA或PB/AB);
   7.   参数表后以@Z标识整个名字的结束,如果该函数无参数,则以Z标识结束。
         当函数使用__stdcall调用约定时,编译器所做工作的规则同上面的__cdecl调用约定,只是参数表的开始标识由上面的@@YA变为@@YG。
         当函数使用__fastcall调用约定时,编译器所做工作的规则同上面的__cdecl调用约定,只是参数表的开始标识由上面的@@YA变为@@YI。

3、C++编译类及其成员函数时名称修饰
对于导出的C++类,仅能使用cdecl调用约定。在编译器编译过程中,编译器会对C++类进行处理。如:class declspec(dllexport) MyClass会被处理为class MyClass & MyClass :: operator=(class MyClass const &)。在C++编译器对C++类进行名称修饰的时候,编译器进行以下工作:
1.以?标识函数名的开始,后跟?4+类名;
2.类名后面跟@@QAE标识,对于导出类来说这是固定的;
3.@@QAE后面跟AAV0@ABV0@,即引用类型标识符AA+V+0(重复的类的标识符)+@(不带加号)和const性质的引用AB+V+ 0(重复的类的标识符)+@(不带加号);
4.最后以@Z标识整个名字的结束。
对于导出的C++类中的成员函数(非构造函数和析构函数),可以使用不同的调用约定。当导出的C++类中的成员函数使用__cdecl调用约定时,编译器进行以下工作:

1.以?标识函数名的开始,后跟函数名+@+类名(不带加号);
2.之后以@@QAE标识开始,后跟返回值和参数表;
3.当函数的返回值或者参数与C++类无关的时候,返回值和参数表以下列代号表示:
B:const
D:char
E:unsigned char
F:short
G:unsigned short
H:int
I:unsigned int
J:long
K:unsigned long
M:float
N:double
_N:bool
PA:指针(*,后面的代号表明指针类型,如果相同类型的指针连续出现,以0
代替,一个0代表一次重复)
PB:const指针
AA:引用(&)
AB:const引用
U:类或结构体
V:Interface(接口)
W4:enum
X:void

4、@@QAE标识之后紧跟的是该函数的返回值类型,其后依次为参数的数据类型,指针标识在其所指数据类型前。当函数的返回值或者参数与C++类无关的时候,其处理符合本条规则,否则按照5、6规则处理;
5、当函数返回值为当前类或带有const性质的当前类的时候,返回值的命名为:?A或?B+V+1+@@(不带加号)。当函数返回值为当前类的指针/引用或者带有const性质的当前类的指针/引用的时候,返回值的命名为:PA/AA或PB/AB+V+1+@@(不带加号);
6、当函数返回值为某个类或带有const性质的类的时候,返回值的命名为:?A/?B+V+类名+@@(不带加号)。当函数返回值为某个类的指针/引用或者带有const性质的类的指针/引用的时候,返回值的命名为:PA/AA或者PB/AB+V+类名+@@(不带加号);
7、函数参数为某个类的时候,并且该参数所使用的类曾经出现过的话(也就是当前要导出的类、与函数返回值所使用的类相同或者与前一个参数使用的类相同的类),则该参数类型格式为:V+1+@(不带加号)。如果该参数所使用的类不是当前要导出的类的话,则该参数类型格式为:V+类名+@@(不带加号)。函数参数为某个类的指针/引用或者带有const性质指针/引用的时候,则该参数类型格式是在上述格式的基础上在V前面加上代表指针/引用类型或者带有const性质指针/引用类型的标识符(PA/AA或PB/AB);
8、参数表后以@Z标识整个名字的结束,如果该函数无参数,则以Z标识结束。
当函数使用stdcall调用约定时,编译器所做工作的规则同上面的cdecl调用约定,只是参数表的开始标识由上面的@@YA变为@@YG
当函数使用fastcall调用约定时,编译器所做工作的规则同上面的cdecl调用约定,只是参数表的开始标识由上面的@@YA变为@@YI
4、C++编译导出数据时名称修饰
对于导出的数据,仅使用__cdecl调用约定。在C++编译器对C++类进行名称修饰的时候,编译器进行以下工作:

1.以?标识数据的开始,后跟数据名;
2.数据名后面以@@3标识开始,后跟数据类型;
3.当数据类型与C++类无关的时候,数据类型以下列代号表示:
B:const
D:char
E:unsigned char
F:short
G:unsigned short
H:int
I:unsigned int
J:long
K:unsigned long
M:float
N:double
_N:bool
PA:指针(*,后面的代号表明指针类型,如果相同类型的指针连续出现,以0
代替,一个0代表一次重复)
PB:const指针
AA:引用(&)
AB:const引用
U:类或结构体
V:Interface(接口)
W4:enum
X:void

4.如果数据类型是某个类的时候,数据类型的命名为:V+类名+@@(不带加号)。当数据类型为当前类的指针/引用或者带有const性质的当前类的指针/引用的时候,数据类型的命名为:PA/AA或PB/AB+V+类名+@@(不带加号);
5.最后,如果数据类型是const性质,则修饰名以B结尾。如果数据类型是非const性质,则修饰名以A结尾。

赞(0) 打赏
取消

感谢您的支持,我会继续努力的!

扫码支持
扫码打赏,您说多少就多少

打开支付宝扫一扫,即可进行扫码打赏哦

分享从这里开始,精彩与您同在

评论

    暂无评论...