DynamoRIO API
dr_ir_macros_aarch64.h File Reference

AArch64-specific instruction creation convenience macros. More...

Macros

#define VECTOR_ELEM_WIDTH_BYTE   0
 
#define VECTOR_ELEM_WIDTH_HALF   1
 
#define VECTOR_ELEM_WIDTH_SINGLE   2
 
#define VECTOR_ELEM_WIDTH_DOUBLE   3
 
#define OPND_CREATE_BYTE()   OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_BYTE)
 
#define OPND_CREATE_HALF()   OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_HALF)
 
#define OPND_CREATE_SINGLE()   OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_SINGLE)
 
#define OPND_CREATE_DOUBLE()   OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_DOUBLE)
 
#define OPND_CREATE_ABSMEM(addr, size)   opnd_create_rel_addr(addr, size)
 
#define OPND_CREATE_INT(val)   OPND_CREATE_INTPTR(val)
 
#define OPND_CREATE_ZR(reg)   opnd_create_reg(opnd_get_size(reg) == OPSZ_4 ? DR_REG_WZR : DR_REG_XZR)
 
#define OPND_CREATE_LSL()   opnd_add_flags(OPND_CREATE_INT(DR_SHIFT_LSL), DR_OPND_IS_SHIFT)
 
#define INSTR_CREATE_and(dc, rd, rn, rm_or_imm)
 
#define INSTR_CREATE_ands(dc, rd, rn, rm_or_imm)
 
#define INSTR_CREATE_bcond(dc, pc)   instr_create_0dst_1src((dc), OP_bcond, (pc))
 
#define INSTR_CREATE_bl(dc, pc)   instr_create_1dst_1src((dc), OP_bl, opnd_create_reg(DR_REG_X30), (pc))
 
#define INSTR_CREATE_fmov_general(dc, Rd, Rn)   instr_create_1dst_1src(dc, OP_fmov, Rd, Rn)
 
#define INSTR_CREATE_shadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_shadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_srhadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_srhadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_shsub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_shsub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqsub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqsub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmgt_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmgt, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmge_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmge, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_srshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_srshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqrshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqrshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smax_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smax, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smin_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smin, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sabd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sabd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_saba_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_saba, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_add_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_add, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmtst_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmtst, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_mla_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_4src(dc, OP_mla, Rd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_mul_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_mul, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smaxp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smaxp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sminp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sminp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmulh_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmulh, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_addp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_addp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmaxnm_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmaxnm, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmla_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_4src(dc, OP_fmla, Rd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmulx_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmulx, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fcmeq_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fcmeq, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmlal_vector(dc, Rd, Rm, Rn)   instr_create_1dst_3src(dc, OP_fmlal, Rd, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmax_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmax, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_frecps_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_frecps, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_and_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_and, Rd, Rm, Rn)
 
#define INSTR_CREATE_bic_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_bic, Rd, Rm, Rn)
 
#define INSTR_CREATE_fminnm_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fminnm, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmls_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_4src(dc, OP_fmls, Rd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fsub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fsub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmlsl_vector(dc, Rd, Rm, Rn)   instr_create_1dst_3src(dc, OP_fmlsl, Rd, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmin_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmin, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_frsqrts_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_frsqrts, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_orr_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_orr, Rd, Rm, Rn)
 
#define INSTR_CREATE_orn_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_orn, Rd, Rm, Rn)
 
#define INSTR_CREATE_uhadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uhadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uqadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uqadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_urhadd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_urhadd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uhsub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uhsub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uqsub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uqsub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmhi_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmhi, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmhs_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmhs, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_ushl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_ushl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uqshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uqshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_urshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_urshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uqrshl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uqrshl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umax_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umax, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umin_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umin, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uabd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uabd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uaba_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uaba, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sub_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sub, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_cmeq_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_cmeq, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_mls_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_4src(dc, OP_mls, Rd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_pmul_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_pmul, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umaxp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umaxp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uminp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uminp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqrdmulh_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqrdmulh, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmaxnmp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmaxnmp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmlal2_vector(dc, Rd, Rm, Rn)   instr_create_1dst_3src(dc, OP_fmlal2, Rd, Rd, Rm, Rn)
 
#define INSTR_CREATE_faddp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_faddp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmul_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmul, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fcmge_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fcmge, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_facge_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_facge, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmaxp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fmaxp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fdiv_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fdiv, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_eor_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_eor, Rd, Rm, Rn)
 
#define INSTR_CREATE_bsl_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_bsl, Rd, Rm, Rn)
 
#define INSTR_CREATE_fminnmp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fminnmp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fmlsl2_vector(dc, Rd, Rm, Rn)   instr_create_1dst_3src(dc, OP_fmlsl2, Rd, Rd, Rm, Rn)
 
#define INSTR_CREATE_fabd_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fabd, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fcmgt_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fcmgt, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_facgt_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_facgt, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_fminp_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_fminp, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_bit_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_bit, Rd, Rm, Rn)
 
#define INSTR_CREATE_bif_vector(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_bif, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmov_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_fmov, Rd, Rm)
 
#define INSTR_CREATE_fabs_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_fabs, Rd, Rm)
 
#define INSTR_CREATE_fneg_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_fneg, Rd, Rm)
 
#define INSTR_CREATE_fsqrt_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_fsqrt, Rd, Rm)
 
#define INSTR_CREATE_fcvt_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_fcvt, Rd, Rm)
 
