第九章　有號數（二）

本章接續前一章，繼續有號數的說明。在這一章裏，將舉個例子，CALCULUS.ASM，說明如何在命令提示字元中，利用 Win64 API 輸入有號數，並進行四則運算，最後還是利用 Win64 API 將結果顯示在螢幕上。但在說明 CALCULUS.ASM 之前，繼續介紹這個應用程式用得到 x64 指令及 Win64 API。

CALCULUS.ASM 用得到的 x64 指令及 Win64 API

StrToIntEx API

StrToIntEx 把由數字組成且以零結尾的字串，轉換成數值，並存於某個變數裏。其語法如下：

BOOL StrToIntEx(
  [in]  PCWSTR     pszString,
        STIF_FLAGS dwFlags,
  [out] int        *piRet
);

StrToIntEx 參數說明如下：

StrToIntEx 是 StrToInt 的擴充版，除了修正後者對於字串「"0",0」所造成無法區分是無法轉換，還是所指的字串轉換後就是 0 之外，還增加對十六進位字串的轉換。pszString 所指字串的內容可分三部分，其格式如下：

"（空白）（正負號）（數字）",0

第一部分可以多個空白，但都會被 StrToIntEx 忽略。第二部分可以省略或是「+」、「-」二擇一；若省略表示正值。第三部分是阿拉伯數字組成的字串，如果指定 STIF_SUPPORT_HEX，最前面可以加上「0x」或「0X」，表示十六進位，其後可以使用「A∼F」（不區分大小寫）表示十六進位數；但指定 STIF_SUPPORT_HEX 之後，無法使用「-」，即使使用「-」仍會被 StrToIntEx 視為正值。StrToIntEx 的回傳值是布林值：若字串成功轉換，傳回 TRUE；否則傳回 FALSE。

看完底下的例子會更清楚 StrToIntEx 函式：

數字字串STIF_DEFAULTSTIF_SUPPORT_HEX說明
結果回傳值結果回傳值
"123",0123TRUE123TRUE字串沒有「0x」起頭，故視為十進位
" + 123",00FALSE0FALSE「+」與阿拉伯數字之間不能有空白，接收的變數會變成 0
"-123",0-123TRUE-123TRUE字串沒有「0x」起頭，故視為十進位
"0x123",00TRUE291TRUESTIF_DEFAULT 時視為十進位，轉換到首個非數字結束；
STIF_SUPPORT_HEX 時視為十六進位，123h=291d
"-0x123",00TRUE291TRUESTIF_DEFAULT 時視為十進位，轉換到首個非數字結束；
STIF_SUPPORT_HEX 時視為十六進位「0x」之前的「-」會被忽略
"4F",04TRUE4TRUE字串沒有「0x」起頭視為十進位，到第一個非數字停止

x64 指令：NEG

NEG 指令是用來計算二補數的指令，語法是

NEG     目的運算元

目的運算元可以是暫存器或變數，NEG 會計算目的運算元的二補數，然後再存回目的運算元，目的運算元會被破壞。前一章提過，某數的二補數其實就是該數的相反數，因此可以用 NEG 計算某數的負值。如果目的運算元是 0，那麼進位旗標會被清除，否則被設定。其餘溢位、符號、零值依運算結果改變旗標。

x64 指令：CLC 與 STC

CLC 與 STC 是用來改變進位旗標之值。CLC 原文是 clear carry flag，也就是清除進位旗標，把進位旗標設為零。STC 原文是 set carry flag，也就是設定進位旗標，把進位旗標設為一。CLC 與 STC 只影響進位旗標，不影響其他旗標。

CALCULUS.ASM 原始程式

到這兒，CALCULUS.ASM 所需的所有 x64 指令與 Win64 API 都介紹完畢，底下應該要把 CALCULUS.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
INCLUDE E:\masm64\include64\masm64rt.inc
;******************************************************************************
.DATA
hInput  DQ      ?       ;標準輸入裝置控制代碼
hOutput DQ      ?       ;標準輸出裝置控制代碼
n1      DD      ?       ;使用者輸入的數值1
n2      DD      ?       ;使用者輸入的數值2
sum          DD ?       ;和
difference   DD ?       ;差
product      DQ ?       ;積
quotient     DD ?       ;商
remainder    DD ?       ;餘數
szFmt   DB      40h DUP (0)
szAns   DB      80h DUP (0)
szCtFmt DB      "%%d、%%d之和、差、積、商及餘數依序為",0dh,0ah,\
                "%s、%s、%%I64d、%%d餘%%d。",0
