OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [spu/] [vmx2spu.h] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn 
/* Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
2 
 
3 
   This file is free software; you can redistribute it and/or modify it under
4 
   the terms of the GNU General Public License as published by the Free
5 
   Software Foundation; either version 3 of the License, or (at your option)
6 
   any later version.
7 
 
8 
   This file is distributed in the hope that it will be useful, but WITHOUT
9 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
11 
   for more details.
12 
 
13 
   Under Section 7 of GPL version 3, you are granted additional
14 
   permissions described in the GCC Runtime Library Exception, version
15 
   3.1, as published by the Free Software Foundation.
16 
 
17 
   You should have received a copy of the GNU General Public License and
18 
   a copy of the GCC Runtime Library Exception along with this program;
19 
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
20 
   <http://www.gnu.org/licenses/>.  */
21 
 
22 
#ifndef _VMX2SPU_H_
23 
#define _VMX2SPU_H_     1
24 
 
25 
#ifdef __cplusplus
26 
 
27 
#ifdef __SPU__
28 
 
29 
#include <spu_intrinsics.h>
30 
#include <vec_types.h>
31 
 
32 
/* This file maps generic VMX intrinsics and predicates to the SPU using
33 
 * overloaded C++ functions.
34 
 */
35 
 
36 
/************************************************************************
37 
 *                        INTRINSICS
38 
 ************************************************************************/
39 
 
40 
/* vec_abs (vector absolute value)
41 
 * =======
42 
 */
43 
static inline vec_char16 vec_abs(vec_char16 a)
44 
{
45 
  vec_char16 minus_a;
46 
 
47 
  minus_a = (vec_char16)(spu_add((vec_ushort8)(spu_and(spu_xor(a, 0xFF), 0x7F)), 0x101));
48 
  return (spu_sel(minus_a, a, spu_cmpgt(a, -1)));
49 
}
50 
 
51 
static inline vec_short8 vec_abs(vec_short8 a)
52 
{
53 
  return (spu_sel(spu_sub(0, a), a, spu_cmpgt(a, -1)));
54 
}
55 
 
56 
static inline vec_int4 vec_abs(vec_int4 a)
57 
{
58 
  return (spu_sel(spu_sub(0, a), a, spu_cmpgt(a, -1)));
59 
}
60 
 
61 
static inline vec_float4 vec_abs(vec_float4 a)
62 
{
63 
  return ((vec_float4)(spu_rlmask(spu_sl((vec_uint4)(a), 1), -1)));
64 
}
65 
 
66 
/* vec_abss (vector absolute value saturate)
67 
 * ========
68 
 */
69 
static inline vec_char16 vec_abss(vec_char16 a)
70 
{
71 
  vec_char16 minus_a;
72 
 
73 
  minus_a = (vec_char16)spu_add((vec_short8)(spu_xor(a, -1)),
74 
                                (vec_short8)(spu_and(spu_cmpgt((vec_uchar16)(a), 0x80), 1)));
75 
  return (spu_sel(minus_a, a, spu_cmpgt(a, -1)));
76 
}
77 
 
78 
static inline vec_short8 vec_abss(vec_short8 a)
79 
{
80 
  vec_short8 minus_a;
81 
 
82 
  minus_a = spu_add(spu_sub(0, a), (vec_short8)(spu_cmpeq(a, ((vec_short8){0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000,0x8000}))));
83 
  return (spu_sel(minus_a, a, spu_cmpgt(a, -1)));
84 
}
85 
 
86 
static inline vec_int4 vec_abss(vec_int4 a)
87 
{
88 
  vec_int4 minus_a;
89 
 
90 
  minus_a = spu_add(spu_sub(0, a), (vec_int4)(spu_cmpeq(a, ((vec_int4){0x80000000,0x80000000,0x80000000,0x80000000}))));
91 
  return (spu_sel(minus_a, a, spu_cmpgt(a, -1)));
92 
}
93 
 
94 
 
95 
/* vec_add (vector add)
96 
 * =======
97 
 */
98 
static inline vec_uchar16 vec_add(vec_uchar16 a, vec_uchar16 b)
99 
{
100 
  return ((vec_uchar16)(spu_sel(spu_add((vec_ushort8)(a), (vec_ushort8)(b)),
101 
                                spu_add(spu_and((vec_ushort8)(a), 0xFF00), spu_and((vec_ushort8)(b), 0xFF00)),
102 
                                spu_splats((unsigned short)(0xFF00)))));
103 
}
104 
 
105 
static inline vec_char16 vec_add(vec_char16 a, vec_char16 b)
106 
{
107 
  return ((vec_char16)vec_add((vec_uchar16)(a), (vec_uchar16)(b)));
108 
}
109 
 
110 
static inline vec_char16 vec_add(vec_bchar16 a, vec_char16 b)
111 
{
112 
  return ((vec_char16)vec_add((vec_uchar16)(a), (vec_uchar16)(b)));
113 
}
114 
 
115 
static inline vec_char16 vec_add(vec_char16 a, vec_bchar16 b)
116 
{
117 
  return ((vec_char16)vec_add((vec_uchar16)(a), (vec_uchar16)(b)));
118 
}
119 
 
120 
static inline vec_ushort8 vec_add(vec_ushort8 a, vec_ushort8 b)
121 
{
122 
  return (spu_add(a, b));
123 
}
124 
 
125 
static inline vec_short8 vec_add(vec_short8 a, vec_short8 b)
126 
{
127 
  return (spu_add(a, b));
128 
}
129 
 
130 
static inline vec_short8 vec_add(vec_bshort8 a, vec_short8 b)
131 
{
132 
  return (spu_add((vec_short8)(a), b));
133 
}
134 
 
135 
static inline vec_short8 vec_add(vec_short8 a, vec_bshort8 b)
136 
{
137 
  return (spu_add(a, (vec_short8)(b)));
138 
}
139 
 
140 
static inline vec_uint4 vec_add(vec_uint4 a, vec_uint4 b)
141 
{
142 
  return (spu_add(a, b));
143 
}
144 
 
145 
static inline vec_int4 vec_add(vec_int4 a, vec_int4 b)
146 
{
147 
  return (spu_add(a, b));
148 
}
149 
 
150 
static inline vec_int4 vec_add(vec_bint4 a, vec_int4 b)
151 
{
152 
  return (spu_add((vec_int4)(a), b));
153 
}
154 
 
155 
static inline vec_int4 vec_add(vec_int4 a, vec_bint4 b)
156 
{
157 
  return (spu_add(a, (vec_int4)(b)));
158 
}
159 
 
160 
static inline vec_float4 vec_add(vec_float4 a, vec_float4 b)
161 
{
162 
  return (spu_add(a, b));
163 
}
164 
 
165 
/* vec_addc (vector add carryout unsigned word)
166 
 * ========
167 
 */
168 
#define vec_addc(_a, _b)        spu_genc(_a, _b)
169 
 
170 
/* vec_adds (vector add saturated)
171 
 * ========
172 
 */
173 
static inline vec_uchar16 vec_adds(vec_uchar16 a, vec_uchar16 b)
174 
{
175 
  vec_uchar16 s1, s2, s, d;
176 
 
177 
  s1 = (vec_uchar16)(spu_add(spu_rlmask((vec_ushort8)(a), -8), spu_rlmask((vec_ushort8)(b), -8)));
178 
  s2 = (vec_uchar16)(spu_add(spu_and((vec_ushort8)(a), 0xFF), spu_and((vec_ushort8)(b), 0xFF)));
179 
  s  = spu_shuffle(s1, s2, ((vec_uchar16){0, 16,  2, 18,  4, 20,  6, 22,
180 
                                          8, 24, 10, 26, 12, 28, 14, 30}));
181 
  d  = spu_shuffle(s1, s2, ((vec_uchar16){1, 17,  3, 19,  5, 21,  7, 23,
182 
                                          9, 25, 11, 27, 13, 29, 15, 31}));
183 
  return (spu_or(d, spu_cmpeq(s, 1)));
184 
}
185 
 
186 
static inline vec_char16 vec_adds(vec_char16 a, vec_char16 b)
187 
{
188 
  vec_uchar16 s1, s2, s, d;
189 
 
190 
  s1 = (vec_uchar16)(spu_add(spu_rlmask((vec_ushort8)(a), -8), spu_rlmask((vec_ushort8)(b), -8)));
191 
  s2 = (vec_uchar16)(spu_add(spu_and((vec_ushort8)(a), 0xFF), spu_and((vec_ushort8)(b), 0xFF)));
192 
  s  = spu_shuffle(s1, s2, ((vec_uchar16){1, 17,  3, 19,  5, 21,  7, 23,
193 
                                          9, 25, 11, 27, 13, 29, 15, 31}));
194 
  d = spu_sel(s, spu_splats((unsigned char)0x7F), spu_cmpgt(spu_and(s, (vec_uchar16)(spu_nor(a, b))), 0x7F));
195 
  d = spu_sel(d, spu_splats((unsigned char)0x80), spu_cmpgt(spu_nor(s, (vec_uchar16)(spu_nand(a, b))), 0x7F));
196 
  return ((vec_char16)(d));
197 
}
198 
 
199 
static inline vec_char16 vec_adds(vec_bchar16 a, vec_char16 b)
200 
{
201 
  return (vec_adds((vec_char16)(a), b));
202 
}
203 
 
204 
static inline vec_char16 vec_adds(vec_char16 a, vec_bchar16 b)
205 
{
206 
  return (vec_adds(a, (vec_char16)(b)));
207 
}
208 
 
209 
static inline vec_ushort8 vec_adds(vec_ushort8 a, vec_ushort8 b)
210 
{
211 
  vec_ushort8 s, d;
212 
 
213 
  s = spu_add(a, b);
214 
  d = spu_or(s, spu_rlmaska(spu_sel(spu_xor(s, -1), a, spu_eqv(a, b)), -15));
215 
  return (d);
216 
}
217 
 
218 
static inline vec_short8 vec_adds(vec_short8 a, vec_short8 b)
219 
{
220 
  vec_short8 s, d;
221 
 
222 
  s = spu_add(a, b);
223 
  d = spu_sel(s, spu_splats((signed short)0x7FFF), (vec_ushort8)(spu_rlmaska(spu_and(s, spu_nor(a, b)), -15)));
224 
  d = spu_sel(d, spu_splats((signed short)0x8000), (vec_ushort8)(spu_rlmaska(spu_nor(s, spu_nand(a, b)), -15)));
225 
  return (d);
226 
}
227 
 
228 
static inline vec_short8 vec_adds(vec_bshort8 a, vec_short8 b)
229 
{
230 
  return (vec_adds((vec_short8)(a), b));
231 
}
232 
 
233 
static inline vec_short8 vec_adds(vec_short8 a, vec_bshort8 b)
234 
{
235 
  return (vec_adds(a, (vec_short8)(b)));
236 
}
237 
 
238 
static inline vec_uint4 vec_adds(vec_uint4 a, vec_uint4 b)
239 
{
240 
  return (spu_or(spu_add(a, b), spu_rlmaska(spu_sl(spu_genc(a, b), 31), -31)));
241 
}
242 
 
243 
static inline vec_int4 vec_adds(vec_int4 a, vec_int4 b)
244 
{
245 
  vec_int4 s, d;
246 
 
247 
  s = spu_add(a, b);
248 
  d = spu_sel(s, spu_splats((signed int)0x7FFFFFFF), (vec_uint4)spu_rlmaska(spu_and(s, spu_nor(a, b)), -31));
249 
  d = spu_sel(d, spu_splats((signed int)0x80000000), (vec_uint4)spu_rlmaska(spu_nor(s, spu_nand(a, b)), -31));
250 
  return (d);
251 
}
252 
 
253 
static inline vec_int4 vec_adds(vec_bint4 a, vec_int4 b)
254 
{
255 
  return (vec_adds((vec_int4)(a), b));
256 
}
257 
 
258 
static inline vec_int4 vec_adds(vec_int4 a, vec_bint4 b)
259 
{
260 
  return (vec_adds(a, (vec_int4)(b)));
261 
}
262 
 
263 
/* vec_and (vector logical and)
264 
 * =======
265 
 */
266 
static inline vec_uchar16 vec_and(vec_uchar16 a, vec_uchar16 b)
267 
{
268 
  return (spu_and(a, b));
269 
}
270 
 
271 
static inline vec_char16 vec_and(vec_char16 a, vec_char16 b)
272 
{
273 
  return (spu_and(a, b));
274 
}
275 
 
276 
static inline vec_char16 vec_and(vec_bchar16 a, vec_char16 b)
277 
{
278 
  return (spu_and((vec_char16)(a), b));
279 
}
280 
 
281 
static inline vec_char16 vec_and(vec_char16 a, vec_bchar16 b)
282 
{
283 
  return (spu_and(a, (vec_char16)(b)));
284 
}
285 
 
286 
static inline vec_ushort8 vec_and(vec_ushort8 a, vec_ushort8 b)
287 
{
288 
  return (spu_and(a, b));
289 
}
290 
 
291 
static inline vec_short8 vec_and(vec_short8 a, vec_short8 b)
292 
{
293 
  return (spu_and(a, b));
294 
}
295 
 
296 
static inline vec_short8 vec_and(vec_bshort8 a, vec_short8 b)
297 
{
298 
  return (spu_and((vec_short8)(a), b));
299 
}
300 
 
301 
static inline vec_short8 vec_and(vec_short8 a, vec_bshort8 b)
302 
{
303 
  return (spu_and(a, (vec_short8)(b)));
304 
}
305 
 
306 
static inline vec_uint4 vec_and(vec_uint4 a, vec_uint4 b)
307 
{
308 
  return (spu_and(a, b));
309 
}
310 
 
311 
static inline vec_int4 vec_and(vec_int4 a, vec_int4 b)
312 
{
313 
  return (spu_and(a, b));
314 
}
315 
 
316 
static inline vec_int4 vec_and(vec_bint4 a, vec_int4 b)
317 
{
318 
  return (spu_and((vec_int4)(a), b));
319 
}
320 
 
321 
static inline vec_int4 vec_and(vec_int4 a, vec_bint4 b)
322 
{
323 
  return (spu_and(a, (vec_int4)(b)));
324 
}
325 
 
326 
static inline vec_float4 vec_and(vec_float4 a, vec_float4 b)
327 
{
328 
  return (spu_and(a, b));
329 
}
330 
 
331 
static inline vec_float4 vec_and(vec_bint4 a, vec_float4 b)
332 
{
333 
  return (spu_and((vec_float4)(a),b));
334 
}
335 
 
336 
static inline vec_float4 vec_and(vec_float4 a, vec_bint4 b)
337 
{
338 
  return (spu_and(a, (vec_float4)(b)));
339 
}
340 
 
341 
 
342 
/* vec_andc (vector logical and with complement)
343 
 * ========
344 
 */
345 
static inline vec_uchar16 vec_andc(vec_uchar16 a, vec_uchar16 b)
346 
{
347 
  return (spu_andc(a, b));
348 
}
349 
 
350 
static inline vec_char16 vec_andc(vec_char16 a, vec_char16 b)
351 
{
352 
  return (spu_andc(a, b));
353 
}
354 
 
355 
static inline vec_char16 vec_andc(vec_bchar16 a, vec_char16 b)
356 
{
357 
  return (spu_andc((vec_char16)(a), b));
358 
}
359 
 
360 
static inline vec_char16 vec_andc(vec_char16 a, vec_bchar16 b)
361 
{
362 
  return (spu_andc(a, (vec_char16)(b)));
363 
}
364 
 
365 
static inline vec_ushort8 vec_andc(vec_ushort8 a, vec_ushort8 b)
366 
{
367 
  return (spu_andc(a, b));
368 
}
369 
 
370 
static inline vec_short8 vec_andc(vec_short8 a, vec_short8 b)
371 
{
372 
  return (spu_andc(a, b));
373 
}
374 
 
375 
static inline vec_short8 vec_andc(vec_bshort8 a, vec_short8 b)
376 
{
377 
  return (spu_andc((vec_short8)(a), b));
378 
}
379 
 
380 
static inline vec_short8 vec_andc(vec_short8 a, vec_bshort8 b)
381 
{
382 
  return (spu_andc(a, (vec_short8)(b)));
383 
}
384 
 
385 
static inline vec_uint4 vec_andc(vec_uint4 a, vec_uint4 b)
386 
{
387 
  return (spu_andc(a, b));
388 
}
389 
 
390 
static inline vec_int4 vec_andc(vec_int4 a, vec_int4 b)
391 
{
392 
  return (spu_andc(a, b));
393 
}
394 
 
395 
static inline vec_int4 vec_andc(vec_bint4 a, vec_int4 b)
396 
{
397 
  return (spu_andc((vec_int4)(a), b));
398 
}
399 
 
400 
static inline vec_int4 vec_andc(vec_int4 a, vec_bint4 b)
401 
{
402 
  return (spu_andc(a, (vec_int4)(b)));
403 
}
404 
 
405 
static inline vec_float4 vec_andc(vec_float4 a, vec_float4 b)
406 
{
407 
  return (spu_andc(a,b));
408 
}
409 
 
410 
static inline vec_float4 vec_andc(vec_bint4 a, vec_float4 b)
411 
{
412 
  return (spu_andc((vec_float4)(a),b));
413 
}
414 
 
415 
static inline vec_float4 vec_andc(vec_float4 a, vec_bint4 b)
416 
{
417 
  return (spu_andc(a, (vec_float4)(b)));
418 
}
419 
 
420 
/* vec_avg (vector average)
421 
 * =======
422 
 */
423 
static inline vec_uchar16 vec_avg(vec_uchar16 a, vec_uchar16 b)
424 
{
425 
  return (spu_avg(a, b));
426 
}
427 
 
428 
static inline vec_char16 vec_avg(vec_char16 a, vec_char16 b)
429 
{
430 
  return ((vec_char16)(spu_xor(spu_avg((vec_uchar16)(a), (vec_uchar16)(b)),
431 
                               (vec_uchar16)(spu_and(spu_xor(a,b), 0x80)))));
432 
}
433 
 
434 
static inline vec_ushort8 vec_avg(vec_ushort8 a, vec_ushort8 b)
435 
{
436 
  return (spu_add(spu_add(spu_rlmask(a, -1), spu_rlmask(b, -1)),
437 
                  spu_and(spu_or(a, b), 1)));
438 
}
439 
 
440 
static inline vec_short8 vec_avg(vec_short8 a, vec_short8 b)
441 
{
442 
  return (spu_add(spu_add(spu_rlmaska(a, -1), spu_rlmaska(b, -1)),
443 
                  spu_and(spu_or(a, b), 1)));
444 
}
445 
 
446 
static inline vec_uint4 vec_avg(vec_uint4 a, vec_uint4 b)
447 
{
448 
  return (spu_add(spu_add(spu_rlmask(a, -1), spu_rlmask(b, -1)),
449 
                  spu_and(spu_or(a, b), 1)));
450 
}
451 
 
452 
static inline vec_int4 vec_avg(vec_int4 a, vec_int4 b)
453 
{
454 
  return (spu_add(spu_add(spu_rlmaska(a, -1), spu_rlmaska(b, -1)),
455 
                  spu_and(spu_or(a, b), 1)));
456 
}
457 
 
458 
 
459 
/* vec_ceil (vector ceiling)
460 
 * ========
461 
 */
462 
static inline vec_float4 vec_ceil(vec_float4 a)
463 
{
464 
  vec_int4  exp;
465 
  vec_uint4 mask;
466 
 
467 
  a = spu_add(a, (vec_float4)(spu_and(spu_xor(spu_rlmaska((vec_int4)a, -31), -1), spu_splats((signed int)0x3F7FFFFF))));
468 
  exp = spu_sub(127, (vec_int4)(spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF)));
469 
  mask = spu_rlmask(spu_splats((unsigned int)0x7FFFFF), exp);
470 
  mask = spu_sel(spu_splats((unsigned int)0), mask, spu_cmpgt(exp, -31));
471 
  mask = spu_or(mask, spu_xor((vec_uint4)(spu_rlmaska(spu_add(exp, -1), -31)), -1));
472 
 
473 
  return ((vec_float4)(spu_andc((vec_uint4)(a), mask)));
474 
}
475 
 
476 
 
477 
/* vec_cmpb (vector compare bounds floating-point)
478 
 * ========
479 
 */
