+Here are the data structures with brief descriptions: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

arm_bilinear_interp_instance_f32	Instance structure for the floating-point bilinear interpolation function
arm_bilinear_interp_instance_q15	Instance structure for the Q15 bilinear interpolation function
arm_bilinear_interp_instance_q31	Instance structure for the Q31 bilinear interpolation function
arm_bilinear_interp_instance_q7	Instance structure for the Q15 bilinear interpolation function
arm_biquad_cas_df1_32x64_ins_q31	Instance structure for the high precision Q31 Biquad cascade filter
arm_biquad_cascade_df2T_instance_f32	Instance structure for the floating-point transposed direct form II Biquad cascade filter
arm_biquad_casd_df1_inst_f32	Instance structure for the floating-point Biquad cascade filter
arm_biquad_casd_df1_inst_q15	Instance structure for the Q15 Biquad cascade filter
arm_biquad_casd_df1_inst_q31	Instance structure for the Q31 Biquad cascade filter
arm_cfft_radix4_instance_f32	Instance structure for the floating-point CFFT/CIFFT function
arm_cfft_radix4_instance_q15	Instance structure for the Q15 CFFT/CIFFT function
arm_cfft_radix4_instance_q31	Instance structure for the Q31 CFFT/CIFFT function
arm_dct4_instance_f32	Instance structure for the floating-point DCT4/IDCT4 function
arm_dct4_instance_q15	Instance structure for the Q15 DCT4/IDCT4 function
arm_dct4_instance_q31	Instance structure for the Q31 DCT4/IDCT4 function
arm_fir_decimate_instance_f32	Instance structure for the floating-point FIR decimator
arm_fir_decimate_instance_q15	Instance structure for the Q15 FIR decimator
arm_fir_decimate_instance_q31	Instance structure for the Q31 FIR decimator
arm_fir_instance_f32	Instance structure for the floating-point FIR filter
arm_fir_instance_q15	Instance structure for the Q15 FIR filter
arm_fir_instance_q31	Instance structure for the Q31 FIR filter
arm_fir_instance_q7	Instance structure for the Q7 FIR filter
arm_fir_interpolate_instance_f32	Instance structure for the floating-point FIR interpolator
arm_fir_interpolate_instance_q15	Instance structure for the Q15 FIR interpolator
arm_fir_interpolate_instance_q31	Instance structure for the Q31 FIR interpolator
arm_fir_lattice_instance_f32	Instance structure for the floating-point FIR lattice filter
arm_fir_lattice_instance_q15	Instance structure for the Q15 FIR lattice filter
arm_fir_lattice_instance_q31	Instance structure for the Q31 FIR lattice filter
arm_fir_sparse_instance_f32	Instance structure for the floating-point sparse FIR filter
arm_fir_sparse_instance_q15	Instance structure for the Q15 sparse FIR filter
arm_fir_sparse_instance_q31	Instance structure for the Q31 sparse FIR filter
arm_fir_sparse_instance_q7	Instance structure for the Q7 sparse FIR filter
arm_iir_lattice_instance_f32	Instance structure for the floating-point IIR lattice filter
arm_iir_lattice_instance_q15	Instance structure for the Q15 IIR lattice filter
arm_iir_lattice_instance_q31	Instance structure for the Q31 IIR lattice filter
arm_linear_interp_instance_f32	Instance structure for the floating-point Linear Interpolate function
arm_lms_instance_f32	Instance structure for the floating-point LMS filter
arm_lms_instance_q15	Instance structure for the Q15 LMS filter
arm_lms_instance_q31	Instance structure for the Q31 LMS filter
arm_lms_norm_instance_f32	Instance structure for the floating-point normalized LMS filter
arm_lms_norm_instance_q15	Instance structure for the Q15 normalized LMS filter
arm_lms_norm_instance_q31	Instance structure for the Q31 normalized LMS filter
arm_matrix_instance_f32	Instance structure for the floating-point matrix structure
arm_matrix_instance_q15	Instance structure for the Q15 matrix structure
arm_matrix_instance_q31	Instance structure for the Q31 matrix structure
arm_pid_instance_f32	Instance structure for the floating-point PID Control
arm_pid_instance_q15	Instance structure for the Q15 PID Control
arm_pid_instance_q31	Instance structure for the Q31 PID Control
arm_rfft_instance_f32	Instance structure for the floating-point RFFT/RIFFT function
arm_rfft_instance_q15	Instance structure for the Q15 RFFT/RIFFT function
arm_rfft_instance_q31	Instance structure for the Q31 RFFT/RIFFT function

+