#define INSTR_CREATE_frintn_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frintn, Rd, Rm)
 
#define INSTR_CREATE_frintp_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frintp, Rd, Rm)
 
#define INSTR_CREATE_frintm_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frintm, Rd, Rm)
 
#define INSTR_CREATE_frintz_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frintz, Rd, Rm)
 
#define INSTR_CREATE_frinta_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frinta, Rd, Rm)
 
#define INSTR_CREATE_frintx_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frintx, Rd, Rm)
 
#define INSTR_CREATE_frinti_scalar(dc, Rd, Rm)   instr_create_1dst_1src(dc, OP_frinti, Rd, Rm)
 
#define INSTR_CREATE_fmul_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fmul, Rd, Rm, Rn)
 
#define INSTR_CREATE_fdiv_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fdiv, Rd, Rm, Rn)
 
#define INSTR_CREATE_fadd_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fadd, Rd, Rm, Rn)
 
#define INSTR_CREATE_fsub_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fsub, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmax_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fmax, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmin_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fmin, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmaxnm_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fmaxnm, Rd, Rm, Rn)
 
#define INSTR_CREATE_fminnm_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fminnm, Rd, Rm, Rn)
 
#define INSTR_CREATE_fnmul_scalar(dc, Rd, Rm, Rn)   instr_create_1dst_2src(dc, OP_fnmul, Rd, Rm, Rn)
 
#define INSTR_CREATE_fmadd_scalar(dc, Rd, Rm, Rn, Ra)   instr_create_1dst_3src(dc, OP_fmadd, Rd, Rm, Rn, Ra)
 
#define INSTR_CREATE_fmsub_scalar(dc, Rd, Rm, Rn, Ra)   instr_create_1dst_3src(dc, OP_fmsub, Rd, Rm, Rn, Ra)
 
#define INSTR_CREATE_fnmadd_scalar(dc, Rd, Rm, Rn, Ra)   instr_create_1dst_3src(dc, OP_fnmadd, Rd, Rm, Rn, Ra)
 
#define INSTR_CREATE_fnmsub_scalar(dc, Rd, Rm, Rn, Ra)   instr_create_1dst_3src(dc, OP_fnmsub, Rd, Rm, Rn, Ra)
 
#define INSTR_CREATE_ld1_multi_1(dc, q, r, s)   instr_create_1dst_2src(dc, OP_ld1, q, r, s)
 
#define INSTR_CREATE_st1_multi_1(dc, r, q, s)   instr_create_1dst_2src(dc, OP_st1, r, q, s)
 
#define INSTR_CREATE_orr_sve_pred(dc, Zd, Pg, Zd_, Zm, width)   instr_create_1dst_4src(dc, OP_orr, Zd, Pg, Zd_, Zm, width)
 
#define INSTR_CREATE_eor_sve_pred(dc, Zd, Pg, Zd_, Zm, width)   instr_create_1dst_4src(dc, OP_eor, Zd, Pg, Zd_, Zm, width)
 
#define INSTR_CREATE_and_sve_pred(dc, Zd, Pg, Zd_, Zm, width)   instr_create_1dst_4src(dc, OP_and, Zd, Pg, Zd_, Zm, width)
 
#define INSTR_CREATE_bic_sve_pred(dc, Zd, Pg, Zd_, Zm, width)   instr_create_1dst_4src(dc, OP_bic, Zd, Pg, Zd_, Zm, width)
 
#define INSTR_CREATE_saddl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_saddl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_saddl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_saddl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_saddw_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_saddw, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_saddw2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_saddw2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_ssubl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_ssubl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_ssubl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_ssubl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_ssubw_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_ssubw, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_ssubw2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_ssubw2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_addhn_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_addhn, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_addhn2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_addhn2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sabal_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sabal, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sabal2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sabal2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_subhn_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_subhn, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_subhn2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_subhn2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sabdl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sabdl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sabdl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sabdl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smlal_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smlal, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smlal2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smlal2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmlal_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmlal, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmlal2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmlal2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smlsl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smlsl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smlsl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smlsl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmlsl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmlsl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmlsl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmlsl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smull_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smull, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_smull2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_smull2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmull_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmull, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_sqdmull2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_sqdmull2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_pmull_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_pmull, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_pmull2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_pmull2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uaddl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uaddl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uaddl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uaddl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uaddw_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uaddw, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uaddw2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uaddw2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_usubl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_usubl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_usubl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_usubl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_usubw_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_usubw, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_usubw2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_usubw2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_raddhn_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_raddhn, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_raddhn2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_raddhn2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uabal_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uabal, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uabal2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uabal2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_rsubhn_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_rsubhn, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_rsubhn2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_rsubhn2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uabdl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uabdl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_uabdl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_uabdl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umlal_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umlal, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umlal2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umlal2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umlsl_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umlsl, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umlsl2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umlsl2, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umull_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umull, Rd, Rm, Rn, width)
 
#define INSTR_CREATE_umull2_vector(dc, Rd, Rm, Rn, width)   instr_create_1dst_3src(dc, OP_umull2, Rd, Rm, Rn, width)
 
Platform-independent macros
#define XINST_CREATE_debug_instr(dc)   INSTR_CREATE_brk((dc), OPND_CREATE_INT16(0))
 
#define XINST_CREATE_load(dc, r, m)   INSTR_CREATE_ldr((dc), (r), (m))
 
#define XINST_CREATE_load_1byte_zext4(dc, r, m)   INSTR_CREATE_ldrb(dc, r, m)
 
