附錄二　UASM64 的陣列存取

怪事年年有

先看一段程式：

.DATA
array   DD      20h DUP (3388h)
        ⁝
.CODE
        ⁝
        mov     r8,2
        mov     eax,array[r8*4]
        ⁝

用 UASM64.EXE 組譯上述程式會發生錯誤失敗，並給你一段錯誤訊息：

Error A2031: invalid addressing mode with current CPU setting

中文的意思是「當前的 CPU 設定下為無效的定址模式」。

但是如果把「mov eax,array[r8*4]」改成其他指令，例如「add eax,array[r8*4]」、「sub eax,array[r8*4]」……等卻能組譯成功。假如改用 ML64.EXE，那麼不管是「mov eax,array[r8*4]」或「add eax,array[r8*4]」、「sub eax,array[r8*4]」……，都能組譯成功。非常奇怪，莫非電腦中邪了？

當然不是，這應該是 UASM64.EXE 的錯誤，也就是 bug。在第十六章，介紹過變通的方法。但這只是治標的方法，治本的方法應該要修改組譯器。假如要這樣做，就得聯絡到作者，請他下次更新版本時修正。在這期間有沒有方法可以彌補這個錯誤呢？事實上，還真的有，這個附錄，就是記載小木偶修正這個錯誤的過程。

組譯哪些指令會出錯及其解決方法

間接定址

要修改這種 UASM64.EXE 無法組譯的錯誤，必須瞭解來龍去脈。先說什麼是定址。當 CPU 要對在記憶體內的資料進行運算、搬移或其他動作時，必須在幾個 G 的記憶體中，指定要處理的資料位於哪一個四字組、雙字組、字組或位元組內；講得更學術一些，就是如何指定哪一個記憶體，像這樣的過程稱為定址（addressing）。

定址方式有兩種：①直接定址、②間接定址。用 UASM64.EXE 能正確組譯直接定址，故不在這個附錄的討論範圍。間接定址有六種，在第二章及第十六章總共介紹了四種間接定址方式，如下：

⑴、[ reg1 ]
⑵、array [ reg1 ] （與 [ reg1＋array ] 同義）
⑶、[ reg2*s ]
⑷、array [ reg2*s ] （與 [ reg2*s＋array ] 同義）

事實上還有兩種間接定址，其樣子如下：

⑸、[ reg1＋reg2*s ]
⑹、array [ reg1＋reg2*s ]（與 [ reg1＋reg2*s＋array ] 同義）

上面六種間接定址中，array 是陣列名稱或變數名稱；s 稱為倍率（scale），只能是 1、2、4、8，此四數都是二的冪次方。reg1、reg2 均為 64 位元的通用暫存器，例如 RAX、RBX……R15，一般把有乘以二冪方的 reg2 稱為索引暫存器（index register），另一個 reg1 稱為基底暫存器（base register）。索引暫存器乘以二的冪方所得乘積，即 reg2*s，稱為索引倍率。

有時也會在上述運算元之前，加上 BYTE PTR、WORD PTR、DWORD PTR 或 QWORD PTR 等資料類型，強制指定資料類型。尤其是運算元沒有特別表明資料長度時，例如⑴、⑶、⑸。

當然上面僅僅說明定址方式，還必須搭配運算、搬移或其他動作，才是一道完整的指令。例如

        mov     reg, [ reg1 ]
        mov     reg, array [ reg1 ]
        mov     [ reg2*s ], reg
        ⁝

其中 reg 也是通用暫存器，但不一定是 64 位元的暫存器，依 array 資料類型而定，也可以是 8、16、32 位元的暫存器。下面的例子，是從一個由字組組成，名為 array 的陣列中，取出第二個元素之值，並存於 CX 暫存器內，程式片段為

array   DW      0,11h,22h,33h,44h,55h,66h
        ⁝
        mov     rax,2
        mov     cx, array[rax*2]    ;*代表乘號，乘以2是因為每個字組佔用了2個位元組

