tag:彙編,pascal,fastcall,stdcall,thiscall,cdecl,呼叫約定,函式呼叫約定,返回值傳遞方式

摘要：文章講述了幾種主要程式語言中的函式呼叫約定；詳細說明時主要以VC6中的函式呼叫約定為主,闡釋方式主要是以C++程式編譯後得到的彙編程式碼來進行說明;

文章來源於abp論壇中的一篇帖子:http://bbs.allaboutprogram.com/viewtopic.php?t=1245

 我所使用的編譯器和平臺：WindowsXP + 賽揚1G + VC6(主要工具)/Delphi6/C++Builder6;

一：函式呼叫約定; 
    函式呼叫約定是函式呼叫者和被呼叫的函式體之間關於引數傳遞、返回值傳遞、堆疊清除、暫存器使用的一種約定; 
    它是需要二進位制級別相容的強約定,函式呼叫者和函式體如果使用不同的呼叫約定,將可能造成程式執行錯誤,必須把它看作是函式宣告的一部分;

二：常見的函式呼叫約定;

VC6中的函式呼叫約定;

        呼叫約定        堆疊清除    引數傳遞 
        __cdecl         呼叫者      從右到左,通過堆疊傳遞 
        __stdcall       函式體      從右到左,通過堆疊傳遞 
        __fastcall      函式體      從右到左,優先使用暫存器(ECX,EDX),然後使用堆疊 
        thiscall        函式體      this指標預設通過ECX傳遞,其它引數從右到左入棧

__cdecl是C/C++的預設呼叫約定; VC的呼叫約定中並沒有thiscall這個關鍵字,它是類成員函式預設呼叫約定; 
C/C++中的main(或wmain)函式的呼叫約定必須是__cdecl,不允許更改; 
預設呼叫約定一般能夠通過編譯器設定進行更改,如果你的程式碼依賴於呼叫約定,請明確指出需要使用的呼叫約定;

Delphi6中的函式呼叫約定;

        呼叫約定        堆疊清除    引數傳遞 
        register        函式體      從左到右,優先使用暫存器(EAX,EDX,ECX),然後使用堆疊 
        pascal          函式體      從左到右,通過堆疊傳遞 
        cdecl           呼叫者      從右到左,通過堆疊傳遞(與C/C++預設呼叫約定相容) 
        stdcall         函式體      從右到左,通過堆疊傳遞(與VC中的__stdcall相容) 
        safecall        函式體      從右到左,通過堆疊傳遞(同stdcall)

Delphi中的預設呼叫約定是register,它也是我認為最有效率的一種呼叫方式,而cdecl是我認為綜合效率最差的一種呼叫方式; 
VC中的__fastcall呼叫約定一般比register效率稍差一些;

C++Builder6中的函式呼叫約定;

        呼叫約定        堆疊清除    引數傳遞 
        __fastcall      函式體      從左到右,優先使用暫存器(EAX,EDX,ECX),然後使用堆疊 (相容Delphi的register) 
        (register與__fastcall等同) 
        __pascal        函式體      從左到右,通過堆疊傳遞 
        __cdecl         呼叫者      從右到左,通過堆疊傳遞(與C/C++預設呼叫約定相容) 
        __stdcall       函式體      從右到左,通過堆疊傳遞(與VC中的__stdcall相容) 
        __msfastcall    函式體      從右到左,優先使用暫存器(ECX,EDX),然後使用堆疊(相容VC的__fastcall)

常見的函式呼叫約定中,只有cdecl約定需要呼叫者來清除堆疊; 
C/C++中的函式支援引數數目不定的引數列表,比如printf函式;由於函式體不知道呼叫者在堆疊中壓入了多少引數, 
所以函式體不能方便的知道應該怎樣清除堆疊,那麼最好的辦法就是把清除堆疊的責任交給呼叫者; 
這應該就是cdecl呼叫約定存在的原因吧;

VB一般使用的是stdcall呼叫約定;(ps：有更強的保證嗎) 
Windows的API中,一般使用的是stdcall約定;(ps: 有更強的保證嗎) 
建議在不同語言間的呼叫中(如DLL)最好採用stdcall呼叫約定,因為它在語言間相容性支援最好;