#define XINST_CREATE_load_1byte(dc, r, m)   INSTR_CREATE_ldrb(dc, r, m)
 
#define XINST_CREATE_load_2bytes(dc, r, m)   INSTR_CREATE_ldrh(dc, r, m)
 
#define XINST_CREATE_store(dc, m, r)
 
#define XINST_CREATE_store_1byte(dc, m, r)   INSTR_CREATE_strb(dc, m, opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), OPSZ_4)))
 
#define XINST_CREATE_store_2bytes(dc, m, r)   INSTR_CREATE_strh(dc, m, opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), OPSZ_4)))
 
#define XINST_CREATE_move(dc, d, s)
 
#define XINST_CREATE_load_simd(dc, r, m)   INSTR_CREATE_ldr((dc), (r), (m))
 
#define XINST_CREATE_store_simd(dc, m, r)   INSTR_CREATE_str((dc), (m), (r))
 
#define XINST_CREATE_jump_reg(dc, r)   INSTR_CREATE_br((dc), (r))
 
#define XINST_CREATE_load_int(dc, r, i)
 
#define XINST_CREATE_return(dc)   INSTR_CREATE_ret(dc, opnd_create_reg(DR_REG_X30))
 
#define XINST_CREATE_jump(dc, t)   INSTR_CREATE_b((dc), (t))
 
#define XINST_CREATE_jump_short(dc, t)   INSTR_CREATE_b((dc), (t))
 
#define XINST_CREATE_call(dc, t)   INSTR_CREATE_bl(dc, t)
 
#define XINST_CREATE_jump_cond(dc, pred, t)   (INSTR_PRED(INSTR_CREATE_bcond((dc), (t)), (pred)))
 
#define XINST_CREATE_add(dc, d, s)   INSTR_CREATE_add(dc, d, d, s)
 
#define XINST_CREATE_add_2src(dc, d, s1, s2)   INSTR_CREATE_add(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_adds(dc, d, d, s)
 
#define XINST_CREATE_sub(dc, d, s)   INSTR_CREATE_sub(dc, d, d, s)
 
#define XINST_CREATE_sub_s(dc, d, s)   INSTR_CREATE_subs(dc, d, d, s)
 
#define XINST_CREATE_and_s(dc, d, s)   INSTR_CREATE_ands(dc, d, d, s)
 
#define XINST_CREATE_cmp(dc, s1, s2)   INSTR_CREATE_cmp(dc, s1, s2)
 
#define XINST_CREATE_interrupt(dc, i)   INSTR_CREATE_svc(dc, (i))
 
#define XINST_CREATE_slr_s(dc, d, rm_or_imm)
 
#define XINST_CREATE_nop(dc)   INSTR_CREATE_nop(dc)
 

Detailed Description

AArch64-specific instruction creation convenience macros.

Macro Definition Documentation

#define INSTR_CREATE_add_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_add, Rd, Rm, Rn, width)

Creates a ADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_addhn2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_addhn2, Rd, Rm, Rn, width)

Creates a ADDHN2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_addhn_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_addhn, Rd, Rm, Rn, width)

Creates a ADDHN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_addp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_addp, Rd, Rm, Rn, width)

Creates a ADDP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_and (   dc,
  rd,
  rn,
  rm_or_imm 
)
Value:
(opnd_is_immed(rm_or_imm) \
? instr_create_1dst_2src((dc), OP_and, (rd), (rn), (rm_or_imm)) \
: INSTR_CREATE_and_shift(dc, rd, rn, rm_or_imm, OPND_CREATE_LSL(), \
INSTR_INLINE bool opnd_is_immed(opnd_t opnd)
#define OPND_CREATE_LSL()
Definition: dr_ir_macros_aarch64.h:109
Definition: dr_ir_opcodes_arm.h:65
#define OPND_CREATE_INT(val)
Definition: dr_ir_macros_aarch64.h:102
instr_t * instr_create_1dst_2src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2)

disabled_until_i4106_is_fixed Creates an AND instruction with one output and two inputs.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
rdThe output register.
rnThe first input register.
rm_or_immThe second input register or immediate.
#define INSTR_CREATE_and_sve_pred (   dc,
  Zd,
  Pg,
  Zd_,
  Zm,
  width 
)    instr_create_1dst_4src(dc, OP_and, Zd, Pg, Zd_, Zm, width)

Creates an AND scalable vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
ZdThe output SVE vector register.
PgPredicate register for predicated instruction, P0-P7.
Zd_The first input SVE vector register. Must match Zd.
ZmThe second input SVE vector register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_and_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_and, Rd, Rm, Rn)

Creates a AND vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_ands (   dc,
  rd,
  rn,
  rm_or_imm 
)
Value:
(opnd_is_immed(rm_or_imm) \
? instr_create_1dst_2src((dc), OP_ands, (rd), (rn), (rm_or_imm)) \
: INSTR_CREATE_ands_shift(dc, rd, rn, rm_or_imm, OPND_CREATE_LSL(), \
INSTR_INLINE bool opnd_is_immed(opnd_t opnd)
#define OPND_CREATE_LSL()
Definition: dr_ir_macros_aarch64.h:109
#define OPND_CREATE_INT(val)
Definition: dr_ir_macros_aarch64.h:102
instr_t * instr_create_1dst_2src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2)
Definition: dr_ir_opcodes_arm.h:66

disabled_until_i4106_is_fixed Creates an ANDS instruction with one output and two inputs.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
rdThe output register.
rnThe first input register.
rm_or_immThe second input register or immediate.
#define INSTR_CREATE_bcond (   dc,
  pc 
)    instr_create_0dst_1src((dc), OP_bcond, (pc))