szFmtUp DB      "%u",0
szFmtUn DB      "-%u",0
szFmtI  DB      "%d",0
sHint   DB      "請輸入負二十億至二十億之間的整數："
sErr0   DB      "無法轉換成整數！"
sErr1   DB      "您輸入的數不在負二十億至二十億之間！"
sErr2   DB      "除數不可為零！"
;******************************************************************************
.CODE
;------------------------------------------------------------------------------
Input   PROC    USES rsi rdi hIn:QWORD,hOut:QWORD
maximum EQU 2000000000  ;二十億=77359400h
;輸入：hIn、hOut－標準輸入、輸出裝置控制代碼
;輸出：CY表示輸入錯誤，EAX=0表示使用者輸入的資料無法轉換成整數
;　　　　　　　　　　　EAX=1表示使用者輸入的整數不在負二十億至二十億之間
;　　　NC表示輸入正確，EAX=使用者輸入的數值
        LOCAL   n:DWORD,nWritn:DWORD,nRead:DWORD,buffer[16]:BYTE
    ;印出sHint字串，並且讓使用者輸入數字字串
        invoke  WriteConsole,hOut,ADDR sHint,SIZEOF sHint,ADDR nWritn,0
        invoke  ReadConsole,hIn,ADDR buffer,SIZEOF buffer,ADDR nRead,0
    ;把使用者輸入的數字字串轉換成數值
        invoke  StrToIntEx,ADDR buffer,0,ADDR n
        or      eax,eax
        jz      error
    ;檢查使用者輸入的數值是否在負二十億至二十億之間
        mov     edi,maximum
        mov     eax,n
        mov     esi,edi ;EDI=二十億
        neg     esi     ;ESI=負二十億，ESI是EDI的2補數
        cmp     eax,edi ;檢查EAX是否大於二十億
        jg      ov100m
        cmp     eax,esi ;檢查EAX是否小於負二十億
        jge     ok
ov100m: mov     rax,1
error:  stc             ;設定進位旗標，並離開Input
        jmp     quit
ok:     clc
quit:   ret
Input   ENDP
;------------------------------------------------------------------------------
main    PROC
    ;取得標準輸入、輸出裝置的控制代碼
        invoke  GetStdHandle,STD_INPUT_HANDLE
        mov     hInput,rax
        invoke  GetStdHandle,STD_OUTPUT_HANDLE
        mov     hOutput,rax
    ;輸入第一個整數
        invoke  Input,hInput,hOutput
        jc      error   ;如果不在負二十億至二十億之間或無法轉換，跳至error
        mov     n1,eax
        mov     sum,eax
        mov     difference,eax
    ;輸入第二個整數
        invoke  Input,hInput,hOutput
        jc      error   ;如果不在負二十億至二十億之間或無法轉換，跳至error
        or      eax,eax ;檢查輸入的數是否為零，因為n2會作為除數
        jz      zero
        mov     n2,eax
    ;處理加法，並決定和的格式規範
        lea     r8,szFmtI    ;先假設n1+n2不溢位
        add     sum,eax
        jno     nv1
        test    n1,80000000h ;若發生溢位，判斷和為正數抑或負數
        jz      pos1
        lea     r8,szFmtUn   ;溢位且和為負
        neg     sum
        jmp     nv1
pos1:   lea     r8,szFmtUp   ;溢位且和為正
    ;處理減法，並決定差的格式規範
nv1:    mov     r9,OFFSET szFmtI
        sub     difference,eax
        jno     nv2
        test    n1,80000000h ;若發生溢位，判斷差為正數抑或負數
        jz      pos2
        mov     r9,OFFSET szFmtUn
        neg     difference
        jmp     nv2
pos2:   mov     r9,OFFSET szFmtUp
    ;製作szFmt字串，作為輸出和、差、積、商、餘的格式控制字串
nv2:    invoke  wsprintf,ADDR szFmt,ADDR szCtFmt,r8,r9
        mov     eax,n1
        imul    n2      ;EDX:EAX=EAX×n2
        mov     DWORD PTR product,eax
        mov     DWORD PTR product[4],edx
        mov     eax,n1
        cdq             ;EDX:EAX=n1，且將EAX符號位元擴充至EAX
        idiv    n2      ;EDX:EAX=EDX:EAX÷n2
    ;如果餘數小於零，必須調整商與餘數，否則跳至done標記，印出結果
        cmp     edx,0
        jge     done
    ;檢查除數（即n2）是否為正數，若為正跳至pos處
        test    n2,80000000h
        jz      pos
        inc     eax     ;若除數為負數
        sub     edx,n2
        jmp     done
