Dynamic Instrumentation Tool Platform
Macros
dr_ir_macros_x86.h File Reference

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_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)
 
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))
 
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))
 
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))
 
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))
 
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))
 
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))
 
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))
 
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))
 
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))
 
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))
 
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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe opnd_t first source operand for the instruction.
riThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.

◆ 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.

◆ 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
opThe OP_xxx opcode for the instruction, which should be in the range [OP_cmovo, OP_cmovnle].
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.

◆ 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
dcThe void * dcontext used to allocate memory for the instr_t.
i16The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()) of OPSZ_2.
i8The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
i1The opnd_t explicit first source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
i2The 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
opThe OP_xxx opcode for the instruction, which should be in the range [OP_fcmovb, OP_fcmovnu], excluding OP_fucompp.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe opnd_t destination (and implicit source) operand for the instruction, which must be a floating point register (opnd_create_reg()).
sThe opnd_t source (and non-destination) operand for the instruction, which must be one of the following:
  1. A floating point register (opnd_create_reg()).
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
fThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.

◆ 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
rThe opnd_t explicit first source operand for the instruction, which must be an xmm register (opnd_create_reg()).
i1The opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
i2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
opThe OP_xxx opcode for the conditional branch, which should be in the range [OP_jo, OP_jnle].
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
opThe OP_xxx opcode for the conditional branch, which should be in the range [OP_jo_short, OP_jnle_short].
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction, which must be a general-purpose register.
s2The opnd_t second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction, which must be a general-purpose register.
s2The opnd_t second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
d1The opnd_t explicit first destination source operand for the instruction, which must be a general-purpose register.
d2The opnd_t explicit first destination source operand for the instruction, which must be a general-purpose register.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.

◆ 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
opThe OP_xxx opcode for the instruction, which should be in the range [OP_seto, OP_setnle].
dThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. An immediate integer (opnd_create_immed_int()) of size OPSZ_1;
  3. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
riThe opnd_t explicit source operand for the instruction, which must be one of the following:
  1. The register cl (opnd_create_reg(DR_REG_CL));
  2. 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe opnd_t explicit source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).