Name	Mnemonic	Description
__SADD8	SADD8	GE setting quad 8-bit signed addition
__QADD8	QADD8	Q setting quad 8-bit saturating addition
__SHADD8	SHADD8	Quad 8-bit signed addition with halved results
__UADD8	UADD8	GE setting quad 8-bit unsigned addition
__UQADD8	UQADD8	Quad 8-bit unsigned saturating addition
__UHADD8	UHADD8	Quad 8-bit unsigned addition with halved results
__SSUB8	SSUB8	GE setting quad 8-bit signed subtraction
__QSUB8	QSUB8	Q setting quad 8-bit saturating subtract
__SHSUB8	SHSUB8	Quad 8-bit signed subtraction with halved results
__USUB8	USUB8	GE setting quad 8-bit unsigned subtract
__UQSUB8	UQSUB8	Quad 8-bit unsigned saturating subtraction
__UHSUB8	UHSUB8	Quad 8-bit unsigned subtraction with halved results
__SADD16	SADD16	GE setting dual 16-bit signed addition
__QADD16	QADD16	Q setting dual 16-bit saturating addition
__SHADD16	SHADD16	Dual 16-bit signed addition with halved results
__UADD16	UADD16	GE setting dual 16-bit unsigned addition
__UQADD16	UQADD16	Dual 16-bit unsigned saturating addition
__UHADD16	UHADD16	Dual 16-bit unsigned addition with halved results
__SSUB16	SSUB16	GE setting dual 16-bit signed subtraction
__QSUB16	QSUB16	Q setting dual 16-bit saturating subtract
__SHSUB16	SHSUB16	Dual 16-bit signed subtraction with halved results
__USUB16	USUB16	GE setting dual 16-bit unsigned subtract
__UQSUB16	UQSUB16	Dual 16-bit unsigned saturating subtraction
__UHSUB16	UHSUB16	Dual 16-bit unsigned subtraction with halved results
__SASX	SASX	GE setting dual 16-bit addition and subtraction with exchange
__QASX	QASX	Q setting dual 16-bit add and subtract with exchange
__SHASX	SHASX	Dual 16-bit signed addition and subtraction with halved results
__UASX	UASX	GE setting dual 16-bit unsigned addition and subtraction with exchange
__UQASX	UQASX	Dual 16-bit unsigned saturating addition and subtraction with exchange
__UHASX	UHASX	Dual 16-bit unsigned addition and subtraction with halved results and exchange
__SSAX	SSAX	GE setting dual 16-bit signed subtraction and addition with exchange
__QSAX	QSAX	Q setting dual 16-bit subtract and add with exchange
__SHSAX	SHSAX	Dual 16-bit signed subtraction and addition with halved results
__USAX	USAX	GE setting dual 16-bit unsigned subtract and add with exchange
__UQSAX	UQSAX	Dual 16-bit unsigned saturating subtraction and addition with exchange
__UHSAX	UHSAX	Dual 16-bit unsigned subtraction and addition with halved results and exchange
__USAD8	USAD8	Unsigned sum of quad 8-bit unsigned absolute difference
__USADA8	USADA8	Unsigned sum of quad 8-bit unsigned absolute difference with 32-bit accumulate
__SSAT16	SSAT16	Q setting dual 16-bit saturate
__USAT16	USAT16	Q setting dual 16-bit unsigned saturate
__UXTB16	UXTB16	Dual extract 8-bits and zero-extend to 16-bits
__UXTAB16	UXTAB16	Extracted 16-bit to 32-bit unsigned addition
__SXTB16	SXTB16	Dual extract 8-bits and sign extend each to 16-bits
__SXTAB16	SXTAB16	Dual extracted 8-bit to 16-bit signed addition
__SMUAD	SMUAD	Q setting sum of dual 16-bit signed multiply
__SMUADX	SMUADX	Q setting sum of dual 16-bit signed multiply with exchange
__SMLAD	SMLAD	Q setting dual 16-bit signed multiply with single 32-bit accumulator
__SMLADX	SMLADX	Q setting pre-exchanged dual 16-bit signed multiply with single 32-bit accumulator
__SMLALD	SMLALD	Dual 16-bit signed multiply with single 64-bit accumulator
__SMLALDX	SMLALDX	Dual 16-bit signed multiply with exchange with single 64-bit accumulator
__SMUSD	SMUSD	Dual 16-bit signed multiply returning difference
__SMUSDX	SMUSDX	Dual 16-bit signed multiply with exchange returning difference
__SMLSD	SMLSD	Q setting dual 16-bit signed multiply subtract with 32-bit accumulate
__SMLSDX	SMLSDX	Q setting dual 16-bit signed multiply with exchange subtract with 32-bit accumulate
__SMLSLD	SMLSLD	Q setting dual 16-bit signed multiply subtract with 64-bit accumulate
__SMLSLDX	SMLSLDX	Q setting dual 16-bit signed multiply with exchange subtract with 64-bit accumulate
__SEL	SEL	Select bytes based on GE bits
__QADD	QADD	Q setting saturating add
__QSUB	QSUB/td> +	Q setting saturating subtract

