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