第十章　迴圈

電腦最擅長的工作是能夠很有耐心的，重複數千次、數萬次枯燥乏味的事情。這一章介紹組合語言中的迴圈，迴圈是程式設計中的一種流程，讓電腦能夠重複執行同一段程式碼多次，直到滿足特定條件才停止。

一如既往，本章會以幾個例子說明迴圈，這些例子與等差數列有關，所以先介紹什麼是等差數列。如果把一系列的數值排列在一起，而且任何相鄰兩數的差均相等，就稱此數列為等差數列（arithmetic sequence，也稱為算術數列）。該差值稱為公差（common difference），通常以 d 表示；每個數都稱為項（term）；這數列總共有多少個項，稱為項數（number of terms）；這些數的第一個稱為首項（以 a1 表示），第二個稱為第二項（以 a2 表示）……依此類推，最後一項稱為末項；這個數的總和，稱為等差級數（arithmetic series，通常以 Sn 表示）。例如底下的數列，就是等差數列：

1、3、5、7、……、99

它的公差是 2，首項是 1，第二項是 3，末項是 99，項數是 50。

新的 x64 指令

x64 指令：LOOP

LOOP 指令的語法是

LOOP    標記

標記（label）是一串英文字組成，可以包含「_」、阿拉伯數字，必須以「:」結尾。它代表著位址，通常位於 LOOP 指令之前的位址（或較低位址），且距離 LOOP 指令所在位址不可超過 128 個位元組，在此標記與 LOOP 之間的指令會重複執行。

要重複執行多少次，由 CX、ECX 或 RCX 指定；至於是哪個暫存器，由位址大小（address size）」決定。64 位元版的 Windows，位址大小是 64 位元，故重複次數放在 RCX；32 位元版的 Windows，位址大小是 32 位元，故重複次數放在 ECX；MS－DOS 是 16 位元的，位址大小也是 16 位元，故重複次數是 CX。因為 CX、ECX、RCX 用於計數，所以它們也稱為計數暫存器（count register）。

當 CPU 執行到 LOOP 指令時，CPU 先使計數暫存器減一，然後再檢查計數暫存器是否為零。如果不是零，就跳躍至標記處執行；如果是零，就不跳躍，而是執行 LOOP 下一個指令。

底下舉個例子說明如何使用 LOOP 指令。假如要使記憶體中填入 1、2、3、……、100 的等差數列，可以使用下面程式。首先定義一百個位元組長的 number 變數，每筆資料均一個位元組。在 again: 標記到 LOOP 指令之間的程式會重複執行，這就是迴圈。

number  DB      100 DUP (0)
         ⁝
        mov     rcx,100
        mov     al,0
        lea     rsi,number
again:  inc     al       ;─┐
        mov     [rsi],al ; ├─迴圈
        inc     rsi      ; │（關於[RSI]的意義，參閱第二章）
        loop    again    ;─┘

假設這段程式載入記憶體中時，number 在位址 0EE2000h 處。那麼在還未執行迴圈之前，記憶體內容如下：

0EE2000  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................
0EE2000  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................
0EE2000  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................

⑴、最前面的三個指令，是用來初始化迴圈所需的變數：①設定計數暫存器為 100，表示迴圈要執行 100 次。②把 AL 設為零，每執行一次迴圈，AL 就增加一。而且是從一開始，到 100。③使 RSI 指向 number 的位址。

⑵、第一次進入迴圈時，AL 原為零，增加一後變成一；再把 AL 存入 RSI 所指位址的記憶體裏面，這時 RSI＝EE2000h，也就是把 AL 之值存於位址為 EE2000h 的記憶體之中（見下面記憶體內容）；然後使 RSI 加一，指向下一個記憶體位址，EE2001h。迴圈最後是 LOOP 指令，CPU 把 RCX 減一變成 99，不是零跳至 again: 處。

0EE2000  01 00 00 00 00 00 00-00 00 00 00 00 00 00 00 00  ................

⑶、第二次執行迴圈時，AL 原為一，增加一後變成二；再把 AL 存入 RSI 所指位址的記憶體裏面，這時 RSI＝EE2001h，也就是把 2 存於位址為 EE2001h 的記憶體之中（見下面記憶體內容）；然後使 RSI 加一，指向下一個記憶體位址，EE2002h。接下來的 LOOP 使 RCX 減一變為 98，不是零跳至 again: 處。

