Open source
  • Bandwidth benchmark
  • TouchWidgets UI lib
  • Diviner big number math
  • Documentation
  • x86 instructions ref
  • GIT quick ref
  • GPG quick ref
  • Avoid Ubuntu
  • Android malware risks
  • iOS malware risks
  • OS/X security tips
  • Who blocks Tor
  • Software engineering
  • BASH aliases
  • I.B. pro/con
  • Nutrition
  • Other apps
  • Blog
  • Contact
    1 at zsmith dot co

    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 , veritasNOSPAM@comcast.net. Fancy HTML modifications are copyright © 2005 by , 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
    



    © Zack Smith