Module inst

Expose all known instructions as Rust structs; this is generated in build.rs.

See also: Inst, an enum containing all these instructions.

Structs

• adcb_i
  adcb: I(al[rw], imm8) => 0x14 ib [_64b | compat]
• adcb_mi
  adcb: MI(rm8[rw], imm8) => 0x80 /2 ib [_64b | compat]
• adcb_mr
  adcb: MR(rm8[rw], r8) => 0x10 /r [_64b | compat]
• adcb_rm
  adcb: RM(r8[rw], rm8) => 0x12 /r [_64b | compat]
• adcl_i
  adcl: I(eax[rw], imm32) => 0x15 id [_64b | compat]
• adcl_mi
  adcl: MI(rm32[rw], imm32) => 0x81 /2 id [_64b | compat]
• adcl_mi_sxb
  adcl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /2 ib [_64b | compat]
• adcl_mr
  adcl: MR(rm32[rw], r32) => 0x11 /r [_64b | compat]
• adcl_rm
  adcl: RM(r32[rw], rm32) => 0x13 /r [_64b | compat]
• adcq_i_sxl
  adcq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x15 id [_64b]
• adcq_mi_sxb
  adcq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /2 ib [_64b]
• adcq_mi_sxl
  adcq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /2 id [_64b]
• adcq_mr
  adcq: MR(rm64[rw], r64) => REX.W + 0x11 /r [_64b]
• adcq_rm
  adcq: RM(r64[rw], rm64) => REX.W + 0x13 /r [_64b]
• adcw_i
  adcw: I(ax[rw], imm16) => 0x66 + 0x15 iw [_64b | compat]
• adcw_mi
  adcw: MI(rm16[rw], imm16) => 0x66 + 0x81 /2 iw [_64b | compat]
• adcw_mr
  adcw: MR(rm16[rw], r16) => 0x66 + 0x11 /r [_64b | compat]
• adcw_rm
  adcw: RM(r16[rw], rm16) => 0x66 + 0x13 /r [_64b | compat]
• addb_i
  addb: I(al[rw], imm8) => 0x04 ib [_64b | compat]
• addb_mi
  addb: MI(rm8[rw], imm8) => 0x80 /0 ib [_64b | compat]
• addb_mr
  addb: MR(rm8[rw], r8) => 0x00 /r [_64b | compat]
• addb_rm
  addb: RM(r8[rw], rm8) => 0x02 /r [_64b | compat]
• addl_i
  addl: I(eax[rw], imm32) => 0x05 id [_64b | compat]
• addl_mi
  addl: MI(rm32[rw], imm32) => 0x81 /0 id [_64b | compat]
• addl_mi_sxb
  addl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /0 ib [_64b | compat]
• addl_mr
  addl: MR(rm32[rw], r32) => 0x01 /r [_64b | compat]
• addl_rm
  addl: RM(r32[rw], rm32) => 0x03 /r [_64b | compat]
• addq_i_sxl
  addq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x05 id [_64b]
• addq_mi_sxb
  addq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /0 ib [_64b]
• addq_mi_sxl
  addq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /0 id [_64b]
• addq_mr
  addq: MR(rm64[rw], r64) => REX.W + 0x01 /r [_64b]
• addq_rm
  addq: RM(r64[rw], rm64) => REX.W + 0x03 /r [_64b]
• addw_i
  addw: I(ax[rw], imm16) => 0x66 + 0x05 iw [_64b | compat]
• addw_mi
  addw: MI(rm16[rw], imm16) => 0x66 + 0x81 /0 iw [_64b | compat]
• addw_mr
  addw: MR(rm16[rw], r16) => 0x66 + 0x01 /r [_64b | compat]
• addw_rm
  addw: RM(r16[rw], rm16) => 0x66 + 0x03 /r [_64b | compat]
• andb_i
  andb: I(al[rw], imm8) => 0x24 ib [_64b | compat]
• andb_mi
  andb: MI(rm8[rw], imm8) => 0x80 /4 ib [_64b | compat]
• andb_mr
  andb: MR(rm8[rw], r8) => 0x20 /r [_64b | compat]
• andb_rm
  andb: RM(r8[rw], rm8) => 0x22 /r [_64b | compat]
• andl_i
  andl: I(eax[rw], imm32) => 0x25 id [_64b | compat]
• andl_mi
  andl: MI(rm32[rw], imm32) => 0x81 /4 id [_64b | compat]
• andl_mi_sxb
  andl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /4 ib [_64b | compat]
• andl_mr
  andl: MR(rm32[rw], r32) => 0x21 /r [_64b | compat]
• andl_rm
  andl: RM(r32[rw], rm32) => 0x23 /r [_64b | compat]
• andq_i_sxl
  andq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x25 id [_64b]