480 
static inline vec_int4 vec_cmpb(vec_float4 a, vec_float4 b)
481 
{
482 
  vec_int4 b0 = (vec_int4)spu_splats(0x80000000);
483 
  vec_int4 b1 = (vec_int4)spu_splats(0x40000000);
484 
 
485 
  return (spu_or(spu_and((vec_int4)spu_cmpgt(a, b), b0),
486 
                 spu_and((vec_int4)spu_cmpgt(spu_xor(b, (vec_float4)(b0)), a), b1)));
487 
}
488 
 
489 
/* vec_cmpeq (vector compare equal)
490 
 * =========
491 
 */
492 
#define vec_cmpeq(_a, _b)       spu_cmpeq(_a, _b)
493 
 
494 
 
495 
/* vec_cmpge (vector compare greater than or equal)
496 
 * =========
497 
 */
498 
static inline vec_bint4 vec_cmpge(vec_float4 a, vec_float4 b)
499 
{
500 
  return (spu_xor(spu_cmpgt(b, a), -1));
501 
}
502 
 
503 
 
504 
/* vec_cmpgt (vector compare greater than)
505 
 * =========
506 
 */
507 
#define vec_cmpgt(_a, _b)       spu_cmpgt(_a, _b)
508 
 
509 
 
510 
/* vec_cmple (vector compare less than or equal)
511 
 * =========
512 
 */
513 
static inline vec_bint4 vec_cmple(vec_float4 a, vec_float4 b)
514 
{
515 
  return (spu_xor(spu_cmpgt(a, b), -1));
516 
}
517 
 
518 
 
519 
/* vec_cmplt (vector compare less than)
520 
 * =========
521 
 */
522 
#define vec_cmplt(_a, _b)       spu_cmpgt(_b, _a)
523 
 
524 
 
525 
/* vec_ctf (vector convert from fixed-point word)
526 
 * =======
527 
 */
528 
#define vec_ctf(_a, _b)         spu_convtf(_a, _b)
529 
 
530 
 
531 
/* vec_cts (vector convert to signed fixed-point word saturate)
532 
 * =======
533 
 */
534 
#define vec_cts(_a, _b)         spu_convts(_a, _b)
535 
 
536 
 
537 
/* vec_ctu (vector convert to unsigned fixed-point word saturate)
538 
 * =======
539 
 */
540 
#define vec_ctu(_a, _b)         spu_convtu(_a, _b)
541 
 
542 
 
543 
/* vec_dss (vector data stream stop)
544 
 * =======
545 
 */
546 
#define vec_dss(_a)
547 
 
548 
 
549 
/* vec_dssall (vector data stream stop all)
550 
 * ==========
551 
 */
552 
#define vec_dssall()
553 
 
554 
 
555 
/* vec_dst (vector data stream touch)
556 
 * =======
557 
 */
558 
#define vec_dst(_a, _b, _c)
559 
 
560 
 
561 
/* vec_dstst (vector data stream touch for store)
562 
 * =========
563 
 */
564 
#define vec_dstst(_a, _b, _c)
565 
 
566 
 
567 
/* vec_dststt (vector data stream touch for store transient)
568 
 * ==========
569 
 */
570 
#define vec_dststt(_a, _b, _c)
571 
 
572 
 
573 
/* vec_dstt (vector data stream touch transient)
574 
 * ========
575 
 */
576 
#define vec_dstt(_a, _b, _c)
577 
 
578 
 
579 
/* vec_expte (vector is 2 raised tp the exponent estimate floating-point)
580 
 * =========
581 
 */
582 
static inline vec_float4 vec_expte(vec_float4 a)
583 
{
584 
  vec_float4 bias, frac, exp;
585 
  vec_int4 ia;
586 
 
587 
  bias = (vec_float4)(spu_andc(spu_splats((signed int)0x3F7FFFFF), spu_rlmaska((vec_int4)(a), -31)));
588 
  ia   = spu_convts(spu_add(a, bias), 0);
589 
  frac = spu_sub(spu_convtf(ia, 0), a);
590 
  exp  = (vec_float4)(spu_sl(spu_add(ia, 127), 23));
591 
 
592 
  return (spu_mul(spu_madd(spu_madd(spu_splats(0.17157287f), frac, spu_splats(-0.67157287f)),
593 
                           frac, spu_splats(1.0f)), exp));
594 
}
595 
 
596 
 
597 
/* vec_floor (vector floor)
598 
 * =========
599 
 */
600 
static inline vec_float4 vec_floor(vec_float4 a)
601 
{
602 
  vec_int4  exp;
603 
  vec_uint4 mask;
604 
 
605 
  a = spu_sub(a, (vec_float4)(spu_and(spu_rlmaska((vec_int4)a, -31), spu_splats((signed int)0x3F7FFFFF))));
606 
  exp = spu_sub(127, (vec_int4)(spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF)));
607 
  mask = spu_rlmask(spu_splats((unsigned int)0x7FFFFF), exp);
608 
  mask = spu_sel(spu_splats((unsigned int)0), mask, spu_cmpgt(exp, -31));
609 
  mask = spu_or(mask, spu_xor((vec_uint4)(spu_rlmaska(spu_add(exp, -1), -31)), -1));
610 
 
611 
  return ((vec_float4)(spu_andc((vec_uint4)(a), mask)));
612 
}
613 
 
614 
 
615 
/* vec_ld (vector load indexed)
616 
 * ======
617 
 */
618 
static inline vec_uchar16 vec_ld(int a, unsigned char *b)
619 
{
620 
  return (*((vec_uchar16 *)(b+a)));
621 
}
622 
 
623 
static inline vec_uchar16 vec_ld(int a, vec_uchar16 *b)
624 
{
625 
  return (*((vec_uchar16 *)((unsigned char *)(b)+a)));
626 
}
627 
 
628 
static inline vec_char16 vec_ld(int a, signed char *b)
629 
{
630 
  return (*((vec_char16 *)(b+a)));
631 
}
632 
 
633 
static inline vec_char16 vec_ld(int a, vec_char16 *b)
634 
{
635 
  return (*((vec_char16 *)((signed char *)(b)+a)));
636 
}
637 
 
638 
static inline vec_ushort8 vec_ld(int a, unsigned short *b)
639 
{
640 
  return (*((vec_ushort8 *)((unsigned char *)(b)+a)));
641 
}
642 
 
643 
static inline vec_ushort8 vec_ld(int a, vec_ushort8 *b)
644 
{
645 
  return (*((vec_ushort8 *)((unsigned char *)(b)+a)));
646 
}
647 
 
648 
static inline vec_short8 vec_ld(int a, signed short *b)
649 
{
650 
  return (*((vec_short8 *)((unsigned char *)(b)+a)));
651 
}
652 
 
653 
static inline vec_short8 vec_ld(int a, vec_short8 *b)
654 
{
655 
  return (*((vec_short8 *)((signed char *)(b)+a)));
656 
}
657 
 
658 
static inline vec_uint4 vec_ld(int a, unsigned int *b)
659 
{
660 
  return (*((vec_uint4 *)((unsigned char *)(b)+a)));
661 
}
662 
 
663 
static inline vec_uint4 vec_ld(int a, vec_uint4 *b)
664 
{
665 
  return (*((vec_uint4 *)((unsigned char *)(b)+a)));
666 
}
667 
 
668 
static inline vec_int4 vec_ld(int a, signed int *b)
669 
{
670 
  return (*((vec_int4 *)((unsigned char *)(b)+a)));
671 
}
672 
 
673 
static inline vec_int4 vec_ld(int a, vec_int4 *b)
674 
{
675 
  return (*((vec_int4 *)((signed char *)(b)+a)));
676 
}
677 
 
678 
static inline vec_float4 vec_ld(int a, float *b)
679 
{
680 
  return (*((vec_float4 *)((unsigned char *)(b)+a)));
681 
}
682 
 
683 
static inline vec_float4 vec_ld(int a, vec_float4 *b)
684 
{
685 
  return (*((vec_float4 *)((unsigned char *)(b)+a)));
686 
}
687 
 
688 
/* vec_lde (vector load element indexed)
689 
 * =======
690 
 */
691 
static inline vec_uchar16 vec_lde(int a, unsigned char *b)
692 
{
693 
  return (*((vec_uchar16 *)(b+a)));
694 
}
695 
 
696 
static inline vec_char16 vec_lde(int a, signed char *b)
697 
{
698 
  return (*((vec_char16 *)(b+a)));
699 
}
700 
 
701 
static inline vec_ushort8 vec_lde(int a, unsigned short *b)
702 
{
703 
  return (*((vec_ushort8 *)((unsigned char *)(b)+a)));
704 
}
705 
 
706 
static inline vec_short8 vec_lde(int a, signed short *b)
707 
{
708 
  return (*((vec_short8 *)((unsigned char *)(b)+a)));
709 
}
710 
 
711 
 
712 
static inline vec_uint4 vec_lde(int a, unsigned int *b)
713 
{
714 
  return (*((vec_uint4 *)((unsigned char *)(b)+a)));
715 
}
716 
 
717 
static inline vec_int4 vec_lde(int a, signed int *b)
718 
{
719 
  return (*((vec_int4 *)((unsigned char *)(b)+a)));
720 
}
721 
 
722 
 
723 
static inline vec_float4 vec_lde(int a, float *b)
724 
{
725 
  return (*((vec_float4 *)((unsigned char *)(b)+a)));
726 
}
727 
 
728 
/* vec_ldl (vector load indexed LRU)
729 
 * =======
730 
 */
731 
#define vec_ldl(_a, _b)         vec_ld(_a, _b)
732 
 
733 
 
734 
/* vec_loge (vector log2 estimate floating-point)
735 
 * ========
736 
 */
737 
static inline vec_float4 vec_loge(vec_float4 a)
738 
{
739 
  vec_int4 exp;
740 
  vec_float4 frac;
741 
 
742 
  exp  = spu_add((vec_int4)(spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF)), -127);
743 
  frac = (vec_float4)(spu_sub((vec_int4)(a), spu_sl(exp, 23)));
744 
 
745 
  return (spu_madd(spu_madd(spu_splats(-0.33985f), frac, spu_splats(2.01955f)),
746 
                   frac, spu_sub(spu_convtf(exp, 0), spu_splats(1.6797f))));
747 
}
748 
 
749 
 
750 
/* vec_lvsl (vector load for shift left)
751 
 * ========
752 
 */
753 
static inline vec_uchar16 vec_lvsl(int a, unsigned char *b)
754 
{
755 
  return ((vec_uchar16)spu_add((vec_ushort8)(spu_splats((unsigned char)((a + (int)(b)) & 0xF))),
756 
                               ((vec_ushort8){0x0001, 0x0203, 0x0405, 0x0607,
757 
                                              0x0809, 0x0A0B, 0x0C0D, 0x0E0F})));
758 
}
759 
 
760 
static inline vec_uchar16 vec_lvsl(int a, signed char *b)
761 
{
762 
  return (vec_lvsl(a, (unsigned char *)b));
763 
}
764 
 
765 
static inline vec_uchar16 vec_lvsl(int a, unsigned short *b)
766 
{
767 
  return (vec_lvsl(a, (unsigned char *)b));
768 
}
769 
 
770 
static inline vec_uchar16 vec_lvsl(int a, short *b)
771 
{
772 
  return (vec_lvsl(a, (unsigned char *)b));
773 
}
774 
 
775 
static inline vec_uchar16 vec_lvsl(int a, unsigned int *b)
776 
{
777 
  return (vec_lvsl(a, (unsigned char *)b));
778 
}
779 
 
780 
static inline vec_uchar16 vec_lvsl(int a, int *b)
781 
{
782 
  return (vec_lvsl(a, (unsigned char *)b));
783 
}
784 
 
785 
static inline vec_uchar16 vec_lvsl(int a, float *b)
786 
{
787 
  return (vec_lvsl(a, (unsigned char *)b));
788 
}
789 
 
790 
 
791 
/* vec_lvsr (vector load for shift right)
792 
 * ========
793 
 */
794 
static  inline vec_uchar16 vec_lvsr(int a, unsigned char *b)
795 
{
796 
  return ((vec_uchar16)(spu_sub(((vec_ushort8){0x1011, 0x1213, 0x1415, 0x1617,
797 
                                               0x1819, 0x1A1B, 0x1C1D, 0x1E1F}),
798 
                                (vec_ushort8)(spu_splats((unsigned char)((a + (int)(b)) & 0xF))))));
799 
}
800 
 
801 
static inline vec_uchar16 vec_lvsr(int a, signed char *b)
802 
{
803 
  return (vec_lvsr(a, (unsigned char *)b));
804 
}
805 
 
806 
static inline vec_uchar16 vec_lvsr(int a, unsigned short *b)
807 
{
808 
  return (vec_lvsr(a, (unsigned char *)b));
809 
}
810 
 
811 
static inline vec_uchar16 vec_lvsr(int a, short *b)
812 
{
813 
  return (vec_lvsr(a, (unsigned char *)b));
814 
}
815 
 
816 
static inline vec_uchar16 vec_lvsr(int a, unsigned int *b)
817 
{
818 
  return (vec_lvsr(a, (unsigned char *)b));
819 
}
820 
 
821 
static inline vec_uchar16 vec_lvsr(int a, int *b)
822 
{
823 
  return (vec_lvsr(a, (unsigned char *)b));
824 
}
825 
 
826 
static inline vec_uchar16 vec_lvsr(int a, float *b)
827 
{
828 
  return (vec_lvsr(a, (unsigned char *)b));
829 
}
830 
 
831 
/* vec_madd (vector multiply add)
832 
 * ========
833 
 */
834 
#define vec_madd(_a, _b, _c)    spu_madd(_a, _b, _c)
835 
 
836 
 
837 
 
838 
/* vec_madds (vector multiply add saturate)
839 
 * =========
840 
 */
841 
static inline vec_short8 vec_madds(vec_short8 a, vec_short8 b, vec_short8 c)
842 
{
843 
  return (vec_adds(c, spu_sel((vec_short8)(spu_sl(spu_mule(a, b), 1)),
844 
                              (vec_short8)(spu_rlmask(spu_mulo(a, b), -15)),
845 
                              ((vec_ushort8){0, 0xFFFF, 0, 0xFFFF, 0, 0xFFFF, 0, 0xFFFF}))));
846 
}
847 
 
848 
/* vec_max (vector maximum)
849 
 * =======
850 
 */
851 
static inline vec_uchar16 vec_max(vec_uchar16 a, vec_uchar16 b)
852 
{
853 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
854 
}
855 
 
856 
static inline vec_char16 vec_max(vec_char16 a, vec_char16 b)
857 
{
858 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
859 
}
860 
 
861 
static inline vec_char16 vec_max(vec_bchar16 a, vec_char16 b)
862 
{
863 
  return (spu_sel(b, (vec_char16)(a), spu_cmpgt((vec_char16)(a), b)));
864 
}
865 
 
866 
static inline vec_char16 vec_max(vec_char16 a, vec_bchar16 b)
867 
{
868 
  return (spu_sel((vec_char16)(b), a, spu_cmpgt(a, (vec_char16)(b))));
869 
}
870 
 
871 
static inline vec_ushort8 vec_max(vec_ushort8 a, vec_ushort8 b)
872 
{
873 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
874 
}
875 
 
876 
static inline vec_short8 vec_max(vec_short8 a, vec_short8 b)
877 
{
878 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
879 
}
880 
 
881 
static inline vec_short8 vec_max(vec_bshort8 a, vec_short8 b)
882 
{
883 
  return (spu_sel(b, (vec_short8)(a), spu_cmpgt((vec_short8)(a), b)));
884 
}
885 
 
886 
static inline vec_short8 vec_max(vec_short8 a, vec_bshort8 b)
887 
{
888 
  return (spu_sel((vec_short8)(b), a, spu_cmpgt(a, (vec_short8)(b))));
889 
}
890 
 
891 
static inline vec_uint4 vec_max(vec_uint4 a, vec_uint4 b)
892 
{
893 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
894 
}
895 
 
896 
static inline vec_int4 vec_max(vec_int4 a, vec_int4 b)
897 
{
898 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
899 
}
900 
 
901 
static inline vec_int4 vec_max(vec_bint4 a, vec_int4 b)
902 
{
903 
  return (spu_sel(b, (vec_int4)(a), spu_cmpgt((vec_int4)(a), b)));
904 
}
905 
 
906 
static inline vec_int4 vec_max(vec_int4 a, vec_bint4 b)
907 
{
908 
  return (spu_sel((vec_int4)(b), a, spu_cmpgt(a, (vec_int4)(b))));
909 
}
910 
 
911 
static inline vec_float4 vec_max(vec_float4 a, vec_float4 b)
912 
{
913 
  return (spu_sel(b, a, spu_cmpgt(a, b)));
914 
}
915 
 
916 
 
917 
/* vec_mergeh (vector merge high)
918 
 * ==========
919 
 */
920 
static inline vec_uchar16 vec_mergeh(vec_uchar16 a, vec_uchar16 b)
921 
{
922 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 16, 1, 17, 2, 18, 3, 19,
923 
                                           4, 20, 5, 21, 6, 22, 7, 23})));
924 
}
925 
 
926 
static inline vec_char16 vec_mergeh(vec_char16 a, vec_char16 b)
927 
{
928 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 16, 1, 17, 2, 18, 3, 19,
929 
                                           4, 20, 5, 21, 6, 22, 7, 23})));
930 
}
931 
 
932 
static inline vec_ushort8 vec_mergeh(vec_ushort8 a, vec_ushort8 b)
933 
{
934 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 1, 16, 17, 2, 3, 18, 19,
935 
                                           4, 5, 20, 21, 6, 7, 22, 23})));
936 
}
937 
 
938 
static inline vec_short8 vec_mergeh(vec_short8 a, vec_short8 b)
939 
{
940 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 1, 16, 17, 2, 3, 18, 19,
941 
                                           4, 5, 20, 21, 6, 7, 22, 23})));
942 
}
943 
 
944 
static inline vec_uint4 vec_mergeh(vec_uint4 a, vec_uint4 b)
945 
{
946 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 1, 2, 3, 16, 17, 18, 19,
947 
                                           4, 5, 6, 7, 20, 21, 22, 23})));
948 
}
949 
 
950 
static inline vec_int4 vec_mergeh(vec_int4 a, vec_int4 b)
951 
{
952 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 1, 2, 3, 16, 17, 18, 19,
953 
                                           4, 5, 6, 7, 20, 21, 22, 23})));
954 
}
955 
 
956 
static inline vec_float4 vec_mergeh(vec_float4 a, vec_float4 b)
957 
{
958 
  return (spu_shuffle(a, b, ((vec_uchar16){0, 1, 2, 3, 16, 17, 18, 19,
959 
                                           4, 5, 6, 7, 20, 21, 22, 23})));
960 
}
961 
 
962 
/* vec_mergel (vector merge low)
963 
 * ==========
964 
 */
965 
static inline vec_uchar16 vec_mergel(vec_uchar16 a, vec_uchar16 b)
966 
{
967 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8, 24,  9, 25, 10, 26, 11, 27,
968 
                                           12, 28, 13, 29, 14, 30, 15, 31})));
969 
}
970 
 
971 
static inline vec_char16 vec_mergel(vec_char16 a, vec_char16 b)
972 
{
973 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8, 24,  9, 25, 10, 26, 11, 27,
974 
                                           12, 28, 13, 29, 14, 30, 15, 31})));
975 
}
976 
 
977 
static inline vec_ushort8 vec_mergel(vec_ushort8 a, vec_ushort8 b)
978 
{
979 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8,  9, 24, 25, 10, 11, 26, 27,
980 
                                           12, 13, 28, 29, 14, 15, 30, 31})));
981 
}
982 
 
983 
static inline vec_short8 vec_mergel(vec_short8 a, vec_short8 b)
984 
{
985 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8,  9, 24, 25, 10, 11, 26, 27,
986 
                                           12, 13, 28, 29, 14, 15, 30, 31})));
987 
}
988 
 
989 
static inline vec_uint4 vec_mergel(vec_uint4 a, vec_uint4 b)
990 
{
991 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8,  9, 10, 11, 24, 25, 26, 27,
992 
                                           12, 13, 14, 15, 28, 29, 30, 31})));
993 
}
994 
 
