AAA AAD AAM AAS ADC ADD AND CALL CBW CLC CLD CLI CMC CMP |
CMPSB CMPSW CWD DAA DAS DEC DIV IDIV IMUL IN INC INT INTO IRET JA |
JAE JB JBE JC JCXZ JE JG JGE JL JLE JMP JNA JNAE JNB |
JNBE JNC JNE JNG JNGE JNL JNLE JNO JNP JNS JNZ JO JP JPE |
JPO JS JZ LAHF LDS LEA LES LODSB LODSW LOOP LOOPE LOOPNE LOOPNZ LOOPZ |
MOV MOVSB MOVSW MUL NEG NOP OR OUT POP POPA POPF PUSH PUSHA PUSHF RCL |
RCR REP REPE REPNE REPNZ REPZ RET RETF ROL ROR SAHF SAL SAR SBB |
SCASB SCASW SHL SHR STC STD STI STOSB STOSW SUB TEST XCHG XLATB XOR |
include 'emu8086.inc' ORG 100h MOV AL, 1 MOV BL, 2 PRINTN 'Hello World!' ; macro. MOV CL, 3 PRINTN 'Welcome!' ; macro. RET
Instruction | Operands | Description |
AAA | No operands |
ASCII Adjust after Addition. Corrects result in AH and AL after addition when working with BCD values. It works according to the following Algorithm: if low nibble of AL > 9 or AF = 1 then:
clear the high nibble of AL. Example: MOV AX, 15 ; AH = 00, AL = 0Fh AAA ; AH = 01, AL = 05 RET |
AAD | No operands |
ASCII Adjust before Division. Prepares two BCD values for division. Algorithm:
Example: MOV AX, 0105h ; AH = 01, AL = 05 AAD ; AH = 00, AL = 0Fh (15) RET |
AAM | No operands |
ASCII Adjust after Multiplication. Corrects the result of multiplication of two BCD values. Algorithm:
Example: MOV AL, 15 ; AL = 0Fh AAM ; AH = 01, AL = 05 RET |
AAS | No operands |
ASCII Adjust after Subtraction. Corrects result in AH and AL after subtraction when working with BCD values. Algorithm: if low nibble of AL > 9 or AF = 1 then:
clear the high nibble of AL. Example: MOV AX, 02FFh ; AH = 02, AL = 0FFh AAS ; AH = 01, AL = 09 RET |
ADC |
memory, REG REG, REG memory, immediate REG, immediate |
Add with Carry. Algorithm: operand1 = operand1 + operand2 + CF Example: STC ; set CF = 1 MOV AL, 5 ; AL = 5 ADC AL, 1 ; AL = 7 RET |
ADD |
memory, REG REG, REG memory, immediate REG, immediate |
Add. Algorithm: operand1 = operand1 + operand2 Example: MOV AL, 5 ; AL = 5 ADD AL, -3 ; AL = 2 RET |
AND |
memory, REG REG, REG memory, immediate REG, immediate |
Logical AND between all bits of two operands. Result is stored in operand1. These rules apply: 1 AND 1 = 1 1 AND 0 = 0 0 AND 1 = 0 0 AND 0 = 0 Example: MOV AL, 'a' ; AL = 01100001b AND AL, 11011111b ; AL = 01000001b ('A') RET |
CALL |
label 4-byte address |
Transfers control to procedure, return address is (IP) is pushed to
stack. 4-byte address may be entered in this form:
1234h:5678h, first value is a segment second
value is an offset (this is a far call, so CS is also pushed to stack). Example: ORG 100h ; for COM file. CALL p1 ADD AX, 1 RET ; return to OS. p1 PROC ; procedure declaration. MOV AX, 1234h RET ; return to caller. p1 ENDP |
CBW | No operands |
Convert byte into word. Algorithm: if high bit of AL = 1 then:
else
Example: MOV AX, 0 ; AH = 0, AL = 0 MOV AL, -5 ; AX = 000FBh (251) CBW ; AX = 0FFFBh (-5) RET |
CLC | No operands |
Clear Carry flag. Algorithm: CF = 0 |
CLD | No operands |
Clear Direction flag. SI and DI will be incremented by chain
instructions: CMPSB, CMPSW, LODSB, LODSW, MOVSB, MOVSW, STOSB, STOSW. Algorithm: DF = 0 |
CLI | No operands |
Clear Interrupt enable flag. This disables hardware interrupts. Algorithm: IF = 0 |
CMC | No operands |
Complement Carry flag. Inverts value of CF. Algorithm: if CF = 1 then CF = 0 if CF = 0 then CF = 1 |
CMP |
memory, REG REG, REG memory, immediate REG, immediate |
Compare.
Algorithm: operand1 - operand2 result is not stored anywhere, flags are set (OF, SF, ZF, AF, PF, CF) according to result. Example: MOV AL, 5 MOV BL, 5 CMP AL, BL ; AL = 5, ZF = 1 (so equal!) RET |
CMPSB | No operands |
Compare bytes: Algorithm:
see cmpsb.asm in Samples. |
CMPSW | No operands |
Compare words: Algorithm:
see cmpsw.asm in Samples. |
CWD | No operands |
Convert Word to Double word. Algorithm: if high bit of AX = 1 then:
else
Example: MOV DX, 0 ; DX = 0 MOV AX, 0 ; AX = 0 MOV AX, -5 ; DX AX = 00000h:0FFFBh CWD ; DX AX = 0FFFFh:0FFFBh RET |
DAA | No operands |
Decimal adjust After Addition. Corrects the result of addition of two packed BCD values. Algorithm: if low nibble of AL > 9 or AF = 1 then:
Example: MOV AL, 0Fh ; AL = 0Fh (15) DAA ; AL = 15h RET |
DAS | No operands |
Decimal adjust After Subtraction. Corrects the result of subtraction of two packed BCD values. Algorithm: if low nibble of AL > 9 or AF = 1 then:
Example: MOV AL, 0FFh ; AL = 0FFh (-1) DAS ; AL = 99h, CF = 1 RET |
DEC |
memory |
Decrement.
Algorithm: operand = operand - 1 Example: MOV AL, 255 ; AL = 0FFh (255 or -1) DEC AL ; AL = 0FEh (254 or -2) RET |
DIV |
memory |
Unsigned divide.
Algorithm: when operand is a byte: when operand is a word:Example: MOV AX, 203 ; AX = 00CBh MOV BL, 4 DIV BL ; AL = 50 (32h), AH = 3 RET |
IDIV |
memory |
Signed divide.
Algorithm: when operand is a byte: when operand is a word:Example: MOV AX, -203 ; AX = 0FF35h MOV BL, 4 IDIV BL ; AL = -50 (0CEh), AH = -3 (0FDh) RET |
IMUL |
memory |
Signed multiply.
Algorithm: when operand is a byte: when operand is a word:Example: MOV AL, -2 MOV BL, -4 IMUL BL ; AX = 8 RET |
IN |
AL, DX AX, im.byte AX, DX |
Input from port into AL or AX. Second operand is a port number. If required to access port number over 255 - DX register should be used. Example: IN AX, 4 ; get status of traffic lights. IN AL, 7 ; get status of stepper-motor. |
INC |
memory |
Increment.
Algorithm: operand = operand + 1 Example: MOV AL, 4 INC AL ; AL = 5 RET |
INT |
|
Interrupt numbered by immediate byte (0..255).
Algorithm:
Example: MOV AH, 0Eh ; teletype. MOV AL, 'A' INT 10h ; BIOS interrupt. RET |
INTO | No operands |
Interrupt 4 if Overflow flag is 1.
Algorithm: if OF = 1 then INT 4 Example: ; -5 - 127 = -132 (not in -128..127) ; the result of SUB is wrong (124), ; so OF = 1 is set: MOV AL, -5 SUB AL, 127 ; AL = 7Ch (124) INTO ; process error. RET |
IRET | No operands |
Interrupt Return.
Algorithm:
|
JA |
|
Short Jump if first operand is Above second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 250 CMP AL, 5 JA label1 PRINT 'AL is not above 5' JMP exit label1: PRINT 'AL is above 5' exit: RET |
JAE |
|
Short Jump if first operand is Above or Equal to second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 CMP AL, 5 JAE label1 PRINT 'AL is not above or equal to 5' JMP exit label1: PRINT 'AL is above or equal to 5' exit: RET |
JB |
|
Short Jump if first operand is Below second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 1 CMP AL, 5 JB label1 PRINT 'AL is not below 5' JMP exit label1: PRINT 'AL is below 5' exit: RET |
JBE |
|
Short Jump if first operand is Below or Equal to second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 CMP AL, 5 JBE label1 PRINT 'AL is not below or equal to 5' JMP exit label1: PRINT 'AL is below or equal to 5' exit: RET |
JC |
|
Short Jump if Carry flag is set to 1.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 255 ADD AL, 1 JC label1 PRINT 'no carry.' JMP exit label1: PRINT 'has carry.' exit: RET |
JCXZ |
|
Short Jump if CX register is 0.
Algorithm:
include 'emu8086.inc' ORG 100h MOV CX, 0 JCXZ label1 PRINT 'CX is not zero.' JMP exit label1: PRINT 'CX is zero.' exit: RET |
JE |
|
Short Jump if first operand is Equal to second operand (as set by CMP instruction).
Signed/Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 CMP AL, 5 JE label1 PRINT 'AL is not equal to 5.' JMP exit label1: PRINT 'AL is equal to 5.' exit: RET |
JG |
|
Short Jump if first operand is Greater then second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 CMP AL, -5 JG label1 PRINT 'AL is not greater -5.' JMP exit label1: PRINT 'AL is greater -5.' exit: RET |
JGE |
|
Short Jump if first operand is Greater or Equal to second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, -5 JGE label1 PRINT 'AL < -5' JMP exit label1: PRINT 'AL >= -5' exit: RET |
JL |
|
Short Jump if first operand is Less then second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, -2 CMP AL, 5 JL label1 PRINT 'AL >= 5.' JMP exit label1: PRINT 'AL < 5.' exit: RET |
JLE |
|
Short Jump if first operand is Less or Equal to second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, -2 CMP AL, 5 JLE label1 PRINT 'AL > 5.' JMP exit label1: PRINT 'AL <= 5.' exit: RET |
JMP |
4-byte address |
Unconditional Jump.
Transfers control to another part of the program.
4-byte address may be entered in this form:
1234h:5678h, first value is a segment second
value is an offset. Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 JMP label1 ; jump over 2 lines! PRINT 'Not Jumped!' MOV AL, 0 label1: PRINT 'Got Here!' RET |
JNA |
|
Short Jump if first operand is Not Above second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, 5 JNA label1 PRINT 'AL is above 5.' JMP exit label1: PRINT 'AL is not above 5.' exit: RET |
JNAE |
|
Short Jump if first operand is Not Above and Not Equal to second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, 5 JNAE label1 PRINT 'AL >= 5.' JMP exit label1: PRINT 'AL < 5.' exit: RET |
JNB |
|
Short Jump if first operand is Not Below second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 7 CMP AL, 5 JNB label1 PRINT 'AL < 5.' JMP exit label1: PRINT 'AL >= 5.' exit: RET |
JNBE |
|
Short Jump if first operand is Not Below and Not Equal to second operand (as set by CMP instruction).
Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 7 CMP AL, 5 JNBE label1 PRINT 'AL <= 5.' JMP exit label1: PRINT 'AL > 5.' exit: RET |
JNC |
|
Short Jump if Carry flag is set to 0.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 ADD AL, 3 JNC label1 PRINT 'has carry.' JMP exit label1: PRINT 'no carry.' exit: RET |
JNE |
|
Short Jump if first operand is Not Equal to second operand (as set by CMP instruction).
Signed/Unsigned.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, 3 JNE label1 PRINT 'AL = 3.' JMP exit label1: PRINT 'Al <> 3.' exit: RET |
JNG |
|
Short Jump if first operand is Not Greater then second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, 3 JNG label1 PRINT 'AL > 3.' JMP exit label1: PRINT 'Al <= 3.' exit: RET |
JNGE |
|
Short Jump if first operand is Not Greater and Not Equal to second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, 3 JNGE label1 PRINT 'AL >= 3.' JMP exit label1: PRINT 'Al < 3.' exit: RET |
JNL |
|
Short Jump if first operand is Not Less then second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, -3 JNL label1 PRINT 'AL < -3.' JMP exit label1: PRINT 'Al >= -3.' exit: RET |
JNLE |
|
Short Jump if first operand is Not Less and Not Equal to second operand (as set by CMP instruction).
Signed.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 2 CMP AL, -3 JNLE label1 PRINT 'AL <= -3.' JMP exit label1: PRINT 'Al > -3.' exit: RET |
JNO |
|
Short Jump if Not Overflow.
Algorithm:
; -5 - 2 = -7 (inside -128..127) ; the result of SUB is correct, ; so OF = 0: include 'emu8086.inc' ORG 100h MOV AL, -5 SUB AL, 2 ; AL = 0F9h (-7) JNO label1 PRINT 'overflow!' JMP exit label1: PRINT 'no overflow.' exit: RET |
JNP |
|
Short Jump if No Parity (odd). Only 8 low bits of result are checked.
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000111b ; AL = 7 OR AL, 0 ; just set flags. JNP label1 PRINT 'parity even.' JMP exit label1: PRINT 'parity odd.' exit: RET |
JNS |
|
Short Jump if Not Signed (if positive).
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000111b ; AL = 7 OR AL, 0 ; just set flags. JNS label1 PRINT 'signed.' JMP exit label1: PRINT 'not signed.' exit: RET |
JNZ |
|
Short Jump if Not Zero (not equal).
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000111b ; AL = 7 OR AL, 0 ; just set flags. JNZ label1 PRINT 'zero.' JMP exit label1: PRINT 'not zero.' exit: RET |
JO |
|
Short Jump if Overflow.
Algorithm:
; -5 - 127 = -132 (not in -128..127) ; the result of SUB is wrong (124), ; so OF = 1 is set: include 'emu8086.inc' org 100h MOV AL, -5 SUB AL, 127 ; AL = 7Ch (124) JO label1 PRINT 'no overflow.' JMP exit label1: PRINT 'overflow!' exit: RET |
JP |
|
Short Jump if Parity (even). Only 8 low bits of result are checked.
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000101b ; AL = 5 OR AL, 0 ; just set flags. JP label1 PRINT 'parity odd.' JMP exit label1: PRINT 'parity even.' exit: RET |
JPE |
|
Short Jump if Parity Even. Only 8 low bits of result are checked.
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000101b ; AL = 5 OR AL, 0 ; just set flags. JPE label1 PRINT 'parity odd.' JMP exit label1: PRINT 'parity even.' exit: RET |
JPO |
|
Short Jump if Parity Odd. Only 8 low bits of result are checked.
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 00000111b ; AL = 7 OR AL, 0 ; just set flags. JPO label1 PRINT 'parity even.' JMP exit label1: PRINT 'parity odd.' exit: RET |
JS |
|
Short Jump if Signed (if negative).
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 10000000b ; AL = -128 OR AL, 0 ; just set flags. JS label1 PRINT 'not signed.' JMP exit label1: PRINT 'signed.' exit: RET |
JZ |
|
Short Jump if Zero (equal).
Set by CMP, SUB, ADD, TEST, AND, OR, XOR instructions.
Algorithm:
include 'emu8086.inc' ORG 100h MOV AL, 5 CMP AL, 5 JZ label1 PRINT 'AL is not equal to 5.' JMP exit label1: PRINT 'AL is equal to 5.' exit: RET |
LAHF | No operands |
Load AH from 8 low bits of Flags register.
Algorithm:
AH bit: 7 6 5 4 3 2 1 0 [SF] [ZF] [0] [AF] [0] [PF] [1] [CF]bits 1, 3, 5 are reserved. |
LDS |
|
Load memory double word into word register and DS.
Algorithm:
Example: ORG 100h LDS AX, m RET m DW 1234h DW 5678h ENDAX is set to 1234h, DS is set to 5678h. |
LEA |
|
Load Effective Address.
Algorithm:
Generally this instruction is replaced by MOV when assembling when possible. Example: ORG 100h LEA AX, m RET m DW 1234h ENDAX is set to: 0104h. LEA instruction takes 3 bytes, RET takes 1 byte, we start at 100h, so the address of 'm' is 104h. |
LES |
|
Load memory double word into word register and ES.
Algorithm:
Example: ORG 100h LES AX, m RET m DW 1234h DW 5678h ENDAX is set to 1234h, ES is set to 5678h. |
LODSB | No operands |
Load byte at DS:[SI] into AL. Update SI. Algorithm:
|
LODSW | No operands |
Load word at DS:[SI] into AX. Update SI. Algorithm:
|
LOOP |
|
Decrease CX, jump to label if CX not zero. Algorithm:
include 'emu8086.inc' ORG 100h MOV CX, 5 label1: PRINTN 'loop!' LOOP label1 RET |
LOOPE |
|
Decrease CX, jump to label if CX not zero and Equal (ZF = 1). Algorithm:
; Loop until result fits into AL alone, ; or 5 times. The result will be over 255 ; on third loop (100+100+100), ; so loop will exit. include 'emu8086.inc' ORG 100h MOV AX, 0 MOV CX, 5 label1: PUTC '*' ADD AX, 100 CMP AH, 0 LOOPE label1 RET |
LOOPNE |
|
Decrease CX, jump to label if CX not zero and Not Equal (ZF = 0). Algorithm:
; Loop until '7' is found, ; or 5 times. include 'emu8086.inc' ORG 100h MOV SI, 0 MOV CX, 5 label1: PUTC '*' MOV AL, v1[SI] INC SI ; next byte (SI=SI+1). CMP AL, 7 LOOPNE label1 RET v1 db 9, 8, 7, 6, 5 |
LOOPNZ |
|
Decrease CX, jump to label if CX not zero and ZF = 0. Algorithm:
; Loop until '7' is found, ; or 5 times. include 'emu8086.inc' ORG 100h MOV SI, 0 MOV CX, 5 label1: PUTC '*' MOV AL, v1[SI] INC SI ; next byte (SI=SI+1). CMP AL, 7 LOOPNZ label1 RET v1 db 9, 8, 7, 6, 5 |
LOOPZ |
|
Decrease CX, jump to label if CX not zero and ZF = 1. Algorithm:
; Loop until result fits into AL alone, ; or 5 times. The result will be over 255 ; on third loop (100+100+100), ; so loop will exit. include 'emu8086.inc' ORG 100h MOV AX, 0 MOV CX, 5 label1: PUTC '*' ADD AX, 100 CMP AH, 0 LOOPZ label1 RET |
MOV |
memory, REG REG, REG memory, immediate REG, immediate SREG, memory memory, SREG REG, SREG SREG, REG |
Copy operand2 to operand1. The MOV instruction cannot:
Algorithm: operand1 = operand2Example: ORG 100h MOV AX, 0B800h ; set AX = B800h (VGA memory). MOV DS, AX ; copy value of AX to DS. MOV CL, 'A' ; CL = 41h (ASCII code). MOV CH, 01011111b ; CL = color attribute. MOV BX, 15Eh ; BX = position on screen. MOV [BX], CX ; w.[0B800h:015Eh] = CX. RET ; returns to operating system. |
MOVSB | No operands |
Copy byte at DS:[SI] to ES:[DI].
Update SI and DI. Algorithm:
|
MOVSW | No operands |
Copy byte at DS:[SI] to ES:[DI].
Update SI and DI. Algorithm:
|
MUL |
memory |
Unsigned multiply.
Algorithm: when operand is a byte: when operand is a word:Example: MOV AL, 200 ; AL = 0C8h MOV BL, 4 MUL BL ; AX = 0320h (800) RET |
NEG |
memory |
Negate. Makes operand negative (two's complement).
Algorithm:
MOV AL, 5 ; AL = 05h NEG AL ; AL = 0FBh (-5) NEG AL ; AL = 05h (5) RET |
NOP | No operands |
No Operation. Algorithm:
NOP NOP NOP RET |
OR |
memory, REG REG, REG memory, immediate REG, immediate |
Logical OR between all bits of two operands.
Result is stored in first operand. These rules apply: 1 OR 1 = 1 1 OR 0 = 1 0 OR 1 = 1 0 OR 0 = 0 Example: MOV AL, 'A' ; AL = 01000001b OR AL, 00100000b ; AL = 01100001b ('a') RET |
OUT |
im.byte, AX DX, AL DX, AX |
Output from AL or AX to port. First operand is a port number. If required to access port number over 255 - DX register should be used. Example: MOV AX, 0FFFh ; Turn on all OUT 4, AX ; traffic lights. MOV AL, 100b ; Turn on the third OUT 7, AL ; magnet of the stepper-motor. |
POP |
SREG memory |
Get 16 bit value from the stack.
Algorithm:
Example: MOV AX, 1234h PUSH AX POP DX ; DX = 1234h RET |
POPA | No operands |
Pop all general purpose registers DI, SI, BP, SP, BX, DX, CX, AX from the stack. SP value is ignored, it is Popped but not set to SP register). Note: this instruction works only on 80186 CPU and later! Algorithm:
|
POPF | No operands |
Get flags register from the stack.
Algorithm:
|
PUSH |
SREG memory immediate |
Store 16 bit value in the stack. Note: PUSH immediate works only on 80186 CPU and later! Algorithm:
Example: MOV AX, 1234h PUSH AX POP DX ; DX = 1234h RET |
PUSHA | No operands |
Push all general purpose registers AX, CX, DX, BX, SP, BP, SI, DI in the stack. Original value of SP register (before PUSHA) is used. Note: this instruction works only on 80186 CPU and later! Algorithm:
|
PUSHF | No operands |
Store flags register in the stack.
Algorithm:
|
RCL |
|
Rotate operand1 left through Carry Flag. The number of rotates is set by operand2.
When immediate is greater then 1, assembler generates several RCL xx, 1 instructions because 8086 has machine code only for this instruction (the same principle works for all other shift/rotate instructions). Algorithm:
Example: STC ; set carry (CF=1). MOV AL, 1Ch ; AL = 00011100b RCL AL, 1 ; AL = 00111001b, CF=0. RET |
RCR |
|
Rotate operand1 right through Carry Flag. The number of rotates is set by operand2.
Algorithm:
Example: STC ; set carry (CF=1). MOV AL, 1Ch ; AL = 00011100b RCR AL, 1 ; AL = 10001110b, CF=0. RET |
REP |
|
Repeat following MOVSB, MOVSW, LODSB, LODSW, STOSB, STOSW instructions
CX times.
Algorithm: check_cx: if CX <> 0 then
|
REPE |
|
Repeat following CMPSB, CMPSW, SCASB, SCASW instructions
while ZF = 1 (result is Equal), maximum CX times.
Algorithm: check_cx: if CX <> 0 then
see cmpsb.asm in Samples. |
REPNE |
|
Repeat following CMPSB, CMPSW, SCASB, SCASW instructions
while ZF = 0 (result is Not Equal), maximum CX times.
Algorithm: check_cx: if CX <> 0 then
|
REPNZ |
|
Repeat following CMPSB, CMPSW, SCASB, SCASW instructions
while ZF = 0 (result is Not Zero), maximum CX times.
Algorithm: check_cx: if CX <> 0 then
|
REPZ |
|
Repeat following CMPSB, CMPSW, SCASB, SCASW instructions
while ZF = 1 (result is Zero), maximum CX times.
Algorithm: check_cx: if CX <> 0 then
|
RET | No operands or even immediate |
Return from near procedure.
Algorithm:
ORG 100h ; for COM file. CALL p1 ADD AX, 1 RET ; return to OS. p1 PROC ; procedure declaration. MOV AX, 1234h RET ; return to caller. p1 ENDP |
RETF | No operands or even immediate |
Return from Far procedure.
Algorithm:
|
ROL |
|
Rotate operand1 left. The number of rotates is set by operand2.
Algorithm:
MOV AL, 1Ch ; AL = 00011100b ROL AL, 1 ; AL = 00111000b, CF=0. RET |
ROR |
|
Rotate operand1 right. The number of rotates is set by operand2.
Algorithm:
MOV AL, 1Ch ; AL = 00011100b ROR AL, 1 ; AL = 00001110b, CF=0. RET |
SAHF | No operands |
Store AH register into low 8 bits of Flags register.
Algorithm:
AH bit: 7 6 5 4 3 2 1 0 [SF] [ZF] [0] [AF] [0] [PF] [1] [CF]bits 1, 3, 5 are reserved. |
SAL |
|
Shift Arithmetic operand1 Left. The number of shifts is set by operand2.
Algorithm:
MOV AL, 0E0h ; AL = 11100000b SAL AL, 1 ; AL = 11000000b, CF=1. RET |
SAR |
|
Shift Arithmetic operand1 Right. The number of shifts is set by operand2.
Algorithm:
MOV AL, 0E0h ; AL = 11100000b SAR AL, 1 ; AL = 11110000b, CF=0. MOV BL, 4Ch ; BL = 01001100b SAR BL, 1 ; BL = 00100110b, CF=0. RET |
SBB |
memory, REG REG, REG memory, immediate REG, immediate |
Subtract with Borrow.
Algorithm: operand1 = operand1 - operand2 - CF |
SCASB | No operands |
Compare bytes: Algorithm:
|
SCASW | No operands |
Compare words: Algorithm:
|
SHL |
|
Shift operand1 Left. The number of shifts is set by operand2.
Algorithm:
|
SHR |
|
Shift operand1 Right. The number of shifts is set by operand2.
Algorithm:
|
STC | No operands |
Set Carry flag. Algorithm: CF = 1 |
STD | No operands |
Set Direction flag. SI and DI will be decremented by chain
instructions: CMPSB, CMPSW, LODSB, LODSW, MOVSB, MOVSW, STOSB, STOSW. Algorithm: DF = 1 |
STI | No operands |
Set Interrupt enable flag. This enables hardware interrupts. Algorithm: IF = 1 |
STOSB | No operands |
Store byte in AL into ES:[DI]. Update SI. Algorithm:
|
STOSW | No operands |
Store word in AX into ES:[DI]. Update SI. Algorithm:
|
SUB |
memory, REG REG, REG memory, immediate REG, immediate |
Subtract.
Algorithm: operand1 = operand1 - operand2 |
TEST |
memory, REG REG, REG memory, immediate REG, immediate |
Logical AND between all bits of two operands for flags only.
These flags are effected: ZF, SF, PF.
Result is not stored anywhere. These rules apply: 1 AND 1 = 1 1 AND 0 = 0 0 AND 1 = 0 0 AND 0 = 0 |
XCHG |
memory, REG REG, REG |
Exchange values of two operands.
Algorithm: operand1 < - > operand2 |
XLATB | No operands |
Translate byte from table. Set value of AL register to memory byte at Algorithm: DS:[BX + unsigned AL] = AL |
XOR |
memory, REG REG, REG memory, immediate REG, immediate |
Logical XOR (Exclusive OR) between all bits of two operands.
Result is stored in first operand. These rules apply: 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 0 = 0 |