汇编语言可以说是未经整理的、原始的计算机语言，读者们大可下一番功夫，找出
其应用的规则，以发挥最高的效率。在下面，我仅就个人的经验，提供一些浅见，以供
切磋研讨。
要写好程序，首先应熟记8088指令的时钟脉冲（Clock ）及指令长度，一般汇编语
言手册中，都详列了与各指令相关的数据。「工欲善其事，必先利其器」，此之谓也。
本节所讨论的，是一般程序员容易忽略的细节，所有的例子都是从我所看过的一些
程序中摘录下来的。看来没什么大了不起，可是程序的效率，受到这些小地方的影响很
大。更重要的是，任何一个人，只要有「小事不做，小善不为」的习惯，我敢断言，这
个人不会有什么大成就！
我最近才查到 Effective Address (EA) 的时钟值，我觉得没有必要死记。原则上，
以寄存器为变量，做间接寻址时为５个时钟，用直接寻址则为６个；若用了两组变量，
则为７至９个，三组则为11或12个。
为了便于叙述，下面以"Ｔ"表「时钟脉冲」; "Ｂ"表字符。其中
时钟脉冲T = 1 / 振荡频率
一、避免浪费速度及空间
汇编语言的效率建立在指令的运用上，如果不用心体会下列指令的有效用法，汇编
语言的优点就难以发挥。
1, CALL ABCD
RET
这种写法，是没有用心的结果，共享了 4B，23T+20T，完全相同的功能，如：
JMP ABCD 或
JMP SHORT ABCD
却只要 2-3B，15T。
此外，上述的CALL XXXX 是调用子程序的格式，在直觉认知上，与JMP XXXX完
全不同。对整体设计而言，是不可原谅的错误，侦错的时候，也很难掌握全盘的理念。
尤其是在精简程序的时候，很可能会遇到 ABCD 这个子程序完全独立，是则把
这段程序直接移到 ABCD 前，不仅能节省空间，而且使程序具有连贯性，易读易用。
2, MOV AX,0
同样，这条指令要 3B，4T,如果用：
SUB AX,AX 或
XOR AX,AX
只要 2B，3T， 唯一要注意的是，后者会影响旗号，所以不要用在有旗号判断的指
令前面。
在程序写作中，经常需要将寄存器或缓冲器清为０，有效的方法，是使某寄存
器保持为０，以便随时应用。
因为，MOV [暂存器]，[暂存器] 只要 2B,2T， 即使是清缓冲器，也比直接填
０为佳。
只是，如何令寄存器保持０，则要下一番功夫了。
还有一种情况，就是在一回路中，每次都需要将 AH 清０，此时对速度要求很
严，有一个指令 CBW 原为将一 个字符转换为双字符，只需 1B，2T 最有效率。可是应
该注意，此时 AL 必须小于 80H，否则 AH 将成为负数。
3, ADD AX,AX
需要 2B,3T不如用：
SHL AX,1
只要2B,2T。
4, MOV AX,4
除非这时 AH 必为０，否则，应该用：
MOV AL,4
这样会少一个字符。
5, MOV AL,46H
MOV AH,0FFH
为什么不写成：
MOV AX,0FF46H
不仅省了一个字符，四个时钟，而且少打几个字母！
6, CMP CX,0
需要 4B，4T， 但若用：
OR CX,CX
完全相同的功能，但只要 2B，3T。再若用：
JCXZ XXXX
则一条指令可以替代两条，时空都省。不幸这条指令限用于CX ，对其他暂器无效。
7, SUB BX,1
这更不能原谅，4B，4T无端浪费。
DEC BX
现成的指令，1B，2T为何不用？
如果是
SUB BL,1
也应该考虑此时 BH 的情况，若可以用
DEC BX
取代，且不影响后果，亦不妨用之。
8, MOV AX,[SI]
INC SI
INC SI
这该挨骂了，一定是没有记熟指令，全部共4B，21T。
LODSW
正是为这个目的设计，却只要 1B,16T。
9, MOV CX,8
MUL CX
写这段程序之时应先养成习惯，每遇到乘、除法，就该打一下算盘。因为它们
太浪费时间。８位的要七十多个时钟，16位则要一百多。所以若有可能，尽量设法用简
单的指令取代。
SHL AX,1
SHL AX,1
SHL AX,1
原来要 5B，137T，现在只要 6B，6T。如果CX能够动用的话，则写成：
MOV CL,3
SHL AX,CL
这样更佳，而且CL之值越大越有利。用CL作为计数专 用暂存器，不仅节省空间，
且因指令系在 CPU中执行，速 度也快。
可是究竟快了多少? 我们做了些测试，以 SHL为例，在10MHZ 频率的机器上，
作了3072 ×14270次，所测得时间为：
指 令 ：SHL AX,CL SHL AX,n
CL = 0 ， 23 秒 n = 0 ， 无效
CL = 1 ， 27 秒 n = 1 ， 14 秒
CL = 2 ， 32 秒 n = 2 ， 28 秒
CL = 3 ， 36 秒 n = 3 ， 42 秒
CL = 4 ， 40 秒 n = 4 ， 56 秒
CL = 5 ， 44 秒 n = 5 ， 71 秒
CL = 6 ， 49 秒 n = 6 ， 85 秒
CL = 7 ， 54 秒 n = 7 ， 99 秒
由此可知，用CL在大于２时即较分别执行有效。
此外，亦可利用回路做加减法，但要算算值不值得，且应注意是否有调整余数
的需要。
10, MOV WORD PTR BUF1,0
MOV WORD PTR BUF2,0
MOV WORD PTR BUF3,0
MOV BYTE PTR BUF4,0
..
我见过太多这种程序，一见就无名火起! 在程序中，最好经常保留一个寄存器
为０，以便应付这种情况。即使没有，也要设法使一寄存器为０，以节省时、空。
SUB AX,AX
MOV BUF1,AX
MOV BUF2,AX
MOV BUF3,AX
MOV BUF4,AL
14B，59T取代了 24B，76T,当然值得。只是，还是不 如事先有组织，考虑清楚各
个缓冲器间的应用关系。以前面举的例来说，假定各缓冲器内数字，即为其实际位置关
系，则可以写成：
MOV CX,3
如已知 CH 为０，则用：
MOV CL,3
SUB AX,AX
MOV DI,OFFSET BUF1
REP STOSW
STOSB
这段程序越长越占便宜，现在用10B，37T，一样划算。
11,子程序之连续调用：
CALL ABCD
CALL EFGH
如果 ABCD，EFGH 都是子程序，且调用的次数甚多，则上述调用的方式就有待
商榷了。因为连续两次调用，不仅时间上不划算，空间也浪费。
若ABCD一定与EFGH连用，应将ABCD放在EFGH之前：
ABCD:
..
EFGH:
..
像这样，只要调用ABCD就够了，但这种情形多半是程序员的疏忽所致，如两个
子程序必需独立使用，而上述连续调用的机会超过两次以上，则应该改为：
CALL ABCDEF
而ABCDEF则应为：
ABCDEF:
CALL ABCD
EFGH:
..
这样的写法速度不会变慢，而空间的节省则与调用的次数成正比。
12,常有些程序，当从缓冲器中取数据时，必须将寄存器高位置为０。如：
SUB AH,AH
MOV AL,BUFFER
这时应该将 BUFFER 先设为：
BUFFER DB ?,0
然后用：
MOV AX,WORD PTR BUFFER
如此，不但速度快了，空间也省了。
13,有时看来多了一个指令，但因为指令的特性，反而更为精简。如：
OR ES:[DI],BH
OR ES:[DI+1],BL
这样需要8B,32T，如果改用下面的指令：
XCHG BL,BH
OR ES:[DI],BX
XCHG BH,BL
则需7B,28T。
14,PUSH 及 POP 是保存寄存器原值的指令，都只需一个字符，但却很费时间。
PUSH 占 15T，POP 占12T,除非不得已，不可随便使用。有时由于子程序说明
不清楚，程序员为了安全，又懒得检查，便把寄存器统统堆在堆栈上。尤其是在系统程
序或子程序中，经常有到堆栈上堆、取的动作。实际上，花点功夫，把寄存器应用查清
楚，就可以增进不少效率。
要知道，系统程序及某些子程序常常应用，有关速度的效率甚大，如果掉以轻
心，就是不负责任！
保存原值的方法很多，其中较有效率的是放到一些不用的寄存器里。以我的经
验，堆栈器用途最少，正好用作临时仓库。但最好的办法，还是把程序中寄存器的应用
安排得合情合理，不要浪费，以免堆得太多。
还有一种方法，是在该子程序中，不用堆栈的手续，但另设一个入口，先将寄
存器堆起，再来调用不用堆栈的子程序。这两个不同的入口，可以分别提供给希望快速
处理，或需要保留寄存器原值者调用。
当然，更简单有效的方法，则是说明本段程序中某些寄存器将被破坏，而由调
用者自行保存之。
二、程序要条理通顺
1,在比较判断的过程中，邻近值不必连比。
CMP AL,0
JE ABCD0
CMP AL,1
JE ABCD1
CMP AL,2
JE ABCD2
..
应为：
CMP AL,1
JNE ABCD0
ABCD1:
..
在标题为ABCD0 中，再作：
JA ABCD2
这种做法端视时间效益而定，似此 ABCD1之速度最快。
2,未经慎思的流程：
ADD AX,4
ABCD:
STOSW
ADD AX,4
ADD DI,2
LOOP ABCD
..
稍稍动点脑筋，就好得多了：
ABCD:
ADD AX,4
STOSW
INC DI
INC DI
LOOP ABCD
..
3,错误的处理方式：
MOV BX,SI
ABCD:
MOV BX,[BX]
OR BX,BX
JZ ABCD1
MOV SI,BX
JMP ABCD
ABCD1:
LODSW
..
上例应该写成：
MOV BX,SI
ABCD:
LODSW
OR AX,AX
JZ ABCD1
MOV SI,BX
JMP ABCD
ABCD1:
..
4,错误的流程：
TEST AL,20H
JNZ ABCD
CALL CDEF[BX]
JMP SHORT ABCD1
ABCD:
CALL CDEF[BX+2]
ABCD1:
..
应该写成：
TEST AL,20H
JZ ABCD
INC BX
INC BX
ABCD:
CALL CDEF[BX]
ABCD1:
..
5,下面是时间的损失：
PUSH DI
MOV CX,BX
REP STOSB
POP DI
PUSH，POP 很费时间，应为：
MOV CX,BX
REP STOSB
SUB DI,BX
同理，很多时候稍稍想一下，就可省下一些指令：
PUSH CX
REP MOVSB
POP CX
SUB DX,CX
为什么不干脆些?
SUB DX,CX
REP MOVSB
6,有段程序，很有规律，但却极无效率：
X1:
TEST AH,1
JZ X2
MOV BUF1,BL
X2:
TEST AH,2
JZ X3
MOV BUF2,DX ; 凡双数用DX，单数用BL
X3:
TEST AH,4
JZ X4
MOV BUF3,BL
X4:
.. ; 以下各段与上述程序相似
X8:
..
这种金玉其表的程序，最没有实用价值，改的方法应由缓冲器着手，先安排成
序列，由小而大如：
BUF1 DB ?
BUF2 DW ?
BUF3 DB ?
BUF4 DW ?
..
然后，程序改为：
MOV DI,OFFSET BUF1 ; 第一个缓冲器
MOV AL,BL
MOV CX,4
X1:
SHR AH,1
JZ X2
STOSB
X2:
SHR AH,1
JZ X3
MOV [DI],DX
INC DI
INC DI
X3:
LOOP X1
7,回路最怕千回百转，不畅不顺，如：
SUB AH,AH
ABCD:
CMP AL,BL
JB ABCD1
SUB AL,BL
INC AH
JMP ABCD
ABCD1:
..
以上 ABCD1这个入口是多余的，下面就好得多：
MOV AH,-1
ABCD:
INC AH
SUB AL,BL
JA ABCD
ADD AL,BL ; 还原
..
8,当处理字码时，需要字母的序数，有这样的写法：
CMP AL,60H
JA ABCD1
SUB AL,40H ; 大写字母
ABCD:
..
ABCD1:
SUB AL,60H ; 小写字母
JMP ABCD
要知道字母码的特色在于大写为 40H 至4AH，小写为60H 至6AH ，以上程序，
其实只要一个指令就可以了：
AND AL,1FH
简单明了！
9,大多数的程序在程序员自己测试下很少发生错误，而一旦换一另个人执，就会发现
错误百出。
其原因在于写程序者已经假定了正确的情况，当然不会以明知为错误的方式操
作。可是换了一个人，没有先入为主的成见，很可能输入了「不正确」的数据，结果是
问题丛生。
要知道真正的使用者，绝非设计者本人，在操作过程中，按键错误在所难免。
这种错误应该在程序中事先加以检查，凡是输入数据有「正确、错误」之别者，错误性
数据一定要事先加以排除。
这样做看起来似乎程序不够精简，可是正确的重要性远在精简之上。一旦发生
了错误，再精简的程序也没有使 用价值。
此外，在程序中常有加、减的运算，这时也应该作正确性检查，否则会发生上
述同样的问题。
三、指令应用要灵活
有一段很简单的程序，其写作的方法甚多，但是指令应用的良窳，会使得程序的效
率相去天上地下，难以估计。
这段程序的用途，是要将一段数据中，英文字符大、小写相互转换。当然，转换的
选择要由使用者决定，在下面程序且略去使用界面，假设已得知转换的方式。
设数据在 DS:SI中，数据长度=CX ，大写转小写时BL=0，反之，则BL=1。
我见过一种写法，简直无法原谅：
1: LOOP1:
2: CALL CHANGE
3: JC LOOP11
4: ADD AL,20H
5: JMP SHORT LOOP12
6: LOOP11:
7: SUB AL,20H
8: LOOP12:
9: MOV [SI-1],AL
10: LOOP LOOP1
11: RET
12: CHANGE:
13: LODSB
14: OR BL,BL
15: JZ CHANGS
16: CMP AL,61H
17: JB CHARET
18: CMP AL,7AH
19: JA CHARET
20: STC
21: CHARET:
22: RET
23: CHANGS:
24: CMP AL,41H
25: JB CHARET
26: CMP AL,5AH
27: JA CHARET
28: CLC
29: RET
这种程序错在把由12到29的程序写得太长，共 25B，有共享的价值，于是作为子程
序调用。
试想一下，每一笔数据，都要调用一次，浪费四个字符事小，但每次要费 23+20个
时钟脉冲，数据多时，不啻为天文数字。更何况这段程序写得极差，在回路中，又多浪
费了几十个时钟。关于这一点，下面会继续讨论。
照上面这段程序，略加改进，写法如下：
1: CHANGE:
2: LODSB
3: OR BL,BL
4: JZ CHANGS
5: CMP AL,61H
6: JB CHARET
7: CMP AL,7AH
8: JA CHARET
9: SUB AL,20H
10: CHANG0:
11: MOV [SI-1],AL
12: CHANG1:
13: LOOP CHANGE
14: RET
15: CHANGS:
16: CMP AL,41H
17: JB CHANG1
18: CMP AL,5AH
19: JA CHANG1
20: ADD AL,20H
21: JMP CHANG1
这样的写法还是不佳，因为在回路中，用常数与寄存器比较，速度较寄存器相比为
慢。应该先将需要比较的值，放在暂存器DH，DL 中，改进如次：
1: MOV AH,20H
2: MOV DX,7A61H
3: OR BL,BL
4: JZ CHANGE
5: MOV DX,5A41H
6: CHANGE:
7: LODSB
8: CMP AL,DL
9: JB CHANG1
10: CMP AL,DH
11: JA CHANG1
12: XOR AL,AH
13: MOV [SI-1],AL
14: CHANG1:
15: LOOP CHANGE
16: RET
以上这段程序，空间小，速度快，每笔数据，平均仅需不到40个时钟值，以10 MHZ
计，十万笔数据，约需半秒钟！
请注意程序中所用的技巧，由２至６的分支法，就比下面这种写法为佳：
1: OR BL,BL
2: JZ CHAN1
3: MOV DX,5A41H
4: JMP SHORT CHANGE
5: CHAN1:
6: MOV DX,7A61H
7: CHANGE:
这种分支也可以由另一种技巧所取代，即预设法。事先将所需用的参数放在固定的
缓冲区中，此时取用即可：
MOV DX,BWCOM ; 比较之默认值
这样程序又简单些了：
1: MOV AH,20H
2: MOV DX,BWCOM
3: CHANGE:
4: LODSB
5: CMP AL,DL
6: JB CHANG1
7: CMP AL,DH
8: JA CHANG1
9: XOR AL,AH
10: MOV [SI-1],AL
11: CHANG1:
12: LOOP CHANGE
13: RET
以上介绍为变量法技巧，即将所要比较的值，放在寄存器中。由于寄存器快速、节
省空间，因此程序效率高。更重要的一点，是程序本身的弹性大，只要应用方式统一，
事先把参数设妥，即可共享。
四、回路中的指令
回路最重要的是速度，因为本段程序，将在计数器的范围之内，连续执行下去。如
果不小心浪费了几个时钟值，在回路的累积下，很可能使程序成为牛步。
要想把回路写好，一定要记清楚每个指令的执行时钟，以便选择效率最高者。同时，
要知道哪些指令可以获得相同的处理效果，才能有更多的选择。
其次，在回路中，最忌讳用缓冲器，不仅占用空间大，处理速度慢，而且不能灵活
运用，功能有限。另外也应极力避免常数，尽量设法经由寄存器执行，用得巧妙时，常
会将整个程序的效率提高百十倍。
还有便是少用 PUSH，POP，DIV，MUL和 CALL 等浪费时钟的指令。除此之外，小心、
谨慎，深思、熟虑，才是把回路写好的不二法门。
在前例中，把比较常数的指令换为比较暂存器，便是很好的证明。如果用常数，两
段程序决不可能共享，时、空都无谓地浪费了。
以下再举数例，乍看这似乎有些吹毛求疵，但是仔细计算一下所浪费的时间，可能
就笑不出声了。
兹假定以下回路需处理五万字符的数据，频率为 10MHZ，其情况为：
1: LOOP1:
2: LODSB
3: XOR AL,[DI]
4: STOSB
5: LOOP LOOP1
本程序计数器等于50,000，每次需
12T+14T+11T+17T=55T 个时钟脉冲
若以50,000次计，需时 47*50,000/10,000,000 秒，即约四分之一秒。
只要稍稍将指令调整一下，为：
1: LOOP1:
2: LODSW
3: XOR AX,[DI]
4: STOSW
5: LOOP LOOP1
这样计数器只要25,000次，每次
16T+18T+15T+17T=66T
则25,000次需时 66*25,000/10,000,000 秒，约六分之一秒，比前面的程序快了二
分之一。
同理，在回路中加回路，而每个回路需 17T，也是很大的浪费。倘若加调用 CALL
指令，则需 23T+20T=43T，浪费得更多，读者不可不慎。
当某一段程序用得很频繁时，理应视作子程序，例如下面的 LODAX：
1: LOOP1:
2: CALL LODAX
3: LOOP LOOP1
4: RET
5: LODAX:
6: LODSW
7: XOR AX,[DI]
8: STOSW
9: RET
其实这是贪小失大，仅四个字符的程序，竟用三个字符的调用指令去交换，是绝对
得不偿失的。
再如同下面的程序，颇有值得商榷之处。
1: LOOP1:
2: MOV DX,NUMBER1
3: MOV CX,NUMBER2
4: LOOP2:
5: PUSH CX
6: MOV CX,DX
7: LOOP3:
8: LODSW
9: XOR AX,[DI]
10: STOSW
11: LOOP LOOP3
12: INC DI
13: INC DI
14: POP CX
15: LOOP LOOP2
16: RET
第二个回路是多余的，这是高级语言常用的观念，对汇编语言完全不适用。
稍加改动，不损上面程序原有的条件，得到：
1: LOOP1:
2: MOV DX,NUMBER1
3: LOOP2:
4: MOV CX,NUMBER2
5: LOOP3:
6: LODSW
7: XOR AX,[DI]
8: STOSW
9: LOOP LOOP3
10: INC DI
11: INC DI
12: DEC DX
13: JNZ LOOP2
14: RET
这样回路少了一个，程序中将5,6,14,15 各条中原来为15T+2T+12T+17T=46T的时间，省
为12,13,14条的2T+16T+17T=35T。
|