├── .gitignore ├── Cargo.toml ├── LICENSE ├── README.md ├── examples ├── addressing_modes.rs ├── encode_basic.rs ├── encode_function.rs ├── encode_long.rs └── encode_real.rs ├── gen_defs ├── Cargo.toml ├── README.md ├── deploy.sh ├── instruction_defs.rs ├── make_all.sh ├── mnemonic.rs └── src │ ├── gen_tests.rs │ ├── instruction.rs │ ├── instruction_def.rs │ ├── main.rs │ ├── operand.rs │ └── todo └── src ├── decoding.rs ├── encoding.rs ├── instruction.rs ├── instruction_buffer.rs ├── instruction_def.rs ├── instruction_defs.rs ├── lib.rs ├── mnemonic.rs ├── operand.rs └── test ├── README.md ├── addressing16.rs ├── addressing32.rs ├── addressing64.rs ├── decode.rs ├── encode.rs ├── instruction_tests ├── aaa.rs ├── aad.rs ├── aam.rs ├── aas.rs ├── adc.rs ├── adcx.rs ├── add.rs ├── addpd.rs ├── addps.rs ├── addsd.rs ├── addss.rs ├── addsubpd.rs ├── addsubps.rs ├── adox.rs ├── aesdec.rs ├── aesdeclast.rs ├── aesenc.rs ├── aesenclast.rs ├── aesimc.rs ├── aeskeygenassist.rs ├── and.rs ├── andn.rs ├── andnpd.rs ├── andnps.rs ├── andpd.rs ├── andps.rs ├── bextr.rs ├── blendpd.rs ├── blendps.rs ├── blendvpd.rs ├── blendvps.rs ├── blsi.rs ├── blsmsk.rs ├── blsr.rs ├── bndcl.rs ├── bndcn.rs ├── bndcu.rs ├── bndldx.rs ├── bndmk.rs ├── bndmov.rs ├── bndstx.rs ├── bound.rs ├── bsf.rs ├── bsr.rs ├── bt.rs ├── btc.rs ├── btr.rs ├── bts.rs ├── bzhi.rs ├── cbw.rs ├── cdq.rs ├── cdqe.rs ├── clac.rs ├── clc.rs ├── cld.rs ├── clflush.rs ├── clflushopt.rs ├── cli.rs ├── clts.rs ├── clwb.rs ├── cmc.rs ├── cmova.rs ├── cmovae.rs ├── cmovb.rs ├── cmovbe.rs ├── cmovc.rs ├── cmove.rs ├── cmovg.rs ├── cmovge.rs ├── cmovl.rs ├── cmovle.rs ├── cmovna.rs ├── cmovnae.rs ├── cmovnb.rs ├── cmovnbe.rs ├── cmovnc.rs ├── cmovne.rs ├── cmovng.rs ├── cmovnge.rs ├── cmovnl.rs ├── cmovnle.rs ├── cmovno.rs ├── cmovnp.rs ├── cmovns.rs ├── cmovnz.rs ├── cmovo.rs ├── cmovp.rs ├── cmovpe.rs ├── cmp.rs ├── cmppd.rs ├── cmpps.rs ├── cmpsb.rs ├── cmpsd.rs ├── cmpsq.rs ├── cmpss.rs ├── cmpsw.rs ├── cmpxchg.rs ├── cmpxchg16b.rs ├── cmpxchg8b.rs ├── comisd.rs ├── comiss.rs ├── cpuid.rs ├── cqo.rs ├── crc32.rs ├── cvtdq2pd.rs ├── cvtdq2ps.rs ├── cvtpd2dq.rs ├── cvtpd2pi.rs ├── cvtpd2ps.rs ├── cvtpi2pd.rs ├── cvtpi2ps.rs ├── cvtps2dq.rs ├── cvtps2pd.rs ├── cvtps2pi.rs ├── cvtsd2si.rs ├── cvtsd2ss.rs ├── cvtsi2sd.rs ├── cvtsi2ss.rs ├── cvtss2sd.rs ├── cvtss2si.rs ├── cvttpd2dq.rs ├── cvttpd2pi.rs ├── cvttps2dq.rs ├── cvttps2pi.rs ├── cvttsd2si.rs ├── cvttss2si.rs ├── cwd.rs ├── cwde.rs ├── daa.rs ├── das.rs ├── div.rs ├── divpd.rs ├── divps.rs ├── divsd.rs ├── divss.rs ├── dppd.rs ├── dpps.rs ├── emms.rs ├── enter.rs ├── extractps.rs ├── f2xm1.rs ├── fabs.rs ├── fadd.rs ├── faddp.rs ├── fbld.rs ├── fbstp.rs ├── fchs.rs ├── fclex.rs ├── fcmovb.rs ├── fcmovbe.rs ├── fcmove.rs ├── fcmovnb.rs ├── fcmovnbe.rs ├── fcmovne.rs ├── fcmovnu.rs ├── fcmovu.rs ├── fcom.rs ├── fcomi.rs ├── fcomip.rs ├── fcomp.rs ├── fcompp.rs ├── fcos.rs ├── fdecstp.rs ├── fdiv.rs ├── fdivp.rs ├── fdivr.rs ├── fdivrp.rs ├── ffree.rs ├── fiadd.rs ├── ficom.rs ├── ficomp.rs ├── fidiv.rs ├── fidivr.rs ├── fild.rs ├── fimul.rs ├── fincstp.rs ├── finit.rs ├── fist.rs ├── fistp.rs ├── fisttp.rs ├── fisub.rs ├── fisubr.rs ├── fld.rs ├── fld1.rs ├── fldcw.rs ├── fldenv.rs ├── fldl2e.rs ├── fldl2t.rs ├── fldlg2.rs ├── fldln2.rs ├── fldpi.rs ├── fldz.rs ├── fmul.rs ├── fmulp.rs ├── fnclex.rs ├── fninit.rs ├── fnop.rs ├── fnsave.rs ├── fnstcw.rs ├── fnstenv.rs ├── fnstsw.rs ├── fpatan.rs ├── fprem.rs ├── fprem1.rs ├── fptan.rs ├── frndint.rs ├── frstor.rs ├── fsave.rs ├── fscale.rs ├── fsin.rs ├── fsincos.rs ├── fsqrt.rs ├── fst.rs ├── fstcw.rs ├── fstenv.rs ├── fstp.rs ├── fstsw.rs ├── fsub.rs ├── fsubp.rs ├── fsubr.rs ├── fsubrp.rs ├── ftst.rs ├── fucom.rs ├── fucomi.rs ├── fucomip.rs ├── fucomp.rs ├── fucompp.rs ├── fwait.rs ├── fxam.rs ├── fxch.rs ├── fxrstor.rs ├── fxrstor64.rs ├── fxsave.rs ├── fxsave64.rs ├── fxtract.rs ├── fyl2x.rs ├── fyl2xp1.rs ├── haddpd.rs ├── haddps.rs ├── hlt.rs ├── hsubpd.rs ├── hsubps.rs ├── idiv.rs ├── imul.rs ├── in.rs ├── ins.rs ├── insb.rs ├── insd.rs ├── insertps.rs ├── instr_aaa.rs ├── instr_aad.rs ├── instr_aam.rs ├── instr_aas.rs ├── instr_adc.rs ├── instr_adcx.rs ├── instr_add.rs ├── instr_addpd.rs ├── instr_addps.rs ├── instr_addsd.rs ├── instr_addss.rs ├── instr_addsubpd.rs ├── instr_addsubps.rs ├── instr_adox.rs ├── instr_aesdec.rs ├── instr_aesdeclast.rs ├── instr_aesenc.rs ├── instr_aesenclast.rs ├── instr_aesimc.rs ├── instr_aeskeygenassist.rs ├── instr_and.rs ├── instr_andn.rs ├── instr_andnpd.rs ├── instr_andnps.rs ├── instr_andpd.rs ├── instr_andps.rs ├── instr_bextr.rs ├── instr_blendpd.rs ├── instr_blendps.rs ├── instr_blendvpd.rs ├── instr_blendvps.rs ├── instr_blsi.rs ├── instr_blsmsk.rs ├── instr_blsr.rs ├── instr_bndcl.rs ├── instr_bndcn.rs ├── instr_bndcu.rs ├── instr_bndldx.rs ├── instr_bndmk.rs ├── instr_bndmov.rs ├── instr_bndstx.rs ├── instr_bound.rs ├── instr_bsf.rs ├── instr_bsr.rs ├── instr_bswap.rs ├── instr_bt.rs ├── instr_btc.rs ├── instr_btr.rs ├── instr_bts.rs ├── instr_bzhi.rs ├── instr_cbw.rs ├── instr_cdq.rs ├── instr_cdqe.rs ├── instr_clac.rs ├── instr_clc.rs ├── instr_cld.rs ├── instr_clflush.rs ├── instr_clflushopt.rs ├── instr_cli.rs ├── instr_clts.rs ├── instr_clwb.rs ├── instr_cmc.rs ├── instr_cmova.rs ├── instr_cmovae.rs ├── instr_cmovb.rs ├── instr_cmovbe.rs ├── instr_cmovc.rs ├── instr_cmove.rs ├── instr_cmovg.rs ├── instr_cmovge.rs ├── instr_cmovl.rs ├── instr_cmovle.rs ├── instr_cmovna.rs ├── instr_cmovnae.rs ├── instr_cmovnb.rs ├── instr_cmovnbe.rs ├── instr_cmovnc.rs ├── instr_cmovne.rs ├── instr_cmovng.rs ├── instr_cmovnge.rs ├── instr_cmovnl.rs ├── instr_cmovnle.rs ├── instr_cmovno.rs ├── instr_cmovnp.rs ├── instr_cmovns.rs ├── instr_cmovnz.rs ├── instr_cmovo.rs ├── instr_cmovp.rs ├── instr_cmovpe.rs ├── instr_cmp.rs ├── instr_cmppd.rs ├── instr_cmpps.rs ├── instr_cmps.rs ├── instr_cmpsb.rs ├── instr_cmpsd.rs ├── instr_cmpsq.rs ├── instr_cmpss.rs ├── instr_cmpsw.rs ├── instr_cmpxchg.rs ├── instr_cmpxchg16b.rs ├── instr_cmpxchg8b.rs ├── instr_comisd.rs ├── instr_comiss.rs ├── instr_cpuid.rs ├── instr_cqo.rs ├── instr_crc32.rs ├── instr_cvtdq2pd.rs ├── instr_cvtdq2ps.rs ├── instr_cvtpd2dq.rs ├── instr_cvtpd2pi.rs ├── instr_cvtpd2ps.rs ├── instr_cvtpi2pd.rs ├── instr_cvtpi2ps.rs ├── instr_cvtps2dq.rs ├── instr_cvtps2pd.rs ├── instr_cvtps2pi.rs ├── instr_cvtsd2si.rs ├── instr_cvtsd2ss.rs ├── instr_cvtsi2sd.rs ├── instr_cvtsi2ss.rs ├── instr_cvtss2sd.rs ├── instr_cvtss2si.rs ├── instr_cvttpd2dq.rs ├── instr_cvttpd2pi.rs ├── instr_cvttps2dq.rs ├── instr_cvttps2pi.rs ├── instr_cvttsd2si.rs ├── instr_cvttss2si.rs ├── instr_cwd.rs ├── instr_cwde.rs ├── instr_daa.rs ├── instr_das.rs ├── instr_dec.rs ├── instr_div.rs ├── instr_divpd.rs ├── instr_divps.rs ├── instr_divsd.rs ├── instr_divss.rs ├── instr_dppd.rs ├── instr_dpps.rs ├── instr_emms.rs ├── instr_enter.rs ├── instr_extractps.rs ├── instr_f2xm1.rs ├── instr_fabs.rs ├── instr_fadd.rs ├── instr_faddp.rs ├── instr_fbld.rs ├── instr_fbstp.rs ├── instr_fchs.rs ├── instr_fclex.rs ├── instr_fcmovb.rs ├── instr_fcmovbe.rs ├── instr_fcmove.rs ├── instr_fcmovnb.rs ├── instr_fcmovnbe.rs ├── instr_fcmovne.rs ├── instr_fcmovnu.rs ├── instr_fcmovu.rs ├── instr_fcom.rs ├── instr_fcomi.rs ├── instr_fcomip.rs ├── instr_fcomp.rs ├── instr_fcompp.rs ├── instr_fcos.rs ├── instr_fdecstp.rs ├── instr_fdiv.rs ├── instr_fdivp.rs ├── instr_fdivr.rs ├── instr_fdivrp.rs ├── instr_ffree.rs ├── instr_fiadd.rs ├── instr_ficom.rs ├── instr_ficomp.rs ├── instr_fidiv.rs ├── instr_fidivr.rs ├── instr_fild.rs ├── instr_fimul.rs ├── instr_fincstp.rs ├── instr_finit.rs ├── instr_fist.rs ├── instr_fistp.rs ├── instr_fisttp.rs ├── instr_fisub.rs ├── instr_fisubr.rs ├── instr_fld.rs ├── instr_fld1.rs ├── instr_fldcw.rs ├── instr_fldenv.rs ├── instr_fldl2e.rs ├── instr_fldl2t.rs ├── instr_fldlg2.rs ├── instr_fldln2.rs ├── instr_fldpi.rs ├── instr_fldz.rs ├── instr_fmul.rs ├── instr_fmulp.rs ├── instr_fnclex.rs ├── instr_fninit.rs ├── instr_fnop.rs ├── instr_fnsave.rs ├── instr_fnstcw.rs ├── instr_fnstenv.rs ├── instr_fnstsw.rs ├── instr_fpatan.rs ├── instr_fprem.rs ├── instr_fprem1.rs ├── instr_fptan.rs ├── instr_frndint.rs ├── instr_frstor.rs ├── instr_fsave.rs ├── instr_fscale.rs ├── instr_fsin.rs ├── instr_fsincos.rs ├── instr_fsqrt.rs ├── instr_fst.rs ├── instr_fstcw.rs ├── instr_fstenv.rs ├── instr_fstp.rs ├── instr_fstsw.rs ├── instr_fsub.rs ├── instr_fsubp.rs ├── instr_fsubr.rs ├── instr_fsubrp.rs ├── instr_ftst.rs ├── instr_fucom.rs ├── instr_fucomi.rs ├── instr_fucomip.rs ├── instr_fucomp.rs ├── instr_fucompp.rs ├── instr_fwait.rs ├── instr_fxam.rs ├── instr_fxch.rs ├── instr_fxrstor.rs ├── instr_fxrstor64.rs ├── instr_fxsave.rs ├── instr_fxsave64.rs ├── instr_fxtract.rs ├── instr_fyl2x.rs ├── instr_fyl2xp1.rs ├── instr_haddpd.rs ├── instr_haddps.rs ├── instr_hlt.rs ├── instr_hsubpd.rs ├── instr_hsubps.rs ├── instr_idiv.rs ├── instr_imul.rs ├── instr_in.rs ├── instr_inc.rs ├── instr_ins.rs ├── instr_insb.rs ├── instr_insd.rs ├── instr_insertps.rs ├── instr_insw.rs ├── instr_int.rs ├── instr_into.rs ├── instr_invd.rs ├── instr_invlpg.rs ├── instr_invpcid.rs ├── instr_iret.rs ├── instr_iretd.rs ├── instr_iretq.rs ├── instr_ja.rs ├── instr_jae.rs ├── instr_jb.rs ├── instr_jbe.rs ├── instr_jc.rs ├── instr_jcxz.rs ├── instr_je.rs ├── instr_jecxz.rs ├── instr_jg.rs ├── instr_jge.rs ├── instr_jl.rs ├── instr_jle.rs ├── instr_jna.rs ├── instr_jnae.rs ├── instr_jnb.rs ├── instr_jnbe.rs ├── instr_jnc.rs ├── instr_jne.rs ├── instr_jng.rs ├── instr_jnge.rs ├── instr_jnl.rs ├── instr_jnle.rs ├── instr_jno.rs ├── instr_jnp.rs ├── instr_jns.rs ├── instr_jnz.rs ├── instr_jo.rs ├── instr_jp.rs ├── instr_jpe.rs ├── instr_jpo.rs ├── instr_jrcxz.rs ├── instr_js.rs ├── instr_jz.rs ├── instr_kaddb.rs ├── instr_kaddd.rs ├── instr_kaddq.rs ├── instr_kaddw.rs ├── instr_kandb.rs ├── instr_kandd.rs ├── instr_kandnb.rs ├── instr_kandnd.rs ├── instr_kandnq.rs ├── instr_kandnw.rs ├── instr_kandq.rs ├── instr_kandw.rs ├── instr_kmovb.rs ├── instr_kmovd.rs ├── instr_kmovq.rs ├── instr_kmovw.rs ├── instr_knotb.rs ├── instr_knotd.rs ├── instr_knotq.rs ├── instr_knotw.rs ├── instr_korb.rs ├── instr_kord.rs ├── instr_korq.rs ├── instr_kortestb.rs ├── instr_kortestd.rs ├── instr_kortestq.rs ├── instr_kortestw.rs ├── instr_korw.rs ├── instr_kshiftlb.rs ├── instr_kshiftld.rs ├── instr_kshiftlq.rs ├── instr_kshiftlw.rs ├── instr_kshiftrb.rs ├── instr_kshiftrd.rs ├── instr_kshiftrq.rs ├── instr_kshiftrw.rs ├── instr_ktestb.rs ├── instr_ktestd.rs ├── instr_ktestq.rs ├── instr_ktestw.rs ├── instr_kunpckbw.rs ├── instr_kunpckdq.rs ├── instr_kunpckwd.rs ├── instr_kxnorb.rs ├── instr_kxnord.rs ├── instr_kxnorq.rs ├── instr_kxnorw.rs ├── instr_kxorb.rs ├── instr_kxord.rs ├── instr_kxorq.rs ├── instr_kxorw.rs ├── instr_lahf.rs ├── instr_lar.rs ├── instr_lddqu.rs ├── instr_ldmxcsr.rs ├── instr_lds.rs ├── instr_lea.rs ├── instr_leave.rs ├── instr_les.rs ├── instr_lfence.rs ├── instr_lfs.rs ├── instr_lgdt.rs ├── instr_lgs.rs ├── instr_lidt.rs ├── instr_lldt.rs ├── instr_lmsw.rs ├── instr_lock.rs ├── instr_lods.rs ├── instr_lodsb.rs ├── instr_lodsd.rs ├── instr_lodsq.rs ├── instr_lodsw.rs ├── instr_loop.rs ├── instr_loope.rs ├── instr_loopne.rs ├── instr_lsl.rs ├── instr_lss.rs ├── instr_ltr.rs ├── instr_lzcnt.rs ├── instr_maskmovdqu.rs ├── instr_maskmovq.rs ├── instr_maxpd.rs ├── instr_maxps.rs ├── instr_maxsd.rs ├── instr_maxss.rs ├── instr_mfence.rs ├── instr_minpd.rs ├── instr_minps.rs ├── instr_minsd.rs ├── instr_minss.rs ├── instr_monitor.rs ├── instr_movapd.rs ├── instr_movaps.rs ├── instr_movbe.rs ├── instr_movd.rs ├── instr_movddup.rs ├── instr_movdq2q.rs ├── instr_movdqa.rs ├── instr_movdqu.rs ├── instr_movhlps.rs ├── instr_movhpd.rs ├── instr_movhps.rs ├── instr_movlhps.rs ├── instr_movlpd.rs ├── instr_movlps.rs ├── instr_movmskpd.rs ├── instr_movmskps.rs ├── instr_movntdq.rs ├── instr_movntdqa.rs ├── instr_movnti.rs ├── instr_movntpd.rs ├── instr_movntps.rs ├── instr_movntq.rs ├── instr_movq2dq.rs ├── instr_movs.rs ├── instr_movsb.rs ├── instr_movsd.rs ├── instr_movshdup.rs ├── instr_movsldup.rs ├── instr_movsq.rs ├── instr_movss.rs ├── instr_movsw.rs ├── instr_movsx.rs ├── instr_movsxd.rs ├── instr_movupd.rs ├── instr_movups.rs ├── instr_movzx.rs ├── instr_mpsadbw.rs ├── instr_mul.rs ├── instr_mulpd.rs ├── instr_mulps.rs ├── instr_mulsd.rs ├── instr_mulss.rs ├── instr_mulx.rs ├── instr_mwait.rs ├── instr_neg.rs ├── instr_nop.rs ├── instr_not.rs ├── instr_or.rs ├── instr_orpd.rs ├── instr_orps.rs ├── instr_out.rs ├── instr_outs.rs ├── instr_outsb.rs ├── instr_outsd.rs ├── instr_outsw.rs ├── instr_pabsb.rs ├── instr_pabsd.rs ├── instr_pabsw.rs ├── instr_packssdw.rs ├── instr_packsswb.rs ├── instr_packusdw.rs ├── instr_packuswb.rs ├── instr_paddb.rs ├── instr_paddd.rs ├── instr_paddq.rs ├── instr_paddsb.rs ├── instr_paddsw.rs ├── instr_paddusb.rs ├── instr_paddusw.rs ├── instr_paddw.rs ├── instr_palignr.rs ├── instr_pand.rs ├── instr_pandn.rs ├── instr_pause.rs ├── instr_pavgb.rs ├── instr_pavgw.rs ├── instr_pblendvb.rs ├── instr_pblendw.rs ├── instr_pclmulqdq.rs ├── instr_pcmpeqb.rs ├── instr_pcmpeqd.rs ├── instr_pcmpeqq.rs ├── instr_pcmpeqw.rs ├── instr_pcmpestri.rs ├── instr_pcmpestrm.rs ├── instr_pcmpgtb.rs ├── instr_pcmpgtd.rs ├── instr_pcmpgtq.rs ├── instr_pcmpgtw.rs ├── instr_pcmpistri.rs ├── instr_pcmpistrm.rs ├── instr_pdep.rs ├── instr_pext.rs ├── instr_phaddd.rs ├── instr_phaddsw.rs ├── instr_phaddw.rs ├── instr_phminposuw.rs ├── instr_phsubd.rs ├── instr_phsubsw.rs ├── instr_phsubw.rs ├── instr_pinsrb.rs ├── instr_pinsrd.rs ├── instr_pinsrq.rs ├── instr_pinsrw.rs ├── instr_pmaddubsw.rs ├── instr_pmaddwd.rs ├── instr_pmaxsb.rs ├── instr_pmaxsd.rs ├── instr_pmaxsw.rs ├── instr_pmaxub.rs ├── instr_pmaxud.rs ├── instr_pmaxuw.rs ├── instr_pminsb.rs ├── instr_pminsd.rs ├── instr_pminsw.rs ├── instr_pminub.rs ├── instr_pminud.rs ├── instr_pminuw.rs ├── instr_pmovmskb.rs ├── instr_pmovsxbd.rs ├── instr_pmovsxbq.rs ├── instr_pmovsxbw.rs ├── instr_pmovsxdq.rs ├── instr_pmovsxwd.rs ├── instr_pmovsxwq.rs ├── instr_pmovzxbd.rs ├── instr_pmovzxbq.rs ├── instr_pmovzxbw.rs ├── instr_pmovzxdq.rs ├── instr_pmovzxwd.rs ├── instr_pmovzxwq.rs ├── instr_pmuldq.rs ├── instr_pmulhrsw.rs ├── instr_pmulhuw.rs ├── instr_pmulhw.rs ├── instr_pmulld.rs ├── instr_pmullw.rs ├── instr_pmuludq.rs ├── instr_pop.rs ├── instr_popa.rs ├── instr_popad.rs ├── instr_popcnt.rs ├── instr_popf.rs ├── instr_popfd.rs ├── instr_popfq.rs ├── instr_por.rs ├── instr_prefetchnta.rs ├── instr_prefetcht0.rs ├── instr_prefetcht1.rs ├── instr_prefetcht2.rs ├── instr_prefetchw.rs ├── instr_prefetchwt1.rs ├── instr_psadbw.rs ├── instr_pshufb.rs ├── instr_pshufd.rs ├── instr_pshufhw.rs ├── instr_pshuflw.rs ├── instr_pshufw.rs ├── instr_psignb.rs ├── instr_psignd.rs ├── instr_psignw.rs ├── instr_pslld.rs ├── instr_pslldq.rs ├── instr_psllq.rs ├── instr_psllw.rs ├── instr_psrad.rs ├── instr_psraw.rs ├── instr_psrld.rs ├── instr_psrldq.rs ├── instr_psrlq.rs ├── instr_psrlw.rs ├── instr_psubb.rs ├── instr_psubd.rs ├── instr_psubq.rs ├── instr_psubsb.rs ├── instr_psubsw.rs ├── instr_psubusb.rs ├── instr_psubusw.rs ├── instr_psubw.rs ├── instr_ptest.rs ├── instr_punpckhbw.rs ├── instr_punpckhdq.rs ├── instr_punpckhqdq.rs ├── instr_punpckhwd.rs ├── instr_punpcklbw.rs ├── instr_punpckldq.rs ├── instr_punpcklqdq.rs ├── instr_punpcklwd.rs ├── instr_push.rs ├── instr_pusha.rs ├── instr_pushad.rs ├── instr_pushf.rs ├── instr_pushfd.rs ├── instr_pushfq.rs ├── instr_pxor.rs ├── instr_rcl.rs ├── instr_rcpps.rs ├── instr_rcpss.rs ├── instr_rcr.rs ├── instr_rdfsbase.rs ├── instr_rdgsbase.rs ├── instr_rdmsr.rs ├── instr_rdpkru.rs ├── instr_rdpmc.rs ├── instr_rdrand.rs ├── instr_rdseed.rs ├── instr_rdtsc.rs ├── instr_rdtscp.rs ├── instr_ret.rs ├── instr_rol.rs ├── instr_ror.rs ├── instr_rorx.rs ├── instr_roundpd.rs ├── instr_roundps.rs ├── instr_roundsd.rs ├── instr_roundss.rs ├── instr_rsm.rs ├── instr_rsqrtps.rs ├── instr_rsqrtss.rs ├── instr_sahf.rs ├── instr_sal.rs ├── instr_sar.rs ├── instr_sarx.rs ├── instr_sbb.rs ├── instr_scas.rs ├── instr_scasb.rs ├── instr_scasd.rs ├── instr_scasq.rs ├── instr_scasw.rs ├── instr_seta.rs ├── instr_setae.rs ├── instr_setb.rs ├── instr_setbe.rs ├── instr_setc.rs ├── instr_sete.rs ├── instr_setg.rs ├── instr_setge.rs ├── instr_setl.rs ├── instr_setle.rs ├── instr_setna.rs ├── instr_setnae.rs ├── instr_setnb.rs ├── instr_setnbe.rs ├── instr_setnc.rs ├── instr_setne.rs ├── instr_setng.rs ├── instr_setnge.rs ├── instr_setnl.rs ├── instr_setnle.rs ├── instr_sfence.rs ├── instr_sgdt.rs ├── instr_sha1msg1.rs ├── instr_sha1msg2.rs ├── instr_sha1nexte.rs ├── instr_sha1rnds4.rs ├── instr_sha256msg1.rs ├── instr_sha256msg2.rs ├── instr_sha256rnds2.rs ├── instr_shl.rs ├── instr_shld.rs ├── instr_shlx.rs ├── instr_shr.rs ├── instr_shrd.rs ├── instr_shrx.rs ├── instr_shufpd.rs ├── instr_shufps.rs ├── instr_sidt.rs ├── instr_sldt.rs ├── instr_smsw.rs ├── instr_sqrtps.rs ├── instr_sqrtsd.rs ├── instr_sqrtss.rs ├── instr_stac.rs ├── instr_stc.rs ├── instr_std.rs ├── instr_sti.rs ├── instr_stmxcsr.rs ├── instr_stos.rs ├── instr_stosb.rs ├── instr_stosd.rs ├── instr_stosq.rs ├── instr_stosw.rs ├── instr_str.rs ├── instr_sub.rs ├── instr_subpd.rs ├── instr_subps.rs ├── instr_subsd.rs ├── instr_subss.rs ├── instr_swapgs.rs ├── instr_syscall.rs ├── instr_sysenter.rs ├── instr_sysexit.rs ├── instr_sysret.rs ├── instr_test.rs ├── instr_tzcnt.rs ├── instr_ucomisd.rs ├── instr_ucomiss.rs ├── instr_ud0.rs ├── instr_ud2.rs ├── instr_unpckhpd.rs ├── instr_unpckhps.rs ├── instr_unpcklpd.rs ├── instr_unpcklps.rs ├── instr_vaddpd.rs ├── instr_vaddps.rs ├── instr_vaddsd.rs ├── instr_vaddss.rs ├── instr_vaddsubpd.rs ├── instr_vaddsubps.rs ├── instr_vaesdec.rs ├── instr_vaesdeclast.rs ├── instr_vaesenc.rs ├── instr_vaesenclast.rs ├── instr_vaesimc.rs ├── instr_vaeskeygenassist.rs ├── instr_valignd.rs ├── instr_valignq.rs ├── instr_vandnpd.rs ├── instr_vandnps.rs ├── instr_vandpd.rs ├── instr_vandps.rs ├── instr_vblendmpd.rs ├── instr_vblendmps.rs ├── instr_vblendpd.rs ├── instr_vblendps.rs ├── instr_vblendvpd.rs ├── instr_vblendvps.rs ├── instr_vbroadcastf128.rs ├── instr_vbroadcastf32x2.rs ├── instr_vbroadcastf32x4.rs ├── instr_vbroadcastf64x2.rs ├── instr_vbroadcasti128.rs ├── instr_vbroadcasti32x2.rs ├── instr_vbroadcasti32x4.rs ├── instr_vbroadcasti32x8.rs ├── instr_vbroadcasti64x2.rs ├── instr_vbroadcasti64x4.rs ├── instr_vbroadcastsd.rs ├── instr_vbroadcastss.rs ├── instr_vcmppd.rs ├── instr_vcmpps.rs ├── instr_vcmpsd.rs ├── instr_vcmpss.rs ├── instr_vcomisd.rs ├── instr_vcomiss.rs ├── instr_vcompresspd.rs ├── instr_vcompressps.rs ├── instr_vcvtdq2pd.rs ├── instr_vcvtdq2ps.rs ├── instr_vcvtpd2dq.rs ├── instr_vcvtpd2ps.rs ├── instr_vcvtpd2qq.rs ├── instr_vcvtpd2udq.rs ├── instr_vcvtpd2uqq.rs ├── instr_vcvtph2ps.rs ├── instr_vcvtps2dq.rs ├── instr_vcvtps2pd.rs ├── instr_vcvtps2ph.rs ├── instr_vcvtps2qq.rs ├── instr_vcvtps2udq.rs ├── instr_vcvtps2uqq.rs ├── instr_vcvtqq2pd.rs ├── instr_vcvtqq2ps.rs ├── instr_vcvtsd2si.rs ├── instr_vcvtsd2ss.rs ├── instr_vcvtsd2usi.rs ├── instr_vcvtsi2sd.rs ├── instr_vcvtsi2ss.rs ├── instr_vcvtss2sd.rs ├── instr_vcvtss2si.rs ├── instr_vcvtss2usi.rs ├── instr_vcvttpd2dq.rs ├── instr_vcvttpd2qq.rs ├── instr_vcvttpd2udq.rs ├── instr_vcvttpd2uqq.rs ├── instr_vcvttps2dq.rs ├── instr_vcvttps2qq.rs ├── instr_vcvttps2udq.rs ├── instr_vcvttps2uqq.rs ├── instr_vcvttsd2si.rs ├── instr_vcvttsd2usi.rs ├── instr_vcvttss2si.rs ├── instr_vcvttss2usi.rs ├── instr_vcvtudq2pd.rs ├── instr_vcvtudq2ps.rs ├── instr_vcvtuqq2pd.rs ├── instr_vcvtuqq2ps.rs ├── instr_vcvtusi2sd.rs ├── instr_vcvtusi2ss.rs ├── instr_vdbpsadbw.rs ├── instr_vdivpd.rs ├── instr_vdivps.rs ├── instr_vdivsd.rs ├── instr_vdivss.rs ├── instr_vdppd.rs ├── instr_vdpps.rs ├── instr_verr.rs ├── instr_verw.rs ├── instr_vexp2pd.rs ├── instr_vexp2ps.rs ├── instr_vexpandpd.rs ├── instr_vexpandps.rs ├── instr_vextractf128.rs ├── instr_vextractf32x4.rs ├── instr_vextractf64x4.rs ├── instr_vextracti128.rs ├── instr_vextracti32x4.rs ├── instr_vextracti64x4.rs ├── instr_vextractps.rs ├── instr_vfixupimmpd.rs ├── instr_vfixupimmps.rs ├── instr_vfixupimmsd.rs ├── instr_vfixupimmss.rs ├── instr_vfmadd132pd.rs ├── instr_vfmadd132ps.rs ├── instr_vfmadd132sd.rs ├── instr_vfmadd132ss.rs ├── instr_vfmadd213pd.rs ├── instr_vfmadd213ps.rs ├── instr_vfmadd213sd.rs ├── instr_vfmadd213ss.rs ├── instr_vfmadd231pd.rs ├── instr_vfmadd231ps.rs ├── instr_vfmadd231sd.rs ├── instr_vfmadd231ss.rs ├── instr_vfmaddsub132pd.rs ├── instr_vfmaddsub132ps.rs ├── instr_vfmaddsub213pd.rs ├── instr_vfmaddsub213ps.rs ├── instr_vfmaddsub231pd.rs ├── instr_vfmaddsub231ps.rs ├── instr_vfmsub132pd.rs ├── instr_vfmsub132ps.rs ├── instr_vfmsub132sd.rs ├── instr_vfmsub132ss.rs ├── instr_vfmsub213pd.rs ├── instr_vfmsub213ps.rs ├── instr_vfmsub213sd.rs ├── instr_vfmsub213ss.rs ├── instr_vfmsub231pd.rs ├── instr_vfmsub231ps.rs ├── instr_vfmsub231sd.rs ├── instr_vfmsub231ss.rs ├── instr_vfmsubadd132pd.rs ├── instr_vfmsubadd132ps.rs ├── instr_vfmsubadd213pd.rs ├── instr_vfmsubadd213ps.rs ├── instr_vfmsubadd231pd.rs ├── instr_vfmsubadd231ps.rs ├── instr_vfnmadd132pd.rs ├── instr_vfnmadd132ps.rs ├── instr_vfnmadd132sd.rs ├── instr_vfnmadd132ss.rs ├── instr_vfnmadd213pd.rs ├── instr_vfnmadd213ps.rs ├── instr_vfnmadd213sd.rs ├── instr_vfnmadd213ss.rs ├── instr_vfnmadd231pd.rs ├── instr_vfnmadd231ps.rs ├── instr_vfnmadd231sd.rs ├── instr_vfnmadd231ss.rs ├── instr_vfnmsub132pd.rs ├── instr_vfnmsub132ps.rs ├── instr_vfnmsub132sd.rs ├── instr_vfnmsub132ss.rs ├── instr_vfnmsub213pd.rs ├── instr_vfnmsub213ps.rs ├── instr_vfnmsub213sd.rs ├── instr_vfnmsub213ss.rs ├── instr_vfnmsub231pd.rs ├── instr_vfnmsub231ps.rs ├── instr_vfnmsub231sd.rs ├── instr_vfnmsub231ss.rs ├── instr_vfpclasspd.rs ├── instr_vfpclassps.rs ├── instr_vfpclasssd.rs ├── instr_vfpclassss.rs ├── instr_vgetexppd.rs ├── instr_vgetexpps.rs ├── instr_vgetexpsd.rs ├── instr_vgetexpss.rs ├── instr_vgetmantpd.rs ├── instr_vgetmantps.rs ├── instr_vgetmantsd.rs ├── instr_vgetmantss.rs ├── instr_vhaddpd.rs ├── instr_vhaddps.rs ├── instr_vhsubpd.rs ├── instr_vhsubps.rs ├── instr_vinsertf128.rs ├── instr_vinserti128.rs ├── instr_vinsertps.rs ├── instr_vlddqu.rs ├── instr_vldmxcsr.rs ├── instr_vmaskmovdqu.rs ├── instr_vmaskmovpd.rs ├── instr_vmaskmovps.rs ├── instr_vmaxpd.rs ├── instr_vmaxps.rs ├── instr_vmaxsd.rs ├── instr_vmaxss.rs ├── instr_vminpd.rs ├── instr_vminps.rs ├── instr_vminsd.rs ├── instr_vminss.rs ├── instr_vmovapd.rs ├── instr_vmovaps.rs ├── instr_vmovd.rs ├── instr_vmovddup.rs ├── instr_vmovdqa.rs ├── instr_vmovdqa32.rs ├── instr_vmovdqa64.rs ├── instr_vmovdqu.rs ├── instr_vmovdqu16.rs ├── instr_vmovdqu32.rs ├── instr_vmovdqu64.rs ├── instr_vmovdqu8.rs ├── instr_vmovhlps.rs ├── instr_vmovhpd.rs ├── instr_vmovhps.rs ├── instr_vmovlhps.rs ├── instr_vmovlpd.rs ├── instr_vmovlps.rs ├── instr_vmovmskpd.rs ├── instr_vmovmskps.rs ├── instr_vmovntdq.rs ├── instr_vmovntdqa.rs ├── instr_vmovntpd.rs ├── instr_vmovntps.rs ├── instr_vmovsd.rs ├── instr_vmovshdup.rs ├── instr_vmovsldup.rs ├── instr_vmovss.rs ├── instr_vmovupd.rs ├── instr_vmovups.rs ├── instr_vmpsadbw.rs ├── instr_vmulpd.rs ├── instr_vmulps.rs ├── instr_vmulsd.rs ├── instr_vmulss.rs ├── instr_vorpd.rs ├── instr_vorps.rs ├── instr_vpabsb.rs ├── instr_vpabsd.rs ├── instr_vpabsw.rs ├── instr_vpackssdw.rs ├── instr_vpacksswb.rs ├── instr_vpackusdw.rs ├── instr_vpackuswb.rs ├── instr_vpaddb.rs ├── instr_vpaddd.rs ├── instr_vpaddq.rs ├── instr_vpaddsb.rs ├── instr_vpaddsw.rs ├── instr_vpaddusb.rs ├── instr_vpaddusw.rs ├── instr_vpaddw.rs ├── instr_vpalignr.rs ├── instr_vpand.rs ├── instr_vpandd.rs ├── instr_vpandn.rs ├── instr_vpandnd.rs ├── instr_vpandnq.rs ├── instr_vpandq.rs ├── instr_vpavgb.rs ├── instr_vpavgw.rs ├── instr_vpblendd.rs ├── instr_vpblendmb.rs ├── instr_vpblendmd.rs ├── instr_vpblendmq.rs ├── instr_vpblendmw.rs ├── instr_vpblendvb.rs ├── instr_vpblendw.rs ├── instr_vpclmulqdq.rs ├── instr_vpcmpb.rs ├── instr_vpcmpd.rs ├── instr_vpcmpeqb.rs ├── instr_vpcmpeqd.rs ├── instr_vpcmpeqq.rs ├── instr_vpcmpeqw.rs ├── instr_vpcmpestri.rs ├── instr_vpcmpestrm.rs ├── instr_vpcmpgtb.rs ├── instr_vpcmpgtd.rs ├── instr_vpcmpgtq.rs ├── instr_vpcmpgtw.rs ├── instr_vpcmpistri.rs ├── instr_vpcmpistrm.rs ├── instr_vpcmpq.rs ├── instr_vpcmpub.rs ├── instr_vpcmpud.rs ├── instr_vpcmpuq.rs ├── instr_vpcmpuw.rs ├── instr_vpcmpw.rs ├── instr_vpcompressd.rs ├── instr_vpcompressq.rs ├── instr_vpconflictd.rs ├── instr_vpconflictq.rs ├── instr_vperm2f128.rs ├── instr_vperm2i128.rs ├── instr_vpermd.rs ├── instr_vpermi2d.rs ├── instr_vpermi2pd.rs ├── instr_vpermi2ps.rs ├── instr_vpermi2q.rs ├── instr_vpermi2w.rs ├── instr_vpermilpd.rs ├── instr_vpermilps.rs ├── instr_vpermpd.rs ├── instr_vpermps.rs ├── instr_vpermq.rs ├── instr_vpermt2d.rs ├── instr_vpermt2pd.rs ├── instr_vpermt2ps.rs ├── instr_vpermt2q.rs ├── instr_vpermt2w.rs ├── instr_vpermw.rs ├── instr_vpexpandd.rs ├── instr_vpexpandq.rs ├── instr_vphaddd.rs ├── instr_vphaddsw.rs ├── instr_vphaddw.rs ├── instr_vphminposuw.rs ├── instr_vphsubd.rs ├── instr_vphsubsw.rs ├── instr_vphsubw.rs ├── instr_vpinsrb.rs ├── instr_vpinsrd.rs ├── instr_vpinsrq.rs ├── instr_vpinsrw.rs ├── instr_vplzcntd.rs ├── instr_vplzcntq.rs ├── instr_vpmaddubsw.rs ├── instr_vpmaddwd.rs ├── instr_vpmaskmovd.rs ├── instr_vpmaskmovq.rs ├── instr_vpmaxsb.rs ├── instr_vpmaxsd.rs ├── instr_vpmaxsw.rs ├── instr_vpmaxub.rs ├── instr_vpmaxud.rs ├── instr_vpmaxuq.rs ├── instr_vpmaxuw.rs ├── instr_vpminsb.rs ├── instr_vpminsd.rs ├── instr_vpminsq.rs ├── instr_vpminsw.rs ├── instr_vpminub.rs ├── instr_vpminud.rs ├── instr_vpminuq.rs ├── instr_vpminuw.rs ├── instr_vpmovb2m.rs ├── instr_vpmovd2m.rs ├── instr_vpmovdb.rs ├── instr_vpmovdw.rs ├── instr_vpmovm2b.rs ├── instr_vpmovm2d.rs ├── instr_vpmovm2q.rs ├── instr_vpmovm2w.rs ├── instr_vpmovmskb.rs ├── instr_vpmovq2m.rs ├── instr_vpmovqb.rs ├── instr_vpmovqw.rs ├── instr_vpmovsdb.rs ├── instr_vpmovsdw.rs ├── instr_vpmovsqb.rs ├── instr_vpmovsqd.rs ├── instr_vpmovsqw.rs ├── instr_vpmovswb.rs ├── instr_vpmovsxbd.rs ├── instr_vpmovsxbq.rs ├── instr_vpmovsxbw.rs ├── instr_vpmovsxdq.rs ├── instr_vpmovsxwd.rs ├── instr_vpmovsxwq.rs ├── instr_vpmovusdb.rs ├── instr_vpmovusdw.rs ├── instr_vpmovusqb.rs ├── instr_vpmovusqd.rs ├── instr_vpmovusqw.rs ├── instr_vpmovuswb.rs ├── instr_vpmovw2m.rs ├── instr_vpmovwb.rs ├── instr_vpmovzxbd.rs ├── instr_vpmovzxbq.rs ├── instr_vpmovzxbw.rs ├── instr_vpmovzxdq.rs ├── instr_vpmovzxwd.rs ├── instr_vpmovzxwq.rs ├── instr_vpmuldq.rs ├── instr_vpmulhrsw.rs ├── instr_vpmulhuw.rs ├── instr_vpmulhw.rs ├── instr_vpmulld.rs ├── instr_vpmullq.rs ├── instr_vpmullw.rs ├── instr_vpmuludq.rs ├── instr_vpor.rs ├── instr_vpord.rs ├── instr_vporq.rs ├── instr_vprold.rs ├── instr_vprolq.rs ├── instr_vprolvd.rs ├── instr_vprolvq.rs ├── instr_vprord.rs ├── instr_vprorq.rs ├── instr_vprorvd.rs ├── instr_vprorvq.rs ├── instr_vpsadbw.rs ├── instr_vpshufb.rs ├── instr_vpshufd.rs ├── instr_vpshufhw.rs ├── instr_vpshuflw.rs ├── instr_vpsignb.rs ├── instr_vpsignd.rs ├── instr_vpsignw.rs ├── instr_vpslld.rs ├── instr_vpslldq.rs ├── instr_vpsllq.rs ├── instr_vpsllvd.rs ├── instr_vpsllvq.rs ├── instr_vpsllvw.rs ├── instr_vpsllw.rs ├── instr_vpsrad.rs ├── instr_vpsraq.rs ├── instr_vpsravd.rs ├── instr_vpsravq.rs ├── instr_vpsravw.rs ├── instr_vpsraw.rs ├── instr_vpsrld.rs ├── instr_vpsrldq.rs ├── instr_vpsrlq.rs ├── instr_vpsrlvd.rs ├── instr_vpsrlvq.rs ├── instr_vpsrlvw.rs ├── instr_vpsrlw.rs ├── instr_vpsubb.rs ├── instr_vpsubd.rs ├── instr_vpsubq.rs ├── instr_vpsubsb.rs ├── instr_vpsubsw.rs ├── instr_vpsubusb.rs ├── instr_vpsubusw.rs ├── instr_vpsubw.rs ├── instr_vpternlogd.rs ├── instr_vpternlogq.rs ├── instr_vptest.rs ├── instr_vptestmb.rs ├── instr_vptestmd.rs ├── instr_vptestmq.rs ├── instr_vptestmw.rs ├── instr_vptestnmb.rs ├── instr_vptestnmd.rs ├── instr_vptestnmq.rs ├── instr_vptestnmw.rs ├── instr_vpunpckhbw.rs ├── instr_vpunpckhdq.rs ├── instr_vpunpckhqdq.rs ├── instr_vpunpckhwd.rs ├── instr_vpunpcklbw.rs ├── instr_vpunpckldq.rs ├── instr_vpunpcklqdq.rs ├── instr_vpunpcklwd.rs ├── instr_vpxor.rs ├── instr_vpxord.rs ├── instr_vpxorq.rs ├── instr_vrangepd.rs ├── instr_vrangeps.rs ├── instr_vrangesd.rs ├── instr_vrangess.rs ├── instr_vrcp14pd.rs ├── instr_vrcp14ps.rs ├── instr_vrcp14sd.rs ├── instr_vrcp14ss.rs ├── instr_vrcp28pd.rs ├── instr_vrcp28ps.rs ├── instr_vrcp28sd.rs ├── instr_vrcp28ss.rs ├── instr_vrcpps.rs ├── instr_vrcpss.rs ├── instr_vreducepd.rs ├── instr_vreduceps.rs ├── instr_vreducesd.rs ├── instr_vreducess.rs ├── instr_vrndscalepd.rs ├── instr_vrndscaleps.rs ├── instr_vrndscalesd.rs ├── instr_vrndscaless.rs ├── instr_vroundpd.rs ├── instr_vroundps.rs ├── instr_vroundsd.rs ├── instr_vroundss.rs ├── instr_vrsqrt14pd.rs ├── instr_vrsqrt14ps.rs ├── instr_vrsqrt14sd.rs ├── instr_vrsqrt14ss.rs ├── instr_vrsqrt28pd.rs ├── instr_vrsqrt28ps.rs ├── instr_vrsqrt28sd.rs ├── instr_vrsqrt28ss.rs ├── instr_vrsqrtps.rs ├── instr_vrsqrtss.rs ├── instr_vscalefpd.rs ├── instr_vscalefps.rs ├── instr_vscalefsd.rs ├── instr_vscalefss.rs ├── instr_vshuff32x4.rs ├── instr_vshuff64x2.rs ├── instr_vshufi32x4.rs ├── instr_vshufi64x2.rs ├── instr_vshufpd.rs ├── instr_vshufps.rs ├── instr_vsqrtps.rs ├── instr_vsqrtsd.rs ├── instr_vsqrtss.rs ├── instr_vstmxcsr.rs ├── instr_vsubpd.rs ├── instr_vsubps.rs ├── instr_vsubsd.rs ├── instr_vsubss.rs ├── instr_vtestpd.rs ├── instr_vtestps.rs ├── instr_vucomisd.rs ├── instr_vucomiss.rs ├── instr_vunpckhpd.rs ├── instr_vunpckhps.rs ├── instr_vunpcklpd.rs ├── instr_vunpcklps.rs ├── instr_vxorpd.rs ├── instr_vxorps.rs ├── instr_vzeroall.rs ├── instr_vzeroupper.rs ├── instr_wait.rs ├── instr_wbinvd.rs ├── instr_wrfsbase.rs ├── instr_wrgsbase.rs ├── instr_wrmsr.rs ├── instr_wrpkru.rs ├── instr_xabort.rs ├── instr_xacquire.rs ├── instr_xadd.rs ├── instr_xbegin.rs ├── instr_xchg.rs ├── instr_xend.rs ├── instr_xgetbv.rs ├── instr_xlat.rs ├── instr_xlatb.rs ├── instr_xor.rs ├── instr_xorpd.rs ├── instr_xorps.rs ├── instr_xrelease.rs ├── instr_xrstor.rs ├── instr_xrstor64.rs ├── instr_xrstors.rs ├── instr_xrstors64.rs ├── instr_xsave.rs ├── instr_xsave64.rs ├── instr_xsavec.rs ├── instr_xsavec64.rs ├── instr_xsaveopt.rs ├── instr_xsaves.rs ├── instr_xsaves64.rs ├── instr_xsetbv.rs ├── instr_xtest.rs ├── insw.rs ├── int.rs ├── into.rs ├── invd.rs ├── invlpg.rs ├── invpcid.rs ├── iret.rs ├── iretd.rs ├── iretq.rs ├── ja.rs ├── jae.rs ├── jb.rs ├── jbe.rs ├── jc.rs ├── jcxz.rs ├── je.rs ├── jecxz.rs ├── jg.rs ├── jge.rs ├── jl.rs ├── jle.rs ├── jna.rs ├── jnae.rs ├── jnb.rs ├── jnbe.rs ├── jnc.rs ├── jne.rs ├── jng.rs ├── jnge.rs ├── jnl.rs ├── jnle.rs ├── jno.rs ├── jnp.rs ├── jns.rs ├── jnz.rs ├── jo.rs ├── jp.rs ├── jpe.rs ├── jpo.rs ├── jrcxz.rs ├── js.rs ├── jz.rs ├── kaddb.rs ├── kaddd.rs ├── kaddq.rs ├── kaddw.rs ├── kandb.rs ├── kandd.rs ├── kandnb.rs ├── kandnd.rs ├── kandnq.rs ├── kandnw.rs ├── kandq.rs ├── kandw.rs ├── kmovb.rs ├── kmovd.rs ├── kmovq.rs ├── kmovw.rs ├── knotb.rs ├── knotd.rs ├── knotq.rs ├── knotw.rs ├── korb.rs ├── kord.rs ├── korq.rs ├── kortestb.rs ├── kortestd.rs ├── kortestq.rs ├── kortestw.rs ├── korw.rs ├── kshiftlb.rs ├── kshiftld.rs ├── kshiftlq.rs ├── kshiftlw.rs ├── kshiftrb.rs ├── kshiftrd.rs ├── kshiftrq.rs ├── kshiftrw.rs ├── ktestb.rs ├── ktestd.rs ├── ktestq.rs ├── ktestw.rs ├── kunpckbw.rs ├── kunpckdq.rs ├── kunpckwd.rs ├── kxnorb.rs ├── kxnord.rs ├── kxnorq.rs ├── kxnorw.rs ├── kxorb.rs ├── kxord.rs ├── kxorq.rs ├── kxorw.rs ├── lahf.rs ├── lddqu.rs ├── ldmxcsr.rs ├── lds.rs ├── lea.rs ├── leave.rs ├── les.rs ├── lfence.rs ├── lfs.rs ├── lgdt.rs ├── lgs.rs ├── lidt.rs ├── lldt.rs ├── lmsw.rs ├── lock.rs ├── lods.rs ├── lodsb.rs ├── lodsd.rs ├── lodsq.rs ├── lodsw.rs ├── loop.rs ├── loope.rs ├── loopne.rs ├── lsl.rs ├── lss.rs ├── ltr.rs ├── lzcnt.rs ├── maskmovdqu.rs ├── maskmovq.rs ├── maxpd.rs ├── maxps.rs ├── maxsd.rs ├── maxss.rs ├── mfence.rs ├── minpd.rs ├── minps.rs ├── minsd.rs ├── minss.rs ├── mod.rs ├── monitor.rs ├── movapd.rs ├── movaps.rs ├── movbe.rs ├── movd.rs ├── movddup.rs ├── movdq2q.rs ├── movdqa.rs ├── movdqu.rs ├── movhlps.rs ├── movhpd.rs ├── movhps.rs ├── movlhps.rs ├── movlpd.rs ├── movlps.rs ├── movmskpd.rs ├── movmskps.rs ├── movntdq.rs ├── movntdqa.rs ├── movntpd.rs ├── movntps.rs ├── movntq.rs ├── movq2dq.rs ├── movs.rs ├── movsb.rs ├── movsd.rs ├── movshdup.rs ├── movsldup.rs ├── movsq.rs ├── movss.rs ├── movsw.rs ├── movsxd.rs ├── movupd.rs ├── movups.rs ├── mpsadbw.rs ├── mul.rs ├── mulpd.rs ├── mulps.rs ├── mulsd.rs ├── mulss.rs ├── mulx.rs ├── mwait.rs ├── neg.rs ├── nop.rs ├── not.rs ├── or.rs ├── orpd.rs ├── orps.rs ├── out.rs ├── outs.rs ├── outsb.rs ├── outsd.rs ├── outsw.rs ├── pabsb.rs ├── pabsd.rs ├── pabsw.rs ├── packssdw.rs ├── packsswb.rs ├── packusdw.rs ├── packuswb.rs ├── paddb.rs ├── paddd.rs ├── paddq.rs ├── paddsb.rs ├── paddsw.rs ├── paddusb.rs ├── paddusw.rs ├── paddw.rs ├── palignr.rs ├── pand.rs ├── pandn.rs ├── pause.rs ├── pavgb.rs ├── pavgw.rs ├── pblendvb.rs ├── pblendw.rs ├── pclmulqdq.rs ├── pcmpeqb.rs ├── pcmpeqd.rs ├── pcmpeqq.rs ├── pcmpeqw.rs ├── pcmpestri.rs ├── pcmpestrm.rs ├── pcmpgtb.rs ├── pcmpgtd.rs ├── pcmpgtq.rs ├── pcmpgtw.rs ├── pcmpistri.rs ├── pcmpistrm.rs ├── pdep.rs ├── pext.rs ├── phaddd.rs ├── phaddsw.rs ├── phaddw.rs ├── phminposuw.rs ├── phsubd.rs ├── phsubsw.rs ├── phsubw.rs ├── pinsrb.rs ├── pinsrd.rs ├── pinsrq.rs ├── pinsrw.rs ├── pmaddubsw.rs ├── pmaddwd.rs ├── pmaxsb.rs ├── pmaxsd.rs ├── pmaxsw.rs ├── pmaxub.rs ├── pmaxud.rs ├── pmaxuw.rs ├── pminsb.rs ├── pminsd.rs ├── pminsw.rs ├── pminub.rs ├── pminud.rs ├── pminuw.rs ├── pmovmskb.rs ├── pmovsxbd.rs ├── pmovsxbq.rs ├── pmovsxbw.rs ├── pmovsxdq.rs ├── pmovsxwd.rs ├── pmovsxwq.rs ├── pmovzxbd.rs ├── pmovzxbq.rs ├── pmovzxbw.rs ├── pmovzxdq.rs ├── pmovzxwd.rs ├── pmovzxwq.rs ├── pmuldq.rs ├── pmulhrsw.rs ├── pmulhuw.rs ├── pmulhw.rs ├── pmulld.rs ├── pmullw.rs ├── pmuludq.rs ├── popa.rs ├── popad.rs ├── popcnt.rs ├── popf.rs ├── popfd.rs ├── popfq.rs ├── por.rs ├── prefetchnta.rs ├── prefetcht0.rs ├── prefetcht1.rs ├── prefetcht2.rs ├── prefetchw.rs ├── prefetchwt1.rs ├── psadbw.rs ├── pshufb.rs ├── pshufd.rs ├── pshufhw.rs ├── pshuflw.rs ├── pshufw.rs ├── psignb.rs ├── psignd.rs ├── psignw.rs ├── pslld.rs ├── pslldq.rs ├── psllq.rs ├── psllw.rs ├── psrad.rs ├── psraw.rs ├── psrld.rs ├── psrldq.rs ├── psrlq.rs ├── psrlw.rs ├── psubb.rs ├── psubd.rs ├── psubq.rs ├── psubsb.rs ├── psubsw.rs ├── psubusb.rs ├── psubusw.rs ├── psubw.rs ├── ptest.rs ├── punpckhbw.rs ├── punpckhdq.rs ├── punpckhqdq.rs ├── punpckhwd.rs ├── punpcklbw.rs ├── punpckldq.rs ├── punpcklqdq.rs ├── punpcklwd.rs ├── pusha.rs ├── pushad.rs ├── pushf.rs ├── pushfd.rs ├── pushfq.rs ├── pxor.rs ├── rcpps.rs ├── rcpss.rs ├── rdfsbase.rs ├── rdgsbase.rs ├── rdmsr.rs ├── rdpkru.rs ├── rdpmc.rs ├── rdrand.rs ├── rdseed.rs ├── rdtsc.rs ├── rdtscp.rs ├── ret.rs ├── rorx.rs ├── roundpd.rs ├── roundps.rs ├── roundsd.rs ├── roundss.rs ├── rsm.rs ├── rsqrtps.rs ├── rsqrtss.rs ├── sahf.rs ├── sarx.rs ├── sbb.rs ├── scas.rs ├── scasb.rs ├── scasd.rs ├── scasq.rs ├── scasw.rs ├── seta.rs ├── setae.rs ├── setb.rs ├── setbe.rs ├── setc.rs ├── sete.rs ├── setg.rs ├── setge.rs ├── setl.rs ├── setle.rs ├── setna.rs ├── setnae.rs ├── setnb.rs ├── setnbe.rs ├── setnc.rs ├── setne.rs ├── setng.rs ├── setnge.rs ├── setnl.rs ├── setnle.rs ├── sfence.rs ├── sgdt.rs ├── sha1msg1.rs ├── sha1msg2.rs ├── sha1nexte.rs ├── sha1rnds4.rs ├── sha256msg1.rs ├── sha256msg2.rs ├── sha256rnds2.rs ├── shld.rs ├── shlx.rs ├── shrd.rs ├── shrx.rs ├── shufpd.rs ├── shufps.rs ├── sidt.rs ├── sqrtps.rs ├── sqrtsd.rs ├── sqrtss.rs ├── stac.rs ├── stc.rs ├── std.rs ├── sti.rs ├── stmxcsr.rs ├── stos.rs ├── stosb.rs ├── stosd.rs ├── stosq.rs ├── stosw.rs ├── sub.rs ├── subpd.rs ├── subps.rs ├── subsd.rs ├── subss.rs ├── swapgs.rs ├── syscall.rs ├── sysenter.rs ├── sysexit.rs ├── sysret.rs ├── test.rs ├── tzcnt.rs ├── ucomisd.rs ├── ucomiss.rs ├── ud0.rs ├── ud2.rs ├── unpckhpd.rs ├── unpckhps.rs ├── unpcklpd.rs ├── unpcklps.rs ├── vaddpd.rs ├── vaddps.rs ├── vaddsd.rs ├── vaddss.rs ├── vaddsubpd.rs ├── vaddsubps.rs ├── vaesdec.rs ├── vaesdeclast.rs ├── vaesenc.rs ├── vaesenclast.rs ├── vaesimc.rs ├── vaeskeygenassist.rs ├── valignd.rs ├── valignq.rs ├── vandnpd.rs ├── vandnps.rs ├── vandpd.rs ├── vandps.rs ├── vblendmpd.rs ├── vblendmps.rs ├── vblendpd.rs ├── vblendps.rs ├── vblendvpd.rs ├── vblendvps.rs ├── vbroadcastf128.rs ├── vbroadcastf32x2.rs ├── vbroadcastf32x4.rs ├── vbroadcastf64x2.rs ├── vbroadcasti128.rs ├── vbroadcasti32x2.rs ├── vbroadcasti32x4.rs ├── vbroadcasti32x8.rs ├── vbroadcasti64x2.rs ├── vbroadcasti64x4.rs ├── vbroadcastsd.rs ├── vbroadcastss.rs ├── vcmppd.rs ├── vcmpps.rs ├── vcmpsd.rs ├── vcmpss.rs ├── vcomisd.rs ├── vcomiss.rs ├── vcompresspd.rs ├── vcompressps.rs ├── vcvtdq2pd.rs ├── vcvtdq2ps.rs ├── vcvtpd2dq.rs ├── vcvtpd2ps.rs ├── vcvtpd2qq.rs ├── vcvtpd2udq.rs ├── vcvtpd2uqq.rs ├── vcvtph2ps.rs ├── vcvtps2dq.rs ├── vcvtps2pd.rs ├── vcvtps2ph.rs ├── vcvtps2qq.rs ├── vcvtps2udq.rs ├── vcvtps2uqq.rs ├── vcvtqq2pd.rs ├── vcvtqq2ps.rs ├── vcvtsd2si.rs ├── vcvtsd2ss.rs ├── vcvtsd2usi.rs ├── vcvtsi2sd.rs ├── vcvtsi2ss.rs ├── vcvtss2sd.rs ├── vcvtss2si.rs ├── vcvtss2usi.rs ├── vcvttpd2dq.rs ├── vcvttpd2qq.rs ├── vcvttpd2uqq.rs ├── vcvttps2dq.rs ├── vcvttps2qq.rs ├── vcvttps2udq.rs ├── vcvttps2uqq.rs ├── vcvttsd2si.rs ├── vcvttsd2usi.rs ├── vcvttss2si.rs ├── vcvttss2usi.rs ├── vcvtudq2pd.rs ├── vcvtudq2ps.rs ├── vcvtuqq2pd.rs ├── vcvtuqq2ps.rs ├── vcvtusi2sd.rs ├── vcvtusi2ss.rs ├── vdbpsadbw.rs ├── vdivpd.rs ├── vdivps.rs ├── vdivsd.rs ├── vdivss.rs ├── vdppd.rs ├── vdpps.rs ├── verr.rs ├── verw.rs ├── vexp2pd.rs ├── vexp2ps.rs ├── vexpandpd.rs ├── vexpandps.rs ├── vextractf128.rs ├── vextractf32x4.rs ├── vextractf64x4.rs ├── vextracti128.rs ├── vextracti32x4.rs ├── vextracti64x4.rs ├── vextractps.rs ├── vfixupimmpd.rs ├── vfixupimmps.rs ├── vfixupimmsd.rs ├── vfixupimmss.rs ├── vfmadd132pd.rs ├── vfmadd132ps.rs ├── vfmadd132sd.rs ├── vfmadd132ss.rs ├── vfmadd213pd.rs ├── vfmadd213ps.rs ├── vfmadd213sd.rs ├── vfmadd213ss.rs ├── vfmadd231pd.rs ├── vfmadd231ps.rs ├── vfmadd231sd.rs ├── vfmadd231ss.rs ├── vfmaddsub132pd.rs ├── vfmaddsub132ps.rs ├── vfmaddsub213pd.rs ├── vfmaddsub213ps.rs ├── vfmaddsub231pd.rs ├── vfmaddsub231ps.rs ├── vfmsub132pd.rs ├── vfmsub132ps.rs ├── vfmsub132sd.rs ├── vfmsub132ss.rs ├── vfmsub213pd.rs ├── vfmsub213ps.rs ├── vfmsub213sd.rs ├── vfmsub213ss.rs ├── vfmsub231pd.rs ├── vfmsub231ps.rs ├── vfmsub231sd.rs ├── vfmsub231ss.rs ├── vfmsubadd132pd.rs ├── vfmsubadd132ps.rs ├── vfmsubadd213pd.rs ├── vfmsubadd213ps.rs ├── vfmsubadd231pd.rs ├── vfmsubadd231ps.rs ├── vfnmadd132pd.rs ├── vfnmadd132ps.rs ├── vfnmadd132sd.rs ├── vfnmadd132ss.rs ├── vfnmadd213pd.rs ├── vfnmadd213ps.rs ├── vfnmadd213sd.rs ├── vfnmadd213ss.rs ├── vfnmadd231pd.rs ├── vfnmadd231ps.rs ├── vfnmadd231sd.rs ├── vfnmadd231ss.rs ├── vfnmsub132pd.rs ├── vfnmsub132ps.rs ├── vfnmsub132sd.rs ├── vfnmsub132ss.rs ├── vfnmsub213pd.rs ├── vfnmsub213ps.rs ├── vfnmsub213sd.rs ├── vfnmsub213ss.rs ├── vfnmsub231pd.rs ├── vfnmsub231ps.rs ├── vfnmsub231sd.rs ├── vfnmsub231ss.rs ├── vfpclasspd.rs ├── vfpclassps.rs ├── vfpclasssd.rs ├── vfpclassss.rs ├── vgetexppd.rs ├── vgetexpps.rs ├── vgetexpsd.rs ├── vgetexpss.rs ├── vgetmantpd.rs ├── vgetmantps.rs ├── vgetmantsd.rs ├── vgetmantss.rs ├── vhaddpd.rs ├── vhaddps.rs ├── vhsubpd.rs ├── vhsubps.rs ├── vinsertf128.rs ├── vinserti128.rs ├── vinsertps.rs ├── vlddqu.rs ├── vldmxcsr.rs ├── vmaskmovdqu.rs ├── vmaskmovpd.rs ├── vmaskmovps.rs ├── vmaxpd.rs ├── vmaxps.rs ├── vmaxsd.rs ├── vmaxss.rs ├── vminpd.rs ├── vminps.rs ├── vminsd.rs ├── vminss.rs ├── vmovapd.rs ├── vmovaps.rs ├── vmovd.rs ├── vmovddup.rs ├── vmovdqa.rs ├── vmovdqa32.rs ├── vmovdqa64.rs ├── vmovdqu.rs ├── vmovdqu16.rs ├── vmovdqu32.rs ├── vmovdqu64.rs ├── vmovdqu8.rs ├── vmovhlps.rs ├── vmovhpd.rs ├── vmovhps.rs ├── vmovlhps.rs ├── vmovlpd.rs ├── vmovlps.rs ├── vmovmskpd.rs ├── vmovmskps.rs ├── vmovntdq.rs ├── vmovntdqa.rs ├── vmovntpd.rs ├── vmovntps.rs ├── vmovsd.rs ├── vmovshdup.rs ├── vmovsldup.rs ├── vmovss.rs ├── vmovupd.rs ├── vmovups.rs ├── vmpsadbw.rs ├── vmulpd.rs ├── vmulps.rs ├── vmulsd.rs ├── vmulss.rs ├── vorpd.rs ├── vorps.rs ├── vpabsb.rs ├── vpabsd.rs ├── vpabsw.rs ├── vpackssdw.rs ├── vpacksswb.rs ├── vpackusdw.rs ├── vpackuswb.rs ├── vpaddb.rs ├── vpaddd.rs ├── vpaddq.rs ├── vpaddsb.rs ├── vpaddsw.rs ├── vpaddusb.rs ├── vpaddusw.rs ├── vpaddw.rs ├── vpalignr.rs ├── vpand.rs ├── vpandd.rs ├── vpandn.rs ├── vpandnd.rs ├── vpandnq.rs ├── vpandq.rs ├── vpavgb.rs ├── vpavgw.rs ├── vpblendd.rs ├── vpblendmb.rs ├── vpblendmd.rs ├── vpblendmq.rs ├── vpblendmw.rs ├── vpblendvb.rs ├── vpblendw.rs ├── vpclmulqdq.rs ├── vpcmpb.rs ├── vpcmpd.rs ├── vpcmpeqb.rs ├── vpcmpeqd.rs ├── vpcmpeqq.rs ├── vpcmpeqw.rs ├── vpcmpestri.rs ├── vpcmpestrm.rs ├── vpcmpgtb.rs ├── vpcmpgtd.rs ├── vpcmpgtq.rs ├── vpcmpgtw.rs ├── vpcmpistri.rs ├── vpcmpistrm.rs ├── vpcmpq.rs ├── vpcmpub.rs ├── vpcmpud.rs ├── vpcmpuq.rs ├── vpcmpuw.rs ├── vpcmpw.rs ├── vpcompressd.rs ├── vpcompressq.rs ├── vpconflictd.rs ├── vpconflictq.rs ├── vperm2f128.rs ├── vperm2i128.rs ├── vpermd.rs ├── vpermi2d.rs ├── vpermi2pd.rs ├── vpermi2ps.rs ├── vpermi2q.rs ├── vpermi2w.rs ├── vpermilpd.rs ├── vpermilps.rs ├── vpermpd.rs ├── vpermps.rs ├── vpermq.rs ├── vpermt2d.rs ├── vpermt2pd.rs ├── vpermt2ps.rs ├── vpermt2q.rs ├── vpermt2w.rs ├── vpermw.rs ├── vpexpandd.rs ├── vpexpandq.rs ├── vphaddd.rs ├── vphaddsw.rs ├── vphaddw.rs ├── vphminposuw.rs ├── vphsubd.rs ├── vphsubsw.rs ├── vphsubw.rs ├── vpinsrb.rs ├── vpinsrd.rs ├── vpinsrq.rs ├── vpinsrw.rs ├── vplzcntd.rs ├── vplzcntq.rs ├── vpmaddubsw.rs ├── vpmaddwd.rs ├── vpmaskmovd.rs ├── vpmaskmovq.rs ├── vpmaxsb.rs ├── vpmaxsd.rs ├── vpmaxsw.rs ├── vpmaxub.rs ├── vpmaxud.rs ├── vpmaxuq.rs ├── vpmaxuw.rs ├── vpminsb.rs ├── vpminsd.rs ├── vpminsq.rs ├── vpminsw.rs ├── vpminub.rs ├── vpminud.rs ├── vpminuq.rs ├── vpminuw.rs ├── vpmovb2m.rs ├── vpmovd2m.rs ├── vpmovdb.rs ├── vpmovdw.rs ├── vpmovm2b.rs ├── vpmovm2d.rs ├── vpmovm2q.rs ├── vpmovm2w.rs ├── vpmovmskb.rs ├── vpmovq2m.rs ├── vpmovqb.rs ├── vpmovqw.rs ├── vpmovsdb.rs ├── vpmovsdw.rs ├── vpmovsqb.rs ├── vpmovsqd.rs ├── vpmovsqw.rs ├── vpmovswb.rs ├── vpmovsxbd.rs ├── vpmovsxbq.rs ├── vpmovsxbw.rs ├── vpmovsxdq.rs ├── vpmovsxwd.rs ├── vpmovsxwq.rs ├── vpmovusdb.rs ├── vpmovusdw.rs ├── vpmovusqb.rs ├── vpmovusqd.rs ├── vpmovusqw.rs ├── vpmovuswb.rs ├── vpmovw2m.rs ├── vpmovwb.rs ├── vpmovzxbd.rs ├── vpmovzxbq.rs ├── vpmovzxbw.rs ├── vpmovzxdq.rs ├── vpmovzxwd.rs ├── vpmovzxwq.rs ├── vpmuldq.rs ├── vpmulhrsw.rs ├── vpmulhuw.rs ├── vpmulhw.rs ├── vpmulld.rs ├── vpmullq.rs ├── vpmullw.rs ├── vpmuludq.rs ├── vpor.rs ├── vpord.rs ├── vporq.rs ├── vprold.rs ├── vprolq.rs ├── vprolvd.rs ├── vprolvq.rs ├── vprord.rs ├── vprorq.rs ├── vprorvd.rs ├── vprorvq.rs ├── vpsadbw.rs ├── vpshufb.rs ├── vpshufd.rs ├── vpshufhw.rs ├── vpshuflw.rs ├── vpsignb.rs ├── vpsignd.rs ├── vpsignw.rs ├── vpslld.rs ├── vpslldq.rs ├── vpsllq.rs ├── vpsllvd.rs ├── vpsllvq.rs ├── vpsllvw.rs ├── vpsllw.rs ├── vpsrad.rs ├── vpsraq.rs ├── vpsravd.rs ├── vpsravq.rs ├── vpsravw.rs ├── vpsraw.rs ├── vpsrld.rs ├── vpsrldq.rs ├── vpsrlq.rs ├── vpsrlvd.rs ├── vpsrlvq.rs ├── vpsrlvw.rs ├── vpsrlw.rs ├── vpsubb.rs ├── vpsubd.rs ├── vpsubq.rs ├── vpsubsb.rs ├── vpsubsw.rs ├── vpsubusb.rs ├── vpsubusw.rs ├── vpsubw.rs ├── vpternlogd.rs ├── vpternlogq.rs ├── vptest.rs ├── vptestmb.rs ├── vptestmd.rs ├── vptestmq.rs ├── vptestmw.rs ├── vptestnmb.rs ├── vptestnmd.rs ├── vptestnmq.rs ├── vptestnmw.rs ├── vpunpckhbw.rs ├── vpunpckhdq.rs ├── vpunpckhqdq.rs ├── vpunpckhwd.rs ├── vpunpcklbw.rs ├── vpunpckldq.rs ├── vpunpcklqdq.rs ├── vpunpcklwd.rs ├── vpxor.rs ├── vpxord.rs ├── vpxorq.rs ├── vrangepd.rs ├── vrangeps.rs ├── vrangesd.rs ├── vrangess.rs ├── vrcp14pd.rs ├── vrcp14ps.rs ├── vrcp14sd.rs ├── vrcp14ss.rs ├── vrcp28pd.rs ├── vrcp28ps.rs ├── vrcp28sd.rs ├── vrcp28ss.rs ├── vrcpps.rs ├── vrcpss.rs ├── vreducepd.rs ├── vreduceps.rs ├── vreducesd.rs ├── vreducess.rs ├── vrndscalepd.rs ├── vrndscaleps.rs ├── vrndscalesd.rs ├── vrndscaless.rs ├── vroundpd.rs ├── vroundps.rs ├── vroundsd.rs ├── vroundss.rs ├── vrsqrt14pd.rs ├── vrsqrt14ps.rs ├── vrsqrt14sd.rs ├── vrsqrt14ss.rs ├── vrsqrt28pd.rs ├── vrsqrt28ps.rs ├── vrsqrt28sd.rs ├── vrsqrt28ss.rs ├── vrsqrtps.rs ├── vrsqrtss.rs ├── vscalefpd.rs ├── vscalefps.rs ├── vscalefsd.rs ├── vscalefss.rs ├── vshuff32x4.rs ├── vshuff64x2.rs ├── vshufi32x4.rs ├── vshufi64x2.rs ├── vshufpd.rs ├── vshufps.rs ├── vsqrtps.rs ├── vsqrtsd.rs ├── vsqrtss.rs ├── vstmxcsr.rs ├── vsubpd.rs ├── vsubps.rs ├── vsubsd.rs ├── vsubss.rs ├── vtestpd.rs ├── vtestps.rs ├── vucomisd.rs ├── vucomiss.rs ├── vunpckhpd.rs ├── vunpckhps.rs ├── vunpcklpd.rs ├── vunpcklps.rs ├── vxorpd.rs ├── vxorps.rs ├── vzeroall.rs ├── vzeroupper.rs ├── wait.rs ├── wbinvd.rs ├── wrfsbase.rs ├── wrgsbase.rs ├── wrmsr.rs ├── wrpkru.rs ├── xabort.rs ├── xacquire.rs ├── xadd.rs ├── xbegin.rs ├── xend.rs ├── xgetbv.rs ├── xlat.rs ├── xlatb.rs ├── xor.rs ├── xorpd.rs ├── xorps.rs ├── xrelease.rs ├── xrstor.rs ├── xrstor64.rs ├── xrstors.rs ├── xrstors64.rs ├── xsave.rs ├── xsave64.rs ├── xsavec.rs ├── xsavec64.rs ├── xsaveopt.rs ├── xsaves.rs ├── xsaves64.rs ├── xsetbv.rs └── xtest.rs ├── mod.rs └── size_inference.rs /.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | **/*.rs.bk 3 | Cargo.lock 4 | *.bin 5 | *.swo 6 | *.swn 7 | *.swp 8 | gen_defs/test 9 | gen_defs/instruction_tests 10 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "x86asm" 3 | version = "0.1.0" 4 | authors = ["Gregory Comer "] 5 | description = "A crate for assembling and disassembling x86 instructions." 6 | repository = "https://github.com/GregoryComer/rust-x86asm" 7 | readme = "README.md" 8 | keywords = ["x86", "assembly", "assemble", "disassemble"] 9 | license = "MIT" 10 | 11 | [dependencies] 12 | arrayvec = "0.3.23" 13 | byteorder = "1" 14 | lazy_static = "0.2" 15 | matches = "0.1" 16 | -------------------------------------------------------------------------------- /examples/encode_basic.rs: -------------------------------------------------------------------------------- 1 | extern crate x86asm; 2 | 3 | use std::io::Cursor; 4 | use x86asm::{InstructionWriter, Mnemonic, Mode, Operand, Reg}; 5 | 6 | fn main() { 7 | let buffer = Cursor::new(Vec::new()); 8 | let mut writer = InstructionWriter::new(buffer, Mode::Protected); 9 | 10 | let bytes_written = 11 | writer.write2(Mnemonic::MOV, Operand::Direct(Reg::EAX), Operand::Literal32(10)).unwrap() + // mov eax, 10 12 | writer.write2(Mnemonic::MOV, Operand::Direct(Reg::EBX), Operand::Literal32(20)).unwrap() + // mov ebx, 20 13 | writer.write2(Mnemonic::ADD, Operand::Direct(Reg::EAX), Operand::Direct(Reg::EBX)).unwrap(); // add eax, ebx 14 | 15 | print!("Output ({} bytes): ", bytes_written); 16 | for byte in writer.get_inner_writer_ref().get_ref().iter() { 17 | print!("{:02X} ", byte); 18 | } 19 | println!(""); 20 | } 21 | -------------------------------------------------------------------------------- /gen_defs/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "libx86_parse_def" 3 | version = "0.1.0" 4 | authors = ["gregory"] 5 | 6 | [dependencies] 7 | csv = "1.0.0-beta.4" 8 | nom = "^3.2" 9 | serde = "1.0.15" 10 | serde_derive = "1.0.15" 11 | rand = "0.3" 12 | itertools = "0.7.1" 13 | -------------------------------------------------------------------------------- /gen_defs/README.md: -------------------------------------------------------------------------------- 1 | # Instruction Generation 2 | 3 | Instruction defitions are programatically generated from the Intel x86 reference manual. The instruction generation code reads from a csv representation extracted from the Intel reference manual. This csv is bundled with this repository. For information on this csv, see https://github.com/GregoryComer/x86-csv. 4 | 5 | Once read, each row in the csv is converted into an InstructionDefinition and written to stdout. When run with --tests, tests are also output to the test directory. 6 | 7 | ## Running 8 | To run the instruction & test generator, run the shell script make_all.sh. This requires GNU AS to be installed for test generation. To copy the output to the main crate, run deploy.sh. 9 | -------------------------------------------------------------------------------- /gen_defs/deploy.sh: -------------------------------------------------------------------------------- 1 | cp instruction_defs.rs ../src/ 2 | cp mnemonic.rs ../src/ 3 | cp -r instruction_tests ../src/test/ 4 | -------------------------------------------------------------------------------- /gen_defs/src/todo: -------------------------------------------------------------------------------- 1 | - MOV SREG forms can use op size prefix in place of VEX.W in 32-bit mode. Need to add instruction defs for this case as it's not explicit in intel docs. 2 | - Manual defs - VPBROADCAST/VPBROADCASTB files overlap? 3 | - Handle unsized register operands better (don't enforce size?) 4 | -------------------------------------------------------------------------------- /src/test/README.md: -------------------------------------------------------------------------------- 1 | # NOTES 2 | All tests in the instruction_tests subdirectory are autogenerated. See *gen_defs/README* for details on modifying these tests. 3 | -------------------------------------------------------------------------------- /src/test/encode.rs: -------------------------------------------------------------------------------- 1 | use ::*; 2 | use ::test::*; 3 | 4 | #[test] 5 | fn extended_regs() { 6 | run_test(&Instruction::new2(Mnemonic::ADD, Operand::Direct(Reg::RAX), Operand::Direct(Reg::R8)), &[0x4C, 0x01, 0xC0], OperandSize::Qword); 7 | run_test(&Instruction::new2(Mnemonic::ADD, Operand::Direct(Reg::AL), Operand::Direct(Reg::SPL)), &[0x40, 0x00, 0xE0], OperandSize::Qword); 8 | run_test(&Instruction::new2(Mnemonic::ADD, Operand::Direct(Reg::AL), Operand::Direct(Reg::BPL)), &[0x40, 0x00, 0xE8], OperandSize::Qword); 9 | run_test(&Instruction::new2(Mnemonic::ADD, Operand::Direct(Reg::AL), Operand::Direct(Reg::SIL)), &[0x40, 0x00, 0xF0], OperandSize::Qword); 10 | run_test(&Instruction::new2(Mnemonic::ADD, Operand::Direct(Reg::AL), Operand::Direct(Reg::DIL)), &[0x40, 0x00, 0xF8], OperandSize::Qword); 11 | } 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/aaa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/aad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn aad_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::AAD, operand1: Some(Literal8(27)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[213, 27], OperandSize::Word) 10 | } 11 | 12 | fn aad_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::AAD, operand1: Some(Literal8(118)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[213, 118], OperandSize::Dword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/aam.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn aam_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::AAM, operand1: Some(Literal8(35)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[212, 35], OperandSize::Word) 10 | } 11 | 12 | fn aam_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::AAM, operand1: Some(Literal8(17)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[212, 17], OperandSize::Dword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/aas.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cbw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cdq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cdqe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/clac.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/clc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cld.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cli.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/clts.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cmc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cmpsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cmpsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cmpsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cmpxchg16b.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn cmpxchg16b_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::CMPXCHG16B, operand1: Some(IndirectScaledIndexedDisplaced(RDI, RCX, Eight, 2129208817, Some(OperandSize::Xmmword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 140, 207, 241, 37, 233, 126], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cpuid.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cqo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cwd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/cwde.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/daa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/das.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/emms.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/f2xm1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fabs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fchs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fclex.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fcompp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fcos.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fdecstp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fincstp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/finit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fld1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldl2e.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldl2t.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldlg2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldln2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldpi.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fldz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fnclex.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fninit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fnop.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fpatan.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fprem.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fprem1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fptan.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/frndint.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fscale.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fsin.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fsincos.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fsqrt.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ftst.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fucompp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fwait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fxam.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fxrstor64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn fxrstor64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::FXRSTOR64, operand1: Some(IndirectScaledIndexedDisplaced(RCX, RDI, Four, 1964928521, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 140, 185, 9, 110, 30, 117], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fxsave64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn fxsave64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::FXSAVE64, operand1: Some(IndirectScaledIndexed(RSI, RAX, Two, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 4, 70], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fxtract.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fyl2x.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/fyl2xp1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/hlt.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/insb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/insd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_aaa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_aad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn aad_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::AAD, operand1: Some(Literal8(36)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[213, 36], OperandSize::Word) 12 | } 13 | 14 | #[test] 15 | fn aad_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::AAD, operand1: Some(Literal8(38)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[213, 38], OperandSize::Dword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_aam.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn aam_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::AAM, operand1: Some(Literal8(116)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[212, 116], OperandSize::Word) 12 | } 13 | 14 | #[test] 15 | fn aam_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::AAM, operand1: Some(Literal8(85)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[212, 85], OperandSize::Dword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_aas.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cbw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cdq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cdqe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_clac.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_clc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cld.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cli.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_clts.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cmc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cmpsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cmpsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cmpsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cmpxchg16b.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn cmpxchg16b_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::CMPXCHG16B, operand1: Some(Indirect(RDX, Some(OperandSize::Xmmword), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 10], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cpuid.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cqo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cwd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_cwde.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_daa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_das.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_emms.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_f2xm1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fabs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fchs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fclex.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fcompp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fcos.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fdecstp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fincstp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_finit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fld1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldl2e.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldl2t.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldlg2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldln2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldpi.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fldz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fnclex.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fninit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fnop.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fpatan.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fprem.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fprem1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fptan.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_frndint.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fscale.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fsin.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fsincos.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fsqrt.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ftst.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fucompp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fwait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fxam.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fxrstor64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn fxrstor64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::FXRSTOR64, operand1: Some(Indirect(RCX, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 9], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fxsave64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn fxsave64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::FXSAVE64, operand1: Some(Indirect(RAX, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 0], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fxtract.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fyl2x.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_fyl2xp1.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_hlt.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_insb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_insd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_insw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_into.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_invd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_iret.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_iretd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_iretq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ja.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jae.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jbe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jcxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_je.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jecxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jg.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jge.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jl.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jle.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jna.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnae.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnbe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jne.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jng.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnge.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnl.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnle.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jno.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jns.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jnz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jpe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jpo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jrcxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_js.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_jz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_knotb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn knotb_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::KNOTB, operand1: Some(Direct(K3)), operand2: Some(Direct(K3)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 68, 219], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn knotb_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::KNOTB, operand1: Some(Direct(K1)), operand2: Some(Direct(K1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 68, 201], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_knotw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn knotw_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::KNOTW, operand1: Some(Direct(K2)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 68, 210], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn knotw_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::KNOTW, operand1: Some(Direct(K5)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 68, 238], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ktestb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn ktestb_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::KTESTB, operand1: Some(Direct(K2)), operand2: Some(Direct(K4)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 153, 212], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn ktestb_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::KTESTB, operand1: Some(Direct(K3)), operand2: Some(Direct(K1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 153, 217], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ktestw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn ktestw_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::KTESTW, operand1: Some(Direct(K2)), operand2: Some(Direct(K7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 153, 215], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn ktestw_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::KTESTW, operand1: Some(Direct(K2)), operand2: Some(Direct(K5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 153, 213], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lahf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_leave.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lock.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lodsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lodsd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lodsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_lodsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_loop.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_loope.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_loopne.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_mfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_monitor.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_movhlps.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn movhlps_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::MOVHLPS, operand1: Some(Direct(XMM1)), operand2: Some(Direct(XMM5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 18, 205], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn movhlps_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::MOVHLPS, operand1: Some(Direct(XMM3)), operand2: Some(Direct(XMM2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 18, 218], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_movsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_movsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_movsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_mwait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_outsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_outsd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_outsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pause.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_popa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_popad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_popf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_popfd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_popfq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pusha.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pushad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pushf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pushfd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_pushfq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdfsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn rdfsbase_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::RDFSBASE, operand1: Some(Direct(EDX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 194], OperandSize::Qword) 12 | } 13 | 14 | #[test] 15 | fn rdfsbase_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::RDFSBASE, operand1: Some(Direct(RBP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 197], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdgsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn rdgsbase_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::RDGSBASE, operand1: Some(Direct(ESP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 204], OperandSize::Qword) 12 | } 13 | 14 | #[test] 15 | fn rdgsbase_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::RDGSBASE, operand1: Some(Direct(RSP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 204], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdmsr.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdpkru.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdpmc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdtsc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rdtscp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_rsm.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sahf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_scasb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_scasd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_scasq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_scasw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stac.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_std.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sti.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stosb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stosd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stosq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_stosw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_swapgs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_syscall.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sysenter.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sysexit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_sysret.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ud0.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_ud2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_vzeroall.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_vzeroupper.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wbinvd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wrfsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn wrfsbase_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::WRFSBASE, operand1: Some(Direct(ESP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 212], OperandSize::Qword) 12 | } 13 | 14 | #[test] 15 | fn wrfsbase_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::WRFSBASE, operand1: Some(Direct(RCX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 209], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wrgsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn wrgsbase_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::WRGSBASE, operand1: Some(Direct(EDX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 218], OperandSize::Qword) 12 | } 13 | 14 | #[test] 15 | fn wrgsbase_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::WRGSBASE, operand1: Some(Direct(RSP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 220], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wrmsr.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_wrpkru.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xabort.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xabort_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XABORT, operand1: Some(Literal8(77)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[198, 248, 77], OperandSize::Dword) 12 | } 13 | 14 | #[test] 15 | fn xabort_2() { 16 | run_test(&Instruction { mnemonic: Mnemonic::XABORT, operand1: Some(Literal8(30)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[198, 248, 30], OperandSize::Qword) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xacquire.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xbegin.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xend.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xgetbv.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xlatb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xrelease.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xrstor64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xrstor64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XRSTOR64, operand1: Some(IndirectScaledDisplaced(RDI, Two, 936335987, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 44, 125, 115, 90, 207, 55], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xrstors64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xrstors64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XRSTORS64, operand1: Some(Indirect(RSI, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 30], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xsave64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xsave64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XSAVE64, operand1: Some(IndirectScaledDisplaced(RAX, Eight, 478519929, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 36, 197, 121, 162, 133, 28], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xsavec64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xsavec64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XSAVEC64, operand1: Some(Indirect(RDX, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 34], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xsaves64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | #[test] 10 | fn xsaves64_1() { 11 | run_test(&Instruction { mnemonic: Mnemonic::XSAVES64, operand1: Some(IndirectScaledDisplaced(RSI, Eight, 1284844663, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 44, 245, 119, 44, 149, 76], OperandSize::Qword) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xsetbv.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/instr_xtest.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | use ::test::run_test; 8 | 9 | -------------------------------------------------------------------------------- /src/test/instruction_tests/insw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/into.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/invd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/iret.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/iretd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/iretq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ja.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jae.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jbe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jcxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/je.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jecxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jg.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jge.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jl.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jle.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jna.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnae.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnbe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jne.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jng.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnge.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnl.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnle.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jno.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jns.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jnz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jpe.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jpo.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jrcxz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/js.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/jz.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kaddb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kaddb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KADDB, operand1: Some(Direct(K5)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 213, 74, 237], OperandSize::Dword) 10 | } 11 | 12 | fn kaddb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KADDB, operand1: Some(Direct(K6)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 213, 74, 245], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kaddd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kaddd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KADDD, operand1: Some(Direct(K2)), operand2: Some(Direct(K3)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 229, 74, 213], OperandSize::Dword) 10 | } 11 | 12 | fn kaddd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KADDD, operand1: Some(Direct(K7)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 213, 74, 253], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kaddq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kaddq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KADDQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K1)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 244, 74, 234], OperandSize::Dword) 10 | } 11 | 12 | fn kaddq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KADDQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K2)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 236, 74, 239], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kaddw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kaddw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KADDW, operand1: Some(Direct(K1)), operand2: Some(Direct(K7)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 196, 74, 206], OperandSize::Dword) 10 | } 11 | 12 | fn kaddw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KADDW, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 236, 74, 225], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDB, operand1: Some(Direct(K6)), operand2: Some(Direct(K4)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 221, 65, 244], OperandSize::Dword) 10 | } 11 | 12 | fn kandb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDB, operand1: Some(Direct(K7)), operand2: Some(Direct(K1)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 245, 65, 253], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDD, operand1: Some(Direct(K5)), operand2: Some(Direct(K3)), operand3: Some(Direct(K3)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 229, 65, 235], OperandSize::Dword) 10 | } 11 | 12 | fn kandd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDD, operand1: Some(Direct(K3)), operand2: Some(Direct(K3)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 229, 65, 223], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandnb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandnb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDNB, operand1: Some(Direct(K2)), operand2: Some(Direct(K1)), operand3: Some(Direct(K3)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 245, 66, 211], OperandSize::Dword) 10 | } 11 | 12 | fn kandnb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDNB, operand1: Some(Direct(K6)), operand2: Some(Direct(K1)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 245, 66, 242], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandnd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandnd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDND, operand1: Some(Direct(K7)), operand2: Some(Direct(K5)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 213, 66, 252], OperandSize::Dword) 10 | } 11 | 12 | fn kandnd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDND, operand1: Some(Direct(K6)), operand2: Some(Direct(K5)), operand3: Some(Direct(K3)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 213, 66, 243], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandnq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandnq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDNQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K4)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 220, 66, 252], OperandSize::Dword) 10 | } 11 | 12 | fn kandnq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDNQ, operand1: Some(Direct(K1)), operand2: Some(Direct(K5)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 212, 66, 204], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandnw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandnw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDNW, operand1: Some(Direct(K3)), operand2: Some(Direct(K7)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 196, 66, 223], OperandSize::Dword) 10 | } 11 | 12 | fn kandnw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDNW, operand1: Some(Direct(K4)), operand2: Some(Direct(K6)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 204, 66, 226], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K7)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 196, 65, 254], OperandSize::Dword) 10 | } 11 | 12 | fn kandq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDQ, operand1: Some(Direct(K2)), operand2: Some(Direct(K7)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 196, 65, 212], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kandw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kandw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KANDW, operand1: Some(Direct(K2)), operand2: Some(Direct(K3)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 228, 65, 209], OperandSize::Dword) 10 | } 11 | 12 | fn kandw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KANDW, operand1: Some(Direct(K5)), operand2: Some(Direct(K1)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 244, 65, 238], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/knotb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn knotb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KNOTB, operand1: Some(Direct(K5)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 68, 238], OperandSize::Dword) 10 | } 11 | 12 | fn knotb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KNOTB, operand1: Some(Direct(K2)), operand2: Some(Direct(K1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 68, 209], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/knotd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn knotd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KNOTD, operand1: Some(Direct(K6)), operand2: Some(Direct(K4)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 68, 244], OperandSize::Dword) 10 | } 11 | 12 | fn knotd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KNOTD, operand1: Some(Direct(K7)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 68, 250], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/knotq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn knotq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KNOTQ, operand1: Some(Direct(K4)), operand2: Some(Direct(K4)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 68, 228], OperandSize::Dword) 10 | } 11 | 12 | fn knotq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KNOTQ, operand1: Some(Direct(K2)), operand2: Some(Direct(K4)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 68, 212], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/knotw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn knotw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KNOTW, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 68, 226], OperandSize::Dword) 10 | } 11 | 12 | fn knotw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KNOTW, operand1: Some(Direct(K5)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 68, 238], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/korb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn korb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORB, operand1: Some(Direct(K6)), operand2: Some(Direct(K1)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 245, 69, 247], OperandSize::Dword) 10 | } 11 | 12 | fn korb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORB, operand1: Some(Direct(K4)), operand2: Some(Direct(K1)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 245, 69, 230], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kord.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kord_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORD, operand1: Some(Direct(K1)), operand2: Some(Direct(K2)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 237, 69, 206], OperandSize::Dword) 10 | } 11 | 12 | fn kord_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORD, operand1: Some(Direct(K6)), operand2: Some(Direct(K6)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 205, 69, 241], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/korq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn korq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K7)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 196, 69, 238], OperandSize::Dword) 10 | } 11 | 12 | fn korq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORQ, operand1: Some(Direct(K3)), operand2: Some(Direct(K2)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 236, 69, 218], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kortestb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kortestb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTB, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 152, 226], OperandSize::Dword) 10 | } 11 | 12 | fn kortestb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTB, operand1: Some(Direct(K7)), operand2: Some(Direct(K7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 152, 255], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kortestd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kortestd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTD, operand1: Some(Direct(K7)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 152, 254], OperandSize::Dword) 10 | } 11 | 12 | fn kortestd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTD, operand1: Some(Direct(K6)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 152, 242], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kortestq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kortestq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTQ, operand1: Some(Direct(K6)), operand2: Some(Direct(K7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 152, 247], OperandSize::Dword) 10 | } 11 | 12 | fn kortestq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 152, 250], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kortestw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kortestw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTW, operand1: Some(Direct(K1)), operand2: Some(Direct(K3)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 152, 203], OperandSize::Dword) 10 | } 11 | 12 | fn kortestw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORTESTW, operand1: Some(Direct(K2)), operand2: Some(Direct(K5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 152, 213], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/korw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn korw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KORW, operand1: Some(Direct(K7)), operand2: Some(Direct(K6)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 204, 69, 249], OperandSize::Dword) 10 | } 11 | 12 | fn korw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KORW, operand1: Some(Direct(K7)), operand2: Some(Direct(K3)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 228, 69, 250], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kshiftld.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kshiftld_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLD, operand1: Some(Direct(K7)), operand2: Some(Direct(K4)), operand3: Some(Literal8(92)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 121, 51, 252, 92], OperandSize::Dword) 10 | } 11 | 12 | fn kshiftld_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLD, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: Some(Literal8(96)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 121, 51, 226, 96], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kshiftlq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kshiftlq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K3)), operand3: Some(Literal8(78)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 51, 235, 78], OperandSize::Dword) 10 | } 11 | 12 | fn kshiftlq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLQ, operand1: Some(Direct(K3)), operand2: Some(Direct(K4)), operand3: Some(Literal8(80)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 51, 220, 80], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kshiftlw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kshiftlw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLW, operand1: Some(Direct(K1)), operand2: Some(Direct(K4)), operand3: Some(Literal8(91)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 50, 204, 91], OperandSize::Dword) 10 | } 11 | 12 | fn kshiftlw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTLW, operand1: Some(Direct(K1)), operand2: Some(Direct(K2)), operand3: Some(Literal8(8)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 50, 202, 8], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kshiftrd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kshiftrd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTRD, operand1: Some(Direct(K7)), operand2: Some(Direct(K6)), operand3: Some(Literal8(51)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 121, 49, 254, 51], OperandSize::Dword) 10 | } 11 | 12 | fn kshiftrd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTRD, operand1: Some(Direct(K5)), operand2: Some(Direct(K7)), operand3: Some(Literal8(99)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 121, 49, 239, 99], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kshiftrq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kshiftrq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTRQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K1)), operand3: Some(Literal8(54)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 49, 233, 54], OperandSize::Dword) 10 | } 11 | 12 | fn kshiftrq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KSHIFTRQ, operand1: Some(Direct(K4)), operand2: Some(Direct(K3)), operand3: Some(Literal8(2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 227, 249, 49, 227, 2], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ktestb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn ktestb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KTESTB, operand1: Some(Direct(K6)), operand2: Some(Direct(K3)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 153, 243], OperandSize::Dword) 10 | } 11 | 12 | fn ktestb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KTESTB, operand1: Some(Direct(K7)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 153, 250], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ktestd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn ktestd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KTESTD, operand1: Some(Direct(K5)), operand2: Some(Direct(K5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 153, 237], OperandSize::Dword) 10 | } 11 | 12 | fn ktestd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KTESTD, operand1: Some(Direct(K3)), operand2: Some(Direct(K1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 249, 153, 217], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ktestq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn ktestq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KTESTQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 153, 254], OperandSize::Dword) 10 | } 11 | 12 | fn ktestq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KTESTQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 248, 153, 238], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ktestw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn ktestw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KTESTW, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 153, 226], OperandSize::Dword) 10 | } 11 | 12 | fn ktestw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KTESTW, operand1: Some(Direct(K5)), operand2: Some(Direct(K4)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 248, 153, 236], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kunpckbw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kunpckbw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKBW, operand1: Some(Direct(K7)), operand2: Some(Direct(K6)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 205, 75, 249], OperandSize::Dword) 10 | } 11 | 12 | fn kunpckbw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKBW, operand1: Some(Direct(K6)), operand2: Some(Direct(K6)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 205, 75, 242], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kunpckdq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kunpckdq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKDQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K2)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 236, 75, 238], OperandSize::Dword) 10 | } 11 | 12 | fn kunpckdq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKDQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K1)), operand3: Some(Direct(K4)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 244, 75, 252], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kunpckwd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kunpckwd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKWD, operand1: Some(Direct(K2)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 212, 75, 213], OperandSize::Dword) 10 | } 11 | 12 | fn kunpckwd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KUNPCKWD, operand1: Some(Direct(K3)), operand2: Some(Direct(K1)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 244, 75, 222], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxnorb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxnorb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXNORB, operand1: Some(Direct(K1)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 213, 70, 205], OperandSize::Dword) 10 | } 11 | 12 | fn kxnorb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXNORB, operand1: Some(Direct(K4)), operand2: Some(Direct(K6)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 205, 70, 225], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxnord.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxnord_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXNORD, operand1: Some(Direct(K2)), operand2: Some(Direct(K5)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 213, 70, 214], OperandSize::Dword) 10 | } 11 | 12 | fn kxnord_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXNORD, operand1: Some(Direct(K4)), operand2: Some(Direct(K5)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 213, 70, 229], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxnorq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxnorq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXNORQ, operand1: Some(Direct(K7)), operand2: Some(Direct(K3)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 228, 70, 255], OperandSize::Dword) 10 | } 11 | 12 | fn kxnorq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXNORQ, operand1: Some(Direct(K5)), operand2: Some(Direct(K6)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 204, 70, 234], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxnorw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxnorw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXNORW, operand1: Some(Direct(K1)), operand2: Some(Direct(K3)), operand3: Some(Direct(K3)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 228, 70, 203], OperandSize::Dword) 10 | } 11 | 12 | fn kxnorw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXNORW, operand1: Some(Direct(K4)), operand2: Some(Direct(K1)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 244, 70, 230], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxorb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxorb_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXORB, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: Some(Direct(K3)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 237, 71, 227], OperandSize::Dword) 10 | } 11 | 12 | fn kxorb_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXORB, operand1: Some(Direct(K1)), operand2: Some(Direct(K5)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 213, 71, 207], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxord.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxord_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXORD, operand1: Some(Direct(K5)), operand2: Some(Direct(K4)), operand3: Some(Direct(K5)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 221, 71, 237], OperandSize::Dword) 10 | } 11 | 12 | fn kxord_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXORD, operand1: Some(Direct(K3)), operand2: Some(Direct(K4)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 221, 71, 217], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxorq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxorq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXORQ, operand1: Some(Direct(K4)), operand2: Some(Direct(K3)), operand3: Some(Direct(K1)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 228, 71, 225], OperandSize::Dword) 10 | } 11 | 12 | fn kxorq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXORQ, operand1: Some(Direct(K6)), operand2: Some(Direct(K2)), operand3: Some(Direct(K2)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[196, 225, 236, 71, 242], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/kxorw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn kxorw_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::KXORW, operand1: Some(Direct(K4)), operand2: Some(Direct(K2)), operand3: Some(Direct(K6)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 236, 71, 230], OperandSize::Dword) 10 | } 11 | 12 | fn kxorw_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::KXORW, operand1: Some(Direct(K5)), operand2: Some(Direct(K7)), operand3: Some(Direct(K7)), operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 196, 71, 239], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lahf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/leave.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lock.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lodsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lodsd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lodsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/lodsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/loop.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/loope.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/loopne.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/maskmovdqu.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn maskmovdqu_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::MASKMOVDQU, operand1: Some(Direct(XMM5)), operand2: Some(Direct(XMM2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 247, 234], OperandSize::Dword) 10 | } 11 | 12 | fn maskmovdqu_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::MASKMOVDQU, operand1: Some(Direct(XMM1)), operand2: Some(Direct(XMM7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 247, 207], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/mfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/monitor.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movhlps.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn movhlps_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::MOVHLPS, operand1: Some(Direct(XMM1)), operand2: Some(Direct(XMM3)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 18, 203], OperandSize::Dword) 10 | } 11 | 12 | fn movhlps_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::MOVHLPS, operand1: Some(Direct(XMM1)), operand2: Some(Direct(XMM1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 18, 201], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movlhps.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn movlhps_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::MOVLHPS, operand1: Some(Direct(XMM2)), operand2: Some(Direct(XMM6)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 22, 214], OperandSize::Dword) 10 | } 11 | 12 | fn movlhps_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::MOVLHPS, operand1: Some(Direct(XMM4)), operand2: Some(Direct(XMM5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 22, 229], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movmskpd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn movmskpd_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::MOVMSKPD, operand1: Some(Direct(ESP)), operand2: Some(Direct(XMM1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 80, 225], OperandSize::Dword) 10 | } 11 | 12 | fn movmskpd_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::MOVMSKPD, operand1: Some(Direct(RDX)), operand2: Some(Direct(XMM1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 80, 209], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movmskps.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn movmskps_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::MOVMSKPS, operand1: Some(Direct(EDI)), operand2: Some(Direct(XMM1)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 80, 249], OperandSize::Dword) 10 | } 11 | 12 | fn movmskps_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::MOVMSKPS, operand1: Some(Direct(RBP)), operand2: Some(Direct(XMM5)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[15, 80, 237], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movsq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/movsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/mwait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/outsb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/outsd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/outsw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pause.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/popa.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/popad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/popf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/popfd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/popfq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pslldq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn pslldq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::PSLLDQ, operand1: Some(Direct(XMM4)), operand2: Some(Literal8(90)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 115, 252, 90], OperandSize::Dword) 10 | } 11 | 12 | fn pslldq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::PSLLDQ, operand1: Some(Direct(XMM6)), operand2: Some(Literal8(32)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 115, 254, 32], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/psrldq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn psrldq_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::PSRLDQ, operand1: Some(Direct(XMM3)), operand2: Some(Literal8(24)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 115, 219, 24], OperandSize::Dword) 10 | } 11 | 12 | fn psrldq_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::PSRLDQ, operand1: Some(Direct(XMM6)), operand2: Some(Literal8(34)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 15, 115, 222, 34], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pusha.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pushad.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pushf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pushfd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/pushfq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdfsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn rdfsbase_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::RDFSBASE, operand1: Some(Direct(EDX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 194], OperandSize::Qword) 10 | } 11 | 12 | fn rdfsbase_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::RDFSBASE, operand1: Some(Direct(RDI)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 199], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdgsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn rdgsbase_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::RDGSBASE, operand1: Some(Direct(EBP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 205], OperandSize::Qword) 10 | } 11 | 12 | fn rdgsbase_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::RDGSBASE, operand1: Some(Direct(RCX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 201], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdmsr.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdpkru.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdpmc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdtsc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rdtscp.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/rsm.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sahf.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/scasb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/scasd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/scasq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/scasw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sfence.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stac.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stc.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/std.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sti.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stosb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stosd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stosq.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/stosw.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/swapgs.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/syscall.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sysenter.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sysexit.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/sysret.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ud0.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/ud2.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/vmaskmovdqu.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn vmaskmovdqu_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::VMASKMOVDQU, operand1: Some(Direct(XMM4)), operand2: Some(Direct(XMM2)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 247, 226], OperandSize::Dword) 10 | } 11 | 12 | fn vmaskmovdqu_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::VMASKMOVDQU, operand1: Some(Direct(XMM0)), operand2: Some(Direct(XMM7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[197, 249, 247, 199], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/vzeroall.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/vzeroupper.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wait.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wbinvd.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wrfsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn wrfsbase_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::WRFSBASE, operand1: Some(Direct(EBP)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 213], OperandSize::Qword) 10 | } 11 | 12 | fn wrfsbase_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::WRFSBASE, operand1: Some(Direct(RBX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 211], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wrgsbase.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn wrgsbase_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::WRGSBASE, operand1: Some(Direct(ECX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 15, 174, 217], OperandSize::Qword) 10 | } 11 | 12 | fn wrgsbase_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::WRGSBASE, operand1: Some(Direct(RDX)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[243, 72, 15, 174, 218], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wrmsr.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/wrpkru.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xabort.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xabort_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XABORT, operand1: Some(Literal8(48)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[198, 248, 48], OperandSize::Dword) 10 | } 11 | 12 | fn xabort_2() { 13 | run_test(&Instruction { mnemonic: Mnemonic::XABORT, operand1: Some(Literal8(1)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[198, 248, 1], OperandSize::Qword) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xacquire.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xbegin.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xend.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xgetbv.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xlatb.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xrelease.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xrstor64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xrstor64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XRSTOR64, operand1: Some(IndirectScaledIndexedDisplaced(RAX, RDI, Eight, 2018336743, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 172, 248, 231, 95, 77, 120], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xrstors64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xrstors64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XRSTORS64, operand1: Some(Indirect(RAX, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 24], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xsave64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xsave64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XSAVE64, operand1: Some(IndirectScaledIndexedDisplaced(RAX, RDI, Two, 1821943582, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 174, 164, 120, 30, 167, 152, 108], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xsavec64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xsavec64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XSAVEC64, operand1: Some(IndirectScaledDisplaced(RAX, Four, 2128812417, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 36, 133, 129, 25, 227, 126], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xsaves64.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | fn xsaves64_1() { 9 | run_test(&Instruction { mnemonic: Mnemonic::XSAVES64, operand1: Some(IndirectScaledIndexedDisplaced(RBX, RDX, Two, 1507884545, Some(OperandSize::Unsized), None)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 15, 199, 172, 83, 1, 126, 224, 89], OperandSize::Qword) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xsetbv.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | -------------------------------------------------------------------------------- /src/test/instruction_tests/xtest.rs: -------------------------------------------------------------------------------- 1 | use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode}; 2 | use ::RegType::*; 3 | use ::instruction_def::*; 4 | use ::Operand::*; 5 | use ::Reg::*; 6 | use ::RegScale::*; 7 | 8 | --------------------------------------------------------------------------------