第四章　副程式

第一章已經提過副程式如何宣告、如何呼叫、如何從副程式返回，但還未真正建立過副程式，也沒說過呼叫過程中堆疊的變化情形。在這一章裡，小木偶將以求得兩正整數的最大公因數及最小公倍數為例子，來說明這個過程。此程式稱為 GCD_LCM.ASM。

你可以試想，如果叫你撰寫這個程式，該如何做？最單純的方式，應該是在程式一開始，就在「命令提示」字元顯示一個字串，提示使用者輸入一個正整數，等輸入完成將它存入一個變數中，以待後續使用。這段過程還要重複一次，因為這個緣故，這段程式可以寫成副程式。

由接下來，就是求得這兩正整數的最大公因數了。這個程式片段有很強烈的目的性，甚至可以獨立出來應用到其他程式上，讓其他程式呼叫，所以這段程式也可以製作成副程式。

由以上看來，GCD_LCM.ASM 至少可以有兩個自行建立的副程式，前者稱為「input_integer」，後者稱為「find_gcd_lcm」。

新的指令

先介紹「GCD_LCM.ASM」會用到的新指令。

x86 指令：XCHG

XCHG 的語法是

XCHG    目的運算元,來源運算元

XCHG 的功用是相互交換目的運算元與來源運算元之數值，這兩個運算元可以是變數或暫存器，但不能都是變數。例如底下的例子：

        mov     rax,5
        mov     rcx,8
        xchg    rax,rcx

最後 RAX＝8，RCX＝5。

x86 指令：MUL

80x86 家族的乘法指令有兩種，MUL 與 IMUL，前者是用來計算無號數 ( 無號數可以看成是正整數 )，後者則是用來計算有號數的。此處僅介紹 MUL，其語法如下：

MUL     運算元

MUL 後面接著的運算元其實就是乘數，可以是暫存器或變數但不可以是常數。被乘數放在 AL、AX、EAX、RAX 裏，至於是哪一個，視乘數的長度來決定，被乘數的長度必須與乘數長度相同。例如乘數是八位元長，那麼被乘數也是八位元長，所以被乘數就放在 AL 裏。

MUL 運算之後，乘積的長度是乘數位數與被乘數位數之和。以我們熟悉的十進位數來說，兩位數乘兩位數最大值是四位數，例如 99×99＝9801。同理，八個位數的二進位數乘八個位數的二進位數所得之乘積為十六個位數的二進位數，而八個位數不就是八位元嗎？所以 AL 乘以八位元暫存器或變數，所得的乘積要放在十六位元的 AX 暫存器裏。不同位元的乘法整理成下表：

乘法方式乘數被乘數乘積 範例
運算前運算後
八位元乘法8 位元變數
或暫存器		ALAX ;計算 2×3＝6
MOV  AX,0102H
MOV  BX,0103H
MUL  BL		 AX=0006
BX=0103H
十六位元乘法16 位元變數
或暫存器		AXDX:AX ;計算 200H×106＝20C00H
MOV  DX,0FFFFH
MOV  AX,200H
MOV  BX,106H
MUL  BX		 DX=0002
AX=0C00H
BX=0106H
三十二位元乘法
只能用於
386等級以上		32 位元變數
或暫存器		EAXEDX:EAX ;計算 80000001H×2＝100000002H
MOV  EDX,88887777H
MOV  EAX,80000001H
MOV  EBX,2
MUL  EBX		 EDX=1
EAX=2
EBX=2
六十四位元乘法
只能用於
x64等級以上		64 位元變數
或暫存器		RAXRDX:RAX ;計算 8×8＝40H
MOV  RDX,123456789ABCDEF0H
MOV  RAX,8
MOV  RBX,8
MUL  RBX		 RDX=0
RAX=40H
RBX=8

上表中十六位元的乘法，乘數與被乘數都是十六位元長，乘數是十六位元的暫存器或變數，被乘數則固定放於 AX 暫存器中。運算之後所得之乘積為三十二位元，但並不是放在 EAX 暫存器裏。這是因為在 x86 CPU 家族中，最早的 CPU 是十六位元的 8086，其暫存器都是十六位元長，沒有三十二位元的暫存器。不得已，只能用兩個暫存器存放，英特爾用 DX、AX 存放，以 DX:AX 表示，DX 是較高位的字組，AX 是較低位的字組。到了三十二位元、六十四位元的乘法，也用此慣例存放乘積。

MUL 不影響零值旗標，即使所得的乘積為零；但是會影響進位旗標。執行 MUL 之後，把乘積的位數均分兩部分，較高位不為零時進位旗標設成一，否則設為零。例如：

        mov     ax,8000h
        mov     cx,8
        mul     cx

執行完後 DX:AX＝0006:4000，因為 DX 不為零故 CPU 會把進位旗標設為一。

x86 指令：DIV

DIV 指令是功用是計算正整數的除法，至於有號數的除法，是用 IDIV 指令，見第 13 章。DIV 的語法如下：

DIV     運算元

運算元是除數，可以變數或暫存器，但不可以是常數。DIV 指令的被除數並沒有寫出來，預設是 AX、DX:AX、EDX:EAX、RDX:RAX，至於是哪一個，要看運算元決定。其規則是被除數的位元個數是除數的兩倍長。依據運算元的長度，可分為四種除法：①八位元除法、②十六位元除法、③三十二位元除法、④六十四位元除法。運算後的商和餘數，分別存於暫存器中，整理如下表：

除法方式除數 被除數商數 餘數範例
運算前運算後
八位元除法8 位元變數
或暫存器		AXALAH ;計算 7÷2＝3⋯⋯1
MOV  AX,7
MOV  CL,2
DIV  CL		 AX=0103（AL＝商，AH＝餘數）
CL=2
十六位元除法16 位元變數
或暫存器		DX:AXAXDX ;計算 9÷4＝2⋯⋯1
MOV  DX,0
MOV  AX,9
MOV  CX,4
DIV  CX		AX=2（商）
DX=1（餘數）
三十二位元除法
只能用於
386等級以上		32 位元變數
或暫存器		EDX:EAXEAXEDX ;計算三百億÷八億＝37⋯⋯400000000
MOV  EDX,6
MOV  EAX,0FC23AC00H
MOV  ECX,2FAF0800H
DIV  ECX		 EAX=25H（商）
EDX=17D78400H（餘數）
六十四位元除法
只能用於
x64等級以上		64 位元變數
或暫存器		RDX:RAXRAXRDX ;10CDEFAB1234567890H÷10000000H
;＝1CDEFAB123H⋯⋯4567890H
MOV  RDX,1
MOV  RAX,0CDEFAB1234567890H
MOV  RCX,10000000H
DIV  RCX		 RAX=1CDEFAB123H（商）
RDX=4567890H（餘數）

