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_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

◆ INSTR_CREATE_add_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_addhn2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_addhn_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_addp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_and

#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(), \
                                  OPND_CREATE_INT(0)))

Creates an AND instruction with one output and two inputs.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
rd	The output register.
rn	The first input register.
rm_or_imm	The second input register or immediate.

◆ INSTR_CREATE_and_sve_pred

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Zd	The output SVE vector register.
Pg	Predicate register for predicated instruction, P0-P7.
Zd_	The first input SVE vector register. Must match Zd.
Zm	The second input SVE vector register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_and_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_ands

#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(), \
                                   OPND_CREATE_INT(0)))

Creates an ANDS instruction with one output and two inputs.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
rd	The output register.
rn	The first input register.
rm_or_imm	The second input register or immediate.

◆ INSTR_CREATE_bcond

#define INSTR_CREATE_bcond	(	dc,
		pc
	)	instr_create_0dst_1src((dc), OP_bcond, (pc))

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
pc	The opnd_t target operand containing the program counter to jump to.

◆ INSTR_CREATE_bic_sve_pred

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Zd	The output SVE vector register.
Pg	Predicate register for predicated instruction, P0-P7.
Zd_	The first input SVE vector register. Must match Zd.
Zm	The second input SVE vector register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_bic_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_bif_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_bit_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_bl

#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

dc	The void * dcontext used to allocate memory for the instr_t.
pc	The opnd_t target operand containing the program counter to jump to.

◆ INSTR_CREATE_bsl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_cmeq_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_cmge_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_cmgt_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_cmhi_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_cmhs_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_cmtst_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_eor_sve_pred

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Zd	The output SVE vector register.
Pg	Predicate register for predicated instruction, P0-P7.
Zd_	The first input SVE vector register. Must match Zd.
Zm	The second input SVE vector register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_eor_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fabd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fabs_scalar

#define INSTR_CREATE_fabs_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_fabs, Rd, Rm)

Creates a FABS floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_facge_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_facgt_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fadd_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_faddp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fcmeq_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fcmge_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fcmgt_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fcvt_scalar

#define INSTR_CREATE_fcvt_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_fcvt, Rd, Rm)

Creates a FCVT floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_fdiv_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fdiv_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmadd_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
Ra	The third input register.

◆ INSTR_CREATE_fmax_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmax_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmaxnm_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmaxnm_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmaxnmp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmaxp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmin_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmin_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fminnm_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fminnm_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fminnmp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fminp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmla_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmlal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmlal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmls_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmlsl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmlsl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmov_general

#define INSTR_CREATE_fmov_general	(	dc,
		Rd,
		Rn
	)	instr_create_1dst_1src(dc, OP_fmov, Rd, Rn)

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rn	The first input register.

◆ INSTR_CREATE_fmov_scalar

#define INSTR_CREATE_fmov_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_fmov, Rd, Rm)

Creates a FMOV floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_fmsub_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
Ra	The third input register.

◆ INSTR_CREATE_fmul_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fmul_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fmulx_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fneg_scalar

#define INSTR_CREATE_fneg_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_fneg, Rd, Rm)

Creates a FNEG floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_fnmadd_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
Ra	The third input register.

◆ INSTR_CREATE_fnmsub_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
Ra	The third input register.

◆ INSTR_CREATE_fnmul_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_frecps_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_frinta_scalar

#define INSTR_CREATE_frinta_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frinta, Rd, Rm)

Creates a FRINTA floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frinti_scalar

#define INSTR_CREATE_frinti_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frinti, Rd, Rm)

Creates a FRINTI floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frintm_scalar

#define INSTR_CREATE_frintm_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frintm, Rd, Rm)

Creates a FRINTM floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frintn_scalar

#define INSTR_CREATE_frintn_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frintn, Rd, Rm)

Creates a FRINTN floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frintp_scalar

#define INSTR_CREATE_frintp_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frintp, Rd, Rm)

Creates a FRINTP floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frintx_scalar

#define INSTR_CREATE_frintx_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frintx, Rd, Rm)

Creates a FRINTX floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frintz_scalar

#define INSTR_CREATE_frintz_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_frintz, Rd, Rm)

Creates a FRINTZ floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_frsqrts_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_fsqrt_scalar

#define INSTR_CREATE_fsqrt_scalar	(	dc,
		Rd,
		Rm
	)	instr_create_1dst_1src(dc, OP_fsqrt, Rd, Rm)

Creates a FSQRT floating point instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.

