# Fun Facts About the 8088

I found this list somewhere on the net. Credits to Chris Peters.

## 1. Comparing a register

The fastest and smallest way to compare a 16 bit register to zero is to OR it with itself, e.g.

OR      BX,BX           ; 2 bytes, 3 clocks
JGE     BXisPositive


this is much better than comparing it with zero, e.g.

CMP     BX,0    ; 3 bytes, 4 clocks (bush league)


For the ultimate in comparing with zero, try to use the CX register. The 8088 contains the single instruction:

JCXZ    CXisZero        ; jump if CX is zero


This instruction makes a short jump if CX is zero.

To destructivly test for 1 or -1, use the DEC or INC instructions:

DEC     DX              ; 1 byte, 3 clocks
JZ      DXisOne         ; if zero, DX was 1


or

INC     DX              ; 1 byte, 3 clocks
JZ      DXisMinusOne    ; if zero, DX was -1


The LOOP instruction is just a fancy way of writing:

DEC     CX
JNZ     CXisNotZero


The difference is that LOOP is 1 byte smaller and 2 clocks faster. The LOOP instruction can be used to compare CX with multiple values as follows:

LOOP    CXisNotOne       ; If CX = 1 then...
...                      ; ...do this code, else...


CXisNotOne: LOOP CXisNotTwo ; if CX = 2 then… … ; …do this code, else…

CXisNotTwo: LOOP CXisNotThree ; if CX = 3 then… … ; …do this code, else etc.

Its possible to check if a signed number is in the range 0-n with a single comparison to n:

CMP     DX,639          ; if <0 or >639...
JA      OutOfRange      ; ...its out of range


This is smaller and faster than:

OR      DX,DX           ; Never CMP DX,0!
JL      OutOfRange      ; If negative, its out of range
CMP     DX,639
JG      OutOfRange      ; if greater, its out of range


This can be generalized to any signed compare within a specific range. If you wanted to make sure the AX register contained a number from -5 to 17:

SUB     AX,-5           ; Subtract off lower bound
CMP     AX,17-(-5)      ; Compare upper - lower bound
JA      OutOfRange


You cannot compare a segment register. To do so copy it to a register or memory location, then compare it.

## 2. Setting a register to zero

To set a register to zero, the smallest, fastest way is to XOR it with itself, e.g.

    XOR     BX,BX           ; 2 bytes, 2 clocks


is smaller and faster than:

    MOV     DX,0            ; 3 bytes, 4 clocks


There is one side affect: MOVing does not affect the flags, but XORing does. The 8088 aficianado will only move a zero into a register in the rare cases where the flags must be preserved.

## 3. Incrementing, Decrementing

It is smaller to increment or decrement a 16 bit register then an 8 bit register, so if it doesnt matter, use a 16 bit register, e.g.:

    INC     DX              ; 1 byte, 3 clocks


is smaller than:

    INC     DL              ; 2 bytes, 3 clocks


Same thing goes for decrementing, its smaller to use a 16 bit register.

Its smaller (but not faster) to increment a register twice then to add 2 to it, e.g.

INC     DX              ; 1 byte,  3 clocks (total)
INC     DX              ; 2 bytes, 6 clocks


is smaller and slower than:

ADD     DX,2            ; 3 bytes, 4 clocks


One side affect: INC and DEC do not affect the carry flag, ADD does.

## 4. If Then Else

When confronted with an If, Then, Else problem the assembly language programmer will often write it as Else, If, Then. For example, a sample problem might be to return 123H in the DX register if AL<5, otherwise return zero in DX. Using If, Then, Else produces:

 CMP     AL,5                ; Is AL less than 5?
JB      ALisBelow5          ; yes...
XOR     DX,DX               ; Set DX to zero if AL>=5
JMP     SHORT Continue      ; proceed  ALisBelow5:
MOV     DX,123H             ; Set DX to 80H if AL<5 Continue:


Using Else, If, Then:

 MOV     DX,123H             ; Set DX to 80H if AL<5
CMP     AL,5                ; Is AL less than 5?
JB      ALisBelow5          ; yes...
XOR     DX,DX               ; Set DX to zero if AL>=5 ALisBelow5:


The idea is to do the work for the most likely case, then do the comparision. If you were right you’re all done, if not then do the other case.

## 5. Copying strings

One of the simplest ways to copy a null terminated string is as follows:

; ; DS:SI points at source ; ES:DI points at destination ; CopyString: LODSB ; read character into AL, inc SI STOSB ; store charcter, increment DI OR AL,AL ; was it the null JNZ CopyString ; no, repeat

A fast way to copy a string where the count is known is

