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