◆ INSTR_CREATE_fsub_scalar

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_fsub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_mla_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_mls_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register. The instruction also reads this register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_mul_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_orn_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_orr_sve_pred

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Zd	The output SVE vector register.
Pg	Predicate register for predicated instruction, P0-P7.
Zd_	The first input SVE vector register. Must match Zd.
Zm	The second input SVE vector register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_orr_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.

◆ INSTR_CREATE_pmul_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use OPND_CREATE_BYTE().

◆ INSTR_CREATE_pmull2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_pmull_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_raddhn2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_raddhn_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_rsubhn2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_rsubhn_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_saba_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sabal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sabal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sabd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sabdl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sabdl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_saddl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_saddl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_saddw2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_saddw_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_shadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_shsub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smax_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smaxp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smin_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sminp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smlal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smlal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smlsl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smlsl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smull2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_smull_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_sqdmlal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmlal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmlsl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmlsl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmulh_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmull2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqdmull_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqrdmulh_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sqrshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_sqshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_sqsub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_srhadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_srshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_sshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_ssubl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_ssubl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_ssubw2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_ssubw_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_sub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_subhn2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_subhn_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uaba_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uabal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uabal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uabd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uabdl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uabdl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uaddl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uaddl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uaddw2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uaddw_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uhadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uhsub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umax_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umaxp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umin_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uminp_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umlal2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umlal_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umlsl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umlsl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umull2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_umull_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_uqadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_uqrshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_uqshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_uqsub_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_urhadd_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_urshl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_ushl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF(), OPND_CREATE_SINGLE() or OPND_CREATE_DOUBLE().

◆ INSTR_CREATE_usubl2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_usubl_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_usubw2_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ INSTR_CREATE_usubw_vector

#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

dc	The void * dcontext used to allocate memory for the instr_t.
Rd	The output register.
Rm	The first input register.
Rn	The second input register.
width	The input vector element width. Use either OPND_CREATE_BYTE(), OPND_CREATE_HALF() or OPND_CREATE_SINGLE().

◆ OPND_CREATE_ABSMEM

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

Create an absolute address operand encoded as pc-relative. Encoding will fail if addr is out of the maximum signed displacement reach for the architecture.

◆ OPND_CREATE_BYTE

#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.

◆ OPND_CREATE_DOUBLE

#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.

◆ OPND_CREATE_HALF

#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.

◆ OPND_CREATE_INT

#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.

◆ OPND_CREATE_LSL

#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.

◆ OPND_CREATE_SINGLE

#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.

◆ OPND_CREATE_ZR

#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.

◆ VECTOR_ELEM_WIDTH_BYTE

#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.

◆ VECTOR_ELEM_WIDTH_DOUBLE

#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.

◆ VECTOR_ELEM_WIDTH_HALF

#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.

◆ VECTOR_ELEM_WIDTH_SINGLE

#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.

◆ XINST_CREATE_add

#define XINST_CREATE_add	(	dc,
		d,
		s
	)	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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_add_2src

#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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction. This must be a register.
s2	The opnd_t explicit source operand for the instruction. This can be either a register or an immediate integer.

◆ XINST_CREATE_add_s

#define XINST_CREATE_add_s	(	dc,
		d,
		s
	)	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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_add_sll

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

Value:

INSTR_CREATE_add_shift((dc), (d), (s1), (s2_toshift), OPND_CREATE_LSL(), \

OPND_CREATE_INT8(shift_amount))

OPND_CREATE_LSL

#define OPND_CREATE_LSL()

Definition: dr_ir_macros_aarch64.h:109

OPND_CREATE_INT8

#define OPND_CREATE_INT8(val)

Definition: dr_ir_macros.h:124

This platform-independent macro creates an instr_t for an addition instruction that does not affect the status flags and takes two register sources plus a destination, with one source being shifted logically left by an immediate amount that is limited to either 0, 1, 2, or 3.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s1	The opnd_t explicit first source operand for the instruction. This must be a register.
s2_toshift	The opnd_t explicit source operand for the instruction. This must be a register.
shift_amount	An integer value that must be either 0, 1, 2, or 3.

◆ XINST_CREATE_and_s

#define XINST_CREATE_and_s	(	dc,
		d,
		s
	)	INSTR_CREATE_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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_call

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

This platform-independent macro creates an instr_t for an unconditional branch instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_cmp

#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

dc	The void * dcontext used to allocate memory for the instr_t.
s1	The opnd_t explicit source operand for the instruction.
s2	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_debug_instr

#define XINST_CREATE_debug_instr ( dc ) INSTR_CREATE_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

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_interrupt

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

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
i	The source integer constant opnd_t operand.