SHR     CX,1    ; divide count by two (2 bytes = 1 word)
REP     MOVSW   ; move the first part fast
JNC     Even    ; No carry if count was even
MOVSB           ; move the odd byte Even:


Slightly faster but slightly bigger is:

SHR     CX,1    ; Get the word count
REP     MOVSW   ; move the words, leaving CX = 0
RCL     CX,1    ; if count was odd make CX = 1
REP     MOVSB   ; (possibly) move last byte


This is slightly faster because there is no jump to empty the prefetch queue.

The REP instruction checks to see if the loop count in CX is zero before starting, there is no need to check it beforehand.

## 6. Testing long pointer for null

Sometimes its necessary to check if a long pointer is null before using it. A sequence of code that works well is:

 LES     DI,[LongPointer]        ; get the long pointer
MOV     CX,ES                   ; copy ES to CX
JCXZ    PointerIsNull           ; if zero, dont use it


This assumes segment zero is an invalid pointer.

## 7. Exchanging

To move a register to or from AX takes 2 bytes and 2 clocks

MOV     AX,DX           ; 2 bytes, 2 clocks


However, to exchange a register with the AX register takes 1 byte and 3 clocks:

XCHG    AX,DX           ; 1 byte, 3 clocks


A clear case where its possible to optimize for size or speed. This optimization is only available with the AX register. A full understanding is actually more complex. Although XCHG takes 3 clocks it is often faster because it only uses one byte of the prefetch queue.

## 8. Testing bits

The 8088 contains an instruction that allows you to test various bits. It works by doing a non destructive AND operation.

TEST    AX,0800H        ; 4 bytes, 5 clocks
JZ      BitIsOff


If one of the bytes is zero (a common occurence) this can be optimized to:

TEST    AH,08H          ; 3 bytes, 4 clocks
JZ      BitIsOff


The best way to test the hi bit is:

OR      AX,AX           ; 2 bytes, 2 clocks
JNS     HiBitIsOff      ; jump not signed (hi bit zero)


A destructive way to test the low order bit is to shift it to the right into the carry flag:

SHR     AX,1            ; 2 bytes, 2 clocks
JNC     LoBitIsOff


You can test multiple bits with the TEST instruction:

TEST    BL,11000000b    ; check 2 highest bits
JZ      BothAreZero     ; if zero, both are zero


Sometimes you want to jump if either are zero instead of both zero, this can usually be accomplished by the NOT instruction and reversing the sense of the jump instruction:

NOT     BL              ; reverse the bits
TEST    BL,11000000b    ; check 2 highest bits
JNZ     EitherAreZero   ; if either were zero, then this
; is non zero


## 9. Absolute value

A fascinating way to get the absolute value of the AX register was discovered by Marlin Eller:

CWD             ; replicate hi order bit of AX into DX
XOR     AX,DX   ; do a 1's complement or do nothing
SUB     AX,DX   ; add 1 to get a 2's complement


The boring method does not affect the DX register and can be used on any register:

OR      BX,BX   ; never CMP BX,0!
JGE     NotNeg  ; if negative...
NEG     BX      ; ...make it positive NotNeg:


The boring method empties the prefetch queue with the JGE instruction, making it much slower.

## 10. Length of null terminated string

To get the length of a null terminated string, scan for the null at the end with a starting count of -1

; ; ES:DI points at null terminated string ; XOR AL,AL ; look for null 2 bytes (total) MOV CX,-1 ; CX = -1 5 bytes REPNE SCASB ; CX = -len-2 7 bytes NOT CX ; CX = len+1 9 bytes DEC CX ; CX = len 10 bytes

This count does not include the null at the end. If you want it to include the null, just delete the final DEC CX. The use of the NOT instruction is quite interesting here.

## 11. Returning flags

The 8088 contains instructions for setting (STC) and clearing (CLC) the carry flag. To set the zero flag, simply compare some register with itself:

CMP     DX,DX            ; set zero flag


To clear the zero flag, OR the stack pointer with itself:

OR      SP,SP           ; clear zero flag


This is making the safe assumption that the stack pointer is not zero.

## 12. Shifting

Variable count shifting is slow on the 8088. Its faster to shift twice then to set a count of 2:

SHR     AX,1    ; 2 bytes, 2 clocks  (total)
SHR     AX,1    ; 4 bytes, 4 clocks


is much faster than:

MOV     CL,2    ; 2 bytes,  4 clocks  (total)
SHR     AX,CL   ; 4 bytes, 20 clocks!


Variable count shifting is slower when shifting less than 5 bits, after that the prefetch queue makes variable shift counts faster.

## 13. Multiply and Divide