pos:    dec     eax     ;若除數為正數
        add     edx,n2
done:   mov     quotient,eax
        mov     remainder,edx
    ;生成szAns字串
        invoke  wsprintf,ADDR szAns,ADDR szFmt,n1,n2,sum,difference,product,quotient,remainder
        mov     rdx,OFFSET szAns
        jmp     pnt_it
error:  cmp     eax,0
        jnz     err1
        mov     rdx,OFFSET sErr0
        mov     eax,SIZEOF sErr0
        jmp     pnt_it
err1:   mov     rdx,OFFSET sErr1
        mov     eax,SIZEOF sErr1
        jmp     pnt_it
zero:   mov     rdx,OFFSET sErr2
        mov     eax,SIZEOF sErr2
    ;印出szAns字串或錯誤訊息
pnt_it: invoke  WriteConsole,hOutput,rdx,eax,0,0
        invoke  ExitProcess,0
main    ENDP
;******************************************************************************
END

組譯與連結步驟，以及執行結果如下圖（黃色字是使用者輸入的指令）：

說明 CALCULUS.ASM

CALCULUS.ASM 功能雖然很簡單，但是要考慮的細節，卻是不少。

Input 副程式

首先，電腦能夠處理的數值可以很大，卻也不是無限制，所以必須讓使用者輸入的數在某個範圍內。考慮到 x64 CPU 能處理的 32 位元有號數範圍是－2147483648∼2147483647，約負二十一億至二十一億之間，因此小木偶設定 CALCULUS 只進行負二十億至二十億之間的有號數四則運算。

輸入兩個數值的過程相同，可以用一個副程式完成，這個副程式稱為 Input。在結束 Input 副程式時，須檢查幾件事：

  1. 如果使用者輸入的資料，無法藉由 StrToIntEx 轉換成數值，那麼必須將此錯誤傳給 main，以便讓 main 印出錯誤訊息。
  2. 如果使用者輸入的數值不在負二十億至二十億之間，也得將此錯誤傳給 main，以便讓 main 印出錯誤訊息。
  3. 使用者輸入的第二個數會被當做除數，而除數不可為零是零，所以第二個數不可為零；但是第一個數可以是零，所以必須特別處理使用者輸入零的情況。

鑒於上面情形，小木偶將 Input 的回傳值設為兩類情形：

  1. 如果使用者輸入的數字字串能經由 StrToIntEx 成功轉換成數值，且在負二十億至二十億之間，Input 將該數值存於 EAX，並清除進位旗標返回。這種情形代表正常運作。
  2. 如果使用者輸入的數字字串能經由 StrToIntEx 成功轉換成數值但不在負二十億至二十億之間，或無法轉換成數值，Input 會設定進位旗標，同時 EAX 代表發生錯誤的原因。這兩種情形代表錯誤。

Input 返回 main 之後，如果是第 2 種情形，依據 EAX 印出哪一種錯誤訊息。如果是第 1 種情形，就進行下一步驟：①繼續輸入第二個數值或②進行四則運算。如果是已經輸入完第二個數值，需檢查 EAX 是否為零。如果是零，就印出「除數不可為零！」後退出 CALCULUS。假如都沒有問題，就進入四則運算。

在 x64 CPU 指令中，進行有號數的四則運算分別是 ADD、SUB、IMUL、IDIV，其中 ADD、SUB 必須考慮溢位的情形較為複雜；IMUL 的單運算元形式，不需考慮溢位，但要考慮如何與 wsprintf 搭配，得到 64 位元有號數；而 IDIV 則是考慮了也沒用，要考慮的是如何調整，使餘數變為正數，以符合數學上的要求。底下就這些指令分別說明。

加減法溢位問題

假如進行 32 位元的有號數加法運算，例如二十億加二十億，程式寫成：

sAnswer DB      20 DUP (0)
szFmt   DB      "%d",0
        ⁝
        mov     eax,2000000000
        add     eax,2000000000
        invoke  wsprintf,ADDR sAnswer,ADDR szFmt,eax