disabled_until_i4106_is_fixed This macro creates an instr_t for a conditional branch instruction. The condition can be set using INSTR_PRED macro.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
pcThe opnd_t target operand containing the program counter to jump to.
#define INSTR_CREATE_bic_sve_pred (   dc,
  Zd,
  Pg,
  Zd_,
  Zm,
  width 
)    instr_create_1dst_4src(dc, OP_bic, Zd, Pg, Zd_, Zm, width)

Creates a BIC scalable vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
ZdThe output SVE vector register.
PgPredicate register for predicated instruction, P0-P7.
Zd_The first input SVE vector register. Must match Zd.
ZmThe second input SVE vector register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_bic_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_bic, Rd, Rm, Rn)

Creates a BIC vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_bif_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_bif, Rd, Rm, Rn)

Creates a BIF vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_bit_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_bit, Rd, Rm, Rn)

Creates a BIT vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_bl (   dc,
  pc 
)    instr_create_1dst_1src((dc), OP_bl, opnd_create_reg(DR_REG_X30), (pc))

This macro creates an instr_t for a BL (branch and link) instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
pcThe opnd_t target operand containing the program counter to jump to.
#define INSTR_CREATE_bsl_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_bsl, Rd, Rm, Rn)

Creates a BSL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_cmeq_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmeq, Rd, Rm, Rn, width)

Creates a CMEQ vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_cmge_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmge, Rd, Rm, Rn, width)

Creates a CMGE vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_cmgt_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmgt, Rd, Rm, Rn, width)

Creates a CMGT vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_cmhi_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmhi, Rd, Rm, Rn, width)

Creates a CMHI vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_cmhs_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmhs, Rd, Rm, Rn, width)

Creates a CMHS vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_cmtst_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_cmtst, Rd, Rm, Rn, width)

Creates a CMTST vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_eor_sve_pred (   dc,
  Zd,
  Pg,
  Zd_,
  Zm,
  width 
)    instr_create_1dst_4src(dc, OP_eor, Zd, Pg, Zd_, Zm, width)

Creates an EOR scalable vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
ZdThe output SVE vector register.
PgPredicate register for predicated instruction, P0-P7.
Zd_The first input SVE vector register. Must match Zd.
ZmThe second input SVE vector register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_eor_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_eor, Rd, Rm, Rn)

Creates a EOR vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fabd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fabd, Rd, Rm, Rn, width)

Creates a FABD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fabs_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_fabs, Rd, Rm)

Creates a FABS floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_facge_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_facge, Rd, Rm, Rn, width)

Creates a FACGE vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_facgt_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_facgt, Rd, Rm, Rn, width)

Creates a FACGT vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fadd_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fadd, Rd, Rm, Rn)

Creates a FADD floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fadd, Rd, Rm, Rn, width)

Creates a FADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_faddp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_faddp, Rd, Rm, Rn, width)

Creates a FADDP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fcmeq_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fcmeq, Rd, Rm, Rn, width)

Creates a FCMEQ vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fcmge_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fcmge, Rd, Rm, Rn, width)

Creates a FCMGE vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fcmgt_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fcmgt, Rd, Rm, Rn, width)

Creates a FCMGT vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fcvt_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_fcvt, Rd, Rm)

Creates a FCVT floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_fdiv_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fdiv, Rd, Rm, Rn)

Creates a FDIV floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fdiv_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fdiv, Rd, Rm, Rn, width)

Creates a FDIV vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmadd_scalar (   dc,
  Rd,
  Rm,
  Rn,
  Ra 
)    instr_create_1dst_3src(dc, OP_fmadd, Rd, Rm, Rn, Ra)

Creates a FMADD floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
RaThe third input register.
#define INSTR_CREATE_fmax_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fmax, Rd, Rm, Rn)

Creates a FMAX floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmax_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmax, Rd, Rm, Rn, width)

Creates a FMAX vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmaxnm_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fmaxnm, Rd, Rm, Rn)

Creates a FMAXNM floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmaxnm_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmaxnm, Rd, Rm, Rn, width)

Creates a FMAXNM vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmaxnmp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmaxnmp, Rd, Rm, Rn, width)

Creates a FMAXNMP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmaxp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmaxp, Rd, Rm, Rn, width)

Creates a FMAXP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmin_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fmin, Rd, Rm, Rn)

Creates a FMIN floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmin_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmin, Rd, Rm, Rn, width)

Creates a FMIN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fminnm_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fminnm, Rd, Rm, Rn)

Creates a FMINNM floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fminnm_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fminnm, Rd, Rm, Rn, width)

Creates a FMINNM vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fminnmp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fminnmp, Rd, Rm, Rn, width)

Creates a FMINNMP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fminp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fminp, Rd, Rm, Rn, width)

Creates a FMINP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmla_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_4src(dc, OP_fmla, Rd, Rd, Rm, Rn, width)

Creates a FMLA vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmlal2_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_3src(dc, OP_fmlal2, Rd, Rd, Rm, Rn)

Creates a FMLAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmlal_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_3src(dc, OP_fmlal, Rd, Rd, Rm, Rn)

Creates a FMLAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmls_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_4src(dc, OP_fmls, Rd, Rd, Rm, Rn, width)