三:函式返回值傳遞方式
   其實，返回值的傳遞從處理上也可以想象為函式呼叫的一個out形引數； 函式返回值傳遞方式也是函式呼叫約定的一部分；
   有返回值的函式返回時：一般int、指標等32bit資料值(包括32bit結構)通過eax傳遞，(bool,char通過al傳遞，short通過ax傳遞),特別的__int64等64bit結構(struct) 通過edx,eax兩個暫存器來傳遞(同理：32bit整形在16bit環境中通過dx,ax傳遞); 其他大小的結構(struct)返回時把其地址通過eax返回；(所以返回值型別不是1,2,4,8byte時，效率可能比較差) 
   引數和返回值傳遞中，引用方式的型別可以看作與傳遞指標方式相同； 
   float/double(包括Delphi中的extended)都是通過浮點暫存器st(0)返回；

四：通過VC中的C++例子和產生出的彙編清單來對函式呼叫約定進行說明;

(ps:後面雖然列出了很多彙編,但是我做了很詳細的註釋,我希望那些對彙編感到“恐懼”的人 
也能順利的閱讀; 併為那些想在VC中使用匯編的人提供一些幫助

A: 
測試程式碼：

int x; 
int __cdecl add(int a,int b) { return a+b; }//使用__cdecl呼叫約定 
int main(int argc, char* argv[]) 
{ 
    x=add(1,2); 
    return 0; 
}

; Debug模式編譯後得到的彙編程式碼

PUBLIC      [email protected]@3HA                    ; x 
_BSS        SEGMENT 
[email protected]@3HA     DD        01H DUP (?)      ; x變數 
_BSS        ENDS 
PUBLIC      [email protected]@[email protected]              ; add 
PUBLIC      _main 
EXTRN       __chkesp:NEAR 
;           COMDAT       _main 
_TEXT       SEGMENT

_main       PROC NEAR                  ; COMDAT        //main函式體

  push    ebp         ; //儲存ebp的值到堆疊,退出函式前用pop ebp恢復 
  mov     ebp, esp    ; //ebp指向當前堆疊; 函式中可以通過ebp來進行堆疊訪問 
  sub     esp, 64     ; //在堆疊中開闢64byte區域性空間

                      ; //說明：這三條彙編指令是很多函式體開始的慣用法; 
                      ; //用ebp指向堆疊(不會改變);並通過ebp來訪問引數和區域性變數;

  push    ebx         ; //一般按照函式間呼叫的約定,函式中可以自由使用eax,ecx,edx; 
  push    esi         ; //其它暫存器如果需要使用則需要儲存,用完時恢復；也就是暫存器的使用約定； 這也使函式呼叫約定的一部分；
  push    edi         ; //即:在函式中呼叫了別的函式後,eax,ecx,edx很可能已經改變, 
                      ; //而其它暫存器(ebx,esi,edi,ebp)的值可以放心繼續使用(esp除外)

  lea    edi, DWORD PTR [ebp-64] 
  mov    ecx, 16                 ; 00000010H 
  mov    eax, -858993460         ; ccccccccH 
  rep stosd                      ; //前面開闢的(16*4)byte區域性空間全部填充0xCC 
                                 ; //注意: 0xCC是除錯中斷(__asm int 3)的指令碼,所以可以想象,當 
                                 ; //程式錯誤的跳轉到這個區域進行執行時將產生除錯中斷

  push   2                       ; //程式碼: x=add(1,2);  
  push   1                       ; //從右到左入棧  (__cdecl呼叫約定!!!) 
  call   [email protected]@[email protected]           ; 呼叫add函式;call指令將把下一條指令的地址(返回地址)壓入堆疊 
  add    esp, 8                  ; add函式呼叫完以後,呼叫者負責清理堆疊 (__cdecl呼叫約定!!!) 
                                 ; 兩個int型引數共使用了8byte空間的堆疊 
  mov    DWORD PTR [email protected]@3HA, eax  ; 將add函式的返回值存入x變數中,可以看出add函式的返回值放在eax中

  xor    eax, eax      ; //原始碼:return 0;   執行eax清零,main函式的返回值0放在eax中

  pop    edi 
  pop    esi 
  pop    ebx           ; //恢復edi,esi,ebx暫存器 
  add    esp, 64       ; //恢復64byte區域性空間 
  cmp    ebp, esp                
  call    __chkesp     ; //到這裡時應該ebp==esp, Debug版進行確認,如果不等,丟擲異常等 
  mov    esp, ebp 
  pop    ebp           ; //恢復ebp暫存器 
  ret    0 
_main     ENDP 
_TEXT     ENDS

;//下面是add函式的程式碼,就不用解釋的像上面那麼詳細了

;        COMDAT  [email protected]@[email protected] 
_TEXT            SEGMENT 
_a$ = 8                                ;//引數a相對於堆疊偏移8 
_b$ = 12                               ;//引數b相對於堆疊偏移12

[email protected]@[email protected] PROC NEAR                ; add, COMDAT        //add函式體

  push        ebp 
  mov         ebp, esp 
  sub         esp, 64                  ; 00000040H 
  push        ebx 
  push        esi 
  push        edi 
  lea         edi, DWORD PTR [ebp-64] 
  mov         ecx, 16                  ; 00000010H 
  mov         eax, -858993460          ; ccccccccH 
  rep stosd

  mov         eax, DWORD PTR _a$[ebp]  ;將引數a的值移動到eax 
  add         eax, DWORD PTR _b$[ebp]  ;將引數b的值累加到eax; 可以看出返回值通過eax返回

  pop         edi 
  pop         esi 
  pop         ebx 
  mov         esp, ebp 
  pop         ebp 
  ret         0                     ; 函式體不管堆疊的引數清理 (__cdecl呼叫約定!!!) 
                                    ; ret指令將取出call指令壓入的返回地址,並跳轉過去繼續執行

[email protected]@[email protected] ENDP                  ; add 
_TEXT        ENDS 
END

; 再來看一下Release模式編譯後得到的彙編程式碼 
; 可以看出,這比Debug模式少了很多的彙編指令,速度當然可能更快了;不再做詳細說明了,請對照上面的解釋

PUBLIC        [email protected]@3HA                   ; x 
_BSS          SEGMENT 
[email protected]@3HA       DD        01H DUP (?)     ; x 
_BSS          ENDS 
PUBLIC        [email protected]@[email protected]             ; add 
PUBLIC        _main 
;             COMDAT            _main 
_TEXT         SEGMENT

_main         PROC NEAR                 ; COMDAT        //main函式體

  push    2 
  push    1                       ; //從右到左入棧  (__cdecl呼叫約定!!!) 
  call    [email protected]@[email protected]           ; //呼叫add函式; 
  mov     DWORD PTR [email protected]@3HA, eax  ; x 
  add     esp, 8                  ; //呼叫者負責清理堆疊 (__cdecl呼叫約定!!!)

  xor     eax, eax 
  ret     0 
_main        ENDP 
_TEXT        ENDS

;            COMDAT   [email protected]@[email protected] 
_TEXT        SEGMENT 
_a$ = 8 
_b$ = 12

[email protected]@[email protected] PROC NEAR            ; add, COMDAT        //add函式體

  mov   eax, DWORD PTR _b$[esp-4]  ;將引數b的值移動到eax 
  mov   ecx, DWORD PTR _a$[esp-4]  ;將引數a的值移動到ecx 
  add   eax, ecx                   ;將ecx的值累加到eax; 返回值通過eax傳遞 
  ret   0                          ;函式體不管堆疊的引數清理 (__cdecl呼叫約定!!!) 
[email protected]@[email protected] ENDP                 ; add 
_TEXT         ENDS 
END

下面的分析中將只給出Release模式編譯後的彙編程式碼

B: 
宣告add函式為__stdcall呼叫約定

int x; 
int __stdcall add(int a,int b) { return a+b; } 
int main(int argc, char* argv[]) 
{ 
    x=add(1,2); 
    return 0; 
}

;來看產生的彙編程式碼：

; //main函式體 
  push    2 
  push    1                        ; //從右到左入棧 
  call    [email protected]@[email protected]            ; add 
  mov     DWORD PTR [email protected]@3HA, eax   ; x 
  xor     eax, eax 
  ret     0

; //add函式體 
  mov     eax, DWORD PTR _b$[esp-4] 
  mov     ecx, DWORD PTR _a$[esp-4] 
  add     eax, ecx 
  ret     8                        ; //函式體負責清棧 ;兩個int型引數共使用了8byte空間的堆疊

C: 
宣告add函式為__fastcall呼叫約定

int x; 
int __fastcall add(int a,int b) { return a+b; } 
int main(int argc, char* argv[]) 
{ 
    x=add(1,2); 
    return 0; 
}

;來看產生的彙編程式碼：

; //main函式體 
  mov    edx, 2                    ; b通過暫存器edx傳遞 
  mov    ecx, 1                    ; a通過暫存器ecx傳遞 
  call   [email protected]@[email protected]             ; add 
  mov    DWORD PTR [email protected]@3HA, eax    ; x 
  xor    eax, eax 
  ret    0

; //add函式體 
  lea    eax, DWORD PTR [ecx+edx]  ; //a,b引數值已經在ecx,edx中,該句將這兩個值的和放到eax作為返回值; 
  ret    0                         ; //這裡應該函式體負責清棧 ;但因為兩個引數已經通過暫存器傳遞 
                                   ; //了,沒有使用堆疊,所以ret 0;

D: 
來看一下類的成員函式的呼叫：

struct T 
{ 
        int start0; 
        T():start0(1){} 
        int  add(int a,int b); //類成員函式;只要不明確宣告呼叫約定則預設使用thiscall呼叫約定;
}; 
int  T::add(int a,int b) { return (*this).start0+a+b; }

int x; 
int main(int argc, char* argv[]) 
{ 
        T t; 
        x=t.add(1,2); 
        return 0; 
}

來看產生的彙編程式碼：

; //main函式體 
  push    ecx                         ; //儲存ecx 
  push    2 
  push    1                           ; //引數從右到左入棧 
  lea     ecx, DWORD PTR _t$[esp+12]  ; //t的地址儲存到ecx 
  mov     DWORD PTR _t$[esp+12], 1    ; //執行t::start0=1; 
  call    [email protected]@@[email protected]            ; //呼叫T::add函式,這時ecx中存放了t的的地址(this指標); 
  mov     DWORD PTR [email protected]@3HA, eax      ; x 
  xor     eax, eax 
  pop     ecx 
  ret     0

; //T::add函式體 
  mov     eax, DWORD PTR [ecx]        ; //通過this指標(儲存在ecx)將start0的值移動到eax 
  mov     ecx, DWORD PTR _a$[esp-4]   ; //把a的值移動到ecx; this的值將丟失,但函式體中已經不需要了 
  add     eax, ecx                    ; //將a的值累加到eax 
  mov     ecx, DWORD PTR _b$[esp-4]   ; //把b的值移動到ecx; 
  add     eax, ecx                    ; //將b的值累加到eax 
  ret     8                           ; //函式體負責清棧 ;

五: 其他

1.在VC中實現一個函式體時可以使用__declspec(naked)宣告,它告訴編譯器,不要為函式體自動產生開始和結束碼; 
2.在VC6中,想得到彙編程式碼清單,設定方法為：

引用:[Project]->[Setting...]->[C++]->[Category:]->[Listing Files]->[Listing file type:]->[Assembily ,...]

3.VC6中嵌入彙編程式碼的方式為：

            __asm { <彙編語句s> } 
         或 __asm <一條彙編語句>

4.VC6中重新設定函式使用的預設呼叫約定的方法是： 
引用:
在[Project]->[Setting...]->[C++]->[Project Options:]中增加編譯設定 
比如：/Gd 代表__cdecl; /Gr 代表__fastcall; /Gz 代表__stdcall

當高階語言函式被編譯成機器碼時，有一個問題就必須解決：因為CPU沒有辦法知道一個函式呼叫需要多少個、什麼樣的引數。即計算機不知道怎麼給這個函式傳遞引數，傳遞引數的工作必須由函式呼叫者和函式本身來協調。為此，計算機提供了一種被稱為棧的資料結構來支援引數傳遞。

   函式呼叫時，呼叫者依次把引數壓棧，然後呼叫函式，函式被呼叫以後，在堆疊中取得資料，並進行計算。函式計算結束以後，或者呼叫者、或者函式本身修改堆疊，使堆疊恢復原裝。在引數傳遞中，有兩個很重要的問題必須得到明確說明：

												   1) 當引數個數多於一個時，按照什麼順序把引數壓入堆疊；

  2) 函式呼叫後，由誰來把堆疊恢復原裝。

  3）函式的返回值放在什麼地方
														

