Ch 10　副程式（二）

前一章介紹了副程式，知道它是一段可以完成特定目的的程式。要讓副程式執行時，得由主程式呼叫它。當然要完成某些特定目的，必定要由主程式傳給副程式某些資料，這些資料一般稱為參數 ( parameter )，而後副程式經過運算才能完成。上一章所介紹的程式，是藉由暫存器作為參數把資料傳給副程式的，但是暫存器畢竟有限數量稀少，有時不夠使用。因此本章介紹另一種傳遞參數的方法，藉由堆疊作為參數傳遞資料。

原理

使用堆疊將參數傳給副程式，仍然要使用 CALL 指令呼叫副程式，但是 MASM 6.x 裏新增一個假指令，INVOKE，能減少程式設計師許多煩人的工作。然而使用 INVOKE 指令呼叫副程式之前得宣告副程式的原型，這可以用 PROTO 假指令達成目的，因此底下先介紹 PROTO 假指令。


PROTO 假指令

宣告副程式原型的意思大致可認為是告訴組譯器副程式需要幾個參數，這可用 PROTO 達成。PROTO 假指令的語法是：

label   PROTO   [distance][language-type][參數列表]

distance 與 language-type 的用法與 PROC 一樣。先說 distance 可以是 NEAR 或是 FAR，分別表示副程式是近程還是遠程。近程的意思是指副程式與主程式在同一區段內；遠程則是在不同區段。

distance 可以省略，如果省略就由程式開始的 .MODEL 決定。如果 .MODEL 指定的記憶體模式是 TINY、SMALL、COMPACT 或 FLAT，那麼副程式是近程的；如果是 MEDIUM、LARGE 或 HUGE，那麼就是遠程。如果是 80386 等級或更高等級的 CPU，可以用 16 或 32 位元區段，distance 還可以使用 NEAR16、NEAR32、FAR16 或 FAR32。

language-type 是語言類型的意思，在第九章提到 PROC/ENDP 時也說過 PROC 中有一選項是語言類型，與 PROTO 的語言類型意義相同，都是用來設定呼叫慣例 ( calling convention ) 的。如果省略 language-type，以 .MODEL 處定義的為準。語言類型可以有 C、BASIC、FORTRAN、PASCAL、SYSCALL 與 STDCALL 六種，與呼叫時參數推入堆疊的情形有關。底下是語言類型的資料：

表一　語言類型
語言類型STDCALLSYSCALL CBASICFORTRANPASCAL
由哪個參數開始推入堆疊右右右左左左
誰負責清除堆疊副程式主程式主程式副程式副程式副程式
是否允許不定參數是 ( 見底下 )是是否否否
修改副程式名稱加入 _ 及 @不修改加入 _改成大寫改成大寫改成大寫

仔細檢查上面語言類型的表格，你就會發現，事實上 BASIC、FORTRAN、PASCAL 這三種語言類型其實是一模一樣。再看 C 與 SYSCALL 似乎也一樣，但是還是有差別的；組譯器不會為 SYSCALL 中的副程式名等符號添加底線或其他字元，但 C 會；這幾乎不會影響程式運作，將它們倆視作相等亦未嘗不可。STDCALL 在參數個數不確定時，亦即使用 VARARG 時是由主程式清除的堆疊，其他情形都由副程式清除。

參數列表是由許多組的參數與資料類型組成，每一組都是「參數:資料類型」，至於要多少組則視副程式的需要決定，也可以一組都沒有。底下是幾個例子：

addup   PROTO   NEAR C arg1:WORD, arg2:WORD, arg3:WORD
myproc  PROTO   :WORD, :BYTE

PROTO 最重要的目的是告訴編譯器參數的數量，參數的名稱並沒有太大用途，僅僅是為了可讀性，因此可以省略，所以上面最後一句也是可以的。在使用 INVOKE 呼叫副程式前，一定要先用 PROTO 宣告副程式原型；但是如果在 INVOKE 呼叫副程式前，副程式已經先由 PROC/ENDP 定義過了，那麼 PROTO 宣告原型就沒有必要了可以省略不寫。


INVOKE 假指令

INVOKE 能建立一系列的 PUSH 指令以及 CALL 指令。INVOKE 的語法如下

INVOKE  副程式名,參數1,參數2……