Summary	+ +uint32_t __SADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four 8-bit signed integer additions. + The GE bits in the APSR are set according to the results of the additions. +
Parameter	+ + val1: first four 8-bit summands. + val2: second four 8-bit summands. + +
Return Value	+ The function returns: + + the addition of the first bytes from each operand, in the first byte of the return value. + the addition of the second bytes of each operand, in the second byte of the return value. + the addition of the third bytes of each operand, in the third byte of the return value. + the addition of the fourth bytes of each operand, in the fourth byte of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[7:0] ≥ 0 then APSR.GE[0] = 1 else 0 + if res[15:8] ≥ 0 then APSR.GE[1] = 1 else 0 + if res[23:16] ≥ 0 then APSR.GE[2] = 1 else 0 + if res[31:24] ≥ 0 then APSR.GE[3] = 1 else 0 + +
Operation	+ +res[7:0] = val1[7:0] + val2[7:0] +res[15:8] = val1[15:8] + val2[15:8] +res[23:16] = val1[23:16] + val2[23:16] +res[31:24] = val1[31:24] + val2[31:24] +

Summary	+ +uint32_t __QADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four 8-bit integer additions, saturating the results to + the 8-bit signed integer range -2⁷ ≤ x ≤ 2⁷ - 1. +
Parameter	+ + val1: first four 8-bit summands. + val2: second four 8-bit summands. + +
Return Value	+ The function returns: + + the saturated addition of the first byte of each operand in the first byte of the return value. + the saturated addition of the second byte of each operand in the second byte of the return value. + the saturated addition of the third byte of each operand in the third byte of the return value. + the saturated addition of the fourth byte of each operand in the fourth byte of the return value. + + The returned results are saturated to the 16-bit signed integer range -2⁷ ≤ x ≤ 2⁷ - 1. + +
Operation	+ +res[7:0] = val1[7:0] + val2[7:0] +res[15:8] = val1[15:8] + val2[15:8] +res[23:16] = val1[23:16] + val2[23:16] +res[31:24] = val1[31:24] + val2[31:24] +

Summary	+ +uint32_t __SHADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four signed 8-bit integer additions, halving the results. +
Parameter	+ + val1: first four 8-bit summands. + val2: second four 8-bit summands. + +
Return Value	+ The function returns: + + the halved addition of the first bytes from each operand, in the first byte of the return value. + the halved addition of the second bytes from each operand, in the second byte of the return value. + the halved addition fo the third bytes from each operand, in the third byte of the return value. + the halved addition of the fourth bytes from each operand, in the fourth byte of the return value. + +
Operation	+ +res[7:0] = (val1[7:0] + val2[7:0]) >> 1 +res[15:8] = (val1[15:8] + val2[15:8]) >> 1 +res[23:16] = (val1[23:16] + val2[23:16]) >> 1 +res[31:24] = (val1[31:24] + val2[31:24]) >> 1 +

Summary	+ +uint32_t __UADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four unsigned 8-bit integer additions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first four 8-bit summands for each addition. + val2: second four 8-bit summands for each addition. + +
Return Value	+ The function returns: + + the addition of the first bytes in each operand, in the first byte of the return value. + the addition of the second bytes in each operand, in the second byte of the return value. + the addition of the third bytes in each operand, in the third byte of the return value. + the addition of the fourth bytes in each operand, in the fourth byte of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[7:0] ≥ 0x100 then APSR.GE[0] = 1 else 0 + if res[15:8] ≥ 0x100 then APSR.GE[1] = 1 else 0 + if res[23:16] ≥ 0x100 then APSR.GE[2] = 1 else 0 + if res[31:24] ≥ 0x100 then APSR.GE[3] = 1 else 0 + +
Operation	+ +res[7:0] = val1[7:0] + val2[7:0] +res[15:8] = val1[15:8] + val2[15:8] +res[23:16] = val1[23:16] + val2[23:16] +res[31:24] = val1[31:24] + val2[31:24] +

Summary	+ +uint32_t __UQADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four unsigned 8-bit integer additions, saturating the + results to the 8-bit unsigned integer range 0 ≤ x ≤ 2⁸ - 1. +
Parameter	+ + val1: first four 8-bit summands. + val2: second four 8-bit summands. + +
Return Value	+ The function returns: + + the addition of the first bytes in each operand, in the first byte of the return value. + the addition of the second bytes in each operand, in the second byte of the return value. + the addition of the third bytes in each operand, in the third byte of the return value. + the addition of the fourth bytes in each operand, in the fourth byte of the return value. + + The results are saturated to the 8-bit unsigned integer range 0 ≤ x ≤ 2⁸ - 1. + +
Operation	+ +res[7:0] = val1[7:0] + val2[7:0] +res[15:8] = val1[15:8] + val2[15:8] +res[23:16] = val1[23:16] + val2[23:16] +res[31:24] = val1[31:24] + val2[31:24] +

