Intrinsics in Alphabetical Order

1665 intrinsics, one page each. See also the grouped pages linked from the home page.

LSX and LASX intrinsics are grouped by the first letter of the operation name (the letter after the v/xv prefix), for example __lsx_vadd_b is listed under LSX_A.

LSX_A (64)

__lsx_vabsd_b — Compute the absolute difference between corresponding signed 8-bit elements in a and b, save the result in dst.
__lsx_vabsd_bu — Compute the absolute difference between corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lsx_vabsd_d — Compute the absolute difference between corresponding signed 64-bit elements in a and b, save the result in dst.
__lsx_vabsd_du — Compute the absolute difference between corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lsx_vabsd_h — Compute the absolute difference between corresponding signed 16-bit elements in a and b, save the result in dst.
__lsx_vabsd_hu — Compute the absolute difference between corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lsx_vabsd_w — Compute the absolute difference between corresponding signed 32-bit elements in a and b, save the result in dst.
__lsx_vabsd_wu — Compute the absolute difference between corresponding unsigned 32-bit elements in a and b, save the result in dst.
__lsx_vadd_b — Add corresponding 8-bit elements in a and b, save the result in dst.
__lsx_vadd_d — Add corresponding 64-bit elements in a and b, save the result in dst.
__lsx_vadd_h — Add corresponding 16-bit elements in a and b, save the result in dst.
__lsx_vadd_q — Add corresponding 128-bit elements in a and b, save the result in dst.
__lsx_vadd_w — Add corresponding 32-bit elements in a and b, save the result in dst.
__lsx_vadda_b — Add the absolute values of the 8-bit elements in a and b, save the result in dst.
__lsx_vadda_d — Add the absolute values of the 64-bit elements in a and b, save the result in dst.
__lsx_vadda_h — Add the absolute values of the 16-bit elements in a and b, save the result in dst.
__lsx_vadda_w — Add the absolute values of the 32-bit elements in a and b, save the result in dst.
__lsx_vaddi_bu — Add the zero-extended imm to each 8-bit element in a, save the result in dst.
__lsx_vaddi_du — Add the zero-extended imm to each 64-bit element in a, save the result in dst.
__lsx_vaddi_hu — Add the zero-extended imm to each 16-bit element in a, save the result in dst.
__lsx_vaddi_wu — Add the zero-extended imm to each 32-bit element in a, save the result in dst.
__lsx_vaddwev_d_w — Add the even-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwev_d_wu — Add the even-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwev_d_wu_w — Add the even-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwev_h_b — Add the even-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwev_h_bu — Add the even-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwev_h_bu_b — Add the even-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwev_q_d — Add the even-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwev_q_du — Add the even-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwev_q_du_d — Add the even-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwev_w_h — Add the even-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vaddwev_w_hu — Add the even-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vaddwev_w_hu_h — Add the even-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vaddwod_d_w — Add the odd-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwod_d_wu — Add the odd-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwod_d_wu_w — Add the odd-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vaddwod_h_b — Add the odd-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwod_h_bu — Add the odd-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwod_h_bu_b — Add the odd-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vaddwod_q_d — Add the odd-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwod_q_du — Add the odd-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwod_q_du_d — Add the odd-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vaddwod_w_h — Add the odd-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vaddwod_w_hu — Add the odd-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vaddwod_w_hu_h — Add the odd-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vand_v — Compute bitwise AND of elements in a and b.
__lsx_vandi_b — Compute bitwise AND of elements in a and imm.
__lsx_vandn_v — Compute bitwise ANDN (~a & b) of elements in a and b.
__lsx_vavg_b — Compute the average (rounded towards negative infinity) of corresponding signed 8-bit elements in a and b, save the result in dst.
__lsx_vavg_bu — Compute the average (rounded towards negative infinity) of corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lsx_vavg_d — Compute the average (rounded towards negative infinity) of corresponding signed 64-bit elements in a and b, save the result in dst.
__lsx_vavg_du — Compute the average (rounded towards negative infinity) of corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lsx_vavg_h — Compute the average (rounded towards negative infinity) of corresponding signed 16-bit elements in a and b, save the result in dst.
__lsx_vavg_hu — Compute the average (rounded towards negative infinity) of corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lsx_vavg_w — Compute the average (rounded towards negative infinity) of corresponding signed 32-bit elements in a and b, save the result in dst.
__lsx_vavg_wu — Compute the average (rounded towards negative infinity) of corresponding unsigned 32-bit elements in a and b, save the result in dst.
__lsx_vavgr_b — Compute the average (rounded towards positive infinity) of corresponding signed 8-bit elements in a and b, save the result in dst.
__lsx_vavgr_bu — Compute the average (rounded towards positive infinity) of corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lsx_vavgr_d — Compute the average (rounded towards positive infinity) of corresponding signed 64-bit elements in a and b, save the result in dst.
__lsx_vavgr_du — Compute the average (rounded towards positive infinity) of corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lsx_vavgr_h — Compute the average (rounded towards positive infinity) of corresponding signed 16-bit elements in a and b, save the result in dst.
__lsx_vavgr_hu — Compute the average (rounded towards positive infinity) of corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lsx_vavgr_w — Compute the average (rounded towards positive infinity) of corresponding signed 32-bit elements in a and b, save the result in dst.
__lsx_vavgr_wu — Compute the average (rounded towards positive infinity) of corresponding unsigned 32-bit elements in a and b, save the result in dst.

LSX_B (38)

__lsx_bnz_b — Expected to be used in branches: branch if all 8-bit elements in a are non-zero.
__lsx_bnz_d — Expected to be used in branches: branch if all 64-bit elements in a are non-zero.
__lsx_bnz_h — Expected to be used in branches: branch if all 16-bit elements in a are non-zero.
__lsx_bnz_v — Expected to be used in branches: branch if the whole vector a is non-zero.
__lsx_bnz_w — Expected to be used in branches: branch if all 32-bit elements in a are non-zero.
__lsx_bz_b — Expected to be used in branches: branch if any 8-bit element in a equals to zero.
__lsx_bz_d — Expected to be used in branches: branch if any 64-bit element in a equals to zero.
__lsx_bz_h — Expected to be used in branches: branch if any 16-bit element in a equals to zero.
__lsx_bz_v — Expected to be used in branches: branch if the whole vector a equals to zero.
__lsx_bz_w — Expected to be used in branches: branch if any 32-bit element in a equals to zero.
__lsx_vbitclr_b — For each 8-bit element, clear the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lsx_vbitclr_d — For each 64-bit element, clear the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lsx_vbitclr_h — For each 16-bit element, clear the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lsx_vbitclr_w — For each 32-bit element, clear the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lsx_vbitclri_b — For each 8-bit element, clear the bit indexed by imm, save the result in dst.
__lsx_vbitclri_d — For each 64-bit element, clear the bit indexed by imm, save the result in dst.
__lsx_vbitclri_h — For each 16-bit element, clear the bit indexed by imm, save the result in dst.
__lsx_vbitclri_w — For each 32-bit element, clear the bit indexed by imm, save the result in dst.
__lsx_vbitrev_b — For each 8-bit element, toggle the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lsx_vbitrev_d — For each 64-bit element, toggle the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lsx_vbitrev_h — For each 16-bit element, toggle the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lsx_vbitrev_w — For each 32-bit element, toggle the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lsx_vbitrevi_b — For each 8-bit element, toggle the bit indexed by imm, save the result in dst.
__lsx_vbitrevi_d — For each 64-bit element, toggle the bit indexed by imm, save the result in dst.
__lsx_vbitrevi_h — For each 16-bit element, toggle the bit indexed by imm, save the result in dst.
__lsx_vbitrevi_w — For each 32-bit element, toggle the bit indexed by imm, save the result in dst.
__lsx_vbitsel_v — Compute bitwise selection: for each bit position, if the bit in c equals to one, copy the bit from b to dst, otherwise copy from a.
__lsx_vbitseli_b — Use each bit of a as a mask: where the bit is 1, select the corresponding bit of imm; where it is 0, select the corresponding bit of b. The result is written to dst.
__lsx_vbitset_b — For each 8-bit element, set the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lsx_vbitset_d — For each 64-bit element, set the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lsx_vbitset_h — For each 16-bit element, set the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lsx_vbitset_w — For each 32-bit element, set the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lsx_vbitseti_b — For each 8-bit element, set the bit indexed by imm, save the result in dst.
__lsx_vbitseti_d — For each 64-bit element, set the bit indexed by imm, save the result in dst.
__lsx_vbitseti_h — For each 16-bit element, set the bit indexed by imm, save the result in dst.
__lsx_vbitseti_w — For each 32-bit element, set the bit indexed by imm, save the result in dst.
__lsx_vbsll_v — Shift each 128-bit lane of a left by (imm % 16) * 8 bits, filling the vacated bits with zeros.
__lsx_vbsrl_v — Shift each 128-bit lane of a right by (imm % 16) * 8 bits, filling the vacated bits with zeros.

LSX_C (8)

__lsx_vclo_b — Count leading ones of 8-bit elements in a.
__lsx_vclo_d — Count leading ones of 64-bit elements in a.
__lsx_vclo_h — Count leading ones of 16-bit elements in a.
__lsx_vclo_w — Count leading ones of 32-bit elements in a.
__lsx_vclz_b — Count leading zeros of 8-bit elements in a.
__lsx_vclz_d — Count leading zeros of 64-bit elements in a.
__lsx_vclz_h — Count leading zeros of 16-bit elements in a.
__lsx_vclz_w — Count leading zeros of 32-bit elements in a.

LSX_D (8)

__lsx_vdiv_b — Divide each signed 8-bit element in a by the corresponding element in b.
__lsx_vdiv_bu — Divide each unsigned 8-bit element in a by the corresponding element in b.
__lsx_vdiv_d — Divide each signed 64-bit element in a by the corresponding element in b.
__lsx_vdiv_du — Divide each unsigned 64-bit element in a by the corresponding element in b.
__lsx_vdiv_h — Divide each signed 16-bit element in a by the corresponding element in b.
__lsx_vdiv_hu — Divide each unsigned 16-bit element in a by the corresponding element in b.
__lsx_vdiv_w — Divide each signed 32-bit element in a by the corresponding element in b.
__lsx_vdiv_wu — Divide each unsigned 32-bit element in a by the corresponding element in b.

LSX_E (14)

__lsx_vexth_d_w — Sign-extend 32-bit elements in the higher half of every 128-bit vector of a to 64-bit.
__lsx_vexth_du_wu — Zero-extend 32-bit elements in the higher half of every 128-bit vector of a to 64-bit.
__lsx_vexth_h_b — Sign-extend 8-bit elements in the higher half of every 128-bit vector of a to 16-bit.
__lsx_vexth_hu_bu — Zero-extend 8-bit elements in the higher half of every 128-bit vector of a to 16-bit.
__lsx_vexth_q_d — Sign-extend 64-bit elements in the higher half of every 128-bit vector of a to 128-bit.
__lsx_vexth_qu_du — Zero-extend 64-bit elements in the higher half of every 128-bit vector of a to 128-bit.
__lsx_vexth_w_h — Sign-extend 16-bit elements in the higher half of every 128-bit vector of a to 32-bit.
__lsx_vexth_wu_hu — Zero-extend 16-bit elements in the higher half of every 128-bit vector of a to 32-bit.
__lsx_vextl_q_d — Sign-extend 64-bit elements in the lower half of every 128-bit vector of a to 128-bit.
__lsx_vextl_qu_du — Zero-extend 64-bit elements in the lower half of every 128-bit vector of a to 128-bit.
__lsx_vextrins_b — Copy the 8-bit element of b selected by imm[3:0] into the element of a selected by imm[7:4]; other elements remain unchanged.
__lsx_vextrins_d — Copy the 64-bit element of b selected by imm[0] into the element of a selected by imm[4]; other elements remain unchanged.
__lsx_vextrins_h — Copy the 16-bit element of b selected by imm[2:0] into the element of a selected by imm[6:4]; other elements remain unchanged.
__lsx_vextrins_w — Copy the 32-bit element of b selected by imm[1:0] into the element of a selected by imm[5:4]; other elements remain unchanged.

LSX_F (140)

__lsx_vfadd_d — Add corresponding double precision floating point elements in a and b.
__lsx_vfadd_s — Add corresponding single precision floating point elements in a and b.
__lsx_vfclass_d — Classify each double precision floating point element in a according to IEEE 754 class(x), writing the 10-bit classification result into the corresponding element of dst.
__lsx_vfclass_s — Classify each single precision floating point element in a according to IEEE 754 class(x), writing the 10-bit classification result into the corresponding element of dst.
__lsx_vfcmp_caf_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_caf_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_ceq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_ceq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cle_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cle_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_clt_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_clt_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cne_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cne_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cor_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cor_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cueq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cueq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cule_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cule_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cult_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cult_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cun_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cun_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cune_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_cune_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lsx_vfcmp_saf_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_saf_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_seq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_seq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sle_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sle_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_slt_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_slt_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sne_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sne_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sor_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sor_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sueq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sueq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sule_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sule_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sult_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sult_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sun_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sun_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sune_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcmp_sune_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lsx_vfcvt_h_s — For each 128-bit lane, convert single-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as half-precision floating point numbers.
__lsx_vfcvt_s_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as single-precision floating point numbers.
__lsx_vfcvth_d_s — Convert single precision floating point elements in higher half of every 128-bit vector of a to double precision.
__lsx_vfcvth_s_h — Convert half precision floating point elements in higher half of every 128-bit vector of a to single precision.
__lsx_vfcvtl_d_s — Convert single precision floating point elements in lower half of every 128-bit vector of a to double precision.
__lsx_vfcvtl_s_h — Convert half precision floating point elements in lower half of every 128-bit vector of a to single precision.
__lsx_vfdiv_d — Divide corresponding double precision floating point elements in a by elements in b.
__lsx_vfdiv_s — Divide corresponding single precision floating point elements in a by elements in b.
__lsx_vffint_d_l — Convert signed 64-bit integer elements in a to double-precision floating point numbers.
__lsx_vffint_d_lu — Convert unsigned 64-bit integer elements in a to double-precision floating point numbers.
__lsx_vffint_s_l — For each 128-bit lane, convert signed 64-bit integer elements in the corresponding lane of a into the upper half and elements in b into the lower half, as single-precision floating point numbers.
__lsx_vffint_s_w — Convert signed 32-bit integer elements in a to single-precision floating point numbers.
__lsx_vffint_s_wu — Convert unsigned 32-bit integer elements in a to single-precision floating point numbers.
__lsx_vffinth_d_w — Convert signed 32-bit integer elements in higher part of every 128-bit vector of a to double precision floating point numbers.
__lsx_vffintl_d_w — Convert signed 32-bit integer elements in lower part of every 128-bit vector of a to double precision floating point numbers.
__lsx_vflogb_d — Compute base-2 logarithm of double precision floating point elements in a.
__lsx_vflogb_s — Compute base-2 logarithm of single precision floating point elements in a.
__lsx_vfmadd_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the result in dst.
__lsx_vfmadd_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the result in dst.
__lsx_vfmax_d — Compute the maximum (maxNum) of double precision floating point elements in a and b.
__lsx_vfmax_s — Compute the maximum (maxNum) of single precision floating point elements in a and b.
__lsx_vfmaxa_d — Compute the maximum (maxNumMag) of double precision floating point elements in a and b, selecting the element with the larger absolute value.
__lsx_vfmaxa_s — Compute the maximum (maxNumMag) of single precision floating point elements in a and b, selecting the element with the larger absolute value.
__lsx_vfmin_d — Compute the minimum (minNum) of double precision floating point elements in a and b.
__lsx_vfmin_s — Compute the minimum (minNum) of single precision floating point elements in a and b.
__lsx_vfmina_d — Compute the minimum (minNumMag) of double precision floating point elements in a and b, selecting the element with the smaller absolute value.
__lsx_vfmina_s — Compute the minimum (minNumMag) of single precision floating point elements in a and b, selecting the element with the smaller absolute value.
__lsx_vfmsub_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the result in dst.
__lsx_vfmsub_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the result in dst.
__lsx_vfmul_d — Multiply corresponding double precision floating point elements in a and b.
__lsx_vfmul_s — Multiply corresponding single precision floating point elements in a and b.
__lsx_vfnmadd_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the negated result in dst.
__lsx_vfnmadd_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the negated result in dst.
__lsx_vfnmsub_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the negated result in dst.
__lsx_vfnmsub_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the negated result in dst.
__lsx_vfrecip_d — Compute reciprocal of double precision floating point elements in a.
__lsx_vfrecip_s — Compute reciprocal of single precision floating point elements in a.
__lsx_vfrecipe_d — Compute estimated reciprocal of double precision floating point elements in a.
__lsx_vfrecipe_s — Compute estimated reciprocal of single precision floating point elements in a.
__lsx_vfrint_d — Round double-precision floating point elements in a to integers, using current rounding mode specified in fscr, and store as floating point numbers.
__lsx_vfrint_s — Round single-precision floating point elements in a to integers, using current rounding mode specified in fscr, and store as floating point numbers.
__lsx_vfrintrm_d — Round double-precision floating point elements in a to integers, rounding towards negative infinity, and store as floating point numbers.
__lsx_vfrintrm_s — Round single-precision floating point elements in a to integers, rounding towards negative infinity, and store as floating point numbers.
__lsx_vfrintrne_d — Round double-precision floating point elements in a to integers, rounding towards nearest even, and store as floating point numbers.
__lsx_vfrintrne_s — Round single-precision floating point elements in a to integers, rounding towards nearest even, and store as floating point numbers.
__lsx_vfrintrp_d — Round double-precision floating point elements in a to integers, rounding towards positive infinity, and store as floating point numbers.
__lsx_vfrintrp_s — Round single-precision floating point elements in a to integers, rounding towards positive infinity, and store as floating point numbers.
__lsx_vfrintrz_d — Round double-precision floating point elements in a to integers, rounding towards zero, and store as floating point numbers.
__lsx_vfrintrz_s — Round single-precision floating point elements in a to integers, rounding towards zero, and store as floating point numbers.
__lsx_vfrsqrt_d — Compute reciprocal of square root of double precision floating point elements in a.
__lsx_vfrsqrt_s — Compute reciprocal of square root of single precision floating point elements in a.
__lsx_vfrsqrte_d — Compute estimated reciprocal of square root of double precision floating point elements in a.
__lsx_vfrsqrte_s — Compute estimated reciprocal of square root of single precision floating point elements in a.
__lsx_vfrstp_b — For each 128-bit lane, find the first negative 8-bit element in b. Write its index into the lane of a selected by the first element of the corresponding lane of c modulo 16, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lsx_vfrstp_h — For each 128-bit lane, find the first negative 16-bit element in b. Write its index into the lane of a selected by the first element of the corresponding lane of c modulo 8, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lsx_vfrstpi_b — For each 128-bit lane, find the first negative 8-bit element in b. Write its index into the lane of a selected by imm modulo 16, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lsx_vfrstpi_h — For each 128-bit lane, find the first negative 16-bit element in b. Write its index into the lane of a selected by imm modulo 8, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lsx_vfscaleb_d — Compute IEEE 754 scaleB (multiply by 2^b) of double precision floating point elements in a using integer exponents in b. Currently undocumented.
__lsx_vfscaleb_s — Compute IEEE 754 scaleB (multiply by 2^b) of single precision floating point elements in a using integer exponents in b. Currently undocumented.
__lsx_vfsqrt_d — Compute square root of double precision floating point elements in a.
__lsx_vfsqrt_s — Compute square root of single precision floating point elements in a.
__lsx_vfsub_d — Subtract corresponding double precision floating point elements in b from elements in a.
__lsx_vfsub_s — Subtract corresponding single precision floating point elements in b from elements in a.
__lsx_vftint_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, using current rounding mode specified in fscr.
__lsx_vftint_lu_d — Convert double-precision floating point elements in a to unsigned 64-bit integer, using current rounding mode specified in fscr.
__lsx_vftint_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, using current rounding mode specified in fscr.
__lsx_vftint_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, using current rounding mode specified in fscr.
__lsx_vftint_wu_s — Convert single-precision floating point elements in a to unsigned 32-bit integer, using current rounding mode specified in fscr.
__lsx_vftinth_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, using current rounding mode specified in fscr.
__lsx_vftintl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, using current rounding mode specified in fscr.
__lsx_vftintrm_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards negative infinity.
__lsx_vftintrm_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards negative infinity.
__lsx_vftintrm_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards negative infinity.
__lsx_vftintrmh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards negative infinity.
__lsx_vftintrml_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards negative infinity.
__lsx_vftintrne_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards nearest even.
__lsx_vftintrne_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards nearest even.
__lsx_vftintrne_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards nearest even.
__lsx_vftintrneh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards nearest even.
__lsx_vftintrnel_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards nearest even.
__lsx_vftintrp_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards positive infinity.
__lsx_vftintrp_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards positive infinity.
__lsx_vftintrp_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards positive infinity.
__lsx_vftintrph_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards positive infinity.
__lsx_vftintrpl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards positive infinity.
__lsx_vftintrz_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards zero.
__lsx_vftintrz_lu_d — Convert double-precision floating point elements in a to unsigned 64-bit integer, rounding towards zero.
__lsx_vftintrz_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards zero.
__lsx_vftintrz_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards zero.
__lsx_vftintrz_wu_s — Convert single-precision floating point elements in a to unsigned 32-bit integer, rounding towards zero.
__lsx_vftintrzh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards zero.
__lsx_vftintrzl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards zero.