副程式名可以是標記或是間接定址，參數1、參數2……中的每個參數都會由 PUSH 指令推入堆疊裏而後被副程式所存取，那麼會有幾個參數得視 PROC 或 PROTO 假指令所定義的參數列表中的參數個數決定。這裏的參數1、參數2……可以使用立即值、變數、暫存器、ADDR 運算子、位址運算式。


呼叫慣例 ( Calling Convention )：以例子說明 PROTO、PROC、INVOKE 的關係

.MODEL、PROTO、PROC 這三個假指令都有一個選項，語言類型 ( language type )，它規定了主程式與副程式之間的參數依照什麼順序傳達、又由誰負責清除堆疊等資訊，這些資訊稱為「呼叫慣例」( calling convention )；也可以說，呼叫慣例是由語言類型設定的。

一般來說，在一個程式裏會呼叫許多副程式，而這些副程式都會設定成相同的呼叫慣例，因此在程式一開始由「.MODEL」設定好，PROTO、PROC 都省略語言類型，這樣較為單純且方便。如果「.MODEL」沒有設定語言類型，那麼同一個副程式在「PROTO」宣告時與「PROC」定義時都要設定相同的語言類型，但不同的副程式可以採用不同的語言類型，這樣就有較大的彈性。不過要注意的是，「PROTO」與「PROC」都要設定，否則組譯器會產生錯誤訊息；當然如果「PROC」在「PROTO」之前，還是可以省略「PROTO」。

例如有個副程式 sum_of 為計算三個整數之和，底下是程式片段：

sum_of  PROTO   語言類型 :WORD,:WORD,:WORD
        ...
        INVOKE  sum_of,num1,num2,num3
        ...
sum_of  PROC    語言類型 n1:WORD,n2:WORD,n3:WORD
        mov     ax,n1
        add     ax,n2
        add     ax,n3
        ret
sum_of  ENDP

因為「sum_of PROC」在「INVOKE sum_of」之後，因此要在「INVOKE sum_of」之前以 PROTO 宣告 sum_of 的原型，否則組譯器無法知道要如何處理參數。如果是「sum_of PROC」在「INVOKE sum_of」之前，就不需要寫「PROTO」了，因為「sum_of PROC」就已經告訴組譯器如何處理參數了。所以上面的程式可以寫成下面那樣：

sum_of  PROC    語言類型 n1:WORD,n2:WORD,n3:WORD
        mov     ax,n1
        add     ax,n2
        add     ax,n3
        ret
sum_of  ENDP
        ...
        INVOKE  sum_of,num1,num2,num3
        ...

底下說明組譯器如何參數。如果把上面程式片段中的「語言類型」依序變更為 STDCALL、SYSCALL、C、BASIC，組譯原始程式後的結果，如下表：

表二　語言類型範例
原始碼STDCALLSYSCALLCBASIC
INVOKE sum_of,num1,\
         num2,num3
 
PUSH    num3
PUSH    num2
PUSH    num1
CALL    sum_of
...

PUSH    num3
PUSH    num2
PUSH    num1
CALL    sum_of
ADD     SP,+06
...

PUSH    num3
PUSH    num2
PUSH    num1
CALL    sum_of
ADD     SP,+06
...

PUSH    num1
PUSH    num2
PUSH    num3
CALL    sum_of
...

sum_of   PROC  語言類型\
  n1:WORD,n2:WORD,n3:WORD
   mov   ax,n1
   add   ax,n2
   add   ax,n3
   ret
sum_of   ENDP
 
PUSH    BP
MOV     BP,SP
MOV     AX,[BP+04]
ADD     AX,[BP+06]
ADD     AX,[BP+08]
POP     BP
RET     0006
 
PUSH    BP
MOV     BP,SP
MOV     AX,[BP+04]
ADD     AX,[BP+06]
ADD     AX,[BP+08]
POP     BP
RET
 
PUSH    BP
MOV     BP,SP
MOV     AX,[BP+04]
ADD     AX,[BP+06]
ADD     AX,[BP+08]
POP     BP
RET
 
PUSH    BP
MOV     BP,SP
MOV     AX,[BP+08]
ADD     AX,[BP+06]
ADD     AX,[BP+04]
POP     BP
RET     0006

