PreviousUpNext

15.4.871  src/lib/src/disassembler-intel32.pkg

## disassembler-intel32.pkg
#
# intel32 (x86)
#
# At the C level we're now using the 'disasm' x86 disassembler library,
# which in Debian is supplied by the packages  disasm0 + disasm-dev:
# See calls to x86_init()/x86_disasm()/x86_format_insn()/x86_cleanup()
# in  src/c/heapcleaner/heap-debug-stuff.c
# So if we need this functionality at the Mythryl level I'd currently
# be inclined to export the disasm calls from the C to the Mythry level,
# rather than re-inventing this wheel in Mythryl.   -- 2011-12-26 CrT

# Compiled by:
#     src/lib/std/standard.lib

###           "Be very, very careful what you put into that head,
###            because you will never, ever get it out."
###
###                          -- Thomas Cardinal Woolsey, 1471-1530



package   disassembler_intel32
:         Disassembler_Intel32                                  # Disassembler_Intel32  is from   src/lib/src/disassembler-intel32.api
{
    Operand_Size
        = SIZE_0                # 
        | B_SIZE                # Byte-size operand
        | V_SIZE                # Variable-size operand
        | W_SIZE                # Word-size operand
        | D_SIZE                # Doubleword-size operand
        | Q_SIZE                # Quadword-size operand
        | T_SIZE                # Tenbyte-size operand
        | X_SIZE                # XMM-size  operand (16 bytes)
        | M_SIZE                # D_SIZE in 32bit, Q_SIZE in 64bit
        | F_SIZE                # 4-6 byte pointer
        | CONDITIONAL_JUMP      #
        | LOOP_JCXZ             #
        | CONSTANT_1            #
        | STACK_V               #
        | AL_REG                
        | CL_REG                
        | DL_REG                
        | BL_REG                
        | AH_REG                
        | CH_REG                
        | DH_REG                
        | BH_REG                
        | CS_REG                
        | DS_REG                
        | ES_REG                
        | FS_REG                
        | GS_REG                
        | SS_REG                
        | EAX_REG               
        | EBX_REG               
        | ECX_REG               
        | EDX_REG               
        | ESP_REG               
        | EBP_REG               
        | ESI_REG               
        | EDI_REG               
        | RAX_REG               
        | RBX_REG               
        | RCX_REG               
        | RDX_REG               
        | RSP_REG               
        | RBP_REG               
        | RSI_REG               
        | RDI_REG               
        | INDIR_DX_REG          
        ;

    Print_Mode
        = A_PRINT               # Print 'b' if no register operands or suffix_always
        | B_PRINT               # Print 'b' if                         suffix_always
        | C_PRINT               # Print 's' or 'l' ('w' or 'd' in Intel mode) depending upon operand
        | F_PRINT               # Print 'w' or 'l' depending on address size prefix (loop instructions)
        | FH_PRINT              # Print F_PRINT, then H_PRINT
        | H_PRINT               # Print ",pt" or ",pn" branch hint
        | P_PRINT               # Print 'w', 'l' or 'q' if instruction has an operand size prefix, or suffix_always is true.  print 'q' if rex prefix is present.
        | Q_PRINT               # Print 'w', 'l' or 'q' if no register operands or suffix_always is true.
        | R_PRINT               # Print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
        | S_PRINT               # Print 'w', 'l' or 'q' if suffix_always is true
        | T_PRINT               # Print 'q' in 64bit mode and behave as 'P' otherwise
        | U_PRINT               # Print 'q' in 64bit mode and behave as 'Q' otherwise
        | V_PRINT               # Print 'q' in 64bit mode and behave as 'S' otherwise
        | W_PRINT               # Print 'b' or 'w' ("w" or "de" in intel mode)
        | PRINT_0               # Null mode.
        ;

    fun op_e         (bytemode, sizeflat)        =        ();
    fun op_g         (bytemode, sizeflat)        =        ();
    fun op_i         (bytemode, sizeflat)        =        ();
    fun op_i64       (bytemode, sizeflat)        =        ();
    fun op_j         (bytemode, sizeflat)        =        ();
    fun op_m         (bytemode, sizeflat)        =        ();
    fun op_si        (bytemode, sizeflat)        =        ();
    fun op_ds        (bytemode, sizeflat)        =        ();
    fun op_es        (bytemode, sizeflat)        =        ();
    fun op_reg       (bytemode, sizeflat)        =        ();
    fun op_seg       (bytemode, sizeflat)        =        ();
    fun op_dir       (bytemode, sizeflat)        =        ();
    fun op_indir_e   (bytemode, sizeflat)        =        ();
    fun op_nop1      (bytemode, sizeflat)        =        ();
    fun op_nop2      (bytemode, sizeflat)        =        ();
    fun op_null      (bytemode, sizeflat)        =        ();
    fun op_imreg     (bytemode, sizeflat)        =        ();
    fun op_off64     (bytemode, sizeflat)        =        ();
    fun op_seg_fixup (bytemode, sizeflat)        =        ();
    fun op_rep_fixup (bytemode, sizeflat)        =        ();

    Operand
        =
        (  (Int,Int) -> Void, Operand_Size );

    a_p      = (op_dir,   SIZE_0);
    e_b      = (op_e,     B_SIZE);
    e_v      = (op_e,     V_SIZE);
    e_w      = (op_e,     W_SIZE);
    e_stackv = (op_e,     STACK_V);
    m        = (op_m,     SIZE_0);
    m_a      = (op_e,     V_SIZE);      # Why this duplication?  Is this a typo for (op_m, V_SIZE)? XXX BUGGO FIXME
    m_p      = (op_e,     F_SIZE);
    g_b      = (op_g,     B_SIZE);
    g_v      = (op_g,     V_SIZE);
    i_1      = (op_i,     CONSTANT_1);
    i_b      = (op_i,     B_SIZE);
    i_q      = (op_i,     Q_SIZE);
    i_v      = (op_i,     V_SIZE);
    i_w      = (op_i,     W_SIZE);
    i_v64    = (op_i64,   V_SIZE);
    j_b      = (op_j,     B_SIZE);
    j_v      = (op_j,     V_SIZE);
    rm_al    = (op_reg,   AL_REG);
    rm_cl    = (op_reg,   CL_REG);
    rm_dl    = (op_reg,   DL_REG);
    rm_bl    = (op_reg,   BL_REG);
    rm_ah    = (op_reg,   AH_REG);
    rm_ch    = (op_reg,   CH_REG);
    rm_dh    = (op_reg,   DH_REG);
    rm_bh    = (op_reg,   BH_REG);
    al       = (op_imreg, AL_REG);
    cl       = (op_imreg, CL_REG);
    dl       = (op_imreg, DL_REG);
    bl       = (op_imreg, BL_REG);
    ah       = (op_imreg, AH_REG);
    ch       = (op_imreg, CH_REG);
    dh       = (op_imreg, DH_REG);
    bh       = (op_imreg, BH_REG);
    si_b     = (op_si,    B_SIZE);      # Sign-extended byte.
    o_b      = (op_off64, B_SIZE);
    o_v      = (op_off64, V_SIZE);
    s_v      = (op_seg_fixup, V_SIZE);
    s_w      = (op_seg_fixup, W_SIZE);
    x_b      = (op_ds, ESI_REG);
    x_v      = (op_ds, ESI_REG);        # Is this duplication a bug?
    y_b      = (op_es, EDI_REG);
    y_v      = (op_es, EDI_REG);        # Is this duplication a bug?
    dsbx      = (op_ds, EBX_REG);
    alr      = (op_rep_fixup,  AL_REG);
    eaxr     = (op_rep_fixup, EAX_REG);
    xbr      = (op_rep_fixup, ESI_REG);
    xvr      = (op_rep_fixup, ESI_REG); # Is this duplication a bug?
    ybr      = (op_rep_fixup, EDI_REG);
    yvr      = (op_rep_fixup, EDI_REG); # Is this duplication a bug?
    indir_ev = (op_indir_e, STACK_V);
    indir_ep = (op_indir_e, F_SIZE);
    indir_dx = (op_imreg, INDIR_DX_REG);

    nop1   = (op_nop1,  EAX_REG);
    nop2   = (op_nop2,  EAX_REG);
    eax    = (op_imreg, EAX_REG);
    cs     = (op_reg,   CS_REG);
    ds     = (op_reg,   DS_REG);
    es     = (op_reg,   ES_REG);
    fs     = (op_reg,   FS_REG);
    gs     = (op_reg,   GS_REG);
    ss     = (op_reg,   SS_REG);
    conditional_jump  = (op_null,   CONDITIONAL_JUMP);
    loop_jcxz_flag    = (op_null,   LOOP_JCXZ);

    rm_eax = (op_reg,  EAX_REG);
    rm_ebx = (op_reg,  EBX_REG);
    rm_ecx = (op_reg,  ECX_REG);
    rm_edx = (op_reg,  EDX_REG);
    rm_esp = (op_reg,  ESP_REG);
    rm_ebp = (op_reg,  EBP_REG);
    rm_esi = (op_reg,  ESI_REG);
    rm_edi = (op_reg,  EDI_REG);

    rm_rax = (op_reg,  RAX_REG);
    rm_rbx = (op_reg,  RBX_REG);
    rm_rcx = (op_reg,  RCX_REG);
    rm_rdx = (op_reg,  RDX_REG);
    rm_rsp = (op_reg,  RSP_REG);
    rm_rbp = (op_reg,  RBP_REG);
    rm_rsi = (op_reg,  RSI_REG);
    rm_rdi = (op_reg,  RDI_REG);

    Instruction
        =
        INSTRUCTION (String, Print_Mode, List Operand, Vector Instruction );

    base_ops
        =
        #[    # 00
              INSTRUCTION ("add",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("add",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("add",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("add",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("add",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("add",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("push",              T_PRINT, [ es ], #[]),
              INSTRUCTION ("pop",               T_PRINT, [ es ], #[]),
              # 08
              INSTRUCTION ("or",                B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("or",                S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("or",                B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("or",                S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("or",                B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("or",                S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("push",              T_PRINT, [ cs ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # 0x0f extended opcode escape 
              # 10
              INSTRUCTION ("adc",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("adc",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("adc",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("adc",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("adc",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("adc",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("push",              T_PRINT, [ ss ], #[]),
              INSTRUCTION ("pop",               T_PRINT, [ ss ], #[]),
              # 18
              INSTRUCTION ("sbb",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("sbb",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("sbb",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("sbb",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("sbb",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("sbb",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("push",              T_PRINT, [ ds ], #[]),
              INSTRUCTION ("pop",               T_PRINT, [ ds ], #[]),
              # 20
              INSTRUCTION ("and",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("and",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("and",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("and",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("and",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("and",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # SEG ES prefix
              INSTRUCTION ("daa",               PRINT_0, [ ], #[]),
              # 28
              INSTRUCTION ("sub",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("sub",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("sub",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("sub",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("sub",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("sub",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # SEG CS prefix
              INSTRUCTION ("das",               PRINT_0, [ ], #[]),
              # 30
              INSTRUCTION ("xor",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("xor",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("xor",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("xor",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("xor",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("xor",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # SEG CS prefix
              INSTRUCTION ("aaa",               PRINT_0, [ ], #[]),
              # 38
              INSTRUCTION ("cmp",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("cmp",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("cmp",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("cmp",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmp",               B_PRINT, [ al,  i_b ], #[]),
              INSTRUCTION ("cmp",               S_PRINT, [ eax, i_v ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # SEG DS prefix
              INSTRUCTION ("aas",               PRINT_0, [ ], #[]),
              # 40
              INSTRUCTION ("inc",               S_PRINT, [ rm_eax ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_ecx ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_edx ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_ebx ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_esp ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_ebp ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_esi ], #[]),
              INSTRUCTION ("inc",               S_PRINT, [ rm_edi ], #[]),
              # 48
              INSTRUCTION ("dec",               S_PRINT, [ rm_eax ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_ecx ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_edx ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_ebx ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_esp ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_ebp ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_esi ], #[]),
              INSTRUCTION ("dec",               S_PRINT, [ rm_edi ], #[]),
              # 50
              INSTRUCTION ("push",              V_PRINT, [ rm_rax ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rcx ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rdx ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rbx ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rsp ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rbp ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rsi ], #[]),
              INSTRUCTION ("push",              V_PRINT, [ rm_rdi ], #[]),
              # 58
              INSTRUCTION ("pop",               V_PRINT, [ rm_rax ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rcx ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rdx ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rbx ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rsp ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rbp ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rsi ], #[]),
              INSTRUCTION ("pop",               V_PRINT, [ rm_rdi ], #[]),
              # 60
              INSTRUCTION ("pusha",             P_PRINT, [ ], #[]),
              INSTRUCTION ("popa",              P_PRINT, [ ], #[]),
              INSTRUCTION ("bound",             S_PRINT, [ g_v, m_a ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),             # "X86_64_0"
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),             # fs seg
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),             # gs seg
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),             # operand-size prefix
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),             # address-size prefix
              # 68
              INSTRUCTION ("push",              T_PRINT, [ i_q ], #[]),
              INSTRUCTION ("imul",              S_PRINT, [ g_v, e_v, i_v ], #[]),
              INSTRUCTION ("push",              T_PRINT, [ si_b ], #[]),
              INSTRUCTION ("imul",              S_PRINT, [ g_v, e_v, si_b ], #[]),
              INSTRUCTION ("insb",              PRINT_0, [ ], #[]),             # XXX BUGGO FIXME incomplete -- but I doubt we ever generate this.
              INSTRUCTION ("ins",               R_PRINT, [ ], #[]),             # XXX BUGGO FIXME incomplete -- but I doubt we ever generate this.
              INSTRUCTION ("outsb",             PRINT_0, [ ], #[]),             # XXX BUGGO FIXME incomplete -- but I doubt we ever generate this.
              INSTRUCTION ("outs",              R_PRINT, [ ], #[]),             # XXX BUGGO FIXME incomplete -- but I doubt we ever generate this.
              # 70
              INSTRUCTION ("jo",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jno",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jb",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jae",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("je",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jne",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jbe",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("ja",                H_PRINT, [ j_b, conditional_jump ], #[]),
              # 78
              INSTRUCTION ("js",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jns",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jp",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jnp",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jl",                H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jge",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jle",               H_PRINT, [ j_b, conditional_jump ], #[]),
              INSTRUCTION ("jg",                H_PRINT, [ j_b, conditional_jump ], #[]),
              # 80
              INSTRUCTION ("(group_1b)",        PRINT_0, [ ], #[

                        INSTRUCTION ("add",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("or",              A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("adc",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("sbb",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("and",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("sub",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("xor",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("cmp",             A_PRINT, [ e_b, i_b ], #[])

                ] ),
              INSTRUCTION ("(group_1S)",        PRINT_0, [ ], #[
                        INSTRUCTION ("add",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("or",              Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("adc",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("sbb",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("and",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("sub",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("xor",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("cmp",             Q_PRINT, [ e_v, i_v ], #[])
                ] ),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),
              INSTRUCTION ("(group_1Ss)",       PRINT_0, [ ], #[
                        INSTRUCTION ("add",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("or",              Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("adc",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("sbb",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("and",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("sub",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("xor",             Q_PRINT, [ e_v, si_b ], #[]),
                        INSTRUCTION ("cmp",             Q_PRINT, [ e_v, si_b ], #[])
                ] ),
              INSTRUCTION ("test",              B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("test",              S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("xchg",              B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ e_v, g_v ], #[]),
              # 88
              INSTRUCTION ("mov",               B_PRINT, [ e_b, g_b ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ e_v, g_v ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ g_b, e_b ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ g_v, e_v ], #[]),
              INSTRUCTION ("mov",               Q_PRINT, [ s_v, s_w ], #[]),
              INSTRUCTION ("lea",               S_PRINT, [ g_v, m   ], #[]),
              INSTRUCTION ("mov",               Q_PRINT, [ s_w, s_v ], #[]),
              INSTRUCTION ("pop",               U_PRINT, [ e_stackv ], #[]),
              # 90
              INSTRUCTION ("xchg",              S_PRINT, [ nop1, nop2 ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_ecx, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_edx, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_ebx, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_esp, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_ebp, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_esi, eax ], #[]),
              INSTRUCTION ("xchg",              S_PRINT, [ rm_edi, eax ], #[]),
              # 98
              INSTRUCTION ("c",                 W_PRINT, [ ], #[]),
              INSTRUCTION ("c",                 R_PRINT, [ ], #[]),
              INSTRUCTION ("lcall",             T_PRINT, [ a_p ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [ ], #[]),                     # (fwait)
              INSTRUCTION ("pushf",             T_PRINT, [ ], #[]),                     # (fwait)
              INSTRUCTION ("popf",              T_PRINT, [ ], #[]),                     # (fwait)
              INSTRUCTION ("sahf",              PRINT_0, [ ], #[]),                     # (fwait)
              INSTRUCTION ("lahf",              PRINT_0, [ ], #[]),                     # (fwait)
              # a0
              INSTRUCTION ("mov",               B_PRINT, [ al,  o_b ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ eax, o_v ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ o_b,  al ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ o_v, eax ], #[]),
              INSTRUCTION ("movs",              PRINT_0, [ ybr, x_b ], #[]),
              INSTRUCTION ("movs",              PRINT_0, [ yvr, x_v ], #[]),
              INSTRUCTION ("cmps",              PRINT_0, [ x_b, y_b ], #[]),
              INSTRUCTION ("cmps",              PRINT_0, [ x_v, y_v ], #[]),
              # a8
              INSTRUCTION ("test",              B_PRINT, [  al,  i_b ], #[]),
              INSTRUCTION ("test",              S_PRINT, [ eax,  i_v ], #[]),
              INSTRUCTION ("stos",              B_PRINT, [ ybr,   al ], #[]),
              INSTRUCTION ("stos",              S_PRINT, [ yvr,  eax ], #[]),
              INSTRUCTION ("lods",              B_PRINT, [ alr,  x_b ], #[]),
              INSTRUCTION ("lods",              S_PRINT, [eaxr,  x_v ], #[]),
              INSTRUCTION ("scas",              B_PRINT, [  al,  y_b ], #[]),
              INSTRUCTION ("scas",              S_PRINT, [ eax,  y_v ], #[]),
              # b0
              INSTRUCTION ("mov",               B_PRINT, [ rm_al,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_cl,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_dl,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_bl,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_ah,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_ch,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_dh,  i_b ], #[]),
              INSTRUCTION ("mov",               B_PRINT, [ rm_bh,  i_b ], #[]),
              # b8
              INSTRUCTION ("mov",               S_PRINT, [ rm_eax,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_ecx,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_edx,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_ebx,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_esp,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_ebp,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_esi,  i_v64 ], #[]),
              INSTRUCTION ("mov",               S_PRINT, [ rm_edi,  i_v64 ], #[]),
              # c0
              INSTRUCTION ("(group_2b)",        PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("ror",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("rcl",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("rcr",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("shl",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("shr",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             A_PRINT, [ e_b, i_b ], #[])
                ] ),
              INSTRUCTION ("(group_2S)",        PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("ror",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("rcl",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("rcr",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("shl",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("shr",             Q_PRINT, [ e_v, i_b ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             Q_PRINT, [ e_b, i_b ], #[])
                ] ),
              INSTRUCTION ("ret",               T_PRINT, [ i_w ], #[]),
              INSTRUCTION ("ret",               T_PRINT, [ ], #[]),
              INSTRUCTION ("les",               S_PRINT, [ g_v, m_p ], #[]),
              INSTRUCTION ("lds",               S_PRINT, [ g_v, m_p ], #[]),
              INSTRUCTION ("(group_11_c6)",     PRINT_0, [ ], #[
                        INSTRUCTION ("mov",             A_PRINT, [ e_b, i_b ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[])
                ] ),
              INSTRUCTION ("(group_11_c7)",     PRINT_0, [ ], #[
                        INSTRUCTION ("mov",             Q_PRINT, [ e_v, i_v ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[])
                ] ),
              # c8
              INSTRUCTION ("enter",             T_PRINT, [ i_w, i_b ], #[]),
              INSTRUCTION ("leave",             T_PRINT, [          ], #[]),
              INSTRUCTION ("lret",              P_PRINT, [ i_w      ], #[]),
              INSTRUCTION ("lret",              P_PRINT, [          ], #[]),
              INSTRUCTION ("int3",              PRINT_0, [          ], #[]),
              INSTRUCTION ("int",               PRINT_0, [ i_b      ], #[]),
              INSTRUCTION ("into",              PRINT_0, [ i_b      ], #[]),
              INSTRUCTION ("iret",              P_PRINT, [          ], #[]),
              # d0
              INSTRUCTION ("(group_2b_one)",    PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("ror",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("rcl",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("rcr",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("shl",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("shr",             A_PRINT, [ e_b, i_1 ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             A_PRINT, [ e_b, i_1 ], #[])
                ] ),
              INSTRUCTION ("(group_2S_one)",    PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("ror",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("rcl",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("rcr",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("shl",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("shr",             Q_PRINT, [ e_v, i_1 ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             Q_PRINT, [ e_v, i_1 ], #[])
                ] ),
              INSTRUCTION ("(group_2b_cl)",     PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("ror",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("rcl",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("rcr",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("shl",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("shr",             A_PRINT, [ e_b, cl ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             A_PRINT, [ e_b, cl ], #[])
                ] ),
              INSTRUCTION ("(group_2S_cl)",     PRINT_0, [ ], #[
                        INSTRUCTION ("rol",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("ror",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("rcl",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("rcr",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("shl",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("shr",             Q_PRINT, [ e_v, cl ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("sar",             Q_PRINT, [ e_v, cl ], #[])
                ] ),
              INSTRUCTION ("aam",               PRINT_0, [ si_b     ], #[]),
              INSTRUCTION ("aad",               PRINT_0, [ si_b     ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("xlat",              PRINT_0, [ dsbx     ], #[]),
              # d8
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(float)",           PRINT_0, [          ], #[]),
              # e0
              INSTRUCTION ("loopne",           FH_PRINT, [ j_b, loop_jcxz_flag ], #[]),
              INSTRUCTION ("loope",            FH_PRINT, [ j_b, loop_jcxz_flag ], #[]),
              INSTRUCTION ("loop",             FH_PRINT, [ j_b, loop_jcxz_flag ], #[]),
              INSTRUCTION ("jecxz",             H_PRINT, [ j_b, loop_jcxz_flag ], #[]), # Should be "jcxz" for 16-bit version, not that we'd ever use it...
              INSTRUCTION ("in",                B_PRINT, [  al, i_b ], #[]),
              INSTRUCTION ("in",                S_PRINT, [ eax, i_b ], #[]),
              INSTRUCTION ("out",               B_PRINT, [ i_b,  al ], #[]),
              INSTRUCTION ("out",               S_PRINT, [ i_b, eax ], #[]),
              # e8
              INSTRUCTION ("call",              T_PRINT, [ j_v      ], #[]),
              INSTRUCTION ("jmp",               T_PRINT, [ j_v      ], #[]),
              INSTRUCTION ("ljmp",              T_PRINT, [ a_p      ], #[]),
              INSTRUCTION ("jmp",               T_PRINT, [ j_b      ], #[]),
              INSTRUCTION ("in",                B_PRINT, [  al, indir_dx  ], #[]),
              INSTRUCTION ("in",                S_PRINT, [ eax, indir_dx  ], #[]),
              INSTRUCTION ("out",               B_PRINT, [ indir_dx,  al  ], #[]),
              INSTRUCTION ("out",               S_PRINT, [ indir_dx, eax  ], #[]),
              # f0
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),    # lock prefix
              INSTRUCTION ("icebp",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),    # repne prefix
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),    # repz  prefix
              INSTRUCTION ("hlt",               PRINT_0, [          ], #[]),
              INSTRUCTION ("cmc",               PRINT_0, [          ], #[]),
              INSTRUCTION ("(group_3b)",        PRINT_0, [ ], #[
                        INSTRUCTION ("test",            A_PRINT, [ e_b, i_b   ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [            ], #[]),
                        INSTRUCTION ("not",             A_PRINT, [ e_b        ], #[]),
                        INSTRUCTION ("neg",             A_PRINT, [ e_b        ], #[]),
                        INSTRUCTION ("mul",             A_PRINT, [ e_b        ], #[]),
                        INSTRUCTION ("imul",            A_PRINT, [ e_b        ], #[]),
                        INSTRUCTION ("div",             A_PRINT, [ e_b        ], #[]),
                        INSTRUCTION ("idiv",            A_PRINT, [ e_b        ], #[])
                ] ),
              INSTRUCTION ("(group_3S)",        PRINT_0, [ ], #[
                        INSTRUCTION ("test",            Q_PRINT, [ e_v, i_v   ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [            ], #[]),
                        INSTRUCTION ("not",             Q_PRINT, [ e_v        ], #[]),
                        INSTRUCTION ("neg",             Q_PRINT, [ e_v        ], #[]),
                        INSTRUCTION ("mul",             Q_PRINT, [ e_v        ], #[]),
                        INSTRUCTION ("imul",            Q_PRINT, [ e_v        ], #[]),
                        INSTRUCTION ("div",             Q_PRINT, [ e_v        ], #[]),
                        INSTRUCTION ("idiv",            Q_PRINT, [ e_v        ], #[])
                ] ),
              # f8
              INSTRUCTION ("clc",               PRINT_0, [          ], #[]),
              INSTRUCTION ("stc",               PRINT_0, [          ], #[]),
              INSTRUCTION ("cli",               PRINT_0, [          ], #[]),
              INSTRUCTION ("sti",               PRINT_0, [          ], #[]),
              INSTRUCTION ("cld",               PRINT_0, [          ], #[]),
              INSTRUCTION ("std",               PRINT_0, [          ], #[]),
              INSTRUCTION ("(group_4)",         PRINT_0, [ ], #[
                        INSTRUCTION ("inc",             A_PRINT, [ e_b     ], #[]),
                        INSTRUCTION ("dec",             A_PRINT, [ e_b     ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[])
                ] ),
              INSTRUCTION ("(group_5)",         PRINT_0, [ ], #[
                        INSTRUCTION ("inc",             Q_PRINT, [ e_v      ], #[]),
                        INSTRUCTION ("dec",             Q_PRINT, [ e_v      ], #[]),
                        INSTRUCTION ("call",            T_PRINT, [ indir_ev ], #[]),
                        INSTRUCTION ("lcall",           T_PRINT, [ indir_ep ], #[]),
                        INSTRUCTION ("jmp",             T_PRINT, [ indir_ev ], #[]),
                        INSTRUCTION ("ljmp",            T_PRINT, [ indir_ep ], #[]),
                        INSTRUCTION ("push",            U_PRINT, [ e_stackv ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[])
                ] )

 ];
    prefix_0f_instructions
        =
        #[    # 00
              INSTRUCTION ("(group_6)",         PRINT_0, [ ], #[
                        INSTRUCTION ("sldt",            PRINT_0, [ e_v      ], #[]),
                        INSTRUCTION ("str",             PRINT_0, [ e_v      ], #[]),
                        INSTRUCTION ("lldt",            PRINT_0, [ e_w      ], #[]),
                        INSTRUCTION ("ltr",             PRINT_0, [ e_w      ], #[]),
                        INSTRUCTION ("verr",            PRINT_0, [ e_w      ], #[]),
                        INSTRUCTION ("verw",            PRINT_0, [ e_w      ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [ ], #[])
                ] ),
              INSTRUCTION ("(group_7)",         PRINT_0, [ ], #[
                        INSTRUCTION ("sgdt",            Q_PRINT, [          ], #[]),    # XXX BUGGO FIXME args for this not implements.
                        INSTRUCTION ("sidt",            Q_PRINT, [          ], #[]),    # XXX BUGGO FIXME args for this not implements.
                        INSTRUCTION ("lgdt",            Q_PRINT, [ m        ], #[]),
                        INSTRUCTION ("lidt",            Q_PRINT, [          ], #[]),    # XXX BUGGO FIXME args for this not implements.
                        INSTRUCTION ("smsw",            PRINT_0, [ e_v      ], #[]),
                        INSTRUCTION ("(bad)",           PRINT_0, [          ], #[]),
                        INSTRUCTION ("lmsw",            PRINT_0, [ e_w      ], #[]),
                        INSTRUCTION ("invlpg",          PRINT_0, [          ], #[])     # XXX BUGGO FIXME args for this not implements.
                ] ),
              INSTRUCTION ("lar",               S_PRINT, [ g_v, e_w ], #[]),
              INSTRUCTION ("lsl",               S_PRINT, [ g_v, e_w ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("syscall",           PRINT_0, [          ], #[]),
              INSTRUCTION ("clts",              PRINT_0, [          ], #[]),
              INSTRUCTION ("sysret",            P_PRINT, [          ], #[]),
              # 08
              INSTRUCTION ("invd",              PRINT_0, [          ], #[]),
              INSTRUCTION ("wbinvd",            PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("ud2a",              PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(GRPAMD)",          PRINT_0, [          ], #[]),
              INSTRUCTION ("femms",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(3DNow)",           PRINT_0, [          ], #[]),
              # 10
              INSTRUCTION ("(PREGRP8)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP9)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP30)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(movlpX)",          PRINT_0, [          ], #[]),
              INSTRUCTION ("(unpcklpX)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(unpckhpX)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP31)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(movhpX)",          PRINT_0, [          ], #[]),
              # 18
              INSTRUCTION ("(GRP16)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("nop",               Q_PRINT, [ e_v      ], #[]),
              # 20
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(mov)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              # 28
              INSTRUCTION ("(movap)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(movap)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP2)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP33",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP4)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP3)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(ucomis)",          PRINT_0, [          ], #[]),
              INSTRUCTION ("(comis)",           PRINT_0, [          ], #[]),
              # 30
              INSTRUCTION ("wrmsr",             PRINT_0, [          ], #[]),
              INSTRUCTION ("rdtsc",             PRINT_0, [          ], #[]),
              INSTRUCTION ("rdmsr",             PRINT_0, [          ], #[]),
              INSTRUCTION ("rdpmc",             PRINT_0, [          ], #[]),
              INSTRUCTION ("sysenter",          PRINT_0, [          ], #[]),
              INSTRUCTION ("sysexit",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              # 38
              INSTRUCTION ("(3-byte 0)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(3-byte 1)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              # 40
              INSTRUCTION ("cmovo",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovno",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovb",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovae",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmove",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovne",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovbe",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmova",             PRINT_0, [ g_v, e_v ], #[]),
              # 48
              INSTRUCTION ("cmovs",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovns",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovp",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovnp",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovl",             PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovge",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovle",            PRINT_0, [ g_v, e_v ], #[]),
              INSTRUCTION ("cmovg",             PRINT_0, [ g_v, e_v ], #[]),
              # 50
              INSTRUCTION ("(movmskp)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP13)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP12)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP11)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(andp)",            PRINT_0, [          ], #[]),
              INSTRUCTION ("(andnp)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(orp)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(xorp)",            PRINT_0, [          ], #[]),
              # 58
              INSTRUCTION ("(PREGRP0)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP10)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP17)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP16)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP14)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP7)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP5)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP6)",         PRINT_0, [          ], #[]),
              # 60
              INSTRUCTION ("(punpcklbw)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(punpcklwd)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(punpckldq)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(packsswb)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpgtb)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpgtw)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpgtd)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(packuswb)",        PRINT_0, [          ], #[]),
              # 68
              INSTRUCTION ("(punpckhbw)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(punpckhwd)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(punpckhdq)",       PRINT_0, [          ], #[]),
              INSTRUCTION ("(packssdw)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP26)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP24)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(movd)",            PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP19)",        PRINT_0, [          ], #[]),
              # 70
              INSTRUCTION ("(PREGRP22)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(GRP12)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(GRP13)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(GRP14)",           PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpeqb)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpeqw)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(pcmpeqd)",         PRINT_0, [          ], #[]),
              INSTRUCTION ("(emms)",            PRINT_0, [          ], #[]),
              # 78
              INSTRUCTION ("(PREGRP34)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP35)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP28)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP29)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP23)",        PRINT_0, [          ], #[]),
              INSTRUCTION ("(PREGRP20)",        PRINT_0, [          ], #[]),
              # 80
              INSTRUCTION ("jo",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jno",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jb",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jae",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("je",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jne",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jbe",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("ja",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              # 88
              INSTRUCTION ("js",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jns",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jp",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jnp",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jl",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jge",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jle",               H_PRINT, [ j_v, conditional_jump  ], #[]),
              INSTRUCTION ("jg",                H_PRINT, [ j_v, conditional_jump  ], #[]),
              # 90
              INSTRUCTION ("seto",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setno",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setb",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setae",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("sete",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setne",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setbe",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("seta",              H_PRINT, [ e_b                    ], #[]),
              # 98
              INSTRUCTION ("sets",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setns",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setp",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setnp",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setl",              H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setge",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setle",             H_PRINT, [ e_b                    ], #[]),
              INSTRUCTION ("setg",              H_PRINT, [ e_b                    ], #[]),
              # a0
              INSTRUCTION ("push",              T_PRINT, [ fs                     ], #[]),
              INSTRUCTION ("pop",               T_PRINT, [ fs                     ], #[]),
              INSTRUCTION ("cpuid",             PRINT_0, [                        ], #[]),
              INSTRUCTION ("bt",                S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("shld",              S_PRINT, [ e_v, g_v, i_b          ], #[]),
              INSTRUCTION ("shld",              S_PRINT, [ e_v, g_v,  cl          ], #[]),
              INSTRUCTION ("(GRPPADLCK2)",      PRINT_0, [                        ], #[]),
              INSTRUCTION ("(GRPPADLCK1)",      PRINT_0, [                        ], #[]),
              # a8
              INSTRUCTION ("push",              T_PRINT, [ gs                     ], #[]),
              INSTRUCTION ("pop",               T_PRINT, [ gs                     ], #[]),
              INSTRUCTION ("rsm",               PRINT_0, [                        ], #[]),
              INSTRUCTION ("bts",               S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("shrd",              S_PRINT, [ e_v, g_v, i_b          ], #[]),
              INSTRUCTION ("shrd",              S_PRINT, [ e_v, g_v,  cl          ], #[]),
              INSTRUCTION ("(GRP15)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("imul",              S_PRINT, [ g_v, e_v               ], #[]),
              # b0
              INSTRUCTION ("cmpxchg",           B_PRINT, [ e_b, g_b               ], #[]),
              INSTRUCTION ("cmpxchg",           S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("lss",               S_PRINT, [ g_v, m_p               ], #[]),
              INSTRUCTION ("btr",               S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("lfs",               S_PRINT, [ g_v, m_p               ], #[]),
              INSTRUCTION ("lgs",               S_PRINT, [ g_v, m_p               ], #[]),
              INSTRUCTION ("movzb",             R_PRINT, [ g_v, e_b               ], #[]),
              INSTRUCTION ("movzw",             R_PRINT, [ g_v, e_w               ], #[]),
              # b8
              INSTRUCTION ("(PREGRP37)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("ud2b",              PRINT_0, [                        ], #[]),
              INSTRUCTION ("(GRP8)",            PRINT_0, [                        ], #[]),
              INSTRUCTION ("btc",               S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("bsf",               S_PRINT, [ g_v, e_v               ], #[]),
              INSTRUCTION ("(PREGRP36)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("movsb",             R_PRINT, [ g_v, e_b               ], #[]),
              INSTRUCTION ("movsw",             R_PRINT, [ g_v, e_w               ], #[]),
              # c0
              INSTRUCTION ("xadd",              B_PRINT, [ e_b, g_b               ], #[]),
              INSTRUCTION ("xadd",              S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("(PREGRP1)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("movnti",            S_PRINT, [ e_v, g_v               ], #[]),
              INSTRUCTION ("(pinsrw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pextrw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(shufp)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(GRP9)",            PRINT_0, [                        ], #[]),
              # c8
              INSTRUCTION ("bswap",             PRINT_0, [ rm_eax                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_ecx                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_edx                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_ebx                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_esp                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_ebp                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_esi                 ], #[]),
              INSTRUCTION ("bswap",             PRINT_0, [ rm_edi                 ], #[]),
              # d0
              INSTRUCTION ("(PREGRP27)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psrlw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psrld)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psrlq)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddq)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmullq)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(PREGRP21)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmovmskb)",        PRINT_0, [                        ], #[]),
              # d8
              INSTRUCTION ("(psubusb)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psubusw)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pminub)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pand)",            PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddusb)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddusw)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmaxub)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pandn)",           PRINT_0, [                        ], #[]),
              # e0
              INSTRUCTION ("(pavgb)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psraw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psrad)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pavgw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmulhuw)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmulhw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(PREGRP15)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("(PREGRP25)",        PRINT_0, [                        ], #[]),
              # e8
              INSTRUCTION ("(psubsb)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psubsw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pminsw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(por)",             PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddsb)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddsw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmaxsw)",          PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pxor)",            PRINT_0, [                        ], #[]),
              # f0
              INSTRUCTION ("(PREGRP32)",        PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psllw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pslld)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psllq)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmuludq)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(pmaddwd)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psaddbw)",         PRINT_0, [                        ], #[]),
              INSTRUCTION ("(PREGRP18)",        PRINT_0, [                        ], #[]),
              # f0
              INSTRUCTION ("(psubb)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psubw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psubd)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(psubq)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddb)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddw)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(paddd)",           PRINT_0, [                        ], #[]),
              INSTRUCTION ("(bad)",             PRINT_0, [                        ], #[])

 ];

    fun disassemble  byte_vector
        =
        "intel32 disassembly:\n";

};


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext