第七章　堆疊框（二）

前一章已經把 GCD.ASM 會用到但未曾提過的 x64 指令、Win64 API 介紹完畢，這一章就要進入主題，說明堆疊框了。

堆疊框是什麼

如同前一章所述，堆疊框是應用程式呼叫副程式時，如有必要會在堆疊上建立一塊記憶體空間，供其執行期間使用。這塊空間通常包含返回位址、呼叫者狀態（如原先的 RBP 或被保存的暫存器）、副程式所需的區域變數以及與相關的資料，這樣的記憶體空間稱為堆疊框（stack frame）。

當應用程式執行 CALL 指令時，建立的堆疊框必須遵循 x64 呼叫慣例。所以 RSP 所指的堆疊位址必須能被 10h 整除，否則應用程式會當掉。因此當 CALL 指令把返回位址推入堆疊時，保存返回位址的堆疊位址之個位數必為 8，如右圖的 HIJKY8。（H、I、J、K、Y 各代表十六進位的一位數，從 0 到 F）

進入副程式後，組譯器會依據 PROC、LOCAL 等假指令，完成底下事情：

⑴、將 RBP 推入堆疊保存起來，然後把 RSP 之值賦予 RBP。如下程式：

        push    rbp
        mov     rbp,rsp

為何要執行這兩道指令呢？這是因為在副程式裡，要用 RBP 作為基準，去存取區域變數或參數。

⑵、組譯器依據 LOCAL 所定義的區域變數的多寡，將堆疊空出一塊區域，作為容納區域變數。方法很簡單，使 RSP 減去區域變數所需的空間。（見右圖區域變數一∼N）

⑶、組譯器依據 PROC 的 USES 暫存器列表，將這些暫存器推入堆疊備份起來。因為副程式執行過程中，會使用到某些暫存器，避免返回主程式時改變這些暫存器，故將其保存，待返回之前（也就是第⑸步驟）恢復原值。這些暫存器就是前面說的非揮發性暫存器，它們可以保存在右圖標示暫存器一∼N。

⑷、在副程式之內，也有可能也會呼叫別的副程式或是 Win64 API。所以接下來必須調整 RSP 之值，此目的有二：①使其能容納別的副程式之影子空間以及更多參數（如果有的話），②並且呼叫別的副程式或 Win64 API 時，堆疊頂端能對齊節位址。調整方式很簡單，把 RSP 減去一數，使其個位數變為零。見右圖對齊空間∼RCX。

⑸、退出副程式時，必須先使 RSP 加上剛剛減去的數，使其恢復調整前之值。以符合 x64 呼叫慣例，呼叫者負責清理堆疊。

⑹、組譯器會在副程式結束之前，也就是在該副程式之中的 RET 指令之前，依據 PROC 的 USES 暫存器列表的反向順序，將原來暫存器之值由堆疊中彈出，最後再加上 LEAVE 指令恢復 RBP 與 RSP 之值。要注意的是，如果副程式中不只一個 RET，那麼組譯器會在每個 RET 之前恢復原暫存器之值，及加上 LEAVE 指令。

上面的五個步驟中，只有第⑷、⑸兩個步驟必須是程式設計師自行計算，其餘的都是組譯器自動添加的。瞭解了堆疊框之後，底下來看看應用程式是如何實現堆疊框，以符合 x64 呼叫慣例。

GCD.ASM 原始程式

