Ch 15　有號數（二）

上一章，小木偶談了有號數的加減法，這一章要繼續談有號數的乘除法。

x86 的乘除法指令

x86 指令集的乘法指令有三個，MUL、IMUL、AAM，分別用於無號數乘法、有號數乘法、乘法運算後調整成 ASCII 碼，這一章將集中在前兩個乘法指令。

MUL 指令

MUL 是用來計算無號數乘法的指令，它的語法依其位元不同，分成四種：

        MUL     r/m8
        MUL     r/m16
        MUL     r/m32
        MUL     r/m64

底下是這四種的說明：

八位元的乘法：r/m8 是八位元的暫存器或記憶體變數，CPU 會把 AL 乘以 r/m8 後的乘積存於 AX 暫存器裏。
十六位元的乘法：r/m16 是十六位元的暫存器或記憶體變數，CPU 會把 AX 乘以 r/m16 後的乘積存於 DX:AX。
三十二位元的乘法：r/m32 是三十二位元的暫存器或記憶體變數，CPU 會把 EAX 乘以 r/m32 後的乘積存入 EDX:EAX 裏。
六十四位元的乘法：r/m64 是六十四位元的暫存器或記憶體變數，CPU 會把 RAX 乘以 r/m64 後的乘積存入 RDX:RAX 裏。

MUL 看起來很複雜，但只要把握住被乘數都是累加器 ( 累加器就是 AL、AX、EAX 或 RAX )，乘數與被乘數長度一樣，亦即它們具有相同的位元數；計算後，乘積的位元數是被乘數的兩倍，乘積都放在資料暫存器:累加器裏面。資料暫存器是指 DX、EDX、RDX。

回想小學時，用十進位計算乘法也是這樣，例如 90×90＝8100，是不是兩位數成兩位數得到四位數。因此當英特爾設計 x86 CPU 時，才會這樣做。也因為乘積的位元個數是被乘數位元數的兩倍，所以不會有乘積超過而容納不下的問題，因此 MUL 指令的進位與溢位和加減法不同。如果乘積較高的半數個位元不為零，進位旗標及溢位旗標都會被設定；反過來則被清除。底下我們來看兩個 MUL 的例子：

        mov     al,8

        mov     bl,5

        mul     bl

執行後，AX 變為 28h，其餘暫存數都不變，此時乘積較高的八個位元，即 AH 為零，故進位旗標、溢位旗標都會被清除 ( NC、NV )。

seconds dw      60*60   ;一小時有3600秒

        mov     ax,24   ;一天24小時

        mul     seconds

執行後，AX＝5180h，DX＝1，DX:AX＝15180h＝86400d，因為乘積較高的 16 位元，即 DX 不為零，故進位旗標、溢位旗標都會被設定 ( CY、OV )。

最後值得一提的是「MUL r/m64」是六十四位元的乘法，只能用在 64 位元的模式下，在 DOS 真實模式不能使用，而且用 ML.EXE 也無法組譯，必須使用 ML64.EXE 才能組譯。

IMUL 指令

IMUL 是用來計算有號數乘法的指令，依據運算元的多寡，分為三種：

只有一個運算元的 IMUL

只有一個運算元的 IMUL 與 MUL 一樣，其語法為：

        IMUL    r/m8
        IMUL    r/m16
        IMUL    r/m32
        IMUL    r/m64

分別是八位元、16 位元、32 位元、64 位元的乘法，被乘數分別是 AL、AX、EAX 或 RAX，都不須寫出來，而乘數就是 IMUL 後接著的運算元，CPU 看見運算元後就知道乘數是多少位元，依此就找到相同位元數的被乘數相乘，把計算後的乘積存在 AX、DX:AX、EDX:EAX、RDX:RAX 裏。例如「IMUL r/m16」指令的乘數為 16 位元，被乘數就是 16 位元的 AX，乘積放在 DX:AX。如果得到的乘積較高的半數位元與較低的半數位元符號擴充相同時，清除溢位旗標與進位旗標；反之則設定溢位旗標與進位旗標。「IMUL r/m64」只能用在 64 位元系統下，無法在 DOS 真實模式下使用。看看底下的例子說明：

        mov     al,4h
        mov     bl,10h
        imul    bl

上面是八位元的有號數乘法，乘積為 0040h，放在 16 位元的 AX 裏。較低的半數位元 ( 較低的八位元是 AL ) 符號位元為 0，將其符號位元擴充至較高的半數位元 ( 即 AH ) ，恰好和乘積的半數高位元相同，都是 00，因此溢位旗標與進位旗標分別是 NV、NC。看下個例子：

        mov     al,1eh  ;1eh＝30d
        mov     bl,0ah  ;0ah＝10d
        imul    bl