◆ XINST_CREATE_jump

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

This platform-independent macro creates an instr_t for an unconditional branch instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_jump_cond

#define XINST_CREATE_jump_cond	(	dc,
		pred,
		t
	)	(INSTR_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

dc	The void * dcontext used to allocate memory for the instr_t.
pred	The dr_pred_type_t condition to match.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_jump_reg

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

This platform-independent macro creates an instr_t for an indirect jump instruction through a register.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The register opnd holding the target.

◆ XINST_CREATE_jump_short

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

This platform-independent macro creates an instr_t for an unconditional branch instruction with the smallest available reach.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
t	The opnd_t target operand for the instruction, which can be either a pc (opnd_create_pc)()) or an instr_t (opnd_create_instr()). Be sure to ensure that the limited reach of this short branch will reach the target (a pc operand is not suitable for most uses unless you know precisely where this instruction will be encoded).

◆ XINST_CREATE_load

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

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_1byte

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

This platform-independent macro creates an instr_t for a 1-byte memory load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_1byte_zext4

#define XINST_CREATE_load_1byte_zext4	(	dc,
		r,
		m
	)	INSTR_CREATE_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

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_2bytes

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

This platform-independent macro creates an instr_t for a 2-byte memory load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_load_int

#define XINST_CREATE_load_int	(	dc,
		r,
		i
	)

Value:

(opnd_get_immed_int(i) < 0                                                     \
         ? INSTR_CREATE_movn((dc), (r), OPND_CREATE_INT32(~opnd_get_immed_int(i)), \
                             OPND_CREATE_INT(0))                                   \
         : INSTR_CREATE_movz((dc), (r), (i), OPND_CREATE_INT(0)))

This platform-independent macro creates an instr_t for an immediate integer load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
i	The source immediate integer opnd.

◆ XINST_CREATE_load_simd

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

This platform-independent macro creates an instr_t for a multimedia register load instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
r	The destination register opnd.
m	The source memory opnd.

◆ XINST_CREATE_move

#define XINST_CREATE_move	(	dc,
		d,
		s
	)

Value:

((opnd_get_reg(d) == DR_REG_XSP || opnd_get_reg(s) == DR_REG_XSP ||  \
      opnd_get_reg(d) == DR_REG_WSP || opnd_get_reg(s) == DR_REG_WSP)    \
         ? instr_create_1dst_4src(dc, OP_add, d, s, OPND_CREATE_INT(0),  \
                                  OPND_CREATE_LSL(), OPND_CREATE_INT(0)) \
         : instr_create_1dst_4src(dc, OP_orr, d, OPND_CREATE_ZR(d), s,   \
                                  OPND_CREATE_LSL(), OPND_CREATE_INT(0)))

This platform-independent macro creates an instr_t for a register to register move instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The destination register opnd.
s	The source register opnd.

◆ XINST_CREATE_nop

#define XINST_CREATE_nop ( dc ) INSTR_CREATE_nop(dc)

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_return

#define XINST_CREATE_return ( dc ) INSTR_CREATE_ret(dc, opnd_create_reg(DR_REG_X30))

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.

◆ XINST_CREATE_slr_s

#define XINST_CREATE_slr_s	(	dc,
		d,
		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,                       \
                                  reg_is_32bit(opnd_get_reg(d)) ? OPND_CREATE_INT(31) \
                                                                : OPND_CREATE_INT(63)))

This platform-independent macro creates an instr_t for a logical right shift instruction that does affect the status flags.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
rm_or_imm	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_store

#define XINST_CREATE_store	(	dc,
		m,
		r
	)

Value:

(opnd_is_base_disp(m) &&                                                           \
             opnd_get_disp(m) % opnd_size_in_bytes(opnd_get_size(m)) != 0              \
         ? INSTR_CREATE_stur(                                                          \
               dc, m,                                                                  \
               opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), opnd_get_size(m)))) \
         : INSTR_CREATE_str(                                                           \
               dc, m,                                                                  \
               opnd_create_reg(reg_resize_to_opsz(opnd_get_reg(r), opnd_get_size(m)))))

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

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_1byte

#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)))

This platform-independent macro creates an instr_t for a 1-byte memory store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_2bytes

#define XINST_CREATE_store_2bytes	(	dc,
		m,
		r
	)	INSTR_CREATE_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

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_store_simd

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

This platform-independent macro creates an instr_t for a multimedia register store instruction.

Parameters