• andq_mi_sxb
  andq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /4 ib [_64b]
• andq_mi_sxl
  andq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /4 id [_64b]
• andq_mr
  andq: MR(rm64[rw], r64) => REX.W + 0x21 /r [_64b]
• andq_rm
  andq: RM(r64[rw], rm64) => REX.W + 0x23 /r [_64b]
• andw_i
  andw: I(ax[rw], imm16) => 0x66 + 0x25 iw [_64b | compat]
• andw_mi
  andw: MI(rm16[rw], imm16) => 0x66 + 0x81 /4 iw [_64b | compat]
• andw_mr
  andw: MR(rm16[rw], r16) => 0x66 + 0x21 /r [_64b | compat]
• andw_rm
  andw: RM(r16[rw], rm16) => 0x66 + 0x23 /r [_64b | compat]
• orb_i
  orb: I(al[rw], imm8) => 0x0c ib [_64b | compat]
• orb_mi
  orb: MI(rm8[rw], imm8) => 0x80 /1 ib [_64b | compat]
• orb_mr
  orb: MR(rm8[rw], r8) => 0x08 /r [_64b | compat]
• orb_rm
  orb: RM(r8[rw], rm8) => 0x0a /r [_64b | compat]
• orl_i
  orl: I(eax[rw], imm32) => 0x0d id [_64b | compat]
• orl_mi
  orl: MI(rm32[rw], imm32) => 0x81 /1 id [_64b | compat]
• orl_mi_sxb
  orl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /1 ib [_64b | compat]
• orl_mr
  orl: MR(rm32[rw], r32) => 0x09 /r [_64b | compat]
• orl_rm
  orl: RM(r32[rw], rm32) => 0x0b /r [_64b | compat]
• orpd_a
  orpd: A(xmm[rw], rm128) => 0x66 + 0x0F + 0x56 /r [_64b]
• orq_i_sxl
  orq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x0d id [_64b]
• orq_mi_sxb
  orq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /1 ib [_64b]
• orq_mi_sxl
  orq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /1 id [_64b]
• orq_mr
  orq: MR(rm64[rw], r64) => REX.W + 0x09 /r [_64b]
• orq_rm
  orq: RM(r64[rw], rm64) => REX.W + 0x0b /r [_64b]
• orw_i
  orw: I(ax[rw], imm16) => 0x66 + 0x0d iw [_64b | compat]
• orw_mi
  orw: MI(rm16[rw], imm16) => 0x66 + 0x81 /1 iw [_64b | compat]
• orw_mr
  orw: MR(rm16[rw], r16) => 0x66 + 0x09 /r [_64b | compat]
• orw_rm
  orw: RM(r16[rw], rm16) => 0x66 + 0x0b /r [_64b | compat]
• sbbb_i
  sbbb: I(al[rw], imm8) => 0x1c ib [_64b | compat]
• sbbb_mi
  sbbb: MI(rm8[rw], imm8) => 0x80 /3 ib [_64b | compat]
• sbbb_mr
  sbbb: MR(rm8[rw], r8) => 0x18 /r [_64b | compat]
• sbbb_rm
  sbbb: RM(r8[rw], rm8) => 0x1a /r [_64b | compat]
• sbbl_i
  sbbl: I(eax[rw], imm32) => 0x1d id [_64b | compat]
• sbbl_mi
  sbbl: MI(rm32[rw], imm32) => 0x81 /3 id [_64b | compat]
• sbbl_mi_sxb
  sbbl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /3 ib [_64b | compat]
• sbbl_mr
  sbbl: MR(rm32[rw], r32) => 0x19 /r [_64b | compat]
• sbbl_rm
  sbbl: RM(r32[rw], rm32) => 0x1b /r [_64b | compat]
• sbbq_i_sxl
  sbbq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x1d id [_64b]
• sbbq_mi_sxb
  sbbq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /3 ib [_64b]
• sbbq_mi_sxl
  sbbq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /3 id [_64b]
• sbbq_mr
  sbbq: MR(rm64[rw], r64) => REX.W + 0x19 /r [_64b]
• sbbq_rm
  sbbq: RM(r64[rw], rm64) => REX.W + 0x1b /r [_64b]
• sbbw_i
  sbbw: I(ax[rw], imm16) => 0x66 + 0x1d iw [_64b | compat]
• sbbw_mi
  sbbw: MI(rm16[rw], imm16) => 0x66 + 0x81 /3 iw [_64b | compat]
• sbbw_mr
  sbbw: MR(rm16[rw], r16) => 0x66 + 0x19 /r [_64b | compat]
• sbbw_rm
  sbbw: RM(r16[rw], rm16) => 0x66 + 0x1b /r [_64b | compat]
• shldl_mrc
  shldl: MRC(rm32[rw], r32, cl) => 0x0F + 0xa5 ib [_64b | compat]