在高階語言中，通過函式呼叫規範(Calling Conventions)來說明這兩個問題。常見的呼叫規範有：

																stdcall
																cdecl

																fastcall

																thiscall

																naked call
														

stdcall呼叫規範

stdcall很多時候被稱為pascal呼叫規範，因為pascal是早期很常見的一種教學用計算機程式設計語言，其語法嚴謹，使用的函式呼叫約定是stdcall。在Microsoft C++系列的C/C++編譯器中，常常用PASCAL巨集來宣告這個呼叫約定，類似的巨集還有WINAPI和CALLBACK。

stdcall呼叫規範宣告的語法為：

																
																		int __stdcall function(int a,int b)
														

stdcall的呼叫約定意味著：

																  1）引數從右向左壓入堆疊；

  2）函式自身修改堆疊；

  3) 函式名自動加前導的下劃線，後面緊跟一個@符號，其後緊跟著引數的尺寸。
														

以上述這個函式為例，引數b首先被壓棧，然後是引數a，函式呼叫function(1,2)呼叫處翻譯成組合語言將變成：

														 push 2          第二個引數入棧

 push 1          第一個引數入棧

 call function   呼叫引數，注意此時自動把cs:eip入棧
														

而對於函式自身，則可以翻譯為：

														  push  ebp               儲存ebp暫存器，該暫存器將用來儲存堆疊的棧頂指標，可以在函式退出時恢復

  mov   ebp,esp           儲存堆疊指標

  mov   eax,[ebp + 8H]    堆疊中ebp指向位置之前依次儲存有ebp,cs:eip,a,b,ebp +8指向a

  add   eax,[ebp + 0CH]   堆疊中ebp + 12處儲存了b

  mov   esp,ebp           恢復esp

  pop   ebp

  ret   8
														

