AMD64/IA-32 instruction creation convenience macros. More...

#include <math.h>

Macros
#define	LOCK(instr_ptr) instr_set_prefix_flag((instr_ptr), PREFIX_LOCK)

#define	OPND_CREATE_ABSMEM(addr, size) opnd_create_rel_addr(addr, size)

#define	OPND_CREATE_MEM_lea(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_lea)

#define	OPND_CREATE_MEM_invlpg(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_invlpg)

#define	OPND_CREATE_MEM_clflush(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_clflush)

#define	OPND_CREATE_MEM_prefetch(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_prefetch)

#define	OPND_CREATE_MEM_lgdt(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_lgdt)

#define	OPND_CREATE_MEM_sgdt(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_sgdt)

#define	OPND_CREATE_MEM_lidt(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_lidt)

#define	OPND_CREATE_MEM_sidt(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_sidt)

#define	OPND_CREATE_MEM_bound(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_bound)

#define	OPND_CREATE_MEM_fldenv(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_fldenv)

#define	OPND_CREATE_MEM_fnstenv(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_fnstenv)

#define	OPND_CREATE_MEM_fnsave(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_fnsave)

#define	OPND_CREATE_MEM_frstor(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_frstor)

#define	OPND_CREATE_MEM_fxsave(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_fxsave)

#define	OPND_CREATE_MEM_fxrstor(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_fxrstor)

#define	OPND_CREATE_MEM_ptwrite(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_ptwrite)

#define	OPND_CREATE_MEM_xsave(base, index, scale, disp) opnd_create_base_disp(base, index, scale, disp, OPSZ_xsave)

#define	INSTR_CREATE_jcc_short(dc, op, t) instr_create_0dst_1src((dc), (op), (t))

#define	INSTR_CREATE_jcc(dc, op, t) instr_create_0dst_1src((dc), (op), (t))

#define	INSTR_CREATE_jmp_ind(dc, t) instr_create_0dst_1src((dc), OP_jmp_ind, (t))

#define	INSTR_CREATE_jmp_far(dc, t) instr_create_0dst_1src((dc), OP_jmp_far, (t))

#define	INSTR_CREATE_jmp_far_ind(dc, t) instr_create_0dst_1src((dc), OP_jmp_far_ind, (t))

#define	INSTR_CREATE_clflush(dc, s) instr_create_0dst_1src((dc), OP_clflush, (s))

#define	INSTR_CREATE_clflushopt(dc, s) instr_create_0dst_1src((dc), OP_clflushopt, (s))

#define	INSTR_CREATE_clwb(dc, s) instr_create_0dst_1src((dc), OP_clwb, (s))

#define	INSTR_CREATE_cldemote(dc, s) instr_create_0dst_1src((dc), OP_cldemote, (s))

#define	INSTR_CREATE_int(dc, i) instr_create_0dst_1src((dc), OP_int, (i))

#define	INSTR_CREATE_fldenv(dc, m) instr_create_0dst_1src((dc), OP_fldenv, (m))

#define	INSTR_CREATE_fldcw(dc, m) instr_create_0dst_1src((dc), OP_fldcw, (m))

#define	INSTR_CREATE_frstor(dc, m) instr_create_0dst_1src((dc), OP_frstor, (m))

#define	INSTR_CREATE_jecxz(dc, t) instr_create_0dst_2src((dc), OP_jecxz, (t), opnd_create_reg(DR_REG_XCX))

#define	INSTR_CREATE_jcxz(dc, t) instr_create_0dst_2src((dc), OP_jecxz, (t), opnd_create_reg(DR_REG_CX))

#define	INSTR_CREATE_setcc(dc, op, d) instr_create_1dst_0src((dc), (op), (d))

#define	INSTR_CREATE_fnstenv(dc, m) instr_create_1dst_0src((dc), OP_fnstenv, (m))

#define	INSTR_CREATE_fnsave(dc, m) instr_create_1dst_0src((dc), OP_fnsave, (m))

#define	INSTR_CREATE_xabort(dc, i) instr_create_1dst_1src((dc), OP_xabort, opnd_create_reg(DR_REG_EAX), (i))

#define	INSTR_CREATE_fcmovcc(dc, op, f)

#define	INSTR_CREATE_fld(dc, s) instr_create_1dst_1src((dc), OP_fld, opnd_create_reg(DR_REG_ST0), (s))

#define	INSTR_CREATE_cmovcc(dc, op, d, s) INSTR_PRED(instr_create_1dst_1src((dc), (op), (d), (s)), DR_PRED_O + (op)-OP_cmovo)

#define	INSTR_CREATE_imul_imm(dc, d, s, i) instr_create_1dst_2src((dc), OP_imul, (d), (s), (i))

#define	INSTR_CREATE_imul(dc, d, s) instr_create_1dst_2src((dc), OP_imul, (d), (s), (d))

#define	INSTR_CREATE_extrq(dc, d, r) instr_create_1dst_1src((dc), OP_extrq, (d), (r))

#define	INSTR_CREATE_extrq_imm(dc, d, i1, i2) instr_create_1dst_2src((dc), OP_extrq, (d), (i1), (i2))

#define	INSTR_CREATE_insertq(dc, d, r) instr_create_1dst_1src((dc), OP_insertq, (d), (r))

#define	INSTR_CREATE_insertq_imm(dc, d, r, i1, i2) instr_create_1dst_3src((dc), OP_insertq, (d), (r), (i1), (i2))

#define	INSTR_CREATE_pop(dc, d)

#define	INSTR_CREATE_fxch(dc, f)

#define	INSTR_CREATE_call(dc, t)

#define	INSTR_CREATE_call_ind(dc, t)

#define	INSTR_CREATE_call_far(dc, t)

#define	INSTR_CREATE_call_far_ind(dc, t)

#define	INSTR_CREATE_push(dc, s)

#define	INSTR_CREATE_push_imm(dc, i)

#define	INSTR_CREATE_mulx(dc, d1, d2, s)

#define	INSTR_CREATE_leave(dc)

#define	INSTR_CREATE_getsec(dc)

#define	INSTR_CREATE_cmpxchg8b(dc, d)

#define	INSTR_CREATE_enter(dc, i16, i8)

#define	INSTR_CREATE_popa(dc) instr_create_popa((dc))

Platform-independent macros
#define	XINST_CREATE_debug_instr(dc) INSTR_CREATE_int3(dc)

#define	XINST_CREATE_load(dc, r, m) INSTR_CREATE_mov_ld(dc, r, m)

#define	XINST_CREATE_load_1byte_zext4(dc, r, m) INSTR_CREATE_movzx(dc, r, m)

#define	XINST_CREATE_load_1byte(dc, r, m) INSTR_CREATE_mov_ld(dc, r, m)

#define	XINST_CREATE_load_2bytes(dc, r, m) INSTR_CREATE_mov_ld(dc, r, m)

#define	XINST_CREATE_store(dc, m, r) INSTR_CREATE_mov_st(dc, m, r)

#define	XINST_CREATE_store_1byte(dc, m, r) INSTR_CREATE_mov_st(dc, m, r)

#define	XINST_CREATE_store_2bytes(dc, m, r) INSTR_CREATE_mov_st(dc, m, r)

#define	XINST_CREATE_move(dc, d, s) INSTR_CREATE_mov_ld(dc, d, s)

#define	XINST_CREATE_load_simd(dc, r, m) INSTR_CREATE_movd(dc, r, m)

#define	XINST_CREATE_store_simd(dc, m, r) INSTR_CREATE_movd(dc, m, r)

#define	XINST_CREATE_jump_mem(dc, m) INSTR_CREATE_jmp_ind(dc, m)

#define	XINST_CREATE_jump_reg(dc, r) INSTR_CREATE_jmp_ind(dc, r)

#define	XINST_CREATE_load_int(dc, r, i) INSTR_CREATE_mov_imm(dc, r, i)

#define	XINST_CREATE_return(dc) INSTR_CREATE_ret(dc)

#define	XINST_CREATE_jump(dc, t) INSTR_CREATE_jmp((dc), (t))

#define	XINST_CREATE_jump_short(dc, t) INSTR_CREATE_jmp_short((dc), (t))

#define	XINST_CREATE_jump_cond(dc, pred, t) (INSTR_CREATE_jcc((dc), (pred)-DR_PRED_O + OP_jo, (t)))

#define	XINST_CREATE_call(dc, t) INSTR_CREATE_call((dc), (t))

#define	XINST_CREATE_add(dc, d, s)

#define	XINST_CREATE_add_2src(dc, d, s1, s2)

#define	XINST_CREATE_add_sll(dc, d, s1, s2_toshift, shift_amount)

#define	XINST_CREATE_add_s(dc, d, s) INSTR_CREATE_add((dc), (d), (s))

#define	XINST_CREATE_sub(dc, d, s)

#define	XINST_CREATE_sub_s(dc, d, s) INSTR_CREATE_sub((dc), (d), (s))

#define	XINST_CREATE_and_s(dc, d, s) INSTR_CREATE_and((dc), (d), (s))

#define	XINST_CREATE_slr_s(dc, d, s) INSTR_CREATE_shr((dc), (d), (s))

#define	XINST_CREATE_cmp(dc, s1, s2) instr_create_0dst_2src((dc), OP_cmp, (s1), (s2))

#define	XINST_CREATE_interrupt(dc, i) INSTR_CREATE_int(dc, i)

#define	XINST_CREATE_nop(dc) INSTR_CREATE_nop(dc)

#define	XINST_CREATE_call_reg(dc, r) INSTR_CREATE_call_ind(dc, r)

No-operand instructions
#define	INSTR_CREATE_fwait(dc) instr_create_0dst_0src((dc), OP_fwait)

#define	INSTR_CREATE_hlt(dc) instr_create_0dst_0src((dc), OP_hlt)

#define	INSTR_CREATE_cmc(dc) instr_create_0dst_0src((dc), OP_cmc)

#define	INSTR_CREATE_clc(dc) instr_create_0dst_0src((dc), OP_clc)

#define	INSTR_CREATE_stc(dc) instr_create_0dst_0src((dc), OP_stc)

#define	INSTR_CREATE_cli(dc) instr_create_0dst_0src((dc), OP_cli)

#define	INSTR_CREATE_sti(dc) instr_create_0dst_0src((dc), OP_sti)

#define	INSTR_CREATE_cld(dc) instr_create_0dst_0src((dc), OP_cld)

#define	INSTR_CREATE_std(dc) instr_create_0dst_0src((dc), OP_std)

#define	INSTR_CREATE_clts(dc) instr_create_0dst_0src((dc), OP_clts)

#define	INSTR_CREATE_invd(dc) instr_create_0dst_0src((dc), OP_invd)

#define	INSTR_CREATE_wbinvd(dc) instr_create_0dst_0src((dc), OP_wbinvd)

#define	INSTR_CREATE_ud2(dc) instr_create_0dst_0src((dc), OP_ud2)

#define	INSTR_CREATE_ud2a(dc) INSTR_CREATE_ud2((dc))

#define	INSTR_CREATE_emms(dc) instr_create_0dst_0src((dc), OP_emms)

#define	INSTR_CREATE_rsm(dc) instr_create_0dst_0src((dc), OP_rsm)

#define	INSTR_CREATE_lfence(dc) instr_create_0dst_0src((dc), OP_lfence)

#define	INSTR_CREATE_mfence(dc) instr_create_0dst_0src((dc), OP_mfence)

#define	INSTR_CREATE_sfence(dc) instr_create_0dst_0src((dc), OP_sfence)

#define	INSTR_CREATE_nop(dc) instr_create_0dst_0src((dc), OP_nop)

#define	INSTR_CREATE_pause(dc) instr_create_0dst_0src((dc), OP_pause)

#define	INSTR_CREATE_fnop(dc) instr_create_0dst_0src((dc), OP_fnop)

#define	INSTR_CREATE_fdecstp(dc) instr_create_0dst_0src((dc), OP_fdecstp)

#define	INSTR_CREATE_fincstp(dc) instr_create_0dst_0src((dc), OP_fincstp)

#define	INSTR_CREATE_fnclex(dc) instr_create_0dst_0src((dc), OP_fnclex)

#define	INSTR_CREATE_fninit(dc) instr_create_0dst_0src((dc), OP_fninit)

#define	INSTR_CREATE_femms(dc) instr_create_0dst_0src((dc), OP_femms)

#define	INSTR_CREATE_swapgs(dc) instr_create_0dst_0src((dc), OP_swapgs)

#define	INSTR_CREATE_vmcall(dc) instr_create_0dst_0src((dc), OP_vmcall)

#define	INSTR_CREATE_vmlaunch(dc) instr_create_0dst_0src((dc), OP_vmlaunch)

#define	INSTR_CREATE_vmresume(dc) instr_create_0dst_0src((dc), OP_vmresume)

#define	INSTR_CREATE_vmxoff(dc) instr_create_0dst_0src((dc), OP_vmxoff)

#define	INSTR_CREATE_vmmcall(dc) instr_create_0dst_0src((dc), OP_vmmcall)

#define	INSTR_CREATE_vmfunc(dc) instr_create_0dst_0src((dc), OP_vmfunc)

#define	INSTR_CREATE_stgi(dc) instr_create_0dst_0src((dc), OP_stgi)

#define	INSTR_CREATE_clgi(dc) instr_create_0dst_0src((dc), OP_clgi)

#define	INSTR_CREATE_int3(dc) instr_create_0dst_0src((dc), OP_int3)

#define	INSTR_CREATE_into(dc) instr_create_0dst_0src((dc), OP_into)

#define	INSTR_CREATE_int1(dc) instr_create_0dst_0src((dc), OP_int1)

#define	INSTR_CREATE_vzeroupper(dc) instr_create_0dst_0src((dc), OP_vzeroupper)

#define	INSTR_CREATE_vzeroall(dc) instr_create_0dst_0src((dc), OP_vzeroall)

#define	INSTR_CREATE_xtest(dc) instr_create_0dst_0src((dc), OP_xtest)

#define	INSTR_CREATE_clac(dc) instr_create_0dst_0src((dc), OP_clac)

#define	INSTR_CREATE_stac(dc) instr_create_0dst_0src((dc), OP_stac)

#define	INSTR_CREATE_xsusldtrk(dc) instr_create_0dst_0src((dc), OP_xsusldtrk)

#define	INSTR_CREATE_xresldtrk(dc) instr_create_0dst_0src((dc), OP_xresldtrk)

#define	INSTR_CREATE_serialize(dc) instr_create_0dst_0src((dc), OP_serialize)

Direct unconditional jump
#define	INSTR_CREATE_jmp(dc, t) instr_create_0dst_1src((dc), OP_jmp, (t))

#define	INSTR_CREATE_jmp_short(dc, t) instr_create_0dst_1src((dc), OP_jmp_short, (t))

#define	INSTR_CREATE_xbegin(dc, t) instr_create_0dst_1src((dc), OP_xbegin, (t))

One explicit source
#define	INSTR_CREATE_lldt(dc, s) instr_create_0dst_1src((dc), OP_lldt, (s))

#define	INSTR_CREATE_ltr(dc, s) instr_create_0dst_1src((dc), OP_ltr, (s))

#define	INSTR_CREATE_verr(dc, s) instr_create_0dst_1src((dc), OP_verr, (s))

#define	INSTR_CREATE_verw(dc, s) instr_create_0dst_1src((dc), OP_verw, (s))

#define	INSTR_CREATE_vmptrld(dc, s) instr_create_0dst_1src((dc), OP_vmptrld, (s))

#define	INSTR_CREATE_vmxon(dc, s) instr_create_0dst_1src((dc), OP_vmxon, (s))

#define	INSTR_CREATE_wrfsbase(dc, s) instr_create_0dst_1src((dc), OP_wrfsbase, (s))

#define	INSTR_CREATE_wrgsbase(dc, s) instr_create_0dst_1src((dc), OP_wrgsbase, (s))

#define	INSTR_CREATE_llwpcb(dc, s) instr_create_0dst_1src((dc), OP_llwpcb, (s))

#define	INSTR_CREATE_lgdt(dc, s) instr_create_0dst_1src((dc), OP_lgdt, (s))

#define	INSTR_CREATE_lidt(dc, s) instr_create_0dst_1src((dc), OP_lidt, (s))

#define	INSTR_CREATE_lmsw(dc, s) instr_create_0dst_1src((dc), OP_lmsw, (s))

#define	INSTR_CREATE_invlpg(dc, s) instr_create_0dst_1src((dc), OP_invlpg, (s))

#define	INSTR_CREATE_fxrstor32(dc, s) instr_create_0dst_1src((dc), OP_fxrstor32, (s))

#define	INSTR_CREATE_fxrstor64(dc, s) instr_create_0dst_1src((dc), OP_fxrstor64, (s))

#define	INSTR_CREATE_ldmxcsr(dc, s) instr_create_0dst_1src((dc), OP_ldmxcsr, (s))

#define	INSTR_CREATE_vldmxcsr(dc, s) instr_create_0dst_1src((dc), OP_vldmxcsr, (s))

#define	INSTR_CREATE_nop_modrm(dc, s) instr_create_0dst_1src((dc), OP_nop_modrm, (s))

#define	INSTR_CREATE_ptwrite(dc, s) instr_create_0dst_1src((dc), OP_ptwrite, (s))

Prefetch
#define	INSTR_CREATE_prefetchnta(dc, s) instr_create_0dst_1src((dc), OP_prefetchnta, (s))

#define	INSTR_CREATE_prefetcht0(dc, s) instr_create_0dst_1src((dc), OP_prefetcht0, (s))

#define	INSTR_CREATE_prefetcht1(dc, s) instr_create_0dst_1src((dc), OP_prefetcht1, (s))

#define	INSTR_CREATE_prefetcht2(dc, s) instr_create_0dst_1src((dc), OP_prefetcht2, (s))

#define	INSTR_CREATE_prefetch(dc, s) instr_create_0dst_1src((dc), OP_prefetch, (s))

#define	INSTR_CREATE_prefetchw(dc, s) instr_create_0dst_1src((dc), OP_prefetchw, (s))

One implicit source
#define	INSTR_CREATE_fxam(dc) instr_create_0dst_1src((dc), OP_fxam, opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_sahf(dc) instr_create_0dst_1src((dc), OP_sahf, opnd_create_reg(DR_REG_AH))

#define	INSTR_CREATE_vmrun(dc) instr_create_0dst_1src((dc), OP_vmrun, opnd_create_reg(DR_REG_XAX))

#define	INSTR_CREATE_vmload(dc) instr_create_0dst_1src((dc), OP_vmload, opnd_create_reg(DR_REG_XAX))

#define	INSTR_CREATE_vmsave(dc) instr_create_0dst_1src((dc), OP_vmsave, opnd_create_reg(DR_REG_XAX))

#define	INSTR_CREATE_skinit(dc) instr_create_0dst_1src((dc), OP_skinit, opnd_create_reg(DR_REG_EAX))

No destination, 2 explicit sources
#define	INSTR_CREATE_cmp(dc, s1, s2) instr_create_0dst_2src((dc), OP_cmp, (s1), (s2))

#define	INSTR_CREATE_test(dc, s1, s2) instr_create_0dst_2src((dc), OP_test, (s1), (s2))

#define	INSTR_CREATE_ptest(dc, s1, s2) instr_create_0dst_2src((dc), OP_ptest, (s1), (s2))

#define	INSTR_CREATE_ud1(dc, s1, s2) instr_create_0dst_2src((dc), OP_ud1, (s1), (s2))

#define	INSTR_CREATE_ud2b(dc, s1, s2) INSTR_CREATE_ud1((dc), (s1), (s2))

#define	INSTR_CREATE_vucomiss(dc, s1, s2) instr_create_0dst_2src((dc), OP_vucomiss, (s1), (s2))

#define	INSTR_CREATE_vucomisd(dc, s1, s2) instr_create_0dst_2src((dc), OP_vucomisd, (s1), (s2))

#define	INSTR_CREATE_vcomiss(dc, s1, s2) instr_create_0dst_2src((dc), OP_vcomiss, (s1), (s2))

#define	INSTR_CREATE_vcomisd(dc, s1, s2) instr_create_0dst_2src((dc), OP_vcomisd, (s1), (s2))

#define	INSTR_CREATE_vptest(dc, s1, s2) instr_create_0dst_2src((dc), OP_vptest, (s1), (s2))

#define	INSTR_CREATE_vtestps(dc, s1, s2) instr_create_0dst_2src((dc), OP_vtestps, (s1), (s2))

#define	INSTR_CREATE_vtestpd(dc, s1, s2) instr_create_0dst_2src((dc), OP_vtestpd, (s1), (s2))

#define	INSTR_CREATE_bound(dc, s1, s2) instr_create_0dst_2src((dc), OP_bound, (s1), (s2))

#define	INSTR_CREATE_bt(dc, s, ri) instr_create_0dst_2src((dc), OP_bt, (s), (ri))

#define	INSTR_CREATE_ucomiss(dc, s1, s2) instr_create_0dst_2src((dc), OP_ucomiss, (s1), (s2))

#define	INSTR_CREATE_ucomisd(dc, s1, s2) instr_create_0dst_2src((dc), OP_ucomisd, (s1), (s2))

#define	INSTR_CREATE_comiss(dc, s1, s2) instr_create_0dst_2src((dc), OP_comiss, (s1), (s2))

#define	INSTR_CREATE_comisd(dc, s1, s2) instr_create_0dst_2src((dc), OP_comisd, (s1), (s2))

#define	INSTR_CREATE_invept(dc, s1, s2) instr_create_0dst_2src((dc), OP_invept, (s1), (s2))

#define	INSTR_CREATE_invvpid(dc, s1, s2) instr_create_0dst_2src((dc), OP_invvpid, (s1), (s2))

#define	INSTR_CREATE_invpcid(dc, s1, s2) instr_create_0dst_2src((dc), OP_invpcid, (s1), (s2))

No destination, 1 mask, and 1 explicit source
#define	INSTR_CREATE_vgatherpf0dps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf0dps, (k), (s))

#define	INSTR_CREATE_vgatherpf0dpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf0dpd, (k), (s))

#define	INSTR_CREATE_vgatherpf0qps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf0qps, (k), (s))

#define	INSTR_CREATE_vgatherpf0qpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf0qpd, (k), (s))

#define	INSTR_CREATE_vgatherpf1dps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf1dps, (k), (s))

#define	INSTR_CREATE_vgatherpf1dpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf1dpd, (k), (s))

#define	INSTR_CREATE_vgatherpf1qps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf1qps, (k), (s))

#define	INSTR_CREATE_vgatherpf1qpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vgatherpf1qpd, (k), (s))

#define	INSTR_CREATE_vscatterpf0dps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf0dps, (k), (s))

#define	INSTR_CREATE_vscatterpf0dpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf0dpd, (k), (s))

#define	INSTR_CREATE_vscatterpf0qps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf0qps, (k), (s))

#define	INSTR_CREATE_vscatterpf0qpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf0qpd, (k), (s))

#define	INSTR_CREATE_vscatterpf1dps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf1dps, (k), (s))

#define	INSTR_CREATE_vscatterpf1dpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf1dpd, (k), (s))

#define	INSTR_CREATE_vscatterpf1qps_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf1qps, (k), (s))

#define	INSTR_CREATE_vscatterpf1qpd_mask(dc, k, s) instr_create_0dst_2src((dc), OP_vscatterpf1qpd, (k), (s))

No destination, 2 sources
#define	INSTR_CREATE_out_1(dc)

#define	INSTR_CREATE_out_4(dc)

No destination, explicit immed source
#define	INSTR_CREATE_out_1_imm(dc, i) instr_create_0dst_2src((dc), OP_out, (i), opnd_create_reg(DR_REG_AL))

#define	INSTR_CREATE_out_4_imm(dc, i) instr_create_0dst_2src((dc), OP_out, (i), opnd_create_reg(DR_REG_EAX))

No destination, 2 implicit sources
#define	INSTR_CREATE_mwait(dc)

#define	INSTR_CREATE_mwaitx(dc)

#define	INSTR_CREATE_invlpga(dc)

#define	INSTR_CREATE_sysret(dc)

#define	INSTR_CREATE_wrmsr(dc)

#define	INSTR_CREATE_monitor(dc)

#define	INSTR_CREATE_monitorx(dc)

#define	INSTR_CREATE_xsetbv(dc)

#define	INSTR_CREATE_wrpkru(dc)

No destination, 3 sources: 1 implicit
#define	INSTR_CREATE_xrstor32(dc, s)

#define	INSTR_CREATE_xrstors32(dc, s)

#define	INSTR_CREATE_xrstor64(dc, s)

#define	INSTR_CREATE_xrstors64(dc, s)

No destination, 3 sources
#define	INSTR_CREATE_lwpins(dc, s1, s2, i) instr_create_0dst_3src((dc), OP_lwpins, (s1), (s2), (i))

#define	INSTR_CREATE_lwpval(dc, s1, s2, i) instr_create_0dst_3src((dc), OP_lwpval, (s1), (s2), (i))

Floating-point with source of memory or fp register
#define	INSTR_CREATE_fcom(dc, s) instr_create_0dst_2src((dc), OP_fcom, (s), opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_fcomp(dc, s) instr_create_0dst_2src((dc), OP_fcomp, (s), opnd_create_reg(DR_REG_ST0))

Floating-point with fp register source
#define	INSTR_CREATE_fcomi(dc, f) instr_create_0dst_2src((dc), OP_fcomi, opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fcomip(dc, f) instr_create_0dst_2src((dc), OP_fcomip, opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fucomi(dc, f) instr_create_0dst_2src((dc), OP_fucomi, opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fucomip(dc, f) instr_create_0dst_2src((dc), OP_fucomip, opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fucom(dc, f) instr_create_0dst_2src((dc), OP_fucom, opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fucomp(dc, f) instr_create_0dst_2src((dc), OP_fucomp, opnd_create_reg(DR_REG_ST0), (f))

Floating-point with no explicit sources
#define	INSTR_CREATE_fucompp(dc)

#define	INSTR_CREATE_fcompp(dc)

1 explicit destination, no sources
#define	INSTR_CREATE_sldt(dc, d) instr_create_1dst_0src((dc), OP_sldt, (d))

#define	INSTR_CREATE_str(dc, d) instr_create_1dst_0src((dc), OP_str, (d))

#define	INSTR_CREATE_vmptrst(dc, d) instr_create_1dst_0src((dc), OP_vmptrst, (d))

#define	INSTR_CREATE_vmclear(dc, d) instr_create_1dst_0src((dc), OP_vmclear, (d))

#define	INSTR_CREATE_rdrand(dc, d) instr_create_1dst_0src((dc), OP_rdrand, (d))

#define	INSTR_CREATE_rdseed(dc, d) instr_create_1dst_0src((dc), OP_rdseed, (d))

#define	INSTR_CREATE_rdfsbase(dc, d) instr_create_1dst_0src((dc), OP_rdfsbase, (d))

#define	INSTR_CREATE_rdgsbase(dc, d) instr_create_1dst_0src((dc), OP_rdgsbase, (d))

#define	INSTR_CREATE_slwpcb(dc, d) instr_create_1dst_0src((dc), OP_slwpcb, (d))

#define	INSTR_CREATE_sgdt(dc, d) instr_create_1dst_0src((dc), OP_sgdt, (d))

#define	INSTR_CREATE_sidt(dc, d) instr_create_1dst_0src((dc), OP_sidt, (d))

#define	INSTR_CREATE_smsw(dc, d) instr_create_1dst_0src((dc), OP_smsw, (d))

#define	INSTR_CREATE_fxsave32(dc, d) instr_create_1dst_0src((dc), OP_fxsave32, (d))

#define	INSTR_CREATE_fxsave64(dc, d) instr_create_1dst_0src((dc), OP_fxsave64, (d))

#define	INSTR_CREATE_stmxcsr(dc, d) instr_create_1dst_0src((dc), OP_stmxcsr, (d))

#define	INSTR_CREATE_vstmxcsr(dc, d) instr_create_1dst_0src((dc), OP_vstmxcsr, (d))

#define	INSTR_CREATE_rdpid(dc, d) instr_create_1dst_0src((dc), OP_rdpid, (d))

Floating-point with memory destination
#define	INSTR_CREATE_fnstcw(dc, m) instr_create_1dst_0src((dc), OP_fnstcw, (m))

#define	INSTR_CREATE_fnstsw(dc, m) instr_create_1dst_0src((dc), OP_fnstsw, (m))

Floating-point with float register destination, no sources
#define	INSTR_CREATE_ffree(dc, f) instr_create_1dst_0src((dc), OP_ffree, (f))

#define	INSTR_CREATE_ffreep(dc, f) instr_create_1dst_0src((dc), OP_ffreep, (f))

1 implicit destination, no sources
#define	INSTR_CREATE_lahf(dc) instr_create_1dst_0src((dc), OP_lahf, opnd_create_reg(DR_REG_AH))

#define	INSTR_CREATE_sysenter(dc) instr_create_1dst_0src((dc), OP_sysenter, opnd_create_reg(DR_REG_XSP))

#define	INSTR_CREATE_salc(dc) instr_create_1dst_0src((dc), OP_salc, opnd_create_reg(DR_REG_AL))

1 destination, 1 source
#define	INSTR_CREATE_arpl(dc, d, s) instr_create_1dst_1src((dc), OP_arpl, (d), (s))

#define	INSTR_CREATE_lea(dc, d, s) instr_create_1dst_1src((dc), OP_lea, (d), (s))

#define	INSTR_CREATE_mov_ld(dc, d, s) instr_create_1dst_1src((dc), OP_mov_ld, (d), (s))

#define	INSTR_CREATE_mov_st(dc, d, s) instr_create_1dst_1src((dc), OP_mov_st, (d), (s))

#define	INSTR_CREATE_mov_imm(dc, d, s) instr_create_1dst_1src((dc), OP_mov_imm, (d), (s))

#define	INSTR_CREATE_mov_seg(dc, d, s) instr_create_1dst_1src((dc), OP_mov_seg, (d), (s))

#define	INSTR_CREATE_mov_priv(dc, d, s) instr_create_1dst_1src((dc), OP_mov_priv, (d), (s))

#define	INSTR_CREATE_lar(dc, d, s) instr_create_1dst_1src((dc), OP_lar, (d), (s))

#define	INSTR_CREATE_lsl(dc, d, s) instr_create_1dst_1src((dc), OP_lsl, (d), (s))

#define	INSTR_CREATE_movntps(dc, d, s) instr_create_1dst_1src((dc), OP_movntps, (d), (s))

#define	INSTR_CREATE_movntpd(dc, d, s) instr_create_1dst_1src((dc), OP_movntpd, (d), (s))

#define	INSTR_CREATE_movd(dc, d, s) instr_create_1dst_1src((dc), OP_movd, (d), (s))

#define	INSTR_CREATE_movq(dc, d, s) instr_create_1dst_1src((dc), OP_movq, (d), (s))

#define	INSTR_CREATE_movdqu(dc, d, s) instr_create_1dst_1src((dc), OP_movdqu, (d), (s))

#define	INSTR_CREATE_movdqa(dc, d, s) instr_create_1dst_1src((dc), OP_movdqa, (d), (s))

#define	INSTR_CREATE_movzx(dc, d, s) instr_create_1dst_1src((dc), OP_movzx, (d), (s))

#define	INSTR_CREATE_movsx(dc, d, s) instr_create_1dst_1src((dc), OP_movsx, (d), (s))

#define	INSTR_CREATE_bsf(dc, d, s) INSTR_PRED(instr_create_1dst_1src((dc), OP_bsf, (d), (s)), DR_PRED_COMPLEX)

#define	INSTR_CREATE_bsr(dc, d, s) INSTR_PRED(instr_create_1dst_1src((dc), OP_bsr, (d), (s)), DR_PRED_COMPLEX)

#define	INSTR_CREATE_pmovmskb(dc, d, s) instr_create_1dst_1src((dc), OP_pmovmskb, (d), (s))

#define	INSTR_CREATE_movups(dc, d, s) instr_create_1dst_1src((dc), OP_movups, (d), (s))

#define	INSTR_CREATE_movss(dc, d, s) instr_create_1dst_1src((dc), OP_movss, (d), (s))

#define	INSTR_CREATE_movupd(dc, d, s) instr_create_1dst_1src((dc), OP_movupd, (d), (s))

#define	INSTR_CREATE_movsd(dc, d, s) instr_create_1dst_1src((dc), OP_movsd, (d), (s))

#define	INSTR_CREATE_movlps(dc, d, s) instr_create_1dst_1src((dc), OP_movlps, (d), (s))

#define	INSTR_CREATE_movlpd(dc, d, s) instr_create_1dst_1src((dc), OP_movlpd, (d), (s))

#define	INSTR_CREATE_movhps(dc, d, s) instr_create_1dst_1src((dc), OP_movhps, (d), (s))

#define	INSTR_CREATE_movhpd(dc, d, s) instr_create_1dst_1src((dc), OP_movhpd, (d), (s))

#define	INSTR_CREATE_movaps(dc, d, s) instr_create_1dst_1src((dc), OP_movaps, (d), (s))

#define	INSTR_CREATE_movapd(dc, d, s) instr_create_1dst_1src((dc), OP_movapd, (d), (s))

#define	INSTR_CREATE_cvtpi2ps(dc, d, s) instr_create_1dst_1src((dc), OP_cvtpi2ps, (d), (s))

#define	INSTR_CREATE_cvtsi2ss(dc, d, s) instr_create_1dst_1src((dc), OP_cvtsi2ss, (d), (s))

#define	INSTR_CREATE_cvtpi2pd(dc, d, s) instr_create_1dst_1src((dc), OP_cvtpi2pd, (d), (s))

#define	INSTR_CREATE_cvtsi2sd(dc, d, s) instr_create_1dst_1src((dc), OP_cvtsi2sd, (d), (s))

#define	INSTR_CREATE_cvttps2pi(dc, d, s) instr_create_1dst_1src((dc), OP_cvttps2pi, (d), (s))

#define	INSTR_CREATE_cvttss2si(dc, d, s) instr_create_1dst_1src((dc), OP_cvttss2si, (d), (s))

#define	INSTR_CREATE_cvttpd2pi(dc, d, s) instr_create_1dst_1src((dc), OP_cvttpd2pi, (d), (s))

#define	INSTR_CREATE_cvttsd2si(dc, d, s) instr_create_1dst_1src((dc), OP_cvttsd2si, (d), (s))

#define	INSTR_CREATE_cvtps2pi(dc, d, s) instr_create_1dst_1src((dc), OP_cvtps2pi, (d), (s))

#define	INSTR_CREATE_cvtss2si(dc, d, s) instr_create_1dst_1src((dc), OP_cvtss2si, (d), (s))

#define	INSTR_CREATE_cvtpd2pi(dc, d, s) instr_create_1dst_1src((dc), OP_cvtpd2pi, (d), (s))

#define	INSTR_CREATE_cvtsd2si(dc, d, s) instr_create_1dst_1src((dc), OP_cvtsd2si, (d), (s))

#define	INSTR_CREATE_cvtps2pd(dc, d, s) instr_create_1dst_1src((dc), OP_cvtps2pd, (d), (s))

#define	INSTR_CREATE_cvtss2sd(dc, d, s) instr_create_1dst_1src((dc), OP_cvtss2sd, (d), (s))

#define	INSTR_CREATE_cvtpd2ps(dc, d, s) instr_create_1dst_1src((dc), OP_cvtpd2ps, (d), (s))

#define	INSTR_CREATE_cvtsd2ss(dc, d, s) instr_create_1dst_1src((dc), OP_cvtsd2ss, (d), (s))

#define	INSTR_CREATE_cvtdq2ps(dc, d, s) instr_create_1dst_1src((dc), OP_cvtdq2ps, (d), (s))

#define	INSTR_CREATE_cvttps2dq(dc, d, s) instr_create_1dst_1src((dc), OP_cvttps2dq, (d), (s))

#define	INSTR_CREATE_cvtps2dq(dc, d, s) instr_create_1dst_1src((dc), OP_cvtps2dq, (d), (s))

#define	INSTR_CREATE_cvtdq2pd(dc, d, s) instr_create_1dst_1src((dc), OP_cvtdq2pd, (d), (s))

#define	INSTR_CREATE_cvttpd2dq(dc, d, s) instr_create_1dst_1src((dc), OP_cvttpd2dq, (d), (s))

#define	INSTR_CREATE_cvtpd2dq(dc, d, s) instr_create_1dst_1src((dc), OP_cvtpd2dq, (d), (s))

#define	INSTR_CREATE_movmskps(dc, d, s) instr_create_1dst_1src((dc), OP_movmskps, (d), (s))

#define	INSTR_CREATE_movmskpd(dc, d, s) instr_create_1dst_1src((dc), OP_movmskpd, (d), (s))

#define	INSTR_CREATE_sqrtps(dc, d, s) instr_create_1dst_1src((dc), OP_sqrtps, (d), (s))

#define	INSTR_CREATE_sqrtss(dc, d, s) instr_create_1dst_1src((dc), OP_sqrtss, (d), (s))

#define	INSTR_CREATE_sqrtpd(dc, d, s) instr_create_1dst_1src((dc), OP_sqrtpd, (d), (s))

#define	INSTR_CREATE_sqrtsd(dc, d, s) instr_create_1dst_1src((dc), OP_sqrtsd, (d), (s))

#define	INSTR_CREATE_rsqrtps(dc, d, s) instr_create_1dst_1src((dc), OP_rsqrtps, (d), (s))

#define	INSTR_CREATE_rsqrtss(dc, d, s) instr_create_1dst_1src((dc), OP_rsqrtss, (d), (s))

#define	INSTR_CREATE_rcpps(dc, d, s) instr_create_1dst_1src((dc), OP_rcpps, (d), (s))

#define	INSTR_CREATE_rcpss(dc, d, s) instr_create_1dst_1src((dc), OP_rcpss, (d), (s))

#define	INSTR_CREATE_lddqu(dc, d, s) instr_create_1dst_1src((dc), OP_lddqu, (d), (s))

#define	INSTR_CREATE_movsldup(dc, d, s) instr_create_1dst_1src((dc), OP_movsldup, (d), (s))

#define	INSTR_CREATE_movshdup(dc, d, s) instr_create_1dst_1src((dc), OP_movshdup, (d), (s))

#define	INSTR_CREATE_movddup(dc, d, s) instr_create_1dst_1src((dc), OP_movddup, (d), (s))

#define	INSTR_CREATE_popcnt(dc, d, s) instr_create_1dst_1src((dc), OP_popcnt, (d), (s))

#define	INSTR_CREATE_movntss(dc, d, s) instr_create_1dst_1src((dc), OP_movntss, (d), (s))

#define	INSTR_CREATE_movntsd(dc, d, s) instr_create_1dst_1src((dc), OP_movntsd, (d), (s))

#define	INSTR_CREATE_movntq(dc, d, s) instr_create_1dst_1src((dc), OP_movntq, (d), (s))

#define	INSTR_CREATE_movntdq(dc, d, s) instr_create_1dst_1src((dc), OP_movntdq, (d), (s))

#define	INSTR_CREATE_movnti(dc, d, s) instr_create_1dst_1src((dc), OP_movnti, (d), (s))

#define	INSTR_CREATE_lzcnt(dc, d, s) instr_create_1dst_1src((dc), OP_lzcnt, (d), (s))

#define	INSTR_CREATE_pmovsxbw(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxbw, (d), (s))

#define	INSTR_CREATE_pmovsxbd(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxbd, (d), (s))

#define	INSTR_CREATE_pmovsxbq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxbq, (d), (s))

#define	INSTR_CREATE_pmovsxwd(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxwd, (d), (s))

#define	INSTR_CREATE_pmovsxwq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxwq, (d), (s))

#define	INSTR_CREATE_pmovsxdq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovsxdq, (d), (s))

#define	INSTR_CREATE_movntdqa(dc, d, s) instr_create_1dst_1src((dc), OP_movntdqa, (d), (s))

#define	INSTR_CREATE_pmovzxbw(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxbw, (d), (s))

#define	INSTR_CREATE_pmovzxbd(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxbd, (d), (s))

#define	INSTR_CREATE_pmovzxbq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxbq, (d), (s))

#define	INSTR_CREATE_pmovzxwd(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxwd, (d), (s))

#define	INSTR_CREATE_pmovzxwq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxwq, (d), (s))

#define	INSTR_CREATE_pmovzxdq(dc, d, s) instr_create_1dst_1src((dc), OP_pmovzxdq, (d), (s))

#define	INSTR_CREATE_phminposuw(dc, d, s) instr_create_1dst_1src((dc), OP_phminposuw, (d), (s))

#define	INSTR_CREATE_vmread(dc, d, s) instr_create_1dst_1src((dc), OP_vmread, (d), (s))

#define	INSTR_CREATE_vmwrite(dc, d, s) instr_create_1dst_1src((dc), OP_vmwrite, (d), (s))

#define	INSTR_CREATE_movsxd(dc, d, s) instr_create_1dst_1src((dc), OP_movsxd, (d), (s))

#define	INSTR_CREATE_movbe(dc, d, s) instr_create_1dst_1src((dc), OP_movbe, (d), (s))

#define	INSTR_CREATE_aesimc(dc, d, s) instr_create_1dst_1src((dc), OP_aesimc, (d), (s))

#define	INSTR_CREATE_pabsb(dc, d, s) instr_create_1dst_1src((dc), OP_pabsb, (d), (s))

#define	INSTR_CREATE_pabsw(dc, d, s) instr_create_1dst_1src((dc), OP_pabsw, (d), (s))

#define	INSTR_CREATE_pabsd(dc, d, s) instr_create_1dst_1src((dc), OP_pabsd, (d), (s))

#define	INSTR_CREATE_vmovups(dc, d, s) instr_create_1dst_1src((dc), OP_vmovups, (d), (s))

#define	INSTR_CREATE_vmovupd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovupd, (d), (s))

#define	INSTR_CREATE_vmovsldup(dc, d, s) instr_create_1dst_1src((dc), OP_vmovsldup, (d), (s))

#define	INSTR_CREATE_vmovddup(dc, d, s) instr_create_1dst_1src((dc), OP_vmovddup, (d), (s))

#define	INSTR_CREATE_vmovlps(dc, d, s) instr_create_1dst_1src((dc), OP_vmovlps, (d), (s))

#define	INSTR_CREATE_vmovlpd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovlpd, (d), (s))

#define	INSTR_CREATE_vmovshdup(dc, d, s) instr_create_1dst_1src((dc), OP_vmovshdup, (d), (s))

#define	INSTR_CREATE_vmovhps(dc, d, s) instr_create_1dst_1src((dc), OP_vmovhps, (d), (s))

#define	INSTR_CREATE_vmovhpd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovhpd, (d), (s))

#define	INSTR_CREATE_vmovaps(dc, d, s) instr_create_1dst_1src((dc), OP_vmovaps, (d), (s))

#define	INSTR_CREATE_vmovapd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovapd, (d), (s))

#define	INSTR_CREATE_vmovntps(dc, d, s) instr_create_1dst_1src((dc), OP_vmovntps, (d), (s))

#define	INSTR_CREATE_vmovntpd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovntpd, (d), (s))

#define	INSTR_CREATE_vcvttss2si(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttss2si, (d), (s))

#define	INSTR_CREATE_vcvttsd2si(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttsd2si, (d), (s))

#define	INSTR_CREATE_vcvtss2si(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtss2si, (d), (s))

#define	INSTR_CREATE_vcvtsd2si(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtsd2si, (d), (s))

#define	INSTR_CREATE_vcvtss2usi(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtss2usi, (d), (s))

#define	INSTR_CREATE_vcvtsd2usi(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtsd2usi, (d), (s))

#define	INSTR_CREATE_vcvttss2usi(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttss2usi, (d), (s))

#define	INSTR_CREATE_vcvttsd2usi(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttsd2usi, (d), (s))

#define	INSTR_CREATE_vmovmskps(dc, d, s) instr_create_1dst_1src((dc), OP_vmovmskps, (d), (s))

#define	INSTR_CREATE_vmovmskpd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovmskpd, (d), (s))

#define	INSTR_CREATE_vsqrtps(dc, d, s) instr_create_1dst_1src((dc), OP_vsqrtps, (d), (s))

#define	INSTR_CREATE_vsqrtpd(dc, d, s) instr_create_1dst_1src((dc), OP_vsqrtpd, (d), (s))

#define	INSTR_CREATE_vrsqrtps(dc, d, s) instr_create_1dst_1src((dc), OP_vrsqrtps, (d), (s))

#define	INSTR_CREATE_vrcpps(dc, d, s) instr_create_1dst_1src((dc), OP_vrcpps, (d), (s))

#define	INSTR_CREATE_vcvtps2pd(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtps2pd, (d), (s))

#define	INSTR_CREATE_vcvtpd2ps(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtpd2ps, (d), (s))

#define	INSTR_CREATE_vcvtdq2ps(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtdq2ps, (d), (s))

#define	INSTR_CREATE_vcvttps2dq(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttps2dq, (d), (s))

#define	INSTR_CREATE_vcvtps2dq(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtps2dq, (d), (s))

#define	INSTR_CREATE_vmovd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovd, (d), (s))

#define	INSTR_CREATE_vmovq(dc, d, s) instr_create_1dst_1src((dc), OP_vmovq, (d), (s))

#define	INSTR_CREATE_vpmovmskb(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovmskb, (d), (s))

#define	INSTR_CREATE_vcvtdq2pd(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtdq2pd, (d), (s))

#define	INSTR_CREATE_vcvttpd2dq(dc, d, s) instr_create_1dst_1src((dc), OP_vcvttpd2dq, (d), (s))

#define	INSTR_CREATE_vcvtpd2dq(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtpd2dq, (d), (s))

#define	INSTR_CREATE_vmovntdq(dc, d, s) instr_create_1dst_1src((dc), OP_vmovntdq, (d), (s))

#define	INSTR_CREATE_vmovdqu(dc, d, s) instr_create_1dst_1src((dc), OP_vmovdqu, (d), (s))

#define	INSTR_CREATE_vmovdqa(dc, d, s) instr_create_1dst_1src((dc), OP_vmovdqa, (d), (s))

#define	INSTR_CREATE_vlddqu(dc, d, s) instr_create_1dst_1src((dc), OP_vlddqu, (d), (s))

#define	INSTR_CREATE_vpmovsxbw(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxbw, (d), (s))

#define	INSTR_CREATE_vpmovsxbd(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxbd, (d), (s))

#define	INSTR_CREATE_vpmovsxbq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxbq, (d), (s))

#define	INSTR_CREATE_vpmovsxwd(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxwd, (d), (s))

#define	INSTR_CREATE_vpmovsxwq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxwq, (d), (s))

#define	INSTR_CREATE_vpmovsxdq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovsxdq, (d), (s))

#define	INSTR_CREATE_vmovntdqa(dc, d, s) instr_create_1dst_1src((dc), OP_vmovntdqa, (d), (s))

#define	INSTR_CREATE_vpmovzxbw(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxbw, (d), (s))

#define	INSTR_CREATE_vpmovzxbd(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxbd, (d), (s))

#define	INSTR_CREATE_vpmovzxbq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxbq, (d), (s))

#define	INSTR_CREATE_vpmovzxwd(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxwd, (d), (s))

#define	INSTR_CREATE_vpmovzxwq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxwq, (d), (s))

#define	INSTR_CREATE_vpmovzxdq(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovzxdq, (d), (s))

#define	INSTR_CREATE_vphminposuw(dc, d, s) instr_create_1dst_1src((dc), OP_vphminposuw, (d), (s))

#define	INSTR_CREATE_vaesimc(dc, d, s) instr_create_1dst_1src((dc), OP_vaesimc, (d), (s))

#define	INSTR_CREATE_vmovss(dc, d, s) instr_create_1dst_1src((dc), OP_vmovss, (d), (s))

#define	INSTR_CREATE_vmovsd(dc, d, s) instr_create_1dst_1src((dc), OP_vmovsd, (d), (s))

#define	INSTR_CREATE_vcvtph2ps(dc, d, s) instr_create_1dst_1src((dc), OP_vcvtph2ps, (d), (s))

#define	INSTR_CREATE_vbroadcastss(dc, d, s) instr_create_1dst_1src((dc), OP_vbroadcastss, (d), (s))

#define	INSTR_CREATE_vbroadcastsd(dc, d, s) instr_create_1dst_1src((dc), OP_vbroadcastsd, (d), (s))

#define	INSTR_CREATE_vbroadcastf128(dc, d, s) instr_create_1dst_1src((dc), OP_vbroadcastf128, (d), (s))

#define	INSTR_CREATE_movq2dq(dc, d, s) instr_create_1dst_1src((dc), OP_movq2dq, (d), (s))

#define	INSTR_CREATE_movdq2q(dc, d, s) instr_create_1dst_1src((dc), OP_movdq2q, (d), (s))

#define	INSTR_CREATE_vpabsb(dc, d, s) instr_create_1dst_1src((dc), OP_vpabsb, (d), (s))

#define	INSTR_CREATE_vpabsw(dc, d, s) instr_create_1dst_1src((dc), OP_vpabsw, (d), (s))

#define	INSTR_CREATE_vpabsd(dc, d, s) instr_create_1dst_1src((dc), OP_vpabsd, (d), (s))

#define	INSTR_CREATE_vfrczps(dc, d, s) instr_create_1dst_1src((dc), OP_vfrczps, (d), (s))

#define	INSTR_CREATE_vfrczpd(dc, d, s) instr_create_1dst_1src((dc), OP_vfrczpd, (d), (s))

#define	INSTR_CREATE_vfrczss(dc, d, s) instr_create_1dst_1src((dc), OP_vfrczss, (d), (s))

#define	INSTR_CREATE_vfrczsd(dc, d, s) instr_create_1dst_1src((dc), OP_vfrczsd, (d), (s))

#define	INSTR_CREATE_vphaddbw(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddbw, (d), (s))

#define	INSTR_CREATE_vphaddbd(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddbd, (d), (s))

#define	INSTR_CREATE_vphaddbq(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddbq, (d), (s))

#define	INSTR_CREATE_vphaddwd(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddwd, (d), (s))

#define	INSTR_CREATE_vphaddwq(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddwq, (d), (s))

#define	INSTR_CREATE_vphadddq(dc, d, s) instr_create_1dst_1src((dc), OP_vphadddq, (d), (s))

#define	INSTR_CREATE_vphaddubw(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddubw, (d), (s))

#define	INSTR_CREATE_vphaddubd(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddubd, (d), (s))

#define	INSTR_CREATE_vphaddubq(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddubq, (d), (s))

#define	INSTR_CREATE_vphadduwd(dc, d, s) instr_create_1dst_1src((dc), OP_vphadduwd, (d), (s))

#define	INSTR_CREATE_vphadduwq(dc, d, s) instr_create_1dst_1src((dc), OP_vphadduwq, (d), (s))

#define	INSTR_CREATE_vphaddudq(dc, d, s) instr_create_1dst_1src((dc), OP_vphaddudq, (d), (s))

#define	INSTR_CREATE_vphsubbw(dc, d, s) instr_create_1dst_1src((dc), OP_vphsubbw, (d), (s))

#define	INSTR_CREATE_vphsubwd(dc, d, s) instr_create_1dst_1src((dc), OP_vphsubwd, (d), (s))

#define	INSTR_CREATE_vphsubdq(dc, d, s) instr_create_1dst_1src((dc), OP_vphsubdq, (d), (s))

#define	INSTR_CREATE_blcfill(dc, d, s) instr_create_1dst_1src((dc), OP_blcfill, (d), (s))

#define	INSTR_CREATE_blci(dc, d, s) instr_create_1dst_1src((dc), OP_blci, (d), (s))

#define	INSTR_CREATE_blcic(dc, d, s) instr_create_1dst_1src((dc), OP_blcic, (d), (s))

#define	INSTR_CREATE_blcmsk(dc, d, s) instr_create_1dst_1src((dc), OP_blcmsk, (d), (s))

#define	INSTR_CREATE_blcs(dc, d, s) instr_create_1dst_1src((dc), OP_blcs, (d), (s))

#define	INSTR_CREATE_blsfill(dc, d, s) instr_create_1dst_1src((dc), OP_blsfill, (d), (s))

#define	INSTR_CREATE_blsic(dc, d, s) instr_create_1dst_1src((dc), OP_blsic, (d), (s))

#define	INSTR_CREATE_t1mskc(dc, d, s) instr_create_1dst_1src((dc), OP_t1mskc, (d), (s))

#define	INSTR_CREATE_tzmsk(dc, d, s) instr_create_1dst_1src((dc), OP_tzmsk, (d), (s))

#define	INSTR_CREATE_blsr(dc, d, s) instr_create_1dst_1src((dc), OP_blsr, (d), (s))

#define	INSTR_CREATE_blsmsk(dc, d, s) instr_create_1dst_1src((dc), OP_blsmsk, (d), (s))

#define	INSTR_CREATE_blsi(dc, d, s) instr_create_1dst_1src((dc), OP_blsi, (d), (s))

#define	INSTR_CREATE_tzcnt(dc, d, s) instr_create_1dst_1src((dc), OP_tzcnt, (d), (s))

#define	INSTR_CREATE_vbroadcasti128(dc, d, s) instr_create_1dst_1src((dc), OP_vbroadcasti128, (d), (s))

#define	INSTR_CREATE_vpbroadcastb(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastb, (d), (s))

#define	INSTR_CREATE_vpbroadcastw(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastw, (d), (s))

#define	INSTR_CREATE_vpbroadcastd(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastd, (d), (s))

#define	INSTR_CREATE_vpbroadcastq(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastq, (d), (s))

#define	INSTR_CREATE_kmovw(dc, d, s) instr_create_1dst_1src((dc), OP_kmovw, (d), (s))

#define	INSTR_CREATE_kmovb(dc, d, s) instr_create_1dst_1src((dc), OP_kmovb, (d), (s))

#define	INSTR_CREATE_kmovq(dc, d, s) instr_create_1dst_1src((dc), OP_kmovq, (d), (s))

#define	INSTR_CREATE_kmovd(dc, d, s) instr_create_1dst_1src((dc), OP_kmovd, (d), (s))

#define	INSTR_CREATE_knotw(dc, d, s) instr_create_1dst_1src((dc), OP_knotw, (d), (s))

#define	INSTR_CREATE_knotb(dc, d, s) instr_create_1dst_1src((dc), OP_knotb, (d), (s))

#define	INSTR_CREATE_knotq(dc, d, s) instr_create_1dst_1src((dc), OP_knotq, (d), (s))

#define	INSTR_CREATE_knotd(dc, d, s) instr_create_1dst_1src((dc), OP_knotd, (d), (s))

#define	INSTR_CREATE_kortestw(dc, d, s) instr_create_1dst_1src((dc), OP_kortestw, (d), (s))

#define	INSTR_CREATE_kortestb(dc, d, s) instr_create_1dst_1src((dc), OP_kortestb, (d), (s))

#define	INSTR_CREATE_kortestq(dc, d, s) instr_create_1dst_1src((dc), OP_kortestq, (d), (s))

#define	INSTR_CREATE_kortestd(dc, d, s) instr_create_1dst_1src((dc), OP_kortestd, (d), (s))

#define	INSTR_CREATE_ktestw(dc, d, s) instr_create_1dst_1src((dc), OP_ktestw, (d), (s))

#define	INSTR_CREATE_ktestb(dc, d, s) instr_create_1dst_1src((dc), OP_ktestb, (d), (s))

#define	INSTR_CREATE_ktestq(dc, d, s) instr_create_1dst_1src((dc), OP_ktestq, (d), (s))

#define	INSTR_CREATE_ktestd(dc, d, s) instr_create_1dst_1src((dc), OP_ktestd, (d), (s))

#define	INSTR_CREATE_vmovd_mask(dc, d, s) instr_create_1dst_1src((dc), OP_vmovd, (d), (s))

#define	INSTR_CREATE_vpmovm2b(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovm2b, (d), (s))

#define	INSTR_CREATE_vpmovm2w(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovm2w, (d), (s))

#define	INSTR_CREATE_vpmovm2d(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovm2d, (d), (s))

#define	INSTR_CREATE_vpmovm2q(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovm2q, (d), (s))

#define	INSTR_CREATE_vpmovb2m(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovb2m, (d), (s))

#define	INSTR_CREATE_vpmovw2m(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovw2m, (d), (s))

#define	INSTR_CREATE_vpmovd2m(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovd2m, (d), (s))

#define	INSTR_CREATE_vpmovq2m(dc, d, s) instr_create_1dst_1src((dc), OP_vpmovq2m, (d), (s))

#define	INSTR_CREATE_vpbroadcastmb2q(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastmb2q, (d), (s))

#define	INSTR_CREATE_vpbroadcastmw2d(dc, d, s) instr_create_1dst_1src((dc), OP_vpbroadcastmw2d, (d), (s))

#define	INSTR_CREATE_bndmov(dc, d, s) instr_create_1dst_1src((dc), OP_bndmov, (d), (s))

#define	INSTR_CREATE_bndcl(dc, d, s) instr_create_1dst_1src((dc), OP_bndcl, (d), (s))

#define	INSTR_CREATE_bndcu(dc, d, s) instr_create_1dst_1src((dc), OP_bndcu, (d), (s))

#define	INSTR_CREATE_bndcn(dc, d, s) instr_create_1dst_1src((dc), OP_bndcn, (d), (s))

#define	INSTR_CREATE_bndmk(dc, d, s) instr_create_1dst_1src((dc), OP_bndmk, (d), (s))

#define	INSTR_CREATE_bndldx(dc, d, s) instr_create_1dst_1src((dc), OP_bndldx, (d), (s))

#define	INSTR_CREATE_bndstx(dc, d, s) instr_create_1dst_1src((dc), OP_bndstx, (d), (s))

#define	INSTR_CREATE_movdiri(dc, d, s) instr_create_1dst_1src((dc), OP_movdiri, (d), (s))

#define	INSTR_CREATE_movdir64b(dc, d, s) instr_create_1dst_1src((dc), OP_movdir64b, (d), (s))

#define	INSTR_CREATE_enqcmd(dc, d, s) instr_create_1dst_1src((dc), OP_enqcmd, (d), (s))

#define	INSTR_CREATE_enqcmds(dc, d, s) instr_create_1dst_1src((dc), OP_enqcmds, (d), (s))

1 destination, 1 implicit source
#define	INSTR_CREATE_inc(dc, d) instr_create_1dst_1src((dc), OP_inc, (d), (d))

#define	INSTR_CREATE_dec(dc, d) instr_create_1dst_1src((dc), OP_dec, (d), (d))

#define	INSTR_CREATE_bswap(dc, d) instr_create_1dst_1src((dc), OP_bswap, (d), (d))

#define	INSTR_CREATE_not(dc, d) instr_create_1dst_1src((dc), OP_not, (d), (d))

#define	INSTR_CREATE_neg(dc, d) instr_create_1dst_1src((dc), OP_neg, (d), (d))

1 implicit destination, 1 implicit source
#define	INSTR_CREATE_cdq(dc)

#define	INSTR_CREATE_daa(dc)

#define	INSTR_CREATE_das(dc)

#define	INSTR_CREATE_aaa(dc)

#define	INSTR_CREATE_aas(dc)

#define	INSTR_CREATE_cwde(dc)

#define	INSTR_CREATE_xlat(dc)

#define	INSTR_CREATE_xend(dc)

#define	INSTR_CREATE_sysexit(dc)

In with no explicit sources
#define	INSTR_CREATE_in_1(dc)

#define	INSTR_CREATE_in_4(dc)

In with explicit source
#define	INSTR_CREATE_in_1_imm(dc, i) instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_AL), (i))

#define	INSTR_CREATE_in_4_imm(dc, i) instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_EAX), (i))

Floating point with destination that is memory or fp register
#define	INSTR_CREATE_fst(dc, d) instr_create_1dst_1src((dc), OP_fst, (d), opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_fstp(dc, d) instr_create_1dst_1src((dc), OP_fstp, (d), opnd_create_reg(DR_REG_ST0))

Floating-point with memory destination and implicit source
#define	INSTR_CREATE_fist(dc, m) instr_create_1dst_1src((dc), OP_fist, (m), opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_fistp(dc, m) instr_create_1dst_1src((dc), OP_fistp, (m), opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_fisttp(dc, m) instr_create_1dst_1src((dc), OP_fisttp, (m), opnd_create_reg(DR_REG_ST0))

#define	INSTR_CREATE_fbstp(dc, m) instr_create_1dst_1src((dc), OP_fbstp, (m), opnd_create_reg(DR_REG_ST0))

Floating-point with memory source
#define	INSTR_CREATE_fild(dc, m) instr_create_1dst_1src((dc), OP_fild, opnd_create_reg(DR_REG_ST0), (m))

#define	INSTR_CREATE_fbld(dc, m) instr_create_1dst_1src((dc), OP_fbld, opnd_create_reg(DR_REG_ST0), (m))

Floating-point implicit destination and implicit source
#define	INSTR_CREATE_fchs(dc)

#define	INSTR_CREATE_fabs(dc)

#define	INSTR_CREATE_ftst(dc)

#define	INSTR_CREATE_fld1(dc)

#define	INSTR_CREATE_fldl2t(dc)

#define	INSTR_CREATE_fldl2e(dc)

#define	INSTR_CREATE_fldpi(dc)

#define	INSTR_CREATE_fldlg2(dc)

#define	INSTR_CREATE_fldln2(dc)

#define	INSTR_CREATE_fldz(dc)

#define	INSTR_CREATE_f2xm1(dc)

#define	INSTR_CREATE_fptan(dc)

#define	INSTR_CREATE_fxtract(dc)

#define	INSTR_CREATE_fsqrt(dc)

#define	INSTR_CREATE_fsincos(dc)

#define	INSTR_CREATE_frndint(dc)

#define	INSTR_CREATE_fsin(dc)

#define	INSTR_CREATE_fcos(dc)

#define	INSTR_CREATE_fscale(dc)

#define	INSTR_CREATE_fyl2x(dc)

#define	INSTR_CREATE_fyl2xp1(dc)

#define	INSTR_CREATE_fpatan(dc)

#define	INSTR_CREATE_fprem(dc)

#define	INSTR_CREATE_fprem1(dc)

1 destination, 2 sources
#define	INSTR_CREATE_pshufw(dc, d, s, i) instr_create_1dst_2src((dc), OP_pshufw, (d), (s), (i))

#define	INSTR_CREATE_pshufd(dc, d, s, i) instr_create_1dst_2src((dc), OP_pshufd, (d), (s), (i))

#define	INSTR_CREATE_pshufhw(dc, d, s, i) instr_create_1dst_2src((dc), OP_pshufhw, (d), (s), (i))

#define	INSTR_CREATE_pshuflw(dc, d, s, i) instr_create_1dst_2src((dc), OP_pshuflw, (d), (s), (i))

#define	INSTR_CREATE_pinsrw(dc, d, s, i) instr_create_1dst_2src((dc), OP_pinsrw, (d), (s), (i))

#define	INSTR_CREATE_pextrw(dc, d, s, i) instr_create_1dst_2src((dc), OP_pextrw, (d), (s), (i))

#define	INSTR_CREATE_pextrb(dc, d, s, i) instr_create_1dst_2src((dc), OP_pextrb, (d), (s), (i))

#define	INSTR_CREATE_pextrd(dc, d, s, i) instr_create_1dst_2src((dc), OP_pextrd, (d), (s), (i))

#define	INSTR_CREATE_extractps(dc, d, s, i) instr_create_1dst_2src((dc), OP_extractps, (d), (s), (i))

#define	INSTR_CREATE_roundps(dc, d, s, i) instr_create_1dst_2src((dc), OP_roundps, (d), (s), (i))

#define	INSTR_CREATE_roundpd(dc, d, s, i) instr_create_1dst_2src((dc), OP_roundpd, (d), (s), (i))

#define	INSTR_CREATE_roundss(dc, d, s, i) instr_create_1dst_2src((dc), OP_roundss, (d), (s), (i))

#define	INSTR_CREATE_roundsd(dc, d, s, i) instr_create_1dst_2src((dc), OP_roundsd, (d), (s), (i))

#define	INSTR_CREATE_pinsrb(dc, d, s, i) instr_create_1dst_2src((dc), OP_pinsrb, (d), (s), (i))

#define	INSTR_CREATE_insertps(dc, d, s, i) instr_create_1dst_2src((dc), OP_insertps, (d), (s), (i))

#define	INSTR_CREATE_pinsrd(dc, d, s, i) instr_create_1dst_2src((dc), OP_pinsrd, (d), (s), (i))

#define	INSTR_CREATE_aeskeygenassist(dc, d, s, i) instr_create_1dst_2src((dc), OP_aeskeygenassist, (d), (s), (i))

1 destination, 1 mask, and 2 sources
#define	INSTR_CREATE_vpshufhw_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vpshufhw, (d), (k), (i), (s))

#define	INSTR_CREATE_vpshufd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vpshufd, (d), (k), (i), (s))

#define	INSTR_CREATE_vpshuflw_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vpshuflw, (d), (k), (i), (s))

#define	INSTR_CREATE_vgetmantps_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vgetmantps, (d), (k), (i), (s))

#define	INSTR_CREATE_vgetmantpd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vgetmantpd, (d), (k), (i), (s))

#define	INSTR_CREATE_vreduceps_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vreduceps, (d), (k), (i), (s))

#define	INSTR_CREATE_vreducepd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vreducepd, (d), (k), (i), (s))

#define	INSTR_CREATE_vrndscaleps_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vrndscaleps, (d), (k), (i), (s))

#define	INSTR_CREATE_vrndscalepd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vrndscalepd, (d), (k), (i), (s))

#define	INSTR_CREATE_vfpclassps_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vfpclassps, (d), (k), (i), (s))

#define	INSTR_CREATE_vfpclasspd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vfpclasspd, (d), (k), (i), (s))

#define	INSTR_CREATE_vfpclassss_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vfpclassss, (d), (k), (i), (s))

#define	INSTR_CREATE_vfpclasssd_mask(dc, d, k, i, s) instr_create_1dst_3src((dc), OP_vfpclasssd, (d), (k), (i), (s))

1 destination, 2 non-immediate sources
#define	INSTR_CREATE_vmovlps_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovlps, (d), (s1), (s2))

#define	INSTR_CREATE_vmovlpd_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovlpd, (d), (s1), (s2))

#define	INSTR_CREATE_vunpcklps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vunpcklps, (d), (s1), (s2))

#define	INSTR_CREATE_vunpcklpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vunpcklpd, (d), (s1), (s2))

#define	INSTR_CREATE_vunpckhps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vunpckhps, (d), (s1), (s2))

#define	INSTR_CREATE_vunpckhpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vunpckhpd, (d), (s1), (s2))

#define	INSTR_CREATE_vmovhps_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovhps, (d), (s1), (s2))

#define	INSTR_CREATE_vmovhpd_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovhpd, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtsi2ss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtsi2ss, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtsi2sd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtsi2sd, (d), (s1), (s2))

#define	INSTR_CREATE_vsqrtss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsqrtss, (d), (s1), (s2))

#define	INSTR_CREATE_vsqrtsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsqrtsd, (d), (s1), (s2))

#define	INSTR_CREATE_vrsqrtss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vrsqrtss, (d), (s1), (s2))

#define	INSTR_CREATE_vrcpss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vrcpss, (d), (s1), (s2))

#define	INSTR_CREATE_vandps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vandps, (d), (s1), (s2))

#define	INSTR_CREATE_vandpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vandpd, (d), (s1), (s2))

#define	INSTR_CREATE_vandnps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vandnps, (d), (s1), (s2))

#define	INSTR_CREATE_vandnpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vandnpd, (d), (s1), (s2))

#define	INSTR_CREATE_vorps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vorps, (d), (s1), (s2))

#define	INSTR_CREATE_vorpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vorpd, (d), (s1), (s2))

#define	INSTR_CREATE_vxorps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vxorps, (d), (s1), (s2))

#define	INSTR_CREATE_vxorpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vxorpd, (d), (s1), (s2))

#define	INSTR_CREATE_vaddps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddps, (d), (s1), (s2))

#define	INSTR_CREATE_vaddss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddss, (d), (s1), (s2))

#define	INSTR_CREATE_vaddpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddpd, (d), (s1), (s2))

#define	INSTR_CREATE_vaddsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddsd, (d), (s1), (s2))

#define	INSTR_CREATE_vmulps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmulps, (d), (s1), (s2))

#define	INSTR_CREATE_vmulss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmulss, (d), (s1), (s2))

#define	INSTR_CREATE_vmulpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmulpd, (d), (s1), (s2))

#define	INSTR_CREATE_vmulsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmulsd, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtss2sd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtss2sd, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtsd2ss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtsd2ss, (d), (s1), (s2))

#define	INSTR_CREATE_vsubps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsubps, (d), (s1), (s2))

#define	INSTR_CREATE_vsubss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsubss, (d), (s1), (s2))

#define	INSTR_CREATE_vsubpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsubpd, (d), (s1), (s2))

#define	INSTR_CREATE_vsubsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vsubsd, (d), (s1), (s2))

#define	INSTR_CREATE_vminps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vminps, (d), (s1), (s2))

#define	INSTR_CREATE_vminss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vminss, (d), (s1), (s2))

#define	INSTR_CREATE_vminpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vminpd, (d), (s1), (s2))

#define	INSTR_CREATE_vminsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vminsd, (d), (s1), (s2))

#define	INSTR_CREATE_vdivps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vdivps, (d), (s1), (s2))

#define	INSTR_CREATE_vdivss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vdivss, (d), (s1), (s2))

#define	INSTR_CREATE_vdivpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vdivpd, (d), (s1), (s2))

#define	INSTR_CREATE_vdivsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vdivsd, (d), (s1), (s2))

#define	INSTR_CREATE_vmaxps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmaxps, (d), (s1), (s2))

#define	INSTR_CREATE_vmaxss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmaxss, (d), (s1), (s2))

#define	INSTR_CREATE_vmaxpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmaxpd, (d), (s1), (s2))

#define	INSTR_CREATE_vmaxsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmaxsd, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpcklbw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpcklbw, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpcklwd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpcklwd, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpckldq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpckldq, (d), (s1), (s2))

#define	INSTR_CREATE_vpacksswb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpacksswb, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpgtb, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpgtw, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpgtd, (d), (s1), (s2))

#define	INSTR_CREATE_vpackuswb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpackuswb, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpckhbw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpckhbw, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpckhwd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpckhwd, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpckhdq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpckhdq, (d), (s1), (s2))

#define	INSTR_CREATE_vpackssdw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpackssdw, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpcklqdq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpcklqdq, (d), (s1), (s2))

#define	INSTR_CREATE_vpunpckhqdq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpunpckhqdq, (d), (s1), (s2))

#define	INSTR_CREATE_vpshufhw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshufhw, (d), (s1), (s2))

#define	INSTR_CREATE_vpshufd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshufd, (d), (s1), (s2))

#define	INSTR_CREATE_vpshuflw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshuflw, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpeqb, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpeqw, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpeqd, (d), (s1), (s2))

#define	INSTR_CREATE_vpextrw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpextrw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrlw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrlw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrld(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrld, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrlq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrlq, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddq, (d), (s1), (s2))

#define	INSTR_CREATE_vpmullw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmullw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubusb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubusb, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubusw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubusw, (d), (s1), (s2))

#define	INSTR_CREATE_vpminub(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminub, (d), (s1), (s2))

#define	INSTR_CREATE_vpand(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpand, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddusb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddusb, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddusw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddusw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxub(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxub, (d), (s1), (s2))

#define	INSTR_CREATE_vpandn(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpandn, (d), (s1), (s2))

#define	INSTR_CREATE_vpavgb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpavgb, (d), (s1), (s2))

#define	INSTR_CREATE_vpsraw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsraw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrad(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrad, (d), (s1), (s2))

#define	INSTR_CREATE_vpavgw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpavgw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmulhuw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmulhuw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmulhw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmulhw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubsb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubsb, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpminsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpor(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpor, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddsb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddsb, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpxor(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpxor, (d), (s1), (s2))

#define	INSTR_CREATE_vpsllw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsllw, (d), (s1), (s2))

#define	INSTR_CREATE_vpslld(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpslld, (d), (s1), (s2))

#define	INSTR_CREATE_vpsllq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsllq, (d), (s1), (s2))

#define	INSTR_CREATE_vpmuludq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmuludq, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaddwd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaddwd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsadbw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsadbw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubb, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsubq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsubq, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddb, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddw, (d), (s1), (s2))

#define	INSTR_CREATE_vpaddd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpaddd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrldq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrldq, (d), (s1), (s2))

#define	INSTR_CREATE_vpslldq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpslldq, (d), (s1), (s2))

#define	INSTR_CREATE_vhaddpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vhaddpd, (d), (s1), (s2))

#define	INSTR_CREATE_vhaddps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vhaddps, (d), (s1), (s2))

#define	INSTR_CREATE_vhsubpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vhsubpd, (d), (s1), (s2))

#define	INSTR_CREATE_vhsubps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vhsubps, (d), (s1), (s2))

#define	INSTR_CREATE_vaddsubpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddsubpd, (d), (s1), (s2))

#define	INSTR_CREATE_vaddsubps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaddsubps, (d), (s1), (s2))

#define	INSTR_CREATE_vpshufb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshufb, (d), (s1), (s2))

#define	INSTR_CREATE_vphaddw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphaddw, (d), (s1), (s2))

#define	INSTR_CREATE_vphaddd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphaddd, (d), (s1), (s2))

#define	INSTR_CREATE_vphaddsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphaddsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaddubsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaddubsw, (d), (s1), (s2))

#define	INSTR_CREATE_vphsubw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphsubw, (d), (s1), (s2))

#define	INSTR_CREATE_vphsubd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphsubd, (d), (s1), (s2))

#define	INSTR_CREATE_vphsubsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vphsubsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsignb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsignb, (d), (s1), (s2))

#define	INSTR_CREATE_vpsignw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsignw, (d), (s1), (s2))

#define	INSTR_CREATE_vpsignd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsignd, (d), (s1), (s2))

#define	INSTR_CREATE_vpmulhrsw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmulhrsw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmuldq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmuldq, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpeqq, (d), (s1), (s2))

#define	INSTR_CREATE_vpackusdw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpackusdw, (d), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpcmpgtq, (d), (s1), (s2))

#define	INSTR_CREATE_vpminsb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminsb, (d), (s1), (s2))

#define	INSTR_CREATE_vpminsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminsd, (d), (s1), (s2))

#define	INSTR_CREATE_vpminuw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminuw, (d), (s1), (s2))

#define	INSTR_CREATE_vpminud(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpminud, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxsb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxsb, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxsd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxsd, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxuw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxuw, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaxud(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmaxud, (d), (s1), (s2))

#define	INSTR_CREATE_vpmulld(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpmulld, (d), (s1), (s2))

#define	INSTR_CREATE_vaesenc(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaesenc, (d), (s1), (s2))

#define	INSTR_CREATE_vaesenclast(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaesenclast, (d), (s1), (s2))

#define	INSTR_CREATE_vaesdec(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaesdec, (d), (s1), (s2))

#define	INSTR_CREATE_vaesdeclast(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaesdeclast, (d), (s1), (s2))

#define	INSTR_CREATE_vpextrb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpextrb, (d), (s1), (s2))

#define	INSTR_CREATE_vpextrd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpextrd, (d), (s1), (s2))

#define	INSTR_CREATE_vextractps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vextractps, (d), (s1), (s2))

#define	INSTR_CREATE_vroundps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vroundps, (d), (s1), (s2))

#define	INSTR_CREATE_vroundpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vroundpd, (d), (s1), (s2))

#define	INSTR_CREATE_vaeskeygenassist(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vaeskeygenassist, (d), (s1), (s2))

#define	INSTR_CREATE_vmovss_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovss, (d), (s1), (s2))

#define	INSTR_CREATE_vmovsd_NDS(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vmovsd, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtps2ph(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtps2ph, (d), (s1), (s2))

#define	INSTR_CREATE_vmaskmovps(dc, d, s1, s2)

#define	INSTR_CREATE_vmaskmovpd(dc, d, s1, s2)

#define	INSTR_CREATE_vpermilps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermilps, (d), (s1), (s2))

#define	INSTR_CREATE_vpermilpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermilpd, (d), (s1), (s2))

#define	INSTR_CREATE_vextractf128(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vextractf128, (d), (s1), (s2))

#define	INSTR_CREATE_vprotb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vprotb, (d), (s1), (s2))

#define	INSTR_CREATE_vprotw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vprotw, (d), (s1), (s2))

#define	INSTR_CREATE_vprotd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vprotd, (d), (s1), (s2))

#define	INSTR_CREATE_vprotq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vprotq, (d), (s1), (s2))

#define	INSTR_CREATE_vpshlb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshlb, (d), (s1), (s2))

#define	INSTR_CREATE_vpshld(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshld, (d), (s1), (s2))

#define	INSTR_CREATE_vpshlq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshlq, (d), (s1), (s2))

#define	INSTR_CREATE_vpshlw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshlw, (d), (s1), (s2))

#define	INSTR_CREATE_vpshab(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshab, (d), (s1), (s2))

#define	INSTR_CREATE_vpshad(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshad, (d), (s1), (s2))

#define	INSTR_CREATE_vpshaq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshaq, (d), (s1), (s2))

#define	INSTR_CREATE_vpshaw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpshaw, (d), (s1), (s2))

#define	INSTR_CREATE_bextr(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_bextr, (d), (s1), (s2))

#define	INSTR_CREATE_andn(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_andn, (d), (s1), (s2))

#define	INSTR_CREATE_bzhi(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_bzhi, (d), (s1), (s2))

#define	INSTR_CREATE_pext(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_pext, (d), (s1), (s2))

#define	INSTR_CREATE_pdep(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_pdep, (d), (s1), (s2))

#define	INSTR_CREATE_sarx(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_sarx, (d), (s1), (s2))

#define	INSTR_CREATE_shlx(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_shlx, (d), (s1), (s2))

#define	INSTR_CREATE_shrx(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_shrx, (d), (s1), (s2))

#define	INSTR_CREATE_rorx(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_rorx, (d), (s1), (s2))

#define	INSTR_CREATE_vpermps(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermps, (d), (s1), (s2))

#define	INSTR_CREATE_vpermd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsravd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsravd, (d), (s1), (s2))

#define	INSTR_CREATE_vextracti128(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vextracti128, (d), (s1), (s2))

#define	INSTR_CREATE_vpermq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermq, (d), (s1), (s2))

#define	INSTR_CREATE_vpermpd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpermpd, (d), (s1), (s2))

#define	INSTR_CREATE_vpmaskmovd(dc, d, s1, s2)

#define	INSTR_CREATE_vpmaskmovq(dc, d, s1, s2)

#define	INSTR_CREATE_vpsllvd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsllvd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsllvq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsllvq, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrlvd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrlvd, (d), (s1), (s2))

#define	INSTR_CREATE_vpsrlvq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpsrlvq, (d), (s1), (s2))

#define	INSTR_CREATE_kandw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandw, (d), (s1), (s2))

#define	INSTR_CREATE_kandb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandb, (d), (s1), (s2))

#define	INSTR_CREATE_kandq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandq, (d), (s1), (s2))

#define	INSTR_CREATE_kandd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandd, (d), (s1), (s2))

#define	INSTR_CREATE_kandnw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandnw, (d), (s1), (s2))

#define	INSTR_CREATE_kandnb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandnb, (d), (s1), (s2))

#define	INSTR_CREATE_kandnq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandnq, (d), (s1), (s2))

#define	INSTR_CREATE_kandnd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kandnd, (d), (s1), (s2))

#define	INSTR_CREATE_kunpckbw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kunpckbw, (d), (s1), (s2))

#define	INSTR_CREATE_kunpckwd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kunpckwd, (d), (s1), (s2))

#define	INSTR_CREATE_kunpckdq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kunpckdq, (d), (s1), (s2))

#define	INSTR_CREATE_korw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_korw, (d), (s1), (s2))

#define	INSTR_CREATE_korb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_korb, (d), (s1), (s2))

#define	INSTR_CREATE_korq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_korq, (d), (s1), (s2))

#define	INSTR_CREATE_kord(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kord, (d), (s1), (s2))

#define	INSTR_CREATE_kxnorw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxnorw, (d), (s1), (s2))

#define	INSTR_CREATE_kxnorb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxnorb, (d), (s1), (s2))

#define	INSTR_CREATE_kxnorq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxnorq, (d), (s1), (s2))

#define	INSTR_CREATE_kxnord(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxnord, (d), (s1), (s2))

#define	INSTR_CREATE_kxorw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxorw, (d), (s1), (s2))

#define	INSTR_CREATE_kxorb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxorb, (d), (s1), (s2))

#define	INSTR_CREATE_kxorq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxorq, (d), (s1), (s2))

#define	INSTR_CREATE_kxord(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kxord, (d), (s1), (s2))

#define	INSTR_CREATE_kaddw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kaddw, (d), (s1), (s2))

#define	INSTR_CREATE_kaddb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kaddb, (d), (s1), (s2))

#define	INSTR_CREATE_kaddq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kaddq, (d), (s1), (s2))

#define	INSTR_CREATE_kaddd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kaddd, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftlw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftlw, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftlb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftlb, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftlq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftlq, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftld(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftld, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftrw(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftrw, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftrb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftrb, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftrq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftrq, (d), (s1), (s2))

#define	INSTR_CREATE_kshiftrd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_kshiftrd, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtusi2ss(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtusi2ss, (d), (s1), (s2))

#define	INSTR_CREATE_vcvtusi2sd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vcvtusi2sd, (d), (s1), (s2))

#define	INSTR_CREATE_vpextrq(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpextrq, (d), (s1), (s2))

#define	INSTR_CREATE_vpdpbusd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpdpbusd, (d), (s1), (s2))

#define	INSTR_CREATE_vpdpbusds(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpdpbusds, (d), (s1), (s2))

#define	INSTR_CREATE_vpdpwssd(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpdpwssd, (d), (s1), (s2))

#define	INSTR_CREATE_vpdpwssds(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vpdpwssds, (d), (s1), (s2))

#define	INSTR_CREATE_vgf2p8mulb(dc, d, s1, s2) instr_create_1dst_2src((dc), OP_vgf2p8mulb, (d), (s1), (s2))

1 destination, 1 mask, and 1 non-immediate source
#define	INSTR_CREATE_vmovups_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovups, (d), (k), (s))

#define	INSTR_CREATE_vmovupd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovupd, (d), (k), (s))

#define	INSTR_CREATE_vmovaps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovaps, (d), (k), (s))

#define	INSTR_CREATE_vmovapd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovapd, (d), (k), (s))

#define	INSTR_CREATE_vmovdqa32_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqa32, (d), (k), (s))

#define	INSTR_CREATE_vmovdqa64_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqa64, (d), (k), (s))

#define	INSTR_CREATE_vmovdqu8_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqu8, (d), (k), (s))

#define	INSTR_CREATE_vmovdqu16_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqu16, (d), (k), (s))

#define	INSTR_CREATE_vmovdqu32_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqu32, (d), (k), (s))

#define	INSTR_CREATE_vmovdqu64_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovdqu64, (d), (k), (s))

#define	INSTR_CREATE_vmovss_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovss, (d), (k), (s))

#define	INSTR_CREATE_vmovsd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovsd, (d), (k), (s))

#define	INSTR_CREATE_vmovsldup_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovsldup, (d), (k), (s))

#define	INSTR_CREATE_vmovddup_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovddup, (d), (k), (s))

#define	INSTR_CREATE_vmovshdup_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vmovshdup, (d), (k), (s))

#define	INSTR_CREATE_vcvtps2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtps2pd, (d), (k), (s))

#define	INSTR_CREATE_vcvtpd2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtpd2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvtdq2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtdq2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvttps2dq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttps2dq, (d), (k), (s))

#define	INSTR_CREATE_vcvtps2dq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtps2dq, (d), (k), (s))

#define	INSTR_CREATE_vcvtdq2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtdq2pd, (d), (k), (s))

#define	INSTR_CREATE_vcvttpd2dq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttpd2dq, (d), (k), (s))

#define	INSTR_CREATE_vcvtpd2dq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtpd2dq, (d), (k), (s))

#define	INSTR_CREATE_vcvtph2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtph2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvtpd2qq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtpd2qq, (d), (k), (s))

#define	INSTR_CREATE_vcvtps2udq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtps2udq, (d), (k), (s))

#define	INSTR_CREATE_vcvtpd2udq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtpd2udq, (d), (k), (s))

#define	INSTR_CREATE_vcvtps2uqq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtps2uqq, (d), (k), (s))

#define	INSTR_CREATE_vcvtpd2uqq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtpd2uqq, (d), (k), (s))

#define	INSTR_CREATE_vcvtps2qq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtps2qq, (d), (k), (s))

#define	INSTR_CREATE_vcvttps2udq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttps2udq, (d), (k), (s))

#define	INSTR_CREATE_vcvttpd2udq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttpd2udq, (d), (k), (s))

#define	INSTR_CREATE_vcvttps2qq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttps2qq, (d), (k), (s))

#define	INSTR_CREATE_vcvttpd2qq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttpd2qq, (d), (k), (s))

#define	INSTR_CREATE_vcvttps2uqq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttps2uqq, (d), (k), (s))

#define	INSTR_CREATE_vcvttpd2uqq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvttpd2uqq, (d), (k), (s))

#define	INSTR_CREATE_vcvtqq2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtqq2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvtqq2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtqq2pd, (d), (k), (s))

#define	INSTR_CREATE_vcvtudq2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtudq2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvtudq2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtudq2pd, (d), (k), (s))

#define	INSTR_CREATE_vcvtuqq2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtuqq2ps, (d), (k), (s))

#define	INSTR_CREATE_vcvtuqq2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtuqq2pd, (d), (k), (s))

#define	INSTR_CREATE_vrcp14ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrcp14ps, (d), (k), (s))

#define	INSTR_CREATE_vrcp14pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrcp14pd, (d), (k), (s))

#define	INSTR_CREATE_vrcp28ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrcp28ps, (d), (k), (s))

#define	INSTR_CREATE_vrcp28pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrcp28pd, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxbw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxbw, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxbd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxbd, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxbq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxbq, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxwd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxwd, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxwq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxwq, (d), (k), (s))

#define	INSTR_CREATE_vpmovsxdq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsxdq, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxbw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxbw, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxbd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxbd, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxbq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxbq, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxwd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxwd, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxwq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxwq, (d), (k), (s))

#define	INSTR_CREATE_vpmovzxdq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovzxdq, (d), (k), (s))

#define	INSTR_CREATE_vpmovqb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovqb, (d), (k), (s))

#define	INSTR_CREATE_vpmovsqb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsqb, (d), (k), (s))

#define	INSTR_CREATE_vpmovusqb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovusqb, (d), (k), (s))

#define	INSTR_CREATE_vpmovqw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovqw, (d), (k), (s))

#define	INSTR_CREATE_vpmovsqw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsqw, (d), (k), (s))

#define	INSTR_CREATE_vpmovusqw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovusqw, (d), (k), (s))

#define	INSTR_CREATE_vpmovqd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovqd, (d), (k), (s))

#define	INSTR_CREATE_vpmovsqd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsqd, (d), (k), (s))

#define	INSTR_CREATE_vpmovusqd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovusqd, (d), (k), (s))

#define	INSTR_CREATE_vpmovdb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovdb, (d), (k), (s))

#define	INSTR_CREATE_vpmovsdb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsdb, (d), (k), (s))

#define	INSTR_CREATE_vpmovusdb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovusdb, (d), (k), (s))

#define	INSTR_CREATE_vpmovdw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovdw, (d), (k), (s))

#define	INSTR_CREATE_vpmovsdw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovsdw, (d), (k), (s))

#define	INSTR_CREATE_vpmovusdw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovusdw, (d), (k), (s))

#define	INSTR_CREATE_vpmovwb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovwb, (d), (k), (s))

#define	INSTR_CREATE_vpmovswb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovswb, (d), (k), (s))

#define	INSTR_CREATE_vpmovuswb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovuswb, (d), (k), (s))

#define	INSTR_CREATE_vpmovm2b_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovm2b, (d), (k), (s))

#define	INSTR_CREATE_vpmovm2w_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovm2w, (d), (k), (s))

#define	INSTR_CREATE_vpmovm2d_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovm2d, (d), (k), (s))

#define	INSTR_CREATE_vpmovm2q_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpmovm2q, (d), (k), (s))

#define	INSTR_CREATE_vpabsb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpabsb, (d), (k), (s))

#define	INSTR_CREATE_vpabsw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpabsw, (d), (k), (s))

#define	INSTR_CREATE_vpabsd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpabsd, (d), (k), (s))

#define	INSTR_CREATE_vpabsq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpabsq, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastss_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastss, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastsd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastsd, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastf32x2_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastf32x2, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastf32x4_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastf32x4, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastf64x2_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastf64x2, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastf32x8_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastf32x8, (d), (k), (s))

#define	INSTR_CREATE_vbroadcastf64x4_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcastf64x4, (d), (k), (s))

#define	INSTR_CREATE_vpbroadcastb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpbroadcastb, (d), (k), (s))

#define	INSTR_CREATE_vpbroadcastw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpbroadcastw, (d), (k), (s))

#define	INSTR_CREATE_vpbroadcastd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpbroadcastd, (d), (k), (s))

#define	INSTR_CREATE_vpbroadcastq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpbroadcastq, (d), (k), (s))

#define	INSTR_CREATE_vbroadcasti32x2_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcasti32x2, (d), (k), (s))

#define	INSTR_CREATE_vbroadcasti32x4_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcasti32x4, (d), (k), (s))

#define	INSTR_CREATE_vbroadcasti64x2_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcasti64x2, (d), (k), (s))

#define	INSTR_CREATE_vbroadcasti32x8_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcasti32x8, (d), (k), (s))

#define	INSTR_CREATE_vbroadcasti64x4_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vbroadcasti64x4, (d), (k), (s))

#define	INSTR_CREATE_vcompressps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcompressps, (d), (k), (s))

#define	INSTR_CREATE_vcompresspd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcompresspd, (d), (k), (s))

#define	INSTR_CREATE_vexpandps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vexpandps, (d), (k), (s))

#define	INSTR_CREATE_vexpandpd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vexpandpd, (d), (k), (s))

#define	INSTR_CREATE_vgetexpps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vgetexpps, (d), (k), (s))

#define	INSTR_CREATE_vgetexppd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vgetexppd, (d), (k), (s))

#define	INSTR_CREATE_vpcompressd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpcompressd, (d), (k), (s))

#define	INSTR_CREATE_vpcompressq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpcompressq, (d), (k), (s))

#define	INSTR_CREATE_vpexpandd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpexpandd, (d), (k), (s))

#define	INSTR_CREATE_vpexpandq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpexpandq, (d), (k), (s))

#define	INSTR_CREATE_vrsqrt14ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrsqrt14ps, (d), (k), (s))

#define	INSTR_CREATE_vrsqrt14pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrsqrt14pd, (d), (k), (s))

#define	INSTR_CREATE_vrsqrt28ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrsqrt28ps, (d), (k), (s))

#define	INSTR_CREATE_vrsqrt28pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vrsqrt28pd, (d), (k), (s))

#define	INSTR_CREATE_vexp2ps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vexp2ps, (d), (k), (s))

#define	INSTR_CREATE_vexp2pd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vexp2pd, (d), (k), (s))

#define	INSTR_CREATE_vpconflictd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpconflictd, (d), (k), (s))

#define	INSTR_CREATE_vpconflictq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpconflictq, (d), (k), (s))

#define	INSTR_CREATE_vplzcntd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vplzcntd, (d), (k), (s))

#define	INSTR_CREATE_vplzcntq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vplzcntq, (d), (k), (s))

#define	INSTR_CREATE_vsqrtps_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vsqrtps, (d), (k), (s))

#define	INSTR_CREATE_vsqrtpd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vsqrtpd, (d), (k), (s))

#define	INSTR_CREATE_vcvtneps2bf16_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vcvtneps2bf16, (d), (k), (s))

#define	INSTR_CREATE_vpopcntd_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpopcntd, (d), (k), (s))

#define	INSTR_CREATE_vpopcntq_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpopcntq, (d), (k), (s))

#define	INSTR_CREATE_vpopcntb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpopcntb, (d), (k), (s))

#define	INSTR_CREATE_vpopcntw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpopcntw, (d), (k), (s))

#define	INSTR_CREATE_vpcompressb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpcompressb, (d), (k), (s))

#define	INSTR_CREATE_vpcompressw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpcompressw, (d), (k), (s))

#define	INSTR_CREATE_vpexpandb_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpexpandb, (d), (k), (s))

#define	INSTR_CREATE_vpexpandw_mask(dc, d, k, s) instr_create_1dst_2src((dc), OP_vpexpandw, (d), (k), (s))

1 destination, 2 sources: 1 explicit, 1 implicit
#define	INSTR_CREATE_add(dc, d, s) instr_create_1dst_2src((dc), OP_add, (d), (s), (d))

#define	INSTR_CREATE_or(dc, d, s) instr_create_1dst_2src((dc), OP_or, (d), (s), (d))

#define	INSTR_CREATE_adc(dc, d, s) instr_create_1dst_2src((dc), OP_adc, (d), (s), (d))

#define	INSTR_CREATE_sbb(dc, d, s) instr_create_1dst_2src((dc), OP_sbb, (d), (s), (d))

#define	INSTR_CREATE_and(dc, d, s) instr_create_1dst_2src((dc), OP_and, (d), (s), (d))

#define	INSTR_CREATE_sub(dc, d, s) instr_create_1dst_2src((dc), OP_sub, (d), (s), (d))

#define	INSTR_CREATE_xor(dc, d, s) instr_create_1dst_2src((dc), OP_xor, (d), (s), (d))

#define	INSTR_CREATE_punpcklbw(dc, d, s) instr_create_1dst_2src((dc), OP_punpcklbw, (d), (s), (d))

#define	INSTR_CREATE_punpcklwd(dc, d, s) instr_create_1dst_2src((dc), OP_punpcklwd, (d), (s), (d))

#define	INSTR_CREATE_punpckldq(dc, d, s) instr_create_1dst_2src((dc), OP_punpckldq, (d), (s), (d))

#define	INSTR_CREATE_packsswb(dc, d, s) instr_create_1dst_2src((dc), OP_packsswb, (d), (s), (d))

#define	INSTR_CREATE_pcmpgtb(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpgtb, (d), (s), (d))

#define	INSTR_CREATE_pcmpgtw(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpgtw, (d), (s), (d))

#define	INSTR_CREATE_pcmpgtd(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpgtd, (d), (s), (d))

#define	INSTR_CREATE_packuswb(dc, d, s) instr_create_1dst_2src((dc), OP_packuswb, (d), (s), (d))

#define	INSTR_CREATE_punpckhbw(dc, d, s) instr_create_1dst_2src((dc), OP_punpckhbw, (d), (s), (d))

#define	INSTR_CREATE_punpckhwd(dc, d, s) instr_create_1dst_2src((dc), OP_punpckhwd, (d), (s), (d))

#define	INSTR_CREATE_punpckhdq(dc, d, s) instr_create_1dst_2src((dc), OP_punpckhdq, (d), (s), (d))

#define	INSTR_CREATE_packssdw(dc, d, s) instr_create_1dst_2src((dc), OP_packssdw, (d), (s), (d))

#define	INSTR_CREATE_punpcklqdq(dc, d, s) instr_create_1dst_2src((dc), OP_punpcklqdq, (d), (s), (d))

#define	INSTR_CREATE_punpckhqdq(dc, d, s) instr_create_1dst_2src((dc), OP_punpckhqdq, (d), (s), (d))

#define	INSTR_CREATE_pcmpeqb(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpeqb, (d), (s), (d))

#define	INSTR_CREATE_pcmpeqw(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpeqw, (d), (s), (d))

#define	INSTR_CREATE_pcmpeqd(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpeqd, (d), (s), (d))

#define	INSTR_CREATE_psrlw(dc, d, s) instr_create_1dst_2src((dc), OP_psrlw, (d), (s), (d))

#define	INSTR_CREATE_psrld(dc, d, s) instr_create_1dst_2src((dc), OP_psrld, (d), (s), (d))

#define	INSTR_CREATE_psrlq(dc, d, s) instr_create_1dst_2src((dc), OP_psrlq, (d), (s), (d))

#define	INSTR_CREATE_paddq(dc, d, s) instr_create_1dst_2src((dc), OP_paddq, (d), (s), (d))

#define	INSTR_CREATE_pmullw(dc, d, s) instr_create_1dst_2src((dc), OP_pmullw, (d), (s), (d))

#define	INSTR_CREATE_psubusb(dc, d, s) instr_create_1dst_2src((dc), OP_psubusb, (d), (s), (d))

#define	INSTR_CREATE_psubusw(dc, d, s) instr_create_1dst_2src((dc), OP_psubusw, (d), (s), (d))

#define	INSTR_CREATE_pminub(dc, d, s) instr_create_1dst_2src((dc), OP_pminub, (d), (s), (d))

#define	INSTR_CREATE_pand(dc, d, s) instr_create_1dst_2src((dc), OP_pand, (d), (s), (d))

#define	INSTR_CREATE_paddusb(dc, d, s) instr_create_1dst_2src((dc), OP_paddusb, (d), (s), (d))

#define	INSTR_CREATE_paddusw(dc, d, s) instr_create_1dst_2src((dc), OP_paddusw, (d), (s), (d))

#define	INSTR_CREATE_pmaxub(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxub, (d), (s), (d))

#define	INSTR_CREATE_pandn(dc, d, s) instr_create_1dst_2src((dc), OP_pandn, (d), (s), (d))

#define	INSTR_CREATE_pavgb(dc, d, s) instr_create_1dst_2src((dc), OP_pavgb, (d), (s), (d))

#define	INSTR_CREATE_psraw(dc, d, s) instr_create_1dst_2src((dc), OP_psraw, (d), (s), (d))

#define	INSTR_CREATE_psrad(dc, d, s) instr_create_1dst_2src((dc), OP_psrad, (d), (s), (d))

#define	INSTR_CREATE_pavgw(dc, d, s) instr_create_1dst_2src((dc), OP_pavgw, (d), (s), (d))

#define	INSTR_CREATE_pmulhuw(dc, d, s) instr_create_1dst_2src((dc), OP_pmulhuw, (d), (s), (d))

#define	INSTR_CREATE_pmulhw(dc, d, s) instr_create_1dst_2src((dc), OP_pmulhw, (d), (s), (d))

#define	INSTR_CREATE_psubsb(dc, d, s) instr_create_1dst_2src((dc), OP_psubsb, (d), (s), (d))

#define	INSTR_CREATE_psubsw(dc, d, s) instr_create_1dst_2src((dc), OP_psubsw, (d), (s), (d))

#define	INSTR_CREATE_pminsw(dc, d, s) instr_create_1dst_2src((dc), OP_pminsw, (d), (s), (d))

#define	INSTR_CREATE_por(dc, d, s) instr_create_1dst_2src((dc), OP_por, (d), (s), (d))

#define	INSTR_CREATE_paddsb(dc, d, s) instr_create_1dst_2src((dc), OP_paddsb, (d), (s), (d))

#define	INSTR_CREATE_paddsw(dc, d, s) instr_create_1dst_2src((dc), OP_paddsw, (d), (s), (d))

#define	INSTR_CREATE_pmaxsw(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxsw, (d), (s), (d))

#define	INSTR_CREATE_pxor(dc, d, s) instr_create_1dst_2src((dc), OP_pxor, (d), (s), (d))

#define	INSTR_CREATE_psllw(dc, d, s) instr_create_1dst_2src((dc), OP_psllw, (d), (s), (d))

#define	INSTR_CREATE_pslld(dc, d, s) instr_create_1dst_2src((dc), OP_pslld, (d), (s), (d))

#define	INSTR_CREATE_psllq(dc, d, s) instr_create_1dst_2src((dc), OP_psllq, (d), (s), (d))

#define	INSTR_CREATE_pmuludq(dc, d, s) instr_create_1dst_2src((dc), OP_pmuludq, (d), (s), (d))

#define	INSTR_CREATE_pmaddwd(dc, d, s) instr_create_1dst_2src((dc), OP_pmaddwd, (d), (s), (d))

#define	INSTR_CREATE_psadbw(dc, d, s) instr_create_1dst_2src((dc), OP_psadbw, (d), (s), (d))

#define	INSTR_CREATE_psubb(dc, d, s) instr_create_1dst_2src((dc), OP_psubb, (d), (s), (d))

#define	INSTR_CREATE_psubw(dc, d, s) instr_create_1dst_2src((dc), OP_psubw, (d), (s), (d))

#define	INSTR_CREATE_psubd(dc, d, s) instr_create_1dst_2src((dc), OP_psubd, (d), (s), (d))

#define	INSTR_CREATE_psubq(dc, d, s) instr_create_1dst_2src((dc), OP_psubq, (d), (s), (d))

#define	INSTR_CREATE_paddb(dc, d, s) instr_create_1dst_2src((dc), OP_paddb, (d), (s), (d))

#define	INSTR_CREATE_paddw(dc, d, s) instr_create_1dst_2src((dc), OP_paddw, (d), (s), (d))

#define	INSTR_CREATE_paddd(dc, d, s) instr_create_1dst_2src((dc), OP_paddd, (d), (s), (d))

#define	INSTR_CREATE_psrldq(dc, d, s) instr_create_1dst_2src((dc), OP_psrldq, (d), (s), (d))

#define	INSTR_CREATE_pslldq(dc, d, s) instr_create_1dst_2src((dc), OP_pslldq, (d), (s), (d))

#define	INSTR_CREATE_unpcklps(dc, d, s) instr_create_1dst_2src((dc), OP_unpcklps, (d), (s), (d))

#define	INSTR_CREATE_unpcklpd(dc, d, s) instr_create_1dst_2src((dc), OP_unpcklpd, (d), (s), (d))

#define	INSTR_CREATE_unpckhps(dc, d, s) instr_create_1dst_2src((dc), OP_unpckhps, (d), (s), (d))

#define	INSTR_CREATE_unpckhpd(dc, d, s) instr_create_1dst_2src((dc), OP_unpckhpd, (d), (s), (d))

#define	INSTR_CREATE_andps(dc, d, s) instr_create_1dst_2src((dc), OP_andps, (d), (s), (d))

#define	INSTR_CREATE_andpd(dc, d, s) instr_create_1dst_2src((dc), OP_andpd, (d), (s), (d))

#define	INSTR_CREATE_andnps(dc, d, s) instr_create_1dst_2src((dc), OP_andnps, (d), (s), (d))

#define	INSTR_CREATE_andnpd(dc, d, s) instr_create_1dst_2src((dc), OP_andnpd, (d), (s), (d))

#define	INSTR_CREATE_orps(dc, d, s) instr_create_1dst_2src((dc), OP_orps, (d), (s), (d))

#define	INSTR_CREATE_orpd(dc, d, s) instr_create_1dst_2src((dc), OP_orpd, (d), (s), (d))

#define	INSTR_CREATE_xorps(dc, d, s) instr_create_1dst_2src((dc), OP_xorps, (d), (s), (d))

#define	INSTR_CREATE_xorpd(dc, d, s) instr_create_1dst_2src((dc), OP_xorpd, (d), (s), (d))

#define	INSTR_CREATE_addps(dc, d, s) instr_create_1dst_2src((dc), OP_addps, (d), (s), (d))

#define	INSTR_CREATE_addss(dc, d, s) instr_create_1dst_2src((dc), OP_addss, (d), (s), (d))

#define	INSTR_CREATE_addpd(dc, d, s) instr_create_1dst_2src((dc), OP_addpd, (d), (s), (d))

#define	INSTR_CREATE_addsd(dc, d, s) instr_create_1dst_2src((dc), OP_addsd, (d), (s), (d))

#define	INSTR_CREATE_mulps(dc, d, s) instr_create_1dst_2src((dc), OP_mulps, (d), (s), (d))

#define	INSTR_CREATE_mulss(dc, d, s) instr_create_1dst_2src((dc), OP_mulss, (d), (s), (d))

#define	INSTR_CREATE_mulpd(dc, d, s) instr_create_1dst_2src((dc), OP_mulpd, (d), (s), (d))

#define	INSTR_CREATE_mulsd(dc, d, s) instr_create_1dst_2src((dc), OP_mulsd, (d), (s), (d))

#define	INSTR_CREATE_subps(dc, d, s) instr_create_1dst_2src((dc), OP_subps, (d), (s), (d))

#define	INSTR_CREATE_subss(dc, d, s) instr_create_1dst_2src((dc), OP_subss, (d), (s), (d))

#define	INSTR_CREATE_subpd(dc, d, s) instr_create_1dst_2src((dc), OP_subpd, (d), (s), (d))

#define	INSTR_CREATE_subsd(dc, d, s) instr_create_1dst_2src((dc), OP_subsd, (d), (s), (d))

#define	INSTR_CREATE_minps(dc, d, s) instr_create_1dst_2src((dc), OP_minps, (d), (s), (d))

#define	INSTR_CREATE_minss(dc, d, s) instr_create_1dst_2src((dc), OP_minss, (d), (s), (d))

#define	INSTR_CREATE_minpd(dc, d, s) instr_create_1dst_2src((dc), OP_minpd, (d), (s), (d))

#define	INSTR_CREATE_minsd(dc, d, s) instr_create_1dst_2src((dc), OP_minsd, (d), (s), (d))

#define	INSTR_CREATE_divps(dc, d, s) instr_create_1dst_2src((dc), OP_divps, (d), (s), (d))

#define	INSTR_CREATE_divss(dc, d, s) instr_create_1dst_2src((dc), OP_divss, (d), (s), (d))

#define	INSTR_CREATE_divpd(dc, d, s) instr_create_1dst_2src((dc), OP_divpd, (d), (s), (d))

#define	INSTR_CREATE_divsd(dc, d, s) instr_create_1dst_2src((dc), OP_divsd, (d), (s), (d))

#define	INSTR_CREATE_maxps(dc, d, s) instr_create_1dst_2src((dc), OP_maxps, (d), (s), (d))

#define	INSTR_CREATE_maxss(dc, d, s) instr_create_1dst_2src((dc), OP_maxss, (d), (s), (d))

#define	INSTR_CREATE_maxpd(dc, d, s) instr_create_1dst_2src((dc), OP_maxpd, (d), (s), (d))

#define	INSTR_CREATE_maxsd(dc, d, s) instr_create_1dst_2src((dc), OP_maxsd, (d), (s), (d))

#define	INSTR_CREATE_haddpd(dc, d, s) instr_create_1dst_2src((dc), OP_haddpd, (d), (s), (d))

#define	INSTR_CREATE_haddps(dc, d, s) instr_create_1dst_2src((dc), OP_haddps, (d), (s), (d))

#define	INSTR_CREATE_hsubpd(dc, d, s) instr_create_1dst_2src((dc), OP_hsubpd, (d), (s), (d))

#define	INSTR_CREATE_hsubps(dc, d, s) instr_create_1dst_2src((dc), OP_hsubps, (d), (s), (d))

#define	INSTR_CREATE_addsubpd(dc, d, s) instr_create_1dst_2src((dc), OP_addsubpd, (d), (s), (d))

#define	INSTR_CREATE_addsubps(dc, d, s) instr_create_1dst_2src((dc), OP_addsubps, (d), (s), (d))

#define	INSTR_CREATE_pavgusb(dc, d, s) instr_create_1dst_2src((dc), OP_pavgusb, (d), (s), (d))

#define	INSTR_CREATE_pfadd(dc, d, s) instr_create_1dst_2src((dc), OP_pfadd, (d), (s), (d))

#define	INSTR_CREATE_pfacc(dc, d, s) instr_create_1dst_2src((dc), OP_pfacc, (d), (s), (d))

#define	INSTR_CREATE_pfcmpge(dc, d, s) instr_create_1dst_2src((dc), OP_pfcmpge, (d), (s), (d))

#define	INSTR_CREATE_pfcmpgt(dc, d, s) instr_create_1dst_2src((dc), OP_pfcmpgt, (d), (s), (d))

#define	INSTR_CREATE_pfcmpeq(dc, d, s) instr_create_1dst_2src((dc), OP_pfcmpeq, (d), (s), (d))

#define	INSTR_CREATE_pfmin(dc, d, s) instr_create_1dst_2src((dc), OP_pfmin, (d), (s), (d))

#define	INSTR_CREATE_pfmax(dc, d, s) instr_create_1dst_2src((dc), OP_pfmax, (d), (s), (d))

#define	INSTR_CREATE_pfmul(dc, d, s) instr_create_1dst_2src((dc), OP_pfmul, (d), (s), (d))

#define	INSTR_CREATE_pfrcp(dc, d, s) instr_create_1dst_2src((dc), OP_pfrcp, (d), (s), (d))

#define	INSTR_CREATE_pfrcpit1(dc, d, s) instr_create_1dst_2src((dc), OP_pfrcpit1, (d), (s), (d))

#define	INSTR_CREATE_pfrcpit2(dc, d, s) instr_create_1dst_2src((dc), OP_pfrcpit2, (d), (s), (d))

#define	INSTR_CREATE_pfrsqrt(dc, d, s) instr_create_1dst_2src((dc), OP_pfrsqrt, (d), (s), (d))

#define	INSTR_CREATE_pfrsqit1(dc, d, s) instr_create_1dst_2src((dc), OP_pfrsqit1, (d), (s), (d))

#define	INSTR_CREATE_pmulhrw(dc, d, s) instr_create_1dst_2src((dc), OP_pmulhrw, (d), (s), (d))

#define	INSTR_CREATE_pfsub(dc, d, s) instr_create_1dst_2src((dc), OP_pfsub, (d), (s), (d))

#define	INSTR_CREATE_pfsubr(dc, d, s) instr_create_1dst_2src((dc), OP_pfsubr, (d), (s), (d))

#define	INSTR_CREATE_pi2fd(dc, d, s) instr_create_1dst_2src((dc), OP_pi2fd, (d), (s), (d))

#define	INSTR_CREATE_pf2id(dc, d, s) instr_create_1dst_2src((dc), OP_pf2id, (d), (s), (d))

#define	INSTR_CREATE_pi2fw(dc, d, s) instr_create_1dst_2src((dc), OP_pi2fw, (d), (s), (d))

#define	INSTR_CREATE_pf2iw(dc, d, s) instr_create_1dst_2src((dc), OP_pf2iw, (d), (s), (d))

#define	INSTR_CREATE_pfnacc(dc, d, s) instr_create_1dst_2src((dc), OP_pfnacc, (d), (s), (d))

#define	INSTR_CREATE_pfpnacc(dc, d, s) instr_create_1dst_2src((dc), OP_pfpnacc, (d), (s), (d))

#define	INSTR_CREATE_pswapd(dc, d, s) instr_create_1dst_2src((dc), OP_pswapd, (d), (s), (d))

#define	INSTR_CREATE_phaddw(dc, d, s) instr_create_1dst_2src((dc), OP_phaddw, (d), (s), (d))

#define	INSTR_CREATE_phaddd(dc, d, s) instr_create_1dst_2src((dc), OP_phaddd, (d), (s), (d))

#define	INSTR_CREATE_phaddsw(dc, d, s) instr_create_1dst_2src((dc), OP_phaddsw, (d), (s), (d))

#define	INSTR_CREATE_pmaddubsw(dc, d, s) instr_create_1dst_2src((dc), OP_pmaddubsw, (d), (s), (d))

#define	INSTR_CREATE_phsubw(dc, d, s) instr_create_1dst_2src((dc), OP_phsubw, (d), (s), (d))

#define	INSTR_CREATE_phsubd(dc, d, s) instr_create_1dst_2src((dc), OP_phsubd, (d), (s), (d))

#define	INSTR_CREATE_phsubsw(dc, d, s) instr_create_1dst_2src((dc), OP_phsubsw, (d), (s), (d))

#define	INSTR_CREATE_psignb(dc, d, s) instr_create_1dst_2src((dc), OP_psignb, (d), (s), (d))

#define	INSTR_CREATE_psignw(dc, d, s) instr_create_1dst_2src((dc), OP_psignw, (d), (s), (d))

#define	INSTR_CREATE_psignd(dc, d, s) instr_create_1dst_2src((dc), OP_psignd, (d), (s), (d))

#define	INSTR_CREATE_pmulhrsw(dc, d, s) instr_create_1dst_2src((dc), OP_pmulhrsw, (d), (s), (d))

#define	INSTR_CREATE_pshufb(dc, d, s) instr_create_1dst_2src((dc), OP_pshufb, (d), (s), (d))

#define	INSTR_CREATE_crc32(dc, d, s) instr_create_1dst_2src((dc), OP_crc32, (d), (s), (d))

#define	INSTR_CREATE_packusdw(dc, d, s) instr_create_1dst_2src((dc), OP_packusdw, (d), (s), (d))

#define	INSTR_CREATE_pcmpeqq(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpeqq, (d), (s), (d))

#define	INSTR_CREATE_pcmpgtq(dc, d, s) instr_create_1dst_2src((dc), OP_pcmpgtq, (d), (s), (d))

#define	INSTR_CREATE_pminsb(dc, d, s) instr_create_1dst_2src((dc), OP_pminsb, (d), (s), (d))

#define	INSTR_CREATE_pminsd(dc, d, s) instr_create_1dst_2src((dc), OP_pminsd, (d), (s), (d))

#define	INSTR_CREATE_pminuw(dc, d, s) instr_create_1dst_2src((dc), OP_pminuw, (d), (s), (d))

#define	INSTR_CREATE_pminud(dc, d, s) instr_create_1dst_2src((dc), OP_pminud, (d), (s), (d))

#define	INSTR_CREATE_pmaxsb(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxsb, (d), (s), (d))

#define	INSTR_CREATE_pmaxsd(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxsd, (d), (s), (d))

#define	INSTR_CREATE_pmaxuw(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxuw, (d), (s), (d))

#define	INSTR_CREATE_pmaxud(dc, d, s) instr_create_1dst_2src((dc), OP_pmaxud, (d), (s), (d))

#define	INSTR_CREATE_pmuldq(dc, d, s) instr_create_1dst_2src((dc), OP_pmuldq, (d), (s), (d))

#define	INSTR_CREATE_pmulld(dc, d, s) instr_create_1dst_2src((dc), OP_pmulld, (d), (s), (d))

#define	INSTR_CREATE_aesenc(dc, d, s) instr_create_1dst_2src((dc), OP_aesenc, (d), (s), (d))

#define	INSTR_CREATE_aesenclast(dc, d, s) instr_create_1dst_2src((dc), OP_aesenclast, (d), (s), (d))

#define	INSTR_CREATE_aesdec(dc, d, s) instr_create_1dst_2src((dc), OP_aesdec, (d), (s), (d))

#define	INSTR_CREATE_aesdeclast(dc, d, s) instr_create_1dst_2src((dc), OP_aesdeclast, (d), (s), (d))

#define	INSTR_CREATE_adox(dc, d, s) instr_create_1dst_2src((dc), OP_adox, (d), (s), (d))

#define	INSTR_CREATE_adcx(dc, d, s) instr_create_1dst_2src((dc), OP_adcx, (d), (s), (d))

#define	INSTR_CREATE_sha1msg1(dc, d, s) instr_create_1dst_2src((dc), OP_sha1msg1, (d), (s), (d))

#define	INSTR_CREATE_sha1msg2(dc, d, s) instr_create_1dst_2src((dc), OP_sha1msg2, (d), (s), (d))

#define	INSTR_CREATE_sha1nexte(dc, d, s) instr_create_1dst_2src((dc), OP_sha1nexte, (d), (s), (d))

#define	INSTR_CREATE_sha256msg1(dc, d, s) instr_create_1dst_2src((dc), OP_sha256msg1, (d), (s), (d))

#define	INSTR_CREATE_sha256msg2(dc, d, s) instr_create_1dst_2src((dc), OP_sha256msg2, (d), (s), (d))

#define	INSTR_CREATE_gf2p8mulb(dc, d, s) instr_create_1dst_2src((dc), OP_gf2p8mulb, (d), (s), (d))

1 destination, 1 explicit register-or-immediate source
#define	INSTR_CREATE_bts(dc, d, ri) instr_create_1dst_2src((dc), OP_bts, (d), (ri), (d))

#define	INSTR_CREATE_btr(dc, d, ri) instr_create_1dst_2src((dc), OP_btr, (d), (ri), (d))

#define	INSTR_CREATE_btc(dc, d, ri) instr_create_1dst_2src((dc), OP_btc, (d), (ri), (d))

1 implicit destination, 1 explicit source
#define	INSTR_CREATE_imul_1(dc, s)

#define	INSTR_CREATE_imul_4(dc, s)

#define	INSTR_CREATE_mul_1(dc, s)

#define	INSTR_CREATE_mul_4(dc, s)

#define	INSTR_CREATE_div_1(dc, s)

#define	INSTR_CREATE_div_4(dc, s)

#define	INSTR_CREATE_idiv_1(dc, s)

#define	INSTR_CREATE_idiv_4(dc, s)

1 destination, 1 explicit source that is cl, an immediate, or a constant
#define	INSTR_CREATE_rol(dc, d, ri) instr_create_1dst_2src((dc), OP_rol, (d), (ri), (d))

#define	INSTR_CREATE_ror(dc, d, ri) instr_create_1dst_2src((dc), OP_ror, (d), (ri), (d))

#define	INSTR_CREATE_rcl(dc, d, ri) instr_create_1dst_2src((dc), OP_rcl, (d), (ri), (d))

#define	INSTR_CREATE_rcr(dc, d, ri) instr_create_1dst_2src((dc), OP_rcr, (d), (ri), (d))

#define	INSTR_CREATE_shl(dc, d, ri) instr_create_1dst_2src((dc), OP_shl, (d), (ri), (d))

#define	INSTR_CREATE_shr(dc, d, ri) instr_create_1dst_2src((dc), OP_shr, (d), (ri), (d))

#define	INSTR_CREATE_sar(dc, d, ri) instr_create_1dst_2src((dc), OP_sar, (d), (ri), (d))

1 implicit destination, 2 explicit sources
#define	INSTR_CREATE_maskmovq(dc, s1, s2)

#define	INSTR_CREATE_maskmovdqu(dc, s1, s2)

#define	INSTR_CREATE_vmaskmovdqu(dc, s1, s2)

Floating-point with explicit destination and explicit mem-or-fp-reg source
#define	INSTR_CREATE_fadd(dc, f, s) instr_create_1dst_2src((dc), OP_fadd, (f), (s), (f))

#define	INSTR_CREATE_fmul(dc, f, s) instr_create_1dst_2src((dc), OP_fmul, (f), (s), (f))

#define	INSTR_CREATE_fdiv(dc, f, s) instr_create_1dst_2src((dc), OP_fdiv, (f), (s), (f))

#define	INSTR_CREATE_fdivr(dc, f, s) instr_create_1dst_2src((dc), OP_fdivr, (f), (s), (f))

#define	INSTR_CREATE_fsub(dc, f, s) instr_create_1dst_2src((dc), OP_fsub, (f), (s), (f))

#define	INSTR_CREATE_fsubr(dc, f, s) instr_create_1dst_2src((dc), OP_fsubr, (f), (s), (f))

Floating-point with explicit destination and implicit source
#define	INSTR_CREATE_faddp(dc, f) instr_create_1dst_2src((dc), OP_faddp, (f), opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fmulp(dc, f) instr_create_1dst_2src((dc), OP_fmulp, (f), opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fdivp(dc, f) instr_create_1dst_2src((dc), OP_fdivp, (f), opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fdivrp(dc, f) instr_create_1dst_2src((dc), OP_fdivrp, (f), opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fsubp(dc, f) instr_create_1dst_2src((dc), OP_fsubp, (f), opnd_create_reg(DR_REG_ST0), (f))

#define	INSTR_CREATE_fsubrp(dc, f) instr_create_1dst_2src((dc), OP_fsubrp, (f), opnd_create_reg(DR_REG_ST0), (f))

Floating-point with implicit destination and explicit memory source
#define	INSTR_CREATE_fiadd(dc, m)

#define	INSTR_CREATE_fimul(dc, m)

#define	INSTR_CREATE_fidiv(dc, m)

#define	INSTR_CREATE_fidivr(dc, m)

#define	INSTR_CREATE_fisub(dc, m)

#define	INSTR_CREATE_fisubr(dc, m)

#define	INSTR_CREATE_ficom(dc, m)

#define	INSTR_CREATE_ficomp(dc, m)

1 destination, 2 implicit sources
#define	INSTR_CREATE_xsave32(dc, d)

#define	INSTR_CREATE_xsaves32(dc, d)

#define	INSTR_CREATE_xsave64(dc, d)

#define	INSTR_CREATE_xsaves64(dc, d)

#define	INSTR_CREATE_xsaveopt32(dc, d)

#define	INSTR_CREATE_xsaveopt64(dc, d)

#define	INSTR_CREATE_xsavec32(dc, d)

#define	INSTR_CREATE_xsavec64(dc, d)

1 implicit destination, 2 sources: 1 explicit, 1 implicit
#define	INSTR_CREATE_aam(dc, i)

#define	INSTR_CREATE_aad(dc, i)

Loop instructions
#define	INSTR_CREATE_loopne(dc, t)

#define	INSTR_CREATE_loope(dc, t)

#define	INSTR_CREATE_loop(dc, t)

1 implicit destination, 2 implicit sources
#define	INSTR_CREATE_popf(dc)

#define	INSTR_CREATE_ret(dc)

#define	INSTR_CREATE_ret_far(dc)

#define	INSTR_CREATE_iret(dc)

1 destination, 3 non-immediate sources
#define	INSTR_CREATE_vpblendvb(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpblendvb, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vblendvps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vblendvps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vblendvpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vblendvpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vinserti128(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vinserti128, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpblendd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpblendd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vperm2i128(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vperm2i128, (d), (s1), (s2), (s3))

1 destination, 1 mask, and 2 non-immediate sources
#define	INSTR_CREATE_vmovss_NDS_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmovss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmovsd_NDS_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmovsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vunpcklps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vunpcklps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vunpcklpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vunpcklpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vunpckhps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vunpckhps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vunpckhpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vunpckhpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vandps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vandps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vandpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vandpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vorps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vorps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vorpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vorpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vxorps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vxorps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vxorpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vxorpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vandnps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vandnps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vandnpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vandnpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpandd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpandd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpandq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpandq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpandnd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpandnd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpandnq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpandnq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpord_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpord, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vporq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vporq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpxord_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpxord, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpxorq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpxorq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vaddps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vaddps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vaddpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vaddpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsubps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsubps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsubpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsubpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vaddss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vaddss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vaddsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vaddsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsubss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsubss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsubsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsubsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddusb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddusb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddusw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddusw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddsb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddsb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpaddsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpaddsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubusb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubusb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubusw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubusw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubsb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubsb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsubsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsubsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaddwd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaddwd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaddubsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaddubsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmulps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmulps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmulpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmulpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmulss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmulss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmulsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmulsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmullw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmullw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmulld_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmulld, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmullq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmullq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmuldq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmuldq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmulhw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmulhw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmulhuw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmulhuw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmuludq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmuludq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmulhrsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmulhrsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vdivps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vdivps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vdivpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vdivpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vdivss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vdivss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vdivsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vdivsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vminps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vminps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vminpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vminpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vminss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vminss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vminsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vminsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmaxps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmaxps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmaxpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmaxpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmaxss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmaxss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vmaxsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vmaxsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vcvtss2sd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vcvtss2sd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vcvtsd2ss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vcvtsd2ss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vcvtps2ph_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vcvtps2ph, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermilps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermilps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermilpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermilpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2ps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2ps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2pd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2pd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2d_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2d, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2q_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2q, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2b_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2b, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermi2w_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermi2w, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2d_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2d, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2q_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2q, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2b_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2b, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2w_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2w, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2ps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2ps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpermt2pd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpermt2pd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpcklbw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpcklbw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpcklwd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpcklwd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpckldq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpckldq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpcklqdq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpcklqdq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpckhbw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpckhbw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpckhwd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpckhwd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpckhdq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpckhdq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpunpckhqdq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpunpckhqdq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpacksswb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpacksswb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpackssdw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpackssdw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpackuswb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpackuswb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpackusdw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpackusdw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextractf32x4_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextractf32x4, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextractf64x2_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextractf64x2, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextractf32x8_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextractf32x8, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextractf64x4_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextractf64x4, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextracti32x4_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextracti32x4, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextracti64x2_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextracti64x2, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextracti32x8_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextracti32x8, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vextracti64x4_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vextracti64x4, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpgtb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpgtw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpgtd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpgtq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpgtq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpeqb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpeqw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpeqd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpcmpeqq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpcmpeqq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminsb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminsb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminsq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminsq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxsb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxsb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxsw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxsw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxsq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxsq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminub_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminub, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminuw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminuw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminud_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminud, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpminuq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpminuq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxub_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxub, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxuw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxuw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxud_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxud, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmaxuq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmaxuq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprolvd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprolvd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprold_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprold, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprolvq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprolvq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprolq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprolq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprorvd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprorvd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprord_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprord, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprorvq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprorvq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vprorq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vprorq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsraw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsraw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrad_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrad, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsraq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsraq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrlw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrlw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrld_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrld, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrlq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrlq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsravw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsravw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsravd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsravd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsravq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsravq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrlvw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrlvw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrlvd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrlvd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsrlvq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsrlvq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsllw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsllw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpslld_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpslld, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsllq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsllq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsllvw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsllvw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsllvd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsllvd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpsllvq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpsllvq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrcp14ss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrcp14ss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrcp14sd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrcp14sd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrcp28ss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrcp28ss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrcp28sd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrcp28sd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpshufb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpshufb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpavgb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpavgb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpavgw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpavgw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vblendmps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vblendmps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vblendmpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vblendmpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vgetexpss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vgetexpss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vgetexpsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vgetexpsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpblendmb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpblendmb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpblendmw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpblendmw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpblendmd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpblendmd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpblendmq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpblendmq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestmb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestmb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestmw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestmw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestmd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestmd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestmq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestmq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestnmb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestnmb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestnmw_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestnmw, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestnmd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestnmd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vptestnmq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vptestnmq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrsqrt14ss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrsqrt14ss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrsqrt14sd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrsqrt14sd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrsqrt28ss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrsqrt28ss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vrsqrt28sd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vrsqrt28sd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vscalefps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vscalefps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vscalefpd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vscalefpd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vscalefss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vscalefss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vscalefsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vscalefsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmadd52huq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmadd52huq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmadd52luq_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmadd52luq, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsqrtss_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsqrtss, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vsqrtsd_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vsqrtsd, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpshufbitqmb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpshufbitqmb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vgf2p8mulb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vgf2p8mulb, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpmultishiftqb_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vpmultishiftqb, (d), (k), (s1), (s2))

1 destination, 3 sources including one immediate
#define	INSTR_CREATE_vcmpps(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vcmpps, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vcmpss(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vcmpss, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vcmppd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vcmppd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vcmpsd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vcmpsd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpinsrw(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpinsrw, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vshufps(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vshufps, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vshufpd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vshufpd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpalignr(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpalignr, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vblendps(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vblendps, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vblendpd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vblendpd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpblendw(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpblendw, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpinsrb(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpinsrb, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vinsertps(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vinsertps, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpinsrd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpinsrd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpinsrq(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpinsrq, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vdpps(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vdpps, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vdppd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vdppd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vmpsadbw(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vmpsadbw, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpclmulqdq(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpclmulqdq, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vroundss(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vroundss, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vroundsd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vroundsd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vperm2f128(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vperm2f128, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vinsertf128(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vinsertf128, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vgf2p8affineqb(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vgf2p8affineqb, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vgf2p8affineinvqb(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vgf2p8affineinvqb, (d), (s1), (s2), (i))

1 destination, 3 sources: 1 implicit
#define	INSTR_CREATE_shld(dc, d, s, ri) instr_create_1dst_3src((dc), OP_shld, (d), (s), (ri), (d))

#define	INSTR_CREATE_shrd(dc, d, s, ri) instr_create_1dst_3src((dc), OP_shrd, (d), (s), (ri), (d))

1 destination, 3 sources: 1 implicit, 1 immed
#define	INSTR_CREATE_pclmulqdq(dc, d, s, i) instr_create_1dst_3src((dc), OP_pclmulqdq, (d), (s), (i), (d))

#define	INSTR_CREATE_blendps(dc, d, s, i) instr_create_1dst_3src((dc), OP_blendps, (d), (s), (i), (d))

#define	INSTR_CREATE_blendpd(dc, d, s, i) instr_create_1dst_3src((dc), OP_blendpd, (d), (s), (i), (d))

#define	INSTR_CREATE_pblendw(dc, d, s, i) instr_create_1dst_3src((dc), OP_pblendw, (d), (s), (i), (d))

1 explicit destination, 2 explicit sources, 1 implicit source
#define	INSTR_CREATE_shufps(dc, d, s, i) instr_create_1dst_3src((dc), OP_shufps, (d), (s), (i), (d))

#define	INSTR_CREATE_shufpd(dc, d, s, i) instr_create_1dst_3src((dc), OP_shufpd, (d), (s), (i), (d))

#define	INSTR_CREATE_cmpps(dc, d, s, i) instr_create_1dst_3src((dc), OP_cmpps, (d), (s), (i), (d))

#define	INSTR_CREATE_cmpss(dc, d, s, i) instr_create_1dst_3src((dc), OP_cmpss, (d), (s), (i), (d))

#define	INSTR_CREATE_cmppd(dc, d, s, i) instr_create_1dst_3src((dc), OP_cmppd, (d), (s), (i), (d))

#define	INSTR_CREATE_cmpsd(dc, d, s, i) instr_create_1dst_3src((dc), OP_cmpsd, (d), (s), (i), (d))

#define	INSTR_CREATE_palignr(dc, d, s, i) instr_create_1dst_3src((dc), OP_palignr, (d), (s), (i), (d))

#define	INSTR_CREATE_dpps(dc, d, s, i) instr_create_1dst_3src((dc), OP_dpps, (d), (s), (i), (d))

#define	INSTR_CREATE_dppd(dc, d, s, i) instr_create_1dst_3src((dc), OP_dppd, (d), (s), (i), (d))

#define	INSTR_CREATE_mpsadbw(dc, d, s, i) instr_create_1dst_3src((dc), OP_mpsadbw, (d), (s), (i), (d))

#define	INSTR_CREATE_sha1rnds4(dc, d, s, i) instr_create_1dst_3src((dc), OP_sha1rnds4, (d), (s), (i), (d))

#define	INSTR_CREATE_gf2p8affineqb(dc, d, s, i) instr_create_1dst_3src((dc), OP_gf2p8affineqb, (d), (s), (i), (d))

#define	INSTR_CREATE_gf2p8affineinvqb(dc, d, s, i) instr_create_1dst_3src((dc), OP_gf2p8affineinvqb, (d), (s), (i), (d))

1 explicit destination, 2 explicit sources, dest is implicit source
#define	INSTR_CREATE_vfmadd132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd132ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd132sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd213ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd213sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd231ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmadd231sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmaddsub231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsubadd231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub132ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub132sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub213ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub213sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub231ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfmsub231sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd132ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd132sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd213ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd213sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd231ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmadd231sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub132ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub132pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub213ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub213pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231ps(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub231ps, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231pd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub231pd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub132ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub132sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub213ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub213sd, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231ss(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub231ss, (d), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231sd(dc, d, s1, s2) instr_create_1dst_3src((dc), OP_vfnmsub231sd, (d), (s1), (s2), (d))

1 explicit destination, 1 mask, 2 explicit sources, dest is implicit source
#define	INSTR_CREATE_vfmadd132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd132ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd132sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd132sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd213ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd213sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd213sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd231ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmadd231sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmadd231sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmaddsub231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmaddsub231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsubadd231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsubadd231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub132ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub132sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub132sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub213ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub213sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub213sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub231ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfmsub231sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfmsub231sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd132ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd132sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd132sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd213ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd213sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd213sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd231ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmadd231sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmadd231sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub132ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub132pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub213ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub213pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231ps_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub231ps, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231pd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub231pd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub132ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub132sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub132sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub213ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub213sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub213sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231ss_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub231ss, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vfnmsub231sd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vfnmsub231sd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vcvtne2ps2bf16_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vcvtne2ps2bf16, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vdpbf16ps_mask(dc, d, k, s1, s2) instr_create_1dst_3src((dc), OP_vdpbf16ps, (d), (k), (s1), (s2))

#define	INSTR_CREATE_vpshldvw_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshldvw, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vpshldvd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshldvd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vpshldvq_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshldvq, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vpshrdvw_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdvw, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vpshrdvd_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdvd, (d), (k), (s1), (s2), (d))

#define	INSTR_CREATE_vpshrdvq_mask(dc, d, k, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdvq, (d), (k), (s1), (s2), (d))

1 explicit destination, 3 explicit sources
#define	INSTR_CREATE_vfmaddsubps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddsubps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmaddsubpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddsubpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubaddps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubaddps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubaddpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubaddpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmaddps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmaddpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmaddss(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddss, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmaddsd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmaddsd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubss(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubss, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfmsubsd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfmsubsd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmaddps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmaddps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmaddpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmaddpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmaddss(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmaddss, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmaddsd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmaddsd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmsubps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmsubps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmsubpd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmsubpd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmsubss(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmsubss, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vfnmsubsd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vfnmsubsd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacssww(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacssww, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacsswd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacsswd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacssdql(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacssdql, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacssdd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacssdd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacssdqh(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacssdqh, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacsww(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacsww, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacswd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacswd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacsdql(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacsdql, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacsdd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacsdd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmacsdqh(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmacsdqh, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmadcsswd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmadcsswd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpmadcswd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpmadcswd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpperm(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpperm, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpcmov(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpcmov, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpermil2pd(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpermil2pd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpermil2ps(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpermil2ps, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpdpbusd_mask(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpdpbusd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpdpbusds_mask(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpdpbusds, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpdpwssd_mask(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpdpwssd, (d), (s1), (s2), (s3))

#define	INSTR_CREATE_vpdpwssds_mask(dc, d, s1, s2, s3) instr_create_1dst_3src((dc), OP_vpdpwssds, (d), (s1), (s2), (s3))

1 destination, 3 sources where the final is an immediate
#define	INSTR_CREATE_vpcomb(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomb, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomw(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomw, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomd(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomd, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomq(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomq, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomub(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomub, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomuw(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomuw, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomud(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomud, (d), (s1), (s2), (i))

#define	INSTR_CREATE_vpcomuq(dc, d, s1, s2, i) instr_create_1dst_3src((dc), OP_vpcomuq, (d), (s1), (s2), (i))

1 explicit destination, 1 mask, 3 sources where the final is an immediate
#define	INSTR_CREATE_vinsertf32x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinsertf32x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinsertf64x2_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinsertf64x2, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinsertf32x8_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinsertf32x8, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinsertf64x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinsertf64x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinserti32x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinserti32x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinserti64x2_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinserti64x2, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinserti32x8_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinserti32x8, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vinserti64x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vinserti64x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpb_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpb, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpw_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpw, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpq, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpub_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpub, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpuw_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpuw, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpud_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpud, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpcmpuq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpcmpuq, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vcmpps_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vcmpps, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vcmpss_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vcmpss, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vcmppd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vcmppd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vcmpsd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vcmpsd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshufps_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshufps, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshufpd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshufpd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshuff32x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshuff32x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshuff64x2_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshuff64x2, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshufi32x4_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshufi32x4, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vshufi64x2_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vshufi64x2, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpalignr_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpalignr, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_valignd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_valignd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_valignq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_valignq, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vfixupimmps_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vfixupimmps, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vfixupimmpd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vfixupimmpd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vfixupimmss_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vfixupimmss, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vfixupimmsd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vfixupimmsd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vgetmantss_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vgetmantss, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vgetmantsd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vgetmantsd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vrangeps_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vrangeps, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vrangepd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vrangepd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vrangess_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vrangess, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vrangesd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vrangesd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vreducess_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vreducess, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vreducesd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vreducesd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vdbpsadbw_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vdbpsadbw, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpternlogd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpternlogd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpternlogq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpternlogq, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vgf2p8affineqb_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vgf2p8affineqb, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vgf2p8affineinvqb_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vgf2p8affineinvqb, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshldw_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshldw, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshldd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshldd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshldq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshldq, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshrdw_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdw, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshrdd_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdd, (d), (k), (i), (s1), (s2))

#define	INSTR_CREATE_vpshrdq_mask(dc, d, k, i, s1, s2) instr_create_1dst_4src((dc), OP_vpshrdq, (d), (k), (i), (s1), (s2))

1 destination, 3 sources where 2 are implicit
#define	INSTR_CREATE_pblendvb(dc, d, s) instr_create_1dst_3src((dc), OP_pblendvb, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

#define	INSTR_CREATE_blendvps(dc, d, s) instr_create_1dst_3src((dc), OP_blendvps, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

#define	INSTR_CREATE_blendvpd(dc, d, s) instr_create_1dst_3src((dc), OP_blendvpd, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

#define	INSTR_CREATE_sha256rnds2(dc, d, s)

1 implicit destination, 3 sources
#define	INSTR_CREATE_pcmpistrm(dc, s1, s2, i)

#define	INSTR_CREATE_pcmpistri(dc, s1, s2, i)

#define	INSTR_CREATE_vpcmpistrm(dc, s1, s2, i)

#define	INSTR_CREATE_vpcmpistri(dc, s1, s2, i)

1 implicit destination, 3 sources: 2 implicit
#define	INSTR_CREATE_ret_imm(dc, i)

#define	INSTR_CREATE_ret_far_imm(dc, i)

1 implicit destination, 5 sources: 2 implicit
#define	INSTR_CREATE_pcmpestrm(dc, s1, s2, i)

#define	INSTR_CREATE_pcmpestri(dc, s1, s2, i)

#define	INSTR_CREATE_vpcmpestrm(dc, s1, s2, i)

#define	INSTR_CREATE_vpcmpestri(dc, s1, s2, i)

2 implicit destinations, no sources
#define	INSTR_CREATE_rdtsc(dc)

#define	INSTR_CREATE_syscall(dc)

2 destinations: 1 implicit, 1 source
#define	INSTR_CREATE_lds(dc, d, s) instr_create_2dst_1src((dc), OP_lds, (d), opnd_create_reg(DR_SEG_DS), (s))

#define	INSTR_CREATE_lss(dc, d, s) instr_create_2dst_1src((dc), OP_lss, (d), opnd_create_reg(DR_SEG_SS), (s))

#define	INSTR_CREATE_les(dc, d, s) instr_create_2dst_1src((dc), OP_les, (d), opnd_create_reg(DR_SEG_ES), (s))

#define	INSTR_CREATE_lfs(dc, d, s) instr_create_2dst_1src((dc), OP_lfs, (d), opnd_create_reg(DR_SEG_FS), (s))

#define	INSTR_CREATE_lgs(dc, d, s) instr_create_2dst_1src((dc), OP_lgs, (d), opnd_create_reg(DR_SEG_GS), (s))

2 implicit destinations, 1 implicit source
#define	INSTR_CREATE_pushf(dc)

#define	INSTR_CREATE_rdmsr(dc)

#define	INSTR_CREATE_rdpmc(dc)

#define	INSTR_CREATE_xgetbv(dc)

#define	INSTR_CREATE_rdpkru(dc)

2 implicit destinations, 3 sources: 1 implicit
#define	INSTR_CREATE_vpgatherdd(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vpgatherdd, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vpgatherdq(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vpgatherdq, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vpgatherqd(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vpgatherqd, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vpgatherqq(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vpgatherqq, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vgatherdps(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vgatherdps, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vgatherdpd(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vgatherdpd, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vgatherqps(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vgatherqps, (d), (s2), (s1), (s2))

#define	INSTR_CREATE_vgatherqpd(dc, d, s1, s2) instr_create_2dst_2src((dc), OP_vgatherqpd, (d), (s2), (s1), (s2))

2 implicit destinations, 1 mask, andd 3 sources: The mask is implicit
#define	INSTR_CREATE_vpgatherdd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpgatherdd, (d), (k), (k), (s))

#define	INSTR_CREATE_vpgatherdq_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpgatherdq, (d), (k), (k), (s))

#define	INSTR_CREATE_vpgatherqd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpgatherqd, (d), (k), (k), (s))

#define	INSTR_CREATE_vpgatherqq_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpgatherqq, (d), (k), (k), (s))

#define	INSTR_CREATE_vgatherdps_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vgatherdps, (d), (k), (k), (s))

#define	INSTR_CREATE_vgatherdpd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vgatherdpd, (d), (k), (k), (s))

#define	INSTR_CREATE_vgatherqps_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vgatherqps, (d), (k), (k), (s))

#define	INSTR_CREATE_vgatherqpd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vgatherqpd, (d), (k), (k), (s))

#define	INSTR_CREATE_vpscatterdd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpscatterdd, (d), (k), (k), (s))

#define	INSTR_CREATE_vpscatterdq_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpscatterdq, (d), (k), (k), (s))

#define	INSTR_CREATE_vpscatterqd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpscatterqd, (d), (k), (k), (s))

#define	INSTR_CREATE_vpscatterqq_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vpscatterqq, (d), (k), (k), (s))

#define	INSTR_CREATE_vscatterdps_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vscatterdps, (d), (k), (k), (s))

#define	INSTR_CREATE_vscatterdpd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vscatterdpd, (d), (k), (k), (s))

#define	INSTR_CREATE_vscatterqps_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vscatterqps, (d), (k), (k), (s))

#define	INSTR_CREATE_vscatterqpd_mask(dc, d, k, s) instr_create_2dst_2src((dc), OP_vscatterqpd, (d), (k), (k), (s))

2 destinations: 1 implicit, 2 sources: 1 implicit
#define	INSTR_CREATE_xchg(dc, d, s) instr_create_2dst_2src((dc), OP_xchg, (d), (s), (d), (s))

#define	INSTR_CREATE_xadd(dc, d, s) instr_create_2dst_2src((dc), OP_xadd, (d), (s), (d), (s))

String instructions
#define	INSTR_CREATE_ins_1(dc)

#define	INSTR_CREATE_ins_4(dc)

#define	INSTR_CREATE_stos_1(dc)

#define	INSTR_CREATE_stos_4(dc)

#define	INSTR_CREATE_stos_8(dc)

#define	INSTR_CREATE_lods_1(dc)

#define	INSTR_CREATE_lods_4(dc)

#define	INSTR_CREATE_lods_8(dc)

#define	INSTR_CREATE_movs_1(dc)

#define	INSTR_CREATE_movs_4(dc)

#define	INSTR_CREATE_rep_ins_1(dc)

#define	INSTR_CREATE_rep_ins_4(dc)

#define	INSTR_CREATE_rep_stos_1(dc)

#define	INSTR_CREATE_rep_stos_4(dc)

#define	INSTR_CREATE_rep_lods_1(dc)

#define	INSTR_CREATE_rep_lods_4(dc)

#define	INSTR_CREATE_rep_movs_1(dc)

#define	INSTR_CREATE_rep_movs_4(dc)

#define	INSTR_CREATE_outs_1(dc)

#define	INSTR_CREATE_outs_4(dc)

#define	INSTR_CREATE_cmps_1(dc)

#define	INSTR_CREATE_cmps_4(dc)

#define	INSTR_CREATE_scas_1(dc)

#define	INSTR_CREATE_scas_4(dc)

#define	INSTR_CREATE_rep_outs_1(dc)

#define	INSTR_CREATE_rep_outs_4(dc)

#define	INSTR_CREATE_rep_cmps_1(dc)

#define	INSTR_CREATE_rep_cmps_4(dc)

#define	INSTR_CREATE_repne_cmps_1(dc)

#define	INSTR_CREATE_repne_cmps_4(dc)

#define	INSTR_CREATE_rep_scas_1(dc)

#define	INSTR_CREATE_rep_scas_4(dc)

#define	INSTR_CREATE_repne_scas_1(dc)

#define	INSTR_CREATE_repne_scas_4(dc)

2 destinations: 1 implicit, 3 sources: 1 implicit
#define	INSTR_CREATE_cmpxchg_1(dc, d, s)

#define	INSTR_CREATE_cmpxchg_4(dc, d, s)

#define	INSTR_CREATE_cmpxchg_8(dc, d, s)

No destination, many implicit sources
#define	INSTR_CREATE_pusha(dc) instr_create_pusha((dc))

#define	INSTR_CREATE_rdtscp(dc)

#define	INSTR_CREATE_cpuid(dc)

#define	INSTR_CREATE_encls(dc)

#define	INSTR_CREATE_enclu(dc)

#define	INSTR_CREATE_enclv(dc)

Nops
#define	INSTR_CREATE_nop1byte(dc) INSTR_CREATE_nop(dc)

#define	INSTR_CREATE_nop2byte(dc) INSTR_CREATE_nop2byte_reg(dc, DR_REG_XDI)

#define	INSTR_CREATE_nop3byte(dc) INSTR_CREATE_nop3byte_reg(dc, DR_REG_XDI)

Functions
2-byte reg nops
static instr_t *	INSTR_CREATE_nop2byte_reg (void *drcontext, reg_id_t reg)

static instr_t *	INSTR_CREATE_nop3byte_reg (void *drcontext, reg_id_t reg)

Detailed Description

AMD64/IA-32 instruction creation convenience macros.

All macros assume default data and address sizes. For the most part these macros do not support building non-default address or data size versions; for that, simply duplicate the macro's body, replacing the size and/or hardcoded registers with smaller versions (the IR does not support cs segments with non-default sizes where the default size requires instruction prefixes). For shrinking data sizes, see the instr_shrink_to_16_bits() routine.

Macro Definition Documentation

◆ INSTR_CREATE_aaa

#define INSTR_CREATE_aaa ( dc )

Value:

instr_create_1dst_1src((dc), OP_aaa, opnd_create_reg(DR_REG_AX), \

opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_aad

#define INSTR_CREATE_aad	(	dc,
		i
	)

Value:

instr_create_1dst_2src((dc), OP_aad, opnd_create_reg(DR_REG_AX), (i), \

opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_aam

#define INSTR_CREATE_aam	(	dc,
		i
	)

Value:

instr_create_1dst_2src((dc), OP_aam, opnd_create_reg(DR_REG_AX), (i), \

opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_aas

#define INSTR_CREATE_aas ( dc )

Value:

instr_create_1dst_1src((dc), OP_aas, opnd_create_reg(DR_REG_AX), \

opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_adc

#define INSTR_CREATE_adc	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_adc, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_adcx

#define INSTR_CREATE_adcx	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_adcx, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_add

#define INSTR_CREATE_add	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_add, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addpd

#define INSTR_CREATE_addpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addps

#define INSTR_CREATE_addps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addsd

#define INSTR_CREATE_addsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addss

#define INSTR_CREATE_addss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addsubpd

#define INSTR_CREATE_addsubpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addsubpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_addsubps

#define INSTR_CREATE_addsubps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_addsubps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_adox

#define INSTR_CREATE_adox	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_adox, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aesdec

#define INSTR_CREATE_aesdec	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_aesdec, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aesdeclast

#define INSTR_CREATE_aesdeclast	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_aesdeclast, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aesenc

#define INSTR_CREATE_aesenc	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_aesenc, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aesenclast

#define INSTR_CREATE_aesenclast	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_aesenclast, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aesimc

#define INSTR_CREATE_aesimc	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_aesimc, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_aeskeygenassist

#define INSTR_CREATE_aeskeygenassist	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_aeskeygenassist, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_and

#define INSTR_CREATE_and	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_and, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_andn

#define INSTR_CREATE_andn	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_andn, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_andnpd

#define INSTR_CREATE_andnpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_andnpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_andnps

#define INSTR_CREATE_andnps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_andnps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_andpd

#define INSTR_CREATE_andpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_andpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_andps

#define INSTR_CREATE_andps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_andps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_arpl

#define INSTR_CREATE_arpl	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_arpl, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bextr

#define INSTR_CREATE_bextr	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_bextr, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_blcfill

#define INSTR_CREATE_blcfill	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blcfill, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blci

#define INSTR_CREATE_blci	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blci, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blcic

#define INSTR_CREATE_blcic	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blcic, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blcmsk

#define INSTR_CREATE_blcmsk	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blcmsk, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blcs

#define INSTR_CREATE_blcs	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blcs, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blendpd

#define INSTR_CREATE_blendpd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_blendpd, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_blendps

#define INSTR_CREATE_blendps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_blendps, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_blendvpd

#define INSTR_CREATE_blendvpd	(	dc,
		d,
		s
	)	instr_create_1dst_3src((dc), OP_blendvpd, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blendvps

#define INSTR_CREATE_blendvps	(	dc,
		d,
		s
	)	instr_create_1dst_3src((dc), OP_blendvps, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blsfill

#define INSTR_CREATE_blsfill	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blsfill, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blsi

#define INSTR_CREATE_blsi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blsi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blsic

#define INSTR_CREATE_blsic	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blsic, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blsmsk

#define INSTR_CREATE_blsmsk	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blsmsk, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_blsr

#define INSTR_CREATE_blsr	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_blsr, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndcl

#define INSTR_CREATE_bndcl	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndcl, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndcn

#define INSTR_CREATE_bndcn	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndcn, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndcu

#define INSTR_CREATE_bndcu	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndcu, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndldx

#define INSTR_CREATE_bndldx	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndldx, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndmk

#define INSTR_CREATE_bndmk	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndmk, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndmov

#define INSTR_CREATE_bndmov	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndmov, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bndstx

#define INSTR_CREATE_bndstx	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_bndstx, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bound

#define INSTR_CREATE_bound	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_bound, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction, which can be created with OPND_CREATE_MEM_bound() to get the appropriate operand size.

◆ INSTR_CREATE_bsf

#define INSTR_CREATE_bsf	(	dc,
		d,
		s
	)	INSTR_PRED(instr_create_1dst_1src((dc), OP_bsf, (d), (s)), DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bsr

#define INSTR_CREATE_bsr	(	dc,
		d,
		s
	)	INSTR_PRED(instr_create_1dst_1src((dc), OP_bsr, (d), (s)), DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_bswap

#define INSTR_CREATE_bswap	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_bswap, (d), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_bt

#define INSTR_CREATE_bt	(	dc,
		s,
		ri
	)	instr_create_0dst_2src((dc), OP_bt, (s), (ri))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t first source operand for the instruction.
ri	The opnd_t second source operand for the instruction, which can be either a register or an immediate integer.

◆ INSTR_CREATE_btc

#define INSTR_CREATE_btc	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_btc, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which can be a register (opnd_create_reg()) or an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_btr

#define INSTR_CREATE_btr	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_btr, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which can be a register (opnd_create_reg()) or an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_bts

#define INSTR_CREATE_bts	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_bts, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which can be a register (opnd_create_reg()) or an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_bzhi

#define INSTR_CREATE_bzhi	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_bzhi, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_call

#define INSTR_CREATE_call	(	dc,
		t
	)

Value:

    instr_create_2dst_2src((dc), OP_call, opnd_create_reg(DR_REG_XSP),             \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,       \
                                                 IF_X64_ELSE(-8, -4), OPSZ_STACK), \
                           (t), opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_call_far

#define INSTR_CREATE_call_far	(	dc,
		t
	)

Value:

    instr_create_2dst_2src(                                                 \
        (dc), OP_call_far, opnd_create_reg(DR_REG_XSP),                     \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, -8, OPSZ_8), (t), \
        opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a far pc operand created with opnd_create_far_pc().

◆ INSTR_CREATE_call_far_ind

#define INSTR_CREATE_call_far_ind	(	dc,
		t
	)

Value:

    instr_create_2dst_2src(                                                 \
        (dc), OP_call_far_ind, opnd_create_reg(DR_REG_XSP),                 \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, -8, OPSZ_8), (t), \
        opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a far memory reference created with opnd_create_far_base_disp().

◆ INSTR_CREATE_call_ind

#define INSTR_CREATE_call_ind	(	dc,
		t
	)

Value:

    instr_create_2dst_2src((dc), OP_call_ind, opnd_create_reg(DR_REG_XSP),         \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,       \
                                                 IF_X64_ELSE(-8, -4), OPSZ_STACK), \
                           (t), opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a memory reference created with opnd_create_base_disp().

◆ INSTR_CREATE_cdq

#define INSTR_CREATE_cdq ( dc )

Value:

instr_create_1dst_1src((dc), OP_cdq, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_clac

#define INSTR_CREATE_clac ( dc ) instr_create_0dst_0src((dc), OP_clac)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_clc

#define INSTR_CREATE_clc ( dc ) instr_create_0dst_0src((dc), OP_clc)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cld

#define INSTR_CREATE_cld ( dc ) instr_create_0dst_0src((dc), OP_cld)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cldemote

#define INSTR_CREATE_cldemote	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_cldemote, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_clflush() to get the appropriate operand size.

◆ INSTR_CREATE_clflush

#define INSTR_CREATE_clflush	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_clflush, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_clflush() to get the appropriate operand size.

◆ INSTR_CREATE_clflushopt

#define INSTR_CREATE_clflushopt	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_clflushopt, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_clflush() to get the appropriate operand size.

◆ INSTR_CREATE_clgi

#define INSTR_CREATE_clgi ( dc ) instr_create_0dst_0src((dc), OP_clgi)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cli

#define INSTR_CREATE_cli ( dc ) instr_create_0dst_0src((dc), OP_cli)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_clts

#define INSTR_CREATE_clts ( dc ) instr_create_0dst_0src((dc), OP_clts)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_clwb

#define INSTR_CREATE_clwb	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_clwb, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_clflush() to get the appropriate operand size.

◆ INSTR_CREATE_cmc

#define INSTR_CREATE_cmc ( dc ) instr_create_0dst_0src((dc), OP_cmc)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cmovcc

#define INSTR_CREATE_cmovcc	(	dc,
		op,
		d,
		s
	)	INSTR_PRED(instr_create_1dst_1src((dc), (op), (d), (s)), DR_PRED_O + (op)-OP_cmovo)

Creates an instr_t for a conditional move instruction with the given opcode and destination operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
op	The OP_xxx opcode for the instruction, which should be in the range [OP_cmovo, OP_cmovnle].
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cmp

#define INSTR_CREATE_cmp	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_cmp, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_cmppd

#define INSTR_CREATE_cmppd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_cmppd, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_cmpps

#define INSTR_CREATE_cmpps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_cmpps, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_cmps_1

#define INSTR_CREATE_cmps_1 ( dc )

Value:

    instr_create_2dst_4src(                                                          \
        (dc), OP_cmps, opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),     \
        opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cmps_4

#define INSTR_CREATE_cmps_4 ( dc )

Value:

    instr_create_2dst_4src((dc), OP_cmps, opnd_create_reg(DR_REG_XSI),                   \
                           opnd_create_reg(DR_REG_XDI),                                  \
                           opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_cmpsd

#define INSTR_CREATE_cmpsd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_cmpsd, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_cmpss

#define INSTR_CREATE_cmpss	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_cmpss, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_cmpxchg8b

#define INSTR_CREATE_cmpxchg8b	(	dc,
		d
	)

Value:

    instr_create_3dst_5src((dc), OP_cmpxchg8b, (d), opnd_create_reg(DR_REG_EAX),     \
                           opnd_create_reg(DR_REG_EDX), (d),                         \
                           opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_EDX), \
                           opnd_create_reg(DR_REG_ECX), opnd_create_reg(DR_REG_EBX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_cmpxchg_1

#define INSTR_CREATE_cmpxchg_1	(	dc,
		d,
		s
	)

Value:

instr_create_2dst_3src((dc), OP_cmpxchg, (d), opnd_create_reg(DR_REG_AL), (s), (d), \

opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx_1, INSTR_CREATE_xxx_4, or INSTR_CREATE_xxx_8 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1, _4, or _8 suffixes distinguish between alternative forms of the same opcode with the given operand size.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cmpxchg_4

#define INSTR_CREATE_cmpxchg_4	(	dc,
		d,
		s
	)

Value:

instr_create_2dst_3src((dc), OP_cmpxchg, (d), opnd_create_reg(DR_REG_EAX), (s), (d), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx_1, INSTR_CREATE_xxx_4, or INSTR_CREATE_xxx_8 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1, _4, or _8 suffixes distinguish between alternative forms of the same opcode with the given operand size.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cmpxchg_8

#define INSTR_CREATE_cmpxchg_8	(	dc,
		d,
		s
	)

Value:

instr_create_2dst_3src((dc), OP_cmpxchg, (d), opnd_create_reg(DR_REG_RAX), (s), (d), \

opnd_create_reg(DR_REG_RAX))

This INSTR_CREATE_xxx_1, INSTR_CREATE_xxx_4, or INSTR_CREATE_xxx_8 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1, _4, or _8 suffixes distinguish between alternative forms of the same opcode with the given operand size.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_comisd

#define INSTR_CREATE_comisd	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_comisd, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_comiss

#define INSTR_CREATE_comiss	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_comiss, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_cpuid

#define INSTR_CREATE_cpuid ( dc )

Value:

    instr_create_4dst_2src((dc), OP_cpuid, opnd_create_reg(DR_REG_EAX),              \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX), \
                           opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_crc32

#define INSTR_CREATE_crc32	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_crc32, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtdq2pd

#define INSTR_CREATE_cvtdq2pd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtdq2pd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtdq2ps

#define INSTR_CREATE_cvtdq2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtdq2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtpd2dq

#define INSTR_CREATE_cvtpd2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtpd2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtpd2pi

#define INSTR_CREATE_cvtpd2pi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtpd2pi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtpd2ps

#define INSTR_CREATE_cvtpd2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtpd2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtpi2pd

#define INSTR_CREATE_cvtpi2pd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtpi2pd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtpi2ps

#define INSTR_CREATE_cvtpi2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtpi2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtps2dq

#define INSTR_CREATE_cvtps2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtps2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtps2pd

#define INSTR_CREATE_cvtps2pd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtps2pd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtps2pi

#define INSTR_CREATE_cvtps2pi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtps2pi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtsd2si

#define INSTR_CREATE_cvtsd2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtsd2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtsd2ss

#define INSTR_CREATE_cvtsd2ss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtsd2ss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtsi2sd

#define INSTR_CREATE_cvtsi2sd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtsi2sd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtsi2ss

#define INSTR_CREATE_cvtsi2ss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtsi2ss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtss2sd

#define INSTR_CREATE_cvtss2sd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtss2sd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvtss2si

#define INSTR_CREATE_cvtss2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvtss2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttpd2dq

#define INSTR_CREATE_cvttpd2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttpd2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttpd2pi

#define INSTR_CREATE_cvttpd2pi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttpd2pi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttps2dq

#define INSTR_CREATE_cvttps2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttps2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttps2pi

#define INSTR_CREATE_cvttps2pi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttps2pi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttsd2si

#define INSTR_CREATE_cvttsd2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttsd2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cvttss2si

#define INSTR_CREATE_cvttss2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_cvttss2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_cwde

#define INSTR_CREATE_cwde ( dc )

Value:

instr_create_1dst_1src((dc), OP_cwde, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_daa

#define INSTR_CREATE_daa ( dc )

Value:

instr_create_1dst_1src((dc), OP_daa, opnd_create_reg(DR_REG_AL), \

opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_das

#define INSTR_CREATE_das ( dc )

Value:

instr_create_1dst_1src((dc), OP_das, opnd_create_reg(DR_REG_AL), \

opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_dec

#define INSTR_CREATE_dec	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_dec, (d), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_div_1

#define INSTR_CREATE_div_1	(	dc,
		s
	)

Value:

instr_create_2dst_2src((dc), OP_div, opnd_create_reg(DR_REG_AH), \

opnd_create_reg(DR_REG_AL), (s), opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_div_4

#define INSTR_CREATE_div_4	(	dc,
		s
	)

Value:

    instr_create_2dst_3src((dc), OP_div, opnd_create_reg(DR_REG_EDX), \
                           opnd_create_reg(DR_REG_EAX), (s),          \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_divpd

#define INSTR_CREATE_divpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_divpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_divps

#define INSTR_CREATE_divps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_divps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_divsd

#define INSTR_CREATE_divsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_divsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_divss

#define INSTR_CREATE_divss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_divss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_dppd

#define INSTR_CREATE_dppd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_dppd, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_dpps

#define INSTR_CREATE_dpps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_dpps, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_emms

#define INSTR_CREATE_emms ( dc ) instr_create_0dst_0src((dc), OP_emms)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_encls

#define INSTR_CREATE_encls ( dc )

Value:

    instr_create_4dst_4src((dc), OP_encls, opnd_create_reg(DR_REG_EAX),              \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX), \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_enclu

#define INSTR_CREATE_enclu ( dc )

Value:

    instr_create_4dst_4src((dc), OP_enclu, opnd_create_reg(DR_REG_EAX),              \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX), \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_enclv

#define INSTR_CREATE_enclv ( dc )

Value:

    instr_create_4dst_4src((dc), OP_enclv, opnd_create_reg(DR_REG_EAX),              \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX), \
                           opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX), \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_enqcmd

#define INSTR_CREATE_enqcmd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_enqcmd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_enqcmds

#define INSTR_CREATE_enqcmds	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_enqcmds, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_enter

#define INSTR_CREATE_enter	(	dc,
		i16,
		i8
	)

Value:

    instr_create_3dst_4src((dc), OP_enter, opnd_create_reg(DR_REG_XSP),            \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,       \
                                                 IF_X64_ELSE(-8, -4), OPSZ_STACK), \
                           opnd_create_reg(DR_REG_XBP), (i16), (i8),               \
                           opnd_create_reg(DR_REG_XSP), opnd_create_reg(DR_REG_XBP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i16	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()) of OPSZ_2.
i8	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()) of OPSZ_1.

◆ INSTR_CREATE_extractps

#define INSTR_CREATE_extractps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_extractps, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_extrq

#define INSTR_CREATE_extrq	(	dc,
		d,
		r
	)	instr_create_1dst_1src((dc), OP_extrq, (d), (r))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
r	The opnd_t explicit source operand for the instruction, which must be an xmm register (opnd_create_reg()).

◆ INSTR_CREATE_extrq_imm

#define INSTR_CREATE_extrq_imm	(	dc,
		d,
		i1,
		i2
	)	instr_create_1dst_2src((dc), OP_extrq, (d), (i1), (i2))

This INSTR_CREATE_xxx_imm macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _imm suffix distinguishes between alternative forms of the same opcode: this form takes explicit immediates.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
i1	The opnd_t explicit first source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
i2	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_f2xm1

#define INSTR_CREATE_f2xm1 ( dc )

Value:

instr_create_1dst_1src((dc), OP_f2xm1, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fabs

#define INSTR_CREATE_fabs ( dc )

Value:

instr_create_1dst_1src((dc), OP_fabs, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fadd

#define INSTR_CREATE_fadd	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fadd, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_faddp

#define INSTR_CREATE_faddp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_faddp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fbld

#define INSTR_CREATE_fbld	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fbld, opnd_create_reg(DR_REG_ST0), (m))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fbstp

#define INSTR_CREATE_fbstp	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fbstp, (m), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fchs

#define INSTR_CREATE_fchs ( dc )

Value:

instr_create_1dst_1src((dc), OP_fchs, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fcmovcc

#define INSTR_CREATE_fcmovcc	(	dc,
		op,
		f
	)

Value:

INSTR_PRED(instr_create_1dst_1src((dc), (op), opnd_create_reg(DR_REG_ST0), (f)), \

DR_PRED_O + instr_cmovcc_to_jcc(op) - OP_jo)

Creates an instr_t for a conditional move instruction with the given opcode and destination operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
op	The OP_xxx opcode for the instruction, which should be in the range [OP_fcmovb, OP_fcmovnu], excluding OP_fucompp.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fcom

#define INSTR_CREATE_fcom	(	dc,
		s
	)	instr_create_0dst_2src((dc), OP_fcom, (s), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fcomi

#define INSTR_CREATE_fcomi	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fcomi, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fcomip

#define INSTR_CREATE_fcomip	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fcomip, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fcomp

#define INSTR_CREATE_fcomp	(	dc,
		s
	)	instr_create_0dst_2src((dc), OP_fcomp, (s), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fcompp

#define INSTR_CREATE_fcompp ( dc )

Value:

instr_create_0dst_2src((dc), OP_fcompp, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fcos

#define INSTR_CREATE_fcos ( dc )

Value:

instr_create_1dst_1src((dc), OP_fcos, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fdecstp

#define INSTR_CREATE_fdecstp ( dc ) instr_create_0dst_0src((dc), OP_fdecstp)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fdiv

#define INSTR_CREATE_fdiv	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fdiv, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_fdivp

#define INSTR_CREATE_fdivp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_fdivp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fdivr

#define INSTR_CREATE_fdivr	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fdivr, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_fdivrp

#define INSTR_CREATE_fdivrp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_fdivrp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_femms

#define INSTR_CREATE_femms ( dc ) instr_create_0dst_0src((dc), OP_femms)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ffree

#define INSTR_CREATE_ffree	(	dc,
		f
	)	instr_create_1dst_0src((dc), OP_ffree, (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_ffreep

#define INSTR_CREATE_ffreep	(	dc,
		f
	)	instr_create_1dst_0src((dc), OP_ffreep, (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fiadd

#define INSTR_CREATE_fiadd	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fiadd, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_ficom

#define INSTR_CREATE_ficom	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_ficom, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_ficomp

#define INSTR_CREATE_ficomp	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_ficomp, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fidiv

#define INSTR_CREATE_fidiv	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fidiv, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fidivr

#define INSTR_CREATE_fidivr	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fidivr, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fild

#define INSTR_CREATE_fild	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fild, opnd_create_reg(DR_REG_ST0), (m))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fimul

#define INSTR_CREATE_fimul	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fimul, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fincstp

#define INSTR_CREATE_fincstp ( dc ) instr_create_0dst_0src((dc), OP_fincstp)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fist

#define INSTR_CREATE_fist	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fist, (m), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fistp

#define INSTR_CREATE_fistp	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fistp, (m), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fisttp

#define INSTR_CREATE_fisttp	(	dc,
		m
	)	instr_create_1dst_1src((dc), OP_fisttp, (m), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx_mem macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fisub

#define INSTR_CREATE_fisub	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fisub, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fisubr

#define INSTR_CREATE_fisubr	(	dc,
		m
	)

Value:

instr_create_1dst_2src((dc), OP_fisubr, opnd_create_reg(DR_REG_ST0), (m), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit memory operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit source operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fld

#define INSTR_CREATE_fld	(	dc,
		s
	)	instr_create_1dst_1src((dc), OP_fld, opnd_create_reg(DR_REG_ST0), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fld1

#define INSTR_CREATE_fld1 ( dc )

Value:

instr_create_1dst_1src((dc), OP_fld1, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float(1.0f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldcw

#define INSTR_CREATE_fldcw	(	dc,
		m
	)	instr_create_0dst_1src((dc), OP_fldcw, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fldenv

#define INSTR_CREATE_fldenv	(	dc,
		m
	)	instr_create_0dst_1src((dc), OP_fldenv, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_fldenv() to get the appropriate operand size.

◆ INSTR_CREATE_fldl2e

#define INSTR_CREATE_fldl2e ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldl2e, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float(1.0f / (float)M_LN2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldl2t

#define INSTR_CREATE_fldl2t ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldl2t, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float((float)M_LN10 / (float)M_LN2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldlg2

#define INSTR_CREATE_fldlg2 ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldlg2, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float((float)M_LN2 / (float)M_LN10))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldln2

#define INSTR_CREATE_fldln2 ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldln2, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float((float)M_LN2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldpi

#define INSTR_CREATE_fldpi ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldpi, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float((float)M_PI))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fldz

#define INSTR_CREATE_fldz ( dc )

Value:

instr_create_1dst_1src((dc), OP_fldz, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float(0.0f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fmul

#define INSTR_CREATE_fmul	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fmul, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_fmulp

#define INSTR_CREATE_fmulp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_fmulp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fnclex

#define INSTR_CREATE_fnclex ( dc ) instr_create_0dst_0src((dc), OP_fnclex)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fninit

#define INSTR_CREATE_fninit ( dc ) instr_create_0dst_0src((dc), OP_fninit)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fnop

#define INSTR_CREATE_fnop ( dc ) instr_create_0dst_0src((dc), OP_fnop)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fnsave

#define INSTR_CREATE_fnsave	(	dc,
		m
	)	instr_create_1dst_0src((dc), OP_fnsave, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_fnsave() to get the appropriate operand size.

◆ INSTR_CREATE_fnstcw

#define INSTR_CREATE_fnstcw	(	dc,
		m
	)	instr_create_1dst_0src((dc), OP_fnstcw, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fnstenv

#define INSTR_CREATE_fnstenv	(	dc,
		m
	)	instr_create_1dst_0src((dc), OP_fnstenv, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_fnstenv() to get the appropriate operand size.

◆ INSTR_CREATE_fnstsw

#define INSTR_CREATE_fnstsw	(	dc,
		m
	)	instr_create_1dst_0src((dc), OP_fnstsw, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which must be a memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fpatan

#define INSTR_CREATE_fpatan ( dc )

Value:

    instr_create_2dst_2src((dc), OP_fpatan, opnd_create_reg(DR_REG_ST0),             \
                           opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0), \
                           opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fprem

#define INSTR_CREATE_fprem ( dc )

Value:

    instr_create_2dst_2src((dc), OP_fprem, opnd_create_reg(DR_REG_ST0),              \
                           opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0), \
                           opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fprem1

#define INSTR_CREATE_fprem1 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_fprem1, opnd_create_reg(DR_REG_ST0),             \
                           opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0), \
                           opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fptan

#define INSTR_CREATE_fptan ( dc )

Value:

instr_create_1dst_1src((dc), OP_fptan, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_frndint

#define INSTR_CREATE_frndint ( dc )

Value:

instr_create_1dst_1src((dc), OP_frndint, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_frstor

#define INSTR_CREATE_frstor	(	dc,
		m
	)	instr_create_0dst_1src((dc), OP_frstor, (m))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_frstor() to get the appropriate operand size.

◆ INSTR_CREATE_fscale

#define INSTR_CREATE_fscale ( dc )

Value:

instr_create_1dst_2src((dc), OP_fscale, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fsin

#define INSTR_CREATE_fsin ( dc )

Value:

instr_create_1dst_1src((dc), OP_fsin, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fsincos

#define INSTR_CREATE_fsincos ( dc )

Value:

instr_create_1dst_1src((dc), OP_fsincos, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fsqrt

#define INSTR_CREATE_fsqrt ( dc )

Value:

instr_create_1dst_1src((dc), OP_fsqrt, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fst

#define INSTR_CREATE_fst	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_fst, (d), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fstp

#define INSTR_CREATE_fstp	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_fstp, (d), opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()).

◆ INSTR_CREATE_fsub

#define INSTR_CREATE_fsub	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fsub, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_fsubp

#define INSTR_CREATE_fsubp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_fsubp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fsubr

#define INSTR_CREATE_fsubr	(	dc,
		f,
		s
	)	instr_create_1dst_2src((dc), OP_fsubr, (f), (s), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given operands, automatically supplying any further implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
s	The opnd_t source (and non-destination) operand for the instruction, which must be one of the following: A floating point register (opnd_create_reg()). A memory reference (opnd_create_base_disp() or opnd_create_far_base_disp()), in which case the destination `f` must be DR_REG_ST0.

◆ INSTR_CREATE_fsubrp

#define INSTR_CREATE_fsubrp	(	dc,
		f
	)	instr_create_1dst_2src((dc), OP_fsubrp, (f), opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit destination + source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_ftst

#define INSTR_CREATE_ftst ( dc )

Value:

instr_create_1dst_1src((dc), OP_ftst, opnd_create_reg(DR_REG_ST0), \

opnd_create_immed_float(0.0f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fucom

#define INSTR_CREATE_fucom	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fucom, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fucomi

#define INSTR_CREATE_fucomi	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fucomi, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fucomip

#define INSTR_CREATE_fucomip	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fucomip, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fucomp

#define INSTR_CREATE_fucomp	(	dc,
		f
	)	instr_create_0dst_2src((dc), OP_fucomp, opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()). The other (implicit) source operand is DR_REG_ST0.

◆ INSTR_CREATE_fucompp

#define INSTR_CREATE_fucompp ( dc )

Value:

instr_create_0dst_2src((dc), OP_fucompp, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fwait

#define INSTR_CREATE_fwait ( dc ) instr_create_0dst_0src((dc), OP_fwait)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fxam

#define INSTR_CREATE_fxam ( dc ) instr_create_0dst_1src((dc), OP_fxam, opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fxch

#define INSTR_CREATE_fxch	(	dc,
		f
	)

Value:

instr_create_2dst_2src((dc), OP_fxch, opnd_create_reg(DR_REG_ST0), (f), \

opnd_create_reg(DR_REG_ST0), (f))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit register operand, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
f	The opnd_t explicit source operand for the instruction, which must be a floating point register (opnd_create_reg()).

◆ INSTR_CREATE_fxrstor32

#define INSTR_CREATE_fxrstor32	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_fxrstor32, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_fxrstor() to get the appropriate operand size.

◆ INSTR_CREATE_fxrstor64

#define INSTR_CREATE_fxrstor64	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_fxrstor64, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_fxrstor() to get the appropriate operand size.

◆ INSTR_CREATE_fxsave32

#define INSTR_CREATE_fxsave32	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_fxsave32, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_fxsave() to get the appropriate operand size.

◆ INSTR_CREATE_fxsave64

#define INSTR_CREATE_fxsave64	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_fxsave64, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_fxsave() to get the appropriate operand size.

◆ INSTR_CREATE_fxtract

#define INSTR_CREATE_fxtract ( dc )

Value:

instr_create_1dst_1src((dc), OP_fxtract, opnd_create_reg(DR_REG_ST0), \

opnd_create_reg(DR_REG_ST0))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fyl2x

#define INSTR_CREATE_fyl2x ( dc )

Value:

    instr_create_2dst_2src((dc), OP_fyl2x, opnd_create_reg(DR_REG_ST0),              \
                           opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0), \
                           opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_fyl2xp1

#define INSTR_CREATE_fyl2xp1 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_fyl2xp1, opnd_create_reg(DR_REG_ST0),            \
                           opnd_create_reg(DR_REG_ST1), opnd_create_reg(DR_REG_ST0), \
                           opnd_create_reg(DR_REG_ST1))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_getsec

#define INSTR_CREATE_getsec ( dc )

Value:

    INSTR_PRED(instr_create_3dst_2src(                                        \
                   (dc), OP_getsec, opnd_create_reg(DR_REG_EAX),              \
                   opnd_create_reg(DR_REG_EBX), opnd_create_reg(DR_REG_ECX),  \
                   opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_EBX)), \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_gf2p8affineinvqb

#define INSTR_CREATE_gf2p8affineinvqb	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_gf2p8affineinvqb, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_gf2p8affineqb

#define INSTR_CREATE_gf2p8affineqb	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_gf2p8affineqb, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_gf2p8mulb

#define INSTR_CREATE_gf2p8mulb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_gf2p8mulb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_haddpd

#define INSTR_CREATE_haddpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_haddpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_haddps

#define INSTR_CREATE_haddps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_haddps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_hlt

#define INSTR_CREATE_hlt ( dc ) instr_create_0dst_0src((dc), OP_hlt)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_hsubpd

#define INSTR_CREATE_hsubpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_hsubpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_hsubps

#define INSTR_CREATE_hsubps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_hsubps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_idiv_1

#define INSTR_CREATE_idiv_1	(	dc,
		s
	)

Value:

instr_create_2dst_2src((dc), OP_idiv, opnd_create_reg(DR_REG_AH), \

opnd_create_reg(DR_REG_AL), (s), opnd_create_reg(DR_REG_AX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_idiv_4

#define INSTR_CREATE_idiv_4	(	dc,
		s
	)

Value:

    instr_create_2dst_3src((dc), OP_idiv, opnd_create_reg(DR_REG_EDX), \
                           opnd_create_reg(DR_REG_EAX), (s),           \
                           opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_imul

#define INSTR_CREATE_imul	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_imul, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_imul_1

#define INSTR_CREATE_imul_1	(	dc,
		s
	)

Value:

instr_create_1dst_2src((dc), OP_imul, opnd_create_reg(DR_REG_AX), (s), \

opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_imul_4

#define INSTR_CREATE_imul_4	(	dc,
		s
	)

Value:

    instr_create_2dst_2src((dc), OP_imul, opnd_create_reg(DR_REG_EDX), \
                           opnd_create_reg(DR_REG_EAX), (s),           \
                           opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_imul_imm

#define INSTR_CREATE_imul_imm	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_imul, (d), (s), (i))

This INSTR_CREATE_xxx_imm macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _imm suffix distinguishes between alternative forms of the same opcode: this form takes an explicit immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_in_1

#define INSTR_CREATE_in_1 ( dc )

Value:

instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_AL), \

opnd_create_reg(DR_REG_DX))

Creates an instr_t for an OP_in instruction with a source of al (INSTR_CREATE_in_1()) or eax (INSTR_CREATE_in_4()) and dx.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_in_1_imm

#define INSTR_CREATE_in_1_imm	(	dc,
		i
	)	instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_AL), (i))

Creates an instr_t for an OP_in instruction with a source of al (INSTR_CREATE_in_1_imm()) or eax (INSTR_CREATE_in_4_imm()) and an immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_in_4

#define INSTR_CREATE_in_4 ( dc )

Value:

instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_DX))

Creates an instr_t for an OP_in instruction with a source of al (INSTR_CREATE_in_1()) or eax (INSTR_CREATE_in_4()) and dx.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_in_4_imm

#define INSTR_CREATE_in_4_imm	(	dc,
		i
	)	instr_create_1dst_1src((dc), OP_in, opnd_create_reg(DR_REG_EAX), (i))

Creates an instr_t for an OP_in instruction with a source of al (INSTR_CREATE_in_1_imm()) or eax (INSTR_CREATE_in_4_imm()) and an immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_inc

#define INSTR_CREATE_inc	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_inc, (d), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_ins_1

#define INSTR_CREATE_ins_1 ( dc )

Value:

    instr_create_2dst_2src(                                                          \
        (dc), OP_ins,                                                                \
        opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_DX),                     \
        opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ins_4

#define INSTR_CREATE_ins_4 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_ins,                                                 \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_DX),      \
                           opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_insertps

#define INSTR_CREATE_insertps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_insertps, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_insertq

#define INSTR_CREATE_insertq	(	dc,
		d,
		r
	)	instr_create_1dst_1src((dc), OP_insertq, (d), (r))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
r	The opnd_t explicit source operand for the instruction, which must be an xmm register (opnd_create_reg()).

◆ INSTR_CREATE_insertq_imm

#define INSTR_CREATE_insertq_imm	(	dc,
		d,
		r,
		i1,
		i2
	)	instr_create_1dst_3src((dc), OP_insertq, (d), (r), (i1), (i2))

This INSTR_CREATE_xxx_imm macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _imm suffix distinguishes between alternative forms of the same opcode: this form takes explicit immediates.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
r	The opnd_t explicit first source operand for the instruction, which must be an xmm register (opnd_create_reg()).
i1	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
i2	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_int

#define INSTR_CREATE_int	(	dc,
		i
	)	instr_create_0dst_1src((dc), OP_int, (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_int1

#define INSTR_CREATE_int1 ( dc ) instr_create_0dst_0src((dc), OP_int1)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_int3

#define INSTR_CREATE_int3 ( dc ) instr_create_0dst_0src((dc), OP_int3)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_into

#define INSTR_CREATE_into ( dc ) instr_create_0dst_0src((dc), OP_into)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_invd

#define INSTR_CREATE_invd ( dc ) instr_create_0dst_0src((dc), OP_invd)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_invept

#define INSTR_CREATE_invept	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_invept, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_invlpg

#define INSTR_CREATE_invlpg	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_invlpg, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_invlpg() to get the appropriate operand size.

◆ INSTR_CREATE_invlpga

#define INSTR_CREATE_invlpga ( dc )

Value:

instr_create_0dst_2src((dc), OP_invlpga, opnd_create_reg(DR_REG_XAX), \

opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_invpcid

#define INSTR_CREATE_invpcid	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_invpcid, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_invvpid

#define INSTR_CREATE_invvpid	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_invvpid, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_iret

#define INSTR_CREATE_iret ( dc )

Value:

    instr_create_1dst_2src((dc), OP_iret, opnd_create_reg(DR_REG_XSP),          \
                           opnd_create_reg(DR_REG_XSP),                         \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, \
                                                 IF_X64_ELSE(OPSZ_40, OPSZ_12)))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_jcc

#define INSTR_CREATE_jcc	(	dc,
		op,
		t
	)	instr_create_0dst_1src((dc), (op), (t))

Creates an instr_t for a conditional branch instruction with the given opcode and target operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
op	The OP_xxx opcode for the conditional branch, which should be in the range [OP_jo, OP_jnle].
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_jcc_short

#define INSTR_CREATE_jcc_short	(	dc,
		op,
		t
	)	instr_create_0dst_1src((dc), (op), (t))

Creates an instr_t for a short conditional branch instruction with the given opcode and target operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
op	The OP_xxx opcode for the conditional branch, which should be in the range [OP_jo_short, OP_jnle_short].
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ INSTR_CREATE_jcxz

#define INSTR_CREATE_jcxz	(	dc,
		t
	)	instr_create_0dst_2src((dc), OP_jecxz, (t), opnd_create_reg(DR_REG_CX))

Creates an instr_t for an OP_jecxz instruction that uses cx instead of ecx (there is no separate OP_jcxz).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_jecxz

#define INSTR_CREATE_jecxz	(	dc,
		t
	)	instr_create_0dst_2src((dc), OP_jecxz, (t), opnd_create_reg(DR_REG_XCX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_jmp

#define INSTR_CREATE_jmp	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_jmp, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_jmp_far

#define INSTR_CREATE_jmp_far	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_jmp_far, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a far pc operand created with opnd_create_far_pc().

◆ INSTR_CREATE_jmp_far_ind

#define INSTR_CREATE_jmp_far_ind	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_jmp_far_ind, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a far memory reference created with opnd_create_far_base_disp().

◆ INSTR_CREATE_jmp_ind

#define INSTR_CREATE_jmp_ind	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_jmp_ind, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which should be a memory reference created with opnd_create_base_disp().

◆ INSTR_CREATE_jmp_short

#define INSTR_CREATE_jmp_short	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_jmp_short, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_kaddb

#define INSTR_CREATE_kaddb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kaddb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kaddd

#define INSTR_CREATE_kaddd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kaddd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kaddq

#define INSTR_CREATE_kaddq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kaddq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kaddw

#define INSTR_CREATE_kaddw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kaddw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandb

#define INSTR_CREATE_kandb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandd

#define INSTR_CREATE_kandd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandnb

#define INSTR_CREATE_kandnb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandnb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandnd

#define INSTR_CREATE_kandnd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandnd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandnq

#define INSTR_CREATE_kandnq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandnq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandnw

#define INSTR_CREATE_kandnw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandnw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandq

#define INSTR_CREATE_kandq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kandw

#define INSTR_CREATE_kandw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kandw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kmovb

#define INSTR_CREATE_kmovb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kmovb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kmovd

#define INSTR_CREATE_kmovd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kmovd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kmovq

#define INSTR_CREATE_kmovq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kmovq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kmovw

#define INSTR_CREATE_kmovw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kmovw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_knotb

#define INSTR_CREATE_knotb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_knotb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_knotd

#define INSTR_CREATE_knotd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_knotd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_knotq

#define INSTR_CREATE_knotq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_knotq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_knotw

#define INSTR_CREATE_knotw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_knotw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_korb

#define INSTR_CREATE_korb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_korb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kord

#define INSTR_CREATE_kord	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kord, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_korq

#define INSTR_CREATE_korq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_korq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kortestb

#define INSTR_CREATE_kortestb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kortestb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kortestd

#define INSTR_CREATE_kortestd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kortestd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kortestq

#define INSTR_CREATE_kortestq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kortestq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kortestw

#define INSTR_CREATE_kortestw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_kortestw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_korw

#define INSTR_CREATE_korw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_korw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftlb

#define INSTR_CREATE_kshiftlb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftlb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftld

#define INSTR_CREATE_kshiftld	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftld, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftlq

#define INSTR_CREATE_kshiftlq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftlq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftlw

#define INSTR_CREATE_kshiftlw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftlw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftrb

#define INSTR_CREATE_kshiftrb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftrb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftrd

#define INSTR_CREATE_kshiftrd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftrd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftrq

#define INSTR_CREATE_kshiftrq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftrq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kshiftrw

#define INSTR_CREATE_kshiftrw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kshiftrw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_ktestb

#define INSTR_CREATE_ktestb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_ktestb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ktestd

#define INSTR_CREATE_ktestd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_ktestd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ktestq

#define INSTR_CREATE_ktestq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_ktestq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ktestw

#define INSTR_CREATE_ktestw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_ktestw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_kunpckbw

#define INSTR_CREATE_kunpckbw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kunpckbw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kunpckdq

#define INSTR_CREATE_kunpckdq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kunpckdq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kunpckwd

#define INSTR_CREATE_kunpckwd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kunpckwd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxnorb

#define INSTR_CREATE_kxnorb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxnorb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxnord

#define INSTR_CREATE_kxnord	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxnord, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxnorq

#define INSTR_CREATE_kxnorq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxnorq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxnorw

#define INSTR_CREATE_kxnorw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxnorw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxorb

#define INSTR_CREATE_kxorb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxorb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxord

#define INSTR_CREATE_kxord	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxord, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxorq

#define INSTR_CREATE_kxorq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxorq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_kxorw

#define INSTR_CREATE_kxorw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_kxorw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_lahf

#define INSTR_CREATE_lahf ( dc ) instr_create_1dst_0src((dc), OP_lahf, opnd_create_reg(DR_REG_AH))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_lar

#define INSTR_CREATE_lar	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_lar, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lddqu

#define INSTR_CREATE_lddqu	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_lddqu, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ldmxcsr

#define INSTR_CREATE_ldmxcsr	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_ldmxcsr, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lds

#define INSTR_CREATE_lds	(	dc,
		d,
		s
	)	instr_create_2dst_1src((dc), OP_lds, (d), opnd_create_reg(DR_SEG_DS), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lea

#define INSTR_CREATE_lea	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_lea, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_lea() to get the appropriate operand size.

◆ INSTR_CREATE_leave

#define INSTR_CREATE_leave ( dc )

Value:

    instr_create_2dst_3src(                                                       \
        (dc), OP_leave, opnd_create_reg(DR_REG_XSP), opnd_create_reg(DR_REG_XBP), \
        opnd_create_reg(DR_REG_XBP), opnd_create_reg(DR_REG_XSP),                 \
        opnd_create_base_disp(DR_REG_XBP, DR_REG_NULL, 0, 0, OPSZ_STACK))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_les

#define INSTR_CREATE_les	(	dc,
		d,
		s
	)	instr_create_2dst_1src((dc), OP_les, (d), opnd_create_reg(DR_SEG_ES), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lfence

#define INSTR_CREATE_lfence ( dc ) instr_create_0dst_0src((dc), OP_lfence)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_lfs

#define INSTR_CREATE_lfs	(	dc,
		d,
		s
	)	instr_create_2dst_1src((dc), OP_lfs, (d), opnd_create_reg(DR_SEG_FS), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lgdt

#define INSTR_CREATE_lgdt	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_lgdt, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_lgdt() to get the appropriate operand size.

◆ INSTR_CREATE_lgs

#define INSTR_CREATE_lgs	(	dc,
		d,
		s
	)	instr_create_2dst_1src((dc), OP_lgs, (d), opnd_create_reg(DR_SEG_GS), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lidt

#define INSTR_CREATE_lidt	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_lidt, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_lidt() to get the appropriate operand size.

◆ INSTR_CREATE_lldt

#define INSTR_CREATE_lldt	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_lldt, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_llwpcb

#define INSTR_CREATE_llwpcb	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_llwpcb, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lmsw

#define INSTR_CREATE_lmsw	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_lmsw, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lods_1

#define INSTR_CREATE_lods_1 ( dc )

Value:

    instr_create_2dst_2src(                                                          \
        (dc), OP_lods, opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XSI),      \
        opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XSI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_lods_4

#define INSTR_CREATE_lods_4 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_lods, opnd_create_reg(DR_REG_EAX),                   \
                           opnd_create_reg(DR_REG_XSI),                                  \
                           opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_short2),               \
                           opnd_create_reg(DR_REG_XSI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_lods_8

#define INSTR_CREATE_lods_8 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_lods, opnd_create_reg(DR_REG_XAX),                   \
                           opnd_create_reg(DR_REG_XSI),                                  \
                           opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, \
                                                     0, 0, OPSZ_8_short2),               \
                           opnd_create_reg(DR_REG_XSI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_loop

#define INSTR_CREATE_loop	(	dc,
		t
	)

Value:

instr_create_1dst_2src((dc), OP_loop, opnd_create_reg(DR_REG_XCX), (t), \

opnd_create_reg(DR_REG_XCX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_loope

#define INSTR_CREATE_loope	(	dc,
		t
	)

Value:

instr_create_1dst_2src((dc), OP_loope, opnd_create_reg(DR_REG_XCX), (t), \

opnd_create_reg(DR_REG_XCX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_loopne

#define INSTR_CREATE_loopne	(	dc,
		t
	)

Value:

instr_create_1dst_2src((dc), OP_loopne, opnd_create_reg(DR_REG_XCX), (t), \

opnd_create_reg(DR_REG_XCX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_lsl

#define INSTR_CREATE_lsl	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_lsl, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lss

#define INSTR_CREATE_lss	(	dc,
		d,
		s
	)	instr_create_2dst_1src((dc), OP_lss, (d), opnd_create_reg(DR_SEG_SS), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ltr

#define INSTR_CREATE_ltr	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_ltr, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_lwpins

#define INSTR_CREATE_lwpins	(	dc,
		s1,
		s2,
		i
	)	instr_create_0dst_3src((dc), OP_lwpins, (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction, which must be a general-purpose register.
s2	The opnd_t second source operand for the instruction
i	The opnd_t third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_lwpval

#define INSTR_CREATE_lwpval	(	dc,
		s1,
		s2,
		i
	)	instr_create_0dst_3src((dc), OP_lwpval, (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction, which must be a general-purpose register.
s2	The opnd_t second source operand for the instruction
i	The opnd_t third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_lzcnt

#define INSTR_CREATE_lzcnt	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_lzcnt, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_maskmovdqu

#define INSTR_CREATE_maskmovdqu	(	dc,
		s1,
		s2
	)

Value:

    INSTR_PRED(instr_create_1dst_2src((dc), OP_maskmovdqu,                             \
                                      opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XDI, \
                                                                DR_REG_NULL, 0, 0,     \
                                                                OPSZ_maskmovdqu),      \
                                      (s1), (s2)),                                     \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_maskmovq

#define INSTR_CREATE_maskmovq	(	dc,
		s1,
		s2
	)

Value:

    INSTR_PRED(instr_create_1dst_2src((dc), OP_maskmovq,                               \
                                      opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XDI, \
                                                                DR_REG_NULL, 0, 0,     \
                                                                OPSZ_maskmovq),        \
                                      (s1), (s2)),                                     \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_maxpd

#define INSTR_CREATE_maxpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_maxpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_maxps

#define INSTR_CREATE_maxps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_maxps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_maxsd

#define INSTR_CREATE_maxsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_maxsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_maxss

#define INSTR_CREATE_maxss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_maxss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mfence

#define INSTR_CREATE_mfence ( dc ) instr_create_0dst_0src((dc), OP_mfence)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_minpd

#define INSTR_CREATE_minpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_minpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_minps

#define INSTR_CREATE_minps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_minps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_minsd

#define INSTR_CREATE_minsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_minsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_minss

#define INSTR_CREATE_minss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_minss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_monitor

#define INSTR_CREATE_monitor ( dc )

Value:

instr_create_0dst_3src((dc), OP_monitor, opnd_create_reg(DR_REG_XAX), \

opnd_create_reg(DR_REG_ECX), opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_monitorx

#define INSTR_CREATE_monitorx ( dc )

Value:

instr_create_0dst_3src((dc), OP_monitorx, opnd_create_reg(DR_REG_XAX), \

opnd_create_reg(DR_REG_ECX), opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_mov_imm

#define INSTR_CREATE_mov_imm	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_mov_imm, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mov_ld

#define INSTR_CREATE_mov_ld	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_mov_ld, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mov_priv

#define INSTR_CREATE_mov_priv	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_mov_priv, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mov_seg

#define INSTR_CREATE_mov_seg	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_mov_seg, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mov_st

#define INSTR_CREATE_mov_st	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_mov_st, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movapd

#define INSTR_CREATE_movapd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movapd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movaps

#define INSTR_CREATE_movaps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movaps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movbe

#define INSTR_CREATE_movbe	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movbe, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movd

#define INSTR_CREATE_movd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movddup

#define INSTR_CREATE_movddup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movddup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movdir64b

#define INSTR_CREATE_movdir64b	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movdir64b, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movdiri

#define INSTR_CREATE_movdiri	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movdiri, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movdq2q

#define INSTR_CREATE_movdq2q	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movdq2q, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movdqa

#define INSTR_CREATE_movdqa	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movdqa, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movdqu

#define INSTR_CREATE_movdqu	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movdqu, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movhpd

#define INSTR_CREATE_movhpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movhpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movhps

#define INSTR_CREATE_movhps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movhps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movlpd

#define INSTR_CREATE_movlpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movlpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movlps

#define INSTR_CREATE_movlps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movlps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movmskpd

#define INSTR_CREATE_movmskpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movmskpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movmskps

#define INSTR_CREATE_movmskps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movmskps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntdq

#define INSTR_CREATE_movntdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntdqa

#define INSTR_CREATE_movntdqa	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntdqa, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movnti

#define INSTR_CREATE_movnti	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movnti, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntpd

#define INSTR_CREATE_movntpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntps

#define INSTR_CREATE_movntps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntq

#define INSTR_CREATE_movntq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntsd

#define INSTR_CREATE_movntsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movntss

#define INSTR_CREATE_movntss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movntss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movq

#define INSTR_CREATE_movq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movq2dq

#define INSTR_CREATE_movq2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movq2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movs_1

#define INSTR_CREATE_movs_1 ( dc )

Value:

    instr_create_3dst_3src(                                                          \
        (dc), OP_movs,                                                               \
        opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),                    \
        opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_movs_4

#define INSTR_CREATE_movs_4 ( dc )

Value:

    instr_create_3dst_3src((dc), OP_movs,                                                \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),     \
                           opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_movsd

#define INSTR_CREATE_movsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movshdup

#define INSTR_CREATE_movshdup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movshdup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movsldup

#define INSTR_CREATE_movsldup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movsldup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movss

#define INSTR_CREATE_movss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movsx

#define INSTR_CREATE_movsx	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movsx, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movsxd

#define INSTR_CREATE_movsxd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movsxd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movupd

#define INSTR_CREATE_movupd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movupd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movups

#define INSTR_CREATE_movups	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movups, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_movzx

#define INSTR_CREATE_movzx	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_movzx, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mpsadbw

#define INSTR_CREATE_mpsadbw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_mpsadbw, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_mul_1

#define INSTR_CREATE_mul_1	(	dc,
		s
	)

Value:

instr_create_1dst_2src((dc), OP_mul, opnd_create_reg(DR_REG_AX), (s), \

opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mul_4

#define INSTR_CREATE_mul_4	(	dc,
		s
	)

Value:

    instr_create_2dst_2src((dc), OP_mul, opnd_create_reg(DR_REG_EDX), \
                           opnd_create_reg(DR_REG_EAX), (s),          \
                           opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx, INSTR_CREATE_xxx_1, or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mulpd

#define INSTR_CREATE_mulpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_mulpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mulps

#define INSTR_CREATE_mulps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_mulps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mulsd

#define INSTR_CREATE_mulsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_mulsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mulss

#define INSTR_CREATE_mulss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_mulss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mulx

#define INSTR_CREATE_mulx	(	dc,
		d1,
		d2,
		s
	)

Value:

    instr_create_2dst_2src(              \
        (dc), OP_mulx, (d1), (d2), (s),  \
        opnd_create_reg(reg_resize_to_opsz(DR_REG_EDX, opnd_get_size(d1))))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d1	The opnd_t explicit first destination source operand for the instruction, which must be a general-purpose register.
d2	The opnd_t explicit first destination source operand for the instruction, which must be a general-purpose register.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_mwait

#define INSTR_CREATE_mwait ( dc )

Value:

instr_create_0dst_2src((dc), OP_mwait, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_mwaitx

#define INSTR_CREATE_mwaitx ( dc )

Value:

instr_create_0dst_2src((dc), OP_mwaitx, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_neg

#define INSTR_CREATE_neg	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_neg, (d), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_nop

#define INSTR_CREATE_nop ( dc ) instr_create_0dst_0src((dc), OP_nop)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_nop1byte

#define INSTR_CREATE_nop1byte ( dc ) INSTR_CREATE_nop(dc)

Convenience routine for nop of certain size. We choose edi as working register for multibyte nops (seems least likely to impact performance: Microsoft uses it and DR used to steal it). Note that Intel now recommends a different set of multi-byte nops, but we stick with these as our tools (mainly windbg) don't understand the OP_nop_modrm encoding (though should work on PPro+).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_nop2byte

#define INSTR_CREATE_nop2byte ( dc ) INSTR_CREATE_nop2byte_reg(dc, DR_REG_XDI)

Convenience routine for nop of certain size. We choose edi as working register for multibyte nops (seems least likely to impact performance: Microsoft uses it and DR used to steal it). Note that Intel now recommends a different set of multi-byte nops, but we stick with these as our tools (mainly windbg) don't understand the OP_nop_modrm encoding (though should work on PPro+).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_nop3byte

#define INSTR_CREATE_nop3byte ( dc ) INSTR_CREATE_nop3byte_reg(dc, DR_REG_XDI)

Convenience routine for nop of certain size. We choose edi as working register for multibyte nops (seems least likely to impact performance: Microsoft uses it and DR used to steal it). Note that Intel now recommends a different set of multi-byte nops, but we stick with these as our tools (mainly windbg) don't understand the OP_nop_modrm encoding (though should work on PPro+).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_nop_modrm

#define INSTR_CREATE_nop_modrm	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_nop_modrm, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_not

#define INSTR_CREATE_not	(	dc,
		d
	)	instr_create_1dst_1src((dc), OP_not, (d), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_or

#define INSTR_CREATE_or	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_or, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_orpd

#define INSTR_CREATE_orpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_orpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_orps

#define INSTR_CREATE_orps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_orps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_out_1

#define INSTR_CREATE_out_1 ( dc )

Value:

instr_create_0dst_2src((dc), OP_out, opnd_create_reg(DR_REG_AL), \

opnd_create_reg(DR_REG_DX))

Creates an instr_t for an OP_out instruction with a source of al (INSTR_CREATE_out_1()) or eax (INSTR_CREATE_out_4()) and dx.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_out_1_imm

#define INSTR_CREATE_out_1_imm	(	dc,
		i
	)	instr_create_0dst_2src((dc), OP_out, (i), opnd_create_reg(DR_REG_AL))

Creates an instr_t for an OP_out instruction with a source of al (INSTR_CREATE_out_1_imm()) or eax (INSTR_CREATE_out_4_imm()) and an immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_out_4

#define INSTR_CREATE_out_4 ( dc )

Value:

instr_create_0dst_2src((dc), OP_out, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_DX))

Creates an instr_t for an OP_out instruction with a source of al (INSTR_CREATE_out_1()) or eax (INSTR_CREATE_out_4()) and dx.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_out_4_imm

#define INSTR_CREATE_out_4_imm	(	dc,
		i
	)	instr_create_0dst_2src((dc), OP_out, (i), opnd_create_reg(DR_REG_EAX))

Creates an instr_t for an OP_out instruction with a source of al (INSTR_CREATE_out_1_imm()) or eax (INSTR_CREATE_out_4_imm()) and an immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_outs_1

#define INSTR_CREATE_outs_1 ( dc )

Value:

    instr_create_1dst_3src(                                                          \
        (dc), OP_outs, opnd_create_reg(DR_REG_XSI),                                  \
        opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XSI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_outs_4

#define INSTR_CREATE_outs_4 ( dc )

Value:

    instr_create_1dst_3src((dc), OP_outs, opnd_create_reg(DR_REG_XSI),                   \
                           opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XSI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_pabsb

#define INSTR_CREATE_pabsb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pabsb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pabsd

#define INSTR_CREATE_pabsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pabsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pabsw

#define INSTR_CREATE_pabsw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pabsw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_packssdw

#define INSTR_CREATE_packssdw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_packssdw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_packsswb

#define INSTR_CREATE_packsswb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_packsswb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_packusdw

#define INSTR_CREATE_packusdw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_packusdw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_packuswb

#define INSTR_CREATE_packuswb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_packuswb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddb

#define INSTR_CREATE_paddb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddd

#define INSTR_CREATE_paddd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddq

#define INSTR_CREATE_paddq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddsb

#define INSTR_CREATE_paddsb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddsb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddsw

#define INSTR_CREATE_paddsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddusb

#define INSTR_CREATE_paddusb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddusb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddusw

#define INSTR_CREATE_paddusw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddusw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_paddw

#define INSTR_CREATE_paddw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_paddw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_palignr

#define INSTR_CREATE_palignr	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_palignr, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pand

#define INSTR_CREATE_pand	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pand, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pandn

#define INSTR_CREATE_pandn	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pandn, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pause

#define INSTR_CREATE_pause ( dc ) instr_create_0dst_0src((dc), OP_pause)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_pavgb

#define INSTR_CREATE_pavgb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pavgb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pavgusb

#define INSTR_CREATE_pavgusb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pavgusb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pavgw

#define INSTR_CREATE_pavgw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pavgw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pblendvb

#define INSTR_CREATE_pblendvb	(	dc,
		d,
		s
	)	instr_create_1dst_3src((dc), OP_pblendvb, (d), (s), opnd_create_reg(DR_REG_XMM0), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pblendw

#define INSTR_CREATE_pblendw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_pblendw, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pclmulqdq

#define INSTR_CREATE_pclmulqdq	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_pclmulqdq, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pcmpeqb

#define INSTR_CREATE_pcmpeqb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpeqb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpeqd

#define INSTR_CREATE_pcmpeqd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpeqd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpeqq

#define INSTR_CREATE_pcmpeqq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpeqq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpeqw

#define INSTR_CREATE_pcmpeqw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpeqw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpestri

#define INSTR_CREATE_pcmpestri	(	dc,
		s1,
		s2,
		i
	)

Value:

    instr_create_1dst_5src((dc), OP_pcmpestri, opnd_create_reg(DR_REG_ECX), (s1), (s2), \
                           (i), opnd_create_reg(DR_REG_EAX),                            \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pcmpestrm

#define INSTR_CREATE_pcmpestrm	(	dc,
		s1,
		s2,
		i
	)

Value:

    instr_create_1dst_5src((dc), OP_pcmpestrm, opnd_create_reg(DR_REG_XMM0), (s1), (s2), \
                           (i), opnd_create_reg(DR_REG_EAX),                             \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pcmpgtb

#define INSTR_CREATE_pcmpgtb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpgtb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpgtd

#define INSTR_CREATE_pcmpgtd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpgtd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpgtq

#define INSTR_CREATE_pcmpgtq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpgtq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpgtw

#define INSTR_CREATE_pcmpgtw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pcmpgtw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pcmpistri

#define INSTR_CREATE_pcmpistri	(	dc,
		s1,
		s2,
		i
	)

Value:

instr_create_1dst_3src((dc), OP_pcmpistri, opnd_create_reg(DR_REG_ECX), (s1), (s2), \

(i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pcmpistrm

#define INSTR_CREATE_pcmpistrm	(	dc,
		s1,
		s2,
		i
	)

Value:

instr_create_1dst_3src((dc), OP_pcmpistrm, opnd_create_reg(DR_REG_XMM0), (s1), (s2), \

(i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pdep

#define INSTR_CREATE_pdep	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_pdep, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_pext

#define INSTR_CREATE_pext	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_pext, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_pextrb

#define INSTR_CREATE_pextrb	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pextrb, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pextrd

#define INSTR_CREATE_pextrd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pextrd, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pextrw

#define INSTR_CREATE_pextrw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pextrw, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pf2id

#define INSTR_CREATE_pf2id	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pf2id, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pf2iw

#define INSTR_CREATE_pf2iw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pf2iw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfacc

#define INSTR_CREATE_pfacc	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfacc, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfadd

#define INSTR_CREATE_pfadd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfadd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfcmpeq

#define INSTR_CREATE_pfcmpeq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfcmpeq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfcmpge

#define INSTR_CREATE_pfcmpge	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfcmpge, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfcmpgt

#define INSTR_CREATE_pfcmpgt	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfcmpgt, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfmax

#define INSTR_CREATE_pfmax	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfmax, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfmin

#define INSTR_CREATE_pfmin	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfmin, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfmul

#define INSTR_CREATE_pfmul	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfmul, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfnacc

#define INSTR_CREATE_pfnacc	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfnacc, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfpnacc

#define INSTR_CREATE_pfpnacc	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfpnacc, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfrcp

#define INSTR_CREATE_pfrcp	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfrcp, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfrcpit1

#define INSTR_CREATE_pfrcpit1	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfrcpit1, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfrcpit2

#define INSTR_CREATE_pfrcpit2	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfrcpit2, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfrsqit1

#define INSTR_CREATE_pfrsqit1	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfrsqit1, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfrsqrt

#define INSTR_CREATE_pfrsqrt	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfrsqrt, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfsub

#define INSTR_CREATE_pfsub	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfsub, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pfsubr

#define INSTR_CREATE_pfsubr	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pfsubr, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phaddd

#define INSTR_CREATE_phaddd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phaddd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phaddsw

#define INSTR_CREATE_phaddsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phaddsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phaddw

#define INSTR_CREATE_phaddw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phaddw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phminposuw

#define INSTR_CREATE_phminposuw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_phminposuw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phsubd

#define INSTR_CREATE_phsubd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phsubd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phsubsw

#define INSTR_CREATE_phsubsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phsubsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_phsubw

#define INSTR_CREATE_phsubw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_phsubw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pi2fd

#define INSTR_CREATE_pi2fd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pi2fd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pi2fw

#define INSTR_CREATE_pi2fw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pi2fw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pinsrb

#define INSTR_CREATE_pinsrb	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pinsrb, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pinsrd

#define INSTR_CREATE_pinsrd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pinsrd, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pinsrw

#define INSTR_CREATE_pinsrw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pinsrw, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pmaddubsw

#define INSTR_CREATE_pmaddubsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaddubsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaddwd

#define INSTR_CREATE_pmaddwd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaddwd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxsb

#define INSTR_CREATE_pmaxsb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxsb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxsd

#define INSTR_CREATE_pmaxsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxsw

#define INSTR_CREATE_pmaxsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxub

#define INSTR_CREATE_pmaxub	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxub, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxud

#define INSTR_CREATE_pmaxud	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxud, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmaxuw

#define INSTR_CREATE_pmaxuw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmaxuw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminsb

#define INSTR_CREATE_pminsb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminsb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminsd

#define INSTR_CREATE_pminsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminsw

#define INSTR_CREATE_pminsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminub

#define INSTR_CREATE_pminub	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminub, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminud

#define INSTR_CREATE_pminud	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminud, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pminuw

#define INSTR_CREATE_pminuw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pminuw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovmskb

#define INSTR_CREATE_pmovmskb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovmskb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxbd

#define INSTR_CREATE_pmovsxbd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxbd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxbq

#define INSTR_CREATE_pmovsxbq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxbq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxbw

#define INSTR_CREATE_pmovsxbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxdq

#define INSTR_CREATE_pmovsxdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxwd

#define INSTR_CREATE_pmovsxwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovsxwq

#define INSTR_CREATE_pmovsxwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovsxwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxbd

#define INSTR_CREATE_pmovzxbd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxbd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxbq

#define INSTR_CREATE_pmovzxbq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxbq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxbw

#define INSTR_CREATE_pmovzxbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxdq

#define INSTR_CREATE_pmovzxdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxwd

#define INSTR_CREATE_pmovzxwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmovzxwq

#define INSTR_CREATE_pmovzxwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_pmovzxwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmuldq

#define INSTR_CREATE_pmuldq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmuldq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmulhrsw

#define INSTR_CREATE_pmulhrsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmulhrsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmulhrw

#define INSTR_CREATE_pmulhrw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmulhrw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmulhuw

#define INSTR_CREATE_pmulhuw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmulhuw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmulhw

#define INSTR_CREATE_pmulhw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmulhw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmulld

#define INSTR_CREATE_pmulld	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmulld, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmullw

#define INSTR_CREATE_pmullw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmullw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pmuludq

#define INSTR_CREATE_pmuludq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pmuludq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pop

#define INSTR_CREATE_pop	(	dc,
		d
	)

Value:

    instr_create_2dst_2src(                                                          \
        (dc), OP_pop, (d), opnd_create_reg(DR_REG_XSP), opnd_create_reg(DR_REG_XSP), \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, OPSZ_VARSTACK))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_popa

#define INSTR_CREATE_popa ( dc ) instr_create_popa((dc))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_popcnt

#define INSTR_CREATE_popcnt	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_popcnt, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_popf

#define INSTR_CREATE_popf ( dc )

Value:

    instr_create_1dst_2src(                                                      \
        (dc), OP_popf, opnd_create_reg(DR_REG_XSP), opnd_create_reg(DR_REG_XSP), \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, OPSZ_STACK))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_por

#define INSTR_CREATE_por	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_por, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_prefetch

#define INSTR_CREATE_prefetch	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetch, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_prefetchnta

#define INSTR_CREATE_prefetchnta	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetchnta, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_prefetcht0

#define INSTR_CREATE_prefetcht0	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetcht0, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_prefetcht1

#define INSTR_CREATE_prefetcht1	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetcht1, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_prefetcht2

#define INSTR_CREATE_prefetcht2	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetcht2, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_prefetchw

#define INSTR_CREATE_prefetchw	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_prefetchw, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_prefetch() to get the appropriate operand size.

◆ INSTR_CREATE_psadbw

#define INSTR_CREATE_psadbw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psadbw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pshufb

#define INSTR_CREATE_pshufb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pshufb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pshufd

#define INSTR_CREATE_pshufd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pshufd, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pshufhw

#define INSTR_CREATE_pshufhw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pshufhw, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pshuflw

#define INSTR_CREATE_pshuflw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pshuflw, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pshufw

#define INSTR_CREATE_pshufw	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_pshufw, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_psignb

#define INSTR_CREATE_psignb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psignb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psignd

#define INSTR_CREATE_psignd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psignd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psignw

#define INSTR_CREATE_psignw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psignw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pslld

#define INSTR_CREATE_pslld	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pslld, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pslldq

#define INSTR_CREATE_pslldq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pslldq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psllq

#define INSTR_CREATE_psllq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psllq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psllw

#define INSTR_CREATE_psllw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psllw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psrad

#define INSTR_CREATE_psrad	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psrad, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psraw

#define INSTR_CREATE_psraw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psraw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psrld

#define INSTR_CREATE_psrld	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psrld, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psrldq

#define INSTR_CREATE_psrldq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psrldq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psrlq

#define INSTR_CREATE_psrlq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psrlq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psrlw

#define INSTR_CREATE_psrlw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psrlw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubb

#define INSTR_CREATE_psubb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubd

#define INSTR_CREATE_psubd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubq

#define INSTR_CREATE_psubq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubsb

#define INSTR_CREATE_psubsb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubsb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubsw

#define INSTR_CREATE_psubsw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubsw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubusb

#define INSTR_CREATE_psubusb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubusb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubusw

#define INSTR_CREATE_psubusw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubusw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_psubw

#define INSTR_CREATE_psubw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_psubw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_pswapd

#define INSTR_CREATE_pswapd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pswapd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ptest

#define INSTR_CREATE_ptest	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_ptest, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_ptwrite

#define INSTR_CREATE_ptwrite	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_ptwrite, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be a general-purpose registers or a memory reference. The latter can be created with OPND_CREATE_MEM_ptwrite() to get the appropriate operand size.

◆ INSTR_CREATE_punpckhbw

#define INSTR_CREATE_punpckhbw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpckhbw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpckhdq

#define INSTR_CREATE_punpckhdq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpckhdq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpckhqdq

#define INSTR_CREATE_punpckhqdq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpckhqdq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpckhwd

#define INSTR_CREATE_punpckhwd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpckhwd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpcklbw

#define INSTR_CREATE_punpcklbw	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpcklbw, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpckldq

#define INSTR_CREATE_punpckldq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpckldq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpcklqdq

#define INSTR_CREATE_punpcklqdq	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpcklqdq, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_punpcklwd

#define INSTR_CREATE_punpcklwd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_punpcklwd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_push

#define INSTR_CREATE_push	(	dc,
		s
	)

Value:

    instr_create_2dst_2src((dc), OP_push, opnd_create_reg(DR_REG_XSP),                \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,          \
                                                 IF_X64_ELSE(-8, -4), OPSZ_VARSTACK), \
                           (s), opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_push_imm

#define INSTR_CREATE_push_imm	(	dc,
		i
	)

Value:

    instr_create_2dst_2src((dc), OP_push_imm, opnd_create_reg(DR_REG_XSP),            \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,          \
                                                 IF_X64_ELSE(-8, -4), OPSZ_VARSTACK), \
                           (i), opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_pusha

#define INSTR_CREATE_pusha ( dc ) instr_create_pusha((dc))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_pushf

#define INSTR_CREATE_pushf ( dc )

Value:

    instr_create_2dst_1src((dc), OP_pushf, opnd_create_reg(DR_REG_XSP),            \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0,       \
                                                 IF_X64_ELSE(-8, -4), OPSZ_STACK), \
                           opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_pxor

#define INSTR_CREATE_pxor	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_pxor, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_rcl

#define INSTR_CREATE_rcl	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_rcl, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_rcpps

#define INSTR_CREATE_rcpps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_rcpps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_rcpss

#define INSTR_CREATE_rcpss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_rcpss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_rcr

#define INSTR_CREATE_rcr	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_rcr, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_rdfsbase

#define INSTR_CREATE_rdfsbase	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_rdfsbase, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_rdgsbase

#define INSTR_CREATE_rdgsbase	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_rdgsbase, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_rdmsr

#define INSTR_CREATE_rdmsr ( dc )

Value:

instr_create_2dst_1src((dc), OP_rdmsr, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rdpid

#define INSTR_CREATE_rdpid	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_rdpid, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_rdpkru

#define INSTR_CREATE_rdpkru ( dc )

Value:

instr_create_2dst_1src((dc), OP_rdpkru, opnd_create_reg(DR_REG_EAX), \

opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rdpmc

#define INSTR_CREATE_rdpmc ( dc )

Value:

instr_create_2dst_1src((dc), OP_rdpmc, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rdrand

#define INSTR_CREATE_rdrand	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_rdrand, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which must be a general-purpose register.

◆ INSTR_CREATE_rdseed

#define INSTR_CREATE_rdseed	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_rdseed, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_rdtsc

#define INSTR_CREATE_rdtsc ( dc )

Value:

instr_create_2dst_0src((dc), OP_rdtsc, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rdtscp

#define INSTR_CREATE_rdtscp ( dc )

Value:

instr_create_3dst_0src((dc), OP_rdtscp, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_cmps_1

#define INSTR_CREATE_rep_cmps_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_3dst_5src(                                                          \
            (dc), OP_rep_cmps, opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI), \
            opnd_create_reg(DR_REG_XCX),                                                 \
            opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),                    \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_cmps_4

#define INSTR_CREATE_rep_cmps_4 ( dc )

Value:

    INSTR_PRED(instr_create_3dst_5src(                                                 \
                   (dc), OP_rep_cmps, opnd_create_reg(DR_REG_XSI),                     \
                   opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),           \
                   opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_ins_1

#define INSTR_CREATE_rep_ins_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_3dst_3src(                                                          \
            (dc), OP_rep_ins,                                                            \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),                    \
            opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XDI),                     \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_ins_4

#define INSTR_CREATE_rep_ins_4 ( dc )

Value:

    INSTR_PRED(instr_create_3dst_3src(                                                 \
                   (dc), OP_rep_ins,                                                   \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),           \
                   opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XDI),            \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_lods_1

#define INSTR_CREATE_rep_lods_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_3dst_3src(                                                          \
            (dc), OP_rep_lods, opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XSI),  \
            opnd_create_reg(DR_REG_XCX),                                                 \
            opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XCX)),                   \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_lods_4

#define INSTR_CREATE_rep_lods_4 ( dc )

Value:

    INSTR_PRED(instr_create_3dst_3src(                                                 \
                   (dc), OP_rep_lods, opnd_create_reg(DR_REG_EAX),                     \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XCX),           \
                   opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XCX)),          \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_movs_1

#define INSTR_CREATE_rep_movs_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_4dst_4src(                                                          \
            (dc), OP_rep_movs,                                                           \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),                    \
            opnd_create_reg(DR_REG_XCX),                                                 \
            opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),                    \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_movs_4

#define INSTR_CREATE_rep_movs_4 ( dc )

Value:

    INSTR_PRED(instr_create_4dst_4src(                                                 \
                   (dc), OP_rep_movs,                                                  \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX),                                        \
                   opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_outs_1

#define INSTR_CREATE_rep_outs_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_2dst_4src(                                                          \
            (dc), OP_rep_outs, opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XCX), \
            opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XSI),                     \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_outs_4

#define INSTR_CREATE_rep_outs_4 ( dc )

Value:

    INSTR_PRED(instr_create_2dst_4src(                                                 \
                   (dc), OP_rep_outs, opnd_create_reg(DR_REG_XSI),                     \
                   opnd_create_reg(DR_REG_XCX),                                        \
                   opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_DX), opnd_create_reg(DR_REG_XSI),            \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_scas_1

#define INSTR_CREATE_rep_scas_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_2dst_4src(                                                          \
            (dc), OP_rep_scas, opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX), \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XDI),                     \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_scas_4

#define INSTR_CREATE_rep_scas_4 ( dc )

Value:

    INSTR_PRED(instr_create_2dst_4src(                                                 \
                   (dc), OP_rep_scas, opnd_create_reg(DR_REG_XDI),                     \
                   opnd_create_reg(DR_REG_XCX),                                        \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_stos_1

#define INSTR_CREATE_rep_stos_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_3dst_3src(                                                          \
            (dc), OP_rep_stos,                                                           \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),                    \
            opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XDI),                     \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rep_stos_4

#define INSTR_CREATE_rep_stos_4 ( dc )

Value:

    INSTR_PRED(instr_create_3dst_3src(                                                 \
                   (dc), OP_rep_stos,                                                  \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),           \
                   opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_repne_cmps_1

#define INSTR_CREATE_repne_cmps_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_3dst_5src(                                                          \
            (dc), OP_repne_cmps, opnd_create_reg(DR_REG_XSI),                            \
            opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),                    \
            opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),                    \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_repne_cmps_4

#define INSTR_CREATE_repne_cmps_4 ( dc )

Value:

    INSTR_PRED(instr_create_3dst_5src(                                                 \
                   (dc), OP_repne_cmps, opnd_create_reg(DR_REG_XSI),                   \
                   opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XCX),           \
                   opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XSI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_XSI), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_repne_scas_1

#define INSTR_CREATE_repne_scas_1 ( dc )

Value:

    INSTR_PRED(                                                                          \
        instr_create_2dst_4src(                                                          \
            (dc), OP_repne_scas, opnd_create_reg(DR_REG_XDI),                            \
            opnd_create_reg(DR_REG_XCX),                                                 \
            opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
            opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XDI),                     \
            opnd_create_reg(DR_REG_XCX)),                                                \
        DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_repne_scas_4

#define INSTR_CREATE_repne_scas_4 ( dc )

Value:

    INSTR_PRED(instr_create_2dst_4src(                                                 \
                   (dc), OP_repne_scas, opnd_create_reg(DR_REG_XDI),                   \
                   opnd_create_reg(DR_REG_XCX),                                        \
                   opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, \
                                             OPSZ_4_rex8_short2),                      \
                   opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_XDI),           \
                   opnd_create_reg(DR_REG_XCX)),                                       \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ret

#define INSTR_CREATE_ret ( dc )

Value:

    instr_create_1dst_2src(                                                     \
        (dc), OP_ret, opnd_create_reg(DR_REG_XSP), opnd_create_reg(DR_REG_XSP), \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, OPSZ_ret))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ret_far

#define INSTR_CREATE_ret_far ( dc )

Value:

    instr_create_1dst_2src((dc), OP_ret_far, opnd_create_reg(DR_REG_XSP),       \
                           opnd_create_reg(DR_REG_XSP),                         \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, \
                                                 IF_X64_ELSE(OPSZ_16, OPSZ_8)))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ret_far_imm

#define INSTR_CREATE_ret_far_imm	(	dc,
		i
	)

Value:

    instr_create_1dst_3src((dc), OP_ret_far, opnd_create_reg(DR_REG_XSP), (i),  \
                           opnd_create_reg(DR_REG_XSP),                         \
                           opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, \
                                                 IF_X64_ELSE(OPSZ_16, OPSZ_8)))

This INSTR_CREATE_xxx_imm macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _imm suffix distinguishes between alternative forms of the same opcode: these forms take an explicit immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_ret_imm

#define INSTR_CREATE_ret_imm	(	dc,
		i
	)

Value:

    instr_create_1dst_3src(                                                          \
        (dc), OP_ret, opnd_create_reg(DR_REG_XSP), (i), opnd_create_reg(DR_REG_XSP), \
        opnd_create_base_disp(DR_REG_XSP, DR_REG_NULL, 0, 0, OPSZ_ret))

This INSTR_CREATE_xxx_imm macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The _imm suffix distinguishes between alternative forms of the same opcode: these forms take an explicit immediate.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_rol

#define INSTR_CREATE_rol	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_rol, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_ror

#define INSTR_CREATE_ror	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_ror, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_rorx

#define INSTR_CREATE_rorx	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_rorx, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_roundpd

#define INSTR_CREATE_roundpd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_roundpd, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_roundps

#define INSTR_CREATE_roundps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_roundps, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_roundsd

#define INSTR_CREATE_roundsd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_roundsd, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_roundss

#define INSTR_CREATE_roundss	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_2src((dc), OP_roundss, (d), (s), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_rsm

#define INSTR_CREATE_rsm ( dc ) instr_create_0dst_0src((dc), OP_rsm)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_rsqrtps

#define INSTR_CREATE_rsqrtps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_rsqrtps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_rsqrtss

#define INSTR_CREATE_rsqrtss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_rsqrtss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sahf

#define INSTR_CREATE_sahf ( dc ) instr_create_0dst_1src((dc), OP_sahf, opnd_create_reg(DR_REG_AH))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_salc

#define INSTR_CREATE_salc ( dc ) instr_create_1dst_0src((dc), OP_salc, opnd_create_reg(DR_REG_AL))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sar

#define INSTR_CREATE_sar	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_sar, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_sarx

#define INSTR_CREATE_sarx	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_sarx, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_sbb

#define INSTR_CREATE_sbb	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sbb, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_scas_1

#define INSTR_CREATE_scas_1 ( dc )

Value:

    instr_create_1dst_3src(                                                          \
        (dc), OP_scas, opnd_create_reg(DR_REG_XDI),                                  \
        opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_AL), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_scas_4

#define INSTR_CREATE_scas_4 ( dc )

Value:

    instr_create_1dst_3src((dc), OP_scas, opnd_create_reg(DR_REG_XDI),                   \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_rex8_short2),          \
                           opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_serialize

#define INSTR_CREATE_serialize ( dc ) instr_create_0dst_0src((dc), OP_serialize)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_setcc

#define INSTR_CREATE_setcc	(	dc,
		op,
		d
	)	instr_create_1dst_0src((dc), (op), (d))

Creates an instr_t for a conditional set instruction with the given opcode and destination operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
op	The OP_xxx opcode for the instruction, which should be in the range [OP_seto, OP_setnle].
d	The opnd_t destination operand for the instruction.

◆ INSTR_CREATE_sfence

#define INSTR_CREATE_sfence ( dc ) instr_create_0dst_0src((dc), OP_sfence)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sgdt

#define INSTR_CREATE_sgdt	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_sgdt, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_sgdt() to get the appropriate operand size.

◆ INSTR_CREATE_sha1msg1

#define INSTR_CREATE_sha1msg1	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sha1msg1, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sha1msg2

#define INSTR_CREATE_sha1msg2	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sha1msg2, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sha1nexte

#define INSTR_CREATE_sha1nexte	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sha1nexte, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sha1rnds4

#define INSTR_CREATE_sha1rnds4	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_sha1rnds4, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_sha256msg1

#define INSTR_CREATE_sha256msg1	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sha256msg1, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sha256msg2

#define INSTR_CREATE_sha256msg2	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sha256msg2, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sha256rnds2

#define INSTR_CREATE_sha256rnds2	(	dc,
		d,
		s
	)

Value:

instr_create_1dst_3src((dc), OP_sha256rnds2, (d), (s), opnd_create_reg(DR_REG_XMM0), \

(d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_shl

#define INSTR_CREATE_shl	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_shl, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_shld

#define INSTR_CREATE_shld	(	dc,
		d,
		s,
		ri
	)	instr_create_1dst_3src((dc), OP_shld, (d), (s), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1;

◆ INSTR_CREATE_shlx

#define INSTR_CREATE_shlx	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_shlx, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_shr

#define INSTR_CREATE_shr	(	dc,
		d,
		ri
	)	instr_create_1dst_2src((dc), OP_shr, (d), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1; An immediate integer with value 1 and size OPSZ_0 (opnd_create_immed_int(1, OPSZ_0)), which will become an implicit operand (whereas opnd_create_immed_int(1, OPSZ_1) will be encoded explicitly).

◆ INSTR_CREATE_shrd

#define INSTR_CREATE_shrd	(	dc,
		d,
		s,
		ri
	)	instr_create_1dst_3src((dc), OP_shrd, (d), (s), (ri), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
ri	The opnd_t explicit source operand for the instruction, which must be one of the following: The register cl (opnd_create_reg(DR_REG_CL)); An immediate integer (opnd_create_immed_int()) of size OPSZ_1;

◆ INSTR_CREATE_shrx

#define INSTR_CREATE_shrx	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_shrx, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_shufpd

#define INSTR_CREATE_shufpd	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_shufpd, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_shufps

#define INSTR_CREATE_shufps	(	dc,
		d,
		s,
		i
	)	instr_create_1dst_3src((dc), OP_shufps, (d), (s), (i), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_sidt

#define INSTR_CREATE_sidt	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_sidt, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_sidt() to get the appropriate operand size.

◆ INSTR_CREATE_skinit

#define INSTR_CREATE_skinit ( dc ) instr_create_0dst_1src((dc), OP_skinit, opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sldt

#define INSTR_CREATE_sldt	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_sldt, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_slwpcb

#define INSTR_CREATE_slwpcb	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_slwpcb, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_smsw

#define INSTR_CREATE_smsw	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_smsw, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_sqrtpd

#define INSTR_CREATE_sqrtpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_sqrtpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sqrtps

#define INSTR_CREATE_sqrtps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_sqrtps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sqrtsd

#define INSTR_CREATE_sqrtsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_sqrtsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_sqrtss

#define INSTR_CREATE_sqrtss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_sqrtss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_stac

#define INSTR_CREATE_stac ( dc ) instr_create_0dst_0src((dc), OP_stac)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_stc

#define INSTR_CREATE_stc ( dc ) instr_create_0dst_0src((dc), OP_stc)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_std

#define INSTR_CREATE_std ( dc ) instr_create_0dst_0src((dc), OP_std)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_stgi

#define INSTR_CREATE_stgi ( dc ) instr_create_0dst_0src((dc), OP_stgi)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sti

#define INSTR_CREATE_sti ( dc ) instr_create_0dst_0src((dc), OP_sti)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_stmxcsr

#define INSTR_CREATE_stmxcsr	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_stmxcsr, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_stos_1

#define INSTR_CREATE_stos_1 ( dc )

Value:

    instr_create_2dst_2src(                                                          \
        (dc), OP_stos,                                                               \
        opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, 0, 0, OPSZ_1), \
        opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_AL),                     \
        opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_stos_4

#define INSTR_CREATE_stos_4 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_stos,                                                \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_4_short2),               \
                           opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_EAX),     \
                           opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_stos_8

#define INSTR_CREATE_stos_8 ( dc )

Value:

    instr_create_2dst_2src((dc), OP_stos,                                                \
                           opnd_create_far_base_disp(DR_SEG_ES, DR_REG_XDI, DR_REG_NULL, \
                                                     0, 0, OPSZ_8_short2),               \
                           opnd_create_reg(DR_REG_XDI), opnd_create_reg(DR_REG_XAX),     \
                           opnd_create_reg(DR_REG_XDI))

This INSTR_CREATE_xxx_1 or INSTR_CREATE_xxx_4 macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands. The _1 or _4 suffixes distinguish between alternative forms of the same opcode (1 and 4 identify the operand size).

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_str

#define INSTR_CREATE_str	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_str, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_sub

#define INSTR_CREATE_sub	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_sub, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_subpd

#define INSTR_CREATE_subpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_subpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_subps

#define INSTR_CREATE_subps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_subps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_subsd

#define INSTR_CREATE_subsd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_subsd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_subss

#define INSTR_CREATE_subss	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_subss, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_swapgs

#define INSTR_CREATE_swapgs ( dc ) instr_create_0dst_0src((dc), OP_swapgs)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_syscall

#define INSTR_CREATE_syscall ( dc )

Value:

instr_create_2dst_0src((dc), OP_syscall, opnd_create_reg(DR_REG_XCX), \

opnd_create_reg(DR_REG_R11))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sysenter

#define INSTR_CREATE_sysenter ( dc ) instr_create_1dst_0src((dc), OP_sysenter, opnd_create_reg(DR_REG_XSP))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sysexit

#define INSTR_CREATE_sysexit ( dc )

Value:

instr_create_1dst_1src((dc), OP_sysexit, opnd_create_reg(DR_REG_XSP), \

opnd_create_reg(DR_REG_XCX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_sysret

#define INSTR_CREATE_sysret ( dc )

Value:

instr_create_0dst_2src((dc), OP_sysret, opnd_create_reg(DR_REG_XCX), \

opnd_create_reg(DR_REG_R11))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_t1mskc

#define INSTR_CREATE_t1mskc	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_t1mskc, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_test

#define INSTR_CREATE_test	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_test, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_tzcnt

#define INSTR_CREATE_tzcnt	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_tzcnt, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_tzmsk

#define INSTR_CREATE_tzmsk	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_tzmsk, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_ucomisd

#define INSTR_CREATE_ucomisd	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_ucomisd, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_ucomiss

#define INSTR_CREATE_ucomiss	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_ucomiss, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_ud1

#define INSTR_CREATE_ud1	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_ud1, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_ud2

#define INSTR_CREATE_ud2 ( dc ) instr_create_0dst_0src((dc), OP_ud2)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ud2a

#define INSTR_CREATE_ud2a ( dc ) INSTR_CREATE_ud2((dc))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_ud2b

#define INSTR_CREATE_ud2b	(	dc,
		s1,
		s2
	)	INSTR_CREATE_ud1((dc), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_unpckhpd

#define INSTR_CREATE_unpckhpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_unpckhpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_unpckhps

#define INSTR_CREATE_unpckhps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_unpckhps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_unpcklpd

#define INSTR_CREATE_unpcklpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_unpcklpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_unpcklps

#define INSTR_CREATE_unpcklps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_unpcklps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vaddpd

#define INSTR_CREATE_vaddpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddpd_mask

#define INSTR_CREATE_vaddpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vaddpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddps

#define INSTR_CREATE_vaddps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddps_mask

#define INSTR_CREATE_vaddps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vaddps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddsd

#define INSTR_CREATE_vaddsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddsd_mask

#define INSTR_CREATE_vaddsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vaddsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddss

#define INSTR_CREATE_vaddss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddss_mask

#define INSTR_CREATE_vaddss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vaddss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddsubpd

#define INSTR_CREATE_vaddsubpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddsubpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaddsubps

#define INSTR_CREATE_vaddsubps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaddsubps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaesdec

#define INSTR_CREATE_vaesdec	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaesdec, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaesdeclast

#define INSTR_CREATE_vaesdeclast	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaesdeclast, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaesenc

#define INSTR_CREATE_vaesenc	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaesenc, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaesenclast

#define INSTR_CREATE_vaesenclast	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaesenclast, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vaesimc

#define INSTR_CREATE_vaesimc	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vaesimc, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vaeskeygenassist

#define INSTR_CREATE_vaeskeygenassist	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vaeskeygenassist, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_valignd_mask

#define INSTR_CREATE_valignd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_valignd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_valignq_mask

#define INSTR_CREATE_valignq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_valignq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vandnpd

#define INSTR_CREATE_vandnpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vandnpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandnpd_mask

#define INSTR_CREATE_vandnpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vandnpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandnps

#define INSTR_CREATE_vandnps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vandnps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandnps_mask

#define INSTR_CREATE_vandnps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vandnps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandpd

#define INSTR_CREATE_vandpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vandpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandpd_mask

#define INSTR_CREATE_vandpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vandpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandps

#define INSTR_CREATE_vandps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vandps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vandps_mask

#define INSTR_CREATE_vandps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vandps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vblendmpd_mask

#define INSTR_CREATE_vblendmpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vblendmpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vblendmps_mask

#define INSTR_CREATE_vblendmps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vblendmps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vblendpd

#define INSTR_CREATE_vblendpd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vblendpd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vblendps

#define INSTR_CREATE_vblendps	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vblendps, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vblendvpd

#define INSTR_CREATE_vblendvpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vblendvpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vblendvps

#define INSTR_CREATE_vblendvps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vblendvps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vbroadcastf128

#define INSTR_CREATE_vbroadcastf128	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vbroadcastf128, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vbroadcastf32x2_mask

#define INSTR_CREATE_vbroadcastf32x2_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastf32x2, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastf32x4_mask

#define INSTR_CREATE_vbroadcastf32x4_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastf32x4, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastf32x8_mask

#define INSTR_CREATE_vbroadcastf32x8_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastf32x8, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastf64x2_mask

#define INSTR_CREATE_vbroadcastf64x2_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastf64x2, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastf64x4_mask

#define INSTR_CREATE_vbroadcastf64x4_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastf64x4, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcasti128

#define INSTR_CREATE_vbroadcasti128	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vbroadcasti128, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vbroadcasti32x2_mask

#define INSTR_CREATE_vbroadcasti32x2_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcasti32x2, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcasti32x4_mask

#define INSTR_CREATE_vbroadcasti32x4_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcasti32x4, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcasti32x8_mask

#define INSTR_CREATE_vbroadcasti32x8_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcasti32x8, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcasti64x2_mask

#define INSTR_CREATE_vbroadcasti64x2_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcasti64x2, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcasti64x4_mask

#define INSTR_CREATE_vbroadcasti64x4_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcasti64x4, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastsd

#define INSTR_CREATE_vbroadcastsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vbroadcastsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vbroadcastsd_mask

#define INSTR_CREATE_vbroadcastsd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastsd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vbroadcastss

#define INSTR_CREATE_vbroadcastss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vbroadcastss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vbroadcastss_mask

#define INSTR_CREATE_vbroadcastss_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vbroadcastss, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcmppd

#define INSTR_CREATE_vcmppd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vcmppd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vcmppd_mask

#define INSTR_CREATE_vcmppd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vcmppd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vcmpps

#define INSTR_CREATE_vcmpps	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vcmpps, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vcmpps_mask

#define INSTR_CREATE_vcmpps_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vcmpps, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vcmpsd

#define INSTR_CREATE_vcmpsd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vcmpsd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vcmpsd_mask

#define INSTR_CREATE_vcmpsd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vcmpsd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vcmpss

#define INSTR_CREATE_vcmpss	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vcmpss, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vcmpss_mask

#define INSTR_CREATE_vcmpss_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vcmpss, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vcomisd

#define INSTR_CREATE_vcomisd	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vcomisd, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vcomiss

#define INSTR_CREATE_vcomiss	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vcomiss, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vcompresspd_mask

#define INSTR_CREATE_vcompresspd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcompresspd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcompressps_mask

#define INSTR_CREATE_vcompressps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcompressps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtdq2pd

#define INSTR_CREATE_vcvtdq2pd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtdq2pd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtdq2pd_mask

#define INSTR_CREATE_vcvtdq2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtdq2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtdq2ps

#define INSTR_CREATE_vcvtdq2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtdq2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtdq2ps_mask

#define INSTR_CREATE_vcvtdq2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtdq2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtne2ps2bf16_mask

#define INSTR_CREATE_vcvtne2ps2bf16_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vcvtne2ps2bf16, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vcvtneps2bf16_mask

#define INSTR_CREATE_vcvtneps2bf16_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtneps2bf16, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtpd2dq

#define INSTR_CREATE_vcvtpd2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtpd2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtpd2dq_mask

#define INSTR_CREATE_vcvtpd2dq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtpd2dq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtpd2ps

#define INSTR_CREATE_vcvtpd2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtpd2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtpd2ps_mask

#define INSTR_CREATE_vcvtpd2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtpd2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtpd2qq_mask

#define INSTR_CREATE_vcvtpd2qq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtpd2qq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtpd2udq_mask

#define INSTR_CREATE_vcvtpd2udq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtpd2udq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtpd2uqq_mask

#define INSTR_CREATE_vcvtpd2uqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtpd2uqq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtph2ps

#define INSTR_CREATE_vcvtph2ps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtph2ps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtph2ps_mask

#define INSTR_CREATE_vcvtph2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtph2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtps2dq

#define INSTR_CREATE_vcvtps2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtps2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtps2dq_mask

#define INSTR_CREATE_vcvtps2dq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtps2dq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtps2pd

#define INSTR_CREATE_vcvtps2pd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtps2pd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtps2pd_mask

#define INSTR_CREATE_vcvtps2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtps2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtps2ph

#define INSTR_CREATE_vcvtps2ph	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtps2ph, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtps2ph_mask

#define INSTR_CREATE_vcvtps2ph_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vcvtps2ph, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtps2qq_mask

#define INSTR_CREATE_vcvtps2qq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtps2qq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtps2udq_mask

#define INSTR_CREATE_vcvtps2udq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtps2udq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtps2uqq_mask

#define INSTR_CREATE_vcvtps2uqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtps2uqq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtqq2pd_mask

#define INSTR_CREATE_vcvtqq2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtqq2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtqq2ps_mask

#define INSTR_CREATE_vcvtqq2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtqq2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtsd2si

#define INSTR_CREATE_vcvtsd2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtsd2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtsd2ss

#define INSTR_CREATE_vcvtsd2ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtsd2ss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtsd2ss_mask

#define INSTR_CREATE_vcvtsd2ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vcvtsd2ss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtsd2usi

#define INSTR_CREATE_vcvtsd2usi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtsd2usi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtsi2sd

#define INSTR_CREATE_vcvtsi2sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtsi2sd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtsi2ss

#define INSTR_CREATE_vcvtsi2ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtsi2ss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtss2sd

#define INSTR_CREATE_vcvtss2sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtss2sd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtss2sd_mask

#define INSTR_CREATE_vcvtss2sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vcvtss2sd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtss2si

#define INSTR_CREATE_vcvtss2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtss2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtss2usi

#define INSTR_CREATE_vcvtss2usi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvtss2usi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttpd2dq

#define INSTR_CREATE_vcvttpd2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttpd2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttpd2dq_mask

#define INSTR_CREATE_vcvttpd2dq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttpd2dq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttpd2qq_mask

#define INSTR_CREATE_vcvttpd2qq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttpd2qq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttpd2udq_mask

#define INSTR_CREATE_vcvttpd2udq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttpd2udq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttpd2uqq_mask

#define INSTR_CREATE_vcvttpd2uqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttpd2uqq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttps2dq

#define INSTR_CREATE_vcvttps2dq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttps2dq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttps2dq_mask

#define INSTR_CREATE_vcvttps2dq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttps2dq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttps2qq_mask

#define INSTR_CREATE_vcvttps2qq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttps2qq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttps2udq_mask

#define INSTR_CREATE_vcvttps2udq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttps2udq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttps2uqq_mask

#define INSTR_CREATE_vcvttps2uqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvttps2uqq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvttsd2si

#define INSTR_CREATE_vcvttsd2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttsd2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttsd2usi

#define INSTR_CREATE_vcvttsd2usi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttsd2usi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttss2si

#define INSTR_CREATE_vcvttss2si	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttss2si, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvttss2usi

#define INSTR_CREATE_vcvttss2usi	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vcvttss2usi, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vcvtudq2pd_mask

#define INSTR_CREATE_vcvtudq2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtudq2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtudq2ps_mask

#define INSTR_CREATE_vcvtudq2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtudq2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtuqq2pd_mask

#define INSTR_CREATE_vcvtuqq2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtuqq2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtuqq2ps_mask

#define INSTR_CREATE_vcvtuqq2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vcvtuqq2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vcvtusi2sd

#define INSTR_CREATE_vcvtusi2sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtusi2sd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vcvtusi2ss

#define INSTR_CREATE_vcvtusi2ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vcvtusi2ss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdbpsadbw_mask

#define INSTR_CREATE_vdbpsadbw_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vdbpsadbw, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vdivpd

#define INSTR_CREATE_vdivpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vdivpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivpd_mask

#define INSTR_CREATE_vdivpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vdivpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivps

#define INSTR_CREATE_vdivps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vdivps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivps_mask

#define INSTR_CREATE_vdivps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vdivps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivsd

#define INSTR_CREATE_vdivsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vdivsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivsd_mask

#define INSTR_CREATE_vdivsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vdivsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivss

#define INSTR_CREATE_vdivss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vdivss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdivss_mask

#define INSTR_CREATE_vdivss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vdivss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vdpbf16ps_mask

#define INSTR_CREATE_vdpbf16ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vdpbf16ps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vdppd

#define INSTR_CREATE_vdppd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vdppd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vdpps

#define INSTR_CREATE_vdpps	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vdpps, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_verr

#define INSTR_CREATE_verr	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_verr, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_verw

#define INSTR_CREATE_verw	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_verw, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vexp2pd_mask

#define INSTR_CREATE_vexp2pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vexp2pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vexp2ps_mask

#define INSTR_CREATE_vexp2ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vexp2ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vexpandpd_mask

#define INSTR_CREATE_vexpandpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vexpandpd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vexpandps_mask

#define INSTR_CREATE_vexpandps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vexpandps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vextractf128

#define INSTR_CREATE_vextractf128	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vextractf128, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextractf32x4_mask

#define INSTR_CREATE_vextractf32x4_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextractf32x4, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextractf32x8_mask

#define INSTR_CREATE_vextractf32x8_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextractf32x8, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextractf64x2_mask

#define INSTR_CREATE_vextractf64x2_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextractf64x2, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextractf64x4_mask

#define INSTR_CREATE_vextractf64x4_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextractf64x4, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextracti128

#define INSTR_CREATE_vextracti128	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vextracti128, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextracti32x4_mask

#define INSTR_CREATE_vextracti32x4_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextracti32x4, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextracti32x8_mask

#define INSTR_CREATE_vextracti32x8_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextracti32x8, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextracti64x2_mask

#define INSTR_CREATE_vextracti64x2_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextracti64x2, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextracti64x4_mask

#define INSTR_CREATE_vextracti64x4_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vextracti64x4, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vextractps

#define INSTR_CREATE_vextractps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vextractps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vfixupimmpd_mask

#define INSTR_CREATE_vfixupimmpd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfixupimmpd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfixupimmps_mask

#define INSTR_CREATE_vfixupimmps_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfixupimmps, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfixupimmsd_mask

#define INSTR_CREATE_vfixupimmsd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfixupimmsd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfixupimmss_mask

#define INSTR_CREATE_vfixupimmss_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfixupimmss, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132pd

#define INSTR_CREATE_vfmadd132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132pd_mask

#define INSTR_CREATE_vfmadd132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132ps

#define INSTR_CREATE_vfmadd132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132ps_mask

#define INSTR_CREATE_vfmadd132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132sd

#define INSTR_CREATE_vfmadd132sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd132sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132sd_mask

#define INSTR_CREATE_vfmadd132sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd132sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132ss

#define INSTR_CREATE_vfmadd132ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd132ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd132ss_mask

#define INSTR_CREATE_vfmadd132ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd132ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213pd

#define INSTR_CREATE_vfmadd213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213pd_mask

#define INSTR_CREATE_vfmadd213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213ps

#define INSTR_CREATE_vfmadd213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213ps_mask

#define INSTR_CREATE_vfmadd213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213sd

#define INSTR_CREATE_vfmadd213sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd213sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213sd_mask

#define INSTR_CREATE_vfmadd213sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd213sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213ss

#define INSTR_CREATE_vfmadd213ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd213ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd213ss_mask

#define INSTR_CREATE_vfmadd213ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd213ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231pd

#define INSTR_CREATE_vfmadd231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231pd_mask

#define INSTR_CREATE_vfmadd231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231ps

#define INSTR_CREATE_vfmadd231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231ps_mask

#define INSTR_CREATE_vfmadd231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231sd

#define INSTR_CREATE_vfmadd231sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd231sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231sd_mask

#define INSTR_CREATE_vfmadd231sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd231sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231ss

#define INSTR_CREATE_vfmadd231ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmadd231ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmadd231ss_mask

#define INSTR_CREATE_vfmadd231ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmadd231ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddpd

#define INSTR_CREATE_vfmaddpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmaddps

#define INSTR_CREATE_vfmaddps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmaddsd

#define INSTR_CREATE_vfmaddsd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddsd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmaddss

#define INSTR_CREATE_vfmaddss	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddss, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub132pd

#define INSTR_CREATE_vfmaddsub132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub132pd_mask

#define INSTR_CREATE_vfmaddsub132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub132ps

#define INSTR_CREATE_vfmaddsub132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub132ps_mask

#define INSTR_CREATE_vfmaddsub132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub213pd

#define INSTR_CREATE_vfmaddsub213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub213pd_mask

#define INSTR_CREATE_vfmaddsub213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub213ps

#define INSTR_CREATE_vfmaddsub213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub213ps_mask

#define INSTR_CREATE_vfmaddsub213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub231pd

#define INSTR_CREATE_vfmaddsub231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub231pd_mask

#define INSTR_CREATE_vfmaddsub231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub231ps

#define INSTR_CREATE_vfmaddsub231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmaddsub231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsub231ps_mask

#define INSTR_CREATE_vfmaddsub231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmaddsub231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmaddsubpd

#define INSTR_CREATE_vfmaddsubpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddsubpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmaddsubps

#define INSTR_CREATE_vfmaddsubps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmaddsubps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsub132pd

#define INSTR_CREATE_vfmsub132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132pd_mask

#define INSTR_CREATE_vfmsub132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132ps

#define INSTR_CREATE_vfmsub132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132ps_mask

#define INSTR_CREATE_vfmsub132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132sd

#define INSTR_CREATE_vfmsub132sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub132sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132sd_mask

#define INSTR_CREATE_vfmsub132sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub132sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132ss

#define INSTR_CREATE_vfmsub132ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub132ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub132ss_mask

#define INSTR_CREATE_vfmsub132ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub132ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213pd

#define INSTR_CREATE_vfmsub213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213pd_mask

#define INSTR_CREATE_vfmsub213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213ps

#define INSTR_CREATE_vfmsub213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213ps_mask

#define INSTR_CREATE_vfmsub213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213sd

#define INSTR_CREATE_vfmsub213sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub213sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213sd_mask

#define INSTR_CREATE_vfmsub213sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub213sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213ss

#define INSTR_CREATE_vfmsub213ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub213ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub213ss_mask

#define INSTR_CREATE_vfmsub213ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub213ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231pd

#define INSTR_CREATE_vfmsub231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231pd_mask

#define INSTR_CREATE_vfmsub231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231ps

#define INSTR_CREATE_vfmsub231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231ps_mask

#define INSTR_CREATE_vfmsub231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231sd

#define INSTR_CREATE_vfmsub231sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub231sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231sd_mask

#define INSTR_CREATE_vfmsub231sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub231sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231ss

#define INSTR_CREATE_vfmsub231ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsub231ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsub231ss_mask

#define INSTR_CREATE_vfmsub231ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsub231ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd132pd

#define INSTR_CREATE_vfmsubadd132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd132pd_mask

#define INSTR_CREATE_vfmsubadd132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd132ps

#define INSTR_CREATE_vfmsubadd132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd132ps_mask

#define INSTR_CREATE_vfmsubadd132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd213pd

#define INSTR_CREATE_vfmsubadd213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd213pd_mask

#define INSTR_CREATE_vfmsubadd213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd213ps

#define INSTR_CREATE_vfmsubadd213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd213ps_mask

#define INSTR_CREATE_vfmsubadd213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd231pd

#define INSTR_CREATE_vfmsubadd231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd231pd_mask

#define INSTR_CREATE_vfmsubadd231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd231ps

#define INSTR_CREATE_vfmsubadd231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfmsubadd231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubadd231ps_mask

#define INSTR_CREATE_vfmsubadd231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfmsubadd231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfmsubaddpd

#define INSTR_CREATE_vfmsubaddpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubaddpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsubaddps

#define INSTR_CREATE_vfmsubaddps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubaddps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsubpd

#define INSTR_CREATE_vfmsubpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsubps

#define INSTR_CREATE_vfmsubps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsubsd

#define INSTR_CREATE_vfmsubsd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubsd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfmsubss

#define INSTR_CREATE_vfmsubss	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfmsubss, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132pd

#define INSTR_CREATE_vfnmadd132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132pd_mask

#define INSTR_CREATE_vfnmadd132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132ps

#define INSTR_CREATE_vfnmadd132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132ps_mask

#define INSTR_CREATE_vfnmadd132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132sd

#define INSTR_CREATE_vfnmadd132sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd132sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132sd_mask

#define INSTR_CREATE_vfnmadd132sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd132sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132ss

#define INSTR_CREATE_vfnmadd132ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd132ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd132ss_mask

#define INSTR_CREATE_vfnmadd132ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd132ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213pd

#define INSTR_CREATE_vfnmadd213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213pd_mask

#define INSTR_CREATE_vfnmadd213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213ps

#define INSTR_CREATE_vfnmadd213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213ps_mask

#define INSTR_CREATE_vfnmadd213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213sd

#define INSTR_CREATE_vfnmadd213sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd213sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213sd_mask

#define INSTR_CREATE_vfnmadd213sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd213sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213ss

#define INSTR_CREATE_vfnmadd213ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd213ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd213ss_mask

#define INSTR_CREATE_vfnmadd213ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd213ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231pd

#define INSTR_CREATE_vfnmadd231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231pd_mask

#define INSTR_CREATE_vfnmadd231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231ps

#define INSTR_CREATE_vfnmadd231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231ps_mask

#define INSTR_CREATE_vfnmadd231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231sd

#define INSTR_CREATE_vfnmadd231sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd231sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231sd_mask

#define INSTR_CREATE_vfnmadd231sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd231sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231ss

#define INSTR_CREATE_vfnmadd231ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmadd231ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmadd231ss_mask

#define INSTR_CREATE_vfnmadd231ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmadd231ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmaddpd

#define INSTR_CREATE_vfnmaddpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmaddpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmaddps

#define INSTR_CREATE_vfnmaddps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmaddps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmaddsd

#define INSTR_CREATE_vfnmaddsd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmaddsd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmaddss

#define INSTR_CREATE_vfnmaddss	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmaddss, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132pd

#define INSTR_CREATE_vfnmsub132pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub132pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132pd_mask

#define INSTR_CREATE_vfnmsub132pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub132pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132ps

#define INSTR_CREATE_vfnmsub132ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub132ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132ps_mask

#define INSTR_CREATE_vfnmsub132ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub132ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132sd

#define INSTR_CREATE_vfnmsub132sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub132sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132sd_mask

#define INSTR_CREATE_vfnmsub132sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub132sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132ss

#define INSTR_CREATE_vfnmsub132ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub132ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub132ss_mask

#define INSTR_CREATE_vfnmsub132ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub132ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213pd

#define INSTR_CREATE_vfnmsub213pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub213pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213pd_mask

#define INSTR_CREATE_vfnmsub213pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub213pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213ps

#define INSTR_CREATE_vfnmsub213ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub213ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213ps_mask

#define INSTR_CREATE_vfnmsub213ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub213ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213sd

#define INSTR_CREATE_vfnmsub213sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub213sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213sd_mask

#define INSTR_CREATE_vfnmsub213sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub213sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213ss

#define INSTR_CREATE_vfnmsub213ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub213ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub213ss_mask

#define INSTR_CREATE_vfnmsub213ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub213ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231pd

#define INSTR_CREATE_vfnmsub231pd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub231pd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231pd_mask

#define INSTR_CREATE_vfnmsub231pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub231pd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231ps

#define INSTR_CREATE_vfnmsub231ps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub231ps, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231ps_mask

#define INSTR_CREATE_vfnmsub231ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub231ps, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231sd

#define INSTR_CREATE_vfnmsub231sd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub231sd, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231sd_mask

#define INSTR_CREATE_vfnmsub231sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub231sd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231ss

#define INSTR_CREATE_vfnmsub231ss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vfnmsub231ss, (d), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsub231ss_mask

#define INSTR_CREATE_vfnmsub231ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vfnmsub231ss, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vfnmsubpd

#define INSTR_CREATE_vfnmsubpd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmsubpd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmsubps

#define INSTR_CREATE_vfnmsubps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmsubps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmsubsd

#define INSTR_CREATE_vfnmsubsd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmsubsd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfnmsubss

#define INSTR_CREATE_vfnmsubss	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vfnmsubss, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vfpclasspd_mask

#define INSTR_CREATE_vfpclasspd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vfpclasspd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfpclassps_mask

#define INSTR_CREATE_vfpclassps_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vfpclassps, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfpclasssd_mask

#define INSTR_CREATE_vfpclasssd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vfpclasssd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfpclassss_mask

#define INSTR_CREATE_vfpclassss_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vfpclassss, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfrczpd

#define INSTR_CREATE_vfrczpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vfrczpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfrczps

#define INSTR_CREATE_vfrczps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vfrczps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfrczsd

#define INSTR_CREATE_vfrczsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vfrczsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vfrczss

#define INSTR_CREATE_vfrczss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vfrczss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vgatherdpd

#define INSTR_CREATE_vgatherdpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vgatherdpd, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherdpd_mask

#define INSTR_CREATE_vgatherdpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vgatherdpd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherdps

#define INSTR_CREATE_vgatherdps	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vgatherdps, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherdps_mask

#define INSTR_CREATE_vgatherdps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vgatherdps, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf0dpd_mask

#define INSTR_CREATE_vgatherpf0dpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf0dpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf0dps_mask

#define INSTR_CREATE_vgatherpf0dps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf0dps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf0qpd_mask

#define INSTR_CREATE_vgatherpf0qpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf0qpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf0qps_mask

#define INSTR_CREATE_vgatherpf0qps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf0qps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf1dpd_mask

#define INSTR_CREATE_vgatherpf1dpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf1dpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf1dps_mask

#define INSTR_CREATE_vgatherpf1dps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf1dps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf1qpd_mask

#define INSTR_CREATE_vgatherpf1qpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf1qpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherpf1qps_mask

#define INSTR_CREATE_vgatherpf1qps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vgatherpf1qps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherqpd

#define INSTR_CREATE_vgatherqpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vgatherqpd, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherqpd_mask

#define INSTR_CREATE_vgatherqpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vgatherqpd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherqps

#define INSTR_CREATE_vgatherqps	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vgatherqps, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgatherqps_mask

#define INSTR_CREATE_vgatherqps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vgatherqps, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vgetexppd_mask

#define INSTR_CREATE_vgetexppd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vgetexppd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vgetexpps_mask

#define INSTR_CREATE_vgetexpps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vgetexpps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vgetexpsd_mask

#define INSTR_CREATE_vgetexpsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vgetexpsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vgetexpss_mask

#define INSTR_CREATE_vgetexpss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vgetexpss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vgetmantpd_mask

#define INSTR_CREATE_vgetmantpd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vgetmantpd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vgetmantps_mask

#define INSTR_CREATE_vgetmantps_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vgetmantps, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vgetmantsd_mask

#define INSTR_CREATE_vgetmantsd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vgetmantsd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vgetmantss_mask

#define INSTR_CREATE_vgetmantss_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vgetmantss, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vgf2p8affineinvqb

#define INSTR_CREATE_vgf2p8affineinvqb	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vgf2p8affineinvqb, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vgf2p8affineinvqb_mask

#define INSTR_CREATE_vgf2p8affineinvqb_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vgf2p8affineinvqb, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vgf2p8affineqb

#define INSTR_CREATE_vgf2p8affineqb	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vgf2p8affineqb, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vgf2p8affineqb_mask

#define INSTR_CREATE_vgf2p8affineqb_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vgf2p8affineqb, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vgf2p8mulb

#define INSTR_CREATE_vgf2p8mulb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vgf2p8mulb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vgf2p8mulb_mask

#define INSTR_CREATE_vgf2p8mulb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vgf2p8mulb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vhaddpd

#define INSTR_CREATE_vhaddpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vhaddpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vhaddps

#define INSTR_CREATE_vhaddps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vhaddps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vhsubpd

#define INSTR_CREATE_vhsubpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vhsubpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vhsubps

#define INSTR_CREATE_vhsubps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vhsubps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vinsertf128

#define INSTR_CREATE_vinsertf128	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vinsertf128, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vinsertf32x4_mask

#define INSTR_CREATE_vinsertf32x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinsertf32x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinsertf32x8_mask

#define INSTR_CREATE_vinsertf32x8_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinsertf32x8, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinsertf64x2_mask

#define INSTR_CREATE_vinsertf64x2_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinsertf64x2, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinsertf64x4_mask

#define INSTR_CREATE_vinsertf64x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinsertf64x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinserti128

#define INSTR_CREATE_vinserti128	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vinserti128, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vinserti32x4_mask

#define INSTR_CREATE_vinserti32x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinserti32x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinserti32x8_mask

#define INSTR_CREATE_vinserti32x8_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinserti32x8, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinserti64x2_mask

#define INSTR_CREATE_vinserti64x2_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinserti64x2, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinserti64x4_mask

#define INSTR_CREATE_vinserti64x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vinserti64x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vinsertps

#define INSTR_CREATE_vinsertps	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vinsertps, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vlddqu

#define INSTR_CREATE_vlddqu	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vlddqu, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vldmxcsr

#define INSTR_CREATE_vldmxcsr	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_vldmxcsr, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmaskmovdqu

#define INSTR_CREATE_vmaskmovdqu	(	dc,
		s1,
		s2
	)

Value:

    INSTR_PRED(instr_create_1dst_2src((dc), OP_vmaskmovdqu,                            \
                                      opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XDI, \
                                                                DR_REG_NULL, 0, 0,     \
                                                                OPSZ_maskmovdqu),      \
                                      (s1), (s2)),                                     \
               DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vmaskmovpd

#define INSTR_CREATE_vmaskmovpd	(	dc,
		d,
		s1,
		s2
	)

Value:

INSTR_PRED(instr_create_1dst_2src((dc), OP_vmaskmovpd, (d), (s1), (s2)), \

DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaskmovps

#define INSTR_CREATE_vmaskmovps	(	dc,
		d,
		s1,
		s2
	)

Value:

INSTR_PRED(instr_create_1dst_2src((dc), OP_vmaskmovps, (d), (s1), (s2)), \

DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxpd

#define INSTR_CREATE_vmaxpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmaxpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxpd_mask

#define INSTR_CREATE_vmaxpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmaxpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxps

#define INSTR_CREATE_vmaxps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmaxps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxps_mask

#define INSTR_CREATE_vmaxps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmaxps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxsd

#define INSTR_CREATE_vmaxsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmaxsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxsd_mask

#define INSTR_CREATE_vmaxsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmaxsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxss

#define INSTR_CREATE_vmaxss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmaxss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmaxss_mask

#define INSTR_CREATE_vmaxss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmaxss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmcall

#define INSTR_CREATE_vmcall ( dc ) instr_create_0dst_0src((dc), OP_vmcall)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmclear

#define INSTR_CREATE_vmclear	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_vmclear, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_vmfunc

#define INSTR_CREATE_vmfunc ( dc ) instr_create_0dst_0src((dc), OP_vmfunc)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vminpd

#define INSTR_CREATE_vminpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vminpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminpd_mask

#define INSTR_CREATE_vminpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vminpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminps

#define INSTR_CREATE_vminps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vminps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminps_mask

#define INSTR_CREATE_vminps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vminps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminsd

#define INSTR_CREATE_vminsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vminsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminsd_mask

#define INSTR_CREATE_vminsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vminsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminss

#define INSTR_CREATE_vminss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vminss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vminss_mask

#define INSTR_CREATE_vminss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vminss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmlaunch

#define INSTR_CREATE_vmlaunch ( dc ) instr_create_0dst_0src((dc), OP_vmlaunch)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmload

#define INSTR_CREATE_vmload ( dc ) instr_create_0dst_1src((dc), OP_vmload, opnd_create_reg(DR_REG_XAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmmcall

#define INSTR_CREATE_vmmcall ( dc ) instr_create_0dst_0src((dc), OP_vmmcall)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmovapd

#define INSTR_CREATE_vmovapd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovapd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovapd_mask

#define INSTR_CREATE_vmovapd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovapd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovaps

#define INSTR_CREATE_vmovaps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovaps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovaps_mask

#define INSTR_CREATE_vmovaps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovaps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovd

#define INSTR_CREATE_vmovd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovd_mask

#define INSTR_CREATE_vmovd_mask	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovddup

#define INSTR_CREATE_vmovddup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovddup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovddup_mask

#define INSTR_CREATE_vmovddup_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovddup, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqa

#define INSTR_CREATE_vmovdqa	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovdqa, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovdqa32_mask

#define INSTR_CREATE_vmovdqa32_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqa32, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqa64_mask

#define INSTR_CREATE_vmovdqa64_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqa64, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqu

#define INSTR_CREATE_vmovdqu	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovdqu, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovdqu16_mask

#define INSTR_CREATE_vmovdqu16_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqu16, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqu32_mask

#define INSTR_CREATE_vmovdqu32_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqu32, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqu64_mask

#define INSTR_CREATE_vmovdqu64_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqu64, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovdqu8_mask

#define INSTR_CREATE_vmovdqu8_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovdqu8, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovhpd

#define INSTR_CREATE_vmovhpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovhpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovhpd_NDS

#define INSTR_CREATE_vmovhpd_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovhpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovhps

#define INSTR_CREATE_vmovhps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovhps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovhps_NDS

#define INSTR_CREATE_vmovhps_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovhps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovlpd

#define INSTR_CREATE_vmovlpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovlpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovlpd_NDS

#define INSTR_CREATE_vmovlpd_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovlpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovlps

#define INSTR_CREATE_vmovlps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovlps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovlps_NDS

#define INSTR_CREATE_vmovlps_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovlps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovmskpd

#define INSTR_CREATE_vmovmskpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovmskpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovmskps

#define INSTR_CREATE_vmovmskps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovmskps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovntdq

#define INSTR_CREATE_vmovntdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovntdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovntdqa

#define INSTR_CREATE_vmovntdqa	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovntdqa, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovntpd

#define INSTR_CREATE_vmovntpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovntpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovntps

#define INSTR_CREATE_vmovntps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovntps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovq

#define INSTR_CREATE_vmovq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovsd

#define INSTR_CREATE_vmovsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovsd_mask

#define INSTR_CREATE_vmovsd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovsd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovsd_NDS

#define INSTR_CREATE_vmovsd_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovsd_NDS_mask

#define INSTR_CREATE_vmovsd_NDS_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmovsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovshdup

#define INSTR_CREATE_vmovshdup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovshdup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovshdup_mask

#define INSTR_CREATE_vmovshdup_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovshdup, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovsldup

#define INSTR_CREATE_vmovsldup	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovsldup, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovsldup_mask

#define INSTR_CREATE_vmovsldup_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovsldup, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovss

#define INSTR_CREATE_vmovss	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovss, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovss_mask

#define INSTR_CREATE_vmovss_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovss, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovss_NDS

#define INSTR_CREATE_vmovss_NDS	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmovss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovss_NDS_mask

#define INSTR_CREATE_vmovss_NDS_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmovss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmovupd

#define INSTR_CREATE_vmovupd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovupd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovupd_mask

#define INSTR_CREATE_vmovupd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovupd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmovups

#define INSTR_CREATE_vmovups	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmovups, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmovups_mask

#define INSTR_CREATE_vmovups_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vmovups, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vmpsadbw

#define INSTR_CREATE_vmpsadbw	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vmpsadbw, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vmptrld

#define INSTR_CREATE_vmptrld	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_vmptrld, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmptrst

#define INSTR_CREATE_vmptrst	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_vmptrst, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_vmread

#define INSTR_CREATE_vmread	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmread, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmresume

#define INSTR_CREATE_vmresume ( dc ) instr_create_0dst_0src((dc), OP_vmresume)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmrun

#define INSTR_CREATE_vmrun ( dc ) instr_create_0dst_1src((dc), OP_vmrun, opnd_create_reg(DR_REG_XAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmsave

#define INSTR_CREATE_vmsave ( dc ) instr_create_0dst_1src((dc), OP_vmsave, opnd_create_reg(DR_REG_XAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmulpd

#define INSTR_CREATE_vmulpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmulpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulpd_mask

#define INSTR_CREATE_vmulpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmulpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulps

#define INSTR_CREATE_vmulps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmulps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulps_mask

#define INSTR_CREATE_vmulps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmulps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulsd

#define INSTR_CREATE_vmulsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmulsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulsd_mask

#define INSTR_CREATE_vmulsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmulsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulss

#define INSTR_CREATE_vmulss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vmulss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmulss_mask

#define INSTR_CREATE_vmulss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vmulss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vmwrite

#define INSTR_CREATE_vmwrite	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vmwrite, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vmxoff

#define INSTR_CREATE_vmxoff ( dc ) instr_create_0dst_0src((dc), OP_vmxoff)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vmxon

#define INSTR_CREATE_vmxon	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_vmxon, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vorpd

#define INSTR_CREATE_vorpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vorpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vorpd_mask

#define INSTR_CREATE_vorpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vorpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vorps

#define INSTR_CREATE_vorps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vorps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vorps_mask

#define INSTR_CREATE_vorps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vorps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpabsb

#define INSTR_CREATE_vpabsb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpabsb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpabsb_mask

#define INSTR_CREATE_vpabsb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpabsb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpabsd

#define INSTR_CREATE_vpabsd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpabsd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpabsd_mask

#define INSTR_CREATE_vpabsd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpabsd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpabsq_mask

#define INSTR_CREATE_vpabsq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpabsq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpabsw

#define INSTR_CREATE_vpabsw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpabsw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpabsw_mask

#define INSTR_CREATE_vpabsw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpabsw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpackssdw

#define INSTR_CREATE_vpackssdw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpackssdw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpackssdw_mask

#define INSTR_CREATE_vpackssdw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpackssdw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpacksswb

#define INSTR_CREATE_vpacksswb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpacksswb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpacksswb_mask

#define INSTR_CREATE_vpacksswb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpacksswb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpackusdw

#define INSTR_CREATE_vpackusdw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpackusdw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpackusdw_mask

#define INSTR_CREATE_vpackusdw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpackusdw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpackuswb

#define INSTR_CREATE_vpackuswb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpackuswb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpackuswb_mask

#define INSTR_CREATE_vpackuswb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpackuswb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddb

#define INSTR_CREATE_vpaddb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddb_mask

#define INSTR_CREATE_vpaddb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddd

#define INSTR_CREATE_vpaddd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddd_mask

#define INSTR_CREATE_vpaddd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddq

#define INSTR_CREATE_vpaddq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddq_mask

#define INSTR_CREATE_vpaddq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddsb

#define INSTR_CREATE_vpaddsb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddsb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddsb_mask

#define INSTR_CREATE_vpaddsb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddsb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddsw

#define INSTR_CREATE_vpaddsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddsw_mask

#define INSTR_CREATE_vpaddsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddusb

#define INSTR_CREATE_vpaddusb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddusb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddusb_mask

#define INSTR_CREATE_vpaddusb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddusb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddusw

#define INSTR_CREATE_vpaddusw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddusw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddusw_mask

#define INSTR_CREATE_vpaddusw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddusw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddw

#define INSTR_CREATE_vpaddw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpaddw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpaddw_mask

#define INSTR_CREATE_vpaddw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpaddw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpalignr

#define INSTR_CREATE_vpalignr	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpalignr, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpalignr_mask

#define INSTR_CREATE_vpalignr_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpalignr, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpand

#define INSTR_CREATE_vpand	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpand, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpandd_mask

#define INSTR_CREATE_vpandd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpandd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpandn

#define INSTR_CREATE_vpandn	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpandn, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpandnd_mask

#define INSTR_CREATE_vpandnd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpandnd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpandnq_mask

#define INSTR_CREATE_vpandnq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpandnq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpandq_mask

#define INSTR_CREATE_vpandq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpandq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpavgb

#define INSTR_CREATE_vpavgb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpavgb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpavgb_mask

#define INSTR_CREATE_vpavgb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpavgb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpavgw

#define INSTR_CREATE_vpavgw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpavgw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpavgw_mask

#define INSTR_CREATE_vpavgw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpavgw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpblendd

#define INSTR_CREATE_vpblendd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpblendd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vpblendmb_mask

#define INSTR_CREATE_vpblendmb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpblendmb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpblendmd_mask

#define INSTR_CREATE_vpblendmd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpblendmd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpblendmq_mask

#define INSTR_CREATE_vpblendmq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpblendmq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpblendmw_mask

#define INSTR_CREATE_vpblendmw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpblendmw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpblendvb

#define INSTR_CREATE_vpblendvb	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpblendvb, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vpblendw

#define INSTR_CREATE_vpblendw	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpblendw, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpbroadcastb

#define INSTR_CREATE_vpbroadcastb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastb_mask

#define INSTR_CREATE_vpbroadcastb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpbroadcastb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpbroadcastd

#define INSTR_CREATE_vpbroadcastd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastd_mask

#define INSTR_CREATE_vpbroadcastd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpbroadcastd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpbroadcastmb2q

#define INSTR_CREATE_vpbroadcastmb2q	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastmb2q, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastmw2d

#define INSTR_CREATE_vpbroadcastmw2d	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastmw2d, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastq

#define INSTR_CREATE_vpbroadcastq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastq_mask

#define INSTR_CREATE_vpbroadcastq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpbroadcastq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpbroadcastw

#define INSTR_CREATE_vpbroadcastw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpbroadcastw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpbroadcastw_mask

#define INSTR_CREATE_vpbroadcastw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpbroadcastw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpclmulqdq

#define INSTR_CREATE_vpclmulqdq	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpclmulqdq, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcmov

#define INSTR_CREATE_vpcmov	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpcmov, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpcmpb_mask

#define INSTR_CREATE_vpcmpb_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpb, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpd_mask

#define INSTR_CREATE_vpcmpd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpeqb

#define INSTR_CREATE_vpcmpeqb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpeqb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqb_mask

#define INSTR_CREATE_vpcmpeqb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpeqb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqd

#define INSTR_CREATE_vpcmpeqd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpeqd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqd_mask

#define INSTR_CREATE_vpcmpeqd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpeqd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqq

#define INSTR_CREATE_vpcmpeqq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpeqq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqq_mask

#define INSTR_CREATE_vpcmpeqq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpeqq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqw

#define INSTR_CREATE_vpcmpeqw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpeqw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpeqw_mask

#define INSTR_CREATE_vpcmpeqw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpeqw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpestri

#define INSTR_CREATE_vpcmpestri	(	dc,
		s1,
		s2,
		i
	)

Value:

    instr_create_1dst_5src((dc), OP_vpcmpestri, opnd_create_reg(DR_REG_ECX), (s1), (s2), \
                           (i), opnd_create_reg(DR_REG_EAX),                             \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcmpestrm

#define INSTR_CREATE_vpcmpestrm	(	dc,
		s1,
		s2,
		i
	)

Value:

    instr_create_1dst_5src((dc), OP_vpcmpestrm, opnd_create_reg(DR_REG_XMM0), (s1), \
                           (s2), (i), opnd_create_reg(DR_REG_EAX),                  \
                           opnd_create_reg(DR_REG_EDX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcmpgtb

#define INSTR_CREATE_vpcmpgtb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpgtb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtb_mask

#define INSTR_CREATE_vpcmpgtb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpgtb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtd

#define INSTR_CREATE_vpcmpgtd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpgtd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtd_mask

#define INSTR_CREATE_vpcmpgtd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpgtd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtq

#define INSTR_CREATE_vpcmpgtq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpgtq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtq_mask

#define INSTR_CREATE_vpcmpgtq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpgtq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtw

#define INSTR_CREATE_vpcmpgtw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpcmpgtw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpgtw_mask

#define INSTR_CREATE_vpcmpgtw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpcmpgtw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpcmpistri

#define INSTR_CREATE_vpcmpistri	(	dc,
		s1,
		s2,
		i
	)

Value:

instr_create_1dst_3src((dc), OP_vpcmpistri, opnd_create_reg(DR_REG_ECX), (s1), (s2), \

(i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcmpistrm

#define INSTR_CREATE_vpcmpistrm	(	dc,
		s1,
		s2,
		i
	)

Value:

instr_create_1dst_3src((dc), OP_vpcmpistrm, opnd_create_reg(DR_REG_XMM0), (s1), \

(s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcmpq_mask

#define INSTR_CREATE_vpcmpq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpub_mask

#define INSTR_CREATE_vpcmpub_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpub, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpud_mask

#define INSTR_CREATE_vpcmpud_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpud, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpuq_mask

#define INSTR_CREATE_vpcmpuq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpuq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpuw_mask

#define INSTR_CREATE_vpcmpuw_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpuw, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcmpw_mask

#define INSTR_CREATE_vpcmpw_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpcmpw, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpcomb

#define INSTR_CREATE_vpcomb	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomb, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomd

#define INSTR_CREATE_vpcomd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcompressb_mask

#define INSTR_CREATE_vpcompressb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpcompressb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpcompressd_mask

#define INSTR_CREATE_vpcompressd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpcompressd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpcompressq_mask

#define INSTR_CREATE_vpcompressq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpcompressq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpcompressw_mask

#define INSTR_CREATE_vpcompressw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpcompressw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpcomq

#define INSTR_CREATE_vpcomq	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomq, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomub

#define INSTR_CREATE_vpcomub	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomub, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomud

#define INSTR_CREATE_vpcomud	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomud, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomuq

#define INSTR_CREATE_vpcomuq	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomuq, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomuw

#define INSTR_CREATE_vpcomuw	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomuw, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpcomw

#define INSTR_CREATE_vpcomw	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpcomw, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpconflictd_mask

#define INSTR_CREATE_vpconflictd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpconflictd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpconflictq_mask

#define INSTR_CREATE_vpconflictq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpconflictq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpdpbusd

#define INSTR_CREATE_vpdpbusd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpdpbusd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpdpbusd_mask

#define INSTR_CREATE_vpdpbusd_mask	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpdpbusd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpdpbusds

#define INSTR_CREATE_vpdpbusds	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpdpbusds, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpdpbusds_mask

#define INSTR_CREATE_vpdpbusds_mask	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpdpbusds, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpdpwssd

#define INSTR_CREATE_vpdpwssd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpdpwssd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpdpwssd_mask

#define INSTR_CREATE_vpdpwssd_mask	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpdpwssd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpdpwssds

#define INSTR_CREATE_vpdpwssds	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpdpwssds, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpdpwssds_mask

#define INSTR_CREATE_vpdpwssds_mask	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpdpwssds, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vperm2f128

#define INSTR_CREATE_vperm2f128	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vperm2f128, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vperm2i128

#define INSTR_CREATE_vperm2i128	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vperm2i128, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
s3	The opnd_t explicit third source operand for the instruction

◆ INSTR_CREATE_vpermb_mask

#define INSTR_CREATE_vpermb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermd

#define INSTR_CREATE_vpermd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermd_mask

#define INSTR_CREATE_vpermd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2b_mask

#define INSTR_CREATE_vpermi2b_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2b, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2d_mask

#define INSTR_CREATE_vpermi2d_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2d, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2pd_mask

#define INSTR_CREATE_vpermi2pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2pd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2ps_mask

#define INSTR_CREATE_vpermi2ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2ps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2q_mask

#define INSTR_CREATE_vpermi2q_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2q, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermi2w_mask

#define INSTR_CREATE_vpermi2w_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermi2w, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermil2pd

#define INSTR_CREATE_vpermil2pd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpermil2pd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpermil2ps

#define INSTR_CREATE_vpermil2ps	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpermil2ps, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpermilpd

#define INSTR_CREATE_vpermilpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermilpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermilpd_mask

#define INSTR_CREATE_vpermilpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermilpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermilps

#define INSTR_CREATE_vpermilps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermilps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermilps_mask

#define INSTR_CREATE_vpermilps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermilps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermpd

#define INSTR_CREATE_vpermpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermpd_mask

#define INSTR_CREATE_vpermpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermps

#define INSTR_CREATE_vpermps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermps_mask

#define INSTR_CREATE_vpermps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermq

#define INSTR_CREATE_vpermq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpermq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermq_mask

#define INSTR_CREATE_vpermq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2b_mask

#define INSTR_CREATE_vpermt2b_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2b, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2d_mask

#define INSTR_CREATE_vpermt2d_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2d, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2pd_mask

#define INSTR_CREATE_vpermt2pd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2pd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2ps_mask

#define INSTR_CREATE_vpermt2ps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2ps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2q_mask

#define INSTR_CREATE_vpermt2q_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2q, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermt2w_mask

#define INSTR_CREATE_vpermt2w_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermt2w, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpermw_mask

#define INSTR_CREATE_vpermw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpermw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpexpandb_mask

#define INSTR_CREATE_vpexpandb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpexpandb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpexpandd_mask

#define INSTR_CREATE_vpexpandd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpexpandd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpexpandq_mask

#define INSTR_CREATE_vpexpandq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpexpandq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpexpandw_mask

#define INSTR_CREATE_vpexpandw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpexpandw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpextrb

#define INSTR_CREATE_vpextrb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpextrb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpextrd

#define INSTR_CREATE_vpextrd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpextrd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpextrq

#define INSTR_CREATE_vpextrq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpextrq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpextrw

#define INSTR_CREATE_vpextrw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpextrw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpgatherdd

#define INSTR_CREATE_vpgatherdd	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vpgatherdd, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherdd_mask

#define INSTR_CREATE_vpgatherdd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpgatherdd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherdq

#define INSTR_CREATE_vpgatherdq	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vpgatherdq, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherdq_mask

#define INSTR_CREATE_vpgatherdq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpgatherdq, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherqd

#define INSTR_CREATE_vpgatherqd	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vpgatherqd, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherqd_mask

#define INSTR_CREATE_vpgatherqd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpgatherqd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherqq

#define INSTR_CREATE_vpgatherqq	(	dc,
		d,
		s1,
		s2
	)	instr_create_2dst_2src((dc), OP_vpgatherqq, (d), (s2), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpgatherqq_mask

#define INSTR_CREATE_vpgatherqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpgatherqq, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vphaddbd

#define INSTR_CREATE_vphaddbd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddbd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddbq

#define INSTR_CREATE_vphaddbq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddbq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddbw

#define INSTR_CREATE_vphaddbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddd

#define INSTR_CREATE_vphaddd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphaddd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphadddq

#define INSTR_CREATE_vphadddq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphadddq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddsw

#define INSTR_CREATE_vphaddsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphaddsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphaddubd

#define INSTR_CREATE_vphaddubd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddubd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddubq

#define INSTR_CREATE_vphaddubq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddubq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddubw

#define INSTR_CREATE_vphaddubw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddubw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddudq

#define INSTR_CREATE_vphaddudq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddudq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphadduwd

#define INSTR_CREATE_vphadduwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphadduwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphadduwq

#define INSTR_CREATE_vphadduwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphadduwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddw

#define INSTR_CREATE_vphaddw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphaddw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphaddwd

#define INSTR_CREATE_vphaddwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphaddwq

#define INSTR_CREATE_vphaddwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphaddwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphminposuw

#define INSTR_CREATE_vphminposuw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphminposuw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphsubbw

#define INSTR_CREATE_vphsubbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphsubbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphsubd

#define INSTR_CREATE_vphsubd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphsubd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphsubdq

#define INSTR_CREATE_vphsubdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphsubdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vphsubsw

#define INSTR_CREATE_vphsubsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphsubsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphsubw

#define INSTR_CREATE_vphsubw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vphsubw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vphsubwd

#define INSTR_CREATE_vphsubwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vphsubwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpinsrb

#define INSTR_CREATE_vpinsrb	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpinsrb, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpinsrd

#define INSTR_CREATE_vpinsrd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpinsrd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpinsrq

#define INSTR_CREATE_vpinsrq	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpinsrq, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vpinsrw

#define INSTR_CREATE_vpinsrw	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vpinsrw, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vplzcntd_mask

#define INSTR_CREATE_vplzcntd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vplzcntd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vplzcntq_mask

#define INSTR_CREATE_vplzcntq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vplzcntq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmacsdd

#define INSTR_CREATE_vpmacsdd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacsdd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacsdqh

#define INSTR_CREATE_vpmacsdqh	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacsdqh, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacsdql

#define INSTR_CREATE_vpmacsdql	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacsdql, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacssdd

#define INSTR_CREATE_vpmacssdd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacssdd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacssdqh

#define INSTR_CREATE_vpmacssdqh	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacssdqh, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacssdql

#define INSTR_CREATE_vpmacssdql	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacssdql, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacsswd

#define INSTR_CREATE_vpmacsswd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacsswd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacssww

#define INSTR_CREATE_vpmacssww	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacssww, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacswd

#define INSTR_CREATE_vpmacswd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacswd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmacsww

#define INSTR_CREATE_vpmacsww	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmacsww, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmadcsswd

#define INSTR_CREATE_vpmadcsswd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmadcsswd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmadcswd

#define INSTR_CREATE_vpmadcswd	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpmadcswd, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vpmadd52huq_mask

#define INSTR_CREATE_vpmadd52huq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmadd52huq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmadd52luq_mask

#define INSTR_CREATE_vpmadd52luq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmadd52luq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaddubsw

#define INSTR_CREATE_vpmaddubsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaddubsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaddubsw_mask

#define INSTR_CREATE_vpmaddubsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaddubsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaddwd

#define INSTR_CREATE_vpmaddwd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaddwd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaddwd_mask

#define INSTR_CREATE_vpmaddwd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaddwd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaskmovd

#define INSTR_CREATE_vpmaskmovd	(	dc,
		d,
		s1,
		s2
	)

Value:

INSTR_PRED(instr_create_1dst_2src((dc), OP_vpmaskmovd, (d), (s1), (s2)), \

DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaskmovq

#define INSTR_CREATE_vpmaskmovq	(	dc,
		d,
		s1,
		s2
	)

Value:

INSTR_PRED(instr_create_1dst_2src((dc), OP_vpmaskmovq, (d), (s1), (s2)), \

DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsb

#define INSTR_CREATE_vpmaxsb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxsb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsb_mask

#define INSTR_CREATE_vpmaxsb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxsb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsd

#define INSTR_CREATE_vpmaxsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsd_mask

#define INSTR_CREATE_vpmaxsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsq_mask

#define INSTR_CREATE_vpmaxsq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxsq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsw

#define INSTR_CREATE_vpmaxsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxsw_mask

#define INSTR_CREATE_vpmaxsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxub

#define INSTR_CREATE_vpmaxub	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxub, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxub_mask

#define INSTR_CREATE_vpmaxub_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxub, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxud

#define INSTR_CREATE_vpmaxud	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxud, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxud_mask

#define INSTR_CREATE_vpmaxud_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxud, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxuq_mask

#define INSTR_CREATE_vpmaxuq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxuq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxuw

#define INSTR_CREATE_vpmaxuw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmaxuw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmaxuw_mask

#define INSTR_CREATE_vpmaxuw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmaxuw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsb

#define INSTR_CREATE_vpminsb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminsb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsb_mask

#define INSTR_CREATE_vpminsb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminsb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsd

#define INSTR_CREATE_vpminsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsd_mask

#define INSTR_CREATE_vpminsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsq_mask

#define INSTR_CREATE_vpminsq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminsq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsw

#define INSTR_CREATE_vpminsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminsw_mask

#define INSTR_CREATE_vpminsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminub

#define INSTR_CREATE_vpminub	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminub, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminub_mask

#define INSTR_CREATE_vpminub_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminub, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminud

#define INSTR_CREATE_vpminud	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminud, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminud_mask

#define INSTR_CREATE_vpminud_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminud, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminuq_mask

#define INSTR_CREATE_vpminuq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminuq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminuw

#define INSTR_CREATE_vpminuw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpminuw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpminuw_mask

#define INSTR_CREATE_vpminuw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpminuw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmovb2m

#define INSTR_CREATE_vpmovb2m	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovb2m, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovd2m

#define INSTR_CREATE_vpmovd2m	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovd2m, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovdb_mask

#define INSTR_CREATE_vpmovdb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovdb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovdw_mask

#define INSTR_CREATE_vpmovdw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovdw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovm2b

#define INSTR_CREATE_vpmovm2b	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovm2b, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovm2b_mask

#define INSTR_CREATE_vpmovm2b_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovm2b, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovm2d

#define INSTR_CREATE_vpmovm2d	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovm2d, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovm2d_mask

#define INSTR_CREATE_vpmovm2d_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovm2d, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovm2q

#define INSTR_CREATE_vpmovm2q	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovm2q, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovm2q_mask

#define INSTR_CREATE_vpmovm2q_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovm2q, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovm2w

#define INSTR_CREATE_vpmovm2w	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovm2w, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovm2w_mask

#define INSTR_CREATE_vpmovm2w_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovm2w, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovmskb

#define INSTR_CREATE_vpmovmskb	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovmskb, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovq2m

#define INSTR_CREATE_vpmovq2m	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovq2m, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovqb_mask

#define INSTR_CREATE_vpmovqb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovqb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovqd_mask

#define INSTR_CREATE_vpmovqd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovqd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovqw_mask

#define INSTR_CREATE_vpmovqw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovqw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsdb_mask

#define INSTR_CREATE_vpmovsdb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsdb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsdw_mask

#define INSTR_CREATE_vpmovsdw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsdw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsqb_mask

#define INSTR_CREATE_vpmovsqb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsqb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsqd_mask

#define INSTR_CREATE_vpmovsqd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsqd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsqw_mask

#define INSTR_CREATE_vpmovsqw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsqw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovswb_mask

#define INSTR_CREATE_vpmovswb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovswb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxbd

#define INSTR_CREATE_vpmovsxbd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxbd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxbd_mask

#define INSTR_CREATE_vpmovsxbd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxbd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxbq

#define INSTR_CREATE_vpmovsxbq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxbq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxbq_mask

#define INSTR_CREATE_vpmovsxbq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxbq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxbw

#define INSTR_CREATE_vpmovsxbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxbw_mask

#define INSTR_CREATE_vpmovsxbw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxbw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxdq

#define INSTR_CREATE_vpmovsxdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxdq_mask

#define INSTR_CREATE_vpmovsxdq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxdq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxwd

#define INSTR_CREATE_vpmovsxwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxwd_mask

#define INSTR_CREATE_vpmovsxwd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxwd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovsxwq

#define INSTR_CREATE_vpmovsxwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovsxwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovsxwq_mask

#define INSTR_CREATE_vpmovsxwq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovsxwq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovusdb_mask

#define INSTR_CREATE_vpmovusdb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovusdb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovusdw_mask

#define INSTR_CREATE_vpmovusdw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovusdw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovusqb_mask

#define INSTR_CREATE_vpmovusqb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovusqb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovusqd_mask

#define INSTR_CREATE_vpmovusqd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovusqd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovusqw_mask

#define INSTR_CREATE_vpmovusqw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovusqw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovuswb_mask

#define INSTR_CREATE_vpmovuswb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovuswb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovw2m

#define INSTR_CREATE_vpmovw2m	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovw2m, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovwb_mask

#define INSTR_CREATE_vpmovwb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovwb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxbd

#define INSTR_CREATE_vpmovzxbd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxbd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxbd_mask

#define INSTR_CREATE_vpmovzxbd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxbd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxbq

#define INSTR_CREATE_vpmovzxbq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxbq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxbq_mask

#define INSTR_CREATE_vpmovzxbq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxbq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxbw

#define INSTR_CREATE_vpmovzxbw	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxbw, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxbw_mask

#define INSTR_CREATE_vpmovzxbw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxbw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxdq

#define INSTR_CREATE_vpmovzxdq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxdq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxdq_mask

#define INSTR_CREATE_vpmovzxdq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxdq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxwd

#define INSTR_CREATE_vpmovzxwd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxwd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxwd_mask

#define INSTR_CREATE_vpmovzxwd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxwd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmovzxwq

#define INSTR_CREATE_vpmovzxwq	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vpmovzxwq, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpmovzxwq_mask

#define INSTR_CREATE_vpmovzxwq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpmovzxwq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpmuldq

#define INSTR_CREATE_vpmuldq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmuldq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmuldq_mask

#define INSTR_CREATE_vpmuldq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmuldq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhrsw

#define INSTR_CREATE_vpmulhrsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmulhrsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhrsw_mask

#define INSTR_CREATE_vpmulhrsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmulhrsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhuw

#define INSTR_CREATE_vpmulhuw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmulhuw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhuw_mask

#define INSTR_CREATE_vpmulhuw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmulhuw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhw

#define INSTR_CREATE_vpmulhw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmulhw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulhw_mask

#define INSTR_CREATE_vpmulhw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmulhw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulld

#define INSTR_CREATE_vpmulld	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmulld, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmulld_mask

#define INSTR_CREATE_vpmulld_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmulld, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmullq_mask

#define INSTR_CREATE_vpmullq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmullq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmullw

#define INSTR_CREATE_vpmullw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmullw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmullw_mask

#define INSTR_CREATE_vpmullw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmullw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmultishiftqb_mask

#define INSTR_CREATE_vpmultishiftqb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmultishiftqb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmuludq

#define INSTR_CREATE_vpmuludq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpmuludq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpmuludq_mask

#define INSTR_CREATE_vpmuludq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpmuludq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpopcntb_mask

#define INSTR_CREATE_vpopcntb_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpopcntb, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpopcntd_mask

#define INSTR_CREATE_vpopcntd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpopcntd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpopcntq_mask

#define INSTR_CREATE_vpopcntq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpopcntq, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpopcntw_mask

#define INSTR_CREATE_vpopcntw_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vpopcntw, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vpor

#define INSTR_CREATE_vpor	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpor, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpord_mask

#define INSTR_CREATE_vpord_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpord, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vporq_mask

#define INSTR_CREATE_vporq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vporq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpperm

#define INSTR_CREATE_vpperm	(	dc,
		d,
		s1,
		s2,
		s3
	)	instr_create_1dst_3src((dc), OP_vpperm, (d), (s1), (s2), (s3))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.
s3	The opnd_t explicit third source operand for the instruction.

◆ INSTR_CREATE_vprold_mask

#define INSTR_CREATE_vprold_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprold, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprolq_mask

#define INSTR_CREATE_vprolq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprolq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprolvd_mask

#define INSTR_CREATE_vprolvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprolvd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprolvq_mask

#define INSTR_CREATE_vprolvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprolvq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprord_mask

#define INSTR_CREATE_vprord_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprord, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprorq_mask

#define INSTR_CREATE_vprorq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprorq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprorvd_mask

#define INSTR_CREATE_vprorvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprorvd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprorvq_mask

#define INSTR_CREATE_vprorvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vprorvq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprotb

#define INSTR_CREATE_vprotb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vprotb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprotd

#define INSTR_CREATE_vprotd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vprotd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprotq

#define INSTR_CREATE_vprotq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vprotq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vprotw

#define INSTR_CREATE_vprotw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vprotw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsadbw

#define INSTR_CREATE_vpsadbw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsadbw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpscatterdd_mask

#define INSTR_CREATE_vpscatterdd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpscatterdd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpscatterdq_mask

#define INSTR_CREATE_vpscatterdq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpscatterdq, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpscatterqd_mask

#define INSTR_CREATE_vpscatterqd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpscatterqd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpscatterqq_mask

#define INSTR_CREATE_vpscatterqq_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vpscatterqq, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vpshab

#define INSTR_CREATE_vpshab	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshab, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshad

#define INSTR_CREATE_vpshad	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshad, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshaq

#define INSTR_CREATE_vpshaq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshaq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshaw

#define INSTR_CREATE_vpshaw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshaw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshlb

#define INSTR_CREATE_vpshlb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshlb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshld

#define INSTR_CREATE_vpshld	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshld, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshldd_mask

#define INSTR_CREATE_vpshldd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshldq_mask

#define INSTR_CREATE_vpshldq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshldvd_mask

#define INSTR_CREATE_vpshldvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldvd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshldvq_mask

#define INSTR_CREATE_vpshldvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldvq, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshldvw_mask

#define INSTR_CREATE_vpshldvw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldvw, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshldw_mask

#define INSTR_CREATE_vpshldw_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshldw, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshlq

#define INSTR_CREATE_vpshlq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshlq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshlw

#define INSTR_CREATE_vpshlw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshlw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshrdd_mask

#define INSTR_CREATE_vpshrdd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshrdq_mask

#define INSTR_CREATE_vpshrdq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshrdvd_mask

#define INSTR_CREATE_vpshrdvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdvd, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshrdvq_mask

#define INSTR_CREATE_vpshrdvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdvq, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshrdvw_mask

#define INSTR_CREATE_vpshrdvw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdvw, (d), (k), (s1), (s2), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshrdw_mask

#define INSTR_CREATE_vpshrdw_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpshrdw, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpshufb

#define INSTR_CREATE_vpshufb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshufb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshufb_mask

#define INSTR_CREATE_vpshufb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpshufb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshufbitqmb_mask

#define INSTR_CREATE_vpshufbitqmb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpshufbitqmb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshufd

#define INSTR_CREATE_vpshufd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshufd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshufd_mask

#define INSTR_CREATE_vpshufd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vpshufd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpshufhw

#define INSTR_CREATE_vpshufhw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshufhw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshufhw_mask

#define INSTR_CREATE_vpshufhw_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vpshufhw, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpshuflw

#define INSTR_CREATE_vpshuflw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpshuflw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpshuflw_mask

#define INSTR_CREATE_vpshuflw_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vpshuflw, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vpsignb

#define INSTR_CREATE_vpsignb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsignb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsignd

#define INSTR_CREATE_vpsignd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsignd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsignw

#define INSTR_CREATE_vpsignw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsignw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpslld

#define INSTR_CREATE_vpslld	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpslld, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpslld_mask

#define INSTR_CREATE_vpslld_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpslld, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpslldq

#define INSTR_CREATE_vpslldq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpslldq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllq

#define INSTR_CREATE_vpsllq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsllq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllq_mask

#define INSTR_CREATE_vpsllq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsllq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllvd

#define INSTR_CREATE_vpsllvd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsllvd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllvd_mask

#define INSTR_CREATE_vpsllvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsllvd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllvq

#define INSTR_CREATE_vpsllvq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsllvq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllvq_mask

#define INSTR_CREATE_vpsllvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsllvq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllvw_mask

#define INSTR_CREATE_vpsllvw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsllvw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllw

#define INSTR_CREATE_vpsllw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsllw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsllw_mask

#define INSTR_CREATE_vpsllw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsllw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrad

#define INSTR_CREATE_vpsrad	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrad, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrad_mask

#define INSTR_CREATE_vpsrad_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrad, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsraq_mask

#define INSTR_CREATE_vpsraq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsraq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsravd

#define INSTR_CREATE_vpsravd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsravd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsravd_mask

#define INSTR_CREATE_vpsravd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsravd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsravq_mask

#define INSTR_CREATE_vpsravq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsravq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsravw_mask

#define INSTR_CREATE_vpsravw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsravw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsraw

#define INSTR_CREATE_vpsraw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsraw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsraw_mask

#define INSTR_CREATE_vpsraw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsraw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrld

#define INSTR_CREATE_vpsrld	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrld, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrld_mask

#define INSTR_CREATE_vpsrld_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrld, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrldq

#define INSTR_CREATE_vpsrldq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrldq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlq

#define INSTR_CREATE_vpsrlq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrlq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlq_mask

#define INSTR_CREATE_vpsrlq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrlq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlvd

#define INSTR_CREATE_vpsrlvd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrlvd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlvd_mask

#define INSTR_CREATE_vpsrlvd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrlvd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlvq

#define INSTR_CREATE_vpsrlvq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrlvq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlvq_mask

#define INSTR_CREATE_vpsrlvq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrlvq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlvw_mask

#define INSTR_CREATE_vpsrlvw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrlvw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlw

#define INSTR_CREATE_vpsrlw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsrlw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsrlw_mask

#define INSTR_CREATE_vpsrlw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsrlw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubb

#define INSTR_CREATE_vpsubb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubb_mask

#define INSTR_CREATE_vpsubb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubd

#define INSTR_CREATE_vpsubd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubd_mask

#define INSTR_CREATE_vpsubd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubq

#define INSTR_CREATE_vpsubq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubq_mask

#define INSTR_CREATE_vpsubq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubsb

#define INSTR_CREATE_vpsubsb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubsb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubsb_mask

#define INSTR_CREATE_vpsubsb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubsb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubsw

#define INSTR_CREATE_vpsubsw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubsw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubsw_mask

#define INSTR_CREATE_vpsubsw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubsw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubusb

#define INSTR_CREATE_vpsubusb	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubusb, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubusb_mask

#define INSTR_CREATE_vpsubusb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubusb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubusw

#define INSTR_CREATE_vpsubusw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubusw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubusw_mask

#define INSTR_CREATE_vpsubusw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubusw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubw

#define INSTR_CREATE_vpsubw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpsubw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpsubw_mask

#define INSTR_CREATE_vpsubw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpsubw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpternlogd_mask

#define INSTR_CREATE_vpternlogd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpternlogd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vpternlogq_mask

#define INSTR_CREATE_vpternlogq_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vpternlogq, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vptest

#define INSTR_CREATE_vptest	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vptest, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vptestmb_mask

#define INSTR_CREATE_vptestmb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestmb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestmd_mask

#define INSTR_CREATE_vptestmd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestmd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestmq_mask

#define INSTR_CREATE_vptestmq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestmq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestmw_mask

#define INSTR_CREATE_vptestmw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestmw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestnmb_mask

#define INSTR_CREATE_vptestnmb_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestnmb, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestnmd_mask

#define INSTR_CREATE_vptestnmd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestnmd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestnmq_mask

#define INSTR_CREATE_vptestnmq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestnmq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vptestnmw_mask

#define INSTR_CREATE_vptestnmw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vptestnmw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhbw

#define INSTR_CREATE_vpunpckhbw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpckhbw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhbw_mask

#define INSTR_CREATE_vpunpckhbw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpckhbw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhdq

#define INSTR_CREATE_vpunpckhdq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpckhdq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhdq_mask

#define INSTR_CREATE_vpunpckhdq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpckhdq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhqdq

#define INSTR_CREATE_vpunpckhqdq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpckhqdq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhqdq_mask

#define INSTR_CREATE_vpunpckhqdq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpckhqdq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhwd

#define INSTR_CREATE_vpunpckhwd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpckhwd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckhwd_mask

#define INSTR_CREATE_vpunpckhwd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpckhwd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklbw

#define INSTR_CREATE_vpunpcklbw	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpcklbw, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklbw_mask

#define INSTR_CREATE_vpunpcklbw_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpcklbw, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckldq

#define INSTR_CREATE_vpunpckldq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpckldq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpckldq_mask

#define INSTR_CREATE_vpunpckldq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpckldq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklqdq

#define INSTR_CREATE_vpunpcklqdq	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpcklqdq, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklqdq_mask

#define INSTR_CREATE_vpunpcklqdq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpcklqdq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklwd

#define INSTR_CREATE_vpunpcklwd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpunpcklwd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpunpcklwd_mask

#define INSTR_CREATE_vpunpcklwd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpunpcklwd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpxor

#define INSTR_CREATE_vpxor	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vpxor, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpxord_mask

#define INSTR_CREATE_vpxord_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpxord, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vpxorq_mask

#define INSTR_CREATE_vpxorq_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vpxorq, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrangepd_mask

#define INSTR_CREATE_vrangepd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vrangepd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vrangeps_mask

#define INSTR_CREATE_vrangeps_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vrangeps, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vrangesd_mask

#define INSTR_CREATE_vrangesd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vrangesd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vrangess_mask

#define INSTR_CREATE_vrangess_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vrangess, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vrcp14pd_mask

#define INSTR_CREATE_vrcp14pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrcp14pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrcp14ps_mask

#define INSTR_CREATE_vrcp14ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrcp14ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrcp14sd_mask

#define INSTR_CREATE_vrcp14sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrcp14sd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrcp14ss_mask

#define INSTR_CREATE_vrcp14ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrcp14ss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrcp28pd_mask

#define INSTR_CREATE_vrcp28pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrcp28pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrcp28ps_mask

#define INSTR_CREATE_vrcp28ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrcp28ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrcp28sd_mask

#define INSTR_CREATE_vrcp28sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrcp28sd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrcp28ss_mask

#define INSTR_CREATE_vrcp28ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrcp28ss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrcpps

#define INSTR_CREATE_vrcpps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vrcpps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vrcpss

#define INSTR_CREATE_vrcpss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vrcpss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vreducepd_mask

#define INSTR_CREATE_vreducepd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vreducepd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vreduceps_mask

#define INSTR_CREATE_vreduceps_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vreduceps, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vreducesd_mask

#define INSTR_CREATE_vreducesd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vreducesd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vreducess_mask

#define INSTR_CREATE_vreducess_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vreducess, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vrndscalepd_mask

#define INSTR_CREATE_vrndscalepd_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vrndscalepd, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vrndscaleps_mask

#define INSTR_CREATE_vrndscaleps_mask	(	dc,
		d,
		k,
		i,
		s
	)	instr_create_1dst_3src((dc), OP_vrndscaleps, (d), (k), (i), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vroundpd

#define INSTR_CREATE_vroundpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vroundpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vroundps

#define INSTR_CREATE_vroundps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vroundps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vroundsd

#define INSTR_CREATE_vroundsd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vroundsd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vroundss

#define INSTR_CREATE_vroundss	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vroundss, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vrsqrt14pd_mask

#define INSTR_CREATE_vrsqrt14pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrsqrt14pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrsqrt14ps_mask

#define INSTR_CREATE_vrsqrt14ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrsqrt14ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrsqrt14sd_mask

#define INSTR_CREATE_vrsqrt14sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrsqrt14sd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrsqrt14ss_mask

#define INSTR_CREATE_vrsqrt14ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrsqrt14ss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrsqrt28pd_mask

#define INSTR_CREATE_vrsqrt28pd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrsqrt28pd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrsqrt28ps_mask

#define INSTR_CREATE_vrsqrt28ps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vrsqrt28ps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vrsqrt28sd_mask

#define INSTR_CREATE_vrsqrt28sd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrsqrt28sd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrsqrt28ss_mask

#define INSTR_CREATE_vrsqrt28ss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vrsqrt28ss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vrsqrtps

#define INSTR_CREATE_vrsqrtps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vrsqrtps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vrsqrtss

#define INSTR_CREATE_vrsqrtss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vrsqrtss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vscalefpd_mask

#define INSTR_CREATE_vscalefpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vscalefpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vscalefps_mask

#define INSTR_CREATE_vscalefps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vscalefps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vscalefsd_mask

#define INSTR_CREATE_vscalefsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vscalefsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vscalefss_mask

#define INSTR_CREATE_vscalefss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vscalefss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vscatterdpd_mask

#define INSTR_CREATE_vscatterdpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vscatterdpd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterdps_mask

#define INSTR_CREATE_vscatterdps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vscatterdps, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf0dpd_mask

#define INSTR_CREATE_vscatterpf0dpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf0dpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf0dps_mask

#define INSTR_CREATE_vscatterpf0dps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf0dps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf0qpd_mask

#define INSTR_CREATE_vscatterpf0qpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf0qpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf0qps_mask

#define INSTR_CREATE_vscatterpf0qps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf0qps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf1dpd_mask

#define INSTR_CREATE_vscatterpf1dpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf1dpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf1dps_mask

#define INSTR_CREATE_vscatterpf1dps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf1dps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf1qpd_mask

#define INSTR_CREATE_vscatterpf1qpd_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf1qpd, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterpf1qps_mask

#define INSTR_CREATE_vscatterpf1qps_mask	(	dc,
		k,
		s
	)	instr_create_0dst_2src((dc), OP_vscatterpf1qps, (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterqpd_mask

#define INSTR_CREATE_vscatterqpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vscatterqpd, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vscatterqps_mask

#define INSTR_CREATE_vscatterqps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_2dst_2src((dc), OP_vscatterqps, (d), (k), (k), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying the mask as an implicit operand.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t first source operand for the instruction.
s	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vshuff32x4_mask

#define INSTR_CREATE_vshuff32x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshuff32x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vshuff64x2_mask

#define INSTR_CREATE_vshuff64x2_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshuff64x2, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vshufi32x4_mask

#define INSTR_CREATE_vshufi32x4_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshufi32x4, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vshufi64x2_mask

#define INSTR_CREATE_vshufi64x2_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshufi64x2, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vshufpd

#define INSTR_CREATE_vshufpd	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vshufpd, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vshufpd_mask

#define INSTR_CREATE_vshufpd_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshufpd, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vshufps

#define INSTR_CREATE_vshufps	(	dc,
		d,
		s1,
		s2,
		i
	)	instr_create_1dst_3src((dc), OP_vshufps, (d), (s1), (s2), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_vshufps_mask

#define INSTR_CREATE_vshufps_mask	(	dc,
		d,
		k,
		i,
		s1,
		s2
	)	instr_create_1dst_4src((dc), OP_vshufps, (d), (k), (i), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
i	The opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction.

◆ INSTR_CREATE_vsqrtpd

#define INSTR_CREATE_vsqrtpd	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vsqrtpd, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vsqrtpd_mask

#define INSTR_CREATE_vsqrtpd_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vsqrtpd, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vsqrtps

#define INSTR_CREATE_vsqrtps	(	dc,
		d,
		s
	)	instr_create_1dst_1src((dc), OP_vsqrtps, (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_vsqrtps_mask

#define INSTR_CREATE_vsqrtps_mask	(	dc,
		d,
		k,
		s
	)	instr_create_1dst_2src((dc), OP_vsqrtps, (d), (k), (s))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s	The opnd_t explicit first source operand for the instruction

◆ INSTR_CREATE_vsqrtsd

#define INSTR_CREATE_vsqrtsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsqrtsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsqrtsd_mask

#define INSTR_CREATE_vsqrtsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsqrtsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsqrtss

#define INSTR_CREATE_vsqrtss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsqrtss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsqrtss_mask

#define INSTR_CREATE_vsqrtss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsqrtss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vstmxcsr

#define INSTR_CREATE_vstmxcsr	(	dc,
		d
	)	instr_create_1dst_0src((dc), OP_vstmxcsr, (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.

◆ INSTR_CREATE_vsubpd

#define INSTR_CREATE_vsubpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsubpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubpd_mask

#define INSTR_CREATE_vsubpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsubpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubps

#define INSTR_CREATE_vsubps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsubps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubps_mask

#define INSTR_CREATE_vsubps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsubps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubsd

#define INSTR_CREATE_vsubsd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsubsd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubsd_mask

#define INSTR_CREATE_vsubsd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsubsd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubss

#define INSTR_CREATE_vsubss	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vsubss, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vsubss_mask

#define INSTR_CREATE_vsubss_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vsubss, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vtestpd

#define INSTR_CREATE_vtestpd	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vtestpd, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vtestps

#define INSTR_CREATE_vtestps	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vtestps, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vucomisd

#define INSTR_CREATE_vucomisd	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vucomisd, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vucomiss

#define INSTR_CREATE_vucomiss	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_vucomiss, (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t first source operand for the instruction.
s2	The opnd_t second source operand for the instruction.

◆ INSTR_CREATE_vunpckhpd

#define INSTR_CREATE_vunpckhpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vunpckhpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpckhpd_mask

#define INSTR_CREATE_vunpckhpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vunpckhpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpckhps

#define INSTR_CREATE_vunpckhps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vunpckhps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpckhps_mask

#define INSTR_CREATE_vunpckhps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vunpckhps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpcklpd

#define INSTR_CREATE_vunpcklpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vunpcklpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpcklpd_mask

#define INSTR_CREATE_vunpcklpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vunpcklpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpcklps

#define INSTR_CREATE_vunpcklps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vunpcklps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vunpcklps_mask

#define INSTR_CREATE_vunpcklps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vunpcklps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vxorpd

#define INSTR_CREATE_vxorpd	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vxorpd, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vxorpd_mask

#define INSTR_CREATE_vxorpd_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vxorpd, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vxorps

#define INSTR_CREATE_vxorps	(	dc,
		d,
		s1,
		s2
	)	instr_create_1dst_2src((dc), OP_vxorps, (d), (s1), (s2))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction.
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vxorps_mask

#define INSTR_CREATE_vxorps_mask	(	dc,
		d,
		k,
		s1,
		s2
	)	instr_create_1dst_3src((dc), OP_vxorps, (d), (k), (s1), (s2))

This INSTR_CREATE_xxx_mask macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands. The first source operand is the instruction's mask.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
k	The opnd_t explicit mask source operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction
s2	The opnd_t explicit second source operand for the instruction

◆ INSTR_CREATE_vzeroall

#define INSTR_CREATE_vzeroall ( dc ) instr_create_0dst_0src((dc), OP_vzeroall)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_vzeroupper

#define INSTR_CREATE_vzeroupper ( dc ) instr_create_0dst_0src((dc), OP_vzeroupper)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_wbinvd

#define INSTR_CREATE_wbinvd ( dc ) instr_create_0dst_0src((dc), OP_wbinvd)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_wrfsbase

#define INSTR_CREATE_wrfsbase	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_wrfsbase, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit second source operand for the instruction, which must be a general-purpose register.

◆ INSTR_CREATE_wrgsbase

#define INSTR_CREATE_wrgsbase	(	dc,
		s
	)	instr_create_0dst_1src((dc), OP_wrgsbase, (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_wrmsr

#define INSTR_CREATE_wrmsr ( dc )

Value:

instr_create_0dst_3src((dc), OP_wrmsr, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_wrpkru

#define INSTR_CREATE_wrpkru ( dc )

Value:

instr_create_0dst_3src((dc), OP_wrpkru, opnd_create_reg(DR_REG_ECX), \

opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xabort

#define INSTR_CREATE_xabort	(	dc,
		i
	)	instr_create_1dst_1src((dc), OP_xabort, opnd_create_reg(DR_REG_EAX), (i))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The opnd_t explicit source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ INSTR_CREATE_xadd

#define INSTR_CREATE_xadd	(	dc,
		d,
		s
	)	instr_create_2dst_2src((dc), OP_xadd, (d), (s), (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_xbegin

#define INSTR_CREATE_xbegin	(	dc,
		t
	)	instr_create_0dst_1src((dc), OP_xbegin, (t))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc()) or an instr_t (opnd_create_instr()).

◆ INSTR_CREATE_xchg

#define INSTR_CREATE_xchg	(	dc,
		d,
		s
	)	instr_create_2dst_2src((dc), OP_xchg, (d), (s), (d), (s))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_xend

#define INSTR_CREATE_xend ( dc )

Value:

INSTR_PRED(instr_create_1dst_0src((dc), OP_xend, opnd_create_reg(DR_REG_EAX)), \

DR_PRED_COMPLEX)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xgetbv

#define INSTR_CREATE_xgetbv ( dc )

Value:

instr_create_2dst_1src((dc), OP_xgetbv, opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX), opnd_create_reg(DR_REG_ECX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xlat

#define INSTR_CREATE_xlat ( dc )

Value:

    instr_create_1dst_1src(                        \
        (dc), OP_xlat, opnd_create_reg(DR_REG_AL), \
        opnd_create_far_base_disp(DR_SEG_DS, DR_REG_XBX, DR_REG_AL, 1, 0, OPSZ_xlat))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xor

#define INSTR_CREATE_xor	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_xor, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_xorpd

#define INSTR_CREATE_xorpd	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_xorpd, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_xorps

#define INSTR_CREATE_xorps	(	dc,
		d,
		s
	)	instr_create_1dst_2src((dc), OP_xorps, (d), (s), (d))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ INSTR_CREATE_xresldtrk

#define INSTR_CREATE_xresldtrk ( dc ) instr_create_0dst_0src((dc), OP_xresldtrk)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xrstor32

#define INSTR_CREATE_xrstor32	(	dc,
		s
	)

Value:

instr_create_0dst_3src((dc), OP_xrstor32, (s), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xrstor64

#define INSTR_CREATE_xrstor64	(	dc,
		s
	)

Value:

instr_create_0dst_3src((dc), OP_xrstor64, (s), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xrstors32

#define INSTR_CREATE_xrstors32	(	dc,
		s
	)

Value:

instr_create_0dst_3src((dc), OP_xrstors32, (s), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xrstors64

#define INSTR_CREATE_xrstors64	(	dc,
		s
	)

Value:

instr_create_0dst_3src((dc), OP_xrstors64, (s), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s	The opnd_t explicit source operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsave32

#define INSTR_CREATE_xsave32	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsave32, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsave64

#define INSTR_CREATE_xsave64	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsave64, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsavec32

#define INSTR_CREATE_xsavec32	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsavec32, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsavec64

#define INSTR_CREATE_xsavec64	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsavec64, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsaveopt32

#define INSTR_CREATE_xsaveopt32	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsaveopt32, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsaveopt64

#define INSTR_CREATE_xsaveopt64	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsaveopt64, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsaves32

#define INSTR_CREATE_xsaves32	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsaves32, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsaves64

#define INSTR_CREATE_xsaves64	(	dc,
		d
	)

Value:

instr_create_1dst_2src((dc), OP_xsaves64, (d), opnd_create_reg(DR_REG_EDX), \

opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx and the given explicit operands, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction, which can be created with OPND_CREATE_MEM_xsave() to get the appropriate operand size.

◆ INSTR_CREATE_xsetbv

#define INSTR_CREATE_xsetbv ( dc )

Value:

instr_create_0dst_3src((dc), OP_xsetbv, opnd_create_reg(DR_REG_ECX), \

opnd_create_reg(DR_REG_EDX), opnd_create_reg(DR_REG_EAX))

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xsusldtrk

#define INSTR_CREATE_xsusldtrk ( dc ) instr_create_0dst_0src((dc), OP_xsusldtrk)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ INSTR_CREATE_xtest

#define INSTR_CREATE_xtest ( dc ) instr_create_0dst_0src((dc), OP_xtest)

This INSTR_CREATE_xxx macro creates an instr_t with opcode OP_xxx, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ LOCK

#define LOCK ( instr_ptr ) instr_set_prefix_flag((instr_ptr), PREFIX_LOCK)

Add the lock prefix to an instruction. For example: instr_t *lock_inc_instr = LOCK(INSTR_CREATE_inc(....));

◆ OPND_CREATE_ABSMEM

#define OPND_CREATE_ABSMEM	(	addr,
		size
	)	opnd_create_rel_addr(addr, size)

Create an absolute address operand encoded as pc-relative. Encoding will fail if addr is out of 32-bit-signed-displacement reach.

◆ OPND_CREATE_MEM_bound

#define OPND_CREATE_MEM_bound	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_bound)

Create a memory reference operand appropriately sized for OP_bound.

◆ OPND_CREATE_MEM_clflush

#define OPND_CREATE_MEM_clflush	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_clflush)

Create a memory reference operand appropriately sized for OP_clflush.

◆ OPND_CREATE_MEM_fldenv

#define OPND_CREATE_MEM_fldenv	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_fldenv)

Create a memory reference operand appropriately sized for OP_fldenv.

◆ OPND_CREATE_MEM_fnsave

#define OPND_CREATE_MEM_fnsave	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_fnsave)

Create a memory reference operand appropriately sized for OP_fnsave.

◆ OPND_CREATE_MEM_fnstenv

#define OPND_CREATE_MEM_fnstenv	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_fnstenv)

Create a memory reference operand appropriately sized for OP_fnstenv.

◆ OPND_CREATE_MEM_frstor

#define OPND_CREATE_MEM_frstor	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_frstor)

Create a memory reference operand appropriately sized for OP_frstor.

◆ OPND_CREATE_MEM_fxrstor

#define OPND_CREATE_MEM_fxrstor	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_fxrstor)

Create a memory reference operand appropriately sized for OP_fxrstor32/OP_fxrstor64.

◆ OPND_CREATE_MEM_fxsave

#define OPND_CREATE_MEM_fxsave	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_fxsave)

Create a memory reference operand appropriately sized for OP_fxsave32/OP_fxsave64.

◆ OPND_CREATE_MEM_invlpg

#define OPND_CREATE_MEM_invlpg	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_invlpg)

Create a memory reference operand appropriately sized for OP_invlpg.

◆ OPND_CREATE_MEM_lea

#define OPND_CREATE_MEM_lea	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_lea)

Create a memory reference operand appropriately sized for OP_lea.

◆ OPND_CREATE_MEM_lgdt

#define OPND_CREATE_MEM_lgdt	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_lgdt)

Create a memory reference operand appropriately sized for OP_lgdt.

◆ OPND_CREATE_MEM_lidt

#define OPND_CREATE_MEM_lidt	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_lidt)

Create a memory reference operand appropriately sized for OP_lidt.

◆ OPND_CREATE_MEM_prefetch

#define OPND_CREATE_MEM_prefetch	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_prefetch)

Create a memory reference operand appropriately sized for OP_prefetch*.

◆ OPND_CREATE_MEM_ptwrite

#define OPND_CREATE_MEM_ptwrite	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_ptwrite)

Create a memory reference operand appropriately sized for OP_ptwrite.

◆ OPND_CREATE_MEM_sgdt

#define OPND_CREATE_MEM_sgdt	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_sgdt)

Create a memory reference operand appropriately sized for OP_sgdt.

◆ OPND_CREATE_MEM_sidt

#define OPND_CREATE_MEM_sidt	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_sidt)

Create a memory reference operand appropriately sized for OP_sidt.

◆ OPND_CREATE_MEM_xsave

#define OPND_CREATE_MEM_xsave	(	base,
		index,
		scale,
		disp
	)	opnd_create_base_disp(base, index, scale, disp, OPSZ_xsave)

Create a memory reference operand appropriately sized for OP_xsave32, OP_xsave64, OP_xsaveopt32, OP_xsaveopt64, OP_xsavec32, OP_xsavec64, OP_xrstor32, or OP_xrstor64.

◆ XINST_CREATE_add

#define XINST_CREATE_add	(	dc,
		d,
		s
	)

Value:

    INSTR_CREATE_lea(                                                        \
        (dc), (d),                                                           \
        OPND_CREATE_MEM_lea(                                                 \
            opnd_get_reg(d), opnd_is_reg(s) ? opnd_get_reg(s) : DR_REG_NULL, \
            opnd_is_reg(s) ? 1 : 0, opnd_is_reg(s) ? 0 : (int)opnd_get_immed_int(s)))

This platform-independent macro creates an instr_t for an addition instruction that does not affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction. This can be either a register or a 32-bit immediate integer on x86.

◆ XINST_CREATE_add_2src

#define XINST_CREATE_add_2src	(	dc,
		d,
		s1,
		s2
	)

Value:

    INSTR_CREATE_lea(                                                           \
        (dc), (d),                                                              \
        OPND_CREATE_MEM_lea(                                                    \
            opnd_get_reg(s1), opnd_is_reg(s2) ? opnd_get_reg(s2) : DR_REG_NULL, \
            opnd_is_reg(s2) ? 1 : 0, opnd_is_reg(s2) ? 0 : (int)opnd_get_immed_int(s2)))

This platform-independent macro creates an instr_t for an addition instruction that does not affect the status flags and takes two sources plus a destination.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction. This must be a register.
s2	The opnd_t explicit source operand for the instruction. This can be either a register or a 32-bit immediate integer on x86.

◆ XINST_CREATE_add_s

#define XINST_CREATE_add_s	(	dc,
		d,
		s
	)	INSTR_CREATE_add((dc), (d), (s))

This platform-independent macro creates an instr_t for an addition instruction that does affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_add_sll

#define XINST_CREATE_add_sll	(	dc,
		d,
		s1,
		s2_toshift,
		shift_amount
	)

Value:

    INSTR_CREATE_lea(                                                                  \
        (dc), (d),                                                                     \
        OPND_CREATE_MEM_lea(                                                           \
            opnd_get_reg(s1), opnd_get_reg(s2_toshift),                                \
            ((shift_amount) == 0                                                       \
                 ? 1                                                                   \
                 : ((shift_amount) == 1                                                \
                        ? 2                                                            \
                        : ((shift_amount) == 2                                         \
                               ? 4                                                     \
                               : ((shift_amount) == 3                                  \
                                      ? 8                                              \
                                      : (DR_ASSERT_MSG(false, "invalid shift amount"), \
                                         0))))),                                       \
            0))

This platform-independent macro creates an instr_t for an addition instruction that does not affect the status flags and takes two register sources plus a destination, with one source being shifted logically left by an immediate amount that is limited to either 0, 1, 2, or 3.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction. This must be a register.
s2_toshift	The opnd_t explicit source operand for the instruction. This must be a register.
shift_amount	An integer value that must be either 0, 1, 2, or 3.

◆ XINST_CREATE_and_s

#define XINST_CREATE_and_s	(	dc,
		d,
		s
	)	INSTR_CREATE_and((dc), (d), (s))

This platform-independent macro creates an instr_t for a bitwise and instruction that does affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_call

#define XINST_CREATE_call	(	dc,
		t
	)	INSTR_CREATE_call((dc), (t))

This platform-independent macro creates an instr_t for an unconditional branch instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_call_reg

#define XINST_CREATE_call_reg	(	dc,
		r
	)	INSTR_CREATE_call_ind(dc, r)

This platform-independent macro creates an instr_t for an indirect call instr through a register.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The opnd_t explicit source operand for the instruction. This should be a reg_id_t operand with the address of the subroutine.

◆ XINST_CREATE_cmp

#define XINST_CREATE_cmp	(	dc,
		s1,
		s2
	)	instr_create_0dst_2src((dc), OP_cmp, (s1), (s2))

This platform-independent macro creates an instr_t for a comparison instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit destination operand for the instruction.
s2	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_debug_instr

#define XINST_CREATE_debug_instr ( dc ) INSTR_CREATE_int3(dc)

This platform-independent macro creates an instr_t for a debug trap instruction, automatically supplying any implicit operands.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_interrupt

#define XINST_CREATE_interrupt	(	dc,
		i
	)	INSTR_CREATE_int(dc, i)

This platform-independent macro creates an instr_t for a software interrupt instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The source integer constant opnd_t operand.

◆ XINST_CREATE_jump

#define XINST_CREATE_jump	(	dc,
		t
	)	INSTR_CREATE_jmp((dc), (t))

This platform-independent macro creates an instr_t for an unconditional branch instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_jump_cond

#define XINST_CREATE_jump_cond	(	dc,
		pred,
		t
	)	(INSTR_CREATE_jcc((dc), (pred)-DR_PRED_O + OP_jo, (t)))

This platform-independent macro creates an instr_t for a conditional branch instruction that branches if the previously-set condition codes indicate the condition indicated by pred.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
pred	The dr_pred_type_t condition to match.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_jump_mem

#define XINST_CREATE_jump_mem	(	dc,
		m
	)	INSTR_CREATE_jmp_ind(dc, m)

This platform-independent macro creates an instr_t for an indirect jump through memory instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The memory opnd holding the target.

◆ XINST_CREATE_jump_reg

#define XINST_CREATE_jump_reg	(	dc,
		r
	)	INSTR_CREATE_jmp_ind(dc, r)

This platform-independent macro creates an instr_t for an indirect jump instruction through a register.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The register opnd holding the target.

◆ XINST_CREATE_jump_short

#define XINST_CREATE_jump_short	(	dc,
		t
	)	INSTR_CREATE_jmp_short((dc), (t))

This platform-independent macro creates an instr_t for an unconditional branch instruction with the smallest available reach.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_load

#define XINST_CREATE_load	(	dc,
		r,
		m
	)	INSTR_CREATE_mov_ld(dc, r, m)

This platform-independent macro creates an instr_t for a 4-byte or 8-byte (x64 only) memory load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_1byte

#define XINST_CREATE_load_1byte	(	dc,
		r,
		m
	)	INSTR_CREATE_mov_ld(dc, r, m)

This platform-independent macro creates an instr_t for a 1-byte memory load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_1byte_zext4

#define XINST_CREATE_load_1byte_zext4	(	dc,
		r,
		m
	)	INSTR_CREATE_movzx(dc, r, m)

This platform-independent macro creates an instr_t which loads 1 byte from memory, zero-extends it to 4 bytes, and writes it to a 4 byte destination register.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_2bytes

#define XINST_CREATE_load_2bytes	(	dc,
		r,
		m
	)	INSTR_CREATE_mov_ld(dc, r, m)

This platform-independent macro creates an instr_t for a 2-byte memory load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_int

#define XINST_CREATE_load_int	(	dc,
		r,
		i
	)	INSTR_CREATE_mov_imm(dc, r, i)

This platform-independent macro creates an instr_t for an immediate integer load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
i	The source immediate integer opnd.

◆ XINST_CREATE_load_simd

#define XINST_CREATE_load_simd	(	dc,
		r,
		m
	)	INSTR_CREATE_movd(dc, r, m)

This platform-independent macro creates an instr_t for a multimedia register load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_move

#define XINST_CREATE_move	(	dc,
		d,
		s
	)	INSTR_CREATE_mov_ld(dc, d, s)

This platform-independent macro creates an instr_t for a register to register move instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The destination register opnd.
s	The source register opnd.

◆ XINST_CREATE_nop

#define XINST_CREATE_nop ( dc ) INSTR_CREATE_nop(dc)

This platform-independent macro creates an instr_t for a nop instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_return

#define XINST_CREATE_return ( dc ) INSTR_CREATE_ret(dc)

This platform-independent macro creates an instr_t for a return instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_slr_s

#define XINST_CREATE_slr_s	(	dc,
		d,
		s
	)	INSTR_CREATE_shr((dc), (d), (s))

This platform-independent macro creates an instr_t for a logical right shift instruction that does affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_store

#define XINST_CREATE_store	(	dc,
		m,
		r
	)	INSTR_CREATE_mov_st(dc, m, r)

This platform-independent macro creates an instr_t for a 4-byte or 8-byte (x64 only) memory store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_1byte

#define XINST_CREATE_store_1byte	(	dc,
		m,
		r
	)	INSTR_CREATE_mov_st(dc, m, r)

This platform-independent macro creates an instr_t for a 1-byte memory store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_2bytes

#define XINST_CREATE_store_2bytes	(	dc,
		m,
		r
	)	INSTR_CREATE_mov_st(dc, m, r)

This platform-independent macro creates an instr_t for a 2-byte memory store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_simd

#define XINST_CREATE_store_simd	(	dc,
		m,
		r
	)	INSTR_CREATE_movd(dc, m, r)

This platform-independent macro creates an instr_t for a multimedia register store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_sub

#define XINST_CREATE_sub	(	dc,
		d,
		s
	)

Value:

    INSTR_CREATE_lea((dc), (d),                                           \
                     OPND_CREATE_MEM_lea(opnd_get_reg(d), DR_REG_NULL, 0, \
                                         -(int)opnd_get_immed_int(s)))

This platform-independent macro creates an instr_t for a subtraction instruction that does not affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction. The source must be an immediate integer on x86.

◆ XINST_CREATE_sub_s

#define XINST_CREATE_sub_s	(	dc,
		d,
		s
	)	INSTR_CREATE_sub((dc), (d), (s))

This platform-independent macro creates an instr_t for a subtraction instruction that does affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

Function Documentation

◆ INSTR_CREATE_nop2byte_reg()

static instr_t* INSTR_CREATE_nop2byte_reg	(	void *	drcontext,
		reg_id_t	reg
	)

inlinestatic

Convenience routine for nop of certain size. Note that Intel now recommends a different set of multi-byte nops, but we stick with these as our tools (mainly windbg) don't understand the OP_nop_modrm encoding (though should work on PPro+). AMD recommends 0x66 0x66 ... 0x90 for older processors.

Parameters

drcontext	The void * dcontext used to allocate memory for the instr_t.
reg	A reg_id_t (NOT opnd_t) to use as source and destination. For 64-bit mode, use a 64-bit register, but NOT rbp or rsp for the 3-byte form.

◆ INSTR_CREATE_nop3byte_reg()

static instr_t* INSTR_CREATE_nop3byte_reg	(	void *	drcontext,
		reg_id_t	reg
	)

inlinestatic

Convenience routine for nop of certain size. Note that Intel now recommends a different set of multi-byte nops, but we stick with these as our tools (mainly windbg) don't understand the OP_nop_modrm encoding (though should work on PPro+). AMD recommends 0x66 0x66 ... 0x90 for older processors.

Parameters

drcontext	The void * dcontext used to allocate memory for the instr_t.
reg	A reg_id_t (NOT opnd_t) to use as source and destination. For 64-bit mode, use a 64-bit register, but NOT rbp or rsp for the 3-byte form.

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ INSTR_CREATE_aaa

◆ INSTR_CREATE_aad

◆ INSTR_CREATE_aam

◆ INSTR_CREATE_aas

◆ INSTR_CREATE_adc

◆ INSTR_CREATE_adcx

◆ INSTR_CREATE_add

◆ INSTR_CREATE_addpd

◆ INSTR_CREATE_addps

◆ INSTR_CREATE_addsd

◆ INSTR_CREATE_addss

◆ INSTR_CREATE_addsubpd

◆ INSTR_CREATE_addsubps

◆ INSTR_CREATE_adox

◆ INSTR_CREATE_aesdec

◆ INSTR_CREATE_aesdeclast

◆ INSTR_CREATE_aesenc

◆ INSTR_CREATE_aesenclast

◆ INSTR_CREATE_aesimc

◆ INSTR_CREATE_aeskeygenassist

◆ INSTR_CREATE_and

◆ INSTR_CREATE_andn

◆ INSTR_CREATE_andnpd

◆ INSTR_CREATE_andnps

◆ INSTR_CREATE_andpd

◆ INSTR_CREATE_andps

◆ INSTR_CREATE_arpl

◆ INSTR_CREATE_bextr

◆ INSTR_CREATE_blcfill

◆ INSTR_CREATE_blci

◆ INSTR_CREATE_blcic

◆ INSTR_CREATE_blcmsk

◆ INSTR_CREATE_blcs

◆ INSTR_CREATE_blendpd

◆ INSTR_CREATE_blendps

◆ INSTR_CREATE_blendvpd

◆ INSTR_CREATE_blendvps

◆ INSTR_CREATE_blsfill

◆ INSTR_CREATE_blsi

◆ INSTR_CREATE_blsic

◆ INSTR_CREATE_blsmsk

◆ INSTR_CREATE_blsr

◆ INSTR_CREATE_bndcl

◆ INSTR_CREATE_bndcn

◆ INSTR_CREATE_bndcu

◆ INSTR_CREATE_bndldx

◆ INSTR_CREATE_bndmk

◆ INSTR_CREATE_bndmov

◆ INSTR_CREATE_bndstx

◆ INSTR_CREATE_bound

◆ INSTR_CREATE_bsf

◆ INSTR_CREATE_bsr

◆ INSTR_CREATE_bswap

◆ INSTR_CREATE_bt

◆ INSTR_CREATE_btc

◆ INSTR_CREATE_btr

◆ INSTR_CREATE_bts

◆ INSTR_CREATE_bzhi

◆ INSTR_CREATE_call

◆ INSTR_CREATE_call_far

◆ INSTR_CREATE_call_far_ind

◆ INSTR_CREATE_call_ind

◆ INSTR_CREATE_cdq

◆ INSTR_CREATE_clac

◆ INSTR_CREATE_clc

◆ INSTR_CREATE_cld

◆ INSTR_CREATE_cldemote

◆ INSTR_CREATE_clflush

◆ INSTR_CREATE_clflushopt

◆ INSTR_CREATE_clgi

◆ INSTR_CREATE_cli

◆ INSTR_CREATE_clts

◆ INSTR_CREATE_clwb

◆ INSTR_CREATE_cmc

◆ INSTR_CREATE_cmovcc

◆ INSTR_CREATE_cmp