]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/config/rs6000/spu2vmx.h
Update copyright years.
[thirdparty/gcc.git] / gcc / config / rs6000 / spu2vmx.h
1 /* Cell SPU 2 VMX intrinsics header
2 Copyright (C) 2007-2020 Free Software Foundation, Inc.
3
4 This file is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 3 of the License, or (at your option)
7 any later version.
8
9 This file is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 for more details.
13
14 Under Section 7 of GPL version 3, you are granted additional
15 permissions described in the GCC Runtime Library Exception, version
16 3.1, as published by the Free Software Foundation.
17
18 You should have received a copy of the GNU General Public License and
19 a copy of the GCC Runtime Library Exception along with this program;
20 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
21 <http://www.gnu.org/licenses/>. */
22
23 #ifndef _SPU2VMX_H_
24 #define _SPU2VMX_H_ 1
25
26 #ifdef __cplusplus
27
28 #ifndef __SPU__
29
30 #include <si2vmx.h>
31
32 /* spu_absd (absolute difference)
33 * ========
34 */
35 static __inline vec_uchar16 spu_absd(vec_uchar16 a, vec_uchar16 b)
36 {
37 return ((vec_uchar16)(si_absdb((qword)(a), (qword)(b))));
38
39 }
40
41
42 /* spu_add
43 * =======
44 */
45 static __inline vec_uint4 spu_add(vec_uint4 a, vec_uint4 b)
46 {
47 return ((vec_uint4)(si_a((qword)(a), (qword)(b))));
48 }
49
50 static __inline vec_int4 spu_add(vec_int4 a, vec_int4 b)
51 {
52 return ((vec_int4)(si_a((qword)(a), (qword)(b))));
53 }
54
55 static __inline vec_ushort8 spu_add(vec_ushort8 a, vec_ushort8 b)
56 {
57 return ((vec_ushort8)(si_ah((qword)(a), (qword)(b))));
58 }
59
60 static __inline vec_short8 spu_add(vec_short8 a, vec_short8 b)
61 {
62 return ((vec_short8)(si_ah((qword)(a), (qword)(b))));
63 }
64
65 static __inline vec_uint4 spu_add(vec_uint4 a, unsigned int b)
66 {
67 return ((vec_uint4)(si_ai((qword)(a), (int)(b))));
68 }
69
70 static __inline vec_int4 spu_add(vec_int4 a, int b)
71 {
72 return ((vec_int4)(si_ai((qword)(a), b)));
73 }
74
75 static __inline vec_ushort8 spu_add(vec_ushort8 a, unsigned short b)
76 {
77 return ((vec_ushort8)(si_ahi((qword)(a), (short)(b))));
78 }
79
80 static __inline vec_short8 spu_add(vec_short8 a, short b)
81 {
82 return ((vec_short8)(si_ahi((qword)(a), b)));
83 }
84
85 static __inline vec_float4 spu_add(vec_float4 a, vec_float4 b)
86 {
87 return ((vec_float4)(si_fa((qword)(a), (qword)(b))));
88 }
89
90 static __inline vec_double2 spu_add(vec_double2 a, vec_double2 b)
91 {
92 return ((vec_double2)(si_dfa((qword)(a), (qword)(b))));
93 }
94
95
96 /* spu_addx
97 * ========
98 */
99 static __inline vec_uint4 spu_addx(vec_uint4 a, vec_uint4 b, vec_uint4 c)
100 {
101 return ((vec_uint4)(si_addx((qword)(a), (qword)(b), (qword)(c))));
102 }
103
104 static __inline vec_int4 spu_addx(vec_int4 a, vec_int4 b, vec_int4 c)
105 {
106 return ((vec_int4)(si_addx((qword)(a), (qword)(b), (qword)(c))));
107 }
108
109
110 /* spu_and
111 * =======
112 */
113 static __inline vec_uchar16 spu_and(vec_uchar16 a, vec_uchar16 b)
114 {
115 return ((vec_uchar16)(si_and((qword)(a), (qword)(b))));
116 }
117
118 static __inline vec_char16 spu_and(vec_char16 a, vec_char16 b)
119 {
120 return ((vec_char16)(si_and((qword)(a), (qword)(b))));
121 }
122
123 static __inline vec_ushort8 spu_and(vec_ushort8 a, vec_ushort8 b)
124 {
125 return ((vec_ushort8)(si_and((qword)(a), (qword)(b))));
126 }
127
128 static __inline vec_short8 spu_and(vec_short8 a, vec_short8 b)
129 {
130 return ((vec_short8)(si_and((qword)(a), (qword)(b))));
131 }
132
133 static __inline vec_uint4 spu_and(vec_uint4 a, vec_uint4 b)
134 {
135 return ((vec_uint4)(si_and((qword)(a), (qword)(b))));
136 }
137
138 static __inline vec_int4 spu_and(vec_int4 a, vec_int4 b)
139 {
140 return ((vec_int4)(si_and((qword)(a), (qword)(b))));
141 }
142
143 static __inline vec_float4 spu_and(vec_float4 a, vec_float4 b)
144 {
145 return ((vec_float4)(si_and((qword)(a), (qword)(b))));
146 }
147
148 static __inline vec_ullong2 spu_and(vec_ullong2 a, vec_ullong2 b)
149 {
150 return ((vec_ullong2)(si_and((qword)(a), (qword)(b))));
151 }
152
153 static __inline vec_llong2 spu_and(vec_llong2 a, vec_llong2 b)
154 {
155 return ((vec_llong2)(si_and((qword)(a), (qword)(b))));
156 }
157
158 static __inline vec_double2 spu_and(vec_double2 a, vec_double2 b)
159 {
160 return ((vec_double2)(si_and((qword)(a), (qword)(b))));
161 }
162
163 static __inline vec_uchar16 spu_and(vec_uchar16 a, unsigned char b)
164 {
165 return ((vec_uchar16)(si_andbi((qword)(a), (signed char)(b))));
166 }
167
168
169 static __inline vec_char16 spu_and(vec_char16 a, signed char b)
170 {
171 return ((vec_char16)(si_andbi((qword)(a), b)));
172 }
173
174 static __inline vec_ushort8 spu_and(vec_ushort8 a, unsigned short b)
175 {
176 return ((vec_ushort8)(si_andhi((qword)(a), (signed short)(b))));
177 }
178
179 static __inline vec_short8 spu_and(vec_short8 a, signed short b)
180 {
181 return ((vec_short8)(si_andhi((qword)(a), b)));
182 }
183
184 static __inline vec_uint4 spu_and(vec_uint4 a, unsigned int b)
185 {
186 return ((vec_uint4)(si_andi((qword)(a), (signed int)(b))));
187 }
188
189 static __inline vec_int4 spu_and(vec_int4 a, signed int b)
190 {
191 return ((vec_int4)(si_andi((qword)(a), b)));
192 }
193
194
195 /* spu_andc
196 * ========
197 */
198 #define spu_andc(_a, _b) vec_andc(_a, _b)
199
200
201 /* spu_avg
202 * =======
203 */
204 #define spu_avg(_a, _b) vec_avg(_a, _b)
205
206
207 /* spu_bisled
208 * spu_bisled_d
209 * spu_bisled_e
210 * ============
211 */
212 #define spu_bisled(_func) /* not mappable */
213 #define spu_bisled_d(_func) /* not mappable */
214 #define spu_bisled_e(_func) /* not mappable */
215
216 /* spu_cmpabseq
217 * ============
218 */
219 static __inline vec_uint4 spu_cmpabseq(vec_float4 a, vec_float4 b)
220 {
221 return ((vec_uint4)(si_fcmeq((qword)(a), (qword)(b))));
222
223 }
224
225 static __inline vec_ullong2 spu_cmpabseq(vec_double2 a, vec_double2 b)
226 {
227 return ((vec_ullong2)(si_dfcmeq((qword)(a), (qword)(b))));
228 }
229
230
231 /* spu_cmpabsgt
232 * ============
233 */
234 static __inline vec_uint4 spu_cmpabsgt(vec_float4 a, vec_float4 b)
235 {
236 return ((vec_uint4)(si_fcmgt((qword)(a), (qword)(b))));
237 }
238
239 static __inline vec_ullong2 spu_cmpabsgt(vec_double2 a, vec_double2 b)
240 {
241 return ((vec_ullong2)(si_dfcmgt((qword)(a), (qword)(b))));
242 }
243
244
245 /* spu_cmpeq
246 * ========
247 */
248 static __inline vec_uchar16 spu_cmpeq(vec_uchar16 a, vec_uchar16 b)
249 {
250 return ((vec_uchar16)(si_ceqb((qword)(a), (qword)(b))));
251 }
252
253 static __inline vec_uchar16 spu_cmpeq(vec_char16 a, vec_char16 b)
254 {
255 return ((vec_uchar16)(si_ceqb((qword)(a), (qword)(b))));
256 }
257
258 static __inline vec_ushort8 spu_cmpeq(vec_ushort8 a, vec_ushort8 b)
259 {
260 return ((vec_ushort8)(si_ceqh((qword)(a), (qword)(b))));
261 }
262
263 static __inline vec_ushort8 spu_cmpeq(vec_short8 a, vec_short8 b)
264 {
265 return ((vec_ushort8)(si_ceqh((qword)(a), (qword)(b))));
266 }
267
268 static __inline vec_uint4 spu_cmpeq(vec_uint4 a, vec_uint4 b)
269 {
270 return ((vec_uint4)(si_ceq((qword)(a), (qword)(b))));
271 }
272
273 static __inline vec_uint4 spu_cmpeq(vec_int4 a, vec_int4 b)
274 {
275 return ((vec_uint4)(si_ceq((qword)(a), (qword)(b))));
276 }
277
278 static __inline vec_uint4 spu_cmpeq(vec_float4 a, vec_float4 b)
279 {
280 return ((vec_uint4)(si_fceq((qword)(a), (qword)(b))));
281 }
282
283 static __inline vec_uchar16 spu_cmpeq(vec_uchar16 a, unsigned char b)
284 {
285 return ((vec_uchar16)(si_ceqbi((qword)(a), (signed char)(b))));
286 }
287
288 static __inline vec_uchar16 spu_cmpeq(vec_char16 a, signed char b)
289 {
290 return ((vec_uchar16)(si_ceqbi((qword)(a), b)));
291 }
292
293 static __inline vec_ushort8 spu_cmpeq(vec_ushort8 a, unsigned short b)
294 {
295 return ((vec_ushort8)(si_ceqhi((qword)(a), (signed short)(b))));
296 }
297
298 static __inline vec_ushort8 spu_cmpeq(vec_short8 a, signed short b)
299 {
300 return ((vec_ushort8)(si_ceqhi((qword)(a), b)));
301 }
302
303 static __inline vec_uint4 spu_cmpeq(vec_uint4 a, unsigned int b)
304 {
305 return ((vec_uint4)(si_ceqi((qword)(a), (signed int)(b))));
306 }
307
308 static __inline vec_uint4 spu_cmpeq(vec_int4 a, signed int b)
309 {
310 return ((vec_uint4)(si_ceqi((qword)(a), b)));
311 }
312
313 static __inline vec_ullong2 spu_cmpeq(vec_double2 a, vec_double2 b)
314 {
315 return ((vec_ullong2)(si_dfceq((qword)(a), (qword)(b))));
316 }
317
318
319 /* spu_cmpgt
320 * ========
321 */
322 static __inline vec_uchar16 spu_cmpgt(vec_uchar16 a, vec_uchar16 b)
323 {
324 return ((vec_uchar16)(si_clgtb((qword)(a), (qword)(b))));
325 }
326
327 static __inline vec_uchar16 spu_cmpgt(vec_char16 a, vec_char16 b)
328 {
329 return ((vec_uchar16)(si_cgtb((qword)(a), (qword)(b))));
330 }
331
332 static __inline vec_ushort8 spu_cmpgt(vec_ushort8 a, vec_ushort8 b)
333 {
334 return ((vec_ushort8)(si_clgth((qword)(a), (qword)(b))));
335 }
336
337 static __inline vec_ushort8 spu_cmpgt(vec_short8 a, vec_short8 b)
338 {
339 return ((vec_ushort8)(si_cgth((qword)(a), (qword)(b))));
340 }
341
342 static __inline vec_uint4 spu_cmpgt(vec_uint4 a, vec_uint4 b)
343 {
344 return ((vec_uint4)(si_clgt((qword)(a), (qword)(b))));
345 }
346
347 static __inline vec_uint4 spu_cmpgt(vec_int4 a, vec_int4 b)
348 {
349 return ((vec_uint4)(si_cgt((qword)(a), (qword)(b))));
350 }
351
352 static __inline vec_uint4 spu_cmpgt(vec_float4 a, vec_float4 b)
353 {
354 return ((vec_uint4)(si_fcgt((qword)(a), (qword)(b))));
355 }
356
357 static __inline vec_uchar16 spu_cmpgt(vec_uchar16 a, unsigned char b)
358 {
359 return ((vec_uchar16)(si_clgtbi((qword)(a), b)));
360 }
361
362 static __inline vec_uchar16 spu_cmpgt(vec_char16 a, signed char b)
363 {
364 return ((vec_uchar16)(si_cgtbi((qword)(a), b)));
365 }
366
367 static __inline vec_ushort8 spu_cmpgt(vec_ushort8 a, unsigned short b)
368 {
369 return ((vec_ushort8)(si_clgthi((qword)(a), b)));
370 }
371
372 static __inline vec_ushort8 spu_cmpgt(vec_short8 a, signed short b)
373 {
374 return ((vec_ushort8)(si_cgthi((qword)(a), b)));
375 }
376
377 static __inline vec_uint4 spu_cmpgt(vec_uint4 a, unsigned int b)
378 {
379 return ((vec_uint4)(si_clgti((qword)(a), b)));
380 }
381
382 static __inline vec_uint4 spu_cmpgt(vec_int4 a, signed int b)
383 {
384 return ((vec_uint4)(si_cgti((qword)(a), b)));
385 }
386
387 static __inline vec_ullong2 spu_cmpgt(vec_double2 a, vec_double2 b)
388 {
389 return ((vec_ullong2)(si_dfcgt((qword)(a), (qword)(b))));
390 }
391
392
393 /* spu_cntb
394 * ========
395 */
396 static __inline vec_uchar16 spu_cntb(vec_uchar16 a)
397 {
398 return ((vec_uchar16)(si_cntb((qword)(a))));
399 }
400
401
402 static __inline vec_uchar16 spu_cntb(vec_char16 a)
403 {
404 return ((vec_uchar16)(si_cntb((qword)(a))));
405 }
406
407 /* spu_cntlz
408 * =========
409 */
410 static __inline vec_uint4 spu_cntlz(vec_uint4 a)
411 {
412 return ((vec_uint4)(si_clz((qword)(a))));
413 }
414
415 static __inline vec_uint4 spu_cntlz(vec_int4 a)
416 {
417 return ((vec_uint4)(si_clz((qword)(a))));
418 }
419
420 static __inline vec_uint4 spu_cntlz(vec_float4 a)
421 {
422 return ((vec_uint4)(si_clz((qword)(a))));
423 }
424
425 /* spu_testsv
426 * ==========
427 */
428 static __inline vec_ullong2 spu_testsv(vec_double2 a, char b)
429 {
430 return ((vec_ullong2)(si_dftsv((qword)(a), b)));
431 }
432
433 /* spu_convtf
434 * ==========
435 */
436 #define spu_convtf(_a, _b) (vec_ctf(_a, _b))
437
438 /* spu_convts
439 * ==========
440 */
441 #define spu_convts(_a, _b) (vec_cts(_a, _b))
442
443 /* spu_convtu
444 * ==========
445 */
446 #define spu_convtu(_a, _b) (vec_ctu(_a, _b))
447
448
449 /* spu_dsync
450 * ========
451 */
452 #define spu_dsync()
453
454 /* spu_eqv
455 * =======
456 */
457 static __inline vec_uchar16 spu_eqv(vec_uchar16 a, vec_uchar16 b)
458 {
459 return ((vec_uchar16)(si_eqv((qword)(a), (qword)(b))));
460 }
461
462 static __inline vec_char16 spu_eqv(vec_char16 a, vec_char16 b)
463 {
464 return ((vec_char16)(si_eqv((qword)(a), (qword)(b))));
465 }
466
467 static __inline vec_ushort8 spu_eqv(vec_ushort8 a, vec_ushort8 b)
468 {
469 return ((vec_ushort8)(si_eqv((qword)(a), (qword)(b))));
470 }
471
472 static __inline vec_short8 spu_eqv(vec_short8 a, vec_short8 b)
473 {
474 return ((vec_short8)(si_eqv((qword)(a), (qword)(b))));
475 }
476
477 static __inline vec_uint4 spu_eqv(vec_uint4 a, vec_uint4 b)
478 {
479 return ((vec_uint4)(si_eqv((qword)(a), (qword)(b))));
480 }
481
482 static __inline vec_int4 spu_eqv(vec_int4 a, vec_int4 b)
483 {
484 return ((vec_int4)(si_eqv((qword)(a), (qword)(b))));
485 }
486
487 static __inline vec_float4 spu_eqv(vec_float4 a, vec_float4 b)
488 {
489 return ((vec_float4)(si_eqv((qword)(a), (qword)(b))));
490 }
491
492 static __inline vec_ullong2 spu_eqv(vec_ullong2 a, vec_ullong2 b)
493 {
494 return ((vec_ullong2)(si_eqv((qword)(a), (qword)(b))));
495 }
496
497 static __inline vec_llong2 spu_eqv(vec_llong2 a, vec_llong2 b)
498 {
499 return ((vec_llong2)(si_eqv((qword)(a), (qword)(b))));
500 }
501
502 static __inline vec_double2 spu_eqv(vec_double2 a, vec_double2 b)
503 {
504 return ((vec_double2)(si_eqv((qword)(a), (qword)(b))));
505 }
506
507 /* spu_extend
508 * ========
509 */
510 static __inline vec_short8 spu_extend(vec_char16 a)
511 {
512 return ((vec_short8)(si_xsbh((qword)(a))));
513 }
514
515
516 static __inline vec_int4 spu_extend(vec_short8 a)
517 {
518 return ((vec_int4)(si_xshw((qword)(a))));
519 }
520
521 static __inline vec_llong2 spu_extend(vec_int4 a)
522 {
523 return ((vec_llong2)(si_xswd((qword)(a))));
524 }
525
526
527 static __inline vec_double2 spu_extend(vec_float4 a)
528 {
529 return ((vec_double2)(si_fesd((qword)(a))));
530 }
531
532
533 /* spu_extract
534 * ========
535 */
536 static __inline unsigned char spu_extract(vec_uchar16 a, int element)
537 {
538 union {
539 vec_uchar16 v;
540 unsigned char c[16];
541 } in;
542
543 in.v = a;
544 return (in.c[element & 15]);
545 }
546
547 static __inline signed char spu_extract(vec_char16 a, int element)
548 {
549 union {
550 vec_char16 v;
551 signed char c[16];
552 } in;
553
554 in.v = a;
555 return (in.c[element & 15]);
556 }
557
558 static __inline unsigned short spu_extract(vec_ushort8 a, int element)
559 {
560 union {
561 vec_ushort8 v;
562 unsigned short s[8];
563 } in;
564
565 in.v = a;
566 return (in.s[element & 7]);
567 }
568
569 static __inline signed short spu_extract(vec_short8 a, int element)
570 {
571 union {
572 vec_short8 v;
573 signed short s[8];
574 } in;
575
576 in.v = a;
577 return (in.s[element & 7]);
578 }
579
580 static __inline unsigned int spu_extract(vec_uint4 a, int element)
581 {
582 union {
583 vec_uint4 v;
584 unsigned int i[4];
585 } in;
586
587 in.v = a;
588 return (in.i[element & 3]);
589 }
590
591 static __inline signed int spu_extract(vec_int4 a, int element)
592 {
593 union {
594 vec_int4 v;
595 signed int i[4];
596 } in;
597
598 in.v = a;
599 return (in.i[element & 3]);
600 }
601
602 static __inline float spu_extract(vec_float4 a, int element)
603 {
604 union {
605 vec_float4 v;
606 float f[4];
607 } in;
608
609 in.v = a;
610 return (in.f[element & 3]);
611 }
612
613 static __inline unsigned long long spu_extract(vec_ullong2 a, int element)
614 {
615 union {
616 vec_ullong2 v;
617 unsigned long long l[2];
618 } in;
619
620 in.v = a;
621 return (in.l[element & 1]);
622 }
623
624 static __inline signed long long spu_extract(vec_llong2 a, int element)
625 {
626 union {
627 vec_llong2 v;
628 signed long long l[2];
629 } in;
630
631 in.v = a;
632 return (in.l[element & 1]);
633 }
634
635 static __inline double spu_extract(vec_double2 a, int element)
636 {
637 union {
638 vec_double2 v;
639 double d[2];
640 } in;
641
642 in.v = a;
643 return (in.d[element & 1]);
644 }
645
646 /* spu_gather
647 * ========
648 */
649 static __inline vec_uint4 spu_gather(vec_uchar16 a)
650 {
651 return ((vec_uint4)(si_gbb((qword)(a))));
652 }
653
654
655 static __inline vec_uint4 spu_gather(vec_char16 a)
656 {
657 return ((vec_uint4)(si_gbb((qword)(a))));
658 }
659
660 static __inline vec_uint4 spu_gather(vec_ushort8 a)
661 {
662 return ((vec_uint4)(si_gbh((qword)(a))));
663 }
664
665 static __inline vec_uint4 spu_gather(vec_short8 a)
666 {
667 return ((vec_uint4)(si_gbh((qword)(a))));
668 }
669
670
671 static __inline vec_uint4 spu_gather(vec_uint4 a)
672 {
673 return ((vec_uint4)(si_gb((qword)(a))));
674 }
675
676 static __inline vec_uint4 spu_gather(vec_int4 a)
677 {
678 return ((vec_uint4)(si_gb((qword)(a))));
679 }
680
681 static __inline vec_uint4 spu_gather(vec_float4 a)
682 {
683 return ((vec_uint4)(si_gb((qword)(a))));
684 }
685
686 /* spu_genb
687 * ========
688 */
689 static __inline vec_uint4 spu_genb(vec_uint4 a, vec_uint4 b)
690 {
691 return ((vec_uint4)(si_bg((qword)(b), (qword)(a))));
692 }
693
694 static __inline vec_int4 spu_genb(vec_int4 a, vec_int4 b)
695 {
696 return ((vec_int4)(si_bg((qword)(b), (qword)(a))));
697 }
698
699 /* spu_genbx
700 * =========
701 */
702 static __inline vec_uint4 spu_genbx(vec_uint4 a, vec_uint4 b, vec_uint4 c)
703 {
704 return ((vec_uint4)(si_bgx((qword)(b), (qword)(a), (qword)(c))));
705 }
706
707 static __inline vec_int4 spu_genbx(vec_int4 a, vec_int4 b, vec_int4 c)
708 {
709 return ((vec_int4)(si_bgx((qword)(b), (qword)(a), (qword)(c))));
710 }
711
712
713 /* spu_genc
714 * ========
715 */
716 static __inline vec_uint4 spu_genc(vec_uint4 a, vec_uint4 b)
717 {
718 return ((vec_uint4)(si_cg((qword)(a), (qword)(b))));
719 }
720
721 static __inline vec_int4 spu_genc(vec_int4 a, vec_int4 b)
722 {
723 return ((vec_int4)(si_cg((qword)(a), (qword)(b))));
724 }
725
726 /* spu_gencx
727 * =========
728 */
729 static __inline vec_uint4 spu_gencx(vec_uint4 a, vec_uint4 b, vec_uint4 c)
730 {
731 return ((vec_uint4)(si_cgx((qword)(a), (qword)(b), (qword)(c))));
732 }
733
734 static __inline vec_int4 spu_gencx(vec_int4 a, vec_int4 b, vec_int4 c)
735 {
736 return ((vec_int4)(si_cgx((qword)(a), (qword)(b), (qword)(c))));
737 }
738
739
740 /* spu_hcmpeq
741 * ========
742 */
743 #define spu_hcmpeq(_a, _b) if (_a == _b) { SPU_HALT_ACTION; };
744
745
746 /* spu_hcmpgt
747 * ========
748 */
749 #define spu_hcmpgt(_a, _b) if (_a > _b) { SPU_HALT_ACTION; };
750
751
752 /* spu_idisable
753 * ============
754 */
755 #define spu_idisable() SPU_UNSUPPORTED_ACTION
756
757
758 /* spu_ienable
759 * ===========
760 */
761 #define spu_ienable() SPU_UNSUPPORTED_ACTION
762
763
764 /* spu_insert
765 * ========
766 */
767 static __inline vec_uchar16 spu_insert(unsigned char a, vec_uchar16 b, int element)
768 {
769 union {
770 vec_uchar16 v;
771 unsigned char c[16];
772 } in;
773
774 in.v = b;
775 in.c[element & 15] = a;
776 return (in.v);
777 }
778
779 static __inline vec_char16 spu_insert(signed char a, vec_char16 b, int element)
780 {
781 return ((vec_char16)spu_insert((unsigned char)(a), (vec_uchar16)(b), element));
782 }
783
784 static __inline vec_ushort8 spu_insert(unsigned short a, vec_ushort8 b, int element)
785 {
786 union {
787 vec_ushort8 v;
788 unsigned short s[8];
789 } in;
790
791 in.v = b;
792 in.s[element & 7] = a;
793 return (in.v);
794 }
795
796 static __inline vec_short8 spu_insert(signed short a, vec_short8 b, int element)
797 {
798 return ((vec_short8)spu_insert((unsigned short)(a), (vec_ushort8)(b), element));
799 }
800
801 static __inline vec_uint4 spu_insert(unsigned int a, vec_uint4 b, int element)
802 {
803 union {
804 vec_uint4 v;
805 unsigned int i[4];
806 } in;
807
808 in.v = b;
809 in.i[element & 3] = a;
810 return (in.v);
811 }
812
813 static __inline vec_int4 spu_insert(signed int a, vec_int4 b, int element)
814 {
815 return ((vec_int4)spu_insert((unsigned int)(a), (vec_uint4)(b), element));
816 }
817
818 static __inline vec_float4 spu_insert(float a, vec_float4 b, int element)
819 {
820 union {
821 vec_float4 v;
822 float f[4];
823 } in;
824
825 in.v = b;
826 in.f[element & 3] = a;
827 return (in.v);
828 }
829
830 static __inline vec_ullong2 spu_insert(unsigned long long a, vec_ullong2 b, int element)
831 {
832 union {
833 vec_ullong2 v;
834 unsigned long long l[2];
835 } in;
836
837 in.v = b;
838 in.l[element & 1] = a;
839 return (in.v);
840 }
841
842 static __inline vec_llong2 spu_insert(signed long long a, vec_llong2 b, int element)
843 {
844 return ((vec_llong2)spu_insert((unsigned long long)(a), (vec_ullong2)(b), element));
845 }
846
847 static __inline vec_double2 spu_insert(double a, vec_double2 b, int element)
848 {
849 union {
850 vec_double2 v;
851 double d[2];
852 } in;
853
854 in.v = b;
855 in.d[element & 1] = a;
856 return (in.v);
857 }
858
859
860 /* spu_madd
861 * ========
862 */
863 static __inline vec_int4 spu_madd(vec_short8 a, vec_short8 b, vec_int4 c)
864 {
865 return ((vec_int4)(si_mpya((qword)(a), (qword)(b), (qword)(c))));
866 }
867
868 static __inline vec_float4 spu_madd(vec_float4 a, vec_float4 b, vec_float4 c)
869 {
870 return ((vec_float4)(si_fma((qword)(a), (qword)(b), (qword)(c))));
871 }
872
873 static __inline vec_double2 spu_madd(vec_double2 a, vec_double2 b, vec_double2 c)
874 {
875 return ((vec_double2)(si_dfma((qword)(a), (qword)(b), (qword)(c))));
876 }
877
878
879 /* spu_maskb
880 * ========
881 */
882 #define spu_maskb(_a) (vec_uchar16)(si_fsmb(si_from_int((int)(_a))))
883
884 /* spu_maskh
885 * ========
886 */
887 #define spu_maskh(_a) (vec_ushort8)(si_fsmh(si_from_int((int)(_a))))
888
889
890 /* spu_maskw
891 * ========
892 */
893 #define spu_maskw(_a) (vec_uint4)(si_fsm(si_from_int((int)(_a))))
894
895
896 /* spu_mfcdma32
897 * ========
898 */
899 #define spu_mfcdma32(_ls, _ea, _size, _tagid, _cmd)
900
901
902 /* spu_mfcdma64
903 * ========
904 */
905 #define spu_mfcdma64(_ls, _eahi, _ealow, _size, _tagid, _cmd)
906
907 /* spu_mfcstat
908 * ========
909 */
910 #define spu_mfcstat(_type) 0xFFFFFFFF
911
912
913
914 /* spu_mffpscr
915 * ===========
916 */
917 #define spu_mffpscr() (vec_uint4)(si_fscrrd())
918
919
920 /* spu_mfspr
921 * ========
922 */
923
924 #define spu_mfspr(_reg) si_to_uint(si_mfspr(_reg))
925
926
927
928 /* spu_mhhadd
929 * ==========
930 */
931 static __inline vec_int4 spu_mhhadd(vec_short8 a, vec_short8 b, vec_int4 c)
932 {
933 return ((vec_int4)(si_mpyhha((qword)(a), (qword)(b), (qword)(c))));
934 }
935
936
937 static __inline vec_uint4 spu_mhhadd(vec_ushort8 a, vec_ushort8 b, vec_uint4 c)
938 {
939 return ((vec_uint4)(si_mpyhhau((qword)(a), (qword)(b), (qword)(c))));
940 }
941
942
943 /* spu_msub
944 * ========
945 */
946 static __inline vec_float4 spu_msub(vec_float4 a, vec_float4 b, vec_float4 c)
947 {
948 return ((vec_float4)(si_fms((qword)(a), (qword)(b), (qword)(c))));
949 }
950
951 static __inline vec_double2 spu_msub(vec_double2 a, vec_double2 b, vec_double2 c)
952 {
953 return ((vec_double2)(si_dfms((qword)(a), (qword)(b), (qword)(c))));
954 }
955
956
957 /* spu_mtfpscr
958 * ===========
959 */
960 #define spu_mtfpscr(_a)
961
962
963 /* spu_mtspr
964 * ========
965 */
966 #define spu_mtspr(_reg, _a)
967
968
969 /* spu_mul
970 * ========
971 */
972 static __inline vec_float4 spu_mul(vec_float4 a, vec_float4 b)
973 {
974 return ((vec_float4)(si_fm((qword)(a), (qword)(b))));
975 }
976
977 static __inline vec_double2 spu_mul(vec_double2 a, vec_double2 b)
978 {
979 return ((vec_double2)(si_dfm((qword)(a), (qword)(b))));
980 }
981
982
983 /* spu_mulh
984 * ========
985 */
986 static __inline vec_int4 spu_mulh(vec_short8 a, vec_short8 b)
987 {
988 return ((vec_int4)(si_mpyh((qword)(a), (qword)(b))));
989 }
990
991 /* spu_mule
992 * =========
993 */
994 #define spu_mule(_a, _b) vec_mule(_a, _b)
995
996
997
998 /* spu_mulo
999 * ========
1000 */
1001 static __inline vec_int4 spu_mulo(vec_short8 a, vec_short8 b)
1002 {
1003 return ((vec_int4)(si_mpy((qword)(a), (qword)(b))));
1004 }
1005
1006
1007 static __inline vec_uint4 spu_mulo(vec_ushort8 a, vec_ushort8 b)
1008 {
1009 return ((vec_uint4)(si_mpyu((qword)(a), (qword)(b))));
1010 }
1011
1012
1013 static __inline vec_int4 spu_mulo(vec_short8 a, short b)
1014 {
1015 return ((vec_int4)(si_mpyi((qword)(a), b)));
1016 }
1017
1018 static __inline vec_uint4 spu_mulo(vec_ushort8 a, unsigned short b)
1019 {
1020 return ((vec_uint4)(si_mpyui((qword)(a), b)));
1021 }
1022
1023
1024 /* spu_mulsr
1025 * =========
1026 */
1027 static __inline vec_int4 spu_mulsr(vec_short8 a, vec_short8 b)
1028 {
1029 return ((vec_int4)(si_mpys((qword)(a), (qword)(b))));
1030 }
1031
1032
1033 /* spu_nand
1034 * ========
1035 */
1036 static __inline vec_uchar16 spu_nand(vec_uchar16 a, vec_uchar16 b)
1037 {
1038 return ((vec_uchar16)(si_nand((qword)(a), (qword)(b))));
1039 }
1040
1041 static __inline vec_char16 spu_nand(vec_char16 a, vec_char16 b)
1042 {
1043 return ((vec_char16)(si_nand((qword)(a), (qword)(b))));
1044 }
1045
1046 static __inline vec_ushort8 spu_nand(vec_ushort8 a, vec_ushort8 b)
1047 {
1048 return ((vec_ushort8)(si_nand((qword)(a), (qword)(b))));
1049 }
1050
1051 static __inline vec_short8 spu_nand(vec_short8 a, vec_short8 b)
1052 {
1053 return ((vec_short8)(si_nand((qword)(a), (qword)(b))));
1054 }
1055
1056 static __inline vec_uint4 spu_nand(vec_uint4 a, vec_uint4 b)
1057 {
1058 return ((vec_uint4)(si_nand((qword)(a), (qword)(b))));
1059 }
1060
1061 static __inline vec_int4 spu_nand(vec_int4 a, vec_int4 b)
1062 {
1063 return ((vec_int4)(si_nand((qword)(a), (qword)(b))));
1064 }
1065
1066 static __inline vec_float4 spu_nand(vec_float4 a, vec_float4 b)
1067 {
1068 return ((vec_float4)(si_nand((qword)(a), (qword)(b))));
1069 }
1070
1071 static __inline vec_ullong2 spu_nand(vec_ullong2 a, vec_ullong2 b)
1072 {
1073 return ((vec_ullong2)(si_nand((qword)(a), (qword)(b))));
1074 }
1075
1076 static __inline vec_llong2 spu_nand(vec_llong2 a, vec_llong2 b)
1077 {
1078 return ((vec_llong2)(si_nand((qword)(a), (qword)(b))));
1079 }
1080
1081 static __inline vec_double2 spu_nand(vec_double2 a, vec_double2 b)
1082 {
1083 return ((vec_double2)(si_nand((qword)(a), (qword)(b))));
1084 }
1085
1086
1087 /* spu_nmadd
1088 * =========
1089 */
1090 static __inline vec_double2 spu_nmadd(vec_double2 a, vec_double2 b, vec_double2 c)
1091 {
1092 return ((vec_double2)(si_dfnma((qword)(a), (qword)(b), (qword)(c))));
1093 }
1094
1095
1096 /* spu_nmsub
1097 * =========
1098 */
1099 static __inline vec_float4 spu_nmsub(vec_float4 a, vec_float4 b, vec_float4 c)
1100 {
1101 return ((vec_float4)(si_fnms((qword)(a), (qword)(b), (qword)(c))));
1102 }
1103
1104 static __inline vec_double2 spu_nmsub(vec_double2 a, vec_double2 b, vec_double2 c)
1105 {
1106 return ((vec_double2)(si_dfnms((qword)(a), (qword)(b), (qword)(c))));
1107 }
1108
1109
1110 /* spu_nor
1111 * =======
1112 */
1113 #define spu_nor(_a, _b) vec_nor(_a, _b)
1114
1115
1116 /* spu_or
1117 * ======
1118 */
1119 static __inline vec_uchar16 spu_or(vec_uchar16 a, vec_uchar16 b)
1120 {
1121 return ((vec_uchar16)(si_or((qword)(a), (qword)(b))));
1122 }
1123
1124 static __inline vec_char16 spu_or(vec_char16 a, vec_char16 b)
1125 {
1126 return ((vec_char16)(si_or((qword)(a), (qword)(b))));
1127 }
1128
1129 static __inline vec_ushort8 spu_or(vec_ushort8 a, vec_ushort8 b)
1130 {
1131 return ((vec_ushort8)(si_or((qword)(a), (qword)(b))));
1132 }
1133
1134 static __inline vec_short8 spu_or(vec_short8 a, vec_short8 b)
1135 {
1136 return ((vec_short8)(si_or((qword)(a), (qword)(b))));
1137 }
1138
1139 static __inline vec_uint4 spu_or(vec_uint4 a, vec_uint4 b)
1140 {
1141 return ((vec_uint4)(si_or((qword)(a), (qword)(b))));
1142 }
1143
1144 static __inline vec_int4 spu_or(vec_int4 a, vec_int4 b)
1145 {
1146 return ((vec_int4)(si_or((qword)(a), (qword)(b))));
1147 }
1148
1149 static __inline vec_float4 spu_or(vec_float4 a, vec_float4 b)
1150 {
1151 return ((vec_float4)(si_or((qword)(a), (qword)(b))));
1152 }
1153
1154 static __inline vec_ullong2 spu_or(vec_ullong2 a, vec_ullong2 b)
1155 {
1156 return ((vec_ullong2)(si_or((qword)(a), (qword)(b))));
1157 }
1158
1159 static __inline vec_llong2 spu_or(vec_llong2 a, vec_llong2 b)
1160 {
1161 return ((vec_llong2)(si_or((qword)(a), (qword)(b))));
1162 }
1163
1164 static __inline vec_double2 spu_or(vec_double2 a, vec_double2 b)
1165 {
1166 return ((vec_double2)(si_or((qword)(a), (qword)(b))));
1167 }
1168
1169
1170 static __inline vec_uchar16 spu_or(vec_uchar16 a, unsigned char b)
1171 {
1172 return ((vec_uchar16)(si_orbi((qword)(a), b)));
1173 }
1174
1175 static __inline vec_char16 spu_or(vec_char16 a, signed char b)
1176 {
1177 return ((vec_char16)(si_orbi((qword)(a), (unsigned char)(b))));
1178 }
1179
1180 static __inline vec_ushort8 spu_or(vec_ushort8 a, unsigned short b)
1181 {
1182 return ((vec_ushort8)(si_orhi((qword)(a), b)));
1183 }
1184
1185 static __inline vec_short8 spu_or(vec_short8 a, signed short b)
1186 {
1187 return ((vec_short8)(si_orhi((qword)(a), (unsigned short)(b))));
1188 }
1189
1190 static __inline vec_uint4 spu_or(vec_uint4 a, unsigned int b)
1191 {
1192 return ((vec_uint4)(si_ori((qword)(a), b)));
1193 }
1194
1195 static __inline vec_int4 spu_or(vec_int4 a, signed int b)
1196 {
1197 return ((vec_int4)(si_ori((qword)(a), (unsigned int)(b))));
1198 }
1199
1200
1201 /* spu_orc
1202 * =======
1203 */
1204 #define spu_orc(_a, _b) vec_or(_a, vec_nor(_b, _b))
1205
1206
1207 /* spu_orx
1208 * =======
1209 */
1210 static __inline vec_uint4 spu_orx(vec_uint4 a)
1211 {
1212 return ((vec_uint4)(si_orx((qword)(a))));
1213 }
1214
1215 static __inline vec_int4 spu_orx(vec_int4 a)
1216 {
1217 return ((vec_int4)(si_orx((qword)(a))));
1218 }
1219
1220
1221 /* spu_promote
1222 * ===========
1223 */
1224 static __inline vec_uchar16 spu_promote(unsigned char a, int element)
1225 {
1226 union {
1227 vec_uchar16 v;
1228 unsigned char c[16];
1229 } in;
1230
1231 in.c[element & 15] = a;
1232 return (in.v);
1233 }
1234
1235 static __inline vec_char16 spu_promote(signed char a, int element)
1236 {
1237 union {
1238 vec_char16 v;
1239 signed char c[16];
1240 } in;
1241
1242 in.c[element & 15] = a;
1243 return (in.v);
1244 }
1245
1246 static __inline vec_ushort8 spu_promote(unsigned short a, int element)
1247 {
1248 union {
1249 vec_ushort8 v;
1250 unsigned short s[8];
1251 } in;
1252
1253 in.s[element & 7] = a;
1254 return (in.v);
1255 }
1256
1257 static __inline vec_short8 spu_promote(signed short a, int element)
1258 {
1259 union {
1260 vec_short8 v;
1261 signed short s[8];
1262 } in;
1263
1264 in.s[element & 7] = a;
1265 return (in.v);
1266 }
1267
1268 static __inline vec_uint4 spu_promote(unsigned int a, int element)
1269 {
1270 union {
1271 vec_uint4 v;
1272 unsigned int i[4];
1273 } in;
1274
1275 in.i[element & 3] = a;
1276 return (in.v);
1277 }
1278
1279 static __inline vec_int4 spu_promote(signed int a, int element)
1280 {
1281 union {
1282 vec_int4 v;
1283 signed int i[4];
1284 } in;
1285
1286 in.i[element & 3] = a;
1287 return (in.v);
1288 }
1289
1290 static __inline vec_float4 spu_promote(float a, int element)
1291 {
1292 union {
1293 vec_float4 v;
1294 float f[4];
1295 } in;
1296
1297 in.f[element & 3] = a;
1298 return (in.v);
1299 }
1300
1301 static __inline vec_ullong2 spu_promote(unsigned long long a, int element)
1302 {
1303 union {
1304 vec_ullong2 v;
1305 unsigned long long l[2];
1306 } in;
1307
1308 in.l[element & 1] = a;
1309 return (in.v);
1310 }
1311
1312 static __inline vec_llong2 spu_promote(signed long long a, int element)
1313 {
1314 union {
1315 vec_llong2 v;
1316 signed long long l[2];
1317 } in;
1318
1319 in.l[element & 1] = a;
1320 return (in.v);
1321 }
1322
1323 static __inline vec_double2 spu_promote(double a, int element)
1324 {
1325 union {
1326 vec_double2 v;
1327 double d[2];
1328 } in;
1329
1330 in.d[element & 1] = a;
1331 return (in.v);
1332 }
1333
1334 /* spu_re
1335 * ======
1336 */
1337 #define spu_re(_a) vec_re(_a)
1338
1339
1340 /* spu_readch
1341 * ==========
1342 */
1343 #define spu_readch(_channel) 0 /* not mappable */
1344
1345
1346 /* spu_readchcnt
1347 * =============
1348 */
1349 #define spu_readchcnt(_channel) 0 /* not mappable */
1350
1351
1352 /* spu_readchqw
1353 * ============
1354 */
1355 #define spu_readchqw(_channel) __extension__ ({ vec_uint4 result = { 0, 0, 0, 0 }; result; })
1356
1357 /* spu_rl
1358 * ======
1359 */
1360 static __inline vec_ushort8 spu_rl(vec_ushort8 a, vec_short8 b)
1361 {
1362 return ((vec_ushort8)(si_roth((qword)(a), (qword)(b))));
1363 }
1364
1365 static __inline vec_short8 spu_rl(vec_short8 a, vec_short8 b)
1366 {
1367 return ((vec_short8)(si_roth((qword)(a), (qword)(b))));
1368 }
1369
1370 static __inline vec_uint4 spu_rl(vec_uint4 a, vec_int4 b)
1371 {
1372 return ((vec_uint4)(si_rot((qword)(a), (qword)(b))));
1373 }
1374
1375 static __inline vec_int4 spu_rl(vec_int4 a, vec_int4 b)
1376 {
1377 return ((vec_int4)(si_rot((qword)(a), (qword)(b))));
1378 }
1379
1380 static __inline vec_ushort8 spu_rl(vec_ushort8 a, int b)
1381 {
1382 return ((vec_ushort8)(si_rothi((qword)(a), b)));
1383 }
1384
1385 static __inline vec_short8 spu_rl(vec_short8 a, int b)
1386 {
1387 return ((vec_short8)(si_rothi((qword)(a), b)));
1388 }
1389
1390 static __inline vec_uint4 spu_rl(vec_uint4 a, int b)
1391 {
1392 return ((vec_uint4)(si_roti((qword)(a), b)));
1393 }
1394
1395 static __inline vec_int4 spu_rl(vec_int4 a, int b)
1396 {
1397 return ((vec_int4)(si_roti((qword)(a), b)));
1398 }
1399
1400
1401 /* spu_rlmask
1402 * ==========
1403 */
1404 static __inline vec_ushort8 spu_rlmask(vec_ushort8 a, vec_short8 b)
1405 {
1406 return ((vec_ushort8)(si_rothm((qword)(a), (qword)(b))));
1407 }
1408
1409 static __inline vec_short8 spu_rlmask(vec_short8 a, vec_short8 b)
1410 {
1411 return ((vec_short8)(si_rothm((qword)(a), (qword)(b))));
1412 }
1413
1414 static __inline vec_uint4 spu_rlmask(vec_uint4 a, vec_int4 b)
1415 {
1416 return ((vec_uint4)(si_rotm((qword)(a), (qword)(b))));
1417 }
1418
1419 static __inline vec_int4 spu_rlmask(vec_int4 a, vec_int4 b)
1420 {
1421 return ((vec_int4)(si_rotm((qword)(a), (qword)(b))));
1422 }
1423
1424 static __inline vec_ushort8 spu_rlmask(vec_ushort8 a, int b)
1425 {
1426 return ((vec_ushort8)(si_rothmi((qword)(a), b)));
1427 }
1428
1429 static __inline vec_short8 spu_rlmask(vec_short8 a, int b)
1430 {
1431 return ((vec_short8)(si_rothmi((qword)(a), b)));
1432 }
1433
1434
1435 static __inline vec_uint4 spu_rlmask(vec_uint4 a, int b)
1436 {
1437 return ((vec_uint4)(si_rotmi((qword)(a), b)));
1438 }
1439
1440 static __inline vec_int4 spu_rlmask(vec_int4 a, int b)
1441 {
1442 return ((vec_int4)(si_rotmi((qword)(a), b)));
1443 }
1444
1445 /* spu_rlmaska
1446 * ===========
1447 */
1448 static __inline vec_short8 spu_rlmaska(vec_short8 a, vec_short8 b)
1449 {
1450 return ((vec_short8)(si_rotmah((qword)(a), (qword)(b))));
1451 }
1452
1453 static __inline vec_ushort8 spu_rlmaska(vec_ushort8 a, vec_short8 b)
1454 {
1455 return ((vec_ushort8)(si_rotmah((qword)(a), (qword)(b))));
1456 }
1457
1458
1459 static __inline vec_int4 spu_rlmaska(vec_int4 a, vec_int4 b)
1460 {
1461 return ((vec_int4)(si_rotma((qword)(a), (qword)(b))));
1462 }
1463
1464 static __inline vec_uint4 spu_rlmaska(vec_uint4 a, vec_int4 b)
1465 {
1466 return ((vec_uint4)(si_rotma((qword)(a), (qword)(b))));
1467 }
1468
1469 static __inline vec_ushort8 spu_rlmaska(vec_ushort8 a, int b)
1470 {
1471 return ((vec_ushort8)(si_rotmahi((qword)(a), b)));
1472 }
1473
1474 static __inline vec_short8 spu_rlmaska(vec_short8 a, int b)
1475 {
1476 return ((vec_short8)(si_rotmahi((qword)(a), b)));
1477 }
1478
1479 static __inline vec_uint4 spu_rlmaska(vec_uint4 a, int b)
1480 {
1481 return ((vec_uint4)(si_rotmai((qword)(a), b)));
1482 }
1483
1484 static __inline vec_int4 spu_rlmaska(vec_int4 a, int b)
1485 {
1486 return ((vec_int4)(si_rotmai((qword)(a), b)));
1487 }
1488
1489
1490 /* spu_rlmaskqw
1491 * ============
1492 */
1493 static __inline vec_uchar16 spu_rlmaskqw(vec_uchar16 a, int count)
1494 {
1495 return ((vec_uchar16)(si_rotqmbi((qword)(a), si_from_int(count))));
1496 }
1497
1498 static __inline vec_char16 spu_rlmaskqw(vec_char16 a, int count)
1499 {
1500 return ((vec_char16)(si_rotqmbi((qword)(a), si_from_int(count))));
1501 }
1502
1503 static __inline vec_ushort8 spu_rlmaskqw(vec_ushort8 a, int count)
1504 {
1505 return ((vec_ushort8)(si_rotqmbi((qword)(a), si_from_int(count))));
1506 }
1507
1508 static __inline vec_short8 spu_rlmaskqw(vec_short8 a, int count)
1509 {
1510 return ((vec_short8)(si_rotqmbi((qword)(a), si_from_int(count))));
1511 }
1512
1513 static __inline vec_uint4 spu_rlmaskqw(vec_uint4 a, int count)
1514 {
1515 return ((vec_uint4)(si_rotqmbi((qword)(a), si_from_int(count))));
1516 }
1517
1518 static __inline vec_int4 spu_rlmaskqw(vec_int4 a, int count)
1519 {
1520 return ((vec_int4)(si_rotqmbi((qword)(a), si_from_int(count))));
1521 }
1522
1523 static __inline vec_float4 spu_rlmaskqw(vec_float4 a, int count)
1524 {
1525 return ((vec_float4)(si_rotqmbi((qword)(a), si_from_int(count))));
1526 }
1527
1528 static __inline vec_ullong2 spu_rlmaskqw(vec_ullong2 a, int count)
1529 {
1530 return ((vec_ullong2)(si_rotqmbi((qword)(a), si_from_int(count))));
1531 }
1532
1533 static __inline vec_llong2 spu_rlmaskqw(vec_llong2 a, int count)
1534 {
1535 return ((vec_llong2)(si_rotqmbi((qword)(a), si_from_int(count))));
1536 }
1537
1538 static __inline vec_double2 spu_rlmaskqw(vec_double2 a, int count)
1539 {
1540 return ((vec_double2)(si_rotqmbi((qword)(a), si_from_int(count))));
1541 }
1542
1543 /* spu_rlmaskqwbyte
1544 * ================
1545 */
1546 static __inline vec_uchar16 spu_rlmaskqwbyte(vec_uchar16 a, int count)
1547 {
1548 return ((vec_uchar16)(si_rotqmby((qword)(a), si_from_int(count))));
1549 }
1550
1551 static __inline vec_char16 spu_rlmaskqwbyte(vec_char16 a, int count)
1552 {
1553 return ((vec_char16)(si_rotqmby((qword)(a), si_from_int(count))));
1554 }
1555
1556 static __inline vec_ushort8 spu_rlmaskqwbyte(vec_ushort8 a, int count)
1557 {
1558 return ((vec_ushort8)(si_rotqmby((qword)(a), si_from_int(count))));
1559 }
1560
1561 static __inline vec_short8 spu_rlmaskqwbyte(vec_short8 a, int count)
1562 {
1563 return ((vec_short8)(si_rotqmby((qword)(a), si_from_int(count))));
1564 }
1565
1566 static __inline vec_uint4 spu_rlmaskqwbyte(vec_uint4 a, int count)
1567 {
1568 return ((vec_uint4)(si_rotqmby((qword)(a), si_from_int(count))));
1569 }
1570
1571 static __inline vec_int4 spu_rlmaskqwbyte(vec_int4 a, int count)
1572 {
1573 return ((vec_int4)(si_rotqmby((qword)(a), si_from_int(count))));
1574 }
1575
1576 static __inline vec_float4 spu_rlmaskqwbyte(vec_float4 a, int count)
1577 {
1578 return ((vec_float4)(si_rotqmby((qword)(a), si_from_int(count))));
1579 }
1580
1581 static __inline vec_ullong2 spu_rlmaskqwbyte(vec_ullong2 a, int count)
1582 {
1583 return ((vec_ullong2)(si_rotqmby((qword)(a), si_from_int(count))));
1584 }
1585
1586 static __inline vec_llong2 spu_rlmaskqwbyte(vec_llong2 a, int count)
1587 {
1588 return ((vec_llong2)(si_rotqmby((qword)(a), si_from_int(count))));
1589 }
1590
1591 static __inline vec_double2 spu_rlmaskqwbyte(vec_double2 a, int count)
1592 {
1593 return ((vec_double2)(si_rotqmby((qword)(a), si_from_int(count))));
1594 }
1595
1596 /* spu_rlmaskqwbytebc
1597 * ==================
1598 */
1599 static __inline vec_uchar16 spu_rlmaskqwbytebc(vec_uchar16 a, int count)
1600 {
1601 return ((vec_uchar16)(si_rotqmbybi((qword)(a), si_from_int(count))));
1602 }
1603
1604 static __inline vec_char16 spu_rlmaskqwbytebc(vec_char16 a, int count)
1605 {
1606 return ((vec_char16)(si_rotqmbybi((qword)(a), si_from_int(count))));
1607 }
1608
1609 static __inline vec_ushort8 spu_rlmaskqwbytebc(vec_ushort8 a, int count)
1610 {
1611 return ((vec_ushort8)(si_rotqmbybi((qword)(a), si_from_int(count))));
1612 }
1613
1614 static __inline vec_short8 spu_rlmaskqwbytebc(vec_short8 a, int count)
1615 {
1616 return ((vec_short8)(si_rotqmbybi((qword)(a), si_from_int(count))));
1617 }
1618
1619 static __inline vec_uint4 spu_rlmaskqwbytebc(vec_uint4 a, int count)
1620 {
1621 return ((vec_uint4)(si_rotqmbybi((qword)(a), si_from_int(count))));
1622 }
1623
1624 static __inline vec_int4 spu_rlmaskqwbytebc(vec_int4 a, int count)
1625 {
1626 return ((vec_int4)(si_rotqmbybi((qword)(a), si_from_int(count))));
1627 }
1628
1629 static __inline vec_float4 spu_rlmaskqwbytebc(vec_float4 a, int count)
1630 {
1631 return ((vec_float4)(si_rotqmbybi((qword)(a), si_from_int(count))));
1632 }
1633
1634 static __inline vec_ullong2 spu_rlmaskqwbytebc(vec_ullong2 a, int count)
1635 {
1636 return ((vec_ullong2)(si_rotqmbybi((qword)(a), si_from_int(count))));
1637 }
1638
1639 static __inline vec_llong2 spu_rlmaskqwbytebc(vec_llong2 a, int count)
1640 {
1641 return ((vec_llong2)(si_rotqmbybi((qword)(a), si_from_int(count))));
1642 }
1643
1644 static __inline vec_double2 spu_rlmaskqwbytebc(vec_double2 a, int count)
1645 {
1646 return ((vec_double2)(si_rotqmbybi((qword)(a), si_from_int(count))));
1647 }
1648
1649
1650 /* spu_rlqwbyte
1651 * ============
1652 */
1653 static __inline vec_uchar16 spu_rlqwbyte(vec_uchar16 a, int count)
1654 {
1655 return ((vec_uchar16)(si_rotqby((qword)(a), si_from_int(count))));
1656 }
1657
1658 static __inline vec_char16 spu_rlqwbyte(vec_char16 a, int count)
1659 {
1660 return ((vec_char16)(si_rotqby((qword)(a), si_from_int(count))));
1661 }
1662
1663 static __inline vec_ushort8 spu_rlqwbyte(vec_ushort8 a, int count)
1664 {
1665 return ((vec_ushort8)(si_rotqby((qword)(a), si_from_int(count))));
1666 }
1667
1668 static __inline vec_short8 spu_rlqwbyte(vec_short8 a, int count)
1669 {
1670 return ((vec_short8)(si_rotqby((qword)(a), si_from_int(count))));
1671 }
1672
1673 static __inline vec_uint4 spu_rlqwbyte(vec_uint4 a, int count)
1674 {
1675 return ((vec_uint4)(si_rotqby((qword)(a), si_from_int(count))));
1676 }
1677
1678 static __inline vec_int4 spu_rlqwbyte(vec_int4 a, int count)
1679 {
1680 return ((vec_int4)(si_rotqby((qword)(a), si_from_int(count))));
1681 }
1682
1683 static __inline vec_float4 spu_rlqwbyte(vec_float4 a, int count)
1684 {
1685 return ((vec_float4)(si_rotqby((qword)(a), si_from_int(count))));
1686 }
1687
1688 static __inline vec_ullong2 spu_rlqwbyte(vec_ullong2 a, int count)
1689 {
1690 return ((vec_ullong2)(si_rotqby((qword)(a), si_from_int(count))));
1691 }
1692
1693 static __inline vec_llong2 spu_rlqwbyte(vec_llong2 a, int count)
1694 {
1695 return ((vec_llong2)(si_rotqby((qword)(a), si_from_int(count))));
1696 }
1697
1698 static __inline vec_double2 spu_rlqwbyte(vec_double2 a, int count)
1699 {
1700 return ((vec_double2)(si_rotqby((qword)(a), si_from_int(count))));
1701 }
1702
1703
1704 /* spu_rlqwbytebc
1705 * ==============
1706 */
1707 static __inline vec_uchar16 spu_rlqwbytebc(vec_uchar16 a, int count)
1708 {
1709 return ((vec_uchar16)(si_rotqbybi((qword)(a), si_from_int(count))));
1710 }
1711
1712 static __inline vec_char16 spu_rlqwbytebc(vec_char16 a, int count)
1713 {
1714 return ((vec_char16)(si_rotqbybi((qword)(a), si_from_int(count))));
1715 }
1716
1717 static __inline vec_ushort8 spu_rlqwbytebc(vec_ushort8 a, int count)
1718 {
1719 return ((vec_ushort8)(si_rotqbybi((qword)(a), si_from_int(count))));
1720 }
1721
1722 static __inline vec_short8 spu_rlqwbytebc(vec_short8 a, int count)
1723 {
1724 return ((vec_short8)(si_rotqbybi((qword)(a), si_from_int(count))));
1725 }
1726
1727 static __inline vec_uint4 spu_rlqwbytebc(vec_uint4 a, int count)
1728 {
1729 return ((vec_uint4)(si_rotqbybi((qword)(a), si_from_int(count))));
1730 }
1731
1732 static __inline vec_int4 spu_rlqwbytebc(vec_int4 a, int count)
1733 {
1734 return ((vec_int4)(si_rotqbybi((qword)(a), si_from_int(count))));
1735 }
1736
1737 static __inline vec_float4 spu_rlqwbytebc(vec_float4 a, int count)
1738 {
1739 return ((vec_float4)(si_rotqbybi((qword)(a), si_from_int(count))));
1740 }
1741
1742 static __inline vec_ullong2 spu_rlqwbytebc(vec_ullong2 a, int count)
1743 {
1744 return ((vec_ullong2)(si_rotqbybi((qword)(a), si_from_int(count))));
1745 }
1746
1747 static __inline vec_llong2 spu_rlqwbytebc(vec_llong2 a, int count)
1748 {
1749 return ((vec_llong2)(si_rotqbybi((qword)(a), si_from_int(count))));
1750 }
1751
1752 static __inline vec_double2 spu_rlqwbytebc(vec_double2 a, int count)
1753 {
1754 return ((vec_double2)(si_rotqbybi((qword)(a), si_from_int(count))));
1755 }
1756
1757 /* spu_rlqw
1758 * ========
1759 */
1760 static __inline vec_uchar16 spu_rlqw(vec_uchar16 a, int count)
1761 {
1762 return ((vec_uchar16)(si_rotqbi((qword)(a), si_from_int(count))));
1763 }
1764
1765 static __inline vec_char16 spu_rlqw(vec_char16 a, int count)
1766 {
1767 return ((vec_char16)(si_rotqbi((qword)(a), si_from_int(count))));
1768 }
1769
1770 static __inline vec_ushort8 spu_rlqw(vec_ushort8 a, int count)
1771 {
1772 return ((vec_ushort8)(si_rotqbi((qword)(a), si_from_int(count))));
1773 }
1774
1775 static __inline vec_short8 spu_rlqw(vec_short8 a, int count)
1776 {
1777 return ((vec_short8)(si_rotqbi((qword)(a), si_from_int(count))));
1778 }
1779
1780 static __inline vec_uint4 spu_rlqw(vec_uint4 a, int count)
1781 {
1782 return ((vec_uint4)(si_rotqbi((qword)(a), si_from_int(count))));
1783 }
1784
1785 static __inline vec_int4 spu_rlqw(vec_int4 a, int count)
1786 {
1787 return ((vec_int4)(si_rotqbi((qword)(a), si_from_int(count))));
1788 }
1789
1790 static __inline vec_float4 spu_rlqw(vec_float4 a, int count)
1791 {
1792 return ((vec_float4)(si_rotqbi((qword)(a), si_from_int(count))));
1793 }
1794
1795 static __inline vec_ullong2 spu_rlqw(vec_ullong2 a, int count)
1796 {
1797 return ((vec_ullong2)(si_rotqbi((qword)(a), si_from_int(count))));
1798 }
1799
1800 static __inline vec_llong2 spu_rlqw(vec_llong2 a, int count)
1801 {
1802 return ((vec_llong2)(si_rotqbi((qword)(a), si_from_int(count))));
1803 }
1804
1805 static __inline vec_double2 spu_rlqw(vec_double2 a, int count)
1806 {
1807 return ((vec_double2)(si_rotqbi((qword)(a), si_from_int(count))));
1808 }
1809
1810 /* spu_roundtf
1811 * ===========
1812 */
1813 static __inline vec_float4 spu_roundtf(vec_double2 a)
1814 {
1815 return ((vec_float4)(si_frds((qword)(a))));
1816 }
1817
1818
1819 /* spu_rsqrte
1820 * ==========
1821 */
1822 #define spu_rsqrte(_a) vec_rsqrte(_a)
1823
1824
1825 /* spu_sel
1826 * =======
1827 */
1828 static __inline vec_uchar16 spu_sel(vec_uchar16 a, vec_uchar16 b, vec_uchar16 pattern)
1829 {
1830 return ((vec_uchar16)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1831 }
1832
1833 static __inline vec_char16 spu_sel(vec_char16 a, vec_char16 b, vec_uchar16 pattern)
1834 {
1835 return ((vec_char16)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1836 }
1837
1838 static __inline vec_ushort8 spu_sel(vec_ushort8 a, vec_ushort8 b, vec_ushort8 pattern)
1839 {
1840 return ((vec_ushort8)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1841 }
1842
1843 static __inline vec_short8 spu_sel(vec_short8 a, vec_short8 b, vec_ushort8 pattern)
1844 {
1845 return ((vec_short8)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1846 }
1847
1848 static __inline vec_uint4 spu_sel(vec_uint4 a, vec_uint4 b, vec_uint4 pattern)
1849 {
1850 return ((vec_uint4)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1851 }
1852
1853 static __inline vec_int4 spu_sel(vec_int4 a, vec_int4 b, vec_uint4 pattern)
1854 {
1855 return ((vec_int4)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1856 }
1857
1858 static __inline vec_float4 spu_sel(vec_float4 a, vec_float4 b, vec_uint4 pattern)
1859 {
1860 return ((vec_float4)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1861 }
1862
1863 static __inline vec_ullong2 spu_sel(vec_ullong2 a, vec_ullong2 b, vec_ullong2 pattern)
1864 {
1865 return ((vec_ullong2)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1866 }
1867
1868 static __inline vec_llong2 spu_sel(vec_llong2 a, vec_llong2 b, vec_ullong2 pattern)
1869 {
1870 return ((vec_llong2)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1871 }
1872
1873 static __inline vec_double2 spu_sel(vec_double2 a, vec_double2 b, vec_ullong2 pattern)
1874 {
1875 return ((vec_double2)(si_selb((qword)(a), (qword)(b), (qword)(pattern))));
1876 }
1877
1878
1879
1880 /* spu_shuffle
1881 * ===========
1882 */
1883 static __inline vec_uchar16 spu_shuffle(vec_uchar16 a, vec_uchar16 b, vec_uchar16 pattern)
1884 {
1885 return ((vec_uchar16)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1886 }
1887
1888 static __inline vec_char16 spu_shuffle(vec_char16 a, vec_char16 b, vec_uchar16 pattern)
1889 {
1890 return ((vec_char16)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1891 }
1892
1893 static __inline vec_ushort8 spu_shuffle(vec_ushort8 a, vec_ushort8 b, vec_uchar16 pattern)
1894 {
1895 return ((vec_ushort8)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1896 }
1897
1898 static __inline vec_short8 spu_shuffle(vec_short8 a, vec_short8 b, vec_uchar16 pattern)
1899 {
1900 return ((vec_short8)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1901 }
1902
1903 static __inline vec_uint4 spu_shuffle(vec_uint4 a, vec_uint4 b, vec_uchar16 pattern)
1904 {
1905 return ((vec_uint4)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1906 }
1907
1908 static __inline vec_int4 spu_shuffle(vec_int4 a, vec_int4 b, vec_uchar16 pattern)
1909 {
1910 return ((vec_int4)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1911 }
1912
1913 static __inline vec_float4 spu_shuffle(vec_float4 a, vec_float4 b, vec_uchar16 pattern)
1914 {
1915 return ((vec_float4)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1916 }
1917
1918 static __inline vec_ullong2 spu_shuffle(vec_ullong2 a, vec_ullong2 b, vec_uchar16 pattern)
1919 {
1920 return ((vec_ullong2)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1921 }
1922
1923 static __inline vec_llong2 spu_shuffle(vec_llong2 a, vec_llong2 b, vec_uchar16 pattern)
1924 {
1925 return ((vec_llong2)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1926 }
1927
1928 static __inline vec_double2 spu_shuffle(vec_double2 a, vec_double2 b, vec_uchar16 pattern)
1929 {
1930 return ((vec_double2)(si_shufb((qword)(a), (qword)(b), (qword)(pattern))));
1931 }
1932
1933
1934 /* spu_sl
1935 * ======
1936 */
1937 static __inline vec_ushort8 spu_sl(vec_ushort8 a, vec_ushort8 b)
1938 {
1939 return ((vec_ushort8)(si_shlh((qword)(a), (qword)(b))));
1940 }
1941
1942 static __inline vec_short8 spu_sl(vec_short8 a, vec_ushort8 b)
1943 {
1944 return ((vec_short8)(si_shlh((qword)(a), (qword)(b))));
1945 }
1946
1947 static __inline vec_uint4 spu_sl(vec_uint4 a, vec_uint4 b)
1948 {
1949 return ((vec_uint4)(si_shl((qword)(a), (qword)(b))));
1950 }
1951
1952 static __inline vec_int4 spu_sl(vec_int4 a, vec_uint4 b)
1953 {
1954 return ((vec_int4)(si_shl((qword)(a), (qword)(b))));
1955 }
1956
1957 static __inline vec_ushort8 spu_sl(vec_ushort8 a, unsigned int b)
1958 {
1959 return ((vec_ushort8)(si_shlhi((qword)(a), b)));
1960 }
1961
1962 static __inline vec_short8 spu_sl(vec_short8 a, unsigned int b)
1963 {
1964 return ((vec_short8)(si_shlhi((qword)(a), b)));
1965 }
1966
1967 static __inline vec_uint4 spu_sl(vec_uint4 a, unsigned int b)
1968 {
1969 return ((vec_uint4)(si_shli((qword)(a), b)));
1970 }
1971
1972 static __inline vec_int4 spu_sl(vec_int4 a, unsigned int b)
1973 {
1974 return ((vec_int4)(si_shli((qword)(a), b)));
1975 }
1976
1977
1978 /* spu_slqw
1979 * ========
1980 */
1981 static __inline vec_uchar16 spu_slqw(vec_uchar16 a, unsigned int count)
1982 {
1983 return ((vec_uchar16)(si_shlqbi((qword)(a), si_from_uint(count))));
1984 }
1985
1986 static __inline vec_char16 spu_slqw(vec_char16 a, unsigned int count)
1987 {
1988 return ((vec_char16)(si_shlqbi((qword)(a), si_from_uint(count))));
1989 }
1990
1991 static __inline vec_ushort8 spu_slqw(vec_ushort8 a, unsigned int count)
1992 {
1993 return ((vec_ushort8)(si_shlqbi((qword)(a), si_from_uint(count))));
1994 }
1995
1996 static __inline vec_short8 spu_slqw(vec_short8 a, unsigned int count)
1997 {
1998 return ((vec_short8)(si_shlqbi((qword)(a), si_from_uint(count))));
1999 }
2000
2001 static __inline vec_uint4 spu_slqw(vec_uint4 a, unsigned int count)
2002 {
2003 return ((vec_uint4)(si_shlqbi((qword)(a), si_from_uint(count))));
2004 }
2005
2006 static __inline vec_int4 spu_slqw(vec_int4 a, unsigned int count)
2007 {
2008 return ((vec_int4)(si_shlqbi((qword)(a), si_from_uint(count))));
2009 }
2010
2011 static __inline vec_float4 spu_slqw(vec_float4 a, unsigned int count)
2012 {
2013 return ((vec_float4)(si_shlqbi((qword)(a), si_from_uint(count))));
2014 }
2015
2016 static __inline vec_ullong2 spu_slqw(vec_ullong2 a, unsigned int count)
2017 {
2018 return ((vec_ullong2)(si_shlqbi((qword)(a), si_from_uint(count))));
2019 }
2020
2021 static __inline vec_llong2 spu_slqw(vec_llong2 a, unsigned int count)
2022 {
2023 return ((vec_llong2)(si_shlqbi((qword)(a), si_from_uint(count))));
2024 }
2025
2026 static __inline vec_double2 spu_slqw(vec_double2 a, unsigned int count)
2027 {
2028 return ((vec_double2)(si_shlqbi((qword)(a), si_from_uint(count))));
2029 }
2030
2031 /* spu_slqwbyte
2032 * ============
2033 */
2034 static __inline vec_uchar16 spu_slqwbyte(vec_uchar16 a, unsigned int count)
2035 {
2036 return ((vec_uchar16)(si_shlqby((qword)(a), si_from_uint(count))));
2037 }
2038
2039 static __inline vec_char16 spu_slqwbyte(vec_char16 a, unsigned int count)
2040 {
2041 return ((vec_char16)(si_shlqby((qword)(a), si_from_uint(count))));
2042 }
2043
2044 static __inline vec_ushort8 spu_slqwbyte(vec_ushort8 a, unsigned int count)
2045 {
2046 return ((vec_ushort8)(si_shlqby((qword)(a), si_from_uint(count))));
2047 }
2048
2049 static __inline vec_short8 spu_slqwbyte(vec_short8 a, unsigned int count)
2050 {
2051 return ((vec_short8)(si_shlqby((qword)(a), si_from_uint(count))));
2052 }
2053
2054 static __inline vec_uint4 spu_slqwbyte(vec_uint4 a, unsigned int count)
2055 {
2056 return ((vec_uint4)(si_shlqby((qword)(a), si_from_uint(count))));
2057 }
2058
2059 static __inline vec_int4 spu_slqwbyte(vec_int4 a, unsigned int count)
2060 {
2061 return ((vec_int4)(si_shlqby((qword)(a), si_from_uint(count))));
2062 }
2063
2064 static __inline vec_float4 spu_slqwbyte(vec_float4 a, unsigned int count)
2065 {
2066 return ((vec_float4)(si_shlqby((qword)(a), si_from_uint(count))));
2067 }
2068
2069 static __inline vec_ullong2 spu_slqwbyte(vec_ullong2 a, unsigned int count)
2070 {
2071 return ((vec_ullong2)(si_shlqby((qword)(a), si_from_uint(count))));
2072 }
2073
2074 static __inline vec_llong2 spu_slqwbyte(vec_llong2 a, unsigned int count)
2075 {
2076 return ((vec_llong2)(si_shlqby((qword)(a), si_from_uint(count))));
2077 }
2078
2079 static __inline vec_double2 spu_slqwbyte(vec_double2 a, unsigned int count)
2080 {
2081 return ((vec_double2)(si_shlqby((qword)(a), si_from_uint(count))));
2082 }
2083
2084 /* spu_slqwbytebc
2085 * ==============
2086 */
2087 static __inline vec_uchar16 spu_slqwbytebc(vec_uchar16 a, unsigned int count)
2088 {
2089 return ((vec_uchar16)(si_shlqbybi((qword)(a), si_from_uint(count))));
2090 }
2091
2092 static __inline vec_char16 spu_slqwbytebc(vec_char16 a, unsigned int count)
2093 {
2094 return ((vec_char16)(si_shlqbybi((qword)(a), si_from_uint(count))));
2095 }
2096
2097 static __inline vec_ushort8 spu_slqwbytebc(vec_ushort8 a, unsigned int count)
2098 {
2099 return ((vec_ushort8)(si_shlqbybi((qword)(a), si_from_uint(count))));
2100 }
2101
2102 static __inline vec_short8 spu_slqwbytebc(vec_short8 a, unsigned int count)
2103 {
2104 return ((vec_short8)(si_shlqbybi((qword)(a), si_from_uint(count))));
2105 }
2106
2107 static __inline vec_uint4 spu_slqwbytebc(vec_uint4 a, unsigned int count)
2108 {
2109 return ((vec_uint4)(si_shlqbybi((qword)(a), si_from_uint(count))));
2110 }
2111
2112 static __inline vec_int4 spu_slqwbytebc(vec_int4 a, unsigned int count)
2113 {
2114 return ((vec_int4)(si_shlqbybi((qword)(a), si_from_uint(count))));
2115 }
2116
2117 static __inline vec_float4 spu_slqwbytebc(vec_float4 a, unsigned int count)
2118 {
2119 return ((vec_float4)(si_shlqbybi((qword)(a), si_from_uint(count))));
2120 }
2121
2122 static __inline vec_ullong2 spu_slqwbytebc(vec_ullong2 a, unsigned int count)
2123 {
2124 return ((vec_ullong2)(si_shlqbybi((qword)(a), si_from_uint(count))));
2125 }
2126
2127 static __inline vec_llong2 spu_slqwbytebc(vec_llong2 a, unsigned int count)
2128 {
2129 return ((vec_llong2)(si_shlqbybi((qword)(a), si_from_uint(count))));
2130 }
2131
2132 static __inline vec_double2 spu_slqwbytebc(vec_double2 a, unsigned int count)
2133 {
2134 return ((vec_double2)(si_shlqbybi((qword)(a), si_from_uint(count))));
2135 }
2136
2137 /* spu_splats
2138 * ==========
2139 */
2140 static __inline vec_uchar16 spu_splats(unsigned char a)
2141 {
2142 union {
2143 vec_uchar16 v;
2144 unsigned char c[16];
2145 } in;
2146
2147 in.c[0] = a;
2148 return (vec_splat(in.v, 0));
2149 }
2150
2151 static __inline vec_char16 spu_splats(signed char a)
2152 {
2153 return ((vec_char16)spu_splats((unsigned char)(a)));
2154 }
2155
2156 static __inline vec_ushort8 spu_splats(unsigned short a)
2157 {
2158 union {
2159 vec_ushort8 v;
2160 unsigned short s[8];
2161 } in;
2162
2163 in.s[0] = a;
2164 return (vec_splat(in.v, 0));
2165 }
2166
2167 static __inline vec_short8 spu_splats(signed short a)
2168 {
2169 return ((vec_short8)spu_splats((unsigned short)(a)));
2170 }
2171
2172 static __inline vec_uint4 spu_splats(unsigned int a)
2173 {
2174 union {
2175 vec_uint4 v;
2176 unsigned int i[4];
2177 } in;
2178
2179 in.i[0] = a;
2180 return (vec_splat(in.v, 0));
2181 }
2182
2183 static __inline vec_int4 spu_splats(signed int a)
2184 {
2185 return ((vec_int4)spu_splats((unsigned int)(a)));
2186 }
2187
2188 static __inline vec_float4 spu_splats(float a)
2189 {
2190 union {
2191 vec_float4 v;
2192 float f[4];
2193 } in;
2194
2195 in.f[0] = a;
2196 return (vec_splat(in.v, 0));
2197 }
2198
2199 static __inline vec_ullong2 spu_splats(unsigned long long a)
2200 {
2201 union {
2202 vec_ullong2 v;
2203 unsigned long long l[2];
2204 } in;
2205
2206 in.l[0] = a;
2207 in.l[1] = a;
2208 return (in.v);
2209 }
2210
2211 static __inline vec_llong2 spu_splats(signed long long a)
2212 {
2213 return ((vec_llong2)spu_splats((unsigned long long)(a)));
2214 }
2215
2216 static __inline vec_double2 spu_splats(double a)
2217 {
2218 union {
2219 vec_double2 v;
2220 double d[2];
2221 } in;
2222
2223 in.d[0] = a;
2224 in.d[1] = a;
2225 return (in.v);
2226 }
2227
2228
2229 /* spu_stop
2230 * ========
2231 */
2232 #define spu_stop(_type) si_stop(_type)
2233
2234
2235 /* spu_sub
2236 * =======
2237 */
2238 static __inline vec_ushort8 spu_sub(vec_ushort8 a, vec_ushort8 b)
2239 {
2240 return ((vec_ushort8)(si_sfh((qword)(b), (qword)(a))));
2241 }
2242
2243 static __inline vec_short8 spu_sub(vec_short8 a, vec_short8 b)
2244 {
2245 return ((vec_short8)(si_sfh((qword)(b), (qword)(a))));
2246 }
2247
2248 static __inline vec_uint4 spu_sub(vec_uint4 a, vec_uint4 b)
2249 {
2250 return ((vec_uint4)(si_sf((qword)(b), (qword)(a))));
2251 }
2252
2253 static __inline vec_int4 spu_sub(vec_int4 a, vec_int4 b)
2254 {
2255 return ((vec_int4)(si_sf((qword)(b), (qword)(a))));
2256 }
2257
2258 static __inline vec_float4 spu_sub(vec_float4 a, vec_float4 b)
2259 {
2260 return ((vec_float4)(si_fs((qword)(a), (qword)(b))));
2261 }
2262
2263 static __inline vec_double2 spu_sub(vec_double2 a, vec_double2 b)
2264 {
2265 return ((vec_double2)(si_dfs((qword)(a), (qword)(b))));
2266 }
2267
2268 static __inline vec_uint4 spu_sub(unsigned int a, vec_uint4 b)
2269 {
2270 return ((vec_uint4)(si_sfi((qword)b, (int)a)));
2271 }
2272
2273 static __inline vec_int4 spu_sub(signed int a, vec_int4 b)
2274 {
2275 return ((vec_int4)(si_sfi((qword)b, (int)a)));
2276 }
2277
2278 static __inline vec_ushort8 spu_sub(unsigned short a, vec_ushort8 b)
2279 {
2280 return ((vec_ushort8)(si_sfhi((qword)b, (short)a)));
2281 }
2282
2283 static __inline vec_short8 spu_sub(signed short a, vec_short8 b)
2284 {
2285 return ((vec_short8)(si_sfhi((qword)b, (short)a)));
2286 }
2287
2288 /* spu_subx
2289 * ========
2290 */
2291 static __inline vec_uint4 spu_subx(vec_uint4 a, vec_uint4 b, vec_uint4 c)
2292 {
2293 return ((vec_uint4)(si_sfx((qword)(b), (qword)(a), (qword)(c))));
2294 }
2295
2296 static __inline vec_int4 spu_subx(vec_int4 a, vec_int4 b, vec_int4 c)
2297 {
2298 return ((vec_int4)(si_sfx((qword)(b), (qword)(a), (qword)(c))));
2299 }
2300
2301 /* spu_sumb
2302 * ========
2303 */
2304 static __inline vec_ushort8 spu_sumb(vec_uchar16 a, vec_uchar16 b)
2305 {
2306 return ((vec_ushort8)(si_sumb((qword)(a), (qword)(b))));
2307 }
2308
2309
2310 /* spu_sync
2311 * spu_sync_c
2312 * ========
2313 */
2314 #define spu_sync() /* do nothing */
2315
2316 #define spu_sync_c() /* do nothing */
2317
2318
2319 /* spu_writech
2320 * ===========
2321 */
2322 #define spu_writech(_channel, _a) /* not mappable */
2323
2324 /* spu_writechqw
2325 * =============
2326 */
2327 #define spu_writechqw(_channel, _a) /* not mappable */
2328
2329
2330 /* spu_xor
2331 * =======
2332 */
2333 static __inline vec_uchar16 spu_xor(vec_uchar16 a, vec_uchar16 b)
2334 {
2335 return ((vec_uchar16)(si_xor((qword)(a), (qword)(b))));
2336 }
2337
2338 static __inline vec_char16 spu_xor(vec_char16 a, vec_char16 b)
2339 {
2340 return ((vec_char16)(si_xor((qword)(a), (qword)(b))));
2341 }
2342
2343 static __inline vec_ushort8 spu_xor(vec_ushort8 a, vec_ushort8 b)
2344 {
2345 return ((vec_ushort8)(si_xor((qword)(a), (qword)(b))));
2346 }
2347
2348 static __inline vec_short8 spu_xor(vec_short8 a, vec_short8 b)
2349 {
2350 return ((vec_short8)(si_xor((qword)(a), (qword)(b))));
2351 }
2352
2353 static __inline vec_uint4 spu_xor(vec_uint4 a, vec_uint4 b)
2354 {
2355 return ((vec_uint4)(si_xor((qword)(a), (qword)(b))));
2356 }
2357
2358 static __inline vec_int4 spu_xor(vec_int4 a, vec_int4 b)
2359 {
2360 return ((vec_int4)(si_xor((qword)(a), (qword)(b))));
2361 }
2362
2363 static __inline vec_float4 spu_xor(vec_float4 a, vec_float4 b)
2364 {
2365 return ((vec_float4)(si_xor((qword)(a), (qword)(b))));
2366 }
2367
2368 static __inline vec_ullong2 spu_xor(vec_ullong2 a, vec_ullong2 b)
2369 {
2370 return ((vec_ullong2)(si_xor((qword)(a), (qword)(b))));
2371 }
2372
2373 static __inline vec_llong2 spu_xor(vec_llong2 a, vec_llong2 b)
2374 {
2375 return ((vec_llong2)(si_xor((qword)(a), (qword)(b))));
2376 }
2377
2378 static __inline vec_double2 spu_xor(vec_double2 a, vec_double2 b)
2379 {
2380 return ((vec_double2)(si_xor((qword)(a), (qword)(b))));
2381 }
2382
2383 static __inline vec_uchar16 spu_xor(vec_uchar16 a, unsigned char b)
2384 {
2385 return ((vec_uchar16)(si_xorbi((qword)(a), b)));
2386 }
2387
2388 static __inline vec_char16 spu_xor(vec_char16 a, signed char b)
2389 {
2390 return ((vec_char16)(si_xorbi((qword)(a), (unsigned char)(b))));
2391 }
2392
2393 static __inline vec_ushort8 spu_xor(vec_ushort8 a, unsigned short b)
2394 {
2395 return ((vec_ushort8)(si_xorhi((qword)(a), b)));
2396 }
2397
2398 static __inline vec_short8 spu_xor(vec_short8 a, signed short b)
2399 {
2400 return ((vec_short8)(si_xorhi((qword)(a), (unsigned short)(b))));
2401 }
2402
2403 static __inline vec_uint4 spu_xor(vec_uint4 a, unsigned int b)
2404 {
2405 return ((vec_uint4)(si_xori((qword)(a), b)));
2406 }
2407
2408 static __inline vec_int4 spu_xor(vec_int4 a, signed int b)
2409 {
2410 return ((vec_int4)(si_xori((qword)(a), (unsigned int)(b))));
2411 }
2412
2413 #endif /* !__SPU__ */
2414 #endif /* __cplusplus */
2415 #endif /* !_SPU2VMX_H_ */