也是八位元的有號數乘法，結果 AX 為 012C0h，較低的半數位元是 C0h，其符號是「1」，擴充至 AH 後應該是 0FFh，但與乘積較高的半數位元 ( 01 ) 不同，因此 CPU 會把溢位旗標與進位旗標分別設為 OV、CY。底下是第三個例子：

        mov     ax,1eh  ;1eh＝30d
        mov     bx,0ah  ;0ah＝10d
        imul    bx

上面是十六位元的有號數乘法，所得乘積為 0000 012Ch，是 32 位元有號數，放在 DX:AX，把 AX 內的符號擴充後是 0000，而乘積的較高十六位元也是 0000，因此 CPU 會把溢位旗標與進位旗標分別設為 NV、NY。底下是第四個例子：

        mov     ax,-16384       ;-16384d＝C000h
        mov     bx,2
        imul    bx

上面是十六位元的有號數乘法，所得乘積 FFFF 8000h，是 32 位元有號數，放在 DX:AX，把 AX 內的符號擴充後是 FFFF，而乘積的較高十六位元也是 FFFF，因此 CPU 會把溢位旗標與進位旗標分別設為 NV、NY。

使用只有一個運算元的 IMUL 指令，運算元的長度就是被乘數的長度，而且能算出正確的乘積，乘積的長度是運算元的兩倍，放在資料暫存器:累加器裏。雖然 CPU 會設定溢位旗標和進位旗標，但是與乘積的正確與否無關，不須檢查這兩個旗標。

有兩個運算元的 IMUL

IMUL 有兩個運算元時，第一個運算元是目的運算元，為被乘數；第二個運算元，是與第一個運算元相同位元數的暫存器、記憶體變數或立即值 ( immediate value，其實就是常數 )，當做乘數。其語法如下：

        IMUL    r16,r/m16
        IMUL    r32,r/m32
        IMUL    r64,r/m64
        IMUL    r16,imm16
        IMUL    r32,imm32
        IMUL    r64,imm64

IMUL 會把第一個運算元乘以第二個運算元，然後把乘積存入第一個運算元裏。如果第一個運算元容納不下乘積時，較高的位元會截斷而消失，這時候 CPU 會設定溢位旗標和進位旗標；反之，則清除溢位旗標和進位旗標。另外根據小木偶實驗的結果，如果目的運算元可以容納得下乘積，但是超出範圍，溢位旗標、進位旗標仍會被設定。「IMUL r64,r/m64」與「IMUL r64,imm64」只能在 64 位元系統下使用，無法用在 DOS 作業系統。看看底下的三個例子：

        mov     ax,4000h        ;4000h＝16384d
        mov     bx,2
        imul    bx,ax

結果 AX 仍為 4000h，BX 變為 8000h，雖然 4000h×2＝8000h，但這是正數才對，十六位元的 BX 值為 8000h，是負數，－32768d，超過 16 位元所能表示的範圍，因此溢位旗標、進位旗標被設為 OV、CY。再看一例：

        mov     si,-16384       ;－16384＝C000h
        mov     di,2
        imul    di,si

結果 SI 仍為 C000h，DI 變為 8000h，8000h 是有號數，換成十進位是－32768d，沒超過範圍，也沒有截斷高字組，因此溢位旗標、進位旗標被設為 NV、NC。第三個例子：

        mov     si,500h         ;1280d＝500h
        mov     cx,422h         ;1058d＝422h
        imul    si,cx

結果 CX 仍為 422h，SI 變為 0AA00h，這是因為 500h×422h＝14AA00h，SI 只能容納 0AA00h，高字組被截斷了，因此溢位旗標、進位旗標被設為 OV、CY。

使用兩個運算元的 IMUL 指令，必須在運算後檢查溢位旗標、進位旗標，只有當這兩個旗標被清除時，目的運算元的乘積才是正確的，否則可能僅僅得到乘積的低半數位元或者是發生溢位。

有三個位元的 IMUL

三個運算元的 IMUL 語法如下

        IMUL    r16,r/m16,imm8
        IMUL    r32,r/m32,imm8
        IMUL    r64,r/m64,imm8
        IMUL    r16,r/m16,imm16
        IMUL    r32,r/m32,imm32
        IMUL    r64,r/m64,imm32

