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(¬_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(¬_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 } 3344