• shldl_mri
  shldl: MRI(rm32[rw], r32, imm8) => 0x0F + 0xa4 ib [_64b | compat]
• shldq_mrc
  shldq: MRC(rm64[rw], r64, cl) => REX.W + 0x0F + 0xa5 ib [_64b]
• shldq_mri
  shldq: MRI(rm64[rw], r64, imm8) => REX.W + 0x0F + 0xa4 ib [_64b]
• shldw_mrc
  shldw: MRC(rm16[rw], r16, cl) => 0x66 + 0x0F + 0xa5 ib [_64b | compat]
• shldw_mri
  shldw: MRI(rm16[rw], r16, imm8) => 0x66 + 0x0F + 0xa4 ib [_64b | compat]
• subb_i
  subb: I(al[rw], imm8) => 0x2c ib [_64b | compat]
• subb_mi
  subb: MI(rm8[rw], imm8) => 0x80 /5 ib [_64b | compat]
• subb_mr
  subb: MR(rm8[rw], r8) => 0x28 /r [_64b | compat]
• subb_rm
  subb: RM(r8[rw], rm8) => 0x2a /r [_64b | compat]
• subl_i
  subl: I(eax[rw], imm32) => 0x2d id [_64b | compat]
• subl_mi
  subl: MI(rm32[rw], imm32) => 0x81 /5 id [_64b | compat]
• subl_mi_sxb
  subl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /5 ib [_64b | compat]
• subl_mr
  subl: MR(rm32[rw], r32) => 0x29 /r [_64b | compat]
• subl_rm
  subl: RM(r32[rw], rm32) => 0x2b /r [_64b | compat]
• subq_i_sxl
  subq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x2d id [_64b]
• subq_mi_sxb
  subq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /5 ib [_64b]
• subq_mi_sxl
  subq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /5 id [_64b]
• subq_mr
  subq: MR(rm64[rw], r64) => REX.W + 0x29 /r [_64b]
• subq_rm
  subq: RM(r64[rw], rm64) => REX.W + 0x2b /r [_64b]
• subw_i
  subw: I(ax[rw], imm16) => 0x66 + 0x2d iw [_64b | compat]
• subw_mi
  subw: MI(rm16[rw], imm16) => 0x66 + 0x81 /5 iw [_64b | compat]
• subw_mr
  subw: MR(rm16[rw], r16) => 0x66 + 0x29 /r [_64b | compat]
• subw_rm
  subw: RM(r16[rw], rm16) => 0x66 + 0x2b /r [_64b | compat]
• xorb_i
  xorb: I(al[rw], imm8) => 0x34 ib [_64b | compat]
• xorb_mi
  xorb: MI(rm8[rw], imm8) => 0x80 /6 ib [_64b | compat]
• xorb_mr
  xorb: MR(rm8[rw], r8) => 0x30 /r [_64b | compat]
• xorb_rm
  xorb: RM(r8[rw], rm8) => 0x32 /r [_64b | compat]
• xorl_i
  xorl: I(eax[rw], imm32) => 0x35 id [_64b | compat]
• xorl_mi
  xorl: MI(rm32[rw], imm32) => 0x81 /6 id [_64b | compat]
• xorl_mi_sxb
  xorl: MI_SXB(rm32[rw], imm8[sxl]) => 0x83 /6 ib [_64b | compat]
• xorl_mr
  xorl: MR(rm32[rw], r32) => 0x31 /r [_64b | compat]
• xorl_rm
  xorl: RM(r32[rw], rm32) => 0x33 /r [_64b | compat]
• xorq_i_sxl
  xorq: I_SXL(rax[rw], imm32[sxq]) => REX.W + 0x35 id [_64b]
• xorq_mi_sxb
  xorq: MI_SXB(rm64[rw], imm8[sxq]) => REX.W + 0x83 /6 ib [_64b]
• xorq_mi_sxl
  xorq: MI_SXL(rm64[rw], imm32[sxq]) => REX.W + 0x81 /6 id [_64b]
• xorq_mr
  xorq: MR(rm64[rw], r64) => REX.W + 0x31 /r [_64b]
• xorq_rm
  xorq: RM(r64[rw], rm64) => REX.W + 0x33 /r [_64b]
• xorw_i
  xorw: I(ax[rw], imm16) => 0x66 + 0x35 iw [_64b | compat]
• xorw_mi
  xorw: MI(rm16[rw], imm16) => 0x66 + 0x81 /6 iw [_64b | compat]
• xorw_mr
  xorw: MR(rm16[rw], r16) => 0x66 + 0x31 /r [_64b | compat]
• xorw_rm
  xorw: RM(r16[rw], rm16) => 0x66 + 0x33 /r [_64b | compat]