小木偶使用 GCD.ASM 來說明如何使用堆疊框。GCD 可讓使用者輸入兩個正整數，然後計算它們的最大公因數，並印在螢幕上，全部原始碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
OPTION CASEMAP:NONE
EXTRN  GetStdHandle:PROC,CloseHandle:PROC,ExitProcess:PROC
EXTRN  StrToIntA:PROC,wsprintfA:PROC,WriteConsoleA:PROC,ReadConsoleA:PROC
INCLUDELIB E:\masm64\lib64\kernel32.lib
INCLUDELIB E:\masm64\lib64\user32.lib
INCLUDELIB E:\masm64\lib64\shlwapi.lib
one_hundred_million EQU 100000000 ;一億=5F5E100h
;******************************************************************************
.DATA
hInput  DQ      ?       ;標準輸入裝置控制代碼
hOutput DQ      ?       ;標準輸出裝置控制代碼
n1      DD      ?       ;使用者輸入的數值1
n2      DD      ?       ;使用者輸入的數值2
gcd     DD      ?       ;n1、n2的最大公因數
szGcd   DB      52 DUP (0)
sHint   DB      "請輸入不大於一億的正整數："
sErr1   DB      "您輸入大於一億的數！"
sErr2   DB      "輸入錯誤或輸入零！"
szFmt   DB      "%d、%d的最大公因數是%d。",0
;******************************************************************************
.CODE
;------------------------------------------------------------------------------
Input   PROC    USES rbx rsi rdi hIn:QWORD,hOut:QWORD,pNumber:QWORD
;輸入：hIn、hOut－標準輸入、輸出裝置控制代碼
;　　　pNumber－使用者輸入的數值存放位址
;輸出：RAX＝0，輸入錯誤
;　　　RAX＝1，輸入正確，pNumber所指位址存有使用者輸入的數值
        LOCAL   nWritn:DWORD,nRead:DWORD,buffer[12]:BYTE
        sub     rsp,30h
    ;把參數存入影子空間
        mov     hIn,rcx
        mov     hOut,rdx
        mov     rbx,r8
    ;invoke WriteConsoleA,hOut,ADDR sHint,SIZEOF sHint,ADDR nWrtin,0（印出sHint字串）
        mov     rcx,hOut
        mov     rdx,OFFSET sHint
        mov     r8,SIZEOF sHint
        lea     r9,nWritn
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
    ;invoke ReadConsoleA,hIn,ADDR buffer,ADDR nRead,0（讓使用者輸入數值字串）
        mov     rcx,hIn
        lea     rdx,buffer
        mov     r8,SIZEOF buffer
        lea     r9,nRead
        mov     QWORD PTR [rsp+20h],0
        call    ReadConsoleA
    ;invoke StrToIntA,ADDR buffer（把使用者輸入的數值字串轉換成數值）
        lea     rcx,buffer
        call    StrToIntA
    ;檢查使用者輸入的數值是否超過十億
        cmp     eax,one_hundred_million
        jbe     chk_zr
        lea     rdx,sErr1       ;若超過印出sErr1
        mov     r8,SIZEOF sErr1
        jmp     pnt_it
chk_zr: test    eax,eax         ;若未超過，再檢查是否為零
        jnz     ok              ;若不為零，跳至ok
        lea     rdx,sErr2       ;若為零，印出sErr2
        mov     r8,SIZEOF sErr2
    ;invoke WriteConsoleA,hOut,rdx,r8d,ADDR nWritn,0（印出sErr1或sErr2的錯誤訊息）
pnt_it: mov     rcx,hOut
        lea     r9,nWritn
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
    ;使RAX變為零，並離開Input
        xor     rax,rax
        jmp     quit
    ;使使用者輸入的數值存入pNumber所指位址
ok:     mov     [rbx],eax
quit:   add     rsp,30h
        ret
Input   ENDP
;------------------------------------------------------------------------------
FindGcd PROC    num1:DWORD,num2:DWORD
;輸入：num1、num2兩個整數
;輸出：EAX＝最大公因數
again:  xchg    ecx,edx ;餘數變為下次的除數，原來的除數變被除數
        mov     eax,edx
        cdq
        div     ecx     ;使EDX:EAX（被除數）除以ECX（除數）
        or      edx,edx ;餘數為EDX
        jnz     again   ;若EDX為零，最後一次的除數即為GCD
        mov     eax,ecx ;把最大公因數存入RAX
        cdqe
        ret
