Lines Matching +full:8 +full:- +full:byte
2 * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
8 * http://www.apache.org/licenses/LICENSE-2.0
31 The second argument can be left-shifted before extraction of the halfword.
32 \param [in] val1 first 16-bit operands
33 \param [in] val2 second 16-bit operands
34 \param [in] val3 value for left-shifting val2. Value range [0..31].
47 of val2 right-shifted with the val3.
49 The second argument can be right-shifted before extraction of the halfword.
50 \param [in] val1 first 16-bit operands
51 \param [in] val2 second 16-bit operands
52 \param [in] val3 value for right-shifting val2. Value range [1..32].
64 \brief Dual 16-bit signed saturate.
66 \param [in] x two signed 16-bit values to be saturated.
85 \brief Dual 16-bit unsigned saturate.
86 …\details This function enables you to saturate two signed 16-bit values to a selected unsigned ran…
87 \param [in] x two signed 16-bit values to be saturated.
89 \return the saturation of the two signed 16-bit values, as non-negative values:
106 \brief Quad 8-bit saturating addition.
107 \details This function enables you to perform four 8-bit integer additions,
108 saturating the results to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1.
109 \param [in] x first four 8-bit summands.
110 \param [in] y second four 8-bit summands.
111 …\return the saturated addition of the first byte of each operand in the first byte of the r…
112 …the saturated addition of the second byte of each operand in the second byte of the return value.\n
113 … the saturated addition of the third byte of each operand in the third byte of the return value.\n
114 …the saturated addition of the fourth byte of each operand in the fourth byte of the return value.\n
115 … The returned results are saturated to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1.
118 res[15:8] = val1[15:8] + val2[15:8] \n
126 r = __SSAT(((((int32_t)x << 24) >> 24) + (((int32_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; in __QADD8()
127 s = __SSAT(((((int32_t)x << 16) >> 24) + (((int32_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; in __QADD8()
128 t = __SSAT(((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; in __QADD8()
129 u = __SSAT(((((int32_t)x) >> 24) + (((int32_t)y) >> 24)), 8) & (int32_t)0x000000FF; in __QADD8()
131 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __QADD8()
135 \brief Quad 8-bit unsigned saturating addition.
136 \details This function enables you to perform four unsigned 8-bit integer additions,
137 saturating the results to the 8-bit unsigned integer range 0 < x < 2^8 - 1.
138 \param [in] x first four 8-bit summands.
139 \param [in] y second four 8-bit summands.
140 …\return the saturated addition of the first byte of each operand in the first byte of the r…
141 …the saturated addition of the second byte of each operand in the second byte of the return value.\n
142 … the saturated addition of the third byte of each operand in the third byte of the return value.\n
143 …the saturated addition of the fourth byte of each operand in the fourth byte of the return value.\n
144 … The returned results are saturated to the 8-bit signed integer range 0 <= x <= 2^8 - 1.
147 res[15:8] = val1[15:8] + val2[15:8] \n
155 r = __IUSAT((((x << 24) >> 24) + ((y << 24) >> 24)), 8) & 0x000000FF; in __UQADD8()
156 s = __IUSAT((((x << 16) >> 24) + ((y << 16) >> 24)), 8) & 0x000000FF; in __UQADD8()
157 t = __IUSAT((((x << 8) >> 24) + ((y << 8) >> 24)), 8) & 0x000000FF; in __UQADD8()
158 u = __IUSAT((((x) >> 24) + ((y) >> 24)), 8) & 0x000000FF; in __UQADD8()
160 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __UQADD8()
164 \brief Quad 8-bit signed addition.
165 \details This function performs four 8-bit signed integer additions.
166 \param [in] x first four 8-bit summands.
167 \param [in] y second four 8-bit summands.
168 …\return the addition of the first bytes from each operand, in the first byte of the return …
169 … the addition of the second bytes of each operand, in the second byte of the return value.\n
170 … the addition of the third bytes of each operand, in the third byte of the return value.\n
171 … the addition of the fourth bytes of each operand, in the fourth byte of the return value.
174 res[15:8] = val1[15:8] + val2[15:8] \n
184 t = ((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)) & (int32_t)0x000000FF; in __SADD8()
187 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __SADD8()
191 \brief Quad 8-bit unsigned addition.
192 \details This function performs four unsigned 8-bit integer additions.
193 \param [in] x first four 8-bit summands.
194 \param [in] y second four 8-bit summands.
195 …\return the addition of the first bytes from each operand, in the first byte of the return …
196 … the addition of the second bytes of each operand, in the second byte of the return value.\n
197 … the addition of the third bytes of each operand, in the third byte of the return value.\n
198 … the addition of the fourth bytes of each operand, in the fourth byte of the return value.
201 res[15:8] = val1[15:8] + val2[15:8] \n
211 t = (((x << 8) >> 24) + ((y << 8) >> 24)) & 0x000000FF; in __UADD8()
214 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __UADD8()
218 \brief Quad 8-bit saturating subtract.
219 \details This function enables you to perform four 8-bit integer subtractions,
220 saturating the results to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1.
221 \param [in] x first four 8-bit summands.
222 \param [in] y second four 8-bit summands.
223 …\return the subtraction of the first byte of each operand in the first byte of the return v…
224 … the subtraction of the second byte of each operand in the second byte of the return value.\n
225 … the subtraction of the third byte of each operand in the third byte of the return value.\n
226 … the subtraction of the fourth byte of each operand in the fourth byte of the return value.\n
227 … The returned results are saturated to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1.
229 res[7:0] = val1[7:0] - val2[7:0] \n
230 res[15:8] = val1[15:8] - val2[15:8] \n
231 res[23:16] = val1[23:16] - val2[23:16] \n
232 res[31:24] = val1[31:24] - val2[31:24]
238 r = __SSAT(((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; in __QSUB8()
239 s = __SSAT(((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; in __QSUB8()
240 t = __SSAT(((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; in __QSUB8()
241 u = __SSAT(((((int32_t)x) >> 24) - (((int32_t)y) >> 24)), 8) & (int32_t)0x000000FF; in __QSUB8()
243 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __QSUB8()
247 \brief Quad 8-bit unsigned saturating subtraction.
248 \details This function enables you to perform four unsigned 8-bit integer subtractions,
249 saturating the results to the 8-bit unsigned integer range 0 < x < 2^8 - 1.
250 \param [in] x first four 8-bit summands.
251 \param [in] y second four 8-bit summands.
252 …\return the subtraction of the first byte of each operand in the first byte of the return v…
253 … the subtraction of the second byte of each operand in the second byte of the return value.\n
254 … the subtraction of the third byte of each operand in the third byte of the return value.\n
255 … the subtraction of the fourth byte of each operand in the fourth byte of the return value.\n
256 … The returned results are saturated to the 8-bit unsigned integer range 0 <= x <= 2^8 - 1.
258 res[7:0] = val1[7:0] - val2[7:0] \n
259 res[15:8] = val1[15:8] - val2[15:8] \n
260 res[23:16] = val1[23:16] - val2[23:16] \n
261 res[31:24] = val1[31:24] - val2[31:24]
267 r = __IUSAT((((x << 24) >> 24) - ((y << 24) >> 24)), 8) & 0x000000FF; in __UQSUB8()
268 s = __IUSAT((((x << 16) >> 24) - ((y << 16) >> 24)), 8) & 0x000000FF; in __UQSUB8()
269 t = __IUSAT((((x << 8) >> 24) - ((y << 8) >> 24)), 8) & 0x000000FF; in __UQSUB8()
270 u = __IUSAT((((x) >> 24) - ((y) >> 24)), 8) & 0x000000FF; in __UQSUB8()
272 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __UQSUB8()
276 \brief Quad 8-bit signed subtraction.
277 \details This function enables you to perform four 8-bit signed integer subtractions.
278 \param [in] x first four 8-bit operands of each subtraction.
279 \param [in] y second four 8-bit operands of each subtraction.
280 …\return the subtraction of the first bytes from each operand, in the first byte of the retu…
281 … the subtraction of the second bytes of each operand, in the second byte of the return value.\n
282 … the subtraction of the third bytes of each operand, in the third byte of the return value.\n
283 … the subtraction of the fourth bytes of each operand, in the fourth byte of the return value.
285 res[7:0] = val1[7:0] - val2[7:0] \n
286 res[15:8] = val1[15:8] - val2[15:8] \n
287 res[23:16] = val1[23:16] - val2[23:16] \n
288 res[31:24] = val1[31:24] - val2[31:24]
294 r = ((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)) & (int32_t)0x000000FF; in __SSUB8()
295 s = ((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)) & (int32_t)0x000000FF; in __SSUB8()
296 t = ((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)) & (int32_t)0x000000FF; in __SSUB8()
297 u = ((((int32_t)x) >> 24) - (((int32_t)y) >> 24)) & (int32_t)0x000000FF; in __SSUB8()
299 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __SSUB8()
303 \brief Quad 8-bit unsigned subtract.
304 \details This function enables you to perform four 8-bit unsigned integer subtractions.
305 \param [in] x first four 8-bit operands of each subtraction.
306 \param [in] y second four 8-bit operands of each subtraction.
307 …\return the subtraction of the first bytes from each operand, in the first byte of the retu…
308 … the subtraction of the second bytes of each operand, in the second byte of the return value.\n
309 … the subtraction of the third bytes of each operand, in the third byte of the return value.\n
310 … the subtraction of the fourth bytes of each operand, in the fourth byte of the return value.
312 res[7:0] = val1[7:0] - val2[7:0] \n
313 res[15:8] = val1[15:8] - val2[15:8] \n
314 res[23:16] = val1[23:16] - val2[23:16] \n
315 res[31:24] = val1[31:24] - val2[31:24]
321 r = (((x << 24) >> 24) - ((y << 24) >> 24)) & 0x000000FF; in __USUB8()
322 s = (((x << 16) >> 24) - ((y << 16) >> 24)) & 0x000000FF; in __USUB8()
323 t = (((x << 8) >> 24) - ((y << 8) >> 24)) & 0x000000FF; in __USUB8()
324 u = (((x) >> 24) - ((y) >> 24)) & 0x000000FF; in __USUB8()
326 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __USUB8()
330 \brief Unsigned sum of quad 8-bit unsigned absolute difference.
331 …\details This function enables you to perform four unsigned 8-bit subtractions, and add the absolu…
333 \param [in] x first four 8-bit operands of each subtraction.
334 \param [in] y second four 8-bit operands of each subtraction.
335 …\return the subtraction of the first bytes from each operand, in the first byte of the retu…
336 … the subtraction of the second bytes of each operand, in the second byte of the return value.\n
337 … the subtraction of the third bytes of each operand, in the third byte of the return value.\n
338 … the subtraction of the fourth bytes of each operand, in the fourth byte of the return value.\n
341 absdiff1 = val1[7:0] - val2[7:0] \n
342 absdiff2 = val1[15:8] - val2[15:8] \n
343 absdiff3 = val1[23:16] - val2[23:16] \n
344 absdiff4 = val1[31:24] - val2[31:24] \n
351 r = (((x << 24) >> 24) - ((y << 24) >> 24)) & 0x000000FF; in __USAD8()
352 s = (((x << 16) >> 24) - ((y << 16) >> 24)) & 0x000000FF; in __USAD8()
353 t = (((x << 8) >> 24) - ((y << 8) >> 24)) & 0x000000FF; in __USAD8()
354 u = (((x) >> 24) - ((y) >> 24)) & 0x000000FF; in __USAD8()
360 \brief Unsigned sum of quad 8-bit unsigned absolute difference with 32-bit accumulate.
361 …\details This function enables you to perform four unsigned 8-bit subtractions, and add the absolu…
362 of the differences to a 32-bit accumulate operand.
363 \param [in] x first four 8-bit operands of each subtraction.
364 \param [in] y second four 8-bit operands of each subtraction.
367 … the subtraction of the first bytes from each operand, in the first byte of the return value.\n
368 … the subtraction of the second bytes of each operand, in the second byte of the return value.\n
369 … the subtraction of the third bytes of each operand, in the third byte of the return value.\n
370 … the subtraction of the fourth bytes of each operand, in the fourth byte of the return value.
372 absdiff1 = val1[7:0] - val2[7:0] \n
373 absdiff2 = val1[15:8] - val2[15:8] \n
374 absdiff3 = val1[23:16] - val2[23:16] \n
375 absdiff4 = val1[31:24] - val2[31:24] \n
383 r = (abs(((x << 24) >> 24) - ((y << 24) >> 24))) & 0x000000FF; in __USADA8()
384 s = (abs(((x << 16) >> 24) - ((y << 16) >> 24))) & 0x000000FF; in __USADA8()
385 t = (abs(((x << 8) >> 24) - ((y << 8) >> 24))) & 0x000000FF; in __USADA8()
386 u = (abs(((x) >> 24) - ((y) >> 24))) & 0x000000FF; in __USADA8()
392 \brief Dual 16-bit saturating addition.
393 \details This function enables you to perform two 16-bit integer arithmetic additions in parallel,
394 saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
395 \param [in] x first two 16-bit summands.
396 \param [in] y second two 16-bit summands.
399 … The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
415 \brief Dual 16-bit unsigned saturating addition.
416 \details This function enables you to perform two unsigned 16-bit integer additions, saturating
417 the results to the 16-bit unsigned integer range 0 < x < 2^16 - 1.
418 \param [in] x first two 16-bit summands.
419 \param [in] y second two 16-bit summands.
422 The results are saturated to the 16-bit unsigned integer range 0 < x < 2^16 - 1.
438 \brief Dual 16-bit signed addition.
439 \details This function enables you to perform two 16-bit signed integer additions.
440 \param [in] x first two 16-bit summands.
441 \param [in] y second two 16-bit summands.
459 \brief Dual 16-bit unsigned addition
460 \details This function enables you to perform two 16-bit unsigned integer additions.
461 \param [in] x first two 16-bit summands for each addition.
462 \param [in] y second two 16-bit summands for each addition.
481 \brief Dual 16-bit signed addition with halved results.
482 …\details This function enables you to perform two signed 16-bit integer additions, halving the res…
483 \param [in] x first two 16-bit summands.
484 \param [in] y second two 16-bit summands.
502 \brief Dual 16-bit unsigned addition with halved results.
503 …\details This function enables you to perform two unsigned 16-bit integer additions, halving the r…
504 \param [in] x first two 16-bit summands.
505 \param [in] y second two 16-bit summands.
523 \brief Quad 8-bit signed addition with halved results.
524 …\details This function enables you to perform four signed 8-bit integer additions, halving the res…
525 \param [in] x first four 8-bit summands.
526 \param [in] y second four 8-bit summands.
527 …\return the halved addition of the first bytes from each operand, in the first byte of the …
528 …the halved addition of the second bytes from each operand, in the second byte of the return value.…
529 … the halved addition of the third bytes from each operand, in the third byte of the return value.\n
530 … the halved addition of the fourth bytes from each operand, in the fourth byte of the return value.
533 res[15:8] = (val1[15:8] + val2[15:8] ) >> 1 \n
543 t = (((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)) >> 1) & (int32_t)0x000000FF; in __SHADD8()
546 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __SHADD8()
550 \brief Quad 8-bit unsigned addition with halved results.
551 …\details This function enables you to perform four unsigned 8-bit integer additions, halving the r…
552 \param [in] x first four 8-bit summands.
553 \param [in] y second four 8-bit summands.
554 …\return the halved addition of the first bytes from each operand, in the first byte of the …
555 …the halved addition of the second bytes from each operand, in the second byte of the return value.…
556 … the halved addition of the third bytes from each operand, in the third byte of the return value.\n
557 … the halved addition of the fourth bytes from each operand, in the fourth byte of the return value.
560 res[15:8] = (val1[15:8] + val2[15:8] ) >> 1 \n
570 t = ((((x << 8) >> 24) + ((y << 8) >> 24)) >> 1) & 0x000000FF; in __UHADD8()
573 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __UHADD8()
577 \brief Dual 16-bit saturating subtract.
578 \details This function enables you to perform two 16-bit integer subtractions in parallel,
579 saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
580 \param [in] x first two 16-bit summands.
581 \param [in] y second two 16-bit summands.
584 … The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
586 res[15:0] = val1[15:0] - val2[15:0] \n
587 res[31:16] = val1[31:16] - val2[31:16]
593 r = __SSAT(((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; in __QSUB16()
594 s = __SSAT(((((int32_t)x) >> 16) - (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; in __QSUB16()
600 \brief Dual 16-bit unsigned saturating subtraction.
601 \details This function enables you to perform two unsigned 16-bit integer subtractions,
602 saturating the results to the 16-bit unsigned integer range 0 < x < 2^16 - 1.
603 \param [in] x first two 16-bit operands for each subtraction.
604 \param [in] y second two 16-bit operands for each subtraction.
607 … The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
609 res[15:0] = val1[15:0] - val2[15:0] \n
610 res[31:16] = val1[31:16] - val2[31:16]
616 r = __IUSAT((((x << 16) >> 16) - ((y << 16) >> 16)), 16) & 0x0000FFFF; in __UQSUB16()
617 s = __IUSAT((((x) >> 16) - ((y) >> 16)), 16) & 0x0000FFFF; in __UQSUB16()
623 \brief Dual 16-bit signed subtraction.
624 \details This function enables you to perform two 16-bit signed integer subtractions.
625 \param [in] x first two 16-bit operands of each subtraction.
626 \param [in] y second two 16-bit operands of each subtraction.
632 res[15:0] = val1[15:0] - val2[15:0] \n
633 res[31:16] = val1[31:16] - val2[31:16]
639 r = ((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; in __SSUB16()
640 s = ((((int32_t)x) >> 16) - (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; in __SSUB16()
646 \brief Dual 16-bit unsigned subtract.
647 \details This function enables you to perform two 16-bit unsigned integer subtractions.
648 \param [in] x first two 16-bit operands of each subtraction.
649 \param [in] y second two 16-bit operands of each subtraction.
655 res[15:0] = val1[15:0] - val2[15:0] \n
656 res[31:16] = val1[31:16] - val2[31:16]
662 r = (((x << 16) >> 16) - ((y << 16) >> 16)) & 0x0000FFFF; in __USUB16()
663 s = (((x) >> 16) - ((y) >> 16)) & 0x0000FFFF; in __USUB16()
669 \brief Dual 16-bit signed subtraction with halved results.
670 …\details This function enables you to perform two signed 16-bit integer subtractions, halving the …
671 \param [in] x first two 16-bit summands.
672 \param [in] y second two 16-bit summands.
676 res[15:0] = (val1[15:0] - val2[15:0]) >> 1 \n
677 res[31:16] = (val1[31:16] - val2[31:16]) >> 1
683 r = (((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; in __SHSUB16()
684 s = (((((int32_t)x) >> 16) - (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; in __SHSUB16()
690 \brief Dual 16-bit unsigned subtraction with halved results.
691 …\details This function enables you to perform two unsigned 16-bit integer subtractions, halving th…
692 \param [in] x first two 16-bit summands.
693 \param [in] y second two 16-bit summands.
697 res[15:0] = (val1[15:0] - val2[15:0]) >> 1 \n
698 res[31:16] = (val1[31:16] - val2[31:16]) >> 1
704 r = ((((x << 16) >> 16) - ((y << 16) >> 16)) >> 1) & 0x0000FFFF; in __UHSUB16()
705 s = ((((x) >> 16) - ((y) >> 16)) >> 1) & 0x0000FFFF; in __UHSUB16()
711 \brief Quad 8-bit signed addition with halved results.
712 …\details This function enables you to perform four signed 8-bit integer subtractions, halving the …
713 \param [in] x first four 8-bit summands.
714 \param [in] y second four 8-bit summands.
715 …\return the halved subtraction of the first bytes from each operand, in the first byte of t…
716 …the halved subtraction of the second bytes from each operand, in the second byte of the return val…
717 …the halved subtraction of the third bytes from each operand, in the third byte of the return value…
718 …the halved subtraction of the fourth bytes from each operand, in the fourth byte of the return val…
720 res[7:0] = (val1[7:0] - val2[7:0] ) >> 1 \n
721 res[15:8] = (val1[15:8] - val2[15:8] ) >> 1 \n
722 res[23:16] = (val1[23:16] - val2[23:16]) >> 1 \n
723 res[31:24] = (val1[31:24] - val2[31:24]) >> 1
729 r = (((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)) >> 1) & (int32_t)0x000000FF; in __SHSUB8()
730 s = (((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)) >> 1) & (int32_t)0x000000FF; in __SHSUB8()
731 t = (((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)) >> 1) & (int32_t)0x000000FF; in __SHSUB8()
732 u = (((((int32_t)x) >> 24) - (((int32_t)y) >> 24)) >> 1) & (int32_t)0x000000FF; in __SHSUB8()
734 return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); in __SHSUB8()
738 \brief Quad 8-bit unsigned subtraction with halved results.
739 …\details This function enables you to perform four unsigned 8-bit integer subtractions, halving th…
740 \param [in] x first four 8-bit summands.
741 \param [in] y second four 8-bit summands.
742 …\return the halved subtraction of the first bytes from each operand, in the first byte of t…
743 …the halved subtraction of the second bytes from each operand, in the second byte of the return val…
744 …the halved subtraction of the third bytes from each operand, in the third byte of the return value…
745 …the halved subtraction of the fourth bytes from each operand, in the fourth byte of the return val…
747 res[7:0] = (val1[7:0] - val2[7:0] ) >> 1 \n
748 res[15:8] = (val1[15:8] - val2[15:8] ) >> 1 \n
749 res[23:16] = (val1[23:16] - val2[23:16]) >> 1 \n
750 res[31:24] = (val1[31:24] - val2[31:24]) >> 1
756 r = ((((x << 24) >> 24) - ((y << 24) >> 24)) >> 1) & 0x000000FF; in __UHSUB8()
757 s = ((((x << 16) >> 24) - ((y << 16) >> 24)) >> 1) & 0x000000FF; in __UHSUB8()
758 t = ((((x << 8) >> 24) - ((y << 8) >> 24)) >> 1) & 0x000000FF; in __UHSUB8()
759 u = ((((x) >> 24) - ((y) >> 24)) >> 1) & 0x000000FF; in __UHSUB8()
761 return ((u << 24) | (t << 16) | (s << 8) | (r)); in __UHSUB8()
765 \brief Dual 16-bit add and subtract with exchange.
768 saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
777 … The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
779 res[15:0] = val1[15:0] - val2[31:16] \n
786 r = __SSAT(((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; in __QASX()
793 \brief Dual 16-bit unsigned saturating addition and subtraction with exchange.
795 perform one unsigned 16-bit integer addition and one unsigned 16-bit subtraction,
796 saturating the results to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1.
805 … The returned results are saturated to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1.
807 res[15:0] = val1[15:0] - val2[31:16] \n
814 r = __IUSAT((((x << 16) >> 16) - ((y) >> 16)), 16) & 0x0000FFFF; in __UQASX()
821 \brief Dual 16-bit addition and subtraction with exchange.
833 res[15:0] = val1[15:0] - val2[31:16] \n
840 r = ((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; in __SASX()
847 \brief Dual 16-bit unsigned addition and subtraction with exchange.
859 res[15:0] = val1[15:0] - val2[31:16] \n
866 r = (((x << 16) >> 16) - ((y) >> 16)) & 0x0000FFFF; in __UASX()
873 \brief Dual 16-bit signed addition and subtraction with halved results.
875 signed 16-bit integer addition and one signed 16-bit subtraction, and halve the results.
876 \param [in] x first 16-bit operands.
877 \param [in] y second 16-bit operands.
883 res[15:0] = (val1[15:0] - val2[31:16]) >> 1 \n
890 r = (((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; in __SHASX()
897 \brief Dual 16-bit unsigned addition and subtraction with halved results and exchange.
909 res[15:0] = (val1[15:0] - val2[31:16]) >> 1 \n
916 r = ((((x << 16) >> 16) - ((y) >> 16)) >> 1) & 0x0000FFFF; in __UHASX()
923 \brief Dual 16-bit subtract and add with exchange.
926 saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
935 … The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1.
938 res[31:16] = val1[31:16] - val2[15:0]
945 s = __SSAT(((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; in __QSAX()
951 \brief Dual 16-bit unsigned saturating subtraction and addition with exchange.
953 one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturating
954 the results to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1.
963 … The returned results are saturated to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1.
966 res[31:16] = val1[31:16] - val2[15:0]
973 s = __IUSAT((((x) >> 16) - ((y << 16) >> 16)), 16) & 0x0000FFFF; in __UQSAX()
979 \brief Dual 16-bit unsigned subtract and add with exchange.
992 res[31:16] = val1[31:16] - val2[15:0]
999 s = (((x) >> 16) - ((y << 16) >> 16)) & 0x0000FFFF; in __USAX()
1005 \brief Dual 16-bit signed subtraction and addition with exchange.
1007 16-bit integer subtraction and one 16-bit addition.
1018 res[31:16] = val1[31:16] - val2[15:0]
1025 s = ((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; in __SSAX()
1032 \brief Dual 16-bit signed subtraction and addition with halved results.
1034 16-bit integer subtraction and one signed 16-bit addition, and halve the results.
1035 \param [in] x first 16-bit operands.
1036 \param [in] y second 16-bit operands.
1043 res[31:16] = (val1[31:16] - val2[15:0]) >> 1
1050 s = (((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; in __SHSAX()
1056 \brief Dual 16-bit unsigned subtraction and addition with halved results and exchange.
1069 res[31:16] = (val1[31:16] - val2[15:0]) >> 1
1076 s = ((((x) >> 16) - ((y << 16) >> 16)) >> 1) & 0x0000FFFF; in __UHSAX()
1082 \brief Dual 16-bit signed multiply with exchange returning difference.
1083 \details This function enables you to perform two 16-bit signed multiplications, subtracting
1086 \param [in] x first 16-bit operands for each multiplication.
1087 \param [in] y second 16-bit operands for each multiplication.
1088 \return the difference of the products of the two 16-bit signed multiplications.
1092 res[31:0] = p1 - p2
1096 return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - in __SMUSDX()
1101 \brief Sum of dual 16-bit signed multiply with exchange.
1102 \details This function enables you to perform two 16-bit signed multiplications with exchanged
1104 \param [in] x first 16-bit operands for each multiplication.
1105 \param [in] y second 16-bit operands for each multiplication.
1106 …\return the sum of the products of the two 16-bit signed multiplications with exchanged hal…
1172 tmp = (int64_t)x - (int64_t)y; in __QSUB()
1178 else if (tmp < (-2147483647 - 1)) in __QSUB()
1180 tmp = -2147483647 - 1; in __QSUB()
1188 \brief Dual 16-bit signed multiply with single 32-bit accumulator.
1189 \details This function enables you to perform two signed 16-bit multiplications,
1190 adding both results to a 32-bit accumulate operand.
1191 \param [in] x first 16-bit operands for each multiplication.
1192 \param [in] y second 16-bit operands for each multiplication.
1194 …\return the product of each multiplication added to the accumulate value, as a 32-bit integ…
1208 \brief Pre-exchanged dual 16-bit signed multiply with single 32-bit accumulator.
1209 \details This function enables you to perform two signed 16-bit multiplications with exchanged
1210 halfwords of the second operand, adding both results to a 32-bit accumulate operand.
1211 \param [in] x first 16-bit operands for each multiplication.
1212 \param [in] y second 16-bit operands for each multiplication.
1215 operand added to the accumulate value, as a 32-bit integer.
1229 \brief Dual 16-bit signed multiply with exchange subtract with 32-bit accumulate.
1230 \details This function enables you to perform two 16-bit signed multiplications, take the
1232 halfword product, and add the difference to a 32-bit accumulate operand.
1233 \param [in] x first 16-bit operands for each multiplication.
1234 \param [in] y second 16-bit operands for each multiplication.
1240 res[31:0] = p1 - p2 + val3[31:0]
1244 return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - in __SMLSD()
1250 \brief Dual 16-bit signed multiply with exchange subtract with 32-bit accumulate.
1251 … This function enables you to exchange the halfwords in the second operand, then perform two 16-bit
1252 … signed multiplications. The difference of the products is added to a 32-bit accumulate operand.
1253 \param [in] x first 16-bit operands for each multiplication.
1254 \param [in] y second 16-bit operands for each multiplication.
1260 res[31:0] = p1 - p2 + val3[31:0]
1264 return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - in __SMLSDX()
1270 \brief Dual 16-bit signed multiply with single 64-bit accumulator.
1271 …\details This function enables you to perform two signed 16-bit multiplications, adding both resul…
1272 … to a 64-bit accumulate operand. Overflow is only possible as a result of the 64-bit addition.
1274 \param [in] x first 16-bit operands for each multiplication.
1275 \param [in] y second 16-bit operands for each multiplication.
1293 \brief Dual 16-bit signed multiply with exchange with single 64-bit accumulator.
1295 … signed 16-bit multiplications, adding both results to a 64-bit accumulate operand. Overflow
1296 … is only possible as a result of the 64-bit addition. This overflow is not detected if it occurs.
1298 \param [in] x first 16-bit operands for each multiplication.
1299 \param [in] y second 16-bit operands for each multiplication.
1317 \brief dual 16-bit signed multiply subtract with 64-bit accumulate.
1318 …\details This function It enables you to perform two 16-bit signed multiplications, take the diffe…
1320 … difference to a 64-bit accumulate operand. Overflow cannot occur during the multiplications or the
1321 … subtraction. Overflow can occur as a result of the 64-bit addition, and this overflow is not
1323 \param [in] x first 16-bit operands for each multiplication.
1324 \param [in] y second 16-bit operands for each multiplication.
1330 res[63:0] = p1 - p2 + val3[63:0]
1334 return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - in __SMLSLD()
1340 \brief Dual 16-bit signed multiply with exchange subtract with 64-bit accumulate.
1341 …on enables you to exchange the halfwords of the second operand, perform two 16-bit multiplications,
1342 …adding the difference of the products to a 64-bit accumulate operand. Overflow cannot occur during…
1343 …multiplications or the subtraction. Overflow can occur as a result of the 64-bit addition, and thi…
1345 \param [in] x first 16-bit operands for each multiplication.
1346 \param [in] y second 16-bit operands for each multiplication.
1352 res[63:0] = p1 - p2 + val3[63:0]
1356 return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - in __SMLSLDX()
1362 \brief 32-bit signed multiply with 32-bit truncated accumulator.
1363 \details This function enables you to perform a signed 32-bit multiplications, adding the most
1364 significant 32 bits of the 64-bit result to a 32-bit accumulate operand.
1368 …of multiplication (most significant 32 bits) is added to the accumulate value, as a 32-bit integer.
1379 \brief Sum of dual 16-bit signed multiply.
1380 …\details This function enables you to perform two 16-bit signed multiplications, adding the produc…
1381 \param [in] x first 16-bit operands for each multiplication.
1382 \param [in] y second 16-bit operands for each multiplication.
1383 \return the sum of the products of the two 16-bit signed multiplications.
1396 \brief Dual 16-bit signed multiply returning difference.
1397 …\details This function enables you to perform two 16-bit signed multiplications, taking the differ…
1399 \param [in] x first 16-bit operands for each multiplication.
1400 \param [in] y second 16-bit operands for each multiplication.
1401 \return the difference of the products of the two 16-bit signed multiplications.
1405 res[31:0] = p1 - p2
1409 return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - in __SMUSD()
1414 \brief Dual extracted 8-bit to 16-bit signed addition.
1415 …\details This function enables you to extract two 8-bit values from the second operand (at bit pos…
1416 … [7:0] and [23:16]), sign-extend them to 16-bits each, and add the results to the first operand.
1417 \param [in] x values added to the sign-extended to 16-bit values.
1418 \param [in] y two 8-bit values to be extracted and sign-extended.
1419 \return the addition of val1 and val2, where the 8-bit values in val2[7:0] and
1420 val2[23:16] have been extracted and sign-extended prior to the addition.
1428 … (((((int32_t)y << 8) >> 8) + (((int32_t)x >> 16) << 16)) & (int32_t)0xFFFF0000))); in __SXTAB16()
1432 \brief Extracted 16-bit to 32-bit unsigned addition.
1433 \details This function enables you to extract two 8-bit values from one operand, zero-extend
1434 them to 16 bits each, and add the results to two 16-bit values from another operand.
1435 \param [in] x values added to the zero-extended to 16-bit values.
1436 \param [in] y two 8-bit values to be extracted and zero-extended.
1437 \return the addition of val1 and val2, where the 8-bit values in val2[7:0] and
1438 val2[23:16] have been extracted and zero-extended prior to the addition.
1446 ((((y << 8) >> 8) + ((x >> 16) << 16)) & 0xFFFF0000))); in __UXTAB16()
1450 \brief Dual extract 8-bits and sign extend each to 16-bits.
1451 …\details This function enables you to extract two 8-bit values from an operand and sign-extend the…
1452 \param [in] x two 8-bit values in val[7:0] and val[23:16] to be sign-extended.
1453 \return the 8-bit values sign-extended to 16-bit values.\n
1454 sign-extended value of val[7:0] in the low halfword of the return value.\n
1455 sign-extended value of val[23:16] in the high halfword of the return value.
1463 ((((int32_t)x << 8) >> 8) & (int32_t)0xFFFF0000))); in __SXTB16()
1467 \brief Dual extract 8-bits and zero-extend to 16-bits.
1468 …\details This function enables you to extract two 8-bit values from an operand and zero-extend the…
1469 \param [in] x two 8-bit values in val[7:0] and val[23:16] to be zero-extended.
1470 \return the 8-bit values sign-extended to 16-bit values.\n
1471 sign-extended value of val[7:0] in the low halfword of the return value.\n
1472 sign-extended value of val[23:16] in the high halfword of the return value.
1480 (((x << 8) >> 8) & 0xFFFF0000))); in __UXTB16()