array 陣列位於記憶體某個位址，這個位址以 array 代替。假如程式載入記憶體後，系統讓 array 位於記憶體位址 8500H 處，那麼 array 的第零個元素就在位址 8500H，第一個元素在位址 8502H，第二個位址在 8504H……。「mov cx, array[rax*2]」中的 RAX*2 等於 4，而 array 代表的位址是 8500H，合起來就是位址 8504H，也就是把 array 的第二個元素取出來存於 CX 內，故 CX 之值為 22H。如果把「[array[rax*2]」寫成「[array＋rax*2]」也是可以的，其中的一對「[ ]」是指記憶體的內容。

針對第⑷種形式

扯遠了，言歸正傳！經小木偶測試，只有第⑷種形式的定址方式配合 MOV 指令雖然符合組合語言的語法，但卻被 UASM64.EXE 視為錯誤。如果第⑷種形式與其他指令，像 ADD、SUB、XOR、MOVSZ 等配合，UASM64.EXE 還是能正確組譯的。也就是說，只有 MOV 指令的第⑷種間接定址方式需要修正，再考慮到哪個是目的運算元哪個是來源運算元，而有下面三類指令需要更正：

1. MOV   reg, array [ reg2*s ]
2. MOV   array [ reg2*s ], reg
3. MOV   array [ reg2*s ], imm

解決 UASM64.EXE Bug 的方法

小木偶提出的解決方案是使用巨集。小木偶打算撰寫一個「mova」巨集，其中的 a 代表陣列（array），其意為這個 mova 巨集是針對陣列的 MOV 指令。mova 只有兩個參數，argument1、argument2，前者是目的運算元，後者是來源運算元，與原來的 MOV 指令一樣，只多了個 a 而已。上面三種情形以 mova 巨集形式引用，就變成底下的樣子；也可以說，就是以下面三式代替上面三式，就可以修正 UASM64.EXE 的錯誤：

甲：mova   reg1, DATA_TYPE array [ reg2*s ]
乙：mova   DATA_TYPE array [ reg2*s ], reg1
丙：mova   DATA_TYPE array [ reg2*s ], imm

上述三式中，DATA_TYPE 是指 BYTE PTR、WORD PTR、DWORD PTR 或 QWORD PTR 等資料類型，這為了與 MOV 指令有類似功能。假如是甲、乙兩種情形，DATA_TYPE 可以省略，因為可以由 reg1 判斷資料類型，如果加上了 DATA_TYPE，就必須兩者一致，否則會顯示錯誤訊息。至於丙的情形，不加 DATA_TYPE 時，可以由陣列名稱判斷，如果加入則強制以 DATA_TYPE 所指定的資料類型為準。此外，reg1 可能是 8、16、32、64 位元的暫存器，但是 reg2 是索引暫存器，牽涉到位址只能是 64 位元的通用暫存器。

mova 的用法如下，假設要把 f_sequence 陣列中的第二個元素設為 1：

;底下是 mova 的定義
mova    MACRO   argument1,argument2
  ⁝
ENDM
  ⁝
.DATA
f_sequence      DD      (?)
  ⁝
.CODE
  ⁝
  mov   rax,2
  mova  f_sequence[rax*4],1 ;因為f_sequence中每個元素佔4個位元組，所以乘以4

最後一行，引用 mova 時，argument1 會等於「f_sequence[rax*4]」字串，argument2 會等於「1」字串，經 mova 分析產生適當的機械碼，使 CPU 能執行。

原理

mova 巨集的原理其實很簡單，它會分析 argument1、argument2，然後將其轉換成機械碼，填入程式中，就跟組譯器做的事一樣。說到機械碼，先看下面的圖： 上圖是 64 位元模式下，一道指令的機械碼，分七部分：Legacy Prefixes、REX prefix、OpCode、ModR/M、SIB、Displacement、Immediate。這七部分，只有 OpCode 一定會出現，其餘部分依需要決定，如果不需要就不會出現而跳過。例如「SUB RSP,28H」機械碼是「48 83 EC 28」，依序是 REX prefix、OpCode、ModR/M、Immediate，而沒有 Legacy Prefixes、SIB、Displacement 因此就跳過它們。

x64 CPU 的指令很多，而本附錄重點是，製作巨集更正 UASM64.EXE 無法組譯而需要修改的三類指令，這三類指令如下：

甲：mova   reg1, DATA_TYPE array [ reg2*s ]
乙：mova   DATA_TYPE array [ reg2*s ], reg1
丙：mova   DATA_TYPE array [ reg2*s ], imm

不幸的是，這三類指令可能都會出現上述機械碼七部分。mova 必須分析輸入的兩個運算元，依據機械碼的規則，產生這七部分機械碼。現在簡略說明這七部分意義：

①、Legacy Prefixes：稱為傳統前置碼，傳統前置碼有許多種。但 mova 只會用到運算元前置碼，66H，在稍後一併說明。

②、REX Prefix：稱為 REX 前置碼。第 4∼7 位元一定是 0、0、1、0，合起來就是 4。第 0∼2 位元用表示新增的暫存器。32 位元的 x86 CPU，其通用暫存器只有八個，到了 x64 時代變成 16 個，就用 REX Prefix 的 B、X、R 來表示新增的暫存器。

W 位元：當運算元長度是 64 位元時，W 位元為 1；其他位元時，W 位元為 0。
R 位元：甲、乙中的 reg1 如果是 x64 時代才新增的暫存器，那麼 R＝1，否則為 0。比較特別的是，如果 reg1 是 RAX∼RDI，那麼 R＝0，理由見機械碼中的暫存器。
X 位元：索引暫存器（reg2）如果是 RAX∼RDI，那麼 X＝0；如果是 R8∼R15，那麼 X＝1。
B 位元：mova 不處理有關基底暫存器的情況，所以 B＝0。（本附錄前述的第⑸∼⑹種定址方式才會用到基底暫存器）

③、OpCode：稱為操作碼或運算碼，它決定了 CPU 要執行的指令。本附錄要更正的指令是 MOV，有關的操作碼有 8AH、8BH、88H、89H、C6H、C7H，整理如下表：

bitsWlegacy
prefixes		 甲
MOV  reg1, array[ reg2*s ]		乙
MOV  array[ reg2*s ], reg1		丙
MOV  array[ reg2*s ], imm
808A88C6
160668B89C7
3208B89C7
6418B89C7

觀察上表，應可知究竟是要用哪一個操作碼，必須知道運算元長度。這三種 MOV 指令只有運算元是位元組時，操作碼與其他三者不同，而且都是偶數（能被二整除）；而其餘的操作碼是前者多一。如果是甲、乙情形，要判斷運算元長度，可以從 reg1 著手；如果是丙，就必須由 array[reg2*s] 的 array 著手。

④、ModR/M：ModR/M 中的 Mod 與 R/M 欄位用來決定定址模式，詳細情形請參閱 DOS 組合語言第 24 章，這裏只提與本附錄有關的部分。當 R/M=100，而 Mod 為 00、01 或 10 時，都與 SIB 定址有關，所謂的 SIB 定址就是指牽涉到基底暫存器、索引暫存器與倍率的定址方式。而 mova 巨集要處理的，僅僅有索引暫存器與倍率，而沒有基底暫存器，所以 Mod 均為 00，R/M 均為 100。
ModR/M 的第 3∼5 位元稱為 Reg/OpCode，決定這三個位元是多少，在甲、乙兩種情形時，與 reg1 所代表的暫存器有關；而丙種情形的 Reg/OpCode 則是操作碼的擴充，恰好為 0（見此表的 GRP11a、GRP11b）。Reg/OpCode 的名稱很奇怪，這是因為有些指令的操作碼會擴充到這三個位元，但大部分時候不會這樣，這時候就是當做表示暫存器使用。而丙情形恰好是前一種狀況。

⑤、SIB：SIB 中的 Scale 與 Index 與運算元中的索引倍率有關，其中的倍率決定了 Scale，索引暫存器決定了 Index 與 REX prefix 的 X 位元。在 mova 巨集中不需要基底暫存器，而索引暫存器與偏移位址，查閱 DOS 組合語言第二十四章 64-Bit Mod 與 Base 的關係，得知 mova 巨集中，Base 必定是 101。

Scale 所代表的倍率
Scale00011011
倍率1248

機械碼中的暫存器

在 x64 CPU 內，有 16 個 64 位元的通用暫存器，每個通用暫存器的第 0∼31 位元可拆成 32 位元的暫存器；而第 0∼15 位元又可拆成 16 位元暫存器，第 0∼7 位元又可拆成八位元的暫存器；特別的是還有四個八位元的暫存器是位於第 8∼15 位元，這四個暫存器是 AH、CH、DH、BH。這樣算起來，共有 68 種暫存器。

68 個暫存器太多太複雜，所以從 x64 的老祖宗，8086/8088 CPU 開始說起。8086/8088 是 16 位元的 CPU，只有八個 16 位元的通用暫存器：AX、CX、DX、BX、SP、BP、SI、DI；前四者，每個都可以再拆成兩個 8 位元的暫存器，所以又有八個八位元的暫存器；SP、BP、SI、DI 不能拆開。如果要表示 16 位元的暫存器，僅需三個位元即可：

二進位數000001010011100101110111
8 位元ALCLDLBLAHCHDHBH
16 位元AXCXDXBXSPBPSIDI

到了 IA－32 的時代，像 80386/80486 等 CPU，將這八個暫存器擴充成 32 位元，所以上表變成：

二進位數000001010011100101110111
8 位元ALCLDLBLAHCHDHBH
16 位元AXCXDXBXSPBPSIDI
32 位元EAXECXEDXEBXESPEBPESIEDI

到了 x64 時代，不僅暫存器變成 64 位元，同時暫存器也由八個變成十六個。多出來的 64 位元暫存器稱為 R8∼R15，必須多用一個位元來表示。因此新增 REX Prefix 來表示新增的暫存器。如果此暫存器在目的運算元或來源運算元，用 REX Prefix 中的 R 位元表示；如果暫存器是在間接定址中，擔任索引暫存器，那麼用 REX Prefix 中的 X 位元表示；如果是基底暫存器，那麼用 REX Prefix 中的 B 位元表示。見下表：

REX.R、REX.X、REX.B 與 Reg、Index、Base 欄位之關係
REX.
R/X/B		暫存器
長度		Reg、Index 或 Base 欄位
000001010011100101110111
0八位元ALCLDLBLAH/SPL CH/BPLDH/SILBH/DIL
十六位元AXCXDXBXSPBPSIDI
三十二位元EAXECXEDXEBXESPEBPESIEDI
六十四位元RAXRCXRDXRBXRSPRBPRSIRDI
1八位元R8BR9BR10BR11BR12BR13BR14BR15B
十六位元R8WR9WR10WR11WR12WR13WR14WR15W
三十二位元R8DR9DR10DR11DR12DR13DR14DR15D
六十四位元R8R9R10R11R12R13R14R15

在上表中，有四對八位元的暫存器，兩兩具有相同的編碼，那就是 AH/SPL、CH/BPL、DH/SIL、BH/DIL，那要怎麼區別呢？上表中以紫色表示的暫存器是 IA－32 時代就已經有的暫存器，不需要加上 REX Prefix 就能表示，所以並沒有 REX.R 位元為零或一的問題。也就是說沒有 REX Prefix 就表示 AH，有 REX Prefix 但相對應的位元為零代表 SPL，其餘三對也是如此。

例子

從上面的說明，或許可以試試幾個例子，把組合語言「翻譯」或「人工組譯」成機械碼。

例子一：MOV eax,array[rdx*4]

組譯過程如下：

  1. Legacy Prefixes：只有運算元是 16 位元才需要 66H，所以此指令的機械碼沒有 Legacy Prefixes。
  2. REX Prefix：目的運算元 reg1 是 EAX，32 位元的暫存器，所以 W、R 位元均為零。索引暫存器是 RDX，故 X 位元為零。前面提過 mova 不須基底暫存器，故 B 位元為零。綜合起來 REX Prefix 的 W、R、X、B 均為 0，所以沒有 REX Prefix。
  3. OpCode：查閱③表格，得知 OpCode 為 8B。
  4. ModR/M：查閱④，得知 Mod 為 00，R/M 為 100。因為 reg1 是 EAX，所以 Reg 為 000。結合起來 ModR/M 是 00 000 100，換算成十六進位是 04。
  5. SIB：倍率是 4，所以 Scale 是 10；索引暫存器是 RDX，所以 Index 為 010；根據⑤，得知 Base 為 101。結合起來 SIB 是 10 010 101，換算成十六進位是 95。
  6. Displacement：偏移位址是從區段起始位址開始算起多少個位元組，可以用 OFFSET array 計算得到。
  7. Immediate：此指令沒有立即值。
  8. 結合前述 1.∼7. 得知 MOV eax,array[rdx*4] 機械碼是 8B 04 95 XX，其中 XX 是雙字組數值。

例子二：MOV BYTE PTR array[r10*2+ 28h],spl

組譯過程如下：

  1. Legacy Prefixes：因為運算元是八位元，所以沒有 Legacy Prefixes。
  2. REX Prefix：運算元是八位元的，所以 W 位元是零，並且 reg1 是 SPL，所以 R 位元為零但必須要有 REX Prefix。索引暫存器是 R10，故 X 位元為一。前面提過 mova 不須基底暫存器，故 B 位元為零。綜合來說 REX Prefix 是 0100 0 0 1 0，換算成十六進位是 42。
  3. OpCode：查閱③表格，得知 OpCode 為 88。
  4. ModR/M：查閱④，得知 Mod 為 00，R/M 為 100。因為 reg1 是 SPL，查閱前表，Reg 為 100。結合起來 ModR/M 是 00 100 100，換算成十六進位是 24。
  5. SIB：倍率是 2，所以 Scale 是 01；索引暫存器是 R10，查閱前表，Index 為 010；根據⑤，得知 Base 為 101。結合起來 SIB 是 01 010 101，換算成十六進位是 55。
  6. Displacement：偏移位址是從區段起始位址開始算起多少個位元組，可以用 OFFSET array 計算得到。而最後面的「＋28h」則是在計算出 OFFSET array 之後再加上 28h。
  7. Immediate：此指令沒有立即值。
  8. 結合前述 1.∼7. 得知 MOV BYTE PTR array[r10*2+ 28h],spl 機械碼是 42 88 24 55 XX，其中 XX 是雙字組數值。

如果把 SPL 改成 AH，變成 MOV BYTE PTR array[r10*2+ 28h],ah，那麼就會發生錯誤而無法組譯。這是因為 AH 與 SPL 是以有沒有 REX Prefix 來區別的，AH 必須沒有 REX Prefix，但是因為 R10 一定會要使用 REX Prefix，所以就無法組譯。如果一定要使用 AH，那麼就得把 R10 換成 RAX∼RDI 中的其中一個。

例子三： MOV WORD PTR array[rax*1],9abch

組譯過程如下：

  1. Legacy Prefixes：因為運算元是十六位元，所以 Legacy Prefixes 為 66。
  2. REX Prefix：運算元是十六位元的，所以 W 位元是零，沒有 reg1，所以 R 位元為零。索引暫存器是 RAX，故 X 位元為零。前面提過 mova 不須基底暫存器，故 B 位元為零。綜合來說 REX Prefix 的 W、R、X、B 均為 0，所以沒有 REX Prefix。
  3. OpCode：查閱③表格，得知 OpCode 為 C7。
  4. ModR/M：查閱④，得知 Mod 為 00，R/M 為 100。因為此例子是丙情形，Reg/OpCode 是操作碼的擴充，可是恰好是 0。結合起來 ModR/M 是 00 000 100，換算成十六進位是 04。
  5. SIB：倍率是 1，所以 Scale 是 00；索引暫存器是 RAX，所以 Index 為 000；根據⑤，得知 Base 為 101。結合起來 SIB 是 00 000 101，換算成十六進位是 05。
  6. Displacement：偏移位址是從區段起始位址開始算起多少個位元組，可以用 OFFSET array 計算得到。
  7. Immediate：立即值為 9abc，按照小序端排列為 BC 9A。
  8. 結合前述 1.∼7. 得知 MOV WORD PTR array[rax*1],9abch 機械碼是 66 C7 04 05 XX BC 9A，其中 XX 是雙字組數值。

實作 mova

說完了 mova 的原理之後，還須實作驗證才是王道。mova 巨集很長，包含 mova 引用的巨集，接近五百行，所以不列出程式碼，請到這兒下載，其架構大致像右圖。前面提過，mova 巨集僅僅取代以下三種 MOV 指令：

甲：mova  reg1, DATA_TYPE array[ reg2*s ]
乙：mova  DATA_TYPE array[ reg2*s ], reg1
丙：mova  DATA_TYPE array[ reg2*s ], imm

DATA_TYPE 可以是 BYTE PTR、WORD PTR、DWORD PTR、QWORD PTR，它們中間的空白可以是一個、兩個……，reg2、*、s、[、] 之間的空白也是一樣。這些不同個數的空白都會增加設計 mova 巨集的困難，故將其刪除。這段刪除空白的程式是一個稱為 remove_space 的巨集所負責，在下表右側；左側則是 mova 開始的前幾行，分別把 argument1 當做引數「呼叫」remove_space 巨集，remove_space 除去空白之後，將其傳回至 mova，存入 arg1 字串變數中。第二個引數，argument2，也如法炮製，並存入 arg2 裏。

mova    MACRO   argument1,argument2
;將兩個參數內的空白除去，變為arg1、arg2
        remove_space argument1,arg1
        remove_space argument2,arg2
  ⁝
ENDM




 
remove_space  MACRO   input,output
;刪除input字串中的所有空白，變成output字串
  temp TEXTEQU <>
  FORC char,<input>
    IFDIF <char>,< >
      temp  CATSTR temp,<char>
    ENDIF
  ENDM
  output TEXTEQU temp
ENDM

remove_space 刪除空白的原理很簡單，先設定一個空字串，temp。然後使用 FORC/ENDM 重複區塊，每次由 input 字串中取出一字元，設為 char。如果 char 不是空白就接在 temp 之後，如果是空白就不做任何事回到 FORC/ENDM 開始處重複下一循環，直至所有 input 內的字元都處理完畢。這樣 temp 就是 input 刪除空白後的結果。

刪除空白之後，接下來就是判斷是哪一種情形，甲、乙還是丙，參考上圖。假如 arg1 是暫存器（可能是 64、32、16 或 8 位元的暫存器），那就是甲情形；如果 arg2 是立即值就是丙情形，剩下的就是乙情形。要判斷運算元是不是暫存器，有兩種方法：一是使用 OPATTR 運算子，二是逐一檢查是否為那 68 種暫存器的其中一種。前者雖然簡便但結果也很簡單，無法判斷是那一個暫存器。因此小木偶採用後一種方法，逐一檢查，但是能獲得到底是哪個暫存器。

get_reg 巨集

小木偶把檢查運算元是不是暫存器的程式獨立成一巨集，稱為 get_reg，其程式碼在下面右側。左側顯示 mova 如何引用 get_reg 巨集，引用時須把 arg1 與 reg64 當成引數傳給 get_reg。arg1 可能是暫存器，也可能是像「DATA_TYPE array [ reg2*s ]」樣子的間接定址。reg64 是所有 64 位元暫存器名稱的列表，見右側的第一、二行。

    ;檢查arg1是否為暫存器，先64位元，
    ;再來是32、16位元，最後是8位元
        get_reg arg1,%reg64
        IF reg LT 8             ;㈰式
          rex_prefix=48h        ;RAX∼RDI
          d_type TEXTEQU <Q>
        ELSEIF reg LT 16
          rex_prefix=4ch        ;R8∼R15
          reg=reg-8
          d_type TEXTEQU <Q>
        ELSE
          get_reg arg1,%reg32
          IF reg LT 8           ;EAX∼EDI
            d_type TEXTEQU <D>
          ELSEIF reg LT 16
            rex_prefix=44h      ;R8D∼R9D
            d_type TEXTEQU <D>
            reg=reg-8
 
reg64 TEXTEQU <rax,rcx,rdx,rbx,rsp,rbp,rsi,rdi,r8,\
               r9,r10,r11,r12,r13,r14,r15>
reg32 TEXTEQU <eax,ecx,edx,ebx,esp,ebp,esi,edi,r8d,
               r9d,r10d,r11d,r12d,r13d,r14d,r15d>
         ⁝
get_reg MACRO   reg_name,reg_lst
;在reg_lst列表中，找到reg_name所指定的暫存器，記錄在
;reg裏。reg代表reg_lst列表中的第幾個元素，由0開始
    reg=0
    FOR element,<reg_lst>
      IFDIFI reg_name,<element>
        reg=reg+1
      ELSE
        EXITM
      ENDIF
    ENDM
ENDM

先看右側 get_reg 巨集。首先設定一個變數，reg，令其為零，然後利用 FOR/ENDM 逐一由 reg64 中取出一個暫存器名稱與 arg1 比對。每取出一個就使 reg 增加一，直到取出的暫存器名稱與 arg1 相同才跳出 FOR/ENDM 重複區塊，或者將 reg64 內的 16 個暫存器都比對完畢還沒有符合時，也會離開 FOR/ENDM 重複區塊。

注意到 reg64 的暫存器的排列方式並不是隨意排列，而是依照前表所敘述 ModR/M 中 Reg 所代表的數值方式排列。如果找到了相符合的暫存器，那麼 reg 之值或 Reg 減 8，就會等於找到的暫存器所代表的 Reg 之值。詳細的說，當 get_reg 退出來後執行到左側㈰式之時，reg 有三種情形：①reg 小於 8，那麼 arg1 是 RAX∼RDI 之中的其中一個暫存器，reg 就恰好是 ModR/M 中的 Reg 欄位。②reg 在 8∼15 之間，那麼 arg1 是 R8∼R15 其中之一，reg 須減去 8 才是 ModR/M 中的 Reg 欄位，同時順便把 REX Prefix 的 R 位元設為一。③reg 等於 16，表示 arg1 不是 64 位元的暫存器。第①、②情形來說都是 64 位元，所以 REX Prefix 的 W 位元設為一，d_type 設為<Q>字串。

如果是③情形就表示 arg1 不是 64 位元暫存器，那麼有可能是 32 位元的暫存器，而 mova 要做的就把第二個引數改成 reg32，接下來就是重複的過程。一直到所有十六位元、八位元的暫存器都檢查完畢，八位元的暫存器有 20 個，所以 reg 大於或等於 20，才表示 arg1 不是暫存器。

判斷屬於甲、乙還是丙情形

檢查完 68 個暫存器，mova 分成兩個分支：①假如 arg1 是暫存器，那麼就是甲的情形；②如果 arg1 不是暫存器，那麼還要進一步檢查是乙還是丙，最簡便的方法是檢查 arg2 是否為數值。arg2 是否為數值也很容易判斷，僅需一行即可，見下面程式。如果 arg2 是數值，那麼它起始的第一個字元必定是阿拉伯數字，所以只需引用 get_reg 檢查其第一個字元是否在 0∼1 之間。如果傳回的 reg 大於或等於 10，那麼 arg2 就不是數值，這是乙的情形，否則就是丙的情形。到這裏，已能確定是甲、乙、丙哪一種情形。

get_reg <@SubStr(%arg2,1,1)>,<0,1,2,3,4,5,6,7,8,9>

上面曾列出 get_reg 巨集的程式碼，有兩個引數：reg_name、reg_lst。雖然名稱上是寫成 reg，看起來好像是檢查名為 reg_name 的暫存器是否為 reg_lst 暫存器列表內的一員；但實際上，也可以把 reg_name 換成任何字元，檢查該字元是否在 reg_lst 內。

現在 mova 已經能夠從輸入的引數判斷是屬於甲、乙、丙哪一種情形，接下來就得分開處理。先說如何處理甲的情形，然後再說處理乙情形，最後是丙。

處理甲情形

在處理甲的情形時，第二個運算元是利用索引暫存器間接定址，像「DATA_TYPE array [ reg2*s ]」的形式，但小木偶想讓 mova 功能更強一些，讓「DATA_TYPE array [ reg2*s ＋ x ]」也能組譯。array、reg2、s、x 依序是陣列名稱、索引暫存器、倍率與偏移位址。DATA_TYPE 本來是「BYTE PTR」、「WORD PTR」、「DWORD PTR」、「QWORD PTR」，但已經被 remove_space 處理過，所以變成「BYTEPTR」、「WORDPTR」、「DWORDPTR」、「QWORDPTR」。即使如此，利用索引暫存器間接定址，仍然多達 22 種排列情形，可分為下面子∼卯四種情形：

子：DATA_TYPE array[reg2*s]      ;reg2、s 可以互換，意即 array[s*reg2]也可以，這樣有兩種排列方式
丑：DATA_TYPE [array＋reg2*s]    ;array 與 reg2*s 可以互換，reg2 與 s 也可以互換，這樣就有 4 種排列方式
寅：DATA_TYPE array[reg2*s＋x]   ;reg2*s 與 x 可以互換，reg2 與 s 也可以互換，這樣就有 4 種排列方式
卯：DATA_TYPE [array＋reg2*s＋x] ;array、reg2*s、x 可以互換，reg2 與 s 也可以互換，這樣就有 12 種排列方式

adjust 巨集

處理 22 種排列情形會使 mova 變得很複雜，故先以 adjust 巨集把這 22 種不同的排列情形都依一定順序轉換成像「Tarray[reg2*s＋x]」的形式，T、array、reg2、s、x 的先後順序是固定的，其中 T 是把「BYTEPTR」、「WORDPTR」、「DWORDPTR」、「QWORDPTR」改用一個英文字母代替，它們依次是 B、W、D、Q、X，分別代表位元組、字組、雙字組、四字組、未指定這些資料類型。下表就是轉換後的例子：（operand、output 是 adjust 的兩個參數，稍後說明）

operandoutput
WORDPTRarray[28H＋RBX*8H]Warray[RBX*8H＋28H]
QWORDPTR[array＋4H*R10＋28H]Qarray[R10*4H＋28H]
[R11*2＋16]X[R11*2＋16]

adjust 巨集總共將近兩百一十行，所以底下僅列出 adjust 巨集的大概結構。adjust 只有兩個參數：operand、output，adjust 會把輸入的 operand 轉換成 output。adjust 第 3∼9 行先將前面的資料類型全都換成用一個字母代替，要注意的是 adjust 是在 remove_space 處理過後才執行，所以 operand 內並沒有空白，第 3 行要檢查的是「BYTEPTR」，而不是「BYTE PTR」。檢查其他資料類型也都一樣，就省略不列出來了。

接下來就是要處理上述子∼卯四種情形，很明顯可以檢查「＋」的數量來決定，這段程式在下表的第 17∼36 行。沒有「＋」的是子，有兩個「＋」的是卯，而丑、寅雖然都有一個「＋」，但可以用「[」的位置決定，因為丑的 operand 會像「B[array＋reg2*s]」，寅的情形則像「Barray[reg2*s＋x]」，所以檢查「[」是否在第 2 個位置即可；這段程式在下表的第 22∼31 行。

adjust 巨集
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
adjust  MACRO   operand,output
      ⁝
  IFIDNI @SubStr(%operand,1,7),<BYTEPTR>
  ;檢查 operand 是否為「BYTEPTR」起頭，如果是將「BYTEPTR」以「B」代替
    temp SUBSTR operand,8
    operand CATSTR <B>,temp
  ELSE
      ⁝
  ENDIF
      ⁝
  l_squbra INSTR 1,operand,<[> ;left square bracket在operand的位置
  r_squbra INSTR 1,operand,<]> ;right square bracket在operand的位置
  asterisk INSTR 1,operand,<*> ;*在operand的位置
  plus1    INSTR 1,operand,<+> ;第一個＋在operand的位置
  plus2    INSTR plus1+1,operand,<+> ;第一個＋在operand的位置
      ⁝
  IF plus1 EQ 0
  ;如果沒有＋，屬於子情形，Tarray[reg*s]，reg、s 可互換，有兩種排列方式
      ⁝
    rtn_str CATSTR @SubStr(%operand,1,1),ary_name,<[>,idx_reg,<*>,scale_str,<]>
  ELSEIF (plus1 NE 0) AND (plus2 EQ 0)
  ;如果plus1不為零且plus2等於零，表示只有一個＋，屬於丑、寅，共8種排列方式
    IF l_squbra EQ 2
    ;如果l_squbra等於2，屬於丑，有4種排列方式
      ⁝
      rtn_str CATSTR @SubStr(%operand,1,1),ary_name,<[>,idx_reg,<*>,scale_str,<]>
    ELSE
    ;否則屬於寅，有4種排列方式
      ⁝
      rtn_str  CATSTR @SubStr(%operand,1,1),ary_name,<[>,idx_reg,<*>,scale_str,<+>,number,<]>
    ENDIF
  ELSE
  ;其他情形有兩個＋，屬於卯，共12種排列方式
      ⁝
    rtn_str CATSTR @SubStr(%operand,1,1),ary_name,<[>,idx_reg,<*>,scale_str,<+>,number,<]>
  ENDIF
  output TEXTEQU rtn_str
ENDM

要把 22 種情形全部列出來篇幅太大，不切實際，所以小木偶僅說明子情形。子情形的 operand 是「DATA_TYPE array[reg2*s]」，其中 reg2、s 可互換位置，所以有兩種排列方式，但不論哪一種，陣列名稱都是由第二個字元開始到「[」所在的前一個位置停止，所以很容易就能計算出陣列名稱，然後存於 ary_name 字串內，見下面㈮式。

  IF plus1 EQ 0
  ;如果沒有＋，屬於子情形，Tarray[reg2*s]，reg2、s 可互換，有兩種排列方式
    ary_name  SUBSTR operand,2,l_squbra-2     ;㈮式
    IFIDNI @SubStr(%operand,asterisk+1,1),<R> ;㈭式
    ;如果相等，表示索引倍率中，倍率在前，索引暫存器在後，例如Tarray[s*reg2]
      idx_reg   SUBSTR operand,asterisk+1,r_squbra-asterisk-1 ;㈬式
      scale_str SUBSTR operand,asterisk-1,1                   ;㈫式
    ELSE
      ⁝
    ENDIF
    rtn_str CATSTR @SubStr(%operand,1,1),ary_name,<[>,idx_reg,<*>,scale_str,<]> ㈯式

接下來要檢查 [ ] 內是倍率在前還是索引暫存器在前，檢查方法也很簡單，因為索引暫存器的名稱都以 R 開頭，所以只需檢查「*」後面的那個字元是否為 R 即可，如果真是 R，就能知道在 [ ] 內是 [s*reg2]，否則是 [reg2*s]。這段程式在上面㈭式。如果是前者，那麼索引暫存器名稱就是從「*」之後到「]」之前，存於 idx_reg 字串內；而倍率則是在「[」之後到「*」之前，存於 scale_str 字串內。即㈬、㈫兩式。

最後在㈯式中重新依據前面提過的順序重新組合，成為 rtn_str 字串。㈯式中的「@SubStr(%operand,1,1)」會得到 operand 的資料類型，B、W、D、Q 或 X。如果輸入的是其他 operand，則可能是其餘丑、寅、卯三種情形，不論哪一種都會依據不同情況，並且依照前面提過的順序重新組合成 rtn_str 字串。最後使 output 字串與 rtn_str 相等後返回 mova 巨集。

生成機械碼

如果已確認是甲情形，且已經經由 adjust 調整之後，那麼 arg1 是暫存器，arg2 是像「Tarray[reg2*s＋x]」的間接定址，整個指令是「mov reg1,Tarray[reg2*s＋x]」，那麼就可以生成機械碼了。

在 mova 巨集裏的 Legacy Prefixes、REX Prefix 與 OpCode 都在檢查是否為暫存器時就順便設好了。只有索引暫存器如果是 R8∼R15 中的其中之一，那麼必須將 REX Prefix 的 X 位元設為一，這部分只有在經過 adjust 巨集調整過運算元 arg2 之後才依狀況是否設定。

ModR/M 中，Mod 與 R/M 分別是 000 與 100，這是不變的；至於第 3∼5 位元是其實就是在檢查是否為暫存器時的 reg。因為它在第 3∼5 位元，所以 reg 必須乘以八，所以 ModR/M 為：

modrm=0+reg*8+4

SIB 中的第 7∼8 位元是倍率，位於「*」之後，而且長度為一個字元，可由下面程式得到：

   temp SUBSTR arg2,asterisk+1,1   ;由arg2中取得倍率，並存於temp內
   IF temp EQ 1
     scale=0
   ELSEIF temp EQ 2
     scale=40h
   ELSEIF temp EQ 4
     scale=80h
   ELSEIF temp EQ 8
     scale=0c0h
   ELSE
     msg_err TEXTEQU <ERROR: Scale must be 1, 2, 4 or 8>
     GOTO error
   ENDIF

SIB 中，Base 在 0∼2 位元，必定是 101，十六進位是 5。第 3∼5 位元是索引暫存器，位於「[」之後到「*」之前，並且是 64 位元的暫存器，可以由下面程式得到：

   temp SUBSTR arg2,l_squbra+1,asterisk-l_squbra-1  ;由arg2中取得索引暫存器名稱，並存於temp字串內
   get_reg temp,%reg64
 ;如果reg大於7，則REX.X需設為一，同時使reg減8
   IF reg GT 15
     msg_err TEXTEQU <ERROR: Must be 64-bit register>
   ELSEIF reg GT 7
     rex_prefix=rex_prefix OR 42h
     reg=reg-8
   ENDIF
   sib=scale+reg*8+5

上面程式最後一行，就是把倍率、索引暫存器、Base 結合起來，成為 SIB 位元組。

甲情形沒有立即值，所以最後一項就是 displacement。甲情形的 argument2 經過 adjust 調整後有兩種情形：「Tarray[reg2*s＋x]」與「Tarray[reg2*s]」，而 displacement 就是把 array 取其位址，再加上 x 即可。所以程式如下：

 ;取得陣列名稱，陣列名稱代表偏移位址
   temp     SUBSTR arg2,2,l_squbra-2
   displacement=OFFSET temp
 ;若plus1不為零，須將[]內的數值必須加進偏移位址中
   IF plus1 NE 0
     temp   SUBSTR arg2,plus1+1,r_squbra-plus1-1
     displacement=displacement+temp
   ENDIF

等這一切位元組都設定好之後，還須依據上面提到的機械碼順序，以 DB 或 DD 假指令方式存入目的檔內才行。為了讓乙、丙兩種情形也能使用，所以需考慮較周全。程式如下：

:save ;把機械碼依據legacy prefixes, REX prefix, OpCode, ModR/M, SIB, displacement, immediate排列
  IF legacy_prefix NE 0
    DB  legacy_prefix
  ENDIF
  IF rex_prefix NE 0
    DB  rex_prefix
  ENDIF
  DB opcode,modrm,sib
  DD displacement
  IF immediate NE 0
    IFIDNI d_type,<B>
      DB immediate
    ELSE
      IFIDNI d_type,<W>
        DW immediate
      ELSE
        IFIDNI d_type,<D>
          DD immediate
        ELSE
          IFIDNI d_type,<Q>
            DD immediate
          ENDIF
        ENDIF
      ENDIF
    ENDIF
  ENDIF

到此就大功告成了，但是只有甲情形是完成了，還有乙、丙兩種情形未完成。

處理乙情形

假如你仔細觀察甲、乙兩種情形：

甲：mova   reg1, DATA_TYPE array [ reg2*s ]
乙：mova   DATA_TYPE array [ reg2*s ], reg1

你會發現這兩種情形只是兩個運算元互換，也可說是兩個引數互換。因為目的運算元與來源運算元互換，導致操作碼不同，除此之外，mova 處理過程都相同，於是有了大膽想法。這個大膽的想法就是把 mova 原來的引數刪除空白後變為 arg1、arg2 互換，再額外設好操作碼即可，於是程式如下。其中 exchange 標記應該指向處理甲情形的一開始，這樣就將乙情形處理完成了。

;處理像「MOV 資料類型 陣列名[暫存器1*倍率＋數值],暫存器2」的指令，跟從:exchange∼:reg_not_target的
;巨集程式碼幾乎一樣，差別在於兩個運算元互換且OpCode變為89h或88h，前者是64、32、16位元，後者是8位元
  mem_reg_v=89h
  mem_reg_b=88h
  temp TEXTEQU arg1
  arg1 TEXTEQU arg2
  arg2 TEXTEQU temp
  GOTO exchange

處理丙情形

剩下最後一種，丙情形了。丙情形的指令是像「mova DATA_TYPE array[reg2*s＋x],imm」的樣子，其中「DATA_TYPE array[reg2 *s＋x]」是 arg1，imm 是 arg2。arg1 裏面的 array 也可以在「[ ]」內，如果在「[ ]」內，那麼 array、reg2*s、x 三者可以互換位置，即使不在「[ ]」內，那麼 reg2*s、x 也可以互換位置，索引倍率 reg2*s 的 reg2 與 s 也可互換位置，所以有很多種情形。

幸好在這之前，已經寫好了 adjust 巨集。它可以把 arg1 依照 array、reg2、s、x 的順序排列，變成像「Tarray[reg2*s＋x]」的樣子，這樣往後處理就會變得簡單了，所以第一步就是引用 adjust 巨集轉換 arg1。第二步是計算 [、]、*＋ 在 arg1 中的位置，分別記錄在 l_squbra、r_squbra、asterisk、plus1 變數裏。

接下來就可以計算機械碼各位元組的數值了。在丙情形裏，ModR/M、SIB、偏移位址均與甲、乙兩種情形的處理方式一樣就不重複說明；就只有一點不同，在丙情形中不使用暫存器，ModR/M 中的 Reg 位元其實是操作碼的擴充，所以應該是 Reg/OpCode 的 OpCode 才是，其值均為零，見此表的 GRP11a、GRP11b。

丙情形有立即值，立即值可視為常數，argument2 就是立即值。眾所周知，MOV 的目的運算元與來源運算元長度需一致，因此雖然不須特別處理立即值，但必須考慮運算元長度。運算元長度除了影響立即值長度之外，還影響 REX Prefix、Legacy Prefixes 及操作碼。當運算元長度為 64 位元時，REX Prefix 的 W 位元須設為一，且較高的四個位元要變為 4；當運算元長度為 16 位元時，Legacy Prefixes 為 66H，否則不存在；當運算元是 8 位元時，操作碼是 0C6H，否則是 0C7H。這段程式如下：

  d_type SUBSTR arg1,1,1
  IFIDNI d_type,<B>
    opcode=0c6h
  ELSE
    opcode=0c7h
    IFIDNI d_type,<W>
      legacy_prefix=66h
    ELSE
      IFIDNI d_type,<D>
      ELSE
        IFIDNI d_type,<Q>
          rex_prefix=rex_prefix OR 48h
        ELSE
          msg_err TEXTEQU <ERROR: The operand length must be specified>
          GOTO error
        ENDIF
      ENDIF
    ENDIF
  ENDIF

值得一提的是，即使運算元長度為 64 位元，可是立即值仍然只能是 32 位元，小木偶不知道原因為何，但是仍然可以組譯成功；如果立即值改成 64 位元，反而會產生錯誤。取得立即值程式如下：

  ;取得立即值
    immediate=argument2

最後一步是把計算機械碼所得的各位元組，以 DB 或 DD 假指令方式存入目的檔內。前面提過，其實跟處理甲、乙兩種情形最後結果一樣，直接跳到「:save」標記處。

到此，真正的大功告成了！

結論

這個附錄裏，小木偶敘述了用巨集的方法，讓原本 UASM64.EXE 不能組譯，但語法正確的組合語言指令能正常組譯。這讓我內心十分高興，竟然能寫出這種程式來。當然這要歸功許多人，他們撰寫了 MASM64 SDK 讓小木偶能觀摩學習。

這個修正 UASM64.EXE 的巨集，mova，以及相關巨集都存在 MYFIX.INC 包含檔內，並製作成壓縮檔放在 MEGA 上，如果用得著的話請自行下載。解壓縮後只有一個 MYFIX.INC 檔案，將其放到「C:\UASM\Include」子目錄內即可，或者放到與組合語言原始檔案同一子目錄也行。

在組合語言程式中，要引用 mova 巨集，必須先包含 MYFIX.INC，然後就能引用，例如底下的例子：

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
;組譯方式
;uasm64 -win64 tst.asm
;link tst.obj /largeaddressaware:no
OPTION  CASEMAP:NONE
OPTION  WIN64:3

INCLUDE WINDOWS.INC
INCLUDE MYFIX.INC       ;包含修正UASM64.EXE所需mova巨集的包含檔

INCLUDELIB      KERNEL32.LIB
INCLUDELIB      USER32.LIB
;*******************************************************************************
.DATA
button  DD      MB_OKCANCEL,MB_ABORTRETRYIGNORE,MB_YESNOCANCEL,MB_YESNO,MB_RETRYCANCEL
number  DD      5
szCap   DB      "TEST MYFIX.INC",0
szText  DB      "PLEASE PRESS ANY BUTTON.",0
;*******************************************************************************
.CODE
;-------------------------------------------------------------------------------
main    PROC
@@:     mov     rax,5
        sub     eax,number
        mova    r9d,button[rax*4]  ;使用mova巨集
        invoke  MessageBox,0,OFFSET szText,OFFSET szCap,r9d
        dec     number
        jnz     @b
        invoke  ExitProcess,0
main    ENDP
;*******************************************************************************
END     main

在第 8 行，引入 MYFIX.INC 包含檔，而後在第 24 行引用 mova 巨集，連結時別忘了要下達「/largeaddressaware:no」選項。如果不用這兩行，就要採用第十六章變通的方法。