執行後 sAnswer 字串是「-294967296」並非四十億，這是因為結果已經超過有號數所能表示的範圍（32 位元有號數的範圍是負二十一億至二十一億之間，見前一章）。像這種情形，較大的正數加較大的正數就有可能發生溢位（這兒較大的正數指的是接近二十億的正數，兩個此類數相加就有可能超過二十一億），這時候應該把格式控制字串（也就是 szFmt）內的格式規範（也就是 %d）改成以無號數類型處理，也就是：

szFmt   DB      "%u",0

那麼還有沒有其他情形會造成溢位呢？事實上還有三種：較小的負數加較小的負數（例如負二十億加負二十億）、較大的正數減較小的負數（例如二十億減負二十億）、較小的負數減較大的正數（例如負二十億減二十億）。發生溢位的四種情形，再加上沒有發生溢位的情形，整理如下表：

是否溢位發生溢位情形例子格式控制字串
溢
位		較大的正數加較大的正數　二十億＋　二十億＝　四十億"%u",0
較小的負數加較小的負數負二十億＋負二十億＝負四十億"-%u",0
較大的正數減較小的負數　二十億－負二十億＝　四十億"%u",0
較小的負數減較大的正數負二十億－　二十億＝負四十億"-%u",0
不溢位其他情形十億＋十億＝二十億"%d",0

上表中的第一、第三種情形，所得的和或差太大，是超過二十一億的正整數，超過三十二位元有號數的所能表示的範圍。雖然可以將其擴充成六十四位元再顯示於螢光幕上，但本章用另外一種技巧，也能達到目的。既然不能用有號數表示，就改用無號數表示，因為反正都是正數。而上表中的第二、四種情形，所得的結果是很小的負數（例如負四十億），那就先用 NEG 指令將其變號，這樣就變成原數的相反數，也就是正數，然後用無號數表示，不過格式控制字串需加上「-」，這樣在螢光幕上看起來就是負數。例如下面的程式：

sAnswer DB      20 DUP (0)
szFmt   DB      "-%u",0
        ⁝
        mov     eax,-2000000000
        add     eax,-2000000000
        neg     eax
        invoke  wsprintf,ADDR sAnswer,ADDR szFmt,eax

對加法作總整理。如果相加後，不溢位，那麼格式規範是「%d」。如果發生溢位，那麼要判斷結果是正數還是負數，如果是正數，表示和超過二十一億，格式規範是「%u」；如果是負數，表示和小於負二十一億，要以原數的相反數處理，應執行 NEG 指令同時「%u」之前必須加上「-」，變成「-%u」。對於減法的處理方式也是一樣，就不贅述。

到此大致已解決發生溢位的問題，僅剩下如何撰寫格式控制字串。先來看看假如不發生溢位，格式控制字串應該長的怎麼樣，然後再慢慢修正。CALCULUS 最後要把使用者輸入的兩個數與這兩數之和、差、積、商與餘數印在螢光幕上。所以一開始，印出這些數值的格式控制字串是：

"%d、%d之和、差、積、商及餘數依序為%d、%d、%I64d、%d餘%d。",0

再來看看格式控制字串該如何修正。這個格式控制字串可分為三部分討論：

  1. 最前面的兩個「%d、%d」，是使用者輸入的兩個有號數的格式規範，是固定不變的。
  2. 第三、第四個，「%d、%d」是和與差的格式規範。根據前面描述，這兩個格式規範有可能因溢位的關係，所以不一定是「%d」，有可能是「%d」、「%u」、「-%u」，三選一。
  3. 最後面的三個，「%I64d」、「%d餘%d」是積、商與餘數的格式規範，這三個是固定不變的。

回想第五章介紹 wsprintf 函式的說明，格式控制字串可以使用「%s」格式規範，生成不同的字串；還有，如果是兩個「%」連在一起，那麼「%」並非代表格式規範的起頭，而就是代表「%」這個字元。在 CALCULUS 裏，執行兩次 wsprintf，第一次是依據是否發生溢位，製造出格式控制字串；第二次才是依據第一次造出的格式控制字串，製造出真正要印在螢光幕上的和、差、積、商及餘數字串。這整段流程如下圖所示：上圖中，橙色字的 szCtFmt 格式控制字串，就是用來製造要真正印在螢光幕上的格式控制字串。有關依據 szCtFmt 格式控制字串生成新的 szFmt 格式控制字串的程式碼如下：

szCtFmt DB "%%d、%%d之和、差、積、商及餘數依序為",0dh,0ah,"%s、%s、%%I64d、%%d餘%%d。",0
        ⁝
        invoke  wsprintf,ADDR szFmt,ADDR szCtFmt,r8,r9

