pub enum Inst<R: Registers> {
Show 719 variants
pabsb_a(pabsb_a<R>),
vpabsb_a(vpabsb_a<R>),
pabsw_a(pabsw_a<R>),
vpabsw_a(vpabsw_a<R>),
pabsd_a(pabsd_a<R>),
vpabsd_a(vpabsd_a<R>),
addb_i(addb_i<R>),
addw_i(addw_i<R>),
addl_i(addl_i<R>),
addq_i_sxl(addq_i_sxl<R>),
addb_mi(addb_mi<R>),
addw_mi(addw_mi<R>),
addl_mi(addl_mi<R>),
addq_mi_sxl(addq_mi_sxl<R>),
addl_mi_sxb(addl_mi_sxb<R>),
addq_mi_sxb(addq_mi_sxb<R>),
addb_mr(addb_mr<R>),
addw_mr(addw_mr<R>),
addl_mr(addl_mr<R>),
addq_mr(addq_mr<R>),
addb_rm(addb_rm<R>),
addw_rm(addw_rm<R>),
addl_rm(addl_rm<R>),
addq_rm(addq_rm<R>),
adcb_i(adcb_i<R>),
adcw_i(adcw_i<R>),
adcl_i(adcl_i<R>),
adcq_i_sxl(adcq_i_sxl<R>),
adcb_mi(adcb_mi<R>),
adcw_mi(adcw_mi<R>),
adcl_mi(adcl_mi<R>),
adcq_mi_sxl(adcq_mi_sxl<R>),
adcl_mi_sxb(adcl_mi_sxb<R>),
adcq_mi_sxb(adcq_mi_sxb<R>),
adcb_mr(adcb_mr<R>),
adcw_mr(adcw_mr<R>),
adcl_mr(adcl_mr<R>),
adcq_mr(adcq_mr<R>),
adcb_rm(adcb_rm<R>),
adcw_rm(adcw_rm<R>),
adcl_rm(adcl_rm<R>),
adcq_rm(adcq_rm<R>),
lock_addb_mi(lock_addb_mi<R>),
lock_addw_mi(lock_addw_mi<R>),
lock_addl_mi(lock_addl_mi<R>),
lock_addq_mi_sxl(lock_addq_mi_sxl<R>),
lock_addl_mi_sxb(lock_addl_mi_sxb<R>),
lock_addq_mi_sxb(lock_addq_mi_sxb<R>),
lock_addb_mr(lock_addb_mr<R>),
lock_addw_mr(lock_addw_mr<R>),
lock_addl_mr(lock_addl_mr<R>),
lock_addq_mr(lock_addq_mr<R>),
lock_adcb_mi(lock_adcb_mi<R>),
lock_adcw_mi(lock_adcw_mi<R>),
lock_adcl_mi(lock_adcl_mi<R>),
lock_adcq_mi_sxl(lock_adcq_mi_sxl<R>),
lock_adcl_mi_sxb(lock_adcl_mi_sxb<R>),
lock_adcq_mi_sxb(lock_adcq_mi_sxb<R>),
lock_adcb_mr(lock_adcb_mr<R>),
lock_adcw_mr(lock_adcw_mr<R>),
lock_adcl_mr(lock_adcl_mr<R>),
lock_adcq_mr(lock_adcq_mr<R>),
addss_a(addss_a<R>),
addsd_a(addsd_a<R>),
addps_a(addps_a<R>),
vaddps_b(vaddps_b<R>),
addpd_a(addpd_a<R>),
vaddpd_b(vaddpd_b<R>),
paddb_a(paddb_a<R>),
paddw_a(paddw_a<R>),
paddd_a(paddd_a<R>),
paddq_a(paddq_a<R>),
paddsb_a(paddsb_a<R>),
paddsw_a(paddsw_a<R>),
paddusb_a(paddusb_a<R>),
paddusw_a(paddusw_a<R>),
phaddw_a(phaddw_a<R>),
phaddd_a(phaddd_a<R>),
lock_xaddb_mr(lock_xaddb_mr<R>),
lock_xaddw_mr(lock_xaddw_mr<R>),
lock_xaddl_mr(lock_xaddl_mr<R>),
lock_xaddq_mr(lock_xaddq_mr<R>),
andb_i(andb_i<R>),
andw_i(andw_i<R>),
andl_i(andl_i<R>),
andq_i_sxl(andq_i_sxl<R>),
andb_mi(andb_mi<R>),
andw_mi(andw_mi<R>),
andl_mi(andl_mi<R>),
andq_mi_sxl(andq_mi_sxl<R>),
andl_mi_sxb(andl_mi_sxb<R>),
andq_mi_sxb(andq_mi_sxb<R>),
andb_mr(andb_mr<R>),
andw_mr(andw_mr<R>),
andl_mr(andl_mr<R>),
andq_mr(andq_mr<R>),
andb_rm(andb_rm<R>),
andw_rm(andw_rm<R>),
andl_rm(andl_rm<R>),
andq_rm(andq_rm<R>),
andnl_rvm(andnl_rvm<R>),
andnq_rvm(andnq_rvm<R>),
lock_andb_mi(lock_andb_mi<R>),
lock_andw_mi(lock_andw_mi<R>),
lock_andl_mi(lock_andl_mi<R>),
lock_andq_mi_sxl(lock_andq_mi_sxl<R>),
lock_andl_mi_sxb(lock_andl_mi_sxb<R>),
lock_andq_mi_sxb(lock_andq_mi_sxb<R>),
lock_andb_mr(lock_andb_mr<R>),
lock_andw_mr(lock_andw_mr<R>),
lock_andl_mr(lock_andl_mr<R>),
lock_andq_mr(lock_andq_mr<R>),
andps_a(andps_a<R>),
andpd_a(andpd_a<R>),
andnps_a(andnps_a<R>),
andnpd_a(andnpd_a<R>),
pand_a(pand_a<R>),
pandn_a(pandn_a<R>),
xchgb_rm(xchgb_rm<R>),
xchgw_rm(xchgw_rm<R>),
xchgl_rm(xchgl_rm<R>),
xchgq_rm(xchgq_rm<R>),
cmpxchg16b_m(cmpxchg16b_m<R>),
lock_cmpxchg16b_m(lock_cmpxchg16b_m<R>),
cmpxchgb_mr(cmpxchgb_mr<R>),
cmpxchgw_mr(cmpxchgw_mr<R>),
cmpxchgl_mr(cmpxchgl_mr<R>),
cmpxchgq_mr(cmpxchgq_mr<R>),
lock_cmpxchgb_mr(lock_cmpxchgb_mr<R>),
lock_cmpxchgw_mr(lock_cmpxchgw_mr<R>),
lock_cmpxchgl_mr(lock_cmpxchgl_mr<R>),
lock_cmpxchgq_mr(lock_cmpxchgq_mr<R>),
pavgb_a(pavgb_a<R>),
vpavgb_b(vpavgb_b<R>),
pavgw_a(pavgw_a<R>),
vpavgw_b(vpavgw_b<R>),
bsfw_rm(bsfw_rm<R>),
bsfl_rm(bsfl_rm<R>),
bsfq_rm(bsfq_rm<R>),
bsrw_rm(bsrw_rm<R>),
bsrl_rm(bsrl_rm<R>),
bsrq_rm(bsrq_rm<R>),
tzcntw_a(tzcntw_a<R>),
tzcntl_a(tzcntl_a<R>),
tzcntq_a(tzcntq_a<R>),
lzcntw_rm(lzcntw_rm<R>),
lzcntl_rm(lzcntl_rm<R>),
lzcntq_rm(lzcntq_rm<R>),
popcntw_rm(popcntw_rm<R>),
popcntl_rm(popcntl_rm<R>),
popcntq_rm(popcntq_rm<R>),
cbtw_zo(cbtw_zo<R>),
cwtl_zo(cwtl_zo<R>),
cltq_zo(cltq_zo<R>),
cwtd_zo(cwtd_zo<R>),
cltd_zo(cltd_zo<R>),
cqto_zo(cqto_zo<R>),
bswapl_o(bswapl_o<R>),
bswapq_o(bswapq_o<R>),
blsrl_vm(blsrl_vm<R>),
blsrq_vm(blsrq_vm<R>),
blsmskl_vm(blsmskl_vm<R>),
blsmskq_vm(blsmskq_vm<R>),
blsil_vm(blsil_vm<R>),
blsiq_vm(blsiq_vm<R>),
bzhil_rmv(bzhil_rmv<R>),
bzhiq_rmv(bzhiq_rmv<R>),
pcmpeqb_a(pcmpeqb_a<R>),
pcmpeqw_a(pcmpeqw_a<R>),
pcmpeqd_a(pcmpeqd_a<R>),
pcmpeqq_a(pcmpeqq_a<R>),
pcmpgtb_a(pcmpgtb_a<R>),
pcmpgtw_a(pcmpgtw_a<R>),
pcmpgtd_a(pcmpgtd_a<R>),
pcmpgtq_a(pcmpgtq_a<R>),
vpcmpeqb_b(vpcmpeqb_b<R>),
vpcmpeqw_b(vpcmpeqw_b<R>),
vpcmpeqd_b(vpcmpeqd_b<R>),
vpcmpeqq_b(vpcmpeqq_b<R>),
vpcmpgtb_b(vpcmpgtb_b<R>),
vpcmpgtw_b(vpcmpgtw_b<R>),
vpcmpgtd_b(vpcmpgtd_b<R>),
vpcmpgtq_b(vpcmpgtq_b<R>),
cmppd_a(cmppd_a<R>),
cmpps_a(cmpps_a<R>),
cmpsd_a(cmpsd_a<R>),
cmpss_a(cmpss_a<R>),
ucomisd_a(ucomisd_a<R>),
ucomiss_a(ucomiss_a<R>),
cmpb_i(cmpb_i<R>),
cmpw_i(cmpw_i<R>),
cmpl_i(cmpl_i<R>),
cmpq_i(cmpq_i<R>),
cmpb_mi(cmpb_mi<R>),
cmpw_mi(cmpw_mi<R>),
cmpl_mi(cmpl_mi<R>),
cmpq_mi(cmpq_mi<R>),
cmpw_mi_sxb(cmpw_mi_sxb<R>),
cmpl_mi_sxb(cmpl_mi_sxb<R>),
cmpq_mi_sxb(cmpq_mi_sxb<R>),
cmpb_mr(cmpb_mr<R>),
cmpw_mr(cmpw_mr<R>),
cmpl_mr(cmpl_mr<R>),
cmpq_mr(cmpq_mr<R>),
cmpb_rm(cmpb_rm<R>),
cmpw_rm(cmpw_rm<R>),
cmpl_rm(cmpl_rm<R>),
cmpq_rm(cmpq_rm<R>),
testb_i(testb_i<R>),
testw_i(testw_i<R>),
testl_i(testl_i<R>),
testq_i(testq_i<R>),
testb_mi(testb_mi<R>),
testw_mi(testw_mi<R>),
testl_mi(testl_mi<R>),
testq_mi(testq_mi<R>),
testb_mr(testb_mr<R>),
testw_mr(testw_mr<R>),
testl_mr(testl_mr<R>),
testq_mr(testq_mr<R>),
cvtps2pd_a(cvtps2pd_a<R>),
cvttps2dq_a(cvttps2dq_a<R>),
cvtss2sd_a(cvtss2sd_a<R>),
cvtss2si_a(cvtss2si_a<R>),
cvtss2si_aq(cvtss2si_aq<R>),
cvttss2si_a(cvttss2si_a<R>),
cvttss2si_aq(cvttss2si_aq<R>),
vcvtps2pd_a(vcvtps2pd_a<R>),
vcvttps2dq_a(vcvttps2dq_a<R>),
vcvtss2sd_b(vcvtss2sd_b<R>),
vcvtss2si_a(vcvtss2si_a<R>),
vcvtss2si_aq(vcvtss2si_aq<R>),
vcvttss2si_a(vcvttss2si_a<R>),
vcvttss2si_aq(vcvttss2si_aq<R>),
cvtpd2ps_a(cvtpd2ps_a<R>),
cvttpd2dq_a(cvttpd2dq_a<R>),
cvtsd2ss_a(cvtsd2ss_a<R>),
cvtsd2si_a(cvtsd2si_a<R>),
cvtsd2si_aq(cvtsd2si_aq<R>),
cvttsd2si_a(cvttsd2si_a<R>),
cvttsd2si_aq(cvttsd2si_aq<R>),
vcvtpd2ps_a(vcvtpd2ps_a<R>),
vcvttpd2dq_a(vcvttpd2dq_a<R>),
vcvtsd2ss_b(vcvtsd2ss_b<R>),
vcvtsd2si_a(vcvtsd2si_a<R>),
vcvtsd2si_aq(vcvtsd2si_aq<R>),
vcvttsd2si_a(vcvttsd2si_a<R>),
vcvttsd2si_aq(vcvttsd2si_aq<R>),
cvtdq2ps_a(cvtdq2ps_a<R>),
cvtdq2pd_a(cvtdq2pd_a<R>),
cvtsi2ssl_a(cvtsi2ssl_a<R>),
cvtsi2ssq_a(cvtsi2ssq_a<R>),
cvtsi2sdl_a(cvtsi2sdl_a<R>),
cvtsi2sdq_a(cvtsi2sdq_a<R>),
vcvtdq2pd_a(vcvtdq2pd_a<R>),
vcvtdq2ps_a(vcvtdq2ps_a<R>),
vcvtsi2sdl_b(vcvtsi2sdl_b<R>),
vcvtsi2sdq_b(vcvtsi2sdq_b<R>),
vcvtsi2ssl_b(vcvtsi2ssl_b<R>),
vcvtsi2ssq_b(vcvtsi2ssq_b<R>),
divb_m(divb_m<R>),
divw_m(divw_m<R>),
divl_m(divl_m<R>),
divq_m(divq_m<R>),
idivb_m(idivb_m<R>),
idivw_m(idivw_m<R>),
idivl_m(idivl_m<R>),
idivq_m(idivq_m<R>),
divps_a(divps_a<R>),
divpd_a(divpd_a<R>),
divss_a(divss_a<R>),
divsd_a(divsd_a<R>),
vdivps_b(vdivps_b<R>),
vdivpd_b(vdivpd_b<R>),
vdivss_b(vdivss_b<R>),
vdivsd_b(vdivsd_b<R>),
pextrb_a(pextrb_a<R>),
pextrw_a(pextrw_a<R>),
pextrw_b(pextrw_b<R>),
pextrd_a(pextrd_a<R>),
pextrq_a(pextrq_a<R>),
pinsrb_a(pinsrb_a<R>),
pinsrw_a(pinsrw_a<R>),
pinsrd_a(pinsrd_a<R>),
pinsrq_a(pinsrq_a<R>),
movmskps_rm(movmskps_rm<R>),
movmskpd_rm(movmskpd_rm<R>),
pmovmskb_rm(pmovmskb_rm<R>),
vmovmskps_rm(vmovmskps_rm<R>),
vmovmskpd_rm(vmovmskpd_rm<R>),
vpmovmskb_rm(vpmovmskb_rm<R>),
movhps_a(movhps_a<R>),
vmovhps_b(vmovhps_b<R>),
movlhps_rm(movlhps_rm<R>),
vmovlhps_rvm(vmovlhps_rvm<R>),
vpinsrb_b(vpinsrb_b<R>),
vpinsrw_b(vpinsrw_b<R>),
vpinsrd_b(vpinsrd_b<R>),
vpinsrq_b(vpinsrq_b<R>),
movddup_a(movddup_a<R>),
vmovddup_a(vmovddup_a<R>),
pblendvb_rm(pblendvb_rm<R>),
blendvps_rm0(blendvps_rm0<R>),
blendvpd_rm0(blendvpd_rm0<R>),
vpblendvb_rvmr(vpblendvb_rvmr<R>),
vblendvps_rvmr(vblendvps_rvmr<R>),
vblendvpd_rvmr(vblendvpd_rvmr<R>),
pshufd_a(pshufd_a<R>),
pshuflw_a(pshuflw_a<R>),
pshufhw_a(pshufhw_a<R>),
vpshufd_a(vpshufd_a<R>),
vpshuflw_a(vpshuflw_a<R>),
vpshufhw_a(vpshufhw_a<R>),
maxss_a(maxss_a<R>),
maxsd_a(maxsd_a<R>),
maxps_a(maxps_a<R>),
maxpd_a(maxpd_a<R>),
pmaxsb_a(pmaxsb_a<R>),
pmaxsw_a(pmaxsw_a<R>),
pmaxsd_a(pmaxsd_a<R>),
pmaxub_a(pmaxub_a<R>),
pmaxuw_a(pmaxuw_a<R>),
pmaxud_a(pmaxud_a<R>),
minss_a(minss_a<R>),
minsd_a(minsd_a<R>),
minps_a(minps_a<R>),
minpd_a(minpd_a<R>),
pminsb_a(pminsb_a<R>),
pminsw_a(pminsw_a<R>),
pminsd_a(pminsd_a<R>),
pminub_a(pminub_a<R>),
pminuw_a(pminuw_a<R>),
pminud_a(pminud_a<R>),
mfence_zo(mfence_zo),
sfence_zo(sfence_zo),
lfence_zo(lfence_zo),
hlt_zo(hlt_zo),
ud2_zo(ud2_zo),
int3_zo(int3_zo),
retq_zo(retq_zo),
retq_i(retq_i),
movb_mr(movb_mr<R>),
movw_mr(movw_mr<R>),
movl_mr(movl_mr<R>),
movq_mr(movq_mr<R>),
movb_rm(movb_rm<R>),
movw_rm(movw_rm<R>),
movl_rm(movl_rm<R>),
movq_rm(movq_rm<R>),
movb_oi(movb_oi<R>),
movw_oi(movw_oi<R>),
movl_oi(movl_oi<R>),
movabsq_oi(movabsq_oi<R>),
movb_mi(movb_mi<R>),
movw_mi(movw_mi<R>),
movl_mi(movl_mi<R>),
movq_mi_sxl(movq_mi_sxl<R>),
movsbw_rm(movsbw_rm<R>),
movsbl_rm(movsbl_rm<R>),
movsbq_rm(movsbq_rm<R>),
movsww_rm(movsww_rm<R>),
movswl_rm(movswl_rm<R>),
movswq_rm(movswq_rm<R>),
movslq_rm(movslq_rm<R>),
movzbw_rm(movzbw_rm<R>),
movzbl_rm(movzbl_rm<R>),
movzbq_rm(movzbq_rm<R>),
movzww_rm(movzww_rm<R>),
movzwl_rm(movzwl_rm<R>),
movzwq_rm(movzwq_rm<R>),
movd_a(movd_a<R>),
movq_a(movq_a<R>),
movd_b(movd_b<R>),
movq_b(movq_b<R>),
vmovd_a(vmovd_a<R>),
vmovq_a(vmovq_a<R>),
vmovd_b(vmovd_b<R>),
vmovq_b(vmovq_b<R>),
movss_a_m(movss_a_m<R>),
movss_a_r(movss_a_r<R>),
movss_c_m(movss_c_m<R>),
movsd_a_m(movsd_a_m<R>),
movsd_a_r(movsd_a_r<R>),
movsd_c_m(movsd_c_m<R>),
movapd_a(movapd_a<R>),
movapd_b(movapd_b<R>),
movaps_a(movaps_a<R>),
movaps_b(movaps_b<R>),
movdqa_a(movdqa_a<R>),
movdqa_b(movdqa_b<R>),
movupd_a(movupd_a<R>),
movupd_b(movupd_b<R>),
movups_a(movups_a<R>),
movups_b(movups_b<R>),
movdqu_a(movdqu_a<R>),
movdqu_b(movdqu_b<R>),
pmovsxbw_a(pmovsxbw_a<R>),
pmovsxbd_a(pmovsxbd_a<R>),
pmovsxbq_a(pmovsxbq_a<R>),
pmovsxwd_a(pmovsxwd_a<R>),
pmovsxwq_a(pmovsxwq_a<R>),
pmovsxdq_a(pmovsxdq_a<R>),
pmovzxbw_a(pmovzxbw_a<R>),
pmovzxbd_a(pmovzxbd_a<R>),
pmovzxbq_a(pmovzxbq_a<R>),
pmovzxwd_a(pmovzxwd_a<R>),
pmovzxwq_a(pmovzxwq_a<R>),
pmovzxdq_a(pmovzxdq_a<R>),
mulb_m(mulb_m<R>),
mulw_m(mulw_m<R>),
mull_m(mull_m<R>),
mulq_m(mulq_m<R>),
imulb_m(imulb_m<R>),
imulw_m(imulw_m<R>),
imull_m(imull_m<R>),
imulq_m(imulq_m<R>),
imulw_rm(imulw_rm<R>),
imull_rm(imull_rm<R>),
imulq_rm(imulq_rm<R>),
imulw_rmi_sxb(imulw_rmi_sxb<R>),
imull_rmi_sxb(imull_rmi_sxb<R>),
imulq_rmi_sxb(imulq_rmi_sxb<R>),
imulw_rmi(imulw_rmi<R>),
imull_rmi(imull_rmi<R>),
imulq_rmi_sxl(imulq_rmi_sxl<R>),
mulxl_rvm(mulxl_rvm<R>),
mulxq_rvm(mulxq_rvm<R>),
mulss_a(mulss_a<R>),
mulsd_a(mulsd_a<R>),
mulps_a(mulps_a<R>),
mulpd_a(mulpd_a<R>),
pmuldq_a(pmuldq_a<R>),
pmulhrsw_a(pmulhrsw_a<R>),
pmulhuw_a(pmulhuw_a<R>),
pmulhw_a(pmulhw_a<R>),
pmulld_a(pmulld_a<R>),
pmullw_a(pmullw_a<R>),
pmuludq_a(pmuludq_a<R>),
negb_m(negb_m<R>),
negw_m(negw_m<R>),
negl_m(negl_m<R>),
negq_m(negq_m<R>),
notb_m(notb_m<R>),
notw_m(notw_m<R>),
notl_m(notl_m<R>),
notq_m(notq_m<R>),
nop_zo(nop_zo),
nopl_m(nopl_m<R>),
nop_1b(nop_1b),
nop_2b(nop_2b),
nop_3b(nop_3b),
nop_4b(nop_4b),
nop_5b(nop_5b),
nop_6b(nop_6b),
nop_7b(nop_7b),
nop_8b(nop_8b),
nop_9b(nop_9b),
orb_i(orb_i<R>),
orw_i(orw_i<R>),
orl_i(orl_i<R>),
orq_i_sxl(orq_i_sxl<R>),
orb_mi(orb_mi<R>),
orw_mi(orw_mi<R>),
orl_mi(orl_mi<R>),
orq_mi_sxl(orq_mi_sxl<R>),
orl_mi_sxb(orl_mi_sxb<R>),
orq_mi_sxb(orq_mi_sxb<R>),
orb_mr(orb_mr<R>),
orw_mr(orw_mr<R>),
orl_mr(orl_mr<R>),
orq_mr(orq_mr<R>),
orb_rm(orb_rm<R>),
orw_rm(orw_rm<R>),
orl_rm(orl_rm<R>),
orq_rm(orq_rm<R>),
lock_orb_mi(lock_orb_mi<R>),
lock_orw_mi(lock_orw_mi<R>),
lock_orl_mi(lock_orl_mi<R>),
lock_orq_mi_sxl(lock_orq_mi_sxl<R>),
lock_orl_mi_sxb(lock_orl_mi_sxb<R>),
lock_orq_mi_sxb(lock_orq_mi_sxb<R>),
lock_orb_mr(lock_orb_mr<R>),
lock_orw_mr(lock_orw_mr<R>),
lock_orl_mr(lock_orl_mr<R>),
lock_orq_mr(lock_orq_mr<R>),
orps_a(orps_a<R>),
orpd_a(orpd_a<R>),
por_a(por_a<R>),
packsswb_a(packsswb_a<R>),
vpacksswb_b(vpacksswb_b<R>),
packssdw_a(packssdw_a<R>),
vpackssdw_b(vpackssdw_b<R>),
packusdw_a(packusdw_a<R>),
vpackusdw_b(vpackusdw_b<R>),
packuswb_a(packuswb_a<R>),
vpackuswb_b(vpackuswb_b<R>),
roundpd_rmi(roundpd_rmi<R>),
roundps_rmi(roundps_rmi<R>),
roundsd_rmi(roundsd_rmi<R>),
roundss_rmi(roundss_rmi<R>),
vroundpd_rmi(vroundpd_rmi<R>),
vroundps_rmi(vroundps_rmi<R>),
vroundsd_rvmi(vroundsd_rvmi<R>),
vroundss_rvmi(vroundss_rvmi<R>),
sarb_mc(sarb_mc<R>),
sarb_mi(sarb_mi<R>),
sarb_m1(sarb_m1<R>),
sarw_mc(sarw_mc<R>),
sarw_mi(sarw_mi<R>),
sarw_m1(sarw_m1<R>),
sarl_mc(sarl_mc<R>),
sarl_mi(sarl_mi<R>),
sarl_m1(sarl_m1<R>),
sarq_mc(sarq_mc<R>),
sarq_mi(sarq_mi<R>),
sarq_m1(sarq_m1<R>),
shlb_mc(shlb_mc<R>),
shlb_mi(shlb_mi<R>),
shlb_m1(shlb_m1<R>),
shlw_mc(shlw_mc<R>),
shlw_mi(shlw_mi<R>),
shlw_m1(shlw_m1<R>),
shll_mc(shll_mc<R>),
shll_mi(shll_mi<R>),
shll_m1(shll_m1<R>),
shlq_mc(shlq_mc<R>),
shlq_mi(shlq_mi<R>),
shlq_m1(shlq_m1<R>),
shrb_mc(shrb_mc<R>),
shrb_mi(shrb_mi<R>),
shrb_m1(shrb_m1<R>),
shrw_mc(shrw_mc<R>),
shrw_mi(shrw_mi<R>),
shrw_m1(shrw_m1<R>),
shrl_mc(shrl_mc<R>),
shrl_mi(shrl_mi<R>),
shrl_m1(shrl_m1<R>),
shrq_mc(shrq_mc<R>),
shrq_mi(shrq_mi<R>),
shrq_m1(shrq_m1<R>),
rolb_mc(rolb_mc<R>),
rolb_mi(rolb_mi<R>),
rolb_m1(rolb_m1<R>),
rolw_mc(rolw_mc<R>),
rolw_mi(rolw_mi<R>),
rolw_m1(rolw_m1<R>),
roll_mc(roll_mc<R>),
roll_mi(roll_mi<R>),
roll_m1(roll_m1<R>),
rolq_mc(rolq_mc<R>),
rolq_mi(rolq_mi<R>),
rolq_m1(rolq_m1<R>),
rorb_mc(rorb_mc<R>),
rorb_mi(rorb_mi<R>),
rorb_m1(rorb_m1<R>),
rorw_mc(rorw_mc<R>),
rorw_mi(rorw_mi<R>),
rorw_m1(rorw_m1<R>),
rorl_mc(rorl_mc<R>),
rorl_mi(rorl_mi<R>),
rorl_m1(rorl_m1<R>),
rorq_mc(rorq_mc<R>),
rorq_mi(rorq_mi<R>),
rorq_m1(rorq_m1<R>),
shldw_mri(shldw_mri<R>),
shldw_mrc(shldw_mrc<R>),
shldl_mri(shldl_mri<R>),
shldq_mri(shldq_mri<R>),
shldl_mrc(shldl_mrc<R>),
shldq_mrc(shldq_mrc<R>),
sarxl_rmv(sarxl_rmv<R>),
shlxl_rmv(shlxl_rmv<R>),
shrxl_rmv(shrxl_rmv<R>),
sarxq_rmv(sarxq_rmv<R>),
shlxq_rmv(shlxq_rmv<R>),
shrxq_rmv(shrxq_rmv<R>),
rorxl_rmi(rorxl_rmi<R>),
rorxq_rmi(rorxq_rmi<R>),
psllw_a(psllw_a<R>),
psllw_b(psllw_b<R>),
pslld_a(pslld_a<R>),
pslld_b(pslld_b<R>),
psllq_a(psllq_a<R>),
psllq_b(psllq_b<R>),
psraw_a(psraw_a<R>),
psraw_b(psraw_b<R>),
psrad_a(psrad_a<R>),
psrad_b(psrad_b<R>),
psrlw_a(psrlw_a<R>),
psrlw_b(psrlw_b<R>),
psrld_a(psrld_a<R>),
psrld_b(psrld_b<R>),
psrlq_a(psrlq_a<R>),
psrlq_b(psrlq_b<R>),
sqrtss_a(sqrtss_a<R>),
sqrtsd_a(sqrtsd_a<R>),
sqrtps_a(sqrtps_a<R>),
sqrtpd_a(sqrtpd_a<R>),
popw_m(popw_m<R>),
popq_m(popq_m<R>),
popw_o(popw_o<R>),
popq_o(popq_o<R>),
pushw_m(pushw_m<R>),
pushq_m(pushq_m<R>),
pushw_o(pushw_o<R>),
pushq_o(pushq_o<R>),
pushq_i8(pushq_i8),
pushw_i16(pushw_i16),
pushq_i32(pushq_i32),
subb_i(subb_i<R>),
subw_i(subw_i<R>),
subl_i(subl_i<R>),
subq_i_sxl(subq_i_sxl<R>),
subb_mi(subb_mi<R>),
subw_mi(subw_mi<R>),
subl_mi(subl_mi<R>),
subq_mi_sxl(subq_mi_sxl<R>),
subl_mi_sxb(subl_mi_sxb<R>),
subq_mi_sxb(subq_mi_sxb<R>),
subb_mr(subb_mr<R>),
subw_mr(subw_mr<R>),
subl_mr(subl_mr<R>),
subq_mr(subq_mr<R>),
subb_rm(subb_rm<R>),
subw_rm(subw_rm<R>),
subl_rm(subl_rm<R>),
subq_rm(subq_rm<R>),
sbbb_i(sbbb_i<R>),
sbbw_i(sbbw_i<R>),
sbbl_i(sbbl_i<R>),
sbbq_i_sxl(sbbq_i_sxl<R>),
sbbb_mi(sbbb_mi<R>),
sbbw_mi(sbbw_mi<R>),
sbbl_mi(sbbl_mi<R>),
sbbq_mi_sxl(sbbq_mi_sxl<R>),
sbbl_mi_sxb(sbbl_mi_sxb<R>),
sbbq_mi_sxb(sbbq_mi_sxb<R>),
sbbb_mr(sbbb_mr<R>),
sbbw_mr(sbbw_mr<R>),
sbbl_mr(sbbl_mr<R>),
sbbq_mr(sbbq_mr<R>),
sbbb_rm(sbbb_rm<R>),
sbbw_rm(sbbw_rm<R>),
sbbl_rm(sbbl_rm<R>),
sbbq_rm(sbbq_rm<R>),
lock_subb_mi(lock_subb_mi<R>),
lock_subw_mi(lock_subw_mi<R>),
lock_subl_mi(lock_subl_mi<R>),
lock_subq_mi_sxl(lock_subq_mi_sxl<R>),
lock_subl_mi_sxb(lock_subl_mi_sxb<R>),
lock_subq_mi_sxb(lock_subq_mi_sxb<R>),
lock_subb_mr(lock_subb_mr<R>),
lock_subw_mr(lock_subw_mr<R>),
lock_subl_mr(lock_subl_mr<R>),
lock_subq_mr(lock_subq_mr<R>),
lock_sbbb_mi(lock_sbbb_mi<R>),
lock_sbbw_mi(lock_sbbw_mi<R>),
lock_sbbl_mi(lock_sbbl_mi<R>),
lock_sbbq_mi_sxl(lock_sbbq_mi_sxl<R>),
lock_sbbl_mi_sxb(lock_sbbl_mi_sxb<R>),
lock_sbbq_mi_sxb(lock_sbbq_mi_sxb<R>),
lock_sbbb_mr(lock_sbbb_mr<R>),
lock_sbbw_mr(lock_sbbw_mr<R>),
lock_sbbl_mr(lock_sbbl_mr<R>),
lock_sbbq_mr(lock_sbbq_mr<R>),
subss_a(subss_a<R>),
subsd_a(subsd_a<R>),
subps_a(subps_a<R>),
subpd_a(subpd_a<R>),
psubb_a(psubb_a<R>),
psubw_a(psubw_a<R>),
psubd_a(psubd_a<R>),
psubq_a(psubq_a<R>),
psubsb_a(psubsb_a<R>),
psubsw_a(psubsw_a<R>),
psubusb_a(psubusb_a<R>),
psubusw_a(psubusw_a<R>),
xorb_i(xorb_i<R>),
xorw_i(xorw_i<R>),
xorl_i(xorl_i<R>),
xorq_i_sxl(xorq_i_sxl<R>),
xorb_mi(xorb_mi<R>),
xorw_mi(xorw_mi<R>),
xorl_mi(xorl_mi<R>),
xorq_mi_sxl(xorq_mi_sxl<R>),
xorl_mi_sxb(xorl_mi_sxb<R>),
xorq_mi_sxb(xorq_mi_sxb<R>),
xorb_mr(xorb_mr<R>),
xorw_mr(xorw_mr<R>),
xorl_mr(xorl_mr<R>),
xorq_mr(xorq_mr<R>),
xorb_rm(xorb_rm<R>),
xorw_rm(xorw_rm<R>),
xorl_rm(xorl_rm<R>),
xorq_rm(xorq_rm<R>),
lock_xorb_mi(lock_xorb_mi<R>),
lock_xorw_mi(lock_xorw_mi<R>),
lock_xorl_mi(lock_xorl_mi<R>),
lock_xorq_mi_sxl(lock_xorq_mi_sxl<R>),
lock_xorl_mi_sxb(lock_xorl_mi_sxb<R>),
lock_xorq_mi_sxb(lock_xorq_mi_sxb<R>),
lock_xorb_mr(lock_xorb_mr<R>),
lock_xorw_mr(lock_xorw_mr<R>),
lock_xorl_mr(lock_xorl_mr<R>),
lock_xorq_mr(lock_xorq_mr<R>),
xorps_a(xorps_a<R>),
xorpd_a(xorpd_a<R>),
pxor_a(pxor_a<R>),
unpcklps_a(unpcklps_a<R>),
unpcklpd_a(unpcklpd_a<R>),
unpckhps_a(unpckhps_a<R>),
punpckhbw_a(punpckhbw_a<R>),
punpckhwd_a(punpckhwd_a<R>),
punpckhdq_a(punpckhdq_a<R>),
punpcklwd_a(punpcklwd_a<R>),
punpcklqdq_a(punpcklqdq_a<R>),
punpcklbw_a(punpcklbw_a<R>),
punpckldq_a(punpckldq_a<R>),
punpckhqdq_a(punpckhqdq_a<R>),
}Expand description
An assembly instruction; contains all instructions known to the assembler.
This wraps all inst structures into a single enumeration for collecting
instructions.