x86.ml

granularity = 8
export = decode

# Optional arguments
#
# Limit:
#   - Restricts the maximium size of the decode-stream
# Recursion-depth:
#   - Annotate the maximum number of recursion steps for
#     the given decoder. This way, we can compute an upper
#     bound for the maximum used storage for the emitted AST.
#     Additionally, the decoder may fail if during runtime
#     a recrusion depth violation occurs.
#
# limit = 120
# recursion-depth = p64 = 4

val decode = do
   update @{tab=void};
   main
end

val main = do
   t <- query $tab;
   update
      @{mode64='1',
        repne='0',
        rep='0',
        rex='0',
        rexw='0',
        rexb='0',
        rexr='0',
        rexx='0',
        opndsz='0',
        addrsz='0',
        lock='0',
        segment=SEG_NONE,
	default-operand-size=32,
        ptrty=32, #TODO: check
        ~tab};
   instr <- p64;
   update @{tab=t};
   return instr
end

val complement v = not v

# Segment prefix handling
type seg_override =
     SEG_NONE
   | SEG_OVERRIDE of register

val set-CS = update@{segment=SEG_OVERRIDE CS}
val set-DS = update@{segment=SEG_OVERRIDE DS}
val set-ES = update@{segment=SEG_OVERRIDE ES}
val set-FS = update@{segment=SEG_OVERRIDE FS}
val set-GS = update@{segment=SEG_OVERRIDE GS}
val set-SS = update@{segment=SEG_OVERRIDE SS}

val set-lock = update@{lock='1'}
val set-addrsz = update@{addrsz='1'}

val opndsz-set-from-d = return void

## Decoding prefixes

# The functions 'after' and 'continue' are used to try different decoders
# in sequence. The first function takes two arguments and runs the first
# one until it calls 'continue', at which point the second decoder is run.

val after fst snd = do
  update@{tab=snd};
  r <- fst;
  # make the type checker happy
  update@{~tab};
  return r
end

val continue = do
  t <- query$tab;
  # make the type checker happy
  update@{~tab};
  # make the type checker happy
  r <- t;
  update@{~tab};
  return r
end

#val after fst snd = do
#   update@{tab=snd};
#   fst
#end
#
#val continue = do
#   t <- query$tab;
#   t
#end

val /66 [] = continue
val /f2 [] = continue
val /f3 [] = continue

val /rex-p ['0100 w:1 r:1 x:1 b:1'] =
   update @{rex='1', rexw=w, rexb=b, rexx=x, rexr=r}
val clear-rex = update @{rex='0',rexw='0',rexb='0',rexr='0',rexx='0'}

val /legacy-p [0x2e] = do clear-rex; set-CS end
val /legacy-p [0x36] = do clear-rex; set-SS end
val /legacy-p [0x3e] = do clear-rex; set-DS end
val /legacy-p [0x26] = do clear-rex; set-ES end
val /legacy-p [0x64] = do clear-rex; set-FS end
val /legacy-p [0x65] = do clear-rex; set-GS end
val /legacy-p [0x67] = do clear-rex; set-addrsz end
val /legacy-p [0xf0] = do clear-rex; set-lock end

val /66-p [0x66] = clear-rex
val /f2-p [0xf2] = clear-rex
val /f3-p [0xf3] = clear-rex