以上表的三十二位元除法為例，如果要計算三百億除以八億，三百億換算成十六進位是 6 FC23 AC00H，占用六十四位元；八億是 2FAF 0800H，占了三十二位元。所以把 EDX 設為 6，EAX 設為 0FC23 AC00H，這樣就完成被除數的設定。除數可以是三十二位元的變數或暫存器，此例是 ECX，所以將 ECX 設為 2FAF 0800H（十進位 800000000＝八億）。運算後的商為 37（十六進位 25H），餘數為四億（十六進位 17D7 8400H）。

還有個問題，既然 DIV 有四種之多，那麼在做運算時要選用哪一種位元數的除法呢？其實不難，依據除數的大小來判定即可。還是以是三百億除以八億為例。除數是八億，換算成十六進位是 2FAF 0800H，占了三十二位元，因此就選用三十二位元的除法。也可以參考第一章的表格得知，三十二位元的數最多能表示四十二億，因此用三十二位元表示八億，綽綽有餘（當然你也可以執意用六十四位元除法，但殺雞焉用牛刀）。三十二位元的除法被除數放在 EDX:EAD 內，因此 EDX＝6，EAX＝0FC23 AC00H，除數只要是 32 位元的變數或暫存器即可，例如 ECX，故使 ECX＝2FAF 0800H，就能夠相除了，結果商放在 EAX＝25H，餘數六億放在 EDX 內。

DIV 不影響旗標暫存器，但要注意商會不會超過暫存器所能存放的大小。例如 0F000÷2＝7800H（十進位是61440÷2＝30720），如果用八位元的除法，所得的商放在 AL，但放不下，就會發生錯誤，這種錯誤稱除法溢位。通常除數太小且被除數太大，就會發生這種情形，可以參考「DOS 組合語言第七章註一」。

x86 指令：OR

在日常生活中，常使用〝或〞這個描述。例如晚飯後，媽媽說：「洗完碗〝或〞倒完廚餘就能打電動。」意思就是洗碗跟倒廚餘兩件事，只要有一樣完成就能打電動。把做完事情當作真，以「1」表示；事情未做完，為假，以「0」表示。能玩電動為真，以「1」表示；不能玩電動為假，以「0」表示。結果如下表：事件甲代表沒洗碗也沒倒廚餘，所以不能玩電動；事件乙表示洗碗但沒倒廚餘，可以打電動……

事件洗完碗倒完廚餘是否能玩電動
甲000
乙101
丙011
丁111

在電腦中，〝或〞運算也像上面「能否打電動」的例子一樣。也就是說，兩個一位元的運算元做〝OR〞運算，只要有一個運算元為一，結果就是一；只有兩個運算元都是零，結果才是零。OR 運算的真值表如下：

0 OR 0＝0
1 OR 0＝1
0 OR 1＝1
1 OR 1＝1

x86 的指令 OR 指令的語法是

OR      目的運算元,來源運算元

OR 指令是將來源運算元的每個位元與目的運算元相對應的位元作 OR 運算，再將其結果存入目的運算元中。目的運算元可以是暫存器、變數，來源運算元可以是暫存器、變數與常值。目的運算元與來源運算元不能同時是變數，而且長度必須相同，都是八位元或十六位元寬。

此外，OR 指令也會依據結果設定旗標暫存器中的零值旗標。假如結果為零，會使零值旗標變為「1」，否則零值旗標為「0」。OR 不會發生借位或進位，因此進位旗標都會設為零。

例如，AL＝32H，執行「OR AL,0C3H」後的結果如右圖，最後結果為 F3，因此 AL 也會變成 F3。

OR 指令有一項特性，如果對自己作 OR 運算結果為零，則自己本身原來也是零。在組合語言裏，常常用這種性質去檢查某個暫存器是否為零。例如在「gcd_lcm.asm」的第 36 行，「or rdx,rdx」就是用來檢查餘數是否為零。

x86 指令：JMP

JMP 的語法是

JMP     標記

JMP 是「Jump」的意思，即無條件跳躍到標記 ( label ) 的位址處繼續執行。

如果標記是「@f」或「@b」的話，必定會有一個是「@@:」的標記。如果是「JMP @f」，代表往高位址跳躍到最近的「@@:」處；如果是「JMP @b」，代表往低位址跳躍到最近的「@@:」處。會有「@@:」標記的原因，主要是因為組合語言用到跳躍指令的機會不少，但是每次都要為標記取個名字很麻煩，因此用「@@:」代替。

CPU 指令：ENTER 與 LEAVE

ENTER 指令能簡化建立堆疊框的工作，它會完成以下三件事情：①把 RBP 推入堆疊；②把 RSP 之值存入 RBP 裏；③保留區域變數的空間。有關 RBP 暫存器、堆疊框稍後介紹。ENTER 的語法是：

ENTER   運算元1,運算元2

這裡的運算元1 與運算元2 都只能是常數。運算元1代表要為區域變數保留多少位元組的空間，如果副程式沒有區域變數，故可用「ENTER 0,0」，這樣就相當於：

        push    rbp
        mov     rbp,rsp

如果副程式有兩個資料類型是 QWORD 的區域變數，佔用十六個位元組，可用「ENTER 16,0」，等效於下面的指令：

        push    rbp
        mov     rbp,rsp
        sub     rsp,16

運算元2是可以八位元的常數，用來支援巢狀副程式，就是指一個副程式甲內包含另一個副程式乙，而乙能夠使用甲的區域變數。這裡的包含副程式乙，並不是呼叫副程式乙，而是原始程式中副程式甲裡面又有副程式乙的意思，如下面程式：

副程式甲　　PROC
　　　　　　enter   16,0
            ⁝
　副程式乙  PROC
            ⁝
　副程式乙  ENDP
            ⁝
副程式甲　　ENDP