995 
static inline vec_int4 vec_mergel(vec_int4 a, vec_int4 b)
996 
{
997 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8,  9, 10, 11, 24, 25, 26, 27,
998 
                                           12, 13, 14, 15, 28, 29, 30, 31})));
999 
}
1000 
 
1001 
static inline vec_float4 vec_mergel(vec_float4 a, vec_float4 b)
1002 
{
1003 
  return (spu_shuffle(a, b, ((vec_uchar16){ 8,  9, 10, 11, 24, 25, 26, 27,
1004 
                                           12, 13, 14, 15, 28, 29, 30, 31})));
1005 
}
1006 
 
1007 
/* vec_mfvscr (vector move from vector status and control register)
1008 
 * ==========
1009 
 */
1010 
static inline vec_ushort8 vec_mfvscr()
1011 
{
1012 
  return ((vec_ushort8)spu_splats(0));           /* not supported */
1013 
}
1014 
 
1015 
 
1016 
/* vec_min (vector minimum)
1017 
 * =======
1018 
 */
1019 
static inline vec_uchar16 vec_min(vec_uchar16 a, vec_uchar16 b)
1020 
{
1021 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1022 
}
1023 
 
1024 
static inline vec_char16 vec_min(vec_char16 a, vec_char16 b)
1025 
{
1026 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1027 
}
1028 
 
1029 
static inline vec_char16 vec_min(vec_bchar16 a, vec_char16 b)
1030 
{
1031 
  return (spu_sel((vec_char16)(a), b, spu_cmpgt((vec_char16)(a), b)));
1032 
}
1033 
 
1034 
static inline vec_char16 vec_min(vec_char16 a, vec_bchar16 b)
1035 
{
1036 
  return (spu_sel(a, (vec_char16)(b), spu_cmpgt(a, (vec_char16)(b))));
1037 
}
1038 
 
1039 
static inline vec_ushort8 vec_min(vec_ushort8 a, vec_ushort8 b)
1040 
{
1041 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1042 
}
1043 
 
1044 
static inline vec_short8 vec_min(vec_short8 a, vec_short8 b)
1045 
{
1046 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1047 
}
1048 
 
1049 
static inline vec_short8 vec_min(vec_bshort8 a, vec_short8 b)
1050 
{
1051 
  return (spu_sel((vec_short8)(a), b, spu_cmpgt((vec_short8)(a), b)));
1052 
}
1053 
 
1054 
static inline vec_short8 vec_min(vec_short8 a, vec_bshort8 b)
1055 
{
1056 
  return (spu_sel(a, (vec_short8)(b), spu_cmpgt(a, (vec_short8)(b))));
1057 
}
1058 
 
1059 
static inline vec_uint4 vec_min(vec_uint4 a, vec_uint4 b)
1060 
{
1061 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1062 
}
1063 
 
1064 
static inline vec_int4 vec_min(vec_int4 a, vec_int4 b)
1065 
{
1066 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1067 
}
1068 
 
1069 
static inline vec_int4 vec_min(vec_bint4 a, vec_int4 b)
1070 
{
1071 
  return (spu_sel((vec_int4)(a), b, spu_cmpgt((vec_int4)(a), b)));
1072 
}
1073 
 
1074 
static inline vec_int4 vec_min(vec_int4 a, vec_bint4 b)
1075 
{
1076 
  return (spu_sel(a, (vec_int4)(b), spu_cmpgt(a, (vec_int4)(b))));
1077 
}
1078 
 
1079 
static inline vec_float4 vec_min(vec_float4 a, vec_float4 b)
1080 
{
1081 
  return (spu_sel(a, b, spu_cmpgt(a, b)));
1082 
}
1083 
 
1084 
/* vec_mladd (vector multiply low and add unsigned half word)
1085 
 * =========
1086 
 */
1087 
static inline vec_short8 vec_mladd(vec_short8 a, vec_short8 b, vec_short8 c)
1088 
{
1089 
  return ((vec_short8)(spu_shuffle(spu_madd((vec_short8)(spu_rl((vec_uint4)(a), -16)),
1090 
                                            (vec_short8)(spu_rl((vec_uint4)(b), -16)),
1091 
                                            (vec_int4)(spu_rl((vec_uint4)(c), -16))),
1092 
                                   spu_madd(a, b, spu_extend(c)),
1093 
                                   ((vec_uchar16){ 2,  3, 18, 19,  6,  7, 22, 23,
1094 
                                                  10, 11, 26, 27, 14, 15, 30, 31}))));
1095 
}
1096 
 
1097 
 
1098 
static inline vec_ushort8 vec_mladd(vec_ushort8 a, vec_ushort8 b, vec_ushort8 c)
1099 
{
1100 
  return ((vec_ushort8)(vec_mladd((vec_short8)(a), (vec_short8)(b), (vec_short8)(c))));
1101 
}
1102 
 
1103 
static inline vec_short8 vec_mladd(vec_ushort8 a, vec_short8 b, vec_short8 c)
1104 
{
1105 
  return (vec_mladd((vec_short8)(a), b, c));
1106 
}
1107 
 
1108 
static inline vec_short8 vec_mladd(vec_short8 a, vec_ushort8 b, vec_ushort8 c)
1109 
{
1110 
  return (vec_mladd(a, (vec_short8)(b), (vec_short8)(c)));
1111 
}
1112 
 
1113 
 
1114 
/* vec_mradds (vector multiply round and add saturate)
1115 
 * ==========
1116 
 */
1117 
static inline vec_short8 vec_mradds(vec_short8 a, vec_short8 b, vec_short8 c)
1118 
{
1119 
  vec_int4 round = (vec_int4)spu_splats(0x4000);
1120 
  vec_short8 hi, lo;
1121 
 
1122 
  hi = (vec_short8)(spu_sl(spu_add(spu_mule(a, b), round), 1));
1123 
  lo = (vec_short8)(spu_rlmask(spu_add(spu_mulo(a, b), round), -15));
1124 
 
1125 
  return (vec_adds(spu_sel(hi, lo, ((vec_ushort8){0, 0xFFFF, 0, 0xFFFF, 0, 0xFFFF, 0, 0xFFFF})), c));
1126 
}
1127 
 
1128 
 
1129 
/* vec_msum (vector multiply sum)
1130 
 * ========
1131 
 */
1132 
static inline vec_uint4 vec_msum(vec_uchar16 a, vec_uchar16 b, vec_uint4 c)
1133 
{
1134 
  vec_ushort8 a1, a2, b1, b2;
1135 
  vec_uint4 p1, p2;
1136 
 
1137 
  a1 = spu_and((vec_ushort8)(a), 0xFF);
1138 
  a2 = spu_rlmask((vec_ushort8)(a), -8);
1139 
  b1 = spu_and((vec_ushort8)(b), 0xFF);
1140 
  b2 = spu_rlmask((vec_ushort8)(b), -8);
1141 
 
1142 
  p1 = spu_add(spu_mulo(a1, b1), spu_mulo(spu_rlqwbyte(a1, -2), spu_rlqwbyte(b1, -2)));
1143 
  p2 = spu_add(spu_mulo(a2, b2), spu_mulo(spu_rlqwbyte(a2, -2), spu_rlqwbyte(b2, -2)));
1144 
  return (spu_add(p2, spu_add(p1, c)));
1145 
}
1146 
 
1147 
static inline vec_int4 vec_msum(vec_char16 a, vec_uchar16 b, vec_int4 c)
1148 
{
1149 
  vec_short8 a1, a2, b1, b2;
1150 
  vec_int4 p1, p2;
1151 
 
1152 
  a1 = (vec_short8)(spu_extend(a));
1153 
  a2 = spu_rlmaska((vec_short8)(a), -8);
1154 
  b1 = (vec_short8)(spu_and((vec_ushort8)(b), 0xFF));
1155 
  b2 = (vec_short8)spu_rlmask((vec_ushort8)(b), -8);
1156 
 
1157 
  p1 = spu_add(spu_mulo(a1, b1), spu_mulo(spu_rlqwbyte(a1, -2), spu_rlqwbyte(b1, -2)));
1158 
  p2 = spu_add(spu_mulo(a2, b2), spu_mulo(spu_rlqwbyte(a2, -2), spu_rlqwbyte(b2, -2)));
1159 
  return (spu_add(p2, spu_add(p1, c)));
1160 
}
1161 
 
1162 
static inline vec_uint4 vec_msum(vec_ushort8 a, vec_ushort8 b, vec_uint4 c)
1163 
{
1164 
  return (spu_add(spu_add(spu_mulo(a, b), spu_mulo(spu_rlqwbyte(a, -2), spu_rlqwbyte(b, -2))), c));
1165 
}
1166 
 
1167 
static inline vec_int4 vec_msum(vec_short8 a, vec_short8 b, vec_int4 c)
1168 
{
1169 
  return (spu_add(spu_add(spu_mulo(a, b), spu_mulo(spu_rlqwbyte(a, -2), spu_rlqwbyte(b, -2))), c));
1170 
}
1171 
 
1172 
 
1173 
/* vec_msums (vector multiply sum saturate)
1174 
 * ========
1175 
 */
1176 
static inline vec_uint4 vec_msums(vec_ushort8 a, vec_ushort8 b, vec_uint4 c)
1177 
{
1178 
  vec_uint4 p1, p2;
1179 
 
1180 
  p1 = spu_mulo(a, b);
1181 
  p2 = spu_mulo(spu_rlqwbyte(a, -2), spu_rlqwbyte(b, -2));
1182 
 
1183 
  return (vec_adds(p2, vec_adds(p1, c)));
1184 
}
1185 
 
1186 
static inline vec_int4 vec_msums(vec_short8 a, vec_short8 b, vec_int4 c)
1187 
{
1188 
  return (vec_adds(spu_add(spu_mulo(a, b), spu_mulo(spu_rlqwbyte(a, -2), spu_rlqwbyte(b, -2))), c));
1189 
}
1190 
 
1191 
/* vec_mtvscr (vector move to vector status and control register)
1192 
 * ==========
1193 
 */
1194 
#define vec_mtvscr(_a)          /* not supported */
1195 
 
1196 
 
1197 
/* vec_mule (vector multiply even)
1198 
 * ========
1199 
 */
1200 
static inline vec_ushort8 vec_mule(vec_uchar16 a, vec_uchar16 b)
1201 
{
1202 
  vec_ushort8 hi, lo;
1203 
 
1204 
  hi = (vec_ushort8)spu_mulo((vec_ushort8)(spu_rlmask((vec_uint4)(a), -24)),
1205 
                             (vec_ushort8)(spu_rlmask((vec_uint4)(b), -24)));
1206 
  lo = (vec_ushort8)spu_mulo((vec_ushort8)(spu_rlmask((vec_short8)(a), -8)),
1207 
                             (vec_ushort8)(spu_rlmask((vec_short8)(b), -8)));
1208 
 
1209 
  return (spu_shuffle(hi, lo, ((vec_uchar16){ 2,  3, 18, 19,  6,  7, 22, 23,
1210 
                                             10, 11, 26, 27, 14, 15, 30, 31})));
1211 
}
1212 
 
1213 
static inline vec_short8 vec_mule(vec_char16 a, vec_char16 b)
1214 
{
1215 
  vec_short8 hi, lo;
1216 
 
1217 
  hi = (vec_short8)spu_mulo((vec_short8)(spu_rlmaska((vec_uint4)(a), -24)),
1218 
                            (vec_short8)(spu_rlmaska((vec_uint4)(b), -24)));
1219 
  lo = (vec_short8)spu_mulo((vec_short8)(spu_rlmaska((vec_short8)(a), -8)),
1220 
                            (vec_short8)(spu_rlmaska((vec_short8)(b), -8)));
1221 
 
1222 
  return (spu_shuffle(hi, lo, ((vec_uchar16){ 2,  3, 18, 19,  6,  7, 22, 23,
1223 
                                             10, 11, 26, 27, 14, 15, 30, 31})));
1224 
}
1225 
 
1226 
static inline vec_uint4 vec_mule(vec_ushort8 a, vec_ushort8 b)
1227 
{
1228 
 return (spu_mulo((vec_ushort8)spu_rlmask((vec_uint4)(a), -16),
1229 
                  (vec_ushort8)spu_rlmask((vec_uint4)(b), -16)));
1230 
}
1231 
 
1232 
 
1233 
static inline vec_int4 vec_mule(vec_short8 a, vec_short8 b)
1234 
{
1235 
 return (spu_mulo((vec_short8)spu_rlmaska((vec_int4)(a), -16),
1236 
                  (vec_short8)spu_rlmaska((vec_int4)(b), -16)));
1237 
}
1238 
 
1239 
 
1240 
/* vec_mulo (vector multiply odd)
1241 
 * ========
1242 
 */
1243 
static inline vec_ushort8 vec_mulo(vec_uchar16 a, vec_uchar16 b)
1244 
{
1245 
  vec_ushort8 hi, lo;
1246 
 
1247 
  hi = (vec_ushort8)spu_mulo((vec_ushort8)(spu_and(spu_rlmask((vec_uint4)(a), -16), 0xFF)),
1248 
                             (vec_ushort8)(spu_and(spu_rlmask((vec_uint4)(b), -16), 0xFF)));
1249 
  lo = (vec_ushort8)spu_mulo(spu_and((vec_ushort8)(a), 0xFF), spu_and((vec_ushort8)(b), 0xFF));
1250 
 
1251 
  return (spu_shuffle(hi, lo, ((vec_uchar16){ 2,  3, 18, 19,  6,  7, 22, 23,
1252 
                                             10, 11, 26, 27, 14, 15, 30, 31})));
1253 
}
1254 
 
1255 
static inline vec_short8 vec_mulo(vec_char16 a, vec_char16 b)
1256 
{
1257 
  vec_short8 aa, bb, hi, lo;
1258 
 
1259 
  aa = spu_extend(a);
1260 
  bb = spu_extend(b);
1261 
 
1262 
  hi = (vec_short8)spu_mulo((vec_short8)(spu_rlmaska((vec_uint4)(aa), -16)),
1263 
                (vec_short8)(spu_rlmaska((vec_uint4)(bb), -16)));
1264 
  lo = (vec_short8)spu_mulo(aa, bb);
1265 
  return (spu_shuffle(hi, lo, ((vec_uchar16){ 2,  3, 18, 19,  6,  7, 22, 23,
1266 
                                             10, 11, 26, 27, 14, 15, 30, 31})));
1267 
}
1268 
 
1269 
static inline vec_uint4 vec_mulo(vec_ushort8 a, vec_ushort8 b)
1270 
{
1271 
  return (spu_mulo(a, b));
1272 
}
1273 
 
1274 
 
1275 
static inline vec_int4 vec_mulo(vec_short8 a, vec_short8 b)
1276 
{
1277 
  return (spu_mulo(a, b));
1278 
}
1279 
 
1280 
 
1281 
/* vec_nmsub (vector negative multiply subtract)
1282 
 * =========
1283 
 */
1284 
#define vec_nmsub(_a, _b, _c)   spu_nmsub(_a, _b, _c)
1285 
 
1286 
 
1287 
/* vec_nor (vector logical nor)
1288 
 * =======
1289 
 */
1290 
#define vec_nor(_a, _b)         spu_nor(_a, _b)
1291 
 
1292 
 
1293 
/* vec_or (vector logical or)
1294 
 * ======
1295 
 */
1296 
static inline vec_uchar16 vec_or(vec_uchar16 a, vec_uchar16 b)
1297 
{
1298 
  return (spu_or(a, b));
1299 
}
1300 
 
1301 
static inline vec_char16 vec_or(vec_char16 a, vec_char16 b)
1302 
{
1303 
  return (spu_or(a, b));
1304 
}
1305 
 
1306 
static inline vec_char16 vec_or(vec_bchar16 a, vec_char16 b)
1307 
{
1308 
  return (spu_or((vec_char16)(a), b));
1309 
}
1310 
 
1311 
static inline vec_char16 vec_or(vec_char16 a, vec_bchar16 b)
1312 
{
1313 
  return (spu_or(a, (vec_char16)(b)));
1314 
}
1315 
 
1316 
static inline vec_ushort8 vec_or(vec_ushort8 a, vec_ushort8 b)
1317 
{
1318 
  return (spu_or(a, b));
1319 
}
1320 
 
1321 
static inline vec_short8 vec_or(vec_short8 a, vec_short8 b)
1322 
{
1323 
  return (spu_or(a, b));
1324 
}
1325 
 
1326 
static inline vec_short8 vec_or(vec_bshort8 a, vec_short8 b)
1327 
{
1328 
  return (spu_or((vec_short8)(a), b));
1329 
}
1330 
 
1331 
static inline vec_short8 vec_or(vec_short8 a, vec_bshort8 b)
1332 
{
1333 
  return (spu_or(a, (vec_short8)(b)));
1334 
}
1335 
 
1336 
static inline vec_uint4 vec_or(vec_uint4 a, vec_uint4 b)
1337 
{
1338 
  return (spu_or(a, b));
1339 
}
1340 
 
1341 
static inline vec_int4 vec_or(vec_int4 a, vec_int4 b)
1342 
{
1343 
  return (spu_or(a, b));
1344 
}
1345 
 
1346 
static inline vec_int4 vec_or(vec_bint4 a, vec_int4 b)
1347 
{
1348 
  return (spu_or((vec_int4)(a), b));
1349 
}
1350 
 
1351 
static inline vec_int4 vec_or(vec_int4 a, vec_bint4 b)
1352 
{
1353 
  return (spu_or(a, (vec_int4)(b)));
1354 
}
1355 
 
1356 
static inline vec_float4 vec_or(vec_float4 a, vec_float4 b)
1357 
{
1358 
  return (spu_or(a, b));
1359 
}
1360 
 
1361 
static inline vec_float4 vec_or(vec_bint4 a, vec_float4 b)
1362 
{
1363 
  return (spu_or((vec_float4)(a),b));
1364 
}
1365 
 
1366 
static inline vec_float4 vec_or(vec_float4 a, vec_bint4 b)
1367 
{
1368 
  return (spu_or(a, (vec_float4)(b)));
1369 
}
1370 
 
1371 
 
1372 
/* vec_pack (vector pack)
1373 
 * ========
1374 
 */
1375 
static inline vec_uchar16 vec_pack(vec_ushort8 a, vec_ushort8 b)
1376 
{
1377 
  return ((vec_uchar16)spu_shuffle(a, b, ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1378 
                                                        17, 19, 21, 23, 25, 27, 29, 31})));
1379 
}
1380 
 
1381 
static inline vec_char16 vec_pack(vec_short8 a, vec_short8 b)
1382 
{
1383 
  return ((vec_char16)spu_shuffle(a, b, ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1384 
                                                       17, 19, 21, 23, 25, 27, 29, 31})));
1385 
}
1386 
 
1387 
static inline vec_ushort8 vec_pack(vec_uint4 a, vec_uint4 b)
1388 
{
1389 
  return ((vec_ushort8)spu_shuffle(a, b, ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1390 
                                                        18, 19, 22, 23, 26, 27, 30, 31})));
1391 
}
1392 
 
1393 
static inline vec_short8 vec_pack(vec_int4 a, vec_int4 b)
1394 
{
1395 
  return ((vec_short8)spu_shuffle(a, b, ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1396 
                                                       18, 19, 22, 23, 26, 27, 30, 31})));
1397 
}
1398 
 
1399 
 
1400 
/* vec_packpx (vector pack pixel)
1401 
 * ==========
1402 
 */
1403 
static inline vec_pixel8 vec_packpx(vec_uint4 a, vec_uint4 b)
1404 
{
1405 
  vec_uint4 x03FF = (vec_uint4)(spu_splats((unsigned short)0x03FF));
1406 
  vec_uint4 x001F = (vec_uint4)(spu_splats((unsigned short)0x001F));
1407 
 
1408 
  return ((vec_pixel8)(spu_shuffle(spu_sel(spu_sel(spu_sl(a, 7), spu_sl(a, 10), x03FF),
1409 
                                           spu_sl(a, 13), x001F),
1410 
                                   spu_sel(spu_sel(spu_sl(b, 7), spu_sl(b, 10), x03FF),
1411 
                                           spu_sl(b, 13), x001F),
1412 
                                   ((vec_uchar16){ 0,  1,  4,  5,   8,  9, 12, 13,
1413 
                                                  16, 17, 20, 21, 24, 25, 28, 29}))));
1414 
}
1415 
 
1416 
 