組譯器會把「INVOKE sum_of,num1,num2,num3」組譯成一系列的 PUSH 與 CALL 指令，若是「語言類型」為 STDCALL，參照上面表一語言類型的說明，最右邊的 num3 參數最先被推入堆疊，然後依序是 num2、num1，最後是 CALL 指令，於是就變成上表二的情形。見下圖圖一，這是進入 sum_of 後，堆疊安排情形，可以見到 BP＋4 位址的地方是 num1，BP＋6 是 num2……，當副程式要存取這些參數時，就是到這些位址去存取。

上圖圖二是副程式結束時，先由堆疊取回原來的 BP，此時堆疊頂端是返回位址，然後執行「RET 6」，由返回主程式並捨棄堆疊上六個位元組的資料，於是堆疊內的情形就和未進入 sum_of 前一樣。由於「RET 6」是在副程式裏執行的，所以表一裏說 STDCALL 由副程式清除堆疊裏的參數。

如果語言類型改成「C」，組譯結果會有些不同。先說相同的部分。在把參數推入堆疊時，由右至左依序推入堆疊，因此 num3 在最高位址，num1 在最低位址。執行「CALL」時再把返回位址推入堆疊，於是堆疊中的情形變成下圖四。進入 sum_of 後，BP＋4 位址的地方是 num1，BP＋6 是 num2……，當副程式要存取這些參數時，也是到這些位址去存取。

上圖五是副程式結束時，先由堆疊取回原來的 BP，此時堆疊頂端是返回位址，然後執行「RET」。程式主控權回到主程式裏，這時候堆疊頂端是 num1 的位址。回到主程式後的第一個指令是「ADD SP,6」，使得 SP 暫存器重新指向未呼叫副程式前的堆疊頂了。由於是在主程式中清除堆疊內的參數，因此表一裏說 C 由主程式清除堆疊裏的參數。

STDCALL 與 C 是較為常用的語言類型。微軟所出品的 Windows 作業系統有 16位元、32 位元與 64 位元三種，其中 32 位元的作業系統，從 Windows 95/98/XP 乃至到 Windows 7/8/10，所使用到的 Win32 API 的呼叫慣例都是 STDCALL，所以撰寫 Win32 程式一定要了解 STDCALL 才行。至於 C，那也不必多說，近十年來最流行且歷久不衰的程式語言非 C 語言莫屬，要學好 C 也不可不知 C 這種呼叫慣例。

一個例子：SEC

小木偶想以一個例子來說明如何用 STDCALL 呼叫慣例讓堆疊傳遞參數。底下的 SEC.ASM 程式是計算五小時四十八分十七秒相當於多少秒鐘，最後在螢幕上印出字串：「05:48:17=20897seconds」。原始程式如下：

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
;SEC把5小時48分17秒換算成共有幾秒鐘
.MODEL  TINY,STDCALL
.386
seconds PROTO   :WORD,:WORD,:WORD,:WORD
;*******************************************************************************
.CODE  
ORG     100h
;-------------------------------------------------------------------------------
;主程式
main    PROC
        jmp     begin
hour    DW      5
minute  DW      48
second  DW      17
string  DB      "05:48:17=00000seconds$"
begin:  mov     dx,OFFSET string
        INVOKE  seconds,hour,minute,second,OFFSET string+9
        mov     ah,9
        int     21h
        int     20h
main    ENDP
;-------------------------------------------------------------------------------
;seconds換算時、分、秒共有幾秒鐘
;參數：n1－時
;　　　n2－分
;　　　n3－秒
;　　　address－轉換後的十進位字串
;回傳值：AX－1，成功無錯誤
;　　　　　－0，錯誤
seconds PROC    USES bx cx dx n1:WORD,n2:WORD,n3:WORD,address:WORD
        LOCAL   ten:WORD
        LOCAL   temp:WORD
        mov     ten,10
        mov     ax,n1
        sub     dx,dx
        mov     cx,3600
        mul     cx      ;AX＝3600×小時
        mov     temp,ax ;把AX暫時存於temp裏，因為AX在做MUL運算會用著
        mov     ax,n2
        sub     dx,dx
        mov     cx,60
        mul     cx      ;AX＝60×分鐘
        add     ax,n3   ;AX＝60×分鐘＋秒鐘
        add     ax,temp ;AX＝已換算成總秒數
        mov     bx,address
        add     bx,4    ;BX＝十進位字串的個位數位址
        mov     cx,5    ;共有五位數
