1 /* ###################### CMSIS Support for Cortex-M4 SIMD Instructions ####################### */
\r
4 \defgroup intrinsic_SIMD_gr Intrinsic Functions for SIMD Instructions [only Cortex-M4 and Cortex-M7]
\r
5 \brief Access to dedicated SIMD instructions.
\r
9 <b>Single Instruction Multiple Data (SIMD)</b> extensions are provided <b>only for Cortex-M4 and Cortex-M7 cores</b>
\r
10 to simplify development of application software. SIMD extensions increase the processing capability
\r
11 without materially increasing the power consumption. The SIMD extensions are completely transparent
\r
12 to the operating system (OS), allowing existing OS ports to be used.
\r
14 <b>SIMD Features:</b>
\r
16 - Simultaneous computation of 2x16-bit or 4x8-bit operands
\r
17 - Fractional arithmetic
\r
18 - User definable saturation modes (arbitrary word-width)
\r
19 - Dual 16x16 multiply-add/subtract 32x32 fractional MAC
\r
20 - Simultaneous 8/16-bit select operations
\r
21 - Performance up to 3.2 GOPS at 800MHz
\r
22 - Performance is achieved with a "near zero" increase in power consumption on a typical implementation
\r
26 \b Addition: Add two values using SIMD function
\r
29 uint32_t add_halfwords(uint32_t val1, uint32_t val2)
\r
31 return __SADD16(val1, val2);
\r
37 \b Subtraction: Subtract two values using SIMD function
\r
40 uint32_t sub_halfwords(uint32_t val1, uint32_t val2)
\r
42 return __SSUB16(val1, val2);
\r
47 \b Multiplication: Performing a multiplication using SIMD function
\r
50 uint32_t dual_mul_add_products(uint32_t val1, uint32_t val2)
\r
52 return __SMUAD(val1, val2);
\r
60 /**************************************************************************************************/
\r
62 \brief GE setting quad 8-bit signed addition
\r
63 \details This function performs four 8-bit signed integer additions.
\r
64 The GE bits of the APSR are set according to the results of the additions.
\r
65 \param val1 first four 8-bit summands.
\r
66 \param val2 second four 8-bit summands.
\r
69 \li the addition of the first bytes from each operand, in the first byte of the return value.
\r
70 \li the addition of the second bytes of each operand, in the second byte of the return value.
\r
71 \li the addition of the third bytes of each operand, in the third byte of the return value.
\r
72 \li the addition of the fourth bytes of each operand, in the fourth byte of the return value.
\r
74 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
75 the results of the operation.
\r
77 If \em res is the return value, then:
\r
78 \li if res[7:0] \>= 0 then APSR.GE[0] = 1 else 0
\r
79 \li if res[15:8] \>= 0 then APSR.GE[1] = 1 else 0
\r
80 \li if res[23:16] \>= 0 then APSR.GE[2] = 1 else 0
\r
81 \li if res[31:24] \>= 0 then APSR.GE[3] = 1 else 0
\r
85 res[7:0] = val1[7:0] + val2[7:0]
\r
86 res[15:8] = val1[15:8] + val2[15:8]
\r
87 res[23:16] = val1[23:16] + val2[23:16]
\r
88 res[31:24] = val1[31:24] + val2[31:24]
\r
91 uint32_t __SADD8(uint32_t val1, uint32_t val2);
\r
94 /**************************************************************************************************/
\r
95 /** \ingroup Intrinsic_SIMD_gr
\r
96 \brief Q setting quad 8-bit saturating addition
\r
97 \details This function enables you to perform four 8-bit integer additions, saturating the results to
\r
98 the 8-bit signed integer range -2<sup>7</sup> \<= x \<= 2<sup>7</sup> - 1.
\r
99 \param val1 first four 8-bit summands.
\r
100 \param val2 second four 8-bit summands.
\r
103 \li the saturated addition of the first byte of each operand in the first byte of the return value.
\r
104 \li the saturated addition of the second byte of each operand in the second byte of the return value.
\r
105 \li the saturated addition of the third byte of each operand in the third byte of the return value.
\r
106 \li the saturated addition of the fourth byte of each operand in the fourth byte of the return value.
\r
108 The returned results are saturated to the 16-bit signed integer range -2<sup>7</sup> \<= x \<= 2<sup>7</sup> - 1.
\r
112 res[7:0] = val1[7:0] + val2[7:0]
\r
113 res[15:8] = val1[15:8] + val2[15:8]
\r
114 res[23:16] = val1[23:16] + val2[23:16]
\r
115 res[31:24] = val1[31:24] + val2[31:24]
\r
118 uint32_t __QADD8(uint32_t val1, uint32_t val2);
\r
121 /**************************************************************************************************/
\r
123 \brief Quad 8-bit signed addition with halved results
\r
124 \details This function enables you to perform four signed 8-bit integer additions, halving the results.
\r
125 \param val1 first four 8-bit summands.
\r
126 \param val2 second four 8-bit summands.
\r
129 \li the halved addition of the first bytes from each operand, in the first byte of the return value.
\r
130 \li the halved addition of the second bytes from each operand, in the second byte of the return value.
\r
131 \li the halved addition of the third bytes from each operand, in the third byte of the return value.
\r
132 \li the halved addition of the fourth bytes from each operand, in the fourth byte of the return value.
\r
136 res[7:0] = val1[7:0] + val2[7:0] >> 1
\r
137 res[15:8] = val1[15:8] + val2[15:8] >> 1
\r
138 res[23:16] = val1[23:16] + val2[23:16] >> 1
\r
139 res[31:24] = val1[31:24] + val2[31:24] >> 1
\r
142 uint32_t __SHADD8(uint32_t val1, uint32_t val2);
\r
145 /**************************************************************************************************/
\r
146 /** \ingroup Intrinsic_SIMD_gr
\r
147 \brief GE setting quad 8-bit unsigned addition
\r
149 \details This function enables you to perform four unsigned 8-bit integer additions.
\r
150 The GE bits of the APSR are set according to the results.
\r
152 \param val1 first four 8-bit summands for each addition.
\r
153 \param val2 second four 8-bit summands for each addition.
\r
156 \li the halved addition of the first bytes from each operand, in the first byte of the return value.
\r
157 \li the halved addition of the second bytes from each operand, in the second byte of the return value.
\r
158 \li the halved addition of the third bytes from each operand, in the third byte of the return value.
\r
159 \li the halved addition of the fourth bytes from each operand, in the fourth byte of the return value.
\r
162 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on the results of the operation.
\r
165 If \em res is the return value, then:
\r
166 \li if res[7:0] \>= 0x100 then APSR.GE[0] = 1 else 0
\r
167 \li if res[15:8] \>= 0x100 then APSR.GE[1] = 1 else 0
\r
168 \li if res[23:16] \>= 0x100 then APSR.GE[2] = 1 else 0
\r
169 \li if res[31:24] \>= 0x100 then APSR.GE[3] = 1 else 0
\r
173 res[7:0] = val1[7:0] + val2[7:0]
\r
174 res[15:8] = val1[15:8] + val2[15:8]
\r
175 res[23:16] = val1[23:16] + val2[23:16]
\r
176 res[31:24] = val1[31:24] + val2[31:24]
\r
179 uint32_t __UADD8(uint32_t val1, uint32_t val2);
\r
182 /**************************************************************************************************/
\r
184 \brief Quad 8-bit unsigned saturating addition
\r
186 \details This function enables you to perform four unsigned 8-bit integer additions, saturating the
\r
187 results to the 8-bit unsigned integer range 0 \< x \< 2<sup>8</sup> - 1.
\r
189 \param val1 first four 8-bit summands.
\r
190 \param val2 second four 8-bit summands.
\r
193 \li the halved addition of the first bytes in each operand, in the first byte of the return value.
\r
194 \li the halved addition of the second bytes in each operand, in the second byte of the return value.
\r
195 \li the halved addition of the third bytes in each operand, in the third byte of the return value.
\r
196 \li the halved addition of the fourth bytes in each operand, in the fourth byte of the return value.
\r
199 The results are saturated to the 8-bit unsigned integer range 0 \< x \< 2<sup>8</sup> - 1.
\r
203 res[7:0] = val1[7:0] + val2[7:0]
\r
204 res[15:8] = val1[15:8] + val2[15:8]
\r
205 res[23:16] = val1[23:16] + val2[23:16]
\r
206 res[31:24] = val1[31:24] + val2[31:24]
\r
209 uint32_t __UQADD8(uint32_t val1, uint32_t val2);
\r
212 /**************************************************************************************************/
\r
214 \brief Quad 8-bit unsigned addition with halved results
\r
216 \details This function enables you to perform four unsigned 8-bit integer additions, halving the results.
\r
218 \param val1 first four 8-bit summands.
\r
219 \param val2 second four 8-bit summands.
\r
222 \li the halved addition of the first bytes in each operand, in the first byte of the return value.
\r
223 \li the halved addition of the second bytes in each operand, in the second byte of the return value.
\r
224 \li the halved addition of the third bytes in each operand, in the third byte of the return value.
\r
225 \li the halved addition of the fourth bytes in each operand, in the fourth byte of the return value.
\r
229 res[7:0] = val1[7:0] + val2[7:0] >> 1
\r
230 res[15:8] = val1[15:8] + val2[15:8] >> 1
\r
231 res[23:16] = val1[23:16] + val2[23:16] >> 1
\r
232 res[31:24] = val1[31:24] + val2[31:24] >> 1
\r
235 uint32_t __UHADD8(uint32_t val1, uint32_t val2);
\r
238 /**************************************************************************************************/
\r
240 \brief GE setting quad 8-bit signed subtraction
\r
242 \details This function enables you to perform four 8-bit signed integer subtractions.<br>
\r
243 The GE bits in the APSR are set according to the results.
\r
245 \param val1 first four 8-bit operands of each subtraction.
\r
246 \param val2 second four 8-bit operands of each subtraction.
\r
249 \li the subtraction of the first byte in the second operand from the first byte in the
\r
250 first operand, in the first bytes of the return value.
\r
251 \li the subtraction of the second byte in the second operand from the second byte in
\r
252 the first operand, in the second byte of the return value.
\r
253 \li the subtraction of the third byte in the second operand from the third byte in the
\r
254 first operand, in the third byte of the return value.
\r
255 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
256 the first operand, in the fourth byte of the return value.
\r
258 \par Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
259 the results of the operation.
\r
262 If \em res is the return value, then:
\r
263 \li if res[8:0] \>= 0 then APSR.GE[0] = 1 else 0
\r
264 \li if res[15:8] \>= 0 then APSR.GE[1] = 1 else 0
\r
265 \li if res[23:16] \>= 0 then APSR.GE[2] = 1 else 0
\r
266 \li if res[31:24] \>= 0 then APSR.GE[3] = 1 else 0
\r
271 res[7:0] = val1[7:0] - val2[7:0]
\r
272 res[15:8] = val1[15:8] - val2[15:8]
\r
273 res[23:16] = val1[23:16] - val2[23:16]
\r
274 res[31:24] = val1[31:24] - val2[31:24]
\r
277 uint32_t __SSUB8(uint32_t val1, uint32_t val2);
\r
280 /**************************************************************************************************/
\r
282 \brief Q setting quad 8-bit saturating subtract
\r
284 \details This function enables you to perform four 8-bit integer subtractions, saturating the results
\r
285 to the 8-bit signed integer range -2<sup>7</sup> \<= x \<= 2<sup>7</sup> - 1.
\r
287 \param val1 first four 8-bit operands.
\r
288 \param val2 second four 8-bit operands.
\r
291 \li the subtraction of the first byte in the second operand from the first byte in the
\r
292 first operand, in the first bytes of the return value.
\r
293 \li the subtraction of the second byte in the second operand from the second byte in
\r
294 the first operand, in the second byte of the return value.
\r
295 \li the subtraction of the third byte in the second operand from the third byte in the
\r
296 first operand, in the third byte of the return value.
\r
297 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
298 the first operand, in the fourth byte of the return value.
\r
301 The returned results are saturated to the 8-bit signed integer range -2<sup>7</sup> \<= x \<= 2<sup>7</sup> - 1.
\r
306 res[7:0] = val1[7:0] - val2[7:0]
\r
307 res[15:8] = val1[15:8] - val2[15:8]
\r
308 res[23:16] = val1[23:16] - val2[23:16]
\r
309 res[31:24] = val1[31:24] - val2[31:24]
\r
312 uint32_t __QSUB8(uint32_t val1, uint32_t val2);
\r
315 /**************************************************************************************************/
\r
317 \brief Quad 8-bit signed subtraction with halved results
\r
319 \details This function enables you to perform four signed 8-bit integer subtractions, halving the
\r
322 \param val1 first four 8-bit operands.
\r
323 \param val2 second four 8-bit operands.
\r
326 \li the halved subtraction of the first byte in the second operand from the first byte in the
\r
327 first operand, in the first bytes of the return value.
\r
328 \li the halved subtraction of the second byte in the second operand from the second byte in
\r
329 the first operand, in the second byte of the return value.
\r
330 \li the halved subtraction of the third byte in the second operand from the third byte in the
\r
331 first operand, in the third byte of the return value.
\r
332 \li the halved subtraction of the fourth byte in the second operand from the fourth byte in
\r
333 the first operand, in the fourth byte of the return value.
\r
337 res[7:0] = val1[7:0] - val2[7:0] >> 1
\r
338 res[15:8] = val1[15:8] - val2[15:8] >> 1
\r
339 res[23:16] = val1[23:16] - val2[23:16] >> 1
\r
340 res[31:24] = val1[31:24] - val2[31:24] >> 1
\r
343 uint32_t __SHSUB8(uint32_t val1, uint32_t val2);
\r
346 /**************************************************************************************************/
\r
348 \brief GE setting quad 8-bit unsigned subtract
\r
350 \details This function enables you to perform four 8-bit unsigned integer subtractions.
\r
351 The GE bits in the APSR are set according to the results.
\r
353 \param val1 first four 8-bit operands.
\r
354 \param val2 second four 8-bit operands.
\r
357 \li the subtraction of the first byte in the second operand from the first byte in the
\r
358 first operand, in the first bytes of the return value.
\r
359 \li the subtraction of the second byte in the second operand from the second byte in
\r
360 the first operand, in the second byte of the return value.
\r
361 \li the subtraction of the third byte in the second operand from the third byte in the
\r
362 first operand, in the third byte of the return value.
\r
363 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
364 the first operand, in the fourth byte of the return value.
\r
367 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
368 the results of the operation.
\r
371 If \em res is the return value, then:
\r
372 \li if res[8:0] \>= 0 then APSR.GE[0] = 1 else 0
\r
373 \li if res[15:8] \>= 0 then APSR.GE[1] = 1 else 0
\r
374 \li if res[23:16] \>= 0 then APSR.GE[2] = 1 else 0
\r
375 \li if res[31:24] \>= 0 then APSR.GE[3] = 1 else 0
\r
380 res[7:0] = val1[7:0] - val2[7:0]
\r
381 res[15:8] = val1[15:8] - val2[15:8]
\r
382 res[23:16] = val1[23:16] - val2[23:16]
\r
383 res[31:24] = val1[31:24] - val2[31:24]
\r
386 uint32_t __USUB8(uint32_t val1, uint32_t val2);
\r
389 /**************************************************************************************************/
\r
391 \brief Quad 8-bit unsigned saturating subtraction
\r
393 \details This function enables you to perform four unsigned 8-bit integer subtractions, saturating
\r
394 the results to the 8-bit unsigned integer range 0 \< x \< 2<sup>8</sup> - 1.
\r
396 \param val1 first four 8-bit operands.
\r
397 \param val2 second four 8-bit operands.
\r
400 \li the subtraction of the first byte in the second operand from the first byte in the
\r
401 first operand, in the first bytes of the return value.
\r
402 \li the subtraction of the second byte in the second operand from the second byte in
\r
403 the first operand, in the second byte of the return value.
\r
404 \li the subtraction of the third byte in the second operand from the third byte in the
\r
405 first operand, in the third byte of the return value.
\r
406 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
407 the first operand, in the fourth byte of the return value.
\r
410 The results are saturated to the 8-bit unsigned integer range 0 \< x \< 2<sup>8</sup> - 1.
\r
415 res[7:0] = val1[7:0] - val2[7:0]
\r
416 res[15:8] = val1[15:8] - val2[15:8]
\r
417 res[23:16] = val1[23:16] - val2[23:16]
\r
418 res[31:24] = val1[31:24] - val2[31:24]
\r
421 uint32_t __UQSUB8(uint32_t val1, uint32_t val2);
\r
424 /**************************************************************************************************/
\r
426 \brief Quad 8-bit unsigned subtraction with halved results
\r
428 \details This function enables you to perform four unsigned 8-bit integer subtractions, halving the
\r
431 \param val1 first four 8-bit operands.
\r
432 \param val2 second four 8-bit operands.
\r
435 \li the halved subtraction of the first byte in the second operand from the first byte in the
\r
436 first operand, in the first bytes of the return value.
\r
437 \li the halved subtraction of the second byte in the second operand from the second byte in
\r
438 the first operand, in the second byte of the return value.
\r
439 \li the halved subtraction of the third byte in the second operand from the third byte in the
\r
440 first operand, in the third byte of the return value.
\r
441 \li the halved subtraction of the fourth byte in the second operand from the fourth byte in
\r
442 the first operand, in the fourth byte of the return value.
\r
446 res[7:0] = val1[7:0] - val2[7:0] >> 1
\r
447 res[15:8] = val1[15:8] - val2[15:8] >> 1
\r
448 res[23:16] = val1[23:16] - val2[23:16] >> 1
\r
449 res[31:24] = val1[31:24] - val2[31:24] >> 1
\r
452 uint32_t __UHSUB8(uint32_t val1, uint32_t val2);
\r
455 /**************************************************************************************************/
\r
457 \brief GE setting dual 16-bit signed addition
\r
459 \details This function enables you to perform two 16-bit signed integer additions.<br>
\r
460 The GE bits in the APSR are set according to the results of the additions.
\r
462 \param val1 first two 16-bit summands.
\r
463 \param val2 second two 16-bit summands.
\r
466 \li the addition of the low halfwords in the low halfword of the return value.
\r
467 \li the addition of the high halfwords in the high halfword of the return value.
\r
470 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
471 the results of the operation.
\r
473 If \em res is the return value, then:
\r
474 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
475 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
480 res[15:0] = val1[15:0] + val2[15:0]
\r
481 res[31:16] = val1[31:16] + val2[31:16]
\r
484 uint32_t __SADD16(uint32_t val1, uint32_t val2);
\r
487 /**************************************************************************************************/
\r
489 \brief Q setting dual 16-bit saturating addition
\r
491 \details This function enables you to perform two 16-bit integer arithmetic additions in parallel,
\r
492 saturating the results to the 16-bit signed integer range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
494 \param val1 first two 16-bit summands.
\r
495 \param val2 second two 16-bit summands.
\r
498 \li the saturated addition of the low halfwords, in the low halfword of the return value.
\r
499 \li the saturated addition of the high halfwords, in the high halfword of the return value.
\r
502 The returned results are saturated to the 16-bit signed integer
\r
503 range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1
\r
507 res[15:0] = val1[15:0] + val2[15:0]
\r
508 res[31:16] = val1[31:16] + val2[31:16]
\r
511 uint32_t __QADD16(uint32_t val1, uint32_t val2);
\r
514 /**************************************************************************************************/
\r
516 \brief Dual 16-bit signed addition with halved results
\r
518 \details This function enables you to perform two signed 16-bit integer additions, halving the
\r
521 \param val1 first two 16-bit summands.
\r
522 \param val2 second two 16-bit summands.
\r
525 \li the halved addition of the low halfwords, in the low halfword of the return value.
\r
526 \li the halved addition of the high halfwords, in the high halfword of the return value.
\r
530 res[15:0] = val1[15:0] + val2[15:0] >> 1
\r
531 res[31:16] = val1[31:16] + val2[31:16] >> 1
\r
534 uint32_t __SHADD16(uint32_t val1, uint32_t val2);
\r
537 /**************************************************************************************************/
\r
539 \brief GE setting dual 16-bit unsigned addition
\r
541 \details This function enables you to perform two 16-bit unsigned integer additions.<br>
\r
542 The GE bits in the APSR are set according to the results.
\r
544 \param val1 first two 16-bit summands for each addition.
\r
545 \param val2 second two 16-bit summands for each addition.
\r
548 \li the addition of the low halfwords in each operand, in the low halfword of the
\r
550 \li the addition of the high halfwords in each operand, in the high halfword of the
\r
554 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
555 the results of the operation.
\r
557 If \em res is the return value, then:
\r
558 \li if res[15:0] \>= 0x10000 then APSR.GE[0] = 11 else 00
\r
559 \li if res[31:16] \>= 0x10000 then APSR.GE[1] = 11 else 00
\r
563 res[15:0] = val1[15:0] + val2[15:0]
\r
564 res[31:16] = val1[31:16] + val2[31:16]
\r
567 uint32_t __UADD16(uint32_t val1, uint32_t val2);
\r
570 /**************************************************************************************************/
\r
572 \brief Dual 16-bit unsigned saturating addition
\r
574 \details This function enables you to perform two unsigned 16-bit integer additions, saturating the
\r
575 results to the 16-bit unsigned integer range 0 \< x \< 2<sup>16</sup> - 1.
\r
577 \param val1 first two 16-bit summands.
\r
578 \param val2 second two 16-bit summands.
\r
581 \li the addition of the low halfword in the first operand and the low halfword in the
\r
582 second operand, in the low halfword of the return value.
\r
583 \li the addition of the high halfword in the first operand and the high halfword in the
\r
584 second operand, in the high halfword of the return value.
\r
587 The results are saturated to the 16-bit unsigned integer
\r
588 range 0 \< x \< 2<sup>16</sup> - 1.
\r
592 res[15:0] = val1[15:0] + val2[15:0]
\r
593 res[31:16] = val1[31:16] + val2[31:16]
\r
596 uint32_t __UQADD16(uint32_t val1, uint32_t val2);
\r
599 /**************************************************************************************************/
\r
601 \brief Dual 16-bit unsigned addition with halved results
\r
603 \details This function enables you to perform two unsigned 16-bit integer additions, halving the
\r
606 \param val1 first two 16-bit summands.
\r
607 \param val2 second two 16-bit summands.
\r
610 \li the halved addition of the low halfwords in each operand, in the low halfword of
\r
612 \li the halved addition of the high halfwords in each operand, in the high halfword
\r
613 of the return value.
\r
617 res[15:0] = val1[15:0] + val2[15:0] >> 1
\r
618 res[31:16] = val1[31:16] + val2[31:16] >> 1
\r
621 uint32_t __UHADD16(uint32_t val1, uint32_t val2);
\r
624 /**************************************************************************************************/
\r
626 \brief GE setting dual 16-bit signed subtraction
\r
628 \details This function enables you to perform two 16-bit signed integer subtractions.<br>
\r
629 The GE bits in the APSR are set according to the results.
\r
631 \param val1 first two 16-bit operands of each subtraction.
\r
632 \param val2 second two 16-bit operands of each subtraction.
\r
635 \li the subtraction of the low halfword in the second operand from the low halfword
\r
636 in the first operand, in the low halfword of the return value.
\r
637 \li the subtraction of the high halfword in the second operand from the high halfword
\r
638 in the first operand, in the high halfword of the return value.
\r
641 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
642 the results of the operation.
\r
644 If \li res is the return value, then:
\r
645 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
646 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
651 res[15:0] = val1[15:0] - val2[15:0]
\r
652 res[31:16] = val1[31:16] - val2[31:16]
\r
655 uint32_t __SSUB16(uint32_t val1, uint32_t val2);
\r
658 /**************************************************************************************************/
\r
660 \brief Q setting dual 16-bit saturating subtract
\r
662 \details This function enables you to perform two 16-bit integer subtractions, saturating the
\r
663 results to the 16-bit signed integer range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
665 \param val1 first two 16-bit operands.
\r
666 \param val2 second two 16-bit operands.
\r
669 \li the saturated subtraction of the low halfword in the second operand from the low
\r
670 halfword in the first operand, in the low halfword of the returned result.
\r
671 \li the saturated subtraction of the high halfword in the second operand from the high
\r
672 halfword in the first operand, in the high halfword of the returned result.
\r
675 The returned results are saturated to the 16-bit signed integer
\r
676 range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
680 res[15:0] = val1[15:0] - val2[15:0]
\r
681 res[31:16] = val1[31:16] - val2[31:16]
\r
684 uint32_t __QSUB16(uint32_t val1, uint32_t val2);
\r
687 /**************************************************************************************************/
\r
689 \brief Dual 16-bit signed subtraction with halved results
\r
691 \details This function enables you to perform two signed 16-bit integer subtractions, halving the
\r
694 \param val1 first two 16-bit operands.
\r
695 \param val2 second two 16-bit operands.
\r
698 \li the halved subtraction of the low halfword in the second operand from the low
\r
699 halfword in the first operand, in the low halfword of the returned result.
\r
700 \li the halved subtraction of the high halfword in the second operand from the high
\r
701 halfword in the first operand, in the high halfword of the returned result.
\r
706 res[15:0] = val1[15:0] - val2[15:0] >> 1
\r
707 res[31:16] = val1[31:16] - val2[31:16] >> 1
\r
710 uint32_t __SHSUB16(uint32_t val1, uint32_t val2);
\r
713 /**************************************************************************************************/
\r
715 \brief GE setting dual 16-bit unsigned subtract
\r
717 \details This function enables you to perform two 16-bit unsigned integer subtractions.<br>
\r
718 The GE bits in the APSR are set according to the results.
\r
720 \param val1 first two 16-bit operands.
\r
721 \param val2 second two 16-bit operands.
\r
724 \li the subtraction of the low halfword in the second operand from the low halfword
\r
725 in the first operand, in the low halfword of the return value.
\r
726 \li the subtraction of the high halfword in the second operand from the high halfword
\r
727 in the first operand, in the high halfword of the return value.
\r
730 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
731 the results of the operation.
\r
734 If \em res is the return value, then:
\r
735 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
736 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
740 res[15:0] = val1[15:0] - val2[15:0]
\r
741 res[31:16] = val1[31:16] - val2[31:16]
\r
744 uint32_t __USUB16(uint32_t val1, uint32_t val2);
\r
747 /**************************************************************************************************/
\r
749 \brief Dual 16-bit unsigned saturating subtraction
\r
751 \details This function enables you to perform two unsigned 16-bit integer subtractions, saturating
\r
752 the results to the 16-bit unsigned integer range 0 \< x \< 2<sup>16</sup> - 1.
\r
754 \param val1 first two 16-bit operands for each subtraction.
\r
755 \param val2 second two 16-bit operands for each subtraction.
\r
758 \li the subtraction of the low halfword in the second operand from the low halfword
\r
759 in the first operand, in the low halfword of the return value.
\r
760 \li the subtraction of the high halfword in the second operand from the high halfword
\r
761 in the first operand, in the high halfword of the return value.
\r
764 The results are saturated to the 16-bit unsigned integer range 0 \< x \< 2<sup>16</sup> - 1.
\r
769 res[15:0] = val1[15:0] - val2[15:0]
\r
770 res[31:16] = val1[31:16] - val2[31:16]
\r
773 uint32_t __UQSUB16(uint32_t val1, uint32_t val2);
\r
776 /**************************************************************************************************/
\r
778 \brief Dual 16-bit unsigned subtraction with halved results
\r
780 \details This function enables you to perform two unsigned 16-bit integer subtractions, halving
\r
783 \param val1 first two 16-bit operands.
\r
784 \param val2 second two 16-bit operands.
\r
787 \li the halved subtraction of the low halfword in the second operand from the low halfword
\r
788 in the first operand, in the low halfword of the return value.
\r
789 \li the halved subtraction of the high halfword in the second operand from the high halfword
\r
790 in the first operand, in the high halfword of the return value.
\r
795 res[15:0] = val1[15:0] - val2[15:0] >> 1
\r
796 res[31:16] = val1[31:16] - val2[31:16] >> 1
\r
799 uint32_t __UHSUB16(uint32_t val1, uint32_t val2);
\r
802 /**************************************************************************************************/
\r
804 \brief GE setting dual 16-bit addition and subtraction with exchange
\r
806 \details This function inserts an SASX instruction into the instruction stream generated by the
\r
807 compiler. It enables you to exchange the halfwords of the second operand, add the high
\r
808 halfwords and subtract the low halfwords.<br>
\r
809 The GE bits in the APRS are set according to the results.
\r
811 \param val1 first operand for the subtraction in the low halfword, and the
\r
812 first operand for the addition in the high halfword.
\r
813 \param val2 second operand for the subtraction in the high halfword, and the
\r
814 second operand for the addition in the low halfword.
\r
817 \li the subtraction of the high halfword in the second operand from the low halfword
\r
818 in the first operand, in the low halfword of the return value.
\r
819 \li the addition of the high halfword in the first operand and the low halfword in the
\r
820 second operand, in the high halfword of the return value.
\r
823 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
824 the results of the operation.
\r
826 If \em res is the return value, then:
\r
827 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
828 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
832 res[15:0] = val1[15:0] - val2[31:16]
\r
833 res[31:16] = val1[31:16] + val2[15:0]
\r
836 uint32_t __SASX(uint32_t val1, uint32_t val2);
\r
839 /**************************************************************************************************/
\r
841 \brief Q setting dual 16-bit add and subtract with exchange
\r
843 \details This function enables you to exchange the halfwords of the one operand, then add the high
\r
844 halfwords and subtract the low halfwords, saturating the results to the 16-bit signed
\r
845 integer range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
847 \param val1 first operand for the subtraction in the low halfword, and the
\r
848 first operand for the addition in the high halfword.
\r
849 \param val2 second operand for the subtraction in the high halfword, and the
\r
850 second operand for the addition in the low halfword.
\r
853 \li the saturated subtraction of the high halfword in the second operand from the low
\r
854 halfword in the first operand, in the low halfword of the return value.
\r
855 \li the saturated addition of the high halfword in the first operand and the low
\r
856 halfword in the second operand, in the high halfword of the return value.
\r
859 The returned results are saturated to the 16-bit signed integer
\r
860 range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
864 res[15:0] = val1[15:0] - val2[31:16]
\r
865 res[31:16] = val1[31:16] + val2[15:0]
\r
868 uint32_t __QASX(uint32_t val1, uint32_t val2);
\r
871 /**************************************************************************************************/
\r
873 \brief Dual 16-bit signed addition and subtraction with halved results
\r
875 \details This function enables you to exchange the two halfwords of one operand, perform one
\r
876 signed 16-bit integer addition and one signed 16-bit subtraction, and halve the results.
\r
878 \param val1 first 16-bit operands.
\r
879 \param val2 second 16-bit operands.
\r
882 \li the halved subtraction of the high halfword in the second operand from the low
\r
883 halfword in the first operand, in the low halfword of the return value.
\r
884 \li the halved subtraction of the low halfword in the second operand from the high
\r
885 halfword in the first operand, in the high halfword of the return value.
\r
889 res[15:0] = (val1[15:0] - val2[31:16]) >> 1
\r
890 res[31:16] = (val1[31:16] - val2[15:0] ) >> 1
\r
893 uint32_t __SHASX(uint32_t val1, uint32_t val2);
\r
896 /**************************************************************************************************/
\r
898 \brief GE setting dual 16-bit unsigned addition and subtraction with exchange
\r
900 \details This function enables you to exchange the two halfwords of the second operand, add the
\r
901 high halfwords and subtract the low halfwords.<br>
\r
902 The GE bits in the APSR are set according to the results.
\r
904 \param val1 first operand for the subtraction in the low halfword, and the
\r
905 first operand for the addition in the high halfword.
\r
906 \param val2 second operand for the subtraction in the high halfword and the
\r
907 second operand for the addition in the low halfword.
\r
910 \li the subtraction of the high halfword in the second operand from the low halfword
\r
911 in the first operand, in the low halfword of the return value.
\r
912 \li the addition of the high halfword in the first operand and the low halfword in the
\r
913 second operand, in the high halfword of the return value.
\r
916 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
917 the results of the operation.
\r
919 \par If \em res is the return value, then:
\r
920 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
921 \li if res[31:16] \>= 0x10000 then APSR.GE[3:2] = 11 else 00
\r
925 res[15:0] = val1[15:0] - val2[31:16]
\r
926 res[31:16] = val1[31:16] + val2[15:0]
\r
929 uint32_t __UASX(uint32_t val1, uint32_t val2);
\r
932 /**************************************************************************************************/
\r
934 \brief Dual 16-bit unsigned saturating addition and subtraction with exchange
\r
936 \details This function enables you to exchange the halfwords of the second operand and perform
\r
937 one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, saturating the
\r
938 results to the 16-bit unsigned integer range 0 \<= x \<= 2<sup>16</sup> - 1.
\r
940 \param val1 first two 16-bit operands.
\r
941 \param val2 second two 16-bit operands.
\r
944 \li the subtraction of the high halfword in the second operand from the low halfword
\r
945 in the first operand, in the low halfword of the return value.
\r
946 \li the subtraction of the low halfword in the second operand from the high halfword
\r
947 in the first operand, in the high halfword of the return value.
\r
950 The results are saturated to the 16-bit unsigned integer
\r
951 range 0 \<= x \<= 2<sup>16</sup> - 1.
\r
955 res[15:0] = val1[15:0] - val2[31:16]
\r
956 res[31:16] = val1[31:16] + val2[15:0]
\r
959 uint32_t __UQASX(uint32_t val1, uint32_t val2);
\r
962 /**************************************************************************************************/
\r
964 \brief Dual 16-bit unsigned addition and subtraction with halved results and exchange
\r
966 \details This function enables you to exchange the halfwords of the second operand, add the high
\r
967 halfwords and subtract the low halfwords, halving the results.
\r
969 \param val1 first operand for the subtraction in the low halfword, and the
\r
970 first operand for the addition in the high halfword.
\r
971 \param val2 second operand for the subtraction in the high halfword, and the
\r
972 second operand for the addition in the low halfword.
\r
975 \li the halved subtraction of the high halfword in the second operand from the low
\r
976 halfword in the first operand.
\r
977 \li the halved addition of the high halfword in the first operand and the low halfword
\r
978 in the second operand.
\r
983 res[15:0] = (val1[15:0] - val2[31:16]) >> 1
\r
984 res[31:16] = (val1[31:16] + val2[15:0] ) >> 1
\r
987 uint32_t __UHASX(uint32_t val1, uint32_t val2);
\r
990 /**************************************************************************************************/
\r
992 \brief GE setting dual 16-bit signed subtraction and addition with exchange
\r
994 \details This function enables you to exchange the two halfwords of one operand and perform one
\r
995 16-bit integer subtraction and one 16-bit addition.<br>
\r
996 The GE bits in the APSR are set according to the results.
\r
998 \param val1 first operand for the addition in the low halfword, and the first
\r
999 operand for the subtraction in the high halfword.
\r
1000 \param val2 second operand for the addition in the high halfword, and the
\r
1001 second operand for the subtraction in the low halfword.
\r
1004 \li the addition of the low halfword in the first operand and the high halfword in the
\r
1005 second operand, in the low halfword of the return value.
\r
1006 \li the subtraction of the low halfword in the second operand from the high halfword
\r
1007 in the first operand, in the high halfword of the return value.
\r
1009 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
1010 the results of the operation.
\r
1012 If \em res is the return value, then:
\r
1013 \li if res[15:0] \>= 0 then APSR.GE[1:0] = 11 else 00
\r
1014 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
1018 res[15:0] = val1[15:0] + val2[31:16]
\r
1019 res[31:16] = val1[31:16] - val2[15:0]
\r
1022 uint32_t __SSAX(uint32_t val1, uint32_t val2);
\r
1025 /**************************************************************************************************/
\r
1027 \brief Q setting dual 16-bit subtract and add with exchange
\r
1029 \details This function enables you to exchange the halfwords of one operand, then subtract the
\r
1030 high halfwords and add the low halfwords, saturating the results to the 16-bit signed
\r
1031 integer range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
1033 \param val1 first operand for the addition in the low halfword, and the first
\r
1034 operand for the subtraction in the high halfword.
\r
1035 \param val2 second operand for the addition in the high halfword, and the
\r
1036 second operand for the subtraction in the low halfword.
\r
1039 \li the saturated addition of the low halfword of the first operand and the high
\r
1040 halfword of the second operand, in the low halfword of the return value.
\r
1041 \li the saturated subtraction of the low halfword of the second operand from the high
\r
1042 halfword of the first operand, in the high halfword of the return value.
\r
1044 The returned results are saturated to the 16-bit signed integer
\r
1045 range -2<sup>15</sup> \<= x \<= 2<sup>15</sup> - 1.
\r
1049 res[15:0] = val1[15:0] + val2[31:16]
\r
1050 res[31:16] = val1[31:16] - val2[15:0]
\r
1053 uint32_t __QSAX(uint32_t val1, uint32_t val2);
\r
1056 /**************************************************************************************************/
\r
1058 \brief Dual 16-bit signed subtraction and addition with halved results
\r
1060 \details This function enables you to exchange the two halfwords of one operand, perform one
\r
1061 signed 16-bit integer subtraction and one signed 16-bit addition, and halve the results.
\r
1063 \param val1 first 16-bit operands.
\r
1064 \param val2 second 16-bit operands.
\r
1067 \li the halved addition of the low halfword in the first operand and the high halfword
\r
1068 in the second operand, in the low halfword of the return value.
\r
1069 \li the halved subtraction of the low halfword in the second operand from the high
\r
1070 halfword in the first operand, in the high halfword of the return value.
\r
1074 res[15:0] = (val1[15:0] + val2[31:16]) >> 1
\r
1075 res[31:16] = (val1[31:16] - val2[15:0] ) >> 1
\r
1078 uint32_t __SHSAX(uint32_t val1, uint32_t val2);
\r
1081 /**************************************************************************************************/
\r
1083 \brief GE setting dual 16-bit unsigned subtract and add with exchange
\r
1085 \details This function enables you to exchange the halfwords of the second operand, subtract the
\r
1086 high halfwords and add the low halfwords.<br>
\r
1087 The GE bits in the APSR are set according to the results.
\r
1089 \param val1 first operand for the addition in the low halfword, and the first
\r
1090 operand for the subtraction in the high halfword.
\r
1091 \param val2 second operand for the addition in the high halfword, and the
\r
1092 second operand for the subtraction in the low halfword.
\r
1095 \li the addition of the low halfword in the first operand and the high halfword in the
\r
1096 second operand, in the low halfword of the return value.
\r
1097 \li the subtraction of the low halfword in the second operand from the high halfword
\r
1098 in the first operand, in the high halfword of the return value.
\r
1100 Each bit in APSR.GE is set or cleared for each byte in the return value, depending on
\r
1101 the results of the operation.
\r
1103 If \em res is the return value, then:
\r
1104 \li if res[15:0] \>= 0x10000 then APSR.GE[1:0] = 11 else 00
\r
1105 \li if res[31:16] \>= 0 then APSR.GE[3:2] = 11 else 00
\r
1109 res[15:0] = val1[15:0] + val2[31:16]
\r
1110 res[31:16] = val1[31:16] - val2[15:0]
\r
1113 uint32_t __USAX(uint32_t val1, uint32_t val2);
\r
1116 /**************************************************************************************************/
\r
1118 \brief Dual 16-bit unsigned saturating subtraction and addition with exchange
\r
1120 \details This function enables you to exchange the halfwords of the second operand and perform
\r
1121 one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturating the
\r
1122 results to the 16-bit unsigned integer range 0 \<= x \<= 2<sup>16</sup> - 1.
\r
1124 \param val1 first 16-bit operand for the addition in the low halfword, and the
\r
1125 first 16-bit operand for the subtraction in the high halfword.
\r
1126 \param val2 second 16-bit halfword for the addition in the high halfword,
\r
1127 and the second 16-bit halfword for the subtraction in the low halfword.
\r
1130 \li the addition of the low halfword in the first operand and the high halfword in the
\r
1131 second operand, in the low halfword of the return value.
\r
1132 \li the subtraction of the low halfword in the second operand from the high halfword
\r
1133 in the first operand, in the high halfword of the return value.
\r
1135 The results are saturated to the 16-bit unsigned integer
\r
1136 range 0 \<= x \<= 2<sup>16</sup> - 1.
\r
1140 res[15:0] = val1[15:0] + val2[31:16]
\r
1141 res[31:16] = val1[31:16] - val2[15:0]
\r
1144 uint32_t __UQSAX(uint32_t val1, uint32_t val2);
\r
1147 /**************************************************************************************************/
\r
1149 \brief Dual 16-bit unsigned subtraction and addition with halved results and exchange
\r
1151 \details This function enables you to exchange the halfwords of the second operand, subtract the
\r
1152 high halfwords and add the low halfwords, halving the results.
\r
1154 \param val1 first operand for the addition in the low halfword, and the first
\r
1155 operand for the subtraction in the high halfword.
\r
1156 \param val2 second operand for the addition in the high halfword, and the
\r
1157 second operand for the subtraction in the low halfword.
\r
1160 \li the halved addition of the high halfword in the second operand and the low
\r
1161 halfword in the first operand, in the low halfword of the return value.
\r
1162 \li the halved subtraction of the low halfword in the second operand from the high
\r
1163 halfword in the first operand, in the high halfword of the return value.
\r
1167 res[15:0] = (val1[15:0] + val2[31:16]) >> 1
\r
1168 res[31:16] = (val1[31:16] - val2[15:0] ) >> 1
\r
1171 uint32_t __UHSAX(uint32_t val1, uint32_t val2);
\r
1174 /**************************************************************************************************/
\r
1176 \brief Unsigned sum of quad 8-bit unsigned absolute difference
\r
1178 \details This function enables you to perform four unsigned 8-bit subtractions, and add the
\r
1179 absolute values of the differences together, returning the result as a single unsigned
\r
1182 \param val1 first four 8-bit operands for the subtractions.
\r
1183 \param val2 second four 8-bit operands for the subtractions.
\r
1186 \li the subtraction of the first byte in the second operand from the first byte in the
\r
1188 \li the subtraction of the second byte in the second operand from the second byte in
\r
1189 the first operand.
\r
1190 \li the subtraction of the third byte in the second operand from the third byte in the
\r
1192 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
1193 the first operand.
\r
1195 The sum is returned as a single unsigned integer.
\r
1200 absdiff1 = val1[7:0] - val2[7:0]
\r
1201 absdiff2 = val1[15:8] - val2[15:8]
\r
1202 absdiff3 = val1[23:16] - val2[23:16]
\r
1203 absdiff4 = val1[31:24] - val2[31:24]
\r
1204 res[31:0] = absdiff1 + absdiff2 + absdiff3 + absdiff4
\r
1207 uint32_t __USAD8(uint32_t val1, uint32_t val2);
\r
1210 /**************************************************************************************************/
\r
1212 \brief Unsigned sum of quad 8-bit unsigned absolute difference with 32-bit accumulate
\r
1214 \details This function enables you to perform four unsigned 8-bit subtractions, and add the
\r
1215 absolute values of the differences to a 32-bit accumulate operand.
\r
1217 \param val1 first four 8-bit operands for the subtractions.
\r
1218 \param val2 second four 8-bit operands for the subtractions.
\r
1219 \param val3 accumulation value.
\r
1222 the sum of the absolute differences of the following
\r
1223 bytes, added to the accumulation value:
\r
1224 \li the subtraction of the first byte in the second operand from the first byte in the
\r
1226 \li the subtraction of the second byte in the second operand from the second byte in
\r
1227 the first operand.
\r
1228 \li the subtraction of the third byte in the second operand from the third byte in the
\r
1230 \li the subtraction of the fourth byte in the second operand from the fourth byte in
\r
1231 the first operand.
\r
1236 absdiff1 = val1[7:0] - val2[7:0]
\r
1237 absdiff2 = val1[15:8] - val2[15:8]
\r
1238 absdiff3 = val1[23:16] - val2[23:16]
\r
1239 absdiff4 = val1[31:24] - val2[31:24]
\r
1240 sum = absdiff1 + absdiff2 + absdiff3 + absdiff4
\r
1241 res[31:0] = sum[31:0] + val3[31:0]
\r
1244 uint32_t __USADA8(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1247 /**************************************************************************************************/
\r
1249 \brief Q setting dual 16-bit saturate
\r
1251 \details This function enables you to saturate two signed 16-bit values to a selected signed range.<br>
\r
1252 The Q bit is set if either operation saturates.
\r
1254 \param val1 two signed 16-bit values to be saturated.
\r
1255 \param val2 bit position for saturation, an integral constant expression in the
\r
1260 the sum of the absolute differences of the following
\r
1261 bytes, added to the accumulation value:
\r
1262 \li the signed saturation of the low halfword in \em val1, saturated to the bit position
\r
1263 specified in \em val2 and returned in the low halfword of the return value.
\r
1264 \li the signed saturation of the high halfword in <i>val1</i>, saturated to the bit position
\r
1265 specified in <i>val2</i> and returned in the high halfword of the return value.
\r
1270 Saturate halfwords in val1 to the signed range specified by the bit position in val2
\r
1273 uint32_t __SSAT16(uint32_t val1, const uint32_t val2);
\r
1276 /**************************************************************************************************/
\r
1278 \brief Q setting dual 16-bit unsigned saturate
\r
1280 \details This function enables you to saturate two signed 16-bit values to a selected unsigned
\r
1282 The Q bit is set if either operation saturates.
\r
1284 \param val1 two 16-bit values that are to be saturated.
\r
1285 \param val2 bit position for saturation, and must be an integral constant
\r
1286 expression in the range 0 to 15.
\r
1290 the saturation of the two signed 16-bit values, as non-negative values.
\r
1291 \li the saturation of the low halfword in \em val1, saturated to the bit position
\r
1292 specified in \em val2 and returned in the low halfword of the return value.
\r
1293 \li the saturation of the high halfword in \em val1, saturated to the bit position
\r
1294 specified in \em val2 and returned in the high halfword of the return value.
\r
1299 Saturate halfwords in val1 to the unsigned range specified by the bit position in val2
\r
1302 uint32_t __USAT16(uint32_t val1, const uint32_t val2);
\r
1305 /**************************************************************************************************/
\r
1307 \brief Dual extract 8-bits and zero-extend to 16-bits
\r
1309 \details This function enables you to extract two 8-bit values from an operand and zero-extend
\r
1310 them to 16 bits each.
\r
1312 \param val two 8-bit values in val[7:0] and val[23:16] to be sign-extended.
\r
1316 the 8-bit values zero-extended to 16-bit values.
\r
1317 \li zero-extended value of val[7:0] in the low halfword of the return value.
\r
1318 \li zero-extended value of val[23:16] in the high halfword of the return value.
\r
1323 res[15:0] = ZeroExtended(val[7:0] )
\r
1324 res[31:16] = ZeroExtended(val[23:16])
\r
1327 uint32_t __UXTB16(uint32_t val);
\r
1330 /**************************************************************************************************/
\r
1332 \brief Extracted 16-bit to 32-bit unsigned addition
\r
1334 \details This function enables you to extract two 8-bit values from one operand, zero-extend them
\r
1335 to 16 bits each, and add the results to two 16-bit values from another operand.
\r
1337 \param val1 value added to the zero-extended to 16-bit values.
\r
1338 \param val2 two 8-bit values to be extracted and zero-extended.
\r
1342 the 8-bit values in \em val2, zero-extended to 16-bit values
\r
1343 and added to \em val1.
\r
1348 res[15:0] = ZeroExt(val2[7:0] to 16 bits) + val1[15:0]
\r
1349 res[31:16] = ZeroExt(val2[31:16] to 16 bits) + val1[31:16]
\r
1352 uint32_t __UXTAB16(uint32_t val1, uint32_t val2);
\r
1355 /**************************************************************************************************/
\r
1357 \brief Dual extract 8-bits and sign extend each to 16-bits
\r
1359 \details This function enables you to extract two 8-bit values from an operand and sign-extend
\r
1360 them to 16 bits each.
\r
1362 \param val two 8-bit values in val[7:0] and val[23:16] to be sign-extended.
\r
1367 the 8-bit values sign-extended to 16-bit values.
\r
1368 \li sign-extended value of val[7:0] in the low halfword of the return value.
\r
1369 \li sign-extended value of val[23:16] in the high halfword of the return value.
\r
1374 res[15:0] = SignExtended(val[7:0]
\r
1375 res[31:16] = SignExtended(val[23:16]
\r
1378 uint32_t __SXTB16(uint32_t val);
\r
1381 /**************************************************************************************************/
\r
1383 \brief Dual extracted 8-bit to 16-bit signed addition
\r
1385 \details This function enables you to extract two 8-bit values from the second operand (at bit
\r
1386 positions [7:0] and [23:16]), sign-extend them to 16-bits each, and add the results to the
\r
1389 \param val1 values added to the zero-extended to 16-bit values.
\r
1390 \param val2 two 8-bit values to be extracted and zero-extended.
\r
1395 the addition of \em val1 and \em val2, where the 8-bit values in
\r
1396 val2[7:0] and val2[23:16] have been extracted and sign-extended prior to the addition.
\r
1401 res[15:0] = val1[15:0] + SignExtended(val2[7:0])
\r
1402 res[31:16] = val1[31:16] + SignExtended(val2[23:16])
\r
1405 uint32_t __SXTAB16(uint32_t val1, uint32_t val2);
\r
1408 /**************************************************************************************************/
\r
1410 \brief Q setting sum of dual 16-bit signed multiply
\r
1412 \details This function enables you to perform two 16-bit signed multiplications, adding the
\r
1413 products together.<br>
\r
1414 The Q bit is set if the addition overflows.
\r
1416 \param val1 first 16-bit operands for each multiplication.
\r
1417 \param val2 second 16-bit operands for each multiplication.
\r
1422 the sum of the products of the two 16-bit signed multiplications.
\r
1427 p1 = val1[15:0] * val2[15:0]
\r
1428 p2 = val1[31:16] * val2[31:16]
\r
1429 res[31:0] = p1 + p2
\r
1432 uint32_t __SMUAD(uint32_t val1, uint32_t val2);
\r
1435 /**************************************************************************************************/
\r
1437 \brief Q setting sum of dual 16-bit signed multiply with exchange
\r
1439 \details This function enables you to perform two 16-bit signed multiplications with exchanged
\r
1440 halfwords of the second operand, adding the products together.<br>
\r
1441 The Q bit is set if the addition overflows.
\r
1443 \param val1 first 16-bit operands for each multiplication.
\r
1444 \param val2 second 16-bit operands for each multiplication.
\r
1449 the sum of the products of the two 16-bit signed multiplications with exchanged
\r
1450 halfwords of the second operand.
\r
1455 p1 = val1[15:0] * val2[31:16]
\r
1456 p2 = val1[31:16] * val2[15:0]
\r
1457 res[31:0] = p1 + p2
\r
1460 uint32_t __SMUADX(uint32_t val1, uint32_t val2);
\r
1463 /**************************************************************************************************/
\r
1465 \brief 32-bit signed multiply with 32-bit truncated accumulator.
\r
1467 \details This function enables you to perform a signed 32-bit multiplications, adding the most significant 32 bits
\r
1468 of the 64-bit result to a 32-bit accumulate operand.<br>
\r
1470 \param val1 first operand for multiplication.
\r
1471 \param val2 second operand for multiplication.
\r
1472 \param val3 accumulate value.
\r
1475 \returns the product of multiplication (most significant 32 bits) is added to the accumulate
\r
1476 value, as a 32-bit integer.
\r
1481 res[31:0] = p[61:32] + val3[31:0]
\r
1484 uint32_t __SMMLA (int32_t val1, int32_t val2, int32_t val3);
\r
1487 /**************************************************************************************************/
\r
1489 \brief Q setting dual 16-bit signed multiply with single 32-bit accumulator
\r
1491 \details This function enables you to perform two signed 16-bit multiplications, adding both
\r
1492 results to a 32-bit accumulate operand.<br>
\r
1493 The Q bit is set if the addition overflows. Overflow cannot occur during the multiplications.
\r
1495 \param val1 first 16-bit operands for each multiplication.
\r
1496 \param val2 second 16-bit operands for each multiplication.
\r
1497 \param val3 accumulate value.
\r
1501 the product of each multiplication added to the accumulate
\r
1502 value, as a 32-bit integer.
\r
1507 p1 = val1[15:0] * val2[15:0]
\r
1508 p2 = val1[31:16] * val2[31:16]
\r
1509 res[31:0] = p1 + p2 + val3[31:0]
\r
1512 uint32_t __SMLAD(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1515 /**************************************************************************************************/
\r
1517 \brief Q setting pre-exchanged dual 16-bit signed multiply with single 32-bit accumulator
\r
1519 \details This function enables you to perform two signed 16-bit multiplications with exchanged
\r
1520 halfwords of the second operand, adding both results to a 32-bit accumulate operand.<br>
\r
1521 The Q bit is set if the addition overflows. Overflow cannot occur during the multiplications.
\r
1523 \param val1 first 16-bit operands for each multiplication.
\r
1524 \param val2 second 16-bit operands for each multiplication.
\r
1525 \param val3 accumulate value.
\r
1529 the product of each multiplication with exchanged
\r
1530 halfwords of the second operand added to the accumulate value, as a 32-bit integer.
\r
1535 p1 = val1[15:0] * val2[31:16]
\r
1536 p2 = val1[31:16] * val2[15:0]
\r
1537 res[31:0] = p1 + p2 + val3[31:0]
\r
1540 uint32_t __SMLADX(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1543 /**************************************************************************************************/
\r
1545 \brief Dual 16-bit signed multiply with single 64-bit accumulator
\r
1547 \details This function enables you to perform two signed 16-bit multiplications, adding both
\r
1548 results to a 64-bit accumulate operand. Overflow is only possible as a result of the 64-bit
\r
1549 addition. This overflow is not detected if it occurs. Instead, the result wraps around
\r
1550 modulo2<sup>64</sup>.
\r
1552 \param val1 first 16-bit operands for each multiplication.
\r
1553 \param val2 second 16-bit operands for each multiplication.
\r
1554 \param val3 accumulate value.
\r
1558 the product of each multiplication added to the accumulate value.
\r
1563 p1 = val1[15:0] * val2[15:0]
\r
1564 p2 = val1[31:16] * val2[31:16]
\r
1565 sum = p1 + p2 + val3[63:32][31:0]
\r
1566 res[63:32] = sum[63:32]
\r
1567 res[31:0] = sum[31:0]
\r
1570 uint64_t __SMLALD(uint32_t val1, uint32_t val2, uint64_t val3);
\r
1573 /**************************************************************************************************/
\r
1575 \brief Dual 16-bit signed multiply with exchange with single 64-bit accumulator
\r
1577 \details This function enables you to exchange the halfwords of the second operand, and perform
\r
1578 two signed 16-bit multiplications, adding both results to a 64-bit accumulate operand.
\r
1579 Overflow is only possible as a result of the 64-bit addition. This overflow is not detected
\r
1580 if it occurs. Instead, the result wraps around modulo2<sup>64</sup>.
\r
1582 \param val1 first 16-bit operands for each multiplication.
\r
1583 \param val2 second 16-bit operands for each multiplication.
\r
1584 \param val3 accumulate value.
\r
1588 the product of each multiplication added to the accumulate value.
\r
1593 p1 = val1[15:0] * val2[31:16]
\r
1594 p2 = val1[31:16] * val2[15:0]
\r
1595 sum = p1 + p2 + val3[63:32][31:0]
\r
1596 res[63:32] = sum[63:32]
\r
1597 res[31:0] = sum[31:0]
\r
1600 unsigned long long __SMLALDX(uint32_t val1, uint32_t val2, unsigned long long val3);
\r
1603 /**************************************************************************************************/
\r
1605 \brief Dual 16-bit signed multiply returning difference
\r
1607 \details This function enables you to perform two 16-bit signed multiplications, taking the
\r
1608 difference of the products by subtracting the high halfword product from the low
\r
1611 \param val1 first 16-bit operands for each multiplication.
\r
1612 \param val2 second 16-bit operands for each multiplication.
\r
1616 the difference of the products of the two 16-bit signed multiplications.
\r
1621 p1 = val1[15:0] * val2[15:0]
\r
1622 p2 = val1[31:16] * val2[31:16]
\r
1623 res[31:0] = p1 - p2
\r
1626 uint32_t __SMUSD(uint32_t val1, uint32_t val2);
\r
1629 /**************************************************************************************************/
\r
1631 \brief Dual 16-bit signed multiply with exchange returning difference
\r
1633 \details This function enables you to perform two 16-bit signed multiplications, subtracting one
\r
1634 of the products from the other. The halfwords of the second operand are exchanged
\r
1635 before performing the arithmetic. This produces top * bottom and bottom * top
\r
1638 \param val1 first 16-bit operands for each multiplication.
\r
1639 \param val2 second 16-bit operands for each multiplication.
\r
1643 the difference of the products of the two 16-bit signed multiplications.
\r
1648 p1 = val1[15:0] * val2[31:16]
\r
1649 p2 = val1[31:16] * val2[15:0]
\r
1650 res[31:0] = p1 - p2
\r
1653 uint32_t __SMUSDX(uint32_t val1, uint32_t val2);
\r
1656 /**************************************************************************************************/
\r
1658 \brief Q setting dual 16-bit signed multiply subtract with 32-bit accumulate
\r
1660 \details This function enables you to perform two 16-bit signed multiplications, take the
\r
1661 difference of the products, subtracting the high halfword product from the low halfword
\r
1662 product, and add the difference to a 32-bit accumulate operand.<br>
\r
1663 The Q bit is set if the accumulation overflows. Overflow cannot occur during the multiplications or the
\r
1666 \param val1 first 16-bit operands for each multiplication.
\r
1667 \param val2 second 16-bit operands for each multiplication.
\r
1668 \param val3 accumulate value.
\r
1672 the difference of the product of each multiplication, added
\r
1673 to the accumulate value.
\r
1678 p1 = val1[15:0] * val2[15:0]
\r
1679 p2 = val1[31:16] * val2[31:16]
\r
1680 res[31:0] = p1 - p2 + val3[31:0]
\r
1683 uint32_t __SMLSD(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1686 /**************************************************************************************************/
\r
1688 \brief Q setting dual 16-bit signed multiply with exchange subtract with 32-bit accumulate
\r
1690 \details This function enables you to exchange the halfwords in the second operand, then perform
\r
1691 two 16-bit signed multiplications. The difference of the products is added to a 32-bit
\r
1692 accumulate operand.<br>
\r
1693 The Q bit is set if the addition overflows. Overflow cannot occur during the multiplications or the subtraction.
\r
1695 \param val1 first 16-bit operands for each multiplication.
\r
1696 \param val2 second 16-bit operands for each multiplication.
\r
1697 \param val3 accumulate value.
\r
1701 the difference of the product of each multiplication, added
\r
1702 to the accumulate value.
\r
1707 p1 = val1[15:0] * val2[31:16]
\r
1708 p2 = val1[31:16] * val2[15:0]
\r
1709 res[31:0] = p1 - p2 + val3[31:0]
\r
1712 uint32_t __SMLSDX(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1715 /**************************************************************************************************/
\r
1717 \brief Q setting dual 16-bit signed multiply subtract with 64-bit accumulate
\r
1719 \details This function It enables you to perform two 16-bit signed multiplications, take the
\r
1720 difference of the products, subtracting the high halfword product from the low halfword
\r
1721 product, and add the difference to a 64-bit accumulate operand. Overflow cannot occur
\r
1722 during the multiplications or the subtraction. Overflow can occur as a result of the 64-bit
\r
1723 addition, and this overflow is not detected. Instead, the result wraps round to
\r
1724 modulo2<sup>64</sup>.
\r
1726 \param val1 first 16-bit operands for each multiplication.
\r
1727 \param val2 second 16-bit operands for each multiplication.
\r
1728 \param val3 accumulate value.
\r
1732 the difference of the product of each multiplication,
\r
1733 added to the accumulate value.
\r
1738 p1 = val1[15:0] * val2[15:0]
\r
1739 p2 = val1[31:16] * val2[31:16]
\r
1740 res[63:0] = p1 - p2 + val3[63:0]
\r
1743 uint64_t __SMLSLD(uint32_t val1, uint32_t val2, uint64_t val3);
\r
1746 /**************************************************************************************************/
\r
1748 \brief Q setting dual 16-bit signed multiply with exchange subtract with 64-bit accumulate
\r
1750 \details This function enables you to exchange the halfwords of the second operand, perform two
\r
1751 16-bit multiplications, adding the difference of the products to a 64-bit accumulate
\r
1752 operand. Overflow cannot occur during the multiplications or the subtraction. Overflow
\r
1753 can occur as a result of the 64-bit addition, and this overflow is not detected. Instead,
\r
1754 the result wraps round to modulo2<sup>64</sup>.
\r
1756 \param val1 first 16-bit operands for each multiplication.
\r
1757 \param val2 second 16-bit operands for each multiplication.
\r
1758 \param val3 accumulate value.
\r
1762 the difference of the product of each multiplication,
\r
1763 added to the accumulate value.
\r
1768 p1 = val1[15:0] * val2[31:16]
\r
1769 p2 = val1[31:16] * val2[15:0]
\r
1770 res[63:0] = p1 - p2 + val3[63:0]
\r
1773 unsigned long long __SMLSLDX(uint32_t val1, uint32_t val2, unsigned long long val3);
\r
1776 /**************************************************************************************************/
\r
1778 \brief Select bytes based on GE bits
\r
1780 \details This function inserts a SEL instruction into the instruction stream generated by the
\r
1781 compiler. It enables you to select bytes from the input parameters, whereby the bytes
\r
1782 that are selected depend upon the results of previous SIMD instruction function. The
\r
1783 results of previous SIMD instruction function are represented by the Greater than or
\r
1784 Equal flags in the Application Program Status Register (APSR).
\r
1785 The __SEL function works equally well on both halfword and byte operand function
\r
1786 results. This is because halfword operand operations set two (duplicate) GE bits per
\r
1789 \param val1 four selectable 8-bit values.
\r
1790 \param val2 four selectable 8-bit values.
\r
1794 The function selects bytes from the input parameters and returns them in the
\r
1795 return value, res, according to the following criteria:
\r
1796 \li if APSR.GE[0] == 1 then res[7:0] = val1[7:0] else res[7:0] = val2[7:0]
\r
1797 \li if APSR.GE[1] == 1 then res[15:8] = val1[15:8] else res[15:8] = val2[15:8]
\r
1798 \li if APSR.GE[2] == 1 then res[23:16] = val1[23:16] else res[23:16] = val2[23:16]
\r
1799 \li if APSR.GE[3] == 1 then res[31;24] = val1[31:24] else res = val2[31:24]
\r
1802 uint32_t __SEL(uint32_t val1, uint32_t val2);
\r
1805 /**************************************************************************************************/
\r
1807 \brief Q setting saturating add
\r
1809 \details This function enables you to obtain the saturating add of two integers.<br>
\r
1810 The Q bit is set if the operation saturates.
\r
1812 \param val1 first summand of the saturating add operation.
\r
1813 \param val2 second summand of the saturating add operation.
\r
1817 the saturating addition of val1 and val2.
\r
1821 res[31:0] = SAT(val1 + SAT(val2))
\r
1824 uint32_t __QADD(uint32_t val1, uint32_t val2);
\r
1827 /**************************************************************************************************/
\r
1829 \brief Q setting saturating subtract
\r
1831 \details This function enables you to obtain the saturating subtraction of two integers.<br>
\r
1832 The Q bit is set if the operation saturates.
\r
1834 \param val1 minuend of the saturating subtraction operation.
\r
1835 \param val2 subtrahend of the saturating subtraction operation.
\r
1839 the saturating subtraction of val1 and val2.
\r
1843 res[31:0] = SAT(val1 - SAT(val2))
\r
1846 uint32_t __QSUB(uint32_t val1, uint32_t val2);
\r
1849 /**************************************************************************************************/
\r
1851 \brief Halfword packing instruction. Combines bits[15:0] of <i>val1</i>
\r
1852 with bits[31:16] of <i>val2</i> levitated with the <i>val3</i>.
\r
1854 \details Combine a halfword from one register with a halfword from another register.
\r
1855 The second argument can be left-shifted before extraction of the halfword. The registers
\r
1856 PC and SP are not allowed as arguments. This instruction does not change the flags.
\r
1858 \param val1 first 16-bit operands
\r
1859 \param val2 second 16-bit operands
\r
1860 \param val3 value for left-shifting <i>val2</i>. Value range [0..31].
\r
1864 the combination of halfwords.
\r
1868 res[15:0] = val1[15:0]
\r
1869 res[31:16] = val2[31:16]<<val3
\r
1872 uint32_t __PKHBT(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1875 /**************************************************************************************************/
\r
1877 \brief Halfword packing instruction. Combines bits[31:16] of <i>val1</i>
\r
1878 with bits[15:0] of <i>val2</i> right-shifted with the <i>val3</i>.
\r
1880 \details Combines a halfword from one register with a halfword from another register.
\r
1881 The second argument can be right-shifted before extraction of the halfword. The registers
\r
1882 PC and SP are not allowed as arguments. This instruction does not change the flags.
\r
1884 \param val1 second 16-bit operands
\r
1885 \param val2 first 16-bit operands
\r
1886 \param val3 value for right-shifting <i>val2</i>. Value range [1..32].
\r
1890 the combination of halfwords.
\r
1894 res[15:0] = val2[15:0]>>val3
\r
1895 res[31:16] = val1[31:16]
\r
1898 uint32_t __PKHTB(uint32_t val1, uint32_t val2, uint32_t val3);
\r
1900 /** @} */ /* end group intrinsic_SIMD_gr */
begriffs.com / projects / cmsis / blob