在這種情形下，副程式甲使用「ENTER xx,0」，副程式乙使用「ENTER yy,1」。這種巢狀副程式因為能讀取上一層副程式的區域變數，會變得很複雜，因此像 C 語言就禁用這種副程式，初學者與老手都最好少用。

LEAVE 指令沒有運算元，它是用來刪去堆疊框的，語法是：

LEAVE

LEAVE 的過程恰好與 ENTER 相反：①把 RBP 之值存入 RSP 裏；②自堆疊彈出一數值到 RBP。LEAVE 並沒有像 ENTER 那樣有「ADD RSP,XX」的過程，事實上也不須這個功能，因為 LEAVE 會把原來存於 RBP 中的堆疊頂取回，這樣就完成刪除區域變數的功能了。總之，LEAVE 指令相當於底下兩個指令的組合：

        mov     rsp,rbp
        pop     rbp

StrToInt API

StrToInt 是把字串轉換成數值的 API，其用法是

invoke  StrToInt,\
        lpSrc           ; pointer to the null-terminated string to be converted

StrToInt 只有一個參數，lpSrc，這個參數是字串位址，此字串是以零結尾的字串，而字串內容應該是以阿拉伯數字組成的，如果字串含有不是阿拉伯數字的字元，那麼 StrToInt 就只轉換到此字元前的一個字元為止。例如 lpSrc 所指的字串是「"123xyz",0」，那麼所得的數值是 123。此字串的第一個字元可以是「-」，但不能為「+」，如果是「-」的話轉換後的數值為負整數。如果字串的第一個字元就不是阿拉伯數字，那麼所得的數值是 0。

StrToInt 只能轉換 32 位元長的正整數，最後所的數值，放在 EAX 返回。32 位元的正整數最大值為 4,294,967,295，超過的部分會被截掉。如果要轉換字串超過此數值，改用 StrToInt64Ex API。

wsprintf API

wsprintf 是模仿 C 語言的 printf 函式，可以數個變數和字串依據格式控制字串中指定的格式，寫到某個記憶體上。wsprintf 用法是：

invoke  wsprintf,\
        lpOut,\	        ; pointer to buffer for output
        lpFmt,\         ; pointer to format-control string
        ⁝               ; optional arguments

lpOut 與 lpFmt 都是字串的位址，前者是輸出的緩衝區字串位址，後者是格式控制字串的位址；而第三個參數以後是變數或暫存器的列表，其總數跟格式控制字串中「%」的個數相同。

格式控制字串標含格式規範（format specifications）及其他文字，wsprintf 會依格式規範的順序配合變數或暫存器的列表，一一將變數和字串轉換而寫入緩衝區字串。格式規範都以百分比符號（%）開始，其樣子如下，其中以一對中括號括住的可以省略：