next:   sub     dx,dx
        div     ten
        add     [bx],dl
        dec     bx
        loop    next
        mov     ax,1
        ret
seconds ENDP
;*******************************************************************************
END     main

把 SEC.ASM 存入「MS-DOS 6.20」虛擬機器中的「E:\DOS\SECOND」子目錄裏，組譯與聯結過程與往常一樣：

C:\>e: [Enter]

E:\>cd dos\second [Enter]

E:\DOS\SECOND>ml sec.asm [Enter]
Microsoft (R) Macro Assembler Version 6.11
Copyright (C) Microsoft Corp 1981-1993.  All rights reserved.

 Assembling: sec.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]: sec.obj/t
Run File [sec.com]: "sec.com"
List File [nul.map]: NUL
Libraries [.lib]:
Definitions File [nul.def]:

E:\DOS\SECOND>sec [Enter]
05:48:17=20897seconds
E:\DOS\SECOND>

看到 SEC 印出「05:48:17=20897seconds」字串，就表示 SEC 已經執行成功了。底下小木偶要談的是呼叫副程式時所建立的堆疊框 ( stack frames )。


堆疊框 ( Stack Frames )

堆疊框是指在呼叫副程式時，在堆疊所建立的一塊記憶體，由高位址向低位址，裏面存放著參數、返回位址、原來的 BP、區域變數以及要保存的暫存器等資料，等返回主程式後這些資料都會被銷毀不能再存取。小木偶在前面已經提過了參數、返回位址、原來的 BP 等資料的安排方式，也談過如何銷毀它們。現在小木偶要藉著 SEC.COM 程式，來談談要保存的暫存器以及區域變數如何配合參數、返回位址、原來的 BP 等資料。

前一章提到 PROC 的語法是

label  PROC  [distance][language-type][visibility][<prologuearg>][USES 暫存器列表][參數列表]

其中的「USES 暫存器列表」會被組譯器組譯成許多類似「PUSH 暫存器」的指令，把暫存器列表內的暫存器暫時保存在堆疊裏；而在要返回主程式時，首先會以相反的順序自堆疊取出暫時存放的暫存器原值。這當然是因為暫存器數量不多，但在許多運算過程都要用到，未防止破獲暫存器重要的資料所以 PROC 特別加入 USES 在堆疊裏保存暫存器。請參考下表：

原始程式組譯後的程式
主程式
INVOKE  seconds,hour,minute,second,
                ADDR string+9
 
PUSH	0111      
PUSH	[second]  
PUSH	[minute]  
PUSH	[hour]    
CALL	_seconds@8
副程式
seconds PROC    USES bx cx dx n1:WORD,
                n2:WORD,n3:WORD,
                address:WORD
        LOCAL   ten:WORD
        LOCAL   temp:WORD
        ....
        ret
seconds ENDP
 
PUSH    BP
MOV     BP,SP
ADD     SP,-04
PUSH    BX
PUSH    CX
PUSH    DX
....
POP     DX
POP     CX
POP     BX
MOV     SP,BP
POP     BP 
RET     0008

對照上表，先看主程式。一條 INVOKE 假指令，就被組譯器組譯成四個 PUSH 指令與一個 CALL 指令。再看副程式，兩條 LOCAL 指令，被組譯器組譯成一條「ADD SP,-04」；一條 PROC 假指令變成四條 PUSH 指令與一條 MOV 指令。返回主程式時，一條 RET 指令變成 RET 8 指令，同時組譯器還在 RET 8 之前額外添加了四條 POP 指令與一條 MOV 指令。

底下小木偶演飾以 SYMDEB 追蹤 SEC.COM，來觀察堆疊框的安排方式。首先載入 SEC.SYM 及 SEC.COM：

E:\DOS\HEX2DEC>c:\tools\mapsym sec [Enter]
Microsoft (R) Symbol File Generator  Version 4.00
Copyright (C) Microsoft Corp 1984, 1985.  All rights reserved.

	Program entry point at 0000:0100

E:\DOS\HEX2DEC>c:\tools\symdeb sec.sym sec.com [Enter]
Microsoft (R) Symbolic Debug Utility  Version 4.00
Copyright (C) Microsoft Corp 1984, 1985.  All rights reserved.