dc	The void * dcontext used to allocate memory for the instr_t.
m	The destination memory opnd.
r	The source register opnd.

◆ XINST_CREATE_sub

#define XINST_CREATE_sub	(	dc,
		d,
		s
	)	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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

◆ XINST_CREATE_sub_s

#define XINST_CREATE_sub_s	(	dc,
		d,
		s
	)	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

dc	The void * dcontext used to allocate memory for the instr_t.
d	The opnd_t explicit destination operand for the instruction.
s	The opnd_t explicit source operand for the instruction.

Macros

Detailed Description

Macro Definition Documentation

◆ INSTR_CREATE_add_vector

◆ INSTR_CREATE_addhn2_vector

◆ INSTR_CREATE_addhn_vector

◆ INSTR_CREATE_addp_vector

◆ INSTR_CREATE_and

◆ INSTR_CREATE_and_sve_pred

◆ INSTR_CREATE_and_vector

◆ INSTR_CREATE_ands

◆ INSTR_CREATE_bcond

◆ INSTR_CREATE_bic_sve_pred

◆ INSTR_CREATE_bic_vector

◆ INSTR_CREATE_bif_vector

◆ INSTR_CREATE_bit_vector

◆ INSTR_CREATE_bl

◆ INSTR_CREATE_bsl_vector

◆ INSTR_CREATE_cmeq_vector

◆ INSTR_CREATE_cmge_vector

◆ INSTR_CREATE_cmgt_vector

◆ INSTR_CREATE_cmhi_vector

◆ INSTR_CREATE_cmhs_vector

◆ INSTR_CREATE_cmtst_vector

◆ INSTR_CREATE_eor_sve_pred

◆ INSTR_CREATE_eor_vector

◆ INSTR_CREATE_fabd_vector

◆ INSTR_CREATE_fabs_scalar

◆ INSTR_CREATE_facge_vector

◆ INSTR_CREATE_facgt_vector

◆ INSTR_CREATE_fadd_scalar

◆ INSTR_CREATE_fadd_vector

◆ INSTR_CREATE_faddp_vector

◆ INSTR_CREATE_fcmeq_vector

◆ INSTR_CREATE_fcmge_vector

◆ INSTR_CREATE_fcmgt_vector

◆ INSTR_CREATE_fcvt_scalar

◆ INSTR_CREATE_fdiv_scalar

◆ INSTR_CREATE_fdiv_vector

◆ INSTR_CREATE_fmadd_scalar

◆ INSTR_CREATE_fmax_scalar

◆ INSTR_CREATE_fmax_vector

◆ INSTR_CREATE_fmaxnm_scalar

◆ INSTR_CREATE_fmaxnm_vector

◆ INSTR_CREATE_fmaxnmp_vector

◆ INSTR_CREATE_fmaxp_vector

◆ INSTR_CREATE_fmin_scalar

◆ INSTR_CREATE_fmin_vector

◆ INSTR_CREATE_fminnm_scalar

◆ INSTR_CREATE_fminnm_vector

◆ INSTR_CREATE_fminnmp_vector

◆ INSTR_CREATE_fminp_vector

◆ INSTR_CREATE_fmla_vector

◆ INSTR_CREATE_fmlal2_vector

◆ INSTR_CREATE_fmlal_vector

◆ INSTR_CREATE_fmls_vector

◆ INSTR_CREATE_fmlsl2_vector

◆ INSTR_CREATE_fmlsl_vector

◆ INSTR_CREATE_fmov_general

◆ INSTR_CREATE_fmov_scalar

◆ INSTR_CREATE_fmsub_scalar

◆ INSTR_CREATE_fmul_scalar

◆ INSTR_CREATE_fmul_vector

◆ INSTR_CREATE_fmulx_vector

◆ INSTR_CREATE_fneg_scalar

◆ INSTR_CREATE_fnmadd_scalar

◆ INSTR_CREATE_fnmsub_scalar

◆ INSTR_CREATE_fnmul_scalar

◆ INSTR_CREATE_frecps_vector

◆ INSTR_CREATE_frinta_scalar

◆ INSTR_CREATE_frinti_scalar

◆ INSTR_CREATE_frintm_scalar

◆ INSTR_CREATE_frintn_scalar

◆ INSTR_CREATE_frintp_scalar

◆ INSTR_CREATE_frintx_scalar

◆ INSTR_CREATE_frintz_scalar

◆ INSTR_CREATE_frsqrts_vector

◆ INSTR_CREATE_fsqrt_scalar

◆ INSTR_CREATE_fsub_scalar

◆ INSTR_CREATE_fsub_vector