而在編譯時，這個函式的名字被翻譯成[email protected]

注意不同編譯器會插入自己的彙編程式碼以提供編譯的通用性，但是大體程式碼如此。其中在函式開始處保留esp到ebp中，在函式結束恢復是編譯器常用的方法。

從函式呼叫看，2和1依次被push進堆疊，而在函式中又通過相對於ebp(即剛進函式時的堆疊指標）的偏移量存取引數。函式結束後，ret 8表示清理8個位元組的堆疊，函式自己恢復了堆疊。

cdecl呼叫規範

cdecl呼叫約定又稱為C呼叫約定，是C語言預設的呼叫約定，它的定義語法是：

													          int function (int a ,int b)           // 不加修飾就是C呼叫約定

  int __cdecl function(int a,int b)     // 明確指出C呼叫約定
														

  cdecl呼叫約定的引數壓棧順序是和stdcall是一樣的，引數首先由有向左壓入堆疊。所不同的是，函式本身不清理堆疊，呼叫者負責清理堆疊。由於這種變化，C呼叫約定允許函式的引數的個數是不固定的，這也是C語言的一大特色。對於前面的function函式，使用cdecl後的彙編碼變成：

														呼叫處

  push   1

  push   2

  call   function

  add    esp,8              注意：這裡呼叫者在恢復堆疊

  被呼叫函式_function處

  push   ebp                儲存ebp暫存器，該暫存器將用來儲存堆疊的棧頂指標，可以在函式退出時恢復

  mov    ebp,esp            儲存堆疊指標

  mov    eax,[ebp + 8H]     堆疊中ebp指向位置之前依次儲存有ebp,cs:eip,a,b,ebp +8指向a

  add    eax,[ebp + 0CH]    堆疊中ebp + 12處儲存了b

  mov    esp,ebp            恢復esp

  pop    ebp

  ret                       注意，這裡沒有修改堆疊
														

MSDN中說，該修飾自動在函式名前加前導的下劃線，因此函式名在符號表中被記錄為_function。 

由於引數按照從右向左順序壓棧，因此最開始的引數在最接近棧頂的位置，因此當採用不定個數引數時，第一個引數在棧中的位置肯定能知道，只要不定的引數個數能夠根據第一個後者後續的明確的引數確定下來，就可以使用不定引數，例如對於sprintf函式，定義為：

																
														int sprintf(char* buffer,constchar* format,...)
														

由於所有的不定引數都可以通過format確定，因此使用不定個數的引數是沒有問題的。

fastcall呼叫規範

fastcall呼叫約定和stdcall類似，它意味著：

												   1) 函式的第一個和第二個DWORD引數（或者尺寸更小的）通過ecx和edx傳遞，其他引數通過從右向左的順序壓棧；

  2) 被呼叫函式清理堆疊；

  3) 函式名修改規則同stdcall。
														