◆ 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The opnd_t explicit second 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The opnd_t explicit second 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction.
s3The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit second source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t first source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The opnd_t explicit second source operand for the instruction
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
iThe opnd_t explicit third source operand for the instruction, which must be an immediate integer (opnd_create_immed_int()).
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
kThe opnd_t explicit mask source operand for the instruction.
s1The opnd_t explicit first source operand for the instruction
s2The 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe 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
dcThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction. This must be a register.
s2The 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
s1The opnd_t explicit first source operand for the instruction. This must be a register.
s2_toshiftThe opnd_t explicit source operand for the instruction. This must be a register.
shift_amountAn 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
s1The opnd_t explicit destination operand for the instruction.
s2The 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
predThe dr_pred_type_t condition to match.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
tThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
iThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe destination register opnd.
sThe 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
dcThe 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
dcThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe destination memory opnd.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe destination memory opnd.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe destination memory opnd.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
mThe destination memory opnd.
rThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
dcThe void * dcontext used to allocate memory for the instr_t.
dThe opnd_t explicit destination operand for the instruction.
sThe 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
drcontextThe void * dcontext used to allocate memory for the instr_t.
regA 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
drcontextThe void * dcontext used to allocate memory for the instr_t.
regA 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_2dst_1src
DR_API instr_t * instr_create_2dst_1src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t src)
OP_push_imm
@ OP_push_imm
Definition: dr_ir_opcodes_x86.h:89
OP_getsec
@ OP_getsec
Definition: dr_ir_opcodes_x86.h:1213
instr_create_3dst_5src
DR_API instr_t * instr_create_3dst_5src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4, opnd_t src5)
DR_REG_ECX
@ DR_REG_ECX
Definition: dr_ir_opnd.h:319
OP_xrstor32
@ OP_xrstor32
Definition: dr_ir_opcodes_x86.h:752
OP_vpcmpistri
@ OP_vpcmpistri
Definition: dr_ir_opcodes_x86.h:992
OP_cwde
@ OP_cwde
Definition: dr_ir_opcodes_x86.h:142
OP_invlpga
@ OP_invlpga
Definition: dr_ir_opcodes_x86.h:728
OP_pushf
@ OP_pushf
Definition: dr_ir_opcodes_x86.h:145
OP_div
@ OP_div
Definition: dr_ir_opcodes_x86.h:351
OPSZ_12
@ OPSZ_12
Definition: dr_ir_opnd.h:152
DR_REG_EAX
@ DR_REG_EAX
Definition: dr_ir_opnd.h:318
instr_create_2dst_2src
DR_API instr_t * instr_create_2dst_2src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t src1, opnd_t src2)
OP_fyl2x
@ OP_fyl2x
Definition: dr_ir_opcodes_x86.h:537
OP_xsaves64
@ OP_xsaves64
Definition: dr_ir_opcodes_x86.h:1621
OP_pcmpistrm
@ OP_pcmpistrm
Definition: dr_ir_opcodes_x86.h:696
OP_movs
@ OP_movs
Definition: dr_ir_opcodes_arm.h:170
OP_call_far
@ OP_call_far
Definition: dr_ir_opcodes_x86.h:116
OP_in
@ OP_in
Definition: dr_ir_opcodes_x86.h:164
OP_fabs
@ OP_fabs
Definition: dr_ir_opcodes_x86.h:526
instr_create_1dst_0src
DR_API instr_t * instr_create_1dst_0src(void *drcontext, int opcode, opnd_t dst)
DR_PRED_O
@ DR_PRED_O
Definition: dr_ir_opnd.h:2068
OP_rdmsr
@ OP_rdmsr
Definition: dr_ir_opcodes_x86.h:188
OP_monitor
@ OP_monitor
Definition: dr_ir_opcodes_x86.h:587
DR_SEG_ES
@ DR_SEG_ES
Definition: dr_ir_opnd.h:426
OPSZ_maskmovq
#define OPSZ_maskmovq
Definition: dr_ir_opnd.h:265
OP_outs
@ OP_outs
Definition: dr_ir_opcodes_x86.h:475
OP_scas
@ OP_scas
Definition: dr_ir_opcodes_x86.h:486
OP_lods
@ OP_lods
Definition: dr_ir_opcodes_x86.h:481
OP_xsavec32
@ OP_xsavec32
Definition: dr_ir_opcodes_x86.h:1256
DR_ASSERT_MSG
#define DR_ASSERT_MSG(x, msg)
Definition: dr_tools.h:97
OP_fimul
@ OP_fimul
Definition: dr_ir_opcodes_x86.h:506
OP_cmpxchg8b
@ OP_cmpxchg8b
Definition: dr_ir_opcodes_x86.h:366
OP_pcmpestrm
@ OP_pcmpestrm
Definition: dr_ir_opcodes_x86.h:694
OP_fldln2
@ OP_fldln2
Definition: dr_ir_opcodes_x86.h:534
OP_xgetbv
@ OP_xgetbv
Definition: dr_ir_opcodes_x86.h:749
OP_ftst
@ OP_ftst
Definition: dr_ir_opcodes_x86.h:527
OP_repne_scas
@ OP_repne_scas
Definition: dr_ir_opcodes_x86.h:488
OP_xsaveopt64
@ OP_xsaveopt64
Definition: dr_ir_opcodes_x86.h:1085
OPSZ_xlat
#define OPSZ_xlat
Definition: dr_ir_opnd.h:257
OP_wrmsr
@ OP_wrmsr
Definition: dr_ir_opcodes_x86.h:186
OP_leave
@ OP_leave
Definition: dr_ir_opcodes_x86.h:156
OP_ret_far
@ OP_ret_far
Definition: dr_ir_opcodes_x86.h:151
OP_aam
@ OP_aam
Definition: dr_ir_opcodes_x86.h:161
OP_sysret
@ OP_sysret
Definition: dr_ir_opcodes_x86.h:179
OP_maskmovq
@ OP_maskmovq
Definition: dr_ir_opcodes_x86.h:329
OP_out
@ OP_out
Definition: dr_ir_opcodes_x86.h:165
OP_cpuid
@ OP_cpuid
Definition: dr_ir_opcodes_x86.h:271
DR_REG_XDI
#define DR_REG_XDI
Definition: dr_ir_opnd.h:1672
OP_vmaskmovpd
@ OP_vmaskmovpd
Definition: dr_ir_opcodes_x86.h:1005
instr_create_1dst_1src
DR_API instr_t * instr_create_1dst_1src(void *drcontext, int opcode, opnd_t dst, opnd_t src)
DR_REG_AL
@ DR_REG_AL
Definition: dr_ir_opnd.h:352
OP_syscall
@ OP_syscall
Definition: dr_ir_opcodes_x86.h:177
OPSZ_8_short2
@ OPSZ_8_short2
Definition: dr_ir_opnd.h:118
opnd_get_size
DR_API opnd_size_t opnd_get_size(opnd_t opnd)
OP_stos
@ OP_stos
Definition: dr_ir_opcodes_x86.h:479
OP_xrstor64
@ OP_xrstor64
Definition: dr_ir_opcodes_x86.h:1084
DR_PRED_COMPLEX
@ DR_PRED_COMPLEX
Definition: dr_ir_opnd.h:2091
DR_REG_XSP
#define DR_REG_XSP
Definition: dr_ir_opnd.h:1666
OP_fisub
@ OP_fisub
Definition: dr_ir_opcodes_x86.h:509
OP_rep_ins
@ OP_rep_ins
Definition: dr_ir_opcodes_x86.h:474
OP_rep_outs
@ OP_rep_outs
Definition: dr_ir_opcodes_x86.h:476
DR_REG_RAX
@ DR_REG_RAX
Definition: dr_ir_opnd.h:301
OP_xsave32
@ OP_xsave32
Definition: dr_ir_opcodes_x86.h:751
OP_jo
@ OP_jo
Definition: dr_ir_opcodes_x86.h:237
OP_xsetbv
@ OP_xsetbv
Definition: dr_ir_opcodes_x86.h:750
OPSZ_STACK
#define OPSZ_STACK
Definition: dr_ir_opnd.h:235
OP_cmps
@ OP_cmps
Definition: dr_ir_opcodes_x86.h:483
DR_REG_XSI
#define DR_REG_XSI
Definition: dr_ir_opnd.h:1670
OP_fcos
@ OP_fcos
Definition: dr_ir_opcodes_x86.h:551
INSTR_CREATE_lea
#define INSTR_CREATE_lea(dc, d, s)
Definition: dr_ir_macros_x86.h:1217
OP_vmaskmovdqu
@ OP_vmaskmovdqu
Definition: dr_ir_opcodes_x86.h:902
OP_xsaveopt32
@ OP_xsaveopt32
Definition: dr_ir_opcodes_x86.h:753
OP_call
@ OP_call
Definition: dr_ir_opcodes_x86.h:114
OP_ficom
@ OP_ficom
Definition: dr_ir_opcodes_x86.h:507
OP_pcmpestri
@ OP_pcmpestri
Definition: dr_ir_opcodes_x86.h:695
OP_repne_cmps
@ OP_repne_cmps
Definition: dr_ir_opcodes_x86.h:485
OP_rdtscp
@ OP_rdtscp
Definition: dr_ir_opcodes_x86.h:730
OP_fxch
@ OP_fxch
Definition: dr_ir_opcodes_x86.h:523
DR_REG_XCX
#define DR_REG_XCX
Definition: dr_ir_opnd.h:1660
DR_REG_EBX
@ DR_REG_EBX
Definition: dr_ir_opnd.h:321
OP_fidiv
@ OP_fidiv
Definition: dr_ir_opcodes_x86.h:511
OP_fptan
@ OP_fptan
Definition: dr_ir_opcodes_x86.h:538
OP_aaa
@ OP_aaa
Definition: dr_ir_opcodes_x86.h:83
opnd_create_immed_float
DR_API opnd_t opnd_create_immed_float(float f)
OP_encls
@ OP_encls
Definition: dr_ir_opcodes_x86.h:1598
OP_fsin
@ OP_fsin
Definition: dr_ir_opcodes_x86.h:550
OPSZ_16
@ OPSZ_16
Definition: dr_ir_opnd.h:90
OP_fldpi
@ OP_fldpi
Definition: dr_ir_opcodes_x86.h:532
opnd_create_base_disp
DR_API opnd_t opnd_create_base_disp(reg_id_t base_reg, reg_id_t index_reg, int scale, int disp, opnd_size_t data_size)
OP_rep_lods
@ OP_rep_lods
Definition: dr_ir_opcodes_x86.h:482
OP_fprem
@ OP_fprem
Definition: dr_ir_opcodes_x86.h:544
OP_xrstors32
@ OP_xrstors32
Definition: dr_ir_opcodes_x86.h:1622
OP_fisubr
@ OP_fisubr
Definition: dr_ir_opcodes_x86.h:510
OP_loopne
@ OP_loopne
Definition: dr_ir_opcodes_x86.h:124
OP_cmpxchg
@ OP_cmpxchg
Definition: dr_ir_opcodes_x86.h:277
DR_REG_R11
@ DR_REG_R11
Definition: dr_ir_opnd.h:312
OP_mulx
@ OP_mulx
Definition: dr_ir_opcodes_x86.h:1210
OP_popf
@ OP_popf
Definition: dr_ir_opcodes_x86.h:146
OP_fld1
@ OP_fld1
Definition: dr_ir_opcodes_x86.h:529
OP_rep_cmps
@ OP_rep_cmps
Definition: dr_ir_opcodes_x86.h:484
OP_fldlg2
@ OP_fldlg2
Definition: dr_ir_opcodes_x86.h:533
OP_fprem1
@ OP_fprem1
Definition: dr_ir_opcodes_x86.h:541
OP_rdpkru
@ OP_rdpkru
Definition: dr_ir_opcodes_x86.h:1594
OP_daa
@ OP_daa
Definition: dr_ir_opcodes_x86.h:79
OP_enclv
@ OP_enclv
Definition: dr_ir_opcodes_x86.h:1600
OP_monitorx
@ OP_monitorx
Definition: dr_ir_opcodes_x86.h:1590
OPSZ_40
@ OPSZ_40
Definition: dr_ir_opnd.h:155
DR_REG_XMM0
@ DR_REG_XMM0
Definition: dr_ir_opnd.h:382
OP_fldl2e
@ OP_fldl2e
Definition: dr_ir_opcodes_x86.h:531
OP_enter
@ OP_enter
Definition: dr_ir_opcodes_x86.h:155
OP_imul
@ OP_imul
Definition: dr_ir_opcodes_x86.h:95
OP_xsavec64
@ OP_xsavec64
Definition: dr_ir_opcodes_x86.h:1257
OP_xlat
@ OP_xlat
Definition: dr_ir_opcodes_x86.h:163
instr_create_0dst_2src
DR_API instr_t * instr_create_0dst_2src(void *drcontext, int opcode, opnd_t src1, opnd_t src2)
instr_create_3dst_2src
DR_API instr_t * instr_create_3dst_2src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t src1, opnd_t src2)
OP_ins
@ OP_ins
Definition: dr_ir_opcodes_x86.h:473
OP_rep_movs
@ OP_rep_movs
Definition: dr_ir_opcodes_x86.h:478
OP_enclu
@ OP_enclu
Definition: dr_ir_opcodes_x86.h:1599
OP_fscale
@ OP_fscale
Definition: dr_ir_opcodes_x86.h:549
OP_xend
@ OP_xend
Definition: dr_ir_opcodes_x86.h:1222
DR_REG_DX
@ DR_REG_DX
Definition: dr_ir_opnd.h:337
OP_ret
@ OP_ret
Definition: dr_ir_opcodes_x86.h:150
OP_rdtsc
@ OP_rdtsc
Definition: dr_ir_opcodes_x86.h:187
reg_resize_to_opsz
DR_API reg_id_t reg_resize_to_opsz(reg_id_t reg, opnd_size_t sz)
OP_idiv
@ OP_idiv
Definition: dr_ir_opcodes_x86.h:352
instr_create_2dst_0src
DR_API instr_t * instr_create_2dst_0src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2)
DR_REG_EDX
@ DR_REG_EDX
Definition: dr_ir_opnd.h:320
OPSZ_1
@ OPSZ_1
Definition: dr_ir_opnd.h:83
opnd_create_reg
DR_API INSTR_INLINE opnd_t opnd_create_reg(reg_id_t r)
instr_cmovcc_to_jcc
DR_API int instr_cmovcc_to_jcc(int cmovcc_opcode)
instr_create_3dst_3src
DR_API instr_t * instr_create_3dst_3src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t src1, opnd_t src2, opnd_t src3)
instr_create_1dst_2src
DR_API instr_t * instr_create_1dst_2src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2)
OP_xsave64
@ OP_xsave64
Definition: dr_ir_opcodes_x86.h:1083
OP_rep_scas
@ OP_rep_scas
Definition: dr_ir_opcodes_x86.h:487
OP_pop
@ OP_pop
Definition: dr_ir_opcodes_x86.h:90
OP_mul
@ OP_mul
Definition: dr_ir_opcodes_arm.h:181
DR_REG_XAX
#define DR_REG_XAX
Definition: dr_ir_opnd.h:1658
OP_fucompp
@ OP_fucompp
Definition: dr_ir_opcodes_x86.h:556
OP_call_ind
@ OP_call_ind
Definition: dr_ir_opcodes_x86.h:115
OP_aas
@ OP_aas
Definition: dr_ir_opcodes_x86.h:85
DR_REG_AH
@ DR_REG_AH
Definition: dr_ir_opnd.h:356
OP_pcmpistri
@ OP_pcmpistri
Definition: dr_ir_opcodes_x86.h:697
OP_fsincos
@ OP_fsincos
Definition: dr_ir_opcodes_x86.h:547
DR_REG_NULL
@ DR_REG_NULL
Definition: dr_ir_opnd.h:298
OPND_CREATE_MEM_lea
#define OPND_CREATE_MEM_lea(base, index, scale, disp)
Definition: dr_ir_macros_x86.h:75
OP_fcompp
@ OP_fcompp
Definition: dr_ir_opcodes_x86.h:570
OP_ficomp
@ OP_ficomp
Definition: dr_ir_opcodes_x86.h:508
OP_vpcmpestrm
@ OP_vpcmpestrm
Definition: dr_ir_opcodes_x86.h:989
OPSZ_4_rex8_short2
@ OPSZ_4_rex8_short2
Definition: dr_ir_opnd.h:113
instr_create_0dst_3src
DR_API instr_t * instr_create_0dst_3src(void *drcontext, int opcode, opnd_t src1, opnd_t src2, opnd_t src3)
OP_mwait
@ OP_mwait
Definition: dr_ir_opcodes_x86.h:588
OP_aad
@ OP_aad
Definition: dr_ir_opcodes_x86.h:162
OPSZ_8
@ OPSZ_8
Definition: dr_ir_opnd.h:87
OP_fchs
@ OP_fchs
Definition: dr_ir_opcodes_x86.h:525
opnd_is_reg
DR_API bool opnd_is_reg(opnd_t opnd)
OP_vpmaskmovd
@ OP_vpmaskmovd
Definition: dr_ir_opcodes_x86.h:1237
instr_create_3dst_0src
DR_API instr_t * instr_create_3dst_0src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3)
OP_mwaitx
@ OP_mwaitx
Definition: dr_ir_opcodes_x86.h:1591
instr_create_4dst_4src
DR_API instr_t * instr_create_4dst_4src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t dst4, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4)
OP_call_far_ind
@ OP_call_far_ind
Definition: dr_ir_opcodes_x86.h:117
OP_loope
@ OP_loope
Definition: dr_ir_opcodes_x86.h:125
OP_iret
@ OP_iret
Definition: dr_ir_opcodes_x86.h:160
OPSZ_maskmovdqu
#define OPSZ_maskmovdqu
Definition: dr_ir_opnd.h:266
OP_fidivr
@ OP_fidivr
Definition: dr_ir_opcodes_x86.h:512
OP_wrpkru
@ OP_wrpkru
Definition: dr_ir_opcodes_x86.h:1595
DR_REG_AX
@ DR_REG_AX
Definition: dr_ir_opnd.h:335
OP_fxtract
@ OP_fxtract
Definition: dr_ir_opcodes_x86.h:540
instr_create_2dst_4src
DR_API instr_t * instr_create_2dst_4src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4)
opnd_get_immed_int
DR_API ptr_int_t opnd_get_immed_int(opnd_t opnd)
instr_create_1dst_5src
DR_API instr_t * instr_create_1dst_5src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4, opnd_t src5)
DR_REG_ST1
@ DR_REG_ST1
Definition: dr_ir_opnd.h:418
DR_REG_XBX
#define DR_REG_XBX
Definition: dr_ir_opnd.h:1664
OP_rep_stos
@ OP_rep_stos
Definition: dr_ir_opcodes_x86.h:480
OPSZ_VARSTACK
#define OPSZ_VARSTACK
Definition: dr_ir_opnd.h:244
instr_create_3dst_4src
DR_API instr_t * instr_create_3dst_4src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4)
OP_push
@ OP_push
Definition: dr_ir_opcodes_x86.h:88
INSTR_PRED
#define INSTR_PRED(instr_ptr, pred)
Definition: dr_ir_macros.h:70
OP_vpmaskmovq
@ OP_vpmaskmovq
Definition: dr_ir_opcodes_x86.h:1238
OPSZ_4_short2
@ OPSZ_4_short2
Definition: dr_ir_opnd.h:112
OP_fldl2t
@ OP_fldl2t
Definition: dr_ir_opcodes_x86.h:530
instr_create_1dst_3src
DR_API instr_t * instr_create_1dst_3src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2, opnd_t src3)
OP_vmaskmovps
@ OP_vmaskmovps
Definition: dr_ir_opcodes_x86.h:1004
instr_create_2dst_3src
DR_API instr_t * instr_create_2dst_3src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t src1, opnd_t src2, opnd_t src3)
OP_maskmovdqu
@ OP_maskmovdqu
Definition: dr_ir_opcodes_x86.h:330
OP_das
@ OP_das
Definition: dr_ir_opcodes_x86.h:81
OP_fsqrt
@ OP_fsqrt
Definition: dr_ir_opcodes_x86.h:546
opnd_get_reg
DR_API reg_id_t opnd_get_reg(opnd_t opnd)
OP_rdpmc
@ OP_rdpmc
Definition: dr_ir_opcodes_x86.h:189
OP_frndint
@ OP_frndint
Definition: dr_ir_opcodes_x86.h:548
OP_sysexit
@ OP_sysexit
Definition: dr_ir_opcodes_x86.h:191
instr_create_4dst_2src
DR_API instr_t * instr_create_4dst_2src(void *drcontext, int opcode, opnd_t dst1, opnd_t dst2, opnd_t dst3, opnd_t dst4, opnd_t src1, opnd_t src2)
OP_f2xm1
@ OP_f2xm1
Definition: dr_ir_opcodes_x86.h:536
OP_cdq
@ OP_cdq
Definition: dr_ir_opcodes_x86.h:143
opnd_create_far_base_disp
DR_API opnd_t opnd_create_far_base_disp(reg_id_t seg, reg_id_t base_reg, reg_id_t index_reg, int scale, int disp, opnd_size_t data_size)
OP_loop
@ OP_loop
Definition: dr_ir_opcodes_x86.h:126
OP_fldz
@ OP_fldz
Definition: dr_ir_opcodes_x86.h:535
DR_SEG_DS
@ DR_SEG_DS
Definition: dr_ir_opnd.h:429
OP_vpcmpestri
@ OP_vpcmpestri
Definition: dr_ir_opcodes_x86.h:990
OP_xsaves32
@ OP_xsaves32
Definition: dr_ir_opcodes_x86.h:1620
OP_fiadd
@ OP_fiadd
Definition: dr_ir_opcodes_x86.h:505
OP_fyl2xp1
@ OP_fyl2xp1
Definition: dr_ir_opcodes_x86.h:545
DR_REG_XBP
#define DR_REG_XBP
Definition: dr_ir_opnd.h:1668
OP_vpcmpistrm
@ OP_vpcmpistrm
Definition: dr_ir_opcodes_x86.h:991
OP_fpatan
@ OP_fpatan
Definition: dr_ir_opcodes_x86.h:539
DR_REG_ST0
@ DR_REG_ST0
Definition: dr_ir_opnd.h:417
OP_sha256rnds2
@ OP_sha256rnds2
Definition: dr_ir_opcodes_x86.h:1575
OPSZ_ret
#define OPSZ_ret
Definition: dr_ir_opnd.h:250
OP_xrstors64
@ OP_xrstors64
Definition: dr_ir_opcodes_x86.h:1623