FindGcd ENDP
;------------------------------------------------------------------------------
main    PROC
        sub     rsp,28h
    ;取得標準輸入、輸出裝置的控制代碼
        mov     rcx,-10 ;STD_INPUT_HANDLE=-10
        call    GetStdHandle
        mov     hInput,rax
        mov     rcx,-11 ;STD_OUTPUT_HANDLE=-11
        call    GetStdHandle
        mov     hOutput,rax
    ;invoke Input,hInput,hOutput,ADDR n1（輸入第一個正整數）
        mov     rcx,hInput
        mov     rdx,hOutput
        mov     r8,OFFSET n1
        call    Input
        or      eax,eax
        jz      error
    ;invoke Input,hInput,hOutput,ADDR n2（輸入第二個正整數）
        mov     rcx,hInput
        mov     rdx,hOutput
        mov     r8,OFFSET n2
        call    Input
        or      eax,eax
        jz      error
    ;invoke FindGcd,n1,n2（計算n1、n2的最大公因數）
        mov     ecx,n1
        mov     edx,n2
        call    FindGcd
    ;invoke wsprintfA,ADDR szGcd,ADDR szFmt,n1,n2,eax（生成szGcd字串）
        mov     rcx,OFFSET szGcd
        mov     rdx,OFFSET szFmt
        mov     r8d,n1
        mov     r9d,n2
        mov     [rsp+20h],eax
        call    wsprintfA
    ;invoke WriteConsoleA,hOutput,ADDR szGcd,eax,0,0（印出szGcd字串）
        mov     rcx,hOutput
        lea     rdx,szGcd
        mov     r8d,eax
        xor     r9,r9
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
    ;invoke ExitProcess,0（離開GCD.EXE）
error:  xor     rcx,rcx
        call    ExitProcess
main    ENDP
;******************************************************************************
END

將上述原始程式儲存在「E:\HomePage\SOURCE\Win64\CONSOLE\GCD.ASM」，然後依照下面步驟組譯、連結，只需要輸入底下黃色字即可得到 GCD.EXE。它是是控制臺程式，可以在命令提示字元中執行，輸入 GCD 即可執行（見下面最後一個黃字的指令），當然輸入兩正整數時，可以輸入任何不大於一億的正整數都，不必一定要是 655360 或 458400：

C:\Users\wanker>cd e:\HomePage\SOURCE\Win64\CONSOLE

C:\Users\wanker>e:

e:\HomePage\SOURCE\Win64\CONSOLE>ml64 gcd.asm /link /subsystem:console
Microsoft (R) Macro Assembler (x64) Version 14.25.28614.0
Copyright (C) Microsoft Corporation.  All rights reserved.

 Assembling: gcd.asm
Microsoft (R) Incremental Linker Version 14.25.28614.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/subsystem:windows /entry:main
/OUT:gcd.exe
gcd.obj
/subsystem:console

e:\HomePage\SOURCE\Win64\CONSOLE>gcd
請輸入不大於一億的正整數：655360
請輸入不大於一億的正整數：458400
655360、458400的最大公因數是160。
e:\HomePage\SOURCE\Win64\CONSOLE>

解析 GCD.ASM

稍微觀察就能發現兩件事：①GCD.ASM 完全不用 MASM64 SDK，而是「純手工」打造，為什麼這樣做呢？前一章已有說明。②GCD.ASM 的結構是一個主程式（main）及由兩個副程式（Input、FindGcd）所組成。

main 負責獲取標準輸出／輸入裝置控制代碼；並呼叫兩次 Input 副程式，以便讓使用者輸入兩個正整數；最後就是呼叫 FindGcd 副程式求出兩數的最大公因數，再於螢幕上印出來。main 內並沒有複雜的流程問題，而有關 FindGcd 的原理在前一章已經說明過了，所以這兩個主題都不討論。這一章的重點在於藉由剖析 Input、FindGcd 兩個副程式，進而瞭解堆疊框的架構。

組譯器改變了原始程式什麼？

如果用 x64dbg 載入 GCD.EXE 並觀察 Input、FindGcd 副程式，你會發現組譯器（這裡指的是 ML64.EXE）會添加一些指令。因為 FindGcd 不牽涉區域變數和備份暫存器，先來觀察它有何變化。 比較簡單下表是左欄是原始程式，右欄是組譯後的程式碼：

原始程式組譯後的原始碼
FindGcd PROC    num1:DWORD,num2:DWORD
;輸入：num1、num2兩個整數
;輸出：EAX＝最大公因數
again:  xchg    ecx,edx ;餘數變為下次的除數，原來的除數變被除數
        mov     eax,edx
        cdq
        div     ecx     ;使EDX:EAX（被除數）除以ECX（除數）
        or      edx,edx ;餘數為EDX
        jnz     again   ;若EDX為零，最後一次的除數即為GCD
        mov     eax,ecx ;把最大公因數存入RAX
        cdqe
        ret