Summary	+ +uint32_t __UHADD8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four unsigned 8-bit integer additions, halving the results. +
Parameter	+ + val1: first four 8-bit summands. + val2: second four 8-bit summands. + +
Return Value	+ The function returns: + + the halved addition of the first bytes in each operand, in the first byte of the return value. + the halved addition of the second bytes in each operand, in the second byte of the return value. + the halved addition of the third bytes in each operand, in the third byte of the return value. + the halved addition of the fourth bytes in each operand, in the fourth byte of the return value. + +
Operation	+ +res[7:0] = (val1[7:0] + val2[7:0]) >> 1 +res[15:8] = (val1[15:8] + val2[15:8]) >> 1 +res[23:16] = (val1[23:16] + val2[23:16]) >> 1 +res[31:24] = (val1[31:24] + val2[31:24]) >> 1 +

Summary	+ +uint32_t __SSUB8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four 8-bit signed integer subtractions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first four 8-bit operands of each subtraction. + val2: second four 8-bit operands of each subtraction. + +
Return Value	+ The function returns: + + the subtraction of the first byte in the second operand from the first byte in the + first operand, in the first bytes of the return value. + the subtraction of the second byte in the second operand from the second byte in + the first operand, in the second byte of the return value. + the subtraction of the third byte in the second operand from the third byte in the + first operand, in the third byte of the return value. + the subtraction of the fourth byte in the second operand from the fourth byte in + the first operand, in the fourth byte of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. If res is the return value, then: + + + if res[8:0] ≥ 0 then APSR.GE[0] = 1 else 0 + if res[15:8] ≥ 0 then APSR.GE[1] = 1 else 0 + if res[23:16] ≥ 0 then APSR.GE[2] = 1 else 0 + if res[31:24] ≥ 0 then APSR.GE[3] = 1 else 0 + +
Operation	+ +res[7:0] = val1[7:0] - val2[7:0] +res[15:8] = val1[15:8] - val2[15:8] +res[23:16] = val1[23:16] - val2[23:16] +res[31:24] = val1[31:24] - val2[31:24] +