Processor is [80286]
-t [Enter] →第一個指令是「JMP begin」
AX=0000  BX=0000  CX=0083  DX=0000  SP=FFFE  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=011E   NV UP EI PL NZ NA PO NC
20E1:011E BA0801         MOV    DX,0108
-g 130 [Enter] →接著有四個 PUSH 指令，把 0111、second、minute、hour 推入堆疊
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFF6  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=0130   NV UP EI PL NZ NA PO NC
20E1:0130 E80600         CALL   _seconds@8

小木偶直接用「g 130」執行四次推入堆疊的指令，不用單步追蹤，相信讀者應該很熟悉 PUSH 指令了。接下來是「call seconds」指令，為什麼 SYMDEB 會把副程式名稱寫成「_seconds@8」？這是組譯器的傑作。如果語言類型為 STDCALL 時，組譯器會把宣告為 PUBLIC 的符號名稱，如副程式名稱，修飾成「_原符號名@n」，n 是指參數總共有多少位元組。接着繼續看下去：

-t [Enter] →進入 seconds 副程式
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFF4  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=0139   NV UP EI PL NZ NA PO NC
DGROUP:_seconds@8:
20E1:0139 55             PUSH   BP
-t [Enter] →，如上面seconds 副程式的第一個指令是把 BP 保存在堆疊上，執行它！
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFF2  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=013A   NV UP EI PL NZ NA PO NC
20E1:013A 8BEC           MOV    BP,SP
-t [Enter] →上面指令是讓 BP 的基準為現在堆疊頂端位址，也是儲存原 BP 值的位址
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFF2  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=013C   NV UP EI PL NZ NA PO NC
20E1:013C 83C4FC         ADD    SP,-04
-t [Enter] →上面指令「ADD SP,-4」是空出四個位元組，存放兩個區域變數
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFEE  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=013F   NV UP EI NG NZ NA PE CY
20E1:013F 53             PUSH   BX
-g 142 [Enter] →接著三個 PUSH 指令，分別把 BX、CX、DX 推入堆疊，直接執行完不一一單步追蹤
AX=0000  BX=0000  CX=0083  DX=0108  SP=FFE8  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=0142   NV UP EI NG NZ NA PE CY
20E1:0142 C746FE0A00     MOV    Word Ptr [BP-02],000A              SS:FFF0=7302

堆疊框右圖顯示的是 SEC.COM 呼叫 seconds 時所建立的堆疊框。透過上面的追蹤，堆疊框建立的順序如下：

  1. 參數：哪個參數先被推入堆疊由語言類型決定。
  2. 呼叫副程式：返回位址被推入堆疊。
  3. 把 BP 推入堆疊：保存原有的 BP。
  4. 使 BP 設為和 SP 相同值：BP 所指位址為基準，該位址存有原來的 BP。
  5. 保留區域變數所需記憶體：SP 減去一數，此數和區域變數類型有關。
  6. 把 PROC 中，USES 所列出的暫存器推入堆疊保存起來。

到此堆疊框已經建立完成，開始進入副程式真正要完成的目的：計算總共有幾秒鐘。不過這部分不是這一章的重點，因此略過不說，見下面的指令直接執行「g 17a」，相信讀者也能夠看懂計算經過。等計算完成，就要返回主程式了，底下就是看看這個過程。

-g 17a [Enter]
AX=0001  BX=0110  CX=0000  DX=0002  SP=FFE8  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=017A   NV UP EI PL NZ NA PO NC
20E1:017A 5A             POP    DX

首先是恢復 USES 後所列出的暫存器之原值，連續三個 PUSH 指令。小木偶也不一一單步追蹤，像下面直接輸入「g 17d」：

-g 17d [Enter]
AX=0001  BX=0000  CX=0083  DX=0108  SP=FFEE  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=017D   NV UP EI PL NZ NA PO NC
20E1:017D 8BE5           MOV    SP,BP

這時候 SP 指向區域變數所在的最低位址，也就是原始程式中最後一個區域變數的位址。但如今要捨棄這些區域變數，而 BP 所指位址恰好就是比區域變數最高位址再高兩個位元組的位址。組譯器很巧妙的用上面的「MOV SP,BP」指令，就能把區域變數去除。可以參考右上圖，會比較清楚。

-t [Enter]
AX=0001  BX=0000  CX=0083  DX=0108  SP=FFF2  BP=FFF2  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=017F   NV UP EI PL NZ NA PO NC
20E1:017F 5D             POP    BP