其宣告語法為：int __fastcall function(int a,int b)

thiscall呼叫規範

thiscall是唯一一個不能明確指明的函式修飾，因為thiscall不是關鍵字。它是C++類成員函式預設的呼叫約定。由於成員函式呼叫還有一個this指標，因此必須特殊處理，thiscall意味著：

												   1) 引數從右向左入棧；

  2) 如果引數個數確定，this指標通過ecx傳遞給被呼叫者；如果引數個數不確定，this指標在所有引數壓棧後被壓入堆疊；

  3) 對引數個數不定的，呼叫者清理堆疊，否則函式自己清理堆疊。
														

為了說明這個呼叫約定，定義如下類和使用程式碼：

																
														class A

{

public:

        int function1(int a,int b);

        int function2(int a,...);

};

int A::function1 (int a,int b)

{

        return a+b;

}

int A::function2(int a,...)

{

        va_list ap;

        va_start(ap,a);

        int i;

        int result = 0;

        for(i = 0 ; i < a ; i ++)

        {

                result += va_arg(ap,int);

        }

        return result;

}

void callee()

{

        A a;

        a.function1(1,2);

        a.function2(3,1,2,3);

}
														

callee函式被翻譯成彙編後就變成：

																  // 函式function1呼叫

  0401C1D    push        2

  00401C1F   push        1

  00401C21   lea         ecx,[ebp-8]

  00401C24   call   function1             注意，這裡this沒有被入棧

  // 函式function2呼叫

  00401C29   push        3

  00401C2B   push        2

  00401C2D   push        1

  00401C2F   push        3

  00401C31   lea         eax,[ebp-8]      這裡引入this指標

  00401C34   push        eax

  00401C35   call   function2

  00401C3A   add         esp,14h


														