The multiply and divide instruction are some of the slowest instructions on the 8088. To give some perspective, a register to register MOV instruction takes 2 clocks, while a signed divide (IDIV) using registers can take 184 clocks.

If your goal is to write fast 8088 code, multiplying by constants can usually be done as a series of shifts and adds:

;
;  Multiply the AX register by 10
;
SHL     AX,1            ; AX = AX *  2    ( 2 clocks)
MOV     BX,AX           ; BX = AX *  2    ( 4 clocks)
SHL     AX,1            ; AX = AX *  4    ( 6 clocks)
SHL     AX,1            ; AX = AX *  8    ( 8 clocks)
ADD     AX,BX           ; AX = AX * 10    (11 clocks)


A multiply would be more than 10 times slower, but would take fewer bytes. Multiply is useful when neither argument is constant or you need to save bytes.

Mark Zbikowski uses this method to divide the AX register by 512:

SHR     AX,1         ; divide AX by 2
XCHG    AL,AH        ; divide AX by 512 (AX is unsigned)
CBW                  ; AL < 128, so this sets AH to 0


## 14. Converting bytes to segments

To convert a byte count to a paragraph count try:

;
;  DX contains a byte count
;
ADD     DX,15       ; round up to next paragraph
MOV     CL,4        ; 2^4 = 16 bytes per paragraph
SHR     DX,CL       ; divide by 16 by shifting 4 times


DX now contains a paragraph count. This assumes the value in DX is less than 0FFF1H. To cover the extended case:

ADD  DX,15        ; round up to next paragraph
RCR  DX,1         ; divide by 2, including carry
MOV  CL,3         ; 2^3 = 8
SHR  DX,CL        ; divide by a total of 16


## 15. Call, Return, Jump

A near call followed by a near return can always be replaced with a near jump:

JMP NearProc  ; 3 bytes, 15 clocks


is smaller and much faster than:

CALL  NearProc  ; 3 bytes, 19 clocks (total)
RET     ; 4 bytes, 35 clocks


Its often possible to eliminate the JMP entirely by moving the subroutines adjacent to each other.

Conditional jumps on the 8088 are always short, i.e. the destination must be within -128 to 127 of the instruction pointer. It seems every time a single line of new code is added some conditional jump becomes out of range. One technique to get around this is to find a similiar conditional jump to jump to:

JC      OutOfRange     ; I want to jump to disk error...
...                    ; ...but its too far away, so...


OutOfRange:

JC      DiskError      ; I jump to this test for carry


Although this is not in the scope of this document, out of range jumps are usually the 8088 telling you that your subroutines have grown too large and should be broken up.

## 16. Multiple Entry Points

An old 8080 trick involving multiple entry points can be adapted to the 8088. Instead of doing this:

Entry1:
MOV     AL,1                    ; 2 bytes (total)
JMP     SHORT EntryCommon       ; 4 bytes
Entry2:
MOV     AL,2                    ; 6 bytes
JMP     SHORT EntryCommon       ; 8 bytes
Entry3:
MOV     AL,3                    ;10 bytes
EntryCommon:


The hearty and brave will do this:

Entry1:
MOV     AL,1                    ; 2 bytes (total)
DB      03DH                    ; 3 bytes
Entry2:
MOV     AL,2                    ; 5 bytes
DB      03DH                    ; 6 bytes
Entry3:
MOV     AL,3                    ; 8 bytes
EntryCommon:                        ; flags are modified


The DB 03DH is the opcode for a CMP AX,xx. In this case the bogus CMP AX’s are used to swallow up the MOV AL,x that follow.

A special case of this discovered by Pat Tharp optimizes for dual entry points:

TrueEntry:      ; come here to set AX = TRUE
DB  0B8H      ; (opcode for MOV AX,...)
FalseEntry:     ; come here to set AX = FALSE
XOR     AX,AX   ; AX = 0 = FALSE


Whats happening here is that the 0B8H is the opcode for MOV AX,### which will put the opcode for the XOR AX,AX (nonzero C031H) in AX. This is a clear win of 3 bytes over the boring method:

TrueEntry:
MOV     AL,1    ; set AX nonzero
JMP     SHORT EntryCommon
FalseEntry:
XOR     AX,AX   ; set AX zero
EntryCommon:


## 17. Assertion Macros

When using these advanced techniques its important not to expose yourself to bugs caused by changing constants in your program. For instance, in the Multiply and Divide section of this document there is a code to quickly multiply by ten. If the constant should later change from ten to twelve this code would no longer work. An assertion macro would flag this code as being in error, saving many hours of needless debugging. In cannot be stressed to strongly that advanced 8088 programming requires liberal use of assertion macros and extra documentation.