1 /* Cell SPU 2 VMX intrinsics header
2 Copyright (C) 2007-2019 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 */
spu_absd(vec_uchar16 a,vec_uchar16 b)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 */
spu_add(vec_uint4 a,vec_uint4 b)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
spu_add(vec_int4 a,vec_int4 b)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
spu_add(vec_ushort8 a,vec_ushort8 b)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
spu_add(vec_short8 a,vec_short8 b)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
spu_add(vec_uint4 a,unsigned int b)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
spu_add(vec_int4 a,int b)70 static __inline vec_int4 spu_add(vec_int4 a, int b)
71 {
72 return ((vec_int4)(si_ai((qword)(a), b)));
73 }
74
spu_add(vec_ushort8 a,unsigned short b)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
spu_add(vec_short8 a,short b)80 static __inline vec_short8 spu_add(vec_short8 a, short b)
81 {
82 return ((vec_short8)(si_ahi((qword)(a), b)));
83 }
84
spu_add(vec_float4 a,vec_float4 b)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
spu_add(vec_double2 a,vec_double2 b)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 */
spu_addx(vec_uint4 a,vec_uint4 b,vec_uint4 c)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
spu_addx(vec_int4 a,vec_int4 b,vec_int4 c)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 */
spu_and(vec_uchar16 a,vec_uchar16 b)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
spu_and(vec_char16 a,vec_char16 b)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
spu_and(vec_ushort8 a,vec_ushort8 b)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
spu_and(vec_short8 a,vec_short8 b)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
spu_and(vec_uint4 a,vec_uint4 b)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
spu_and(vec_int4 a,vec_int4 b)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
spu_and(vec_float4 a,vec_float4 b)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
spu_and(vec_ullong2 a,vec_ullong2 b)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
spu_and(vec_llong2 a,vec_llong2 b)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
spu_and(vec_double2 a,vec_double2 b)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
spu_and(vec_uchar16 a,unsigned char b)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
spu_and(vec_char16 a,signed char b)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
spu_and(vec_ushort8 a,unsigned short b)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
spu_and(vec_short8 a,signed short b)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
spu_and(vec_uint4 a,unsigned int b)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
spu_and(vec_int4 a,signed int b)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 */
spu_cmpabseq(vec_float4 a,vec_float4 b)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
spu_cmpabseq(vec_double2 a,vec_double2 b)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 */
spu_cmpabsgt(vec_float4 a,vec_float4 b)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
spu_cmpabsgt(vec_double2 a,vec_double2 b)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 */
spu_cmpeq(vec_uchar16 a,vec_uchar16 b)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
spu_cmpeq(vec_char16 a,vec_char16 b)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
spu_cmpeq(vec_ushort8 a,vec_ushort8 b)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
spu_cmpeq(vec_short8 a,vec_short8 b)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
spu_cmpeq(vec_uint4 a,vec_uint4 b)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
spu_cmpeq(vec_int4 a,vec_int4 b)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
spu_cmpeq(vec_float4 a,vec_float4 b)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
spu_cmpeq(vec_uchar16 a,unsigned char b)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
spu_cmpeq(vec_char16 a,signed char b)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
spu_cmpeq(vec_ushort8 a,unsigned short b)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
spu_cmpeq(vec_short8 a,signed short b)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
spu_cmpeq(vec_uint4 a,unsigned int b)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
spu_cmpeq(vec_int4 a,signed int b)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
spu_cmpeq(vec_double2 a,vec_double2 b)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 */
spu_cmpgt(vec_uchar16 a,vec_uchar16 b)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
spu_cmpgt(vec_char16 a,vec_char16 b)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
spu_cmpgt(vec_ushort8 a,vec_ushort8 b)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
spu_cmpgt(vec_short8 a,vec_short8 b)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
spu_cmpgt(vec_uint4 a,vec_uint4 b)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
spu_cmpgt(vec_int4 a,vec_int4 b)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
spu_cmpgt(vec_float4 a,vec_float4 b)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
spu_cmpgt(vec_uchar16 a,unsigned char b)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
spu_cmpgt(vec_char16 a,signed char b)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
spu_cmpgt(vec_ushort8 a,unsigned short b)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
spu_cmpgt(vec_short8 a,signed short b)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
spu_cmpgt(vec_uint4 a,unsigned int b)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
spu_cmpgt(vec_int4 a,signed int b)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
spu_cmpgt(vec_double2 a,vec_double2 b)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 */
spu_cntb(vec_uchar16 a)396 static __inline vec_uchar16 spu_cntb(vec_uchar16 a)
397 {
398 return ((vec_uchar16)(si_cntb((qword)(a))));
399 }
400
401
spu_cntb(vec_char16 a)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 */
spu_cntlz(vec_uint4 a)410 static __inline vec_uint4 spu_cntlz(vec_uint4 a)
411 {
412 return ((vec_uint4)(si_clz((qword)(a))));
413 }
414
spu_cntlz(vec_int4 a)415 static __inline vec_uint4 spu_cntlz(vec_int4 a)
416 {
417 return ((vec_uint4)(si_clz((qword)(a))));
418 }
419
spu_cntlz(vec_float4 a)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 */
spu_testsv(vec_double2 a,char b)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 */
spu_eqv(vec_uchar16 a,vec_uchar16 b)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
spu_eqv(vec_char16 a,vec_char16 b)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
spu_eqv(vec_ushort8 a,vec_ushort8 b)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
spu_eqv(vec_short8 a,vec_short8 b)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
spu_eqv(vec_uint4 a,vec_uint4 b)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
spu_eqv(vec_int4 a,vec_int4 b)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
spu_eqv(vec_float4 a,vec_float4 b)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
spu_eqv(vec_ullong2 a,vec_ullong2 b)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
spu_eqv(vec_llong2 a,vec_llong2 b)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
spu_eqv(vec_double2 a,vec_double2 b)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 */
spu_extend(vec_char16 a)510 static __inline vec_short8 spu_extend(vec_char16 a)
511 {
512 return ((vec_short8)(si_xsbh((qword)(a))));
513 }
514
515
spu_extend(vec_short8 a)516 static __inline vec_int4 spu_extend(vec_short8 a)
517 {
518 return ((vec_int4)(si_xshw((qword)(a))));
519 }
520
spu_extend(vec_int4 a)521 static __inline vec_llong2 spu_extend(vec_int4 a)
522 {
523 return ((vec_llong2)(si_xswd((qword)(a))));
524 }
525
526
spu_extend(vec_float4 a)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 */
spu_extract(vec_uchar16 a,int element)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
spu_extract(vec_char16 a,int element)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
spu_extract(vec_ushort8 a,int element)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
spu_extract(vec_short8 a,int element)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
spu_extract(vec_uint4 a,int element)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
spu_extract(vec_int4 a,int element)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
spu_extract(vec_float4 a,int element)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
spu_extract(vec_ullong2 a,int element)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
spu_extract(vec_llong2 a,int element)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
spu_extract(vec_double2 a,int element)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 */
spu_gather(vec_uchar16 a)649 static __inline vec_uint4 spu_gather(vec_uchar16 a)
650 {
651 return ((vec_uint4)(si_gbb((qword)(a))));
652 }
653
654
spu_gather(vec_char16 a)655 static __inline vec_uint4 spu_gather(vec_char16 a)
656 {
657 return ((vec_uint4)(si_gbb((qword)(a))));
658 }
659
spu_gather(vec_ushort8 a)660 static __inline vec_uint4 spu_gather(vec_ushort8 a)
661 {
662 return ((vec_uint4)(si_gbh((qword)(a))));
663 }
664
spu_gather(vec_short8 a)665 static __inline vec_uint4 spu_gather(vec_short8 a)
666 {
667 return ((vec_uint4)(si_gbh((qword)(a))));
668 }
669
670
spu_gather(vec_uint4 a)671 static __inline vec_uint4 spu_gather(vec_uint4 a)
672 {
673 return ((vec_uint4)(si_gb((qword)(a))));
674 }
675
spu_gather(vec_int4 a)676 static __inline vec_uint4 spu_gather(vec_int4 a)
677 {
678 return ((vec_uint4)(si_gb((qword)(a))));
679 }
680
spu_gather(vec_float4 a)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 */
spu_genb(vec_uint4 a,vec_uint4 b)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
spu_genb(vec_int4 a,vec_int4 b)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 */
spu_genbx(vec_uint4 a,vec_uint4 b,vec_uint4 c)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
spu_genbx(vec_int4 a,vec_int4 b,vec_int4 c)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 */
spu_genc(vec_uint4 a,vec_uint4 b)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
spu_genc(vec_int4 a,vec_int4 b)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 */
spu_gencx(vec_uint4 a,vec_uint4 b,vec_uint4 c)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
spu_gencx(vec_int4 a,vec_int4 b,vec_int4 c)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 */
spu_insert(unsigned char a,vec_uchar16 b,int element)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
spu_insert(signed char a,vec_char16 b,int element)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
spu_insert(unsigned short a,vec_ushort8 b,int element)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
spu_insert(signed short a,vec_short8 b,int element)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
spu_insert(unsigned int a,vec_uint4 b,int element)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
spu_insert(signed int a,vec_int4 b,int element)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
spu_insert(float a,vec_float4 b,int element)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
spu_insert(unsigned long long a,vec_ullong2 b,int element)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
spu_insert(signed long long a,vec_llong2 b,int element)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
spu_insert(double a,vec_double2 b,int element)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 */
spu_madd(vec_short8 a,vec_short8 b,vec_int4 c)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
spu_madd(vec_float4 a,vec_float4 b,vec_float4 c)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
spu_madd(vec_double2 a,vec_double2 b,vec_double2 c)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 */
spu_mhhadd(vec_short8 a,vec_short8 b,vec_int4 c)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
spu_mhhadd(vec_ushort8 a,vec_ushort8 b,vec_uint4 c)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 */
spu_msub(vec_float4 a,vec_float4 b,vec_float4 c)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
spu_msub(vec_double2 a,vec_double2 b,vec_double2 c)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 */
spu_mul(vec_float4 a,vec_float4 b)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
spu_mul(vec_double2 a,vec_double2 b)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 */
spu_mulh(vec_short8 a,vec_short8 b)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 */
spu_mulo(vec_short8 a,vec_short8 b)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
spu_mulo(vec_ushort8 a,vec_ushort8 b)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
spu_mulo(vec_short8 a,short b)1013 static __inline vec_int4 spu_mulo(vec_short8 a, short b)
1014 {
1015 return ((vec_int4)(si_mpyi((qword)(a), b)));
1016 }
1017
spu_mulo(vec_ushort8 a,unsigned short b)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 */
spu_mulsr(vec_short8 a,vec_short8 b)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 */
spu_nand(vec_uchar16 a,vec_uchar16 b)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
spu_nand(vec_char16 a,vec_char16 b)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
spu_nand(vec_ushort8 a,vec_ushort8 b)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
spu_nand(vec_short8 a,vec_short8 b)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
spu_nand(vec_uint4 a,vec_uint4 b)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
spu_nand(vec_int4 a,vec_int4 b)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
spu_nand(vec_float4 a,vec_float4 b)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
spu_nand(vec_ullong2 a,vec_ullong2 b)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
spu_nand(vec_llong2 a,vec_llong2 b)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
spu_nand(vec_double2 a,vec_double2 b)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 */
spu_nmadd(vec_double2 a,vec_double2 b,vec_double2 c)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 */
spu_nmsub(vec_float4 a,vec_float4 b,vec_float4 c)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
spu_nmsub(vec_double2 a,vec_double2 b,vec_double2 c)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 */
spu_or(vec_uchar16 a,vec_uchar16 b)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
spu_or(vec_char16 a,vec_char16 b)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
spu_or(vec_ushort8 a,vec_ushort8 b)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
spu_or(vec_short8 a,vec_short8 b)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
spu_or(vec_uint4 a,vec_uint4 b)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
spu_or(vec_int4 a,vec_int4 b)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
spu_or(vec_float4 a,vec_float4 b)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
spu_or(vec_ullong2 a,vec_ullong2 b)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
spu_or(vec_llong2 a,vec_llong2 b)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
spu_or(vec_double2 a,vec_double2 b)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
spu_or(vec_uchar16 a,unsigned char b)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
spu_or(vec_char16 a,signed char b)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
spu_or(vec_ushort8 a,unsigned short b)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
spu_or(vec_short8 a,signed short b)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
spu_or(vec_uint4 a,unsigned int b)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
spu_or(vec_int4 a,signed int b)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 */
spu_orx(vec_uint4 a)1210 static __inline vec_uint4 spu_orx(vec_uint4 a)
1211 {
1212 return ((vec_uint4)(si_orx((qword)(a))));
1213 }
1214
spu_orx(vec_int4 a)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 */
spu_promote(unsigned char a,int element)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
spu_promote(signed char a,int element)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
spu_promote(unsigned short a,int element)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
spu_promote(signed short a,int element)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
spu_promote(unsigned int a,int element)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
spu_promote(signed int a,int element)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
spu_promote(float a,int element)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
spu_promote(unsigned long long a,int element)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
spu_promote(signed long long a,int element)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
spu_promote(double a,int element)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 */
spu_rl(vec_ushort8 a,vec_short8 b)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
spu_rl(vec_short8 a,vec_short8 b)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
spu_rl(vec_uint4 a,vec_int4 b)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
spu_rl(vec_int4 a,vec_int4 b)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
spu_rl(vec_ushort8 a,int b)1380 static __inline vec_ushort8 spu_rl(vec_ushort8 a, int b)
1381 {
1382 return ((vec_ushort8)(si_rothi((qword)(a), b)));
1383 }
1384
spu_rl(vec_short8 a,int b)1385 static __inline vec_short8 spu_rl(vec_short8 a, int b)
1386 {
1387 return ((vec_short8)(si_rothi((qword)(a), b)));
1388 }
1389
spu_rl(vec_uint4 a,int b)1390 static __inline vec_uint4 spu_rl(vec_uint4 a, int b)
1391 {
1392 return ((vec_uint4)(si_roti((qword)(a), b)));
1393 }
1394
spu_rl(vec_int4 a,int b)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 */
spu_rlmask(vec_ushort8 a,vec_short8 b)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
spu_rlmask(vec_short8 a,vec_short8 b)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
spu_rlmask(vec_uint4 a,vec_int4 b)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
spu_rlmask(vec_int4 a,vec_int4 b)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
spu_rlmask(vec_ushort8 a,int b)1424 static __inline vec_ushort8 spu_rlmask(vec_ushort8 a, int b)
1425 {
1426 return ((vec_ushort8)(si_rothmi((qword)(a), b)));
1427 }
1428
spu_rlmask(vec_short8 a,int b)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
spu_rlmask(vec_uint4 a,int b)1435 static __inline vec_uint4 spu_rlmask(vec_uint4 a, int b)
1436 {
1437 return ((vec_uint4)(si_rotmi((qword)(a), b)));
1438 }
1439
spu_rlmask(vec_int4 a,int b)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 */
spu_rlmaska(vec_short8 a,vec_short8 b)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
spu_rlmaska(vec_ushort8 a,vec_short8 b)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
spu_rlmaska(vec_int4 a,vec_int4 b)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
spu_rlmaska(vec_uint4 a,vec_int4 b)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
spu_rlmaska(vec_ushort8 a,int b)1469 static __inline vec_ushort8 spu_rlmaska(vec_ushort8 a, int b)
1470 {
1471 return ((vec_ushort8)(si_rotmahi((qword)(a), b)));
1472 }
1473
spu_rlmaska(vec_short8 a,int b)1474 static __inline vec_short8 spu_rlmaska(vec_short8 a, int b)
1475 {
1476 return ((vec_short8)(si_rotmahi((qword)(a), b)));
1477 }
1478
spu_rlmaska(vec_uint4 a,int b)1479 static __inline vec_uint4 spu_rlmaska(vec_uint4 a, int b)
1480 {
1481 return ((vec_uint4)(si_rotmai((qword)(a), b)));
1482 }
1483
spu_rlmaska(vec_int4 a,int b)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 */
spu_rlmaskqw(vec_uchar16 a,int count)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
spu_rlmaskqw(vec_char16 a,int count)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
spu_rlmaskqw(vec_ushort8 a,int count)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
spu_rlmaskqw(vec_short8 a,int count)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
spu_rlmaskqw(vec_uint4 a,int count)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
spu_rlmaskqw(vec_int4 a,int count)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
spu_rlmaskqw(vec_float4 a,int count)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
spu_rlmaskqw(vec_ullong2 a,int count)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
spu_rlmaskqw(vec_llong2 a,int count)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
spu_rlmaskqw(vec_double2 a,int count)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 */
spu_rlmaskqwbyte(vec_uchar16 a,int count)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
spu_rlmaskqwbyte(vec_char16 a,int count)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
spu_rlmaskqwbyte(vec_ushort8 a,int count)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
spu_rlmaskqwbyte(vec_short8 a,int count)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
spu_rlmaskqwbyte(vec_uint4 a,int count)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
spu_rlmaskqwbyte(vec_int4 a,int count)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
spu_rlmaskqwbyte(vec_float4 a,int count)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
spu_rlmaskqwbyte(vec_ullong2 a,int count)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
spu_rlmaskqwbyte(vec_llong2 a,int count)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
spu_rlmaskqwbyte(vec_double2 a,int count)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 */
spu_rlmaskqwbytebc(vec_uchar16 a,int count)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
spu_rlmaskqwbytebc(vec_char16 a,int count)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
spu_rlmaskqwbytebc(vec_ushort8 a,int count)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
spu_rlmaskqwbytebc(vec_short8 a,int count)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
spu_rlmaskqwbytebc(vec_uint4 a,int count)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
spu_rlmaskqwbytebc(vec_int4 a,int count)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
spu_rlmaskqwbytebc(vec_float4 a,int count)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
spu_rlmaskqwbytebc(vec_ullong2 a,int count)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
spu_rlmaskqwbytebc(vec_llong2 a,int count)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
spu_rlmaskqwbytebc(vec_double2 a,int count)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 */
spu_rlqwbyte(vec_uchar16 a,int count)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
spu_rlqwbyte(vec_char16 a,int count)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
spu_rlqwbyte(vec_ushort8 a,int count)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
spu_rlqwbyte(vec_short8 a,int count)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
spu_rlqwbyte(vec_uint4 a,int count)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
spu_rlqwbyte(vec_int4 a,int count)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
spu_rlqwbyte(vec_float4 a,int count)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
spu_rlqwbyte(vec_ullong2 a,int count)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
spu_rlqwbyte(vec_llong2 a,int count)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
spu_rlqwbyte(vec_double2 a,int count)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 */
spu_rlqwbytebc(vec_uchar16 a,int count)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
spu_rlqwbytebc(vec_char16 a,int count)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
spu_rlqwbytebc(vec_ushort8 a,int count)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
spu_rlqwbytebc(vec_short8 a,int count)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
spu_rlqwbytebc(vec_uint4 a,int count)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
spu_rlqwbytebc(vec_int4 a,int count)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
spu_rlqwbytebc(vec_float4 a,int count)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
spu_rlqwbytebc(vec_ullong2 a,int count)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
spu_rlqwbytebc(vec_llong2 a,int count)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
spu_rlqwbytebc(vec_double2 a,int count)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 */
spu_rlqw(vec_uchar16 a,int count)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
spu_rlqw(vec_char16 a,int count)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
spu_rlqw(vec_ushort8 a,int count)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
spu_rlqw(vec_short8 a,int count)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
spu_rlqw(vec_uint4 a,int count)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
spu_rlqw(vec_int4 a,int count)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
spu_rlqw(vec_float4 a,int count)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
spu_rlqw(vec_ullong2 a,int count)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
spu_rlqw(vec_llong2 a,int count)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
spu_rlqw(vec_double2 a,int count)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 */
spu_roundtf(vec_double2 a)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 */
spu_sel(vec_uchar16 a,vec_uchar16 b,vec_uchar16 pattern)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
spu_sel(vec_char16 a,vec_char16 b,vec_uchar16 pattern)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
spu_sel(vec_ushort8 a,vec_ushort8 b,vec_ushort8 pattern)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
spu_sel(vec_short8 a,vec_short8 b,vec_ushort8 pattern)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
spu_sel(vec_uint4 a,vec_uint4 b,vec_uint4 pattern)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
spu_sel(vec_int4 a,vec_int4 b,vec_uint4 pattern)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
spu_sel(vec_float4 a,vec_float4 b,vec_uint4 pattern)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
spu_sel(vec_ullong2 a,vec_ullong2 b,vec_ullong2 pattern)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
spu_sel(vec_llong2 a,vec_llong2 b,vec_ullong2 pattern)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
spu_sel(vec_double2 a,vec_double2 b,vec_ullong2 pattern)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 */
spu_shuffle(vec_uchar16 a,vec_uchar16 b,vec_uchar16 pattern)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
spu_shuffle(vec_char16 a,vec_char16 b,vec_uchar16 pattern)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
spu_shuffle(vec_ushort8 a,vec_ushort8 b,vec_uchar16 pattern)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
spu_shuffle(vec_short8 a,vec_short8 b,vec_uchar16 pattern)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
spu_shuffle(vec_uint4 a,vec_uint4 b,vec_uchar16 pattern)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
spu_shuffle(vec_int4 a,vec_int4 b,vec_uchar16 pattern)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
spu_shuffle(vec_float4 a,vec_float4 b,vec_uchar16 pattern)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
spu_shuffle(vec_ullong2 a,vec_ullong2 b,vec_uchar16 pattern)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
spu_shuffle(vec_llong2 a,vec_llong2 b,vec_uchar16 pattern)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
spu_shuffle(vec_double2 a,vec_double2 b,vec_uchar16 pattern)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 */
spu_sl(vec_ushort8 a,vec_ushort8 b)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
spu_sl(vec_short8 a,vec_ushort8 b)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
spu_sl(vec_uint4 a,vec_uint4 b)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
spu_sl(vec_int4 a,vec_uint4 b)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
spu_sl(vec_ushort8 a,unsigned int b)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
spu_sl(vec_short8 a,unsigned int b)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
spu_sl(vec_uint4 a,unsigned int b)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
spu_sl(vec_int4 a,unsigned int b)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 */
spu_slqw(vec_uchar16 a,unsigned int count)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
spu_slqw(vec_char16 a,unsigned int count)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
spu_slqw(vec_ushort8 a,unsigned int count)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
spu_slqw(vec_short8 a,unsigned int count)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
spu_slqw(vec_uint4 a,unsigned int count)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
spu_slqw(vec_int4 a,unsigned int count)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
spu_slqw(vec_float4 a,unsigned int count)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
spu_slqw(vec_ullong2 a,unsigned int count)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
spu_slqw(vec_llong2 a,unsigned int count)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
spu_slqw(vec_double2 a,unsigned int count)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 */
spu_slqwbyte(vec_uchar16 a,unsigned int count)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
spu_slqwbyte(vec_char16 a,unsigned int count)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
spu_slqwbyte(vec_ushort8 a,unsigned int count)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
spu_slqwbyte(vec_short8 a,unsigned int count)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
spu_slqwbyte(vec_uint4 a,unsigned int count)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
spu_slqwbyte(vec_int4 a,unsigned int count)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
spu_slqwbyte(vec_float4 a,unsigned int count)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
spu_slqwbyte(vec_ullong2 a,unsigned int count)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
spu_slqwbyte(vec_llong2 a,unsigned int count)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
spu_slqwbyte(vec_double2 a,unsigned int count)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 */
spu_slqwbytebc(vec_uchar16 a,unsigned int count)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
spu_slqwbytebc(vec_char16 a,unsigned int count)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
spu_slqwbytebc(vec_ushort8 a,unsigned int count)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
spu_slqwbytebc(vec_short8 a,unsigned int count)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
spu_slqwbytebc(vec_uint4 a,unsigned int count)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
spu_slqwbytebc(vec_int4 a,unsigned int count)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
spu_slqwbytebc(vec_float4 a,unsigned int count)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
spu_slqwbytebc(vec_ullong2 a,unsigned int count)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
spu_slqwbytebc(vec_llong2 a,unsigned int count)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
spu_slqwbytebc(vec_double2 a,unsigned int count)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 */
spu_splats(unsigned char a)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
spu_splats(signed char a)2151 static __inline vec_char16 spu_splats(signed char a)
2152 {
2153 return ((vec_char16)spu_splats((unsigned char)(a)));
2154 }
2155
spu_splats(unsigned short a)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
spu_splats(signed short a)2167 static __inline vec_short8 spu_splats(signed short a)
2168 {
2169 return ((vec_short8)spu_splats((unsigned short)(a)));
2170 }
2171
spu_splats(unsigned int a)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
spu_splats(signed int a)2183 static __inline vec_int4 spu_splats(signed int a)
2184 {
2185 return ((vec_int4)spu_splats((unsigned int)(a)));
2186 }
2187
spu_splats(float a)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
spu_splats(unsigned long long a)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
spu_splats(signed long long a)2211 static __inline vec_llong2 spu_splats(signed long long a)
2212 {
2213 return ((vec_llong2)spu_splats((unsigned long long)(a)));
2214 }
2215
spu_splats(double a)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 */
spu_sub(vec_ushort8 a,vec_ushort8 b)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
spu_sub(vec_short8 a,vec_short8 b)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
spu_sub(vec_uint4 a,vec_uint4 b)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
spu_sub(vec_int4 a,vec_int4 b)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
spu_sub(vec_float4 a,vec_float4 b)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
spu_sub(vec_double2 a,vec_double2 b)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
spu_sub(unsigned int a,vec_uint4 b)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
spu_sub(signed int a,vec_int4 b)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
spu_sub(unsigned short a,vec_ushort8 b)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
spu_sub(signed short a,vec_short8 b)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 */
spu_subx(vec_uint4 a,vec_uint4 b,vec_uint4 c)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
spu_subx(vec_int4 a,vec_int4 b,vec_int4 c)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 */
spu_sumb(vec_uchar16 a,vec_uchar16 b)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 */
spu_xor(vec_uchar16 a,vec_uchar16 b)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
spu_xor(vec_char16 a,vec_char16 b)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
spu_xor(vec_ushort8 a,vec_ushort8 b)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
spu_xor(vec_short8 a,vec_short8 b)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
spu_xor(vec_uint4 a,vec_uint4 b)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
spu_xor(vec_int4 a,vec_int4 b)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
spu_xor(vec_float4 a,vec_float4 b)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
spu_xor(vec_ullong2 a,vec_ullong2 b)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
spu_xor(vec_llong2 a,vec_llong2 b)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
spu_xor(vec_double2 a,vec_double2 b)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
spu_xor(vec_uchar16 a,unsigned char b)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
spu_xor(vec_char16 a,signed char b)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
spu_xor(vec_ushort8 a,unsigned short b)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
spu_xor(vec_short8 a,signed short b)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
spu_xor(vec_uint4 a,unsigned int b)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
spu_xor(vec_int4 a,signed int b)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_ */
2416