LSX_H (16)

__lsx_vhaddw_d_w — Add odd-positioned signed 32-bit elements in a to even-positioned signed 32-bit elements in b, sign-extending both to 64-bit, to get the 64-bit result.
__lsx_vhaddw_du_wu — Add odd-positioned unsigned 32-bit elements in a to even-positioned unsigned 32-bit elements in b, zero-extending both to 64-bit, to get the 64-bit result.
__lsx_vhaddw_h_b — Add odd-positioned signed 8-bit elements in a to even-positioned signed 8-bit elements in b, sign-extending both to 16-bit, to get the 16-bit result.
__lsx_vhaddw_hu_bu — Add odd-positioned unsigned 8-bit elements in a to even-positioned unsigned 8-bit elements in b, zero-extending both to 16-bit, to get the 16-bit result.
__lsx_vhaddw_q_d — Add odd-positioned signed 64-bit elements in a to even-positioned signed 64-bit elements in b, sign-extending both to 128-bit, to get the 128-bit result.
__lsx_vhaddw_qu_du — Add odd-positioned unsigned 64-bit elements in a to even-positioned unsigned 64-bit elements in b, zero-extending both to 128-bit, to get the 128-bit result.
__lsx_vhaddw_w_h — Add odd-positioned signed 16-bit elements in a to even-positioned signed 16-bit elements in b, sign-extending both to 32-bit, to get the 32-bit result.
__lsx_vhaddw_wu_hu — Add odd-positioned unsigned 16-bit elements in a to even-positioned unsigned 16-bit elements in b, zero-extending both to 32-bit, to get the 32-bit result.
__lsx_vhsubw_d_w — Subtract even-positioned signed 32-bit elements in b from odd-positioned signed 32-bit elements in a, sign-extending both to 64-bit, to get the 64-bit result.
__lsx_vhsubw_du_wu — Subtract even-positioned unsigned 32-bit elements in b from odd-positioned unsigned 32-bit elements in a, zero-extending both to 64-bit, to get the 64-bit result.
__lsx_vhsubw_h_b — Subtract even-positioned signed 8-bit elements in b from odd-positioned signed 8-bit elements in a, sign-extending both to 16-bit, to get the 16-bit result.
__lsx_vhsubw_hu_bu — Subtract even-positioned unsigned 8-bit elements in b from odd-positioned unsigned 8-bit elements in a, zero-extending both to 16-bit, to get the 16-bit result.
__lsx_vhsubw_q_d — Subtract even-positioned signed 64-bit elements in b from odd-positioned signed 64-bit elements in a, sign-extending both to 128-bit, to get the 128-bit result.
__lsx_vhsubw_qu_du — Subtract even-positioned unsigned 64-bit elements in b from odd-positioned unsigned 64-bit elements in a, zero-extending both to 128-bit, to get the 128-bit result.
__lsx_vhsubw_w_h — Subtract even-positioned signed 16-bit elements in b from odd-positioned signed 16-bit elements in a, sign-extending both to 32-bit, to get the 32-bit result.
__lsx_vhsubw_wu_hu — Subtract even-positioned unsigned 16-bit elements in b from odd-positioned unsigned 16-bit elements in a, zero-extending both to 32-bit, to get the 32-bit result.

LSX_I (12)

__lsx_vilvh_b — For each 128-bit lane, interleave the 8-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvh_d — For each 128-bit lane, interleave the 64-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvh_h — For each 128-bit lane, interleave the 16-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvh_w — For each 128-bit lane, interleave the 32-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvl_b — For each 128-bit lane, interleave the 8-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvl_d — For each 128-bit lane, interleave the 64-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvl_h — For each 128-bit lane, interleave the 16-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vilvl_w — For each 128-bit lane, interleave the 32-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vinsgr2vr_b — Insert the low 8 bits of b into lane imm of a; the other lanes are unchanged.
__lsx_vinsgr2vr_d — Insert the low 64 bits of b into lane imm of a; the other lanes are unchanged.
__lsx_vinsgr2vr_h — Insert the low 16 bits of b into lane imm of a; the other lanes are unchanged.
__lsx_vinsgr2vr_w — Insert the low 32 bits of b into lane imm of a; the other lanes are unchanged.

LSX_L (7)

__lsx_vld — Read whole vector from memory address addr + offset, save the data into dst. Address misalignment does not raise an exception. Note that you can use this intrinsic to load floating point vectors, even though the return type represents integer vectors.
__lsx_vldi — Initialize dst using predefined patterns:
__lsx_vldrepl_b — Read 8-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vldrepl_d — Read 64-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vldrepl_h — Read 16-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vldrepl_w — Read 32-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vldx — Read whole vector from memory address addr + offset, save the data into dst. Address misalignment does not raise an exception. Note that you can use this intrinsic to load floating point vectors, even though the return type represents integer vectors.

LSX_M (115)

__lsx_vmadd_b — Multiply 8-bit elements in b and c, add the low 8 bits of the product to elements in a, save the result in dst.
__lsx_vmadd_d — Multiply 64-bit elements in b and c, add the low 64 bits of the product to elements in a, save the result in dst.
__lsx_vmadd_h — Multiply 16-bit elements in b and c, add the low 16 bits of the product to elements in a, save the result in dst.
__lsx_vmadd_w — Multiply 32-bit elements in b and c, add the low 32 bits of the product to elements in a, save the result in dst.
__lsx_vmaddwev_d_w — Multiply the even-positioned signed 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwev_d_wu — Multiply the even-positioned unsigned 32-bit elements in b and the corresponding unsigned 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwev_d_wu_w — Multiply the even-positioned unsigned 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwev_h_b — Multiply the even-positioned signed 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwev_h_bu — Multiply the even-positioned unsigned 8-bit elements in b and the corresponding unsigned 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwev_h_bu_b — Multiply the even-positioned unsigned 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwev_q_d — Multiply the even-positioned signed 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwev_q_du — Multiply the even-positioned unsigned 64-bit elements in b and the corresponding unsigned 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwev_q_du_d — Multiply the even-positioned unsigned 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwev_w_h — Multiply the even-positioned signed 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmaddwev_w_hu — Multiply the even-positioned unsigned 16-bit elements in b and the corresponding unsigned 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmaddwev_w_hu_h — Multiply the even-positioned unsigned 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmaddwod_d_w — Multiply the odd-positioned signed 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwod_d_wu — Multiply the odd-positioned unsigned 32-bit elements in b and the corresponding unsigned 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwod_d_wu_w — Multiply the odd-positioned unsigned 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lsx_vmaddwod_h_b — Multiply the odd-positioned signed 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwod_h_bu — Multiply the odd-positioned unsigned 8-bit elements in b and the corresponding unsigned 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwod_h_bu_b — Multiply the odd-positioned unsigned 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lsx_vmaddwod_q_d — Multiply the odd-positioned signed 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwod_q_du — Multiply the odd-positioned unsigned 64-bit elements in b and the corresponding unsigned 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwod_q_du_d — Multiply the odd-positioned unsigned 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lsx_vmaddwod_w_h — Multiply the odd-positioned signed 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmaddwod_w_hu — Multiply the odd-positioned unsigned 16-bit elements in b and the corresponding unsigned 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmaddwod_w_hu_h — Multiply the odd-positioned unsigned 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lsx_vmax_b — Compute elementwise maximum for corresponding signed 8-bit elements in a and b.
__lsx_vmax_bu — Compute elementwise maximum for corresponding unsigned 8-bit elements in a and b.
__lsx_vmax_d — Compute elementwise maximum for corresponding signed 64-bit elements in a and b.
__lsx_vmax_du — Compute elementwise maximum for corresponding unsigned 64-bit elements in a and b.
__lsx_vmax_h — Compute elementwise maximum for corresponding signed 16-bit elements in a and b.
__lsx_vmax_hu — Compute elementwise maximum for corresponding unsigned 16-bit elements in a and b.
__lsx_vmax_w — Compute elementwise maximum for corresponding signed 32-bit elements in a and b.
__lsx_vmax_wu — Compute elementwise maximum for corresponding unsigned 32-bit elements in a and b.
__lsx_vmaxi_b — Compute elementwise maximum for signed 8-bit elements in a and the sign-extended imm.
__lsx_vmaxi_bu — Compute elementwise maximum for unsigned 8-bit elements in a and the zero-extended imm.
__lsx_vmaxi_d — Compute elementwise maximum for signed 64-bit elements in a and the sign-extended imm.
__lsx_vmaxi_du — Compute elementwise maximum for unsigned 64-bit elements in a and the zero-extended imm.
__lsx_vmaxi_h — Compute elementwise maximum for signed 16-bit elements in a and the sign-extended imm.
__lsx_vmaxi_hu — Compute elementwise maximum for unsigned 16-bit elements in a and the zero-extended imm.
__lsx_vmaxi_w — Compute elementwise maximum for signed 32-bit elements in a and the sign-extended imm.
__lsx_vmaxi_wu — Compute elementwise maximum for unsigned 32-bit elements in a and the zero-extended imm.
__lsx_vmepatmsk_v — Compute an 8-bit pattern selected by mode (0: repeating 0..3; 1: 0..3 shifted by 1 for each group; 2: 4..7 shifted by 1 for each group; 3: 0..15), then add uimm5 to each byte element.
__lsx_vmin_b — Compute elementwise minimum for corresponding signed 8-bit elements in a and b.
__lsx_vmin_bu — Compute elementwise minimum for corresponding unsigned 8-bit elements in a and b.
__lsx_vmin_d — Compute elementwise minimum for corresponding signed 64-bit elements in a and b.
__lsx_vmin_du — Compute elementwise minimum for corresponding unsigned 64-bit elements in a and b.
__lsx_vmin_h — Compute elementwise minimum for corresponding signed 16-bit elements in a and b.
__lsx_vmin_hu — Compute elementwise minimum for corresponding unsigned 16-bit elements in a and b.
__lsx_vmin_w — Compute elementwise minimum for corresponding signed 32-bit elements in a and b.
__lsx_vmin_wu — Compute elementwise minimum for corresponding unsigned 32-bit elements in a and b.
__lsx_vmini_b — Compute elementwise minimum for signed 8-bit elements in a and the sign-extended imm.
__lsx_vmini_bu — Compute elementwise minimum for unsigned 8-bit elements in a and the zero-extended imm.
__lsx_vmini_d — Compute elementwise minimum for signed 64-bit elements in a and the sign-extended imm.
__lsx_vmini_du — Compute elementwise minimum for unsigned 64-bit elements in a and the zero-extended imm.
__lsx_vmini_h — Compute elementwise minimum for signed 16-bit elements in a and the sign-extended imm.
__lsx_vmini_hu — Compute elementwise minimum for unsigned 16-bit elements in a and the zero-extended imm.
__lsx_vmini_w — Compute elementwise minimum for signed 32-bit elements in a and the sign-extended imm.
__lsx_vmini_wu — Compute elementwise minimum for unsigned 32-bit elements in a and the zero-extended imm.
__lsx_vmod_b — Compute the remainder of each signed 8-bit element in a divided by the corresponding element in b.
__lsx_vmod_bu — Compute the remainder of each unsigned 8-bit element in a divided by the corresponding element in b.
__lsx_vmod_d — Compute the remainder of each signed 64-bit element in a divided by the corresponding element in b.
__lsx_vmod_du — Compute the remainder of each unsigned 64-bit element in a divided by the corresponding element in b.
__lsx_vmod_h — Compute the remainder of each signed 16-bit element in a divided by the corresponding element in b.
__lsx_vmod_hu — Compute the remainder of each unsigned 16-bit element in a divided by the corresponding element in b.
__lsx_vmod_w — Compute the remainder of each signed 32-bit element in a divided by the corresponding element in b.
__lsx_vmod_wu — Compute the remainder of each unsigned 32-bit element in a divided by the corresponding element in b.
__lsx_vmskgez_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is greater than or equal to zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmskltz_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmskltz_d — For each 128-bit lane, for each 64-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmskltz_h — For each 128-bit lane, for each 16-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmskltz_w — For each 128-bit lane, for each 32-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmsknz_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is non-zero, otherwise zero; the remaining bits of the lane are zero.
__lsx_vmsub_b — Multiply 8-bit elements in b and c, subtract the low 8 bits of the product from elements in a, save the result in dst.
__lsx_vmsub_d — Multiply 64-bit elements in b and c, subtract the low 64 bits of the product from elements in a, save the result in dst.
__lsx_vmsub_h — Multiply 16-bit elements in b and c, subtract the low 16 bits of the product from elements in a, save the result in dst.
__lsx_vmsub_w — Multiply 32-bit elements in b and c, subtract the low 32 bits of the product from elements in a, save the result in dst.
__lsx_vmuh_b — Multiply corresponding signed 8-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_bu — Multiply corresponding unsigned 8-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_d — Multiply corresponding signed 64-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_du — Multiply corresponding unsigned 64-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_h — Multiply corresponding signed 16-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_hu — Multiply corresponding unsigned 16-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_w — Multiply corresponding signed 32-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmuh_wu — Multiply corresponding unsigned 32-bit elements in a and b, save the upper half of the double-width product in dst.
__lsx_vmul_b — Multiply corresponding 8-bit elements in a and b, save the result in dst.
__lsx_vmul_d — Multiply corresponding 64-bit elements in a and b, save the result in dst.
__lsx_vmul_h — Multiply corresponding 16-bit elements in a and b, save the result in dst.
__lsx_vmul_w — Multiply corresponding 32-bit elements in a and b, save the result in dst.
__lsx_vmulwev_d_w — Multiply the even-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwev_d_wu — Multiply the even-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwev_d_wu_w — Multiply the even-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwev_h_b — Multiply the even-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwev_h_bu — Multiply the even-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwev_h_bu_b — Multiply the even-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwev_q_d — Multiply the even-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwev_q_du — Multiply the even-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwev_q_du_d — Multiply the even-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwev_w_h — Multiply the even-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vmulwev_w_hu — Multiply the even-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vmulwev_w_hu_h — Multiply the even-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vmulwod_d_w — Multiply the odd-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwod_d_wu — Multiply the odd-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwod_d_wu_w — Multiply the odd-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vmulwod_h_b — Multiply the odd-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwod_h_bu — Multiply the odd-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwod_h_bu_b — Multiply the odd-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vmulwod_q_d — Multiply the odd-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwod_q_du — Multiply the odd-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwod_q_du_d — Multiply the odd-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vmulwod_w_h — Multiply the odd-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vmulwod_w_hu — Multiply the odd-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vmulwod_w_hu_h — Multiply the odd-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.