接下來是由堆疊頂端之 BP 原值彈出來恢復 BP 暫存器原本的資料，如下面執行它：

-t [Enter]
AX=0001  BX=0000  CX=0083  DX=0108  SP=FFF4  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=0180   NV UP EI PL NZ NA PO NC
20E1:0180 C20800         RET    0008

副程式的最後一個指令，RET 指令，但是除了返回主程式外，還得捨棄四個參數，每個參數有兩個位元組，因此要用「RET 8」，而不能用「RET」這樣單純。

-t [Enter]
AX=0001  BX=0000  CX=0083  DX=0108  SP=FFFE  BP=0000  SI=0000  DI=0000
DS=20E1  ES=20E1  SS=20E1  CS=20E1  IP=0133   NV UP EI PL NZ NA PO NC
20E1:0133 B409           MOV    AH,09

執行完上面的「t」指令後，是不是 SP 暫存器仍指向尚未執行 INVOKE 前的堆疊頂端，意即位址「FFFE」。


x86 指令：MUL

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

MUL     運算元

MUL 後面接著的運算元可以是八位元、十六位元、三十二位元的變數或暫存器，不能是立即值，而所得的乘積長度分別是十六位元、三十二位元、六十四位元。當指令 MUL 所接運算元為八位元時，就表示此運算是 AL 乘以此八位元的運算元，而所得之乘積存於 AX 暫存器裏，原先 AH、AL 之值會消失；當 MUL 所接的運算元是十六位元時，就表示是 AX 乘以此 16 位元的運算元，而所得之乘積存於 DX:AX 暫存器裏，原先 AX、DX 之值會消失；當 MUL 所接的運算元是三十二位元時，就表示是 EAX 乘以此三十二位元的運算元，而所得之乘積存於 EDX:EAX 暫存器裏，原先 EAX、EDX 之值會消失。整理如下表：

乘法方式被乘數 乘數乘積 範例（底下數值為十六進位）
運算前運算後
8 位元AL8 位元暫存器
或變數		AX AX=0105
BX=0106
MUL BL		AX=001E
BX=0106
16 位元AX16 位元暫存器
或變數		DX:AX DX=FFFF
AX=0200
BX=0106
MUL BX		DX=0002
AX=0C00
BX=0106
32 位元
只能用於
386等級以上		EAX32 位元暫存器
或變數		EDX:EAX EDX=88887777
EAX=80000001
EBX=00000002
MUL EBX		 EDX=00000001
EAX=00000002
EBX=00000002
64 位元
只能用於
x64等級以上		RAX64 位元暫存器
或變數		RDX:RAXEDX=123456789ABCDEF0
RAX=8
RBX=8
MUL RBX		RDX=0
RAX=40
RBX=8

小木偶私下猜想，這樣的安排還是很合理的。以我們熟悉的十進位數來說，兩位數乘兩位數最大值是四位數，例如 99×99＝9801。因此八位二進位數乘八位二進位數所得之乘積為十六位二進位數，簡單的說，八位二進位數，不就八位元的數嗎？十六位二進位數不就是十六位元的數嗎？因此 AL×BL 所得的乘積要放在十六位元的暫存器裏。

例如，如果要計算 9 乘以 8，可以用底下的方式：

        mov     al,9
        mov     bl,8
        mul     bl

這是因為 9、8 都不超過 255 ( 還記得吧？八位元的暫存器或記憶體寬度可以表示 0 到 255 範圍的正數 )，因此被乘數、乘數都存於八位元的暫存器裏，但是依據 80x86 MUL 語法，被乘數只能用 AL，所以第一行為「mov al,9」，至於乘數，8，可放於任何一個八位元的暫存器，如 AH、BL、BH……都可以，也可以放在以 DB 所定義的八位元記憶體變數裏，最後再以指令「mul bl」計算，所得乘積會在 AX 暫存器裏，AX 會變成 0048h，BL 仍是 8。

後話

第九、十兩章提到了副程式，也講了一大堆，小木偶突然想到，DOS 的服務程式 INT 20H 或 INT 21H 也像是副程式一樣，但是它們並非使用堆疊傳遞參數，而是利用暫存器，然後呼叫這些副程式幫我們完成特定的工作，就像在本章範例的 seconds 副程式一樣。因此從這個角度來看，我們也可以把 DOS 服務程式看成是一種副程式。