1417 
/* vec_packs (vector pack saturate)
1418 
 * =========
1419 
 */
1420 
static inline vec_uchar16 vec_packs(vec_ushort8 a, vec_ushort8 b)
1421 
{
1422 
  vec_ushort8 max = spu_splats((unsigned short)0x00FF);
1423 
 
1424 
  return ((vec_uchar16)(spu_shuffle(spu_sel(a, max, spu_cmpgt(a, 255)),
1425 
                                    spu_sel(b, max, spu_cmpgt(b, 255)),
1426 
                                    ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1427 
                                                   17, 19, 21, 23, 25, 27, 29, 31}))));
1428 
}
1429 
 
1430 
static inline vec_char16 vec_packs(vec_short8 a, vec_short8 b)
1431 
{
1432 
  vec_short8 max = spu_splats((signed short)0x007F);
1433 
  vec_short8 min = spu_splats((signed short)0xFF80);
1434 
 
1435 
  return ((vec_char16)(spu_shuffle(spu_sel(min, spu_sel(a, max, spu_cmpgt(a, 127)), spu_cmpgt(a, -128)),
1436 
                                    spu_sel(min, spu_sel(b, max, spu_cmpgt(b, 127)), spu_cmpgt(b, -128)),
1437 
                                   ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1438 
                                                  17, 19, 21, 23, 25, 27, 29, 31}))));
1439 
}
1440 
 
1441 
static inline vec_ushort8 vec_packs(vec_uint4 a, vec_uint4 b)
1442 
{
1443 
  vec_uint4 max = spu_splats((unsigned int)0x0000FFFF);
1444 
 
1445 
  return ((vec_ushort8)(spu_shuffle(spu_sel(a, max, spu_cmpgt(a, max)),
1446 
                                    spu_sel(b, max, spu_cmpgt(b, max)),
1447 
                                    ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1448 
                                                   18, 19, 22, 23, 26, 27, 30, 31}))));
1449 
}
1450 
 
1451 
static inline vec_short8 vec_packs(vec_int4 a, vec_int4 b)
1452 
{
1453 
  vec_int4 max = spu_splats((signed int)0x00007FFF);
1454 
  vec_int4 min = spu_splats((signed int)0xFFFF8000);
1455 
 
1456 
  return ((vec_short8)(spu_shuffle(spu_sel(min, spu_sel(a, max, spu_cmpgt(a, max)), spu_cmpgt(a, min)),
1457 
                                   spu_sel(min, spu_sel(b, max, spu_cmpgt(b, max)), spu_cmpgt(b, min)),
1458 
                                   ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1459 
                                                  18, 19, 22, 23, 26, 27, 30, 31}))));
1460 
}
1461 
 
1462 
 
1463 
/* vec_packsu (vector pack saturate unsigned)
1464 
 * ==========
1465 
 */
1466 
static inline vec_uchar16 vec_packsu(vec_ushort8 a, vec_ushort8 b)
1467 
{
1468 
  return ((vec_uchar16)spu_shuffle(spu_or(a, (vec_ushort8)(spu_cmpgt(a, 255))),
1469 
                                   spu_or(b, (vec_ushort8)(spu_cmpgt(b, 255))),
1470 
                                   ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1471 
                                                  17, 19, 21, 23, 25, 27, 29, 31})));
1472 
}
1473 
 
1474 
static inline vec_uchar16 vec_packsu(vec_short8 a, vec_short8 b)
1475 
{
1476 
  vec_short8 max = spu_splats((signed short)0x00FF);
1477 
  vec_short8 min = spu_splats((signed short)0x0000);
1478 
 
1479 
  return ((vec_uchar16)(spu_shuffle(spu_sel(min, spu_sel(a, max, spu_cmpgt(a, 255)), spu_cmpgt(a, 0)),
1480 
                                    spu_sel(min, spu_sel(b, max, spu_cmpgt(b, 255)), spu_cmpgt(b, 0)),
1481 
                                    ((vec_uchar16){ 1,  3,  5,  7,  9, 11, 13, 15,
1482 
                                                   17, 19, 21, 23, 25, 27, 29, 31}))));
1483 
 
1484 
  return (vec_packsu((vec_ushort8)(a), (vec_ushort8)(b)));
1485 
}
1486 
 
1487 
static inline vec_ushort8 vec_packsu(vec_uint4 a, vec_uint4 b)
1488 
{
1489 
  vec_uint4 max = spu_splats((unsigned int)0xFFFF);
1490 
 
1491 
  return ((vec_ushort8)spu_shuffle(spu_or(a, (vec_uint4)(spu_cmpgt(a, max))),
1492 
                                   spu_or(b, (vec_uint4)(spu_cmpgt(b, max))),
1493 
                                   ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1494 
                                                  18, 19, 22, 23, 26, 27, 30, 31})));
1495 
}
1496 
 
1497 
static inline vec_ushort8 vec_packsu(vec_int4 a, vec_int4 b)
1498 
{
1499 
  vec_int4 max = spu_splats((signed int)0x0000FFFF);
1500 
  vec_int4 min = spu_splats((signed int)0x00000000);
1501 
 
1502 
  return ((vec_ushort8)(spu_shuffle(spu_sel(min, spu_sel(a, max, spu_cmpgt(a, max)), spu_cmpgt(a, min)),
1503 
                                    spu_sel(min, spu_sel(b, max, spu_cmpgt(b, max)), spu_cmpgt(b, min)),
1504 
                                    ((vec_uchar16){ 2,  3,  6,  7, 10, 11, 14, 15,
1505 
                                                   18, 19, 22, 23, 26, 27, 30, 31}))));
1506 
}
1507 
 
1508 
 
1509 
/* vec_perm (vector permute)
1510 
 * ========
1511 
 */
1512 
static inline vec_uchar16 vec_perm(vec_uchar16 a, vec_uchar16 b, vec_uchar16 c)
1513 
{
1514 
  return (spu_shuffle(a, b, spu_and(c, 0x1F)));
1515 
}
1516 
 