第一個運算元是目的運算元，存放運算後的乘積；第二個運算元是被乘數；第三個運算元是乘數。三個運算元的 IMUL 與兩個運算元的用法類似，溢位旗標與進位旗標的設定也一樣，差別只在於可以指定另一個暫存器存放乘積。例如底下的例子：

        mov     bx,400h
        imul    si,bx,12h

運算後，SI 變為 4800h，BX 不變，乘積的高字組也沒被截斷，因此溢位旗標、進位旗標設為 NV、NC。

IDIV 指令

x86 指令集的除法指令也有三個，DIV、IDIV、AAD，DIV 是無號數的除法，已經在第七章介紹過了；這裏要介紹的是有號數的除法，IDIV 指令；至於 AAD 則是調整成 ASCII 碼的除法，以後再談。

IDIV 的語法是：

        IDIV    r/m8
        IDIV    r/m16
        IDIV    r/m32
        IDIV    r/m54

IDIV 不像 IMUL 有三種類型，它只有一種類型，只能有一個運算元。這個運算元其實就是除數，它可以是八位元、16 位元、32 位元或 64 位元的暫存器或記憶體變數。當除數是八位元時，被除數就是 AX；除數是 16 位元時，被除數是 DX:AX；除數是 32 位元時，被除數是 EDX:EAX；除數是 64 位元時，只能在 64 位元模式下使用，被除數是 RDX:RAX。整理如下表：

運算元 ( 除數 )	被除數	商數	餘數	範例
運算元 ( 除數 )	被除數	商數	餘數	運算前	運算後	說明
8位元	AX	AL	AH	MOV AX,－4050d MOV BL,100d IDIV BL	AL＝－40d(商) AH＝－50d(餘)	－4050d＝0F02Eh －50d＝0CEh －40d＝0D8h
16位元	DX:AX	AX	DX	MOV EAX,5D50h MOV EDX,0FFF8h MOV EBX,－500d IDIV EBX	EAX＝1000d(商) DX＝－400d(餘)	FFF8:5D50h＝－500400d
32位元只能用於 386等級以上	EDX:EAX	EAX	EDX	MOV EAX,5D50h MOV EDX,0FFFFFFF8h MOV EBX,－500d IDIV EBX	EAX＝68719428d(商) DX＝－480d(餘)	FFFFFFF8:00005D50h＝－34359714480d
64位元只能用於 x64等級以上	RDX:RAX	RAX	RDX

IDIV 的被除數不需要寫出來，必定是累加器，或是資料暫存器與累加器的組合，而且被除數的位元個數是除數的兩倍，這也非常好理解。回想小學時所學過的數學，例如 1000÷20＝50，四位數被兩位數除，可得兩位數。

IDIV 運算時，如果除數為零，或是被除數的絕對值太大而除數的絕對值太小，以致於造成商太大，累加器容納不下，就會造成溢位。這種溢位會跳出程式回到作業系統。要避免這種情形，可以參考第七章 DIV 的溢位。

不論是無號數或有號數，進行除法運算，都能看成連續的加法或減法運算，由被除數開始每次往零的方向移動一個除數，直到最接近零且不可越過零為止。例如以－7 除以 3 為例，－7 離零有七格的距離，因為除以三，所以每次向零移三格，只能移兩次，第三次就會越過零了，因此－7 除以 3 得－2 餘－1，寫成數學式為：

－7＝3×(－2) ＋ (－1)

從上面的例子，便可以推論，不論被除數是正數還是負數，也不管除數是正數還是負數，餘數的符號必與被除數相同。商與除數乘積的符號必與被除數相同。

範例：COMPUTE1.ASM

一如既往，介紹完原理後，就是實作一個程式印證理論。這個程式叫 COMPUTE1.ASM，它讓使用者輸入兩個在－32768～32767 之間的有號數，COMPUTE1 會把這兩個數做乘法和除法運算，並把乘積與商、餘數顯示在螢光幕上。底下是 COMPUTE1.ASM 的原始碼：

;任輸入兩數，n1與n2，COMPUTE1會對此二數做乘除法運算，然後印出答案來

.MODEL SMALL,C

.386

;*******************************************************************************

.STACK 256

;*******************************************************************************

.DATA

n1 SWORD ?

n2 SWORD ?

remainder DW ?

n_str DB 12 DUP (?),"$"

msg1 DB "Input a number (-32768~32767):$"

msg2 DB 0dh,0ah,"Error input.$"

msg3 DB 0dh,0ah,"Divide is zero.$"

