You are on page 1of 2

“reg” Field Bit Assignments: MOV – MOVE (BYTE OR WORD)

16-Bit 8-Bit Direction:


Segment
(w=1) (w=0) D=0 SRC=REG Operation (DEST) (SRC)


000 AX 000 AL 00 ES D=1 DST=REG Flags Affected None
001 CX 001 CL 01 CS
Description MOV destination, source
010 DX 010 DL 10 SS
011 BX 011 BL 11 DS Word:
W=0 8-Bit MOVE transfers a byte or a word from the source operand to
100 SP 100 AH the destination operand.
101 BP 101 CH W=1 16-Bit
110 SI 110 DH Encoding
111 DI 111 BH mod reg r/m
Memory or Register Operand to/from Register Operand
1 0 0 0 1 0 d w mod reg r/m data low data high
“mod” Field Bit Assignments: If d = 1 then SRC = EA, DEST = REG, else SRC = REG, DEST = EA.
mod Displacement
00 DISP = 0*, disp-low and disp-high are absent Immediate Operand to Memory or Register Operand
01 DISP = disp-low sign-extended to 16-bits, disp-high is absent 1 1 0 0 0 1 1 w mod 0 0 0 r/m Data data if w=1
10 DISP = disp-high:disp-low SRC = data, DEST = EA.
11 r/m is treated as “reg” field
DISP follows 2nd byte of instruction (before data if required). Immediate Operand to Register
*except if mod = 00 and r/m = 110 then EA = disp-high:disp-low 1 0 1 1 w reg data data if w=1
SRC = data, DEST = REG.
“r/m” Field Bit Assignments: Memory Operand to Accumulator
r/m Operand Address 1 0 1 0 0 0 0 w addr-low addr-high
000 (BX) + (SI) + DISP If w = 0 then SRC = addr, DEST = AL, else SRC = addr + 1:addr, DEST = AX.
001 (BX) + (DI) + DISP
010 (BP) + (SI) + DISP Accumulator to Memory Operand
011 (BP) + (DI) + DISP 1 0 1 0 0 0 1 w addr-low addr-high
100 (SI) + DISP If w = 0 then SRC = AL, DEST = addr, else SRC = AX, DEST = addr + 1:addr.
101 (DI) + DISP
110 (BP) + DISP Memory or Register Operand to/from Segment Register
111 (BX) + DISP 1 0 0 0 1 1 d 0 mod 0 reg r/m
d must be set such that segment register is encoded by 2-bit reg field. CS cannot be DST.
Table 3-14 Effective Address Calculation Time
EA Components Clocks MOV Operands Clocks Transfers Bytes MOV Coding Example
Displacement Only 6 memory, accumulator 10 1 3 MOV ARRAY, AL
accumulator, memory 10 1 3 MOV AX, TEMP_RESULT
Base or Index Only (BX,BP,SI,DI) 5
register, register 2 - 2 MOV AX, CX
Disp + Base or Index (BX,BP,SI,DI) + DISP 9 MOV BP, STACK_TOP
register, memory 8 + EA 1 2-4
BP + DI, BX + SI 7 memory, register 9 + EA 1 2-4 MOV COUNT[DI], CX
Base + Index
BP + SI, BX + DI 8 register, immediate 4 - 2-3 MOV CL, 2
BP + DI + DISP memory, immediate 10 + EA 1 3-6 MOV MASK[BX][SI], 2CH
11
BX + SI + DISP seg-reg, reg16 2 - 2 MOV ES, CX
Disp + Base + Index
BP + SI + DISP seg-reg, mem16 8 + EA 1 2-4 MOV DS, SEGMENT_BASE
12
BX + DI + DISP reg16, seg-reg 2 - 2 MOV BP, SS
memory, seg-reg 9 + EA 1 2-4 MOV [BX]SEG_SAVE,CS
ADD – ADDITION DEC – DECREMENT
Operation (DEST) (LSRC) + (RSRC) Operation (DEST) (DEST) – 1


Flags AF, CF, OF, PF, SF, ZF Flags AF, OF, PF, SF, ZF
Affected Affected
Description ADD destination, source Description DEC (Decrement) subtracts one from the destination operand. The
operand may be a byte or a word and is treated as an unsigned
The sum of the two operands, which may be bytes or words, binary number (see AA and DAA). DEC updates AF, OF, PF, SF
replaces the destination operand. Both operands may be signed or and ZF; it does not affect CF.
unsigned binary numbers (see AAA and DAA). ADD updates AF,
CF, OF, PF, SF and ZF.
Encoding Encoding
Memory or Register Operand with Register Operand
8-bit Register or Memory
0 0 0 0 0 0 d w mod reg r/m data low data high
1 1 1 1 1 1 1 w mod 0 0 1 r/m
If d=1 then LSRC = REG, RSRC = EA, DEST = REG, DEST = EA.
else LSRC = EA, RSRC = REG, DEST = EA.

Immediate Operand to Memory or Register Operand 16-bit Register Operand


0 1 0 0 1 reg
1 0 0 0 0 0 s w mod 0 0 0 r/m data data if w=1
DEST = REG.
LSRC = EA, RSRC = data, DEST = EA.

Immediate Operand to Accumulator DEC Operands Clocks Transfers Bytes ADD Coding Example
0 0 0 0 0 1 0 w data data if w=1 reg16 3 - 1 DEC AX
If w=0 then LSRC = AL, RSRC = data, DEST = AL, reg8 3 - 2 DEC AL
else LSRC = AX, RSRC = data, DEST = AX. memory 15 + EA 2 2-4 DEC ARRAY[SI]

ADD Operands Clocks Transfers Bytes ADD Coding Example


register,register 3 - 2 ADD CX, DX
register,memory 9 + EA 1 2-4 ADD DI, [BX]ALPHA JNE – JUMP ON NOT EQUAL / JNZ – JUMP ON NOT ZERO
memory,register 16 + EA 2 2-4 ADD TEMP, CL
Operation If (ZF) = 0 then (IP) (IP) + disp (sign extended to 16-bits)


register,immediate 4 - 3-4 ADD CL,2 Flags none
memory,immediate 17 + EA 2 3-6 ADD ALPHA,2 Affected
accumulator,immediate 4 - 2-3 MOV AX, 200 Description JNE (Jump on Not Equal to)/JNZ (Jump on Not Zero) transfers
control to the target operand (IP + displacement) if the condition
tested (ZF = 0) is true.

Encoding
0 1 1 1 0 1 0 1 Disp

JNE/JNZ Operands Clocks Transfers Bytes ADD Coding Example


Short-label 16 or 4 - 2 JNE NOT_EQUAL