1517 
static inline vec_char16 vec_perm(vec_char16 a, vec_char16 b, vec_uchar16 c)
1518 
{
1519 
  return ((vec_char16)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1520 
}
1521 
 
1522 
static inline vec_ushort8 vec_perm(vec_ushort8 a, vec_ushort8 b, vec_uchar16 c)
1523 
{
1524 
  return ((vec_ushort8)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1525 
}
1526 
 
1527 
static inline vec_short8 vec_perm(vec_short8 a, vec_short8 b, vec_uchar16 c)
1528 
{
1529 
  return ((vec_short8)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1530 
}
1531 
 
1532 
static inline vec_uint4 vec_perm(vec_uint4 a, vec_uint4 b, vec_uchar16 c)
1533 
{
1534 
  return ((vec_uint4)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1535 
}
1536 
 
1537 
static inline vec_int4 vec_perm(vec_int4 a, vec_int4 b, vec_uchar16 c)
1538 
{
1539 
  return ((vec_int4)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1540 
}
1541 
 
1542 
static inline vec_float4 vec_perm(vec_float4 a, vec_float4 b, vec_uchar16 c)
1543 
{
1544 
  return ((vec_float4)(vec_perm((vec_uchar16)(a), (vec_uchar16)(b), c)));
1545 
}
1546 
 
1547 
 
1548 
/* vec_re (vector reciprocal estimate)
1549 
 * ======
1550 
 */
1551 
#define vec_re(_a)      spu_re(_a)
1552 
 
1553 
 
1554 
/* vec_rl (vector rotate left)
1555 
 * ======
1556 
 */
1557 
static inline vec_uchar16 vec_rl(vec_uchar16 a, vec_uchar16 b)
1558 
{
1559 
  vec_ushort8 r1, r2;
1560 
 
1561 
  r1 = spu_rl(spu_and((vec_ushort8)(a), 0xFF), (vec_short8)spu_and((vec_ushort8)(b), 7));
1562 
  r2 = spu_rl(spu_and((vec_ushort8)(a), -256), (vec_short8)spu_and(spu_rlmask((vec_ushort8)(b), -8), 7));
1563 
  return ((vec_uchar16)(spu_sel(spu_or(r2, spu_sl(r2, 8)), spu_or(r1, spu_rlmask(r1, -8)), spu_splats((unsigned short)0xFF))));
1564 
}
1565 
 
1566 
static inline vec_char16 vec_rl(vec_char16 a, vec_uchar16 b)
1567 
{
1568 
  return ((vec_char16)(vec_rl((vec_uchar16)(a), b)));
1569 
}
1570 
 
1571 
static inline vec_ushort8 vec_rl(vec_ushort8 a, vec_ushort8 b)
1572 
{
1573 
  return (spu_rl(a, (vec_short8)(b)));
1574 
}
1575 
 
1576 
static inline vec_short8 vec_rl(vec_short8 a, vec_ushort8 b)
1577 
{
1578 
  return (spu_rl(a, (vec_short8)(b)));
1579 
}
1580 
 
1581 
static inline vec_uint4 vec_rl(vec_uint4 a, vec_uint4 b)
1582 
{
1583 
  return (spu_rl(a, (vec_int4)(b)));
1584 
}
1585 
 
1586 
static inline vec_int4 vec_rl(vec_int4 a, vec_uint4 b)
1587 
{
1588 
  return (spu_rl(a, (vec_int4)(b)));
1589 
}
1590 
 
1591 
 
1592 
/* vec_round (vector round)
1593 
 * =========
1594 
 */
1595 
static inline vec_float4 vec_round(vec_float4 a)
1596 
{
1597 
  vec_float4 s_half, s_one, d;
1598 
  vec_uint4 odd;
1599 
  vec_uint4 msb = spu_splats((unsigned int)0x80000000);
1600 
  vec_float4 half = spu_splats(0.5f);
1601 
  vec_int4 exp;
1602 
  vec_uint4 mask;
1603 
 
1604 
  s_half = (vec_float4)(spu_sel((vec_uint4)(half), (vec_uint4)(a), msb));
1605 
  a = spu_add(a, s_half);
1606 
  s_one = spu_add(s_half, s_half);
1607 
  exp  = spu_sub(127, (vec_int4)(spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF)));
1608 
  mask = spu_rlmask(spu_splats((unsigned int)0x7FFFFF), exp);
1609 
  mask = spu_sel(spu_splats((unsigned int)0), mask, spu_cmpgt(exp, -31));
1610 
  mask = spu_or(mask, spu_xor((vec_uint4)(spu_rlmaska(spu_add(exp, -1), -31)), -1));
1611 
 
1612 
  odd = spu_and((vec_uint4)(spu_convts(a, 0)), 1);
1613 
  s_one = spu_andc(s_one, (vec_float4)spu_cmpeq(mask, 0));
1614 
  s_one = spu_and(s_one, spu_and((vec_float4)spu_cmpeq(spu_and((vec_uint4)(a), mask), 0),
1615 
                                 (vec_float4)spu_cmpeq(odd, 1)));
1616 
  d = spu_andc(a, (vec_float4)(mask));
1617 
  d = spu_sub(d, s_one);
1618 
  return (d);
1619 
}
1620 
 
1621 
/* vec_rsqrte (vector reciprocal square root estimate)
1622 
 * ==========
1623 
 */
1624 
#define vec_rsqrte(_a)  spu_rsqrte(_a)
1625 
 
1626 
 
1627 
/* vec_sel (vector select)
1628 
 * =======
1629 
 */
1630 
#define vec_sel(_a, _b, _c)     spu_sel(_a, _b, _c)
1631 
 
1632 
 
1633 
/* vec_sl (vector shift left)
1634 
 * ======
1635 
 */
1636 
static inline vec_uchar16 vec_sl(vec_uchar16 a, vec_uchar16 b)
1637 
{
1638 
  vec_ushort8 hi, lo;
1639 
 
1640 
  lo = spu_and(spu_sl((vec_ushort8)(a), spu_and((vec_ushort8)(b), 7)), 0xFF);
1641 
  hi = spu_sl(spu_and((vec_ushort8)(a), -256), spu_and(spu_rlmask((vec_ushort8)(b), -8), 7));
1642 
 
1643 
  return ((vec_uchar16)(spu_or(hi, lo)));
1644 
}
1645 
 
1646 
static inline vec_char16 vec_sl(vec_char16 a, vec_uchar16 b)
1647 
{
1648 
  return ((vec_char16)(vec_sl((vec_uchar16)(a), b)));
1649 
}
1650 
 
1651 
static inline vec_ushort8 vec_sl(vec_ushort8 a, vec_ushort8 b)
1652 
{
1653 
  return (spu_sl(a, spu_and(b, 15)));
1654 
}
1655 
 
1656 
static inline vec_short8 vec_sl(vec_short8 a, vec_ushort8 b)
1657 
{
1658 
  return (spu_sl(a, spu_and((vec_ushort8)(b), 15)));
1659 
}
1660 
 
1661 
static inline vec_uint4 vec_sl(vec_uint4 a, vec_uint4 b)
1662 
{
1663 
  return (spu_sl(a, spu_and(b, 31)));
1664 
}
1665 
 
1666 
static inline vec_int4 vec_sl(vec_int4 a, vec_uint4 b)
1667 
{
1668 
  return (spu_sl(a, spu_and(b, 31)));
1669 
}
1670 
 
1671 
 
1672 
/* vec_sld (vector shift left double)
1673 
 * =======
1674 
 */
1675 
#define vec_sld(_a, _b, _c)     spu_shuffle(_a, _b, ((vec_uchar16){ 0+(_c),  1+(_c),  2+(_c),  3+(_c),  \
1676 
                                                                    4+(_c),  5+(_c),  6+(_c),  7+(_c),  \
1677 
                                                                    8+(_c),  9+(_c), 10+(_c), 11+(_c),  \
1678 
                                                                   12+(_c), 13+(_c), 14+(_c), 15+(_c)}))
1679 
 
1680 
 
1681 
/* vec_sll (vector shift left long)
1682 
 * =======
1683 
 */
1684 
#define vec_sll(_a, _b)         spu_slqw(_a, spu_extract((vec_uint4)(_b), 0))
1685 
 
1686 
 
1687 
/* vec_slo (vector shift left by octet)
1688 
 * =======
1689 
 */
1690 
#define vec_slo(_a, _b)         spu_slqwbytebc(_a, spu_extract((vec_uint4)(_b), 3) & 0x7F)
1691 
 
1692 
 
1693 
/* vec_splat (vector splat)
1694 
 * =========
1695 
 */
1696 
#define vec_splat(_a, _b)       spu_splats(spu_extract(_a, _b))
1697 
 
1698 
 
1699 
/* vec_splat_s8 (vector splat signed byte)
1700 
 * ============
1701 
 */
1702 
#define vec_splat_s8(_a)        spu_splats((signed char)(_a))
1703 
 
1704 
 
1705 
/* vec_splat_s16 (vector splat signed half-word)
1706 
 * =============
1707 
 */
1708 
#define vec_splat_s16(_a)       spu_splats((signed short)(_a))
1709 
 
1710 
 
1711 
/* vec_splat_s32 (vector splat signed word)
1712 
 * =============
1713 
 */
1714 
#define vec_splat_s32(_a)       spu_splats((signed int)(_a))
1715 
 
1716 
 
1717 
/* vec_splat_u8 (vector splat unsigned byte)
1718 
 * ============
1719 
 */
1720 
#define vec_splat_u8(_a)        spu_splats((unsigned char)(_a))
1721 
 
1722 
 
1723 
/* vec_splat_u16 (vector splat unsigned half-word)
1724 
 * =============
1725 
 */
1726 
#define vec_splat_u16(_a)       spu_splats((unsigned short)(_a))
1727 
 
1728 
 
1729 
/* vec_splat_u32 (vector splat unsigned word)
1730 
 * =============
1731 
 */
1732 
#define vec_splat_u32(_a)       spu_splats((unsigned int)(_a))
1733 
 
1734 
 
1735 
/* vec_sr (vector shift right)
1736 
 * ======
1737 
 */
1738 
static inline vec_uchar16 vec_sr(vec_uchar16 a, vec_uchar16 b)
1739 
{
1740 
  vec_ushort8 hi, lo;
1741 
 
1742 
  lo = spu_rlmask(spu_and((vec_ushort8)(a), 0xFF), spu_sub(0, (vec_short8)(spu_and((vec_ushort8)(b), 7))));
1743 
  hi = spu_and(spu_rlmask((vec_ushort8)(a), spu_sub(0, (vec_short8)(spu_and(spu_rlmask((vec_ushort8)(b), -8), 7)))), -256);
1744 
 
1745 
  return ((vec_uchar16)(spu_or(hi, lo)));
1746 
}
1747 
 
1748 
static inline vec_char16 vec_sr(vec_char16 a, vec_uchar16 b)
1749 
{
1750 
  return ((vec_char16)(vec_sr((vec_uchar16)(a), b)));
1751 
}
1752 
 
1753 
static inline vec_ushort8 vec_sr(vec_ushort8 a, vec_ushort8 b)
1754 
{
1755 
  return (spu_rlmask(a, spu_sub(0, (vec_short8)(spu_and(b, 15)))));
1756 
}
1757 
 
1758 
static inline vec_short8 vec_sr(vec_short8 a, vec_ushort8 b)
1759 
{
1760 
  return ((vec_short8)(vec_sr((vec_ushort8)(a), b)));
1761 
}
1762 
 
1763 
static inline vec_uint4 vec_sr(vec_uint4 a, vec_uint4 b)
1764 
{
1765 
  return (spu_rlmask(a, spu_sub(0, (vec_int4)(spu_and(b, 31)))));
1766 
}
1767 
 
1768 
static inline vec_int4 vec_sr(vec_int4 a, vec_uint4 b)
1769 
{
1770 
  return ((vec_int4)(vec_sr((vec_uint4)(a), b)));
1771 
}
1772 
 
1773 
 
1774 
/* vec_sra (vector shift right algebraic)
1775 
 * =======
1776 
 */
1777 
static inline vec_char16 vec_sra(vec_char16 a, vec_uchar16 b)
1778 
{
1779 
  vec_short8 hi, lo;
1780 
 
1781 
  lo = spu_and(spu_rlmaska(spu_extend(a), spu_sub(0, (vec_short8)(spu_and((vec_ushort8)(b), 7)))), 0xFF);
1782 
  hi = spu_and(spu_rlmaska((vec_short8)(a), spu_sub(0, (vec_short8)(spu_and(spu_rlmask((vec_ushort8)(b), -8), 7)))), -256);
1783 
 
1784 
  return ((vec_char16)(spu_or(hi, lo)));
1785 
}
1786 
 
1787 
static inline vec_uchar16 vec_sra(vec_uchar16 a, vec_uchar16 b)
1788 
{
1789 
  return ((vec_uchar16)(vec_sra((vec_char16)(a), b)));
1790 
}
1791 
 
1792 
static inline vec_short8 vec_sra(vec_short8 a, vec_ushort8 b)
1793 
{
1794 
  return (spu_rlmaska(a, spu_sub(0, (vec_short8)(spu_and(b, 15)))));
1795 
}
1796 
 
1797 
static inline vec_ushort8 vec_sra(vec_ushort8 a, vec_ushort8 b)
1798 
{
1799 
  return ((vec_ushort8)(vec_sra((vec_short8)(a), b)));
1800 
}
1801 
 
1802 
static inline vec_int4 vec_sra(vec_int4 a, vec_uint4 b)
1803 
{
1804 
  return (spu_rlmaska(a, spu_sub(0, (vec_int4)(spu_and(b, 31)))));
1805 
}
1806 
 
1807 
static inline vec_uint4 vec_sra(vec_uint4 a, vec_uint4 b)
1808 
{
1809 
  return ((vec_uint4)(vec_sra((vec_int4)(a), b)));
1810 
}
1811 
 
1812 
 
1813 
/* vec_srl (vector shift right long)
1814 
 * =======
1815 
 */
1816 
#define vec_srl(_a, _b)         spu_rlmaskqw(_a, 0-spu_extract((vec_int4)(_b), 3))
1817 
 
1818 
 
1819 
/* vec_sro (vector shift right by octet)
1820 
 * =======
1821 
 */
1822 
#define vec_sro(_a, _b)         spu_rlmaskqwbyte(_a, 0 - ((spu_extract((vec_int4)(_b), 3) >> 3) & 0xF))
1823 
 
1824 
/* vec_st (vector store indexed)
1825 
 * ======
1826 
 */
1827 
static inline void vec_st(vec_uchar16 a, int b, unsigned char *c)
1828 
{
1829 
  *((vec_uchar16 *)(c+b)) = a;
1830 
}
1831 
 
1832 
static inline void vec_st(vec_uchar16 a, int b, vec_uchar16 *c)
1833 
{
1834 
  *((vec_uchar16 *)((unsigned char *)(c)+b)) = a;
1835 
}
1836 
 
1837 
static inline void vec_st(vec_char16 a, int b, signed char *c)
1838 
{
1839 
  *((vec_char16 *)(c+b)) = a;
1840 
}
1841 
 
1842 
static inline void vec_st(vec_char16 a, int b, vec_char16 *c)
1843 
{
1844 
  *((vec_char16 *)((signed char *)(c)+b)) = a;
1845 
}
1846 
 
1847 
static inline void vec_st(vec_bchar16 a, int b, signed char *c)
1848 
{
1849 
  *((vec_bchar16 *)((signed char *)(c)+b)) = a;
1850 
}
1851 
 
1852 
static inline void vec_st(vec_ushort8 a, int b, unsigned short *c)
1853 
{
1854 
  *((vec_ushort8 *)((unsigned char *)(c)+b)) = a;
1855 
}
1856 
 
1857 
static inline void vec_st(vec_ushort8 a, int b, vec_ushort8 *c)
1858 
{
1859 
  *((vec_ushort8 *)((unsigned char *)(c)+b)) = a;
1860 
}
1861 
 
1862 
static inline void vec_st(vec_short8 a, int b, signed short *c)
1863 
{
1864 
  *((vec_short8 *)((unsigned char *)(c)+b)) = a;
1865 
}
1866 
 
1867 
static inline void vec_st(vec_short8 a, int b, vec_short8 *c)
1868 
{
1869 
  *((vec_short8 *)((signed char *)(c)+b)) = a;
1870 
}
1871 
 
1872 
static inline void vec_st(vec_bshort8 a, int b, signed short *c)
1873 
{
1874 
  *((vec_bshort8 *)((signed char *)(c)+b)) = a;
1875 
}
1876 
 
1877 
static inline void vec_st(vec_uint4 a, int b, unsigned int *c)
1878 
{
1879 
  *((vec_uint4 *)((unsigned char *)(c)+b)) = a;
1880 
}
1881 
 
1882 
static inline void vec_st(vec_uint4 a, int b, vec_uint4 *c)
1883 
{
1884 
  *((vec_uint4 *)((unsigned char *)(c)+b)) = a;
1885 
}
1886 
 
1887 
static inline void vec_st(vec_int4 a, int b, signed int *c)
1888 
{
1889 
  *((vec_int4 *)((unsigned char *)(c)+b)) = a;
1890 
}
1891 
 
1892 
static inline void vec_st(vec_int4 a, int b, vec_int4 *c)
1893 
{
1894 
  *((vec_int4 *)((signed char *)(c)+b)) = a;
1895 
}
1896 
 
1897 
static inline void vec_st(vec_bint4 a, int b, signed int *c)
1898 
{
1899 
  *((vec_bint4 *)((signed char *)(c)+b)) = a;
1900 
}
1901 
 
1902 
static inline void vec_st(vec_float4 a, int b, float *c)
1903 
{
1904 
  *((vec_float4 *)((unsigned char *)(c)+b)) = a;
1905 
}
1906 
 
1907 
static inline void vec_st(vec_float4 a, int b, vec_float4 *c)
1908 
{
1909 
  *((vec_float4 *)((unsigned char *)(c)+b)) = a;
1910 
}
1911 
 
1912 
 
1913 
/* vec_ste (vector store element indexed)
1914 
 * =======
1915 
 */
1916 
static inline void vec_ste(vec_uchar16 a, int b, unsigned char *c)
1917 
{
1918 
  unsigned char *ptr;
1919 
 
1920 
  ptr = c + b;
1921 
  *ptr = spu_extract(a, (int)(ptr) & 15);
1922 
}
1923 
 
1924 
static inline void vec_ste(vec_char16 a, int b, signed char *c)
1925 
{
1926 
  vec_ste((vec_uchar16)(a), b, (unsigned char *)(c));
1927 
}
1928 
 
1929 
static inline void vec_ste(vec_bchar16 a, int b, signed char *c)
1930 
{
1931 
  vec_ste((vec_uchar16)(a), b, (unsigned char *)(c));
1932 
}
1933 
 
1934 
static inline void vec_ste(vec_ushort8 a, int b, unsigned short *c)
1935 
{
1936 
  unsigned short *ptr;
1937 
 
1938 
  ptr = (unsigned short *)(((unsigned int)(c) + b) & ~1);
1939 
  *ptr = spu_extract(a, ((int)(ptr) >> 1) & 7);
1940 
}
1941 
 
1942 
static inline void vec_ste(vec_short8 a, int b, signed short *c)
1943 
{
1944 
  vec_ste((vec_ushort8)(a), b, (unsigned short *)(c));
1945 
}
1946 
 
1947 
static inline void vec_ste(vec_bshort8 a, int b, signed short *c)
1948 
{
1949 
  vec_ste((vec_ushort8)(a), b, (unsigned short *)(c));
1950 
}
1951 
 
1952 
static inline void vec_ste(vec_uint4 a, int b, unsigned int *c)
1953 
{
1954 
  unsigned int *ptr;
1955 
 
1956 
  ptr = (unsigned int *)(((unsigned int)(c) + b) & ~3);
1957 
  *ptr = spu_extract(a, ((int)(ptr) >> 2) & 3);
1958 
}
1959 
 
1960 
static inline void vec_ste(vec_int4 a, int b, signed int *c)
1961 
{
1962 
  vec_ste((vec_uint4)(a), b, (unsigned int *)(c));
1963 
}
1964 
 
1965 
static inline void vec_ste(vec_bint4 a, int b, signed int *c)
1966 
{
1967 
  vec_ste((vec_uint4)(a), b, (unsigned int *)(c));
1968 
}
1969 
 
1970 
static inline void vec_ste(vec_float4 a, int b, float *c)
1971 
{
1972 
  vec_ste((vec_uint4)(a), b, (unsigned int *)(c));
1973 
}
1974 
 
1975 
 
1976 
/* vec_stl (vector store indexed LRU)
1977 
 * =======
1978 
 */
1979 
#define vec_stl(_a, _b, _c)             vec_st(_a, _b, _c)
1980 
 
1981 
 
1982 
/* vec_sub (vector subtract)
1983 
 * =======
1984 
 */
1985 
static inline vec_uchar16 vec_sub(vec_uchar16 a, vec_uchar16 b)
1986 
{
1987 
  return ((vec_uchar16)(spu_sel(spu_sub((vec_ushort8)(a), (vec_ushort8)(b)),
1988 
                                spu_sub(spu_and((vec_ushort8)(a), -256), spu_and((vec_ushort8)(b), -256)),
1989 
                                spu_splats((unsigned short)0xFF00))));
1990 
}
1991 
 
1992 
static inline vec_char16 vec_sub(vec_char16 a, vec_char16 b)
1993 
{
1994 
  return ((vec_char16)(vec_sub((vec_uchar16)(a), (vec_uchar16)(b))));
1995 
}
1996 
 
1997 
static inline vec_char16 vec_sub(vec_bchar16 a, vec_char16 b)
1998 
{
1999 
  return ((vec_char16)(vec_sub((vec_uchar16)(a), (vec_uchar16)(b))));
2000 
}
2001 
 
2002 
static inline vec_char16 vec_sub(vec_char16 a, vec_bchar16 b)
2003 
{
2004 
  return ((vec_char16)(vec_sub((vec_uchar16)(a), (vec_uchar16)(b))));
2005 
}
2006 
 
2007 
static inline vec_ushort8 vec_sub(vec_ushort8 a, vec_ushort8 b)
2008 
{
2009 
  return (spu_sub(a, b));
2010 
}
2011 
 
2012 
static inline vec_short8 vec_sub(vec_short8 a, vec_short8 b)
2013 
{
2014 
  return (spu_sub(a, b));
2015 
}
2016 
 
2017 
static inline vec_short8 vec_sub(vec_bshort8 a, vec_short8 b)
2018 
{
2019 
  return (spu_sub((vec_short8)(a), b));
2020 
}
2021 
 
2022 
static inline vec_short8 vec_sub(vec_short8 a, vec_bshort8 b)
2023 
{
2024 
  return (spu_sub(a, (vec_short8)(b)));
2025 
}
2026 
 
2027 
static inline vec_uint4 vec_sub(vec_uint4 a, vec_uint4 b)
2028 
{
2029 
  return (spu_sub(a, b));
2030 
}
2031 
 
2032 
static inline vec_int4 vec_sub(vec_int4 a, vec_int4 b)
2033 
{
2034 
  return (spu_sub(a, b));
2035 
}
2036 
 
2037 
static inline vec_int4 vec_sub(vec_bint4 a, vec_int4 b)
2038 
{
2039 
  return (spu_sub((vec_int4)(a), b));
2040 
}
2041 
 
2042 
static inline vec_int4 vec_sub(vec_int4 a, vec_bint4 b)
2043 
{
2044 
  return (spu_sub(a, (vec_int4)(b)));
2045 
}
2046 
 
2047 
static inline vec_float4 vec_sub(vec_float4 a, vec_float4 b)
2048 
{
2049 
  return (spu_sub(a, b));
2050 
}
2051 
 
2052 
 
2053 
/* vec_subc (vector subtract carryout)
2054 
 * ========
2055 
 */
2056 
#define vec_subc(_a, _b)        spu_genb(_a, _b)
2057 
 
2058 
 
2059 
/* vec_subs (vector subtract saturate)
2060 
 * ========
2061 
 */
2062 
static inline vec_uchar16 vec_subs(vec_uchar16 a, vec_uchar16 b)
2063 
{
2064 
  vec_ushort8 s1, s2;
2065 
  vec_uchar16 s, d;
2066 
 
2067 
  s1 = spu_sub(spu_rlmask((vec_ushort8)(a), -8), spu_rlmask((vec_ushort8)(b), -8));
2068 
  s2 = spu_sub(spu_and((vec_ushort8)(a), 0xFF), spu_and((vec_ushort8)(b), 0xFF));
2069 
  s  = (vec_uchar16)(spu_shuffle(s1, s2, ((vec_uchar16){0, 16,  2, 18,  4, 20,  6, 22,
2070 
                                                        8, 24, 10, 26, 12, 28, 14, 30})));
2071 
  d  = (vec_uchar16)(spu_shuffle(s1, s2, ((vec_uchar16){1, 17,  3, 19,  5, 21,  7, 23,
2072 
                                                        9, 25, 11, 27, 13, 29, 15, 31})));
2073 
  return (spu_andc(d, s));
2074 
}
2075 
 
2076 
static inline vec_char16 vec_subs(vec_char16 a, vec_char16 b)
2077 
{
2078 
  vec_ushort8 s1, s2;
2079 
  vec_uchar16 s, d;
2080 
 
2081 
  s1 = spu_sub(spu_rlmask((vec_ushort8)(a), -8), spu_rlmask((vec_ushort8)(b), -8));
2082 
  s2 = spu_sub(spu_and((vec_ushort8)(a), 0xFF), spu_and((vec_ushort8)(b), 0xFF));
2083 
  s  = (vec_uchar16)(spu_shuffle(s1, s2, ((vec_uchar16){1, 17,  3, 19,  5, 21,  7, 23,
2084 
                                                        9, 25, 11, 27, 13, 29, 15, 31})));
2085 
  d  = spu_sel(s, spu_splats((unsigned char)0x7F), spu_cmpgt(spu_nor((vec_uchar16)(a), spu_nand(s, (vec_uchar16)(b))), 0x7F));
2086 
  d  = spu_sel(d, spu_splats((unsigned char)0x80), spu_cmpgt(spu_and((vec_uchar16)(a), spu_nor(s, (vec_uchar16)(b))), 0x7F));
2087 
 
2088 
  return ((vec_char16)(d));
2089 
}
2090 
 
2091 
static inline vec_char16 vec_subs(vec_bchar16 a, vec_char16 b)
2092 
{
2093 
  return (vec_subs((vec_char16)(a), b));
2094 
}
2095 
 
2096 
static inline vec_char16 vec_subs(vec_char16 a, vec_bchar16 b)
2097 
{
2098 
  return (vec_subs(a, (vec_char16)(b)));
2099 
}
2100 
 
2101 
static inline vec_ushort8 vec_subs(vec_ushort8 a, vec_ushort8 b)
2102 
{
2103 
  return (spu_andc(spu_sub(a, b), spu_cmpgt(b, a)));
2104 
}
2105 
 
2106 
static inline vec_short8 vec_subs(vec_short8 a, vec_short8 b)
2107 
{
2108 
  vec_short8 s;
2109 
  vec_short8 d;
2110 
 
2111 
  s = spu_sub(a, b);
2112 
  d = spu_sel(s, spu_splats((signed short)0x7FFF), (vec_ushort8)(spu_rlmaska(spu_nor(a, spu_nand(s, b)), -15)));
2113 
  d = spu_sel(d, spu_splats((signed short)0x8000), (vec_ushort8)(spu_rlmaska(spu_and(a, spu_nor(s, b)), -15)));
2114 
 
2115 
  return (d);
2116 
}
2117 
 
2118 
static inline vec_short8 vec_subs(vec_bshort8 a, vec_short8 b)
2119 
{
2120 
  return ((vec_short8)(vec_subs((vec_short8)(a), b)));
2121 
}
2122 
 
2123 
static inline vec_short8 vec_subs(vec_short8 a, vec_bshort8 b)
2124 
{
2125 
  return ((vec_short8)(vec_subs(a, (vec_short8)(b))));
2126 
}
2127 
 
2128 
static inline vec_uint4 vec_subs(vec_uint4 a, vec_uint4 b)
2129 
{
2130 
  return (spu_andc(spu_sub(a, b), spu_cmpgt(b, a)));
2131 
}
2132 
 
2133 
static inline vec_int4 vec_subs(vec_int4 a, vec_int4 b)
2134 
{
2135 
  vec_int4 s;
2136 
  vec_int4 d;
2137 
 
2138 
  s = spu_sub(a, b);
2139 
  d = spu_sel(s, spu_splats((signed int)0x7FFFFFFF), (vec_uint4)(spu_rlmaska(spu_nor(a, spu_nand(s, b)), -31)));
2140 
  d = spu_sel(d, spu_splats((signed int)0x80000000), (vec_uint4)(spu_rlmaska(spu_and(a, spu_nor(s, b)), -31)));
2141 
 
2142 
  return (d);
2143 
}
2144 
 
2145 
static inline vec_int4 vec_subs(vec_bint4 a, vec_int4 b)
2146 
{
2147 
  return ((vec_int4)(vec_subs((vec_int4)(a), b)));
2148 
}
2149 
 
2150 
static inline vec_int4 vec_subs(vec_int4 a, vec_bint4 b)
2151 
{
2152 
  return ((vec_int4)(vec_subs(a, (vec_int4)(b))));
2153 
}
2154 
 
2155 
 
2156 
/* vec_sum4s (vector sum across partial (1/4) saturated)
2157 
 * =========
2158 
 */
2159 
static inline vec_uint4 vec_sum4s(vec_uchar16 a, vec_uint4 b)
2160 
{
2161 
  vec_uint4 a01_23, a0123;
2162 
 
2163 
  a01_23 = (vec_uint4)(spu_add(spu_rlmask((vec_ushort8)(a), -8),
2164 
                               spu_and((vec_ushort8)(a), 0xFF)));
2165 
  a0123 = spu_add(spu_rlmask(a01_23, -16), spu_and(a01_23, 0x1FF));
2166 
  return (vec_adds(a0123, b));
2167 
}
2168 
 
2169 
static inline vec_int4 vec_sum4s(vec_char16 a, vec_int4 b)
2170 
{
2171 
  vec_int4 a01_23, a0123;
2172 
 
2173 
  a01_23 = (vec_int4)(spu_add(spu_rlmaska((vec_short8)(a), -8),
2174 
                              spu_extend(a)));
2175 
  a0123 = spu_add(spu_rlmaska(a01_23, -16), spu_extend((vec_short8)(a01_23)));
2176 
  return (vec_adds(a0123, b));
2177 
}
2178 
 
2179 
static inline vec_int4 vec_sum4s(vec_short8 a, vec_int4 b)
2180 
{
2181 
  vec_int4 a0123;
2182 
 
2183 
  a0123 = spu_add(spu_rlmaska((vec_int4)(a), -16), spu_extend(a));
2184 
  return (vec_adds(a0123, b));
2185 
}
2186 
 
2187 
 
2188 
/* vec_sum2s (vector sum across partial (1/2) saturated)
2189 
 * =========
2190 
 */
2191 
static inline vec_int4 vec_sum2s(vec_int4 a, vec_int4 b)
2192 
{
2193 
  vec_int4 c, d;
2194 
  vec_int4 sign1, sign2, sign3;
2195 
  vec_int4 carry, sum_l, sum_h, sat, sat_val;
2196 
 
2197 
  sign1 = spu_rlmaska(a, -31);
2198 
  sign2 = spu_rlmaska(b, -31);
2199 
 
2200 
  c = spu_rlqwbyte(a, -4);
2201 
  sign3 = spu_rlqwbyte(sign1, -4);
2202 
 
2203 
  carry = spu_genc(a, b);
2204 
  sum_l = spu_add(a, b);
2205 
  sum_h = spu_addx(sign1, sign2, carry);
2206 
 
2207 
  carry = spu_genc(sum_l, c);
2208 
  sum_l = spu_add(sum_l, c);
2209 
  sum_h = spu_addx(sum_h, sign3, carry);
2210 
 
2211 
  sign1 = spu_rlmaska(sum_l, -31);
2212 
  sign2 = spu_rlmaska(sum_h, -31);
2213 
 
2214 
  sat_val = spu_xor(sign2, spu_splats((signed int)0x7FFFFFFF));
2215 
 
2216 
  sat = spu_orc(spu_xor(sign1, sign2), (vec_int4)spu_cmpeq(sum_h, sign2));
2217 
 
2218 
  d = spu_and(spu_sel(sum_l, sat_val, (vec_uint4)(sat)), (vec_int4){0, -1, 0, -1});
2219 
 
2220 
  return (d);
2221 
}
2222 
 
2223 
 
2224 
/* vec_sums (vector sum saturated)
2225 
 * ========
2226 
 */
2227 
static inline vec_int4 vec_sums(vec_int4 a, vec_int4 b)
2228 
{
2229 
  vec_int4 a0, a1, a2, c0, c1, c2, d;
2230 
  vec_int4 sign_a, sign_b, sign_l, sign_h;
2231 
  vec_int4 sum_l, sum_h, sat, sat_val;
2232 
 
2233 
  sign_a = spu_rlmaska(a, -31);
2234 
  sign_b = spu_rlmaska(b, -31);
2235 
 
2236 
  a0 = spu_rlqwbyte(a, -12);
2237 
  a1 = spu_rlqwbyte(a, -8);
2238 
  a2 = spu_rlqwbyte(a, -4);
2239 
 
2240 
  sum_l = spu_add(a, b);
2241 
  sum_h = spu_addx(sign_a, sign_b, spu_genc(a, b));
2242 
 
2243 
  c2 = spu_genc(sum_l, a2);
2244 
  sum_l = spu_add(sum_l, a2);
2245 
  sum_h = spu_addx(sum_h, spu_rlqwbyte(sign_a, -4), c2);
2246 
 
2247 
  c1 = spu_genc(sum_l, a1);
2248 
  sum_l = spu_add(sum_l, a1);
2249 
  sum_h = spu_addx(sum_h, spu_rlqwbyte(sign_a, -8), c1);
2250 
 
2251 
  c0 = spu_genc(sum_l, a0);
2252 
  sum_l = spu_add(sum_l, a0);
2253 
  sum_h = spu_addx(sum_h, spu_rlqwbyte(sign_a, -12), c0);
2254 
 
2255 
  sign_l = spu_rlmaska(sum_l, -31);
2256 
  sign_h = spu_rlmaska(sum_h, -31);
2257 
 
2258 
  sat_val = spu_xor(sign_h, spu_splats((signed int)0x7FFFFFFF));
2259 
 
2260 
  sat = spu_orc(spu_xor(sign_l, sign_h), (vec_int4)spu_cmpeq(sum_h, sign_h));
2261 
 
2262 
  d = spu_and(spu_sel(sum_l, sat_val, (vec_uint4)(sat)), ((vec_int4){0, 0, 0, -1}));
2263 
 
2264 
  return (d);
2265 
}
2266 
 
2267 
 
2268 
/* vec_trunc (vector truncate)
2269 
 * =========
2270 
 */
2271 
static inline vec_float4 vec_trunc(vec_float4 a)
2272 
{
2273 
  vec_int4 exp;
2274 
  vec_uint4 mask;
2275 
 
2276 
  exp  = spu_sub(127, (vec_int4)(spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF)));
2277 
  mask = spu_rlmask(spu_splats((unsigned int)0x7FFFFF), exp);
2278 
  mask = spu_sel(spu_splats((unsigned int)0), mask, spu_cmpgt(exp, -31));
2279 
  mask = spu_or(mask, spu_xor((vec_uint4)(spu_rlmaska(spu_add(exp, -1), -31)), -1));
2280 
  return (spu_andc(a, (vec_float4)(mask)));
2281 
}
2282 
 