val p/vex/0f [0xc4 'r:1 x:1 b:1 00001' 'w:1 v:4 l:1 00'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00001'}
end

val p/vex/0f [0xc5 'r:1 v:4 l:1 00'] = do
   update
      @{rex='1',
        rexw='0',
        vexw='0',
        rexr=not r,
        vexl=l,
        vexv=complement v,
        vexm='00001'} #TODO: sane default value for vexm,rexw,rexb,..
end

val p/vex/66/0f [0xc4 'r:1 x:1 b:1 00001' 'w:1 v:4 l:1 01'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,

        vexm='00001'}
end

val p/vex/66/0f [0xc5 'r:1 v:4 l:1 01'] = do
   update
      @{rex='1',
        rexw='0',
        vexw='0',
        rexr=not r,
        vexl=l,
        vexv=complement v,
        vexm='00001'} #TODO: sane default value for vexm,rexw,rexb,..
end

val p/vex/f3/0f [0xc4 'r:1 x:1 b:1 00001' 'w:1 v:4 l:1 10'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00001'}
end

val p/vex/f3/0f [0xc5 'r:1 v:4 l:1 10'] = do
   update
      @{rex='1',
        rexw='0',
        vexw='0',
        rexr=not r,
        vexl=l,
        vexv=complement v,
        vexm='00001'} #TODO: sane default value for vexm,rexw,rexb,..
end

val p/vex/f2/0f [0xc4 'r:1 x:1 b:1 00001' 'w:1 v:4 l:1 11'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00001'}
end

val p/vex/f2/0f [0xc5 'r:1 v:4 l:1 11'] = do
   update
      @{rex='1',
        rexw='0',
        vexw='0',
        rexr=not r,
        vexl=l,
        vexv=complement v,
        vexm='00001'} #TODO: sane default value for vexm,rexw,rexb,..
end

val p/vex/0f/38 [0xc4 'r:1 x:1 b:1 00010' 'w:1 v:4 l:1 00'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00010'}
end

val p/vex/66/0f/38 [0xc4 'r:1 x:1 b:1 00010' 'w:1 v:4 l:1 01'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00010'}
end

val p/vex/f2/0f/38 [0xc4 'r:1 x:1 b:1 00010' 'w:1 v:4 l:1 11'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00010'}
end

val p/vex/f3/0f/38 [0xc4 'r:1 x:1 b:1 00010' 'w:1 v:4 l:1 10'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00010'}
end

val p/vex/0f/3a [0xc4 'r:1 x:1 b:1 00011' 'w:1 v:4 l:1 00'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00011'}
end

val p/vex/66/0f/3a [0xc4 'r:1 x:1 b:1 00011' 'w:1 v:4 l:1 01'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00011'}
end

val p/vex/f2/0f/3a [0xc4 'r:1 x:1 b:1 00011' 'w:1 v:4 l:1 11'] = do
   update
      @{rex='1',
	rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00011'}
end

val p/vex/f3/0f/3a [0xc4 'r:1 x:1 b:1 00011' 'w:1 v:4 l:1 10'] = do
   update
      @{rex='1',
        rexw=w,
        vexw=w,
        rexr=not r,
        rexb=not b,
        rexx=not x,
        vexl=l,
        vexv=complement v,
        vexm='00011'}
end

val set-opndsz = update@{opndsz='1'}
val set-repne = update@{repne='1'}
val set-rep = update@{rep='1'}

val with-66 act = do
  update@{opndsz='1'};
  insn <- act;
  update@{opndsz='0'};
  return insn
end

val with-f2 act = do
  update@{repne='1'};
  insn <- act;
  update@{repne='0'};
  return insn
end

val with-f3 act = do
  update@{rep='1'};
  insn <- act;
  update@{rep='0'};
  return insn
end

val p64 [/66-p] = p/66
val p64 [/f2-p] = p/f2
val p64 [/f3-p] = p/f3
val p64 [/legacy-p] = p64
val p64 [/rex-p]
 | mode64? = p64
 | mode32? & rexw? = unop DEC rex/reg32
 | mode32? & // rexw? = unop INC rex/reg32
#val p64 [p/vex/0f] = /vex/0f
val p64 [p/vex/f2/0f]
 | vndd? = /vex/f2/0f/vexv
 | otherwise = /vex/f2/0f
val p64 [p/vex/f3/0f]
 | vndd? = /vex/f3/0f/vexv
 | otherwise = /vex/f3/0f
val p64 [p/vex/66/0f]
 | vndd? = /vex/66/0f/vexv
 | otherwise = /vex/66/0f
val p64 [p/vex/66/0f/38]
 | vndd? = /vex/66/0f/38/vexv
 | otherwise = /vex/66/0f/38
val p64 [p/vex/66/0f/3a]
 | vndd? = /vex/66/0f/3a/vexv
 | otherwise = /vex/66/0f/3a
#val p64 [p/vex/66/f2/0f]
# | vndd? = /vex/66/f2/0f/vexv
# | otherwise = /vex/66/f2/0f
#val p64 [p/vex/66/f3/0f]
# | vndd? = /vex/66/f3/0f/vexv
# | otherwise = /vex/66/f3/0f
val p64 [] = /

val p/66 [/66-p] = p/66/f2
val p/66 [/f2-p] = p/66/f3
val p/66 [/f3-p] = p/66
val p/66 [/legacy-p] = p/66
val p/66 [/rex-p]
 | mode64? = p/66
 | mode32? & rexw? = unop DEC rex/reg16
 | mode32? & // rexw? = unop INC rex/reg16
val p/66 [] = after /66 (with-66 /)

val p/f2 [/66-p] = p/66/f2
val p/f2 [/f2-p] = p/f2
val p/f2 [/f3-p] = p/f2/f3
val p/f2 [/legacy-p] = p/f2
val p/f2 [/rex-p]
 | mode64? = p/f2
 | mode32? & rexw? = unop DEC rex/reg32
 | mode32? & // rexw? = unop INC rex/reg32
val p/f2 [] = after /f2 (with-f2 /)

val p/f3 [/66-p] = p/66/f3
val p/f3 [/f2-p] = p/f3/f2
val p/f3 [/f3-p] = p/f3
val p/f3 [/legacy-p] = p/f3
val p/f3 [/rex-p]
 | mode64? = p/f3
 | mode32? & rexw? = unop DEC rex/reg32
 | mode32? & // rexw? = unop INC rex/reg32
val p/f3 [] = after /f3 (with-f3 /)

val p/f2/f3 [/66-p] = p/66/f2/f3
val p/f2/f3 [/f2-p] = p/f3/f2
val p/f2/f3 [/f3-p] = p/f2/f3
val p/f2/f3 [/legacy-p] = p/f2/f3
val p/f2/f3 [/rex-p]
 | mode64? = p/f2/f3
 | mode32? & rexw? = unop DEC rex/reg32
 | mode32? & // rexw? = unop INC rex/reg32
val p/f2/f3 [] = after (with-f2 /f3) (
                 after (with-f3 /f2) (with-f2 (with-f3 /)))

val p/f3/f2 [/66-p] = p/66/f2/f3
val p/f3/f2 [/f2-p] = p/f3/f2
val p/f3/f2 [/f3-p] = p/f2/f3
val p/f3/f2 [/legacy-p] = p/f3/f2
val p/f3/f2 [/rex-p]
 | mode64? = p/f3/f2
 | mode32? & rexw? = unop DEC rex/reg32
 | mode32? & // rexw? = unop INC rex/reg32
val p/f3/f2 [] = after (with-f3 /f2) (
                 after (with-f2 /f3) (with-f2 (with-f3 /)))

val p/66/f2 [/66-p] = p/66/f2
val p/66/f2 [/f2-p] = p/66/f2
val p/66/f2 [/f3-p] = p/66/f2/f3
val p/66/f2 [/legacy-p] = p/66/f2
val p/66/f2 [/rex-p]
 | mode64? = p/66/f2
 | mode32? & rexw? = unop DEC rex/reg16
 | mode32? & // rexw? = unop INC rex/reg16
val p/66/f2 [] = after (with-66 /f2) (
                 after (with-f2 /66) (with-66 (with-f2 /)))

val p/66/f3 [/66-p] = p/66/f3
val p/66/f3 [/f2-p] = p/66/f3/f2
val p/66/f3 [/f3-p] = p/66/f3
val p/66/f3 [/legacy-p] = p/66/f3
val p/66/f3 [/rex-p]
 | mode64? = p/66/f3
 | mode32? & rexw? = unop DEC rex/reg16
 | mode32? & // rexw? = unop INC rex/reg16
val p/66/f3 [] = after (with-66 /f3) (
                 after (with-f3 /66) (
                        with-66 (with-f3 /)))

val p/66/f2/f3 [/66-p] = do clear-rex; p/66/f2/f3 end
val p/66/f2/f3 [/f2-p] = do clear-rex; p/66/f3/f2 end
val p/66/f2/f3 [/f3-p] = do clear-rex; p/66/f2/f3 end
val p/66/f2/f3 [/legacy-p] = p/66/f2/f3
val p/66/f2/f3 [/rex-p]
 | mode64? = p/66/f2/f3
 | mode32? & rexw? = unop DEC rex/reg16
 | mode32? & // rexw? = unop INC rex/reg16
val p/66/f2/f3 [] = after (with-66 (with-f2 /f3)) (
                    after (with-66 (with-f3 /f2)) (
                    after (with-f2 (with-f3 /66)) (
                           with-66 (with-f2 (with-f3 /)))))

val p/66/f3/f2 [/66-p] = do clear-rex; p/66/f3/f2 end
val p/66/f3/f2 [/f2-p] = do clear-rex; p/66/f3/f2 end
val p/66/f3/f2 [/f3-p] = do clear-rex; p/66/f2/f3 end
val p/66/f3/f2 [/legacy-p] = p/66/f3/f2
val p/66/f3/f2 [/rex-p]
 | mode64? = p/66/f3/f2
 | mode32? & rexw? = unop DEC rex/reg16
 | mode32? & // rexw? = unop INC rex/reg16
val p/66/f3/f2 [] = after (with-66 (with-f3 /f2)) (
                    after (with-66 (with-f2 /f3)) (
		    after (with-f2 (with-f3 /66)) (
		           with-66 (with-f2 (with-f3 /)))))

type register =
   AL
 | AH
 | AX
 | EAX
 | RAX
 | BL
 | BH
 | BX
 | EBX
 | RBX
 | CL
 | CH
 | CX
 | ECX
 | RCX
 | DL
 | DH
 | DX
 | EDX
 | RDX
 | R8B
 | R8L
 | R8D
 | R8
 | R9B
 | R9L
 | R9D
 | R9
 | R10B
 | R10L
 | R10D
 | R10
 | R11B
 | R11L
 | R11D
 | R11
 | R12B
 | R12L
 | R12D
 | R12
 | R13B
 | R13L
 | R13D
 | R13
 | R14B
 | R14L
 | R14D
 | R14
 | R15B
 | R15L
 | R15D
 | R15
 | SP
 | ESP
 | RSP
 | BP
 | EBP
 | RBP
 | SI
 | ESI
 | RSI
 | DI
 | EDI
 | RDI
 | XMM0
 | XMM1
 | XMM2
 | XMM3
 | XMM4
 | XMM5
 | XMM6
 | XMM7
 | XMM8
 | XMM9
 | XMM10
 | XMM11
 | XMM12
 | XMM13
 | XMM14
 | XMM15
 | YMM0
 | YMM1
 | YMM2
 | YMM3
 | YMM4
 | YMM5
 | YMM6
 | YMM7
 | YMM8
 | YMM9
 | YMM10
 | YMM11
 | YMM12
 | YMM13
 | YMM14
 | YMM15
 | MM0
 | MM1
 | MM2
 | MM3
 | MM4
 | MM5
 | MM6
 | MM7
 | ES
 | SS
 | DS
 | FS
 | GS
 | CS
 | ST0
 | ST1
 | ST2
 | ST3
 | ST4
 | ST5
 | ST6
 | ST7
 | RIP

type opnd =
   IMM8 of 8
 | IMM16 of 16
 | IMM32 of 32
 | IMM64 of 64
 | REG of register
 | MEM of {sz:int,psz:int,segment:seg_override,opnd:opnd}
 | SUM of {a:opnd,b:opnd}
 | SCALE of {imm:2,opnd:opnd}

type flowopnd =
   REL8 of 8
 | REL16 of 16
 | REL32 of 32
 | REL64 of 64
 | PTR16/16 of 32
 | PTR16/32 of 48
 | NEARABS of opnd
 | FARABS of opnd

type flow1 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1,opnd1:flowopnd}
type arity0 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1}
type arity1 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1,opnd1:opnd}
type arity2 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1,opnd1:opnd,opnd2:opnd}
type arity3 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1,opnd1:opnd,opnd2:opnd,opnd3:opnd}
type arity4 = {opnd-sz:int,addr-sz:int,rep:1,repne:1,lock:1,opnd1:opnd,opnd2:opnd,opnd3:opnd,opnd4:opnd}

type varity =
   VA0 of arity0
 | VA1 of arity1
 | VA2 of arity2
 | VA3 of arity3
 | VA4 of arity4

type insn =
   AAA of arity0
 | AAD of arity1
 | AAM of arity1
 | AAS of arity0
 | ADC of arity2
 | ADD of arity2
 | ADDPD of arity2
 | ADDPS of arity2
 | ADDSD of arity2
 | ADDSS of arity2
 | ADDSUBPD of arity2
 | ADDSUBPS of arity2
 | AESDEC of arity2
 | AESDECLAST of arity2
 | AESENC of arity2
 | AESENCLAST of arity2
 | AESIMC of arity2
 | AESKEYGENASSIST of arity3
 | AND of arity2
 | ANDNPD of arity2
 | ANDNPS of arity2
 | ANDPD of arity2
 | ANDPS of arity2
 | ARPL of arity2
 | BLENDPD of arity3
 | BLENDPS of arity3
 | BLENDVPD of arity3
 | BLENDVPS of arity3
 | BOUND of arity2
 | BSF of arity2
 | BSR of arity2
 | BSWAP of arity1
 | BT of arity2
 | BTC of arity2
 | BTR of arity2
 | BTS of arity2
 | CALL of flow1
 | CBW of arity0
 | CDQ of arity0
 | CDQE of arity0
 | CLC of arity0
 | CLD of arity0
 | CLFLUSH of arity1
 | CLI of arity0
 | CLTS of arity0
 | CMC of arity0
 | CMOVA of arity2
 | CMOVAE of arity2
 | CMOVB of arity2
 | CMOVBE of arity2
 | CMOVC of arity2
 | CMOVE of arity2
 | CMOVG of arity2
 | CMOVGE of arity2
 | CMOVL of arity2
 | CMOVLE of arity2
 | CMOVNA of arity2
 | CMOVNAE of arity2
 | CMOVNB of arity2
 | CMOVNBE of arity2
 | CMOVNC of arity2
 | CMOVNE of arity2
 | CMOVNG of arity2
 | CMOVNGE of arity2
 | CMOVNL of arity2
 | CMOVNLE of arity2
 | CMOVNO of arity2
 | CMOVNP of arity2
 | CMOVNS of arity2
 | CMOVNZ of arity2
 | CMOVO of arity2
 | CMOVP of arity2
 | CMOVPE of arity2
 | CMOVPO of arity2
 | CMOVS of arity2
 | CMOVZ of arity2
 | CMP of arity2
 | CMPPD of arity3
 | CMPPS of arity3
 | CMPS of arity2
 | CMPSD of arity3
 | CMPSS of arity3
 | CMPXCHG of arity2
 | CMPXCHG16B of arity1
 | CMPXCHG8B of arity1
 | COMISD of arity2
 | COMISS of arity2
 | CPUID of arity0
 | CQO of arity0
 | CRC32 of arity2
 | CVTDQ2PD of arity2
 | CVTDQ2PS of arity2
 | CVTPD2DQ of arity2
 | CVTPD2PI of arity2
 | CVTPD2PS of arity2
 | CVTPI2PD of arity2
 | CVTPI2PS of arity2
 | CVTPS2DQ of arity2
 | CVTPS2PD of arity2
 | CVTPS2PI of arity2
 | CVTSD2SI of arity2
 | CVTSD2SS of arity2
 | CVTSI2SD of arity2
 | CVTSI2SS of arity2
 | CVTSS2SD of arity2
 | CVTSS2SI of arity2
 | CVTTPD2DQ of arity2
 | CVTTPD2PI of arity2
 | CVTTPS2DQ of arity2
 | CVTTPS2PI of arity2
 | CVTTSD2SI of arity2
 | CVTTSS2SI of arity2
 | CWD of arity0
 | CWDE of arity0
 | DAA of arity0
 | DAS of arity0
 | DEC of arity1
 | DIV of arity1
 | DIVPD of arity2
 | DIVPS of arity2
 | DIVSD of arity2
 | DIVSS of arity2
 | DPPD of arity3
 | DPPS of arity3
 | EMMS of arity0
 | ENTER of arity2
 | EXTRACTPS of arity3
 | F2XM1 of arity0
 | FABS of arity0
 | FADD of arity2
 | FADDP of arity2
 | FBLD of arity1
 | FBSTP of arity1
 | FCHS of arity0
 | FCLEX of arity0
 | FCMOVB of arity2
 | FCMOVBE of arity2
 | FCMOVE of arity2
 | FCMOVNB of arity2
 | FCMOVNBE of arity2
 | FCMOVNE of arity2
 | FCMOVNU of arity2
 | FCMOVU of arity2
 | FCOM of arity1
 | FCOMI of arity2
 | FCOMIP of arity2
 | FCOMP of arity1
 | FCOMPP of arity0
 | FCOS of arity0
 | FDECSTP of arity0
 | FDIV of arity2
 | FDIVP of arity2
 | FDIVR of arity2
 | FDIVRP of arity2
 | FFREE of arity1
 | FIADD of arity1
 | FICOM of arity1
 | FICOMP of arity1
 | FIDIV of arity2
 | FIDIVR of arity1
 | FILD of arity1
 | FIMUL of arity1
 | FINCSTP of arity0
 | FINIT of arity0
 | FIST of arity1
 | FISTP of arity1
 | FISTTP of arity1
 | FISUB of arity1
 | FISUBR of arity1
 | FLD of arity1
 | FLD1 of arity0
 | FLDCW of arity1
 | FLDENV of arity1
 | FLDL2E of arity0
 | FLDL2T of arity0
 | FLDLG2 of arity0
 | FLDLN2 of arity0
 | FLDPI of arity0
 | FLDZ of arity0
 | FMUL of arity2
 | FMULP of arity2
 | FNCLEX of arity0
 | FNINIT of arity0
 | FNOP of arity0
 | FNSAVE of arity1
 | FNSTCW of arity1
 | FNSTENV of arity1
 | FNSTSW of arity1
 | FPATAN of arity0
 | FPREM of arity0
 | FPREM1 of arity0
 | FPTAN of arity0
 | FRNDINT of arity0
 | FRSTOR of arity1
 | FSAVE of arity1
 | FSCALE of arity0
 | FSIN of arity0
 | FSINCOS of arity0
 | FSQRT of arity0
 | FST of arity1
 | FSTCW of arity1
 | FSTENV of arity1
 | FSTP of arity1
 | FSTSW of arity1
 | FSUB of arity2
 | FSUBP of arity2
 | FSUBR of arity2
 | FSUBRP of arity2
 | FTST of arity0
 | FUCOM of arity1
 | FUCOMI of arity1
 | FUCOMIP of arity1
 | FUCOMP of arity1
 | FUCOMPP of arity0
 | FXAM of arity0
 | FXCH of arity1
 | FXRSTOR of arity1
 | FXRSTOR64 of arity1
 | FXSAVE of arity1
 | FXSAVE64 of arity1
 | FXTRACT of arity0
 | FYL2X of arity0
 | FYL2XP1 of arity0
 | HADDPD of arity2
 | HADDPS of arity2
 | HLT of arity0
 | HSUBPD of arity2
 | HSUBPS of arity2
 | IDIV of arity1
 | IMUL of varity
 | IN of arity2
 | INC of arity1
 | INSB of arity0
 | INSD of arity0
 | INSERTPS of arity3
 | INSW of arity0
 | INT of arity1
 | INT0 of arity0
 | INT3 of arity0
 | INVD of arity0
 | INVLPG of arity1
 | INVPCID of arity2
 | IRET of arity0
 | IRETD of arity0
 | IRETQ of arity0
 | JA of flow1
 | JAE of flow1
 | JB of flow1
 | JBE of flow1
 | JC of flow1
 | JCXZ of flow1
 | JE of flow1
 | JECXZ of flow1
 | JG of flow1
 | JGE of flow1
 | JL of flow1
 | JLE of flow1
 | JMP of flow1
 | JNA of flow1
 | JNAE of flow1
 | JNB of flow1
 | JNBE of flow1
 | JNC of flow1
 | JNE of flow1
 | JNG of flow1
 | JNGE of flow1
 | JNL of flow1
 | JNLE of flow1
 | JNO of flow1
 | JNP of flow1
 | JNS of flow1
 | JNZ of flow1
 | JO of flow1
 | JP of flow1
 | JPE of flow1
 | JPO of flow1
 | JRCXZ of flow1
 | JS of flow1
 | JZ of flow1
 | LAHF of arity0
 | LAR of arity2
 | LDDQU of arity2
 | LDMXCSR of arity1
 | LDS of arity2
 | LEA of arity2
 | LEAVE of arity0
 | LES of arity2
 | LFENCE of arity0
 | LFS of arity2
 | LGDT of arity1
 | LGS of arity2
 | LIDT of arity1
 | LLDT of arity1
 | LMSW of arity1
 | LODS of arity1
 | LOOP of flow1
 | LOOPE of flow1
 | LOOPNE of flow1
 | LSL of arity2
 | LSS of arity2
 | LTR of arity1
 | MASKMOVDQU of arity3
 | MASKMOVQ of arity3
 | MAXPD of arity2
 | MAXPS of arity2
 | MAXSD of arity2
 | MAXSS of arity2
 | MFENCE of arity0
 | MINPD of arity2
 | MINPS of arity2
 | MINSD of arity2
 | MINSS of arity2
 | MONITOR of arity0
 | MOV of arity2
 | MOVAPD of arity2
 | MOVAPS of arity2
 | MOVBE of arity2
 | MOVD of arity2
 | MOVDDUP of arity2
 | MOVDQ2Q of arity2
 | MOVDQA of arity2
 | MOVDQU of arity2
 | MOVHLPS of arity2
 | MOVHPD of arity2
 | MOVHPS of arity2
 | MOVLHPS of arity2
 | MOVLPD of arity2
 | MOVLPS of arity2
 | MOVMSKPD of arity2
 | MOVMSKPS of arity2
 | MOVNTDQ of arity2
 | MOVNTDQA of arity2
 | MOVNTI of arity2
 | MOVNTPD of arity2
 | MOVNTPS of arity2
 | MOVNTQ of arity2
 | MOVQ of arity2
 | MOVQ2DQ of arity2
 | MOVS of arity2
 | MOVSD of arity2
 | MOVSHDUP of arity2
 | MOVSLDUP of arity2
 | MOVSS of arity2
 | MOVSW of arity2
 | MOVSX of arity2
 | MOVSXD of arity2
 | MOVUPD of arity2
 | MOVUPS of arity2
 | MOVZX of arity2
 | MPSADBW of arity3
 | MUL of arity1
 | MULPD of arity2
 | MULPS of arity2
 | MULSD of arity2
 | MULSS of arity2
 | MWAIT of arity0
 | NEG of arity1
 | NOP of varity
 | NOT of arity1
 | OR of arity2
 | ORPD of arity2
 | ORPS of arity2
 | OUT of arity2
 | OUTS of arity0
 | OUTSB of arity0
 | OUTSD of arity0