在 szCtFmt 格式控制字串中，兩個「%s」會把 R8、R9 所指位址上的字串代入，而產生新的 szFmt；而其他的「%%」，wsprintf 只會把它們當做一個「%」的普通字元，照抄進 szFmt。舉個例子說明，可能會更清楚。

假設某次用 x64dbg 載入 CALCULUS.EXE，資料區段的部分資料如下：

0A12000  00 00 00 00 00 00 00 00 00 00 00 00 25 25 64 A1  ............%%d.
0A12010  42 25 25 64 A4 A7 A9 4D A1 42 AE 74 A1 42 BF 6E  .%%d之和、差、積
0A12020  A1 42 B0 D3 A4 CE BE 6C BC C6 A8 CC A7 C7 AC B0  、商及餘數依序為
0A12030  0D 0A 25 73 A1 42 25 73 A1 42 25 25 49 36 34 64  ..%s、%s、%%I64d
0A12040  A1 42 25 25 64 BE 6C 25 25 64 A1 43 00 25 75 00  、%%d餘%%d。.%u.
0A12050  2D 25 75 00 25 64 00 BD D0 BF E9 A4 4A AD 74 A4  -%u.%d.請輸入負.
0A12060  47 A4 51 BB F5 A6 DC A4 47 A4 51 BB F5 A4 A7 B6  .十億至二十億之.

使用者在 CALCULUS 兩次提示「請輸入負二十億至二十億之間的整數：」時，先後輸入負二十億和二十億，那麼依據上面流程圖，這兩數相加為零，不溢位，R8 會指向字串「"%d",0」的位址，即 A12054h（上表中白色字所示）；兩數相減為負四十億，發生溢位，R9 會指向字串「"-%u",0」的位址，即 A12050h（上表中紫色字所示）。

當執行到「invoke wsprintf,ADDR szFmt,ADDR szCtFmt,r8,r9」時，wsprintf 會依據 szCtFmt 的內容（如下），把 szFmt 逐步製造出來，過程如下：

szCtFmt DB "%%d、%%d之和、差、積、商及餘數依序為",0dh,0ah,"%s、%s、%%I64d、%%d餘%%d。",0
  1. szCtFmt 一開始是兩個「%%d」，其中的「%%」會被 wsprintf 視為普通字元「%」而不是格式規範的開始。所以「%%d」代表把「%d」填入 szFmt 中，於是 szFmt 變為「"%d、%d"」。
  2. szCtFmt 接下來的幾個字元（包含「0dh、0ah」所代表的換行符號）並無特殊之處，照抄進入 szFmt。所以 szFmt 的內容變成「"%d、%d之和、差、積、商及餘數依序為",0dh,0ah」。
  3. szCtFmt 接下來的是格式規範「%s」，代表要到 wsprintf 的第三個參數，R8，所指位址上的字，並將該字串複製到 szFmt 裏面。R8＝A12054h，所以就到位址 A12054h，把該位址的字串「"%d"」加進到 szFmt 裏。於是 szFmt 變成「"%d、%d之和、差、積、商及餘數依序為",0dh,0ah,"%d"」。
  4. 接下來是「、%s、%%I64d、%%d餘%%d。」，除了「%s」是格式規範之外，其餘都是普通字元照抄寫入 szFmt。而「%s」須到第四個參數，R9，所指的位址，也就是位址 A12050h，把該位址的字串「"-%u"」嵌入到 szFmt 內。於是 szFmt 變成「"%d、%d之和、差、積、商及餘數依序為",0dh,0ah,"%d、-%u、%I64d、%d餘%d。"」

經由上面幾個步驟所生成的格式控制字串，szFmt，會在接下來的程式中，再次成為呼叫 wsprintf 的參數，就是上面流程圖的最後一步驟。這一次會製造出要印在螢光幕的字串，最後呼叫 WriteConsole 印在螢光幕上。

處理 64 位元的乘積

CALCULUS 用 32 位元的有號數乘以 32 位元的有號數，所得的積為 64 位元，存於兩個 32 位元的暫存器 EDX、EAX 裏面，以 EDX:EAX 表示，EDX 是高半部的 32 位元，EAX 低半部的 32 位元。而 CALCULUS 在資料區段內，卻是用 DQ 定義 product 為 64 位元。因此必須分兩次將 EAX、EDX 存入 product，這時候必須用 DWORD PTR 強制改變 product 的資料類型。