LSX_N (6)

__lsx_vneg_b — Negate 8-bit elements in a and save the result in dst.
__lsx_vneg_d — Negate 64-bit elements in a and save the result in dst.
__lsx_vneg_h — Negate 16-bit elements in a and save the result in dst.
__lsx_vneg_w — Negate 32-bit elements in a and save the result in dst.
__lsx_vnor_v — Compute bitwise NOR (~(a | b)) of elements in a and b.
__lsx_vnori_b — Compute bitwise NOR (~(a | imm)) of elements in a and imm.

LSX_O (3)

__lsx_vor_v — Compute bitwise OR of elements in a and b.
__lsx_vori_b — Compute bitwise OR of elements in a and imm.
__lsx_vorn_v — Compute bitwise ORN (a | ~b) of elements in a and b.

LSX_P (29)

__lsx_vpackev_b — Interleave even-positioned 8-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackev_d — Interleave even-positioned 64-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackev_h — Interleave even-positioned 16-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackev_w — Interleave even-positioned 32-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackod_b — Interleave odd-positioned 8-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackod_d — Interleave odd-positioned 64-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackod_h — Interleave odd-positioned 16-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpackod_w — Interleave odd-positioned 32-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lsx_vpcnt_b — Count the number of ones (population, popcount) in 8-bit elements in a.
__lsx_vpcnt_d — Count the number of ones (population, popcount) in 64-bit elements in a.
__lsx_vpcnt_h — Count the number of ones (population, popcount) in 16-bit elements in a.
__lsx_vpcnt_w — Count the number of ones (population, popcount) in 32-bit elements in a.
__lsx_vpermi_w — For each 128-bit lane, use imm[1:0] and imm[3:2] to select words 0 and 1 from b, and imm[5:4] and imm[7:6] to select words 2 and 3 from a; store the result in dst.
__lsx_vpickev_b — For each 128-bit lane, place even-positioned 8-bit elements of b into its lower half and even-positioned 8-bit elements of a into its upper half.
__lsx_vpickev_d — For each 128-bit lane, place even-positioned 64-bit elements of b into its lower half and even-positioned 64-bit elements of a into its upper half.
__lsx_vpickev_h — For each 128-bit lane, place even-positioned 16-bit elements of b into its lower half and even-positioned 16-bit elements of a into its upper half.
__lsx_vpickev_w — For each 128-bit lane, place even-positioned 32-bit elements of b into its lower half and even-positioned 32-bit elements of a into its upper half.
__lsx_vpickod_b — For each 128-bit lane, place odd-positioned 8-bit elements of b into its lower half and odd-positioned 8-bit elements of a into its upper half.
__lsx_vpickod_d — For each 128-bit lane, place odd-positioned 64-bit elements of b into its lower half and odd-positioned 64-bit elements of a into its upper half.
__lsx_vpickod_h — For each 128-bit lane, place odd-positioned 16-bit elements of b into its lower half and odd-positioned 16-bit elements of a into its upper half.
__lsx_vpickod_w — For each 128-bit lane, place odd-positioned 32-bit elements of b into its lower half and odd-positioned 32-bit elements of a into its upper half.
__lsx_vpickve2gr_b — Pick the 8-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_bu — Pick the 8-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_d — Pick the 64-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_du — Pick the 64-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_h — Pick the 16-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_hu — Pick the 16-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_w — Pick the 32-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lsx_vpickve2gr_wu — Pick the 32-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.

LSX_R (24)

__lsx_vreplgr2vr_b — Broadcast the low 8 bits of val to all lanes of dst.
__lsx_vreplgr2vr_d — Broadcast the low 64 bits of val to all lanes of dst.
__lsx_vreplgr2vr_h — Broadcast the low 16 bits of val to all lanes of dst.
__lsx_vreplgr2vr_w — Broadcast the low 32 bits of val to all lanes of dst.
__lsx_vrepli_b — Repeat imm to fill whole vector.
__lsx_vrepli_d — Repeat imm to fill whole vector.
__lsx_vrepli_h — Repeat imm to fill whole vector.
__lsx_vrepli_w — Repeat imm to fill whole vector.
__lsx_vreplve_b — Repeat the element in lane idx (index modulo 16) of a to fill whole vector.
__lsx_vreplve_d — Repeat the element in lane idx (index modulo 2) of a to fill whole vector.
__lsx_vreplve_h — Repeat the element in lane idx (index modulo 8) of a to fill whole vector.
__lsx_vreplve_w — Repeat the element in lane idx (index modulo 4) of a to fill whole vector.
__lsx_vreplvei_b — Repeat the element in lane idx of a to fill whole vector.
__lsx_vreplvei_d — Repeat the element in lane idx of a to fill whole vector.
__lsx_vreplvei_h — Repeat the element in lane idx of a to fill whole vector.
__lsx_vreplvei_w — Repeat the element in lane idx of a to fill whole vector.
__lsx_vrotr_b — Rotate right each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vrotr_d — Rotate right each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vrotr_h — Rotate right each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vrotr_w — Rotate right each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vrotri_b — Rotate right the unsigned 8-bit elements in a by imm, store the result to dst.
__lsx_vrotri_d — Rotate right the unsigned 64-bit elements in a by imm, store the result to dst.
__lsx_vrotri_h — Rotate right the unsigned 16-bit elements in a by imm, store the result to dst.
__lsx_vrotri_w — Rotate right the unsigned 32-bit elements in a by imm, store the result to dst.

LSX_S (237)

__lsx_vsadd_b — Saturating add corresponding signed 8-bit elements in a and b, store the result to dst.
__lsx_vsadd_bu — Saturating add corresponding unsigned 8-bit elements in a and b, store the result to dst.
__lsx_vsadd_d — Saturating add corresponding signed 64-bit elements in a and b, store the result to dst.
__lsx_vsadd_du — Saturating add corresponding unsigned 64-bit elements in a and b, store the result to dst.
__lsx_vsadd_h — Saturating add corresponding signed 16-bit elements in a and b, store the result to dst.
__lsx_vsadd_hu — Saturating add corresponding unsigned 16-bit elements in a and b, store the result to dst.
__lsx_vsadd_w — Saturating add corresponding signed 32-bit elements in a and b, store the result to dst.
__lsx_vsadd_wu — Saturating add corresponding unsigned 32-bit elements in a and b, store the result to dst.
__lsx_vsat_b — Saturate each signed 8-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_bu — Saturate each unsigned 8-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_d — Saturate each signed 64-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_du — Saturate each unsigned 64-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_h — Saturate each signed 16-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_hu — Saturate each unsigned 16-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_w — Saturate each signed 32-bit element in a to the number of significant bits specified by imm.
__lsx_vsat_wu — Saturate each unsigned 32-bit element in a to the number of significant bits specified by imm.
__lsx_vseq_b — Compare the 8-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lsx_vseq_d — Compare the 64-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lsx_vseq_h — Compare the 16-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lsx_vseq_w — Compare the 32-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lsx_vseqi_b — Compare the 8-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lsx_vseqi_d — Compare the 64-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lsx_vseqi_h — Compare the 16-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lsx_vseqi_w — Compare the 32-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lsx_vshuf4i_b — For each group of four consecutive 8-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lsx_vshuf4i_d — For each 128-bit lane, select two 64-bit elements from the four elements formed by the corresponding lanes of a and b using imm[1:0] and imm[3:2], save the result to dst.
__lsx_vshuf4i_h — For each group of four consecutive 16-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lsx_vshuf4i_w — For each group of four consecutive 32-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lsx_vshuf_b — For each 128-bit lane, shuffle bytes from a and b using the low 5 bits of the indices from the corresponding lane of c.
__lsx_vshuf_d — For each 128-bit lane, shuffle 64-bit elements from b and c using the low 2 bits of the indices from the corresponding lane of a, and save the result to dst.
__lsx_vshuf_h — For each 128-bit lane, shuffle 16-bit elements from b and c using the low 4 bits of the indices from the corresponding lane of a, and save the result to dst.
__lsx_vshuf_w — For each 128-bit lane, shuffle 32-bit elements from b and c using the low 3 bits of the indices from the corresponding lane of a, and save the result to dst.
__lsx_vsigncov_b — If the 8-bit element in a equals to zero, set the result to zero. If the signed 8-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lsx_vsigncov_d — If the 64-bit element in a equals to zero, set the result to zero. If the signed 64-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lsx_vsigncov_h — If the 16-bit element in a equals to zero, set the result to zero. If the signed 16-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lsx_vsigncov_w — If the 32-bit element in a equals to zero, set the result to zero. If the signed 32-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lsx_vsle_b — Compare the signed 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_bu — Compare the unsigned 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_d — Compare the signed 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_du — Compare the unsigned 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_h — Compare the signed 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_hu — Compare the unsigned 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_w — Compare the signed 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vsle_wu — Compare the unsigned 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lsx_vslei_b — Compare the signed 8-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_bu — Compare the unsigned 8-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_d — Compare the signed 64-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_du — Compare the unsigned 64-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_h — Compare the signed 16-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_hu — Compare the unsigned 16-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_w — Compare the signed 32-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vslei_wu — Compare the unsigned 32-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lsx_vsll_b — Logical left shift each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vsll_d — Logical left shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vsll_h — Logical left shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vsll_w — Logical left shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vslli_b — Logical left shift the unsigned 8-bit elements in a by imm, store the result to dst.
__lsx_vslli_d — Logical left shift the unsigned 64-bit elements in a by imm, store the result to dst.
__lsx_vslli_h — Logical left shift the unsigned 16-bit elements in a by imm, store the result to dst.
__lsx_vslli_w — Logical left shift the unsigned 32-bit elements in a by imm, store the result to dst.
__lsx_vsllwil_d_w — For each 128-bit lane, sign-extend and shift the 32-bit elements in the lower part of that lane by imm to 64-bit result.
__lsx_vsllwil_du_wu — For each 128-bit lane, zero-extend and shift the 32-bit elements in the lower part of that lane by imm to 64-bit result.
__lsx_vsllwil_h_b — For each 128-bit lane, sign-extend and shift the 8-bit elements in the lower part of that lane by imm to 16-bit result.
__lsx_vsllwil_hu_bu — For each 128-bit lane, zero-extend and shift the 8-bit elements in the lower part of that lane by imm to 16-bit result.
__lsx_vsllwil_w_h — For each 128-bit lane, sign-extend and shift the 16-bit elements in the lower part of that lane by imm to 32-bit result.
__lsx_vsllwil_wu_hu — For each 128-bit lane, zero-extend and shift the 16-bit elements in the lower part of that lane by imm to 32-bit result.
__lsx_vslt_b — Compare the signed 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_bu — Compare the unsigned 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_d — Compare the signed 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_du — Compare the unsigned 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_h — Compare the signed 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_hu — Compare the unsigned 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_w — Compare the signed 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslt_wu — Compare the unsigned 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lsx_vslti_b — Compare the signed 8-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_bu — Compare the unsigned 8-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_d — Compare the signed 64-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_du — Compare the unsigned 64-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_h — Compare the signed 16-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_hu — Compare the unsigned 16-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_w — Compare the signed 32-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vslti_wu — Compare the unsigned 32-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lsx_vsra_b — Arithmetic right shift each signed 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vsra_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vsra_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vsra_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vsrai_b — Arithmetic right shift the signed 8-bit elements in a by imm, store the result to dst.
__lsx_vsrai_d — Arithmetic right shift the signed 64-bit elements in a by imm, store the result to dst.
__lsx_vsrai_h — Arithmetic right shift the signed 16-bit elements in a by imm, store the result to dst.
__lsx_vsrai_w — Arithmetic right shift the signed 32-bit elements in a by imm, store the result to dst.
__lsx_vsran_b_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsran_h_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsran_w_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrani_b_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrani_d_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lsx_vsrani_h_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrani_w_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrar_b — Arithmetic right shift with rounding each signed 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vsrar_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vsrar_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vsrar_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vsrari_b — Arithmetic right shift (with rounding) the signed 8-bit elements in a by imm, store the result to dst.
__lsx_vsrari_d — Arithmetic right shift (with rounding) the signed 64-bit elements in a by imm, store the result to dst.
__lsx_vsrari_h — Arithmetic right shift (with rounding) the signed 16-bit elements in a by imm, store the result to dst.
__lsx_vsrari_w — Arithmetic right shift (with rounding) the signed 32-bit elements in a by imm, store the result to dst.
__lsx_vsrarn_b_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrarn_h_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrarn_w_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrarni_b_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrarni_d_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lsx_vsrarni_h_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrarni_w_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrl_b — Logical right shift each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vsrl_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vsrl_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vsrl_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vsrli_b — Logical right shift the unsigned 8-bit elements in a by imm, store the result to dst.
__lsx_vsrli_d — Logical right shift the unsigned 64-bit elements in a by imm, store the result to dst.
__lsx_vsrli_h — Logical right shift the unsigned 16-bit elements in a by imm, store the result to dst.
__lsx_vsrli_w — Logical right shift the unsigned 32-bit elements in a by imm, store the result to dst.
__lsx_vsrln_b_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrln_h_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrln_w_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlni_b_h — Logical right shift the unsigned 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlni_d_q — Logical right shift the unsigned 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lsx_vsrlni_h_w — Logical right shift the unsigned 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlni_w_d — Logical right shift the unsigned 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlr_b — Logical right shift with rounding each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lsx_vsrlr_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lsx_vsrlr_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lsx_vsrlr_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lsx_vsrlri_b — Logical right shift (with rounding) the unsigned 8-bit elements in a by imm, store the result to dst.
__lsx_vsrlri_d — Logical right shift (with rounding) the unsigned 64-bit elements in a by imm, store the result to dst.
__lsx_vsrlri_h — Logical right shift (with rounding) the unsigned 16-bit elements in a by imm, store the result to dst.
__lsx_vsrlri_w — Logical right shift (with rounding) the unsigned 32-bit elements in a by imm, store the result to dst.
__lsx_vsrlrn_b_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlrn_h_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlrn_w_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlrni_b_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlrni_d_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lsx_vsrlrni_h_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vsrlrni_w_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_b_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_bu_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_h_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_hu_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_w_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssran_wu_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_b_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_bu_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_d_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lsx_vssrani_du_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lsx_vssrani_h_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_hu_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_w_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrani_wu_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_b_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_bu_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_h_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_hu_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_w_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarn_wu_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_b_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_bu_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_d_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lsx_vssrarni_du_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lsx_vssrarni_h_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_hu_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_w_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrarni_wu_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_b_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_bu_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_h_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_hu_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_w_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrln_wu_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_b_h — Logical right shift the unsigned 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_bu_h — Logical right shift the unsigned 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_d_q — Logical right shift the unsigned 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lsx_vssrlni_du_q — Logical right shift the unsigned 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lsx_vssrlni_h_w — Logical right shift the unsigned 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_hu_w — Logical right shift the unsigned 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_w_d — Logical right shift the unsigned 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlni_wu_d — Logical right shift the unsigned 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_b_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_bu_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_h_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_hu_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_w_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrn_wu_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_b_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_bu_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_d_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lsx_vssrlrni_du_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lsx_vssrlrni_h_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_hu_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_w_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssrlrni_wu_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lsx_vssub_b — Saturating subtract corresponding signed 8-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_bu — Saturating subtract corresponding unsigned 8-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_d — Saturating subtract corresponding signed 64-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_du — Saturating subtract corresponding unsigned 64-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_h — Saturating subtract corresponding signed 16-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_hu — Saturating subtract corresponding unsigned 16-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_w — Saturating subtract corresponding signed 32-bit elements in b from elements in a, store the result to dst.
__lsx_vssub_wu — Saturating subtract corresponding unsigned 32-bit elements in b from elements in a, store the result to dst.
__lsx_vst — Write whole vector data in data to memory address addr + offset. Address misalignment does not raise an exception.
__lsx_vstelm_b — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vstelm_d — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vstelm_h — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vstelm_w — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lsx_vstx — Write whole vector data in data to memory address addr + offset. Address misalignment does not raise an exception.
__lsx_vsub_b — Subtract corresponding 8-bit elements in b from elements in a, save the result in dst.
__lsx_vsub_d — Subtract corresponding 64-bit elements in b from elements in a, save the result in dst.
__lsx_vsub_h — Subtract corresponding 16-bit elements in b from elements in a, save the result in dst.
__lsx_vsub_q — Subtract corresponding 128-bit elements in b from elements in a, save the result in dst.
__lsx_vsub_w — Subtract corresponding 32-bit elements in b from elements in a, save the result in dst.
__lsx_vsubi_bu — Subtract the zero-extended imm from each 8-bit element in a, save the result in dst.
__lsx_vsubi_du — Subtract the zero-extended imm from each 64-bit element in a, save the result in dst.
__lsx_vsubi_hu — Subtract the zero-extended imm from each 16-bit element in a, save the result in dst.
__lsx_vsubi_wu — Subtract the zero-extended imm from each 32-bit element in a, save the result in dst.
__lsx_vsubwev_d_w — Subtract the even-positioned signed 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vsubwev_d_wu — Subtract the even-positioned unsigned 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vsubwev_h_b — Subtract the even-positioned signed 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vsubwev_h_bu — Subtract the even-positioned unsigned 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vsubwev_q_d — Subtract the even-positioned signed 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vsubwev_q_du — Subtract the even-positioned unsigned 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vsubwev_w_h — Subtract the even-positioned signed 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vsubwev_w_hu — Subtract the even-positioned unsigned 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vsubwod_d_w — Subtract the odd-positioned signed 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vsubwod_d_wu — Subtract the odd-positioned unsigned 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lsx_vsubwod_h_b — Subtract the odd-positioned signed 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vsubwod_h_bu — Subtract the odd-positioned unsigned 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lsx_vsubwod_q_d — Subtract the odd-positioned signed 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vsubwod_q_du — Subtract the odd-positioned unsigned 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lsx_vsubwod_w_h — Subtract the odd-positioned signed 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lsx_vsubwod_w_hu — Subtract the odd-positioned unsigned 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.