Creates a FMLS vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmlsl2_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_3src(dc, OP_fmlsl2, Rd, Rd, Rm, Rn)

Creates a FMLSL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmlsl_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_3src(dc, OP_fmlsl, Rd, Rd, Rm, Rn)

Creates a FMLSL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmov_general (   dc,
  Rd,
  Rn 
)    instr_create_1dst_1src(dc, OP_fmov, Rd, Rn)

disabled_until_i4106_is_fixed Creates an FMOV instruction to move between GPRs and floating point registers.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RnThe first input register.
#define INSTR_CREATE_fmov_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_fmov, Rd, Rm)

Creates a FMOV floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_fmsub_scalar (   dc,
  Rd,
  Rm,
  Rn,
  Ra 
)    instr_create_1dst_3src(dc, OP_fmsub, Rd, Rm, Rn, Ra)

Creates a FMSUB floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
RaThe third input register.
#define INSTR_CREATE_fmul_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fmul, Rd, Rm, Rn)

Creates a FMUL floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fmul_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmul, Rd, Rm, Rn, width)

Creates a FMUL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fmulx_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fmulx, Rd, Rm, Rn, width)

Creates a FMULX vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fneg_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_fneg, Rd, Rm)

Creates a FNEG floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_fnmadd_scalar (   dc,
  Rd,
  Rm,
  Rn,
  Ra 
)    instr_create_1dst_3src(dc, OP_fnmadd, Rd, Rm, Rn, Ra)

Creates a FNMADD floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
RaThe third input register.
#define INSTR_CREATE_fnmsub_scalar (   dc,
  Rd,
  Rm,
  Rn,
  Ra 
)    instr_create_1dst_3src(dc, OP_fnmsub, Rd, Rm, Rn, Ra)

Creates a FNMSUB floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
RaThe third input register.
#define INSTR_CREATE_fnmul_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fnmul, Rd, Rm, Rn)

Creates a FNMUL floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_frecps_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_frecps, Rd, Rm, Rn, width)

Creates a FRECPS vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_frinta_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frinta, Rd, Rm)

Creates a FRINTA floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frinti_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frinti, Rd, Rm)

Creates a FRINTI floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frintm_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frintm, Rd, Rm)

Creates a FRINTM floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frintn_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frintn, Rd, Rm)

Creates a FRINTN floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frintp_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frintp, Rd, Rm)

Creates a FRINTP floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frintx_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frintx, Rd, Rm)

Creates a FRINTX floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frintz_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_frintz, Rd, Rm)

Creates a FRINTZ floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_frsqrts_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_frsqrts, Rd, Rm, Rn, width)

Creates a FRSQRTS vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_fsqrt_scalar (   dc,
  Rd,
  Rm 
)    instr_create_1dst_1src(dc, OP_fsqrt, Rd, Rm)

Creates a FSQRT floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
#define INSTR_CREATE_fsub_scalar (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_fsub, Rd, Rm, Rn)

Creates a FSUB floating point instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_fsub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_fsub, Rd, Rm, Rn, width)

Creates a FSUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_ld1_multi_1 (   dc,
  q,
  r,
 
)    instr_create_1dst_2src(dc, OP_ld1, q, r, s)

Creates an Advanced SIMD (NEON) LD1 instruction to load multiple single element structures to one vector register, e.g. LD1 {V0.4H},[X0].

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
qThe destination vector register operand.
rThe source memory operand.
sThe size of the vector element.
#define INSTR_CREATE_mla_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_4src(dc, OP_mla, Rd, Rd, Rm, Rn, width)

Creates a MLA vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_mls_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_4src(dc, OP_mls, Rd, Rd, Rm, Rn, width)

Creates a MLS vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register. The instruction also reads this register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_mul_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_mul, Rd, Rm, Rn, width)

Creates a MUL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_orn_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_orn, Rd, Rm, Rn)

Creates a ORN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_orr_sve_pred (   dc,
  Zd,
  Pg,
  Zd_,
  Zm,
  width 
)    instr_create_1dst_4src(dc, OP_orr, Zd, Pg, Zd_, Zm, width)

Creates an ORR scalable vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
ZdThe output SVE vector register.
PgPredicate register for predicated instruction, P0-P7.
Zd_The first input SVE vector register. Must match Zd.
ZmThe second input SVE vector register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_orr_vector (   dc,
  Rd,
  Rm,
  Rn 
)    instr_create_1dst_2src(dc, OP_orr, Rd, Rm, Rn)

Creates a ORR vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
#define INSTR_CREATE_pmul_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_pmul, Rd, Rm, Rn, width)

Creates a PMUL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use OPND_CREATE_BYTE().
#define INSTR_CREATE_pmull2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_pmull2, Rd, Rm, Rn, width)

Creates a PMULL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_pmull_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_pmull, Rd, Rm, Rn, width)

Creates a PMULL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_raddhn2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_raddhn2, Rd, Rm, Rn, width)

Creates a RADDHN2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_raddhn_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_raddhn, Rd, Rm, Rn, width)

Creates a RADDHN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_rsubhn2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_rsubhn2, Rd, Rm, Rn, width)

Creates a RSUBHN2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_rsubhn_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_rsubhn, Rd, Rm, Rn, width)

Creates a RSUBHN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_saba_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_saba, Rd, Rm, Rn, width)

Creates a SABA vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sabal2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sabal2, Rd, Rm, Rn, width)