FindGcd ENDP
    push rbp
    mov  rbp,rsp
@@: xchg edx,ecx
    mov  eax,edx
    cdq
    div  ecx
    or   edx,edx
    jne  @b
    mov  eax,ecx
    cdqe
    leave
    ret

比較兩邊之後，當可發現，組譯器添加了白色標示的兩道指令（在上表右欄）。因為 FindGcd 只是簡單的運算而已，使用 RAX、RCX、RDX 就已經足夠，所以其實添加的這兩道指令並無用途。不過從這兒可知，不論有沒有用途，組譯器見到 PROC 假指令後，會自動添加這兩道指令，作為後面堆疊框的準備工作，縱使沒用途。

再來看看 Input 組譯前後的差別，見下表。左欄是 Input 副程式的原始碼，右欄則是在 x64dbg 載入後可執行檔 GCD.EXE，顯示 Input 程式碼的結果。當然 x64dbg 並不會顯示註解，那是小木偶加上去的，便於觀察兩者不同。

原始程式組譯後的原始碼
Input   PROC  USES rbx rsi rdi hIn:QWORD,hOut:QWORD,pNumber:QWORD
;輸入：hIn、hOut－標準輸入、輸出裝置控制代碼
;　　　pNumber－使用者輸入的數值存放位址
;輸出：RAX＝0，輸入錯誤
;　　　RAX＝1，輸入正確，pNumber所指位址存有使用者輸入的數值
        LOCAL   nWritn:DWORD,nRead:DWORD,buffer[12]:BYTE
        sub     rsp,30h
;把參數存入影子空間
        mov     hIn,rcx
        mov     hOut,rdx
        mov     rbx,r8
;invoke WriteConsoleA,hOut,ADDR sHint,SIZEOF sHint,ADDR nWrtin,0
;（印出sHint字串）
        mov     rcx,hOut
        mov     rdx,OFFSET sHint
        mov     r8,SIZEOF sHint
        lea     r9,nWritn
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
;invoke ReadConsoleA,hIn,ADDR buffer,ADDR nRead,0
;（讓使用者輸入數值字串）
        mov     rcx,hIn
        lea     rdx,buffer
        mov     r8,SIZEOF buffer
        lea     r9,nRead
        mov     QWORD PTR [rsp+20h],0
        call    ReadConsoleA
;invoke StrToIntA,ADDR buffer（把使用者輸入的數值字串轉換成數值）
        lea     rcx,buffer
        call    StrToIntA
;檢查使用者輸入的數值是否超過十億
        cmp     eax,one_hundred_million
        jbe     chk_zr
        lea     rdx,sErr1       ;若超過印出sErr1
        mov     r8,SIZEOF sErr1
        jmp     pnt_it
chk_zr: test    eax,eax         ;若未超過，再檢查是否為零
        jnz     ok              ;若不為零，跳至ok
        lea     rdx,sErr2       ;若為零，印出sErr2
        mov     r8,SIZEOF sErr2
;invoke WriteConsoleA,hOut,rdx,r8d,ADDR nWritn,0
;（印出sErr1或sErr2的錯誤訊息）
pnt_it: mov     rcx,hOut
        lea     r9,nWritn
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
;使RAX變為零，並離開Input
        xor     rax,rax
        jmp     quit
;使使用者輸入的數值存入pNumber所指位址
ok:     mov     [rbx],eax
quit:   add     rsp,30h
        ret
Input   ENDP
        push rbp
        mov  rbp,rsp
        add  rsp,FFFFFFFFFFFFFFE8
        push rbx
        push rsi
        push rdi
        sub  rsp,30
;把參數存入影子空間
        mov  qword ptr ss:[rbp+10],rcx ;hIn=[RBP+10]
        mov  qword ptr ss:[rbp+18],rdx ;hOut=[RBP+18]
        mov  rbx,r8
;invoke WriteConsoleA,hOut,ADDR sHint,SIZEOF sHint,ADDR nWrtin,0
;（印出sHint字串）
        mov  rcx,qword ptr ss:[rbp+18]
        mov  rdx,gcd.7FF6D1CB3050
        mov  r8,18
        lea  r9,qword ptr ss:[rbp-4]   ;nWritn=[RBP-4]
        mov  qword ptr ss:[rsp+20],0
        call <JMP.&WriteConsoleA>