2283 
/* vec_unpackh (vector unpack high element)
2284 
 * ===========
2285 
 */
2286 
static inline vec_short8 vec_unpackh(vec_char16 a)
2287 
{
2288 
  return (spu_extend(spu_shuffle(a, a, ((vec_uchar16){0, 0, 1, 1, 2, 2, 3, 3,
2289 
                                                      4, 4, 5, 5, 6, 6, 7, 7}))));
2290 
}
2291 
 
2292 
static inline vec_bshort8 vec_unpackh(vec_bchar16 a)
2293 
{
2294 
  return ((vec_bshort8)(vec_unpackh((vec_char16)(a))));
2295 
}
2296 
 
2297 
static inline vec_int4 vec_unpackh(vec_short8 a)
2298 
{
2299 
  return (spu_extend(spu_shuffle(a, a, ((vec_uchar16){0, 0, 0, 1, 0, 0, 2, 3,
2300 
                                                      0, 0, 4, 5, 0, 0, 6, 7}))));
2301 
}
2302 
 
2303 
#ifdef SUPPORT_UNPACK_PIXEL
2304 
/* Due to type conflicts, unpacking of pixel types and boolean shorts
2305 
 * can not simultaneously be supported. By default, the boolean short is
2306 
 * supported.
2307 
 */
2308 
static inline vec_uint4 vec_unpackh(vec_pixel8 a)
2309 
{
2310 
  vec_ushort8 p1, p2;
2311 
 
2312 
  p1 = spu_shuffle((vec_ushort8)(spu_rlmaska((vec_short8)(a.p), -7)),
2313 
                   spu_and((vec_ushort8)(a.p), 0x1F),
2314 
                   ((vec_uchar16){ 0, 128, 128, 17,  2, 128, 128, 19,
2315 
                                   4, 128, 128, 21,  6, 128, 128, 23}));
2316 
  p2 = spu_shuffle(spu_and(spu_rlmask((vec_ushort8)(a.p), -5), 0x1F),
2317 
                   spu_and(spu_rlmask((vec_ushort8)(a.p), -10), 0x1F),
2318 
                   ((vec_uchar16){ 128,  17, 1, 128, 128,  19, 3, 128,
2319 
                                   128,  21, 5, 128, 128,  23, 7, 128}));
2320 
  return ((vec_uint4)(spu_or(p1, p2)));
2321 
}
2322 
 
2323 
#else
2324 
 
2325 
static inline vec_bint4 vec_unpackh(vec_bshort8 a)
2326 
{
2327 
  return ((vec_bint4)(vec_unpackh((vec_short8)(a))));
2328 
}
2329 
#endif
2330 
 
2331 
 
2332 
 
2333 
 
2334 
 
2335 
/* vec_unpackl (vector unpack low element)
2336 
 * ===========
2337 
 */
2338 
static inline vec_short8 vec_unpackl(vec_char16 a)
2339 
{
2340 
  return (spu_extend(spu_shuffle(a, a, ((vec_uchar16){8, 8, 9, 9, 10, 10, 11, 11,
2341 
                                                      12, 12, 13, 13, 14, 14, 15, 15}))));
2342 
}
2343 
 
2344 
static inline vec_bshort8 vec_unpackl(vec_bchar16 a)
2345 
{
2346 
  return ((vec_bshort8)(vec_unpackl((vec_char16)(a))));
2347 
}
2348 
 
2349 
 
2350 
static inline vec_int4 vec_unpackl(vec_short8 a)
2351 
{
2352 
  return (spu_extend(spu_shuffle(a, a, ((vec_uchar16){0, 0, 8, 9, 0, 0, 10, 11,
2353 
                                                      0, 0,12,13, 0, 0, 14, 15}))));
2354 
}
2355 
 
2356 
 
2357 
#ifdef SUPPORT_UNPACK_PIXEL
2358 
/* Due to type conflicts, unpacking of pixel types and boolean shorts
2359 
 * can not simultaneously be supported. By default, the boolean short is
2360 
 * supported.
2361 
 */
2362 
static inline vec_uint4 vec_unpackl(vec_pixel8 a)
2363 
{
2364 
  vec_ushort8 p1, p2;
2365 
 
2366 
  p1 = spu_shuffle((vec_ushort8)(spu_rlmaska((vec_short8)(a), -7)),
2367 
                   spu_and((vec_ushort8)(a), 0x1F),
2368 
                   ((vec_uchar16){ 8, 128, 128, 25,  10, 128, 128, 27,
2369 
                                  12, 128, 128, 29,  14, 128, 128, 31}));
2370 
  p2 = spu_shuffle(spu_and(spu_rlmask((vec_ushort8)(a), -5), 0x1F),
2371 
                   spu_and(spu_rlmask((vec_ushort8)(a), -10), 0x1F),
2372 
                   ((vec_uchar16){ 128, 25,  9, 128, 128, 27, 11, 128,
2373 
                                   128, 29, 13, 128, 128, 31, 15, 128}));
2374 
  return ((vec_uint4)(spu_or(p1, p2)));
2375 
}
2376 
 
2377 
#else
2378 
 
2379 
static inline vec_bint4 vec_unpackl(vec_bshort8 a)
2380 
{
2381 
  return ((vec_bint4)(vec_unpackl((vec_short8)(a))));
2382 
 
2383 
}
2384 
#endif
2385 
 
2386 
 
2387 
 
2388 
/* vec_xor (vector logical xor)
2389 
 * ======
2390 
 */
2391 
static inline vec_uchar16 vec_xor(vec_uchar16 a, vec_uchar16 b)
2392 
{
2393 
  return (spu_xor(a, b));
2394 
}
2395 
 
2396 
static inline vec_char16 vec_xor(vec_char16 a, vec_char16 b)
2397 
{
2398 
  return (spu_xor(a, b));
2399 
}
2400 
 
2401 
static inline vec_char16 vec_xor(vec_bchar16 a, vec_char16 b)
2402 
{
2403 
  return (spu_xor((vec_char16)(a), b));
2404 
}
2405 
 
2406 
static inline vec_char16 vec_xor(vec_char16 a, vec_bchar16 b)
2407 
{
2408 
  return (spu_xor(a, (vec_char16)(b)));
2409 
}
2410 
 
2411 
static inline vec_ushort8 vec_xor(vec_ushort8 a, vec_ushort8 b)
2412 
{
2413 
  return (spu_xor(a, b));
2414 
}
2415 
 
2416 
static inline vec_short8 vec_xor(vec_short8 a, vec_short8 b)
2417 
{
2418 
  return (spu_xor(a, b));
2419 
}
2420 
 
2421 
static inline vec_short8 vec_xor(vec_bshort8 a, vec_short8 b)
2422 
{
2423 
  return (spu_xor((vec_short8)(a), b));
2424 
}
2425 
 
2426 
static inline vec_short8 vec_xor(vec_short8 a, vec_bshort8 b)
2427 
{
2428 
  return (spu_xor(a, (vec_short8)(b)));
2429 
}
2430 
 
2431 
static inline vec_uint4 vec_xor(vec_uint4 a, vec_uint4 b)
2432 
{
2433 
  return (spu_xor(a, b));
2434 
}
2435 
 
2436 
static inline vec_int4 vec_xor(vec_int4 a, vec_int4 b)
2437 
{
2438 
  return (spu_xor(a, b));
2439 
}
2440 
 
2441 
static inline vec_int4 vec_xor(vec_bint4 a, vec_int4 b)
2442 
{
2443 
  return (spu_xor((vec_int4)(a), b));
2444 
}
2445 
 
2446 
static inline vec_int4 vec_xor(vec_int4 a, vec_bint4 b)
2447 
{
2448 
  return (spu_xor(a, (vec_int4)(b)));
2449 
}
2450 
 
2451 
static inline vec_float4 vec_xor(vec_float4 a, vec_float4 b)
2452 
{
2453 
  return (spu_xor(a, b));
2454 
}
2455 
 
2456 
static inline vec_float4 vec_xor(vec_bint4 a, vec_float4 b)
2457 
{
2458 
  return (spu_xor((vec_float4)(a),b));
2459 
}
2460 
 
2461 
static inline vec_float4 vec_xor(vec_float4 a, vec_bint4 b)
2462 
{
2463 
  return (spu_xor(a, (vec_float4)(b)));
2464 
}
2465 
 
2466 
/************************************************************************
2467 
 *                        PREDICATES
2468 
 ************************************************************************/
2469 
 
2470 
/* vec_all_eq (all elements equal)
2471 
 * ==========
2472 
 */
2473 
static inline int vec_all_eq(vec_uchar16 a, vec_uchar16 b)
2474 
{
2475 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xFFFF));
2476 
}
2477 
 
2478 
static inline int vec_all_eq(vec_char16 a, vec_char16 b)
2479 
{
2480 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xFFFF));
2481 
}
2482 
 
2483 
static inline int vec_all_eq(vec_bchar16 a, vec_char16 b)
2484 
{
2485 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_char16)(a), b)), 0) == 0xFFFF));
2486 
}
2487 
 
2488 
static inline int vec_all_eq(vec_char16 a, vec_bchar16 b)
2489 
{
2490 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_char16)(b))), 0) == 0xFFFF));
2491 
}
2492 
 
2493 
static inline int vec_all_eq(vec_ushort8 a, vec_ushort8 b)
2494 
{
2495 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xFF));
2496 
}
2497 
 
2498 
static inline int vec_all_eq(vec_short8 a, vec_short8 b)
2499 
{
2500 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xFF));
2501 
}
2502 
 
2503 
static inline int vec_all_eq(vec_bshort8 a, vec_short8 b)
2504 
{
2505 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_short8)(a), b)), 0) == 0xFF));
2506 
}
2507 
 
2508 
static inline int vec_all_eq(vec_short8 a, vec_bshort8 b)
2509 
{
2510 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_short8)(b))), 0) == 0xFF));
2511 
}
2512 
 
2513 
static inline int vec_all_eq(vec_uint4 a, vec_uint4 b)
2514 
{
2515 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xF));
2516 
}
2517 
 
2518 
static inline int vec_all_eq(vec_int4 a, vec_int4 b)
2519 
{
2520 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xF));
2521 
}
2522 
 
2523 
static inline int vec_all_eq(vec_bint4 a, vec_int4 b)
2524 
{
2525 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_int4)(a), b)), 0) == 0xF));
2526 
}
2527 
 
2528 
static inline int vec_all_eq(vec_int4 a, vec_bint4 b)
2529 
{
2530 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_int4)(b))), 0) == 0xF));
2531 
}
2532 
 
2533 
static inline int vec_all_eq(vec_float4 a, vec_float4 b)
2534 
{
2535 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0xF));
2536 
}
2537 
 
2538 
 
2539 
/* vec_all_ge (all elements greater than or equal)
2540 
 * ==========
2541 
 */
2542 
static inline int vec_all_ge(vec_uchar16 a, vec_uchar16 b)
2543 
{
2544 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2545 
}
2546 
 
2547 
static inline int vec_all_ge(vec_char16 a, vec_char16 b)
2548 
{
2549 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2550 
}
2551 
 
2552 
static inline  int vec_all_ge(vec_bchar16 a, vec_char16 b)
2553 
{
2554 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_char16)(a))), 0) == 0));
2555 
}
2556 
 
2557 
static inline int vec_all_ge(vec_char16 a, vec_bchar16 b)
2558 
{
2559 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(b), a)), 0) == 0));
2560 
}
2561 
 
2562 
static inline int vec_all_ge(vec_ushort8 a, vec_ushort8 b)
2563 
{
2564 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2565 
}
2566 
 
2567 
static inline int vec_all_ge(vec_short8 a, vec_short8 b)
2568 
{
2569 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2570 
}
2571 
 
2572 
static inline int vec_all_ge(vec_bshort8 a, vec_short8 b)
2573 
{
2574 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_short8)(a))), 0) == 0));
2575 
}
2576 
 
2577 
static inline int vec_all_ge(vec_short8 a, vec_bshort8 b)
2578 
{
2579 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(b), a)), 0) == 0));
2580 
}
2581 
 
2582 
static inline int vec_all_ge(vec_uint4 a, vec_uint4 b)
2583 
{
2584 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2585 
}
2586 
 
2587 
static inline int vec_all_ge(vec_int4 a, vec_int4 b)
2588 
{
2589 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2590 
}
2591 
 
2592 
static inline int vec_all_ge(vec_bint4 a, vec_int4 b)
2593 
{
2594 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_int4)(a))), 0) == 0));
2595 
}
2596 
 
2597 
static inline int vec_all_ge(vec_int4 a, vec_bint4 b)
2598 
{
2599 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(b), a)), 0) == 0));
2600 
}
2601 
 
2602 
static inline int vec_all_ge(vec_float4 a, vec_float4 b)
2603 
{
2604 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2605 
}
2606 
 
2607 
 
2608 
/* vec_all_gt (all elements greater than)
2609 
 * ==========
2610 
 */
2611 
static inline int vec_all_gt(vec_uchar16 a, vec_uchar16 b)
2612 
{
2613 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xFFFF));
2614 
}
2615 
 
2616 
static inline int vec_all_gt(vec_char16 a, vec_char16 b)
2617 
{
2618 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xFFFF));
2619 
}
2620 
 
2621 
static inline int vec_all_gt(vec_bchar16 a, vec_char16 b)
2622 
{
2623 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(a), b)), 0) == 0xFFFF));
2624 
}
2625 
 
2626 
static inline int vec_all_gt(vec_char16 a, vec_bchar16 b)
2627 
{
2628 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_char16)(b))), 0) == 0xFFFF));
2629 
}
2630 
 
2631 
static inline int vec_all_gt(vec_ushort8 a, vec_ushort8 b)
2632 
{
2633 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xFF));
2634 
}
2635 
 
2636 
static inline int vec_all_gt(vec_short8 a, vec_short8 b)
2637 
{
2638 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xFF));
2639 
}
2640 
 
2641 
static inline int vec_all_gt(vec_bshort8 a, vec_short8 b)
2642 
{
2643 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(a), b)), 0) == 0xFF));
2644 
}
2645 
 
2646 
static inline int vec_all_gt(vec_short8 a, vec_bshort8 b)
2647 
{
2648 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_short8)(b))), 0) == 0xFF));
2649 
}
2650 
 
2651 
static inline int vec_all_gt(vec_uint4 a, vec_uint4 b)
2652 
{
2653 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xF));
2654 
}
2655 
 
2656 
static inline int vec_all_gt(vec_int4 a, vec_int4 b)
2657 
{
2658 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xF));
2659 
}
2660 
 
2661 
static inline int vec_all_gt(vec_bint4 a, vec_int4 b)
2662 
{
2663 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(a), b)), 0) == 0xF));
2664 
}
2665 
 
2666 
static inline int vec_all_gt(vec_int4 a, vec_bint4 b)
2667 
{
2668 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_int4)(b))), 0) == 0xF));
2669 
}
2670 
 
2671 
static inline int vec_all_gt(vec_float4 a, vec_float4 b)
2672 
{
2673 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xF));
2674 
}
2675 
 
2676 
 
2677 
/* vec_all_in (all elements in bounds)
2678 
 * ==========
2679 
 */
2680 
static inline int vec_all_in(vec_float4 a, vec_float4 b)
2681 
{
2682 
  return (spu_extract(spu_gather(spu_nor(spu_cmpabsgt(a, b), (vec_uint4)(spu_rlmaska((vec_int4)(b), -31)))), 0) == 0xF);
2683 
}
2684 
 
2685 
 
2686 
/* vec_all_le (all elements less than or equal)
2687 
 * ==========
2688 
 */
2689 
static inline int vec_all_le(vec_uchar16 a, vec_uchar16 b)
2690 
{
2691 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2692 
}
2693 
 
2694 
static inline int vec_all_le(vec_char16 a, vec_char16 b)
2695 
{
2696 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2697 
}
2698 
 
2699 
static inline int vec_all_le(vec_bchar16 a, vec_char16 b)
2700 
{
2701 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(a), b)), 0) == 0));
2702 
}
2703 
 
2704 
static inline int vec_all_le(vec_char16 a, vec_bchar16 b)
2705 
{
2706 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_char16)(b))), 0) == 0));
2707 
}
2708 
 
2709 
static inline int vec_all_le(vec_ushort8 a, vec_ushort8 b)
2710 
{
2711 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2712 
}
2713 
 
2714 
static inline int vec_all_le(vec_short8 a, vec_short8 b)
2715 
{
2716 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2717 
}
2718 
 
2719 
static inline int vec_all_le(vec_bshort8 a, vec_short8 b)
2720 
{
2721 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(a), b)), 0) == 0));
2722 
}
2723 
 
2724 
static inline int vec_all_le(vec_short8 a, vec_bshort8 b)
2725 
{
2726 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_short8)(b))), 0) == 0));
2727 
}
2728 
 
2729 
static inline int vec_all_le(vec_uint4 a, vec_uint4 b)
2730 
{
2731 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2732 
}
2733 
 
2734 
static inline int vec_all_le(vec_int4 a, vec_int4 b)
2735 
{
2736 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2737 
}
2738 
 
2739 
static inline int vec_all_le(vec_bint4 a, vec_int4 b)
2740 
{
2741 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(a), b)), 0) == 0));
2742 
}
2743 
 
2744 
static inline int vec_all_le(vec_int4 a, vec_bint4 b)
2745 
{
2746 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_int4)(b))), 0) == 0));
2747 
}
2748 
 
2749 
static inline int vec_all_le(vec_float4 a, vec_float4 b)
2750 
{
2751 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2752 
}
2753 
 
2754 
 
2755 
/* vec_all_lt (all elements less than)
2756 
 * ==========
2757 
 */
2758 
static inline int vec_all_lt(vec_uchar16 a, vec_uchar16 b)
2759 
{
2760 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xFFFF));
2761 
}
2762 
 
2763 
static inline int vec_all_lt(vec_char16 a, vec_char16 b)
2764 
{
2765 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xFFFF));
2766 
}
2767 
 
2768 
static inline int vec_all_lt(vec_bchar16 a, vec_char16 b)
2769 
{
2770 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_char16)(a))), 0) == 0xFFFF));
2771 
}
2772 
 
2773 
static inline int vec_all_lt(vec_char16 a, vec_bchar16 b)
2774 
{
2775 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(b), a)), 0) == 0xFFFF));
2776 
}
2777 
 
2778 
static inline int vec_all_lt(vec_ushort8 a, vec_ushort8 b)
2779 
{
2780 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xFF));
2781 
}
2782 
 
2783 
static inline int vec_all_lt(vec_short8 a, vec_short8 b)
2784 
{
2785 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xFF));
2786 
}
2787 
 
2788 
static inline int vec_all_lt(vec_bshort8 a, vec_short8 b)
2789 
{
2790 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_short8)(a))), 0) == 0xFF));
2791 
}
2792 
 
2793 
static inline int vec_all_lt(vec_short8 a, vec_bshort8 b)
2794 
{
2795 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(b), a)), 0) == 0xFF));
2796 
}
2797 
 
2798 
static inline int vec_all_lt(vec_uint4 a, vec_uint4 b)
2799 
{
2800 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xF));
2801 
}
2802 
 