Summary	+ +uint32_t __SHSUB8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four signed 8-bit integer subtractions, halving the + results. +
Parameter	+ + val1: first four 8-bit operands. + val2: second four 8-bit operands. + +
Return Value	+ The function returns: + + the halved subtraction of the first byte in the second operand from the first byte + in the first operand, in the first byte of the return value. + the halved subtraction of the second byte in the second operand from the second + byte in the first operand, in the second byte of the return value. + the halved subtraction of the third byte in the second operand from the third byte + in the first operand, in the third byte of the return value. + the halved subtraction of the fourth byte in the second operand from the fourth + byte in the first operand, in the fourth byte of the return value. + +
Operation	+ +res[7:0] = (val1[7:0] - val2[7:0]) >> 1 +res[15:8] = (val1[15:8] - val2[15:8]) >> 1 +res[23:16] = (val1[23:16] - val2[23:16] >> 1 +res[31:24] = (val1[31:24] - val2[31:24] >> 1 +

Summary	+ +uint32_t __USUB8(uint32_t val1, uint32_t val2); +
Description	This function It enables you to perform four 8-bit unsigned integer subtractions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first four 8-bit operands. + val2: second four 8-bit operands. + +
Return Value	+ The function returns: + + the subtraction of the first byte in the second operand from the first byte in the + first operand, in the first byte of the return value. + the subtraction of the second byte in the second operand from the second byte in + the first operand, in the second byte of the return value. + the subtraction of the third byte in the second operand from the third byte in the + first operand, in the third byte of the return value. + the subtraction of the fourth byte in the second operand from the fourth byte in + the first operand, in the fourth byte of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[7:0] ≥ 0 then APSR.GE[0] = 1 else 0 + if res[15:8] ≥ 0 then APSR.GE[1] = 1 else 0 + if res[23:16] ≥ 0 then APSR.GE[2] = 1 else 0 + if res[31:24] ≥ 0 then APSR.GE[3] = 1 else 0 + +
Operation	+ +res[7:0] = val1[7:0] - val2[7:0] +res[15:8] = val1[15:8] - val2[15:8] +res[23:16] = val1[23:16] - val2[23:16] +res[31:24] = val1[31:24] - val2[31:24] +

Summary	+ +uint32_t __UQSUB8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four unsigned 8-bit integer subtractions, saturating + the results to the 8-bit unsigned integer range 0 ≤ x ≤ 2⁸ - 1. +
Parameter	+ + val1: first four 8-bit operands. + val2: second four 8-bit operands. + +
Return Value	+ The function returns: + + the subtraction of the first byte in the second operand from the first byte in the + first operand, in the first byte of the return value. + the subtraction of the second byte in the second operand from the second byte in + the first operand, in the second byte of the return value. + the subtraction of the third byte in the second operand from the third byte in the + first operand, in the third byte of the return value. + the subtraction of the fourth byte in the second operand from the fourth byte in + the first operand, in the fourth byte of the return value. + + The results are saturated to the 8-bit unsigned integer range 0 ≤ x ≤ 2⁸ - 1. + +
Operation	+ +res[7:0] = val1[7:0] - val2[7:0] +res[15:8] = val1[15:8] - val2[15:8] +res[23:16] = val1[23:16] - val2[23:16] +res[31:24] = val1[31:24] - val2[31:24] +

Summary	+ +uint32_t __UHSUB8(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform four unsigned 8-bit integer subtractions, halving the + results. +
Parameter	+ + val1: first four 8-bit operands. + val2: second four 8-bit operands. + +
Return Value	+ The function returns: + + the halved subtraction of the first byte in the second operand from the first byte + in the first operand, in the first byte of the return value. + the halved subtraction of the second byte in the second operand from the second + byte in the first operand, in the second byte of the return value. + the halved subtraction of the third byte in the second operand from the third byte + in the first operand, in the third byte of the return value. + the halved subtraction of the fourth byte in the second operand from the fourth + byte in the first operand, in the fourth byte of the return value. + +
Operation	+ +res[7:0] = (val1[7:0] - val2[7:0]) >> 1 +res[15:8] = (val1[15:8] - val2[15:8]) >> 1 +res[23:16] = (val1[23:16] - val2[23:16]) >> 1 +res[31:24] = (val1[31:24] - val2[31:24]) >> 1 +

Summary	+ +uint32_t __SADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit signed integer additions. + The GE bits in the APSR are set according to the results of the additions. +
Parameter	+ + val1: first two 16-bit summands. + val2: second two 16-bit summands. + +
Return Value	+ The function returns: + + the addition of the low halfwords in the low halfword of the return value. + the addition of the high halfwords in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] + val2[15:0] +res[31:16] = val1[31:16] + val2[31:16] +

Summary	+ +uint32_t __QADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit integer arithmetic additions in parallel, + saturating the results to the 16-bit signed integer range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. +
Parameter	+ + val1: first two 16-bit summands. + val2: second two 16-bit summands. + +
Return Value	+ The function returns: + + the saturated addition of the low halfwords in the low halfword of the return value. + the saturated addition of the high halfwords in the high halfword of the return value. + + The returned results are saturated to the 16-bit signed integer + range -2¹⁵ ≤ x ≤ 2¹⁵ - 1 + +
Operation	+ +res[15:0] = val1[15:0] + val2[15:0] +res[16:31] = val1[31:16] + val2[31:16] +

Summary	+ +uint32_t __SHADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two signed 16-bit integer additions, halving the + results. +
Parameter	+ + val1: first two 16-bit summands. + val2: second two 16-bit summands. + +
Return Value	+ The function returns: + + the halved addition of the low halfwords from each operand, in the low halfword + of the return value. + the halved addition of the high halfwords from each operand, in the high halfword + of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] + val2[15:0]) >> 1 +res[31:16] = (val1[31:16] + val2[31:16]) >> 1 +

Summary	+ +uint32_t __UADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit unsigned integer additions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first two 16-bit summands for each addition. + val2: second two 16-bit summands for each addition. + +
Return Value	+ The function returns: + + the addition of the low halfwords in each operand, in the low halfword of the + return value. + the addition of the high halfwords in each operand, in the high halfword of the + return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0x10000 then APSR.GE[0] = 11 else 00 + if res[31:16] ≥ 0x10000 then APSR.GE[1] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] + val2[15:0] +res[31:16] = val1[31:16] + val2[31:16] +

Summary	+ +uint32_t __UQADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two unsigned 16-bit integer additions, saturating the + results to the 16-bit unsigned integer range 0 ≤ x ≤ 2¹⁶ - 1. +
Parameter	+ + val1: first two 16-bit summands. + val2: second two 16-bit summands. + +
Return Value	+ The function returns: + + the addition of the low halfword in the first operand and the low halfword in the + second operand, in the low halfword of the return value. + the addition of the high halfword in the first operand and the high halfword in the + second operand, in the high halfword of the return value. + + The results are saturated to the 16-bit unsigned integer + range 0 ≤ x ≤ 2¹⁶ - 1. + +
Operation	+ +res[15:0] = val1[15:0] + val2[15:0] +res[31:16] = val1[31:16] + val2[31:16] +