product DQ      ?       ;積
         ⁝
        mov     eax,n1
        imul    n2      ;EDX:EAX=EAX×n2
        mov     DWORD PTR product,eax
        mov     DWORD PTR product[4],edx
         ⁝
        invoke  wsprintf,ADDR szAns,ADDR szFmt,n1,n2,sum,difference,product,quotient,remainder

然後呼叫 wsprintf 將 product 轉換成數字字串，要注意的是，product 以 DQ 定義，其相對應的格式規範是「%I64d」。

處理除法的問題

除法的問題有兩個：①溢位、②餘數的正負。

雖然 DIV 或 IDIV 指令是有可能發生溢位的情形，但是卻無法由溢位旗標中得到。因為本章標題是有號數，所以舉一個 32 位元的 IDIV 為例子，說明發生溢位的情形；DIV 也是一樣的道理，聰明的你應該能觸類旁通。IDIV 指令執行前須將 64 位元的被除數放在 EDX:EAX 裏，32 位元的除數放在暫存器或變數裏。假如用四十億除以一，得到的商是四十億，餘數是零，如下面程式：

        mov     eax,0EE6B2800h
        mov     edx,0
        mov     r8d,1
        idiv    r8d

所得的商存於 EAX，顯然超過 32 位元有號數所能表示的範圍。像這樣，被除數太大而除數太小，導致商無法存於累加器中（x64 CPU 中的 AX 稱為累加器，accumulator，這裏包含 EAX、RAX），進而發生溢位。然而在 x64 CPU 中，這種溢位會引發除法錯誤例外（簡稱 #DE），不會在旗標中表現出來。

x64 CPU 在執行指令的過程中，如果偵測到異常或特殊情況，需要暫時中斷目前的程式，轉而執行專門處理該情況的程式碼（稱為「例外處理常式」），這種情形稱為例外（exception）。x64 CPU 的每種例外都以「#」開頭，並以縮寫表示，例如 #DE 表示除法錯誤例外（divide error exception），#GP 表示一般保護錯誤（general protection exception）……。而例外處理常式一般都包含在作業系統內，應用程式通常不處理例外。

應用程式能做的是預防 #DE 發生。除了剛剛說的被除數太大而除數太小，導致商超過所能表示的範圍會引發 #DE 之外，除以零也會引發 #DE。對於後者，CALCULUS 已做預防。對於前者，可以參考 DOS 組合語言第七章註一，自行改良 CALCULUS。

接著說明餘數的正負值。前一章曾提過，不論被除數或除數是正值、還是負值，都應遵守其絕對值小於除數的絕對值。這樣就造成兩種定義：①餘數為正值，這是多數數學家採用的。②餘數與被除數同號，這是 IDIV 採用的。為了符合多數數學家採用的定義，CALCULUS 必須對執行 IDIV 後的結果稍作修改，讓我們從頭開始說明除法的運作過程。

CALCULUS 讓使用者輸入 32 位元的有號數，進行 32 位元的有號數除法，被除數應為 64 位元，存於 EDX:EAX 裏。低半部的 32 位元可以使用 MOV 指令，而高半部的 32 位元必須是低半部的符號位元延伸，所以須使用 CDQ 指令。見 CALCULUS.ASM 第 101∼102 行。接下來執行 IDIV 指令，如果餘數是正值，那麼就沒問題可以把商與餘數存入 quotient、remainder 變數裏；如果餘數是負值，才須調整。

被除數與除數可能為正、亦可能為負，共有四種情形，見下表：

被除數除數例子使餘數為正
正數正數(+23)÷(+4)＝+5……+3不須修正
正數負數(+23)÷(-4)＝-5……+3不須修正
負數正數(-23)÷(+4)＝-5……-3(-23)÷(+4)＝-6……+1
負數負數(-23)÷(-4)＝+5……-3(-23)÷(-4)＝+6……+1

觀察上表當可發現，如果被除數為正數，餘數必為正數，不須修正餘數；被除數為負數，餘數亦為負數，才要修正餘數。修正餘數仍得遵守底下的方程式：

a＝dq＋r，且 0＜|r|＜|d|

其中 a、d、q、r 依序是被除數、除數、商及餘數，而且都是整數。現在看上表中須要修正餘數的情形，像第三種情形，除數是正數，修正時使原來餘數加上除數即可變成正數，而商則須減一；第四種情形，除數是負數，修正時使原來餘數減去除數即可變成正數，而商則須加一。