2803 
static inline int vec_all_lt(vec_int4 a, vec_int4 b)
2804 
{
2805 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xF));
2806 
}
2807 
 
2808 
static inline int vec_all_lt(vec_bint4 a, vec_int4 b)
2809 
{
2810 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_int4)(a))), 0) == 0xF));
2811 
}
2812 
 
2813 
static inline int vec_all_lt(vec_int4 a, vec_bint4 b)
2814 
{
2815 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(b), a)), 0) == 0xF));
2816 
}
2817 
 
2818 
static inline int vec_all_lt(vec_float4 a, vec_float4 b)
2819 
{
2820 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xF));
2821 
}
2822 
 
2823 
 
2824 
/* vec_all_nan (all elements not a number)
2825 
 * ===========
2826 
 */
2827 
static inline int vec_all_nan(vec_float4 a)
2828 
{
2829 
  vec_uint4 exp, man;
2830 
  vec_uint4 exp_mask = spu_splats((unsigned int)0x7F800000);
2831 
 
2832 
  exp = spu_and((vec_uint4)(a), exp_mask);
2833 
  man = spu_and((vec_uint4)(a), spu_splats((unsigned int)0x007FFFFF));
2834 
  return ((int)(spu_extract(spu_gather(spu_andc(spu_cmpeq(exp, exp_mask),
2835 
                                                spu_cmpeq(man, 0))), 0) == 0xF));
2836 
}
2837 
 
2838 
#define vec_all_nan(_a)         (0)
2839 
 
2840 
 
2841 
/* vec_all_ne (all elements not equal)
2842 
 * ==========
2843 
 */
2844 
static inline int vec_all_ne(vec_uchar16 a, vec_uchar16 b)
2845 
{
2846 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2847 
}
2848 
 
2849 
static inline int vec_all_ne(vec_char16 a, vec_char16 b)
2850 
{
2851 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2852 
}
2853 
 
2854 
static inline int vec_all_ne(vec_bchar16 a, vec_char16 b)
2855 
{
2856 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_char16)(a), b)), 0) == 0));
2857 
}
2858 
 
2859 
static inline int vec_all_ne(vec_char16 a, vec_bchar16 b)
2860 
{
2861 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_char16)(b))), 0) == 0));
2862 
}
2863 
 
2864 
static inline int vec_all_ne(vec_ushort8 a, vec_ushort8 b)
2865 
{
2866 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2867 
}
2868 
 
2869 
static inline int vec_all_ne(vec_short8 a, vec_short8 b)
2870 
{
2871 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2872 
}
2873 
 
2874 
static inline int vec_all_ne(vec_bshort8 a, vec_short8 b)
2875 
{
2876 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_short8)(a), b)), 0) == 0));
2877 
}
2878 
 
2879 
static inline int vec_all_ne(vec_short8 a, vec_bshort8 b)
2880 
{
2881 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_short8)(b))), 0) == 0));
2882 
}
2883 
 
2884 
static inline int vec_all_ne(vec_uint4 a, vec_uint4 b)
2885 
{
2886 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2887 
}
2888 
 
2889 
static inline int vec_all_ne(vec_int4 a, vec_int4 b)
2890 
{
2891 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2892 
}
2893 
 
2894 
static inline int vec_all_ne(vec_bint4 a, vec_int4 b)
2895 
{
2896 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_int4)(a), b)), 0) == 0));
2897 
}
2898 
 
2899 
static inline int vec_all_ne(vec_int4 a, vec_bint4 b)
2900 
{
2901 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_int4)(b))), 0) == 0));
2902 
}
2903 
 
2904 
static inline int vec_all_ne(vec_float4 a, vec_float4 b)
2905 
{
2906 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) == 0));
2907 
}
2908 
 
2909 
 
2910 
/* vec_all_nge (all elements not greater than or equal)
2911 
 * ===========
2912 
 */
2913 
static inline int vec_all_nge(vec_float4 a, vec_float4 b)
2914 
{
2915 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0xF));
2916 
}
2917 
 
2918 
 
2919 
/* vec_all_ngt (all elements not greater than)
2920 
 * ===========
2921 
 */
2922 
static inline int vec_all_ngt(vec_float4 a, vec_float4 b)
2923 
{
2924 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0));
2925 
}
2926 
 
2927 
 
2928 
/* vec_all_nle (all elements not less than or equal)
2929 
 * ===========
2930 
 */
2931 
static inline int vec_all_nle(vec_float4 a, vec_float4 b)
2932 
{
2933 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) == 0xF));
2934 
}
2935 
 
2936 
 
2937 
/* vec_all_nlt (all elements not less than)
2938 
 * ===========
2939 
 */
2940 
static inline int vec_all_nlt(vec_float4 a, vec_float4 b)
2941 
{
2942 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) == 0));
2943 
}
2944 
 
2945 
 
2946 
/* vec_all_numeric (all elements numeric)
2947 
 * ===========
2948 
 */
2949 
static inline int vec_all_numeric(vec_float4 a)
2950 
{
2951 
  vec_uint4 exp;
2952 
 
2953 
  exp = spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF);
2954 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(exp, 255)), 0) == 0));
2955 
}
2956 
 
2957 
 
2958 
 
2959 
/* vec_any_eq (any elements equal)
2960 
 * ==========
2961 
 */
2962 
static inline int vec_any_eq(vec_uchar16 a, vec_uchar16 b)
2963 
{
2964 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0));
2965 
}
2966 
 
2967 
static inline int vec_any_eq(vec_char16 a, vec_char16 b)
2968 
{
2969 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0));
2970 
}
2971 
 
2972 
static inline int vec_any_eq(vec_bchar16 a, vec_char16 b)
2973 
{
2974 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_char16)(a), b)), 0) != 0));
2975 
}
2976 
 
2977 
static inline int vec_any_eq(vec_char16 a, vec_bchar16 b)
2978 
{
2979 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_char16)(b))), 0) != 0));
2980 
}
2981 
 
2982 
static inline int vec_any_eq(vec_ushort8 a, vec_ushort8 b)
2983 
{
2984 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0));
2985 
}
2986 
 
2987 
static inline int vec_any_eq(vec_short8 a, vec_short8 b)
2988 
{
2989 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0));
2990 
}
2991 
 
2992 
static inline int vec_any_eq(vec_bshort8 a, vec_short8 b)
2993 
{
2994 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_short8)(a), b)), 0) != 0));
2995 
}
2996 
 
2997 
static inline int vec_any_eq(vec_short8 a, vec_bshort8 b)
2998 
{
2999 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_short8)(b))), 0) != 0));
3000 
}
3001 
 
3002 
static inline int vec_any_eq(vec_uint4 a, vec_uint4 b)
3003 
{
3004 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpeq(a, b), -31)), 0)));
3005 
}
3006 
 
3007 
static inline int vec_any_eq(vec_int4 a, vec_int4 b)
3008 
{
3009 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpeq(a, b), -31)), 0)));
3010 
}
3011 
 
3012 
static inline int vec_any_eq(vec_bint4 a, vec_int4 b)
3013 
{
3014 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpeq((vec_int4)(a), b), -31)), 0)));
3015 
}
3016 
 
3017 
static inline int vec_any_eq(vec_int4 a, vec_bint4 b)
3018 
{
3019 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpeq(a, (vec_int4)(b)), -31)), 0)));
3020 
}
3021 
 
3022 
static inline int vec_any_eq(vec_float4 a, vec_float4 b)
3023 
{
3024 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpeq(a, b), -31)), 0)));
3025 
}
3026 
 
3027 
/* vec_any_ge (any elements greater than or equal)
3028 
 * ==========
3029 
 */
3030 
static inline int vec_any_ge(vec_uchar16 a, vec_uchar16 b)
3031 
{
3032 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xFFFF));
3033 
}
3034 
 
3035 
static inline int vec_any_ge(vec_char16 a, vec_char16 b)
3036 
{
3037 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xFFFF));
3038 
}
3039 
 
3040 
static inline int vec_any_ge(vec_bchar16 a, vec_char16 b)
3041 
{
3042 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_char16)(a))), 0) != 0xFFFF));
3043 
}
3044 
 
3045 
static inline int vec_any_ge(vec_char16 a, vec_bchar16 b)
3046 
{
3047 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(b), a)), 0) != 0xFFFF));
3048 
}
3049 
 
3050 
static inline int vec_any_ge(vec_ushort8 a, vec_ushort8 b)
3051 
{
3052 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xFF));
3053 
}
3054 
 
3055 
static inline int vec_any_ge(vec_short8 a, vec_short8 b)
3056 
{
3057 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xFF));
3058 
}
3059 
 
3060 
static inline int vec_any_ge(vec_bshort8 a, vec_short8 b)
3061 
{
3062 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_short8)(a))), 0) != 0xFF));
3063 
}
3064 
 
3065 
static inline int vec_any_ge(vec_short8 a, vec_bshort8 b)
3066 
{
3067 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(b), a)), 0) != 0xFF));
3068 
}
3069 
 
3070 
static inline int vec_any_ge(vec_uint4 a, vec_uint4 b)
3071 
{
3072 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xF));
3073 
}
3074 
 
3075 
static inline int vec_any_ge(vec_int4 a, vec_int4 b)
3076 
{
3077 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xF));
3078 
}
3079 
 
3080 
static inline int vec_any_ge(vec_bint4 a, vec_int4 b)
3081 
{
3082 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_int4)(a))), 0) != 0xF));
3083 
}
3084 
 
3085 
static inline int vec_any_ge(vec_int4 a, vec_bint4 b)
3086 
{
3087 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(b), a)), 0) != 0xF));
3088 
}
3089 
 
3090 
static inline int vec_any_ge(vec_float4 a, vec_float4 b)
3091 
{
3092 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xF));
3093 
}
3094 
 
3095 
 
3096 
/* vec_any_gt (any elements greater than)
3097 
 * ==========
3098 
 */
3099 
static inline int vec_any_gt(vec_uchar16 a, vec_uchar16 b)
3100 
{
3101 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0));
3102 
}
3103 
 
3104 
static inline int vec_any_gt(vec_char16 a, vec_char16 b)
3105 
{
3106 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0));
3107 
}
3108 
 
3109 
static inline int vec_any_gt(vec_bchar16 a, vec_char16 b)
3110 
{
3111 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(a), b)), 0) != 0));
3112 
}
3113 
 
3114 
static inline int vec_any_gt(vec_char16 a, vec_bchar16 b)
3115 
{
3116 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_char16)(b))), 0) != 0));
3117 
}
3118 
 
3119 
static inline int vec_any_gt(vec_ushort8 a, vec_ushort8 b)
3120 
{
3121 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0));
3122 
}
3123 
 
3124 
static inline int vec_any_gt(vec_short8 a, vec_short8 b)
3125 
{
3126 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0));
3127 
}
3128 
 
3129 
static inline int vec_any_gt(vec_bshort8 a, vec_short8 b)
3130 
{
3131 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(a), b)), 0) != 0));
3132 
}
3133 
 
3134 
static inline int vec_any_gt(vec_short8 a, vec_bshort8 b)
3135 
{
3136 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_short8)(b))), 0) != 0));
3137 
}
3138 
 
3139 
 
3140 
static inline int vec_any_gt(vec_uint4 a, vec_uint4 b)
3141 
{
3142 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(a, b), -31)), 0)));
3143 
}
3144 
 
3145 
static inline int vec_any_gt(vec_int4 a, vec_int4 b)
3146 
{
3147 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(a, b), -31)), 0)));
3148 
}
3149 
 
3150 
static inline int vec_any_gt(vec_bint4 a, vec_int4 b)
3151 
{
3152 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt((vec_int4)(a), b), -31)), 0)));
3153 
}
3154 
 
3155 
static inline int vec_any_gt(vec_int4 a, vec_bint4 b)
3156 
{
3157 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(a, (vec_int4)(b)), -31)), 0)));
3158 
}
3159 
 
3160 
static inline int vec_any_gt(vec_float4 a, vec_float4 b)
3161 
{
3162 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(a, b), -31)), 0)));
3163 
}
3164 
 
3165 
/* vec_any_le (any elements less than or equal)
3166 
 * ==========
3167 
 */
3168 
static inline int vec_any_le(vec_uchar16 a, vec_uchar16 b)
3169 
{
3170 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xFFFF));
3171 
}
3172 
 
3173 
static inline int vec_any_le(vec_char16 a, vec_char16 b)
3174 
{
3175 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xFFFF));
3176 
}
3177 
 
3178 
static inline int vec_any_le(vec_bchar16 a, vec_char16 b)
3179 
{
3180 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(a), b)), 0) != 0xFFFF));
3181 
}
3182 
 
3183 
static inline int vec_any_le(vec_char16 a, vec_bchar16 b)
3184 
{
3185 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_char16)(b))), 0) != 0xFFFF));
3186 
}
3187 
 
3188 
static inline int vec_any_le(vec_ushort8 a, vec_ushort8 b)
3189 
{
3190 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xFF));
3191 
}
3192 
 
3193 
static inline int vec_any_le(vec_short8 a, vec_short8 b)
3194 
{
3195 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xFF));
3196 
}
3197 
 
3198 
static inline int vec_any_le(vec_bshort8 a, vec_short8 b)
3199 
{
3200 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(a), b)), 0) != 0xFF));
3201 
}
3202 
 
3203 
static inline int vec_any_le(vec_short8 a, vec_bshort8 b)
3204 
{
3205 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_short8)(b))), 0) != 0xFF));
3206 
}
3207 
 
3208 
static inline int vec_any_le(vec_uint4 a, vec_uint4 b)
3209 
{
3210 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xF));
3211 
}
3212 
 
3213 
static inline int vec_any_le(vec_int4 a, vec_int4 b)
3214 
{
3215 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xF));
3216 
}
3217 
 
3218 
static inline int vec_any_le(vec_bint4 a, vec_int4 b)
3219 
{
3220 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_int4)(a), b)), 0) != 0xF));
3221 
}
3222 
 
3223 
static inline int vec_any_le(vec_int4 a, vec_bint4 b)
3224 
{
3225 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, (vec_int4)(b))), 0) != 0xF));
3226 
}
3227 
 
3228 
static inline int vec_any_le(vec_float4 a, vec_float4 b)
3229 
{
3230 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xF));
3231 
}
3232 
 
3233 
 
3234 
/* vec_any_lt (any elements less than)
3235 
 * ==========
3236 
 */
3237 
static inline int vec_any_lt(vec_uchar16 a, vec_uchar16 b)
3238 
{
3239 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0));
3240 
}
3241 
 
3242 
static inline int vec_any_lt(vec_char16 a, vec_char16 b)
3243 
{
3244 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0));
3245 
}
3246 
 
3247 
static inline int vec_any_lt(vec_bchar16 a, vec_char16 b)
3248 
{
3249 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_char16)(a))), 0) != 0));
3250 
}
3251 
 
3252 
static inline int vec_any_lt(vec_char16 a, vec_bchar16 b)
3253 
{
3254 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_char16)(b), a)), 0) != 0));
3255 
}
3256 
 
3257 
static inline int vec_any_lt(vec_ushort8 a, vec_ushort8 b)
3258 
{
3259 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0));
3260 
}
3261 
 
3262 
static inline int vec_any_lt(vec_short8 a, vec_short8 b)
3263 
{
3264 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0));
3265 
}
3266 
 
3267 
static inline int vec_any_lt(vec_bshort8 a, vec_short8 b)
3268 
{
3269 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, (vec_short8)(a))), 0) != 0));
3270 
}
3271 
 
3272 
static inline int vec_any_lt(vec_short8 a, vec_bshort8 b)
3273 
{
3274 
  return ((int)(spu_extract(spu_gather(spu_cmpgt((vec_short8)(b), a)), 0) != 0));
3275 
}
3276 
 
3277 
static inline int vec_any_lt(vec_uint4 a, vec_uint4 b)
3278 
{
3279 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(b, a), -31)), 0)));
3280 
}
3281 
 
3282 
static inline int vec_any_lt(vec_int4 a, vec_int4 b)
3283 
{
3284 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(b, a), -31)), 0)));
3285 
}
3286 
 
3287 
static inline int vec_any_lt(vec_bint4 a, vec_int4 b)
3288 
{
3289 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(b, (vec_int4)(a)), -31)), 0)));
3290 
}
3291 
 
3292 
static inline int vec_any_lt(vec_int4 a, vec_bint4 b)
3293 
{
3294 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt((vec_int4)(b), a), -31)), 0)));
3295 
}
3296 
 
3297 
static inline int vec_any_lt(vec_float4 a, vec_float4 b)
3298 
{
3299 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(b, a), -31)), 0)));
3300 
}
3301 
 
3302 
/* vec_any_nan (any elements not a number)
3303 
 * ===========
3304 
 */
3305 
static inline int vec_any_nan(vec_float4 a)
3306 
{
3307 
  vec_uint4 exp, man;
3308 
  vec_uint4 exp_mask = spu_splats((unsigned int)0x7F800000);
3309 
 
3310 
  exp = spu_and((vec_uint4)(a), exp_mask);
3311 
  man = spu_and((vec_uint4)(a), spu_splats((unsigned int)0x007FFFFF));
3312 
  return ((int)(spu_extract(spu_gather(spu_andc(spu_cmpeq(exp, exp_mask),
3313 
                                                spu_cmpeq(man, 0))), 0) != 0));
3314 
}
3315 
 
3316 
 
3317 
/* vec_any_ne (any elements not equal)
3318 
 * ==========
3319 
 */
3320 
static inline int vec_any_ne(vec_uchar16 a, vec_uchar16 b)
3321 
{
3322 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xFFFF));
3323 
}
3324 
 
3325 
static inline int vec_any_ne(vec_char16 a, vec_char16 b)
3326 
{
3327 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xFFFF));
3328 
}
3329 
 
3330 
static inline int vec_any_ne(vec_bchar16 a, vec_char16 b)
3331 
{
3332 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_char16)(a), b)), 0) != 0xFFFF));
3333 
}
3334 
 
3335 
static inline int vec_any_ne(vec_char16 a, vec_bchar16 b)
3336 
{
3337 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_char16)(b))), 0) != 0xFFFF));
3338 
}
3339 
 
3340 
static inline int vec_any_ne(vec_ushort8 a, vec_ushort8 b)
3341 
{
3342 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xFF));
3343 
}
3344 
 
3345 
static inline int vec_any_ne(vec_short8 a, vec_short8 b)
3346 
{
3347 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xFF));
3348 
}
3349 
 
3350 
static inline int vec_any_ne(vec_bshort8 a, vec_short8 b)
3351 
{
3352 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_short8)(a), b)), 0) != 0xFF));
3353 
}
3354 
 
3355 
static inline int vec_any_ne(vec_short8 a, vec_bshort8 b)
3356 
{
3357 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_short8)(b))), 0) != 0xFF));
3358 
}
3359 
 
3360 
static inline int vec_any_ne(vec_uint4 a, vec_uint4 b)
3361 
{
3362 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xF));
3363 
}
3364 
 
3365 
static inline int vec_any_ne(vec_int4 a, vec_int4 b)
3366 
{
3367 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xF));
3368 
}
3369 
 
3370 
static inline int vec_any_ne(vec_bint4 a, vec_int4 b)
3371 
{
3372 
  return ((int)(spu_extract(spu_gather(spu_cmpeq((vec_int4)(a), b)), 0) != 0xF));
3373 
}
3374 
 
3375 
static inline int vec_any_ne(vec_int4 a, vec_bint4 b)
3376 
{
3377 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, (vec_int4)(b))), 0) != 0xF));
3378 
}
3379 
 
3380 
static inline int vec_any_ne(vec_float4 a, vec_float4 b)
3381 
{
3382 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(a, b)), 0) != 0xF));
3383 
}
3384 
 
3385 
 
3386 
/* vec_any_nge (any elements not greater than or equal)
3387 
 * ===========
3388 
 */
3389 
static inline int vec_any_nge(vec_float4 a, vec_float4 b)
3390 
{
3391 
  return ((int)(spu_extract(spu_orx(spu_rlmask(spu_cmpgt(b, a), -31)), 0)));
3392 
}
3393 
 
3394 
/* vec_any_ngt (any elements not greater than)
3395 
 * ===========
3396 
 */
3397 
static inline int vec_any_ngt(vec_float4 a, vec_float4 b)
3398 
{
3399 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0xF));
3400 
}
3401 
 