LSX_X (2)

__lsx_vxor_v — Compute bitwise XOR of elements in a and b.
__lsx_vxori_b — Compute bitwise XOR of elements in a and imm.

LASX_A (64)

__lasx_xvabsd_b — Compute the absolute difference between corresponding signed 8-bit elements in a and b, save the result in dst.
__lasx_xvabsd_bu — Compute the absolute difference between corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lasx_xvabsd_d — Compute the absolute difference between corresponding signed 64-bit elements in a and b, save the result in dst.
__lasx_xvabsd_du — Compute the absolute difference between corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lasx_xvabsd_h — Compute the absolute difference between corresponding signed 16-bit elements in a and b, save the result in dst.
__lasx_xvabsd_hu — Compute the absolute difference between corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lasx_xvabsd_w — Compute the absolute difference between corresponding signed 32-bit elements in a and b, save the result in dst.
__lasx_xvabsd_wu — Compute the absolute difference between corresponding unsigned 32-bit elements in a and b, save the result in dst.
__lasx_xvadd_b — Add corresponding 8-bit elements in a and b, save the result in dst.
__lasx_xvadd_d — Add corresponding 64-bit elements in a and b, save the result in dst.
__lasx_xvadd_h — Add corresponding 16-bit elements in a and b, save the result in dst.
__lasx_xvadd_q — Add corresponding 128-bit elements in a and b, save the result in dst.
__lasx_xvadd_w — Add corresponding 32-bit elements in a and b, save the result in dst.
__lasx_xvadda_b — Add the absolute values of the 8-bit elements in a and b, save the result in dst.
__lasx_xvadda_d — Add the absolute values of the 64-bit elements in a and b, save the result in dst.
__lasx_xvadda_h — Add the absolute values of the 16-bit elements in a and b, save the result in dst.
__lasx_xvadda_w — Add the absolute values of the 32-bit elements in a and b, save the result in dst.
__lasx_xvaddi_bu — Add the zero-extended imm to each 8-bit element in a, save the result in dst.
__lasx_xvaddi_du — Add the zero-extended imm to each 64-bit element in a, save the result in dst.
__lasx_xvaddi_hu — Add the zero-extended imm to each 16-bit element in a, save the result in dst.
__lasx_xvaddi_wu — Add the zero-extended imm to each 32-bit element in a, save the result in dst.
__lasx_xvaddwev_d_w — Add the even-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwev_d_wu — Add the even-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwev_d_wu_w — Add the even-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwev_h_b — Add the even-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwev_h_bu — Add the even-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwev_h_bu_b — Add the even-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwev_q_d — Add the even-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwev_q_du — Add the even-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwev_q_du_d — Add the even-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwev_w_h — Add the even-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvaddwev_w_hu — Add the even-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvaddwev_w_hu_h — Add the even-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvaddwod_d_w — Add the odd-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwod_d_wu — Add the odd-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwod_d_wu_w — Add the odd-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvaddwod_h_b — Add the odd-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwod_h_bu — Add the odd-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwod_h_bu_b — Add the odd-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvaddwod_q_d — Add the odd-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwod_q_du — Add the odd-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwod_q_du_d — Add the odd-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvaddwod_w_h — Add the odd-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvaddwod_w_hu — Add the odd-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvaddwod_w_hu_h — Add the odd-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvand_v — Compute bitwise AND of elements in a and b.
__lasx_xvandi_b — Compute bitwise AND of elements in a and imm.
__lasx_xvandn_v — Compute bitwise ANDN (~a & b) of elements in a and b.
__lasx_xvavg_b — Compute the average (rounded towards negative infinity) of corresponding signed 8-bit elements in a and b, save the result in dst.
__lasx_xvavg_bu — Compute the average (rounded towards negative infinity) of corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lasx_xvavg_d — Compute the average (rounded towards negative infinity) of corresponding signed 64-bit elements in a and b, save the result in dst.
__lasx_xvavg_du — Compute the average (rounded towards negative infinity) of corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lasx_xvavg_h — Compute the average (rounded towards negative infinity) of corresponding signed 16-bit elements in a and b, save the result in dst.
__lasx_xvavg_hu — Compute the average (rounded towards negative infinity) of corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lasx_xvavg_w — Compute the average (rounded towards negative infinity) of corresponding signed 32-bit elements in a and b, save the result in dst.
__lasx_xvavg_wu — Compute the average (rounded towards negative infinity) of corresponding unsigned 32-bit elements in a and b, save the result in dst.
__lasx_xvavgr_b — Compute the average (rounded towards positive infinity) of corresponding signed 8-bit elements in a and b, save the result in dst.
__lasx_xvavgr_bu — Compute the average (rounded towards positive infinity) of corresponding unsigned 8-bit elements in a and b, save the result in dst.
__lasx_xvavgr_d — Compute the average (rounded towards positive infinity) of corresponding signed 64-bit elements in a and b, save the result in dst.
__lasx_xvavgr_du — Compute the average (rounded towards positive infinity) of corresponding unsigned 64-bit elements in a and b, save the result in dst.
__lasx_xvavgr_h — Compute the average (rounded towards positive infinity) of corresponding signed 16-bit elements in a and b, save the result in dst.
__lasx_xvavgr_hu — Compute the average (rounded towards positive infinity) of corresponding unsigned 16-bit elements in a and b, save the result in dst.
__lasx_xvavgr_w — Compute the average (rounded towards positive infinity) of corresponding signed 32-bit elements in a and b, save the result in dst.
__lasx_xvavgr_wu — Compute the average (rounded towards positive infinity) of corresponding unsigned 32-bit elements in a and b, save the result in dst.

LASX_B (38)

__lasx_xbnz_b — Expected to be used in branches: branch if all 8-bit elements in a are non-zero.
__lasx_xbnz_d — Expected to be used in branches: branch if all 64-bit elements in a are non-zero.
__lasx_xbnz_h — Expected to be used in branches: branch if all 16-bit elements in a are non-zero.
__lasx_xbnz_v — Expected to be used in branches: branch if the whole vector a is non-zero.
__lasx_xbnz_w — Expected to be used in branches: branch if all 32-bit elements in a are non-zero.
__lasx_xbz_b — Expected to be used in branches: branch if any 8-bit element in a equals to zero.
__lasx_xbz_d — Expected to be used in branches: branch if any 64-bit element in a equals to zero.
__lasx_xbz_h — Expected to be used in branches: branch if any 16-bit element in a equals to zero.
__lasx_xbz_v — Expected to be used in branches: branch if the whole vector a equals to zero.
__lasx_xbz_w — Expected to be used in branches: branch if any 32-bit element in a equals to zero.
__lasx_xvbitclr_b — For each 8-bit element, clear the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lasx_xvbitclr_d — For each 64-bit element, clear the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lasx_xvbitclr_h — For each 16-bit element, clear the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lasx_xvbitclr_w — For each 32-bit element, clear the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lasx_xvbitclri_b — For each 8-bit element, clear the bit indexed by imm, save the result in dst.
__lasx_xvbitclri_d — For each 64-bit element, clear the bit indexed by imm, save the result in dst.
__lasx_xvbitclri_h — For each 16-bit element, clear the bit indexed by imm, save the result in dst.
__lasx_xvbitclri_w — For each 32-bit element, clear the bit indexed by imm, save the result in dst.
__lasx_xvbitrev_b — For each 8-bit element, toggle the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lasx_xvbitrev_d — For each 64-bit element, toggle the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lasx_xvbitrev_h — For each 16-bit element, toggle the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lasx_xvbitrev_w — For each 32-bit element, toggle the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lasx_xvbitrevi_b — For each 8-bit element, toggle the bit indexed by imm, save the result in dst.
__lasx_xvbitrevi_d — For each 64-bit element, toggle the bit indexed by imm, save the result in dst.
__lasx_xvbitrevi_h — For each 16-bit element, toggle the bit indexed by imm, save the result in dst.
__lasx_xvbitrevi_w — For each 32-bit element, toggle the bit indexed by imm, save the result in dst.
__lasx_xvbitsel_v — Compute bitwise selection: for each bit position, if the bit in c equals to one, copy the bit from b to dst, otherwise copy from a.
__lasx_xvbitseli_b — Use each bit of a as a mask: where the bit is 1, select the corresponding bit of imm; where it is 0, select the corresponding bit of b. The result is written to dst.
__lasx_xvbitset_b — For each 8-bit element, set the bit indexed by the corresponding element of b modulo 8, save the result in dst.
__lasx_xvbitset_d — For each 64-bit element, set the bit indexed by the corresponding element of b modulo 64, save the result in dst.
__lasx_xvbitset_h — For each 16-bit element, set the bit indexed by the corresponding element of b modulo 16, save the result in dst.
__lasx_xvbitset_w — For each 32-bit element, set the bit indexed by the corresponding element of b modulo 32, save the result in dst.
__lasx_xvbitseti_b — For each 8-bit element, set the bit indexed by imm, save the result in dst.
__lasx_xvbitseti_d — For each 64-bit element, set the bit indexed by imm, save the result in dst.
__lasx_xvbitseti_h — For each 16-bit element, set the bit indexed by imm, save the result in dst.
__lasx_xvbitseti_w — For each 32-bit element, set the bit indexed by imm, save the result in dst.
__lasx_xvbsll_v — Shift each 128-bit lane of a left by (imm % 16) * 8 bits, filling the vacated bits with zeros.
__lasx_xvbsrl_v — Shift each 128-bit lane of a right by (imm % 16) * 8 bits, filling the vacated bits with zeros.

LASX_C (14)

__lasx_cast_128 — Return a 256-bit integer vector whose low 128-bit half contains a. The high 128-bit half is unspecified.
__lasx_cast_128_d — Return a 256-bit double precision vector whose low 128-bit half contains a. The high 128-bit half is unspecified.
__lasx_cast_128_s — Return a 256-bit single precision vector whose low 128-bit half contains a. The high 128-bit half is unspecified.
__lasx_concat_128 — Concatenate two 128-bit integer vectors. lo becomes the low 128-bit half and hi becomes the high 128-bit half.
__lasx_concat_128_d — Concatenate two 128-bit double precision vectors. lo becomes the low 128-bit half and hi becomes the high 128-bit half.
__lasx_concat_128_s — Concatenate two 128-bit single precision vectors. lo becomes the low 128-bit half and hi becomes the high 128-bit half.
__lasx_xvclo_b — Count leading ones of 8-bit elements in a.
__lasx_xvclo_d — Count leading ones of 64-bit elements in a.
__lasx_xvclo_h — Count leading ones of 16-bit elements in a.
__lasx_xvclo_w — Count leading ones of 32-bit elements in a.
__lasx_xvclz_b — Count leading zeros of 8-bit elements in a.
__lasx_xvclz_d — Count leading zeros of 64-bit elements in a.
__lasx_xvclz_h — Count leading zeros of 16-bit elements in a.
__lasx_xvclz_w — Count leading zeros of 32-bit elements in a.

LASX_D (8)

__lasx_xvdiv_b — Divide each signed 8-bit element in a by the corresponding element in b.
__lasx_xvdiv_bu — Divide each unsigned 8-bit element in a by the corresponding element in b.
__lasx_xvdiv_d — Divide each signed 64-bit element in a by the corresponding element in b.
__lasx_xvdiv_du — Divide each unsigned 64-bit element in a by the corresponding element in b.
__lasx_xvdiv_h — Divide each signed 16-bit element in a by the corresponding element in b.
__lasx_xvdiv_hu — Divide each unsigned 16-bit element in a by the corresponding element in b.
__lasx_xvdiv_w — Divide each signed 32-bit element in a by the corresponding element in b.
__lasx_xvdiv_wu — Divide each unsigned 32-bit element in a by the corresponding element in b.

LASX_E (20)

__lasx_extract_128_hi — Extract the high 128-bit half of a as an integer vector.
__lasx_extract_128_hi_d — Extract the high 128-bit half of a as a double precision vector.
__lasx_extract_128_hi_s — Extract the high 128-bit half of a as a single precision vector.
__lasx_extract_128_lo — Extract the low 128-bit half of a as an integer vector.
__lasx_extract_128_lo_d — Extract the low 128-bit half of a as a double precision vector.
__lasx_extract_128_lo_s — Extract the low 128-bit half of a as a single precision vector.
__lasx_xvexth_d_w — Sign-extend 32-bit elements in the higher half of every 128-bit vector of a to 64-bit.
__lasx_xvexth_du_wu — Zero-extend 32-bit elements in the higher half of every 128-bit vector of a to 64-bit.
__lasx_xvexth_h_b — Sign-extend 8-bit elements in the higher half of every 128-bit vector of a to 16-bit.
__lasx_xvexth_hu_bu — Zero-extend 8-bit elements in the higher half of every 128-bit vector of a to 16-bit.
__lasx_xvexth_q_d — Sign-extend 64-bit elements in the higher half of every 128-bit vector of a to 128-bit.
__lasx_xvexth_qu_du — Zero-extend 64-bit elements in the higher half of every 128-bit vector of a to 128-bit.
__lasx_xvexth_w_h — Sign-extend 16-bit elements in the higher half of every 128-bit vector of a to 32-bit.
__lasx_xvexth_wu_hu — Zero-extend 16-bit elements in the higher half of every 128-bit vector of a to 32-bit.
__lasx_xvextl_q_d — Sign-extend 64-bit elements in the lower half of every 128-bit vector of a to 128-bit.
__lasx_xvextl_qu_du — Zero-extend 64-bit elements in the lower half of every 128-bit vector of a to 128-bit.
__lasx_xvextrins_b — For each 128-bit lane, copy the 8-bit element of b selected by imm[3:0] into the element of a selected by imm[7:4]; other elements remain unchanged.
__lasx_xvextrins_d — For each 128-bit lane, copy the 64-bit element of b selected by imm[0] into the element of a selected by imm[4]; other elements remain unchanged.
__lasx_xvextrins_h — For each 128-bit lane, copy the 16-bit element of b selected by imm[2:0] into the element of a selected by imm[6:4]; other elements remain unchanged.
__lasx_xvextrins_w — For each 128-bit lane, copy the 32-bit element of b selected by imm[1:0] into the element of a selected by imm[5:4]; other elements remain unchanged.

LASX_F (140)