;invoke ReadConsoleA,hIn,ADDR buffer,ADDR nRead,0
;（讓使用者輸入數值字串）
        mov  rcx,qword ptr ss:[rbp+10]
        lea  rdx,qword ptr ss:[rbp-14] ;buffer=[RBP-14]
        mov  r8,C
        lea  r9,qword ptr ss:[rbp-8]   ;nRead=[RBP-8]
        mov  qword ptr ss:[rsp+20],0
        call <JMP.&ReadConsoleA>
;invoke StrToIntA,ADDR buffer（把使用者輸入的數值字串轉換成數值）
        lea  rcx,qword ptr ss:[rbp-14]
        call <JMP.&StrToIntA>
;檢查使用者輸入的數值是否超過十億
        cmp  eax,5F5E100
        jbe  chk_zr
        lea  rdx,qword ptr ds:[7FF6D1CB3068]
        mov  r8,14
        jmp  pnt_it
chk_zr: test eax,eax
        jne  ok
        lea  rdx,qword ptr ds:[7FF6D1CB307C]
        mov  r8,12
;invoke WriteConsoleA,hOut,rdx,r8d,ADDR nWritn,0
;（印出sErr1或sErr2的錯誤訊息）
pnt_it: mov  rcx,qword ptr ss:[rbp+18]
        lea  r9,qword ptr ss:[rbp-4]
        mov  qword ptr ss:[rsp+20],0
        call <JMP.&WriteConsoleA>
        xor  rax,rax
        jmp  quit
ok:     mov  dword ptr ds:[rbx],eax
quit:   add  rsp,30
        pop  rdi
        pop  rsi
        pop  rbx
        leave
        ret

比較左右兩欄就能發現：①第一個參數在位址 RBP+10h（即淡藍色字，hIn），第二個參數在位址 RBP+18h（即藍色字，hOut）。②第一個區域變數在位址 RBP-4（黃色字，nWritn），第二個區域變數在位址 RBP-8（澄色字，nRead），第三個區域變數在位址 RBP-14h（紅色字，buffer）。從這兩點的發現就能得知，組譯器會把 RBP 作為存取基準點，再加上每個參數或區域變數距離此基準點不同的偏移位址，就能存取個別參數或區域變數了。問題來了，組譯器是怎麼決定這些參數或區域變數的位址呢？這與組譯器所添加的指令有關。

底下先來看看這些添加的指令如何運作？請參閱下圖。圖一是在 main 即將呼叫 Input 副程式時堆疊的情形，堆疊頂端，RSP 指向位址 1FFA60，符合個位數是 0，也就是對齊一節位址。雖然 Input 只有三個參數，但別忘了影子空間至少要能保存四個參數，同時也不要忘了 main 會呼叫 wsprintfA、WriteConsoleA，它們都有五個參數，因此也得預留第五個參數的空間。

執行「CALL Input」後，將返回位址推入堆疊，見圖二。接下來就是組譯器添加的「push rbp」、「mov rbp,rsp」兩道指令，執行完後堆疊情形如圖三。這時候原來的 RBP 已保存在堆疊位址 1FFA50 處，而且 RBP、RSP 之值都是 1FFA50。在 Input 之內如要存取區域變數或參數，都以 1FFA50 為基準；除此之外，在 Input 內，RBP 之值都不應改變，這樣做的理由有二：①如果改變存取區域變數或參數就會有問題。②將來要返回 main 時，不論 RSP 改變多少，只要執行「mov rsp,rbp」就能找到進入 Input 時的堆疊頂端，執行「pop rbp」就能恢復原 RBP；或者直接執行「leave」就能同時達成兩道指令的功能。

