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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [spu/] [vmx2spu.h] - Blame information for rev 282

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 282 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.