Creates a SABAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sabal_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sabal, Rd, Rm, Rn, width)

Creates a SABAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sabd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sabd, Rd, Rm, Rn, width)

Creates a SABD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sabdl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sabdl2, Rd, Rm, Rn, width)

Creates a SABDL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sabdl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sabdl, Rd, Rm, Rn, width)

Creates a SABDL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_saddl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_saddl2, Rd, Rm, Rn, width)

Creates a SADDL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_saddl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_saddl, Rd, Rm, Rn, width)

Creates a SADDL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_saddw2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_saddw2, Rd, Rm, Rn, width)

Creates a SADDW2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_saddw_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_saddw, Rd, Rm, Rn, width)

Creates a SADDW vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_shadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_shadd, Rd, Rm, Rn, width)

Creates a SHADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_shsub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_shsub, Rd, Rm, Rn, width)

Creates a SHSUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smax_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smax, Rd, Rm, Rn, width)

Creates a SMAX vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smaxp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smaxp, Rd, Rm, Rn, width)

Creates a SMAXP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smin_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smin, Rd, Rm, Rn, width)

Creates a SMIN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sminp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sminp, Rd, Rm, Rn, width)

Creates a SMINP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smlal2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smlal2, Rd, Rm, Rn, width)

Creates a SMLAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smlal_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smlal, Rd, Rm, Rn, width)

Creates a SMLAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smlsl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smlsl2, Rd, Rm, Rn, width)

Creates a SMLSL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smlsl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smlsl, Rd, Rm, Rn, width)

Creates a SMLSL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smull2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smull2, Rd, Rm, Rn, width)

Creates a SMULL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_smull_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_smull, Rd, Rm, Rn, width)

Creates a SMULL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqadd, Rd, Rm, Rn, width)

Creates a SQADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_sqdmlal2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmlal2, Rd, Rm, Rn, width)

Creates a SQDMLAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmlal_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmlal, Rd, Rm, Rn, width)

Creates a SQDMLAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmlsl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmlsl2, Rd, Rm, Rn, width)

Creates a SQDMLSL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmlsl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmlsl, Rd, Rm, Rn, width)

Creates a SQDMLSL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmulh_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmulh, Rd, Rm, Rn, width)

Creates a SQDMULH vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmull2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmull2, Rd, Rm, Rn, width)

Creates a SQDMULL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqdmull_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqdmull, Rd, Rm, Rn, width)

Creates a SQDMULL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqrdmulh_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqrdmulh, Rd, Rm, Rn, width)

Creates a SQRDMULH vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_sqrshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqrshl, Rd, Rm, Rn, width)

Creates a SQRSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_sqshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqshl, Rd, Rm, Rn, width)

Creates a SQSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_sqsub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sqsub, Rd, Rm, Rn, width)

Creates a SQSUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_srhadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_srhadd, Rd, Rm, Rn, width)

Creates a SRHADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_srshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_srshl, Rd, Rm, Rn, width)

Creates a SRSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_sshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sshl, Rd, Rm, Rn, width)

Creates a SSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_ssubl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_ssubl2, Rd, Rm, Rn, width)

Creates a SSUBL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_ssubl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_ssubl, Rd, Rm, Rn, width)

Creates a SSUBL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_ssubw2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_ssubw2, Rd, Rm, Rn, width)

Creates a SSUBW2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_ssubw_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_ssubw, Rd, Rm, Rn, width)

Creates a SSUBW vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_st1_multi_1 (   dc,
  r,
  q,
 
)    instr_create_1dst_2src(dc, OP_st1, r, q, s)

Creates an Advanced SIMD (NEON) ST1 instruction to store multiple single element structures from one vector register, e.g. ST1 {V1.2S},[X1].

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination memory operand.
qThe source vector register operand.
sThe size of the vector element.
#define INSTR_CREATE_sub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_sub, Rd, Rm, Rn, width)

Creates a SUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_subhn2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_subhn2, Rd, Rm, Rn, width)

Creates a SUBHN2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_subhn_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_subhn, Rd, Rm, Rn, width)

Creates a SUBHN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uaba_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uaba, Rd, Rm, Rn, width)

Creates a UABA vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uabal2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uabal2, Rd, Rm, Rn, width)

Creates a UABAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uabal_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uabal, Rd, Rm, Rn, width)

Creates a UABAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uabd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uabd, Rd, Rm, Rn, width)

Creates a UABD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uabdl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uabdl2, Rd, Rm, Rn, width)

Creates a UABDL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uabdl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uabdl, Rd, Rm, Rn, width)

Creates a UABDL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uaddl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uaddl2, Rd, Rm, Rn, width)

Creates a UADDL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uaddl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uaddl, Rd, Rm, Rn, width)

Creates a UADDL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uaddw2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uaddw2, Rd, Rm, Rn, width)

Creates a UADDW2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uaddw_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uaddw, Rd, Rm, Rn, width)

Creates a UADDW vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uhadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uhadd, Rd, Rm, Rn, width)

Creates a UHADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uhsub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uhsub, Rd, Rm, Rn, width)

Creates a UHSUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umax_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umax, Rd, Rm, Rn, width)

Creates a UMAX vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umaxp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umaxp, Rd, Rm, Rn, width)

Creates a UMAXP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umin_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umin, Rd, Rm, Rn, width)

Creates a UMIN vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uminp_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uminp, Rd, Rm, Rn, width)