0EE2000  01 02 00 00 00 00 00-00 00 00 00 00 00 00 00 00  ................

⑷、如此一直重複，直到迴圈已經執行過 99 次後（也就是執行過 99 次 LOOP 指令後），且跳至 again: 時，RCX＝1，AL＝99，RSI＝0EE2063h。而這時候，記憶體內容如下：

0EE2000  01 02 03 04 05 06 07 08-09 0A 0B 0C 0D 0E 0F 10  ................
0EE2010  11 12 13 14 15 16 17 18-19 1A 1B 1C 1D 1E 1F 20  ...............
0EE2020  21 22 23 24 25 26 27 28-29 2A 2B 2C 2D 2E 2F 30  !"#$%&'()*+,-./0
0EE2030  31 32 33 34 35 36 37 38-39 3A 3B 3C 3D 3E 3F 40  123456789:;<=>?@
0EE2040  41 42 43 44 45 46 47 48-49 4A 4B 4C 4D 4E 4F 50  ABCDEFGHIJKLMNOP
0EE2050  51 52 53 54 55 56 57 58-59 5A 5B 5C 5D 5E 5F 60  QRSTUVWXYZ[\]^_`
0EE2060  61 62 63 00 00 00 00 00-00 00 00 00 00 00 00 00  abc.............

下表是從初始化迴圈開始，以及各次執行過 LOOP 之後，AL、RCX、RSI 數值的整理：

　　情況　　　　　　AL　RCX　　　RSI
------------------------------------------------
尚未進入迴圈前LOOP　0 　100　　EE2000h
第一次執行完LOOP　　1　　99　　EE2001h
第二次執行完LOOP　　2　　98　　EE2002h
第三次執行完LOOP　　3　　97　　EE2003h
 ⁝　　　　　　　　　 ⁝　　　⁝     ⁝
第99次執行完LOOP　63h 　　1   EE2063h

⑸、再執行迴圈時，AL 變為 100（即十六進位的 64h），接下來把 AL 存入 RSI 所指的記憶體位址（即位址 0EE2063h）。接下來使 RSI 加一指向下一個位址，但這步驟沒用，因為即將跳脫迴圈。再來是執行 LOOP 指令，因為這時 RCX＝1，減一之後變為零，並不會跳至 again: 處，而是執行 LOOP 的下一個指令，於是就跳離迴圈了。

有關 LOOP 指令還有件事值得注意，某些情形下把計數暫存器設為零，並不是不執行迴圈，有可能執行很多次。例如

        mov     rcx,0
        mov     al,0
        lea     rsi,number
again:  inc     al
        mov     [rsi],al
        inc     rsi
        loop    again

並不是不執行迴圈，而是會執行很多次。因為第一次執行到 LOOP 時，會先把 RCX 減一，使它變成 264-1，因此理論上會進行 264 次迴圈。但由於程式會不斷寫入記憶體，很快就會超出合法記憶體範圍並產生存取違例（access violation），導致程式崩潰。

x64 指令：LOOPZ/LOOPE 與 LOOPNZ/LOOPE

LOOPZ 與 LOOPE 是相同的指令，它先將計數暫存器減一，然後再檢查計數暫存器是否不等於零，且零值旗標是否為一；只有在兩者同時成立時，才會跳回標記位址處繼續迴圈。

LOOPNZ 與 LOOPNE 是相同的指令，它先將計數暫存器減一，然後再檢查計數暫存器是否不等於零，且零值旗標是否為零，只有在兩者同時成立時，才會跳回標記位址處繼續迴圈。

有關 LOOPZ 與 LOOPNZ 還有一件事要注意，它們本身不會改變零值旗標，而是依賴先前指令對零值旗標的影響，來判斷是否繼續迴圈。

x64 指令：JO 與 JNO

JO 指令用於檢查運算結果是否發生溢位，如果發生溢位，那麼 CPU 會把溢位旗標設為一；JO 檢測到溢位旗標為一，就會發生跳躍。如果沒有發生溢位，CPU 會把溢位旗標設為零；JO 檢測到溢位旗標為零，不發生跳躍。JNO 指令則是反過來，如果不發生溢位，才跳躍；發生溢位，不跳躍。

另外有許多常用的條件跳躍指令，已整理成一張表，請參閱第八章。

例子一

底下的例子是計算 1+2+3+……+100 等於多少？

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
;計算1+2+3+……+100等於多少？
INCLUDE E:\masm64\include64\masm64rt.inc
number_of_terms EQU 100
;******************************************************************************
.DATA
hStdOut DQ      ?
szFmt   DB      "1+2+3+……+%d=%d",0
buffer  DB      20h DUP (0)
;******************************************************************************
.CODE
;------------------------------------------------------------------------------
main    PROC
        LOCAL   written:DWORD
    ;取得標準輸出控制代碼
        invoke  GetStdHandle,STD_OUTPUT_HANDLE
        mov     hStdOut,rax
    ;計算1+2+3+……等於多少？
    ;其中R8D為數列，由1開始每次增加一。R9D為其總和。
        xor     r8d,r8d
        xor     r9d,r9d
        mov     rcx,number_of_terms
again:  inc     r8d
        add     r9d,r8d
        loop    again
    ;印出1+2+3+……的結果
        invoke  wsprintf,ADDR buffer,ADDR szFmt,r8d,r9d
        invoke  WriteConsole,hStdOut,ADDR buffer,eax,ADDR written,0
        invoke  ExitProcess,0
main    ENDP
;------------------------------------------------------------------------------
END

將它存成 AS1.ASM，然後在命令提示字元中輸入底下命令，將其組譯、連結：

path E:\masm64\bin64;%path%
set link=/subsystem:console /entry:main
ml64 as1.asm

說明

因為 AS1.ASM 並不難，所以不打算講解，只列出在進入迴圈前，以及執行迴圈若干次 RCX、R8D、R9D 的變化，聰明如你應當可以推敲而得到：

　　情況　　　　　　R8D　　R9D　　RCX
------------------------------------------------
尚未進入迴圈前LOOP　0　　　　0　　100
第一次執行完LOOP　　1　　　　1　　99
第二次執行完LOOP　　2　　　　3　　98
第三次執行完LOOP　　3　　　　6　　97
　　⁝　　　　　　 　 ⁝　　　　⁝     ⁝
第99次執行完LOOP　100 　　1   EE2063h

例子二

第二個例子也是計算等差數列的和，但是它可以讓使用者自由輸入首項、公差以及項數，然後再計算出等差數列的總和。

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
INCLUDE E:\masm64\include64\masm64rt.inc
;******************************************************************************
.DATA
hInput  DQ      ?       ;標準輸入裝置控制代碼
hOutput DQ      ?       ;標準輸出裝置控制代碼
a1      DD      ?       ;首項
a2      DD      ?       ;第二項
a3      DD      ?       ;第三項
an      DD      ?       ;末項
d       DD      ?       ;公差
n       DD      ?       ;項數
sum     DD      0       ;總和
szFmt   DB      20h DUP (0)
szSum   DB      40 DUP (0)
szCtFmt DB      "%s+%s+%s+……+%s=%%d",0
sStr1   DB      "計算等差數列的總和。",0dh,0ah,"請輸入首項："
sStr2   DB      "請輸入公差："
sStr3   DB      "請輸入項數（項數必須是正整數）："
sErr0   DB      "無法轉換成整數！"
sErr1   DB      "項數不能小於或等於零。"
sErr2   DB      "發生溢位，AS2終止執行。"
szNeg   DB      "(%d)",0
szPos   DB      "%d",0
;******************************************************************************
.CODE
;------------------------------------------------------------------------------
Input   PROC    USES rsi rdi hIn:QWORD,hOut:QWORD,pHint:LPSTR,lenHint:DWORD
maximum EQU 2000000000  ;二十億=77359400h
;輸入：hIn、hOut－標準輸入、輸出裝置控制代碼
;　　　pHint－提示字串位址
;　　　lenHint－提示字串長度
;輸出：CY表示輸入錯誤，EAX=0表示使用者輸入的資料無法轉換成整數
;　　　　　　　　　　　EAX=1表示使用者輸入的整數不在負二十億至二十億之間
;　　　NC表示輸入正確，EAX=使用者輸入的數值
        LOCAL   num:DWORD,nWritn:DWORD,nRead:DWORD,buffer[16]:BYTE
    ;印出sHint字串，並且讓使用者輸入數字字串
        invoke  WriteConsole,hOut,pHint,lenHint,ADDR nWritn,0
        invoke  ReadConsole,hIn,ADDR buffer,SIZEOF buffer,ADDR nRead,0
    ;把使用者輸入的數字字串轉換成數值
        invoke  StrToIntEx,ADDR buffer,0,ADDR num
        or      eax,eax
        jz      error
    ;檢查使用者輸入的數值是否在負二十億至二十億之間
        mov     edi,maximum
        mov     eax,num
        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,ADDR sStr1,SIZEOF sStr1
        jc      err0
        mov     a1,eax  ;a1＝首項
        mov     a2,eax
        mov     a3,eax
        invoke  Input,hInput,hOutput,ADDR sStr2,SIZEOF sStr2
        jc      err0
        mov     d,eax   ;d＝公差
        add     a2,eax  ;a2＝第二項
        mov     r10d,a2
        add     r10d,eax
        mov     a3,r10d ;a3＝第三項
        invoke  Input,hInput,hOutput,ADDR sStr3,SIZEOF sStr3
        jc      err0
        cmp     eax,0   ;項數不能小於或等於零
        jle     err1
        mov     n,eax   ;n＝項數
        cdqe
    ;開始計算末項及等差級數
        mov     r11d,a1 ;R11D由首項開始，每次增加一個公差，直至末項
        mov     sum,0
        mov     rcx,rax
again:  add     sum,r11d
        jo      err2
        add     r11d,d
        jo      err2
        loop    again
        sub     r11d,d
        mov     an,r11d ;an＝末項
    ;製造szFmt格式控制字串
        mov     r8,OFFSET szPos
        test    a1,80000000h
        jz      chk_a2
        mov     r8,OFFSET szNeg
chk_a2: mov     r9,OFFSET szPos
        test    a2,80000000h
        jz      chk_a3
        mov     r9,OFFSET szNeg
chk_a3: mov     r10,OFFSET szPos
        test    a3,80000000h
        jz      chk_an
        mov     r10,OFFSET szNeg
chk_an: mov     r11,OFFSET szPos
        test    an,80000000h
        jz      crt_fm
        mov     r11,OFFSET szNeg
crt_fm: invoke  wsprintf,ADDR szFmt,ADDR szCtFmt,r8,r9,r10,r11
        invoke  wsprintf,ADDR szSum,ADDR szFmt,a1,a2,a3,an,sum
        lea     rdx,szSum
        jmp     pnt_it
err0:   lea     rdx,sErr0
        mov     eax,SIZEOF sErr0
        jmp     pnt_it
err1:   lea     rdx,sErr1
        mov     eax,SIZEOF sErr1
        jmp     pnt_it
err2:   lea     rdx,sErr2
        mov     eax,SIZEOF sErr2
    ;印出szAns字串或錯誤訊息
pnt_it: invoke  WriteConsole,hOutput,rdx,eax,0,0
        invoke  ExitProcess,0
main    ENDP
;------------------------------------------------------------------------------
END

將它存成 AS2.ASM，然後在命令提示字元中輸入底下命令，將其組譯、連結：

path E:\masm64\bin64;%path%
set link=/subsystem:console /entry:main
ml64 as2.asm

說明

AS2.ASM 中有幾處地方值得說明。

首先是第 83 行的 CDQE 指令。因為項數必為正數，況且小木偶也不太希望能 AS2 處理項數很多的等差數列，所以 Input 副程式只讓使用者輸入 32 位元的正整數。但是 LOOP 迴圈的計數暫存器是 RCX，必須用這個指令是把 EAX 內的符號位元延伸到 RAX 的第 32∼63 位元，也就是把 RAX 半高部的每個位元都填入 EAX 的符號旗標。然後在第 87 行，將項數指定給 RCX 作為 LOOP 的重複次數。

第二是在迴圈之中，也就是第 89、91 兩行，使用 JO 指令，這是因為在計算每一項，或是總和的時候，都可能發生溢位。為了不使錯誤的結果顯示在螢幕上，所以當發生溢位時，在螢幕上印出的是發生溢位的錯誤訊息。

第三是第 95∼112 行，這幾行是用來檢查首項、第二項、第三項及末項是正數還是負數，如果是負數就要加上一對「(」、「)」，如果是正數就不加。假設首項是 5，公差是 -3，項數是 10，印出來的是

5+2+(-1)+……+(-22)=-85

如果印出下面的樣子，較難閱讀

5+2+-1+……+-22=-85