另外還有一兩個指令，也與副程式有關，它們是 ENTER 與 LEAVE。

x86 指令：ENTER

ENTER 指令能簡化建立堆疊框的工作，它會完成以下三件事情：①把 BP 推入堆疊；②把 SP 之值存入 BP 裏；③保留區域變數的空間。儘管如此，ENTER 並不會把參數即返回位址推入堆疊，也不會保存暫存器的資料。ENTER 的語法是：

ENTER   運算元1,運算元2

運算元1代表要為區域變數保留多少位元組的空間，例如上面的 some_of 副程式沒有區域變數，故可用「ENTER 0,0」，這樣就相當於：

        push    bp
        mov     bp,sp

再例如前面說的 seconds 有兩個區域變數，因此可用「ENTER 4,0」，等效於下面的指令：

        push    bp
        mov     bp,sp
        sub     sp,4

x86 指令：LEAVE

LEAVE 指令用來銷毀部分堆疊框，它與 ENTER 的過程恰好相反：①把 BP 之值存入 SP 裏；②自堆疊彈出一數值到 BP。LEAVE 並沒有除去區域變數的功能。LEAVE 的語法是

LEAVE

看起來，這裏介紹的 ENTER/LEAVE 指令可以用一條指令代替兩三條 PUSH/POP/MOV 指令，似乎很有效率。但實際情形並非如此，CPU 在執行運算過程時的效率，不是僅看有幾道指令而已，實際上以酷睿 11 而言， ENTER 平均執行速率比 PUSH/MOV/ADD 總和還要慢上 7 個時脈左右，LEVEL 也慢上 3 個時脈左右，因此一般組譯器或編譯器很少使用 ENTER/LEVEL 指令。

回顧

簡單使用 PROC/ENDP 與 INVOKE

這一章講了許多呼叫副程式瑣碎的過程，這些都是為了呼叫其他高階語言所撰寫的副程式所需要的。如果不能完全瞭解這些過程，只想簡單使用 INVOKE 與 PROC/ENDP 的話，只要遵循下面原則即可：

  1. 在程式一開始用「.MODEL」宣告語言類型，而且語言類型儘量用 STDCALL 或 C，因為前者是撰寫 Windows 程式所必須遵守的，後者是 C 語言規定的。
  2. 把副程式放在主程式之前，這樣就不必使用「PROTO」宣告副程式原型。
  3. 寫副程式時注意步驟 3∼6 項。用「PROC USES 暫存器列表 parm1:WORD,parm2:WORD……」宣告副程式。
  4. 區域變數用「LOCAL var1:資料類型」宣告，而且緊接著 PROC 的下一行。如果有多個區域變數，可以接在下面幾行。
  5. 副程式結束時用「RET」返回主程式，只需寫「RET」即可不必寫「RET n」，如需消除區域變數，組譯器能自行決定。
  6. RET 下一行就應該是「ENDP」，組譯器會自行考慮其他細節，程式設計師不必去擔心這個問題。
  7. 呼叫副程式時，用「INVOKE 副程式名稱,num1,num2……」即可，但要注意 num1 的資料類型要與 parm1 一樣、num2 的資料類型要與 parm2 一樣……，否則會產生錯誤。

如果想知道更多

如果還想知道更多，就要了解堆疊框的構造，底下是幾個重點：

  1. 堆疊框由高位址向低位址，裏面存放著參數、返回位址、原來的 BP、區域變數以及要保存的暫存器。
  2. 在整個副程式執行過程中，BP 之值都不能改變，否則會存取到錯誤的參數或區域變數。
  3. 存取參數或區域變數都是以 BP 為準。語言類型為 C 或 STDCALL 時，第一個參數在位址 [BP+04]、第二個參數在位址 [BP+06]、第三個參數在位址 [BP+08]……
  4. 第一個區域變數在位址 [BP-02]、第二個區域變數在位址 [BP-04]、第三個區域變數在位址 [BP-06]……
  5. 如果在 Win32 程式設計裏，第一個區域變數在位址 [BP-04]、第二個區域變數在位址 [BP-08]、第三個區域變數在位址 [BP-0C]……；第一個參數在位址 [BP+08]、第二個參數在位址 [BP+0C]、第三個參數在位址 [BP+10]……