cdecl、stdcall、fastcall 与 pascal 浅析

短命女 2023-06-07 08:05 20阅读 0赞

*  X86调用约定 calling convention：[https://www.cnblogs.com/shangdawei/p/3323252.html][https_www.cnblogs.com_shangdawei_p_3323252.html]
 *  \_\_cdecl、\_\_stdcall、\_\_fastcall 与 \_\_pascal 浅析：[https://www.cnblogs.com/yenyuloong/p/9626658.html][https_www.cnblogs.com_yenyuloong_p_9626658.html]
 *  王爽 汇编语言第三版 第9章 转移指令的原理：[https://blog.csdn.net/freeking101/article/details/100581181][https_blog.csdn.net_freeking101_article_details_100581181]
 *  调用约定(Calling Conventions) (\_\_cdecl、\_\_stdcall、\_\_fastcall) C++函数名修饰 ( Name Mangling )：[http://www.3scard.com/index.php?m=blog&f=view&id=10][http_www.3scard.com_index.php_m_blog_f_view_id_10]
 *  深入体会\_\_cdecl与\_\_stdcall：[https://www.cnblogs.com/sober/archive/2009/09/01/1558178.html][https_www.cnblogs.com_sober_archive_2009_09_01_1558178.html]
 *  \_\_stdcall 详解：[https://www.cnblogs.com/songfeixiang/p/3733661.html][https_www.cnblogs.com_songfeixiang_p_3733661.html]
 *  用od分析\_cdecl和\_stdcall调用惯例的差异：[https://blog.csdn.net/tch3430493902/article/details/101366850][https_blog.csdn.net_tch3430493902_article_details_101366850]
 *  X86调用约定：[https://zh.wikipedia.org/wiki/X86调用约定][https_zh.wikipedia.org_wiki_X86]

在C语言中，假设我们有这样的一个函数：int function(int a,int b)；调用时只要用result = function(1,2)这样的方式就可以使用这个函数。但是，当高级语言被编译成计算机可以识别的机器码时，有一个问题就凸现出来：在CPU中，计算机没有办法知道一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数。也就是说，计算机不知道怎么给这个函数传递参数，传递参数的工作必须由函数调用者和函数本身来协调。为此，计算机提供了一种被称为栈的数据结构来支持参数传递。  
        栈是一种先进后出的数据结构，栈有一个存储区、一个栈顶指针。栈顶指针指向堆栈中第一个可用的数据项（被称为栈顶）。用户可以在栈顶上方向栈中加入数据，这个操作被称为压栈(Push)，压栈以后，栈顶自动变成新加入数据项的位置，栈顶指针也随之修改。用户也可以从堆栈中取走栈顶，称为弹出栈(pop)，弹出栈后，栈顶下的一个元素变成栈顶，栈顶指针随之修改。函数调用时，调用者依次把参数压栈，然后调用函数，函数被调用以后，在堆栈中取得数据，并进行计算。函数计算结束以后，或者调用者、或者函数本身修改栈，使堆栈恢复原装。  
        **在参数传递中，有两个很重要的问题必须得到明确说明：当参数个数多于一个时，按照什么顺序把参数压入堆栈函数调用后，由谁来把堆栈恢复原装。在高级语言中，通过函数调用约定来说明这两个问题。**常见的调用约定有：\_\_stdcall，\_\_cdecl，\_\_fastcall，\_\_thiscall，naked call

## extern "C" 的含义 和 \_\_stdcall/\_\_cdecl的区别 ##

extern "C" 和 \_\_stdcall、\_\_cdecl 这两个概念都是C和C++语言混用时需要关注的。extern "C"是代码段的修饰， 既可以单独对函数进行修饰也可以放在代码片段前对整段代码进行修饰；是告知编译器接下来的代码中所有的函数名要以C语言的方式进行解析；\_stdcall和\_cdecl则是对函数名进行修饰，告知编译器函数名应该按何种方式进行解析。

**为什么要加extern C**

工程中经常会遇到C和C++混合编程的情况，有时是C++的工程中需要使用C语言编写的库，有时是C的工程需要使用C++；但如果不加任何修饰，直接调用的话，就会遇到链接问题，提示找不到函数名称。  
　　这是由于C++在编译时候，会将函数名做一些修饰，在函数名前加上函数名的长度，在函数名后面加上参数类型。链接的时候也使用相同的策略。C++这么做是由于C++语言支持函数重载，在函数名相同参数不同的几个函数也可以共存。C语言不支持重载，所以编译和链接时对函数名不会加修饰。加extern ”C“就是为了让编译器以C语言的函数名处理方式来编译。

**使用场景主要有两种：**

**1.C++ 的模块调用 C语言写的库**

C语言 test.h、test.c 创建的动态库libtest.so

\#\#\#\# test.h文件如下

#include "stdio.h"
    
    void test_add(int a, int b);

\#\#\#\# test.c文件如下

#include "test.h"
    
    void test_add(int a, int b)
    {
        int num = a + b;
        printf("%d + %d = %d\n", a, b, num);
    }

\#\#\#\# 编译命令

gcc test.c -fPIC -shared -o libtest.so

\#\#\#\# C++ 的文件 caller\_cplusplus.cpp 调用

#ifdef __cplusplus
    extern "C"
    {
    #endif
    #ifdef __cplusplus
    #include "test.h"
    }
    #endif
    int main()
    {
        test_add(3, 4);
        return 0;
    }

\#\#\#\# 编译命令

g++ -o callerCpp caller_cplusplus.cpp -L. -ltest

**2. C++头文件声明接口函数 **

在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

//C++头文件 cppExample.h

#ifndef CPP_EXAMPLE_H
    #define CPP_EXAMPLE_H
    
    extern "C" int add( int x, int y );
    
    #endif

//C++实现文件 cppExample.cpp

#include "cppExample.h"
    
    int add( int x, int y )
    {
        return x + y;
    }

/\* C实现文件 cFile.c\*/  
/\* 这样会编译出错：\#include "cExample.h" \*/

extern int add( int x, int y );
    
    int main( int argc, char* argv[] )
    {
        add( 2, 3 );
        return 0;
    }

上面介绍的是extern "C"的含义和使用方法，主要是跨C和C++的库调用时需要注意的地方。

> **CRT链接选项（C运行时库的链接选择）**：一个原则，调用者和库的CRT链接选项要相同，尽量都使用/MD选项 （多线程动态链接）。

\_\_cdecl/\_\_stdcall 是规定了函数名应该如何修饰，以及参数压栈方式，栈由谁清理

**函数名修饰规则：**

*  **\_\_stdcall ：**约定在输出函数名前加上一个下划线前缀，后面加上一个“@”符号和其参数的字节数，格式为\_functionname@number（number即参数栈长度）
 *  **\_\_cdecl ：**约定仅在输出函数名前加上一个下划线前缀，格式为\_functionname

**参数栈的管理：**两种方式定义的参数传递方式都是从右至左压，区别在于清理栈的角色不同。

*  **\_\_stdcall：**是被调用函数清理（即函数自己清理）
 *  **\_\_cdecl：**是调用者清理；

所以\_\_stdcall修饰函数名时加上参数栈的大小可以让函数自己进行栈的清理；对于可变参数的函数，无法在函数定义时确认参数长度，只能让调用者去清理参数栈，所以对于可变参数的函数应该用\_\_cdecl修饰（可变参数的函数exp：printf）

## **调用约定（或者 调用协议） \_\_cdecl、\_\_stdcall 和 \_\_fastcall 的区别** ##

[https://blog.csdn.net/a3192048/article/details/82084374][https_blog.csdn.net_a3192048_article_details_82084374]

**\_\_stdcall 和 \_\_cdecl 的区别浅析（ C 代码 和 生成对应汇编代码分析 ）**：[https://blog.csdn.net/qinrenzhi/article/details/94403385][https_blog.csdn.net_qinrenzhi_article_details_94403385]

函数的 **调用约定**，顾名思义就是对函数调用的一个约束和规定(规范)，描述了函数参数是怎么传递和由谁清除堆栈的。它决定以下内容：

*  (1) 函数参数的压栈顺序。
 *  (2) 由调用者还是被调用者把参数弹出栈。
 *  (3) 以及产生函数修饰名的方法。

*  **1）  \_\_stdcall 的全称是 standard call。是 C++ 的标准调用方式**。函数所有参数从右到左依次入栈，如果是调用类成员的话，最后一个入栈的是this[指针][Link 1]。函数返回时使用 retn X 指令，其中 X 为调整堆栈的字节数。这些[堆栈][Link 2]中的参数由被调用的函数在返回后清除，使用的 指令是 retn X，X 表示参数占用的字节数，CPU在 ret 之后自动弹出 X 个字节的堆栈空间，称为**自动清栈，这种方式 叫做自动清栈 ( **被调用的函数在返回前清理传送参数的内存栈 **)**。**即 函数在编译的时候就必须确定参数个数，并且调用者必须严格的控制参数的生成，不能多，不能少，否则返回后会出错**。
 *  **2）  \_\_cdecl 的全称是 C Declaration**（declaration，声明）**，即 C语言默认的函数调用方式**。函数参数的入栈顺序为从右到左依次入栈。函数返回时作用 ret 指令。被调用的函数支持 **可变参数**，即 [被调用函数][Link 3]不会要求调用者传递多少参数，调用者传递过多或者过少的参数，甚至完全不同的参数都不会产生编译阶段的错误。**调用者根据调用时传入参数的个数，手动平衡堆栈，即 这些参数由调用者清除，称为手动清栈。**
 *  3）  \_\_fastcall 是[编译器][Link 4]指定的快速调用方式。由于大多数的函数参数个数很少，使用[堆栈][Link 2]传递比较费时。因此 \_\_fastcall 通常规定将前两个（或若干个）参数由[寄存器][Link 5]传递，其余参数还是通过堆栈传递。不同编译器编译的程序规定的寄存器不同。返回方式和 \_\_stdcall 相当。（实际上，它用 ECX 和 EDX 传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈）。
 *  4）  \_\_thiscall 是为了解决类成员调用中 this[指针][Link 1]传递而规定的。\_thiscall 要求把 this 指针放在特定寄存器中，该寄存器由编译器决定。VC 使用 ecx，Borland 的 C++ 编译器使用 eax。返回方式 和 \_\_stdcall 相当。
 *  5）  nakedcall 采用 1 - 4  的调用约定时，如果必要的话，进入函数时[编译器][Link 4]会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。naked call不产生这样的代码。naked call不是类型修饰符，故必须和\_declspec 共同使用。

**注意 **：\_\_fastcall 和  \_\_thiscall  涉及的寄存器由[编译器][Link 4]决定，因此不能用作跨编译器的接口。所以 Windows 上的 COM 对象接口都定义为 \_\_stdcall 调用方式。

用 \_\_stdcall 定义的函数在结束时由该函数自己负责把参数弹出堆栈，windows API 都是采用 \_\_stdcall 压栈/调用方式。  
用 \_\_cdecl 定义的函数在结束时不管参数，而由调用函数负责把参数弹出堆栈，c 的库函数都是采用 \_\_cdecl 压栈/调用方式，在c 程序中定义的函数默认都是 \_\_cdecl 方式。

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

**VC++ 对函数的省缺声明是  "\_\_cedcl" ，将只能被 C/C++ 调用 。**

**示例代码：**

#include<stdio.h>
 #include<iostream>
 
 // 使用 __stdcall
 void __stdcall output_1(int x, int y)
 {
 	printf("%d %d", x, y);
 }
 
 
 // VC++对函数的省缺声明是 "__cedcl", 将只能被C/C++调用. 
 void output_2(int x, int y)
 {
 	printf("%d %d", x, y);
 }
 
 
 void test_1()
 {
 	__asm
 	{
 		mov eax, 10
 		mov ebx, 20
 		push eax
 		push ebx
 		call output_1
 	}
 	printf("\n");
 }
 
 void test_2()
 {
 	__asm
 	{
 		mov eax, 10
 		mov ebx, 20
 		push eax
 		push ebx
 		call output_2
 		add esp, 8; 调用者负责平衡堆栈
 	}
 	printf("\n");
 }
 
 
 int main(int argc, char* argv[])
 {
 	test_1();
 	test_2();
 	return 0;
 }

运行结果：

![20191013231239363.png][]

示例代码：

#define _AFXDLL // 如果不定义这，需要改成单线程版本
 
 #include <afx.h> // CString 头文件
 #include <afxwin.h> // AfxMessageBox的头文件
 
 TCHAR appname[] = TEXT("API Test");
 
 void main()
 {
 int a = 5; //变量a 
 
 _asm
 {
 mov eax, a; // 将变量a的值放入寄存器eax 
 add eax, eax; // 相当于a=a+a 
 mov a, eax; // 将 a+a 的结果赋给a 
 }
 
 //查看结果，注意a的初值为5 
 CString rst;
 rst.Format(_T("a=%d"), a);
 AfxMessageBox(rst);
 }

### 使用规则 和 设置方法 ###

1、**修饰名 **( Decoration name )，**即编译之后的函数名。**"C" 或者 "C++" 函数 在 内部（编译和链接）通过 修饰名 识别。修饰名是编译器 在 编译 函数定义 或者 原型 时生成的 字符串。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出  "C++" 重载函数、构造函数、析构函数，又如在汇编代码里调用 "C" 或 "C++" 函数等。修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。

2、**函数名修饰约定** 随 **编译种类** 和 **调用约定** 的不同而不同，下面分别说明。

**C语言编译器 的 函数名修饰约定规则：**

__stdcall 调用约定在输出函数名前加上一个下划线前缀，后面加上一个 "@" 符号和其参数的字节数，
             格式为: _functionname@number，
             例如: function(int a, int b)，其修饰名为：_function@8
    		 
    __cdecl 调用约定仅在输出函数名前加上一个下划线前缀，
            格式为: _functionname。
    		
    __fastcall 调用约定在输出函数名前加上一个 "@" 符号，后面也是一个 "@" 符号 和 其参数的字节数，
            格式为: @functionname@number。

**C++语言编译器 的 函数名修饰约定规则：  **

__stdcall调用约定：    
            1、以 "?" 标识函数名的开始，后跟函数名；    
            2、函数名后面以“@@YG”标识参数表的开始，后跟参数表；    
            3、参数表以代号表示：    
                    X--void，    
                    D--char，    
                    E--unsigned char，    
                    F--short，    
                    H--int，    
                    I--unsigned int，    
                    J--long，    
                    K--unsigned long，    
                    M--float，    
                    N--double，    
                    _N--bool，    
                    ....    
                    PA--表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以 "0" 代替，一个 "0" 代表一次重复；    
            4、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前；    
            5、参数表后以 "@Z" 标识整个名字的结束，如果该函数无参数，则以 "Z" 标识结束。    
     
    其格式为 ?functionname@@YG*****@Z 或 ?functionname@@YG*XZ ，
    例如    
            int  Test1(char *var1, unsigned long)  -----  ?Test1@@YGHPADK@Z    
            void  Test2()                          -----  ?Test2@@YGXXZ
    
    
    
    __cdecl调用约定：    
            规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的“@@YG”变为“@@YA”。    
     
    
    __fastcall调用约定：    
            规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的“@@YG”变为“@@YI”。

### \_\_stdcall 和 \_\_cdecl 相同点 和 不同点 ###

**相同点：**参数入栈顺序相同：从右到左

**不同点：**

1.  堆栈平衡方式不同：\_\_stdcall 自动清栈，\_\_cdecl 手动清栈。
2.  返回指令不同：\_stdcall 使用 retn x， \_\_cdecl 使用 ret
3.  编译后函数的修饰名不同： 假设有函数 int foo(int a, int b)，采用\_\_stdcall 编译后的函数名为 \_foo@8，而采用\_\_cdecl 编译后的函数名为\_foo。

支持可变参数的函数必须定义为\_\_cdecl，如：

int printf(char \*fmt, ...);

在 windef.h 中对 \_\_stdcall 和 \_\_cdecl 的定义

#define CALLBACK   __stdcall
    #define WINAPI    __stdcall
    #define WINAPIV   __cdecl
    #define APIENTRY   WINAPI
    #define APIPRIVATE  __stdcall
    #define PASCAL    __stdcall
    #define cdecl _cdecl
    #ifndef CDECL
    #define CDECL _cdecl
    #endif

特别说明

*  1.  在默认情况下，采用 \_\_cdecl 方式，因此可以省略.
 *  2.  WINAPI 一般用于修饰动态链接库中导出函数
 *  3.  CALLBACK 仅用于修饰回调函数

便于更好理解, 看下面例子（函数调用的过程以汇编代码表示）：

//函数定义     
    void cdecl fun1(int x,int y); 
    void stdcall fun2(int x,int y); 
    void pascal fun3(int x,int y);   
    
    
    // 对应调用函数时的汇编代码
    **************************************** 
    void cdecl fun1(int x,int y); 
    fun1(x,y); 
    调用 fun1 的汇编代码 
    push y 
    push x 
    call fun1 
    add sp,sizeof(x)+sizeof(y) ；跳过参数区（x，y） 
    fun1 的汇编代码： 
    fun1 proc 
    push bp 
    mov bp,sp 
    …… 
    … 
    pop bp 
    ret ；返回，但不跳过参数区 
    fun1 endp 
    
    **************************************** 
    void stdcall fun2(int x,int y); 
    fun2(x,y); 
    调用 fun2 的汇编代码 
    push y 
    push x 
    call fun2 
    fun2 的汇编代码： 
    fun2 proc 
    push bp 
    mov bp,sp 
    …… 
    … 
    pop bp 
    ret sizeof(x)+sizeof(y) ；返回并跳过参数区（x，y） 
    fun2 endp 
    
    ***************************************** 
    void pascal fun3(int x,int y); 
    fun3(x,y); 
    调用 fun3 的汇编代码 
    push x 
    push y 
    call fun3 
    fun3 的汇编代码： 
    fun3 proc 
    push bp 
    mov bp,sp 
    …… 
    … 
    pop bp 
    ret sizeof(x)+sizeof(y) ；返回并跳过参数区（x，y） 
    fun3 endp

### \_stdcall 与 \_cdecl 两者之间的区别： ###

WINDOWS 的函数调用时需要用到栈（STACK，一种先入后出的存储结构）。当函数调用完成后，栈需要清除，这里就是问题的关键，如何清除？？  
      如果我们的函数使用了 \_cdecl，那么栈的清除工作是由调用者，用 COM 的术语来讲就是客户来完成的。这样带来了一个棘手的问题，不同的编译器产生栈的方式不尽相同，那么调用者能否正常的完成清除工作呢？答案是不能。  
      如果使用 \_\_stdcall，上面的问题就解决了，函数自己解决清除工作。**所以，在跨（开发）平台的调用中，我们都使用\_\_stdcall（ 虽然有时是以 WINAPI 的样子出现 ）。**  
      那么为什么还需要\_cdecl 呢 ？当我们遇到这样的函数如 fprintf() 它的参数是可变的，不定长的，被调用者事先无法知道参数的长度，事后的清除工作也无法正常的进行，因此，这种情况我们只能使用\_cdecl。  
      到这里我们有一个结论：**如果程序中没有涉及可变参数，最好使用\_\_stdcall 关键字**

### cdecl ###

cdecl( C declaration，即C声明 ) 是源起C语言的一种调用约定，也是C语言的事实上的标准。在x86架构上，其内容包括：

1.  函数实参在线程栈上按照从右至左的顺序依次压栈。
2.  函数结果保存在寄存器EAX/AX/AL中
3.  浮点型结果存放在寄存器ST0中
4.  编译后的函数名前缀以一个下划线字符
5.  调用者负责从线程栈中弹出实参（即清栈）
6.  8比特或者16比特长的整形实参提升为32比特长。
7.  受到函数调用影响的寄存器（volatile registers）：EAX, ECX, EDX, ST0 - ST7, ES, GS
8.  不受函数调用影响的寄存器： EBX, EBP, ESP, EDI, ESI, CS, DS
9.  RET 指令从函数被调用者返回到调用者（实质上是读取寄存器EBP所指的线程栈之处保存的函数返回地址并加载到IP寄存器）

Visual C++ 规定 函数返回值如果是POD值且长度如果不超过32比特，用寄存器EAX传递；长度在33-64比特范围内，用寄存器EAX:EDX传递；长度超过64比特或者非POD值，则调用者为函数返回值预先分配一个空间，把该空间的地址作为隐式参数传递给被调函数。

GCC的函数返回值都是由调用者分配空间，并把该空间的地址作为隐式参数传递给被调函数，而不使用寄存器EAX。GCC自4.5版本开始，调用函数时，堆栈上的数据必须以16B对齐(之前的版本只需要4B对齐即可)。

考虑下面的C代码片段：

int callee(int, int, int);
      int caller(void)
      {
          register int ret;
          
          ret = callee(1, 2, 3);
          ret += 5;
          return ret;
      }

在x86上， 会产生如下汇编代码(AT&T 语法)：

.globl  caller
      caller:
            pushl   %ebp
            movl    %esp,%ebp
            pushl   $3
            pushl   $2
            pushl   $1
            call    callee
            addl    $12,%esp
            addl    $5,%eax
            leave
            ret

在函数返回后，调用的函数清理了堆栈。 在cdecl的理解上存在一些不同，尤其是在如何返回值的问题上。结果，x86程序经过不同OS平台的不同编译器编译后，会有不兼容的情况，即使它们使用的都是“cdecl”规则并且不会使用系统调用。某些编译器返回简单的数据结构，长度大致占用两个寄存器，放在寄存器对EAX:EDX中；大点的结构和类对象需要异常处理器的一些特殊处理(如一个定义的构造函数，析构函数或赋值)，存放在内存上。为了放置在内存上，调用者需要分配一些内存，并且让一个指针指向这块内存，这个指针就作为隐藏的第一个参数；被调用者使用这块内存并返回指针----返回时弹出隐藏的指针。 在Linux/GCC，浮点数值通过x87伪栈被推入堆栈。像这样：

sub esp, 8      ; 给double值一点空间
            fld [ebp + x]   ; 加载double值到浮点堆栈上
            fstp [esp]      ; 推入堆栈
            call funct
            add esp, 8

使用这种方法确保能以正确的格式推入堆栈。 cdecl调用约定通常作为x86 C编译器的默认调用规则，许多编译器也提供了自动切换调用约定的选项。如果需要手动指定调用规则为cdecl，编译器可能会支持如下语法：

return_type _cdecl funct();

其中\_cdecl修饰符需要在函数原型中给出，在函数声明中会覆盖掉其他的设置。

## **call 指令与 retn 指令** ##

首先我们得了解 CALL 和 RETN 指令的作用，才能更好地理解调用规则，这也是先决条件。

实际上，CALL 指令就是先将下一条指令的 EIP 压栈，然后 JMP 跳转到对应的函数的首地址，当执行完函数体后，通过 RETN 指令从堆栈中弹出 EIP，程序就可以继续执行 CALL 的下一条指令。

## **\_\_cdecl 与 \_\_stdcall 调用规则** ##

C/C++ 中不同的函数调用规则会生成不同的机器代码，产生不同的微观效果，接下来让我们一起来浅析四种调用规则的原理和它们各自的异同。首先我们通过一段 C 语言代码来引导我们的浅析过程。

这里我们编写了三个函数，它们的功能都是返回两个参数的相加结果，只是每个函数都有不一样的调用规则。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70][]

我们使用 printf 函数主要是为了在 OllyDBG 中能够快速下断点，以确定后边调用三个函数的位置，便于分析。在这里我给每个函数都用了内联的 NOP 指令来分隔开，图中也用红框标明，这样可以便于区分每个函数的调用过程。通过一些简单的步骤，我们用 OllyDBG 查看了编译后代码的“真面目”。代码中有 4 个 CALL，第一个是 printf，我们不关心这个。后面三个分别是具有 \_\_cdecl，\_\_stdcall，\_\_fastcall 调用规则的函数 CALL（这里我已经做了注释）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1][]

在这里为了循序渐进，我们先介绍 \_\_cdecl 与 \_\_stdcall 调用规则，后面我们会接着浅析 \_\_fastcall 调用规则。

首先，我们得明白一个教条（其实也是自己概括的），那就是 —— 调用规则的区别产生其实就是由于调用者与被调用者之间的“责任分配”问题。

代码段中的第 2 个就是 \_\_cdecl 调用规则的 CALL。**\_\_cdecl 是 C/C++、MFC 默认的调用规则**。我们可以看到，在执行 CALL 之前，程序会将参数按照从右到左的方式压栈，这里是两个整型参数，每压栈一个 ESP 都会减 4，这样下来 ESP 会减少 8，然后 CALL 这个函数。常规地，我们可以看到，这个 CALL 里面参数的处理和通常情况下一致，先将 EBP 压栈保存现场，然后使 EBP 重合于 ESP，再通过 EBP + 偏移地址来取得两个参数值，赋值再累加到 EAX 中，EAX 将作为返回值给调用者使用，还原 EBP 现场，调用 RETN 返回到调用者。最后，使得 ESP 加 8。哎！这刚好和开头对称嘛！为了堆栈平衡，ESP 最终又被拉回到了 CALL 之前的位置。我们暂且可以小结一下，实际上 **在 \_\_cdecl 调用规则中，需要调用者来负责清栈操作（由调用者将 ESP 拉高以维持堆栈平衡）。**

![20191013181129556.png][]

代码段中的第 3 个是 \_\_stdcall 调用规则的 CALL。\_\_stdcall 调用规则在 Win32 API 函数中用的比较多。跟 \_\_cdecl 一样，在执行 CALL 之前，程序会先将参数从右到左依次压栈，我们跟进 CALL 里面，可以看到以下的反汇编代码，我们很容易发现，除了最后一条指令，其他的指令与 \_\_cdecl 调用规则是基本一样的。最后一条指令是“RETN 0x8”，这是什么意思呢？实际上呢，就相当于先执行“ADD ESP, 0x8”再执行“POP EIP” 。换言之，就是将 ESP 加 8，然后正常 RETN 返回到调用者。

![20191013181157975.png][]

我们不难发现**，\_\_stdcall 调用规则使得被调用者来执行清栈操作（由被调用者函数自身将 ESP 拉高以维持堆栈平衡）**，这也是 \_\_stdcall 与 \_\_cdecl 调用规则的最根本的区别。

\_\_cdecl 偏向于把责任分配给调用者，动脑筋想想，我们的程序在 CALL \_\_cdecl 调用规则的函数之前，把参数从右到左依次压栈，CALL 返回后，剩下的清栈操作都交给调用者处理，调用者负责拉高 ESP。再回来想想 \_\_stdcall，在 CALL 中将调用者的 EBP 压栈以保存现场，然后使 EBP 对齐于 ESP，然后通过 EBP + 偏移地址取得参数，并且经过加法得到 EAX 返回值，从堆栈弹出 EBP 恢复现场，但是最后不一样的地方，程序将执行 “RETN 0x8” 将 ESP 拉回之前的 ESP + 8 的位置，换言之，被调用者将负责清栈操作。这就是之前所谓的“责任分配”的区别。

## **\_\_fastcall 调用规则** ##

不难揣测 fastcall 的英文意思貌似是“快速调用”，这一点与它的调用规则息息相关，它的快速是有原因的，让我们继续来看看之前那张反汇编的截图，代码段中的第 4 个就是 \_\_fastcall 调用规则的 CALL。进 CALL 前，出乎意料地，程序将两个参数从右到左分别传给了 EDX，ECX 寄存器，讲到这里，学过计算机系统相关知识的人很容易理解为什么这叫“快速调用”了，寄存器比内存快很多很多倍，可以认为传参给寄存器，要比在内存中更快得多，效率更高。

![20191013181446764.png][]

由于参数是直接传递给了寄存器，堆栈并未发生改变，在 CALL 中，EBP 压栈，EBP 和 ESP 对齐之后，ESP 减 8，这个操作有点像对局部变量分配堆栈空间（**[这里][Link 6]**有我之前一篇博客，对局部变量的存放规则做了浅析），然后程序将 EDX，ECX 分别赋值给 EBP – 8 与 EBP – 4 这两个地址，这个过程相当于用寄存器给局部变量赋值，接下来运算结果将保存在 EAX 中，ESP 归位，EBP 恢复现场，最后 RETN 返回调用者领空。

本例只传送了两个整数型参数。其实呢，对于 \_\_fastcall 调用规则，左边开始的两个不大于4字节（int）的参数分别放在ECX和EDX寄存器，其余的参数仍旧自右向左压栈传送。并且，**\_\_fastcall 调用规则使得被调用者负责清理栈的操作（由被调用者函数自身将 ESP 拉高以维持堆栈平衡）**，这一点和 \_\_stdcall 一样。

## **\_\_pascal 调用规则** ##

\_\_pascal 是用于 Pascal / Delphi 编程语言的调用规则，C/C++ 中也可以使用这种调用规则。简单地说，\_\_pascal 调用规则与 \_\_stdcall 不同的地方就是压栈顺序恰恰相反，前面讲到的三种调用规则的压栈顺序都是从右到左依次入栈**，\_\_pascal 则是从左到右依次入栈。**并且，**被调用者（函数自身）将自行完成清栈操作**，这和 \_\_stdcall，\_\_fastcall 一样。由于比较简单，我就没有做出示例。

## **小结** ##

做个表格来小结一下，很直观就能看出这四种调用规则的异同：

<table style="width:643px;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 调用规则 </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 入栈顺序 </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 清栈责任 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> __cdecl </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 从右到左 </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 调用者 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> __stdcall </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 从右到左 </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 被调用者 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> __fastcall </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 从右到左（先 EDX、ECX，再到堆栈） </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 被调用者 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> __pascal </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 从左到右 </td> 
 <td style="border-color:#c0c0c0;vertical-align:top;"> 被调用者 </td> 
 </tr> 
 </tbody> 
</table>

# 通过分析反汇编还原 C 语言 if…else 结构 #

From：[https://www.cnblogs.com/yenyuloong/p/9629749.html][https_www.cnblogs.com_yenyuloong_p_9629749.html]

让我们从反汇编的角度去分析并还原 C 语言的 if … else 结构，首先我们不看源代码，我们用 OllyDBG 载入 PE 文件，定位到 main 函数领空，如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2][]

以下的 C 语言代码段。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3][]

# 函数调用方式 \_\_stdcall 与 \_\_cdecl #

在程序执行过程中发生函数调用时，系统会作如下操作：首先把参数压入堆栈，然后把ip寄存器的值压入堆栈（作为函数的返回地址），然后把堆栈指针（ESP）的值赋给EBP并把EBP压入堆栈，最后为本地变量留出一定空间，即把ESP减去一定的值。

1.   用 \_\_stdcall 定义的函数在结束时由该函数自己负责把参数弹出堆栈，windows API都是采用\_\_stdcall压栈/调用方式。
2.   用 \_\_cdecl 定义的函数在结束时不管参数，而由调用函数负责把参数弹出堆栈，C的库函数都是采用 \_\_cdecl 压栈/调用方式，在C 程序中定义的函数默认都是 \_\_cdecl 方式。

举个例子说明一下：  
在 VC 中建一个 Win32 Console Application的空项目，输入以下代码：

#include<stdio.h>
 
 int test(int a, int b)
 {
 	return a + b;
 }
 
 void main(int argc, char** argv)
 {
 	test(10, 20);
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4][]

在 main 函数的下一行设置断点，编译，调试。按 Alt + F9、 A 切换到汇编窗口，可以看到

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5][]

源代码对应汇编代码：

3   int test(int a, int b)       //test函数的定义
    4   {
        007416E0  push        ebp        //ebp入栈
        007416E1  mov         ebp,esp    //esp-->ebp
        007416E3  sub         esp,0C0h  
        007416E9  push        ebx  
        007416EA  push        esi  
        007416EB  push        edi  
        007416EC  lea         edi,[ebp-0C0h]  
        007416F2  mov         ecx,30h  
        007416F7  mov         eax,0CCCCCCCCh  
        007416FC  rep stos    dword ptr es:[edi]  
        007416FE  mov         ecx,offset _8A1C4DC9_C++_console@cpp (074C003h)  
        00741703  call        @__CheckForDebuggerJustMyCode@4 (07411FEh)  
    5       return a + b;
        00741708  mov         eax,dword ptr [a]  
        0074170B  add         eax,dword ptr [b]  
    6   }
        0074170E  pop         edi  
        0074170F  pop         esi  
        00741710  pop         ebx  
        00741711  add         esp,0C0h  
        00741717  cmp         ebp,esp  
        00741719  call        __RTC_CheckEsp (0741208h)  
        0074171E  mov         esp,ebp  
        00741720  pop         ebp  
        00741721  ret 
        ......
        ......
    
    7
    8   void main(int argc, char** argv)
    9   {
        00741750  push        ebp  
        00741751  mov         ebp,esp  
        00741753  sub         esp,0C0h  
        00741759  push        ebx  
        0074175A  push        esi  
        0074175B  push        edi  
        0074175C  lea         edi,[ebp-0C0h]  
        00741762  mov         ecx,30h  
        00741767  mov         eax,0CCCCCCCCh  
        0074176C  rep stos    dword ptr es:[edi]  
        0074176E  mov         ecx,offset _8A1C4DC9_C++_console@cpp (074C003h)  
        00741773  call        @__CheckForDebuggerJustMyCode@4 (07411FEh)  
    10    	test(10, 20);
        00741778  push        14h                //将参数压入堆栈，14h转换成十进制是20
        0074177A  push        0Ah                //将参数压入堆栈，0Ah转换成十进制是10
        0074177C  call        test (0741230h)    //调用test函数
        00741781  add         esp,8              //恢复堆栈，这是__cdecl的工作方式
    11  }
        00741784  xor         eax,eax  
        00741786  pop         edi  
        00741787  pop         esi  
        00741788  pop         ebx  
        00741789  add         esp,0C0h  
        0074178F  cmp         ebp,esp  
        00741791  call        __RTC_CheckEsp (0741208h)  
        00741796  mov         esp,ebp  
        00741798  pop         ebp  
        00741799  ret

现在把上面的 C 语言代码第一行改为：int \_\_stdcall test(int a,int b)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6][]

对应汇编代码：

int __stdcall test(int a, int b)
    {
    00A716E0  push        ebp  
    00A716E1  mov         ebp,esp  
    00A716E3  sub         esp,0C0h  
    00A716E9  push        ebx  
    00A716EA  push        esi  
    00A716EB  push        edi  
    00A716EC  lea         edi,[ebp-0C0h]  
    00A716F2  mov         ecx,30h  
    00A716F7  mov         eax,0CCCCCCCCh  
    00A716FC  rep stos    dword ptr es:[edi]  
    00A716FE  mov         ecx,offset _8A1C4DC9_C++_console@cpp (0A7C003h)  
    00A71703  call        @__CheckForDebuggerJustMyCode@4 (0A711FEh)  
    	return a + b;
    00A71708  mov         eax,dword ptr [a]  
    00A7170B  add         eax,dword ptr [b]  
    }
    00A7170E  pop         edi  
    00A7170F  pop         esi  
    00A71710  pop         ebx  
    00A71711  add         esp,0C0h  
    00A71717  cmp         ebp,esp  
    00A71719  call        __RTC_CheckEsp (0A71208h)  
    00A7171E  mov         esp,ebp  
    00A71720  pop         ebp  
    00A71721  ret         8        //与__cdecl的不同之处，由被调用函数自己恢复堆栈
    
    
    
    void main(int argc, char** argv)
    {
    00A71750  push        ebp  
    00A71751  mov         ebp,esp  
    00A71753  sub         esp,0C0h  
    00A71759  push        ebx  
    00A7175A  push        esi  
    00A7175B  push        edi  
    00A7175C  lea         edi,[ebp-0C0h]  
    00A71762  mov         ecx,30h  
    00A71767  mov         eax,0CCCCCCCCh  
    00A7176C  rep stos    dword ptr es:[edi]  
    00A7176E  mov         ecx,offset _8A1C4DC9_C++_console@cpp (0A7C003h)  
    00A71773  call        @__CheckForDebuggerJustMyCode@4 (0A711FEh)  
    	test(10, 20);
    00A71778  push        14h  
    00A7177A  push        0Ah  
    00A7177C  call        test (0A7137Ah)  
                                           //调用过程不负责恢复堆栈
    }
    00A71781  xor         eax,eax  
    00A71783  pop         edi  
    00A71784  pop         esi  
    00A71785  pop         ebx  
    00A71786  add         esp,0C0h  
    00A7178C  cmp         ebp,esp  
    00A7178E  call        __RTC_CheckEsp (0A71208h)  
    00A71793  mov         esp,ebp  
    00A71795  pop         ebp  
    00A71796  ret

[https_www.cnblogs.com_shangdawei_p_3323252.html]: https://www.cnblogs.com/shangdawei/p/3323252.html
[https_www.cnblogs.com_yenyuloong_p_9626658.html]: https://www.cnblogs.com/yenyuloong/p/9626658.html
[https_blog.csdn.net_freeking101_article_details_100581181]: https://blog.csdn.net/freeking101/article/details/100581181
[http_www.3scard.com_index.php_m_blog_f_view_id_10]: http://www.3scard.com/index.php?m=blog&f=view&id=10
[https_www.cnblogs.com_sober_archive_2009_09_01_1558178.html]: https://www.cnblogs.com/sober/archive/2009/09/01/1558178.html
[https_www.cnblogs.com_songfeixiang_p_3733661.html]: https://www.cnblogs.com/songfeixiang/p/3733661.html
[https_blog.csdn.net_tch3430493902_article_details_101366850]: https://blog.csdn.net/tch3430493902/article/details/101366850
[https_zh.wikipedia.org_wiki_X86]: https://zh.wikipedia.org/wiki/X86%E8%B0%83%E7%94%A8%E7%BA%A6%E5%AE%9A
[https_blog.csdn.net_a3192048_article_details_82084374]: https://blog.csdn.net/a3192048/article/details/82084374
[https_blog.csdn.net_qinrenzhi_article_details_94403385]: https://blog.csdn.net/qinrenzhi/article/details/94403385
[Link 1]: https://baike.baidu.com/item/%E6%8C%87%E9%92%88
[Link 2]: https://baike.baidu.com/item/%E5%A0%86%E6%A0%88
[Link 3]: https://baike.baidu.com/item/%E8%A2%AB%E8%B0%83%E7%94%A8%E5%87%BD%E6%95%B0
[Link 4]: https://baike.baidu.com/item/%E7%BC%96%E8%AF%91%E5%99%A8
[Link 5]: https://baike.baidu.com/item/%E5%AF%84%E5%AD%98%E5%99%A8
[20191013231239363.png]: /images/20230601/1aa0828c7eb342de934e50eb8dccebdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70]: /images/20230601/585384f2819143528e94c4a37932f8a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 1]: /images/20230601/ad266c86b96a474997fc192c75e9cef4.png
[20191013181129556.png]: /images/20230601/31ed05f9b3c74d0db7c73295d27de654.png
[20191013181157975.png]: /images/20230601/2f42e530ec17478e884b3693422ce9d4.png
[20191013181446764.png]: /images/20230601/0a34c663cbb94896bcc5210d01993cf4.png
[Link 6]: https://www.cnblogs.com/yenyuloong/p/9621538.html
[https_www.cnblogs.com_yenyuloong_p_9629749.html]: https://www.cnblogs.com/yenyuloong/p/9629749.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 2]: /images/20230601/c38784ae908149578b06b4fb79dcad7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 3]: /images/20230601/f85d1432ffc14595be97ff8e85fcafad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 4]: /images/20230601/2dd5fc52f8664fc5a9150619bbe63a94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 5]: /images/20230601/215331c7f0174fb9a24639bd0dea3b2a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyZWVraW5nMTAx_size_16_color_FFFFFF_t_70 6]: /images/20230601/06c4014b8c8e4efeaa6883539015eb39.png