%[-][#][0][width][.precision]type

如果 wsprintf 執行成功，回傳值是有多少個字元存入緩衝區（不含結尾的「0」）；如果失敗，回傳值小於格式控制字串的字元個數。

例如底下的例子：

.DATA
kilo     DQ      1024
szKilo   DB      "1K是",0
szFmt    DB      "%s%d，相當於十六進位的%x。",0
szBuffer DB      80 DUP (?)
         ⁝
         lea    rcx,szBuffer
         lea    rdx,szFmt
         lea    r8,szKilo
         mov    r9,kilo
         mov    QWORD PTR [rsp+20h],r9
         call   wsprintfA

格式控制字串中的「%」字元共有三個，因此格式規範也有三個（以白色標示），而變數與字串列表中也有三個元素。這三個格式規範依序是「%s」( 字串 )、「%d」( 十進位有號數 )、「%x」( 十六進位數 )，因此變數與字串列表中依序是字串位址及兩個變數 ( kilo )。執行後，wsprintfA 會把 szBuffer 字串會變成

1K是1024，相當於十六進位的400。

其中〝1K是〞是由「%s」運算的結果，〝1024〞是「%d」的結果，〝400〞是「%x」的結果。

LOCAL 假指令

LOCAL 假指令是用來定義區域變數 ( local variables，大陸翻成局部變量 )。區域變數相對於全域變數 ( global variables，全局變量 ) 而來的，它們的差別在於區域變數只能在某個副程式中定義，也只有在這個副程式中才能存取 ( 包含修改與讀取 )，其他副程式與主程式都無法存取；而全域變數則是任意副程式或主程式都能存取。也因為全域變數在任何地方都可以修改其數值，以致於造成與很許多副程式相關，對於程式的維護會增加許多負擔，尤其是程式很大時更加困難。現代的觀念認為，不必要的全域變數是寫程式的壞習慣之一，因此能不使用就別用，儘量使用區域變數。

那麼如何定義區域變數呢？在組合語言裡使用 LOCAL 假指令，它的語法是：

LOCAL   變數名稱[元素個數]:資料類型,...

定義區域變數有幾項細節要注意：

  1. 如果此變數只有一個元素，亦即不是陣列 ( array ) 或字串的的話，「[元素個數]」可以省略。
  2. 資料類型必須是 BYTE、WORD、DWORD、QWORD 其中之一，不能用 DB、DW、DD、DQ。
  3. 一行 LOCAL 可以定義多個區域變數，中間以「,」隔開。如果只定義一個，就省略後面的「,...」。
  4. LOCAL 無法設定區域變數的初始值，必須由副程式中自行設定。許多錯誤的產生，就是沒有設定初始值。
  5. LOCAL 必須緊接著 PROC 宣告之後。不過 PROC 與 LOCAL 之間可以插入一行或數行註解。

例如底下的例子，定義了兩個四字組的區域變數，qRead 與 qWritten，與一個 24 位元組長的 sNumber 字串：

        LOCAL   qRead:QWORD,qWritten:QWORD
        LOCAL   sNumber[24]:BYTE

我們知道全域變數是存放在「.DATA」或「.DATA?」區段內，那麼區域變數存放在哪裡呢？答案是在堆疊裡，也就是這個原因，只有在執行時才能確認區域變數的位址。也因為如此，如果要取得區域變數的位址，必須使用「LEA 目的運算元,區域變數」，無法使用「MOV 運算元,OFFSET 區域變數」這樣的指令。

底下先來瀏覽 GCD_LCM.ASM 的原始程式，緊接著說明撰寫副程式時應注意事項，包含如何在堆疊中安排區域變數與其存取。

GCD_LCM.ASM 原始程式與解說

GCD_LCM.ASM 原始程式

底下是 GCD_LCM.ASM 原始程式的內容：

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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
;計算兩整數的最大公因數（GCD）與最小公倍數（LCM）
;組譯與連結：
;path e:\masm32\bin64;%path%
;set link=/subsystem:console /entry:main
;ml64 gcd_lcm.asm
OPTION          CASEMAP:NONE
EXTRN           GetStdHandle:PROC,WriteConsoleA:PROC,ReadConsoleA:PROC
EXTRN           ExitProcess:PROC,StrToIntA:PROC,wsprintfA:PROC
INCLUDELIB      e:\masm32\lib64\kernel32.lib
INCLUDELIB      e:\masm32\lib64\shlwapi.lib
INCLUDELIB      e:\masm32\lib64\user32.lib
STD_INPUT_HANDLE        EQU     -10
STD_OUTPUT_HANDLE       EQU     -11
INVALID_HANDLE_VALUE    EQU     -1  
;***************************************************************************************************
.CONST
sStr1   DB      "計算兩正整數的最大公因數與最小公倍數",0dh,0ah,"輸入第一個正整數（小於一億）："
sStr2   DB      "輸入第二個正整數（小於一億）："
szFmt   DB      "%d與%d的最大公因數是%d，最小公倍數是%I64u。",0
sError1 DB      "請輸入阿拉伯數字且不能為零。"
sError2 DB      "無法取得標準輸出/輸入裝置。"
;***************************************************************************************************
.DATA
hOut    DQ      ?
hIn     DQ      ?
n1      DQ      ?
n2      DQ      ?
Gcd     DQ      ?
Lcm     DQ      ?
sBuffer DB      48 DUP (0)
;***************************************************************************************************
.CODE
;---------------------------------------------------------------------------------------------------
;利用輾轉相除法，計算兩整數的GCD；再利用LCM＝num1*num2/GCD求LCM
;輸入：num1、num2兩個整數
;　　　pGcdLcm－GCD與LCM的存放位址，指向兩個四字組，位址低的存GCD，高的存LCM
find_gcd_lcm    PROC    num1:QWORD,num2:QWORD,pGcdLcm:QWORD
        mov     r10,rcx
        mov     r11,rdx
        mov     pGcdLcm,r8
        cmp     rcx,rdx ;RCX＝num1，RDX＝num2
        jb      below   ;若RCX小於RDX，則跳躍到below
again:  xchg    rcx,rdx ;餘數變為下次的除數
below:  mov     rax,rdx
        xor     rdx,rdx ;RDX:RAX（被除數）除以RCX（除數）
        div     rcx     ;除數＝RCX
        or      rdx,rdx ;餘數為RDX，若為零則最後一次的除數即為GCD
        jnz     again
        mov     [r8],rcx;把最大公因數存入pGcdLcm所指的位址
        mov     rax,r10
        mul     r11
        div     rcx
        mov     [r8+8],rax
        ret
find_gcd_lcm    ENDP
;---------------------------------------------------------------------------------------------------
;把pStr位址上的字串（長lenStr個位元組）印在標準輸出裝置（hOutput）螢幕上，當做提示使用者該輸入什麼
;資料，等使用者輸入完畢，轉換整數數值，存於RAX
;輸入：hOutput－標準輸出裝置代碼，印出提示字串時使用
;　　　hInput－標準輸入裝置代碼，使用者輸入字串時使用
;　　　pStr－提示字串位址
;　　　lenStr－提示字串長度
;輸出：RAX＝0－失敗
;　　　RAX≠0－成功，RAX＝使用者輸入的正整數
input_integer   PROC    hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD
        LOCAL   qRead:QWORD,qWritten:QWORD
        LOCAL   sNumber[24]:BYTE
        sub     rsp,28h
        mov     hOutput,rcx             ;把前四個參數保存在堆疊裡
        mov     hInput,rdx
        mov     pStr,r8
        mov     lenStr,r9

        mov     rdx,pStr
        mov     r8,lenStr
        lea     r9,qWritten
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA           ;印出pStr所指位址的字串
        or      rax,rax
        jz      exit

        mov     rcx,hInput
        lea     rdx,sNumber
        mov     r8,14
        lea     r9,qRead
        mov     QWORD PTR [rsp+20h],0
        call    ReadConsoleA            ;輸入數值(此為數值形式的ASCII字串)
        or      rax,rax
        jz      exit

        lea     rcx,sNumber
        call    StrToIntA               ;把數值形式的ASCII字串變成數值
exit:   add     rsp,28h
        ret
input_integer   ENDP
;---------------------------------------------------------------------------------------------------
main    PROC
        sub     rsp,38h
;取得標準輸出輸入裝置代碼，如果失敗跳至err2處，印出錯誤訊息後退出GCD_LCM
        mov     rcx,STD_OUTPUT_HANDLE
        call    GetStdHandle
        cmp     rax,INVALID_HANDLE_VALUE
        je      err2
        mov     hOut,rax

        mov     rcx,STD_INPUT_HANDLE
        call    GetStdHandle
        cmp     rax,INVALID_HANDLE_VALUE
        je      err2
        mov     hIn,rax
;印出提示，讓使用者輸入兩個正整數。若發生錯誤，跳至err1印出
;訊息後退出GCD_LCM；否則把輸入的兩正整數分別存於n1、n2
        mov     rcx,hOut
        mov     rdx,hIn
        lea     r8,sStr1
        mov     r9,SIZEOF sStr1
        call    input_integer   ;輸入第一個整數
        or      rax,rax
        jz      err1
        mov     n1,rax

        mov     rcx,hOut
        mov     rdx,hIn
        lea     r8,sStr2
        mov     r9,SIZEOF sStr2
        call    input_integer   ;輸入第二個整數
        or      rax,rax
        jz      err1
        mov     n2,rax
;求n1、n2的最大公因數與最小公倍數，分別存入Gcd、Lcm變數裡
        mov     rcx,n1
        mov     rdx,n2
        lea     r8,Gcd
        call    find_gcd_lcm
;把「n1與n2的最大公因數是Gcd，最小公倍數是Lcm。」字串存入sBuffer中。
;此四個數值都已被wsprintfA轉換成十進位數形式的字串。
        lea     rcx,sBuffer
        lea     rdx,szFmt
        mov     r8,n1
        mov     r9,n2
        mov     r10,Gcd
        mov     r11,Lcm
        mov     QWORD PTR [rsp+20h],r10
        mov     QWORD PTR [rsp+28h],r11
        call    wsprintfA
;把該字串印出來
        lea     rdx,sBuffer
pnt_it: mov     rcx,hOut
        mov     r8,rax
        lea     r9,n1
        mov     QWORD PTR [rsp+20h],0
        call    WriteConsoleA
        jmp     @f
err1:   lea     rdx,sError1
        mov     rax,SIZEOF sError1
        jmp     pnt_it
err2:   lea     rdx,sError2
        mov     rax,SIZEOF sError2
        jmp     pnt_it
@@:     xor     rcx,rcx
        call    ExitProcess
main    ENDP
;***************************************************************************************************
END

組譯與連結的方法，跟前一章相同，要注意的是必須設定「set link=/subsystem:console /entry:main」。

main 主程式

GCD_LCM 的進入點在第 97 行，「main PROC」。接下來的第一道指令是「sub rsp,38H」，這是因為在 main 中呼叫了好幾個 Win64 API 及 input_integer、find_gcd_lcm 副程式，它們所需的參數要保留在堆疊上。利用「sub rsp,38H」，使 RSP 減少 38H 個位元組，堆疊頂往低位址移動，就能保留 38 個位元組的空間。在 main 中最多參數的副程式是 wsprintfA，共有六個參數，所以使 RSP 減去 38H ( 參閱第二章在堆疊中保留參數空間與對齊節的邊界的策略 )。

main 主程式大致可分為八個部分：

  1. 第 98 行：「sub rsp,38H」保留堆疊空間，給參數使用。
  2. 第 99∼110 行：呼叫 GetStdHandle 兩次，先後獲得標準輸出裝置代碼及標準輸入裝置代碼，並存入全域變數 hOut 與 hIn 裡。
  3. 第 111∼129 行：呼叫 input_integer 副程式兩次，每次都會提示使用者輸入正整數，等使用者按下「Enter」鍵輸入完畢後，將這個正整數存入 n1 及 n2 全域變數裡。
  4. 第 130∼134 行：呼叫 find_gcd_lcm 副程式，計算 n1、n2 的最大公因數及最小公倍數。
  5. 第 135∼145 行：呼叫 wsprintfA，把最大公因數及最小公倍數轉換成字串。
  6. 第 146∼153 行：把上步驟的字串印在「命令提示字元」的視窗內。
  7. 第 154∼159 行：處理錯誤。
  8. 第 160∼162 行：結束 GCD_LCM.EXE 程式。

本章一開始就提過，本章的重點是呼叫副程式的過程，而且其他部分不是解說過，就是不難，所以不說明了。所以，底下來看看第三部分與第四部分。

input_integer 副程式

input_integer 會把提示字串，也就是「計算兩正整數的最大公因數……輸入第一個正整數……」這樣的字串顯示在「命令提示字元」內，同時也要讓使用者輸入，因此一定需要傳入兩個參數：標準輸出裝置代碼及標準輸入裝置代碼。再加上要印出字串，一定也要有輸入字串位址及字串長度。這樣加起來就有四個參數了。因此宣告 input_integer 的程式碼如下：

;把pStr位址上的字串（長lenStr個位元組）印在標準輸出裝置（hOutput）螢幕上，當做提示使用者該輸入什麼
;資料，等使用者輸入完畢，轉換整數數值，存於RAX
;輸入：hOutput－標準輸出裝置代碼，印出提示字串時使用
;　　　hInput－標準輸入裝置代碼，使用者輸入字串時使用
;　　　pStr－提示字串位址
;　　　lenStr－提示字串長度
;輸出：RAX＝0－失敗
;　　　RAX≠0－成功，RAX＝使用者輸入的正整數
input_integer   PROC    hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD

這也就是在 GCD_LCM.ASM 的第 57∼65 行。通常在宣告副程式時，也要養成良好習慣，在副程式前加上註解，以說明這個副程式的用途、參數及回傳值，以利之後修改。

這四個參數必須寫在「PROC」之後，以「參數名稱:資料類型」的方式宣告，如果有很多參數就以接在後面，以「,」隔開。這些「參數名稱」只能在這個副程式的範圍有效，也就是說只有這個副程式存取，其他副程式或主程式都無法存取。如果在副程式中想使用到可變的暫存器 ( 見第零章可變與不變的暫存器 )，也可以使用 USES 將其保存起來。例如想要保存 RSI 及 RDI，可以這樣宣告 ( 暫存器之間以空白分隔 )：

input_integer   PROC    USES rsi rdi hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD

那 main 又如何呼叫 input_integer 呢？在 GCD_LCM.ASM 中呼叫 input_integer 的程式碼有兩處，如下：

輸入第一個整數輸入第二個整數
       mov     rcx,hOut
       mov     rdx,hIn
       lea     r8,sStr1
       mov     r9,SIZEOF sStr1
       call    input_integer   ;輸入第一個整數		        mov     rcx,hOut
       mov     rdx,hIn
       lea     r8,sStr2
       mov     r9,SIZEOF sStr2
       call    input_integer   ;輸入第二個整數

主程式把參數傳給副程式時，不能用在宣告副程式時，放在 PROC 之後的「參數名稱」，必須依據 x64 呼叫慣例。也就是前四個參數必須存入 RCX、RDX、R8、R9 暫存器裡，超過的部分要存入堆疊裡 ( 像是 [RSP+20h]、[RSP+28h]…… )，最後才執行 CALL 指令。像上面表中的樣子，也就是 GCD_LCM.ASM 的第 113∼117 行或是第 122∼126 行。

如果副程式中要用到區域變數，可以用「LOCAL」假指令定義區域變數。LOCAL 必須緊接著 PROC 之後，像底下的樣子：

input_integer   PROC    hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD
        LOCAL   qRead:QWORD,qWritten:QWORD
        LOCAL   sNumber[24]:BYTE

在副程式中，要存取參數，才使用放在 PROC 之後的「參數名稱」。要存取區域變數時，也是用 LOCAL 定義時候的變數名稱。參數與區域變數，都只有在其宣告與定義的副程式內才有效，才能存取。原因很簡單，它們都存放在堆疊中，呼叫完畢，堆疊框也就銷毀了，當然其他副程式甚至主程式都無法存取。

底下的例子就是在 input_integer 把原本存在四個暫存器的參數值，存入參數中，見「GCD_LCM.ASM」的第 69∼72 行。通常進入副程式以後，會做這件事情，讓暫存器可以用作其他用途，例如做乘除運算等等；當然也可以不做，視需要而定。

        mov     hOutput,rcx             ;把前四個參數保存在堆疊裡
        mov     hInput,rdx
        mov     pStr,r8
        mov     lenStr,r9

底下是取得區域變數 sNumber 的位址，見「GCD_LCM.ASM」的第 91 行：

        lea     rcx,sNumber

事實上，在宣告副程式、定義區域變數，以及在結束副程式時執行 RET 指令的地方，組譯器都會添加一些指令，讓在副程式之中以 RBP 為基準存取參數及區域變數。底下的表格，是以 input_integer 為例子，把原始程式與組譯後程式碼並列作為比較：

原始程式組譯後結果
input_integer   PROC    hOutput:QWORD,hInput:QWORD,\
                        pStr:QWORD,lenStr:QWORD
       LOCAL   qRead:QWORD,qWritten:QWORD
       LOCAL   sNumber[24]:BYTE
       sub     rsp,28h
       mov     hOutput,rcx
       mov     hInput,rdx
       mov     pStr,r8
       mov     lenStr,r9
       ⁝
       lea     rcx,sNumber
       call    StrToIntA
exit:  add     rsp,28h
       ret
input_integer   ENDP		        push    rbp
       mov     rbp,rsp
       add     rsp,-40
       sub     rsp,28h
       mov     [rbp+10h],rcx
       mov     [rbp+18h],rdx
       mov     [rbp+20h],r8
       mov     [rbp+28h],r9
       ⁝
       lea     rcx,[rbp-28h]
       call    StrToIntA
       add     rsp,28h
       leave
       ret

上表中，左欄橙色字是宣告 input_integer，組譯成右邊橙色字的「push rbp」與「mov rpb,rsp」；左欄黃字是定義區域變數的兩行，組譯後僅變成一道指令「add rsp,-40」；左欄白色字是結束副程式返回主程式的「ret」指令，組譯後變為兩道指令「leave」與「ret」。為什麼會這樣呢？這是為了存取參數及區域變數所做的設定，待會兒以 x64dbg 對 input_integer 進行單步時，就能明瞭了。

現在就用 x64dbg 載入 GCD_LCM.EXE，如下圖。前面的第 97∼110 行都跳過，而設置 input_integer 參數的部分也跳過，在即將執行「call input_integer」前設置中斷點 ( 以滑鼠點擊位址 13FBC1100 處，再按「F2」鍵，見下圖藍色框 )。 注意到上圖反組譯區的橙色框內的返回位址是 13FBC1105，待會會用到。另外，以綠色框框起來的是 GCD_LCM.EXE 進入點後的第一個指令，「sub rsp,38h」，剛剛已提為何要使 RSP 減去 38H，這裡就不再贅述；此時 RSP 為 2DF7D8H，所以減去之後 RSP 為 2DF7A0H，故返回位址應存在堆疊位址 2DF798H 處。

按下「F9」鍵執行，到中斷點 13FBC1100 處會停下來，再按「F7」鍵執行「call input_integer」，進入 input_integer 副程式裡面，如下圖。先觀察堆疊區的 2DF798H 位址上已推入返回位址。再來觀察反組譯區，以藍色框框住的是 input_integer 副程式，與原始程式 GCD_LCM.ASM 比較，就會發現多出了以紅色框框住的四行程式碼：①「push rbp」、②「mov rbp,rsp」、③「add rsp,FFFFFFFFFFFFFFD8」、④「leave」。 除了多出四個指令外，參數與區域變數都變成以「[rbp+xx]」或「[rbp-xx]」表示，例如 GCD_LCM.ASM 的第 69∼72 行是把存於暫存器的四個參數保存在堆疊中，原本的程式碼是

        mov     hOutput,rcx             ;把前四個參數保存在堆疊裡
        mov     hInput,rdx
        mov     pStr,r8
        mov     lenStr,r9

結果變成上圖以綠色框框住的指令。

RBP 是 CPU 內一個 64 位元的暫存器，英文名字叫 base pointer register，可以翻譯成基底指標暫存器，通常是用來當做基準，存取堆疊中的參數以及區域變數用的暫存器。像這種以暫存器為基準再加上或減去一個常數，當做位址，再到位址去讀取或寫入數值的方式，是間接定址的一種。

從這裡就可以看出來，在副程式中要存取參數或區域變數，都是以 RBP 當成基準。多出來的前兩道指令，就是把原來的 RBP 值保存在堆疊裡，然後把 RBP 指向當前 RSP 所指的位址，這樣既能保存原來的 RSP 值，也可以把當前 RSP 所指的位址當做是基準位址，存取第一個參數時就以「[rbp+10h]」表示、第二個參數時就以「[rbp+18h]」表示……。然後 RSP 就能自由使用，這樣就能在副程式裡再繼續呼叫其他副程式或 Win64 API，而不會有問題。等到副程式結束時，執行多出來的第四道指令「leave」以使 RBP 恢復原值並使 RSP 所指的堆疊頂是返回位址。LEAVE 指令實際上可以看成是

        mov     rsp,rbp
        pop     rbp

如此一來，RSP 就還原成原來的堆疊頂了，RBP 也恢復成剛進入副程式時候的數值了。

多出來的第三道指令是「add rsp,FFFFFFFFFFFFFFD8」，這個指令是因為區域變數造成的。GCD_LCM.ASM 的第 66∼67 行是：

        LOCAL   qRead:QWORD,qWritten:QWORD
        LOCAL   sNumber[24]:BYTE

這兩行是定義區域變數。兩個四字組變數，共 16 個位元組，再加上一個 24 個位元組的字串變數，總共 40 個位元組，換成十六進位是 28H。也就是必須在堆疊保留 28H 個位元組作為區域變數的空間，本來應該是用「sub rsp,28h」，但是減去 28H，相當於加上 -28H，負 28H 其實就是「FFFFFFFFFFFFFFD8H」。( 註一 )

緊接著在「add rsp,FFFFFFFFFFFFFFD8」後的指令是「sub rsp,28」( 見「GCD_LCM.ASM」第 68 行 )。在副程式中，大部分時候都還會再呼叫其他副程式或 Win64 API。這保留的 28H 個位元組的堆疊空間，是給 input_integer 內，呼叫其他副程式或 Win64 API 時的參數使用。

在 input_integer 副程式內，還呼叫三個 Win64 API，分別是 WriteConsoleA、ReadConsoleA、StrToIntA，參數最多的是 WriteConsoleA、ReadConsoleA，有五個參數，所以把 RSP 減去 28H。

這個保留給 input_integer 內呼叫副程式時，參數所使用的堆疊，在返回 main 時也必須由呼叫方清除，也就是由 input_integer 銷毀。因此在「GCD_LCM.ASM」第 93 行有一道「add rsp,28h」指令，其作用就是清理堆疊。見第二章x64 呼叫慣例的第 5 點說明。

底下小木偶想補充一點。有時候在撰寫副程式時，會要用到某些「不變的暫存器」，例如在處理字串時常用到 RSI、RDI，這時候必須將其保留起來，可以利用 PROC 的屬性－－USES。假設 input_integer 要保存 RSI、RDI，那麼可以這樣寫

input_integer   PROC    USES esi edi hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD

保存起來的暫存器之間以空白相隔。這樣的話，組譯器會自動在「add rsp,-40」與「sub rsp,28h」之間，加上「push rsi」與「push rdi」，變成

        add     rsp,-40
        push    rsi
        push    rdi
        sub     rsp,28h

而且在副程式返回主程式的「ret」前會加上「pop rdi」與「pop rsi」，再加上原先添加的「leave」指令，最後變成

        pop     rdi
        pop     rsi
        leave
        ret

這樣就能把不變的暫存器保存在堆疊裡，然後安心地使用它們，不必擔心程式崩潰。而這種動作只需要在 PROC 加上「USES」，不須再添加額外的指令，非常方便。

好了，言歸正傳。現在即將執行 input_integer 的第一個指令，「push rbp」及之後的幾個指令，但都已解釋過了。所以直接跳過，按 12 次「F7」鍵，到「call WriteConsoleA」，然後按「F8」鍵，再按 7 次「F7」鍵，到「call ReadConsoleA」停止。如下圖： 然後按「F8」鍵，這時候是呼叫 ReadConsoleA，等待使用者輸入。必須在螢幕最底下的工作列找到「命令提示字元」，在其內輸入數值。假設輸入「12345678」，按「Enter」鍵輸入完畢。如下圖：

接著，使用者必須自行切換到 x64dbg 視窗觀察結果，如下圖： 看到上圖的堆疊區中，ReadConsoleA 已經在區域變數，sNumber，裡面填入了我們剛剛輸入的字串。我們輸入的是字串，所以先輸入的字元在低位址，「1」在低位址、「8」在高位址；但是，在堆疊區的資料是以整數形式表示，所以「8」是高位數、「1」是低位數。我們看到的排列情形，就如同 sNumber 字串，用不深不淺的藍色框線框住的那樣。另外兩個區域變數，也顯示在圖上。這裡可以檢驗 qRead 的數值，我們總共輸入十個字元 ( 包含 0DH、0AH )，所以 qRead 中的數值為 0AH，即十進位的 10 ( 以淡藍色的框線框住 )。

堆疊框 ( Stack Frame )

到此已經介紹完呼叫副程式時，堆疊種種變化的情形。但剛剛是以 x64dbg 追蹤整個過程來說明，有點兒煩瑣，底下以圖片簡明扼要地整理整個過程。

此外，小木偶私下揣測，以後大概再也沒有機會介紹，呼叫副程式時堆疊的變化過程了。所以為了更完整說明，小木偶假設 input_integer 副程式有五個參數，而且 PROC 有使用「USES」屬性，所以 input_integer 副程式變成：

input_integer   PROC    USES rsi rdi hOutput:QWORD,hInput:QWORD,pStr:QWORD,lenStr:QWORD,fifth:QWORD
                LOCAL   qRead:QWORD,qWritten:QWORD
                LOCAL   sNumber[24]:BYTE
                ⁝
                ret
input_integer   ENDP

經過組譯後的 input_integer 副程式會變成下表左邊欄位，而呼叫的方式則是下表右邊欄位：

           push    rbp
           mov     rbp,rsp
           add     rsp,-28h
           push    rsi
           push    rdi
           sub     rsp,28h
           ⁝
           pop     rdi
           pop     rsi
           leave
           ret		            mov     rcx,參數一
           mov     rdx,參數二
           mov     r8,參數三
           mov     r9,參數四
           mov     QWORD PTR [rsp+20h],參數五
           call    input_integer

其堆疊的變化過程，如下圖。圖一是尚未呼叫 input_integer，也就是即將執行「call input_integer」但還未執行時，堆疊內的情形。這時候，堆疊頂指向參數一的位址，依據 x64 呼叫慣例，此位址如以十六進位表示，其「個位數」必須是零。見下圖一，此位址是「2DF7A0」，符合此項慣例。

當然，參數一還未真正存入到這個位址的記憶體內，參數二、三、四也是如此；只是留下影子空間，等進入副程式後再把這些參數填入堆疊內 ( 不過副程式是否真的要把這些參數保存在影子空間中，可以自由決定 )。第一∼四個參數是存入暫存器中傳給副程式，第五個參數以及以後的參數則是必須以堆疊傳給副程式。第五個參數的位址是「RSP＋20h」；第六個參數的位址是「RSP＋28h」( 如果有的話 )……其餘依此類推。

圖二∼圖三是進入 input_integer 副程式後所做的工作：
①、首先把 RBP 推入堆疊保存起來，再使 RSP 之值移入 RBP 內，堆疊內的情形就如同圖二。這時候，RBP、RSP 都指向同一位址，2DF790。
②、保留區域變數所需空間。input_integer 副程式的區域變數總共 40 個位元組，變成十六進位是 28H，因此執行「add rsp,-28h」就可以了。第一個區域變數的位址是「RBP－08h」，以後的區域變數位址則視前面的區域變數的總長度及本身的長度決定。不過這不須程式設計師擔心，組譯器能自動決定。以 input_integer 為例，因為第一個區域變數長度是四字組，所以第二個位址就是「RBP－10h」。
③、處理 PROC 的 USES 屬性，其實就是把其後所接的暫存器一一推入堆疊保存起來。
④、如果副程式內也呼叫其他副程式或 Win64 API，那麼也要為其他副程式或 Win64 API 保存影子空間。以 input_integer 為例，在 input_integer 內呼叫的 Win64 API 中，參數最多的是 WriteConsoleA、ReadConsoleA，有五個參數，所以把 RSP 減去 28H。

我們可以自由為參數、區域變數取個響亮的名稱，而組譯器會自動計算出位址來。但是如果超過四個參數，多出來的就只能用像「[rsp+20h]」這種方式表示，不過以後會加入包含檔或以 UASM 組譯，也可以不用這種方式表示。

像這樣，呼叫副程式時，由最後一個參數所存放的堆疊空間開始，往堆疊的低位址分別是各個參數、返回位址、原來的 RBP，區域變數到保留的暫存器，這一段堆疊內容稱為「堆疊框」( stack frame，大陸翻譯成「棧幀」 )。

find_gcd_lcm 副程式

find_gcd_lcm 是利用輾轉相除法，求得兩正整數的最大公因數，然後再以兩數之乘積除以最大公因數，所得之商即為最小公倍數。

輾轉相除法也叫歐幾里得算法 ( Euclidean algorithm )，是計算兩整數的最大公因數的方法。過程是兩數相除所得的餘數為下次相除的除數，下次相除的被除數為原來的除數，這樣一直相除直到整除為止，最後一次的除數即為最大公因數。例如要求 18、48 的最大公因數的過程，可以參考下圖： 第一次相除的被除數，當然是選擇較大的數，較小的是除數，所以用「48÷18＝2…12」。第二次相除的被除數是第一次的除數，而除數則是第一次的餘數，所以是「18÷12＝1…6」( 事實上，餘數一定比除數小，所以還是選擇較大的為被除數，較小的為除數 )。第三次相除的被除數是第二次的除數，而除數則是第二次的餘數，所以是「12÷6＝3…0」，結果整除，所以最大公因數就是最後一次的除數，6。

如果把這過程畫成電腦程式的流程圖，就變成下面的樣子：

輾轉相除法的原理請參閱HPM 通訊第十卷第十一期，這裡不介紹，此處要看的是組譯後的副程式，如下圖： 以藍色框線框住的就是 find_gcd_lcm 副程式。原始程式的 find_gcd_lcm 內沒有區域變數，也沒有呼叫其他副程式或 Win64 API，只是單純的計算，所以不須要調整 RSP 之值。

在 find_gcd_lcm 裡，事實上也不需要把參數存入記憶體中，用暫存器儲存就夠用了。但是為了說明，小木偶還是在 GCD_LCM.ASM 的第 40 行寫了「mov pGcdLcm,r8」，其實這是多餘的。它是把第三個參數存入影子空間。照前面的所說的圖三，第三個參數的位址是在「RBP＋20h」，果然在上圖藍色框線內把「mov pGcdLcm,r8」組譯成「mov [rbp+20h],r8」。

find_gcd_lcm 的第三個參數是一個位址，當 find_gcd_lcm 計算完兩數的最大公因數與最小公倍數後，會把前者存入此位址的記憶體內，把後者存入比此位址再高八個位元組的位址之記憶體內。在 Win64 API 中，也有許多參數是這種樣子。

結論

本章一開始就說，這一章是要說明如何自行宣告副程式以及其呼叫與執行的過程。

第一、宣告副程式使用 PROC/ENDP 假指令，

label  PROC  USES 暫存器列表 參數1:資料類型,參數2:資料類型...
　　　　LOCAL      變數名稱:資料類型
　　　　程式片段
label  ENDP

詳細情形參閱第一章宣告副程式：PROC/END。這裡要說的是：①在原始程式裡，宣告副程式要在執行 CALL 之前，否則就會發生錯誤。②如果有使用區域變數，LOCAL 必須緊接著 PROC 之後，如果不這樣也會發生錯誤。

第二，主程式必須保留堆疊空間供給副程式的參數使用，這有兩種策略：①在主程式一開始時，程式設計師自行統計哪個副程式的參數最多，保留堆疊空間的多少以此副程式為準。②每次呼叫副程式時，依這個副程式的參數保留堆疊空間。可以參考第一章的 FIRST.ASM 與第二章的 FIRST1.ASM，前者採用策略①，後者採用策略②。即使如此，往後我們載入包含檔或採用 UASM 組譯器時，幾乎不必擔心這個問題，因為包含檔與組譯器都已幫程式設計師安排好了。

第三、呼叫完之後，主程式必須銷毀保留給副程式參數的堆疊空間。這有兩種情形：①主程式結束時呼叫 ExitProcess，這樣就結束程式，控制權歸還給 Windows 作業系統，就不須擔心這種情形。②如果是副程式中又呼叫其他副程式，把前者當作甲副程式，甲副程式中可能會呼叫 A 副程式、B 副程式等等；不過在結束甲副程式之前，組譯器會自動插入「LEAVE」指令，這樣就銷毀保留給副程式參數的堆疊空間了。因此程式設計師其實不必擔心第三件事，因為組譯器已經安排好了。

第四、也是最重要的一點。不管往後使用①ML64.EXE 組譯器與 hutch-- 主導的包含檔或②使用 UASM 組譯器與 WinInc 包含檔，往後呼叫副程式或 Win64 API 都用「INVOKE」假指令或巨集，而且不需擔心上面種種細節。小木偶花了這麼多的篇幅，介紹這麼複雜的過程，只為揭破這細節，讓這過程攤在陽光下，為大眾所知，這才是組合語言的本色。

接下來，還要再花兩章的篇幅介紹巨集，這樣才能更明瞭 INVOKE 到底在做什麼。

註一

有關負數的原理，以後再說。但是，現在我們可以用「小算盤」驗證看看，在 64 位元的記憶體中：

-28H＝FFFFFFFFFFFFFFD8H

開啟左下角「開始」→「應用程式」→「小算盤」，然後在上面的主選單選「檢視」→「程式設計師」，進入不同類型的計算機後，如下面左圖，選左邊的「十六進位」圓形按鈕，然後輸入 28。此時螢幕上會顯示十六進位的 28，此時還是正數，見下面左圖。現在按下「±」按鈕 ( 圖中「滑鼠游標」所指處，其按鈕略帶橙色 )，就會變成負數，也就是 -28H，而小算盤顯示為「FFFFFFFFFFFFFFD8」。也就是說：

-28H＝FFFFFFFFFFFFFFD8H