Summary	+ +uint32_t __UHADD16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two unsigned 16-bit integer additions, halving the + results. +
Parameter	+ + val1: first two 16-bit summands. + val2: second two 16-bit summands. + +
Return Value	+ The function returns: + + the halved addition of the low halfwords in each operand, in the low halfword of + the return value. + the halved addition of the high halfwords in each operand, in the high halfword + of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] + val2[15:0]) >> 1 +res[31:16] = (val1[31:16] + val2[31:16]) >> 1 +

Summary	+ +uint32_t __SSUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit signed integer subtractions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first two 16-bit operands of each subtraction. + val2: second two 16-bit operands of each subtraction. + +
Return Value	+ The function returns: + + the subtraction of the low halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the subtraction of the high halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] - val2[15:0] +res[31:16] = val1[31:16] - val2[31:16] +

Summary	+ +uint32_t __QSUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit integer subtractions, saturating the + results to the 16-bit signed integer range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. +
Parameter	+ + val1: first two 16-bit operands. + val2: second two 16-bit operands. + +
Return Value	+ The function returns: + + the saturated subtraction of the low halfword in the second operand from the low + halfword in the first operand, in the low halfword of the returned result. + the saturated subtraction of the high halfword in the second operand from the high + halfword in the first operand, in the high halfword of the returned result. + + The returned results are saturated to the 16-bit signed integer + range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. + +
Operation	+ +res[15:0] = val1[15:0] - val2[15:0] +res[31:16] = val1[31:16] - val2[31:16] +

Summary	+ +uint32_t __SHSUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two signed 16-bit integer subtractions, halving the + results. +
Parameter	+ + val1: first two 16-bit operands. + val2: second two 16-bit operands. + +
Return Value	+ The function returns: + + the halved subtraction of the low halfword in the second operand from the low + halfword in the first operand, in the low halfword of the return value. + the halved subtraction of the high halfword in the second operand from the high + halfword in the first operand, in the high halfword of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] - val2[15:0]) >> 1 +res[31:16] = (val1[31:16] - val2[31:16]) >> 1 +

Summary	+ +uint32_t __USUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two 16-bit unsigned integer subtractions. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first two 16-bit operands. + val2: second two 16-bit operands. + +
Return Value	+ The function returns: + + the subtraction of the low halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the subtraction of the high halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] - val2[15:0] +res[31:16] = val1[31:16] - val2[31:16] +

Summary	+ +uint32_t __UQSUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two unsigned 16-bit integer subtractions, saturating + the results to the 16-bit unsigned integer range 0 ≤ x ≤ 2¹⁶ - 1. +
Parameter	+ + val1: first two 16-bit operands for each subtraction. + val2: second two 16-bit operands for each subtraction. + +
Return Value	+ The function returns: + + the subtraction of the low halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the subtraction of the high halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + The results are saturated to the 16-bit unsigned integer range 0 ≤ x ≤ 2¹⁶ - 1. + +
Operation	+ +res[15:0] = val1[15:0] - val2[15:0] +res[31:16] = val1[31:16] - val2[31:16] +

Summary	+ +uint32_t __UHSUB16(uint32_t val1, uint32_t val2); +
Description	This function enables you to perform two unsigned 16-bit integer subtractions, halving + the results. +
Parameter	+ + val1: first two 16-bit operands. + val2: second two 16-bit operands. + +
Return Value	+ The function returns: + + the halved subtraction of the low halfword in the second operand from the low + halfword in the first operand, in the low halfword of the return value. + the halved subtraction of the high halfword in the second operand from the high + halfword in the first operand, in the high halfword of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] - val2[15:0]) >> 1 +res[31:16] = (val1[31:16] - val2[31:16]) >> 1 +

Summary	+ +uint32_t __SASX(uint32_t val1, uint32_t val2); +
Description	This function inserts an SASX instruction into the instruction stream generated by the + compiler. It enables you to exchange the halfwords of the second operand, add the high + halfwords and subtract the low halfwords. + The GE bits in the APRS are set according to the results. +
Parameter	+ + val1: first operand for the subtraction in the low halfword, and the + first operand for the addition in the high halfword. + val2: second operand for the subtraction in the high halfword, and the + second operand for the addition in the low halfword. + +
Return Value	+ The function returns: + + the subtraction of the high halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the addition of the high halfword in the first operand and the low halfword in the + second operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] - val2[31:16] +res[31:16] = val1[31:16] + val2[15:0] +