Creates a UMINP vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umlal2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umlal2, Rd, Rm, Rn, width)

Creates a UMLAL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umlal_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umlal, Rd, Rm, Rn, width)

Creates a UMLAL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umlsl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umlsl2, Rd, Rm, Rn, width)

Creates a UMLSL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umlsl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umlsl, Rd, Rm, Rn, width)

Creates a UMLSL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umull2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umull2, Rd, Rm, Rn, width)

Creates a UMULL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_umull_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_umull, Rd, Rm, Rn, width)

Creates a UMULL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_uqadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uqadd, Rd, Rm, Rn, width)

Creates a UQADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_uqrshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uqrshl, Rd, Rm, Rn, width)

Creates a UQRSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_uqshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uqshl, Rd, Rm, Rn, width)

Creates a UQSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_uqsub_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_uqsub, Rd, Rm, Rn, width)

Creates a UQSUB vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_urhadd_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_urhadd, Rd, Rm, Rn, width)

Creates a URHADD vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_urshl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_urshl, Rd, Rm, Rn, width)

Creates a URSHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_ushl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_ushl, Rd, Rm, Rn, width)

Creates a USHL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().
#define INSTR_CREATE_usubl2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_usubl2, Rd, Rm, Rn, width)

Creates a USUBL2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_usubl_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_usubl, Rd, Rm, Rn, width)

Creates a USUBL vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_usubw2_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_usubw2, Rd, Rm, Rn, width)

Creates a USUBW2 vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#define INSTR_CREATE_usubw_vector (   dc,
  Rd,
  Rm,
  Rn,
  width 
)    instr_create_1dst_3src(dc, OP_usubw, Rd, Rm, Rn, width)

Creates a USUBW vector instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
RdThe output register.
RmThe first input register.
RnThe second input register.
widthThe input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().
#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 the maximum signed displacement reach for the architecture.

#define OPND_CREATE_BYTE ( )    OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_BYTE)

Operand denoting 8 bit vector element width for the other operands of the containing instruction.

#define OPND_CREATE_DOUBLE ( )    OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_DOUBLE)

Operand denoting 64 bit vector element width for the other operands of the containing instruction.

#define OPND_CREATE_HALF ( )    OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_HALF)

Operand denoting 16 bit vector element width for the other operands of the containing instruction.

#define OPND_CREATE_INT (   val)    OPND_CREATE_INTPTR(val)

Create an immediate integer operand. For AArch64 the size of an immediate is ignored when encoding, so there is no need to specify the final size.

#define OPND_CREATE_LSL ( )    opnd_add_flags(OPND_CREATE_INT(DR_SHIFT_LSL), DR_OPND_IS_SHIFT)

Create an operand specifying LSL, the default shift type when there is no shift.

#define OPND_CREATE_SINGLE ( )    OPND_CREATE_INT8(VECTOR_ELEM_WIDTH_SINGLE)

Operand denoting 32 bit vector element width for the other operands of the containing instruction.

#define OPND_CREATE_ZR (   reg)    opnd_create_reg(opnd_get_size(reg) == OPSZ_4 ? DR_REG_WZR : DR_REG_XZR)

Create a zero register operand of the same size as reg.

#define VECTOR_ELEM_WIDTH_BYTE   0

Used in an additional immediate source operand to a vector operation, denotes 8 bit vector element width. See AArch64 IR Variations.

#define VECTOR_ELEM_WIDTH_DOUBLE   3

Used in an additional immediate source operand to a vector operation, denotes 64 bit vector element width. See AArch64 IR Variations.

#define VECTOR_ELEM_WIDTH_HALF   1

Used in an additional immediate source operand to a vector operation, denotes 16 bit vector element width. See AArch64 IR Variations.

#define VECTOR_ELEM_WIDTH_SINGLE   2

Used in an additional immediate source operand to a vector operation, denotes 32 bit vector element width. See AArch64 IR Variations.

