The Intel 8086 / 8088 / 80186 / 80286 / 80386 / 80486 Instruction Set

This HTML version of the file intel.doc from the PC Game Programmer's guide was produced by Zack T Smith. Fancy HTML modifications are copyright © 2005 by Zack T Smith, all rights reserved. This information is provided in the hope that it will be useful, but without any warranty. It is provided AS-IS, without even the implied warranty of fitness for a particular purpose.

P Instructions

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.

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        reg16             8     5     4     4             1
        reg32             4     -     -     4             1
        segreg            8     5     7     3             1
        mem16           17+EA   5     5     6            2-4
        mem32             5     -     -     6            2-4

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.

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        none              -     19    24    9             1

POPF/POPFD - Pop Flags off Stack

        Usage:  POPF
                POPFD  (386+)
        Modifies flags: all flags

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

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        none             8/12   5     5     9             1  (W88=12)
        none  (PM)        -     -     5     6             1

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).

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        reg16           11/15   3     2     1             1
        reg32             -     -     2     1             1
        mem16           16+EA   5     5     4            2-4  (W88=24+EA)
        mem32             -     -     5     4            2-4
        segreg          10/14   3     2     3             1
        immed             -     3     2     1            2-3

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.

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        none              -     19    24    11            1

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.

                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes

        none            10/14   3     4     4             1
        none  (PM)        -     -     4     3             1