gcc/config/rs6000/si2vmx.h

   1 /* Cell BEA specific SPU intrinsics to PPU/VMX intrinsics
   2    Copyright (C) 2007, 2009 Free Software Foundation, Inc.
   3
   4    This file is free software; you can redistribute it and/or modify it under
   5    the terms of the GNU General Public License as published by the Free
   6    Software Foundation; either version 3 of the License, or (at your option)
   7    any later version.
   8
   9    This file is distributed in the hope that it will be useful, but WITHOUT
  10    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12    for more details.
  13
  14    Under Section 7 of GPL version 3, you are granted additional
  15    permissions described in the GCC Runtime Library Exception, version
  16    3.1, as published by the Free Software Foundation.
  17
  18    You should have received a copy of the GNU General Public License and
  19    a copy of the GCC Runtime Library Exception along with this program;
  20    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  21    <http://www.gnu.org/licenses/>.  */
  22
  23 #ifndef _SI2VMX_H_
  24 #define _SI2VMX_H_      1
  25
  26 #ifndef __SPU__
  27
  28 #include <stdlib.h>
  29 #include <vec_types.h>
  30
  31
  32 /* Specify a default halt action for spu_hcmpeq and spu_hcmpgt intrinsics.
  33  * Users can override the action by defining it prior to including this
  34  * header file.
  35  */
  36 #ifndef SPU_HALT_ACTION
  37 #define SPU_HALT_ACTION         abort()
  38 #endif
  39
  40 /* Specify a default stop action for the spu_stop intrinsic.
  41  * Users can override the action by defining it prior to including this
  42  * header file.
  43  */
  44 #ifndef SPU_STOP_ACTION
  45 #define SPU_STOP_ACTION         abort()
  46 #endif
  47
  48
  49 /* Specify a default action for unsupported intrinsic.
  50  * Users can override the action by defining it prior to including this
  51  * header file.
  52  */
  53 #ifndef SPU_UNSUPPORTED_ACTION
  54 #define SPU_UNSUPPORTED_ACTION  abort()
  55 #endif
  56
  57
  58 /* Casting intrinsics - from scalar to quadword
  59  */
  60
  61 static __inline qword si_from_uchar(unsigned char c) {
  62   union {
  63     qword q;
  64     unsigned char c[16];
  65   } x;
  66   x.c[3] = c;
  67   return (x.q);
  68 }
  69
  70 static __inline qword si_from_char(signed char c) {
  71   union {
  72     qword q;
  73     signed char c[16];
  74   } x;
  75   x.c[3] = c;
  76   return (x.q);
  77 }
  78
  79 static __inline qword si_from_ushort(unsigned short s) {
  80   union {
  81     qword q;
  82     unsigned short s[8];
  83   } x;
  84   x.s[1] = s;
  85   return (x.q);
  86 }
  87
  88 static __inline qword si_from_short(short s) {
  89   union {
  90     qword q;
  91     short s[8];
  92   } x;
  93   x.s[1] = s;
  94   return (x.q);
  95 }
  96
  97
  98 static __inline qword si_from_uint(unsigned int i) {
  99   union {
 100     qword q;
 101     unsigned int i[4];
 102   } x;
 103   x.i[0] = i;
 104   return (x.q);
 105 }
 106
 107 static __inline qword si_from_int(int i) {
 108   union {
 109     qword q;
 110     int i[4];
 111   } x;
 112   x.i[0] = i;
 113   return (x.q);
 114 }
 115
 116 static __inline qword si_from_ullong(unsigned long long l) {
 117   union {
 118     qword q;
 119     unsigned long long l[2];
 120   } x;
 121   x.l[0] = l;
 122   return (x.q);
 123 }
 124
 125 static __inline qword si_from_llong(long long l) {
 126   union {
 127     qword q;
 128     long long l[2];
 129   } x;
 130   x.l[0] = l;
 131   return (x.q);
 132 }
 133
 134 static __inline qword si_from_float(float f) {
 135   union {
 136     qword q;
 137     float f[4];
 138   } x;
 139   x.f[0] = f;
 140   return (x.q);
 141 }
 142
 143 static __inline qword si_from_double(double d) {
 144   union {
 145     qword q;
 146     double d[2];
 147   } x;
 148   x.d[0] = d;
 149   return (x.q);
 150 }
 151
 152 static __inline qword si_from_ptr(void *ptr) {
 153   union {
 154     qword q;
 155     void *p;
 156   } x;
 157   x.p = ptr;
 158   return (x.q);
 159 }
 160
 161
 162 /* Casting intrinsics - from quadword to scalar
 163  */
 164 static __inline unsigned char si_to_uchar(qword q) {
 165   union {
 166     qword q;
 167     unsigned char c[16];
 168   } x;
 169   x.q = q;
 170   return (x.c[3]);
 171 }
 172
 173 static __inline signed char si_to_char(qword q) {
 174   union {
 175     qword q;
 176     signed char c[16];
 177   } x;
 178   x.q = q;
 179   return (x.c[3]);
 180 }
 181
 182 static __inline unsigned short si_to_ushort(qword q) {
 183   union {
 184     qword q;
 185     unsigned short s[8];
 186   } x;
 187   x.q = q;
 188   return (x.s[1]);
 189 }
 190
 191 static __inline short si_to_short(qword q) {
 192   union {
 193     qword q;
 194     short s[8];
 195   } x;
 196   x.q = q;
 197   return (x.s[1]);
 198 }
 199
 200 static __inline unsigned int si_to_uint(qword q) {
 201   union {
 202     qword q;
 203     unsigned int i[4];
 204   } x;
 205   x.q = q;
 206   return (x.i[0]);
 207 }
 208
 209 static __inline int si_to_int(qword q) {
 210   union {
 211     qword q;
 212     int i[4];
 213   } x;
 214   x.q = q;
 215   return (x.i[0]);
 216 }
 217
 218 static __inline unsigned long long si_to_ullong(qword q) {
 219   union {
 220     qword q;
 221     unsigned long long l[2];
 222   } x;
 223   x.q = q;
 224   return (x.l[0]);
 225 }
 226
 227 static __inline long long si_to_llong(qword q) {
 228   union {
 229     qword q;
 230     long long l[2];
 231   } x;
 232   x.q = q;
 233   return (x.l[0]);
 234 }
 235
 236 static __inline float si_to_float(qword q) {
 237   union {
 238     qword q;
 239     float f[4];
 240   } x;
 241   x.q = q;
 242   return (x.f[0]);
 243 }
 244
 245 static __inline double si_to_double(qword q) {
 246   union {
 247     qword q;
 248     double d[2];
 249   } x;
 250   x.q = q;
 251   return (x.d[0]);
 252 }
 253
 254 static __inline void * si_to_ptr(qword q) {
 255   union {
 256     qword q;
 257     void *p;
 258   } x;
 259   x.q = q;
 260   return (x.p);
 261 }
 262
 263
 264 /* Absolute difference
 265  */
 266 static __inline qword si_absdb(qword a, qword b)
 267 {
 268   vec_uchar16 ac, bc, dc;
 269
 270   ac = (vec_uchar16)(a);
 271   bc = (vec_uchar16)(b);
 272   dc = vec_sel(vec_sub(bc, ac), vec_sub(ac, bc), vec_cmpgt(ac, bc));
 273
 274   return ((qword)(dc));
 275 }
 276
 277 /* Add intrinsics
 278  */
 279 #define si_a(_a, _b)            ((qword)(vec_add((vec_uint4)(_a), (vec_uint4)(_b))))
 280
 281 #define si_ah(_a, _b)           ((qword)(vec_add((vec_ushort8)(_a), (vec_ushort8)(_b))))
 282
 283 static __inline qword si_ai(qword a, int b)
 284 {
 285   return ((qword)(vec_add((vec_int4)(a),
 286                           vec_splat((vec_int4)(si_from_int(b)), 0))));
 287 }
 288
 289
 290 static __inline qword si_ahi(qword a, short b)
 291 {
 292   return ((qword)(vec_add((vec_short8)(a),
 293                           vec_splat((vec_short8)(si_from_short(b)), 1))));
 294 }
 295
 296
 297 #define si_fa(_a, _b)   ((qword)(vec_add((vec_float4)(_a), (vec_float4)(_b))))
 298
 299
 300 static __inline qword si_dfa(qword a, qword b)
 301 {
 302   union {
 303     vec_double2 v;
 304     double d[2];
 305   } ad, bd, dd;
 306
 307   ad.v = (vec_double2)(a);
 308   bd.v = (vec_double2)(b);
 309   dd.d[0] = ad.d[0] + bd.d[0];
 310   dd.d[1] = ad.d[1] + bd.d[1];
 311
 312   return ((qword)(dd.v));
 313 }
 314
 315 /* Add word extended
 316  */
 317 #define si_addx(_a, _b, _c)     ((qword)(vec_add(vec_add((vec_uint4)(_a), (vec_uint4)(_b)),     \
 318                                                  vec_and((vec_uint4)(_c), vec_splat_u32(1)))))
 319
 320
 321 /* Bit-wise AND
 322  */
 323 #define si_and(_a, _b)          ((qword)(vec_and((vec_uint4)(_a), (vec_uint4)(_b))))
 324
 325
 326 static __inline qword si_andbi(qword a, signed char b)
 327 {
 328   return ((qword)(vec_and((vec_char16)(a),
 329                           vec_splat((vec_char16)(si_from_char(b)), 3))));
 330 }
 331
 332 static __inline qword si_andhi(qword a, signed short b)
 333 {
 334   return ((qword)(vec_and((vec_short8)(a),
 335                           vec_splat((vec_short8)(si_from_short(b)), 1))));
 336 }
 337
 338
 339 static __inline qword si_andi(qword a, signed int b)
 340 {
 341   return ((qword)(vec_and((vec_int4)(a),
 342                           vec_splat((vec_int4)(si_from_int(b)), 0))));
 343 }
 344
 345
 346 /* Bit-wise AND with complement
 347  */
 348 #define si_andc(_a, _b)         ((qword)(vec_andc((vec_uchar16)(_a), (vec_uchar16)(_b))))
 349
 350
 351 /* Average byte vectors
 352  */
 353 #define si_avgb(_a, _b)         ((qword)(vec_avg((vec_uchar16)(_a), (vec_uchar16)(_b))))
 354
 355
 356 /* Branch indirect and set link on external data
 357  */
 358 #define si_bisled(_func)        /* not mappable */
 359 #define si_bisledd(_func)       /* not mappable */
 360 #define si_bislede(_func)       /* not mappable */
 361
 362
 363 /* Borrow generate
 364  */
 365 #define si_bg(_a, _b)           ((qword)(vec_subc((vec_uint4)(_b), (vec_uint4)(_a))))
 366
 367 #define si_bgx(_a, _b, _c)      ((qword)(vec_and(vec_or(vec_cmpgt((vec_uint4)(_b), (vec_uint4)(_a)),            \
 368                                                         vec_and(vec_cmpeq((vec_uint4)(_b), (vec_uint4)(_a)),    \
 369                                                                 (vec_uint4)(_c))), vec_splat_u32(1))))
 370
 371 /* Compare absolute equal
 372  */
 373 static __inline qword si_fcmeq(qword a, qword b)
 374 {
 375   vec_float4 msb = (vec_float4)((vec_uint4){0x80000000, 0x80000000, 0x80000000, 0x80000000});
 376
 377   return ((qword)(vec_cmpeq(vec_andc((vec_float4)(a), msb),
 378                                   vec_andc((vec_float4)(b), msb))));
 379 }
 380
 381 static __inline qword si_dfcmeq(qword a, qword b)
 382 {
 383   vec_uint4 sign_mask= (vec_uint4) { 0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
 384   vec_uint4 nan_mask = (vec_uint4) { 0x7FF00000, 0x00000000, 0x7FF00000, 0x00000000 };
 385   vec_uchar16 hihi_promote = (vec_uchar16) { 0,1,2,3,  16,17,18,19,  8,9,10,11, 24,25,26,27};
 386
 387   vec_uint4 biteq;
 388   vec_uint4 aabs;
 389   vec_uint4 babs;
 390   vec_uint4 a_gt;
 391   vec_uint4 ahi_inf;
 392   vec_uint4 anan;
 393   vec_uint4 result;
 394
 395   union {
 396     vec_uchar16 v;
 397     int i[4];
 398   } x;
 399
 400   /* Shift 4 bytes  */
 401   x.i[3] = 4 << 3;
 402
 403   /*  Mask out sign bits */
 404   aabs = vec_and((vec_uint4)a,sign_mask);
 405   babs = vec_and((vec_uint4)b,sign_mask);
 406
 407   /*  A)  Check for bit equality, store in high word */
 408   biteq = (vec_uint4) vec_cmpeq((vec_uint4)aabs,(vec_uint4)babs);
 409   biteq = vec_and(biteq,(vec_uint4)vec_slo((vec_uchar16)biteq,x.v));
 410
 411   /*
 412       B)  Check if a is NaN, store in high word
 413
 414       B1) If the high word is greater than max_exp (indicates a NaN)
 415       B2) If the low word is greater than 0
 416   */
 417   a_gt = (vec_uint4)vec_cmpgt(aabs,nan_mask);
 418
 419   /*  B3) Check if the high word is equal to the inf exponent */
 420   ahi_inf = (vec_uint4)vec_cmpeq(aabs,nan_mask);
 421
 422   /*  anan = B1[hi] or (B2[lo] and B3[hi]) */
 423   anan = (vec_uint4)vec_or(a_gt,vec_and((vec_uint4)vec_slo((vec_uchar16)a_gt,x.v),ahi_inf));
 424
 425   /*  result = A and not B  */
 426   result = vec_andc(biteq, anan);
 427
 428   /*  Promote high words to 64 bits and return  */
 429   return ((qword)(vec_perm((vec_uchar16)result, (vec_uchar16)result, hihi_promote)));
 430 }
 431
 432
 433 /* Compare absolute greater than
 434  */
 435 static __inline qword si_fcmgt(qword a, qword b)
 436 {
 437   vec_float4 msb = (vec_float4)((vec_uint4){0x80000000, 0x80000000, 0x80000000, 0x80000000});
 438
 439   return ((qword)(vec_cmpgt(vec_andc((vec_float4)(a), msb),
 440                                   vec_andc((vec_float4)(b), msb))));
 441 }
 442
 443 static __inline qword si_dfcmgt(qword a, qword b)
 444 {
 445   vec_uchar16 splat_hi = (vec_uchar16) { 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
 446   vec_uint4 nan_mask = (vec_uint4) { 0x7FF00000, 0x0, 0x7FF00000, 0x0 };
 447   vec_uint4 sign_mask = (vec_uint4) { 0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
 448
 449   union {
 450     vec_uchar16 v;
 451     int i[4];
 452   } x;
 453
 454   /* Shift 4 bytes  */
 455   x.i[3] = 4 << 3;
 456
 457   // absolute value of a,b
 458   vec_uint4 aabs = vec_and((vec_uint4)a, sign_mask);
 459   vec_uint4 babs = vec_and((vec_uint4)b, sign_mask);
 460
 461   // check if a is nan
 462   vec_uint4 a_inf = (vec_uint4)vec_cmpeq(aabs, nan_mask);
 463   vec_uint4 a_nan = (vec_uint4)vec_cmpgt(aabs, nan_mask);
 464   a_nan = vec_or(a_nan, vec_and((vec_uint4)vec_slo((vec_uchar16)a_nan,x.v),a_inf));
 465   a_nan = (vec_uint4)vec_perm((vec_uchar16)a_nan, (vec_uchar16)a_nan, splat_hi);
 466
 467   // check if b is nan
 468   vec_uint4 b_inf = (vec_uint4)vec_cmpeq(babs, nan_mask);
 469   vec_uint4 b_nan = (vec_uint4)vec_cmpgt(babs, nan_mask);
 470   b_nan = vec_or(b_nan, vec_and((vec_uint4)vec_slo((vec_uchar16)b_nan,x.v),b_inf));
 471   b_nan = (vec_uint4)vec_perm((vec_uchar16)b_nan, (vec_uchar16)b_nan, splat_hi);
 472
 473   // A) Check if the exponents are different
 474   vec_uint4 gt_hi = (vec_uint4)vec_cmpgt(aabs,babs);
 475
 476   // B) Check if high word equal, and low word greater
 477   vec_uint4 gt_lo = (vec_uint4)vec_cmpgt((vec_uint4)aabs, (vec_uint4)babs);
 478   vec_uint4 eq = (vec_uint4)vec_cmpeq(aabs, babs);
 479   vec_uint4 eqgt = vec_and(eq,vec_slo(gt_lo,x.v));
 480
 481   //  If either A or B is true, return true (unless NaNs detected)
 482   vec_uint4 r = vec_or(gt_hi, eqgt);
 483
 484   // splat the high words of the comparison step
 485   r = (vec_uint4)vec_perm((vec_uchar16)r,(vec_uchar16)r,splat_hi);
 486
 487   // correct for NaNs in input
 488   return ((qword)vec_andc(r,vec_or(a_nan,b_nan)));
 489 }
 490
 491
 492 /* Compare equal
 493  */
 494 static __inline qword si_ceqb(qword a, qword b)
 495 {
 496   return ((qword)(vec_cmpeq((vec_uchar16)(a), (vec_uchar16)(b))));
 497 }
 498
 499 static __inline qword si_ceqh(qword a, qword b)
 500 {
 501   return ((qword)(vec_cmpeq((vec_ushort8)(a), (vec_ushort8)(b))));
 502 }
 503
 504 static __inline qword si_ceq(qword a, qword b)
 505 {
 506   return ((qword)(vec_cmpeq((vec_uint4)(a), (vec_uint4)(b))));
 507 }
 508
 509 static __inline qword si_fceq(qword a, qword b)
 510 {
 511   return ((qword)(vec_cmpeq((vec_float4)(a), (vec_float4)(b))));
 512 }
 513
 514 static __inline qword si_ceqbi(qword a, signed char b)
 515 {
 516   return ((qword)(vec_cmpeq((vec_char16)(a),
 517                             vec_splat((vec_char16)(si_from_char(b)), 3))));
 518 }
 519
 520 static __inline qword si_ceqhi(qword a, signed short b)
 521 {
 522   return ((qword)(vec_cmpeq((vec_short8)(a),
 523                           vec_splat((vec_short8)(si_from_short(b)), 1))));
 524 }
 525
 526 static __inline qword si_ceqi(qword a, signed int b)
 527 {
 528   return ((qword)(vec_cmpeq((vec_int4)(a),
 529                           vec_splat((vec_int4)(si_from_int(b)), 0))));
 530 }
 531
 532 static __inline qword si_dfceq(qword a, qword b)
 533 {
 534   vec_uint4 sign_mask= (vec_uint4) { 0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
 535   vec_uint4 nan_mask = (vec_uint4) { 0x7FF00000, 0x00000000, 0x7FF00000, 0x00000000 };
 536   vec_uchar16 hihi_promote = (vec_uchar16) { 0,1,2,3,  16,17,18,19,  8,9,10,11, 24,25,26,27};
 537
 538   vec_uint4 biteq;
 539   vec_uint4 aabs;
 540   vec_uint4 babs;
 541   vec_uint4 a_gt;
 542   vec_uint4 ahi_inf;
 543   vec_uint4 anan;
 544   vec_uint4 iszero;
 545   vec_uint4 result;
 546
 547   union {
 548     vec_uchar16 v;
 549     int i[4];
 550   } x;
 551
 552   /* Shift 4 bytes  */
 553   x.i[3] = 4 << 3;
 554
 555   /*  A)  Check for bit equality, store in high word */
 556   biteq = (vec_uint4) vec_cmpeq((vec_uint4)a,(vec_uint4)b);
 557   biteq = vec_and(biteq,(vec_uint4)vec_slo((vec_uchar16)biteq,x.v));
 558
 559   /*  Mask out sign bits */
 560   aabs = vec_and((vec_uint4)a,sign_mask);
 561   babs = vec_and((vec_uint4)b,sign_mask);
 562
 563   /*
 564       B)  Check if a is NaN, store in high word
 565
 566       B1) If the high word is greater than max_exp (indicates a NaN)
 567       B2) If the low word is greater than 0
 568   */
 569   a_gt = (vec_uint4)vec_cmpgt(aabs,nan_mask);
 570
 571   /*  B3) Check if the high word is equal to the inf exponent */
 572   ahi_inf = (vec_uint4)vec_cmpeq(aabs,nan_mask);
 573
 574   /*  anan = B1[hi] or (B2[lo] and B3[hi]) */
 575   anan = (vec_uint4)vec_or(a_gt,vec_and((vec_uint4)vec_slo((vec_uchar16)a_gt,x.v),ahi_inf));
 576
 577   /*  C)  Check for 0 = -0 special case */
 578   iszero =(vec_uint4)vec_cmpeq((vec_uint4)vec_or(aabs,babs),(vec_uint4)vec_splat_u32(0));
 579   iszero = vec_and(iszero,(vec_uint4)vec_slo((vec_uchar16)iszero,x.v));
 580
 581   /*  result = (A or C) and not B  */
 582   result = vec_or(biteq,iszero);
 583   result = vec_andc(result, anan);
 584
 585   /*  Promote high words to 64 bits and return  */
 586   return ((qword)(vec_perm((vec_uchar16)result, (vec_uchar16)result, hihi_promote)));
 587 }
 588
 589
 590 /* Compare greater than
 591  */
 592 static __inline qword si_cgtb(qword a, qword b)
 593 {
 594   return ((qword)(vec_cmpgt((vec_char16)(a), (vec_char16)(b))));
 595 }
 596
 597 static __inline qword si_cgth(qword a, qword b)
 598 {
 599   return ((qword)(vec_cmpgt((vec_short8)(a), (vec_short8)(b))));
 600 }
 601
 602 static __inline qword si_cgt(qword a, qword b)
 603 {
 604   return ((qword)(vec_cmpgt((vec_int4)(a), (vec_int4)(b))));
 605 }
 606
 607 static __inline qword si_clgtb(qword a, qword b)
 608 {
 609   return ((qword)(vec_cmpgt((vec_uchar16)(a), (vec_uchar16)(b))));
 610 }
 611
 612 static __inline qword si_clgth(qword a, qword b)
 613 {
 614   return ((qword)(vec_cmpgt((vec_ushort8)(a), (vec_ushort8)(b))));
 615 }
 616
 617 static __inline qword si_clgt(qword a, qword b)
 618 {
 619   return ((qword)(vec_cmpgt((vec_uint4)(a), (vec_uint4)(b))));
 620 }
 621
 622 static __inline qword si_fcgt(qword a, qword b)
 623 {
 624   return ((qword)(vec_cmpgt((vec_float4)(a), (vec_float4)(b))));
 625 }
 626
 627 static __inline qword si_dfcgt(qword a, qword b)
 628 {
 629   vec_uchar16 splat_hi = (vec_uchar16) { 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
 630   vec_uchar16 borrow_shuffle = (vec_uchar16) { 4,5,6,7, 192,192,192,192, 12,13,14,15, 192,192,192,192 };
 631   vec_uint4 nan_mask = (vec_uint4) { 0x7FF00000, 0x0, 0x7FF00000, 0x0 };
 632   vec_uint4 sign_mask = (vec_uint4) { 0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
 633
 634   union {
 635     vec_uchar16 v;
 636     int i[4];
 637   } x;
 638
 639   /* Shift 4 bytes  */
 640   x.i[3] = 4 << 3;
 641
 642   // absolute value of a,b
 643   vec_uint4 aabs = vec_and((vec_uint4)a, sign_mask);
 644   vec_uint4 babs = vec_and((vec_uint4)b, sign_mask);
 645
 646   // check if a is nan
 647   vec_uint4 a_inf = (vec_uint4)vec_cmpeq(aabs, nan_mask);
 648   vec_uint4 a_nan = (vec_uint4)vec_cmpgt(aabs, nan_mask);
 649   a_nan = vec_or(a_nan, vec_and((vec_uint4)vec_slo((vec_uchar16)a_nan,x.v),a_inf));
 650   a_nan = (vec_uint4)vec_perm((vec_uchar16)a_nan, (vec_uchar16)a_nan, splat_hi);
 651
 652   // check if b is nan
 653   vec_uint4 b_inf = (vec_uint4)vec_cmpeq(babs, nan_mask);
 654   vec_uint4 b_nan = (vec_uint4)vec_cmpgt(babs, nan_mask);
 655   b_nan = vec_or(b_nan, vec_and((vec_uint4)vec_slo((vec_uchar16)b_nan,x.v),b_inf));
 656   b_nan = (vec_uint4)vec_perm((vec_uchar16)b_nan, (vec_uchar16)b_nan, splat_hi);
 657
 658   // sign of a
 659   vec_uint4 asel = (vec_uint4)vec_sra((vec_int4)(a), (vec_uint4)vec_splat(((vec_uint4)si_from_int(31)), 0));
 660   asel = (vec_uint4)vec_perm((vec_uchar16)asel,(vec_uchar16)asel,splat_hi);
 661
 662   // sign of b
 663   vec_uint4 bsel = (vec_uint4)vec_sra((vec_int4)(b), (vec_uint4)vec_splat(((vec_uint4)si_from_int(31)), 0));
 664   bsel = (vec_uint4)vec_perm((vec_uchar16)bsel,(vec_uchar16)bsel,splat_hi);
 665
 666   // negative a
 667   vec_uint4 abor = vec_subc((vec_uint4)vec_splat_u32(0), aabs);
 668   vec_uchar16 pat = vec_sel(((vec_uchar16){0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15}), vec_sr(borrow_shuffle, vec_splat_u8(3)), vec_sra(borrow_shuffle, vec_splat_u8(7)));
 669   abor = (vec_uint4)(vec_perm(vec_perm((vec_uchar16)abor, (vec_uchar16)abor, borrow_shuffle),((vec_uchar16){0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80}),pat));
 670   vec_uint4 aneg = vec_add(vec_add(vec_splat_u32(0), vec_nor(aabs, aabs)), vec_and(abor, vec_splat_u32(1)));
 671
 672   // pick the one we want
 673   vec_int4 aval = (vec_int4)vec_sel((vec_uchar16)aabs, (vec_uchar16)aneg, (vec_uchar16)asel);
 674
 675   // negative b
 676   vec_uint4 bbor = vec_subc((vec_uint4)vec_splat_u32(0), babs);
 677   bbor = (vec_uint4)(vec_perm(vec_perm((vec_uchar16)bbor, (vec_uchar16)bbor, borrow_shuffle),((vec_uchar16){0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80}),pat));
 678   vec_uint4 bneg = vec_add(vec_nor(babs, babs), vec_and(bbor, vec_splat_u32(1)));
 679
 680   // pick the one we want
 681   vec_int4 bval=(vec_int4)vec_sel((vec_uchar16)babs, (vec_uchar16)bneg, (vec_uchar16)bsel);
 682
 683   // A) Check if the exponents are different
 684   vec_uint4 gt_hi = (vec_uint4)vec_cmpgt(aval,bval);
 685
 686   // B) Check if high word equal, and low word greater
 687   vec_uint4 gt_lo = (vec_uint4)vec_cmpgt((vec_uint4)aval, (vec_uint4)bval);
 688   vec_uint4 eq = (vec_uint4)vec_cmpeq(aval, bval);
 689   vec_uint4 eqgt = vec_and(eq,vec_slo(gt_lo,x.v));
 690
 691   //  If either A or B is true, return true (unless NaNs detected)
 692   vec_uint4 r = vec_or(gt_hi, eqgt);
 693
 694   // splat the high words of the comparison step
 695   r = (vec_uint4)vec_perm((vec_uchar16)r,(vec_uchar16)r,splat_hi);
 696
 697   // correct for NaNs in input
 698   return ((qword)vec_andc(r,vec_or(a_nan,b_nan)));
 699 }
 700
 701 static __inline qword si_cgtbi(qword a, signed char b)
 702 {
 703   return ((qword)(vec_cmpgt((vec_char16)(a),
 704                             vec_splat((vec_char16)(si_from_char(b)), 3))));
 705 }
 706
 707 static __inline qword si_cgthi(qword a, signed short b)
 708 {
 709   return ((qword)(vec_cmpgt((vec_short8)(a),
 710                             vec_splat((vec_short8)(si_from_short(b)), 1))));
 711 }
 712
 713 static __inline qword si_cgti(qword a, signed int b)
 714 {
 715   return ((qword)(vec_cmpgt((vec_int4)(a),
 716                             vec_splat((vec_int4)(si_from_int(b)), 0))));
 717 }
 718
 719 static __inline qword si_clgtbi(qword a, unsigned char b)
 720 {
 721   return ((qword)(vec_cmpgt((vec_uchar16)(a),
 722                             vec_splat((vec_uchar16)(si_from_uchar(b)), 3))));
 723 }
 724
 725 static __inline qword si_clgthi(qword a, unsigned short b)
 726 {
 727   return ((qword)(vec_cmpgt((vec_ushort8)(a),
 728                             vec_splat((vec_ushort8)(si_from_ushort(b)), 1))));
 729 }
 730
 731 static __inline qword si_clgti(qword a, unsigned int b)
 732 {
 733   return ((qword)(vec_cmpgt((vec_uint4)(a),
 734                             vec_splat((vec_uint4)(si_from_uint(b)), 0))));
 735 }
 736
 737 static __inline qword si_dftsv(qword a, char b)
 738 {
 739   vec_uchar16 splat_hi = (vec_uchar16) { 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
 740   vec_uint4 sign_mask = (vec_uint4) { 0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF };
 741   vec_uint4 result = (vec_uint4){0};
 742   vec_uint4 sign = (vec_uint4)vec_sra((vec_int4)(a), (vec_uint4)vec_splat(((vec_uint4)si_from_int(31)), 0));
 743   sign = (vec_uint4)vec_perm((vec_uchar16)sign,(vec_uchar16)sign,splat_hi);
 744   vec_uint4 aabs = vec_and((vec_uint4)a,sign_mask);
 745
 746   union {
 747     vec_uchar16 v;
 748     int i[4];
 749   } x;
 750
 751   /* Shift 4 bytes  */
 752   x.i[3] = 4 << 3;
 753
 754   /* Nan or +inf or -inf  */
 755   if (b & 0x70)
 756   {
 757     vec_uint4 nan_mask = (vec_uint4) { 0x7FF00000, 0x0, 0x7FF00000, 0x0 };
 758     vec_uint4 a_inf = (vec_uint4)vec_cmpeq(aabs, nan_mask);
 759      /* NaN  */
 760      if (b & 0x40)
 761      {
 762        vec_uint4 a_nan = (vec_uint4)vec_cmpgt(aabs, nan_mask);
 763        a_nan = vec_or(a_nan, vec_and((vec_uint4)vec_slo((vec_uchar16)a_nan,x.v),a_inf));
 764        a_nan = (vec_uint4)vec_perm((vec_uchar16)a_nan, (vec_uchar16)a_nan, splat_hi);
 765        result = vec_or(result, a_nan);
 766      }
 767      /* inf  */
 768      if (b & 0x30)
 769      {
 770        a_inf = vec_and((vec_uint4)vec_slo((vec_uchar16)a_inf,x.v), a_inf);
 771        a_inf = (vec_uint4)vec_perm((vec_uchar16)a_inf, (vec_uchar16)a_inf, splat_hi);
 772         /* +inf  */
 773         if (b & 0x20)
 774           result = vec_or(vec_andc(a_inf, sign), result);
 775         /* -inf  */
 776         if (b & 0x10)
 777           result = vec_or(vec_and(a_inf, sign), result);
 778      }
 779   }
 780   /* 0 or denorm  */
 781   if (b & 0xF)
 782   {
 783     vec_uint4 iszero =(vec_uint4)vec_cmpeq(aabs,(vec_uint4)vec_splat_u32(0));
 784     iszero = vec_and(iszero,(vec_uint4)vec_slo((vec_uchar16)iszero,x.v));
 785     /* denorm  */
 786     if (b & 0x3)
 787     {
 788       vec_uint4 denorm_mask = (vec_uint4){0xFFFFF, 0xFFFFF, 0xFFFFF, 0xFFFFF};
 789       vec_uint4 isdenorm = vec_nor((vec_uint4)vec_cmpgt(aabs, denorm_mask), iszero);
 790       isdenorm = (vec_uint4)vec_perm((vec_uchar16)isdenorm, (vec_uchar16)isdenorm, splat_hi);
 791       /* +denorm  */
 792      if (b & 0x2)
 793         result = vec_or(vec_andc(isdenorm, sign), result);
 794       /* -denorm  */
 795      if (b & 0x1)
 796         result = vec_or(vec_and(isdenorm, sign), result);
 797     }
 798     /* 0  */
 799     if (b & 0xC)
 800     {
 801       iszero = (vec_uint4)vec_perm((vec_uchar16)iszero, (vec_uchar16)iszero, splat_hi);
 802       /* +0  */
 803      if (b & 0x8)
 804         result = vec_or(vec_andc(iszero, sign), result);
 805       /* -0  */
 806      if (b & 0x4)
 807         result = vec_or(vec_and(iszero, sign), result);
 808     }
 809   }
 810   return ((qword)result);
 811 }
 812
 813
 814 /* Carry generate
 815  */
 816 #define si_cg(_a, _b)           ((qword)(vec_addc((vec_uint4)(_a), (vec_uint4)(_b))))
 817
 818 #define si_cgx(_a, _b, _c)      ((qword)(vec_or(vec_addc((vec_uint4)(_a), (vec_uint4)(_b)),             \
 819                                                 vec_addc(vec_add((vec_uint4)(_a), (vec_uint4)(_b)),     \
 820                                                          vec_and((vec_uint4)(_c), vec_splat_u32(1))))))
 821
 822
 823 /* Count ones for bytes
 824  */
 825 static __inline qword si_cntb(qword a)
 826 {
 827   vec_uchar16 nib_cnt = (vec_uchar16){0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
 828   vec_uchar16 four = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
 829   vec_uchar16 av;
 830
 831   av = (vec_uchar16)(a);
 832
 833   return ((qword)(vec_add(vec_perm(nib_cnt, nib_cnt, av),
 834                           vec_perm(nib_cnt, nib_cnt, vec_sr (av, four)))));
 835 }
 836
 837 /* Count ones for bytes
 838  */
 839 static __inline qword si_clz(qword a)
 840 {
 841   vec_uchar16 av;
 842   vec_uchar16 cnt_hi, cnt_lo, cnt, tmp1, tmp2, tmp3;
 843   vec_uchar16 four    = vec_splat_u8(4);
 844   vec_uchar16 nib_cnt = (vec_uchar16){4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 845   vec_uchar16 eight   = vec_splat_u8(8);
 846   vec_uchar16 sixteen = (vec_uchar16){16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16};
 847   vec_uchar16 twentyfour = (vec_uchar16){24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24};
 848
 849   av = (vec_uchar16)(a);
 850
 851   cnt_hi = vec_perm(nib_cnt, nib_cnt, vec_sr(av, four));
 852   cnt_lo = vec_perm(nib_cnt, nib_cnt, av);
 853
 854   cnt = vec_add(cnt_hi, vec_and(cnt_lo, vec_cmpeq(cnt_hi, four)));
 855
 856   tmp1 = (vec_uchar16)vec_sl((vec_uint4)(cnt), (vec_uint4)(eight));
 857   tmp2 = (vec_uchar16)vec_sl((vec_uint4)(cnt), (vec_uint4)(sixteen));
 858   tmp3 = (vec_uchar16)vec_sl((vec_uint4)(cnt), (vec_uint4)(twentyfour));
 859
 860   cnt = vec_add(cnt, vec_and(tmp1, vec_cmpeq(cnt, eight)));
 861   cnt = vec_add(cnt, vec_and(tmp2, vec_cmpeq(cnt, sixteen)));
 862   cnt = vec_add(cnt, vec_and(tmp3, vec_cmpeq(cnt, twentyfour)));
 863
 864   return (qword)((vec_sr((vec_uint4)(cnt), (vec_uint4)(twentyfour))));
 865 }
 866
 867 /* Convert to float
 868  */
 869 #define si_cuflt(_a, _b)        ((qword)(vec_ctf((vec_uint4)(_a), _b)))
 870 #define si_csflt(_a, _b)        ((qword)(vec_ctf((vec_int4)(_a), _b)))
 871
 872 /* Convert to signed int
 873  */
 874 #define si_cflts(_a, _b)        ((qword)(vec_cts((vec_float4)(_a), _b)))
 875
 876 /* Convert to unsigned int
 877  */
 878 #define si_cfltu(_a, _b)        ((qword)(vec_ctu((vec_float4)(_a), _b)))
 879
 880 /* Synchronize
 881  */
 882 #define si_dsync()              /* do nothing */
 883 #define si_sync()               /* do nothing */
 884 #define si_syncc()              /* do nothing */
 885
 886
 887 /* Equivalence
 888  */
 889 static __inline qword si_eqv(qword a, qword b)
 890 {
 891   vec_uchar16 d;
 892
 893   d = vec_xor((vec_uchar16)(a), (vec_uchar16)(b));
 894   return ((qword)(vec_nor(d, d)));
 895 }
 896
 897 /* Extend
 898  */
 899 static __inline qword si_xsbh(qword a)
 900 {
 901   vec_char16 av;
 902
 903   av = (vec_char16)(a);
 904   return ((qword)(vec_unpackh(vec_perm(av, av, ((vec_uchar16){1, 3, 5, 7, 9,11,13,15,
 905                                                               0, 0, 0, 0, 0, 0, 0, 0})))));
 906 }
 907
 908 static __inline qword si_xshw(qword a)
 909 {
 910   vec_short8 av;
 911
 912   av = (vec_short8)(a);
 913   return ((qword)(vec_unpackh(vec_perm(av, av, ((vec_uchar16){2, 3, 6, 7,
 914                                                               10,11,14,15,
 915                                                               0, 0, 0, 0,
 916                                                               0, 0, 0, 0})))));
 917 }
 918
 919 static __inline qword si_xswd(qword a)
 920 {
 921   vec_int4 av;
 922
 923   av = (vec_int4)(a);
 924   return ((qword)(vec_perm(av, vec_sra(av, ((vec_uint4){31,31,31,31})),
 925                            ((vec_uchar16){20, 21, 22, 23,
 926                                            4,  5,  6,  7,
 927                                           28, 29, 30, 31,
 928                                           12, 13, 14, 15}))));
 929 }
 930
 931 static __inline qword si_fesd(qword a)
 932 {
 933   union {
 934     double d[2];
 935     vec_double2 vd;
 936   } out;
 937   union {
 938     float f[4];
 939     vec_float4 vf;
 940   } in;
 941
 942   in.vf = (vec_float4)(a);
 943   out.d[0] = (double)(in.f[0]);
 944   out.d[1] = (double)(in.f[2]);
 945   return ((qword)(out.vd));
 946 }
 947
 948 /* Gather
 949  */
 950 static __inline qword si_gbb(qword a)
 951 {
 952   vec_uchar16 bits;
 953   vec_uint4   bytes;
 954
 955   bits  = vec_sl(vec_and((vec_uchar16)(a), vec_splat_u8(1)), ((vec_uchar16){7, 6, 5, 4, 3, 2, 1, 0,
 956                                                                             7, 6, 5, 4, 3, 2, 1, 0}));
 957   bytes = (vec_uint4)vec_sum2s((vec_int4)(vec_sum4s(bits, ((vec_uint4){0}))), ((vec_int4){0}));
 958
 959   return ((qword)(vec_perm(bytes, bytes, ((vec_uchar16){0, 0, 7,15, 0, 0, 0, 0,
 960                                                         0, 0, 0, 0, 0, 0, 0, 0}))));
 961 }
 962
 963
 964 static __inline qword si_gbh(qword a)
 965 {
 966   vec_ushort8 bits;
 967   vec_uint4   bytes;
 968
 969   bits  = vec_sl(vec_and((vec_ushort8)(a), vec_splat_u16(1)), ((vec_ushort8){7, 6, 5, 4, 3, 2, 1, 0}));
 970
 971   bytes = (vec_uint4)vec_sums((vec_int4)(vec_sum4s((vec_short8)(bits), (vec_int4){0})), (vec_int4){0});
 972
 973   return ((qword)(vec_sld(bytes, bytes, 12)));
 974 }
 975
 976 static __inline qword si_gb(qword a)
 977 {
 978   vec_uint4 bits;
 979   vec_uint4 bytes;
 980
 981   bits  = vec_sl(vec_and((vec_uint4)(a), vec_splat_u32(1)), ((vec_uint4){3, 2, 1, 0}));
 982   bytes = (vec_uint4)vec_sums((vec_int4)(bits), ((vec_int4){0}));
 983   return ((qword)(vec_sld(bytes, bytes, 12)));
 984 }
 985
 986
 987 /* Compare and halt
 988  */
 989 static __inline void si_heq(qword a, qword b)
 990 {
 991   union {
 992     vector unsigned int v;
 993     unsigned int i[4];
 994   } aa, bb;
 995
 996   aa.v = (vector unsigned int)(a);
 997   bb.v = (vector unsigned int)(b);
 998
 999   if (aa.i[0] == bb.i[0]) { SPU_HALT_ACTION; };
1000 }
1001
1002 static __inline void si_heqi(qword a, unsigned int b)
1003 {
1004   union {
1005     vector unsigned int v;
1006     unsigned int i[4];
1007   } aa;
1008
1009   aa.v = (vector unsigned int)(a);
1010
1011   if (aa.i[0] == b) { SPU_HALT_ACTION; };
1012 }
1013
1014 static __inline void si_hgt(qword a, qword b)
1015 {
1016   union {
1017     vector signed int v;
1018     signed int i[4];
1019   } aa, bb;
1020
1021   aa.v = (vector signed int)(a);
1022   bb.v = (vector signed int)(b);
1023
1024   if (aa.i[0] > bb.i[0]) { SPU_HALT_ACTION; };
1025 }
1026
1027 static __inline void si_hgti(qword a, signed int b)
1028 {
1029   union {
1030     vector signed int v;
1031     signed int i[4];
1032   } aa;
1033
1034   aa.v = (vector signed int)(a);
1035
1036   if (aa.i[0] > b) { SPU_HALT_ACTION; };
1037 }
1038
1039 static __inline void si_hlgt(qword a, qword b)
1040 {
1041   union {
1042     vector unsigned int v;
1043     unsigned int i[4];
1044   } aa, bb;
1045
1046   aa.v = (vector unsigned int)(a);
1047   bb.v = (vector unsigned int)(b);
1048
1049   if (aa.i[0] > bb.i[0]) { SPU_HALT_ACTION; };
1050 }
1051
1052 static __inline void si_hlgti(qword a, unsigned int b)
1053 {
1054   union {
1055     vector unsigned int v;
1056     unsigned int i[4];
1057   } aa;
1058
1059   aa.v = (vector unsigned int)(a);
1060
1061   if (aa.i[0] > b) { SPU_HALT_ACTION; };
1062 }
1063
1064
1065 /* Multiply and Add
1066  */
1067 static __inline qword si_mpya(qword a, qword b, qword c)
1068 {
1069   return ((qword)(vec_msum(vec_and((vec_short8)(a),
1070                                    ((vec_short8){0, -1, 0, -1, 0, -1, 0, -1})),
1071                            (vec_short8)(b), (vec_int4)(c))));
1072 }
1073
1074 static __inline qword si_fma(qword a, qword b, qword c)
1075 {
1076   return ((qword)(vec_madd((vec_float4)(a), (vec_float4)(b), (vec_float4)(c))));
1077 }
1078
1079 static __inline qword si_dfma(qword a, qword b, qword c)
1080 {
1081   union {
1082     vec_double2 v;
1083     double d[2];
1084   } aa, bb, cc, dd;
1085
1086   aa.v = (vec_double2)(a);
1087   bb.v = (vec_double2)(b);
1088   cc.v = (vec_double2)(c);
1089   dd.d[0] = aa.d[0] * bb.d[0] + cc.d[0];
1090   dd.d[1] = aa.d[1] * bb.d[1] + cc.d[1];
1091   return ((qword)(dd.v));
1092 }
1093
1094 /* Form Mask
1095  */
1096 #define si_fsmbi(_a)    si_fsmb(si_from_int(_a))
1097
1098 static __inline qword si_fsmb(qword a)
1099 {
1100   vec_char16 mask;
1101   vec_ushort8 in;
1102
1103   in = (vec_ushort8)(a);
1104   mask = (vec_char16)(vec_perm(in, in, ((vec_uchar16){2, 2, 2, 2, 2, 2, 2, 2,
1105                                                       3, 3, 3, 3, 3, 3, 3, 3})));
1106   return ((qword)(vec_sra(vec_sl(mask, ((vec_uchar16){0, 1, 2, 3, 4, 5, 6, 7,
1107                                                       0, 1, 2, 3, 4, 5, 6, 7})),
1108                           vec_splat_u8(7))));
1109 }
1110
1111
1112 static __inline qword si_fsmh(qword a)
1113 {
1114   vec_uchar16 in;
1115   vec_short8 mask;
1116
1117   in = (vec_uchar16)(a);
1118   mask = (vec_short8)(vec_splat(in, 3));
1119   return ((qword)(vec_sra(vec_sl(mask, ((vec_ushort8){0, 1, 2, 3, 4, 5, 6, 7})),
1120                           vec_splat_u16(15))));
1121 }
1122
1123 static __inline qword si_fsm(qword a)
1124 {
1125   vec_uchar16 in;
1126   vec_int4 mask;
1127
1128   in = (vec_uchar16)(a);
1129   mask = (vec_int4)(vec_splat(in, 3));
1130   return ((qword)(vec_sra(vec_sl(mask, ((vec_uint4){28, 29, 30, 31})),
1131                           ((vec_uint4){31,31,31,31}))));
1132 }
1133
1134 /* Move from/to registers
1135  */
1136 #define si_fscrrd()             ((qword)((vec_uint4){0}))
1137 #define si_fscrwr(_a)
1138
1139 #define si_mfspr(_reg)          ((qword)((vec_uint4){0}))
1140 #define si_mtspr(_reg, _a)
1141
1142 /* Multiply High High Add
1143  */
1144 static __inline qword si_mpyhha(qword a, qword b, qword c)
1145 {
1146   return ((qword)(vec_add(vec_mule((vec_short8)(a), (vec_short8)(b)), (vec_int4)(c))));
1147 }
1148
1149 static __inline qword si_mpyhhau(qword a, qword b, qword c)
1150 {
1151   return ((qword)(vec_add(vec_mule((vec_ushort8)(a), (vec_ushort8)(b)), (vec_uint4)(c))));
1152 }
1153
1154 /* Multiply Subtract
1155  */
1156 static __inline qword si_fms(qword a, qword b, qword c)
1157 {
1158   return ((qword)(vec_madd((vec_float4)(a), (vec_float4)(b),
1159                            vec_sub(((vec_float4){0.0f}), (vec_float4)(c)))));
1160 }
1161
1162 static __inline qword si_dfms(qword a, qword b, qword c)
1163 {
1164   union {
1165     vec_double2 v;
1166     double d[2];
1167   } aa, bb, cc, dd;
1168
1169   aa.v = (vec_double2)(a);
1170   bb.v = (vec_double2)(b);
1171   cc.v = (vec_double2)(c);
1172   dd.d[0] = aa.d[0] * bb.d[0] - cc.d[0];
1173   dd.d[1] = aa.d[1] * bb.d[1] - cc.d[1];
1174   return ((qword)(dd.v));
1175 }
1176
1177 /* Multiply
1178  */
1179 static __inline qword si_fm(qword a, qword b)
1180 {
1181   return ((qword)(vec_madd((vec_float4)(a), (vec_float4)(b), ((vec_float4){0.0f}))));
1182 }
1183
1184 static __inline qword si_dfm(qword a, qword b)
1185 {
1186   union {
1187     vec_double2 v;
1188     double d[2];
1189   } aa, bb, dd;
1190
1191   aa.v = (vec_double2)(a);
1192   bb.v = (vec_double2)(b);
1193   dd.d[0] = aa.d[0] * bb.d[0];
1194   dd.d[1] = aa.d[1] * bb.d[1];
1195   return ((qword)(dd.v));
1196 }
1197
1198 /* Multiply High
1199  */
1200 static __inline qword si_mpyh(qword a, qword b)
1201 {
1202   vec_uint4 sixteen = (vec_uint4){16, 16, 16, 16};
1203
1204   return ((qword)(vec_sl(vec_mule((vec_short8)(a), (vec_short8)(vec_sl((vec_uint4)(b), sixteen))), sixteen)));
1205 }
1206
1207
1208 /* Multiply High High
1209  */
1210 static __inline qword si_mpyhh(qword a, qword b)
1211 {
1212   return ((qword)(vec_mule((vec_short8)(a), (vec_short8)(b))));
1213 }
1214
1215 static __inline qword si_mpyhhu(qword a, qword b)
1216 {
1217   return ((qword)(vec_mule((vec_ushort8)(a), (vec_ushort8)(b))));
1218 }
1219
1220 /* Multiply Odd
1221  */
1222 static __inline qword si_mpy(qword a, qword b)
1223 {
1224   return ((qword)(vec_mulo((vec_short8)(a), (vec_short8)(b))));
1225 }
1226
1227 static __inline qword si_mpyu(qword a, qword b)
1228 {
1229   return ((qword)(vec_mulo((vec_ushort8)(a), (vec_ushort8)(b))));
1230 }
1231
1232 static __inline qword si_mpyi(qword a, short b)
1233 {
1234   return ((qword)(vec_mulo((vec_short8)(a),
1235                            vec_splat((vec_short8)(si_from_short(b)), 1))));
1236 }
1237
1238 static __inline qword si_mpyui(qword a, unsigned short b)
1239 {
1240   return ((qword)(vec_mulo((vec_ushort8)(a),
1241                            vec_splat((vec_ushort8)(si_from_ushort(b)), 1))));
1242 }
1243
1244 /* Multiply and Shift Right
1245  */
1246 static __inline qword si_mpys(qword a, qword b)
1247 {
1248   return ((qword)(vec_sra(vec_mulo((vec_short8)(a), (vec_short8)(b)), ((vec_uint4){16,16,16,16}))));
1249 }
1250
1251 /* Nand
1252  */
1253 static __inline qword si_nand(qword a, qword b)
1254 {
1255   vec_uchar16 d;
1256
1257   d = vec_and((vec_uchar16)(a), (vec_uchar16)(b));
1258   return ((qword)(vec_nor(d, d)));
1259 }
1260
1261 /* Negative Multiply Add
1262  */
1263 static __inline qword si_dfnma(qword a, qword b, qword c)
1264 {
1265   union {
1266     vec_double2 v;
1267     double d[2];
1268   } aa, bb, cc, dd;
1269
1270   aa.v = (vec_double2)(a);
1271   bb.v = (vec_double2)(b);
1272   cc.v = (vec_double2)(c);
1273   dd.d[0] = -cc.d[0] - aa.d[0] * bb.d[0];
1274   dd.d[1] = -cc.d[1] - aa.d[1] * bb.d[1];
1275   return ((qword)(dd.v));
1276 }
1277
1278 /* Negative Multiply and Subtract
1279  */
1280 static __inline qword si_fnms(qword a, qword b, qword c)
1281 {
1282   return ((qword)(vec_nmsub((vec_float4)(a), (vec_float4)(b), (vec_float4)(c))));
1283 }
1284
1285 static __inline qword si_dfnms(qword a, qword b, qword c)
1286 {
1287   union {
1288     vec_double2 v;
1289     double d[2];
1290   } aa, bb, cc, dd;
1291
1292   aa.v = (vec_double2)(a);
1293   bb.v = (vec_double2)(b);
1294   cc.v = (vec_double2)(c);
1295   dd.d[0] = cc.d[0] - aa.d[0] * bb.d[0];
1296   dd.d[1] = cc.d[1] - aa.d[1] * bb.d[1];
1297   return ((qword)(dd.v));
1298 }
1299
1300 /* Nor
1301  */
1302 static __inline qword si_nor(qword a, qword b)
1303 {
1304   return ((qword)(vec_nor((vec_uchar16)(a), (vec_uchar16)(b))));
1305 }
1306
1307 /* Or
1308  */
1309 static __inline qword si_or(qword a, qword b)
1310 {
1311   return ((qword)(vec_or((vec_uchar16)(a), (vec_uchar16)(b))));
1312 }
1313
1314 static __inline qword si_orbi(qword a, unsigned char b)
1315 {
1316   return ((qword)(vec_or((vec_uchar16)(a),
1317                          vec_splat((vec_uchar16)(si_from_uchar(b)), 3))));
1318 }
1319
1320 static __inline qword si_orhi(qword a, unsigned short b)
1321 {
1322   return ((qword)(vec_or((vec_ushort8)(a),
1323                           vec_splat((vec_ushort8)(si_from_ushort(b)), 1))));
1324 }
1325
1326 static __inline qword si_ori(qword a, unsigned int b)
1327 {
1328   return ((qword)(vec_or((vec_uint4)(a),
1329                           vec_splat((vec_uint4)(si_from_uint(b)), 0))));
1330 }
1331
1332 /* Or Complement
1333  */
1334 static __inline qword si_orc(qword a, qword b)
1335 {
1336   return ((qword)(vec_or((vec_uchar16)(a), vec_nor((vec_uchar16)(b), (vec_uchar16)(b)))));
1337 }
1338
1339
1340 /* Or Across
1341  */
1342 static __inline qword si_orx(qword a)
1343 {
1344   vec_uchar16 tmp;
1345   tmp = (vec_uchar16)(a);
1346   tmp = vec_or(tmp, vec_sld(tmp, tmp, 8));
1347   tmp = vec_or(tmp, vec_sld(tmp, tmp, 4));
1348   return ((qword)(vec_and(tmp, ((vec_uchar16){0xFF,0xFF,0xFF,0xFF, 0x00,0x00,0x00,0x00,
1349                                               0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00}))));
1350 }
1351
1352
1353 /* Estimates
1354  */
1355 static __inline qword si_frest(qword a)
1356 {
1357   return ((qword)(vec_re((vec_float4)(a))));
1358 }
1359
1360 static __inline qword si_frsqest(qword a)
1361 {
1362   return ((qword)(vec_rsqrte((vec_float4)(a))));
1363 }
1364
1365 #define si_fi(_a, _d)           (_d)
1366
1367 /* Channel Read and Write
1368  */
1369 #define si_rdch(_channel)               ((qword)(vec_splat_u8(0)))      /* not mappable */
1370 #define si_rchcnt(_channel)             ((qword)(vec_splat_u8(0)))      /* not mappable */
1371 #define si_wrch(_channel, _a)           /* not mappable */
1372
1373 /* Rotate Left
1374  */
1375 static __inline qword si_roth(qword a, qword b)
1376 {
1377   return ((qword)(vec_rl((vec_ushort8)(a), (vec_ushort8)(b))));
1378 }
1379
1380 static __inline qword si_rot(qword a, qword b)
1381 {
1382   return ((qword)(vec_rl((vec_uint4)(a), (vec_uint4)(b))));
1383 }
1384
1385 static __inline qword si_rothi(qword a, int b)
1386 {
1387   return ((qword)(vec_rl((vec_ushort8)(a),
1388                          vec_splat((vec_ushort8)(si_from_int(b)), 1))));
1389 }
1390
1391 static __inline qword si_roti(qword a, int b)
1392 {
1393   return ((qword)(vec_rl((vec_uint4)(a),
1394                          vec_splat((vec_uint4)(si_from_int(b)), 0))));
1395 }
1396
1397 /* Rotate Left with Mask
1398  */
1399 static __inline qword si_rothm(qword a, qword b)
1400 {
1401   vec_ushort8 neg_b;
1402   vec_ushort8 mask;
1403
1404   neg_b = (vec_ushort8)vec_sub(vec_splat_s16(0), (vec_short8)(b));
1405   mask = vec_sra(vec_sl(neg_b, vec_splat_u16(11)), vec_splat_u16(15));
1406   return ((qword)(vec_andc(vec_sr((vec_ushort8)(a), neg_b), mask)));
1407 }
1408
1409 static __inline qword si_rotm(qword a, qword b)
1410 {
1411   vec_uint4 neg_b;
1412   vec_uint4 mask;
1413
1414   neg_b = (vec_uint4)vec_sub(vec_splat_s32(0), (vec_int4)(b));
1415   mask = vec_sra(vec_sl(neg_b, ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1416   return ((qword)(vec_andc(vec_sr((vec_uint4)(a), neg_b), mask)));
1417 }
1418
1419 static __inline qword si_rothmi(qword a, int b)
1420 {
1421   vec_ushort8 neg_b;
1422   vec_ushort8 mask;
1423
1424   neg_b = vec_splat((vec_ushort8)(si_from_int(-b)), 1);
1425   mask = vec_sra(vec_sl(neg_b, vec_splat_u16(11)), vec_splat_u16(15));
1426   return ((qword)(vec_andc(vec_sr((vec_ushort8)(a), neg_b), mask)));
1427 }
1428
1429 static __inline qword si_rotmi(qword a, int b)
1430 {
1431   vec_uint4 neg_b;
1432   vec_uint4 mask;
1433
1434   neg_b = vec_splat((vec_uint4)(si_from_int(-b)), 0);
1435   mask = vec_sra(vec_sl(neg_b, ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1436   return ((qword)(vec_andc(vec_sr((vec_uint4)(a), neg_b), mask)));
1437 }
1438
1439
1440 /* Rotate Left Algebraic with Mask
1441  */
1442 static __inline qword si_rotmah(qword a, qword b)
1443 {
1444   vec_ushort8 neg_b;
1445   vec_ushort8 mask;
1446
1447   neg_b = (vec_ushort8)vec_sub(vec_splat_s16(0), (vec_short8)(b));
1448   mask = vec_sra(vec_sl(neg_b, vec_splat_u16(11)), vec_splat_u16(15));
1449   return ((qword)(vec_sra((vec_short8)(a), (vec_ushort8)vec_or(neg_b, mask))));
1450 }
1451
1452 static __inline qword si_rotma(qword a, qword b)
1453 {
1454   vec_uint4 neg_b;
1455   vec_uint4 mask;
1456
1457   neg_b = (vec_uint4)vec_sub(vec_splat_s32(0), (vec_int4)(b));
1458   mask = vec_sra(vec_sl(neg_b, ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1459   return ((qword)(vec_sra((vec_int4)(a), (vec_uint4)vec_or(neg_b, mask))));
1460 }
1461
1462
1463 static __inline qword si_rotmahi(qword a, int b)
1464 {
1465   vec_ushort8 neg_b;
1466   vec_ushort8 mask;
1467
1468   neg_b = vec_splat((vec_ushort8)(si_from_int(-b)), 1);
1469   mask = vec_sra(vec_sl(neg_b, vec_splat_u16(11)), vec_splat_u16(15));
1470   return ((qword)(vec_sra((vec_short8)(a), (vec_ushort8)vec_or(neg_b, mask))));
1471 }
1472
1473 static __inline qword si_rotmai(qword a, int b)
1474 {
1475   vec_uint4 neg_b;
1476   vec_uint4 mask;
1477
1478   neg_b = vec_splat((vec_uint4)(si_from_int(-b)), 0);
1479   mask = vec_sra(vec_sl(neg_b, ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1480   return ((qword)(vec_sra((vec_int4)(a), (vec_uint4)vec_or(neg_b, mask))));
1481 }
1482
1483
1484 /* Rotate Left Quadword by Bytes with Mask
1485  */
1486 static __inline qword si_rotqmbyi(qword a, int count)
1487 {
1488   union {
1489     vec_uchar16 v;
1490     int i[4];
1491   } x;
1492   vec_uchar16 mask;
1493
1494   count = 0 - count;
1495   x.i[3] = count << 3;
1496   mask = (count & 0x10) ? vec_splat_u8(0) : vec_splat_u8(-1);
1497
1498   return ((qword)(vec_and(vec_sro((vec_uchar16)(a), x.v), mask)));
1499 }
1500
1501
1502 static __inline qword si_rotqmby(qword a, qword count)
1503 {
1504   union {
1505     vec_uchar16 v;
1506     int i[4];
1507   } x;
1508   int cnt;
1509   vec_uchar16 mask;
1510
1511   x.v = (vec_uchar16)(count);
1512   x.i[0] = cnt = (0 - x.i[0]) << 3;
1513
1514   x.v = vec_splat(x.v, 3);
1515   mask = (cnt & 0x80) ? vec_splat_u8(0) : vec_splat_u8(-1);
1516
1517   return ((qword)(vec_and(vec_sro((vec_uchar16)(a), x.v), mask)));
1518 }
1519
1520
1521 /* Rotate Left Quadword by Bytes
1522  */
1523 static __inline qword si_rotqbyi(qword a, int count)
1524 {
1525   union {
1526     vec_uchar16 v;
1527     int i[4];
1528   } left, right;
1529
1530   count <<= 3;
1531   left.i[3] = count;
1532   right.i[3] = 0 - count;
1533   return ((qword)(vec_or(vec_slo((vec_uchar16)(a), left.v), vec_sro((vec_uchar16)(a), right.v))));
1534 }
1535
1536 static __inline qword si_rotqby(qword a, qword count)
1537 {
1538   vec_uchar16 left, right;
1539
1540   left = vec_sl(vec_splat((vec_uchar16)(count), 3), vec_splat_u8(3));
1541   right = vec_sub(vec_splat_u8(0), left);
1542   return ((qword)(vec_or(vec_slo((vec_uchar16)(a), left), vec_sro((vec_uchar16)(a), right))));
1543 }
1544
1545 /* Rotate Left Quadword by Bytes Bit Count
1546  */
1547 static __inline qword si_rotqbybi(qword a, qword count)
1548 {
1549   vec_uchar16 left, right;
1550
1551   left = vec_splat((vec_uchar16)(count), 3);
1552   right = vec_sub(vec_splat_u8(7), left);
1553   return ((qword)(vec_or(vec_slo((vec_uchar16)(a), left), vec_sro((vec_uchar16)(a), right))));
1554 }
1555
1556
1557 /* Rotate Left Quadword by Bytes Bit Count
1558  */
1559 static __inline qword si_rotqbii(qword a, int count)
1560 {
1561   vec_uchar16 x, y;
1562   vec_uchar16 result;
1563
1564   x = vec_splat((vec_uchar16)(si_from_int(count & 7)), 3);
1565   y = (vec_uchar16)(vec_sr((vec_uint4)vec_sro((vec_uchar16)(a), ((vec_uchar16)((vec_uint4){0,0,0,120}))),
1566                            (vec_uint4)vec_sub(vec_splat_u8(8), x)));
1567   result = vec_or(vec_sll((qword)(a), x), y);
1568   return ((qword)(result));
1569 }
1570
1571 static __inline qword si_rotqbi(qword a, qword count)
1572 {
1573   vec_uchar16 x, y;
1574   vec_uchar16 result;
1575
1576   x = vec_and(vec_splat((vec_uchar16)(count), 3), vec_splat_u8(7));
1577   y = (vec_uchar16)(vec_sr((vec_uint4)vec_sro((vec_uchar16)(a), ((vec_uchar16)((vec_uint4){0,0,0,120}))),
1578                            (vec_uint4)vec_sub(vec_splat_u8(8), x)));
1579
1580   result = vec_or(vec_sll((qword)(a), x), y);
1581   return ((qword)(result));
1582 }
1583
1584
1585 /* Rotate Left Quadword and Mask by Bits
1586  */
1587 static __inline qword si_rotqmbii(qword a, int count)
1588 {
1589   return ((qword)(vec_srl((vec_uchar16)(a), vec_splat((vec_uchar16)(si_from_int(0 - count)), 3))));
1590 }
1591
1592 static __inline qword si_rotqmbi(qword a, qword count)
1593 {
1594   return ((qword)(vec_srl((vec_uchar16)(a), vec_sub(vec_splat_u8(0), vec_splat((vec_uchar16)(count), 3)))));
1595 }
1596
1597
1598 /* Rotate Left Quadword and Mask by Bytes with Bit Count
1599  */
1600 static __inline qword si_rotqmbybi(qword a, qword count)
1601 {
1602   union {
1603     vec_uchar16 v;
1604     int i[4];
1605   } x;
1606   int cnt;
1607   vec_uchar16 mask;
1608
1609   x.v = (vec_uchar16)(count);
1610   x.i[0] = cnt = 0 - (x.i[0] & ~7);
1611   x.v = vec_splat(x.v, 3);
1612   mask = (cnt & 0x80) ? vec_splat_u8(0) : vec_splat_u8(-1);
1613
1614   return ((qword)(vec_and(vec_sro((vec_uchar16)(a), x.v), mask)));
1615 }
1616
1617
1618
1619
1620 /* Round Double to Float
1621  */
1622 static __inline qword si_frds(qword a)
1623 {
1624   union {
1625     vec_float4 v;
1626     float f[4];
1627   } d;
1628   union {
1629     vec_double2 v;
1630     double d[2];
1631   } in;
1632
1633   in.v = (vec_double2)(a);
1634   d.v = (vec_float4){0.0f};
1635   d.f[0] = (float)in.d[0];
1636   d.f[2] = (float)in.d[1];
1637
1638   return ((qword)(d.v));
1639 }
1640
1641 /* Select Bits
1642  */
1643 static __inline qword si_selb(qword a, qword b, qword c)
1644 {
1645   return ((qword)(vec_sel((vec_uchar16)(a), (vec_uchar16)(b), (vec_uchar16)(c))));
1646 }
1647
1648
1649 /* Shuffle Bytes
1650  */
1651 static __inline qword si_shufb(qword a, qword b, qword pattern)
1652 {
1653   vec_uchar16 pat;
1654
1655   pat = vec_sel(((vec_uchar16){0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15}),
1656                 vec_sr((vec_uchar16)(pattern), vec_splat_u8(3)),
1657                 vec_sra((vec_uchar16)(pattern), vec_splat_u8(7)));
1658   return ((qword)(vec_perm(vec_perm(a, b, pattern),
1659                            ((vec_uchar16){0, 0, 0, 0, 0, 0, 0, 0,
1660                                           0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80}),
1661                            pat)));
1662 }
1663
1664
1665 /* Shift Left
1666  */
1667 static __inline qword si_shlh(qword a, qword b)
1668 {
1669   vec_ushort8 mask;
1670
1671   mask = (vec_ushort8)vec_sra(vec_sl((vec_ushort8)(b), vec_splat_u16(11)), vec_splat_u16(15));
1672   return ((qword)(vec_andc(vec_sl((vec_ushort8)(a), (vec_ushort8)(b)), mask)));
1673 }
1674
1675 static __inline qword si_shl(qword a, qword b)
1676 {
1677   vec_uint4 mask;
1678
1679   mask = (vec_uint4)vec_sra(vec_sl((vec_uint4)(b), ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1680   return ((qword)(vec_andc(vec_sl((vec_uint4)(a), (vec_uint4)(b)), mask)));
1681 }
1682
1683
1684 static __inline qword si_shlhi(qword a, unsigned int b)
1685 {
1686   vec_ushort8 mask;
1687   vec_ushort8 bv;
1688
1689   bv = vec_splat((vec_ushort8)(si_from_int(b)), 1);
1690   mask = (vec_ushort8)vec_sra(vec_sl(bv, vec_splat_u16(11)), vec_splat_u16(15));
1691   return ((qword)(vec_andc(vec_sl((vec_ushort8)(a), bv), mask)));
1692 }
1693
1694 static __inline qword si_shli(qword a, unsigned int b)
1695 {
1696   vec_uint4 bv;
1697   vec_uint4 mask;
1698
1699   bv = vec_splat((vec_uint4)(si_from_uint(b)), 0);
1700   mask = (vec_uint4)vec_sra(vec_sl(bv, ((vec_uint4){26,26,26,26})), ((vec_uint4){31,31,31,31}));
1701   return ((qword)(vec_andc(vec_sl((vec_uint4)(a), bv), mask)));
1702 }
1703
1704
1705 /* Shift Left Quadword
1706  */
1707 static __inline qword si_shlqbii(qword a, unsigned int count)
1708 {
1709   vec_uchar16 x;
1710
1711   x = vec_splat((vec_uchar16)(si_from_uint(count)), 3);
1712   return ((qword)(vec_sll((vec_uchar16)(a), x)));
1713 }
1714
1715 static __inline qword si_shlqbi(qword a, qword count)
1716 {
1717   vec_uchar16 x;
1718
1719   x = vec_splat((vec_uchar16)(count), 3);
1720   return ((qword)(vec_sll((vec_uchar16)(a), x)));
1721 }
1722
1723
1724 /* Shift Left Quadword by Bytes
1725  */
1726 static __inline qword si_shlqbyi(qword a, unsigned int count)
1727 {
1728   union {
1729     vec_uchar16 v;
1730     int i[4];
1731   } x;
1732   vec_uchar16 mask;
1733
1734   x.i[3] = count << 3;
1735   mask = (count & 0x10) ? vec_splat_u8(0) : vec_splat_u8(-1);
1736   return ((qword)(vec_and(vec_slo((vec_uchar16)(a), x.v), mask)));
1737 }
1738
1739 static __inline qword si_shlqby(qword a, qword count)
1740 {
1741   union {
1742     vec_uchar16 v;
1743     unsigned int i[4];
1744   } x;
1745   unsigned int cnt;
1746   vec_uchar16 mask;
1747
1748   x.v = vec_sl(vec_splat((vec_uchar16)(count), 3), vec_splat_u8(3));
1749   cnt = x.i[0];
1750   mask = (cnt & 0x80) ? vec_splat_u8(0) : vec_splat_u8(-1);
1751   return ((qword)(vec_and(vec_slo((vec_uchar16)(a), x.v), mask)));
1752 }
1753
1754 /* Shift Left Quadword by Bytes with Bit Count
1755  */
1756 static __inline qword si_shlqbybi(qword a, qword count)
1757 {
1758   union {
1759     vec_uchar16 v;
1760     int i[4];
1761   } x;
1762   unsigned int cnt;
1763   vec_uchar16 mask;
1764
1765   x.v = vec_splat((vec_uchar16)(count), 3);
1766   cnt = x.i[0];
1767   mask = (cnt & 0x80) ? vec_splat_u8(0) : vec_splat_u8(-1);
1768   return ((qword)(vec_and(vec_slo((vec_uchar16)(a), x.v), mask)));
1769 }
1770
1771
1772 /* Stop and Signal
1773  */
1774 #define si_stop(_type)          SPU_STOP_ACTION
1775 #define si_stopd(a, b, c)       SPU_STOP_ACTION
1776
1777
1778 /* Subtract
1779  */
1780 static __inline qword si_sfh(qword a, qword b)
1781 {
1782   return ((qword)(vec_sub((vec_ushort8)(b), (vec_ushort8)(a))));
1783 }
1784
1785 static __inline qword si_sf(qword a, qword b)
1786 {
1787   return ((qword)(vec_sub((vec_uint4)(b), (vec_uint4)(a))));
1788 }
1789
1790 static __inline qword si_fs(qword a, qword b)
1791 {
1792   return ((qword)(vec_sub((vec_float4)(a), (vec_float4)(b))));
1793 }
1794
1795 static __inline qword si_dfs(qword a, qword b)
1796 {
1797   union {
1798     vec_double2 v;
1799     double d[2];
1800   } aa, bb, dd;
1801
1802   aa.v = (vec_double2)(a);
1803   bb.v = (vec_double2)(b);
1804   dd.d[0] = aa.d[0] - bb.d[0];
1805   dd.d[1] = aa.d[1] - bb.d[1];
1806   return ((qword)(dd.v));
1807 }
1808
1809 static __inline qword si_sfhi(qword a, short b)
1810 {
1811   return ((qword)(vec_sub(vec_splat((vec_short8)(si_from_short(b)), 1),
1812                           (vec_short8)(a))));
1813 }
1814
1815 static __inline qword si_sfi(qword a, int b)
1816 {
1817   return ((qword)(vec_sub(vec_splat((vec_int4)(si_from_int(b)), 0),
1818                           (vec_int4)(a))));
1819 }
1820
1821 /* Subtract word extended
1822  */
1823 #define si_sfx(_a, _b, _c)      ((qword)(vec_add(vec_add((vec_uint4)(_b),                               \
1824                                                          vec_nor((vec_uint4)(_a), (vec_uint4)(_a))),    \
1825                                                  vec_and((vec_uint4)(_c), vec_splat_u32(1)))))
1826
1827
1828 /* Sum Bytes into Shorts
1829  */
1830 static __inline qword si_sumb(qword a, qword b)
1831 {
1832   vec_uint4 zero = (vec_uint4){0};
1833   vec_ushort8 sum_a, sum_b;
1834
1835   sum_a = (vec_ushort8)vec_sum4s((vec_uchar16)(a), zero);
1836   sum_b = (vec_ushort8)vec_sum4s((vec_uchar16)(b), zero);
1837
1838   return ((qword)(vec_perm(sum_a, sum_b, ((vec_uchar16){18, 19,  2,  3, 22, 23,  6,  7,
1839                                                         26, 27, 10, 11, 30, 31, 14, 15}))));
1840 }
1841
1842 /* Exclusive OR
1843  */
1844 static __inline qword si_xor(qword a, qword b)
1845 {
1846   return ((qword)(vec_xor((vec_uchar16)(a), (vec_uchar16)(b))));
1847 }
1848
1849 static __inline qword si_xorbi(qword a, unsigned char b)
1850 {
1851   return ((qword)(vec_xor((vec_uchar16)(a),
1852                           vec_splat((vec_uchar16)(si_from_uchar(b)), 3))));
1853 }
1854
1855 static __inline qword si_xorhi(qword a, unsigned short b)
1856 {
1857   return ((qword)(vec_xor((vec_ushort8)(a),
1858                           vec_splat((vec_ushort8)(si_from_ushort(b)), 1))));
1859 }
1860
1861 static __inline qword si_xori(qword a, unsigned int b)
1862 {
1863   return ((qword)(vec_xor((vec_uint4)(a),
1864                           vec_splat((vec_uint4)(si_from_uint(b)), 0))));
1865 }
1866
1867
1868 /* Generate Controls for Sub-Quadword Insertion
1869  */
1870 static __inline qword si_cbd(qword a, int imm)
1871 {
1872   union {
1873     vec_uint4 v;
1874     unsigned char c[16];
1875   } shmask;
1876
1877   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1878   shmask.c[(si_to_uint(a) + (unsigned int)(imm)) & 0xF] = 0x03;
1879   return ((qword)(shmask.v));
1880 }
1881
1882 static __inline qword si_cdd(qword a, int imm)
1883 {
1884   union {
1885     vec_uint4 v;
1886     unsigned long long ll[2];
1887   } shmask;
1888
1889   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1890   shmask.ll[((si_to_uint(a) + (unsigned int)(imm)) >> 3) & 0x1] = 0x0001020304050607ULL;
1891   return ((qword)(shmask.v));
1892 }
1893
1894 static __inline qword si_chd(qword a, int imm)
1895 {
1896   union {
1897     vec_uint4 v;
1898     unsigned short s[8];
1899   } shmask;
1900
1901   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1902   shmask.s[((si_to_uint(a) + (unsigned int)(imm)) >> 1) & 0x7] = 0x0203;
1903   return ((qword)(shmask.v));
1904 }
1905
1906 static __inline qword si_cwd(qword a, int imm)
1907 {
1908   union {
1909     vec_uint4 v;
1910     unsigned int i[4];
1911   } shmask;
1912
1913   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1914   shmask.i[((si_to_uint(a) + (unsigned int)(imm)) >> 2) & 0x3] = 0x00010203;
1915   return ((qword)(shmask.v));
1916 }
1917
1918 static __inline qword si_cbx(qword a, qword b)
1919 {
1920   union {
1921     vec_uint4 v;
1922     unsigned char c[16];
1923   } shmask;
1924
1925   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1926   shmask.c[si_to_uint((qword)(vec_add((vec_uint4)(a), (vec_uint4)(b)))) & 0xF] = 0x03;
1927   return ((qword)(shmask.v));
1928 }
1929
1930
1931 static __inline qword si_cdx(qword a, qword b)
1932 {
1933   union {
1934     vec_uint4 v;
1935     unsigned long long ll[2];
1936   } shmask;
1937
1938   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1939   shmask.ll[(si_to_uint((qword)(vec_add((vec_uint4)(a), (vec_uint4)(b)))) >> 3) & 0x1] = 0x0001020304050607ULL;
1940   return ((qword)(shmask.v));
1941 }
1942
1943 static __inline qword si_chx(qword a, qword b)
1944 {
1945   union {
1946     vec_uint4 v;
1947     unsigned short s[8];
1948   } shmask;
1949
1950   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1951   shmask.s[(si_to_uint((qword)(vec_add((vec_uint4)(a), (vec_uint4)(b)))) >> 1) & 0x7] = 0x0203;
1952   return ((qword)(shmask.v));
1953 }
1954
1955 static __inline qword si_cwx(qword a, qword b)
1956 {
1957   union {
1958     vec_uint4 v;
1959     unsigned int i[4];
1960   } shmask;
1961
1962   shmask.v = ((vec_uint4){0x10111213, 0x14151617, 0x18191A1B, 0x1C1D1E1F});
1963   shmask.i[(si_to_uint((qword)(vec_add((vec_uint4)(a), (vec_uint4)(b)))) >> 2) & 0x3] = 0x00010203;
1964   return ((qword)(shmask.v));
1965 }
1966
1967
1968 /* Constant Formation
1969  */
1970 static __inline qword si_il(signed short imm)
1971 {
1972   return ((qword)(vec_splat((vec_int4)(si_from_int((signed int)(imm))), 0)));
1973 }
1974
1975
1976 static __inline qword si_ila(unsigned int imm)
1977 {
1978   return ((qword)(vec_splat((vec_uint4)(si_from_uint(imm)), 0)));
1979 }
1980
1981 static __inline qword si_ilh(signed short imm)
1982 {
1983   return ((qword)(vec_splat((vec_short8)(si_from_short(imm)), 1)));
1984 }
1985
1986 static __inline qword si_ilhu(signed short imm)
1987 {
1988   return ((qword)(vec_splat((vec_uint4)(si_from_uint((unsigned int)(imm) << 16)), 0)));
1989 }
1990
1991 static __inline qword si_iohl(qword a, unsigned short imm)
1992 {
1993   return ((qword)(vec_or((vec_uint4)(a), vec_splat((vec_uint4)(si_from_uint((unsigned int)(imm))), 0))));
1994 }
1995
1996 /* No Operation
1997  */
1998 #define si_lnop()               /* do nothing */
1999 #define si_nop()                /* do nothing */
2000
2001
2002 /* Memory Load and Store
2003  */
2004 static __inline qword si_lqa(unsigned int imm)
2005 {
2006   return ((qword)(vec_ld(0, (vector unsigned char *)(imm))));
2007 }
2008
2009 static __inline qword si_lqd(qword a, unsigned int imm)
2010 {
2011   return ((qword)(vec_ld(si_to_uint(a) & ~0xF, (vector unsigned char *)(imm))));
2012 }
2013
2014 static __inline qword si_lqr(unsigned int imm)
2015 {
2016   return ((qword)(vec_ld(0, (vector unsigned char *)(imm))));
2017 }
2018
2019 static __inline qword si_lqx(qword a, qword b)
2020 {
2021   return ((qword)(vec_ld(si_to_uint((qword)(vec_add((vec_uint4)(a), (vec_uint4)(b)))), (vector unsigned char *)(0))));
2022 }
2023
2024 static __inline void si_stqa(qword a, unsigned int imm)
2025 {
2026   vec_st((vec_uchar16)(a), 0, (vector unsigned char *)(imm));
2027 }
2028
2029 static __inline void si_stqd(qword a, qword b, unsigned int imm)
2030 {
2031   vec_st((vec_uchar16)(a), si_to_uint(b) & ~0xF, (vector unsigned char *)(imm));
2032 }
2033
2034 static __inline void si_stqr(qword a, unsigned int imm)
2035 {
2036   vec_st((vec_uchar16)(a), 0, (vector unsigned char *)(imm));
2037 }
2038
2039 static __inline void si_stqx(qword a, qword b, qword c)
2040 {
2041   vec_st((vec_uchar16)(a),
2042          si_to_uint((qword)(vec_add((vec_uint4)(b), (vec_uint4)(c)))),
2043          (vector unsigned char *)(0));
2044 }
2045
2046 #endif /* !__SPU__ */
2047 #endif /* !_SI2VMX_H_ */
2048