#define XINST_CREATE_add (   dc,
  d,
 
)    INSTR_CREATE_add(dc, d, d, 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.
#define XINST_CREATE_add_2src (   dc,
  d,
  s1,
  s2 
)    INSTR_CREATE_add(dc, d, s1, 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 an immediate integer.
#define XINST_CREATE_add_s (   dc,
  d,
 
)    INSTR_CREATE_adds(dc, d, 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.
#define XINST_CREATE_add_sll (   dc,
  d,
  s1,
  s2_toshift,
  shift_amount 
)
Value:
INSTR_CREATE_add_shift((dc), (d), (s1), (s2_toshift), OPND_CREATE_LSL(), \
OPND_CREATE_INT8(shift_amount))
#define OPND_CREATE_LSL()
Definition: dr_ir_macros_aarch64.h:109
#define OPND_CREATE_INT8(val)
Definition: dr_ir_macros.h:129

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.
#define XINST_CREATE_and_s (   dc,
  d,
 
)    INSTR_CREATE_ands(dc, d, 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.
#define XINST_CREATE_call (   dc,
 
)    INSTR_CREATE_bl(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).
#define XINST_CREATE_cmp (   dc,
  s1,
  s2 
)    INSTR_CREATE_cmp(dc, 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 source operand for the instruction.
s2The opnd_t explicit source operand for the instruction.
#define XINST_CREATE_debug_instr (   dc)    INSTR_CREATE_brk((dc), OPND_CREATE_INT16(0))

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.
#define XINST_CREATE_interrupt (   dc,
 
)    INSTR_CREATE_svc(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.
#define XINST_CREATE_jump (   dc,
 
)    INSTR_CREATE_b((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).
#define XINST_CREATE_jump_cond (   dc,
  pred,
 
)    (INSTR_PRED(INSTR_CREATE_bcond((dc), (t)), (pred)))

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).
#define XINST_CREATE_jump_reg (   dc,
 
)    INSTR_CREATE_br((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.
#define XINST_CREATE_jump_short (   dc,
 
)    INSTR_CREATE_b((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).
#define XINST_CREATE_load (   dc,
  r,
 
)    INSTR_CREATE_ldr((dc), (r), (m))

This platform-independent macro creates an instr_t for a 4-byte or 8-byte memory load instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
rThe destination register opnd.
mThe source memory opnd.
#define XINST_CREATE_load_1byte (   dc,
  r,
 
)    INSTR_CREATE_ldrb(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.
#define XINST_CREATE_load_1byte_zext4 (   dc,
  r,
 
)    INSTR_CREATE_ldrb(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.
#define XINST_CREATE_load_2bytes (   dc,
  r,
 
)    INSTR_CREATE_ldrh(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.
#define XINST_CREATE_load_int (   dc,
  r,
 
)
Value:
? INSTR_CREATE_movn((dc), (r), OPND_CREATE_INT32(~opnd_get_immed_int(i)), \
: INSTR_CREATE_movz((dc), (r), (i), OPND_CREATE_INT(0)))
#define OPND_CREATE_INT32(val)
Definition: dr_ir_macros.h:117
#define OPND_CREATE_INT(val)
Definition: dr_ir_macros_aarch64.h:102
ptr_int_t opnd_get_immed_int(opnd_t opnd)

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.
#define XINST_CREATE_load_simd (   dc,
  r,
 
)    INSTR_CREATE_ldr((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.
#define XINST_CREATE_move (   dc,
  d,
 
)
Value:
opnd_get_reg(d) == DR_REG_WSP || opnd_get_reg(s) == DR_REG_WSP) \
instr_t * instr_create_1dst_4src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2, opnd_t src3, opnd_t src4)
#define OPND_CREATE_LSL()
Definition: dr_ir_macros_aarch64.h:109
reg_id_t opnd_get_reg(opnd_t opnd)
Definition: dr_ir_opcodes_arm.h:58
#define OPND_CREATE_INT(val)
Definition: dr_ir_macros_aarch64.h:102
#define OPND_CREATE_ZR(reg)
Definition: dr_ir_macros_aarch64.h:105
#define DR_REG_XSP
Definition: dr_ir_opnd.h:1341
Definition: dr_ir_opcodes_arm.h:177

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.
#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.
#define XINST_CREATE_return (   dc)    INSTR_CREATE_ret(dc, opnd_create_reg(DR_REG_X30))

This platform-independent macro creates an instr_t for a return instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
#define XINST_CREATE_slr_s (   dc,
  d,
  rm_or_imm 
)
Value:
(opnd_is_reg(rm_or_imm) \
? instr_create_1dst_2src(dc, OP_lsrv, d, d, rm_or_imm) \
: instr_create_1dst_3src(dc, OP_ubfm, d, d, rm_or_imm, \
bool reg_is_32bit(reg_id_t reg)
reg_id_t opnd_get_reg(opnd_t opnd)
#define OPND_CREATE_INT(val)
Definition: dr_ir_macros_aarch64.h:102
instr_t * instr_create_1dst_2src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2)
bool opnd_is_reg(opnd_t opnd)
instr_t * instr_create_1dst_3src(void *drcontext, int opcode, opnd_t dst, opnd_t src1, opnd_t src2, opnd_t src3)

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.
rm_or_immThe opnd_t explicit source operand for the instruction.
#define XINST_CREATE_store (   dc,
  m,
 
)
Value:
? INSTR_CREATE_stur( \
dc, m, \
dc, m, \
#define INSTR_CREATE_str(dc, mem, Rt)
Definition: dr_ir_macros_arm.h:1842
uint opnd_size_in_bytes(opnd_size_t size)
reg_id_t reg_resize_to_opsz(reg_id_t reg, opnd_size_t sz)
INSTR_INLINE opnd_t opnd_create_reg(reg_id_t r)
reg_id_t opnd_get_reg(opnd_t opnd)
opnd_size_t opnd_get_size(opnd_t opnd)
bool opnd_is_base_disp(opnd_t opnd)
int opnd_get_disp(opnd_t opnd)

This platform-independent macro creates an instr_t for a 4-byte or 8-byte memory store instruction.

Parameters
dcThe void * dcontext used to allocate memory for the instr_t.
mThe destination memory opnd.
rThe source register opnd.
#define XINST_CREATE_store_1byte (   dc,
  m,
 
)    INSTR_CREATE_strb(dc, m, opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), OPSZ_4)))

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.
#define XINST_CREATE_store_2bytes (   dc,
  m,
 
)    INSTR_CREATE_strh(dc, m, opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), OPSZ_4)))

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.
#define XINST_CREATE_store_simd (   dc,
  m,
 
)    INSTR_CREATE_str((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.
#define XINST_CREATE_sub (   dc,
  d,
 
)    INSTR_CREATE_sub(dc, d, d, 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.
#define XINST_CREATE_sub_s (   dc,
  d,
 
)    INSTR_CREATE_subs(dc, d, 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.