可見，對於引數個數固定情況下，它類似於stdcall，不定時則類似cdecl

naked call呼叫規範

這是一個很少見的呼叫約定，一般程式設計者建議不要使用。編譯器不會給這種函式增加初始化和清理程式碼，更特殊的是，不能用return返回返回值，只能用插入彙編返回結果。這一般用於真實模式驅動程式設計，假設定義一個求和的加法程式，可以定義為：

														__declspec(naked) int  add(int a,int b)

   {

       __asm mov eax,a

       __asm add eax,b

       __asm ret

   }
														

注意，這個函式沒有顯式的return返回值，返回通過修改eax暫存器實現，而且連退出函式的ret指令都必須顯式插入。上面程式碼被翻譯成彙編以後變成：

   mov    eax,[ebp+8]

   add    eax,[ebp+12]

   ret    8

注意這個修飾是和__stdcall及cdecl結合使用的，前面是它和cdecl結合使用的程式碼，對於和stdcall結合的程式碼，則變成：

														 __declspec(naked) int __stdcall function(int a,int b)

   {

       __asm mov eax,a

       __asm add eax,b

       __asm ret 8//注意後面的8

   }
														

至於這種函式被呼叫，則和普通的cdecl及stdcall呼叫函式一致。

函式呼叫約定導致的常見問題

如果定義的約定和使用的約定不一致，則將導致堆疊被破壞，導致嚴重問題，下面是兩種常見的問題：

												 1) 函式原型宣告和函式體定義不一致

2) DLL匯入函式時聲明瞭不同的函式約定

轉自：http://www.cppblog.com/oosky/archive/2007/01/08/17422.html