3402 
 
3403 
/* vec_any_nle (any elements not less than or equal)
3404 
 * ===========
3405 
 */
3406 
static inline int vec_any_nle(vec_float4 a, vec_float4 b)
3407 
{
3408 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(a, b)), 0) != 0));
3409 
}
3410 
 
3411 
 
3412 
/* vec_any_nlt (any elements not less than)
3413 
 * ===========
3414 
 */
3415 
static inline int vec_any_nlt(vec_float4 a, vec_float4 b)
3416 
{
3417 
  return ((int)(spu_extract(spu_gather(spu_cmpgt(b, a)), 0) != 0xF));
3418 
}
3419 
 
3420 
 
3421 
/* vec_any_numeric (any elements numeric)
3422 
 * ===============
3423 
 */
3424 
static inline int vec_any_numeric(vec_float4 a)
3425 
{
3426 
  vec_uint4 exp;
3427 
 
3428 
  exp = spu_and(spu_rlmask((vec_uint4)(a), -23), 0xFF);
3429 
  return ((int)(spu_extract(spu_gather(spu_cmpeq(exp, 255)), 0) != 0xF));
3430 
}
3431 
 
3432 
 
3433 
/* vec_any_out (any elements out of bounds)
3434 
 * ===========
3435 
 */
3436 
static inline int vec_any_out(vec_float4 a, vec_float4 b)
3437 
{
3438 
  return (spu_extract(spu_gather(spu_nor(spu_cmpabsgt(a, b), (vec_uint4)(spu_rlmaska((vec_int4)(b), -31)))), 0) != 0xF);
3439 
}
3440 
 
3441 
 
3442 
/* CBE Language Extension Intrinsics
3443 
 */
3444 
 
3445 
/* vec_extract (extract element from vector)
3446 
 * ===========
3447 
 */
3448 
#define vec_extract(_a, _element)       spu_extract(_a, _element)
3449 
 
3450 
 
3451 
/* vec_insert (insert scalar into specified vector element)
3452 
 * ==========
3453 
 */
3454 
#define vec_insert(_a, _b, _element)    spu_insert(_a, _b, _element)
3455 
 
3456 
/* vec_lvlx (load vector left indexed)
3457 
 * ========
3458 
 */
3459 
static inline vec_uchar16 vec_lvlx(int a, unsigned char *b)
3460 
{
3461 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(b) + a);
3462 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3463 
}
3464 
 
3465 
static inline vec_uchar16 vec_lvlx(int a, vec_uchar16 *b)
3466 
{
3467 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(b) + a);
3468 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3469 
}
3470 
 
3471 
static inline vec_char16 vec_lvlx(int a, signed char *b)
3472 
{
3473 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(b) + a);
3474 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3475 
}
3476 
 
3477 
static inline vec_char16 vec_lvlx(int a, vec_char16 *b)
3478 
{
3479 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(b) + a);
3480 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3481 
}
3482 
 
3483 
static inline vec_ushort8 vec_lvlx(int a, unsigned short *b)
3484 
{
3485 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(b) + a);
3486 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3487 
}
3488 
 
3489 
static inline vec_ushort8 vec_lvlx(int a, vec_ushort8 *b)
3490 
{
3491 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(b) + a);
3492 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3493 
}
3494 
 
3495 
static inline vec_short8 vec_lvlx(int a, signed short *b)
3496 
{
3497 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(b) + a);
3498 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3499 
}
3500 
 
3501 
static inline vec_short8 vec_lvlx(int a, vec_short8 *b)
3502 
{
3503 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(b) + a);
3504 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3505 
}
3506 
 
3507 
static inline vec_uint4 vec_lvlx(int a, unsigned int *b)
3508 
{
3509 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(b) + a);
3510 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3511 
}
3512 
 
3513 
static inline vec_uint4 vec_lvlx(int a, vec_uint4 *b)
3514 
{
3515 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(b) + a);
3516 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3517 
}
3518 
 
3519 
static inline vec_int4 vec_lvlx(int a, signed int *b)
3520 
{
3521 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(b) + a);
3522 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3523 
}
3524 
 
3525 
static inline vec_int4 vec_lvlx(int a, vec_int4 *b)
3526 
{
3527 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(b) + a);
3528 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3529 
}
3530 
 
3531 
static inline vec_float4 vec_lvlx(int a, float *b)
3532 
{
3533 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(b) + a);
3534 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3535 
}
3536 
 
3537 
static inline vec_float4 vec_lvlx(int a, vec_float4 *b)
3538 
{
3539 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(b) + a);
3540 
  return(spu_slqwbyte(*p, (unsigned int)p & 0xF));
3541 
}
3542 
 
3543 
 
3544 
/* vec_lvlxl (load vector left indexed last)
3545 
 * =========
3546 
 */
3547 
#define vec_lvlxl(_a, _b)       vec_lvlx(_a, _b)
3548 
 
3549 
 
3550 
/* vec_lvrx (load vector right indexed)
3551 
 * ========
3552 
 */
3553 
static inline vec_uchar16 vec_lvrx(int a, unsigned char *b)
3554 
{
3555 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(b) + a);
3556 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3557 
}
3558 
 
3559 
static inline vec_uchar16 vec_lvrx(int a, vec_uchar16 *b)
3560 
{
3561 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(b) + a);
3562 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3563 
}
3564 
 
3565 
static inline vec_char16 vec_lvrx(int a, signed char *b)
3566 
{
3567 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(b) + a);
3568 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3569 
}
3570 
 
3571 
static inline vec_char16 vec_lvrx(int a, vec_char16 *b)
3572 
{
3573 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(b) + a);
3574 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3575 
}
3576 
 
3577 
static inline vec_ushort8 vec_lvrx(int a, unsigned short *b)
3578 
{
3579 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(b) + a);
3580 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3581 
}
3582 
 
3583 
static inline vec_ushort8 vec_lvrx(int a, vec_ushort8 *b)
3584 
{
3585 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(b) + a);
3586 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3587 
}
3588 
 
3589 
static inline vec_short8 vec_lvrx(int a, signed short *b)
3590 
{
3591 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(b) + a);
3592 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3593 
}
3594 
 
3595 
static inline vec_short8 vec_lvrx(int a, vec_short8 *b)
3596 
{
3597 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(b) + a);
3598 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3599 
}
3600 
 
3601 
static inline vec_uint4 vec_lvrx(int a, unsigned int *b)
3602 
{
3603 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(b) + a);
3604 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3605 
}
3606 
 
3607 
static inline vec_uint4 vec_lvrx(int a, vec_uint4 *b)
3608 
{
3609 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(b) + a);
3610 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3611 
}
3612 
 
3613 
static inline vec_int4 vec_lvrx(int a, signed int *b)
3614 
{
3615 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(b) + a);
3616 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3617 
}
3618 
 
3619 
static inline vec_int4 vec_lvrx(int a, vec_int4 *b)
3620 
{
3621 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(b) + a);
3622 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3623 
}
3624 
 
3625 
static inline vec_float4 vec_lvrx(int a, float *b)
3626 
{
3627 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(b) + a);
3628 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3629 
}
3630 
 
3631 
static inline vec_float4 vec_lvrx(int a, vec_float4 *b)
3632 
{
3633 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(b) + a);
3634 
  return(spu_rlmaskqwbyte(*p, ((int)p & 0xF)-16));
3635 
}
3636 
 
3637 
 
3638 
 
3639 
/* vec_lvrxl (load vector right indexed last)
3640 
 * =========
3641 
 */
3642 
#define vec_lvrxl(_a, _b)       vec_lvrx(_a, _b)
3643 
 
3644 
 
3645 
/* vec_promote (promote scalar to a vector)
3646 
 * ===========
3647 
 */
3648 
#define vec_promote(_a, _element)       spu_promote(_a, _element)
3649 
 
3650 
 
3651 
/* vec_splats (splat scalar to a vector)
3652 
 * ==========
3653 
 */
3654 
#define vec_splats(_a)  spu_splats(_a)
3655 
 
3656 
 
3657 
/* vec_stvlx (store vector left indexed)
3658 
 * =========
3659 
 */
3660 
static inline void vec_stvlx(vec_uchar16 a, int b, unsigned char *c)
3661 
{
3662 
  int shift;
3663 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(c) + b);
3664 
 
3665 
  shift = -((int)p & 0xF);
3666 
  *p = spu_sel(*p,
3667 
               spu_rlmaskqwbyte(a, shift),
3668 
               spu_rlmaskqwbyte(spu_splats((unsigned char)0xFF), shift));
3669 
}
3670 
 
3671 
static inline void vec_stvlx(vec_uchar16 a, int b, vec_uchar16 *c)
3672 
{
3673 
  int shift;
3674 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(c) + b);
3675 
 
3676 
  shift = -((int)p & 0xF);
3677 
  *p = spu_sel(*p,
3678 
               spu_rlmaskqwbyte(a, shift),
3679 
               spu_rlmaskqwbyte(spu_splats((unsigned char)0xFF), shift));
3680 
}
3681 
 
3682 
static inline void vec_stvlx(vec_char16 a, int b, signed char *c)
3683 
{
3684 
  int shift;
3685 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(c) + b);
3686 
 
3687 
  shift = -((int)p & 0xF);
3688 
  *p = spu_sel(*p,
3689 
               spu_rlmaskqwbyte(a, shift),
3690 
               spu_rlmaskqwbyte(spu_splats((unsigned char)0xFF), shift));
3691 
}
3692 
 
3693 
static inline void vec_stvlx(vec_char16 a, int b, vec_char16 *c)
3694 
{
3695 
  int shift;
3696 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(c) + b);
3697 
 
3698 
  shift = -((int)p & 0xF);
3699 
  *p = spu_sel(*p,
3700 
               spu_rlmaskqwbyte(a, shift),
3701 
               spu_rlmaskqwbyte(spu_splats((unsigned char)0xFF), shift));
3702 
}
3703 
 
3704 
static inline void vec_stvlx(vec_ushort8 a, int b, unsigned short *c)
3705 
{
3706 
  int shift;
3707 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(c) + b);
3708 
 
3709 
  shift = -((int)p & 0xF);
3710 
  *p = spu_sel(*p,
3711 
               spu_rlmaskqwbyte(a, shift),
3712 
               spu_rlmaskqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3713 
}
3714 
 
3715 
static inline void vec_stvlx(vec_ushort8 a, int b, vec_ushort8 *c)
3716 
{
3717 
  int shift;
3718 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(c) + b);
3719 
 
3720 
  shift = -((int)p & 0xF);
3721 
  *p = spu_sel(*p,
3722 
               spu_rlmaskqwbyte(a, shift),
3723 
               spu_rlmaskqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3724 
}
3725 
 
3726 
static inline void vec_stvlx(vec_short8 a, int b, signed short *c)
3727 
{
3728 
  int shift;
3729 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(c) + b);
3730 
 
3731 
  shift = -((int)p & 0xF);
3732 
  *p = spu_sel(*p,
3733 
               spu_rlmaskqwbyte(a, shift),
3734 
               spu_rlmaskqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3735 
}
3736 
 
3737 
static inline void vec_stvlx(vec_short8 a, int b, vec_short8 *c)
3738 
{
3739 
  int shift;
3740 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(c) + b);
3741 
 
3742 
  shift = -((int)p & 0xF);
3743 
  *p = spu_sel(*p,
3744 
               spu_rlmaskqwbyte(a, shift),
3745 
               spu_rlmaskqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3746 
}
3747 
 
3748 
static inline void vec_stvlx(vec_uint4 a, int b, unsigned int *c)
3749 
{
3750 
  int shift;
3751 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(c) + b);
3752 
 
3753 
  shift = -((int)p & 0xF);
3754 
  *p = spu_sel(*p,
3755 
               spu_rlmaskqwbyte(a, shift),
3756 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3757 
}
3758 
 
3759 
static inline void vec_stvlx(vec_uint4 a, int b, vec_uint4 *c)
3760 
{
3761 
  int shift;
3762 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(c) + b);
3763 
 
3764 
  shift = -((int)p & 0xF);
3765 
  *p = spu_sel(*p,
3766 
               spu_rlmaskqwbyte(a, shift),
3767 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3768 
}
3769 
 
3770 
static inline void vec_stvlx(vec_int4 a, int b, signed int *c)
3771 
{
3772 
  int shift;
3773 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(c) + b);
3774 
 
3775 
  shift = -((int)p & 0xF);
3776 
  *p = spu_sel(*p,
3777 
               spu_rlmaskqwbyte(a, shift),
3778 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3779 
}
3780 
 
3781 
static inline void vec_stvlx(vec_int4 a, int b, vec_int4 *c)
3782 
{
3783 
  int shift;
3784 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(c) + b);
3785 
 
3786 
  shift = -((int)p & 0xF);
3787 
  *p = spu_sel(*p,
3788 
               spu_rlmaskqwbyte(a, shift),
3789 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3790 
}
3791 
 
3792 
static inline void vec_stvlx(vec_float4 a, int b, float *c)
3793 
{
3794 
  int shift;
3795 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(c) + b);
3796 
 
3797 
  shift = -((int)p & 0xF);
3798 
  *p = spu_sel(*p,
3799 
               spu_rlmaskqwbyte(a, shift),
3800 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3801 
}
3802 
 
3803 
static inline void vec_stvlx(vec_float4 a, int b, vec_float4 *c)
3804 
{
3805 
  int shift;
3806 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(c) + b);
3807 
 
3808 
  shift = -((int)p & 0xF);
3809 
  *p = spu_sel(*p,
3810 
               spu_rlmaskqwbyte(a, shift),
3811 
               spu_rlmaskqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3812 
}
3813 
 
3814 
/* vec_stvlxl (store vector left indexed last)
3815 
 * ==========
3816 
 */
3817 
#define vec_stvlxl(_a, _b, _c)  vec_stvlx(_a, _b, _c)
3818 
 
3819 
 
3820 
/* vec_stvrx (store vector right indexed)
3821 
 * =========
3822 
 */
3823 
static inline void vec_stvrx(vec_uchar16 a, int b, unsigned char *c)
3824 
{
3825 
  int shift;
3826 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(c) + b);
3827 
 
3828 
  shift = 16-((int)p & 0xF);
3829 
  *p = spu_sel(*p,
3830 
               spu_slqwbyte(a, shift),
3831 
               spu_slqwbyte(spu_splats((unsigned char)0xFF), shift));
3832 
}
3833 
 
3834 
static inline void vec_stvrx(vec_uchar16 a, int b, vec_uchar16 *c)
3835 
{
3836 
  int shift;
3837 
  vec_uchar16 *p = (vec_uchar16 *)((unsigned char *)(c) + b);
3838 
 
3839 
  shift = 16-((int)p & 0xF);
3840 
  *p = spu_sel(*p,
3841 
               spu_slqwbyte(a, shift),
3842 
               spu_slqwbyte(spu_splats((unsigned char)0xFF), shift));
3843 
}
3844 
 
3845 
static inline void vec_stvrx(vec_char16 a, int b, signed char *c)
3846 
{
3847 
  int shift;
3848 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(c) + b);
3849 
 
3850 
  shift = 16-((int)p & 0xF);
3851 
  *p = spu_sel(*p,
3852 
               spu_slqwbyte(a, shift),
3853 
               spu_slqwbyte(spu_splats((unsigned char)0xFF), shift));
3854 
}
3855 
 
3856 
static inline void vec_stvrx(vec_char16 a, int b, vec_char16 *c)
3857 
{
3858 
  int shift;
3859 
  vec_char16 *p = (vec_char16 *)((unsigned char *)(c) + b);
3860 
 
3861 
  shift = 16-((int)p & 0xF);
3862 
  *p = spu_sel(*p,
3863 
               spu_slqwbyte(a, shift),
3864 
               spu_slqwbyte(spu_splats((unsigned char)0xFF), shift));
3865 
}
3866 
 
3867 
static inline void vec_stvrx(vec_ushort8 a, int b, unsigned short *c)
3868 
{
3869 
  int shift;
3870 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(c) + b);
3871 
 
3872 
  shift = 16-((int)p & 0xF);
3873 
  *p = spu_sel(*p,
3874 
               spu_slqwbyte(a, shift),
3875 
               spu_slqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3876 
}
3877 
 
3878 
static inline void vec_stvrx(vec_ushort8 a, int b, vec_ushort8 *c)
3879 
{
3880 
  int shift;
3881 
  vec_ushort8 *p = (vec_ushort8 *)((unsigned char *)(c) + b);
3882 
 
3883 
  shift = 16-((int)p & 0xF);
3884 
  *p = spu_sel(*p,
3885 
               spu_slqwbyte(a, shift),
3886 
               spu_slqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3887 
}
3888 
 
3889 
static inline void vec_stvrx(vec_short8 a, int b, signed short *c)
3890 
{
3891 
  int shift;
3892 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(c) + b);
3893 
 
3894 
  shift = 16-((int)p & 0xF);
3895 
  *p = spu_sel(*p,
3896 
               spu_slqwbyte(a, shift),
3897 
               spu_slqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3898 
}
3899 
 
3900 
static inline void vec_stvrx(vec_short8 a, int b, vec_short8 *c)
3901 
{
3902 
  int shift;
3903 
  vec_short8 *p = (vec_short8 *)((unsigned char *)(c) + b);
3904 
 
3905 
  shift = 16-((int)p & 0xF);
3906 
  *p = spu_sel(*p,
3907 
               spu_slqwbyte(a, shift),
3908 
               spu_slqwbyte(spu_splats((unsigned short)0xFFFF), shift));
3909 
}
3910 
 
3911 
static inline void vec_stvrx(vec_uint4 a, int b, unsigned int *c)
3912 
{
3913 
  int shift;
3914 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(c) + b);
3915 
 
3916 
  shift = 16-((int)p & 0xF);
3917 
  *p = spu_sel(*p,
3918 
               spu_slqwbyte(a, shift),
3919 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3920 
}
3921 
 
3922 
static inline void vec_stvrx(vec_uint4 a, int b, vec_uint4 *c)
3923 
{
3924 
  int shift;
3925 
  vec_uint4 *p = (vec_uint4 *)((unsigned char *)(c) + b);
3926 
 
3927 
  shift = 16-((int)p & 0xF);
3928 
  *p = spu_sel(*p,
3929 
               spu_slqwbyte(a, shift),
3930 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3931 
}
3932 
 
3933 
static inline void vec_stvrx(vec_int4 a, int b, signed int *c)
3934 
{
3935 
  int shift;
3936 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(c) + b);
3937 
 
3938 
  shift = 16-((int)p & 0xF);
3939 
  *p = spu_sel(*p,
3940 
               spu_slqwbyte(a, shift),
3941 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3942 
}
3943 
 
3944 
static inline void vec_stvrx(vec_int4 a, int b, vec_int4 *c)
3945 
{
3946 
  int shift;
3947 
  vec_int4 *p = (vec_int4 *)((unsigned char *)(c) + b);
3948 
 
3949 
  shift = 16-((int)p & 0xF);
3950 
  *p = spu_sel(*p,
3951 
               spu_slqwbyte(a, shift),
3952 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3953 
}
3954 
 
3955 
static inline void vec_stvrx(vec_float4 a, int b, float *c)
3956 
{
3957 
  int shift;
3958 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(c) + b);
3959 
 
3960 
  shift = 16-((int)p & 0xF);
3961 
  *p = spu_sel(*p,
3962 
               spu_slqwbyte(a, shift),
3963 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3964 
}
3965 
 
3966 
static inline void vec_stvrx(vec_float4 a, int b, vec_float4 *c)
3967 
{
3968 
  int shift;
3969 
  vec_float4 *p = (vec_float4 *)((unsigned char *)(c) + b);
3970 
 
3971 
  shift = 16-((int)p & 0xF);
3972 
  *p = spu_sel(*p,
3973 
               spu_slqwbyte(a, shift),
3974 
               spu_slqwbyte(spu_splats((unsigned int)0xFFFFFFFF), shift));
3975 
}
3976 
 
3977 
/* vec_stvrxl (store vector right indexed last)
3978 
 * ==========
3979 
 */
3980 
#define vec_stvrxl(_a, _b, _c)  vec_stvrx(_a, _b, _c)
3981 
 
3982 
 
3983 
#endif /* __SPU__ */
3984 
#endif /* __cplusplus */
3985 
#endif /* !_VMX2SPU_H_ */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.