__lasx_xvfadd_d — Add corresponding double precision floating point elements in a and b.
__lasx_xvfadd_s — Add corresponding single precision floating point elements in a and b.
__lasx_xvfclass_d — Classify each double precision floating point element in a according to IEEE 754 class(x), writing the 10-bit classification result into the corresponding element of dst.
__lasx_xvfclass_s — Classify each single precision floating point element in a according to IEEE 754 class(x), writing the 10-bit classification result into the corresponding element of dst.
__lasx_xvfcmp_caf_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_caf_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_ceq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_ceq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cle_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cle_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_clt_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_clt_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cne_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cne_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cor_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cor_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cueq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cueq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cule_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cule_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cult_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cult_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cun_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cun_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cune_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_cune_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. No exception is raised for QNaN.
__lasx_xvfcmp_saf_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_saf_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if AF(Always False), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_seq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_seq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if EQ(Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sle_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sle_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LE(Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_slt_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_slt_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if LT(Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sne_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sne_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if NE(Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sor_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sor_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if OR(Ordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sueq_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sueq_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UEQ(Unordered or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sule_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sule_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULE(Unordered or Less than or Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sult_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sult_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if ULT(Unordered or Less than), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sun_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sun_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UN(Unordered), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sune_d — Compare corresponding double precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcmp_sune_s — Compare corresponding single precision elements in a and b, save the comparison result (all ones if UNE(Unordered or Not Equal), all zeros otherwise) into dst. An exception is raised for QNaN.
__lasx_xvfcvt_h_s — For each 128-bit lane, convert single-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as half-precision floating point numbers.
__lasx_xvfcvt_s_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as single-precision floating point numbers.
__lasx_xvfcvth_d_s — Convert single precision floating point elements in higher half of every 128-bit vector of a to double precision.
__lasx_xvfcvth_s_h — Convert half precision floating point elements in higher half of every 128-bit vector of a to single precision.
__lasx_xvfcvtl_d_s — Convert single precision floating point elements in lower half of every 128-bit vector of a to double precision.
__lasx_xvfcvtl_s_h — Convert half precision floating point elements in lower half of every 128-bit vector of a to single precision.
__lasx_xvfdiv_d — Divide corresponding double precision floating point elements in a by elements in b.
__lasx_xvfdiv_s — Divide corresponding single precision floating point elements in a by elements in b.
__lasx_xvffint_d_l — Convert signed 64-bit integer elements in a to double-precision floating point numbers.
__lasx_xvffint_d_lu — Convert unsigned 64-bit integer elements in a to double-precision floating point numbers.
__lasx_xvffint_s_l — For each 128-bit lane, convert signed 64-bit integer elements in the corresponding lane of a into the upper half and elements in b into the lower half, as single-precision floating point numbers.
__lasx_xvffint_s_w — Convert signed 32-bit integer elements in a to single-precision floating point numbers.
__lasx_xvffint_s_wu — Convert unsigned 32-bit integer elements in a to single-precision floating point numbers.
__lasx_xvffinth_d_w — Convert signed 32-bit integer elements in higher part of every 128-bit vector of a to double precision floating point numbers.
__lasx_xvffintl_d_w — Convert signed 32-bit integer elements in lower part of every 128-bit vector of a to double precision floating point numbers.
__lasx_xvflogb_d — Compute base-2 logarithm of double precision floating point elements in a.
__lasx_xvflogb_s — Compute base-2 logarithm of single precision floating point elements in a.
__lasx_xvfmadd_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the result in dst.
__lasx_xvfmadd_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the result in dst.
__lasx_xvfmax_d — Compute the maximum (maxNum) of double precision floating point elements in a and b.
__lasx_xvfmax_s — Compute the maximum (maxNum) of single precision floating point elements in a and b.
__lasx_xvfmaxa_d — Compute the maximum (maxNumMag) of double precision floating point elements in a and b, selecting the element with the larger absolute value.
__lasx_xvfmaxa_s — Compute the maximum (maxNumMag) of single precision floating point elements in a and b, selecting the element with the larger absolute value.
__lasx_xvfmin_d — Compute the minimum (minNum) of double precision floating point elements in a and b.
__lasx_xvfmin_s — Compute the minimum (minNum) of single precision floating point elements in a and b.
__lasx_xvfmina_d — Compute the minimum (minNumMag) of double precision floating point elements in a and b, selecting the element with the smaller absolute value.
__lasx_xvfmina_s — Compute the minimum (minNumMag) of single precision floating point elements in a and b, selecting the element with the smaller absolute value.
__lasx_xvfmsub_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the result in dst.
__lasx_xvfmsub_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the result in dst.
__lasx_xvfmul_d — Multiply corresponding double precision floating point elements in a and b.
__lasx_xvfmul_s — Multiply corresponding single precision floating point elements in a and b.
__lasx_xvfnmadd_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the negated result in dst.
__lasx_xvfnmadd_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, accumulate to elements in c and store the negated result in dst.
__lasx_xvfnmsub_d — Compute packed double precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the negated result in dst.
__lasx_xvfnmsub_s — Compute packed single precision floating point FMA(Fused Multiply-Add): multiply elements in a and b, subtract elements in c and store the negated result in dst.
__lasx_xvfrecip_d — Compute reciprocal of double precision floating point elements in a.
__lasx_xvfrecip_s — Compute reciprocal of single precision floating point elements in a.
__lasx_xvfrecipe_d — Compute estimated reciprocal of double precision floating point elements in a.
__lasx_xvfrecipe_s — Compute estimated reciprocal of single precision floating point elements in a.
__lasx_xvfrint_d — Round double-precision floating point elements in a to integers, using current rounding mode specified in fscr, and store as floating point numbers.
__lasx_xvfrint_s — Round single-precision floating point elements in a to integers, using current rounding mode specified in fscr, and store as floating point numbers.
__lasx_xvfrintrm_d — Round double-precision floating point elements in a to integers, rounding towards negative infinity, and store as floating point numbers.
__lasx_xvfrintrm_s — Round single-precision floating point elements in a to integers, rounding towards negative infinity, and store as floating point numbers.
__lasx_xvfrintrne_d — Round double-precision floating point elements in a to integers, rounding towards nearest even, and store as floating point numbers.
__lasx_xvfrintrne_s — Round single-precision floating point elements in a to integers, rounding towards nearest even, and store as floating point numbers.
__lasx_xvfrintrp_d — Round double-precision floating point elements in a to integers, rounding towards positive infinity, and store as floating point numbers.
__lasx_xvfrintrp_s — Round single-precision floating point elements in a to integers, rounding towards positive infinity, and store as floating point numbers.
__lasx_xvfrintrz_d — Round double-precision floating point elements in a to integers, rounding towards zero, and store as floating point numbers.
__lasx_xvfrintrz_s — Round single-precision floating point elements in a to integers, rounding towards zero, and store as floating point numbers.
__lasx_xvfrsqrt_d — Compute reciprocal of square root of double precision floating point elements in a.
__lasx_xvfrsqrt_s — Compute reciprocal of square root of single precision floating point elements in a.
__lasx_xvfrsqrte_d — Compute estimated reciprocal of square root of double precision floating point elements in a.
__lasx_xvfrsqrte_s — Compute estimated reciprocal of square root of single precision floating point elements in a.
__lasx_xvfrstp_b — For each 128-bit lane, find the first negative 8-bit element in b. Write its index into the lane of a selected by the first element of the corresponding lane of c modulo 16, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lasx_xvfrstp_h — For each 128-bit lane, find the first negative 16-bit element in b. Write its index into the lane of a selected by the first element of the corresponding lane of c modulo 8, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lasx_xvfrstpi_b — For each 128-bit lane, find the first negative 8-bit element in b. Write its index into the lane of a selected by imm modulo 16, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lasx_xvfrstpi_h — For each 128-bit lane, find the first negative 16-bit element in b. Write its index into the lane of a selected by imm modulo 8, or write the maximum valid index plus one if no such element exists. Other elements of a remain unchanged.
__lasx_xvfscaleb_d — Compute IEEE 754 scaleB (multiply by 2^b) of double precision floating point elements in a using integer exponents in b. Currently undocumented.
__lasx_xvfscaleb_s — Compute IEEE 754 scaleB (multiply by 2^b) of single precision floating point elements in a using integer exponents in b. Currently undocumented.
__lasx_xvfsqrt_d — Compute square root of double precision floating point elements in a.
__lasx_xvfsqrt_s — Compute square root of single precision floating point elements in a.
__lasx_xvfsub_d — Subtract corresponding double precision floating point elements in b from elements in a.
__lasx_xvfsub_s — Subtract corresponding single precision floating point elements in b from elements in a.
__lasx_xvftint_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, using current rounding mode specified in fscr.
__lasx_xvftint_lu_d — Convert double-precision floating point elements in a to unsigned 64-bit integer, using current rounding mode specified in fscr.
__lasx_xvftint_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, using current rounding mode specified in fscr.
__lasx_xvftint_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, using current rounding mode specified in fscr.
__lasx_xvftint_wu_s — Convert single-precision floating point elements in a to unsigned 32-bit integer, using current rounding mode specified in fscr.
__lasx_xvftinth_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, using current rounding mode specified in fscr.
__lasx_xvftintl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, using current rounding mode specified in fscr.
__lasx_xvftintrm_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards negative infinity.
__lasx_xvftintrm_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards negative infinity.
__lasx_xvftintrm_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards negative infinity.
__lasx_xvftintrmh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards negative infinity.
__lasx_xvftintrml_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards negative infinity.
__lasx_xvftintrne_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards nearest even.
__lasx_xvftintrne_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards nearest even.
__lasx_xvftintrne_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards nearest even.
__lasx_xvftintrneh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards nearest even.
__lasx_xvftintrnel_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards nearest even.
__lasx_xvftintrp_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards positive infinity.
__lasx_xvftintrp_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards positive infinity.
__lasx_xvftintrp_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards positive infinity.
__lasx_xvftintrph_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards positive infinity.
__lasx_xvftintrpl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards positive infinity.
__lasx_xvftintrz_l_d — Convert double-precision floating point elements in a to signed 64-bit integer, rounding towards zero.
__lasx_xvftintrz_lu_d — Convert double-precision floating point elements in a to unsigned 64-bit integer, rounding towards zero.
__lasx_xvftintrz_w_d — For each 128-bit lane, convert double-precision floating point elements in the corresponding lane of a into the upper half and elements in b into the lower half, as signed 32-bit integers, rounding towards zero.
__lasx_xvftintrz_w_s — Convert single-precision floating point elements in a to signed 32-bit integer, rounding towards zero.
__lasx_xvftintrz_wu_s — Convert single-precision floating point elements in a to unsigned 32-bit integer, rounding towards zero.
__lasx_xvftintrzh_l_s — Convert single-precision floating point elements in higher part of every 128-bit vector of a to signed 64-bit integer, rounding towards zero.
__lasx_xvftintrzl_l_s — Convert single-precision floating point elements in lower part of every 128-bit vector of a to signed 64-bit integer, rounding towards zero.

LASX_H (17)

__lasx_xvhaddw_d_w — Add odd-positioned signed 32-bit elements in a to even-positioned signed 32-bit elements in b, sign-extending both to 64-bit, to get the 64-bit result.
__lasx_xvhaddw_du_wu — Add odd-positioned unsigned 32-bit elements in a to even-positioned unsigned 32-bit elements in b, zero-extending both to 64-bit, to get the 64-bit result.
__lasx_xvhaddw_h_b — Add odd-positioned signed 8-bit elements in a to even-positioned signed 8-bit elements in b, sign-extending both to 16-bit, to get the 16-bit result.
__lasx_xvhaddw_hu_bu — Add odd-positioned unsigned 8-bit elements in a to even-positioned unsigned 8-bit elements in b, zero-extending both to 16-bit, to get the 16-bit result.
__lasx_xvhaddw_q_d — Add odd-positioned signed 64-bit elements in a to even-positioned signed 64-bit elements in b, sign-extending both to 128-bit, to get the 128-bit result.
__lasx_xvhaddw_qu_du — Add odd-positioned unsigned 64-bit elements in a to even-positioned unsigned 64-bit elements in b, zero-extending both to 128-bit, to get the 128-bit result.
__lasx_xvhaddw_w_h — Add odd-positioned signed 16-bit elements in a to even-positioned signed 16-bit elements in b, sign-extending both to 32-bit, to get the 32-bit result.
__lasx_xvhaddw_wu_hu — Add odd-positioned unsigned 16-bit elements in a to even-positioned unsigned 16-bit elements in b, zero-extending both to 32-bit, to get the 32-bit result.
__lasx_xvhseli_d — Select each double word of dst from an adjacent pair in a according to imm: bits 0 and 1 choose the sources for D[0] and D[1] from {a.D[0], a.D[1]}, and bits 2 and 3 choose the sources for D[2] and D[3] from {a.D[2], a.D[3]}.
__lasx_xvhsubw_d_w — Subtract even-positioned signed 32-bit elements in b from odd-positioned signed 32-bit elements in a, sign-extending both to 64-bit, to get the 64-bit result.
__lasx_xvhsubw_du_wu — Subtract even-positioned unsigned 32-bit elements in b from odd-positioned unsigned 32-bit elements in a, zero-extending both to 64-bit, to get the 64-bit result.
__lasx_xvhsubw_h_b — Subtract even-positioned signed 8-bit elements in b from odd-positioned signed 8-bit elements in a, sign-extending both to 16-bit, to get the 16-bit result.
__lasx_xvhsubw_hu_bu — Subtract even-positioned unsigned 8-bit elements in b from odd-positioned unsigned 8-bit elements in a, zero-extending both to 16-bit, to get the 16-bit result.
__lasx_xvhsubw_q_d — Subtract even-positioned signed 64-bit elements in b from odd-positioned signed 64-bit elements in a, sign-extending both to 128-bit, to get the 128-bit result.
__lasx_xvhsubw_qu_du — Subtract even-positioned unsigned 64-bit elements in b from odd-positioned unsigned 64-bit elements in a, zero-extending both to 128-bit, to get the 128-bit result.
__lasx_xvhsubw_w_h — Subtract even-positioned signed 16-bit elements in b from odd-positioned signed 16-bit elements in a, sign-extending both to 32-bit, to get the 32-bit result.
__lasx_xvhsubw_wu_hu — Subtract even-positioned unsigned 16-bit elements in b from odd-positioned unsigned 16-bit elements in a, zero-extending both to 32-bit, to get the 32-bit result.

LASX_I (18)

__lasx_insert_128_hi — Replace the high 128-bit half of a with the integer vector b.
__lasx_insert_128_hi_d — Replace the high 128-bit half of a with the double precision vector b.
__lasx_insert_128_hi_s — Replace the high 128-bit half of a with the single precision vector b.
__lasx_insert_128_lo — Replace the low 128-bit half of a with the integer vector b.
__lasx_insert_128_lo_d — Replace the low 128-bit half of a with the double precision vector b.
__lasx_insert_128_lo_s — Replace the low 128-bit half of a with the single precision vector b.
__lasx_xvilvh_b — For each 128-bit lane, interleave the 8-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvh_d — For each 128-bit lane, interleave the 64-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvh_h — For each 128-bit lane, interleave the 16-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvh_w — For each 128-bit lane, interleave the 32-bit elements in the upper half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvl_b — For each 128-bit lane, interleave the 8-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvl_d — For each 128-bit lane, interleave the 64-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvl_h — For each 128-bit lane, interleave the 16-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvilvl_w — For each 128-bit lane, interleave the 32-bit elements in the lower half of that lane from a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvinsgr2vr_d — Insert the low 64 bits of b into lane imm of a; the other lanes are unchanged.
__lasx_xvinsgr2vr_w — Insert the low 32 bits of b into lane imm of a; the other lanes are unchanged.
__lasx_xvinsve0_d — Insert the first 64-bit element of b into lane imm of a; the other lanes are unchanged.
__lasx_xvinsve0_w — Insert the first 32-bit element of b into lane imm of a; the other lanes are unchanged.

LASX_L (7)

__lasx_xvld — Read whole vector from memory address addr + offset, save the data into dst. Address misalignment does not raise an exception. Note that you can use this intrinsic to load floating point vectors, even though the return type represents integer vectors.
__lasx_xvldi — Initialize dst using predefined patterns:
__lasx_xvldrepl_b — Read 8-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvldrepl_d — Read 64-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvldrepl_h — Read 16-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvldrepl_w — Read 32-bit data from memory address addr + offset, replicate the data to all vector lanes and save into dst. Address misalignment does not raise an exception. The offset operand is a byte offset, matching the assembly immediate; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvldx — Read whole vector from memory address addr + offset, save the data into dst. Address misalignment does not raise an exception. Note that you can use this intrinsic to load floating point vectors, even though the return type represents integer vectors.

LASX_M (115)

__lasx_xvmadd_b — Multiply 8-bit elements in b and c, add the low 8 bits of the product to elements in a, save the result in dst.
__lasx_xvmadd_d — Multiply 64-bit elements in b and c, add the low 64 bits of the product to elements in a, save the result in dst.
__lasx_xvmadd_h — Multiply 16-bit elements in b and c, add the low 16 bits of the product to elements in a, save the result in dst.
__lasx_xvmadd_w — Multiply 32-bit elements in b and c, add the low 32 bits of the product to elements in a, save the result in dst.
__lasx_xvmaddwev_d_w — Multiply the even-positioned signed 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwev_d_wu — Multiply the even-positioned unsigned 32-bit elements in b and the corresponding unsigned 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwev_d_wu_w — Multiply the even-positioned unsigned 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwev_h_b — Multiply the even-positioned signed 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwev_h_bu — Multiply the even-positioned unsigned 8-bit elements in b and the corresponding unsigned 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwev_h_bu_b — Multiply the even-positioned unsigned 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwev_q_d — Multiply the even-positioned signed 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwev_q_du — Multiply the even-positioned unsigned 64-bit elements in b and the corresponding unsigned 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwev_q_du_d — Multiply the even-positioned unsigned 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwev_w_h — Multiply the even-positioned signed 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmaddwev_w_hu — Multiply the even-positioned unsigned 16-bit elements in b and the corresponding unsigned 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmaddwev_w_hu_h — Multiply the even-positioned unsigned 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmaddwod_d_w — Multiply the odd-positioned signed 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwod_d_wu — Multiply the odd-positioned unsigned 32-bit elements in b and the corresponding unsigned 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwod_d_wu_w — Multiply the odd-positioned unsigned 32-bit elements in b and the corresponding signed 32-bit elements in c, extending both to 64-bit, and add the product to the 64-bit elements in a.
__lasx_xvmaddwod_h_b — Multiply the odd-positioned signed 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwod_h_bu — Multiply the odd-positioned unsigned 8-bit elements in b and the corresponding unsigned 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwod_h_bu_b — Multiply the odd-positioned unsigned 8-bit elements in b and the corresponding signed 8-bit elements in c, extending both to 16-bit, and add the product to the 16-bit elements in a.
__lasx_xvmaddwod_q_d — Multiply the odd-positioned signed 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwod_q_du — Multiply the odd-positioned unsigned 64-bit elements in b and the corresponding unsigned 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwod_q_du_d — Multiply the odd-positioned unsigned 64-bit elements in b and the corresponding signed 64-bit elements in c, extending both to 128-bit, and add the product to the 128-bit elements in a.
__lasx_xvmaddwod_w_h — Multiply the odd-positioned signed 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmaddwod_w_hu — Multiply the odd-positioned unsigned 16-bit elements in b and the corresponding unsigned 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmaddwod_w_hu_h — Multiply the odd-positioned unsigned 16-bit elements in b and the corresponding signed 16-bit elements in c, extending both to 32-bit, and add the product to the 32-bit elements in a.
__lasx_xvmax_b — Compute elementwise maximum for corresponding signed 8-bit elements in a and b.
__lasx_xvmax_bu — Compute elementwise maximum for corresponding unsigned 8-bit elements in a and b.
__lasx_xvmax_d — Compute elementwise maximum for corresponding signed 64-bit elements in a and b.
__lasx_xvmax_du — Compute elementwise maximum for corresponding unsigned 64-bit elements in a and b.
__lasx_xvmax_h — Compute elementwise maximum for corresponding signed 16-bit elements in a and b.
__lasx_xvmax_hu — Compute elementwise maximum for corresponding unsigned 16-bit elements in a and b.
__lasx_xvmax_w — Compute elementwise maximum for corresponding signed 32-bit elements in a and b.
__lasx_xvmax_wu — Compute elementwise maximum for corresponding unsigned 32-bit elements in a and b.
__lasx_xvmaxi_b — Compute elementwise maximum for signed 8-bit elements in a and the sign-extended imm.
__lasx_xvmaxi_bu — Compute elementwise maximum for unsigned 8-bit elements in a and the zero-extended imm.
__lasx_xvmaxi_d — Compute elementwise maximum for signed 64-bit elements in a and the sign-extended imm.
__lasx_xvmaxi_du — Compute elementwise maximum for unsigned 64-bit elements in a and the zero-extended imm.
__lasx_xvmaxi_h — Compute elementwise maximum for signed 16-bit elements in a and the sign-extended imm.
__lasx_xvmaxi_hu — Compute elementwise maximum for unsigned 16-bit elements in a and the zero-extended imm.
__lasx_xvmaxi_w — Compute elementwise maximum for signed 32-bit elements in a and the sign-extended imm.
__lasx_xvmaxi_wu — Compute elementwise maximum for unsigned 32-bit elements in a and the zero-extended imm.
__lasx_xvmepatmsk_v — Compute an 8-bit pattern selected by mode (0: repeating 0..3; 1: 0..3 shifted by 1 for each group; 2: 4..7 shifted by 1 for each group; 3: 0..15), then add uimm5 to each byte element.
__lasx_xvmin_b — Compute elementwise minimum for corresponding signed 8-bit elements in a and b.
__lasx_xvmin_bu — Compute elementwise minimum for corresponding unsigned 8-bit elements in a and b.
__lasx_xvmin_d — Compute elementwise minimum for corresponding signed 64-bit elements in a and b.
__lasx_xvmin_du — Compute elementwise minimum for corresponding unsigned 64-bit elements in a and b.
__lasx_xvmin_h — Compute elementwise minimum for corresponding signed 16-bit elements in a and b.
__lasx_xvmin_hu — Compute elementwise minimum for corresponding unsigned 16-bit elements in a and b.
__lasx_xvmin_w — Compute elementwise minimum for corresponding signed 32-bit elements in a and b.
__lasx_xvmin_wu — Compute elementwise minimum for corresponding unsigned 32-bit elements in a and b.
__lasx_xvmini_b — Compute elementwise minimum for signed 8-bit elements in a and the sign-extended imm.
__lasx_xvmini_bu — Compute elementwise minimum for unsigned 8-bit elements in a and the zero-extended imm.
__lasx_xvmini_d — Compute elementwise minimum for signed 64-bit elements in a and the sign-extended imm.
__lasx_xvmini_du — Compute elementwise minimum for unsigned 64-bit elements in a and the zero-extended imm.
__lasx_xvmini_h — Compute elementwise minimum for signed 16-bit elements in a and the sign-extended imm.
__lasx_xvmini_hu — Compute elementwise minimum for unsigned 16-bit elements in a and the zero-extended imm.
__lasx_xvmini_w — Compute elementwise minimum for signed 32-bit elements in a and the sign-extended imm.
__lasx_xvmini_wu — Compute elementwise minimum for unsigned 32-bit elements in a and the zero-extended imm.
__lasx_xvmod_b — Compute the remainder of each signed 8-bit element in a divided by the corresponding element in b.
__lasx_xvmod_bu — Compute the remainder of each unsigned 8-bit element in a divided by the corresponding element in b.
__lasx_xvmod_d — Compute the remainder of each signed 64-bit element in a divided by the corresponding element in b.
__lasx_xvmod_du — Compute the remainder of each unsigned 64-bit element in a divided by the corresponding element in b.
__lasx_xvmod_h — Compute the remainder of each signed 16-bit element in a divided by the corresponding element in b.
__lasx_xvmod_hu — Compute the remainder of each unsigned 16-bit element in a divided by the corresponding element in b.
__lasx_xvmod_w — Compute the remainder of each signed 32-bit element in a divided by the corresponding element in b.
__lasx_xvmod_wu — Compute the remainder of each unsigned 32-bit element in a divided by the corresponding element in b.
__lasx_xvmskgez_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is greater than or equal to zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmskltz_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmskltz_d — For each 128-bit lane, for each 64-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmskltz_h — For each 128-bit lane, for each 16-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmskltz_w — For each 128-bit lane, for each 32-bit element in a, set the bit at that element's index within the lane to one if the element is less than zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmsknz_b — For each 128-bit lane, for each 8-bit element in a, set the bit at that element's index within the lane to one if the element is non-zero, otherwise zero; the remaining bits of the lane are zero.
__lasx_xvmsub_b — Multiply 8-bit elements in b and c, subtract the low 8 bits of the product from elements in a, save the result in dst.
__lasx_xvmsub_d — Multiply 64-bit elements in b and c, subtract the low 64 bits of the product from elements in a, save the result in dst.
__lasx_xvmsub_h — Multiply 16-bit elements in b and c, subtract the low 16 bits of the product from elements in a, save the result in dst.
__lasx_xvmsub_w — Multiply 32-bit elements in b and c, subtract the low 32 bits of the product from elements in a, save the result in dst.
__lasx_xvmuh_b — Multiply corresponding signed 8-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_bu — Multiply corresponding unsigned 8-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_d — Multiply corresponding signed 64-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_du — Multiply corresponding unsigned 64-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_h — Multiply corresponding signed 16-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_hu — Multiply corresponding unsigned 16-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_w — Multiply corresponding signed 32-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmuh_wu — Multiply corresponding unsigned 32-bit elements in a and b, save the upper half of the double-width product in dst.
__lasx_xvmul_b — Multiply corresponding 8-bit elements in a and b, save the result in dst.
__lasx_xvmul_d — Multiply corresponding 64-bit elements in a and b, save the result in dst.
__lasx_xvmul_h — Multiply corresponding 16-bit elements in a and b, save the result in dst.
__lasx_xvmul_w — Multiply corresponding 32-bit elements in a and b, save the result in dst.
__lasx_xvmulwev_d_w — Multiply the even-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwev_d_wu — Multiply the even-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwev_d_wu_w — Multiply the even-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwev_h_b — Multiply the even-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwev_h_bu — Multiply the even-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwev_h_bu_b — Multiply the even-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwev_q_d — Multiply the even-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwev_q_du — Multiply the even-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwev_q_du_d — Multiply the even-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwev_w_h — Multiply the even-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvmulwev_w_hu — Multiply the even-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvmulwev_w_hu_h — Multiply the even-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvmulwod_d_w — Multiply the odd-positioned signed 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwod_d_wu — Multiply the odd-positioned unsigned 32-bit elements in a and the corresponding unsigned 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwod_d_wu_w — Multiply the odd-positioned unsigned 32-bit elements in a and the corresponding signed 32-bit elements in b, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvmulwod_h_b — Multiply the odd-positioned signed 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwod_h_bu — Multiply the odd-positioned unsigned 8-bit elements in a and the corresponding unsigned 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwod_h_bu_b — Multiply the odd-positioned unsigned 8-bit elements in a and the corresponding signed 8-bit elements in b, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvmulwod_q_d — Multiply the odd-positioned signed 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwod_q_du — Multiply the odd-positioned unsigned 64-bit elements in a and the corresponding unsigned 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwod_q_du_d — Multiply the odd-positioned unsigned 64-bit elements in a and the corresponding signed 64-bit elements in b, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvmulwod_w_h — Multiply the odd-positioned signed 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvmulwod_w_hu — Multiply the odd-positioned unsigned 16-bit elements in a and the corresponding unsigned 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvmulwod_w_hu_h — Multiply the odd-positioned unsigned 16-bit elements in a and the corresponding signed 16-bit elements in b, extending both to 32-bit, and save the 32-bit result in dst.

LASX_N (6)

__lasx_xvneg_b — Negate 8-bit elements in a and save the result in dst.
__lasx_xvneg_d — Negate 64-bit elements in a and save the result in dst.
__lasx_xvneg_h — Negate 16-bit elements in a and save the result in dst.
__lasx_xvneg_w — Negate 32-bit elements in a and save the result in dst.
__lasx_xvnor_v — Compute bitwise NOR (~(a | b)) of elements in a and b.
__lasx_xvnori_b — Compute bitwise NOR (~(a | imm)) of elements in a and imm.

LASX_O (3)

__lasx_xvor_v — Compute bitwise OR of elements in a and b.
__lasx_xvori_b — Compute bitwise OR of elements in a and imm.
__lasx_xvorn_v — Compute bitwise ORN (a | ~b) of elements in a and b.

LASX_P (32)

__lasx_xvpackev_b — Interleave even-positioned 8-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackev_d — Interleave even-positioned 64-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackev_h — Interleave even-positioned 16-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackev_w — Interleave even-positioned 32-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackod_b — Interleave odd-positioned 8-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackod_d — Interleave odd-positioned 64-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackod_h — Interleave odd-positioned 16-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpackod_w — Interleave odd-positioned 32-bit elements of a and b: the element from b is placed at the even output position and the element from a at the following odd position.
__lasx_xvpcnt_b — Count the number of ones (population, popcount) in 8-bit elements in a.
__lasx_xvpcnt_d — Count the number of ones (population, popcount) in 64-bit elements in a.
__lasx_xvpcnt_h — Count the number of ones (population, popcount) in 16-bit elements in a.
__lasx_xvpcnt_w — Count the number of ones (population, popcount) in 32-bit elements in a.
__lasx_xvperm_w — For each word, use the low 3 bits of the corresponding word in b as an index into the eight words of a, and store the result in dst.
__lasx_xvpermi_d — Select four double words from a using imm[1:0], imm[3:2], imm[5:4], and imm[7:6], and store them in dst.
__lasx_xvpermi_q — Select the two quad words of dst from the four quad words of a and b using imm[1:0] and imm[5:4].
__lasx_xvpermi_w — For each 128-bit lane, use imm[1:0] and imm[3:2] to select words 0 and 1 from b, and imm[5:4] and imm[7:6] to select words 2 and 3 from a; store the result in dst.
__lasx_xvpickev_b — For each 128-bit lane, place even-positioned 8-bit elements of b into its lower half and even-positioned 8-bit elements of a into its upper half.
__lasx_xvpickev_d — For each 128-bit lane, place even-positioned 64-bit elements of b into its lower half and even-positioned 64-bit elements of a into its upper half.
__lasx_xvpickev_h — For each 128-bit lane, place even-positioned 16-bit elements of b into its lower half and even-positioned 16-bit elements of a into its upper half.
__lasx_xvpickev_w — For each 128-bit lane, place even-positioned 32-bit elements of b into its lower half and even-positioned 32-bit elements of a into its upper half.
__lasx_xvpickod_b — For each 128-bit lane, place odd-positioned 8-bit elements of b into its lower half and odd-positioned 8-bit elements of a into its upper half.
__lasx_xvpickod_d — For each 128-bit lane, place odd-positioned 64-bit elements of b into its lower half and odd-positioned 64-bit elements of a into its upper half.
__lasx_xvpickod_h — For each 128-bit lane, place odd-positioned 16-bit elements of b into its lower half and odd-positioned 16-bit elements of a into its upper half.
__lasx_xvpickod_w — For each 128-bit lane, place odd-positioned 32-bit elements of b into its lower half and odd-positioned 32-bit elements of a into its upper half.
__lasx_xvpickve2gr_d — Pick the 64-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lasx_xvpickve2gr_du — Pick the 64-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.
__lasx_xvpickve2gr_w — Pick the 32-bit element at lane idx from a, sign-extend it to the GPR width, and store it in dst.
__lasx_xvpickve2gr_wu — Pick the 32-bit element at lane idx from a, zero-extend it to the GPR width, and store it in dst.
__lasx_xvpickve_d — Copy one 64-bit lane from a specified by imm to the first lane of dst, and set the other lanes to zero.
__lasx_xvpickve_d_f — Copy one 64-bit lane from a specified by imm to the first lane of dst, and set the other lanes to zero.
__lasx_xvpickve_w — Copy one 32-bit lane from a specified by imm to the first lane of dst, and set the other lanes to zero.
__lasx_xvpickve_w_f — Copy one 32-bit lane from a specified by imm to the first lane of dst, and set the other lanes to zero.

LASX_R (29)

__lasx_xvrepl128vei_b — For each 128-bit lane, repeat that lane's element idx to fill the same lane.
__lasx_xvrepl128vei_d — For each 128-bit lane, repeat that lane's element idx to fill the same lane.
__lasx_xvrepl128vei_h — For each 128-bit lane, repeat that lane's element idx to fill the same lane.
__lasx_xvrepl128vei_w — For each 128-bit lane, repeat that lane's element idx to fill the same lane.
__lasx_xvreplgr2vr_b — Broadcast the low 8 bits of val to all lanes of dst.
__lasx_xvreplgr2vr_d — Broadcast the low 64 bits of val to all lanes of dst.
__lasx_xvreplgr2vr_h — Broadcast the low 16 bits of val to all lanes of dst.
__lasx_xvreplgr2vr_w — Broadcast the low 32 bits of val to all lanes of dst.
__lasx_xvrepli_b — Repeat imm to fill whole vector.
__lasx_xvrepli_d — Repeat imm to fill whole vector.
__lasx_xvrepli_h — Repeat imm to fill whole vector.
__lasx_xvrepli_w — Repeat imm to fill whole vector.
__lasx_xvreplve0_b — Repeat the first 8-bit lane from a to all lanes of dst.
__lasx_xvreplve0_d — Repeat the first 64-bit lane from a to all lanes of dst.
__lasx_xvreplve0_h — Repeat the first 16-bit lane from a to all lanes of dst.
__lasx_xvreplve0_q — Repeat the first 128-bit lane from a to all lanes of dst.
__lasx_xvreplve0_w — Repeat the first 32-bit lane from a to all lanes of dst.
__lasx_xvreplve_b — For each 128-bit lane, repeat that lane's element idx (index modulo 16) to fill the same lane.
__lasx_xvreplve_d — For each 128-bit lane, repeat that lane's element idx (index modulo 2) to fill the same lane.
__lasx_xvreplve_h — For each 128-bit lane, repeat that lane's element idx (index modulo 8) to fill the same lane.
__lasx_xvreplve_w — For each 128-bit lane, repeat that lane's element idx (index modulo 4) to fill the same lane.
__lasx_xvrotr_b — Rotate right each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvrotr_d — Rotate right each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvrotr_h — Rotate right each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvrotr_w — Rotate right each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvrotri_b — Rotate right the unsigned 8-bit elements in a by imm, store the result to dst.
__lasx_xvrotri_d — Rotate right the unsigned 64-bit elements in a by imm, store the result to dst.
__lasx_xvrotri_h — Rotate right the unsigned 16-bit elements in a by imm, store the result to dst.
__lasx_xvrotri_w — Rotate right the unsigned 32-bit elements in a by imm, store the result to dst.

LASX_S (237)

__lasx_xvsadd_b — Saturating add corresponding signed 8-bit elements in a and b, store the result to dst.
__lasx_xvsadd_bu — Saturating add corresponding unsigned 8-bit elements in a and b, store the result to dst.
__lasx_xvsadd_d — Saturating add corresponding signed 64-bit elements in a and b, store the result to dst.
__lasx_xvsadd_du — Saturating add corresponding unsigned 64-bit elements in a and b, store the result to dst.
__lasx_xvsadd_h — Saturating add corresponding signed 16-bit elements in a and b, store the result to dst.
__lasx_xvsadd_hu — Saturating add corresponding unsigned 16-bit elements in a and b, store the result to dst.
__lasx_xvsadd_w — Saturating add corresponding signed 32-bit elements in a and b, store the result to dst.
__lasx_xvsadd_wu — Saturating add corresponding unsigned 32-bit elements in a and b, store the result to dst.
__lasx_xvsat_b — Saturate each signed 8-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_bu — Saturate each unsigned 8-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_d — Saturate each signed 64-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_du — Saturate each unsigned 64-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_h — Saturate each signed 16-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_hu — Saturate each unsigned 16-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_w — Saturate each signed 32-bit element in a to the number of significant bits specified by imm.
__lasx_xvsat_wu — Saturate each unsigned 32-bit element in a to the number of significant bits specified by imm.
__lasx_xvseq_b — Compare the 8-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lasx_xvseq_d — Compare the 64-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lasx_xvseq_h — Compare the 16-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lasx_xvseq_w — Compare the 32-bit elements in a and b, store all-ones to dst if equal, zero otherwise.
__lasx_xvseqi_b — Compare the 8-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lasx_xvseqi_d — Compare the 64-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lasx_xvseqi_h — Compare the 16-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lasx_xvseqi_w — Compare the 32-bit elements in a and the sign-extended imm, store all-ones to dst if equal, zero otherwise.
__lasx_xvshuf4i_b — For each group of four consecutive 8-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lasx_xvshuf4i_d — For each 128-bit lane, select two 64-bit elements from the four elements formed by the corresponding lanes of a and b using imm[1:0] and imm[3:2], save the result to dst.
__lasx_xvshuf4i_h — For each group of four consecutive 16-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lasx_xvshuf4i_w — For each group of four consecutive 32-bit elements in a, permute the group according to the four 2-bit fields of imm, save the result to dst.
__lasx_xvshuf_b — For each 128-bit lane, shuffle bytes from a and b using the low 5 bits of the indices from the corresponding lane of c.
__lasx_xvshuf_d — For each 128-bit lane, shuffle 64-bit elements from b and c using the low 2 bits of the indices from the corresponding lane of a, and save the result to dst.
__lasx_xvshuf_h — For each 128-bit lane, shuffle 16-bit elements from b and c using the low 4 bits of the indices from the corresponding lane of a, and save the result to dst.
__lasx_xvshuf_w — For each 128-bit lane, shuffle 32-bit elements from b and c using the low 3 bits of the indices from the corresponding lane of a, and save the result to dst.
__lasx_xvsigncov_b — If the 8-bit element in a equals to zero, set the result to zero. If the signed 8-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lasx_xvsigncov_d — If the 64-bit element in a equals to zero, set the result to zero. If the signed 64-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lasx_xvsigncov_h — If the 16-bit element in a equals to zero, set the result to zero. If the signed 16-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lasx_xvsigncov_w — If the 32-bit element in a equals to zero, set the result to zero. If the signed 32-bit element in a is positive, copy element in b to result. Otherwise, copy negated element in b to result. If a and b are the same vectors, it is equivalent to computing absolute value.
__lasx_xvsle_b — Compare the signed 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_bu — Compare the unsigned 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_d — Compare the signed 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_du — Compare the unsigned 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_h — Compare the signed 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_hu — Compare the unsigned 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_w — Compare the signed 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvsle_wu — Compare the unsigned 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than or equal to b, zero otherwise.
__lasx_xvslei_b — Compare the signed 8-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_bu — Compare the unsigned 8-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_d — Compare the signed 64-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_du — Compare the unsigned 64-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_h — Compare the signed 16-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_hu — Compare the unsigned 16-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_w — Compare the signed 32-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvslei_wu — Compare the unsigned 32-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than or equal to imm, zero otherwise.
__lasx_xvsll_b — Logical left shift each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvsll_d — Logical left shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvsll_h — Logical left shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvsll_w — Logical left shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvslli_b — Logical left shift the unsigned 8-bit elements in a by imm, store the result to dst.
__lasx_xvslli_d — Logical left shift the unsigned 64-bit elements in a by imm, store the result to dst.
__lasx_xvslli_h — Logical left shift the unsigned 16-bit elements in a by imm, store the result to dst.
__lasx_xvslli_w — Logical left shift the unsigned 32-bit elements in a by imm, store the result to dst.
__lasx_xvsllwil_d_w — For each 128-bit lane, sign-extend and shift the 32-bit elements in the lower part of that lane by imm to 64-bit result.
__lasx_xvsllwil_du_wu — For each 128-bit lane, zero-extend and shift the 32-bit elements in the lower part of that lane by imm to 64-bit result.
__lasx_xvsllwil_h_b — For each 128-bit lane, sign-extend and shift the 8-bit elements in the lower part of that lane by imm to 16-bit result.
__lasx_xvsllwil_hu_bu — For each 128-bit lane, zero-extend and shift the 8-bit elements in the lower part of that lane by imm to 16-bit result.
__lasx_xvsllwil_w_h — For each 128-bit lane, sign-extend and shift the 16-bit elements in the lower part of that lane by imm to 32-bit result.
__lasx_xvsllwil_wu_hu — For each 128-bit lane, zero-extend and shift the 16-bit elements in the lower part of that lane by imm to 32-bit result.
__lasx_xvslt_b — Compare the signed 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_bu — Compare the unsigned 8-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_d — Compare the signed 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_du — Compare the unsigned 64-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_h — Compare the signed 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_hu — Compare the unsigned 16-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_w — Compare the signed 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslt_wu — Compare the unsigned 32-bit elements in a and b, store all-ones to dst if corresponding element in a is less than b, zero otherwise.
__lasx_xvslti_b — Compare the signed 8-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_bu — Compare the unsigned 8-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_d — Compare the signed 64-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_du — Compare the unsigned 64-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_h — Compare the signed 16-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_hu — Compare the unsigned 16-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_w — Compare the signed 32-bit elements in a and the sign-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvslti_wu — Compare the unsigned 32-bit elements in a and the zero-extended imm, store all-ones to dst if corresponding element in a is less than imm, zero otherwise.
__lasx_xvsra_b — Arithmetic right shift each signed 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvsra_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvsra_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvsra_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvsrai_b — Arithmetic right shift the signed 8-bit elements in a by imm, store the result to dst.
__lasx_xvsrai_d — Arithmetic right shift the signed 64-bit elements in a by imm, store the result to dst.
__lasx_xvsrai_h — Arithmetic right shift the signed 16-bit elements in a by imm, store the result to dst.
__lasx_xvsrai_w — Arithmetic right shift the signed 32-bit elements in a by imm, store the result to dst.
__lasx_xvsran_b_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsran_h_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsran_w_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrani_b_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrani_d_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lasx_xvsrani_h_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrani_w_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrar_b — Arithmetic right shift with rounding each signed 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvsrar_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvsrar_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvsrar_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvsrari_b — Arithmetic right shift (with rounding) the signed 8-bit elements in a by imm, store the result to dst.
__lasx_xvsrari_d — Arithmetic right shift (with rounding) the signed 64-bit elements in a by imm, store the result to dst.
__lasx_xvsrari_h — Arithmetic right shift (with rounding) the signed 16-bit elements in a by imm, store the result to dst.
__lasx_xvsrari_w — Arithmetic right shift (with rounding) the signed 32-bit elements in a by imm, store the result to dst.
__lasx_xvsrarn_b_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrarn_h_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrarn_w_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrarni_b_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrarni_d_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lasx_xvsrarni_h_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrarni_w_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrl_b — Logical right shift each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvsrl_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvsrl_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvsrl_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvsrli_b — Logical right shift the unsigned 8-bit elements in a by imm, store the result to dst.
__lasx_xvsrli_d — Logical right shift the unsigned 64-bit elements in a by imm, store the result to dst.
__lasx_xvsrli_h — Logical right shift the unsigned 16-bit elements in a by imm, store the result to dst.
__lasx_xvsrli_w — Logical right shift the unsigned 32-bit elements in a by imm, store the result to dst.
__lasx_xvsrln_b_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrln_h_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrln_w_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlni_b_h — Logical right shift the unsigned 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlni_d_q — Logical right shift the unsigned 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lasx_xvsrlni_h_w — Logical right shift the unsigned 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlni_w_d — Logical right shift the unsigned 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlr_b — Logical right shift with rounding each unsigned 8-bit element in a by the corresponding element of b modulo 8, store the result in dst.
__lasx_xvsrlr_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, store the result in dst.
__lasx_xvsrlr_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, store the result in dst.
__lasx_xvsrlr_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, store the result in dst.
__lasx_xvsrlri_b — Logical right shift (with rounding) the unsigned 8-bit elements in a by imm, store the result to dst.
__lasx_xvsrlri_d — Logical right shift (with rounding) the unsigned 64-bit elements in a by imm, store the result to dst.
__lasx_xvsrlri_h — Logical right shift (with rounding) the unsigned 16-bit elements in a by imm, store the result to dst.
__lasx_xvsrlri_w — Logical right shift (with rounding) the unsigned 32-bit elements in a by imm, store the result to dst.
__lasx_xvsrlrn_b_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlrn_h_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlrn_w_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlrni_b_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, write the lower 8 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlrni_d_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, write the 64-bit results into dst.
__lasx_xvsrlrni_h_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, write the lower 16 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvsrlrni_w_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, write the lower 32 bits of the shifted result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_b_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_bu_h — Arithmetic right shift each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_h_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_hu_w — Arithmetic right shift each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_w_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssran_wu_d — Arithmetic right shift each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_b_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_bu_h — Arithmetic right shift the signed 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_d_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lasx_xvssrani_du_q — Arithmetic right shift the signed 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lasx_xvssrani_h_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_hu_w — Arithmetic right shift the signed 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_w_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrani_wu_d — Arithmetic right shift the signed 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_b_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_bu_h — Arithmetic right shift with rounding each signed 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_h_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_hu_w — Arithmetic right shift with rounding each signed 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_w_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarn_wu_d — Arithmetic right shift with rounding each signed 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_b_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_bu_h — Arithmetic right shift with rounding the signed 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_d_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lasx_xvssrarni_du_q — Arithmetic right shift with rounding the signed 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lasx_xvssrarni_h_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_hu_w — Arithmetic right shift with rounding the signed 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_w_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrarni_wu_d — Arithmetic right shift with rounding the signed 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_b_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_bu_h — Logical right shift each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_h_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_hu_w — Logical right shift each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_w_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrln_wu_d — Logical right shift each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_b_h — Logical right shift the unsigned 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_bu_h — Logical right shift the unsigned 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_d_q — Logical right shift the unsigned 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lasx_xvssrlni_du_q — Logical right shift the unsigned 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lasx_xvssrlni_h_w — Logical right shift the unsigned 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_hu_w — Logical right shift the unsigned 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_w_d — Logical right shift the unsigned 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlni_wu_d — Logical right shift the unsigned 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_b_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to signed 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_bu_h — Logical right shift with rounding each unsigned 16-bit element in a by the corresponding element of b modulo 16, saturate the result to unsigned 8-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_h_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to signed 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_hu_w — Logical right shift with rounding each unsigned 32-bit element in a by the corresponding element of b modulo 32, saturate the result to unsigned 16-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_w_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to signed 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrn_wu_d — Logical right shift with rounding each unsigned 64-bit element in a by the corresponding element of b modulo 64, saturate the result to unsigned 32-bit, write it into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_b_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, saturate the result to signed 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_bu_h — Logical right shift with rounding the unsigned 16-bit elements in a and b by imm, saturate the result to unsigned 8-bit, write the 8-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_d_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, saturate the result to signed 64-bit, write the 64-bit results into dst.
__lasx_xvssrlrni_du_q — Logical right shift with rounding the unsigned 128-bit elements in a and b by imm, saturate the result to unsigned 64-bit, write the 64-bit results into dst.
__lasx_xvssrlrni_h_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, saturate the result to signed 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_hu_w — Logical right shift with rounding the unsigned 32-bit elements in a and b by imm, saturate the result to unsigned 16-bit, write the 16-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_w_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, saturate the result to signed 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssrlrni_wu_d — Logical right shift with rounding the unsigned 64-bit elements in a and b by imm, saturate the result to unsigned 32-bit, write the 32-bit result into the lower half of each 128-bit lane of dst, and zero the upper half.
__lasx_xvssub_b — Saturating subtract corresponding signed 8-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_bu — Saturating subtract corresponding unsigned 8-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_d — Saturating subtract corresponding signed 64-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_du — Saturating subtract corresponding unsigned 64-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_h — Saturating subtract corresponding signed 16-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_hu — Saturating subtract corresponding unsigned 16-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_w — Saturating subtract corresponding signed 32-bit elements in b from elements in a, store the result to dst.
__lasx_xvssub_wu — Saturating subtract corresponding unsigned 32-bit elements in b from elements in a, store the result to dst.
__lasx_xvst — Write whole vector data in data to memory address addr + offset. Address misalignment does not raise an exception.
__lasx_xvstelm_b — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvstelm_d — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvstelm_h — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvstelm_w — Store element lane of data to memory address addr + offset. Address misalignment does not raise an exception. The offset operand is a byte offset; the encoded instruction stores it as a scaled immediate for wider elements.
__lasx_xvstx — Write whole vector data in data to memory address addr + offset. Address misalignment does not raise an exception.
__lasx_xvsub_b — Subtract corresponding 8-bit elements in b from elements in a, save the result in dst.
__lasx_xvsub_d — Subtract corresponding 64-bit elements in b from elements in a, save the result in dst.
__lasx_xvsub_h — Subtract corresponding 16-bit elements in b from elements in a, save the result in dst.
__lasx_xvsub_q — Subtract corresponding 128-bit elements in b from elements in a, save the result in dst.
__lasx_xvsub_w — Subtract corresponding 32-bit elements in b from elements in a, save the result in dst.
__lasx_xvsubi_bu — Subtract the zero-extended imm from each 8-bit element in a, save the result in dst.
__lasx_xvsubi_du — Subtract the zero-extended imm from each 64-bit element in a, save the result in dst.
__lasx_xvsubi_hu — Subtract the zero-extended imm from each 16-bit element in a, save the result in dst.
__lasx_xvsubi_wu — Subtract the zero-extended imm from each 32-bit element in a, save the result in dst.
__lasx_xvsubwev_d_w — Subtract the even-positioned signed 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvsubwev_d_wu — Subtract the even-positioned unsigned 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvsubwev_h_b — Subtract the even-positioned signed 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvsubwev_h_bu — Subtract the even-positioned unsigned 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvsubwev_q_d — Subtract the even-positioned signed 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvsubwev_q_du — Subtract the even-positioned unsigned 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvsubwev_w_h — Subtract the even-positioned signed 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvsubwev_w_hu — Subtract the even-positioned unsigned 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvsubwod_d_w — Subtract the odd-positioned signed 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvsubwod_d_wu — Subtract the odd-positioned unsigned 32-bit elements in b from the corresponding elements in a, extending both to 64-bit, and save the 64-bit result in dst.
__lasx_xvsubwod_h_b — Subtract the odd-positioned signed 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvsubwod_h_bu — Subtract the odd-positioned unsigned 8-bit elements in b from the corresponding elements in a, extending both to 16-bit, and save the 16-bit result in dst.
__lasx_xvsubwod_q_d — Subtract the odd-positioned signed 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvsubwod_q_du — Subtract the odd-positioned unsigned 64-bit elements in b from the corresponding elements in a, extending both to 128-bit, and save the 128-bit result in dst.
__lasx_xvsubwod_w_h — Subtract the odd-positioned signed 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.
__lasx_xvsubwod_w_hu — Subtract the odd-positioned unsigned 16-bit elements in b from the corresponding elements in a, extending both to 32-bit, and save the 32-bit result in dst.

LASX_V (12)

__lasx_vext2xv_d_b — Sign-extend the lowest 4 8-bit elements of a to 64-bit elements.
__lasx_vext2xv_d_h — Sign-extend the lowest 4 16-bit elements of a to 64-bit elements.
__lasx_vext2xv_d_w — Sign-extend the lowest 4 32-bit elements of a to 64-bit elements.
__lasx_vext2xv_du_bu — Zero-extend the lowest 4 8-bit elements of a to 64-bit elements.
__lasx_vext2xv_du_hu — Zero-extend the lowest 4 16-bit elements of a to 64-bit elements.
__lasx_vext2xv_du_wu — Zero-extend the lowest 4 32-bit elements of a to 64-bit elements.
__lasx_vext2xv_h_b — Sign-extend the lowest 16 8-bit elements of a to 16-bit elements.
__lasx_vext2xv_hu_bu — Zero-extend the lowest 16 8-bit elements of a to 16-bit elements.
__lasx_vext2xv_w_b — Sign-extend the lowest 8 8-bit elements of a to 32-bit elements.
__lasx_vext2xv_w_h — Sign-extend the lowest 8 16-bit elements of a to 32-bit elements.
__lasx_vext2xv_wu_bu — Zero-extend the lowest 8 8-bit elements of a to 32-bit elements.
__lasx_vext2xv_wu_hu — Zero-extend the lowest 8 16-bit elements of a to 32-bit elements.

LASX_X (2)

__lasx_xvxor_v — Compute bitwise XOR of elements in a and b.
__lasx_xvxori_b — Compute bitwise XOR of elements in a and imm.

A (28)

adc.b — Add 8-bit values in rj and rk with carry (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
adc.d — Add 64-bit values in rj and rk with carry (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
adc.h — Add 16-bit values in rj and rk with carry (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
adc.w — Add 32-bit values in rj and rk with carry (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
addu12i.d — Add sign-extended 5-bit immediate left-shifted by 12 to 64-bit value in rj and store the result in rd.
addu12i.w — Add sign-extended 5-bit immediate left-shifted by 12 to unsigned 32-bit value in rj, sign-extend the 32-bit result to 64-bit and store in rd.
armadc.w — ARM-style add with carry (32-bit): conditionally add values in rj and rk with carry (C in ARMFLAGS). Update ARMFLAGS (C, V, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armadd.w — ARM-style add (32-bit): conditionally add values in rj and rk. Update ARMFLAGS (C, V, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armand.w — ARM-style bitwise AND (32-bit): conditionally AND values in rj and rk. Update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armmfflag — Move from ARMFLAGS: read selected ARM flags (N, Z, C, V) from ARMFLAGS as determined by mask, pack them into rd.
armmov.d — ARM-style move (with flag update): conditionally test the 64-bit value in rj and update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armmov.w — ARM-style move (with flag update): conditionally test the 32-bit value in rj and update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armmove — ARM-style conditional move: if the ARM condition holds, copy the value in rj to rd. ARMFLAGS are not updated.
armmtflag — Move to ARMFLAGS: write selected ARM flags (N, Z, C, V) in ARMFLAGS from the corresponding bit positions in rd, as determined by mask.
armnot.w — ARM-style bitwise NOT (32-bit): conditionally bitwise NOT the value in rj. Update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armor.w — ARM-style bitwise OR (32-bit): conditionally OR values in rj and rk. Update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armrotr.w — ARM-style rotate right (32-bit): conditionally rotate value in rj right by amount in rk (masked to 8 bits, rotate modulo 32). Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armrotri.w — ARM-style rotate right immediate (32-bit): conditionally rotate value in rj right by imm. Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armrrx.w — ARM-style rotate right extended (32-bit): conditionally rotate the value in rj and C (in ARMFLAGS) together as a 33-bit ring right by 1. Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsbc.w — ARM-style subtract with borrow (32-bit): conditionally subtract value in rk from rj with borrow (C in ARMFLAGS). Update ARMFLAGS (C, V, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsll.w — ARM-style logical shift left (32-bit): conditionally shift value in rj left by amount in rk (masked to 8 bits). Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armslli.w — ARM-style logical shift left immediate (32-bit): conditionally shift value in rj left by imm. Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsra.w — ARM-style arithmetic shift right (32-bit): conditionally shift value in rj right arithmetically by amount in rk (masked to 8 bits). Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsrai.w — ARM-style arithmetic shift right immediate (32-bit): conditionally shift value in rj right arithmetically by imm. Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsrl.w — ARM-style logical shift right (32-bit): conditionally shift value in rj right logically by amount in rk (masked to 8 bits). Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsrli.w — ARM-style logical shift right immediate (32-bit): conditionally shift value in rj right logically by imm. Update ARMFLAGS (C, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armsub.w — ARM-style subtract (32-bit): conditionally subtract value in rk from rj. Update ARMFLAGS (C, V, N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.
armxor.w — ARM-style bitwise XOR (32-bit): conditionally XOR values in rj and rk. Update ARMFLAGS (N, Z). Only ARMFLAGS (LBT4) is updated; the GPR is not modified.

F (3)

fcvt.d.ld — Convert x87 80-bit extended precision value (upper 16 bits in fj, lower 64 bits in fk) to double-precision floating point, store in fd.
fcvt.ld.d — Convert double-precision floating point value in fj to the lower 64 bits (integer bit and fraction) of x87 80-bit extended precision format, store in fd.
fcvt.ud.d — Convert double-precision floating point value in fj to the upper 16 bits (sign and exponent) of x87 80-bit extended precision format, store in fd.

J (2)

jiscr0 — Jump via scratch register 0: add imm to the value in SCR[0] and jump to the resulting address.
jiscr1 — Jump via scratch register 1: save the current PC to SCR[0], then add imm to the value in SCR[1] and jump to the resulting address.

L (4)

ldl.d — MIPS-style load doubleword left: load left part of an unaligned doubleword/word from memory at address rj + imm, merge with the existing value in rd, store the result in rd.
ldl.w — MIPS-style load doubleword left: load left part of an unaligned doubleword/word from memory at address rj + imm, merge with the existing value in rd, store the result in rd.
ldr.d — MIPS-style load doubleword right: load right part of an unaligned doubleword/word from memory at address rj + imm, merge with the existing value in rd, store the result in rd.
ldr.w — MIPS-style load doubleword right: load right part of an unaligned doubleword/word from memory at address rj + imm, merge with the existing value in rd, store the result in rd.

M (2)

movgr2scr — Move GPR to scratch register: copy value in rj to the scratch register selected by scrd (0-3). Scratch registers LBT0-LBT3 are accessible via $scr0-$scr3.
movscr2gr — Move scratch register to GPR: copy value in the scratch register selected by scrj (0-3) to rd.

R (16)

rcr.b — Rotate 8-bit value in rj and CF (in EFLAGS) together as a 9-bit ring right by the amount specified in rk. The result is written to rd.
rcr.d — Rotate 64-bit value in rj and CF (in EFLAGS) together as a 65-bit ring right by the amount specified in rk. The result is written to rd.
rcr.h — Rotate 16-bit value in rj and CF (in EFLAGS) together as a 17-bit ring right by the amount specified in rk. The result is written to rd.
rcr.w — Rotate 32-bit value in rj and CF (in EFLAGS) together as a 33-bit ring right by the amount specified in rk. The result is written to rd.
rcri.b — Rotate 8-bit value in rj and CF (in EFLAGS) together as a 9-bit ring right by immediate imm. The result is written to rd.
rcri.d — Rotate 64-bit value in rj and CF (in EFLAGS) together as a 65-bit ring right by immediate imm. The result is written to rd.
rcri.h — Rotate 16-bit value in rj and CF (in EFLAGS) together as a 17-bit ring right by immediate imm. The result is written to rd.
rcri.w — Rotate 32-bit value in rj and CF (in EFLAGS) together as a 33-bit ring right by immediate imm. The result is written to rd.
rotr.b — Rotate 8-bit value in rj right by the amount specified in rk. The shift amount is masked modulo 8.
rotr.d — Rotate 64-bit value in rj right by the amount specified in rk. The shift amount is masked modulo 64.
rotr.h — Rotate 16-bit value in rj right by the amount specified in rk. The shift amount is masked modulo 16.
rotr.w — Rotate 32-bit value in rj right by the amount specified in rk. The shift amount is masked modulo 32.
rotri.b — Rotate 8-bit value in rj right by immediate imm. The shift amount is masked modulo 8.
rotri.d — Rotate 64-bit value in rj right by immediate imm. The shift amount is masked modulo 64.
rotri.h — Rotate 16-bit value in rj right by immediate imm. The shift amount is masked modulo 16.
rotri.w — Rotate 32-bit value in rj right by immediate imm. The shift amount is masked modulo 32.

S (12)

sbc.b — Subtract 8-bit values in rj and rk with borrow (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
sbc.d — Subtract 64-bit values in rj and rk with borrow (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
sbc.h — Subtract 16-bit values in rj and rk with borrow (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
sbc.w — Subtract 32-bit values in rj and rk with borrow (CF in EFLAGS), sign-extend the result to 64-bit and store in rd.
setarmj — ARM-style set if condition: evaluate ARM condition code cond against ARMFLAGS. Store 1 in rd if the condition holds, 0 otherwise.
setx86j — x86-style set if condition: evaluate x86 condition code cond against EFLAGS. Store 1 in rd if the condition holds, 0 otherwise.
setx86loope — x86-style loop while equal: the value in rj is the counter after decrement. Store 1 in rd if the counter is non-zero and ZF (in EFLAGS) is set, 0 otherwise.
setx86loopne — x86-style loop while not equal: the value in rj is the counter after decrement. Store 1 in rd if the counter is non-zero and ZF (in EFLAGS) is clear, 0 otherwise.
stl.d — MIPS-style store doubleword left: store left part of value in rd to unaligned memory address rj + imm.
stl.w — MIPS-style store doubleword left: store left part of value in rd to unaligned memory address rj + imm.
str.d — MIPS-style store doubleword right: store right part of value in rd to unaligned memory address rj + imm.
str.w — MIPS-style store doubleword right: store right part of value in rd to unaligned memory address rj + imm.

X (113)

x86adc.b — x86-style add with carry: add 8-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86adc.d — x86-style add with carry: add 64-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86adc.h — x86-style add with carry: add 16-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86adc.w — x86-style add with carry: add 32-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.b — x86-style add: add 8-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.d — x86-style add: add 64-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.du — x86-style add: add unsigned 64-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.h — x86-style add: add 16-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.w — x86-style add: add 32-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86add.wu — x86-style add: add unsigned 32-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86and.b — x86-style bitwise AND: compute 8-bit AND of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86and.d — x86-style bitwise AND: compute 64-bit AND of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86and.h — x86-style bitwise AND: compute 16-bit AND of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86and.w — x86-style bitwise AND: compute 32-bit AND of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86clrtm — Clear x87 FPU stack translation mode: disable TOP-based remapping of FPR registers.
x86dec.b — x86-style decrement: subtract 1 from the 8-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86dec.d — x86-style decrement: subtract 1 from the 64-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86dec.h — x86-style decrement: subtract 1 from the 16-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86dec.w — x86-style decrement: subtract 1 from the 32-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86dectop — Decrement x87 FPU stack top pointer (FDECSTP): decrement TOP by 1, wrapping modulo 8.
x86inc.b — x86-style increment: add 1 to the 8-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86inc.d — x86-style increment: add 1 to the 64-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86inc.h — x86-style increment: add 1 to the 16-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86inc.w — x86-style increment: add 1 to the 32-bit value in rj. Update EFLAGS (AF, OF, PF, ZF, SF). Preserve CF. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86inctop — Increment x87 FPU stack top pointer (FINCSTP): increment TOP by 1, wrapping modulo 8.
x86mfflag — Move from x86 EFLAGS: read selected x86 flags (CF, PF, AF, ZF, SF, OF) from EFLAGS as determined by mask, pack them into rd.
x86mftop — Move from x87 FPU stack top pointer: read the current x87 TOP (stack top index, 3-bit) into rd.
x86mtflag — Move to x86 EFLAGS: write selected x86 flags (CF, PF, AF, ZF, SF, OF) in EFLAGS from the corresponding bit positions in rd, as determined by mask.
x86mttop — Move to x87 FPU stack top pointer: set the x87 TOP (stack top index, 3-bit) to imm.
x86mul.b — x86-style multiply: multiply signed 8-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 8-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.bu — x86-style multiply: multiply unsigned 8-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 8-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.d — x86-style multiply: multiply signed 64-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 64-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.du — x86-style multiply: multiply unsigned 64-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 64-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.h — x86-style multiply: multiply signed 16-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 16-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.hu — x86-style multiply: multiply unsigned 16-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 16-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.w — x86-style multiply: multiply signed 32-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 32-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86mul.wu — x86-style multiply: multiply unsigned 32-bit values in rj and rk. Set CF and OF if overflow (result does not fit in 32-bits), clear other flags. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86or.b — x86-style bitwise OR: compute 8-bit OR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86or.d — x86-style bitwise OR: compute 64-bit OR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86or.h — x86-style bitwise OR: compute 16-bit OR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86or.w — x86-style bitwise OR: compute 32-bit OR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcl.b — x86-style rotate left through carry: rotate 8-bit value in rj and CF together as a 9-bit ring left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcl.d — x86-style rotate left through carry: rotate 64-bit value in rj and CF together as a 65-bit ring left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcl.h — x86-style rotate left through carry: rotate 16-bit value in rj and CF together as a 17-bit ring left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcl.w — x86-style rotate left through carry: rotate 32-bit value in rj and CF together as a 33-bit ring left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcli.b — x86-style rotate left through carry: rotate 8-bit value in rj and CF together as a 9-bit ring left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcli.d — x86-style rotate left through carry: rotate 64-bit value in rj and CF together as a 65-bit ring left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcli.h — x86-style rotate left through carry: rotate 16-bit value in rj and CF together as a 17-bit ring left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcli.w — x86-style rotate left through carry: rotate 32-bit value in rj and CF together as a 33-bit ring left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcr.b — x86-style rotate right through carry: rotate 8-bit value in rj and CF together as a 9-bit ring right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcr.d — x86-style rotate right through carry: rotate 64-bit value in rj and CF together as a 65-bit ring right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcr.h — x86-style rotate right through carry: rotate 16-bit value in rj and CF together as a 17-bit ring right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcr.w — x86-style rotate right through carry: rotate 32-bit value in rj and CF together as a 33-bit ring right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcri.b — x86-style rotate right through carry: rotate 8-bit value in rj and CF together as a 9-bit ring right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcri.d — x86-style rotate right through carry: rotate 64-bit value in rj and CF together as a 65-bit ring right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcri.h — x86-style rotate right through carry: rotate 16-bit value in rj and CF together as a 17-bit ring right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rcri.w — x86-style rotate right through carry: rotate 32-bit value in rj and CF together as a 33-bit ring right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotl.b — x86-style rotate left: rotate 8-bit value in rj left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotl.d — x86-style rotate left: rotate 64-bit value in rj left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotl.h — x86-style rotate left: rotate 16-bit value in rj left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotl.w — x86-style rotate left: rotate 32-bit value in rj left by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotli.b — x86-style rotate left: rotate 8-bit value in rj left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotli.d — x86-style rotate left: rotate 64-bit value in rj left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotli.h — x86-style rotate left: rotate 16-bit value in rj left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotli.w — x86-style rotate left: rotate 32-bit value in rj left by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotr.b — x86-style rotate right: rotate 8-bit value in rj right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotr.d — x86-style rotate right: rotate 64-bit value in rj right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotr.h — x86-style rotate right: rotate 16-bit value in rj right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotr.w — x86-style rotate right: rotate 32-bit value in rj right by the amount specified in rk. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotri.b — x86-style rotate right: rotate 8-bit value in rj right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotri.d — x86-style rotate right: rotate 64-bit value in rj right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotri.h — x86-style rotate right: rotate 16-bit value in rj right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86rotri.w — x86-style rotate right: rotate 32-bit value in rj right by immediate imm. Update CF, OF (for shift count of 1). Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sbc.b — x86-style subtract with borrow: subtract 8-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sbc.d — x86-style subtract with borrow: subtract 64-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sbc.h — x86-style subtract with borrow: subtract 16-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sbc.w — x86-style subtract with borrow: subtract 32-bit values in rj and rk with CF (in EFLAGS). Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86settag — Set x87 tag word bit in rd according to imm1 and imm2. imm2 selects the target bit position. imm1%8 determines the operation: 0=set bit (0→1 only), 1=clear bit (1→0 only), 2-4=check tag byte then modify. Raises a BTE (Binary Translation Exception) on invalid state transitions.
x86settm — Set x87 FPU stack translation mode: enable TOP-based remapping of FPR registers (bits 0-7 are offset by TOP when TM is set).
x86sll.b — x86-style shift left logical: shift 8-bit value in rj left by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sll.d — x86-style shift left logical: shift 64-bit value in rj left by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sll.h — x86-style shift left logical: shift 16-bit value in rj left by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sll.w — x86-style shift left logical: shift 32-bit value in rj left by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86slli.b — x86-style shift left logical: shift 8-bit value in rj left by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86slli.d — x86-style shift left logical: shift 64-bit value in rj left by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86slli.h — x86-style shift left logical: shift 16-bit value in rj left by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86slli.w — x86-style shift left logical: shift 32-bit value in rj left by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sra.b — x86-style shift right arithmetic: shift 8-bit value in rj right arithmetically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sra.d — x86-style shift right arithmetic: shift 64-bit value in rj right arithmetically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sra.h — x86-style shift right arithmetic: shift 16-bit value in rj right arithmetically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sra.w — x86-style shift right arithmetic: shift 32-bit value in rj right arithmetically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srai.b — x86-style shift right arithmetic: shift 8-bit value in rj right arithmetically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srai.d — x86-style shift right arithmetic: shift 64-bit value in rj right arithmetically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srai.h — x86-style shift right arithmetic: shift 16-bit value in rj right arithmetically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srai.w — x86-style shift right arithmetic: shift 32-bit value in rj right arithmetically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (OF is set to 0 if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srl.b — x86-style shift right logical: shift 8-bit value in rj right logically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srl.d — x86-style shift right logical: shift 64-bit value in rj right logically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srl.h — x86-style shift right logical: shift 16-bit value in rj right logically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srl.w — x86-style shift right logical: shift 32-bit value in rj right logically by the amount specified in rk. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srli.b — x86-style shift right logical: shift 8-bit value in rj right logically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srli.d — x86-style shift right logical: shift 64-bit value in rj right logically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srli.h — x86-style shift right logical: shift 16-bit value in rj right logically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86srli.w — x86-style shift right logical: shift 32-bit value in rj right logically by immediate imm. If shift count is non-zero, update CF, PF, ZF, SF (and OF if count is 1). If shift count is zero, flags are unchanged. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.b — x86-style subtract: subtract 8-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.d — x86-style subtract: subtract 64-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.du — x86-style subtract: subtract unsigned 64-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.h — x86-style subtract: subtract 16-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.w — x86-style subtract: subtract 32-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86sub.wu — x86-style subtract: subtract unsigned 32-bit values in rj and rk. Update EFLAGS (CF, AF, OF, PF, ZF, SF) according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86xor.b — x86-style bitwise XOR: compute 8-bit XOR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86xor.d — x86-style bitwise XOR: compute 64-bit XOR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86xor.h — x86-style bitwise XOR: compute 16-bit XOR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.
x86xor.w — x86-style bitwise XOR: compute 32-bit XOR of values in rj and rk. Clear CF, OF, AF. Update PF, ZF, SF according to the result. Only EFLAGS (LBT4) is updated; the GPR is not modified.