crlf DB 0dh,0ah,"$"

buffer DB 9 DUP (?)

exit_code DB ?

;*******************************************************************************

.CODE

;-------------------------------------------------------------------------------

print_string PROC p_str:WORD

mov dx,p_str

mov ah,9

int 21h

ret

print_string ENDP

;-------------------------------------------------------------------------------

;get_number會把point所指位址的數字字串變成有號數存入AX

;輸入：point：數字字串之位址，此字串第一個位元組代表數字佔用多少位元組。

;　　　　　　例如「03,2dh,33h,33h」，即「-33」，最後AX＝FFDFh

;輸出：進位旗標：CX＝0，錯誤

;　　　　　　　　CX＝1，正確，AX＝有號數

get_number PROC point:WORD

LOCAL n:SWORD

LOCAL sign:WORD

mov si,point

mov n,0

movzx cx,BYTE PTR [si] ;CX＝使用者輸入的位元組個數

;檢查使用者輸入的第一個位元組是否為"+"、"-"，如果是則使sign填入符號，並

;調整CX與SI，使其指向下一個位元組

inc si

cmp BYTE PTR [si],"-"

jne chk_positive

mov sign,2dh ;2dh="-"

jmp short adjust

chk_positive: mov sign,2bh ;2bh="+"，若使用者沒輸入符號，當成

cmp BYTE PTR [si],"+" ;正數，因此「mov sign,2bh」在 cmp

jne arabic_numeral ;之前

adjust: inc si ;如果使用者有輸入"+"、"-"，讓

dec cx ;SI指向下一位元組，CX減一

cmp cx,5 ;一個字組的十進位數最大為5位數

ja error ;若超過，表示輸入錯誤

arabic_numeral: cld

next: mov dx,n ;此行到下面三行，其實是計算10*n

shl n,3 ;10*n＝2*n+8*n，「shl n,3」亦即計算8*n

shl dx,1 ;計算2*n

add n,dx ;不使用MUL指令是因為MUL費時較多

jo ovflw

lodsb

sub al,"0"

;檢查使用者輸入的自是否為阿拉伯數字，必須在0～9之間

cmp al,0

jb error

cmp al,9

ja error

cbw

add n,ax

jo ovflw ;如果溢位，表示不在-32768~32767

loop next

jmp ok

ovflw: .IF sign==2dh

cmp n,8000h

je ok

.ENDIF

error: sub cx,cx

jmp exit

ok: mov ax,n

.IF sign==2dh

neg ax

.ENDIF

mov cx,1

exit: ret

get_number ENDP

;-------------------------------------------------------------------------------

;hex2dec_str把三十二位元的十六進位數值變成十進位的字串

;輸入：DX:AX－三十二位元的十六進位數值，AX是較低的字組，DX是較高的字組

;　　　sign－指定正負號。0：以n的最高位元決定正或負；"+"：n為正數；"-"：n為負數

;　　　address－十進位字串的個位數，至少要預留11個位元組

;輸出：AX－十進位字串起始位址

hex2dec_str PROC sign:WORD,address:WORD

LOCAL ten:WORD

LOCAL temp:WORD

LOCAL quotient:WORD ;暫時存放商的較高字組

mov cx,10 ;32位元有號數阿拉伯數字最多10位

mov ten,cx

mov bx,address

.IF sign==2dh

negative: not ax

not dx

add ax,1

adc dx,0

.ELSEIF sign==2bh

positive: mov sign,2bh

.ELSE

test dx,8000h

jz positive

mov sign,2dh

jmp negative

.ENDIF

next: mov temp,ax ;把較低字組儲存在temp裏

mov ax,dx ;先計算較高字組除以ten

sub dx,dx

div ten ;除ten後，DX＝低字組除ten時的較高字組

mov quotient,ax ;AX＝最後商的較高字組

mov ax,temp ;計算較低字組除以ten

div ten ;AX＝最後商的較低字組

add dl,"0" ;DX＝最後的餘數

mov [bx],dl

cmp quotient,0 ;若最後的商等於零，表示已完成

jnz q_isnt_zero

or ax,ax

jz finish

q_isnt_zero: dec bx

mov dx,quotient ;取回商的高字組

loop next

finish: .IF sign==2dh

dec bx

mov BYTE PTR [bx],"-"

.ENDIF

mov ax,bx ;返回十進位數字字串起始位址

ret

hex2dec_str ENDP

;-------------------------------------------------------------------------------

print_char PROC char:BYTE

mov dl,char