CMSIS Support for Cortex-M4 SIMD Instructions

Revision History

Contents

About

Cortex-M4 SIMD instruction support

Function __SADD8

Function __QADD8

Function __SHADD8

Function __UADD8

Function __UQADD8

Function __UHADD8

Function __SSUB8

Function __QSUB8

Function __SHSUB8

Function __USUB8

Function __UQSUB8

Function __UHSUB8

Function __SADD16

Function __QADD16

Function __SHADD16

Function __UADD16

Function __UQADD16

Function __UHADD16

Function __SSUB16

Function __QSUB16

Function __SHSUB16

Function __USUB16

Function __UQSUB16

Function __UHSUB16

Function __SASX

Function __QASX

Function __SHASX

Function __UASX

Function __UQASX

Function __UHASX

Function __SSAX

Function __QSAX

Function __SHSAX

Function __USAX

Function __UQSAX

Function __UHSAX

Function __USAD8

Function __USADA8

Function __SSAT16

Function __USAT16

Function __UXTB16

Function __UXTAB16

Function __SXTB16

Function __SXTAB16

Function __SMUAD

Function __SMUADX

Function __SMLAD

Function __SMLADX

Function __SMLALD

Function __SMLALDX

Function __SMUSD

Function __SMUSDX

Function __SMLSD

Function __SMLSDX

Function __SMLSLD

Function __SMLSLDX

Function __SEL

Function __QADD

Function __QSUB

Examples

Addition

Subtraction

Multiplication

Cortex Microcontroller Software Interface Standard

Contents

About

Coding Rules and Conventions

Essentials

Recommendations

Data Types and IO Type Qualifiers

CMSIS Version Number

CMSIS Cortex Core

CMSIS Files

device.h

Interrupt Number Definition

Cortex Microcontroller Software Interface Standard
+System View Description

Summary	+ +uint32_t __QASX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of the one operand, then add the high + halfwords and subtract the low halfwords, saturating the results to the 16-bit signed + integer range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. +
Parameter	+ + val1: first operand for the subtraction in the low halfword, and the + first operand for the addition in the high halfword. + val2: second operand for the subtraction in the high halfword, and the + second operand for the addition in the low halfword. + +
Return Value	+ The function returns: + + the saturated subtraction of the high halfword in the second operand from the low + halfword in the first operand, in the low halfword of the return value. + the saturated addition of the high halfword in the first operand and the low + halfword in the second operand, in the high halfword of the return value. + + The returned results are saturated to the 16-bit signed integer + range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. + +
Operation	+ +res[15:0] = val1[15:0] - val2[31:16] +res[31:16] = val1[31:16] + val2[15:0] +

Summary	+ +uint32_t __SHASX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the two halfwords of one operand, perform one + signed 16-bit integer addition and one signed 16-bit subtraction, and halve the results. +
Parameter	+ + val1: first 16-bit operands. + val2: second 16-bit operands. + +
Return Value	+ The function returns: + + the halved subtraction of the high halfword in the second operand from the low + halfword in the first operand, in the low halfword of the return value. + the halved subtraction of the low halfword in the second operand from the high + halfword in the first operand, in the high halfword of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] - val2[31:16]) >> 1 +res[31:16] = (val1[31:16] - val2[15:0]) >> 1 +

Summary	+ +uint32_t __UASX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the two halfwords of the second operand, add the + high halfwords and subtract the low halfwords. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first operand for the subtraction in the low halfword, and the + first operand for the addition in the high halfword. + val2: second operand for the subtraction in the high halfword and the + second operand for the addition in the low halfword. + +
Return Value	+ The function returns: + + the subtraction of the high halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the addition of the high halfword in the first operand and the low halfword in the + second operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0x10000 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] - val2[31:16] +res[31:16] = val1[31:16] + val2[15:0] +

Summary	+ +uint32_t __UQASX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of the second operand and perform + one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, saturating the + results to the 16-bit unsigned integer range 0 ≤ x ≤ 2¹⁶ - 1. +
Parameter	+ + val1: first two 16-bit operands. + val2: second two 16-bit operands. + +
Return Value	+ The function returns: + + the subtraction of the high halfword in the second operand from the low halfword + in the first operand, in the low halfword of the return value. + the subtraction of the low halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + The results are saturated to the 16-bit unsigned integer + range 0 ≤ x ≤ 2¹⁶ - 1. + +
Operation	+ +res[15:0] = val1[15:0] - val2[31:16] +res[31:16] = val1[31:16] + val2[15:0] +

