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 "internal.h"
  22 #include "qemu/host-utils.h"
  23 #include "exec/helper-proto.h"
  24 #include "crypto/aes.h"
  25 #include "fpu/softfloat.h"
  26 #include "qapi/error.h"
  27 #include "qemu/guest-random.h"
  28
  29 #include "helper_regs.h"
  30 /*****************************************************************************/
  31 /* Fixed point operations helpers */
  32
  33 static inline void helper_update_ov_legacy(CPUPPCState *env, int ov)
  34 {
  35     if (unlikely(ov)) {
  36         env->so = env->ov = 1;
  37     } else {
  38         env->ov = 0;
  39     }
  40 }
  41
  42 target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb,
  43                            uint32_t oe)
  44 {
  45     uint64_t rt = 0;
  46     int overflow = 0;
  47
  48     uint64_t dividend = (uint64_t)ra << 32;
  49     uint64_t divisor = (uint32_t)rb;
  50
  51     if (unlikely(divisor == 0)) {
  52         overflow = 1;
  53     } else {
  54         rt = dividend / divisor;
  55         overflow = rt > UINT32_MAX;
  56     }
  57
  58     if (unlikely(overflow)) {
  59         rt = 0; /* Undefined */
  60     }
  61
  62     if (oe) {
  63         helper_update_ov_legacy(env, overflow);
  64     }
  65
  66     return (target_ulong)rt;
  67 }
  68
  69 target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb,
  70                           uint32_t oe)
  71 {
  72     int64_t rt = 0;
  73     int overflow = 0;
  74
  75     int64_t dividend = (int64_t)ra << 32;
  76     int64_t divisor = (int64_t)((int32_t)rb);
  77
  78     if (unlikely((divisor == 0) ||
  79                  ((divisor == -1ull) && (dividend == INT64_MIN)))) {
  80         overflow = 1;
  81     } else {
  82         rt = dividend / divisor;
  83         overflow = rt != (int32_t)rt;
  84     }
  85
  86     if (unlikely(overflow)) {
  87         rt = 0; /* Undefined */
  88     }
  89
  90     if (oe) {
  91         helper_update_ov_legacy(env, overflow);
  92     }
  93
  94     return (target_ulong)rt;
  95 }
  96
  97 #if defined(TARGET_PPC64)
  98
  99 uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe)
 100 {
 101     uint64_t rt = 0;
 102     int overflow = 0;
 103
 104     overflow = divu128(&rt, &ra, rb);
 105
 106     if (unlikely(overflow)) {
 107         rt = 0; /* Undefined */
 108     }
 109
 110     if (oe) {
 111         helper_update_ov_legacy(env, overflow);
 112     }
 113
 114     return rt;
 115 }
 116
 117 uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe)
 118 {
 119     int64_t rt = 0;
 120     int64_t ra = (int64_t)rau;
 121     int64_t rb = (int64_t)rbu;
 122     int overflow = divs128(&rt, &ra, rb);
 123
 124     if (unlikely(overflow)) {
 125         rt = 0; /* Undefined */
 126     }
 127
 128     if (oe) {
 129         helper_update_ov_legacy(env, overflow);
 130     }
 131
 132     return rt;
 133 }
 134
 135 #endif
 136
 137
 138 #if defined(TARGET_PPC64)
 139 /* if x = 0xab, returns 0xababababababababa */
 140 #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff))
 141
 142 /*
 143  * subtract 1 from each byte, and with inverse, check if MSB is set at each
 144  * byte.
 145  * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80
 146  *      (0xFF & 0xFF) & 0x80 = 0x80 (zero found)
 147  */
 148 #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80))
 149
 150 /* When you XOR the pattern and there is a match, that byte will be zero */
 151 #define hasvalue(x, n)  (haszero((x) ^ pattern(n)))
 152
 153 uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb)
 154 {
 155     return hasvalue(rb, ra) ? CRF_GT : 0;
 156 }
 157
 158 #undef pattern
 159 #undef haszero
 160 #undef hasvalue
 161
 162 /*
 163  * Return a random number.
 164  */
 165 uint64_t helper_darn32(void)
 166 {
 167     Error *err = NULL;
 168     uint32_t ret;
 169
 170     if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) {
 171         qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s",
 172                       error_get_pretty(err));
 173         error_free(err);
 174         return -1;
 175     }
 176
 177     return ret;
 178 }
 179
 180 uint64_t helper_darn64(void)
 181 {
 182     Error *err = NULL;
 183     uint64_t ret;
 184
 185     if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) {
 186         qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s",
 187                       error_get_pretty(err));
 188         error_free(err);
 189         return -1;
 190     }
 191
 192     return ret;
 193 }
 194
 195 uint64_t helper_bpermd(uint64_t rs, uint64_t rb)
 196 {
 197     int i;
 198     uint64_t ra = 0;
 199
 200     for (i = 0; i < 8; i++) {
 201         int index = (rs >> (i * 8)) & 0xFF;
 202         if (index < 64) {
 203             if (rb & PPC_BIT(index)) {
 204                 ra |= 1 << i;
 205             }
 206         }
 207     }
 208     return ra;
 209 }
 210
 211 #endif
 212
 213 target_ulong helper_cmpb(target_ulong rs, target_ulong rb)
 214 {
 215     target_ulong mask = 0xff;
 216     target_ulong ra = 0;
 217     int i;
 218
 219     for (i = 0; i < sizeof(target_ulong); i++) {
 220         if ((rs & mask) == (rb & mask)) {
 221             ra |= mask;
 222         }
 223         mask <<= 8;
 224     }
 225     return ra;
 226 }
 227
 228 /* shift right arithmetic helper */
 229 target_ulong helper_sraw(CPUPPCState *env, target_ulong value,
 230                          target_ulong shift)
 231 {
 232     int32_t ret;
 233
 234     if (likely(!(shift & 0x20))) {
 235         if (likely((uint32_t)shift != 0)) {
 236             shift &= 0x1f;
 237             ret = (int32_t)value >> shift;
 238             if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
 239                 env->ca32 = env->ca = 0;
 240             } else {
 241                 env->ca32 = env->ca = 1;
 242             }
 243         } else {
 244             ret = (int32_t)value;
 245             env->ca32 = env->ca = 0;
 246         }
 247     } else {
 248         ret = (int32_t)value >> 31;
 249         env->ca32 = env->ca = (ret != 0);
 250     }
 251     return (target_long)ret;
 252 }
 253
 254 #if defined(TARGET_PPC64)
 255 target_ulong helper_srad(CPUPPCState *env, target_ulong value,
 256                          target_ulong shift)
 257 {
 258     int64_t ret;
 259
 260     if (likely(!(shift & 0x40))) {
 261         if (likely((uint64_t)shift != 0)) {
 262             shift &= 0x3f;
 263             ret = (int64_t)value >> shift;
 264             if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) {
 265                 env->ca32 = env->ca = 0;
 266             } else {
 267                 env->ca32 = env->ca = 1;
 268             }
 269         } else {
 270             ret = (int64_t)value;
 271             env->ca32 = env->ca = 0;
 272         }
 273     } else {
 274         ret = (int64_t)value >> 63;
 275         env->ca32 = env->ca = (ret != 0);
 276     }
 277     return ret;
 278 }
 279 #endif
 280
 281 #if defined(TARGET_PPC64)
 282 target_ulong helper_popcntb(target_ulong val)
 283 {
 284     /* Note that we don't fold past bytes */
 285     val = (val & 0x5555555555555555ULL) + ((val >>  1) &
 286                                            0x5555555555555555ULL);
 287     val = (val & 0x3333333333333333ULL) + ((val >>  2) &
 288                                            0x3333333333333333ULL);
 289     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) &
 290                                            0x0f0f0f0f0f0f0f0fULL);
 291     return val;
 292 }
 293
 294 target_ulong helper_popcntw(target_ulong val)
 295 {
 296     /* Note that we don't fold past words.  */
 297     val = (val & 0x5555555555555555ULL) + ((val >>  1) &
 298                                            0x5555555555555555ULL);
 299     val = (val & 0x3333333333333333ULL) + ((val >>  2) &
 300                                            0x3333333333333333ULL);
 301     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) &
 302                                            0x0f0f0f0f0f0f0f0fULL);
 303     val = (val & 0x00ff00ff00ff00ffULL) + ((val >>  8) &
 304                                            0x00ff00ff00ff00ffULL);
 305     val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) &
 306                                            0x0000ffff0000ffffULL);
 307     return val;
 308 }
 309 #else
 310 target_ulong helper_popcntb(target_ulong val)
 311 {
 312     /* Note that we don't fold past bytes */
 313     val = (val & 0x55555555) + ((val >>  1) & 0x55555555);
 314     val = (val & 0x33333333) + ((val >>  2) & 0x33333333);
 315     val = (val & 0x0f0f0f0f) + ((val >>  4) & 0x0f0f0f0f);
 316     return val;
 317 }
 318 #endif
 319
 320 /*****************************************************************************/
 321 /* PowerPC 601 specific instructions (POWER bridge) */
 322 target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2)
 323 {
 324     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
 325
 326     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 327         (int32_t)arg2 == 0) {
 328         env->spr[SPR_MQ] = 0;
 329         return INT32_MIN;
 330     } else {
 331         env->spr[SPR_MQ] = tmp % arg2;
 332         return  tmp / (int32_t)arg2;
 333     }
 334 }
 335
 336 target_ulong helper_divo(CPUPPCState *env, target_ulong arg1,
 337                          target_ulong arg2)
 338 {
 339     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
 340
 341     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 342         (int32_t)arg2 == 0) {
 343         env->so = env->ov = 1;
 344         env->spr[SPR_MQ] = 0;
 345         return INT32_MIN;
 346     } else {
 347         env->spr[SPR_MQ] = tmp % arg2;
 348         tmp /= (int32_t)arg2;
 349         if ((int32_t)tmp != tmp) {
 350             env->so = env->ov = 1;
 351         } else {
 352             env->ov = 0;
 353         }
 354         return tmp;
 355     }
 356 }
 357
 358 target_ulong helper_divs(CPUPPCState *env, target_ulong arg1,
 359                          target_ulong arg2)
 360 {
 361     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 362         (int32_t)arg2 == 0) {
 363         env->spr[SPR_MQ] = 0;
 364         return INT32_MIN;
 365     } else {
 366         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
 367         return (int32_t)arg1 / (int32_t)arg2;
 368     }
 369 }
 370
 371 target_ulong helper_divso(CPUPPCState *env, target_ulong arg1,
 372                           target_ulong arg2)
 373 {
 374     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
 375         (int32_t)arg2 == 0) {
 376         env->so = env->ov = 1;
 377         env->spr[SPR_MQ] = 0;
 378         return INT32_MIN;
 379     } else {
 380         env->ov = 0;
 381         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
 382         return (int32_t)arg1 / (int32_t)arg2;
 383     }
 384 }
 385
 386 /*****************************************************************************/
 387 /* 602 specific instructions */
 388 /* mfrom is the most crazy instruction ever seen, imho ! */
 389 /* Real implementation uses a ROM table. Do the same */
 390 /*
 391  * Extremely decomposed:
 392  *                      -arg / 256
 393  * return 256 * log10(10           + 1.0) + 0.5
 394  */
 395 #if !defined(CONFIG_USER_ONLY)
 396 target_ulong helper_602_mfrom(target_ulong arg)
 397 {
 398     if (likely(arg < 602)) {
 399 #include "mfrom_table.inc.c"
 400         return mfrom_ROM_table[arg];
 401     } else {
 402         return 0;
 403     }
 404 }
 405 #endif
 406
 407 /*****************************************************************************/
 408 /* Altivec extension helpers */
 409 #if defined(HOST_WORDS_BIGENDIAN)
 410 #define VECTOR_FOR_INORDER_I(index, element)                    \
 411     for (index = 0; index < ARRAY_SIZE(r->element); index++)
 412 #else
 413 #define VECTOR_FOR_INORDER_I(index, element)                    \
 414     for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--)
 415 #endif
 416
 417 /* Saturating arithmetic helpers.  */
 418 #define SATCVT(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)min) {                               \
 424             r = min;                                            \
 425             *sat = 1;                                           \
 426         } else if (x > (from_type)max) {                        \
 427             r = max;                                            \
 428             *sat = 1;                                           \
 429         } else {                                                \
 430             r = x;                                              \
 431         }                                                       \
 432         return r;                                               \
 433     }
 434 #define SATCVTU(from, to, from_type, to_type, min, max)         \
 435     static inline to_type cvt##from##to(from_type x, int *sat)  \
 436     {                                                           \
 437         to_type r;                                              \
 438                                                                 \
 439         if (x > (from_type)max) {                               \
 440             r = max;                                            \
 441             *sat = 1;                                           \
 442         } else {                                                \
 443             r = x;                                              \
 444         }                                                       \
 445         return r;                                               \
 446     }
 447 SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX)
 448 SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX)
 449 SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX)
 450
 451 SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX)
 452 SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX)
 453 SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX)
 454 SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX)
 455 SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX)
 456 SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX)
 457 #undef SATCVT
 458 #undef SATCVTU
 459
 460 void helper_lvsl(ppc_avr_t *r, target_ulong sh)
 461 {
 462     int i, j = (sh & 0xf);
 463
 464     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
 465         r->VsrB(i) = j++;
 466     }
 467 }
 468
 469 void helper_lvsr(ppc_avr_t *r, target_ulong sh)
 470 {
 471     int i, j = 0x10 - (sh & 0xf);
 472
 473     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
 474         r->VsrB(i) = j++;
 475     }
 476 }
 477
 478 void helper_mtvscr(CPUPPCState *env, uint32_t vscr)
 479 {
 480     env->vscr = vscr & ~(1u << VSCR_SAT);
 481     /* Which bit we set is completely arbitrary, but clear the rest.  */
 482     env->vscr_sat.u64[0] = vscr & (1u << VSCR_SAT);
 483     env->vscr_sat.u64[1] = 0;
 484     set_flush_to_zero((vscr >> VSCR_NJ) & 1, &env->vec_status);
 485 }
 486
 487 uint32_t helper_mfvscr(CPUPPCState *env)
 488 {
 489     uint32_t sat = (env->vscr_sat.u64[0] | env->vscr_sat.u64[1]) != 0;
 490     return env->vscr | (sat << VSCR_SAT);
 491 }
 492
 493 static inline void set_vscr_sat(CPUPPCState *env)
 494 {
 495     /* The choice of non-zero value is arbitrary.  */
 496     env->vscr_sat.u32[0] = 1;
 497 }
 498
 499 void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
 500 {
 501     int i;
 502
 503     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
 504         r->u32[i] = ~a->u32[i] < b->u32[i];
 505     }
 506 }
 507
 508 /* vprtybw */
 509 void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b)
 510 {
 511     int i;
 512     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
 513         uint64_t res = b->u32[i] ^ (b->u32[i] >> 16);
 514         res ^= res >> 8;
 515         r->u32[i] = res & 1;
 516     }
 517 }
 518
 519 /* vprtybd */
 520 void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b)
 521 {
 522     int i;
 523     for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
 524         uint64_t res = b->u64[i] ^ (b->u64[i] >> 32);
 525         res ^= res >> 16;
 526         res ^= res >> 8;
 527         r->u64[i] = res & 1;
 528     }
 529 }
 530
 531 /* vprtybq */
 532 void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b)
 533 {
 534     uint64_t res = b->u64[0] ^ b->u64[1];
 535     res ^= res >> 32;
 536     res ^= res >> 16;
 537     res ^= res >> 8;
 538     r->VsrD(1) = res & 1;
 539     r->VsrD(0) = 0;
 540 }
 541
 542 #define VARITH_DO(name, op, element)                                    \
 543     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 544     {                                                                   \
 545         int i;                                                          \
 546                                                                         \
 547         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 548             r->element[i] = a->element[i] op b->element[i];             \
 549         }                                                               \
 550     }
 551 VARITH_DO(muluwm, *, u32)
 552 #undef VARITH_DO
 553 #undef VARITH
 554
 555 #define VARITHFP(suffix, func)                                          \
 556     void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
 557                           ppc_avr_t *b)                                 \
 558     {                                                                   \
 559         int i;                                                          \
 560                                                                         \
 561         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {                      \
 562             r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status);   \
 563         }                                                               \
 564     }
 565 VARITHFP(addfp, float32_add)
 566 VARITHFP(subfp, float32_sub)
 567 VARITHFP(minfp, float32_min)
 568 VARITHFP(maxfp, float32_max)
 569 #undef VARITHFP
 570
 571 #define VARITHFPFMA(suffix, type)                                       \
 572     void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
 573                            ppc_avr_t *b, ppc_avr_t *c)                  \
 574     {                                                                   \
 575         int i;                                                          \
 576         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {                      \
 577             r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \
 578                                        type, &env->vec_status);         \
 579         }                                                               \
 580     }
 581 VARITHFPFMA(maddfp, 0);
 582 VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c);
 583 #undef VARITHFPFMA
 584
 585 #define VARITHSAT_CASE(type, op, cvt, element)                          \
 586     {                                                                   \
 587         type result = (type)a->element[i] op (type)b->element[i];       \
 588         r->element[i] = cvt(result, &sat);                              \
 589     }
 590
 591 #define VARITHSAT_DO(name, op, optype, cvt, element)                    \
 592     void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat,              \
 593                         ppc_avr_t *a, ppc_avr_t *b, uint32_t desc)      \
 594     {                                                                   \
 595         int sat = 0;                                                    \
 596         int i;                                                          \
 597                                                                         \
 598         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 599             VARITHSAT_CASE(optype, op, cvt, element);                   \
 600         }                                                               \
 601         if (sat) {                                                      \
 602             vscr_sat->u32[0] = 1;                                       \
 603         }                                                               \
 604     }
 605 #define VARITHSAT_SIGNED(suffix, element, optype, cvt)          \
 606     VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element)      \
 607     VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element)
 608 #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt)        \
 609     VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element)      \
 610     VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element)
 611 VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb)
 612 VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh)
 613 VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw)
 614 VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub)
 615 VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh)
 616 VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw)
 617 #undef VARITHSAT_CASE
 618 #undef VARITHSAT_DO
 619 #undef VARITHSAT_SIGNED
 620 #undef VARITHSAT_UNSIGNED
 621
 622 #define VAVG_DO(name, element, etype)                                   \
 623     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
 624     {                                                                   \
 625         int i;                                                          \
 626                                                                         \
 627         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 628             etype x = (etype)a->element[i] + (etype)b->element[i] + 1;  \
 629             r->element[i] = x >> 1;                                     \
 630         }                                                               \
 631     }
 632
 633 #define VAVG(type, signed_element, signed_type, unsigned_element,       \
 634              unsigned_type)                                             \
 635     VAVG_DO(avgs##type, signed_element, signed_type)                    \
 636     VAVG_DO(avgu##type, unsigned_element, unsigned_type)
 637 VAVG(b, s8, int16_t, u8, uint16_t)
 638 VAVG(h, s16, int32_t, u16, uint32_t)
 639 VAVG(w, s32, int64_t, u32, uint64_t)
 640 #undef VAVG_DO
 641 #undef VAVG
 642
 643 #define VABSDU_DO(name, element)                                        \
 644 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)           \
 645 {                                                                       \
 646     int i;                                                              \
 647                                                                         \
 648     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                      \
 649         r->element[i] = (a->element[i] > b->element[i]) ?               \
 650             (a->element[i] - b->element[i]) :                           \
 651             (b->element[i] - a->element[i]);                            \
 652     }                                                                   \
 653 }
 654
 655 /*
 656  * VABSDU - Vector absolute difference unsigned
 657  *   name    - instruction mnemonic suffix (b: byte, h: halfword, w: word)
 658  *   element - element type to access from vector
 659  */
 660 #define VABSDU(type, element)                   \
 661     VABSDU_DO(absdu##type, element)
 662 VABSDU(b, u8)
 663 VABSDU(h, u16)
 664 VABSDU(w, u32)
 665 #undef VABSDU_DO
 666 #undef VABSDU
 667
 668 #define VCF(suffix, cvt, element)                                       \
 669     void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r,             \
 670                             ppc_avr_t *b, uint32_t uim)                 \
 671     {                                                                   \
 672         int i;                                                          \
 673                                                                         \
 674         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {                      \
 675             float32 t = cvt(b->element[i], &env->vec_status);           \
 676             r->f32[i] = float32_scalbn(t, -uim, &env->vec_status);      \
 677         }                                                               \
 678     }
 679 VCF(ux, uint32_to_float32, u32)
 680 VCF(sx, int32_to_float32, s32)
 681 #undef VCF
 682
 683 #define VCMP_DO(suffix, compare, element, record)                       \
 684     void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r,            \
 685                              ppc_avr_t *a, ppc_avr_t *b)                \
 686     {                                                                   \
 687         uint64_t ones = (uint64_t)-1;                                   \
 688         uint64_t all = ones;                                            \
 689         uint64_t none = 0;                                              \
 690         int i;                                                          \
 691                                                                         \
 692         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
 693             uint64_t result = (a->element[i] compare b->element[i] ?    \
 694                                ones : 0x0);                             \
 695             switch (sizeof(a->element[0])) {                            \
 696             case 8:                                                     \
 697                 r->u64[i] = result;                                     \
 698                 break;                                                  \
 699             case 4:                                                     \
 700                 r->u32[i] = result;                                     \
 701                 break;                                                  \
 702             case 2:                                                     \
 703                 r->u16[i] = result;                                     \
 704                 break;                                                  \
 705             case 1:                                                     \
 706                 r->u8[i] = result;                                      \
 707                 break;                                                  \
 708             }                                                           \
 709             all &= result;                                              \
 710             none |= result;                                             \
 711         }                                                               \
 712         if (record) {                                                   \
 713             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
 714         }                                                               \
 715     }
 716 #define VCMP(suffix, compare, element)          \
 717     VCMP_DO(suffix, compare, element, 0)        \
 718     VCMP_DO(suffix##_dot, compare, element, 1)
 719 VCMP(equb, ==, u8)
 720 VCMP(equh, ==, u16)
 721 VCMP(equw, ==, u32)
 722 VCMP(equd, ==, u64)
 723 VCMP(gtub, >, u8)
 724 VCMP(gtuh, >, u16)
 725 VCMP(gtuw, >, u32)
 726 VCMP(gtud, >, u64)
 727 VCMP(gtsb, >, s8)
 728 VCMP(gtsh, >, s16)
 729 VCMP(gtsw, >, s32)
 730 VCMP(gtsd, >, s64)
 731 #undef VCMP_DO
 732 #undef VCMP
 733
 734 #define VCMPNE_DO(suffix, element, etype, cmpzero, record)              \
 735 void helper_vcmpne##suffix(CPUPPCState *env, ppc_avr_t *r,              \
 736                             ppc_avr_t *a, ppc_avr_t *b)                 \
 737 {                                                                       \
 738     etype ones = (etype)-1;                                             \
 739     etype all = ones;                                                   \
 740     etype result, none = 0;                                             \
 741     int i;                                                              \
 742                                                                         \
 743     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                      \
 744         if (cmpzero) {                                                  \
 745             result = ((a->element[i] == 0)                              \
 746                            || (b->element[i] == 0)                      \
 747                            || (a->element[i] != b->element[i]) ?        \
 748                            ones : 0x0);                                 \
 749         } else {                                                        \
 750             result = (a->element[i] != b->element[i]) ? ones : 0x0;     \
 751         }                                                               \
 752         r->element[i] = result;                                         \
 753         all &= result;                                                  \
 754         none |= result;                                                 \
 755     }                                                                   \
 756     if (record) {                                                       \
 757         env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);           \
 758     }                                                                   \
 759 }
 760
 761 /*
 762  * VCMPNEZ - Vector compare not equal to zero
 763  *   suffix  - instruction mnemonic suffix (b: byte, h: halfword, w: word)
 764  *   element - element type to access from vector
 765  */
 766 #define VCMPNE(suffix, element, etype, cmpzero)         \
 767     VCMPNE_DO(suffix, element, etype, cmpzero, 0)       \
 768     VCMPNE_DO(suffix##_dot, element, etype, cmpzero, 1)
 769 VCMPNE(zb, u8, uint8_t, 1)
 770 VCMPNE(zh, u16, uint16_t, 1)
 771 VCMPNE(zw, u32, uint32_t, 1)
 772 VCMPNE(b, u8, uint8_t, 0)
 773 VCMPNE(h, u16, uint16_t, 0)
 774 VCMPNE(w, u32, uint32_t, 0)
 775 #undef VCMPNE_DO
 776 #undef VCMPNE
 777
 778 #define VCMPFP_DO(suffix, compare, order, record)                       \
 779     void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r,            \
 780                              ppc_avr_t *a, ppc_avr_t *b)                \
 781     {                                                                   \
 782         uint32_t ones = (uint32_t)-1;                                   \
 783         uint32_t all = ones;                                            \
 784         uint32_t none = 0;                                              \
 785         int i;                                                          \
 786                                                                         \
 787         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {                      \
 788             uint32_t result;                                            \
 789             int rel = float32_compare_quiet(a->f32[i], b->f32[i],       \
 790                                             &env->vec_status);          \
 791             if (rel == float_relation_unordered) {                      \
 792                 result = 0;                                             \
 793             } else if (rel compare order) {                             \
 794                 result = ones;                                          \
 795             } else {                                                    \
 796                 result = 0;                                             \
 797             }                                                           \
 798             r->u32[i] = result;                                         \
 799             all &= result;                                              \
 800             none |= result;                                             \
 801         }                                                               \
 802         if (record) {                                                   \
 803             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
 804         }                                                               \
 805     }
 806 #define VCMPFP(suffix, compare, order)          \
 807     VCMPFP_DO(suffix, compare, order, 0)        \
 808     VCMPFP_DO(suffix##_dot, compare, order, 1)
 809 VCMPFP(eqfp, ==, float_relation_equal)
 810 VCMPFP(gefp, !=, float_relation_less)
 811 VCMPFP(gtfp, ==, float_relation_greater)
 812 #undef VCMPFP_DO
 813 #undef VCMPFP
 814
 815 static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r,
 816                                     ppc_avr_t *a, ppc_avr_t *b, int record)
 817 {
 818     int i;
 819     int all_in = 0;
 820
 821     for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
 822         int le_rel = float32_compare_quiet(a->f32[i], b->f32[i],
 823                                            &env->vec_status);
 824         if (le_rel == float_relation_unordered) {
 825             r->u32[i] = 0xc0000000;
 826             all_in = 1;
 827         } else {
 828             float32 bneg = float32_chs(b->f32[i]);
 829             int ge_rel = float32_compare_quiet(a->f32[i], bneg,
 830                                                &env->vec_status);
 831             int le = le_rel != float_relation_greater;
 832             int ge = ge_rel != float_relation_less;
 833
 834             r->u32[i] = ((!le) << 31) | ((!ge) << 30);
 835             all_in |= (!le | !ge);
 836         }
 837     }
 838     if (record) {
 839         env->crf[6] = (all_in == 0) << 1;
 840     }
 841 }
 842
 843 void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
 844 {
 845     vcmpbfp_internal(env, r, a, b, 0);
 846 }
 847
 848 void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 849                         ppc_avr_t *b)
 850 {
 851     vcmpbfp_internal(env, r, a, b, 1);
 852 }
 853
 854 #define VCT(suffix, satcvt, element)                                    \
 855     void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r,             \
 856                             ppc_avr_t *b, uint32_t uim)                 \
 857     {                                                                   \
 858         int i;                                                          \
 859         int sat = 0;                                                    \
 860         float_status s = env->vec_status;                               \
 861                                                                         \
 862         set_float_rounding_mode(float_round_to_zero, &s);               \
 863         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {                      \
 864             if (float32_is_any_nan(b->f32[i])) {                        \
 865                 r->element[i] = 0;                                      \
 866             } else {                                                    \
 867                 float64 t = float32_to_float64(b->f32[i], &s);          \
 868                 int64_t j;                                              \
 869                                                                         \
 870                 t = float64_scalbn(t, uim, &s);                         \
 871                 j = float64_to_int64(t, &s);                            \
 872                 r->element[i] = satcvt(j, &sat);                        \
 873             }                                                           \
 874         }                                                               \
 875         if (sat) {                                                      \
 876             set_vscr_sat(env);                                          \
 877         }                                                               \
 878     }
 879 VCT(uxs, cvtsduw, u32)
 880 VCT(sxs, cvtsdsw, s32)
 881 #undef VCT
 882
 883 target_ulong helper_vclzlsbb(ppc_avr_t *r)
 884 {
 885     target_ulong count = 0;
 886     int i;
 887     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
 888         if (r->VsrB(i) & 0x01) {
 889             break;
 890         }
 891         count++;
 892     }
 893     return count;
 894 }
 895
 896 target_ulong helper_vctzlsbb(ppc_avr_t *r)
 897 {
 898     target_ulong count = 0;
 899     int i;
 900     for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
 901         if (r->VsrB(i) & 0x01) {
 902             break;
 903         }
 904         count++;
 905     }
 906     return count;
 907 }
 908
 909 void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 910                       ppc_avr_t *b, ppc_avr_t *c)
 911 {
 912     int sat = 0;
 913     int i;
 914
 915     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 916         int32_t prod = a->s16[i] * b->s16[i];
 917         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
 918
 919         r->s16[i] = cvtswsh(t, &sat);
 920     }
 921
 922     if (sat) {
 923         set_vscr_sat(env);
 924     }
 925 }
 926
 927 void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 928                        ppc_avr_t *b, ppc_avr_t *c)
 929 {
 930     int sat = 0;
 931     int i;
 932
 933     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 934         int32_t prod = a->s16[i] * b->s16[i] + 0x00004000;
 935         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
 936         r->s16[i] = cvtswsh(t, &sat);
 937     }
 938
 939     if (sat) {
 940         set_vscr_sat(env);
 941     }
 942 }
 943
 944 void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
 945 {
 946     int i;
 947
 948     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 949         int32_t prod = a->s16[i] * b->s16[i];
 950         r->s16[i] = (int16_t) (prod + c->s16[i]);
 951     }
 952 }
 953
 954 #define VMRG_DO(name, element, access, ofs)                                  \
 955     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)            \
 956     {                                                                        \
 957         ppc_avr_t result;                                                    \
 958         int i, half = ARRAY_SIZE(r->element) / 2;                            \
 959                                                                              \
 960         for (i = 0; i < half; i++) {                                         \
 961             result.access(i * 2 + 0) = a->access(i + ofs);                   \
 962             result.access(i * 2 + 1) = b->access(i + ofs);                   \
 963         }                                                                    \
 964         *r = result;                                                         \
 965     }
 966
 967 #define VMRG(suffix, element, access)          \
 968     VMRG_DO(mrgl##suffix, element, access, half)   \
 969     VMRG_DO(mrgh##suffix, element, access, 0)
 970 VMRG(b, u8, VsrB)
 971 VMRG(h, u16, VsrH)
 972 VMRG(w, u32, VsrW)
 973 #undef VMRG_DO
 974 #undef VMRG
 975
 976 void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 977                      ppc_avr_t *b, ppc_avr_t *c)
 978 {
 979     int32_t prod[16];
 980     int i;
 981
 982     for (i = 0; i < ARRAY_SIZE(r->s8); i++) {
 983         prod[i] = (int32_t)a->s8[i] * b->u8[i];
 984     }
 985
 986     VECTOR_FOR_INORDER_I(i, s32) {
 987         r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] +
 988             prod[4 * i + 2] + prod[4 * i + 3];
 989     }
 990 }
 991
 992 void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
 993                      ppc_avr_t *b, ppc_avr_t *c)
 994 {
 995     int32_t prod[8];
 996     int i;
 997
 998     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
 999         prod[i] = a->s16[i] * b->s16[i];
1000     }
1001
1002     VECTOR_FOR_INORDER_I(i, s32) {
1003         r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1];
1004     }
1005 }
1006
1007 void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1008                      ppc_avr_t *b, ppc_avr_t *c)
1009 {
1010     int32_t prod[8];
1011     int i;
1012     int sat = 0;
1013
1014     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
1015         prod[i] = (int32_t)a->s16[i] * b->s16[i];
1016     }
1017
1018     VECTOR_FOR_INORDER_I(i, s32) {
1019         int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1];
1020
1021         r->u32[i] = cvtsdsw(t, &sat);
1022     }
1023
1024     if (sat) {
1025         set_vscr_sat(env);
1026     }
1027 }
1028
1029 void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1030                      ppc_avr_t *b, ppc_avr_t *c)
1031 {
1032     uint16_t prod[16];
1033     int i;
1034
1035     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1036         prod[i] = a->u8[i] * b->u8[i];
1037     }
1038
1039     VECTOR_FOR_INORDER_I(i, u32) {
1040         r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] +
1041             prod[4 * i + 2] + prod[4 * i + 3];
1042     }
1043 }
1044
1045 void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1046                      ppc_avr_t *b, ppc_avr_t *c)
1047 {
1048     uint32_t prod[8];
1049     int i;
1050
1051     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
1052         prod[i] = a->u16[i] * b->u16[i];
1053     }
1054
1055     VECTOR_FOR_INORDER_I(i, u32) {
1056         r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1];
1057     }
1058 }
1059
1060 void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1061                      ppc_avr_t *b, ppc_avr_t *c)
1062 {
1063     uint32_t prod[8];
1064     int i;
1065     int sat = 0;
1066
1067     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
1068         prod[i] = a->u16[i] * b->u16[i];
1069     }
1070
1071     VECTOR_FOR_INORDER_I(i, s32) {
1072         uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1];
1073
1074         r->u32[i] = cvtuduw(t, &sat);
1075     }
1076
1077     if (sat) {
1078         set_vscr_sat(env);
1079     }
1080 }
1081
1082 #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast)   \
1083     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
1084     {                                                                   \
1085         int i;                                                          \
1086                                                                         \
1087         for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) {           \
1088             r->prod_access(i >> 1) = (cast)a->mul_access(i) *           \
1089                                      (cast)b->mul_access(i);            \
1090         }                                                               \
1091     }
1092
1093 #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast)   \
1094     void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)       \
1095     {                                                                   \
1096         int i;                                                          \
1097                                                                         \
1098         for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) {           \
1099             r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) *       \
1100                                      (cast)b->mul_access(i + 1);        \
1101         }                                                               \
1102     }
1103
1104 #define VMUL(suffix, mul_element, mul_access, prod_access, cast)       \
1105     VMUL_DO_EVN(mule##suffix, mul_element, mul_access, prod_access, cast)  \
1106     VMUL_DO_ODD(mulo##suffix, mul_element, mul_access, prod_access, cast)
1107 VMUL(sb, s8, VsrSB, VsrSH, int16_t)
1108 VMUL(sh, s16, VsrSH, VsrSW, int32_t)
1109 VMUL(sw, s32, VsrSW, VsrSD, int64_t)
1110 VMUL(ub, u8, VsrB, VsrH, uint16_t)
1111 VMUL(uh, u16, VsrH, VsrW, uint32_t)
1112 VMUL(uw, u32, VsrW, VsrD, uint64_t)
1113 #undef VMUL_DO_EVN
1114 #undef VMUL_DO_ODD
1115 #undef VMUL
1116
1117 void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1118                   ppc_avr_t *c)
1119 {
1120     ppc_avr_t result;
1121     int i;
1122
1123     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1124         int s = c->VsrB(i) & 0x1f;
1125         int index = s & 0xf;
1126
1127         if (s & 0x10) {
1128             result.VsrB(i) = b->VsrB(index);
1129         } else {
1130             result.VsrB(i) = a->VsrB(index);
1131         }
1132     }
1133     *r = result;
1134 }
1135
1136 void helper_vpermr(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1137                   ppc_avr_t *c)
1138 {
1139     ppc_avr_t result;
1140     int i;
1141
1142     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1143         int s = c->VsrB(i) & 0x1f;
1144         int index = 15 - (s & 0xf);
1145
1146         if (s & 0x10) {
1147             result.VsrB(i) = a->VsrB(index);
1148         } else {
1149             result.VsrB(i) = b->VsrB(index);
1150         }
1151     }
1152     *r = result;
1153 }
1154
1155 #if defined(HOST_WORDS_BIGENDIAN)
1156 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)])
1157 #define VBPERMD_INDEX(i) (i)
1158 #define VBPERMQ_DW(index) (((index) & 0x40) != 0)
1159 #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1))
1160 #else
1161 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)])
1162 #define VBPERMD_INDEX(i) (1 - i)
1163 #define VBPERMQ_DW(index) (((index) & 0x40) == 0)
1164 #define EXTRACT_BIT(avr, i, index) \
1165         (extract64((avr)->u64[1 - i], 63 - index, 1))
1166 #endif
1167
1168 void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1169 {
1170     int i, j;
1171     ppc_avr_t result = { .u64 = { 0, 0 } };
1172     VECTOR_FOR_INORDER_I(i, u64) {
1173         for (j = 0; j < 8; j++) {
1174             int index = VBPERMQ_INDEX(b, (i * 8) + j);
1175             if (index < 64 && EXTRACT_BIT(a, i, index)) {
1176                 result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j);
1177             }
1178         }
1179     }
1180     *r = result;
1181 }
1182
1183 void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1184 {
1185     int i;
1186     uint64_t perm = 0;
1187
1188     VECTOR_FOR_INORDER_I(i, u8) {
1189         int index = VBPERMQ_INDEX(b, i);
1190
1191         if (index < 128) {
1192             uint64_t mask = (1ull << (63 - (index & 0x3F)));
1193             if (a->u64[VBPERMQ_DW(index)] & mask) {
1194                 perm |= (0x8000 >> i);
1195             }
1196         }
1197     }
1198
1199     r->VsrD(0) = perm;
1200     r->VsrD(1) = 0;
1201 }
1202
1203 #undef VBPERMQ_INDEX
1204 #undef VBPERMQ_DW
1205
1206 static const uint64_t VGBBD_MASKS[256] = {
1207     0x0000000000000000ull, /* 00 */
1208     0x0000000000000080ull, /* 01 */
1209     0x0000000000008000ull, /* 02 */
1210     0x0000000000008080ull, /* 03 */
1211     0x0000000000800000ull, /* 04 */
1212     0x0000000000800080ull, /* 05 */
1213     0x0000000000808000ull, /* 06 */
1214     0x0000000000808080ull, /* 07 */
1215     0x0000000080000000ull, /* 08 */
1216     0x0000000080000080ull, /* 09 */
1217     0x0000000080008000ull, /* 0A */
1218     0x0000000080008080ull, /* 0B */
1219     0x0000000080800000ull, /* 0C */
1220     0x0000000080800080ull, /* 0D */
1221     0x0000000080808000ull, /* 0E */
1222     0x0000000080808080ull, /* 0F */
1223     0x0000008000000000ull, /* 10 */
1224     0x0000008000000080ull, /* 11 */
1225     0x0000008000008000ull, /* 12 */
1226     0x0000008000008080ull, /* 13 */
1227     0x0000008000800000ull, /* 14 */
1228     0x0000008000800080ull, /* 15 */
1229     0x0000008000808000ull, /* 16 */
1230     0x0000008000808080ull, /* 17 */
1231     0x0000008080000000ull, /* 18 */
1232     0x0000008080000080ull, /* 19 */
1233     0x0000008080008000ull, /* 1A */
1234     0x0000008080008080ull, /* 1B */
1235     0x0000008080800000ull, /* 1C */
1236     0x0000008080800080ull, /* 1D */
1237     0x0000008080808000ull, /* 1E */
1238     0x0000008080808080ull, /* 1F */
1239     0x0000800000000000ull, /* 20 */
1240     0x0000800000000080ull, /* 21 */
1241     0x0000800000008000ull, /* 22 */
1242     0x0000800000008080ull, /* 23 */
1243     0x0000800000800000ull, /* 24 */
1244     0x0000800000800080ull, /* 25 */
1245     0x0000800000808000ull, /* 26 */
1246     0x0000800000808080ull, /* 27 */
1247     0x0000800080000000ull, /* 28 */
1248     0x0000800080000080ull, /* 29 */
1249     0x0000800080008000ull, /* 2A */
1250     0x0000800080008080ull, /* 2B */
1251     0x0000800080800000ull, /* 2C */
1252     0x0000800080800080ull, /* 2D */
1253     0x0000800080808000ull, /* 2E */
1254     0x0000800080808080ull, /* 2F */
1255     0x0000808000000000ull, /* 30 */
1256     0x0000808000000080ull, /* 31 */
1257     0x0000808000008000ull, /* 32 */
1258     0x0000808000008080ull, /* 33 */
1259     0x0000808000800000ull, /* 34 */
1260     0x0000808000800080ull, /* 35 */
1261     0x0000808000808000ull, /* 36 */
1262     0x0000808000808080ull, /* 37 */
1263     0x0000808080000000ull, /* 38 */
1264     0x0000808080000080ull, /* 39 */
1265     0x0000808080008000ull, /* 3A */
1266     0x0000808080008080ull, /* 3B */
1267     0x0000808080800000ull, /* 3C */
1268     0x0000808080800080ull, /* 3D */
1269     0x0000808080808000ull, /* 3E */
1270     0x0000808080808080ull, /* 3F */
1271     0x0080000000000000ull, /* 40 */
1272     0x0080000000000080ull, /* 41 */
1273     0x0080000000008000ull, /* 42 */
1274     0x0080000000008080ull, /* 43 */
1275     0x0080000000800000ull, /* 44 */
1276     0x0080000000800080ull, /* 45 */
1277     0x0080000000808000ull, /* 46 */
1278     0x0080000000808080ull, /* 47 */
1279     0x0080000080000000ull, /* 48 */
1280     0x0080000080000080ull, /* 49 */
1281     0x0080000080008000ull, /* 4A */
1282     0x0080000080008080ull, /* 4B */
1283     0x0080000080800000ull, /* 4C */
1284     0x0080000080800080ull, /* 4D */
1285     0x0080000080808000ull, /* 4E */
1286     0x0080000080808080ull, /* 4F */
1287     0x0080008000000000ull, /* 50 */
1288     0x0080008000000080ull, /* 51 */
1289     0x0080008000008000ull, /* 52 */
1290     0x0080008000008080ull, /* 53 */
1291     0x0080008000800000ull, /* 54 */
1292     0x0080008000800080ull, /* 55 */
1293     0x0080008000808000ull, /* 56 */
1294     0x0080008000808080ull, /* 57 */
1295     0x0080008080000000ull, /* 58 */
1296     0x0080008080000080ull, /* 59 */
1297     0x0080008080008000ull, /* 5A */
1298     0x0080008080008080ull, /* 5B */
1299     0x0080008080800000ull, /* 5C */
1300     0x0080008080800080ull, /* 5D */
1301     0x0080008080808000ull, /* 5E */
1302     0x0080008080808080ull, /* 5F */
1303     0x0080800000000000ull, /* 60 */
1304     0x0080800000000080ull, /* 61 */
1305     0x0080800000008000ull, /* 62 */
1306     0x0080800000008080ull, /* 63 */
1307     0x0080800000800000ull, /* 64 */
1308     0x0080800000800080ull, /* 65 */
1309     0x0080800000808000ull, /* 66 */
1310     0x0080800000808080ull, /* 67 */
1311     0x0080800080000000ull, /* 68 */
1312     0x0080800080000080ull, /* 69 */
1313     0x0080800080008000ull, /* 6A */
1314     0x0080800080008080ull, /* 6B */
1315     0x0080800080800000ull, /* 6C */
1316     0x0080800080800080ull, /* 6D */
1317     0x0080800080808000ull, /* 6E */
1318     0x0080800080808080ull, /* 6F */
1319     0x0080808000000000ull, /* 70 */
1320     0x0080808000000080ull, /* 71 */
1321     0x0080808000008000ull, /* 72 */
1322     0x0080808000008080ull, /* 73 */
1323     0x0080808000800000ull, /* 74 */
1324     0x0080808000800080ull, /* 75 */
1325     0x0080808000808000ull, /* 76 */
1326     0x0080808000808080ull, /* 77 */
1327     0x0080808080000000ull, /* 78 */
1328     0x0080808080000080ull, /* 79 */
1329     0x0080808080008000ull, /* 7A */
1330     0x0080808080008080ull, /* 7B */
1331     0x0080808080800000ull, /* 7C */
1332     0x0080808080800080ull, /* 7D */
1333     0x0080808080808000ull, /* 7E */
1334     0x0080808080808080ull, /* 7F */
1335     0x8000000000000000ull, /* 80 */
1336     0x8000000000000080ull, /* 81 */
1337     0x8000000000008000ull, /* 82 */
1338     0x8000000000008080ull, /* 83 */
1339     0x8000000000800000ull, /* 84 */
1340     0x8000000000800080ull, /* 85 */
1341     0x8000000000808000ull, /* 86 */
1342     0x8000000000808080ull, /* 87 */
1343     0x8000000080000000ull, /* 88 */
1344     0x8000000080000080ull, /* 89 */
1345     0x8000000080008000ull, /* 8A */
1346     0x8000000080008080ull, /* 8B */
1347     0x8000000080800000ull, /* 8C */
1348     0x8000000080800080ull, /* 8D */
1349     0x8000000080808000ull, /* 8E */
1350     0x8000000080808080ull, /* 8F */
1351     0x8000008000000000ull, /* 90 */
1352     0x8000008000000080ull, /* 91 */
1353     0x8000008000008000ull, /* 92 */
1354     0x8000008000008080ull, /* 93 */
1355     0x8000008000800000ull, /* 94 */
1356     0x8000008000800080ull, /* 95 */
1357     0x8000008000808000ull, /* 96 */
1358     0x8000008000808080ull, /* 97 */
1359     0x8000008080000000ull, /* 98 */
1360     0x8000008080000080ull, /* 99 */
1361     0x8000008080008000ull, /* 9A */
1362     0x8000008080008080ull, /* 9B */
1363     0x8000008080800000ull, /* 9C */
1364     0x8000008080800080ull, /* 9D */
1365     0x8000008080808000ull, /* 9E */
1366     0x8000008080808080ull, /* 9F */
1367     0x8000800000000000ull, /* A0 */
1368     0x8000800000000080ull, /* A1 */
1369     0x8000800000008000ull, /* A2 */
1370     0x8000800000008080ull, /* A3 */
1371     0x8000800000800000ull, /* A4 */
1372     0x8000800000800080ull, /* A5 */
1373     0x8000800000808000ull, /* A6 */
1374     0x8000800000808080ull, /* A7 */
1375     0x8000800080000000ull, /* A8 */
1376     0x8000800080000080ull, /* A9 */
1377     0x8000800080008000ull, /* AA */
1378     0x8000800080008080ull, /* AB */
1379     0x8000800080800000ull, /* AC */
1380     0x8000800080800080ull, /* AD */
1381     0x8000800080808000ull, /* AE */
1382     0x8000800080808080ull, /* AF */
1383     0x8000808000000000ull, /* B0 */
1384     0x8000808000000080ull, /* B1 */
1385     0x8000808000008000ull, /* B2 */
1386     0x8000808000008080ull, /* B3 */
1387     0x8000808000800000ull, /* B4 */
1388     0x8000808000800080ull, /* B5 */
1389     0x8000808000808000ull, /* B6 */
1390     0x8000808000808080ull, /* B7 */
1391     0x8000808080000000ull, /* B8 */
1392     0x8000808080000080ull, /* B9 */
1393     0x8000808080008000ull, /* BA */
1394     0x8000808080008080ull, /* BB */
1395     0x8000808080800000ull, /* BC */
1396     0x8000808080800080ull, /* BD */
1397     0x8000808080808000ull, /* BE */
1398     0x8000808080808080ull, /* BF */
1399     0x8080000000000000ull, /* C0 */
1400     0x8080000000000080ull, /* C1 */
1401     0x8080000000008000ull, /* C2 */
1402     0x8080000000008080ull, /* C3 */
1403     0x8080000000800000ull, /* C4 */
1404     0x8080000000800080ull, /* C5 */
1405     0x8080000000808000ull, /* C6 */
1406     0x8080000000808080ull, /* C7 */
1407     0x8080000080000000ull, /* C8 */
1408     0x8080000080000080ull, /* C9 */
1409     0x8080000080008000ull, /* CA */
1410     0x8080000080008080ull, /* CB */
1411     0x8080000080800000ull, /* CC */
1412     0x8080000080800080ull, /* CD */
1413     0x8080000080808000ull, /* CE */
1414     0x8080000080808080ull, /* CF */
1415     0x8080008000000000ull, /* D0 */
1416     0x8080008000000080ull, /* D1 */
1417     0x8080008000008000ull, /* D2 */
1418     0x8080008000008080ull, /* D3 */
1419     0x8080008000800000ull, /* D4 */
1420     0x8080008000800080ull, /* D5 */
1421     0x8080008000808000ull, /* D6 */
1422     0x8080008000808080ull, /* D7 */
1423     0x8080008080000000ull, /* D8 */
1424     0x8080008080000080ull, /* D9 */
1425     0x8080008080008000ull, /* DA */
1426     0x8080008080008080ull, /* DB */
1427     0x8080008080800000ull, /* DC */
1428     0x8080008080800080ull, /* DD */
1429     0x8080008080808000ull, /* DE */
1430     0x8080008080808080ull, /* DF */
1431     0x8080800000000000ull, /* E0 */
1432     0x8080800000000080ull, /* E1 */
1433     0x8080800000008000ull, /* E2 */
1434     0x8080800000008080ull, /* E3 */
1435     0x8080800000800000ull, /* E4 */
1436     0x8080800000800080ull, /* E5 */
1437     0x8080800000808000ull, /* E6 */
1438     0x8080800000808080ull, /* E7 */
1439     0x8080800080000000ull, /* E8 */
1440     0x8080800080000080ull, /* E9 */
1441     0x8080800080008000ull, /* EA */
1442     0x8080800080008080ull, /* EB */
1443     0x8080800080800000ull, /* EC */
1444     0x8080800080800080ull, /* ED */
1445     0x8080800080808000ull, /* EE */
1446     0x8080800080808080ull, /* EF */
1447     0x8080808000000000ull, /* F0 */
1448     0x8080808000000080ull, /* F1 */
1449     0x8080808000008000ull, /* F2 */
1450     0x8080808000008080ull, /* F3 */
1451     0x8080808000800000ull, /* F4 */
1452     0x8080808000800080ull, /* F5 */
1453     0x8080808000808000ull, /* F6 */
1454     0x8080808000808080ull, /* F7 */
1455     0x8080808080000000ull, /* F8 */
1456     0x8080808080000080ull, /* F9 */
1457     0x8080808080008000ull, /* FA */
1458     0x8080808080008080ull, /* FB */
1459     0x8080808080800000ull, /* FC */
1460     0x8080808080800080ull, /* FD */
1461     0x8080808080808000ull, /* FE */
1462     0x8080808080808080ull, /* FF */
1463 };
1464
1465 void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b)
1466 {
1467     int i;
1468     uint64_t t[2] = { 0, 0 };
1469
1470     VECTOR_FOR_INORDER_I(i, u8) {
1471 #if defined(HOST_WORDS_BIGENDIAN)
1472         t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7);
1473 #else
1474         t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (7 - (i & 7));
1475 #endif
1476     }
1477
1478     r->u64[0] = t[0];
1479     r->u64[1] = t[1];
1480 }
1481
1482 #define PMSUM(name, srcfld, trgfld, trgtyp)                   \
1483 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
1484 {                                                             \
1485     int i, j;                                                 \
1486     trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])];    \
1487                                                               \
1488     VECTOR_FOR_INORDER_I(i, srcfld) {                         \
1489         prod[i] = 0;                                          \
1490         for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) {      \
1491             if (a->srcfld[i] & (1ull << j)) {                 \
1492                 prod[i] ^= ((trgtyp)b->srcfld[i] << j);       \
1493             }                                                 \
1494         }                                                     \
1495     }                                                         \
1496                                                               \
1497     VECTOR_FOR_INORDER_I(i, trgfld) {                         \
1498         r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1];         \
1499     }                                                         \
1500 }
1501
1502 PMSUM(vpmsumb, u8, u16, uint16_t)
1503 PMSUM(vpmsumh, u16, u32, uint32_t)
1504 PMSUM(vpmsumw, u32, u64, uint64_t)
1505
1506 void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1507 {
1508
1509 #ifdef CONFIG_INT128
1510     int i, j;
1511     __uint128_t prod[2];
1512
1513     VECTOR_FOR_INORDER_I(i, u64) {
1514         prod[i] = 0;
1515         for (j = 0; j < 64; j++) {
1516             if (a->u64[i] & (1ull << j)) {
1517                 prod[i] ^= (((__uint128_t)b->u64[i]) << j);
1518             }
1519         }
1520     }
1521
1522     r->u128 = prod[0] ^ prod[1];
1523
1524 #else
1525     int i, j;
1526     ppc_avr_t prod[2];
1527
1528     VECTOR_FOR_INORDER_I(i, u64) {
1529         prod[i].VsrD(1) = prod[i].VsrD(0) = 0;
1530         for (j = 0; j < 64; j++) {
1531             if (a->u64[i] & (1ull << j)) {
1532                 ppc_avr_t bshift;
1533                 if (j == 0) {
1534                     bshift.VsrD(0) = 0;
1535                     bshift.VsrD(1) = b->u64[i];
1536                 } else {
1537                     bshift.VsrD(0) = b->u64[i] >> (64 - j);
1538                     bshift.VsrD(1) = b->u64[i] << j;
1539                 }
1540                 prod[i].VsrD(1) ^= bshift.VsrD(1);
1541                 prod[i].VsrD(0) ^= bshift.VsrD(0);
1542             }
1543         }
1544     }
1545
1546     r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1);
1547     r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0);
1548 #endif
1549 }
1550
1551
1552 #if defined(HOST_WORDS_BIGENDIAN)
1553 #define PKBIG 1
1554 #else
1555 #define PKBIG 0
1556 #endif
1557 void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1558 {
1559     int i, j;
1560     ppc_avr_t result;
1561 #if defined(HOST_WORDS_BIGENDIAN)
1562     const ppc_avr_t *x[2] = { a, b };
1563 #else
1564     const ppc_avr_t *x[2] = { b, a };
1565 #endif
1566
1567     VECTOR_FOR_INORDER_I(i, u64) {
1568         VECTOR_FOR_INORDER_I(j, u32) {
1569             uint32_t e = x[i]->u32[j];
1570
1571             result.u16[4 * i + j] = (((e >> 9) & 0xfc00) |
1572                                      ((e >> 6) & 0x3e0) |
1573                                      ((e >> 3) & 0x1f));
1574         }
1575     }
1576     *r = result;
1577 }
1578
1579 #define VPK(suffix, from, to, cvt, dosat)                               \
1580     void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r,             \
1581                             ppc_avr_t *a, ppc_avr_t *b)                 \
1582     {                                                                   \
1583         int i;                                                          \
1584         int sat = 0;                                                    \
1585         ppc_avr_t result;                                               \
1586         ppc_avr_t *a0 = PKBIG ? a : b;                                  \
1587         ppc_avr_t *a1 = PKBIG ? b : a;                                  \
1588                                                                         \
1589         VECTOR_FOR_INORDER_I(i, from) {                                 \
1590             result.to[i] = cvt(a0->from[i], &sat);                      \
1591             result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\
1592         }                                                               \
1593         *r = result;                                                    \
1594         if (dosat && sat) {                                             \
1595             set_vscr_sat(env);                                          \
1596         }                                                               \
1597     }
1598 #define I(x, y) (x)
1599 VPK(shss, s16, s8, cvtshsb, 1)
1600 VPK(shus, s16, u8, cvtshub, 1)
1601 VPK(swss, s32, s16, cvtswsh, 1)
1602 VPK(swus, s32, u16, cvtswuh, 1)
1603 VPK(sdss, s64, s32, cvtsdsw, 1)
1604 VPK(sdus, s64, u32, cvtsduw, 1)
1605 VPK(uhus, u16, u8, cvtuhub, 1)
1606 VPK(uwus, u32, u16, cvtuwuh, 1)
1607 VPK(udus, u64, u32, cvtuduw, 1)
1608 VPK(uhum, u16, u8, I, 0)
1609 VPK(uwum, u32, u16, I, 0)
1610 VPK(udum, u64, u32, I, 0)
1611 #undef I
1612 #undef VPK
1613 #undef PKBIG
1614
1615 void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1616 {
1617     int i;
1618
1619     for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1620         r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status);
1621     }
1622 }
1623
1624 #define VRFI(suffix, rounding)                                  \
1625     void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r,    \
1626                              ppc_avr_t *b)                      \
1627     {                                                           \
1628         int i;                                                  \
1629         float_status s = env->vec_status;                       \
1630                                                                 \
1631         set_float_rounding_mode(rounding, &s);                  \
1632         for (i = 0; i < ARRAY_SIZE(r->f32); i++) {              \
1633             r->f32[i] = float32_round_to_int (b->f32[i], &s);   \
1634         }                                                       \
1635     }
1636 VRFI(n, float_round_nearest_even)
1637 VRFI(m, float_round_down)
1638 VRFI(p, float_round_up)
1639 VRFI(z, float_round_to_zero)
1640 #undef VRFI
1641
1642 #define VROTATE(suffix, element, mask)                                  \
1643     void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)   \
1644     {                                                                   \
1645         int i;                                                          \
1646                                                                         \
1647         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1648             unsigned int shift = b->element[i] & mask;                  \
1649             r->element[i] = (a->element[i] << shift) |                  \
1650                 (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \
1651         }                                                               \
1652     }
1653 VROTATE(b, u8, 0x7)
1654 VROTATE(h, u16, 0xF)
1655 VROTATE(w, u32, 0x1F)
1656 VROTATE(d, u64, 0x3F)
1657 #undef VROTATE
1658
1659 void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1660 {
1661     int i;
1662
1663     for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1664         float32 t = float32_sqrt(b->f32[i], &env->vec_status);
1665
1666         r->f32[i] = float32_div(float32_one, t, &env->vec_status);
1667     }
1668 }
1669
1670 #define VRLMI(name, size, element, insert)                            \
1671 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)          \
1672 {                                                                     \
1673     int i;                                                            \
1674     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                    \
1675         uint##size##_t src1 = a->element[i];                          \
1676         uint##size##_t src2 = b->element[i];                          \
1677         uint##size##_t src3 = r->element[i];                          \
1678         uint##size##_t begin, end, shift, mask, rot_val;              \
1679                                                                       \
1680         shift = extract##size(src2, 0, 6);                            \
1681         end   = extract##size(src2, 8, 6);                            \
1682         begin = extract##size(src2, 16, 6);                           \
1683         rot_val = rol##size(src1, shift);                             \
1684         mask = mask_u##size(begin, end);                              \
1685         if (insert) {                                                 \
1686             r->element[i] = (rot_val & mask) | (src3 & ~mask);        \
1687         } else {                                                      \
1688             r->element[i] = (rot_val & mask);                         \
1689         }                                                             \
1690     }                                                                 \
1691 }
1692
1693 VRLMI(vrldmi, 64, u64, 1);
1694 VRLMI(vrlwmi, 32, u32, 1);
1695 VRLMI(vrldnm, 64, u64, 0);
1696 VRLMI(vrlwnm, 32, u32, 0);
1697
1698 void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1699                  ppc_avr_t *c)
1700 {
1701     r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]);
1702     r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]);
1703 }
1704
1705 void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1706 {
1707     int i;
1708
1709     for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1710         r->f32[i] = float32_exp2(b->f32[i], &env->vec_status);
1711     }
1712 }
1713
1714 void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1715 {
1716     int i;
1717
1718     for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1719         r->f32[i] = float32_log2(b->f32[i], &env->vec_status);
1720     }
1721 }
1722
1723 #if defined(HOST_WORDS_BIGENDIAN)
1724 #define VEXTU_X_DO(name, size, left)                                \
1725     target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b)  \
1726     {                                                               \
1727         int index;                                                  \
1728         if (left) {                                                 \
1729             index = (a & 0xf) * 8;                                  \
1730         } else {                                                    \
1731             index = ((15 - (a & 0xf) + 1) * 8) - size;              \
1732         }                                                           \
1733         return int128_getlo(int128_rshift(b->s128, index)) &        \
1734             MAKE_64BIT_MASK(0, size);                               \
1735     }
1736 #else
1737 #define VEXTU_X_DO(name, size, left)                                \
1738     target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b)  \
1739     {                                                               \
1740         int index;                                                  \
1741         if (left) {                                                 \
1742             index = ((15 - (a & 0xf) + 1) * 8) - size;              \
1743         } else {                                                    \
1744             index = (a & 0xf) * 8;                                  \
1745         }                                                           \
1746         return int128_getlo(int128_rshift(b->s128, index)) &        \
1747             MAKE_64BIT_MASK(0, size);                               \
1748     }
1749 #endif
1750
1751 VEXTU_X_DO(vextublx,  8, 1)
1752 VEXTU_X_DO(vextuhlx, 16, 1)
1753 VEXTU_X_DO(vextuwlx, 32, 1)
1754 VEXTU_X_DO(vextubrx,  8, 0)
1755 VEXTU_X_DO(vextuhrx, 16, 0)
1756 VEXTU_X_DO(vextuwrx, 32, 0)
1757 #undef VEXTU_X_DO
1758
1759 /*
1760  * The specification says that the results are undefined if all of the
1761  * shift counts are not identical.  We check to make sure that they
1762  * are to conform to what real hardware appears to do.
1763  */
1764 #define VSHIFT(suffix, leftp)                                           \
1765     void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)    \
1766     {                                                                   \
1767         int shift = b->VsrB(15) & 0x7;                                  \
1768         int doit = 1;                                                   \
1769         int i;                                                          \
1770                                                                         \
1771         for (i = 0; i < ARRAY_SIZE(r->u8); i++) {                       \
1772             doit = doit && ((b->u8[i] & 0x7) == shift);                 \
1773         }                                                               \
1774         if (doit) {                                                     \
1775             if (shift == 0) {                                           \
1776                 *r = *a;                                                \
1777             } else if (leftp) {                                         \
1778                 uint64_t carry = a->VsrD(1) >> (64 - shift);            \
1779                                                                         \
1780                 r->VsrD(0) = (a->VsrD(0) << shift) | carry;             \
1781                 r->VsrD(1) = a->VsrD(1) << shift;                       \
1782             } else {                                                    \
1783                 uint64_t carry = a->VsrD(0) << (64 - shift);            \
1784                                                                         \
1785                 r->VsrD(1) = (a->VsrD(1) >> shift) | carry;             \
1786                 r->VsrD(0) = a->VsrD(0) >> shift;                       \
1787             }                                                           \
1788         }                                                               \
1789     }
1790 VSHIFT(l, 1)
1791 VSHIFT(r, 0)
1792 #undef VSHIFT
1793
1794 void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1795 {
1796     int i;
1797     unsigned int shift, bytes, size;
1798
1799     size = ARRAY_SIZE(r->u8);
1800     for (i = 0; i < size; i++) {
1801         shift = b->VsrB(i) & 0x7;             /* extract shift value */
1802         bytes = (a->VsrB(i) << 8) +           /* extract adjacent bytes */
1803             (((i + 1) < size) ? a->VsrB(i + 1) : 0);
1804         r->VsrB(i) = (bytes << shift) >> 8;   /* shift and store result */
1805     }
1806 }
1807
1808 void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1809 {
1810     int i;
1811     unsigned int shift, bytes;
1812
1813     /*
1814      * Use reverse order, as destination and source register can be
1815      * same. Its being modified in place saving temporary, reverse
1816      * order will guarantee that computed result is not fed back.
1817      */
1818     for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
1819         shift = b->VsrB(i) & 0x7;               /* extract shift value */
1820         bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i);
1821                                                 /* extract adjacent bytes */
1822         r->VsrB(i) = (bytes >> shift) & 0xFF;   /* shift and store result */
1823     }
1824 }
1825
1826 void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
1827 {
1828     int sh = shift & 0xf;
1829     int i;
1830     ppc_avr_t result;
1831
1832     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1833         int index = sh + i;
1834         if (index > 0xf) {
1835             result.VsrB(i) = b->VsrB(index - 0x10);
1836         } else {
1837             result.VsrB(i) = a->VsrB(index);
1838         }
1839     }
1840     *r = result;
1841 }
1842
1843 void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1844 {
1845     int sh = (b->VsrB(0xf) >> 3) & 0xf;
1846
1847 #if defined(HOST_WORDS_BIGENDIAN)
1848     memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1849     memset(&r->u8[16 - sh], 0, sh);
1850 #else
1851     memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1852     memset(&r->u8[0], 0, sh);
1853 #endif
1854 }
1855
1856 #if defined(HOST_WORDS_BIGENDIAN)
1857 #define VINSERT(suffix, element)                                            \
1858     void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1859     {                                                                       \
1860         memmove(&r->u8[index], &b->u8[8 - sizeof(r->element[0])],           \
1861                sizeof(r->element[0]));                                      \
1862     }
1863 #else
1864 #define VINSERT(suffix, element)                                            \
1865     void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1866     {                                                                       \
1867         uint32_t d = (16 - index) - sizeof(r->element[0]);                  \
1868         memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0]));               \
1869     }
1870 #endif
1871 VINSERT(b, u8)
1872 VINSERT(h, u16)
1873 VINSERT(w, u32)
1874 VINSERT(d, u64)
1875 #undef VINSERT
1876 #if defined(HOST_WORDS_BIGENDIAN)
1877 #define VEXTRACT(suffix, element)                                            \
1878     void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1879     {                                                                        \
1880         uint32_t es = sizeof(r->element[0]);                                 \
1881         memmove(&r->u8[8 - es], &b->u8[index], es);                          \
1882         memset(&r->u8[8], 0, 8);                                             \
1883         memset(&r->u8[0], 0, 8 - es);                                        \
1884     }
1885 #else
1886 #define VEXTRACT(suffix, element)                                            \
1887     void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1888     {                                                                        \
1889         uint32_t es = sizeof(r->element[0]);                                 \
1890         uint32_t s = (16 - index) - es;                                      \
1891         memmove(&r->u8[8], &b->u8[s], es);                                   \
1892         memset(&r->u8[0], 0, 8);                                             \
1893         memset(&r->u8[8 + es], 0, 8 - es);                                   \
1894     }
1895 #endif
1896 VEXTRACT(ub, u8)
1897 VEXTRACT(uh, u16)
1898 VEXTRACT(uw, u32)
1899 VEXTRACT(d, u64)
1900 #undef VEXTRACT
1901
1902 void helper_xxextractuw(CPUPPCState *env, target_ulong xtn,
1903                         target_ulong xbn, uint32_t index)
1904 {
1905     ppc_vsr_t xt, xb;
1906     size_t es = sizeof(uint32_t);
1907     uint32_t ext_index;
1908     int i;
1909
1910     getVSR(xbn, &xb, env);
1911     memset(&xt, 0, sizeof(xt));
1912
1913     ext_index = index;
1914     for (i = 0; i < es; i++, ext_index++) {
1915         xt.VsrB(8 - es + i) = xb.VsrB(ext_index % 16);
1916     }
1917
1918     putVSR(xtn, &xt, env);
1919 }
1920
1921 void helper_xxinsertw(CPUPPCState *env, target_ulong xtn,
1922                       target_ulong xbn, uint32_t index)
1923 {
1924     ppc_vsr_t xt, xb;
1925     size_t es = sizeof(uint32_t);
1926     int ins_index, i = 0;
1927
1928     getVSR(xbn, &xb, env);
1929     getVSR(xtn, &xt, env);
1930
1931     ins_index = index;
1932     for (i = 0; i < es && ins_index < 16; i++, ins_index++) {
1933         xt.VsrB(ins_index) = xb.VsrB(8 - es + i);
1934     }
1935
1936     putVSR(xtn, &xt, env);
1937 }
1938
1939 #define VEXT_SIGNED(name, element, cast)                            \
1940 void helper_##name(ppc_avr_t *r, ppc_avr_t *b)                      \
1941 {                                                                   \
1942     int i;                                                          \
1943     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1944         r->element[i] = (cast)b->element[i];                        \
1945     }                                                               \
1946 }
1947 VEXT_SIGNED(vextsb2w, s32, int8_t)
1948 VEXT_SIGNED(vextsb2d, s64, int8_t)
1949 VEXT_SIGNED(vextsh2w, s32, int16_t)
1950 VEXT_SIGNED(vextsh2d, s64, int16_t)
1951 VEXT_SIGNED(vextsw2d, s64, int32_t)
1952 #undef VEXT_SIGNED
1953
1954 #define VNEG(name, element)                                         \
1955 void helper_##name(ppc_avr_t *r, ppc_avr_t *b)                      \
1956 {                                                                   \
1957     int i;                                                          \
1958     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
1959         r->element[i] = -b->element[i];                             \
1960     }                                                               \
1961 }
1962 VNEG(vnegw, s32)
1963 VNEG(vnegd, s64)
1964 #undef VNEG
1965
1966 void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1967 {
1968     int sh = (b->VsrB(0xf) >> 3) & 0xf;
1969
1970 #if defined(HOST_WORDS_BIGENDIAN)
1971     memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1972     memset(&r->u8[0], 0, sh);
1973 #else
1974     memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1975     memset(&r->u8[16 - sh], 0, sh);
1976 #endif
1977 }
1978
1979 void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1980 {
1981     int i;
1982
1983     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1984         r->u32[i] = a->u32[i] >= b->u32[i];
1985     }
1986 }
1987
1988 void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1989 {
1990     int64_t t;
1991     int i, upper;
1992     ppc_avr_t result;
1993     int sat = 0;
1994
1995     upper = ARRAY_SIZE(r->s32) - 1;
1996     t = (int64_t)b->VsrSW(upper);
1997     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1998         t += a->VsrSW(i);
1999         result.VsrSW(i) = 0;
2000     }
2001     result.VsrSW(upper) = cvtsdsw(t, &sat);
2002     *r = result;
2003
2004     if (sat) {
2005         set_vscr_sat(env);
2006     }
2007 }
2008
2009 void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2010 {
2011     int i, j, upper;
2012     ppc_avr_t result;
2013     int sat = 0;
2014
2015     upper = 1;
2016     for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
2017         int64_t t = (int64_t)b->VsrSW(upper + i * 2);
2018
2019         result.VsrD(i) = 0;
2020         for (j = 0; j < ARRAY_SIZE(r->u64); j++) {
2021             t += a->VsrSW(2 * i + j);
2022         }
2023         result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat);
2024     }
2025
2026     *r = result;
2027     if (sat) {
2028         set_vscr_sat(env);
2029     }
2030 }
2031
2032 void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2033 {
2034     int i, j;
2035     int sat = 0;
2036
2037     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
2038         int64_t t = (int64_t)b->s32[i];
2039
2040         for (j = 0; j < ARRAY_SIZE(r->s32); j++) {
2041             t += a->s8[4 * i + j];
2042         }
2043         r->s32[i] = cvtsdsw(t, &sat);
2044     }
2045
2046     if (sat) {
2047         set_vscr_sat(env);
2048     }
2049 }
2050
2051 void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2052 {
2053     int sat = 0;
2054     int i;
2055
2056     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
2057         int64_t t = (int64_t)b->s32[i];
2058
2059         t += a->s16[2 * i] + a->s16[2 * i + 1];
2060         r->s32[i] = cvtsdsw(t, &sat);
2061     }
2062
2063     if (sat) {
2064         set_vscr_sat(env);
2065     }
2066 }
2067
2068 void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2069 {
2070     int i, j;
2071     int sat = 0;
2072
2073     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
2074         uint64_t t = (uint64_t)b->u32[i];
2075
2076         for (j = 0; j < ARRAY_SIZE(r->u32); j++) {
2077             t += a->u8[4 * i + j];
2078         }
2079         r->u32[i] = cvtuduw(t, &sat);
2080     }
2081
2082     if (sat) {
2083         set_vscr_sat(env);
2084     }
2085 }
2086
2087 #if defined(HOST_WORDS_BIGENDIAN)
2088 #define UPKHI 1
2089 #define UPKLO 0
2090 #else
2091 #define UPKHI 0
2092 #define UPKLO 1
2093 #endif
2094 #define VUPKPX(suffix, hi)                                              \
2095     void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b)                \
2096     {                                                                   \
2097         int i;                                                          \
2098         ppc_avr_t result;                                               \
2099                                                                         \
2100         for (i = 0; i < ARRAY_SIZE(r->u32); i++) {                      \
2101             uint16_t e = b->u16[hi ? i : i + 4];                        \
2102             uint8_t a = (e >> 15) ? 0xff : 0;                           \
2103             uint8_t r = (e >> 10) & 0x1f;                               \
2104             uint8_t g = (e >> 5) & 0x1f;                                \
2105             uint8_t b = e & 0x1f;                                       \
2106                                                                         \
2107             result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b;       \
2108         }                                                               \
2109         *r = result;                                                    \
2110     }
2111 VUPKPX(lpx, UPKLO)
2112 VUPKPX(hpx, UPKHI)
2113 #undef VUPKPX
2114
2115 #define VUPK(suffix, unpacked, packee, hi)                              \
2116     void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b)                \
2117     {                                                                   \
2118         int i;                                                          \
2119         ppc_avr_t result;                                               \
2120                                                                         \
2121         if (hi) {                                                       \
2122             for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) {             \
2123                 result.unpacked[i] = b->packee[i];                      \
2124             }                                                           \
2125         } else {                                                        \
2126             for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \
2127                  i++) {                                                 \
2128                 result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \
2129             }                                                           \
2130         }                                                               \
2131         *r = result;                                                    \
2132     }
2133 VUPK(hsb, s16, s8, UPKHI)
2134 VUPK(hsh, s32, s16, UPKHI)
2135 VUPK(hsw, s64, s32, UPKHI)
2136 VUPK(lsb, s16, s8, UPKLO)
2137 VUPK(lsh, s32, s16, UPKLO)
2138 VUPK(lsw, s64, s32, UPKLO)
2139 #undef VUPK
2140 #undef UPKHI
2141 #undef UPKLO
2142
2143 #define VGENERIC_DO(name, element)                                      \
2144     void helper_v##name(ppc_avr_t *r, ppc_avr_t *b)                     \
2145     {                                                                   \
2146         int i;                                                          \
2147                                                                         \
2148         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2149             r->element[i] = name(b->element[i]);                        \
2150         }                                                               \
2151     }
2152
2153 #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8)
2154 #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16)
2155 #define clzw(v) clz32((v))
2156 #define clzd(v) clz64((v))
2157
2158 VGENERIC_DO(clzb, u8)
2159 VGENERIC_DO(clzh, u16)
2160 VGENERIC_DO(clzw, u32)
2161 VGENERIC_DO(clzd, u64)
2162
2163 #undef clzb
2164 #undef clzh
2165 #undef clzw
2166 #undef clzd
2167
2168 #define ctzb(v) ((v) ? ctz32(v) : 8)
2169 #define ctzh(v) ((v) ? ctz32(v) : 16)
2170 #define ctzw(v) ctz32((v))
2171 #define ctzd(v) ctz64((v))
2172
2173 VGENERIC_DO(ctzb, u8)
2174 VGENERIC_DO(ctzh, u16)
2175 VGENERIC_DO(ctzw, u32)
2176 VGENERIC_DO(ctzd, u64)
2177
2178 #undef ctzb
2179 #undef ctzh
2180 #undef ctzw
2181 #undef ctzd
2182
2183 #define popcntb(v) ctpop8(v)
2184 #define popcnth(v) ctpop16(v)
2185 #define popcntw(v) ctpop32(v)
2186 #define popcntd(v) ctpop64(v)
2187
2188 VGENERIC_DO(popcntb, u8)
2189 VGENERIC_DO(popcnth, u16)
2190 VGENERIC_DO(popcntw, u32)
2191 VGENERIC_DO(popcntd, u64)
2192
2193 #undef popcntb
2194 #undef popcnth
2195 #undef popcntw
2196 #undef popcntd
2197
2198 #undef VGENERIC_DO
2199
2200 #if defined(HOST_WORDS_BIGENDIAN)
2201 #define QW_ONE { .u64 = { 0, 1 } }
2202 #else
2203 #define QW_ONE { .u64 = { 1, 0 } }
2204 #endif
2205
2206 #ifndef CONFIG_INT128
2207
2208 static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a)
2209 {
2210     t->u64[0] = ~a.u64[0];
2211     t->u64[1] = ~a.u64[1];
2212 }
2213
2214 static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b)
2215 {
2216     if (a.VsrD(0) < b.VsrD(0)) {
2217         return -1;
2218     } else if (a.VsrD(0) > b.VsrD(0)) {
2219         return 1;
2220     } else if (a.VsrD(1) < b.VsrD(1)) {
2221         return -1;
2222     } else if (a.VsrD(1) > b.VsrD(1)) {
2223         return 1;
2224     } else {
2225         return 0;
2226     }
2227 }
2228
2229 static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
2230 {
2231     t->VsrD(1) = a.VsrD(1) + b.VsrD(1);
2232     t->VsrD(0) = a.VsrD(0) + b.VsrD(0) +
2233                      (~a.VsrD(1) < b.VsrD(1));
2234 }
2235
2236 static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
2237 {
2238     ppc_avr_t not_a;
2239     t->VsrD(1) = a.VsrD(1) + b.VsrD(1);
2240     t->VsrD(0) = a.VsrD(0) + b.VsrD(0) +
2241                      (~a.VsrD(1) < b.VsrD(1));
2242     avr_qw_not(&not_a, a);
2243     return avr_qw_cmpu(not_a, b) < 0;
2244 }
2245
2246 #endif
2247
2248 void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2249 {
2250 #ifdef CONFIG_INT128
2251     r->u128 = a->u128 + b->u128;
2252 #else
2253     avr_qw_add(r, *a, *b);
2254 #endif
2255 }
2256
2257 void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2258 {
2259 #ifdef CONFIG_INT128
2260     r->u128 = a->u128 + b->u128 + (c->u128 & 1);
2261 #else
2262
2263     if (c->VsrD(1) & 1) {
2264         ppc_avr_t tmp;
2265
2266         tmp.VsrD(0) = 0;
2267         tmp.VsrD(1) = c->VsrD(1) & 1;
2268         avr_qw_add(&tmp, *a, tmp);
2269         avr_qw_add(r, tmp, *b);
2270     } else {
2271         avr_qw_add(r, *a, *b);
2272     }
2273 #endif
2274 }
2275
2276 void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2277 {
2278 #ifdef CONFIG_INT128
2279     r->u128 = (~a->u128 < b->u128);
2280 #else
2281     ppc_avr_t not_a;
2282
2283     avr_qw_not(&not_a, *a);
2284
2285     r->VsrD(0) = 0;
2286     r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0);
2287 #endif
2288 }
2289
2290 void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2291 {
2292 #ifdef CONFIG_INT128
2293     int carry_out = (~a->u128 < b->u128);
2294     if (!carry_out && (c->u128 & 1)) {
2295         carry_out = ((a->u128 + b->u128 + 1) == 0) &&
2296                     ((a->u128 != 0) || (b->u128 != 0));
2297     }
2298     r->u128 = carry_out;
2299 #else
2300
2301     int carry_in = c->VsrD(1) & 1;
2302     int carry_out = 0;
2303     ppc_avr_t tmp;
2304
2305     carry_out = avr_qw_addc(&tmp, *a, *b);
2306
2307     if (!carry_out && carry_in) {
2308         ppc_avr_t one = QW_ONE;
2309         carry_out = avr_qw_addc(&tmp, tmp, one);
2310     }
2311     r->VsrD(0) = 0;
2312     r->VsrD(1) = carry_out;
2313 #endif
2314 }
2315
2316 void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2317 {
2318 #ifdef CONFIG_INT128
2319     r->u128 = a->u128 - b->u128;
2320 #else
2321     ppc_avr_t tmp;
2322     ppc_avr_t one = QW_ONE;
2323
2324     avr_qw_not(&tmp, *b);
2325     avr_qw_add(&tmp, *a, tmp);
2326     avr_qw_add(r, tmp, one);
2327 #endif
2328 }
2329
2330 void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2331 {
2332 #ifdef CONFIG_INT128
2333     r->u128 = a->u128 + ~b->u128 + (c->u128 & 1);
2334 #else
2335     ppc_avr_t tmp, sum;
2336
2337     avr_qw_not(&tmp, *b);
2338     avr_qw_add(&sum, *a, tmp);
2339
2340     tmp.VsrD(0) = 0;
2341     tmp.VsrD(1) = c->VsrD(1) & 1;
2342     avr_qw_add(r, sum, tmp);
2343 #endif
2344 }
2345
2346 void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2347 {
2348 #ifdef CONFIG_INT128
2349     r->u128 = (~a->u128 < ~b->u128) ||
2350                  (a->u128 + ~b->u128 == (__uint128_t)-1);
2351 #else
2352     int carry = (avr_qw_cmpu(*a, *b) > 0);
2353     if (!carry) {
2354         ppc_avr_t tmp;
2355         avr_qw_not(&tmp, *b);
2356         avr_qw_add(&tmp, *a, tmp);
2357         carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull));
2358     }
2359     r->VsrD(0) = 0;
2360     r->VsrD(1) = carry;
2361 #endif
2362 }
2363
2364 void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2365 {
2366 #ifdef CONFIG_INT128
2367     r->u128 =
2368         (~a->u128 < ~b->u128) ||
2369         ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1));
2370 #else
2371     int carry_in = c->VsrD(1) & 1;
2372     int carry_out = (avr_qw_cmpu(*a, *b) > 0);
2373     if (!carry_out && carry_in) {
2374         ppc_avr_t tmp;
2375         avr_qw_not(&tmp, *b);
2376         avr_qw_add(&tmp, *a, tmp);
2377         carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull));
2378     }
2379
2380     r->VsrD(0) = 0;
2381     r->VsrD(1) = carry_out;
2382 #endif
2383 }
2384
2385 #define BCD_PLUS_PREF_1 0xC
2386 #define BCD_PLUS_PREF_2 0xF
2387 #define BCD_PLUS_ALT_1  0xA
2388 #define BCD_NEG_PREF    0xD
2389 #define BCD_NEG_ALT     0xB
2390 #define BCD_PLUS_ALT_2  0xE
2391 #define NATIONAL_PLUS   0x2B
2392 #define NATIONAL_NEG    0x2D
2393
2394 #if defined(HOST_WORDS_BIGENDIAN)
2395 #define BCD_DIG_BYTE(n) (15 - ((n) / 2))
2396 #else
2397 #define BCD_DIG_BYTE(n) ((n) / 2)
2398 #endif
2399
2400 static int bcd_get_sgn(ppc_avr_t *bcd)
2401 {
2402     switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) {
2403     case BCD_PLUS_PREF_1:
2404     case BCD_PLUS_PREF_2:
2405     case BCD_PLUS_ALT_1:
2406     case BCD_PLUS_ALT_2:
2407     {
2408         return 1;
2409     }
2410
2411     case BCD_NEG_PREF:
2412     case BCD_NEG_ALT:
2413     {
2414         return -1;
2415     }
2416
2417     default:
2418     {
2419         return 0;
2420     }
2421     }
2422 }
2423
2424 static int bcd_preferred_sgn(int sgn, int ps)
2425 {
2426     if (sgn >= 0) {
2427         return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2;
2428     } else {
2429         return BCD_NEG_PREF;
2430     }
2431 }
2432
2433 static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid)
2434 {
2435     uint8_t result;
2436     if (n & 1) {
2437         result = bcd->u8[BCD_DIG_BYTE(n)] >> 4;
2438     } else {
2439        result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF;
2440     }
2441
2442     if (unlikely(result > 9)) {
2443         *invalid = true;
2444     }
2445     return result;
2446 }
2447
2448 static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n)
2449 {
2450     if (n & 1) {
2451         bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F;
2452         bcd->u8[BCD_DIG_BYTE(n)] |= (digit << 4);
2453     } else {
2454         bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0;
2455         bcd->u8[BCD_DIG_BYTE(n)] |= digit;
2456     }
2457 }
2458
2459 static bool bcd_is_valid(ppc_avr_t *bcd)
2460 {
2461     int i;
2462     int invalid = 0;
2463
2464     if (bcd_get_sgn(bcd) == 0) {
2465         return false;
2466     }
2467
2468     for (i = 1; i < 32; i++) {
2469         bcd_get_digit(bcd, i, &invalid);
2470         if (unlikely(invalid)) {
2471             return false;
2472         }
2473     }
2474     return true;
2475 }
2476
2477 static int bcd_cmp_zero(ppc_avr_t *bcd)
2478 {
2479     if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) {
2480         return CRF_EQ;
2481     } else {
2482         return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT;
2483     }
2484 }
2485
2486 static uint16_t get_national_digit(ppc_avr_t *reg, int n)
2487 {
2488     return reg->VsrH(7 - n);
2489 }
2490
2491 static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n)
2492 {
2493     reg->VsrH(7 - n) = val;
2494 }
2495
2496 static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b)
2497 {
2498     int i;
2499     int invalid = 0;
2500     for (i = 31; i > 0; i--) {
2501         uint8_t dig_a = bcd_get_digit(a, i, &invalid);
2502         uint8_t dig_b = bcd_get_digit(b, i, &invalid);
2503         if (unlikely(invalid)) {
2504             return 0; /* doesn't matter */
2505         } else if (dig_a > dig_b) {
2506             return 1;
2507         } else if (dig_a < dig_b) {
2508             return -1;
2509         }
2510     }
2511
2512     return 0;
2513 }
2514
2515 static void bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2516                        int *overflow)
2517 {
2518     int carry = 0;
2519     int i;
2520     for (i = 1; i <= 31; i++) {
2521         uint8_t digit = bcd_get_digit(a, i, invalid) +
2522                         bcd_get_digit(b, i, invalid) + carry;
2523         if (digit > 9) {
2524             carry = 1;
2525             digit -= 10;
2526         } else {
2527             carry = 0;
2528         }
2529
2530         bcd_put_digit(t, digit, i);
2531     }
2532
2533     *overflow = carry;
2534 }
2535
2536 static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2537                        int *overflow)
2538 {
2539     int carry = 0;
2540     int i;
2541
2542     for (i = 1; i <= 31; i++) {
2543         uint8_t digit = bcd_get_digit(a, i, invalid) -
2544                         bcd_get_digit(b, i, invalid) + carry;
2545         if (digit & 0x80) {
2546             carry = -1;
2547             digit += 10;
2548         } else {
2549             carry = 0;
2550         }
2551
2552         bcd_put_digit(t, digit, i);
2553     }
2554
2555     *overflow = carry;
2556 }
2557
2558 uint32_t helper_bcdadd(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2559 {
2560
2561     int sgna = bcd_get_sgn(a);
2562     int sgnb = bcd_get_sgn(b);
2563     int invalid = (sgna == 0) || (sgnb == 0);
2564     int overflow = 0;
2565     uint32_t cr = 0;
2566     ppc_avr_t result = { .u64 = { 0, 0 } };
2567
2568     if (!invalid) {
2569         if (sgna == sgnb) {
2570             result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2571             bcd_add_mag(&result, a, b, &invalid, &overflow);
2572             cr = bcd_cmp_zero(&result);
2573         } else {
2574             int magnitude = bcd_cmp_mag(a, b);
2575             if (magnitude > 0) {
2576                 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2577                 bcd_sub_mag(&result, a, b, &invalid, &overflow);
2578                 cr = (sgna > 0) ? CRF_GT : CRF_LT;
2579             } else if (magnitude < 0) {
2580                 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps);
2581                 bcd_sub_mag(&result, b, a, &invalid, &overflow);
2582                 cr = (sgnb > 0) ? CRF_GT : CRF_LT;
2583             } else {
2584                 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(0, ps);
2585                 cr = CRF_EQ;
2586             }
2587         }
2588     }
2589
2590     if (unlikely(invalid)) {
2591         result.VsrD(0) = result.VsrD(1) = -1;
2592         cr = CRF_SO;
2593     } else if (overflow) {
2594         cr |= CRF_SO;
2595     }
2596
2597     *r = result;
2598
2599     return cr;
2600 }
2601
2602 uint32_t helper_bcdsub(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2603 {
2604     ppc_avr_t bcopy = *b;
2605     int sgnb = bcd_get_sgn(b);
2606     if (sgnb < 0) {
2607         bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0);
2608     } else if (sgnb > 0) {
2609         bcd_put_digit(&bcopy, BCD_NEG_PREF, 0);
2610     }
2611     /* else invalid ... defer to bcdadd code for proper handling */
2612
2613     return helper_bcdadd(r, a, &bcopy, ps);
2614 }
2615
2616 uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2617 {
2618     int i;
2619     int cr = 0;
2620     uint16_t national = 0;
2621     uint16_t sgnb = get_national_digit(b, 0);
2622     ppc_avr_t ret = { .u64 = { 0, 0 } };
2623     int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG);
2624
2625     for (i = 1; i < 8; i++) {
2626         national = get_national_digit(b, i);
2627         if (unlikely(national < 0x30 || national > 0x39)) {
2628             invalid = 1;
2629             break;
2630         }
2631
2632         bcd_put_digit(&ret, national & 0xf, i);
2633     }
2634
2635     if (sgnb == NATIONAL_PLUS) {
2636         bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0);
2637     } else {
2638         bcd_put_digit(&ret, BCD_NEG_PREF, 0);
2639     }
2640
2641     cr = bcd_cmp_zero(&ret);
2642
2643     if (unlikely(invalid)) {
2644         cr = CRF_SO;
2645     }
2646
2647     *r = ret;
2648
2649     return cr;
2650 }
2651
2652 uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2653 {
2654     int i;
2655     int cr = 0;
2656     int sgnb = bcd_get_sgn(b);
2657     int invalid = (sgnb == 0);
2658     ppc_avr_t ret = { .u64 = { 0, 0 } };
2659
2660     int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0);
2661
2662     for (i = 1; i < 8; i++) {
2663         set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i);
2664
2665         if (unlikely(invalid)) {
2666             break;
2667         }
2668     }
2669     set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0);
2670
2671     cr = bcd_cmp_zero(b);
2672
2673     if (ox_flag) {
2674         cr |= CRF_SO;
2675     }
2676
2677     if (unlikely(invalid)) {
2678         cr = CRF_SO;
2679     }
2680
2681     *r = ret;
2682
2683     return cr;
2684 }
2685
2686 uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2687 {
2688     int i;
2689     int cr = 0;
2690     int invalid = 0;
2691     int zone_digit = 0;
2692     int zone_lead = ps ? 0xF : 0x3;
2693     int digit = 0;
2694     ppc_avr_t ret = { .u64 = { 0, 0 } };
2695     int sgnb = b->u8[BCD_DIG_BYTE(0)] >> 4;
2696
2697     if (unlikely((sgnb < 0xA) && ps)) {
2698         invalid = 1;
2699     }
2700
2701     for (i = 0; i < 16; i++) {
2702         zone_digit = i ? b->u8[BCD_DIG_BYTE(i * 2)] >> 4 : zone_lead;
2703         digit = b->u8[BCD_DIG_BYTE(i * 2)] & 0xF;
2704         if (unlikely(zone_digit != zone_lead || digit > 0x9)) {
2705             invalid = 1;
2706             break;
2707         }
2708
2709         bcd_put_digit(&ret, digit, i + 1);
2710     }
2711
2712     if ((ps && (sgnb == 0xB || sgnb == 0xD)) ||
2713             (!ps && (sgnb & 0x4))) {
2714         bcd_put_digit(&ret, BCD_NEG_PREF, 0);
2715     } else {
2716         bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0);
2717     }
2718
2719     cr = bcd_cmp_zero(&ret);
2720
2721     if (unlikely(invalid)) {
2722         cr = CRF_SO;
2723     }
2724
2725     *r = ret;
2726
2727     return cr;
2728 }
2729
2730 uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2731 {
2732     int i;
2733     int cr = 0;
2734     uint8_t digit = 0;
2735     int sgnb = bcd_get_sgn(b);
2736     int zone_lead = (ps) ? 0xF0 : 0x30;
2737     int invalid = (sgnb == 0);
2738     ppc_avr_t ret = { .u64 = { 0, 0 } };
2739
2740     int ox_flag = ((b->VsrD(0) >> 4) != 0);
2741
2742     for (i = 0; i < 16; i++) {
2743         digit = bcd_get_digit(b, i + 1, &invalid);
2744
2745         if (unlikely(invalid)) {
2746             break;
2747         }
2748
2749         ret.u8[BCD_DIG_BYTE(i * 2)] = zone_lead + digit;
2750     }
2751
2752     if (ps) {
2753         bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1);
2754     } else {
2755         bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1);
2756     }
2757
2758     cr = bcd_cmp_zero(b);
2759
2760     if (ox_flag) {
2761         cr |= CRF_SO;
2762     }
2763
2764     if (unlikely(invalid)) {
2765         cr = CRF_SO;
2766     }
2767
2768     *r = ret;
2769
2770     return cr;
2771 }
2772
2773 uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2774 {
2775     int i;
2776     int cr = 0;
2777     uint64_t lo_value;
2778     uint64_t hi_value;
2779     ppc_avr_t ret = { .u64 = { 0, 0 } };
2780
2781     if (b->VsrSD(0) < 0) {
2782         lo_value = -b->VsrSD(1);
2783         hi_value = ~b->VsrD(0) + !lo_value;
2784         bcd_put_digit(&ret, 0xD, 0);
2785     } else {
2786         lo_value = b->VsrD(1);
2787         hi_value = b->VsrD(0);
2788         bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0);
2789     }
2790
2791     if (divu128(&lo_value, &hi_value, 1000000000000000ULL) ||
2792             lo_value > 9999999999999999ULL) {
2793         cr = CRF_SO;
2794     }
2795
2796     for (i = 1; i < 16; hi_value /= 10, i++) {
2797         bcd_put_digit(&ret, hi_value % 10, i);
2798     }
2799
2800     for (; i < 32; lo_value /= 10, i++) {
2801         bcd_put_digit(&ret, lo_value % 10, i);
2802     }
2803
2804     cr |= bcd_cmp_zero(&ret);
2805
2806     *r = ret;
2807
2808     return cr;
2809 }
2810
2811 uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2812 {
2813     uint8_t i;
2814     int cr;
2815     uint64_t carry;
2816     uint64_t unused;
2817     uint64_t lo_value;
2818     uint64_t hi_value = 0;
2819     int sgnb = bcd_get_sgn(b);
2820     int invalid = (sgnb == 0);
2821
2822     lo_value = bcd_get_digit(b, 31, &invalid);
2823     for (i = 30; i > 0; i--) {
2824         mulu64(&lo_value, &carry, lo_value, 10ULL);
2825         mulu64(&hi_value, &unused, hi_value, 10ULL);
2826         lo_value += bcd_get_digit(b, i, &invalid);
2827         hi_value += carry;
2828
2829         if (unlikely(invalid)) {
2830             break;
2831         }
2832     }
2833
2834     if (sgnb == -1) {
2835         r->VsrSD(1) = -lo_value;
2836         r->VsrSD(0) = ~hi_value + !r->VsrSD(1);
2837     } else {
2838         r->VsrSD(1) = lo_value;
2839         r->VsrSD(0) = hi_value;
2840     }
2841
2842     cr = bcd_cmp_zero(b);
2843
2844     if (unlikely(invalid)) {
2845         cr = CRF_SO;
2846     }
2847
2848     return cr;
2849 }
2850
2851 uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2852 {
2853     int i;
2854     int invalid = 0;
2855
2856     if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) {
2857         return CRF_SO;
2858     }
2859
2860     *r = *a;
2861     bcd_put_digit(r, b->u8[BCD_DIG_BYTE(0)] & 0xF, 0);
2862
2863     for (i = 1; i < 32; i++) {
2864         bcd_get_digit(a, i, &invalid);
2865         bcd_get_digit(b, i, &invalid);
2866         if (unlikely(invalid)) {
2867             return CRF_SO;
2868         }
2869     }
2870
2871     return bcd_cmp_zero(r);
2872 }
2873
2874 uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2875 {
2876     int sgnb = bcd_get_sgn(b);
2877
2878     *r = *b;
2879     bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0);
2880
2881     if (bcd_is_valid(b) == false) {
2882         return CRF_SO;
2883     }
2884
2885     return bcd_cmp_zero(r);
2886 }
2887
2888 uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2889 {
2890     int cr;
2891 #if defined(HOST_WORDS_BIGENDIAN)
2892     int i = a->s8[7];
2893 #else
2894     int i = a->s8[8];
2895 #endif
2896     bool ox_flag = false;
2897     int sgnb = bcd_get_sgn(b);
2898     ppc_avr_t ret = *b;
2899     ret.VsrD(1) &= ~0xf;
2900
2901     if (bcd_is_valid(b) == false) {
2902         return CRF_SO;
2903     }
2904
2905     if (unlikely(i > 31)) {
2906         i = 31;
2907     } else if (unlikely(i < -31)) {
2908         i = -31;
2909     }
2910
2911     if (i > 0) {
2912         ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2913     } else {
2914         urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
2915     }
2916     bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0);
2917
2918     *r = ret;
2919
2920     cr = bcd_cmp_zero(r);
2921     if (ox_flag) {
2922         cr |= CRF_SO;
2923     }
2924
2925     return cr;
2926 }
2927
2928 uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2929 {
2930     int cr;
2931     int i;
2932     int invalid = 0;
2933     bool ox_flag = false;
2934     ppc_avr_t ret = *b;
2935
2936     for (i = 0; i < 32; i++) {
2937         bcd_get_digit(b, i, &invalid);
2938
2939         if (unlikely(invalid)) {
2940             return CRF_SO;
2941         }
2942     }
2943
2944 #if defined(HOST_WORDS_BIGENDIAN)
2945     i = a->s8[7];
2946 #else
2947     i = a->s8[8];
2948 #endif
2949     if (i >= 32) {
2950         ox_flag = true;
2951         ret.VsrD(1) = ret.VsrD(0) = 0;
2952     } else if (i <= -32) {
2953         ret.VsrD(1) = ret.VsrD(0) = 0;
2954     } else if (i > 0) {
2955         ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2956     } else {
2957         urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
2958     }
2959     *r = ret;
2960
2961     cr = bcd_cmp_zero(r);
2962     if (ox_flag) {
2963         cr |= CRF_SO;
2964     }
2965
2966     return cr;
2967 }
2968
2969 uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2970 {
2971     int cr;
2972     int unused = 0;
2973     int invalid = 0;
2974     bool ox_flag = false;
2975     int sgnb = bcd_get_sgn(b);
2976     ppc_avr_t ret = *b;
2977     ret.VsrD(1) &= ~0xf;
2978
2979 #if defined(HOST_WORDS_BIGENDIAN)
2980     int i = a->s8[7];
2981     ppc_avr_t bcd_one = { .u64 = { 0, 0x10 } };
2982 #else
2983     int i = a->s8[8];
2984     ppc_avr_t bcd_one = { .u64 = { 0x10, 0 } };
2985 #endif
2986
2987     if (bcd_is_valid(b) == false) {
2988         return CRF_SO;
2989     }
2990
2991     if (unlikely(i > 31)) {
2992         i = 31;
2993     } else if (unlikely(i < -31)) {
2994         i = -31;
2995     }
2996
2997     if (i > 0) {
2998         ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2999     } else {
3000         urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
3001
3002         if (bcd_get_digit(&ret, 0, &invalid) >= 5) {
3003             bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused);
3004         }
3005     }
3006     bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0);
3007
3008     cr = bcd_cmp_zero(&ret);
3009     if (ox_flag) {
3010         cr |= CRF_SO;
3011     }
3012     *r = ret;
3013
3014     return cr;
3015 }
3016
3017 uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
3018 {
3019     uint64_t mask;
3020     uint32_t ox_flag = 0;
3021 #if defined(HOST_WORDS_BIGENDIAN)
3022     int i = a->s16[3] + 1;
3023 #else
3024     int i = a->s16[4] + 1;
3025 #endif
3026     ppc_avr_t ret = *b;
3027
3028     if (bcd_is_valid(b) == false) {
3029         return CRF_SO;
3030     }
3031
3032     if (i > 16 && i < 32) {
3033         mask = (uint64_t)-1 >> (128 - i * 4);
3034         if (ret.VsrD(0) & ~mask) {
3035             ox_flag = CRF_SO;
3036         }
3037
3038         ret.VsrD(0) &= mask;
3039     } else if (i >= 0 && i <= 16) {
3040         mask = (uint64_t)-1 >> (64 - i * 4);
3041         if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) {
3042             ox_flag = CRF_SO;
3043         }
3044
3045         ret.VsrD(1) &= mask;
3046         ret.VsrD(0) = 0;
3047     }
3048     bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0);
3049     *r = ret;
3050
3051     return bcd_cmp_zero(&ret) | ox_flag;
3052 }
3053
3054 uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
3055 {
3056     int i;
3057     uint64_t mask;
3058     uint32_t ox_flag = 0;
3059     int invalid = 0;
3060     ppc_avr_t ret = *b;
3061
3062     for (i = 0; i < 32; i++) {
3063         bcd_get_digit(b, i, &invalid);
3064
3065         if (unlikely(invalid)) {
3066             return CRF_SO;
3067         }
3068     }
3069
3070 #if defined(HOST_WORDS_BIGENDIAN)
3071     i = a->s16[3];
3072 #else
3073     i = a->s16[4];
3074 #endif
3075     if (i > 16 && i < 33) {
3076         mask = (uint64_t)-1 >> (128 - i * 4);
3077         if (ret.VsrD(0) & ~mask) {
3078             ox_flag = CRF_SO;
3079         }
3080
3081         ret.VsrD(0) &= mask;
3082     } else if (i > 0 && i <= 16) {
3083         mask = (uint64_t)-1 >> (64 - i * 4);
3084         if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) {
3085             ox_flag = CRF_SO;
3086         }
3087
3088         ret.VsrD(1) &= mask;
3089         ret.VsrD(0) = 0;
3090     } else if (i == 0) {
3091         if (ret.VsrD(0) || ret.VsrD(1)) {
3092             ox_flag = CRF_SO;
3093         }
3094         ret.VsrD(0) = ret.VsrD(1) = 0;
3095     }
3096
3097     *r = ret;
3098     if (r->VsrD(0) == 0 && r->VsrD(1) == 0) {
3099         return ox_flag | CRF_EQ;
3100     }
3101
3102     return ox_flag | CRF_GT;
3103 }
3104
3105 void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a)
3106 {
3107     int i;
3108     VECTOR_FOR_INORDER_I(i, u8) {
3109         r->u8[i] = AES_sbox[a->u8[i]];
3110     }
3111 }
3112
3113 void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
3114 {
3115     ppc_avr_t result;
3116     int i;
3117
3118     VECTOR_FOR_INORDER_I(i, u32) {
3119         result.VsrW(i) = b->VsrW(i) ^
3120             (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^
3121              AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^
3122              AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^
3123              AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]);
3124     }
3125     *r = result;
3126 }
3127
3128 void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
3129 {
3130     ppc_avr_t result;
3131     int i;
3132
3133     VECTOR_FOR_INORDER_I(i, u8) {
3134         result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]);
3135     }
3136     *r = result;
3137 }
3138
3139 void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
3140 {
3141     /* This differs from what is written in ISA V2.07.  The RTL is */
3142     /* incorrect and will be fixed in V2.07B.                      */
3143     int i;
3144     ppc_avr_t tmp;
3145
3146     VECTOR_FOR_INORDER_I(i, u8) {
3147         tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])];
3148     }
3149
3150     VECTOR_FOR_INORDER_I(i, u32) {
3151         r->VsrW(i) =
3152             AES_imc[tmp.VsrB(4 * i + 0)][0] ^
3153             AES_imc[tmp.VsrB(4 * i + 1)][1] ^
3154             AES_imc[tmp.VsrB(4 * i + 2)][2] ^
3155             AES_imc[tmp.VsrB(4 * i + 3)][3];
3156     }
3157 }
3158
3159 void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
3160 {
3161     ppc_avr_t result;
3162     int i;
3163
3164     VECTOR_FOR_INORDER_I(i, u8) {
3165         result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]);
3166     }
3167     *r = result;
3168 }
3169
3170 void helper_vshasigmaw(ppc_avr_t *r,  ppc_avr_t *a, uint32_t st_six)
3171 {
3172     int st = (st_six & 0x10) != 0;
3173     int six = st_six & 0xF;
3174     int i;
3175
3176     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
3177         if (st == 0) {
3178             if ((six & (0x8 >> i)) == 0) {
3179                 r->VsrW(i) = ror32(a->VsrW(i), 7) ^
3180                              ror32(a->VsrW(i), 18) ^
3181                              (a->VsrW(i) >> 3);
3182             } else { /* six.bit[i] == 1 */
3183                 r->VsrW(i) = ror32(a->VsrW(i), 17) ^
3184                              ror32(a->VsrW(i), 19) ^
3185                              (a->VsrW(i) >> 10);
3186             }
3187         } else { /* st == 1 */
3188             if ((six & (0x8 >> i)) == 0) {
3189                 r->VsrW(i) = ror32(a->VsrW(i), 2) ^
3190                              ror32(a->VsrW(i), 13) ^
3191                              ror32(a->VsrW(i), 22);
3192             } else { /* six.bit[i] == 1 */
3193                 r->VsrW(i) = ror32(a->VsrW(i), 6) ^
3194                              ror32(a->VsrW(i), 11) ^
3195                              ror32(a->VsrW(i), 25);
3196             }
3197         }
3198     }
3199 }
3200
3201 void helper_vshasigmad(ppc_avr_t *r,  ppc_avr_t *a, uint32_t st_six)
3202 {
3203     int st = (st_six & 0x10) != 0;
3204     int six = st_six & 0xF;
3205     int i;
3206
3207     for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
3208         if (st == 0) {
3209             if ((six & (0x8 >> (2 * i))) == 0) {
3210                 r->VsrD(i) = ror64(a->VsrD(i), 1) ^
3211                              ror64(a->VsrD(i), 8) ^
3212                              (a->VsrD(i) >> 7);
3213             } else { /* six.bit[2*i] == 1 */
3214                 r->VsrD(i) = ror64(a->VsrD(i), 19) ^
3215                              ror64(a->VsrD(i), 61) ^
3216                              (a->VsrD(i) >> 6);
3217             }
3218         } else { /* st == 1 */
3219             if ((six & (0x8 >> (2 * i))) == 0) {
3220                 r->VsrD(i) = ror64(a->VsrD(i), 28) ^
3221                              ror64(a->VsrD(i), 34) ^
3222                              ror64(a->VsrD(i), 39);
3223             } else { /* six.bit[2*i] == 1 */
3224                 r->VsrD(i) = ror64(a->VsrD(i), 14) ^
3225                              ror64(a->VsrD(i), 18) ^
3226                              ror64(a->VsrD(i), 41);
3227             }
3228         }
3229     }
3230 }
3231
3232 void helper_vpermxor(ppc_avr_t *r,  ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
3233 {
3234     ppc_avr_t result;
3235     int i;
3236
3237     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
3238         int indexA = c->VsrB(i) >> 4;
3239         int indexB = c->VsrB(i) & 0xF;
3240
3241         result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB);
3242     }
3243     *r = result;
3244 }
3245
3246 #undef VECTOR_FOR_INORDER_I
3247
3248 /*****************************************************************************/
3249 /* SPE extension helpers */
3250 /* Use a table to make this quicker */
3251 static const uint8_t hbrev[16] = {
3252     0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
3253     0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
3254 };
3255
3256 static inline uint8_t byte_reverse(uint8_t val)
3257 {
3258     return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
3259 }
3260
3261 static inline uint32_t word_reverse(uint32_t val)
3262 {
3263     return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
3264         (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
3265 }
3266
3267 #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */
3268 target_ulong helper_brinc(target_ulong arg1, target_ulong arg2)
3269 {
3270     uint32_t a, b, d, mask;
3271
3272     mask = UINT32_MAX >> (32 - MASKBITS);
3273     a = arg1 & mask;
3274     b = arg2 & mask;
3275     d = word_reverse(1 + word_reverse(a | ~b));
3276     return (arg1 & ~mask) | (d & b);
3277 }
3278
3279 uint32_t helper_cntlsw32(uint32_t val)
3280 {
3281     if (val & 0x80000000) {
3282         return clz32(~val);
3283     } else {
3284         return clz32(val);
3285     }
3286 }
3287
3288 uint32_t helper_cntlzw32(uint32_t val)
3289 {
3290     return clz32(val);
3291 }
3292
3293 /* 440 specific */
3294 target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high,
3295                           target_ulong low, uint32_t update_Rc)
3296 {
3297     target_ulong mask;
3298     int i;
3299
3300     i = 1;
3301     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
3302         if ((high & mask) == 0) {
3303             if (update_Rc) {
3304                 env->crf[0] = 0x4;
3305             }
3306             goto done;
3307         }
3308         i++;
3309     }
3310     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
3311         if ((low & mask) == 0) {
3312             if (update_Rc) {
3313                 env->crf[0] = 0x8;
3314             }
3315             goto done;
3316         }
3317         i++;
3318     }
3319     i = 8;
3320     if (update_Rc) {
3321         env->crf[0] = 0x2;
3322     }
3323  done:
3324     env->xer = (env->xer & ~0x7F) | i;
3325     if (update_Rc) {
3326         env->crf[0] |= xer_so;
3327     }
3328     return i;
3329 }