• Home »
• Tutorials »
• Intel Syntax Reference Guide

Intel Syntax Reference Guide

This is an intel syntax reference guide. I want to thank Leos Literak for putting this together! The reason I am replicating it here is (1) for practical reference and (2) just to make sure it doesn't get lost in the ether of the internet. This is really practical when your debugging and need to know what memory manipulations a series of instructions will make.

 

Instructions

---

Registers - CPU Registers
Clock Cycle - Instruction Clock Cycle Calculations
Task State - Calculation
FLAGS - Intel 8086 Family Flags Register
MSW - Machine Status Word (286+ only)
AAA - Ascii Adjust for Addition
AAD - Ascii Adjust for Division
AAM - Ascii Adjust for Multiplication
AAS - Ascii Adjust for Subtraction
ADC - Add With Carry
ADD - Arithmetic Addition
AND - Logical And
ARPL - Adjusted Requested Privilege Level of Selector (286+ PM)
BOUND - Array Index Bound Check (80188+)
BSF - Bit Scan Forward (386+)
BSR - Bit Scan Reverse (386+)
BSWAP - Byte Swap (486+)
BT - Bit Test (386+)
BTC - Bit Test with Compliment (386+
BTR - Bit Test with Reset (386+)
BTS - Bit Test and Set (386+)
CALL - Procedure Call
CBW - Convert Byte to Word
CDQ - Convert Double to Quad (386+)
CLC - Clear Carry
CLD - Clear Direction Flag
CLI - Clear Interrupt Flag (disable)
CLTS - Clear Task Switched Flag (286+ privileged).
CMC - Complement Carry Flag
CMP - Compare
CMPS - Compare String (Byte, Word or Doubleword)
CMPXCHG - Compare and Exchange
CWD - Convert Word to Doubleword
CWDE - Convert Word to Extended Doubleword (386+)
DAA - Decimal Adjust for Addition
DAS - Decimal Adjust for Subtraction
DEC - Decrement.
DIV - Divide
ENTER - Make Stack Frame (80188+)
ESC - Escape
HLT - Halt CPU
IDIV - Signed Integer Division
IMUL - Signed Multiply
IN - Input Byte or Word From Port
INC - Increment
INS - Input String from Port (80188+)
INT - Interrupt
INTO - Interrupt on Overflow
INVD - Invalidate Cache (486+)
INVLPG - Invalidate Translation Look-Aside Buffer Entry (486+)
IRET/IRETD - Interrupt Return.
Jxx - Jump Instructions Table.
JCXZ/JECXZ - Jump if Register (E)CX is Zero

---

JMP - Unconditional Jump
LAHF - Load Register AH From Flags
LAR - Load Access Rights (286+ protected)
LDS - Load Pointer Using DS
LEA - Load Effective Address
LEAVE - Restore Stack for Procedure Exit (80188+)
LES - Load Pointer Using ES
LFS - Load Pointer Using FS (386+)
LGDT - Load Global Descriptor Table (286+privileged)
LIDT - Load Interrupt Descriptor Table (286+privileged)
LGS - Load Pointer Using GS (386+)
LLDT - Load Local Descriptor Table (286+privileged)
LMSW - Load Machine Status Word (286+ privileged)
LOCK - Lock Bus
LODS - Load String (Byte, Word or Double)
LOOP - Decrement CX and Loop if CX Not Zero
LOOPE/LOOPZ - Loop While Equal / Loop While Zero
LOOPNZ/LOOPNE - Loop While Not Zero / Loop While Not Equal
LSL - Load Segment Limit (286+ protected)
LSS - Load Pointer Using SS (386+)
LTR - Load Task Register (286+ privileged)
MOV - Move Byte or Word
MOVS - Move String (Byte or Word)
MOVSX - Move with Sign Extend (386+)
MOVZX - Move with Zero Extend (386+)
MUL - Unsigned Multiply
NEG - Two's Complement Negation
NOP - No Operation (90h)
NOT - One's Compliment Negation (Logical NOT)
OR - Inclusive Logical OR
OUT - Output Data to Port.
OUTS - Output String to Port (80188+)
POP - Pop Word off Stack
POPA/POPAD - Pop All Registers onto Stack (80188+)
POPF/POPFD - Pop Flags off Stack
PUSH - Push Word onto Stack
PUSHA/PUSHAD - Push All Registers onto Stack (80188+)
PUSHF/PUSHFD - Push Flags onto Stack
RCL - Rotate Through Carry Left.
RCR - Rotate Through Carry Right
REP - Repeat String Operation
REPE/REPZ - Repeat Equal / Repeat Zero
REPNE/REPNZ - Repeat Not Equal / Repeat Not Zero
RET/RETF - Return From Procedure
ROL - Rotate Left.
ROR - Rotate Right
SAHF - Store AH Register into FLAGS

---

SAL - Shift Arithmetic Left / Shift Logical Left
SAR - Shift Arithmetic Right
SBB - Subtract with Borrow/Carry
SCAS - Scan String (Byte, Word or Doubleword)
SETAE/SETNB - Set if Above or Equal / Set if Not Below (386+)
SETB/SETNAE - Set if Below / Set if Not Above or Equal (386+)
SETBE/SETNA - Set if Below or Equal / Set if Not Above (386+)
SETE/SETZ - Set if Equal / Set if Zero (386+)
SETNE/SETNZ - Set if Not Equal / Set if Not Zero (386+)
SETL/SETNGE - Set if Less / Set if Not Greater or Equal (386+)
SETGE/SETNL - Set if Greater or Equal / Set if Not Less (386+)
SETLE/SETNG - Set if Less or Equal / Set if Not greater or Equal (386+)
SETG/SETNLE - Set if Greater / Set if Not Less or Equal (386+)
SETS - Set if Signed (386+)
SETNS - Set if Not Signed (386+)
SETC - Set if Carry (386+)
SETNC - Set if Not Carry (386+)
SETO - Set if Overflow (386+)
SETNO - Set if Not Overflow (386+)
SETP/SETPE - Set if Parity / Set if Parity Even (386+)
SETNP/SETPO - Set if No Parity / Set if Parity Odd (386+)
SGDT - Store Global Descriptor Table (286+privileged)
SIDT - Store Interrupt Descriptor Table (286+privileged)
SHL - Shift Logical Left
SHR - Shift Logical Right
SHLD/SHRD - Double Precision Shift (386+)
SLDT - Store Local Descriptor Table (286+privileged)
SMSW - Store Machine Status Word (286+ privileged)
STC - Set Carry
STD - Set Direction Flag
STI - Set Interrupt Flag (Enable Interrupts)
STOS - Store String (Byte, Word or Doubleword)
STR - Store Task Register (286+ privileged)
SUB - Subtract
TEST - Test For Bit Pattern
VERR - Verify Read (286+ protected)
VERW - Verify Write (286+ protected)
WAIT/FWAIT - Event Wait
WBINVD - Write-Back and Invalidate Cache(486+)
XCHG - Exchange
XLAT/XLATB - Translate
XOR - Exclusive OR

Instruction Details

Intel 80x86 Family Architecture

Register overriding

Instruction Clock Cycle Calculation

Some instructions require additional clock cycles due to a "Next Instruction Component" identified by a "+m" in the instruction clock cycle listings. This is due to the prefetch queue being purge on a control transfers. Below is the general rule for calculating "m":

• 286 "m" is the number of bytes in the next instruction
• 386 "m" is the number of components in the next instruction (the instruction coding (each byte), plus the data and the displacement are all considered components)

Task State Calculation

"TS" is defined as switching from VM/486 or 80286 TSS to one of the following:

Miscellaneous

• all timings are for best case and do not take into account wait states, instruction alignment, the state of the prefetch queue, DMA refresh cycles, cache hits/misses or exception processing.
• to convert clocks to nanoseconds divide one microsecond by the processor speed in MegaHertz: (1000MHz/(n MHz)) = X nanoseconds

FLAGS - Intel 8086 Family Flags Register

      |11|10|F|E|D|C|B|A|9|8|7|6|5|4|3|2|1|0|
        |  | | | | | | | | | | | | | | | | |___  CF Carry Flag
        |  | | | | | | | | | | | | | | | |___  1
        |  | | | | | | | | | | | | | | |___  PF Parity Flag
        |  | | | | | | | | | | | | | |___  0
        |  | | | | | | | | | | | | |___  AF Auxiliary Flag
        |  | | | | | | | | | | | |___  0
        |  | | | | | | | | | | |___  ZF Zero Flag
        |  | | | | | | | | | |___  SF Sign Flag
        |  | | | | | | | | |___  TF Trap Flag  (Single Step)
        |  | | | | | | | |___  IF Interrupt Flag
        |  | | | | | | |___  DF Direction Flag
        |  | | | | | |___  OF Overflow flag
        |  | | | |_____  IOPL I/O Privilege Level  (286+ only)
        |  | | |_____  NT Nested Task Flag  (286+ only)
        |  | |_____  0
        |  |_____  RF Resume Flag (386+ only)
        |______  VM  Virtual Mode Flag (386+ only)

MSW - Machine Status Word (286+ only)

      |31|30-5|4|3|2|1|0|  Machine Status Word
        |   |  | | | | |____ Protection Enable (PE)
        |   |  | | | |_____ Math Present (MP)
        |   |  | | |______ Emulation (EM)
        |   |  | |_______ Task Switched (TS)
        |   |  |________ Extension Type (ET)
        |   |__________ Reserved
        |_____________ Paging (PG)

Bit 0  PE Protection Enable, switches processor between protected and real mode
Bit 1  MP Math Present, controls function of the WAIT instruction
Bit 2  EM Emulation, indicates whether coprocessor functions are to be emulated
Bit 3  TS Task Switched, set and interrogated by coprocessor on task switches and when interpretting coprocessor instructions
Bit 4  ET Extension Type, indicates type of coprocessor in system
Bits 5-30 Reserved
bit 31  PG Paging, indicates whether the processor uses page tables to translate linear addresses to physical addresses

AAA - Ascii Adjust for Addition

Usage: AAA

Modifies Flags: AF CF (OF,PF,SF,ZF undefined)

Changes contents of AL to valid unpacked decimal. The high order nibble is zeroed.

AAD - Ascii Adjust for Division

Usage: AAD

Modifies Flags: SF ZF PF (AF,CF,OF undefined)

Used before dividing unpacked decimal numbers. Multiplies AH by 10 and the adds result into AL. Sets AH to zero. This instruction is also known to have an undocumented behavior.

AL := 10*AH+AL
AH := 0

AAM - Ascii Adjust for Multiplication

Usage: AAM

Modifies Flags: PF SF ZF (AF,CF,OF undefined)

Used after multiplication of two unpacked decimal numbers, this instruction adjusts an unpacked decimal number. The high order nibble of each byte must be zeroed before using this instruction. This instruction is also known to have an undocumented behavior.

AAS - Ascii Adjust for Subtraction

Usage: AAS

Modifies Flags: AF CF (OF,PF,SF,ZF undefined)

Corrects result of a previous unpacked decimal subtraction in AL. High order nibble is zeroed.

ADC - Add With Carry

Usage: ADC dest,src

Modifies Flags: AF CF OF SF PF ZF

Sums two binary operands placing the result in the destination. If CF is set, a 1 is added to the destination.

ADD - Arithmetic Addition

Usage: ADD dest,src

Modifies Flags: AF CF OF PF SF ZF

Adds "src" to "dest" and replacing the original contents of "dest". Both operands are binary.

AND - Logical And

Usage: AND dest,src

Modifies Flags: CF OF PF SF ZF (AF undefined)

Performs a logical AND of the two operands replacing the destination with the result.

ARPL - Adjusted Requested Privilege Level of Selector (286+ PM)

Usage: ARPL dest,src

Modifies Flags: ZF

Compares the RPL bits of "dest" against "src". If the RPL bits of "dest" are less than "src", the destination RPL bits are set equal to the source RPL bits and the Zero Flag is set. Otherwise the Zero Flag is cleared.

BOUND - Array Index Bound Check

Usage: BOUND src,limit

Modifies Flags: None

Array index in source register is checked against upper and lower bounds in memory source. The first word located at "limit" is the lower boundary and the word at "limit+2" is the upper array bound. Interrupt 5 occurs if the source value is less than or higher than the source.

BSF - Bit Scan Forward (386+)

Usage: BSF dest,src

Modifies Flags: ZF

Scans source operand for first bit set. Sets ZF if a bit is found set and loads the destination with an index to first set bit. Clears ZF if no bits are found set. BSF scans forward across bit pattern (0-n) while BSR scans in reverse (n-0).

BSR - Bit Scan Reverse (386+)

Usage: BSR dest,src

Modifies Flags: ZF

Scans source operand for first bit set. Sets ZF if a bit is found set and loads the destination with an index to first set bit. Clears ZF if no bits are found set. BSF scans forward across bit pattern (0-n) while BSR scans in reverse (n-0).

BSWAP - Byte Swap (486+)

Usage: BSWAP reg32

Modifies Flags: none

Changes the byte order of a 32 bit register from big endian to little endian or vice versa. Result left in destination register is undefined if the operand is a 16 bit register.

BT - Bit Test (386+)

Usage: BT dest,src

Modifies Flags: CF

The destination bit indexed by the source value is copied into the Carry Flag.

BTC - Bit Test with Compliment (386+)

Usage: BTC dest,src

Modifies Flags: CF

The destination bit indexed by the source value is copied into the Carry Flag after being complimented (inverted).

BTR - Bit Test with Reset (386+)

Usage: BTR dest,src

Modifies Flags: CF

The destination bit indexed by the source value is copied into the Carry Flag and then cleared in the destination.

BTS - Bit Test and Set (386+)

Usage: BTS dest,src

Modifies Flags: CF

The destination bit indexed by the source value is copied into the Carry Flag and then set in the destination.

CALL - Procedure Call

Usage: CALL destination

Modifies Flags: None

Pushes Instruction Pointer (and Code Segment for far calls) onto stack and loads Instruction Pointer with the address of proc-name. Code continues with execution at CS:IP.

CBW - Convert Byte to Word

Usage: CBW

Modifies Flags: None

Converts byte in AL to word Value in AX by extending sign of AL throughout register AH.

CDQ - Convert Double to Quad (386+)

Usage: CDQ

Modifies Flags: None

Converts signed DWORD in EAX to a signed quad word in EDX:EAX by extending the high order bit of EAX throughout EDX

CLC - Clear Carry

Usage: CLC

Modifies Flags: CF

Clears the Carry Flag.

CLD - Clear Direction Flag

Usage: CLD

Modifies Flags: DF

Clears the Direction Flag causing string instructions to increment the SI and DI index registers.

CLI - Clear Interrupt Flag (disable)

Usage: CLI

Modifies Flags: IF

Disables the maskable hardware interrupts by clearing the Interrupt flag. NMI's and software interrupts are not inhibited.

CLTS - Clear Task Switched Flag (286+ privileged)

Usage: CLTS

Modifies Flags: None

Clears the Task Switched Flag in the Machine Status Register. This is a privileged operation and is generally used only by operating system code.

CMC - Complement Carry Flag

Usage: CMC

Modifies Flags: CF

Toggles (inverts) the Carry Flag

CMP - Compare

Usage: CMP dest,src

Modifies Flags: AF CF OF PF SF ZF

Subtracts source from destination and updates the flags but does not save result. Flags can subsequently be checked for conditions.

CMPS - Compare String (Byte, Word or Doubleword)

Usage: CMPS dest,src
             CMPSB
             CMPSW
             CMPSD (386+)

Modifies Flags: AF CF OF PF SF ZF

Subtracts destination value from source without saving results. Updates flags based on the subtraction and the index registers (E)SI and (E)DI are incremented or decremented depending on the state of the Direction Flag. CMPSB inc/decrements the index registers by 1, CMPSW inc/decrements by 2, while CMPSD increments or decrements by 4. The REP prefixes can be used to process entire data items.

CMPXCHG - Compare and Exchange (486+)

Usage: CMPXCHG dest,src

Modifies Flags: AF CF OF PF SF ZF

Compares the accumulator (8-32 bits) with "dest". If equal the "dest" is loaded with "src", otherwise the accumulator is loaded with "dest".

CWD - Convert Word to Doubleword

Usage: CWD

Modifies Flags: None

Extends sign of word in register AX throughout register DX forming a doubleword quantity in DX:AX.

CWDE - Convert Word to Extended Doubleword (386+)

Usage: CWDE

Modifies Flags: None

Converts a signed word in AX to a signed doubleword in EAX by extending the sign bit of AX throughout EAX.

DAA - Decimal Adjust for Addition

Usage: DAA

Modifies Flags: AF CF PF SF ZF (OF undefined)

Corrects result (in AL) of a previous BCD addition operation. Contents of AL are changed to a pair of packed decimal digits.

DAS - Decimal Adjust for Subtraction

Usage: DAS

Modifies Flags: AF CF PF SF ZF (OF undefined)

Corrects result (in AL) of a previous BCD subtraction operation. Contents of AL are changed to a pair of packed decimal digits.

DEC - Decrement

Usage: DEC dest

Modifies Flags: AF OF PF SF ZF

Unsigned binary subtraction of one from the destination.

DIV - Divide

Usage: DIV src

Modifies Flags: (AF,CF,OF,PF,SF,ZF undefined)

Unsigned binary division of accumulator by source. If the source divisor is a byte value then AX is divided by "src" and the quotient is placed in AL and the remainder in AH. If source operand is a word value, then DX:AX is divided by "src" and the quotient is stored in AX and the remainder in DX.

ENTER - Make Stack Frame (80188+)

Usage: ENTER locals,level

Modifies Flags: None

Modifies stack for entry to procedure for high level language. Operand "locals" specifies the amount of storage to be allocated on the stack. "Level" specifies the nesting level of the routine. Paired with the LEAVE instruction, this is an efficient method of entry and exit to procedures.

ESC - Escape

Usage: ESC immed,src

Modifies Flags: None

Provides access to the data bus for other resident processors. The CPU treats it as a NOP but places memory operand on bus.

HLT - Halt CPU

Usage: HLT

Modifies Flags: None

Halts CPU until RESET line is activated, NMI or maskable interrupt received. The CPU becomes dormant but retains the current CS:IP for later restart.

IDIV - Signed Integer Division

Usage: IDIV src

Modifies Flags: (AF,CF,OF,PF,SF,ZF undefined)

Signed binary division of accumulator by source. If source is a byte value, AX is divided by "src" and the quotient is stored in AL and the remainder in AH. If source is a word value, DX:AX is divided by "src", and the quotient is stored in AL and the remainder in DX.

IMUL - Signed Multiply

Usage: IMUL src
           IMUL src,immed (286+)
           IMUL dest,src,immed8 (286+)
           IMUL dest,src (386+)

Modifies Flags: CF OF (AF,PF,SF,ZF undefined)

Signed multiplication of accumulator by "src" with result placed in the accumulator. If the source operand is a byte value, it is multiplied by AL and the result stored in AX. If the source operand is a word value it is multiplied by AX and the result is stored in DX:AX. Other variations of this instruction allow specification of source and destination registers as well as a third immediate factor.

IN - Input Byte or Word From Port

Usage: IN accum,port

Modifies Flags: None

A byte, word or dword is read from "port" and placed in AL, AX or EAX respectively. If the port number is in the range of 0-255 it can be specified as an immediate, otherwise the port number must be specified in DX. Valid port ranges on the PC are 0-1024, though values through 65535 may be specified and recognized by third party vendors and PS/2's.

INC - Increment

Usage: INC dest

Modifies Flags: AF OF PF SF ZF

Adds one to destination unsigned binary operand.

INS - Input String from Port (80188+)

Usage: INS dest,port
           INSB
           INSW
           INSD (386+)

Modifies Flags: None

Loads data from port to the destination ES:(E)DI (even if a destination operand is supplied). (E)DI is adjusted by the size of the operand and increased if the Direction Flag is cleared and decreased if the Direction Flag is set. For INSB, INSW, INSD no operands are allowed and the size is determined by the mnemonic.

INT - Interrupt

Usage: INT num

Modifies Flags: TF IF

Initiates a software interrupt by pushing the flags, clearing the Trap and Interrupt Flags, pushing CS followed by IP and loading CS:IP with the value found in the interrupt vector table. Execution then begins at the location addressed by the new CS:IP

INTO - Interrupt on Overflow

Usage: INTO

Modifies Flags: IF TF

If the Overflow Flag is set this instruction generates an INT 4 which causes the code addressed by 0000:0010 to be executed.

INVD - Invalidate Cache (486+)

Usage: INVD

Modifies Flags: None

Flushes CPU internal cache. Issues special function bus cycle which indicates to flush external caches. Data in write-back external caches is lost.

INVLPG - Invalidate Translation Look-Aside Buffer Entry (486+)

Usage: INVLPG

Modifies Flags: None

Invalidates a single page table entry in the Translation Look-Aside Buffer. Intel warns that this instruction may be implemented differently on future processors.

IRET/IRETD - Interrupt Return

Usage: IRET
IRETD (386+)

Modifies Flags: AF CF DF IF PF SF TF ZF

Returns control to point of interruption by popping IP, CS and then the Flags from the stack and continues execution at this location. CPU exception interrupts will return to the instruction that cause the exception because the CS:IP placed on the stack during the interrupt is the address of the offending instruction.

JXX - Jump Instructions Table

Mnemonic	Meaning	Jump Condition
JA	Jump if Above	CF=0 and ZF=0
JAE	Jump if Above or Equal	CF=0
JB	Jump if Below	CF=1
JBE	Jump if Below or Equal	CF=1 or ZF=1
JC	Jump if Carry	CF=1
JCXZ	Jump if CX Zero	CX=0
JE	Jump if Equal	ZF=1
JG	Jump if Greater (signed)	ZF=0 and SF=OF
JGE	Jump if Greater or Equal (signed)	SF=OF
JL	Jump if Less (signed)	SF != OF
JLE	Jump if Less or Equal (signed)	ZF=1 or SF != OF
JMP	Unconditional Jump	unconditional
JNA	Jump if Not Above	CF=1 or ZF=1
JNAE	Jump if Not Above or Equal	CF=1
JNB	Jump if Not Below	CF=0
JNBE	Jump if Not Below or Equal	CF=0 and ZF=0
JNC	Jump if Not Carry	CF=0
JNE	Jump if Not Equal	ZF=0
JNG	Jump if Not Greater (signed)	ZF=1 or SF != OF
JNGE	Jump if Not Greater or Equal (signed)	SF != OF
JNL	Jump if Not Less (signed)	SF=OF
JNLE	Jump if Not Less or Equal (signed)	ZF=0 and SF=OF
JNO	Jump if Not Overflow (signed)	OF=0
JNP	Jump if No Parity	PF=0
JNS	Jump if Not Signed (signed)	SF=0
JNZ	Jump if Not Zero	ZF=0
JO	Jump if Overflow (signed)	OF=1
JP	Jump if Parity	PF=1
JPE	Jump if Parity Even	PF=1
JPO	Jump if Parity Odd	PF=0
JS	Jump if Signed (signed)	SF=1
JZ	Jump if Zero	ZF=1

JCXZ/JECXZ - Jump if Register (E)CX is Zero

Usage: JCXZ label
JECXZ label (386+)

Modifies Flags: None

Causes execution to branch to "label" if register CX is zero. Uses unsigned comparision.

JMP - Unconditional Jump

Usage: JMP target

Modifies Flags: None

Unconditionally transfers control to "label". Jumps by default are within -32768 to 32767 bytes from the instruction following the jump. NEAR and SHORT jumps cause the IP to be updated while FAR jumps cause CS and IP to be updated.

LAHF - Load Register AH From Flags

Usage: LAHF

Modifies Flags: None

Copies bits 0-7 of the flags register into AH. This includes flags AF, CF, PF, SF and ZF other bits are undefined.

AH := SF ZF xx AF xx PF xx CF

LAR - Load Access Rights (286+ protected)

Usage: LAR dest,src

Modifies Flags: ZF

The high byte of the of the destination register is overwritten by the value of the access rights byte and the low order byte is zeroed depending on the selection in the source operand. The Zero Flag is set if the load operation is successful.

LDS - Load Pointer Using DS

Usage: LDS dest,src

Modifies Flags: None

Loads 32-bit pointer from memory source to destination register and DS. The offset is placed in the destination register and the segment is placed in DS. To use this instruction the word at the lower memory address must contain the offset and the word at the higher address must contain the segment. This simplifies the loading of far pointers from the stack and the interrupt vector table.

LEA - Load Effective Address

Usage: LEA dest,src

Modifies Flags: None

Transfers offset address of "src" to the destination register.

LEAVE - Restore Stack for Procedure Exit (80188+)

Usage: LEAVE

Modifies Flags: LEAVE

Releases the local variables created by the previous ENTER instruction by restoring SP and BP to their condition before the procedure stack frame was initialized.

LES - Load Pointer Using ES

Usage: LES dest,src

Modifies Flags: None

Loads 32-bit pointer from memory source to destination register and ES. The offset is placed in the destination register and the segment is placed in ES. To use this instruction the word at the lower memory address must contain the offset and the word at the higher address must contain the segment. This simplifies the loading of far pointers from the stack and the interrupt vector table.

LFS - Load Pointer Using FS (386+)

Usage: LFS dest,src

Modifies Flags: None

Loads 32-bit pointer from memory source to destination register and FS. The offset is placed in the destination register and the segment is placed in FS. To use this instruction the word at the lower memory address must contain the offset and the word at the higher address must contain the segment. This simplifies the loading of far pointers from the stack and the interrupt vector table.

LGDT - Load Global Descriptor Table (286+ privileged)

Usage: LGDT src

Modifies Flags: None

Loads a value from an operand into the Global Descriptor Table (GDT) register.

LIDT - Load Interrupt Descriptor Table (286+ privileged)

Usage: LIDT src

Modifies Flags: None

Loads a value from an operand into the Interrupt Descriptor Table (IDT) register.

LGS - Load Pointer Using GS (386+)

Usage: LGS dest,src

Modifies Flags: None

Loads 32-bit pointer from memory source to destination register and GS. The offset is placed in the destination register and the segment is placed in GS. To use this instruction the word at the lower memory address must contain the offset and the word at the higher address must contain the segment. This simplifies the loading of far pointers from the stack and the interrupt vector table.

LLDT - Load Local Descriptor Table (286+ privileged)

Usage: LLDT src

Modifies Flags: None

Loads a value from an operand into the Local Descriptor Table Register (LDTR).

LMSW - Load Machine Status Word (286+ privileged)

Usage: LMSW src

Modifies Flags: None

Loads the Machine Status Word (MSW) from data found at "src"

LOCK - Lock Bus

Usage: LOCK
           LOCK: (386+ prefix)

Modifies Flags: None

This instruction is a prefix that causes the CPU assert bus lock signal during the execution of the next instruction. Used to avoid two processors from updating the same data location. The 286 always asserts lock during an XCHG with memory operands. This should only be used to lock the bus prior to XCHG, MOV, IN and OUT instructions.

LODS - Load String (Byte, Word or Double)

Usage: LODS src
           LODSB
           LODSW
           LODSD (386+)

Modifies Flags: None

Transfers string element addressed by DS:SI (even if an operand is supplied) to the accumulator. SI is incremented based on the size of the operand or based on the instruction used. If the Direction Flag is set SI is decremented, if the Direction Flag is clear SI is incremented. Use with REP prefixes.

LOOP - Decrement CX and Loop if CX Not Zero

Usage: LOOP label

Modifies Flags: None

Decrements CX by 1 and transfers control to "label" if CX is not Zero. The "label" operand must be within -128 or 127 bytes of the instruction following the loop instruction

Usage: LOOPE label
           LOOPZ label

Modifies Flags: None

Decrements CX by 1 (without modifying the flags) and transfers control to "label" if CX != 0 and the Zero Flag is set. The "label" operand must be within -128 or 127 bytes of the instruction following the loop instruction.

LOOPNZ/LOOPNE - Loop While Not Zero / Loop While Not Equal

Usage: LOOPNZ label
           LOOPNE label

Modifies Flags: None

Decrements CX by 1 (without modifying the flags) and transfers control to "label" if CX != 0 and the Zero Flag is clear. The "label" operand must be within -128 or 127 bytes of the instruction following the loop instruction.

LSL - Load Segment Limit (286+ protected)

Usage: LSL dest,src

Modifies Flags: ZF

Loads the segment limit of a selector into the destination register if the selector is valid and visible at the current privilege level. If loading is successful the Zero Flag is set, otherwise it is cleared.

LSS - Load Pointer Using SS (386+)

Usage: LSS dest,src

Modifies Flags: None

Loads 32-bit pointer from memory source to destination register and SS. The offset is placed in the destination register and the segment is placed in SS. To use this instruction the word at the lower memory address must contain the offset and the word at the higher address must contain the segment. This simplifies the loading of far pointers from the stack and the interrupt vector table.

LTR - Load Task Register (286+ privileged)

Usage: LTR src

Modifies Flags: None

Loads the current task register with the value specified in "src".

MOV - Move Byte or Word

Usage: MOV dest,src

Modifies Flags: None

Copies byte or word from the source operand to the destination operand. If the destination is SS interrupts are disabled except on early buggy 808x CPUs. Some CPUs disable interrupts if the destination is any of the segment registers

MOVS - Move String (Byte or Word)

Usage: MOVS dest,src
           MOVSB
           MOVSW
           MOVSD (386+)

Modifies Flags: None

Copies data from addressed by DS:SI (even if operands are given) to the location ES:DI destination and updates SI and DI based on the size of the operand or instruction used. SI and DI are incremented when the Direction Flag is cleared and decremented when the Direction Flag is Set. Use with REP prefixes.

MOVSX - Move with Sign Extend (386+)

Usage: MOVSX dest,src

Modifies Flags: None

Copies the value of the source operand to the destination register with the sign extended.

MOVZX - Move with Zero Extend (386+)

Usage: MOVZX dest,src

Modifies Flags: None

Copies the value of the source operand to the destination register with the zeroes extended.

MUL - Unsigned Multiply

Usage: MUL src

Modifies Flags: CF OF (AF,PF,SF,ZF undefined)

Unsigned multiply of the accumulator by the source. If "src" is a byte value, then AL is used as the other multiplicand and the result is placed in AX. If "src" is a word value, then AX is multiplied by "src" and DX:AX receives the result. If "src" is a double word value, then EAX is multiplied by "src" and EDX:EAX receives the result. The 386+ uses an early out algorithm which makes multiplying any size value in EAX as fast as in the 8 or 16 bit registers.

NEG - Two's Complement Negation

Usage: NEG dest

Modifies Flags: AF CF OF PF SF ZF

Subtracts the destination from 0 and saves the 2s complement of "dest" back into "dest".

Usage: NOP

Modifies Flags: None

This is a do nothing instruction. It results in occupation of both space and time and is most useful for patching code segments. (This is the original XCHG AL,AL instruction)

NOT - One's Complement Negation (Logical NOT)

Usage: NOT dest

Modifies Flags: None

Inverts the bits of the "dest" operand forming the 1s complement.

OR - Inclusive Logical OR

Usage: OR dest,src

Modifies Flags: CF OF PF SF ZF (AF undefined)

Logical inclusive OR of the two operands returning the result in the destination. Any bit set in either operand will be set in the destination.

OUT - Output Data to Port

Usage: OUT port,accum

Modifies Flags: None

Transfers byte in AL,word in AX or dword in EAX to the specified hardware port address. If the port number is in the range of 0-255 it can be specified as an immediate. If greater than 255 then the port number must be specified in DX. Since the PC only decodes 10 bits of the port address, values over 1023 can only be decoded by third party vendor equipment and also map to the port range 0-1023.

OUTS - Output String to Port (80188+)

Usage: OUTS port,src
           OUTSB
           OUTSW
           OUTSD (386+)

Modifies Flags: None

Transfers a byte, word or doubleword from "src" to the hardware port specified in DX. For instructions with no operands the "src" is located at DS:SI and SI is incremented or decremented by the size of the operand or the size dictated by the instruction format. When the Direction Flag is set SI is decremented, when clear, SI is incremented. If the port number is in the range of 0-255 it can be specified as an immediate. If greater than 255 then the port number must be specified in DX. Since the PC only decodes 10 bits of the port address, values over 1023 can only be decoded by third party vendor equipment and also map to the port range 0-1023.

POP - Pop Word off Stack

Usage: POP dest

Modifies Flags: None

Transfers word at the current stack top (SS:SP) to the destination then increments SP by two to point to the new stack top. CS is not a valid destination.

POPA/POPAD - Pop All Registers onto Stack (80188+)

Usage: POPA
           POPAD (386+)

Modifies Flags: None

Pops the top 8 words off the stack into the 8 general purpose 16/32 bit registers. Registers are popped in the following order: (E)DI, (E)SI, (E)BP, (E)SP, (E)DX, (E)CX and (E)AX. The (E)SP value popped from the stack is actually discarded.

POPF/POPFD - Pop Flags off Stack

Usage: POPF
           POPFD (386+)

Modifies Flags: All

Pops word/doubleword from stack into the Flags Register and then increments SP by 2 (for POPF) or 4 (for POPFD).

PUSH - Push Word onto Stack

Usage: PUSH src
           PUSH immed (80188+ only)

Modifies Flags: None

Decrements SP by the size of the operand (two or four, byte values are sign extended) and transfers one word from source to the stack top (SS:SP).

PUSHA/PUSHAD - Push All Registers onto Stack (80188+)

Usage: PUSHA
           PUSHAD (386+)

Modifies Flags: None

Pushes all general purpose registers onto the stack in the following order: (E)AX, (E)CX, (E)DX, (E)BX, (E)SP, (E)BP, (E)SI, (E)DI. The value of SP is the value before the actual push of SP.

PUSHF/PUSHFD - Push Flags onto Stack

Usage: PUSHF
           PUSHFD (386+)

Modifies Flags: None

Transfers the Flags Register onto the stack. PUSHF saves a 16 bit value while PUSHFD saves a 32 bit value.

RCL - Rotate Through Carry Left

Usage: RCL dest,count

Modifies Flags: CF OF



Rotates the bits in the destination to the left "count" times with all data pushed out the left side re-entering on the right. The Carry Flag holds the last bit rotated out.

RCR - Rotate Through Carry Right

Usage: RCR dest,count

Modifies Flags: CF OF



Rotates the bits in the destination to the right "count" times with all data pushed out the right side re-entering on the left. The Carry Flag holds the last bit rotated out.

REP - Repeat String Operation

Usage: REP

Modifies Flags: None

Repeats execution of string instructions while CX != 0. After each string operation, CX is decremented and the Zero Flag is tested. The combination of a repeat prefix and a segment override on CPU's before the 386 may result in errors if an interrupt occurs before CX=0. The following code shows code that is susceptible to this and how to avoid it:

         again:  rep movs  byte ptr ES:[DI],ES:[SI]   ; vulnerable instr.
                     jcxz  next              ; continue if REP successful
                     loop  again             ; interrupt goofed count
         next:

REPE/REPZ - Repeat Equal / Repeat Zero

Usage: REPE
           REPZ

Modifies Flags: None

Repeats execution of string instructions while CX != 0 and the Zero Flag is set. CX is decremented and the Zero Flag tested after each string operation. The combination of a repeat prefix and a segment override on processors other than the 386 may result in errors if an interrupt occurs before CX=0. Look at example, how to avoid it.

REPNE/REPNZ - Repeat Not Equal / Repeat Not Zero

Usage: REPNE
           REPNZ

Modifies Flags: None

Repeats execution of string instructions while CX != 0 and the Zero Flag is clear. CX is decremented and the Zero Flag tested after each string operation. The combination of a repeat prefix and a segment override on processors other than the 386 may result in errors if an interrupt occurs before CX=0. There is an example how to avoid it.

RET/RETF - Return From Procedure

Usage: RET nBytes
           RETF nBytes
           RETN nBytes

Modifies Flags: None

Transfers control from a procedure back to the instruction address saved on the stack. "n bytes" is an optional number of bytes to release. Far returns pop the IP followed by the CS, while near returns pop only the IP register.

ROL - Rotate Left

Usage: ROL dest,count

Modifies Flags: CF OF



Rotates the bits in the destination to the left "count" times with all data pushed out the left side re-entering on the right. The Carry Flag will contain the value of the last bit rotated out.

ROR - Rotate Right

Usage: ROR dest,count

Modifies Flags: CF OF



Rotates the bits in the destination to the right "count" times with all data pushed out the right side re-entering on the left. The Carry Flag will contain the value of the last bit rotated out.

SAHF - Store AH Register into FLAGS

Usage: SAHF

Modifies Flags: AF CF PF SF ZF

Transfers bits 0-7 of AH into the Flags Register. This includes AF, CF, PF, SF and ZF.

SAL/SHL - Shift Arithmetic Left / Shift Logical Left

Usage: SAL dest,count
             SHL dest,count

Modifies Flags: CF OF PF SF ZF (AF undefined)



Shifts the destination left by "count" bits with zeroes shifted in on right. The Carry Flag contains the last bit shifted out.

SAR - Shift Arithmetic Right

Usage: SAR dest,count

Modifies Flags: CF OF PF SF ZF (AF undefined)



Shifts the destination right by "count" bits with the current sign bit replicated in the leftmost bit. The Carry Flag contains the last bit shifted out.

SBB - Subtract with Borrow/Carry

Usage: SBB dest,src

Modifies Flags: AF CF OF PF SF ZF

Subtracts the source from the destination, and subtracts 1 extra if the Carry Flag is set. Results are returned in "dest".

SCAS - Scan String (Byte, Word or Doubleword)

Usage: SCAS string
             SCASB
             SCASW
             SCASD (386+)

Modifies Flags: AF CF OF PF SF ZF

Compares value at ES:DI (even if operand is specified) from the accumulator and sets the flags similar to a subtraction. DI is incremented/decremented based on the instruction format (or operand size) and the state of the Direction Flag. Use with REP prefixes.

SETAE/SETNB - Set if Above or Equal / Set if Not Below (386+)

Usage: SETAE dest
             SETNB dest (unsigned, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Carry Flag is clear otherwise sets the operand to 0.

SETB/SETNAE - Set if Below / Set if Not Above or Equal (386+)

Usage: SETB dest
             SETNAE dest (unsigned, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Carry Flag is set otherwise sets the operand to 0.

SETBE/SETNA - Set if Below or Equal / Set if Not Above (386+)

Usage: SETBE dest
             SETNA dest (unsigned, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Carry Flag or the Zero Flag is set, otherwise sets the operand to 0.

SETE/SETZ - Set if Equal / Set if Zero (386+)

Usage: SETE dest
             SETZ dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Zero Flag is set, otherwise sets the operand to 0.

SETNE/SETNZ - Set if Not Equal / Set if Not Zero (386+)

Usage: SETNE dest
             SETNZ dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Zero Flag is clear, otherwise sets the operand to 0.

SETL/SETNGE - Set if Less / Set if Not Greater or Equal (386+)

Usage: SETL dest
             SETNGE dest (signed, 386+)

Modifies Flags: None

SETGE/SETNL - Set if Greater or Equal / Set if Not Less (386+)

Usage: SETGE dest
             SETNL dest (signed, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Sign Flag equals the Overflow Flag, otherwise sets the operand to 0.

SETLE/SETNG - Set if Less or Equal / Set if Not greater or Equal (386+)

Usage: SETLE dest
             SETNG dest (signed, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Zero Flag is set or the Sign Flag is not equal to the Overflow Flag, otherwise sets the operand to 0.

SETG/SETNLE - Set if Greater / Set if Not Less or Equal (386+)

Usage: SETG dest
             SETNLE dest (signed, 386+)

Modifies Flags: None

Sets the byte in the operand to 1 if the Zero Flag is clear or the Sign Flag equals to the Overflow Flag, otherwise sets the operand to 0.

SETS - Set if Signed (386+)

Usage: SETS dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Sign Flag is set, otherwise sets the operand to 0.

SETNS - Set if Not Signed (386+)

Usage: SETNS dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Sign Flag is clear, otherwise sets the operand to 0.

SETC - Set if Carry (386+)

Usage: SETC dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Carry Flag is set, otherwise sets the operand to 0.

SETNC - Set if Not Carry (386+)

Usage: SETNC dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Carry Flag is clear, otherwise sets the operand to 0.

SETO - Set if Overflow (386+)

Usage: SETO dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Overflow Flag is set, otherwise sets the operand to 0.

SETNO - Set if Not Overflow (386+)

Usage: SETNO dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Overflow Flag is clear, otherwise sets the operand to 0.

SETP/SETPE - Set if Parity / Set if Parity Even (386+)

Usage: SETP dest
             SETPE dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Parity Flag is set, otherwise sets the operand to 0.

SETNP/SETPO - Set if No Parity / Set if Parity Odd (386+)

Usage: SETNP dest
             SETPO dest

Modifies Flags: None

Sets the byte in the operand to 1 if the Parity Flag is clear, otherwise sets the operand to 0.

SGDT - Store Global Descriptor Table (286+ privileged)

Usage: SGDT dest

Modifies Flags: None

Stores the Global Descriptor Table (GDT) Register into the specified operand.

SIDT - Store Interrupt Descriptor Table (286+ privileged)

Usage: SIDT dest

Modifies Flags: None

Stores the Interrupt Descriptor Table (IDT) Register into the specified operand.

SHR - Shift Logical Right

Usage: SHR dest,count

Modifies Flags: CF OF PF SF ZF (AF undefined)



Shifts the destination right by "count" bits with zeroes shifted in on the left. The Carry Flag contains the last bit shifted out.

SHLD/SHRD - Double Precision Shift (386+)

Usage: SHLD dest,src,count
             SHRD dest,src,count

Modifies Flags: CF PF SF ZF (OF,AF undefined)

SHLD shifts "dest" to the left "count" times and the bit positions opened are filled with the most significant bits of "src". SHRD shifts "dest" to the right "count" times and the bit positions opened are filled with the least significant bits of the second operand. Only the 5 lower bits of "count" are used.

SLDT - Store Local Descriptor Table (286+ privileged)

Usage: SLDT dest

Modifies Flags: none

Stores the Local Descriptor Table (LDT) Register into the specified operand.

SMSW - Store Machine Status Word (286+ privileged)

Usage: SMSW dest

Modifies Flags: none

Store Machine Status Word (MSW) into "dest".

STC - Set Carry

Usage: STC

Modifies Flags: CF

Sets the Carry Flag to 1.

STD - Set Direction Flag

Usage: STD

Modifies Flags: DF

Sets the Direction Flag to 1 causing string instructions to auto-decrement SI and DI instead of auto-increment.

STI - Set Interrupt Flag (Enable Interrupts)

Usage: STI

Modifies Flags: IF

Sets the Interrupt Flag to 1, which enables recognition of all hardware interrupts. If an interrupt is generated by a hardware device, an End of Interrupt (EOI) must also be issued to enable other hardware interrupts of the same or lower priority.

STOS - Store String (Byte, Word or Doubleword)

Usage: STOS dest
             STOSB dest
             STOSW dest
             STOSD dest

Modifies Flags: none

Stores value in accumulator to location at ES:(E)DI (even if operand is given). (E)DI is incremented/decremented based on the size of the operand (or instruction format) and the state of the Direction Flag. Use with REP prefixes.

STR - Store Task Register (286+ privileged)

Usage: STR dest

Modifies Flags: None

Stores the current Task Register to the specified operand.

SUB - Subtract

Usage: SUB dest,src

Modifies Flags: AF CF OF PF SF ZF

The source is subtracted from the destination and the result is stored in the destination.

TEST - Test For Bit Pattern

Usage: TEST dest,src

Modifies Flags: CF OF PF SF ZF (AF undefined)

Performs a logical AND of the two operands updating the flags register without saving the result.

VERR - Verify Read (286+ protected)

Usage: VERR src

Modifies Flags: ZF

Verifies the specified segment selector is valid and is readable at the current privilege level. If the segment is readable, the Zero Flag is set, otherwise it is cleared.

VERW - Verify Write (286+ protected)

Usage: VERW src

Modifies Flags: ZF

Verifies the specified segment selector is valid and is writable at the current privilege level. If the segment is writable, the Zero Flag is set, otherwise it is cleared.

WAIT/FWAIT - Event Wait

Usage: WAIT
             FWAIT

Modifies Flags: None

CPU enters wait state until the coprocessor signals it has finished its operation. This instruction is used to prevent the CPU from accessing memory that may be temporarily in use by the coprocessor. WAIT and FWAIT are identical.

WBINVD - Write-Back and Invalidate Cache (486+)

Usage: WBINVD

Modifies Flags: None

Flushes internal cache, then signals the external cache to write back current data followed by a signal to flush the external cache.

XCHG - Exchange

Usage: XCHG dest,src

Modifies Flags: None

Exchanges contents of source and destination.

XLAT/XLATB - Translate

Usage: XLAT translation-table
XLATB (masm 5.x)

Modifies Flags: None

Replaces the byte in AL with byte from a user table addressed by BX. The original value of AL is the index into the translate table. The best way to discripe this is MOV AL,[BX+AL]

XOR - Exclusive OR

Usage: XOR dest,src

Modifies Flags: CF OF PF SF ZF (AF undefined)

Performs a bitwise exclusive OR of the operands and returns the result in the destination.