mov ah,2

int 21h

ret

print_char ENDP

;-------------------------------------------------------------------------------

expression PROC char:BYTE

;印出n1

mov ax,n1

cwd

INVOKE hex2dec_str,0,OFFSET n_str+SIZEOF n_str-2

INVOKE print_string,ax

;印出「*」或「/」

INVOKE print_char,char

;如果n2為負數，那麼要印出「(」，否則不必

test n2,8000h

jz positive1

INVOKE print_char,"("

;印出n2

positive1: mov ax,n2

cwd

INVOKE hex2dec_str,0,OFFSET n_str+SIZEOF n_str-2

INVOKE print_string,ax

;如果n2是負數，那麼要印出「)」，否則不必

test n2,8000h

jz positive2

INVOKE print_char,")"

;印出「=」

positive2: INVOKE print_char,"="

ret

expression ENDP

;-------------------------------------------------------------------------------

.STARTUP

;印出「Input a number (-32768~32767):」，並讓使用者輸入數字字串

INVOKE print_string,OFFSET msg1

mov ah,0ah

lea dx,buffer

mov buffer,7

int 21h

;把數字字串變成有號數，存於n1

INVOKE get_number,OFFSET buffer+1

jcxz err1

mov n1,ax

INVOKE print_string,OFFSET crlf ;換行

;印出「Input a number (-32768~32767):」，並讓使用者輸入數字字串

INVOKE print_string,OFFSET msg1

mov ah,0ah

lea dx,buffer

mov buffer,7

int 21h

;把數字字串變成有號數，存於n2

INVOKE get_number,OFFSET buffer+1

jcxz err1

mov n2,ax

INVOKE print_string,OFFSET crlf

jmp compute

err1: mov dx,OFFSET msg2

jmp err2

;計算n1*n2之乘積，並印出結果來

compute: INVOKE expression,"*"

mov ax,n1

imul n2

INVOKE hex2dec_str,0,OFFSET n_str+SIZEOF n_str-2

INVOKE print_string,ax

;計算n1/n2之商與餘數，並印出結果來

cmp n2,0

jnz divide_nonzero

mov dx,OFFSET msg3

err2: INVOKE print_string,dx

mov exit_code,1

jmp short quit

divide_nonzero: INVOKE print_string,OFFSET crlf

INVOKE expression,"/"

mov ax,n1

cwd

idiv n2

mov remainder,dx

cwd

INVOKE hex2dec_str,0,OFFSET n_str+SIZEOF n_str-2

INVOKE print_string,ax

mov cx,5

again: INVOKE print_char,"."

loop again

mov ax,remainder

cwd

INVOKE hex2dec_str,0,OFFSET n_str+SIZEOF n_str-2

INVOKE print_string,ax

mov exit_code,0

quit: .EXIT exit_code

;*******************************************************************************

END

COMPUTE1.ASM 與前一章的 COMPUTE.ASM 很相似，小木偶僅就兩者不同之處談一談。

副程式：hex2dec_str

副程式 hex2dec_str 是用來把十六進位數值變成一個十進位數字字串，與前一章的 hex2dec_str 不同的是本章能處理 32 位元的有號數。理由顯而易見，使用者輸入的是兩個 16 位元的有號數，它們相乘後，有可能得到 32 位元的有號數，因此本章的 hex2dec_str 必須能把 32 位元的有號數變成十進位數字字串。

本章的 hex2dec_str 所用原理其實和前一章的一樣，都是用連續除法，所不同的是 32 位元的有號數除以十，有可能會造成商太大，AX 無法容納得下，因此用兩段式除法。先算高字組除以十，再算低字組除以十。見程式第 110～118 行。這段程式可以參考第七章有關除法溢位的說明。

如果 DX:AX 是負數，要把它轉換成十進位的數字字串，要先變號 ( 即求其二補數 )，再依正整數連續除以十變成十進位數字字串的方式處理。問題是雖有 NEG 指令可以求某個暫存器的二補數，但是並沒有指令能夠求 DX:AX 的二補數。不過我們知道方法：①所有位元反轉，②加一。因此只好分開來寫，就變成下面的程式：

        not     ax
        not     dx
        add     ax,1
        adc     dx,0

在 COMPUTE1.ASM 的第 98～101 行，就是上面四行程式，它是用來計算 DX:AX 的二補數。前三行很容易理解，第四行的 ADC 是以前未見過的指令。

x86 指令：ADC

ADC 指令是加法運算時，也把進位旗標加進來。ADC 的語法是：

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

