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.

    I Instructions

    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.
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
    
        reg8          101-112   17    19    19            2
        reg16         165-184   25    27    27            2
        reg32            -      -     43    43            2
        mem8     (107-118)+EA   20    22    20           2-4
        mem16    (171-190)+EA   38    30    28           2-4  (W88=175-194)
        mem32            -      -     46    44           2-4
    

    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.
    
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
    
        reg8             80-98   13   9-14  13-18         2
        reg16           128-154  21   9-22  13-26         2
        reg32              -     -    9-38  12-42         2
        mem8             86-104  16  12-17  13-18        2-4
        mem16           134-160  24  12-25  13-26        2-4
        mem32              -     -   12-41  13-42        2-4
        reg16,reg16        -     -    9-22  13-26        3-5
        reg32,reg32        -     -    9-38  13-42        3-5
        reg16,mem16        -     -   12-25  13-26        3-5
        reg32,mem32        -     -   12-41  13-42        3-5
        reg16,immed        -     21   9-22  13-26         3
        reg32,immed        -     21   9-38  13-42        3-6
        reg16,reg16,immed  -     2    9-22  13-26        3-6
        reg32,reg32,immed  -     21   9-38  13-42        3-6
        reg16,mem16,immed  -     24  12-25  13-26        3-6
        reg32,mem32,immed  -     24  12-41  13-42        3-6
    

    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.
    
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
    
        accum,immed8    10/14   5     12     14           2
        accum,immed8 (PM)            6/26  8/28/27        2
        accum,DX         8/12   5     13     14           1
        accum,DX (PM)                7/27  8/28/27        1
    
        - 386+ protected mode timings depend on privilege levels.
    
          first number is the timing if:    CPL ≤ IOPL
          second number is the timing if:   CPL > IOPL or in VM 86 mode (386)
                                            CPL ≥ IOPL  (486)
          third number is the timing when:    virtual mode on 486 processor
        - 486 virtual mode always requires 27 cycles
    

    INC - Increment
     
        Usage:  INC     dest
        Modifies flags: AF OF PF SF ZF
    
        Adds one to destination unsigned binary operand.
    
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
    
        reg8              3     2     2     1             2
        reg16             3     2     2     1             1
        reg32             3     2     2     1             1
        mem             15+EA   7     6     3            2-4  (W88=23+EA)
    

    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.
    
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
    
        dest,port         -     5     15     17           1
        dest,port (PM)    -     5    9/29 10/32/30        1
        none              -     5     15     17           1
        none (PM)         -     5    9/29 10/32/30        1
    
        - 386+ protected mode timings depend on privilege levels.
    
          first number is the timing if:    CPL ≤ IOPL
          second number is the timing if:   CPL > IOPL
          third number is the timing if:    virtual mode on 486 processor
    

    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
    
                                               Clocks           Size
            Operands                    808x  286   386   486   Bytes
    
     3 (constant)                      52/72  23+m   33    26     1
     3 (prot. mode, same priv.)          -    40+m   59    44     1       
     3 (prot. mode, more priv.)          -    78+m   99    71     1
     3 (from VM86 to PL 0)               -     -    119    82     1
     3 (prot. mode via task gate)        -   167+m   TS  37+TS    1
     immed8                            51/71  23+m   37    30     2
     immed8 (prot. mode, same priv.)     -    40+m   59    44     2
     immed8 (prot. mode, more priv.)     -    78+m   99    71     2
     immed8 (from VM86 to PL 0)          -     -    119    86     2
     immed8 (prot. mode, via task gate)      -   167+m   TS  37+TS    2
    
    Note:
    INT 3 is encoded as a different opcode (0xCC) from INT imm8 (0xCD).
    
    Trivia:
    On PC systems, INT 10 is the BIOS call for video services;
    INT 13 is for disk I/O and INT 21 is MSDOS operations.
    

    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.
    
                                          Clocks           Size
        Operands                808x    286   386   486    Bytes
    
        none: jump             53/73   24+m    35    28      1
              no jump            4       3     3     3
        (prot. mode, same priv.) -       -     59    46      1
        (prot. mode, more priv.) -       -     99    73      1
        (from VM86 to PL 0)      -       -    119    84      1
        (prot. mode, via task gate)      -     TS  39+TS     1
    

    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.
        
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
    
        none              -      -     -     4            2
    

    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.
        
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
    
        none              -      -     -     12           2
    
        - timing is for TLB entry hit only.
    

    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.
    
                                         Clocks                 Size
            Operands            808x   286   386   486          Bytes
    
        iret                   32/44  17+m    22    15            1
        iret  (prot. mode)       -    31+m    38    15            1
        iret  (to less privilege)    -    55+m    82    36        1
        iret  (different task, NT=1) -   169+m    TS  TS+32       1
        iretd                    -      -   22/38   15            1
        iretd (to less privilege)    -      -     82    36        1
        iretd (to VM86 mode)     -      -     60    15            1
        iretd (different task, NT=1) -      -     TS  TS+32       1
    
        - 386 timings are listed as real-mode/protected-mode
    



    © Zack Smith