qemu/target-ppc/int_helper.c

   1 /*
   2  *  PowerPC integer and vector emulation helpers for QEMU.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "qemu/osdep.h"
  20 #include "cpu.h"
  21 #include "qemu/host-utils.h"
  22 #include "exec/helper-proto.h"
  23 #include "crypto/aes.h"
  24
  25 #include "helper_regs.h"
  26 /*****************************************************************************/
  27 /* Fixed point operations helpers */
  28
  29 target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb,
  30                            uint32_t oe)
  31 {
  32     uint64_t rt = 0;
  33     int overflow = 0;
  34
  35     uint64_t dividend = (uint64_t)ra << 32;
  36     uint64_t divisor = (uint32_t)rb;
  37
  38     if (unlikely(divisor == 0)) {
  39         overflow = 1;
  40     } else {
  41         rt = dividend / divisor;
  42         overflow = rt > UINT32_MAX;
  43     }
  44
  45     if (unlikely(overflow)) {
  46         rt = 0; /* Undefined */
  47     }
  48
  49     if (oe) {
  50         if (unlikely(overflow)) {
  51             env->so = env->ov = 1;
  52         } else {
  53             env->ov = 0;
  54         }
  55     }
  56
  57     return (target_ulong)rt;
  58 }
  59
  60 target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb,
  61                           uint32_t oe)
  62 {
  63     int64_t rt = 0;
  64     int overflow = 0;
  65
  66     int64_t dividend = (int64_t)ra << 32;
  67     int64_t divisor = (int64_t)((int32_t)rb);
  68
  69     if (unlikely((divisor == 0) ||
  70                  ((divisor == -1ull) && (dividend == INT64_MIN)))) {
  71         overflow = 1;
  72     } else {
  73         rt = dividend / divisor;
  74         overflow = rt != (int32_t)rt;
  75     }
  76
  77     if (unlikely(overflow)) {
  78         rt = 0; /* Undefined */
  79     }
  80
  81     if (oe) {
  82         if (unlikely(overflow)) {
  83             env->so = env->ov = 1;
  84         } else {
  85             env->ov = 0;
  86         }
  87     }
  88
  89     return (target_ulong)rt;
  90 }
  91
  92 #if defined(TARGET_PPC64)
  93
  94 uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe)
  95 {
  96     uint64_t rt = 0;
  97     int overflow = 0;
  98
  99     overflow = divu128(&rt, &ra, rb);
 100
 101     if (unlikely(overflow)) {
 102         rt = 0; /* Undefined */
 103     }
 104
 105     if (oe) {
 106         if (unlikely(overflow)) {
 107             env->so = env->ov = 1;
 108         } else {
 109             env->ov = 0;
 110         }
 111     }
 112
 113     return rt;
 114 }
 115
 116 uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe)
 117 {
 118     int64_t rt = 0;
 119     int64_t ra = (int64_t)rau;
 120     int64_t rb = (int64_t)rbu;
 121     int overflow = divs128(&rt, &ra, rb);
 122
 123     if (unlikely(overflow)) {
 124         rt = 0; /* Undefined */
 125     }
 126
 127     if (oe) {
 128
 129         if (unlikely(overflow)) {
 130             env->so = env->ov = 1;
 131         } else {
 132             env->ov = 0;
 133         }
 134     }
 135
 136     return rt;
 137 }
 138
 139 #endif
 140
 141
 142 target_ulong helper_cntlzw(target_ulong t)
 143 {
 144     return clz32(t);
 145 }
 146
 147 #if defined(TARGET_PPC64)
 148 target_ulong helper_cntlzd(target_ulong t)
 149 {
 150     return clz64(t);
 151 }
 152 #endif
 153
 154 #if defined(TARGET_PPC64)
 155
 156 uint64_t helper_bpermd(uint64_t rs, uint64_t rb)
 157 {
 158     int i;
 159     uint64_t ra = 0;
 160
 161     for (i = 0; i < 8; i++) {
 162         int index = (rs >> (i*8)) & 0xFF;
 163         if (index < 64) {
 164             if (rb & (1ull << (63-index))) {
 165                 ra |= 1 << i;
 166             }
 167         }
 168     }
 169     return ra;
 170 }
 171
 172 #endif
 173
 174 target_ulong helper_cmpb(target_ulong rs, target_ulong rb)
 175 {
 176     target_ulong mask = 0xff;
 177     target_ulong ra = 0;
 178     int i;
 179
 180     for (i = 0; i < sizeof(target_ulong); i++) {
 181         if ((rs & mask) == (rb & mask)) {
 182             ra |= mask;
 183         }
 184         mask <<= 8;
 185     }
 186     return ra;
 187 }
 188
 189 /* shift right arithmetic helper */
 190 target_ulong helper_sraw(CPUPPCState *env, target_ulong value,
 191                          target_ulong shift)
 192 {
 193     int32_t ret;
 194
 195     if (likely(!(shift & 0x20))) {
 196         if (likely((uint32_t)shift != 0)) {
 197             shift &= 0x1f;
 198             ret = (int32_t)value >> shift;
 199             if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
 200                 env->ca = 0;
 201             } else {
 202                 env->ca = 1;
 203             }
 204         } else {
 205             ret = (int32_t)value;
 206             env->ca = 0;
 207         }
 208     } else {
 209         ret = (int32_t)value >> 31;
 210         env->ca = (ret != 0);
 211     }
 212     return (target_long)ret;
 213 }
 214
 215 #if defined(TARGET_PPC64)
 216 target_ulong helper_srad(CPUPPCState *env, target_ulong value,
 217                          target_ulong shift)
 218 {
 219     int64_t ret;
 220
 221     if (likely(!(shift & 0x40))) {
 222         if (likely((uint64_t)shift != 0)) {
 223             shift &= 0x3f;
 224             ret = (int64_t)value >> shift;
 225             if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) {
 226                 env->ca = 0;
 227             } else {
 228                 env->ca = 1;
 229             }
 230         } else {
 231             ret = (int64_t)value;
 232             env->ca = 0;
 233         }
 234     } else {
 235         ret = (int64_t)value >> 63;
 236         env->ca = (ret != 0);
 237     }
 238     return ret;
 239 }
 240 #endif
 241
 242 #if defined(TARGET_PPC64)
 243 target_ulong helper_popcntb(target_ulong val)
 244 {
 245     val = (val & 0x5555555555555555ULL) + ((val >>  1) &
 246                                            0x5555555555555555ULL);
 247     val = (val & 0x3333333333333333ULL) + ((val >>  2) &
 248                                            0x3333333333333333ULL);
 249     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) &
 250                                            0x0f0f0f0f0f0f0f0fULL);
 251     return val;
 252 }
 253
 254 target_ulong helper_popcntw(target_ulong val)
 255 {
 256     val = (val & 0x5555555555555555ULL) + ((val >>  1) &
 257                                            0x5555555555555555ULL);
 258     val = (val & 0x3333333333333333ULL) + ((val >>  2) &
 259                                            0x3333333333333333ULL);
 260     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) &
 261                                            0x0f0f0f0f0f0f0f0fULL);
 262     val = (val & 0x00ff00ff00ff00ffULL) + ((val >>  8) &
 263                                            0x00ff00ff00ff00ffULL);
 264     val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) &
 265                                            0x0000ffff0000ffffULL);
 266     return val;
 267 }
 268
 269 target_ulong helper_popcntd(target_ulong val)
 270 {
 271     return ctpop64(val);
 272 }
 273 #else
 274 target_ulong helper_popcntb(target_ulong val)
 275 {
 276     val = (val & 0x55555555) + ((val >>  1) & 0x55555555);
 277     val = (val & 0x33333333) + ((val >>  2) & 0x33333333);
 278     val = (val & 0x0f0f0f0f) + ((val >>  4) & 0x0f0f0f0f);
 279     return val;
 280 }
 281
 282 target_ulong helper_popcntw(target_ulong val)
 283 {
 284     val = (val & 0x55555555) + ((val >>  1) & 0x55555555);
 285     val = (val & 0x33333333) + ((val >>  2) & 0x33333333);
 286     val = (val & 0x0f0f0f0f) + ((val >>  4) & 0x0f0f0f0f);
 287     val = (val & 0x00ff00ff) + ((val >>  8) & 0x00ff00ff);
 288     val = (val & 0x0000ffff) + ((val >> 16) & 0x0000ffff);
 289     return val;
 290 }
 291 #endif
 292
 293 /*****************************************************************************/
 294 /* PowerPC 601 specific instructions (POWER bridge) */
 295 target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2)
 296 {
 297     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
 298
 299     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 300         (int32_t)arg2 == 0) {
 301         env->spr[SPR_MQ] = 0;
 302         return INT32_MIN;
 303     } else {
 304         env->spr[SPR_MQ] = tmp % arg2;
 305         return  tmp / (int32_t)arg2;
 306     }
 307 }
 308
 309 target_ulong helper_divo(CPUPPCState *env, target_ulong arg1,
 310                          target_ulong arg2)
 311 {
 312     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
 313
 314     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 315         (int32_t)arg2 == 0) {
 316         env->so = env->ov = 1;
 317         env->spr[SPR_MQ] = 0;
 318         return INT32_MIN;
 319     } else {
 320         env->spr[SPR_MQ] = tmp % arg2;
 321         tmp /= (int32_t)arg2;
 322         if ((int32_t)tmp != tmp) {
 323             env->so = env->ov = 1;
 324         } else {
 325             env->ov = 0;
 326         }
 327         return tmp;
 328     }
 329 }
 330
 331 target_ulong helper_divs(CPUPPCState *env, target_ulong arg1,
 332                          target_ulong arg2)
 333 {
 334     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 335         (int32_t)arg2 == 0) {
 336         env->spr[SPR_MQ] = 0;
 337         return INT32_MIN;
 338     } else {
 339         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
 340         return (int32_t)arg1 / (int32_t)arg2;
 341     }
 342 }
 343
 344 target_ulong helper_divso(CPUPPCState *env, target_ulong arg1,
 345                           target_ulong arg2)
 346 {
 347     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 348         (int32_t)arg2 == 0) {
 349         env->so = env->ov = 1;
 350         env->spr[SPR_MQ] = 0;
 351         return INT32_MIN;
 352     } else {
 353         env->ov = 0;
 354         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
 355         return (int32_t)arg1 / (int32_t)arg2;
 356     }
 357 }
 358
 359 /*****************************************************************************/
 360 /* 602 specific instructions */
 361 /* mfrom is the most crazy instruction ever seen, imho ! */
 362 /* Real implementation uses a ROM table. Do the same */
 363 /* Extremely decomposed:
 364  *                      -arg / 256
 365  * return 256 * log10(10           + 1.0) + 0.5
 366  */
 367 #if !defined(CONFIG_USER_ONLY)
 368 target_ulong helper_602_mfrom(target_ulong arg)
 369 {
 370     if (likely(arg < 602)) {
 371 #include "mfrom_table.c"
 372         return mfrom_ROM_table[arg];
 373     } else {
 374         return 0;
 375     }
 376 }
 377 #endif
 378
 379 /*****************************************************************************/
 380 /* Altivec extension helpers */
 381 #if defined(HOST_WORDS_BIGENDIAN)
 382 #define HI_IDX 0
 383 #define LO_IDX 1
 384 #define AVRB(i) u8[i]
 385 #define AVRW(i) u32[i]
 386 #else
 387 #define HI_IDX 1
 388 #define LO_IDX 0
 389 #define AVRB(i) u8[15-(i)]
 390 #define AVRW(i) u32[3-(i)]
 391 #endif
 392
 393 #if defined(HOST_WORDS_BIGENDIAN)
 394 #define VECTOR_FOR_INORDER_I(index, element)                    \
 395     for (index = 0; index < ARRAY_SIZE(r->element); index++)
 396 #else
 397 #define VECTOR_FOR_INORDER_I(index, element)                    \
 398     for (index = ARRAY_SIZE(r->element)-1; index >= 0; index--)
 399 #endif
 400
 401 /* Saturating arithmetic helpers.  */
 402 #define SATCVT(from, to, from_type, to_type, min, max)          \
 403     static inline to_type cvt##from##to(from_type x, int *sat)  \
 404     {                                                           \
 405         to_type r;                                              \
 406                                                                 \
 407         if (x < (from_type)min) {                               \
 408             r = min;                                            \
 409             *sat = 1;                                           \
 410         } else if (x > (from_type)max) {                        \
 411             r = max;                                            \
 412             *sat = 1;                                           \
 413         } else {                                                \
 414             r = x;                                              \
 415         }                                                       \
 416         return r;                                               \
 417     }
 418 #define SATCVTU(from, to, from_type, to_type, min, max)         \
 419     static inline to_type cvt##from##to(from_type x, int *sat)  \
 420     {                                                           \
 421         to_type r;                                              \
 422                                                                 \
 423         if (x > (from_type)max) {                               \
 424             r = max;                                            \
 425             *sat = 1;                                           \
 426         } else {                                                \
 427             r = x;                                              \
 428         }                                                       \
 429         return r;                                               \
 430     }
 431 SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX)
 432 SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX)
 433 SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX)
 434
 435 SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX)
 436 SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX)
 437 SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX)
 438 SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX)
 439 SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX)
 440 SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX)
 441 #undef SATCVT
 442 #undef SATCVTU
 443
 444 void helper_lvsl(ppc_avr_t *r, target_ulong sh)
 445 {
 446     int i, j = (sh & 0xf);
 447
 448     VECTOR_FOR_INORDER_I(i, u8) {
 449         r->u8[i] = j++;
 450     }
 451 }
 452
 453 void helper_lvsr(ppc_avr_t *r, target_ulong sh)
 454 {
 455     int i, j = 0x10 - (sh & 0xf);
 456
 457     VECTOR_FOR_INORDER_I(i, u8) {
 458         r->u8[i] = j++;
 459     }
 460 }
 461
 462 void helper_mtvscr(CPUPPCState *env, ppc_avr_t *r)
 463 {
 464 #if defined(HOST_WORDS_BIGENDIAN)
 465     env->vscr = r->u32[3];
 466 #else
 467     env->vscr = r->u32[0];
 468 #endif
 469     set_flush_to_zero(vscr_nj, &env->vec_status);
 470 }
 471
 472 void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
 473 {
 474     int i;
 475
 476     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
 477         r->u32[i] = ~a->u32[i] < b->u32[i];
 478     }
 479 }
 480
 481 #define VARITH_DO(name, op, element)                                    \
 482     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 483     {                                                                   \
 484         int i;                                                          \
 485                                                                         \
 486         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 487             r->element[i] = a->element[i] op b->element[i];             \
 488         }                                                               \
 489     }
 490 #define VARITH(suffix, element)                 \
 491     VARITH_DO(add##suffix, +, element)          \
 492     VARITH_DO(sub##suffix, -, element)
 493 VARITH(ubm, u8)
 494 VARITH(uhm, u16)
 495 VARITH(uwm, u32)
 496 VARITH(udm, u64)
 497 VARITH_DO(muluwm, *, u32)
 498 #undef VARITH_DO
 499 #undef VARITH
 500
 501 #define VARITHFP(suffix, func)                                          \
 502     void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
 503                           ppc_avr_t *b)                                 \
 504     {                                                                   \
 505         int i;                                                          \
 506                                                                         \
 507         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
 508             r->f[i] = func(a->f[i], b->f[i], &env->vec_status);         \
 509         }                                                               \
 510     }
 511 VARITHFP(addfp, float32_add)
 512 VARITHFP(subfp, float32_sub)
 513 VARITHFP(minfp, float32_min)
 514 VARITHFP(maxfp, float32_max)
 515 #undef VARITHFP
 516
 517 #define VARITHFPFMA(suffix, type)                                       \
 518     void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
 519                            ppc_avr_t *b, ppc_avr_t *c)                  \
 520     {                                                                   \
 521         int i;                                                          \
 522         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
 523             r->f[i] = float32_muladd(a->f[i], c->f[i], b->f[i],         \
 524                                      type, &env->vec_status);           \
 525         }                                                               \
 526     }
 527 VARITHFPFMA(maddfp, 0);
 528 VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c);
 529 #undef VARITHFPFMA
 530
 531 #define VARITHSAT_CASE(type, op, cvt, element)                          \
 532     {                                                                   \
 533         type result = (type)a->element[i] op (type)b->element[i];       \
 534         r->element[i] = cvt(result, &sat);                              \
 535     }
 536
 537 #define VARITHSAT_DO(name, op, optype, cvt, element)                    \
 538     void helper_v##name(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,   \
 539                         ppc_avr_t *b)                                   \
 540     {                                                                   \
 541         int sat = 0;                                                    \
 542         int i;                                                          \
 543                                                                         \
 544         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 545             switch (sizeof(r->element[0])) {                            \
 546             case 1:                                                     \
 547                 VARITHSAT_CASE(optype, op, cvt, element);               \
 548                 break;                                                  \
 549             case 2:                                                     \
 550                 VARITHSAT_CASE(optype, op, cvt, element);               \
 551                 break;                                                  \
 552             case 4:                                                     \
 553                 VARITHSAT_CASE(optype, op, cvt, element);               \
 554                 break;                                                  \
 555             }                                                           \
 556         }                                                               \
 557         if (sat) {                                                      \
 558             env->vscr |= (1 << VSCR_SAT);                               \
 559         }                                                               \
 560     }
 561 #define VARITHSAT_SIGNED(suffix, element, optype, cvt)          \
 562     VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element)      \
 563     VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element)
 564 #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt)        \
 565     VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element)      \
 566     VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element)
 567 VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb)
 568 VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh)
 569 VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw)
 570 VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub)
 571 VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh)
 572 VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw)
 573 #undef VARITHSAT_CASE
 574 #undef VARITHSAT_DO
 575 #undef VARITHSAT_SIGNED
 576 #undef VARITHSAT_UNSIGNED
 577
 578 #define VAVG_DO(name, element, etype)                                   \
 579     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 580     {                                                                   \
 581         int i;                                                          \
 582                                                                         \
 583         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 584             etype x = (etype)a->element[i] + (etype)b->element[i] + 1;  \
 585             r->element[i] = x >> 1;                                     \
 586         }                                                               \
 587     }
 588
 589 #define VAVG(type, signed_element, signed_type, unsigned_element,       \
 590              unsigned_type)                                             \
 591     VAVG_DO(avgs##type, signed_element, signed_type)                    \
 592     VAVG_DO(avgu##type, unsigned_element, unsigned_type)
 593 VAVG(b, s8, int16_t, u8, uint16_t)
 594 VAVG(h, s16, int32_t, u16, uint32_t)
 595 VAVG(w, s32, int64_t, u32, uint64_t)
 596 #undef VAVG_DO
 597 #undef VAVG
 598
 599 #define VCF(suffix, cvt, element)                                       \
 600     void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r,             \
 601                             ppc_avr_t *b, uint32_t uim)                 \
 602     {                                                                   \
 603         int i;                                                          \
 604                                                                         \
 605         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
 606             float32 t = cvt(b->element[i], &env->vec_status);           \
 607             r->f[i] = float32_scalbn(t, -uim, &env->vec_status);        \
 608         }                                                               \
 609     }
 610 VCF(ux, uint32_to_float32, u32)
 611 VCF(sx, int32_to_float32, s32)
 612 #undef VCF
 613
 614 #define VCMP_DO(suffix, compare, element, record)                       \
 615     void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r,            \
 616                              ppc_avr_t *a, ppc_avr_t *b)                \
 617     {                                                                   \
 618         uint64_t ones = (uint64_t)-1;                                   \
 619         uint64_t all = ones;                                            \
 620         uint64_t none = 0;                                              \
 621         int i;                                                          \
 622                                                                         \
 623         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 624             uint64_t result = (a->element[i] compare b->element[i] ?    \
 625                                ones : 0x0);                             \
 626             switch (sizeof(a->element[0])) {                            \
 627             case 8:                                                     \
 628                 r->u64[i] = result;                                     \
 629                 break;                                                  \
 630             case 4:                                                     \
 631                 r->u32[i] = result;                                     \
 632                 break;                                                  \
 633             case 2:                                                     \
 634                 r->u16[i] = result;                                     \
 635                 break;                                                  \
 636             case 1:                                                     \
 637                 r->u8[i] = result;                                      \
 638                 break;                                                  \
 639             }                                                           \
 640             all &= result;                                              \
 641             none |= result;                                             \
 642         }                                                               \
 643         if (record) {                                                   \
 644             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
 645         }                                                               \
 646     }
 647 #define VCMP(suffix, compare, element)          \
 648     VCMP_DO(suffix, compare, element, 0)        \
 649     VCMP_DO(suffix##_dot, compare, element, 1)
 650 VCMP(equb, ==, u8)
 651 VCMP(equh, ==, u16)
 652 VCMP(equw, ==, u32)
 653 VCMP(equd, ==, u64)
 654 VCMP(gtub, >, u8)
 655 VCMP(gtuh, >, u16)
 656 VCMP(gtuw, >, u32)
 657 VCMP(gtud, >, u64)
 658 VCMP(gtsb, >, s8)
 659 VCMP(gtsh, >, s16)
 660 VCMP(gtsw, >, s32)
 661 VCMP(gtsd, >, s64)
 662 #undef VCMP_DO
 663 #undef VCMP
 664
 665 #define VCMPFP_DO(suffix, compare, order, record)                       \
 666     void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r,            \
 667                              ppc_avr_t *a, ppc_avr_t *b)                \
 668     {                                                                   \
 669         uint32_t ones = (uint32_t)-1;                                   \
 670         uint32_t all = ones;                                            \
 671         uint32_t none = 0;                                              \
 672         int i;                                                          \
 673                                                                         \
 674         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
 675             uint32_t result;                                            \
 676             int rel = float32_compare_quiet(a->f[i], b->f[i],           \
 677                                             &env->vec_status);          \
 678             if (rel == float_relation_unordered) {                      \
 679                 result = 0;                                             \
 680             } else if (rel compare order) {                             \
 681                 result = ones;                                          \
 682             } else {                                                    \
 683                 result = 0;                                             \
 684             }                                                           \
 685             r->u32[i] = result;                                         \
 686             all &= result;                                              \
 687             none |= result;                                             \
 688         }                                                               \
 689         if (record) {                                                   \
 690             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
 691         }                                                               \
 692     }
 693 #define VCMPFP(suffix, compare, order)          \
 694     VCMPFP_DO(suffix, compare, order, 0)        \
 695     VCMPFP_DO(suffix##_dot, compare, order, 1)
 696 VCMPFP(eqfp, ==, float_relation_equal)
 697 VCMPFP(gefp, !=, float_relation_less)
 698 VCMPFP(gtfp, ==, float_relation_greater)
 699 #undef VCMPFP_DO
 700 #undef VCMPFP
 701
 702 static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r,
 703                                     ppc_avr_t *a, ppc_avr_t *b, int record)
 704 {
 705     int i;
 706     int all_in = 0;
 707
 708     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
 709         int le_rel = float32_compare_quiet(a->f[i], b->f[i], &env->vec_status);
 710         if (le_rel == float_relation_unordered) {
 711             r->u32[i] = 0xc0000000;
 712             all_in = 1;
 713         } else {
 714             float32 bneg = float32_chs(b->f[i]);
 715             int ge_rel = float32_compare_quiet(a->f[i], bneg, &env->vec_status);
 716             int le = le_rel != float_relation_greater;
 717             int ge = ge_rel != float_relation_less;
 718
 719             r->u32[i] = ((!le) << 31) | ((!ge) << 30);
 720             all_in |= (!le | !ge);
 721         }
 722     }
 723     if (record) {
 724         env->crf[6] = (all_in == 0) << 1;
 725     }
 726 }
 727
 728 void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
 729 {
 730     vcmpbfp_internal(env, r, a, b, 0);
 731 }
 732
 733 void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 734                         ppc_avr_t *b)
 735 {
 736     vcmpbfp_internal(env, r, a, b, 1);
 737 }
 738
 739 #define VCT(suffix, satcvt, element)                                    \
 740     void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r,             \
 741                             ppc_avr_t *b, uint32_t uim)                 \
 742     {                                                                   \
 743         int i;                                                          \
 744         int sat = 0;                                                    \
 745         float_status s = env->vec_status;                               \
 746                                                                         \
 747         set_float_rounding_mode(float_round_to_zero, &s);               \
 748         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
 749             if (float32_is_any_nan(b->f[i])) {                          \
 750                 r->element[i] = 0;                                      \
 751             } else {                                                    \
 752                 float64 t = float32_to_float64(b->f[i], &s);            \
 753                 int64_t j;                                              \
 754                                                                         \
 755                 t = float64_scalbn(t, uim, &s);                         \
 756                 j = float64_to_int64(t, &s);                            \
 757                 r->element[i] = satcvt(j, &sat);                        \
 758             }                                                           \
 759         }                                                               \
 760         if (sat) {                                                      \
 761             env->vscr |= (1 << VSCR_SAT);                               \
 762         }                                                               \
 763     }
 764 VCT(uxs, cvtsduw, u32)
 765 VCT(sxs, cvtsdsw, s32)
 766 #undef VCT
 767
 768 void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 769                       ppc_avr_t *b, ppc_avr_t *c)
 770 {
 771     int sat = 0;
 772     int i;
 773
 774     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 775         int32_t prod = a->s16[i] * b->s16[i];
 776         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
 777
 778         r->s16[i] = cvtswsh(t, &sat);
 779     }
 780
 781     if (sat) {
 782         env->vscr |= (1 << VSCR_SAT);
 783     }
 784 }
 785
 786 void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 787                        ppc_avr_t *b, ppc_avr_t *c)
 788 {
 789     int sat = 0;
 790     int i;
 791
 792     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 793         int32_t prod = a->s16[i] * b->s16[i] + 0x00004000;
 794         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
 795         r->s16[i] = cvtswsh(t, &sat);
 796     }
 797
 798     if (sat) {
 799         env->vscr |= (1 << VSCR_SAT);
 800     }
 801 }
 802
 803 #define VMINMAX_DO(name, compare, element)                              \
 804     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 805     {                                                                   \
 806         int i;                                                          \
 807                                                                         \
 808         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 809             if (a->element[i] compare b->element[i]) {                  \
 810                 r->element[i] = b->element[i];                          \
 811             } else {                                                    \
 812                 r->element[i] = a->element[i];                          \
 813             }                                                           \
 814         }                                                               \
 815     }
 816 #define VMINMAX(suffix, element)                \
 817     VMINMAX_DO(min##suffix, >, element)         \
 818     VMINMAX_DO(max##suffix, <, element)
 819 VMINMAX(sb, s8)
 820 VMINMAX(sh, s16)
 821 VMINMAX(sw, s32)
 822 VMINMAX(sd, s64)
 823 VMINMAX(ub, u8)
 824 VMINMAX(uh, u16)
 825 VMINMAX(uw, u32)
 826 VMINMAX(ud, u64)
 827 #undef VMINMAX_DO
 828 #undef VMINMAX
 829
 830 void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
 831 {
 832     int i;
 833
 834     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 835         int32_t prod = a->s16[i] * b->s16[i];
 836         r->s16[i] = (int16_t) (prod + c->s16[i]);
 837     }
 838 }
 839
 840 #define VMRG_DO(name, element, highp)                                   \
 841     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 842     {                                                                   \
 843         ppc_avr_t result;                                               \
 844         int i;                                                          \
 845         size_t n_elems = ARRAY_SIZE(r->element);                        \
 846                                                                         \
 847         for (i = 0; i < n_elems / 2; i++) {                             \
 848             if (highp) {                                                \
 849                 result.element[i*2+HI_IDX] = a->element[i];             \
 850                 result.element[i*2+LO_IDX] = b->element[i];             \
 851             } else {                                                    \
 852                 result.element[n_elems - i * 2 - (1 + HI_IDX)] =        \
 853                     b->element[n_elems - i - 1];                        \
 854                 result.element[n_elems - i * 2 - (1 + LO_IDX)] =        \
 855                     a->element[n_elems - i - 1];                        \
 856             }                                                           \
 857         }                                                               \
 858         *r = result;                                                    \
 859     }
 860 #if defined(HOST_WORDS_BIGENDIAN)
 861 #define MRGHI 0
 862 #define MRGLO 1
 863 #else
 864 #define MRGHI 1
 865 #define MRGLO 0
 866 #endif
 867 #define VMRG(suffix, element)                   \
 868     VMRG_DO(mrgl##suffix, element, MRGHI)       \
 869     VMRG_DO(mrgh##suffix, element, MRGLO)
 870 VMRG(b, u8)
 871 VMRG(h, u16)
 872 VMRG(w, u32)
 873 #undef VMRG_DO
 874 #undef VMRG
 875 #undef MRGHI
 876 #undef MRGLO
 877
 878 void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 879                      ppc_avr_t *b, ppc_avr_t *c)
 880 {
 881     int32_t prod[16];
 882     int i;
 883
 884     for (i = 0; i < ARRAY_SIZE(r->s8); i++) {
 885         prod[i] = (int32_t)a->s8[i] * b->u8[i];
 886     }
 887
 888     VECTOR_FOR_INORDER_I(i, s32) {
 889         r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] +
 890             prod[4 * i + 2] + prod[4 * i + 3];
 891     }
 892 }
 893
 894 void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 895                      ppc_avr_t *b, ppc_avr_t *c)
 896 {
 897     int32_t prod[8];
 898     int i;
 899
 900     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 901         prod[i] = a->s16[i] * b->s16[i];
 902     }
 903
 904     VECTOR_FOR_INORDER_I(i, s32) {
 905         r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1];
 906     }
 907 }
 908
 909 void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 910                      ppc_avr_t *b, ppc_avr_t *c)
 911 {
 912     int32_t prod[8];
 913     int i;
 914     int sat = 0;
 915
 916     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 917         prod[i] = (int32_t)a->s16[i] * b->s16[i];
 918     }
 919
 920     VECTOR_FOR_INORDER_I(i, s32) {
 921         int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1];
 922
 923         r->u32[i] = cvtsdsw(t, &sat);
 924     }
 925
 926     if (sat) {
 927         env->vscr |= (1 << VSCR_SAT);
 928     }
 929 }
 930
 931 void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 932                      ppc_avr_t *b, ppc_avr_t *c)
 933 {
 934     uint16_t prod[16];
 935     int i;
 936
 937     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
 938         prod[i] = a->u8[i] * b->u8[i];
 939     }
 940
 941     VECTOR_FOR_INORDER_I(i, u32) {
 942         r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] +
 943             prod[4 * i + 2] + prod[4 * i + 3];
 944     }
 945 }
 946
 947 void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 948                      ppc_avr_t *b, ppc_avr_t *c)
 949 {
 950     uint32_t prod[8];
 951     int i;
 952
 953     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
 954         prod[i] = a->u16[i] * b->u16[i];
 955     }
 956
 957     VECTOR_FOR_INORDER_I(i, u32) {
 958         r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1];
 959     }
 960 }
 961
 962 void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 963                      ppc_avr_t *b, ppc_avr_t *c)
 964 {
 965     uint32_t prod[8];
 966     int i;
 967     int sat = 0;
 968
 969     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
 970         prod[i] = a->u16[i] * b->u16[i];
 971     }
 972
 973     VECTOR_FOR_INORDER_I(i, s32) {
 974         uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1];
 975
 976         r->u32[i] = cvtuduw(t, &sat);
 977     }
 978
 979     if (sat) {
 980         env->vscr |= (1 << VSCR_SAT);
 981     }
 982 }
 983
 984 #define VMUL_DO(name, mul_element, prod_element, cast, evenp)           \
 985     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 986     {                                                                   \
 987         int i;                                                          \
 988                                                                         \
 989         VECTOR_FOR_INORDER_I(i, prod_element) {                         \
 990             if (evenp) {                                                \
 991                 r->prod_element[i] =                                    \
 992                     (cast)a->mul_element[i * 2 + HI_IDX] *              \
 993                     (cast)b->mul_element[i * 2 + HI_IDX];               \
 994             } else {                                                    \
 995                 r->prod_element[i] =                                    \
 996                     (cast)a->mul_element[i * 2 + LO_IDX] *              \
 997                     (cast)b->mul_element[i * 2 + LO_IDX];               \
 998             }                                                           \
 999         }                                                               \
1000     }
1001 #define VMUL(suffix, mul_element, prod_element, cast)            \
1002     VMUL_DO(mule##suffix, mul_element, prod_element, cast, 1)    \
1003     VMUL_DO(mulo##suffix, mul_element, prod_element, cast, 0)
1004 VMUL(sb, s8, s16, int16_t)
1005 VMUL(sh, s16, s32, int32_t)
1006 VMUL(sw, s32, s64, int64_t)
1007 VMUL(ub, u8, u16, uint16_t)
1008 VMUL(uh, u16, u32, uint32_t)
1009 VMUL(uw, u32, u64, uint64_t)
1010 #undef VMUL_DO
1011 #undef VMUL
1012
1013 void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1014                   ppc_avr_t *c)
1015 {
1016     ppc_avr_t result;
1017     int i;
1018
1019     VECTOR_FOR_INORDER_I(i, u8) {
1020         int s = c->u8[i] & 0x1f;
1021 #if defined(HOST_WORDS_BIGENDIAN)
1022         int index = s & 0xf;
1023 #else
1024         int index = 15 - (s & 0xf);
1025 #endif
1026
1027         if (s & 0x10) {
1028             result.u8[i] = b->u8[index];
1029         } else {
1030             result.u8[i] = a->u8[index];
1031         }
1032     }
1033     *r = result;
1034 }
1035
1036 #if defined(HOST_WORDS_BIGENDIAN)
1037 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)])
1038 #define VBPERMQ_DW(index) (((index) & 0x40) != 0)
1039 #else
1040 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15-(i)])
1041 #define VBPERMQ_DW(index) (((index) & 0x40) == 0)
1042 #endif
1043
1044 void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1045 {
1046     int i;
1047     uint64_t perm = 0;
1048
1049     VECTOR_FOR_INORDER_I(i, u8) {
1050         int index = VBPERMQ_INDEX(b, i);
1051
1052         if (index < 128) {
1053             uint64_t mask = (1ull << (63-(index & 0x3F)));
1054             if (a->u64[VBPERMQ_DW(index)] & mask) {
1055                 perm |= (0x8000 >> i);
1056             }
1057         }
1058     }
1059
1060     r->u64[HI_IDX] = perm;
1061     r->u64[LO_IDX] = 0;
1062 }
1063
1064 #undef VBPERMQ_INDEX
1065 #undef VBPERMQ_DW
1066
1067 static const uint64_t VGBBD_MASKS[256] = {
1068     0x0000000000000000ull, /* 00 */
1069     0x0000000000000080ull, /* 01 */
1070     0x0000000000008000ull, /* 02 */
1071     0x0000000000008080ull, /* 03 */
1072     0x0000000000800000ull, /* 04 */
1073     0x0000000000800080ull, /* 05 */
1074     0x0000000000808000ull, /* 06 */
1075     0x0000000000808080ull, /* 07 */
1076     0x0000000080000000ull, /* 08 */
1077     0x0000000080000080ull, /* 09 */
1078     0x0000000080008000ull, /* 0A */
1079     0x0000000080008080ull, /* 0B */
1080     0x0000000080800000ull, /* 0C */
1081     0x0000000080800080ull, /* 0D */
1082     0x0000000080808000ull, /* 0E */
1083     0x0000000080808080ull, /* 0F */
1084     0x0000008000000000ull, /* 10 */
1085     0x0000008000000080ull, /* 11 */
1086     0x0000008000008000ull, /* 12 */
1087     0x0000008000008080ull, /* 13 */
1088     0x0000008000800000ull, /* 14 */
1089     0x0000008000800080ull, /* 15 */
1090     0x0000008000808000ull, /* 16 */
1091     0x0000008000808080ull, /* 17 */
1092     0x0000008080000000ull, /* 18 */
1093     0x0000008080000080ull, /* 19 */
1094     0x0000008080008000ull, /* 1A */
1095     0x0000008080008080ull, /* 1B */
1096     0x0000008080800000ull, /* 1C */
1097     0x0000008080800080ull, /* 1D */
1098     0x0000008080808000ull, /* 1E */
1099     0x0000008080808080ull, /* 1F */
1100     0x0000800000000000ull, /* 20 */
1101     0x0000800000000080ull, /* 21 */
1102     0x0000800000008000ull, /* 22 */
1103     0x0000800000008080ull, /* 23 */
1104     0x0000800000800000ull, /* 24 */
1105     0x0000800000800080ull, /* 25 */
1106     0x0000800000808000ull, /* 26 */
1107     0x0000800000808080ull, /* 27 */
1108     0x0000800080000000ull, /* 28 */
1109     0x0000800080000080ull, /* 29 */
1110     0x0000800080008000ull, /* 2A */
1111     0x0000800080008080ull, /* 2B */
1112     0x0000800080800000ull, /* 2C */
1113     0x0000800080800080ull, /* 2D */
1114     0x0000800080808000ull, /* 2E */
1115     0x0000800080808080ull, /* 2F */
1116     0x0000808000000000ull, /* 30 */
1117     0x0000808000000080ull, /* 31 */
1118     0x0000808000008000ull, /* 32 */
1119     0x0000808000008080ull, /* 33 */
1120     0x0000808000800000ull, /* 34 */
1121     0x0000808000800080ull, /* 35 */
1122     0x0000808000808000ull, /* 36 */
1123     0x0000808000808080ull, /* 37 */
1124     0x0000808080000000ull, /* 38 */
1125     0x0000808080000080ull, /* 39 */
1126     0x0000808080008000ull, /* 3A */
1127     0x0000808080008080ull, /* 3B */
1128     0x0000808080800000ull, /* 3C */
1129     0x0000808080800080ull, /* 3D */
1130     0x0000808080808000ull, /* 3E */
1131     0x0000808080808080ull, /* 3F */
1132     0x0080000000000000ull, /* 40 */
1133     0x0080000000000080ull, /* 41 */
1134     0x0080000000008000ull, /* 42 */
1135     0x0080000000008080ull, /* 43 */
1136     0x0080000000800000ull, /* 44 */
1137     0x0080000000800080ull, /* 45 */
1138     0x0080000000808000ull, /* 46 */
1139     0x0080000000808080ull, /* 47 */
1140     0x0080000080000000ull, /* 48 */
1141     0x0080000080000080ull, /* 49 */
1142     0x0080000080008000ull, /* 4A */
1143     0x0080000080008080ull, /* 4B */
1144     0x0080000080800000ull, /* 4C */
1145     0x0080000080800080ull, /* 4D */
1146     0x0080000080808000ull, /* 4E */
1147     0x0080000080808080ull, /* 4F */
1148     0x0080008000000000ull, /* 50 */
1149     0x0080008000000080ull, /* 51 */
1150     0x0080008000008000ull, /* 52 */
1151     0x0080008000008080ull, /* 53 */
1152     0x0080008000800000ull, /* 54 */
1153     0x0080008000800080ull, /* 55 */
1154     0x0080008000808000ull, /* 56 */
1155     0x0080008000808080ull, /* 57 */
1156     0x0080008080000000ull, /* 58 */
1157     0x0080008080000080ull, /* 59 */
1158     0x0080008080008000ull, /* 5A */
1159     0x0080008080008080ull, /* 5B */
1160     0x0080008080800000ull, /* 5C */
1161     0x0080008080800080ull, /* 5D */
1162     0x0080008080808000ull, /* 5E */
1163     0x0080008080808080ull, /* 5F */
1164     0x0080800000000000ull, /* 60 */
1165     0x0080800000000080ull, /* 61 */
1166     0x0080800000008000ull, /* 62 */
1167     0x0080800000008080ull, /* 63 */
1168     0x0080800000800000ull, /* 64 */
1169     0x0080800000800080ull, /* 65 */
1170     0x0080800000808000ull, /* 66 */
1171     0x0080800000808080ull, /* 67 */
1172     0x0080800080000000ull, /* 68 */
1173     0x0080800080000080ull, /* 69 */
1174     0x0080800080008000ull, /* 6A */
1175     0x0080800080008080ull, /* 6B */
1176     0x0080800080800000ull, /* 6C */
1177     0x0080800080800080ull, /* 6D */
1178     0x0080800080808000ull, /* 6E */
1179     0x0080800080808080ull, /* 6F */
1180     0x0080808000000000ull, /* 70 */
1181     0x0080808000000080ull, /* 71 */
1182     0x0080808000008000ull, /* 72 */
1183     0x0080808000008080ull, /* 73 */
1184     0x0080808000800000ull, /* 74 */
1185     0x0080808000800080ull, /* 75 */
1186     0x0080808000808000ull, /* 76 */
1187     0x0080808000808080ull, /* 77 */
1188     0x0080808080000000ull, /* 78 */
1189     0x0080808080000080ull, /* 79 */
1190     0x0080808080008000ull, /* 7A */
1191     0x0080808080008080ull, /* 7B */
1192     0x0080808080800000ull, /* 7C */
1193     0x0080808080800080ull, /* 7D */
1194     0x0080808080808000ull, /* 7E */
1195     0x0080808080808080ull, /* 7F */
1196     0x8000000000000000ull, /* 80 */
1197     0x8000000000000080ull, /* 81 */
1198     0x8000000000008000ull, /* 82 */
1199     0x8000000000008080ull, /* 83 */
1200     0x8000000000800000ull, /* 84 */
1201     0x8000000000800080ull, /* 85 */
1202     0x8000000000808000ull, /* 86 */
1203     0x8000000000808080ull, /* 87 */
1204     0x8000000080000000ull, /* 88 */
1205     0x8000000080000080ull, /* 89 */
1206     0x8000000080008000ull, /* 8A */
1207     0x8000000080008080ull, /* 8B */
1208     0x8000000080800000ull, /* 8C */
1209     0x8000000080800080ull, /* 8D */
1210     0x8000000080808000ull, /* 8E */
1211     0x8000000080808080ull, /* 8F */
1212     0x8000008000000000ull, /* 90 */
1213     0x8000008000000080ull, /* 91 */
1214     0x8000008000008000ull, /* 92 */
1215     0x8000008000008080ull, /* 93 */
1216     0x8000008000800000ull, /* 94 */
1217     0x8000008000800080ull, /* 95 */
1218     0x8000008000808000ull, /* 96 */
1219     0x8000008000808080ull, /* 97 */
1220     0x8000008080000000ull, /* 98 */
1221     0x8000008080000080ull, /* 99 */
1222     0x8000008080008000ull, /* 9A */
1223     0x8000008080008080ull, /* 9B */
1224     0x8000008080800000ull, /* 9C */
1225     0x8000008080800080ull, /* 9D */
1226     0x8000008080808000ull, /* 9E */
1227     0x8000008080808080ull, /* 9F */
1228     0x8000800000000000ull, /* A0 */
1229     0x8000800000000080ull, /* A1 */
1230     0x8000800000008000ull, /* A2 */
1231     0x8000800000008080ull, /* A3 */
1232     0x8000800000800000ull, /* A4 */
1233     0x8000800000800080ull, /* A5 */
1234     0x8000800000808000ull, /* A6 */
1235     0x8000800000808080ull, /* A7 */
1236     0x8000800080000000ull, /* A8 */
1237     0x8000800080000080ull, /* A9 */
1238     0x8000800080008000ull, /* AA */
1239     0x8000800080008080ull, /* AB */
1240     0x8000800080800000ull, /* AC */
1241     0x8000800080800080ull, /* AD */
1242     0x8000800080808000ull, /* AE */
1243     0x8000800080808080ull, /* AF */
1244     0x8000808000000000ull, /* B0 */
1245     0x8000808000000080ull, /* B1 */
1246     0x8000808000008000ull, /* B2 */
1247     0x8000808000008080ull, /* B3 */
1248     0x8000808000800000ull, /* B4 */
1249     0x8000808000800080ull, /* B5 */
1250     0x8000808000808000ull, /* B6 */
1251     0x8000808000808080ull, /* B7 */
1252     0x8000808080000000ull, /* B8 */
1253     0x8000808080000080ull, /* B9 */
1254     0x8000808080008000ull, /* BA */
1255     0x8000808080008080ull, /* BB */
1256     0x8000808080800000ull, /* BC */
1257     0x8000808080800080ull, /* BD */
1258     0x8000808080808000ull, /* BE */
1259     0x8000808080808080ull, /* BF */
1260     0x8080000000000000ull, /* C0 */
1261     0x8080000000000080ull, /* C1 */
1262     0x8080000000008000ull, /* C2 */
1263     0x8080000000008080ull, /* C3 */
1264     0x8080000000800000ull, /* C4 */
1265     0x8080000000800080ull, /* C5 */
1266     0x8080000000808000ull, /* C6 */
1267     0x8080000000808080ull, /* C7 */
1268     0x8080000080000000ull, /* C8 */
1269     0x8080000080000080ull, /* C9 */
1270     0x8080000080008000ull, /* CA */
1271     0x8080000080008080ull, /* CB */
1272     0x8080000080800000ull, /* CC */
1273     0x8080000080800080ull, /* CD */
1274     0x8080000080808000ull, /* CE */
1275     0x8080000080808080ull, /* CF */
1276     0x8080008000000000ull, /* D0 */
1277     0x8080008000000080ull, /* D1 */
1278     0x8080008000008000ull, /* D2 */
1279     0x8080008000008080ull, /* D3 */
1280     0x8080008000800000ull, /* D4 */
1281     0x8080008000800080ull, /* D5 */
1282     0x8080008000808000ull, /* D6 */
1283     0x8080008000808080ull, /* D7 */
1284     0x8080008080000000ull, /* D8 */
1285     0x8080008080000080ull, /* D9 */
1286     0x8080008080008000ull, /* DA */
1287     0x8080008080008080ull, /* DB */
1288     0x8080008080800000ull, /* DC */
1289     0x8080008080800080ull, /* DD */
1290     0x8080008080808000ull, /* DE */
1291     0x8080008080808080ull, /* DF */
1292     0x8080800000000000ull, /* E0 */
1293     0x8080800000000080ull, /* E1 */
1294     0x8080800000008000ull, /* E2 */
1295     0x8080800000008080ull, /* E3 */
1296     0x8080800000800000ull, /* E4 */
1297     0x8080800000800080ull, /* E5 */
1298     0x8080800000808000ull, /* E6 */
1299     0x8080800000808080ull, /* E7 */
1300     0x8080800080000000ull, /* E8 */
1301     0x8080800080000080ull, /* E9 */
1302     0x8080800080008000ull, /* EA */
1303     0x8080800080008080ull, /* EB */
1304     0x8080800080800000ull, /* EC */
1305     0x8080800080800080ull, /* ED */
1306     0x8080800080808000ull, /* EE */
1307     0x8080800080808080ull, /* EF */
1308     0x8080808000000000ull, /* F0 */
1309     0x8080808000000080ull, /* F1 */
1310     0x8080808000008000ull, /* F2 */
1311     0x8080808000008080ull, /* F3 */
1312     0x8080808000800000ull, /* F4 */
1313     0x8080808000800080ull, /* F5 */
1314     0x8080808000808000ull, /* F6 */
1315     0x8080808000808080ull, /* F7 */
1316     0x8080808080000000ull, /* F8 */
1317     0x8080808080000080ull, /* F9 */
1318     0x8080808080008000ull, /* FA */
1319     0x8080808080008080ull, /* FB */
1320     0x8080808080800000ull, /* FC */
1321     0x8080808080800080ull, /* FD */
1322     0x8080808080808000ull, /* FE */
1323     0x8080808080808080ull, /* FF */
1324 };
1325
1326 void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b)
1327 {
1328     int i;
1329     uint64_t t[2] = { 0, 0 };
1330
1331     VECTOR_FOR_INORDER_I(i, u8) {
1332 #if defined(HOST_WORDS_BIGENDIAN)
1333         t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7);
1334 #else
1335         t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (7-(i & 7));
1336 #endif
1337     }
1338
1339     r->u64[0] = t[0];
1340     r->u64[1] = t[1];
1341 }
1342
1343 #define PMSUM(name, srcfld, trgfld, trgtyp)                   \
1344 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
1345 {                                                             \
1346     int i, j;                                                 \
1347     trgtyp prod[sizeof(ppc_avr_t)/sizeof(a->srcfld[0])];      \
1348                                                               \
1349     VECTOR_FOR_INORDER_I(i, srcfld) {                         \
1350         prod[i] = 0;                                          \
1351         for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) {      \
1352             if (a->srcfld[i] & (1ull<<j)) {                   \
1353                 prod[i] ^= ((trgtyp)b->srcfld[i] << j);       \
1354             }                                                 \
1355         }                                                     \
1356     }                                                         \
1357                                                               \
1358     VECTOR_FOR_INORDER_I(i, trgfld) {                         \
1359         r->trgfld[i] = prod[2*i] ^ prod[2*i+1];               \
1360     }                                                         \
1361 }
1362
1363 PMSUM(vpmsumb, u8, u16, uint16_t)
1364 PMSUM(vpmsumh, u16, u32, uint32_t)
1365 PMSUM(vpmsumw, u32, u64, uint64_t)
1366
1367 void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1368 {
1369
1370 #ifdef CONFIG_INT128
1371     int i, j;
1372     __uint128_t prod[2];
1373
1374     VECTOR_FOR_INORDER_I(i, u64) {
1375         prod[i] = 0;
1376         for (j = 0; j < 64; j++) {
1377             if (a->u64[i] & (1ull<<j)) {
1378                 prod[i] ^= (((__uint128_t)b->u64[i]) << j);
1379             }
1380         }
1381     }
1382
1383     r->u128 = prod[0] ^ prod[1];
1384
1385 #else
1386     int i, j;
1387     ppc_avr_t prod[2];
1388
1389     VECTOR_FOR_INORDER_I(i, u64) {
1390         prod[i].u64[LO_IDX] = prod[i].u64[HI_IDX] = 0;
1391         for (j = 0; j < 64; j++) {
1392             if (a->u64[i] & (1ull<<j)) {
1393                 ppc_avr_t bshift;
1394                 if (j == 0) {
1395                     bshift.u64[HI_IDX] = 0;
1396                     bshift.u64[LO_IDX] = b->u64[i];
1397                 } else {
1398                     bshift.u64[HI_IDX] = b->u64[i] >> (64-j);
1399                     bshift.u64[LO_IDX] = b->u64[i] << j;
1400                 }
1401                 prod[i].u64[LO_IDX] ^= bshift.u64[LO_IDX];
1402                 prod[i].u64[HI_IDX] ^= bshift.u64[HI_IDX];
1403             }
1404         }
1405     }
1406
1407     r->u64[LO_IDX] = prod[0].u64[LO_IDX] ^ prod[1].u64[LO_IDX];
1408     r->u64[HI_IDX] = prod[0].u64[HI_IDX] ^ prod[1].u64[HI_IDX];
1409 #endif
1410 }
1411
1412
1413 #if defined(HOST_WORDS_BIGENDIAN)
1414 #define PKBIG 1
1415 #else
1416 #define PKBIG 0
1417 #endif
1418 void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1419 {
1420     int i, j;
1421     ppc_avr_t result;
1422 #if defined(HOST_WORDS_BIGENDIAN)
1423     const ppc_avr_t *x[2] = { a, b };
1424 #else
1425     const ppc_avr_t *x[2] = { b, a };
1426 #endif
1427
1428     VECTOR_FOR_INORDER_I(i, u64) {
1429         VECTOR_FOR_INORDER_I(j, u32) {
1430             uint32_t e = x[i]->u32[j];
1431
1432             result.u16[4*i+j] = (((e >> 9) & 0xfc00) |
1433                                  ((e >> 6) & 0x3e0) |
1434                                  ((e >> 3) & 0x1f));
1435         }
1436     }
1437     *r = result;
1438 }
1439
1440 #define VPK(suffix, from, to, cvt, dosat)                               \
1441     void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r,             \
1442                             ppc_avr_t *a, ppc_avr_t *b)                 \
1443     {                                                                   \
1444         int i;                                                          \
1445         int sat = 0;                                                    \
1446         ppc_avr_t result;                                               \
1447         ppc_avr_t *a0 = PKBIG ? a : b;                                  \
1448         ppc_avr_t *a1 = PKBIG ? b : a;                                  \
1449                                                                         \
1450         VECTOR_FOR_INORDER_I(i, from) {                                 \
1451             result.to[i] = cvt(a0->from[i], &sat);                      \
1452             result.to[i+ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);  \
1453         }                                                               \
1454         *r = result;                                                    \
1455         if (dosat && sat) {                                             \
1456             env->vscr |= (1 << VSCR_SAT);                               \
1457         }                                                               \
1458     }
1459 #define I(x, y) (x)
1460 VPK(shss, s16, s8, cvtshsb, 1)
1461 VPK(shus, s16, u8, cvtshub, 1)
1462 VPK(swss, s32, s16, cvtswsh, 1)
1463 VPK(swus, s32, u16, cvtswuh, 1)
1464 VPK(sdss, s64, s32, cvtsdsw, 1)
1465 VPK(sdus, s64, u32, cvtsduw, 1)
1466 VPK(uhus, u16, u8, cvtuhub, 1)
1467 VPK(uwus, u32, u16, cvtuwuh, 1)
1468 VPK(udus, u64, u32, cvtuduw, 1)
1469 VPK(uhum, u16, u8, I, 0)
1470 VPK(uwum, u32, u16, I, 0)
1471 VPK(udum, u64, u32, I, 0)
1472 #undef I
1473 #undef VPK
1474 #undef PKBIG
1475
1476 void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1477 {
1478     int i;
1479
1480     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1481         r->f[i] = float32_div(float32_one, b->f[i], &env->vec_status);
1482     }
1483 }
1484
1485 #define VRFI(suffix, rounding)                                  \
1486     void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r,    \
1487                              ppc_avr_t *b)                      \
1488     {                                                           \
1489         int i;                                                  \
1490         float_status s = env->vec_status;                       \
1491                                                                 \
1492         set_float_rounding_mode(rounding, &s);                  \
1493         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                \
1494             r->f[i] = float32_round_to_int (b->f[i], &s);       \
1495         }                                                       \
1496     }
1497 VRFI(n, float_round_nearest_even)
1498 VRFI(m, float_round_down)
1499 VRFI(p, float_round_up)
1500 VRFI(z, float_round_to_zero)
1501 #undef VRFI
1502
1503 #define VROTATE(suffix, element, mask)                                  \
1504     void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)   \
1505     {                                                                   \
1506         int i;                                                          \
1507                                                                         \
1508         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1509             unsigned int shift = b->element[i] & mask;                  \
1510             r->element[i] = (a->element[i] << shift) |                  \
1511                 (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \
1512         }                                                               \
1513     }
1514 VROTATE(b, u8, 0x7)
1515 VROTATE(h, u16, 0xF)
1516 VROTATE(w, u32, 0x1F)
1517 VROTATE(d, u64, 0x3F)
1518 #undef VROTATE
1519
1520 void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1521 {
1522     int i;
1523
1524     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1525         float32 t = float32_sqrt(b->f[i], &env->vec_status);
1526
1527         r->f[i] = float32_div(float32_one, t, &env->vec_status);
1528     }
1529 }
1530
1531 void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1532                  ppc_avr_t *c)
1533 {
1534     r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]);
1535     r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]);
1536 }
1537
1538 void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1539 {
1540     int i;
1541
1542     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1543         r->f[i] = float32_exp2(b->f[i], &env->vec_status);
1544     }
1545 }
1546
1547 void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1548 {
1549     int i;
1550
1551     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1552         r->f[i] = float32_log2(b->f[i], &env->vec_status);
1553     }
1554 }
1555
1556 /* The specification says that the results are undefined if all of the
1557  * shift counts are not identical.  We check to make sure that they are
1558  * to conform to what real hardware appears to do.  */
1559 #define VSHIFT(suffix, leftp)                                           \
1560     void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)    \
1561     {                                                                   \
1562         int shift = b->u8[LO_IDX*15] & 0x7;                             \
1563         int doit = 1;                                                   \
1564         int i;                                                          \
1565                                                                         \
1566         for (i = 0; i < ARRAY_SIZE(r->u8); i++) {                       \
1567             doit = doit && ((b->u8[i] & 0x7) == shift);                 \
1568         }                                                               \
1569         if (doit) {                                                     \
1570             if (shift == 0) {                                           \
1571                 *r = *a;                                                \
1572             } else if (leftp) {                                         \
1573                 uint64_t carry = a->u64[LO_IDX] >> (64 - shift);        \
1574                                                                         \
1575                 r->u64[HI_IDX] = (a->u64[HI_IDX] << shift) | carry;     \
1576                 r->u64[LO_IDX] = a->u64[LO_IDX] << shift;               \
1577             } else {                                                    \
1578                 uint64_t carry = a->u64[HI_IDX] << (64 - shift);        \
1579                                                                         \
1580                 r->u64[LO_IDX] = (a->u64[LO_IDX] >> shift) | carry;     \
1581                 r->u64[HI_IDX] = a->u64[HI_IDX] >> shift;               \
1582             }                                                           \
1583         }                                                               \
1584     }
1585 VSHIFT(l, 1)
1586 VSHIFT(r, 0)
1587 #undef VSHIFT
1588
1589 #define VSL(suffix, element, mask)                                      \
1590     void helper_vsl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)   \
1591     {                                                                   \
1592         int i;                                                          \
1593                                                                         \
1594         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1595             unsigned int shift = b->element[i] & mask;                  \
1596                                                                         \
1597             r->element[i] = a->element[i] << shift;                     \
1598         }                                                               \
1599     }
1600 VSL(b, u8, 0x7)
1601 VSL(h, u16, 0x0F)
1602 VSL(w, u32, 0x1F)
1603 VSL(d, u64, 0x3F)
1604 #undef VSL
1605
1606 void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
1607 {
1608     int sh = shift & 0xf;
1609     int i;
1610     ppc_avr_t result;
1611
1612 #if defined(HOST_WORDS_BIGENDIAN)
1613     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1614         int index = sh + i;
1615         if (index > 0xf) {
1616             result.u8[i] = b->u8[index - 0x10];
1617         } else {
1618             result.u8[i] = a->u8[index];
1619         }
1620     }
1621 #else
1622     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1623         int index = (16 - sh) + i;
1624         if (index > 0xf) {
1625             result.u8[i] = a->u8[index - 0x10];
1626         } else {
1627             result.u8[i] = b->u8[index];
1628         }
1629     }
1630 #endif
1631     *r = result;
1632 }
1633
1634 void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1635 {
1636     int sh = (b->u8[LO_IDX*0xf] >> 3) & 0xf;
1637
1638 #if defined(HOST_WORDS_BIGENDIAN)
1639     memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1640     memset(&r->u8[16-sh], 0, sh);
1641 #else
1642     memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1643     memset(&r->u8[0], 0, sh);
1644 #endif
1645 }
1646
1647 /* Experimental testing shows that hardware masks the immediate.  */
1648 #define _SPLAT_MASKED(element) (splat & (ARRAY_SIZE(r->element) - 1))
1649 #if defined(HOST_WORDS_BIGENDIAN)
1650 #define SPLAT_ELEMENT(element) _SPLAT_MASKED(element)
1651 #else
1652 #define SPLAT_ELEMENT(element)                                  \
1653     (ARRAY_SIZE(r->element) - 1 - _SPLAT_MASKED(element))
1654 #endif
1655 #define VSPLT(suffix, element)                                          \
1656     void helper_vsplt##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t splat) \
1657     {                                                                   \
1658         uint32_t s = b->element[SPLAT_ELEMENT(element)];                \
1659         int i;                                                          \
1660                                                                         \
1661         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1662             r->element[i] = s;                                          \
1663         }                                                               \
1664     }
1665 VSPLT(b, u8)
1666 VSPLT(h, u16)
1667 VSPLT(w, u32)
1668 #undef VSPLT
1669 #undef SPLAT_ELEMENT
1670 #undef _SPLAT_MASKED
1671
1672 #define VSPLTI(suffix, element, splat_type)                     \
1673     void helper_vspltis##suffix(ppc_avr_t *r, uint32_t splat)   \
1674     {                                                           \
1675         splat_type x = (int8_t)(splat << 3) >> 3;               \
1676         int i;                                                  \
1677                                                                 \
1678         for (i = 0; i < ARRAY_SIZE(r->element); i++) {          \
1679             r->element[i] = x;                                  \
1680         }                                                       \
1681     }
1682 VSPLTI(b, s8, int8_t)
1683 VSPLTI(h, s16, int16_t)
1684 VSPLTI(w, s32, int32_t)
1685 #undef VSPLTI
1686
1687 #define VSR(suffix, element, mask)                                      \
1688     void helper_vsr##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)   \
1689     {                                                                   \
1690         int i;                                                          \
1691                                                                         \
1692         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1693             unsigned int shift = b->element[i] & mask;                  \
1694             r->element[i] = a->element[i] >> shift;                     \
1695         }                                                               \
1696     }
1697 VSR(ab, s8, 0x7)
1698 VSR(ah, s16, 0xF)
1699 VSR(aw, s32, 0x1F)
1700 VSR(ad, s64, 0x3F)
1701 VSR(b, u8, 0x7)
1702 VSR(h, u16, 0xF)
1703 VSR(w, u32, 0x1F)
1704 VSR(d, u64, 0x3F)
1705 #undef VSR
1706
1707 void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1708 {
1709     int sh = (b->u8[LO_IDX * 0xf] >> 3) & 0xf;
1710
1711 #if defined(HOST_WORDS_BIGENDIAN)
1712     memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1713     memset(&r->u8[0], 0, sh);
1714 #else
1715     memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1716     memset(&r->u8[16 - sh], 0, sh);
1717 #endif
1718 }
1719
1720 void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1721 {
1722     int i;
1723
1724     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1725         r->u32[i] = a->u32[i] >= b->u32[i];
1726     }
1727 }
1728
1729 void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1730 {
1731     int64_t t;
1732     int i, upper;
1733     ppc_avr_t result;
1734     int sat = 0;
1735
1736 #if defined(HOST_WORDS_BIGENDIAN)
1737     upper = ARRAY_SIZE(r->s32)-1;
1738 #else
1739     upper = 0;
1740 #endif
1741     t = (int64_t)b->s32[upper];
1742     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1743         t += a->s32[i];
1744         result.s32[i] = 0;
1745     }
1746     result.s32[upper] = cvtsdsw(t, &sat);
1747     *r = result;
1748
1749     if (sat) {
1750         env->vscr |= (1 << VSCR_SAT);
1751     }
1752 }
1753
1754 void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1755 {
1756     int i, j, upper;
1757     ppc_avr_t result;
1758     int sat = 0;
1759
1760 #if defined(HOST_WORDS_BIGENDIAN)
1761     upper = 1;
1762 #else
1763     upper = 0;
1764 #endif
1765     for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
1766         int64_t t = (int64_t)b->s32[upper + i * 2];
1767
1768         result.u64[i] = 0;
1769         for (j = 0; j < ARRAY_SIZE(r->u64); j++) {
1770             t += a->s32[2 * i + j];
1771         }
1772         result.s32[upper + i * 2] = cvtsdsw(t, &sat);
1773     }
1774
1775     *r = result;
1776     if (sat) {
1777         env->vscr |= (1 << VSCR_SAT);
1778     }
1779 }
1780
1781 void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1782 {
1783     int i, j;
1784     int sat = 0;
1785
1786     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1787         int64_t t = (int64_t)b->s32[i];
1788
1789         for (j = 0; j < ARRAY_SIZE(r->s32); j++) {
1790             t += a->s8[4 * i + j];
1791         }
1792         r->s32[i] = cvtsdsw(t, &sat);
1793     }
1794
1795     if (sat) {
1796         env->vscr |= (1 << VSCR_SAT);
1797     }
1798 }
1799
1800 void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1801 {
1802     int sat = 0;
1803     int i;
1804
1805     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1806         int64_t t = (int64_t)b->s32[i];
1807
1808         t += a->s16[2 * i] + a->s16[2 * i + 1];
1809         r->s32[i] = cvtsdsw(t, &sat);
1810     }
1811
1812     if (sat) {
1813         env->vscr |= (1 << VSCR_SAT);
1814     }
1815 }
1816
1817 void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1818 {
1819     int i, j;
1820     int sat = 0;
1821
1822     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1823         uint64_t t = (uint64_t)b->u32[i];
1824
1825         for (j = 0; j < ARRAY_SIZE(r->u32); j++) {
1826             t += a->u8[4 * i + j];
1827         }
1828         r->u32[i] = cvtuduw(t, &sat);
1829     }
1830
1831     if (sat) {
1832         env->vscr |= (1 << VSCR_SAT);
1833     }
1834 }
1835
1836 #if defined(HOST_WORDS_BIGENDIAN)
1837 #define UPKHI 1
1838 #define UPKLO 0
1839 #else
1840 #define UPKHI 0
1841 #define UPKLO 1
1842 #endif
1843 #define VUPKPX(suffix, hi)                                              \
1844     void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b)                \
1845     {                                                                   \
1846         int i;                                                          \
1847         ppc_avr_t result;                                               \
1848                                                                         \
1849         for (i = 0; i < ARRAY_SIZE(r->u32); i++) {                      \
1850             uint16_t e = b->u16[hi ? i : i+4];                          \
1851             uint8_t a = (e >> 15) ? 0xff : 0;                           \
1852             uint8_t r = (e >> 10) & 0x1f;                               \
1853             uint8_t g = (e >> 5) & 0x1f;                                \
1854             uint8_t b = e & 0x1f;                                       \
1855                                                                         \
1856             result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b;       \
1857         }                                                               \
1858         *r = result;                                                    \
1859     }
1860 VUPKPX(lpx, UPKLO)
1861 VUPKPX(hpx, UPKHI)
1862 #undef VUPKPX
1863
1864 #define VUPK(suffix, unpacked, packee, hi)                              \
1865     void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b)                \
1866     {                                                                   \
1867         int i;                                                          \
1868         ppc_avr_t result;                                               \
1869                                                                         \
1870         if (hi) {                                                       \
1871             for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) {             \
1872                 result.unpacked[i] = b->packee[i];                      \
1873             }                                                           \
1874         } else {                                                        \
1875             for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \
1876                  i++) {                                                 \
1877                 result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \
1878             }                                                           \
1879         }                                                               \
1880         *r = result;                                                    \
1881     }
1882 VUPK(hsb, s16, s8, UPKHI)
1883 VUPK(hsh, s32, s16, UPKHI)
1884 VUPK(hsw, s64, s32, UPKHI)
1885 VUPK(lsb, s16, s8, UPKLO)
1886 VUPK(lsh, s32, s16, UPKLO)
1887 VUPK(lsw, s64, s32, UPKLO)
1888 #undef VUPK
1889 #undef UPKHI
1890 #undef UPKLO
1891
1892 #define VGENERIC_DO(name, element)                                      \
1893     void helper_v##name(ppc_avr_t *r, ppc_avr_t *b)                     \
1894     {                                                                   \
1895         int i;                                                          \
1896                                                                         \
1897         VECTOR_FOR_INORDER_I(i, element) {                              \
1898             r->element[i] = name(b->element[i]);                        \
1899         }                                                               \
1900     }
1901
1902 #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8)
1903 #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16)
1904 #define clzw(v) clz32((v))
1905 #define clzd(v) clz64((v))
1906
1907 VGENERIC_DO(clzb, u8)
1908 VGENERIC_DO(clzh, u16)
1909 VGENERIC_DO(clzw, u32)
1910 VGENERIC_DO(clzd, u64)
1911
1912 #undef clzb
1913 #undef clzh
1914 #undef clzw
1915 #undef clzd
1916
1917 #define popcntb(v) ctpop8(v)
1918 #define popcnth(v) ctpop16(v)
1919 #define popcntw(v) ctpop32(v)
1920 #define popcntd(v) ctpop64(v)
1921
1922 VGENERIC_DO(popcntb, u8)
1923 VGENERIC_DO(popcnth, u16)
1924 VGENERIC_DO(popcntw, u32)
1925 VGENERIC_DO(popcntd, u64)
1926
1927 #undef popcntb
1928 #undef popcnth
1929 #undef popcntw
1930 #undef popcntd
1931
1932 #undef VGENERIC_DO
1933
1934 #if defined(HOST_WORDS_BIGENDIAN)
1935 #define QW_ONE { .u64 = { 0, 1 } }
1936 #else
1937 #define QW_ONE { .u64 = { 1, 0 } }
1938 #endif
1939
1940 #ifndef CONFIG_INT128
1941
1942 static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a)
1943 {
1944     t->u64[0] = ~a.u64[0];
1945     t->u64[1] = ~a.u64[1];
1946 }
1947
1948 static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b)
1949 {
1950     if (a.u64[HI_IDX] < b.u64[HI_IDX]) {
1951         return -1;
1952     } else if (a.u64[HI_IDX] > b.u64[HI_IDX]) {
1953         return 1;
1954     } else if (a.u64[LO_IDX] < b.u64[LO_IDX]) {
1955         return -1;
1956     } else if (a.u64[LO_IDX] > b.u64[LO_IDX]) {
1957         return 1;
1958     } else {
1959         return 0;
1960     }
1961 }
1962
1963 static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
1964 {
1965     t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX];
1966     t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] +
1967                      (~a.u64[LO_IDX] < b.u64[LO_IDX]);
1968 }
1969
1970 static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
1971 {
1972     ppc_avr_t not_a;
1973     t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX];
1974     t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] +
1975                      (~a.u64[LO_IDX] < b.u64[LO_IDX]);
1976     avr_qw_not(&not_a, a);
1977     return avr_qw_cmpu(not_a, b) < 0;
1978 }
1979
1980 #endif
1981
1982 void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1983 {
1984 #ifdef CONFIG_INT128
1985     r->u128 = a->u128 + b->u128;
1986 #else
1987     avr_qw_add(r, *a, *b);
1988 #endif
1989 }
1990
1991 void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1992 {
1993 #ifdef CONFIG_INT128
1994     r->u128 = a->u128 + b->u128 + (c->u128 & 1);
1995 #else
1996
1997     if (c->u64[LO_IDX] & 1) {
1998         ppc_avr_t tmp;
1999
2000         tmp.u64[HI_IDX] = 0;
2001         tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1;
2002         avr_qw_add(&tmp, *a, tmp);
2003         avr_qw_add(r, tmp, *b);
2004     } else {
2005         avr_qw_add(r, *a, *b);
2006     }
2007 #endif
2008 }
2009
2010 void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2011 {
2012 #ifdef CONFIG_INT128
2013     r->u128 = (~a->u128 < b->u128);
2014 #else
2015     ppc_avr_t not_a;
2016
2017     avr_qw_not(&not_a, *a);
2018
2019     r->u64[HI_IDX] = 0;
2020     r->u64[LO_IDX] = (avr_qw_cmpu(not_a, *b) < 0);
2021 #endif
2022 }
2023
2024 void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2025 {
2026 #ifdef CONFIG_INT128
2027     int carry_out = (~a->u128 < b->u128);
2028     if (!carry_out && (c->u128 & 1)) {
2029         carry_out = ((a->u128 + b->u128 + 1) == 0) &&
2030                     ((a->u128 != 0) || (b->u128 != 0));
2031     }
2032     r->u128 = carry_out;
2033 #else
2034
2035     int carry_in = c->u64[LO_IDX] & 1;
2036     int carry_out = 0;
2037     ppc_avr_t tmp;
2038
2039     carry_out = avr_qw_addc(&tmp, *a, *b);
2040
2041     if (!carry_out && carry_in) {
2042         ppc_avr_t one = QW_ONE;
2043         carry_out = avr_qw_addc(&tmp, tmp, one);
2044     }
2045     r->u64[HI_IDX] = 0;
2046     r->u64[LO_IDX] = carry_out;
2047 #endif
2048 }
2049
2050 void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2051 {
2052 #ifdef CONFIG_INT128
2053     r->u128 = a->u128 - b->u128;
2054 #else
2055     ppc_avr_t tmp;
2056     ppc_avr_t one = QW_ONE;
2057
2058     avr_qw_not(&tmp, *b);
2059     avr_qw_add(&tmp, *a, tmp);
2060     avr_qw_add(r, tmp, one);
2061 #endif
2062 }
2063
2064 void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2065 {
2066 #ifdef CONFIG_INT128
2067     r->u128 = a->u128 + ~b->u128 + (c->u128 & 1);
2068 #else
2069     ppc_avr_t tmp, sum;
2070
2071     avr_qw_not(&tmp, *b);
2072     avr_qw_add(&sum, *a, tmp);
2073
2074     tmp.u64[HI_IDX] = 0;
2075     tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1;
2076     avr_qw_add(r, sum, tmp);
2077 #endif
2078 }
2079
2080 void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2081 {
2082 #ifdef CONFIG_INT128
2083     r->u128 = (~a->u128 < ~b->u128) ||
2084                  (a->u128 + ~b->u128 == (__uint128_t)-1);
2085 #else
2086     int carry = (avr_qw_cmpu(*a, *b) > 0);
2087     if (!carry) {
2088         ppc_avr_t tmp;
2089         avr_qw_not(&tmp, *b);
2090         avr_qw_add(&tmp, *a, tmp);
2091         carry = ((tmp.s64[HI_IDX] == -1ull) && (tmp.s64[LO_IDX] == -1ull));
2092     }
2093     r->u64[HI_IDX] = 0;
2094     r->u64[LO_IDX] = carry;
2095 #endif
2096 }
2097
2098 void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2099 {
2100 #ifdef CONFIG_INT128
2101     r->u128 =
2102         (~a->u128 < ~b->u128) ||
2103         ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1));
2104 #else
2105     int carry_in = c->u64[LO_IDX] & 1;
2106     int carry_out = (avr_qw_cmpu(*a, *b) > 0);
2107     if (!carry_out && carry_in) {
2108         ppc_avr_t tmp;
2109         avr_qw_not(&tmp, *b);
2110         avr_qw_add(&tmp, *a, tmp);
2111         carry_out = ((tmp.u64[HI_IDX] == -1ull) && (tmp.u64[LO_IDX] == -1ull));
2112     }
2113
2114     r->u64[HI_IDX] = 0;
2115     r->u64[LO_IDX] = carry_out;
2116 #endif
2117 }
2118
2119 #define BCD_PLUS_PREF_1 0xC
2120 #define BCD_PLUS_PREF_2 0xF
2121 #define BCD_PLUS_ALT_1  0xA
2122 #define BCD_NEG_PREF    0xD
2123 #define BCD_NEG_ALT     0xB
2124 #define BCD_PLUS_ALT_2  0xE
2125
2126 #if defined(HOST_WORDS_BIGENDIAN)
2127 #define BCD_DIG_BYTE(n) (15 - (n/2))
2128 #else
2129 #define BCD_DIG_BYTE(n) (n/2)
2130 #endif
2131
2132 static int bcd_get_sgn(ppc_avr_t *bcd)
2133 {
2134     switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) {
2135     case BCD_PLUS_PREF_1:
2136     case BCD_PLUS_PREF_2:
2137     case BCD_PLUS_ALT_1:
2138     case BCD_PLUS_ALT_2:
2139     {
2140         return 1;
2141     }
2142
2143     case BCD_NEG_PREF:
2144     case BCD_NEG_ALT:
2145     {
2146         return -1;
2147     }
2148
2149     default:
2150     {
2151         return 0;
2152     }
2153     }
2154 }
2155
2156 static int bcd_preferred_sgn(int sgn, int ps)
2157 {
2158     if (sgn >= 0) {
2159         return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2;
2160     } else {
2161         return BCD_NEG_PREF;
2162     }
2163 }
2164
2165 static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid)
2166 {
2167     uint8_t result;
2168     if (n & 1) {
2169         result = bcd->u8[BCD_DIG_BYTE(n)] >> 4;
2170     } else {
2171        result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF;
2172     }
2173
2174     if (unlikely(result > 9)) {
2175         *invalid = true;
2176     }
2177     return result;
2178 }
2179
2180 static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n)
2181 {
2182     if (n & 1) {
2183         bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F;
2184         bcd->u8[BCD_DIG_BYTE(n)] |= (digit<<4);
2185     } else {
2186         bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0;
2187         bcd->u8[BCD_DIG_BYTE(n)] |= digit;
2188     }
2189 }
2190
2191 static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b)
2192 {
2193     int i;
2194     int invalid = 0;
2195     for (i = 31; i > 0; i--) {
2196         uint8_t dig_a = bcd_get_digit(a, i, &invalid);
2197         uint8_t dig_b = bcd_get_digit(b, i, &invalid);
2198         if (unlikely(invalid)) {
2199             return 0; /* doesn't matter */
2200         } else if (dig_a > dig_b) {
2201             return 1;
2202         } else if (dig_a < dig_b) {
2203             return -1;
2204         }
2205     }
2206
2207     return 0;
2208 }
2209
2210 static int bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2211                        int *overflow)
2212 {
2213     int carry = 0;
2214     int i;
2215     int is_zero = 1;
2216     for (i = 1; i <= 31; i++) {
2217         uint8_t digit = bcd_get_digit(a, i, invalid) +
2218                         bcd_get_digit(b, i, invalid) + carry;
2219         is_zero &= (digit == 0);
2220         if (digit > 9) {
2221             carry = 1;
2222             digit -= 10;
2223         } else {
2224             carry = 0;
2225         }
2226
2227         bcd_put_digit(t, digit, i);
2228
2229         if (unlikely(*invalid)) {
2230             return -1;
2231         }
2232     }
2233
2234     *overflow = carry;
2235     return is_zero;
2236 }
2237
2238 static int bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2239                        int *overflow)
2240 {
2241     int carry = 0;
2242     int i;
2243     int is_zero = 1;
2244     for (i = 1; i <= 31; i++) {
2245         uint8_t digit = bcd_get_digit(a, i, invalid) -
2246                         bcd_get_digit(b, i, invalid) + carry;
2247         is_zero &= (digit == 0);
2248         if (digit & 0x80) {
2249             carry = -1;
2250             digit += 10;
2251         } else {
2252             carry = 0;
2253         }
2254
2255         bcd_put_digit(t, digit, i);
2256
2257         if (unlikely(*invalid)) {
2258             return -1;
2259         }
2260     }
2261
2262     *overflow = carry;
2263     return is_zero;
2264 }
2265
2266 uint32_t helper_bcdadd(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2267 {
2268
2269     int sgna = bcd_get_sgn(a);
2270     int sgnb = bcd_get_sgn(b);
2271     int invalid = (sgna == 0) || (sgnb == 0);
2272     int overflow = 0;
2273     int zero = 0;
2274     uint32_t cr = 0;
2275     ppc_avr_t result = { .u64 = { 0, 0 } };
2276
2277     if (!invalid) {
2278         if (sgna == sgnb) {
2279             result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2280             zero = bcd_add_mag(&result, a, b, &invalid, &overflow);
2281             cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2282         } else if (bcd_cmp_mag(a, b) > 0) {
2283             result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2284             zero = bcd_sub_mag(&result, a, b, &invalid, &overflow);
2285             cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2286         } else {
2287             result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps);
2288             zero = bcd_sub_mag(&result, b, a, &invalid, &overflow);
2289             cr = (sgnb > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2290         }
2291     }
2292
2293     if (unlikely(invalid)) {
2294         result.u64[HI_IDX] = result.u64[LO_IDX] = -1;
2295         cr = 1 << CRF_SO;
2296     } else if (overflow) {
2297         cr |= 1 << CRF_SO;
2298     } else if (zero) {
2299         cr = 1 << CRF_EQ;
2300     }
2301
2302     *r = result;
2303
2304     return cr;
2305 }
2306
2307 uint32_t helper_bcdsub(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2308 {
2309     ppc_avr_t bcopy = *b;
2310     int sgnb = bcd_get_sgn(b);
2311     if (sgnb < 0) {
2312         bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0);
2313     } else if (sgnb > 0) {
2314         bcd_put_digit(&bcopy, BCD_NEG_PREF, 0);
2315     }
2316     /* else invalid ... defer to bcdadd code for proper handling */
2317
2318     return helper_bcdadd(r, a, &bcopy, ps);
2319 }
2320
2321 void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a)
2322 {
2323     int i;
2324     VECTOR_FOR_INORDER_I(i, u8) {
2325         r->u8[i] = AES_sbox[a->u8[i]];
2326     }
2327 }
2328
2329 void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2330 {
2331     ppc_avr_t result;
2332     int i;
2333
2334     VECTOR_FOR_INORDER_I(i, u32) {
2335         result.AVRW(i) = b->AVRW(i) ^
2336             (AES_Te0[a->AVRB(AES_shifts[4*i + 0])] ^
2337              AES_Te1[a->AVRB(AES_shifts[4*i + 1])] ^
2338              AES_Te2[a->AVRB(AES_shifts[4*i + 2])] ^
2339              AES_Te3[a->AVRB(AES_shifts[4*i + 3])]);
2340     }
2341     *r = result;
2342 }
2343
2344 void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2345 {
2346     ppc_avr_t result;
2347     int i;
2348
2349     VECTOR_FOR_INORDER_I(i, u8) {
2350         result.AVRB(i) = b->AVRB(i) ^ (AES_sbox[a->AVRB(AES_shifts[i])]);
2351     }
2352     *r = result;
2353 }
2354
2355 void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2356 {
2357     /* This differs from what is written in ISA V2.07.  The RTL is */
2358     /* incorrect and will be fixed in V2.07B.                      */
2359     int i;
2360     ppc_avr_t tmp;
2361
2362     VECTOR_FOR_INORDER_I(i, u8) {
2363         tmp.AVRB(i) = b->AVRB(i) ^ AES_isbox[a->AVRB(AES_ishifts[i])];
2364     }
2365
2366     VECTOR_FOR_INORDER_I(i, u32) {
2367         r->AVRW(i) =
2368             AES_imc[tmp.AVRB(4*i + 0)][0] ^
2369             AES_imc[tmp.AVRB(4*i + 1)][1] ^
2370             AES_imc[tmp.AVRB(4*i + 2)][2] ^
2371             AES_imc[tmp.AVRB(4*i + 3)][3];
2372     }
2373 }
2374
2375 void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2376 {
2377     ppc_avr_t result;
2378     int i;
2379
2380     VECTOR_FOR_INORDER_I(i, u8) {
2381         result.AVRB(i) = b->AVRB(i) ^ (AES_isbox[a->AVRB(AES_ishifts[i])]);
2382     }
2383     *r = result;
2384 }
2385
2386 #define ROTRu32(v, n) (((v) >> (n)) | ((v) << (32-n)))
2387 #if defined(HOST_WORDS_BIGENDIAN)
2388 #define EL_IDX(i) (i)
2389 #else
2390 #define EL_IDX(i) (3 - (i))
2391 #endif
2392
2393 void helper_vshasigmaw(ppc_avr_t *r,  ppc_avr_t *a, uint32_t st_six)
2394 {
2395     int st = (st_six & 0x10) != 0;
2396     int six = st_six & 0xF;
2397     int i;
2398
2399     VECTOR_FOR_INORDER_I(i, u32) {
2400         if (st == 0) {
2401             if ((six & (0x8 >> i)) == 0) {
2402                 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 7) ^
2403                                     ROTRu32(a->u32[EL_IDX(i)], 18) ^
2404                                     (a->u32[EL_IDX(i)] >> 3);
2405             } else { /* six.bit[i] == 1 */
2406                 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 17) ^
2407                                     ROTRu32(a->u32[EL_IDX(i)], 19) ^
2408                                     (a->u32[EL_IDX(i)] >> 10);
2409             }
2410         } else { /* st == 1 */
2411             if ((six & (0x8 >> i)) == 0) {
2412                 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 2) ^
2413                                     ROTRu32(a->u32[EL_IDX(i)], 13) ^
2414                                     ROTRu32(a->u32[EL_IDX(i)], 22);
2415             } else { /* six.bit[i] == 1 */
2416                 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 6) ^
2417                                     ROTRu32(a->u32[EL_IDX(i)], 11) ^
2418                                     ROTRu32(a->u32[EL_IDX(i)], 25);
2419             }
2420         }
2421     }
2422 }
2423
2424 #undef ROTRu32
2425 #undef EL_IDX
2426
2427 #define ROTRu64(v, n) (((v) >> (n)) | ((v) << (64-n)))
2428 #if defined(HOST_WORDS_BIGENDIAN)
2429 #define EL_IDX(i) (i)
2430 #else
2431 #define EL_IDX(i) (1 - (i))
2432 #endif
2433
2434 void helper_vshasigmad(ppc_avr_t *r,  ppc_avr_t *a, uint32_t st_six)
2435 {
2436     int st = (st_six & 0x10) != 0;
2437     int six = st_six & 0xF;
2438     int i;
2439
2440     VECTOR_FOR_INORDER_I(i, u64) {
2441         if (st == 0) {
2442             if ((six & (0x8 >> (2*i))) == 0) {
2443                 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 1) ^
2444                                     ROTRu64(a->u64[EL_IDX(i)], 8) ^
2445                                     (a->u64[EL_IDX(i)] >> 7);
2446             } else { /* six.bit[2*i] == 1 */
2447                 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 19) ^
2448                                     ROTRu64(a->u64[EL_IDX(i)], 61) ^
2449                                     (a->u64[EL_IDX(i)] >> 6);
2450             }
2451         } else { /* st == 1 */
2452             if ((six & (0x8 >> (2*i))) == 0) {
2453                 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 28) ^
2454                                     ROTRu64(a->u64[EL_IDX(i)], 34) ^
2455                                     ROTRu64(a->u64[EL_IDX(i)], 39);
2456             } else { /* six.bit[2*i] == 1 */
2457                 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 14) ^
2458                                     ROTRu64(a->u64[EL_IDX(i)], 18) ^
2459                                     ROTRu64(a->u64[EL_IDX(i)], 41);
2460             }
2461         }
2462     }
2463 }
2464
2465 #undef ROTRu64
2466 #undef EL_IDX
2467
2468 void helper_vpermxor(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2469 {
2470     ppc_avr_t result;
2471     int i;
2472
2473     VECTOR_FOR_INORDER_I(i, u8) {
2474         int indexA = c->u8[i] >> 4;
2475         int indexB = c->u8[i] & 0xF;
2476 #if defined(HOST_WORDS_BIGENDIAN)
2477         result.u8[i] = a->u8[indexA] ^ b->u8[indexB];
2478 #else
2479         result.u8[i] = a->u8[15-indexA] ^ b->u8[15-indexB];
2480 #endif
2481     }
2482     *r = result;
2483 }
2484
2485 #undef VECTOR_FOR_INORDER_I
2486 #undef HI_IDX
2487 #undef LO_IDX
2488
2489 /*****************************************************************************/
2490 /* SPE extension helpers */
2491 /* Use a table to make this quicker */
2492 static const uint8_t hbrev[16] = {
2493     0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
2494     0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
2495 };
2496
2497 static inline uint8_t byte_reverse(uint8_t val)
2498 {
2499     return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
2500 }
2501
2502 static inline uint32_t word_reverse(uint32_t val)
2503 {
2504     return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
2505         (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
2506 }
2507
2508 #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */
2509 target_ulong helper_brinc(target_ulong arg1, target_ulong arg2)
2510 {
2511     uint32_t a, b, d, mask;
2512
2513     mask = UINT32_MAX >> (32 - MASKBITS);
2514     a = arg1 & mask;
2515     b = arg2 & mask;
2516     d = word_reverse(1 + word_reverse(a | ~b));
2517     return (arg1 & ~mask) | (d & b);
2518 }
2519
2520 uint32_t helper_cntlsw32(uint32_t val)
2521 {
2522     if (val & 0x80000000) {
2523         return clz32(~val);
2524     } else {
2525         return clz32(val);
2526     }
2527 }
2528
2529 uint32_t helper_cntlzw32(uint32_t val)
2530 {
2531     return clz32(val);
2532 }
2533
2534 /* 440 specific */
2535 target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high,
2536                           target_ulong low, uint32_t update_Rc)
2537 {
2538     target_ulong mask;
2539     int i;
2540
2541     i = 1;
2542     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2543         if ((high & mask) == 0) {
2544             if (update_Rc) {
2545                 env->crf[0] = 0x4;
2546             }
2547             goto done;
2548         }
2549         i++;
2550     }
2551     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2552         if ((low & mask) == 0) {
2553             if (update_Rc) {
2554                 env->crf[0] = 0x8;
2555             }
2556             goto done;
2557         }
2558         i++;
2559     }
2560     i = 8;
2561     if (update_Rc) {
2562         env->crf[0] = 0x2;
2563     }
2564  done:
2565     env->xer = (env->xer & ~0x7F) | i;
2566     if (update_Rc) {
2567         env->crf[0] |= xer_so;
2568     }
2569     return i;
2570 }