到這兒可以說一說應用程式是如何存取參數。看圖三，RBP 所指位址是 1FFA50，而在影子空間中的第一個參數在位址 1FFA60、第二個參數在 1FFA68……，所以第一個參數位址就是 RBP+10、第二個參數位址是 RBP+18……，是不是符合上表中，以淡藍色、藍色所標示的第一、二個參數位址。接下來的「add rsp,FFFFFFFFFFFFFFE8」是組譯器添加的指令。其實 FFFFFFFFFFFFFFE8h 是有號數，相當於 -18h（以後再談有號數）。所以這個指令相當於把 RSP 減去 18h，也就是減去十進位的 24，目的是把堆疊頂端往上移 24 個位元組空出一塊空間，這塊空間是給區域變數使用的，見上圖四。在 Input 定義的區域變數是：

        LOCAL   nWritn:DWORD,nRead:DWORD,buffer[12]:BYTE

總共是二十個位元組（4+4+12=20）。不過在 Win64 系統中，堆疊頂端每次只能移動八個位元組，所以只好浪費四個位元組捨棄不用。由於使用堆疊是從高位址往低位址延伸，所以 nWritn 位於堆疊 1FFA48∼1FFA4F 較高位址的四個位元組，nRead 則位於較低位址的四個位元組；故 nWritn 的位址是 1FFA4C，nRead 的位址是 1FFA48。RBP 指向 1FFA50，所以 nWritn、nRead 的位址分別是 RBP-4、RBP-8（見上表標示的黃色與橙色字）。

接下來是連續三道 PUSH 指令，讓 RBX、RSI、RDI 依序推入堆疊保存其值。x64 呼叫慣例中，RBX、RSI、RDI 屬於非揮發性暫存器，如果副程式內使用這類暫存器，那麼副程式有義務保存其值，使其在退出副程式時，其值仍不變。方法就是使用 PUSH，將非揮發性暫存器保存於堆疊裏。ML64.EXE 組譯器提供一個簡潔的辦法，利用 PROC 假指令的 USES，可以自動生成將暫存器 PUSH 至堆疊的程式碼。

接下來的指令是「sub rsp,30h」，為何要執行它呢？原因是在 Input 內，會呼叫 WriteConsoleA、ReadConsoleA、StrToIntA，其中以 WriteConsoleA 所需的五個參數最多，所以得在堆疊上預留五個參數的空間。但是 5×8＝40＝28h，那為什麼是使 RSP 減去 30h，而不是減去 28h 呢？這原因牽涉到在執行 CALL 指令時，不僅要預留參數空間，還要使 RSP 能對齊一節的位址。值得注意的是，這兒只需考慮參數最多的即可，因為參數較少的一定可以容納進參數較多的。

當 main 執行 CALL 指令呼叫 Input 副程式時，RSP 必須指向對齊一節的位址，其個位數是零。進入 Input 副程式後，CALL 會把返回位址推入堆疊，Input 接下來會把 RBP 推入堆疊保存起來，到此 RSP 的個位數仍是零。我們可以得到一個小小的概念，那就是每兩筆資料推入堆疊，RSP 將會減 10h，仍然對齊一節的位址。接下來區域變數佔了堆疊三筆資料，而 Input 又將三個暫存器推入堆疊，總共六筆資料，到此 RSP 仍對齊一節的位址。此時若減去 28h 會使得 RSP 在執行 CALL 時沒有對齊一節位址，因此要修正為減去 30h，即便是浪費了八個位元組的堆疊空間。

最後再囉嗦一下，要退出副程式時，可參考上圖六。先使 RSP 加上 30h（此步驟必須由程式設計的人撰寫），使其指向保存暫存器的地方，再一一恢復暫存器原值（此步驟由組譯器自動添加）。接下來的 LEAVE 指令是組譯器自動添加的，它可使 RSP 之值變為 RBP，即 1FFA50，然後由堆疊恢復原來的 RBP。最後執行 RET 返回 main。

在此做一個小小的結論，進入副程式後，堆疊框裏的內容，位址由高至低依序是：①返回位址（八個位元組）、②原 RBP（八個位元組）、③區域變數（依需求決定）、④保存的暫存器（依需求決定）、⑤進入副程式後再呼叫副程式預留的參數（由最多的參數與是否對齊一節的位址決定）。

後記

這一章用純手工方式打造 GCD.EXE，目的只純粹是為了說明堆疊框內容，而不希望因為包含檔的引入而添加許多奇奇怪怪的裝飾。往後再也不會用這種方式，而是直接站在巨人的肩膀上，使用 MASM64 SDK，讓設計應用程式變得簡便一些。