Summary	+ +uint32_t __UHASX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of the second operand, add the high + halfwords and subtract the low halfwords, halving the results. +
Parameter	+ + val1: first operand for the subtraction in the low halfword, and the + first operand for the addition in the high halfword. + val2: second operand for the subtraction in the high halfword, and the + second operand for the addition in the low halfword. + +
Return Value	+ The function returns: + + the halved subtraction of the high halfword in the second operand from the low + halfword in the first operand. + the halved addition of the high halfword in the first operand and the low halfword + in the second operand. + +
Operation	+ +res[15:0] = (val1[15:0] - val2[31:16]) >> 1 +res[31:16] = (val1[31:16] + val2[15:0]) >> 1 +

Summary	+ +uint32_t __SSAX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the two halfwords of one operand and perform one + 16-bit integer subtraction and one 16-bit addition. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first operand for the addition in the low halfword, and the first + operand for the subtraction in the high halfword. + val2: second operand for the addition in the high halfword, and the + second operand for the subtraction in the low halfword. + +
Return Value	+ The function returns: + + the addition of the low halfword in the first operand and the high halfword in the + second operand, in the low halfword of the return value. + the subtraction of the low halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] + val2[31:16] +res[31:16] = val1[31:16] - val2[15:0] +

Summary	+ +uint32_t __QSAX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of one operand, then subtract the + high halfwords and add the low halfwords, saturating the results to the 16-bit signed + integer range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. +
Parameter	+ + val1: first operand for the addition in the low halfword, and the first + operand for the subtraction in the high halfword. + val2: second operand for the addition in the high halfword, and the + second operand for the subtraction in the low halfword. + +
Return Value	+ The function returns: + + the saturated addition of the low halfword of the first operand and the high + halfword of the second operand, in the low halfword of the return value. + the saturated subtraction of the low halfword of the second operand from the high + halfword of the first operand, in the high halfword of the return value. + + The returned results are saturated to the 16-bit signed integer + range -2¹⁵ ≤ x ≤ 2¹⁵ - 1. + +
Operation	+ +res[15:0] = val1[15:0] + val2[31:16] +res[31:16] = val1[31:16] - val2[15:0] +

Summary	+ +uint32_t __SHSAX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the two halfwords of one operand, perform one + signed 16-bit integer subtraction and one signed 16-bit addition, and halve the results. +
Parameter	+ + val1: first 16-bit operands. + val2: second 16-bit operands. + +
Return Value	+ The function returns: + + the halved addition of the low halfword in the first operand and the high halfword + in the second operand, in the low halfword of the return value. + the halved subtraction of the low halfword in the second operand from the high + halfword in the first operand, in the high halfword of the return value. + +
Operation	+ +res[15:0] = (val1[15:0] + val2[31:16]) >> 1 +res[31:16] = (val1[31:16] - val2[15:0]) >> 1 +

Summary	+ +uint32_t __USAX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of the second operand, subtract the + high halfwords and add the low halfwords. + The GE bits in the APSR are set according to the results. +
Parameter	+ + val1: first operand for the addition in the low halfword, and the first + operand for the subtraction in the high halfword. + val2: second operand for the addition in the high halfword, and the + second operand for the subtraction in the low halfword. + +
Return Value	+ The function returns: + + the addition of the low halfword in the first operand and the high halfword in the + second operand, in the low halfword of the return value. + the subtraction of the low halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + Each bit in APSR.GE is set or cleared for each byte in the return value, depending on + the results of the operation. + If res is the return value, then: + + + if res[15:0] ≥ 0x10000 then APSR.GE[1:0] = 11 else 00 + if res[31:16] ≥ 0 then APSR.GE[3:2] = 11 else 00 + +
Operation	+ +res[15:0] = val1[15:0] + val2[31:16] +res[31:16] = val1[31:16] - val2[15:0] +

Summary	+ +uint32_t __UQSAX(uint32_t val1, uint32_t val2); +
Description	This function enables you to exchange the halfwords of the second operand and perform + one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturating the + results to the 16-bit unsigned integer range 0 ≤ x ≤ 2¹⁶ - 1. +
Parameter	+ + val1: first 16-bit operand for the addition in the low halfword, and the + first 16-bit operand for the subtraction in the high halfword. + val2: second 16-bit halfword for the addition in the high halfword, + and the second 16-bit halfword for the subtraction in the low halfword. + +
Return Value	+ The function returns: + + the addition of the low halfword in the first operand and the high halfword in the + second operand, in the low halfword of the return value. + the subtraction of the low halfword in the second operand from the high halfword + in the first operand, in the high halfword of the return value. + + The results are saturated to the 16-bit unsigned integer + range 0 ≤ x ≤ 2¹⁶ - 1. + +
Operation	+ +res[15:0] = val1[15:0] + val2[31:16] +res[31:16] = val1[31:16] - val2[15:0] +