|
0
|
1 /* Cell SPU 2 VMX intrinsics header
|
|
|
2 Copyright (C) 2007, 2009 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_ */
|
