上圖中，ModR/M 位元組的 Mod 欄位以及 R/M 欄位用來表示運算元，也就是暫存器。查閱第 24 章「Bit-32 Mod 與 R/M 的關係」，得知 Mod 為 11 時，R/M 數值不同代表不同的暫存器。R/M 有三個位元，恰好可以表示八個通用暫存器。x86 家族的 CPU 自民國 67 年（西元 1978 年）發展至今，經歷過許多次改革，添加了許多新的指令。但是環顧市面上談論組合語言的書籍，所介紹的 x86 指令仍然停留在當初制定的 8086/8088 指令，對於新添的指令避而不談。有一種原因，可能是他們所使用的組譯器，MASM 6.11d 是民國 84 年發表的，並不支援後來新加入的指令。而他們也別無選擇，因為 MASM 6.11d ，雖然很古老，但卻是微軟最後一版單獨販售的組譯器。
說實在的，這的確也不能怪他們。但是有沒有可能，可以在舊的 MASM 6.11 添加新的指令，而讓這些新的指令也能在 MS－DOS 作業系統下組譯、連結成功，並且還能執行成功呢？答案是肯定的，我們可以藉由「巨集」以及「條件組譯」，讓不支援新指令的組譯器，也能順利組譯這些新指令，也能連結成功，最後也可以執行。你說，是不是很奇妙啊？
在這一章裏面，小木偶就以在民國 101 年（西元 2012 年）才在 x86 指令集中新添加的 RDRAND 為例子，介紹如何以「巨集」及「條件組譯」搭配前一章所說的「機械碼」，讓 MASM 6.11 也能使用 RDRAND 指令。在說明之前，先介紹 RDRAND 指令。
RDRAND 是 read random，亦即讀取亂數的意思，它是從內建於晶片中的熵源（entropy source）產生亂數種子，而後再由此亂數種子初始化硬體亂數產生器，以生成亂數。這種熵源可以依據各種隨機性的來源，例如微弱的電子雜訊、熱雜訊、或其他來自硬體的不確定生成亂數種子，確保生成的亂數是具有良好隨機性的。RDRAND 的語法是：
RDRAND 暫存器
這裏的暫存器可以是 16、32、64 位元的通用暫存器，例如 RAX、EAX、AX 等等。亂數產生器會依據暫存器的大小，產生相對應大小的亂數，並存於此暫存器中。如果前述過程順利完成，CPU 會設定進位旗標，否則會清除進位旗標。應用程式應該要檢查進位旗標，以確保正確性。
巨集是一系列文字敘述或一些指令的集合（大陸把 macro 翻譯成「宏」）。一旦宣告巨集之後，就可以在原始程式引用此巨集。組譯器在組譯原始程式時期，如果遇見已宣告過的巨集，會預先處理巨集，「展開」（expand）成原來的假指令或 x86 指令，安插在引用巨集的地方。這樣只需宣告一次巨集，就能重複多次引用，以達到精簡原始程式的目的。如果巨集再配合條件組譯與巨集運算子，甚至會有意想不到的效果。
巨集分成下面五種類型：
在開始介紹巨集之前，要先說明使用巨集的術語。在 MASM 6.1 手冊中，使用巨集的方式稱為「呼叫」，而在這個網頁中，改成「引用」，原因是為了避免與副程式混淆。巨集與副程式都能精簡原始程式，但兩者並不相同。組譯器組譯原始程式之後，對副程式只會產生一份機械碼，每當主程式呼叫副程式時，都會跳躍到副程式所在之處執行，等副程式執行完畢再跳回原來地方，繼續下面的程式。但是組譯器對巨集卻不是這樣，每次使用巨集時，都會產生一份機械碼，取代使用巨集的地方，即使是使用同一個巨集。而當程式執行到巨集時，也就依照順序執行，不會發生跳躍的情形。因此雖然 MASM 6.1 手冊上稱使用巨集為呼叫巨集，但在這個網頁中，改成「引用」巨集。
這一章只會提到與讓 MASM 6.11 能使用 RDRAND 指令有關的巨集。因此雖然巨集分成五種類型，但並不會都介紹。如果想瞭解其他類型，或在本章中語焉不詳的巨集用法，可以參閱 Win64 組合語言的第五章與第六章，這兩章有較完整的介紹。
先介紹最簡單也是最常用的巨集－－巨集程序。因為它太常用了，所以有時候巨集程序也被稱為巨集，當然這很容易混淆，有時必須由上下文才能分得清楚。
在原始程式中定義巨集程序的方法是使用 MACRO/ENDM 假指令，語法如下：
巨集名稱 MACRO 參數列表
敘述
ENDM
巨集程序的形式如上，底下必須再更進一步說明：
現在可以來試試看巨集如何精簡原始程式了。在第四章，介紹了一個 HELLOW1.ASM 程式，其原始程式如下：
.MODEL SMALL,C
.386
.STACK
;***********************************************************
.DATA
msg DB "Hellow, World.$"
;***********************************************************
.CODE
.STARTUP
mov dx,OFFSET msg
mov ah,9
int 21h
.EXIT 0
;***********************************************************
END
HELLOW1.ASM 呼叫了兩次 DOS 服務程式：①第一次是呼叫印出字串的 AH＝09H/INT 21、②第二次呼叫是 AH＝4CH/INT 21，但已經簡化成「.EXIT 0」假指令了，就不必再多事了。因此把注意力集中在如何精簡 AH＝09H/INT 21，這裏所說的精簡並非精簡 DOS 內部有關此中斷的程式碼，而是精簡原始程式。假設想將 AH＝09H/INT 21 精簡成類似高階語言的「display 字串」這樣的指令，那麼 display 巨集可以像底下藍色框內的這樣寫：
display MACRO string ;;巨集開始 LOCAL temp ;;將temp設為區域性的 .DATA temp DB string,"$" ;;在參數 string 之後加上 $ .CODE ;;字元，做為字串結束 mov ah,9 mov dx,OFFSET temp int 21h ENDM ;;巨集結束
把上面藍色框的內容，以純文字檔的格式儲存在「E:\DOS\MACRO\DOSCALL.INC」檔案裏。如此一來，不僅本章的程式可以使用 display 巨集，以後的程式也可以使用，只要在原始程式內開始不久，將「DOSCALL.INC」含括進來即可。
要把某個純文字檔含括進原始程式中，必須使用「INCLUDE」假指令，它的作用相當於把「INCLUDE」之後所接的純文字檔，取代整條「INCLUDE」假指令，變成原始程式的一部分。有關 INCLUDE 的用法，請參閱註一。像這種被 INCLUDE 含括進來的檔案稱為「包含檔」。
這樣原始程式就幾乎寫成了，但是這樣又嫌太簡單了，於是再加上顯示另一個字串，就變成底下的樣子，將它存於「E:\DOS\MACRO\HELLOW3.ASM」：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 |
.MODEL SMALL,C
.386
INCLUDE DOSCALL.INC ;將DOSCALL.INC含括進來
;*************************************************
.STACK
;*************************************************
.CODE
.STARTUP
display <"Hellow, World.",0dh,0ah>
display "I love assembly language!"
.EXIT 0
;*************************************************
END |
上面的原始程式是不是很簡單，看起來一點兒都不像是組合語言，但它卻真的能組譯、連結，並且也能順利執行成功。依下面方式組譯：
E:\DOS\MACRO>ml /Fl hellow3.asm [Enter] →輸入「/Fl」選項以製作列表檔 Microsoft (R) Macro Assembler Version 6.11 Copyright (C) Microsoft Corp 1981-1993. All rights reserved. Assembling: hellow3.asm Microsoft (R) Segmented Executable Linker Version 5.31.009 Jul 13 1992 Copyright (C) Microsoft Corp 1984-1992. All rights reserved. Object Modules [.obj]: hellow3.obj Run File [hellow3.exe]: "hellow3.exe" List File [nul.map]: NUL Libraries [.lib]: Definitions File [nul.def]: E:\DOS\MACRO>hellow3 [Enter] Hellow, World. →執行成功 I love assembly language! E:\DOS\MACRO>
看！可以正確執行！這個程式雖然簡單，但卻有許多值得說的主題。先說最簡單的部分。
在巨集內也能加上註解，巨集的註解可以用「;」或「;;」。組譯器都會忽略掉在「;」或「;;」之後的文字，因此可以用它們作為註解的起頭。「;」與「;;」的差別在於展開巨集時，以「;」為起頭的註解會列在列表檔裡面；而以「;;」為起頭的不會，就顯得不那麼囉嗦。
剛剛提到「展開巨集」，在本章的一開始提到巨集分成五個類型之處，也提過「展開」，這到底是什麼呢？
在原始程式中，如果有定義巨集或是引入有巨集的包含檔，那麼在組譯時期遇到巨集，就會將巨集名稱之後的引數一一代入到巨集內的參數中，如果有其他指令也會一併處理，然後將這些處理過的程式碼插入原先引用巨集的地方。例如在 HELLOW3.ASM 中第 10 行引用了 display 巨集，ML.EXE 就會以「<"Hellow, World.",0dh,0ah>」代入 string 中，於是就產生如下的程式碼：
LOCAL temp ;;將temp設為區域性的 .DATA temp DB "Hellow, World.",0dh,0ah,"$" ;;在參數 string 之後加上 $ .CODE ;;字元，做為字串結束 mov ah,9 mov dx,OFFSET temp int 21h
這些程式碼會被 ML.EXE 安插在引用 display 巨集的地方，也就是安插在第 10 行。而第 11 行也引用 display 巨集，也比照辦理。下面把原始程式與列表檔列出來，就一目瞭然了。
看底下 HELLOW3.ASM 與 HELLOW3.LST 的比較就會發現，在原始程式的「INCLUDE DOSCALL.INC」之後就是堆疊區段，而在列表檔「INCLUDE DOSCALL.INC」之後，卻是 DOSCALL.INC 的所有內容，並在前面加上「C」。同樣在原始程式「display <"Hellow, World.",0dh,0ah>」之後是其他指令，在列表檔中卻是 display 巨集的內容，但每一行前加上「1」，並且參數 string 被引數「"Hellow, World.",0dh,0ah」所取代。像這樣的過程就稱為「展開巨集」。
| HELLOW3.ASM | HELLOW3.LST |
|
Microsoft (R) Macro Assembler Version 6.11 10/08/23 13:58:39
hellow3.asm Page 1 - 1
.MODEL SMALL,C
.386
INCLUDE DOSCALL.INC ;將DOSCALL.INC含括進來
C display MACRO string ;;巨集開始
C LOCAL temp ;;將temp設為區域性的
C .DATA
C temp DB string,"$" ;;在參數string之後加上$
C .CODE ;;字元，做為字串結束
C mov ah,9
C mov dx,OFFSET temp
C int 21h
C ENDM ;;巨集結束
;*************************************************
.STACK
;*************************************************
0000 .CODE
.STARTUP
display <"Hellow, World.",0dh,0ah>
0000 1 .DATA
0000 48 65 6C 6C 6F 77 1 ??0000 DB "Hellow, World.",0dh,0ah,"$"
2C 20 57 6F 72 6C
64 2E 0D 0A 24
0010 1 .CODE
0010 B4 09 1 mov ah,9
0012 BA 0000 R 1 mov dx,OFFSET ??0000
0015 CD 21 1 int 21h
display "I love assembly language!"
0011 1 .DATA
0011 49 20 6C 6F 76 65 1 ??0001 DB "I love assembly language!","$"
20 61 73 73 65 6D
62 6C 79 20 6C 61
6E 67 75 61 67 65
21 24
0017 1 .CODE
0017 B4 09 1 mov ah,9
0019 BA 0011 R 1 mov dx,OFFSET ??0001
001C CD 21 1 int 21h
.EXIT 0
;*************************************************
END
Microsoft (R) Macro Assembler Version 6.11 10/08/23 13:58:39
hellow3.asm Symbols 2 - 1
Macros:
N a m e Type
display . . . . . . . . . . . . Proc
Segments and Groups:
N a m e Size Length Align Combine Class
DGROUP . . . . . . . . . . . . . GROUP
_DATA . . . . . . . . . . . . . 16 Bit 002B Word Public 'DATA'
STACK . . . . . . . . . . . . . 16 Bit 0400 Para Stack 'STACK'
_TEXT . . . . . . . . . . . . . 16 Bit 0023 Word Public 'CODE'
Symbols:
N a m e Type Value Attr
??0000 . . . . . . . . . . . . . Byte 0000 _DATA
??0001 . . . . . . . . . . . . . Byte 0011 _DATA
@CodeSize . . . . . . . . . . . Number 0000h
@DataSize . . . . . . . . . . . Number 0000h
@Interface . . . . . . . . . . . Number 0001h
@Model . . . . . . . . . . . . . Number 0002h
@Startup . . . . . . . . . . . . L Near 0000 _TEXT
@code . . . . . . . . . . . . . Text _TEXT
@data . . . . . . . . . . . . . Text DGROUP
@fardata? . . . . . . . . . . . Text FAR_BSS
@fardata . . . . . . . . . . . . Text FAR_DATA
@stack . . . . . . . . . . . . . Text DGROUP
0 Warnings
0 Errors |
展開之後的巨集，會進一步被組譯器組譯，然後在寫入目的檔中，最後由連結器轉化成可執行檔。有關 HELLOW3.ASM 程式還有幾個有趣的地方，可以談一談。這幾個地方是①文字分隔運算子、②區段的排列。
一般將「< >」稱為文字分隔運算子，在這對「< >」之間的文字，即使有分隔符號，像空白、逗號 ( , )、引號 ( " )、分號 ( ; )……等，都會由於文字分隔運算子的關係，而把這些分隔符號視為一般字元，使整段文字變為一個字串。
如果在 HELLOW3.ASM 的第 10 行改成像下面的樣子：
display "Hellow, World.",0dh,0ah
那麼 ML.EXE 就會告訴你，發生錯誤，因為參數太多了。理由很簡單，上面引用 display 的方式，每個「,」都是分隔符號，所以總共有三個參數。必須像下面方式才是正確的：
display <"Hellow, World.",0dh,0ah>
這樣，display 就會將上面分開的三部分，看成是一個字串。
在 HELLOW3.ASM 中引用了 display 巨集兩次，由列表檔看起來程式碼區段與資料區段似乎交錯著分布，但其實真正載入到記憶體之後，卻不是如此。
這是因為 HELLOW3.ASM 在宣告區段時，採用簡易方式。以簡易方式宣告時，例如 .CODE、.DATA，區段選項中的合併形式（combine）均會設定為內定值，此內定值就是 PUBLIC，而 PUBLIC 會使得具有相同名稱且相同類別名的區段合併成一個區段。
例如在 SMALL 模式下，以「.CODE」方式宣告程式碼區段，其區段名稱均為「_TEXT」，而類別名稱均是「"CODE"」，因此雖然程式碼區段看似分成三部分，但實則合併在一起。資料區段也是一樣。在 SMALL 模式下，以「.DATA」方式宣告資料區段，其區段名稱均為「_DATA」，而類別名稱是是「"DATA"」，所以也一樣會合併在一起。如果你用除錯器載入觀察，也能證實這一點。
假如某個符號 ( 包含變數、標記……) 只有在某個巨集中使用到，那麼可以將此符號設為區域的。把符號設為區域的方法是使用 LOCAL 假指令，它的語法是
LOCAL 符號名稱列表
要注意的是，LOCAL 必須緊接著在 MACRO 下一行，除非兩行之間是註解行。另外在巨集中宣告某些符號是區域性的，與在副程式中宣告區域變數，雖然都是使用 LOCAL，但是兩者意義完全不同。區分方式很簡單，前者是緊接著 MACRO 之後；後者緊接著 PROC 之後。有關在副程式中的區域變數，請參閱第九章區域變數。
在巨集中，宣告某個符號是區域性後，每次引用此巨集時，組譯器會自動為已宣告過的區域性符號產生新的名稱。這個新的符號名稱才是此區域變數真正的名稱，其格式是「??XXXX」，其中的 XXXX 是從零開始的十六進位數。因為這樣的緣故，所以表面上看起來，能達到使符號變成區域性的目的。但是知道的這樣的命名規則之後，就可以由巨集以外的地方存取這樣的變數，或是跳躍至這樣的標記處。
在 HELLOW3.ASM 中的 display 巨集中宣告了字串變數 temp 作為區域變數。當第一次引用 display 時，temp 字串變數真正的名稱是 ??0000；第二此引用時，真正的名稱是 ??0001。這一點能夠從列表檔中看出來。
在巨集內部，免不了要對數值或是字串做運算，因此有時必須在巨集內宣告變數。這些變數區分成兩類：數值變數與字串變數。數值變數可以用 EQU 或 = 假指令宣告，差別在於以前者宣告之後無法更改其數值；後者可以。所以嚴格來說，EQU 宣告常數，= 宣告變數，它們的語法是：
符號 EQU 算術運算式 符號 = 算術運算式
其中的符號就是變數名稱或常數名稱；算術運算式是指可以是用算術計算的數學式子，其運算元應該都是數值或已宣告過的變數。以這兩種方式宣告的符號，只有在組譯時期有效，而不是在執行時期。
字串變數的宣告方法是用 EQU 或 TEXTEQU，語法如下：
符號 EQU <字串> 符號 TEXTEQU <字串>
不管用 EQU 還是 TEXTEQU 宣告的字串，都能更改變成另一個字串，差別是 TEXTEQU 能搭配 ECHO 假指令及巨集運算子做運算，而 EQU 不能。有關 TEXTEQU 與 ECHO 的功能還不只宣告字串，還有許多，請參考 Win64 組合語言第五章文字巨集。
MASM 可使用的重複區塊有：①WHILE/ENDM、②REPEAT/ENDM、③FOR/ENDM、④FORC/ENDM，共四種，不過在這一章，小木偶只打算介紹這一章會用得着的第①及③兩種，其餘的可參閱 Win64 組合語言第六章重複區塊。
WHILE/ENDM 的語法是：
WHILE 判斷式 敘述 ENDM
WHILE/ENDM 會先檢查判斷式是否為真，假如為假就跳到 ENDM 之後；假如為真就組譯 WHILE 與 ENDM 之間的敘述，至敘述的最後一行，然後回到 WHILE 處，再度檢查判斷式是否為真，依其真假判斷是否重複；如此一直到判斷式為假時，才跳出 WHILE/ENDM 迴圈。上面的敘述可以是 x86 指令或是符合組合語言語法的假指令。
判斷式有三種形式：
①：可以是數值關係式，其形式為：
number1 比較運算子 number2
number1 與 number2 可以是算術運算式或是組譯時期的變數、常數。常用的比較運算子有下列六種：
LT 小於 NE 不等於 LE 小於或等於 GT 大於 EQ 等於 GE 大於或等於
②：可以是數值關係式之間，再做複雜的邏輯運算，可用的邏輯運算子有 AND、OR 及 XOR。( 此三個邏輯運算子並非 x86 指令，僅用於判斷式裡面 )。例如底下的例子是當 x 小於 25 且 y 小於 80 才會執行重複區塊的程式碼：
WHILE ( x LT 80 ) AND ( y LT 25 ) ⁝ ENDM
③：判斷式也可以是單一個組譯時期的變數或數學運算式。事實上，當組譯器對判斷式進行判斷時，如果該組譯時期的變數或數學運算式之結果為非零值，代表真；如果譯時期的變數或數學運算式之結果為零，代表假。
舉個例子來說明 WHILE/ENDW 的用法。假設在原始程式碼中要設置一個陣列，這個陣列是從 1 開始，然後是 3、5、7、9……199，共 100 個奇數組成的陣列，若要一個一個輸入，非常麻煩，可以用 WHILE/ENDM 重複區塊，如下面程式碼：
d=2 ;;公差 an=1 ;;第 n 項，最先的是首項 n=100 ;;共 100 項 odd_number LABEL WORD WHILE n DW an ;;定義第 n 項 an=an+d ;;下一項為前一項加公差 n=n-1 ;;項數少一 ENDM
要引用此重複區塊時，只需將上述程式碼複製貼在資料區段中即可。上述程式碼中，d、an、n 都是組譯時期變數，它們在 ML.EXE 組譯時，於記憶體中建立；組譯時期，由 ML.EXE 負責管理與計算這些變數；當 ML.EXE 組譯完成之後，它們就消失了；當使用者執行所產生的應用程式，也不會建立這三個變數。
WHILE/ENDM 重複區塊以 n 當做判斷式，只有當 n 不為零時，判斷式為真，才會執行 WHILE 與 ENDM 之間的程式碼。因為有 100 項，所以在重複區塊開始前，把 n 設為 100。然後執行到 WHILE，WHILE 會檢查判斷式是否為真，若為真就會執行 WHILE 與 ENDM 之間的程式碼。而一開始 n 為 100，故判斷式為真，執行 WHILE 與 ENDM 之間的程式碼。爾後每執行一次區塊，n 減一，直到變為零之前都會在重複區塊內執行。
在 WHILE 與 ENDM 之間的程式碼很簡單。首先定義「DW an」，這樣會在資料區段中留下一個字組大小的空間，也就是留下一個陣列中的元素。然後計算下一項，使 an 變為 an＋d，其中 d 是公差，其實就是 2。然後再使項數減一，接著遇到 ENDM，它會使控制權回到 WHILE 之處，讓 WHILE 檢查是否繼續下一次重複區塊。
有時候一個變數需要有兩個名稱，或是只需要指定某個位址時，可以用「LABEL」假指令。LABEL 的語法是：
符號名 LABEL 資料類型
LABEL 會把符號名指定為後面的資料類型，但是卻不分配記憶體空間。上面的資料類型可以是 BYTE、WORD、DWORD、QWORD 等 MASM 已定義的資料類型。例如底下的例子：
.DATA
x LABEL WORD
y BYTE 11h,22h
⁝
mov ax,x
mov cl,y
x、y 這兩個變數的位址都相同，但是 x 的長度是字組，y 是位元組。因此上述程式執行後，x 為 2211H，y 為 11H。
另一個例子是上面所提到由 1 到 199 的奇數組成的陣列。在這個例子中，沒有辦法在 WHILE 與 ENDM 之間宣告變數名稱，因為這樣的話就會使該變數名稱重複，會發生重複定義變數名稱的錯誤。因此在這個重複區塊之前，以 LABEL 假指令宣告這 100 個奇數所組成的陣列名稱為 odd_number，以利應用程式存取。
上面的例子還可以再加以改進。因為每次需要 odd_number 陣列時，都要複製貼上，也是有些麻煩，可以讓這段程式碼寫在另一個巨集之中，見下面的巢狀巨集的說明。
在巨集之內還有另一個巨集，這種情況稱為巢狀巨集。一般而言，巢狀巨集的形式如下：
甲 MACRO 甲巨集參數列表 ⁝ 乙 MACRO 乙巨集參數列表 ⁝ ENDM ⁝ ENDM
甲、乙不一定一定是巨集程序，可以是其他類型的巨集。例如將上面的 WHILE/ENDM 重複區塊包含進另一個巨集程序之中，變成下面的樣子：
arithmetic MACRO a1,d,terms ;;等差數列巨集 an=a1 ;;首項 n=terms WHILE n DW an ;;定義第 n 項 an=an+d ;;下一項為前一項加公差 terms=terms-1 ;;項數少一 ENDM ENDM
arithmetic 是等差數列（arithmetic sequence）的意思，arithmetic 巨集有三個參數：①首項是 a1，②公差是 d，③項數是 terms。因為在巨集中無法改變參數之值，所以設立另外兩個變數 an、n 來讓此巨集工作。引用 arithmetic 巨集的方法如下：
.DATA ⁝ odd_number LABEL WORD arithmetic 1,2,100
arithmetic 巨集不僅可以像上面一樣建立 1∼199 的奇數所組成的數列，如果適當設定 a1、d、terms，也可以建立其他等差數列。arithmetic 巨集的用途頗大，也可以把 arithmetic 巨集存入某個包含檔中，當要建立等差數列時，就將此包含檔含括進來，再引用 arithmetic 巨集。
FOR/ENDM 的語法是：
FOR 參數,<引數一,引數二,引數三,……>
敘述
ENDM
組譯器會將引數一代入參數，組譯 FOR 與 ENDM 之間的敘述；然後再以引數二代入參數，組譯 FOR 與 ENDM 之間的敘述……如此一直重複，直到「<」、「>」內的引數全都代入過為止。舉個例子，假設有個巨集是：
FOR arg,<1,2,3,4,5>
BYTE arg DUP (arg)
ENDM
上面的巨集產生底下的程式碼：
BYTE 1 DUP (1), 2 DUP (2), 3 DUP (3), 4 DUP (4), 5 DUP (5)
條件組譯是指在某些條件下，讓組譯器組譯某段程式，或者不組譯某段程式。組譯某段程式，就意味著會產生機械碼、依假指令指示組譯，並產生組譯時期的變數依此變數結果組譯，然後將上述所有結果寫入目的檔及可執行檔裡面 ( 當然組譯時期的變數，並不會寫入目的檔及可執行檔內 )；反之，不組譯某段程式，就意味著跳過該段程式碼，當然也不會寫入目的檔及可執行檔裡面。條件組譯的假指令有好幾種，先介紹最常見的 IF/ELSE/ENDIF。
第六章曾經提過的條件控制流程指令，.IF/.ESLEIF/.ELSE/.ENDIF，看起來與這裏講的 IF/ELSE/ENDIF 很像，但它們是不一樣的概念。首先前者是在應用程式執行時期時被 CPU 所執行，後者則是在組譯時期被 CPU 所執行；其次前者的判斷式多以數學符號表示，後者則是以英文字母表示。
IF/ELSE/ENDIF 大概是最常見的條件組譯了，它的語法有兩種，分別介紹如下：
IF 判斷式
程式片段
ENDIF
上面的程式碼是說，如果判斷式為真，那麼就組譯程式片段中的程式，否則就不組譯。依據需要，IF 也可以搭配 ELSE，語法為：
IF 判斷式
程式片段一
ELSE
程式片段二
ENDIF
上面的程式碼是說，如果判斷式為真，那麼就組譯程式片段一中的程式，否則就組譯程式片段二中的程式。判斷式的寫法與前述提及的 WHILE/ENDM 一樣，請自行參考。
IFE 的意義與 IF 相反，其語法是：
IFE 判斷式
程式片段
ENDIF
IFE 的意思是如果判斷式為假，則組譯程式片段中的程式。IFE 也可以搭配 ELSE 使用，其語法是：
IFE 判斷式
程式片段一
ELSE
程式片段二
ENDIF
上面的程式是說，如果判斷式為假，則組譯程式片段一；否則組譯程式片段二。
IFIDN/ELSE/ENDIF 的語法也有兩種，較簡單的是
IFIDN <參數1>,<參數2>
程式片段
ENDIF
IFIDN 中的 IDN 是「identical」的意思，參數1 與參數2 都必須以一對「<」、「>」括起來中間以「,」隔開。上述程式就表示如果參數1 和參數2 相同的話，就組譯程式片段。也可以視需要而使用第二種語法：
IFIDN <參數1>,<參數2>
程式片段一
ELSE
程式片段二
ENDIF
上述程式就表示如果參數1 和參數2 相同的話，就組譯程式片段一；否則組譯程式片段二。
IFIDNI/ELSE/ENDIF 比 IFIDN/ELSE/ENDIF 多了一個「I」，是表示在比較參數1 和參數2 時，忽略英文字母大小寫的不同，其他方面都一樣。另外，IFIDN/ELSE/ENDIF 與 IFIDNI/ELSE/ENDIF 也可以用於比較字串變數是否相等，如果是用於比較字串變數的話，那麼字串變數的名稱不可用一對「<」、「>」括起來。
經過第 24 章以及本章前半部的補充，現在我們已經有能力讓 MASM 6.11 支援原本未支援的 x86 指令，RDRAND。查閱附錄七的「64-Bit OpCode Extensions」得知 RDRAND 的機械碼位於 GRP9，其操作碼（OpCode）有兩個，依次是 0FH 0C7H，並且有延伸的操作碼（OpCode Extensions），110，此延伸的操作碼位於 ModR/M 位元組的第 3∼5 位元，如下圖：
上圖中，ModR/M 位元組的 Mod 欄位以及 R/M 欄位用來表示運算元，也就是暫存器。查閱第 24 章「Bit-32 Mod 與 R/M 的關係」，得知 Mod 為 11 時，R/M 數值不同代表不同的暫存器。R/M 有三個位元，恰好可以表示八個通用暫存器。
前面說過，RDRAND 的運算元只有一個，這個運算元是 64、32 或 16 位元的暫存器。但是，在 MS－DOS 中，並無法使用 x64 新增的暫存器，也就是不能使用 64 位元的暫存器。這裏得再說得更清楚一些，事實上，不能使用的暫存器還更多一些。所謂「新增的暫存器」，是指進入 x64 時代，其暫存器的名稱是新增的。也就是說，像 RAX、RBX……等不能使用，但可以使用 EAX、AX、EBX、BX……，因為前兩者是 x64 新增的，而後四者是 IA－32 原本就有的。同理，雖然 R8D、R8W 分別是 32、16 位元的暫存器，卻也無法在 MS－DOS 使用，原因是這兩個暫存器名稱也是新增的。
為何如此呢？小木偶猜想其中的原因大概是要使用 x64 新增的暫存器，就必須要使用 REX 前置碼。第 24 章提過，REX 前置碼在範圍 40H∼4FH 之間，而在真實模式時，這段範圍的機械碼是代表 INC、DEC 指令。很不幸，MS－DOS 就是在真實模式下運作的，所以在 MS－DOS 中，並無法使用 x64 新增的暫存器。
但又很幸運的是，因為在 MS－DOS 執行的程式不能使用新增的暫存器，情況漸變得很單純了。也就是說，RDRAND 指令的運算元，就只要考慮原本的 32 或 16 位元的暫存器即可。
先說假如 RDRAND 指令的運算元是 16 位元的話，如何表示？為了單純起見，以「RDRAND AX」為例子。查閱第 24 章「Bit-32 Mod 與 R/M 的關係」可以得知 Mod 為 11 且 R/M 為 000 時，所代表的運算元是 AL、AX 或 EAX。表中的 W 位元是操作碼的第零個位元，不管是 0FH 或 0C7H 第零個位元均為 1，故運算元為 AX 或 EAX 其中之一（也可以想成 RDRAND 的運算元不能是八位元的暫存器）。因為 MS－DOS 是 16 位元的作業系統，故選擇 AX。綜合上述過程，ModR/M 位元組是 11 110 000，第 7、6 位元是 Mod 欄位，第 3∼5 位元是操作碼的延伸，第 0∼2 位元是 R/M 欄位，代表 AX 暫存器，合在一起就是 0F0H。MS－DOS 應用程式中，要使用「RDRAND AX」指令，可以在程式碼區段填入其機械碼：
.CODE
⁝
DB 0FH,0C7H,0F0H ;能執行 rdrand ax 指令
那如果是「RDRAND CX」，只有 R/M 欄位改成 001；同理其餘暫存器也只有 R/M 欄位不同。讀者可以自行以此撰寫程式，然後用除錯器載入觀察，你會發現結果實在是又驚又喜，竟然真的可以執行。
那麼如果要執行「RDRAND EAX」指令，又當如何呢？其實並不難，只要加上運算元前置碼（operand-size override prefix）即可，也就是在原本的機械碼之前加上 66H。前一章提過，運算元前置碼是用來切換運算元大小。原本在 MS－DOS 是十六位元的區段，預設運算元大小也是十六位元，加上了 66H 之後就切換成三十二位元。因此要使用「RDRAND EAX」指令，可以在程式碼區段填入其機械碼：
.CODE
⁝
DB 66H,0FH,0C7H,0F0H ;能執行 rdrand eax 指令
那麼如何將 RDRAND 的運算元改成 RBX、RCX……呢？跟十六位元的情況一樣，只有 ModR/M 中的 R/M 欄位改變而已。
對於要以任何一個合法的暫存器作為 RDRAND 指令的運算元，應該都能寫出來了。但是如果要執行 RDRAND 指令，都要使用「DB 0FH,0C7H……」，看起來就很低級。小木偶野心更大，想製作一個巨集，而且就將這個巨集命名為 rdrand，它就只有一個參數，此參數就是暫存器，引用起來可以就跟其他 x86 指令一模一樣。這個 rdrand 巨集內容如下：
rdrand MACRO arg ;;雖然MASM 6.11並未支援RDRAND指令，但rdrand巨集透過在程式碼區段中填充機械 ;;碼的方式，實作RDRAND指令，讓MASM 6.11也能執行RDRAND指令 ;;flag是用來檢查arg是否為合法的16或32位元的暫存器。若為合法暫存器，執行到 ;;巨集最後面，flag為1；若不合法，則到巨集最後面flag為0 flag=0 ;;檢查arg是否為32位元暫存器 i=0 FOR param,<eax,ecx,edx,ebx,esp,ebp,esi,edi> IFIDNI <arg>,<param> flag=1 ModRM=0f0h+i DB 66h,0fh,0c7h,ModRM EXITM ;;若arg為32位元暫存器，退出FOR/ENDM重複區塊 ENDIF i=i+1 ENDM IF flag EQ 1 ;;若flag為1，表示arg是32位元暫存器，退出rdrand巨集 EXITM ENDIF ;;檢查arg是否為16位元暫存器 i=0 FOR param,<ax,cx,dx,bx,sp,bp,si,di> IFIDNI <arg>,<param> flag=1 ModRM=0f0h+i DB 0fh,0c7h,ModRM EXITM ;;若arg為16位元暫存器，退出FOR/ENDM重複區塊 ENDIF i=i+1 ENDM ;;若flag為0，表示arg不是16位元也不是32位元的暫存器，印出錯誤訊息 IF flag EQ 0 ECHO ERROR: ECHO THE OPERANDS MUST BE 16, 32 BITS REGISTERS, ECHO AND REGISTERS LIKE R8D, R8W CANNOT BE USED. ENDIF ENDM
可以看出來，rdrand 巨集使用了兩個 FOR/ENDM 來分別檢查 32、16 位元暫存器。這兩種不同位元數的暫存器各有八個，數量不多，所以作為 FOR 的引數列表，還不算太麻煩。在進入 FOR/ENDM 之前先將 flag 變數設為 0，此變數是個旗標，用來表示是否有合法的參數。在每個 FOR/ENDM 重複區塊內，都有一個 IFIDNI/ENDIF 來檢查程式傳來的參數，是否符合 FOR 之後的引數列表。如果符合，就表示找到合法的暫存器，flag 會被設為一；反之，flag 仍然是零。
變數 i 是用來計算在引數列表中的第幾個引數符合參數，而引數的排列順序如果與 R/M 欄位所代表的暫存器順序一樣，那麼 R/M 之值就會與 i 相等。而 Mod 與 OpCode 延伸欄位之值是固定的，其實就是 0F0H，所以 ModR/M 位元組就是 0F0H 加上 i。
在 rdrand 巨集中還有兩個假指令不曾介紹：①EXITM、②ECHO。
在巨集中，可以利用 EXITM 強迫巨集結束，同時把回傳值傳回。EXITM 的語法是：
EXITM textitem
當組譯器由上而下組譯原始程式的巨集時，如果遇到 EXITM，就會忽略從 EXITM 到 ENDM 之間的巨集程式碼，跳出巨集，並傳回回傳值。
回傳值就是緊接著 EXITM 之後的 textitem，textitem 必須是字串或是代表字串的符號名稱，也可以是另一個巨集函式的回傳值。回傳值也可以省略，如果省略的話，就沒有 textitem。EXITM 僅僅是結束自身所在的巨集，所以在巢狀巨集中，如果在第二層巨集使用 EXITM，那麼就只有結束第二層巨集，但仍在第一層巨集中。例如底下例子：
a_mac MACRO ;;──────────┐ ⁝ ;; │ b_mac MACRO ;;─┐ │ ⁝ ;; │ │ IF arg LT 20h ;; │ │ EXITM ;; ├─b_mac │ ENDIF ;; │ ├─a_mac ⁝ ;; │ │ ENDM ;;─┘ │ arg=20h ;; │ ⁝ ;; │ ENDM ;;──────────┘
上面的 a_mac、b_mac 都是巨集中，但 a_mac 巨集包含了另一個 b_mac 巨集，這種情形稱為巢狀巨集。當組譯到 b_mac，如果 arg 小於 20H，那麼就會退出 b_mac；但並非同時也退出 a_mac，而是會繼續組譯「arg=20h」以及其後 a_mac 的剩餘部分。
ECHO 會使組譯器在組譯原始程式期間，把接在 ECHO 之後的資料印在螢幕上。其主要目的，是對巨集除錯。它有兩種用法：
ECHO 字串 %ECHO 字串變數
第一種用法很簡單，就是單純的把字串印在螢光幕上。第二種用法能把字串變數的內容印出來，如果在 ECHO 之前不加上「%」運算子，就只能印出變數的名稱，就變成第一種用法。加了「%」之後，「%」有求得其值的功用，「%」與 ECHO 之間可以有空白，也可以不加空白。例如底下的例子：
Love EQU <I love assembly.> ;;宣告Love字串 ECHO Love ;;組譯時只會印出Love %ECHO Love ;;組譯時會印出「I love assembly.」
底下的例子，TSTRND.ASM，會利用上述的 rdrand 巨集，產生 0∼65535 之間的亂數共 65536 個，然後統計這些亂數落在各範圍內的個數。這些範圍共區有 16 個，每個範圍所包含的數都一樣多，它們分別是 0000∼0FFFH（0∼4095）、1000H∼1FFFH（4096∼8191）、2000H∼2FFFH（8192∼12287）……、0F000H∼0FFFFH（61440∼65535），在「（」、「）」內的是以十進位表示。
在 TSTRND.ASM 中，有個 qty 陣列，它有 16 個元素，每個元素記錄著落在該範圍內的亂數個數。例如第 0 個元素，是紀錄落在 0∼4095 之間的亂數有幾個、第一個元素，是紀錄落在 4096∼8191 之間的亂數有幾個……。底下先來看看 TSTRND.ASM 的程式碼。
底下是 TSTRND.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 |
;TSTRND用巨集實現MASM 6.11未支援的RDRAND x86指令
;TSTRND執行65536次RDRAND指令，並以每1000H為範圍，統計其出現次數。也就是
;說TSTRND會統計所生成的亂數落在0∼0FFFH有幾次，落在1000H∼1FFFH有幾次……
.MODEL TINY
.586
rdrand MACRO arg
;;雖然MASM 6.11並未支援RDRAND指令，但rdrand巨集透過在程式碼區段中填充機械
;;碼的方式，實作RDRAND指令，讓MASM 6.11也能執行RDRAND指令
;;flag是用來紀錄arg是否為合法的16或32位元的暫存器。若為合法暫存器，執行到
;;巨集最後面，flag為1；若不合法，則到巨集最後面flag為0
flag=0
;;檢查arg是否為合法的32位元暫存器
;;若arg為合法的32位元暫存器，那麼i就是FOR參數列表中的第幾個符合arg。例如
;;若arg為EAX，i就是0；arg為ECX，i就是1……
i=0
FOR param,<eax,ecx,edx,ebx,esp,ebp,esi,edi>
IFIDNI <arg>,<param>
flag=1
ModRM=0f0h+i
DB 66h,0fh,0c7h,ModRM
EXITM ;;若arg為32位元暫存器，退出FOR/ENDM重複區塊
ENDIF
i=i+1
ENDM
IF flag EQ 1 ;;若flag為1，表示arg是32位元暫存器，退出rdrand巨集
EXITM
ENDIF
;;檢查arg是否為合法的16位元暫存器
i=0
FOR param,<ax,cx,dx,bx,sp,bp,si,di>
IFIDNI <arg>,<param>
flag=1
ModRM=0f0h+i
DB 0fh,0c7h,ModRM
EXITM ;;若arg為16位元暫存器，退出FOR/ENDM重複區塊
ENDIF
i=i+1
ENDM
;;若flag為0，表示arg不是16位元也不是32位元的暫存器，印出錯誤訊息
IF flag EQ 0
ECHO ERROR:
ECHO THE OPERANDS MUST BE 16, 32 BITS REGISTERS,
ECHO AND REGISTERS LIKE R8D, R8W CANNOT BE USED.
ENDIF
ENDM
;*********************************************************************
.CODE
ORG 100h
;---------------------------------------------------------------------
main PROC
jmp begin
msg DB "TSTRND implementation generates unsupported",\
0dh,0ah,"x86 instructions using macros in ML.EXE",\
0dh,0ah,0dh,0ah," Range Freq",0dh,0ah,"$"
;qty陣列紀錄落在個範圍內的亂數個數。舉例來說，落在0∼0FFFh之間的亂數
;個數存於qty[0]處，;落在1000h∼1FFFh之間的亂數個數存於qty[2]處，落在
;2000h∼2FFFh之間的亂數個數存於qty[4]處……
qty DW 16 DUP (0) ;每個範圍的亂數個數
ten DW 10
buffer DB "?000-?FFF:XXXX",0dh,0ah,"$"
begin: mov ah,9
lea dx,msg
int 21h
xor cx,cx ;CX會從0FFFFH∼0，使下面迴圈執行65536次
again: rdrand bx ;取得亂數，並存於BX
shr bx,12
shl bx,1
inc qty[bx]
loop again
xor bx,bx ;BX會從0、2、4……一直到1EH，共16個
mov cx,16 ;底下的迴圈印出出現在每個範圍內的亂數次數
next: call print
add bx,2
loop next
int 20h ;程式結束
main ENDP
;---------------------------------------------------------------------
;輸入：BX－qty陣列中的元素位址，從0、2、4……一直到1EH
;輸出：印出類似「?000-?FFF:XXXX」的字串
print PROC
lea di,buffer
;計算「?000-?FFF:XXXX」中的兩個「?」
mov ax,bx
shr ax,1
add al,"0"
cmp al,"9"
jbe save
add al,7
save: stosb
mov di,OFFSET buffer+5
stosb
;計算「?000-?FFF:XXXX」中的「XXXX」，
;XXXX為亂數落在?000-?FFF的範圍內的個數
mov ax,qty[bx]
mov di,OFFSET buffer+13
.WHILE 1
xor dx,dx
div ten
add dl,"0"
mov [di],dl
.BREAK .IF ax==0
dec di
.ENDW
mov dx,OFFSET buffer
mov ah,9
int 21h
ret
print ENDP
;*********************************************************************
END main |
TSTRND.ASM 第 63∼65 行，是印出 TSTRND 的程式功能，這沒什麼可說。
TSTRND.ASM 第 66∼71 行，是用來產生 65536 個亂數，然後將這些亂數歸類在每個範圍內。但 TSTRND.ASM 並非一次產生 65536 個亂數，然後再歸類；而是用一個執行 65536 次的迴圈，每執行一次迴圈只產生一個亂數，然後歸類。此處的歸類是指根據生成的亂數大小，判斷它落在哪一個範圍內，然後使代表該範圍的 qty 元素之值增加一。
判斷亂數落在哪個範圍，就只用第 68、69 兩行程式碼就完成了，底下解釋如何做到。首先，觀察這十六個範圍：
0000H∼0FFFH 1000H∼1FFFH 2000H∼2FFFH 3000H∼3FFFH ⁝ F000H∼FFFFH
我們可以這樣想：
經過上面的整理歸納，就會發現，到底要使 qty 陣列裏的哪一個元素之值增加一，只與亂數的最高位有關。例如假如生成的亂數是 6571，換成十六進位是 19ABH，落在 1000H∼1FFFH（也就是十進位的 4096∼8191）。對於 TSTRND.ASM 來說，只要檢測十六進位的最高位，1，就能知道要使 qty 的第一個元素之值增加一。TSTRND.ASM 用 SHR 指令將生成的亂數右移 12 個位元，就能得到最高位（TSTRND.ASM 第 68 行）。
qty 陣列是由 16 個元素組成的，每個元素佔用兩個位元組（兩個位元組相當於一個字組）。因此還必須將 qty 的第幾個元素乘以二，也就是 TSTRND.ASM 的第 69 行，利用 SHL 將第幾個元素向左移一位。或許有人會這樣想，先要向右移 12 個位元，然後立即右向左移一個位元，那麼是否可以直接向右移 11 個位元呢？答案是不行，這個原因其實很簡單，請自行想想。TSTRND.ASM 的其餘部分的原理，前面章節都提過，就不贅述了。
亂數，顧名思義，越亂越好，但何謂「亂」？以小木偶淺薄的見識以為，亂數是無法預測的而且落點得均勻分布，也就是說在每個等大範圍內出現的次數都應該相同。TSTRND.ASM 會執行 rdrand 巨集而生成 65536 個亂數，依據其大小將它們分成十六個範圍，並顯示落在每個範圍的亂數個數。這種方法可以用人工來判斷 CPU 的 RDRAND 指令是否能產生落點分佈均勻的亂數，當然這是最粗淺的方式，還可以更深入，但這已超出組合語言教學的範圍。
這一章除了檢測 CPU 生成的亂數品質之外，還有一亮點，那就是讓不支援 RDRAND 指令的 MASM 6.11，能正常組譯此指令，並且能正常執行。這個想法是小木偶自行想出來的，並沒有看見其他地方有這樣的想法。當然，有可能是小木偶孤陋寡聞，也可能是還在用 MASM 6.11 的人本就少了，所以幾乎沒什麼人會去想如何增進 MASM 6.11 的功能。