目的運算元可以是暫存器或記憶體變數，來源運算元可以是暫存器、記憶體變數或立即值。但是有些限制：①目的運算元、來源運算元不可以同時是記憶體變數；②目的運算元、來源運算元長度必須相同；③如果來源運算元是立即值，那麼立即值可以只有八位元，而目的運算元是其他長度，也就是不受第二個限制 ( 當然立即值的長度也可以和目的運算元相同 )。

ADC 指令會把來源運算元和目的運算元相加，同時再加上進位旗標。這樣的方式，可以讓原來只有 16 位元的暫存器做 32 位元的加法運算，或是 32 位元的暫存器做 64 位元的加法運算。例如要用 16 位元暫存器計算 160000＋172800，160000 換成十六進位是 27100h，172800 換成十六進位是 2A300h，假設把 DX:AX＝0002 7100h，BX:CX＝0002 A300h，如下圖：

        mov     dx,2
        mov     ax,7100h
        mov     bx,2
        mov     cx,0a300h
        add     ax,cx
        adc     dx,bx

當執行完「add ax,cx」之後，會發生進位，CPU 會設定進位旗標，因此進位旗標為 1 ( 見上圖，白色的「1」)，在執行下一道「adc dx,bx」時，CPU 除了把 DX 加上 BX 之外，還會加上進位旗標，因此 DX 會變成 5。

再回到解說 COMPUTE1.ASM。在計算 32 位元二補數時，先反轉各位元，然後加一，考慮有時候會進位，因此在第 101 行，使用指令「adc dx,0」，這樣如果低字組加一後發生進位，也能把進位加在高字組了。

本章就此結束。底下是有號數的回顧。

回顧有號數

人類發明電腦的目的，本意是幫助我們計算，因此電腦當然要能表示數值，不管是正整數、負整數，甚至還要能表示帶有小數的有理數才行。本章與前一章，介紹了電腦如何表示正整數與負整數。底下是一些整理。

二補數

在電腦裏，我們用某數的二補數代表其相反數。計算某數的二補數有兩個步驟：

第一步：把某數變為二進位數，然後將每一個位元反轉，反轉的意思就是 1 變為 0，0 變為 1。
第二步：把第一步的結果加一，即得某數 2 的補數。

例如 5Fh 的二補數是 0A1h，這個 0A1h 是如何算出來的呢？

首先先把 5Fh 變成二進位：0101 1111，再反轉所有位元變成 1010 0000。
再加一，變成 1010 0001，變回十六進位是 0A1h。

因此 5Fh 的二補數是 0A1h。把 5Fh 換成十進位是 95，其負數是－95，變成十六進位是 0A1h。結論就是 5fh＝95d，0A1h＝－95d。

十六進位有號數變成十進位數字字串

把十六進位有號數變成十進位數字字串的意思，是把存在記憶體內的數值，變成由阿拉伯數字組成的字串。例如 AL＝0A1h，這個 0A1h 就是十六進位數，把它轉換成「2dh、39h、35h、24h」，用 ASCII 碼來表示就是「-35$」。本章的 hex2dec_str 副程式可以把存於 DX:AX 裏的 32 位元有號數，轉變成由阿拉伯數字組成的 ASCII 碼字串。

方法很簡單，先判斷 DX:AX 裏的數值為正還是負。如果是正整數，用連續除以十的方法所得的餘數就是個位數、十位數、百位數等等。如果是負數，就先用二補數求出此負數的絕對值，再以正整數的方法運算，就可得由阿拉伯數字組成的 ASCII 碼字串，最後在字串最前面加上「－」號即可。

有號數的四則運算

有號數或無號數的加減法，均可使用 ADD、SUB 指令，但要注意是否溢位；而乘除法有區別，無號數的乘除法用 MUL、DIV，不必管溢位是否發生，都是正確的，而有號數的乘除法用 IMUL、IDIV，一般情形下不必擔心溢位的問題，除非乘法使用 IMUL 的雙運算元、或三運算元的形式，或是除法中除數為零，或被除數太大且除數太小。

Ch 15 有號數（二）

x86 的乘除法指令

MUL 指令

IMUL 指令

只有一個運算元的 IMUL

有兩個運算元的 IMUL

有三個位元的 IMUL

IDIV 指令

範例：COMPUTE1.ASM

副程式：hex2dec_str

x86 指令：ADC

回顧有號數

二補數

十六進位有號數變成十進位數字字串

有號數的四則運算

Ch 15　有號數（二）