vcs.maemo.org Git - qemu/blob - target-ppc/op_helper.c

   1 /*
   2  *  PowerPC 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, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
  19  */
  20 #include <string.h>
  21 #include "exec.h"
  22 #include "host-utils.h"
  23 #include "helper.h"
  24
  25 #include "helper_regs.h"
  26
  27 //#define DEBUG_OP
  28 //#define DEBUG_EXCEPTIONS
  29 //#define DEBUG_SOFTWARE_TLB
  30
  31 #ifdef DEBUG_SOFTWARE_TLB
  32 #  define LOG_SWTLB(...) qemu_log(__VA_ARGS__)
  33 #else
  34 #  define LOG_SWTLB(...) do { } while (0)
  35 #endif
  36
  37
  38 /*****************************************************************************/
  39 /* Exceptions processing helpers */
  40
  41 void helper_raise_exception_err (uint32_t exception, uint32_t error_code)
  42 {
  43 #if 0
  44     printf("Raise exception %3x code : %d\n", exception, error_code);
  45 #endif
  46     env->exception_index = exception;
  47     env->error_code = error_code;
  48     cpu_loop_exit();
  49 }
  50
  51 void helper_raise_exception (uint32_t exception)
  52 {
  53     helper_raise_exception_err(exception, 0);
  54 }
  55
  56 /*****************************************************************************/
  57 /* SPR accesses */
  58 void helper_load_dump_spr (uint32_t sprn)
  59 {
  60     qemu_log("Read SPR %d %03x => " ADDRX "\n",
  61                 sprn, sprn, env->spr[sprn]);
  62 }
  63
  64 void helper_store_dump_spr (uint32_t sprn)
  65 {
  66     qemu_log("Write SPR %d %03x <= " ADDRX "\n",
  67                 sprn, sprn, env->spr[sprn]);
  68 }
  69
  70 target_ulong helper_load_tbl (void)
  71 {
  72     return cpu_ppc_load_tbl(env);
  73 }
  74
  75 target_ulong helper_load_tbu (void)
  76 {
  77     return cpu_ppc_load_tbu(env);
  78 }
  79
  80 target_ulong helper_load_atbl (void)
  81 {
  82     return cpu_ppc_load_atbl(env);
  83 }
  84
  85 target_ulong helper_load_atbu (void)
  86 {
  87     return cpu_ppc_load_atbu(env);
  88 }
  89
  90 target_ulong helper_load_601_rtcl (void)
  91 {
  92     return cpu_ppc601_load_rtcl(env);
  93 }
  94
  95 target_ulong helper_load_601_rtcu (void)
  96 {
  97     return cpu_ppc601_load_rtcu(env);
  98 }
  99
 100 #if !defined(CONFIG_USER_ONLY)
 101 #if defined (TARGET_PPC64)
 102 void helper_store_asr (target_ulong val)
 103 {
 104     ppc_store_asr(env, val);
 105 }
 106 #endif
 107
 108 void helper_store_sdr1 (target_ulong val)
 109 {
 110     ppc_store_sdr1(env, val);
 111 }
 112
 113 void helper_store_tbl (target_ulong val)
 114 {
 115     cpu_ppc_store_tbl(env, val);
 116 }
 117
 118 void helper_store_tbu (target_ulong val)
 119 {
 120     cpu_ppc_store_tbu(env, val);
 121 }
 122
 123 void helper_store_atbl (target_ulong val)
 124 {
 125     cpu_ppc_store_atbl(env, val);
 126 }
 127
 128 void helper_store_atbu (target_ulong val)
 129 {
 130     cpu_ppc_store_atbu(env, val);
 131 }
 132
 133 void helper_store_601_rtcl (target_ulong val)
 134 {
 135     cpu_ppc601_store_rtcl(env, val);
 136 }
 137
 138 void helper_store_601_rtcu (target_ulong val)
 139 {
 140     cpu_ppc601_store_rtcu(env, val);
 141 }
 142
 143 target_ulong helper_load_decr (void)
 144 {
 145     return cpu_ppc_load_decr(env);
 146 }
 147
 148 void helper_store_decr (target_ulong val)
 149 {
 150     cpu_ppc_store_decr(env, val);
 151 }
 152
 153 void helper_store_hid0_601 (target_ulong val)
 154 {
 155     target_ulong hid0;
 156
 157     hid0 = env->spr[SPR_HID0];
 158     if ((val ^ hid0) & 0x00000008) {
 159         /* Change current endianness */
 160         env->hflags &= ~(1 << MSR_LE);
 161         env->hflags_nmsr &= ~(1 << MSR_LE);
 162         env->hflags_nmsr |= (1 << MSR_LE) & (((val >> 3) & 1) << MSR_LE);
 163         env->hflags |= env->hflags_nmsr;
 164         qemu_log("%s: set endianness to %c => " ADDRX "\n",
 165                     __func__, val & 0x8 ? 'l' : 'b', env->hflags);
 166     }
 167     env->spr[SPR_HID0] = (uint32_t)val;
 168 }
 169
 170 void helper_store_403_pbr (uint32_t num, target_ulong value)
 171 {
 172     if (likely(env->pb[num] != value)) {
 173         env->pb[num] = value;
 174         /* Should be optimized */
 175         tlb_flush(env, 1);
 176     }
 177 }
 178
 179 target_ulong helper_load_40x_pit (void)
 180 {
 181     return load_40x_pit(env);
 182 }
 183
 184 void helper_store_40x_pit (target_ulong val)
 185 {
 186     store_40x_pit(env, val);
 187 }
 188
 189 void helper_store_40x_dbcr0 (target_ulong val)
 190 {
 191     store_40x_dbcr0(env, val);
 192 }
 193
 194 void helper_store_40x_sler (target_ulong val)
 195 {
 196     store_40x_sler(env, val);
 197 }
 198
 199 void helper_store_booke_tcr (target_ulong val)
 200 {
 201     store_booke_tcr(env, val);
 202 }
 203
 204 void helper_store_booke_tsr (target_ulong val)
 205 {
 206     store_booke_tsr(env, val);
 207 }
 208
 209 void helper_store_ibatu (uint32_t nr, target_ulong val)
 210 {
 211     ppc_store_ibatu(env, nr, val);
 212 }
 213
 214 void helper_store_ibatl (uint32_t nr, target_ulong val)
 215 {
 216     ppc_store_ibatl(env, nr, val);
 217 }
 218
 219 void helper_store_dbatu (uint32_t nr, target_ulong val)
 220 {
 221     ppc_store_dbatu(env, nr, val);
 222 }
 223
 224 void helper_store_dbatl (uint32_t nr, target_ulong val)
 225 {
 226     ppc_store_dbatl(env, nr, val);
 227 }
 228
 229 void helper_store_601_batl (uint32_t nr, target_ulong val)
 230 {
 231     ppc_store_ibatl_601(env, nr, val);
 232 }
 233
 234 void helper_store_601_batu (uint32_t nr, target_ulong val)
 235 {
 236     ppc_store_ibatu_601(env, nr, val);
 237 }
 238 #endif
 239
 240 /*****************************************************************************/
 241 /* Memory load and stores */
 242
 243 static always_inline target_ulong addr_add(target_ulong addr, target_long arg)
 244 {
 245 #if defined(TARGET_PPC64)
 246         if (!msr_sf)
 247             return (uint32_t)(addr + arg);
 248         else
 249 #endif
 250             return addr + arg;
 251 }
 252
 253 void helper_lmw (target_ulong addr, uint32_t reg)
 254 {
 255     for (; reg < 32; reg++) {
 256         if (msr_le)
 257             env->gpr[reg] = bswap32(ldl(addr));
 258         else
 259             env->gpr[reg] = ldl(addr);
 260         addr = addr_add(addr, 4);
 261     }
 262 }
 263
 264 void helper_stmw (target_ulong addr, uint32_t reg)
 265 {
 266     for (; reg < 32; reg++) {
 267         if (msr_le)
 268             stl(addr, bswap32((uint32_t)env->gpr[reg]));
 269         else
 270             stl(addr, (uint32_t)env->gpr[reg]);
 271         addr = addr_add(addr, 4);
 272     }
 273 }
 274
 275 void helper_lsw(target_ulong addr, uint32_t nb, uint32_t reg)
 276 {
 277     int sh;
 278     for (; nb > 3; nb -= 4) {
 279         env->gpr[reg] = ldl(addr);
 280         reg = (reg + 1) % 32;
 281         addr = addr_add(addr, 4);
 282     }
 283     if (unlikely(nb > 0)) {
 284         env->gpr[reg] = 0;
 285         for (sh = 24; nb > 0; nb--, sh -= 8) {
 286             env->gpr[reg] |= ldub(addr) << sh;
 287             addr = addr_add(addr, 1);
 288         }
 289     }
 290 }
 291 /* PPC32 specification says we must generate an exception if
 292  * rA is in the range of registers to be loaded.
 293  * In an other hand, IBM says this is valid, but rA won't be loaded.
 294  * For now, I'll follow the spec...
 295  */
 296 void helper_lswx(target_ulong addr, uint32_t reg, uint32_t ra, uint32_t rb)
 297 {
 298     if (likely(xer_bc != 0)) {
 299         if (unlikely((ra != 0 && reg < ra && (reg + xer_bc) > ra) ||
 300                      (reg < rb && (reg + xer_bc) > rb))) {
 301             helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
 302                                        POWERPC_EXCP_INVAL |
 303                                        POWERPC_EXCP_INVAL_LSWX);
 304         } else {
 305             helper_lsw(addr, xer_bc, reg);
 306         }
 307     }
 308 }
 309
 310 void helper_stsw(target_ulong addr, uint32_t nb, uint32_t reg)
 311 {
 312     int sh;
 313     for (; nb > 3; nb -= 4) {
 314         stl(addr, env->gpr[reg]);
 315         reg = (reg + 1) % 32;
 316         addr = addr_add(addr, 4);
 317     }
 318     if (unlikely(nb > 0)) {
 319         for (sh = 24; nb > 0; nb--, sh -= 8) {
 320             stb(addr, (env->gpr[reg] >> sh) & 0xFF);
 321             addr = addr_add(addr, 1);
 322         }
 323     }
 324 }
 325
 326 static void do_dcbz(target_ulong addr, int dcache_line_size)
 327 {
 328     addr &= ~(dcache_line_size - 1);
 329     int i;
 330     for (i = 0 ; i < dcache_line_size ; i += 4) {
 331         stl(addr + i , 0);
 332     }
 333     if (env->reserve == addr)
 334         env->reserve = (target_ulong)-1ULL;
 335 }
 336
 337 void helper_dcbz(target_ulong addr)
 338 {
 339     do_dcbz(addr, env->dcache_line_size);
 340 }
 341
 342 void helper_dcbz_970(target_ulong addr)
 343 {
 344     if (((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1)
 345         do_dcbz(addr, 32);
 346     else
 347         do_dcbz(addr, env->dcache_line_size);
 348 }
 349
 350 void helper_icbi(target_ulong addr)
 351 {
 352     uint32_t tmp;
 353
 354     addr &= ~(env->dcache_line_size - 1);
 355     /* Invalidate one cache line :
 356      * PowerPC specification says this is to be treated like a load
 357      * (not a fetch) by the MMU. To be sure it will be so,
 358      * do the load "by hand".
 359      */
 360     tmp = ldl(addr);
 361     tb_invalidate_page_range(addr, addr + env->icache_line_size);
 362 }
 363
 364 // XXX: to be tested
 365 target_ulong helper_lscbx (target_ulong addr, uint32_t reg, uint32_t ra, uint32_t rb)
 366 {
 367     int i, c, d;
 368     d = 24;
 369     for (i = 0; i < xer_bc; i++) {
 370         c = ldub(addr);
 371         addr = addr_add(addr, 1);
 372         /* ra (if not 0) and rb are never modified */
 373         if (likely(reg != rb && (ra == 0 || reg != ra))) {
 374             env->gpr[reg] = (env->gpr[reg] & ~(0xFF << d)) | (c << d);
 375         }
 376         if (unlikely(c == xer_cmp))
 377             break;
 378         if (likely(d != 0)) {
 379             d -= 8;
 380         } else {
 381             d = 24;
 382             reg++;
 383             reg = reg & 0x1F;
 384         }
 385     }
 386     return i;
 387 }
 388
 389 /*****************************************************************************/
 390 /* Fixed point operations helpers */
 391 #if defined(TARGET_PPC64)
 392
 393 /* multiply high word */
 394 uint64_t helper_mulhd (uint64_t arg1, uint64_t arg2)
 395 {
 396     uint64_t tl, th;
 397
 398     muls64(&tl, &th, arg1, arg2);
 399     return th;
 400 }
 401
 402 /* multiply high word unsigned */
 403 uint64_t helper_mulhdu (uint64_t arg1, uint64_t arg2)
 404 {
 405     uint64_t tl, th;
 406
 407     mulu64(&tl, &th, arg1, arg2);
 408     return th;
 409 }
 410
 411 uint64_t helper_mulldo (uint64_t arg1, uint64_t arg2)
 412 {
 413     int64_t th;
 414     uint64_t tl;
 415
 416     muls64(&tl, (uint64_t *)&th, arg1, arg2);
 417     /* If th != 0 && th != -1, then we had an overflow */
 418     if (likely((uint64_t)(th + 1) <= 1)) {
 419         env->xer &= ~(1 << XER_OV);
 420     } else {
 421         env->xer |= (1 << XER_OV) | (1 << XER_SO);
 422     }
 423     return (int64_t)tl;
 424 }
 425 #endif
 426
 427 target_ulong helper_cntlzw (target_ulong t)
 428 {
 429     return clz32(t);
 430 }
 431
 432 #if defined(TARGET_PPC64)
 433 target_ulong helper_cntlzd (target_ulong t)
 434 {
 435     return clz64(t);
 436 }
 437 #endif
 438
 439 /* shift right arithmetic helper */
 440 target_ulong helper_sraw (target_ulong value, target_ulong shift)
 441 {
 442     int32_t ret;
 443
 444     if (likely(!(shift & 0x20))) {
 445         if (likely((uint32_t)shift != 0)) {
 446             shift &= 0x1f;
 447             ret = (int32_t)value >> shift;
 448             if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
 449                 env->xer &= ~(1 << XER_CA);
 450             } else {
 451                 env->xer |= (1 << XER_CA);
 452             }
 453         } else {
 454             ret = (int32_t)value;
 455             env->xer &= ~(1 << XER_CA);
 456         }
 457     } else {
 458         ret = (int32_t)value >> 31;
 459         if (ret) {
 460             env->xer |= (1 << XER_CA);
 461         } else {
 462             env->xer &= ~(1 << XER_CA);
 463         }
 464     }
 465     return (target_long)ret;
 466 }
 467
 468 #if defined(TARGET_PPC64)
 469 target_ulong helper_srad (target_ulong value, target_ulong shift)
 470 {
 471     int64_t ret;
 472
 473     if (likely(!(shift & 0x40))) {
 474         if (likely((uint64_t)shift != 0)) {
 475             shift &= 0x3f;
 476             ret = (int64_t)value >> shift;
 477             if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
 478                 env->xer &= ~(1 << XER_CA);
 479             } else {
 480                 env->xer |= (1 << XER_CA);
 481             }
 482         } else {
 483             ret = (int64_t)value;
 484             env->xer &= ~(1 << XER_CA);
 485         }
 486     } else {
 487         ret = (int64_t)value >> 63;
 488         if (ret) {
 489             env->xer |= (1 << XER_CA);
 490         } else {
 491             env->xer &= ~(1 << XER_CA);
 492         }
 493     }
 494     return ret;
 495 }
 496 #endif
 497
 498 target_ulong helper_popcntb (target_ulong val)
 499 {
 500     val = (val & 0x55555555) + ((val >>  1) & 0x55555555);
 501     val = (val & 0x33333333) + ((val >>  2) & 0x33333333);
 502     val = (val & 0x0f0f0f0f) + ((val >>  4) & 0x0f0f0f0f);
 503     return val;
 504 }
 505
 506 #if defined(TARGET_PPC64)
 507 target_ulong helper_popcntb_64 (target_ulong val)
 508 {
 509     val = (val & 0x5555555555555555ULL) + ((val >>  1) & 0x5555555555555555ULL);
 510     val = (val & 0x3333333333333333ULL) + ((val >>  2) & 0x3333333333333333ULL);
 511     val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >>  4) & 0x0f0f0f0f0f0f0f0fULL);
 512     return val;
 513 }
 514 #endif
 515
 516 /*****************************************************************************/
 517 /* Floating point operations helpers */
 518 uint64_t helper_float32_to_float64(uint32_t arg)
 519 {
 520     CPU_FloatU f;
 521     CPU_DoubleU d;
 522     f.l = arg;
 523     d.d = float32_to_float64(f.f, &env->fp_status);
 524     return d.ll;
 525 }
 526
 527 uint32_t helper_float64_to_float32(uint64_t arg)
 528 {
 529     CPU_FloatU f;
 530     CPU_DoubleU d;
 531     d.ll = arg;
 532     f.f = float64_to_float32(d.d, &env->fp_status);
 533     return f.l;
 534 }
 535
 536 static always_inline int isden (float64 d)
 537 {
 538     CPU_DoubleU u;
 539
 540     u.d = d;
 541
 542     return ((u.ll >> 52) & 0x7FF) == 0;
 543 }
 544
 545 uint32_t helper_compute_fprf (uint64_t arg, uint32_t set_fprf)
 546 {
 547     CPU_DoubleU farg;
 548     int isneg;
 549     int ret;
 550     farg.ll = arg;
 551     isneg = float64_is_neg(farg.d);
 552     if (unlikely(float64_is_nan(farg.d))) {
 553         if (float64_is_signaling_nan(farg.d)) {
 554             /* Signaling NaN: flags are undefined */
 555             ret = 0x00;
 556         } else {
 557             /* Quiet NaN */
 558             ret = 0x11;
 559         }
 560     } else if (unlikely(float64_is_infinity(farg.d))) {
 561         /* +/- infinity */
 562         if (isneg)
 563             ret = 0x09;
 564         else
 565             ret = 0x05;
 566     } else {
 567         if (float64_is_zero(farg.d)) {
 568             /* +/- zero */
 569             if (isneg)
 570                 ret = 0x12;
 571             else
 572                 ret = 0x02;
 573         } else {
 574             if (isden(farg.d)) {
 575                 /* Denormalized numbers */
 576                 ret = 0x10;
 577             } else {
 578                 /* Normalized numbers */
 579                 ret = 0x00;
 580             }
 581             if (isneg) {
 582                 ret |= 0x08;
 583             } else {
 584                 ret |= 0x04;
 585             }
 586         }
 587     }
 588     if (set_fprf) {
 589         /* We update FPSCR_FPRF */
 590         env->fpscr &= ~(0x1F << FPSCR_FPRF);
 591         env->fpscr |= ret << FPSCR_FPRF;
 592     }
 593     /* We just need fpcc to update Rc1 */
 594     return ret & 0xF;
 595 }
 596
 597 /* Floating-point invalid operations exception */
 598 static always_inline uint64_t fload_invalid_op_excp (int op)
 599 {
 600     uint64_t ret = 0;
 601     int ve;
 602
 603     ve = fpscr_ve;
 604     switch (op) {
 605     case POWERPC_EXCP_FP_VXSNAN:
 606         env->fpscr |= 1 << FPSCR_VXSNAN;
 607         break;
 608     case POWERPC_EXCP_FP_VXSOFT:
 609         env->fpscr |= 1 << FPSCR_VXSOFT;
 610         break;
 611     case POWERPC_EXCP_FP_VXISI:
 612         /* Magnitude subtraction of infinities */
 613         env->fpscr |= 1 << FPSCR_VXISI;
 614         goto update_arith;
 615     case POWERPC_EXCP_FP_VXIDI:
 616         /* Division of infinity by infinity */
 617         env->fpscr |= 1 << FPSCR_VXIDI;
 618         goto update_arith;
 619     case POWERPC_EXCP_FP_VXZDZ:
 620         /* Division of zero by zero */
 621         env->fpscr |= 1 << FPSCR_VXZDZ;
 622         goto update_arith;
 623     case POWERPC_EXCP_FP_VXIMZ:
 624         /* Multiplication of zero by infinity */
 625         env->fpscr |= 1 << FPSCR_VXIMZ;
 626         goto update_arith;
 627     case POWERPC_EXCP_FP_VXVC:
 628         /* Ordered comparison of NaN */
 629         env->fpscr |= 1 << FPSCR_VXVC;
 630         env->fpscr &= ~(0xF << FPSCR_FPCC);
 631         env->fpscr |= 0x11 << FPSCR_FPCC;
 632         /* We must update the target FPR before raising the exception */
 633         if (ve != 0) {
 634             env->exception_index = POWERPC_EXCP_PROGRAM;
 635             env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_VXVC;
 636             /* Update the floating-point enabled exception summary */
 637             env->fpscr |= 1 << FPSCR_FEX;
 638             /* Exception is differed */
 639             ve = 0;
 640         }
 641         break;
 642     case POWERPC_EXCP_FP_VXSQRT:
 643         /* Square root of a negative number */
 644         env->fpscr |= 1 << FPSCR_VXSQRT;
 645     update_arith:
 646         env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
 647         if (ve == 0) {
 648             /* Set the result to quiet NaN */
 649             ret = 0xFFF8000000000000ULL;
 650             env->fpscr &= ~(0xF << FPSCR_FPCC);
 651             env->fpscr |= 0x11 << FPSCR_FPCC;
 652         }
 653         break;
 654     case POWERPC_EXCP_FP_VXCVI:
 655         /* Invalid conversion */
 656         env->fpscr |= 1 << FPSCR_VXCVI;
 657         env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
 658         if (ve == 0) {
 659             /* Set the result to quiet NaN */
 660             ret = 0xFFF8000000000000ULL;
 661             env->fpscr &= ~(0xF << FPSCR_FPCC);
 662             env->fpscr |= 0x11 << FPSCR_FPCC;
 663         }
 664         break;
 665     }
 666     /* Update the floating-point invalid operation summary */
 667     env->fpscr |= 1 << FPSCR_VX;
 668     /* Update the floating-point exception summary */
 669     env->fpscr |= 1 << FPSCR_FX;
 670     if (ve != 0) {
 671         /* Update the floating-point enabled exception summary */
 672         env->fpscr |= 1 << FPSCR_FEX;
 673         if (msr_fe0 != 0 || msr_fe1 != 0)
 674             helper_raise_exception_err(POWERPC_EXCP_PROGRAM, POWERPC_EXCP_FP | op);
 675     }
 676     return ret;
 677 }
 678
 679 static always_inline void float_zero_divide_excp (void)
 680 {
 681     env->fpscr |= 1 << FPSCR_ZX;
 682     env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
 683     /* Update the floating-point exception summary */
 684     env->fpscr |= 1 << FPSCR_FX;
 685     if (fpscr_ze != 0) {
 686         /* Update the floating-point enabled exception summary */
 687         env->fpscr |= 1 << FPSCR_FEX;
 688         if (msr_fe0 != 0 || msr_fe1 != 0) {
 689             helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
 690                                        POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX);
 691         }
 692     }
 693 }
 694
 695 static always_inline void float_overflow_excp (void)
 696 {
 697     env->fpscr |= 1 << FPSCR_OX;
 698     /* Update the floating-point exception summary */
 699     env->fpscr |= 1 << FPSCR_FX;
 700     if (fpscr_oe != 0) {
 701         /* XXX: should adjust the result */
 702         /* Update the floating-point enabled exception summary */
 703         env->fpscr |= 1 << FPSCR_FEX;
 704         /* We must update the target FPR before raising the exception */
 705         env->exception_index = POWERPC_EXCP_PROGRAM;
 706         env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_OX;
 707     } else {
 708         env->fpscr |= 1 << FPSCR_XX;
 709         env->fpscr |= 1 << FPSCR_FI;
 710     }
 711 }
 712
 713 static always_inline void float_underflow_excp (void)
 714 {
 715     env->fpscr |= 1 << FPSCR_UX;
 716     /* Update the floating-point exception summary */
 717     env->fpscr |= 1 << FPSCR_FX;
 718     if (fpscr_ue != 0) {
 719         /* XXX: should adjust the result */
 720         /* Update the floating-point enabled exception summary */
 721         env->fpscr |= 1 << FPSCR_FEX;
 722         /* We must update the target FPR before raising the exception */
 723         env->exception_index = POWERPC_EXCP_PROGRAM;
 724         env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_UX;
 725     }
 726 }
 727
 728 static always_inline void float_inexact_excp (void)
 729 {
 730     env->fpscr |= 1 << FPSCR_XX;
 731     /* Update the floating-point exception summary */
 732     env->fpscr |= 1 << FPSCR_FX;
 733     if (fpscr_xe != 0) {
 734         /* Update the floating-point enabled exception summary */
 735         env->fpscr |= 1 << FPSCR_FEX;
 736         /* We must update the target FPR before raising the exception */
 737         env->exception_index = POWERPC_EXCP_PROGRAM;
 738         env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_XX;
 739     }
 740 }
 741
 742 static always_inline void fpscr_set_rounding_mode (void)
 743 {
 744     int rnd_type;
 745
 746     /* Set rounding mode */
 747     switch (fpscr_rn) {
 748     case 0:
 749         /* Best approximation (round to nearest) */
 750         rnd_type = float_round_nearest_even;
 751         break;
 752     case 1:
 753         /* Smaller magnitude (round toward zero) */
 754         rnd_type = float_round_to_zero;
 755         break;
 756     case 2:
 757         /* Round toward +infinite */
 758         rnd_type = float_round_up;
 759         break;
 760     default:
 761     case 3:
 762         /* Round toward -infinite */
 763         rnd_type = float_round_down;
 764         break;
 765     }
 766     set_float_rounding_mode(rnd_type, &env->fp_status);
 767 }
 768
 769 void helper_fpscr_clrbit (uint32_t bit)
 770 {
 771     int prev;
 772
 773     prev = (env->fpscr >> bit) & 1;
 774     env->fpscr &= ~(1 << bit);
 775     if (prev == 1) {
 776         switch (bit) {
 777         case FPSCR_RN1:
 778         case FPSCR_RN:
 779             fpscr_set_rounding_mode();
 780             break;
 781         default:
 782             break;
 783         }
 784     }
 785 }
 786
 787 void helper_fpscr_setbit (uint32_t bit)
 788 {
 789     int prev;
 790
 791     prev = (env->fpscr >> bit) & 1;
 792     env->fpscr |= 1 << bit;
 793     if (prev == 0) {
 794         switch (bit) {
 795         case FPSCR_VX:
 796             env->fpscr |= 1 << FPSCR_FX;
 797             if (fpscr_ve)
 798                 goto raise_ve;
 799         case FPSCR_OX:
 800             env->fpscr |= 1 << FPSCR_FX;
 801             if (fpscr_oe)
 802                 goto raise_oe;
 803             break;
 804         case FPSCR_UX:
 805             env->fpscr |= 1 << FPSCR_FX;
 806             if (fpscr_ue)
 807                 goto raise_ue;
 808             break;
 809         case FPSCR_ZX:
 810             env->fpscr |= 1 << FPSCR_FX;
 811             if (fpscr_ze)
 812                 goto raise_ze;
 813             break;
 814         case FPSCR_XX:
 815             env->fpscr |= 1 << FPSCR_FX;
 816             if (fpscr_xe)
 817                 goto raise_xe;
 818             break;
 819         case FPSCR_VXSNAN:
 820         case FPSCR_VXISI:
 821         case FPSCR_VXIDI:
 822         case FPSCR_VXZDZ:
 823         case FPSCR_VXIMZ:
 824         case FPSCR_VXVC:
 825         case FPSCR_VXSOFT:
 826         case FPSCR_VXSQRT:
 827         case FPSCR_VXCVI:
 828             env->fpscr |= 1 << FPSCR_VX;
 829             env->fpscr |= 1 << FPSCR_FX;
 830             if (fpscr_ve != 0)
 831                 goto raise_ve;
 832             break;
 833         case FPSCR_VE:
 834             if (fpscr_vx != 0) {
 835             raise_ve:
 836                 env->error_code = POWERPC_EXCP_FP;
 837                 if (fpscr_vxsnan)
 838                     env->error_code |= POWERPC_EXCP_FP_VXSNAN;
 839                 if (fpscr_vxisi)
 840                     env->error_code |= POWERPC_EXCP_FP_VXISI;
 841                 if (fpscr_vxidi)
 842                     env->error_code |= POWERPC_EXCP_FP_VXIDI;
 843                 if (fpscr_vxzdz)
 844                     env->error_code |= POWERPC_EXCP_FP_VXZDZ;
 845                 if (fpscr_vximz)
 846                     env->error_code |= POWERPC_EXCP_FP_VXIMZ;
 847                 if (fpscr_vxvc)
 848                     env->error_code |= POWERPC_EXCP_FP_VXVC;
 849                 if (fpscr_vxsoft)
 850                     env->error_code |= POWERPC_EXCP_FP_VXSOFT;
 851                 if (fpscr_vxsqrt)
 852                     env->error_code |= POWERPC_EXCP_FP_VXSQRT;
 853                 if (fpscr_vxcvi)
 854                     env->error_code |= POWERPC_EXCP_FP_VXCVI;
 855                 goto raise_excp;
 856             }
 857             break;
 858         case FPSCR_OE:
 859             if (fpscr_ox != 0) {
 860             raise_oe:
 861                 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_OX;
 862                 goto raise_excp;
 863             }
 864             break;
 865         case FPSCR_UE:
 866             if (fpscr_ux != 0) {
 867             raise_ue:
 868                 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_UX;
 869                 goto raise_excp;
 870             }
 871             break;
 872         case FPSCR_ZE:
 873             if (fpscr_zx != 0) {
 874             raise_ze:
 875                 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX;
 876                 goto raise_excp;
 877             }
 878             break;
 879         case FPSCR_XE:
 880             if (fpscr_xx != 0) {
 881             raise_xe:
 882                 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_XX;
 883                 goto raise_excp;
 884             }
 885             break;
 886         case FPSCR_RN1:
 887         case FPSCR_RN:
 888             fpscr_set_rounding_mode();
 889             break;
 890         default:
 891             break;
 892         raise_excp:
 893             /* Update the floating-point enabled exception summary */
 894             env->fpscr |= 1 << FPSCR_FEX;
 895                 /* We have to update Rc1 before raising the exception */
 896             env->exception_index = POWERPC_EXCP_PROGRAM;
 897             break;
 898         }
 899     }
 900 }
 901
 902 void helper_store_fpscr (uint64_t arg, uint32_t mask)
 903 {
 904     /*
 905      * We use only the 32 LSB of the incoming fpr
 906      */
 907     uint32_t prev, new;
 908     int i;
 909
 910     prev = env->fpscr;
 911     new = (uint32_t)arg;
 912     new &= ~0x60000000;
 913     new |= prev & 0x60000000;
 914     for (i = 0; i < 8; i++) {
 915         if (mask & (1 << i)) {
 916             env->fpscr &= ~(0xF << (4 * i));
 917             env->fpscr |= new & (0xF << (4 * i));
 918         }
 919     }
 920     /* Update VX and FEX */
 921     if (fpscr_ix != 0)
 922         env->fpscr |= 1 << FPSCR_VX;
 923     else
 924         env->fpscr &= ~(1 << FPSCR_VX);
 925     if ((fpscr_ex & fpscr_eex) != 0) {
 926         env->fpscr |= 1 << FPSCR_FEX;
 927         env->exception_index = POWERPC_EXCP_PROGRAM;
 928         /* XXX: we should compute it properly */
 929         env->error_code = POWERPC_EXCP_FP;
 930     }
 931     else
 932         env->fpscr &= ~(1 << FPSCR_FEX);
 933     fpscr_set_rounding_mode();
 934 }
 935
 936 void helper_float_check_status (void)
 937 {
 938 #ifdef CONFIG_SOFTFLOAT
 939     if (env->exception_index == POWERPC_EXCP_PROGRAM &&
 940         (env->error_code & POWERPC_EXCP_FP)) {
 941         /* Differred floating-point exception after target FPR update */
 942         if (msr_fe0 != 0 || msr_fe1 != 0)
 943             helper_raise_exception_err(env->exception_index, env->error_code);
 944     } else {
 945         int status = get_float_exception_flags(&env->fp_status);
 946         if (status & float_flag_divbyzero) {
 947             float_zero_divide_excp();
 948         } else if (status & float_flag_overflow) {
 949             float_overflow_excp();
 950         } else if (status & float_flag_underflow) {
 951             float_underflow_excp();
 952         } else if (status & float_flag_inexact) {
 953             float_inexact_excp();
 954         }
 955     }
 956 #else
 957     if (env->exception_index == POWERPC_EXCP_PROGRAM &&
 958         (env->error_code & POWERPC_EXCP_FP)) {
 959         /* Differred floating-point exception after target FPR update */
 960         if (msr_fe0 != 0 || msr_fe1 != 0)
 961             helper_raise_exception_err(env->exception_index, env->error_code);
 962     }
 963 #endif
 964 }
 965
 966 #ifdef CONFIG_SOFTFLOAT
 967 void helper_reset_fpstatus (void)
 968 {
 969     set_float_exception_flags(0, &env->fp_status);
 970 }
 971 #endif
 972
 973 /* fadd - fadd. */
 974 uint64_t helper_fadd (uint64_t arg1, uint64_t arg2)
 975 {
 976     CPU_DoubleU farg1, farg2;
 977
 978     farg1.ll = arg1;
 979     farg2.ll = arg2;
 980 #if USE_PRECISE_EMULATION
 981     if (unlikely(float64_is_signaling_nan(farg1.d) ||
 982                  float64_is_signaling_nan(farg2.d))) {
 983         /* sNaN addition */
 984         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
 985     } else if (unlikely(float64_is_infinity(farg1.d) && float64_is_infinity(farg2.d) &&
 986                       float64_is_neg(farg1.d) != float64_is_neg(farg2.d))) {
 987         /* Magnitude subtraction of infinities */
 988         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
 989     } else {
 990         farg1.d = float64_add(farg1.d, farg2.d, &env->fp_status);
 991     }
 992 #else
 993     farg1.d = float64_add(farg1.d, farg2.d, &env->fp_status);
 994 #endif
 995     return farg1.ll;
 996 }
 997
 998 /* fsub - fsub. */
 999 uint64_t helper_fsub (uint64_t arg1, uint64_t arg2)
1000 {
1001     CPU_DoubleU farg1, farg2;
1002
1003     farg1.ll = arg1;
1004     farg2.ll = arg2;
1005 #if USE_PRECISE_EMULATION
1006 {
1007     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1008                  float64_is_signaling_nan(farg2.d))) {
1009         /* sNaN subtraction */
1010         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1011     } else if (unlikely(float64_is_infinity(farg1.d) && float64_is_infinity(farg2.d) &&
1012                       float64_is_neg(farg1.d) == float64_is_neg(farg2.d))) {
1013         /* Magnitude subtraction of infinities */
1014         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1015     } else {
1016         farg1.d = float64_sub(farg1.d, farg2.d, &env->fp_status);
1017     }
1018 }
1019 #else
1020     farg1.d = float64_sub(farg1.d, farg2.d, &env->fp_status);
1021 #endif
1022     return farg1.ll;
1023 }
1024
1025 /* fmul - fmul. */
1026 uint64_t helper_fmul (uint64_t arg1, uint64_t arg2)
1027 {
1028     CPU_DoubleU farg1, farg2;
1029
1030     farg1.ll = arg1;
1031     farg2.ll = arg2;
1032 #if USE_PRECISE_EMULATION
1033     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1034                  float64_is_signaling_nan(farg2.d))) {
1035         /* sNaN multiplication */
1036         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1037     } else if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
1038                         (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
1039         /* Multiplication of zero by infinity */
1040         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1041     } else {
1042         farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1043     }
1044 #else
1045     farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1046 #endif
1047     return farg1.ll;
1048 }
1049
1050 /* fdiv - fdiv. */
1051 uint64_t helper_fdiv (uint64_t arg1, uint64_t arg2)
1052 {
1053     CPU_DoubleU farg1, farg2;
1054
1055     farg1.ll = arg1;
1056     farg2.ll = arg2;
1057 #if USE_PRECISE_EMULATION
1058     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1059                  float64_is_signaling_nan(farg2.d))) {
1060         /* sNaN division */
1061         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1062     } else if (unlikely(float64_is_infinity(farg1.d) && float64_is_infinity(farg2.d))) {
1063         /* Division of infinity by infinity */
1064         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIDI);
1065     } else if (unlikely(float64_is_zero(farg1.d) && float64_is_zero(farg2.d))) {
1066         /* Division of zero by zero */
1067         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXZDZ);
1068     } else {
1069         farg1.d = float64_div(farg1.d, farg2.d, &env->fp_status);
1070     }
1071 #else
1072     farg1.d = float64_div(farg1.d, farg2.d, &env->fp_status);
1073 #endif
1074     return farg1.ll;
1075 }
1076
1077 /* fabs */
1078 uint64_t helper_fabs (uint64_t arg)
1079 {
1080     CPU_DoubleU farg;
1081
1082     farg.ll = arg;
1083     farg.d = float64_abs(farg.d);
1084     return farg.ll;
1085 }
1086
1087 /* fnabs */
1088 uint64_t helper_fnabs (uint64_t arg)
1089 {
1090     CPU_DoubleU farg;
1091
1092     farg.ll = arg;
1093     farg.d = float64_abs(farg.d);
1094     farg.d = float64_chs(farg.d);
1095     return farg.ll;
1096 }
1097
1098 /* fneg */
1099 uint64_t helper_fneg (uint64_t arg)
1100 {
1101     CPU_DoubleU farg;
1102
1103     farg.ll = arg;
1104     farg.d = float64_chs(farg.d);
1105     return farg.ll;
1106 }
1107
1108 /* fctiw - fctiw. */
1109 uint64_t helper_fctiw (uint64_t arg)
1110 {
1111     CPU_DoubleU farg;
1112     farg.ll = arg;
1113
1114     if (unlikely(float64_is_signaling_nan(farg.d))) {
1115         /* sNaN conversion */
1116         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1117     } else if (unlikely(float64_is_nan(farg.d) || float64_is_infinity(farg.d))) {
1118         /* qNan / infinity conversion */
1119         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1120     } else {
1121         farg.ll = float64_to_int32(farg.d, &env->fp_status);
1122 #if USE_PRECISE_EMULATION
1123         /* XXX: higher bits are not supposed to be significant.
1124          *     to make tests easier, return the same as a real PowerPC 750
1125          */
1126         farg.ll |= 0xFFF80000ULL << 32;
1127 #endif
1128     }
1129     return farg.ll;
1130 }
1131
1132 /* fctiwz - fctiwz. */
1133 uint64_t helper_fctiwz (uint64_t arg)
1134 {
1135     CPU_DoubleU farg;
1136     farg.ll = arg;
1137
1138     if (unlikely(float64_is_signaling_nan(farg.d))) {
1139         /* sNaN conversion */
1140         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1141     } else if (unlikely(float64_is_nan(farg.d) || float64_is_infinity(farg.d))) {
1142         /* qNan / infinity conversion */
1143         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1144     } else {
1145         farg.ll = float64_to_int32_round_to_zero(farg.d, &env->fp_status);
1146 #if USE_PRECISE_EMULATION
1147         /* XXX: higher bits are not supposed to be significant.
1148          *     to make tests easier, return the same as a real PowerPC 750
1149          */
1150         farg.ll |= 0xFFF80000ULL << 32;
1151 #endif
1152     }
1153     return farg.ll;
1154 }
1155
1156 #if defined(TARGET_PPC64)
1157 /* fcfid - fcfid. */
1158 uint64_t helper_fcfid (uint64_t arg)
1159 {
1160     CPU_DoubleU farg;
1161     farg.d = int64_to_float64(arg, &env->fp_status);
1162     return farg.ll;
1163 }
1164
1165 /* fctid - fctid. */
1166 uint64_t helper_fctid (uint64_t arg)
1167 {
1168     CPU_DoubleU farg;
1169     farg.ll = arg;
1170
1171     if (unlikely(float64_is_signaling_nan(farg.d))) {
1172         /* sNaN conversion */
1173         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1174     } else if (unlikely(float64_is_nan(farg.d) || float64_is_infinity(farg.d))) {
1175         /* qNan / infinity conversion */
1176         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1177     } else {
1178         farg.ll = float64_to_int64(farg.d, &env->fp_status);
1179     }
1180     return farg.ll;
1181 }
1182
1183 /* fctidz - fctidz. */
1184 uint64_t helper_fctidz (uint64_t arg)
1185 {
1186     CPU_DoubleU farg;
1187     farg.ll = arg;
1188
1189     if (unlikely(float64_is_signaling_nan(farg.d))) {
1190         /* sNaN conversion */
1191         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1192     } else if (unlikely(float64_is_nan(farg.d) || float64_is_infinity(farg.d))) {
1193         /* qNan / infinity conversion */
1194         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1195     } else {
1196         farg.ll = float64_to_int64_round_to_zero(farg.d, &env->fp_status);
1197     }
1198     return farg.ll;
1199 }
1200
1201 #endif
1202
1203 static always_inline uint64_t do_fri (uint64_t arg, int rounding_mode)
1204 {
1205     CPU_DoubleU farg;
1206     farg.ll = arg;
1207
1208     if (unlikely(float64_is_signaling_nan(farg.d))) {
1209         /* sNaN round */
1210         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1211     } else if (unlikely(float64_is_nan(farg.d) || float64_is_infinity(farg.d))) {
1212         /* qNan / infinity round */
1213         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1214     } else {
1215         set_float_rounding_mode(rounding_mode, &env->fp_status);
1216         farg.ll = float64_round_to_int(farg.d, &env->fp_status);
1217         /* Restore rounding mode from FPSCR */
1218         fpscr_set_rounding_mode();
1219     }
1220     return farg.ll;
1221 }
1222
1223 uint64_t helper_frin (uint64_t arg)
1224 {
1225     return do_fri(arg, float_round_nearest_even);
1226 }
1227
1228 uint64_t helper_friz (uint64_t arg)
1229 {
1230     return do_fri(arg, float_round_to_zero);
1231 }
1232
1233 uint64_t helper_frip (uint64_t arg)
1234 {
1235     return do_fri(arg, float_round_up);
1236 }
1237
1238 uint64_t helper_frim (uint64_t arg)
1239 {
1240     return do_fri(arg, float_round_down);
1241 }
1242
1243 /* fmadd - fmadd. */
1244 uint64_t helper_fmadd (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1245 {
1246     CPU_DoubleU farg1, farg2, farg3;
1247
1248     farg1.ll = arg1;
1249     farg2.ll = arg2;
1250     farg3.ll = arg3;
1251 #if USE_PRECISE_EMULATION
1252     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1253                  float64_is_signaling_nan(farg2.d) ||
1254                  float64_is_signaling_nan(farg3.d))) {
1255         /* sNaN operation */
1256         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1257     } else if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
1258                         (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
1259         /* Multiplication of zero by infinity */
1260         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1261     } else {
1262 #ifdef FLOAT128
1263         /* This is the way the PowerPC specification defines it */
1264         float128 ft0_128, ft1_128;
1265
1266         ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1267         ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1268         ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1269         if (unlikely(float128_is_infinity(ft0_128) && float64_is_infinity(farg3.d) &&
1270                      float128_is_neg(ft0_128) != float64_is_neg(farg3.d))) {
1271             /* Magnitude subtraction of infinities */
1272             farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1273         } else {
1274             ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1275             ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
1276             farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1277         }
1278 #else
1279         /* This is OK on x86 hosts */
1280         farg1.d = (farg1.d * farg2.d) + farg3.d;
1281 #endif
1282     }
1283 #else
1284     farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1285     farg1.d = float64_add(farg1.d, farg3.d, &env->fp_status);
1286 #endif
1287     return farg1.ll;
1288 }
1289
1290 /* fmsub - fmsub. */
1291 uint64_t helper_fmsub (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1292 {
1293     CPU_DoubleU farg1, farg2, farg3;
1294
1295     farg1.ll = arg1;
1296     farg2.ll = arg2;
1297     farg3.ll = arg3;
1298 #if USE_PRECISE_EMULATION
1299     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1300                  float64_is_signaling_nan(farg2.d) ||
1301                  float64_is_signaling_nan(farg3.d))) {
1302         /* sNaN operation */
1303         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1304     } else if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
1305                         (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
1306         /* Multiplication of zero by infinity */
1307         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1308     } else {
1309 #ifdef FLOAT128
1310         /* This is the way the PowerPC specification defines it */
1311         float128 ft0_128, ft1_128;
1312
1313         ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1314         ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1315         ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1316         if (unlikely(float128_is_infinity(ft0_128) && float64_is_infinity(farg3.d) &&
1317                      float128_is_neg(ft0_128) == float64_is_neg(farg3.d))) {
1318             /* Magnitude subtraction of infinities */
1319             farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1320         } else {
1321             ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1322             ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
1323             farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1324         }
1325 #else
1326         /* This is OK on x86 hosts */
1327         farg1.d = (farg1.d * farg2.d) - farg3.d;
1328 #endif
1329     }
1330 #else
1331     farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1332     farg1.d = float64_sub(farg1.d, farg3.d, &env->fp_status);
1333 #endif
1334     return farg1.ll;
1335 }
1336
1337 /* fnmadd - fnmadd. */
1338 uint64_t helper_fnmadd (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1339 {
1340     CPU_DoubleU farg1, farg2, farg3;
1341
1342     farg1.ll = arg1;
1343     farg2.ll = arg2;
1344     farg3.ll = arg3;
1345
1346     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1347                  float64_is_signaling_nan(farg2.d) ||
1348                  float64_is_signaling_nan(farg3.d))) {
1349         /* sNaN operation */
1350         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1351     } else if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
1352                         (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
1353         /* Multiplication of zero by infinity */
1354         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1355     } else {
1356 #if USE_PRECISE_EMULATION
1357 #ifdef FLOAT128
1358         /* This is the way the PowerPC specification defines it */
1359         float128 ft0_128, ft1_128;
1360
1361         ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1362         ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1363         ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1364         if (unlikely(float128_is_infinity(ft0_128) && float64_is_infinity(farg3.d) &&
1365                      float128_is_neg(ft0_128) != float64_is_neg(farg3.d))) {
1366             /* Magnitude subtraction of infinities */
1367             farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1368         } else {
1369             ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1370             ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
1371             farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1372         }
1373 #else
1374         /* This is OK on x86 hosts */
1375         farg1.d = (farg1.d * farg2.d) + farg3.d;
1376 #endif
1377 #else
1378         farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1379         farg1.d = float64_add(farg1.d, farg3.d, &env->fp_status);
1380 #endif
1381         if (likely(!float64_is_nan(farg1.d)))
1382             farg1.d = float64_chs(farg1.d);
1383     }
1384     return farg1.ll;
1385 }
1386
1387 /* fnmsub - fnmsub. */
1388 uint64_t helper_fnmsub (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1389 {
1390     CPU_DoubleU farg1, farg2, farg3;
1391
1392     farg1.ll = arg1;
1393     farg2.ll = arg2;
1394     farg3.ll = arg3;
1395
1396     if (unlikely(float64_is_signaling_nan(farg1.d) ||
1397                  float64_is_signaling_nan(farg2.d) ||
1398                  float64_is_signaling_nan(farg3.d))) {
1399         /* sNaN operation */
1400         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1401     } else if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
1402                         (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
1403         /* Multiplication of zero by infinity */
1404         farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1405     } else {
1406 #if USE_PRECISE_EMULATION
1407 #ifdef FLOAT128
1408         /* This is the way the PowerPC specification defines it */
1409         float128 ft0_128, ft1_128;
1410
1411         ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1412         ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1413         ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1414         if (unlikely(float128_is_infinity(ft0_128) && float64_is_infinity(farg3.d) &&
1415                      float128_is_neg(ft0_128) == float64_is_neg(farg3.d))) {
1416             /* Magnitude subtraction of infinities */
1417             farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1418         } else {
1419             ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1420             ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
1421             farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1422         }
1423 #else
1424         /* This is OK on x86 hosts */
1425         farg1.d = (farg1.d * farg2.d) - farg3.d;
1426 #endif
1427 #else
1428         farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1429         farg1.d = float64_sub(farg1.d, farg3.d, &env->fp_status);
1430 #endif
1431         if (likely(!float64_is_nan(farg1.d)))
1432             farg1.d = float64_chs(farg1.d);
1433     }
1434     return farg1.ll;
1435 }
1436
1437 /* frsp - frsp. */
1438 uint64_t helper_frsp (uint64_t arg)
1439 {
1440     CPU_DoubleU farg;
1441     float32 f32;
1442     farg.ll = arg;
1443
1444 #if USE_PRECISE_EMULATION
1445     if (unlikely(float64_is_signaling_nan(farg.d))) {
1446         /* sNaN square root */
1447        farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1448     } else {
1449        f32 = float64_to_float32(farg.d, &env->fp_status);
1450        farg.d = float32_to_float64(f32, &env->fp_status);
1451     }
1452 #else
1453     f32 = float64_to_float32(farg.d, &env->fp_status);
1454     farg.d = float32_to_float64(f32, &env->fp_status);
1455 #endif
1456     return farg.ll;
1457 }
1458
1459 /* fsqrt - fsqrt. */
1460 uint64_t helper_fsqrt (uint64_t arg)
1461 {
1462     CPU_DoubleU farg;
1463     farg.ll = arg;
1464
1465     if (unlikely(float64_is_signaling_nan(farg.d))) {
1466         /* sNaN square root */
1467         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1468     } else if (unlikely(float64_is_neg(farg.d) && !float64_is_zero(farg.d))) {
1469         /* Square root of a negative nonzero number */
1470         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSQRT);
1471     } else {
1472         farg.d = float64_sqrt(farg.d, &env->fp_status);
1473     }
1474     return farg.ll;
1475 }
1476
1477 /* fre - fre. */
1478 uint64_t helper_fre (uint64_t arg)
1479 {
1480     CPU_DoubleU farg;
1481     farg.ll = arg;
1482
1483     if (unlikely(float64_is_signaling_nan(farg.d))) {
1484         /* sNaN reciprocal */
1485         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1486     } else {
1487         farg.d = float64_div(float64_one, farg.d, &env->fp_status);
1488     }
1489     return farg.d;
1490 }
1491
1492 /* fres - fres. */
1493 uint64_t helper_fres (uint64_t arg)
1494 {
1495     CPU_DoubleU farg;
1496     float32 f32;
1497     farg.ll = arg;
1498
1499     if (unlikely(float64_is_signaling_nan(farg.d))) {
1500         /* sNaN reciprocal */
1501         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1502     } else {
1503         farg.d = float64_div(float64_one, farg.d, &env->fp_status);
1504         f32 = float64_to_float32(farg.d, &env->fp_status);
1505         farg.d = float32_to_float64(f32, &env->fp_status);
1506     }
1507     return farg.ll;
1508 }
1509
1510 /* frsqrte  - frsqrte. */
1511 uint64_t helper_frsqrte (uint64_t arg)
1512 {
1513     CPU_DoubleU farg;
1514     float32 f32;
1515     farg.ll = arg;
1516
1517     if (unlikely(float64_is_signaling_nan(farg.d))) {
1518         /* sNaN reciprocal square root */
1519         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1520     } else if (unlikely(float64_is_neg(farg.d) && !float64_is_zero(farg.d))) {
1521         /* Reciprocal square root of a negative nonzero number */
1522         farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSQRT);
1523     } else {
1524         farg.d = float64_sqrt(farg.d, &env->fp_status);
1525         farg.d = float64_div(float64_one, farg.d, &env->fp_status);
1526         f32 = float64_to_float32(farg.d, &env->fp_status);
1527         farg.d = float32_to_float64(f32, &env->fp_status);
1528     }
1529     return farg.ll;
1530 }
1531
1532 /* fsel - fsel. */
1533 uint64_t helper_fsel (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1534 {
1535     CPU_DoubleU farg1;
1536
1537     farg1.ll = arg1;
1538
1539     if ((!float64_is_neg(farg1.d) || float64_is_zero(farg1.d)) && !float64_is_nan(farg1.d))
1540         return arg2;
1541     else
1542         return arg3;
1543 }
1544
1545 void helper_fcmpu (uint64_t arg1, uint64_t arg2, uint32_t crfD)
1546 {
1547     CPU_DoubleU farg1, farg2;
1548     uint32_t ret = 0;
1549     farg1.ll = arg1;
1550     farg2.ll = arg2;
1551
1552     if (unlikely(float64_is_nan(farg1.d) ||
1553                  float64_is_nan(farg2.d))) {
1554         ret = 0x01UL;
1555     } else if (float64_lt(farg1.d, farg2.d, &env->fp_status)) {
1556         ret = 0x08UL;
1557     } else if (!float64_le(farg1.d, farg2.d, &env->fp_status)) {
1558         ret = 0x04UL;
1559     } else {
1560         ret = 0x02UL;
1561     }
1562
1563     env->fpscr &= ~(0x0F << FPSCR_FPRF);
1564     env->fpscr |= ret << FPSCR_FPRF;
1565     env->crf[crfD] = ret;
1566     if (unlikely(ret == 0x01UL
1567                  && (float64_is_signaling_nan(farg1.d) ||
1568                      float64_is_signaling_nan(farg2.d)))) {
1569         /* sNaN comparison */
1570         fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1571     }
1572 }
1573
1574 void helper_fcmpo (uint64_t arg1, uint64_t arg2, uint32_t crfD)
1575 {
1576     CPU_DoubleU farg1, farg2;
1577     uint32_t ret = 0;
1578     farg1.ll = arg1;
1579     farg2.ll = arg2;
1580
1581     if (unlikely(float64_is_nan(farg1.d) ||
1582                  float64_is_nan(farg2.d))) {
1583         ret = 0x01UL;
1584     } else if (float64_lt(farg1.d, farg2.d, &env->fp_status)) {
1585         ret = 0x08UL;
1586     } else if (!float64_le(farg1.d, farg2.d, &env->fp_status)) {
1587         ret = 0x04UL;
1588     } else {
1589         ret = 0x02UL;
1590     }
1591
1592     env->fpscr &= ~(0x0F << FPSCR_FPRF);
1593     env->fpscr |= ret << FPSCR_FPRF;
1594     env->crf[crfD] = ret;
1595     if (unlikely (ret == 0x01UL)) {
1596         if (float64_is_signaling_nan(farg1.d) ||
1597             float64_is_signaling_nan(farg2.d)) {
1598             /* sNaN comparison */
1599             fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN |
1600                                   POWERPC_EXCP_FP_VXVC);
1601         } else {
1602             /* qNaN comparison */
1603             fload_invalid_op_excp(POWERPC_EXCP_FP_VXVC);
1604         }
1605     }
1606 }
1607
1608 #if !defined (CONFIG_USER_ONLY)
1609 void helper_store_msr (target_ulong val)
1610 {
1611     val = hreg_store_msr(env, val, 0);
1612     if (val != 0) {
1613         env->interrupt_request |= CPU_INTERRUPT_EXITTB;
1614         helper_raise_exception(val);
1615     }
1616 }
1617
1618 static always_inline void do_rfi (target_ulong nip, target_ulong msr,
1619                                     target_ulong msrm, int keep_msrh)
1620 {
1621 #if defined(TARGET_PPC64)
1622     if (msr & (1ULL << MSR_SF)) {
1623         nip = (uint64_t)nip;
1624         msr &= (uint64_t)msrm;
1625     } else {
1626         nip = (uint32_t)nip;
1627         msr = (uint32_t)(msr & msrm);
1628         if (keep_msrh)
1629             msr |= env->msr & ~((uint64_t)0xFFFFFFFF);
1630     }
1631 #else
1632     nip = (uint32_t)nip;
1633     msr &= (uint32_t)msrm;
1634 #endif
1635     /* XXX: beware: this is false if VLE is supported */
1636     env->nip = nip & ~((target_ulong)0x00000003);
1637     hreg_store_msr(env, msr, 1);
1638 #if defined (DEBUG_OP)
1639     cpu_dump_rfi(env->nip, env->msr);
1640 #endif
1641     /* No need to raise an exception here,
1642      * as rfi is always the last insn of a TB
1643      */
1644     env->interrupt_request |= CPU_INTERRUPT_EXITTB;
1645 }
1646
1647 void helper_rfi (void)
1648 {
1649     do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1],
1650            ~((target_ulong)0x0), 1);
1651 }
1652
1653 #if defined(TARGET_PPC64)
1654 void helper_rfid (void)
1655 {
1656     do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1],
1657            ~((target_ulong)0x0), 0);
1658 }
1659
1660 void helper_hrfid (void)
1661 {
1662     do_rfi(env->spr[SPR_HSRR0], env->spr[SPR_HSRR1],
1663            ~((target_ulong)0x0), 0);
1664 }
1665 #endif
1666 #endif
1667
1668 void helper_tw (target_ulong arg1, target_ulong arg2, uint32_t flags)
1669 {
1670     if (!likely(!(((int32_t)arg1 < (int32_t)arg2 && (flags & 0x10)) ||
1671                   ((int32_t)arg1 > (int32_t)arg2 && (flags & 0x08)) ||
1672                   ((int32_t)arg1 == (int32_t)arg2 && (flags & 0x04)) ||
1673                   ((uint32_t)arg1 < (uint32_t)arg2 && (flags & 0x02)) ||
1674                   ((uint32_t)arg1 > (uint32_t)arg2 && (flags & 0x01))))) {
1675         helper_raise_exception_err(POWERPC_EXCP_PROGRAM, POWERPC_EXCP_TRAP);
1676     }
1677 }
1678
1679 #if defined(TARGET_PPC64)
1680 void helper_td (target_ulong arg1, target_ulong arg2, uint32_t flags)
1681 {
1682     if (!likely(!(((int64_t)arg1 < (int64_t)arg2 && (flags & 0x10)) ||
1683                   ((int64_t)arg1 > (int64_t)arg2 && (flags & 0x08)) ||
1684                   ((int64_t)arg1 == (int64_t)arg2 && (flags & 0x04)) ||
1685                   ((uint64_t)arg1 < (uint64_t)arg2 && (flags & 0x02)) ||
1686                   ((uint64_t)arg1 > (uint64_t)arg2 && (flags & 0x01)))))
1687         helper_raise_exception_err(POWERPC_EXCP_PROGRAM, POWERPC_EXCP_TRAP);
1688 }
1689 #endif
1690
1691 /*****************************************************************************/
1692 /* PowerPC 601 specific instructions (POWER bridge) */
1693
1694 target_ulong helper_clcs (uint32_t arg)
1695 {
1696     switch (arg) {
1697     case 0x0CUL:
1698         /* Instruction cache line size */
1699         return env->icache_line_size;
1700         break;
1701     case 0x0DUL:
1702         /* Data cache line size */
1703         return env->dcache_line_size;
1704         break;
1705     case 0x0EUL:
1706         /* Minimum cache line size */
1707         return (env->icache_line_size < env->dcache_line_size) ?
1708                 env->icache_line_size : env->dcache_line_size;
1709         break;
1710     case 0x0FUL:
1711         /* Maximum cache line size */
1712         return (env->icache_line_size > env->dcache_line_size) ?
1713                 env->icache_line_size : env->dcache_line_size;
1714         break;
1715     default:
1716         /* Undefined */
1717         return 0;
1718         break;
1719     }
1720 }
1721
1722 target_ulong helper_div (target_ulong arg1, target_ulong arg2)
1723 {
1724     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
1725
1726     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
1727         (int32_t)arg2 == 0) {
1728         env->spr[SPR_MQ] = 0;
1729         return INT32_MIN;
1730     } else {
1731         env->spr[SPR_MQ] = tmp % arg2;
1732         return  tmp / (int32_t)arg2;
1733     }
1734 }
1735
1736 target_ulong helper_divo (target_ulong arg1, target_ulong arg2)
1737 {
1738     uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
1739
1740     if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
1741         (int32_t)arg2 == 0) {
1742         env->xer |= (1 << XER_OV) | (1 << XER_SO);
1743         env->spr[SPR_MQ] = 0;
1744         return INT32_MIN;
1745     } else {
1746         env->spr[SPR_MQ] = tmp % arg2;
1747         tmp /= (int32_t)arg2;
1748         if ((int32_t)tmp != tmp) {
1749             env->xer |= (1 << XER_OV) | (1 << XER_SO);
1750         } else {
1751             env->xer &= ~(1 << XER_OV);
1752         }
1753         return tmp;
1754     }
1755 }
1756
1757 target_ulong helper_divs (target_ulong arg1, target_ulong arg2)
1758 {
1759     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
1760         (int32_t)arg2 == 0) {
1761         env->spr[SPR_MQ] = 0;
1762         return INT32_MIN;
1763     } else {
1764         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
1765         return (int32_t)arg1 / (int32_t)arg2;
1766     }
1767 }
1768
1769 target_ulong helper_divso (target_ulong arg1, target_ulong arg2)
1770 {
1771     if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
1772         (int32_t)arg2 == 0) {
1773         env->xer |= (1 << XER_OV) | (1 << XER_SO);
1774         env->spr[SPR_MQ] = 0;
1775         return INT32_MIN;
1776     } else {
1777         env->xer &= ~(1 << XER_OV);
1778         env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
1779         return (int32_t)arg1 / (int32_t)arg2;
1780     }
1781 }
1782
1783 #if !defined (CONFIG_USER_ONLY)
1784 target_ulong helper_rac (target_ulong addr)
1785 {
1786     mmu_ctx_t ctx;
1787     int nb_BATs;
1788     target_ulong ret = 0;
1789
1790     /* We don't have to generate many instances of this instruction,
1791      * as rac is supervisor only.
1792      */
1793     /* XXX: FIX THIS: Pretend we have no BAT */
1794     nb_BATs = env->nb_BATs;
1795     env->nb_BATs = 0;
1796     if (get_physical_address(env, &ctx, addr, 0, ACCESS_INT) == 0)
1797         ret = ctx.raddr;
1798     env->nb_BATs = nb_BATs;
1799     return ret;
1800 }
1801
1802 void helper_rfsvc (void)
1803 {
1804     do_rfi(env->lr, env->ctr, 0x0000FFFF, 0);
1805 }
1806 #endif
1807
1808 /*****************************************************************************/
1809 /* 602 specific instructions */
1810 /* mfrom is the most crazy instruction ever seen, imho ! */
1811 /* Real implementation uses a ROM table. Do the same */
1812 /* Extremly decomposed:
1813  *                      -arg / 256
1814  * return 256 * log10(10           + 1.0) + 0.5
1815  */
1816 #if !defined (CONFIG_USER_ONLY)
1817 target_ulong helper_602_mfrom (target_ulong arg)
1818 {
1819     if (likely(arg < 602)) {
1820 #include "mfrom_table.c"
1821         return mfrom_ROM_table[arg];
1822     } else {
1823         return 0;
1824     }
1825 }
1826 #endif
1827
1828 /*****************************************************************************/
1829 /* Embedded PowerPC specific helpers */
1830
1831 /* XXX: to be improved to check access rights when in user-mode */
1832 target_ulong helper_load_dcr (target_ulong dcrn)
1833 {
1834     target_ulong val = 0;
1835
1836     if (unlikely(env->dcr_env == NULL)) {
1837         qemu_log("No DCR environment\n");
1838         helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
1839                                    POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL);
1840     } else if (unlikely(ppc_dcr_read(env->dcr_env, dcrn, &val) != 0)) {
1841         qemu_log("DCR read error %d %03x\n", (int)dcrn, (int)dcrn);
1842         helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
1843                                    POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
1844     }
1845     return val;
1846 }
1847
1848 void helper_store_dcr (target_ulong dcrn, target_ulong val)
1849 {
1850     if (unlikely(env->dcr_env == NULL)) {
1851         qemu_log("No DCR environment\n");
1852         helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
1853                                    POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL);
1854     } else if (unlikely(ppc_dcr_write(env->dcr_env, dcrn, val) != 0)) {
1855         qemu_log("DCR write error %d %03x\n", (int)dcrn, (int)dcrn);
1856         helper_raise_exception_err(POWERPC_EXCP_PROGRAM,
1857                                    POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
1858     }
1859 }
1860
1861 #if !defined(CONFIG_USER_ONLY)
1862 void helper_40x_rfci (void)
1863 {
1864     do_rfi(env->spr[SPR_40x_SRR2], env->spr[SPR_40x_SRR3],
1865            ~((target_ulong)0xFFFF0000), 0);
1866 }
1867
1868 void helper_rfci (void)
1869 {
1870     do_rfi(env->spr[SPR_BOOKE_CSRR0], SPR_BOOKE_CSRR1,
1871            ~((target_ulong)0x3FFF0000), 0);
1872 }
1873
1874 void helper_rfdi (void)
1875 {
1876     do_rfi(env->spr[SPR_BOOKE_DSRR0], SPR_BOOKE_DSRR1,
1877            ~((target_ulong)0x3FFF0000), 0);
1878 }
1879
1880 void helper_rfmci (void)
1881 {
1882     do_rfi(env->spr[SPR_BOOKE_MCSRR0], SPR_BOOKE_MCSRR1,
1883            ~((target_ulong)0x3FFF0000), 0);
1884 }
1885 #endif
1886
1887 /* 440 specific */
1888 target_ulong helper_dlmzb (target_ulong high, target_ulong low, uint32_t update_Rc)
1889 {
1890     target_ulong mask;
1891     int i;
1892
1893     i = 1;
1894     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
1895         if ((high & mask) == 0) {
1896             if (update_Rc) {
1897                 env->crf[0] = 0x4;
1898             }
1899             goto done;
1900         }
1901         i++;
1902     }
1903     for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
1904         if ((low & mask) == 0) {
1905             if (update_Rc) {
1906                 env->crf[0] = 0x8;
1907             }
1908             goto done;
1909         }
1910         i++;
1911     }
1912     if (update_Rc) {
1913         env->crf[0] = 0x2;
1914     }
1915  done:
1916     env->xer = (env->xer & ~0x7F) | i;
1917     if (update_Rc) {
1918         env->crf[0] |= xer_so;
1919     }
1920     return i;
1921 }
1922
1923 /*****************************************************************************/
1924 /* Altivec extension helpers */
1925 #if defined(WORDS_BIGENDIAN)
1926 #define HI_IDX 0
1927 #define LO_IDX 1
1928 #else
1929 #define HI_IDX 1
1930 #define LO_IDX 0
1931 #endif
1932
1933 #if defined(WORDS_BIGENDIAN)
1934 #define VECTOR_FOR_INORDER_I(index, element)            \
1935     for (index = 0; index < ARRAY_SIZE(r->element); index++)
1936 #else
1937 #define VECTOR_FOR_INORDER_I(index, element)            \
1938   for (index = ARRAY_SIZE(r->element)-1; index >= 0; index--)
1939 #endif
1940
1941 /* If X is a NaN, store the corresponding QNaN into RESULT.  Otherwise,
1942  * execute the following block.  */
1943 #define DO_HANDLE_NAN(result, x)                \
1944     if (float32_is_nan(x) || float32_is_signaling_nan(x)) {     \
1945         CPU_FloatU __f;                                         \
1946         __f.f = x;                                              \
1947         __f.l = __f.l | (1 << 22);  /* Set QNaN bit. */         \
1948         result = __f.f;                                         \
1949     } else
1950
1951 #define HANDLE_NAN1(result, x)                  \
1952     DO_HANDLE_NAN(result, x)
1953 #define HANDLE_NAN2(result, x, y)               \
1954     DO_HANDLE_NAN(result, x) DO_HANDLE_NAN(result, y)
1955 #define HANDLE_NAN3(result, x, y, z)            \
1956     DO_HANDLE_NAN(result, x) DO_HANDLE_NAN(result, y) DO_HANDLE_NAN(result, z)
1957
1958 /* Saturating arithmetic helpers.  */
1959 #define SATCVT(from, to, from_type, to_type, min, max, use_min, use_max) \
1960     static always_inline to_type cvt##from##to (from_type x, int *sat)  \
1961     {                                                                   \
1962         to_type r;                                                      \
1963         if (use_min && x < min) {                                       \
1964             r = min;                                                    \
1965             *sat = 1;                                                   \
1966         } else if (use_max && x > max) {                                \
1967             r = max;                                                    \
1968             *sat = 1;                                                   \
1969         } else {                                                        \
1970             r = x;                                                      \
1971         }                                                               \
1972         return r;                                                       \
1973     }
1974 SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX, 1, 1)
1975 SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX, 1, 1)
1976 SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX, 1, 1)
1977 SATCVT(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX, 0, 1)
1978 SATCVT(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX, 0, 1)
1979 SATCVT(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX, 0, 1)
1980 SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX, 1, 1)
1981 SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX, 1, 1)
1982 SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX, 1, 1)
1983 #undef SATCVT
1984
1985 #define LVE(name, access, swap, element)                        \
1986     void helper_##name (ppc_avr_t *r, target_ulong addr)        \
1987     {                                                           \
1988         size_t n_elems = ARRAY_SIZE(r->element);                \
1989         int adjust = HI_IDX*(n_elems-1);                        \
1990         int sh = sizeof(r->element[0]) >> 1;                    \
1991         int index = (addr & 0xf) >> sh;                         \
1992         if(msr_le) {                                            \
1993             r->element[LO_IDX ? index : (adjust - index)] = swap(access(addr)); \
1994         } else {                                                        \
1995             r->element[LO_IDX ? index : (adjust - index)] = access(addr); \
1996         }                                                               \
1997     }
1998 #define I(x) (x)
1999 LVE(lvebx, ldub, I, u8)
2000 LVE(lvehx, lduw, bswap16, u16)
2001 LVE(lvewx, ldl, bswap32, u32)
2002 #undef I
2003 #undef LVE
2004
2005 void helper_lvsl (ppc_avr_t *r, target_ulong sh)
2006 {
2007     int i, j = (sh & 0xf);
2008
2009     VECTOR_FOR_INORDER_I (i, u8) {
2010         r->u8[i] = j++;
2011     }
2012 }
2013
2014 void helper_lvsr (ppc_avr_t *r, target_ulong sh)
2015 {
2016     int i, j = 0x10 - (sh & 0xf);
2017
2018     VECTOR_FOR_INORDER_I (i, u8) {
2019         r->u8[i] = j++;
2020     }
2021 }
2022
2023 #define STVE(name, access, swap, element)                       \
2024     void helper_##name (ppc_avr_t *r, target_ulong addr)        \
2025     {                                                           \
2026         size_t n_elems = ARRAY_SIZE(r->element);                \
2027         int adjust = HI_IDX*(n_elems-1);                        \
2028         int sh = sizeof(r->element[0]) >> 1;                    \
2029         int index = (addr & 0xf) >> sh;                         \
2030         if(msr_le) {                                            \
2031             access(addr, swap(r->element[LO_IDX ? index : (adjust - index)])); \
2032         } else {                                                        \
2033             access(addr, r->element[LO_IDX ? index : (adjust - index)]); \
2034         }                                                               \
2035     }
2036 #define I(x) (x)
2037 STVE(stvebx, stb, I, u8)
2038 STVE(stvehx, stw, bswap16, u16)
2039 STVE(stvewx, stl, bswap32, u32)
2040 #undef I
2041 #undef LVE
2042
2043 void helper_mtvscr (ppc_avr_t *r)
2044 {
2045 #if defined(WORDS_BIGENDIAN)
2046     env->vscr = r->u32[3];
2047 #else
2048     env->vscr = r->u32[0];
2049 #endif
2050     set_flush_to_zero(vscr_nj, &env->vec_status);
2051 }
2052
2053 void helper_vaddcuw (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2054 {
2055     int i;
2056     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
2057         r->u32[i] = ~a->u32[i] < b->u32[i];
2058     }
2059 }
2060
2061 #define VARITH_DO(name, op, element)        \
2062 void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)          \
2063 {                                                                       \
2064     int i;                                                              \
2065     for (i = 0; i < ARRAY_SIZE(r->element); i++) {                      \
2066         r->element[i] = a->element[i] op b->element[i];                 \
2067     }                                                                   \
2068 }
2069 #define VARITH(suffix, element)                  \
2070   VARITH_DO(add##suffix, +, element)             \
2071   VARITH_DO(sub##suffix, -, element)
2072 VARITH(ubm, u8)
2073 VARITH(uhm, u16)
2074 VARITH(uwm, u32)
2075 #undef VARITH_DO
2076 #undef VARITH
2077
2078 #define VARITHFP(suffix, func)                                          \
2079     void helper_v##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)    \
2080     {                                                                   \
2081         int i;                                                          \
2082         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2083             HANDLE_NAN2(r->f[i], a->f[i], b->f[i]) {                    \
2084                 r->f[i] = func(a->f[i], b->f[i], &env->vec_status);     \
2085             }                                                           \
2086         }                                                               \
2087     }
2088 VARITHFP(addfp, float32_add)
2089 VARITHFP(subfp, float32_sub)
2090 #undef VARITHFP
2091
2092 #define VARITHSAT_CASE(type, op, cvt, element)                          \
2093     {                                                                   \
2094         type result = (type)a->element[i] op (type)b->element[i];       \
2095         r->element[i] = cvt(result, &sat);                              \
2096     }
2097
2098 #define VARITHSAT_DO(name, op, optype, cvt, element)                    \
2099     void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)      \
2100     {                                                                   \
2101         int sat = 0;                                                    \
2102         int i;                                                          \
2103         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2104             switch (sizeof(r->element[0])) {                            \
2105             case 1: VARITHSAT_CASE(optype, op, cvt, element); break;    \
2106             case 2: VARITHSAT_CASE(optype, op, cvt, element); break;    \
2107             case 4: VARITHSAT_CASE(optype, op, cvt, element); break;    \
2108             }                                                           \
2109         }                                                               \
2110         if (sat) {                                                      \
2111             env->vscr |= (1 << VSCR_SAT);                               \
2112         }                                                               \
2113     }
2114 #define VARITHSAT_SIGNED(suffix, element, optype, cvt)        \
2115     VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element)    \
2116     VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element)
2117 #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt)       \
2118     VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element)     \
2119     VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element)
2120 VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb)
2121 VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh)
2122 VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw)
2123 VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub)
2124 VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh)
2125 VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw)
2126 #undef VARITHSAT_CASE
2127 #undef VARITHSAT_DO
2128 #undef VARITHSAT_SIGNED
2129 #undef VARITHSAT_UNSIGNED
2130
2131 #define VAVG_DO(name, element, etype)                                   \
2132     void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)      \
2133     {                                                                   \
2134         int i;                                                          \
2135         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2136             etype x = (etype)a->element[i] + (etype)b->element[i] + 1;  \
2137             r->element[i] = x >> 1;                                     \
2138         }                                                               \
2139     }
2140
2141 #define VAVG(type, signed_element, signed_type, unsigned_element, unsigned_type) \
2142     VAVG_DO(avgs##type, signed_element, signed_type)                    \
2143     VAVG_DO(avgu##type, unsigned_element, unsigned_type)
2144 VAVG(b, s8, int16_t, u8, uint16_t)
2145 VAVG(h, s16, int32_t, u16, uint32_t)
2146 VAVG(w, s32, int64_t, u32, uint64_t)
2147 #undef VAVG_DO
2148 #undef VAVG
2149
2150 #define VCF(suffix, cvt, element)                                       \
2151     void helper_vcf##suffix (ppc_avr_t *r, ppc_avr_t *b, uint32_t uim)  \
2152     {                                                                   \
2153         int i;                                                          \
2154         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2155             float32 t = cvt(b->element[i], &env->vec_status);           \
2156             r->f[i] = float32_scalbn (t, -uim, &env->vec_status);       \
2157         }                                                               \
2158     }
2159 VCF(ux, uint32_to_float32, u32)
2160 VCF(sx, int32_to_float32, s32)
2161 #undef VCF
2162
2163 #define VCMP_DO(suffix, compare, element, record)                       \
2164     void helper_vcmp##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
2165     {                                                                   \
2166         uint32_t ones = (uint32_t)-1;                                   \
2167         uint32_t all = ones;                                            \
2168         uint32_t none = 0;                                              \
2169         int i;                                                          \
2170         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2171             uint32_t result = (a->element[i] compare b->element[i] ? ones : 0x0); \
2172             switch (sizeof (a->element[0])) {                           \
2173             case 4: r->u32[i] = result; break;                          \
2174             case 2: r->u16[i] = result; break;                          \
2175             case 1: r->u8[i] = result; break;                           \
2176             }                                                           \
2177             all &= result;                                              \
2178             none |= result;                                             \
2179         }                                                               \
2180         if (record) {                                                   \
2181             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
2182         }                                                               \
2183     }
2184 #define VCMP(suffix, compare, element)          \
2185     VCMP_DO(suffix, compare, element, 0)        \
2186     VCMP_DO(suffix##_dot, compare, element, 1)
2187 VCMP(equb, ==, u8)
2188 VCMP(equh, ==, u16)
2189 VCMP(equw, ==, u32)
2190 VCMP(gtub, >, u8)
2191 VCMP(gtuh, >, u16)
2192 VCMP(gtuw, >, u32)
2193 VCMP(gtsb, >, s8)
2194 VCMP(gtsh, >, s16)
2195 VCMP(gtsw, >, s32)
2196 #undef VCMP_DO
2197 #undef VCMP
2198
2199 #define VCMPFP_DO(suffix, compare, order, record)                       \
2200     void helper_vcmp##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
2201     {                                                                   \
2202         uint32_t ones = (uint32_t)-1;                                   \
2203         uint32_t all = ones;                                            \
2204         uint32_t none = 0;                                              \
2205         int i;                                                          \
2206         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2207             uint32_t result;                                            \
2208             int rel = float32_compare_quiet(a->f[i], b->f[i], &env->vec_status); \
2209             if (rel == float_relation_unordered) {                      \
2210                 result = 0;                                             \
2211             } else if (rel compare order) {                             \
2212                 result = ones;                                          \
2213             } else {                                                    \
2214                 result = 0;                                             \
2215             }                                                           \
2216             r->u32[i] = result;                                         \
2217             all &= result;                                              \
2218             none |= result;                                             \
2219         }                                                               \
2220         if (record) {                                                   \
2221             env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1);       \
2222         }                                                               \
2223     }
2224 #define VCMPFP(suffix, compare, order)           \
2225     VCMPFP_DO(suffix, compare, order, 0)         \
2226     VCMPFP_DO(suffix##_dot, compare, order, 1)
2227 VCMPFP(eqfp, ==, float_relation_equal)
2228 VCMPFP(gefp, !=, float_relation_less)
2229 VCMPFP(gtfp, ==, float_relation_greater)
2230 #undef VCMPFP_DO
2231 #undef VCMPFP
2232
2233 static always_inline void vcmpbfp_internal (ppc_avr_t *r, ppc_avr_t *a,
2234                                             ppc_avr_t *b, int record)
2235 {
2236     int i;
2237     int all_in = 0;
2238     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2239         int le_rel = float32_compare_quiet(a->f[i], b->f[i], &env->vec_status);
2240         if (le_rel == float_relation_unordered) {
2241             r->u32[i] = 0xc0000000;
2242             /* ALL_IN does not need to be updated here.  */
2243         } else {
2244             float32 bneg = float32_chs(b->f[i]);
2245             int ge_rel = float32_compare_quiet(a->f[i], bneg, &env->vec_status);
2246             int le = le_rel != float_relation_greater;
2247             int ge = ge_rel != float_relation_less;
2248             r->u32[i] = ((!le) << 31) | ((!ge) << 30);
2249             all_in |= (!le | !ge);
2250         }
2251     }
2252     if (record) {
2253         env->crf[6] = (all_in == 0) << 1;
2254     }
2255 }
2256
2257 void helper_vcmpbfp (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2258 {
2259     vcmpbfp_internal(r, a, b, 0);
2260 }
2261
2262 void helper_vcmpbfp_dot (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2263 {
2264     vcmpbfp_internal(r, a, b, 1);
2265 }
2266
2267 #define VCT(suffix, satcvt, element)                                    \
2268     void helper_vct##suffix (ppc_avr_t *r, ppc_avr_t *b, uint32_t uim)  \
2269     {                                                                   \
2270         int i;                                                          \
2271         int sat = 0;                                                    \
2272         float_status s = env->vec_status;                               \
2273         set_float_rounding_mode(float_round_to_zero, &s);               \
2274         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2275             if (float32_is_nan(b->f[i]) ||                              \
2276                 float32_is_signaling_nan(b->f[i])) {                    \
2277                 r->element[i] = 0;                                      \
2278             } else {                                                    \
2279                 float64 t = float32_to_float64(b->f[i], &s);            \
2280                 int64_t j;                                              \
2281                 t = float64_scalbn(t, uim, &s);                         \
2282                 j = float64_to_int64(t, &s);                            \
2283                 r->element[i] = satcvt(j, &sat);                        \
2284             }                                                           \
2285         }                                                               \
2286         if (sat) {                                                      \
2287             env->vscr |= (1 << VSCR_SAT);                               \
2288         }                                                               \
2289     }
2290 VCT(uxs, cvtsduw, u32)
2291 VCT(sxs, cvtsdsw, s32)
2292 #undef VCT
2293
2294 void helper_vmaddfp (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2295 {
2296     int i;
2297     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2298         HANDLE_NAN3(r->f[i], a->f[i], b->f[i], c->f[i]) {
2299             /* Need to do the computation in higher precision and round
2300              * once at the end.  */
2301             float64 af, bf, cf, t;
2302             af = float32_to_float64(a->f[i], &env->vec_status);
2303             bf = float32_to_float64(b->f[i], &env->vec_status);
2304             cf = float32_to_float64(c->f[i], &env->vec_status);
2305             t = float64_mul(af, cf, &env->vec_status);
2306             t = float64_add(t, bf, &env->vec_status);
2307             r->f[i] = float64_to_float32(t, &env->vec_status);
2308         }
2309     }
2310 }
2311
2312 void helper_vmhaddshs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2313 {
2314     int sat = 0;
2315     int i;
2316
2317     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
2318         int32_t prod = a->s16[i] * b->s16[i];
2319         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
2320         r->s16[i] = cvtswsh (t, &sat);
2321     }
2322
2323     if (sat) {
2324         env->vscr |= (1 << VSCR_SAT);
2325     }
2326 }
2327
2328 void helper_vmhraddshs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2329 {
2330     int sat = 0;
2331     int i;
2332
2333     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
2334         int32_t prod = a->s16[i] * b->s16[i] + 0x00004000;
2335         int32_t t = (int32_t)c->s16[i] + (prod >> 15);
2336         r->s16[i] = cvtswsh (t, &sat);
2337     }
2338
2339     if (sat) {
2340         env->vscr |= (1 << VSCR_SAT);
2341     }
2342 }
2343
2344 #define VMINMAX_DO(name, compare, element)                              \
2345     void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)      \
2346     {                                                                   \
2347         int i;                                                          \
2348         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2349             if (a->element[i] compare b->element[i]) {                  \
2350                 r->element[i] = b->element[i];                          \
2351             } else {                                                    \
2352                 r->element[i] = a->element[i];                          \
2353             }                                                           \
2354         }                                                               \
2355     }
2356 #define VMINMAX(suffix, element)                \
2357   VMINMAX_DO(min##suffix, >, element)           \
2358   VMINMAX_DO(max##suffix, <, element)
2359 VMINMAX(sb, s8)
2360 VMINMAX(sh, s16)
2361 VMINMAX(sw, s32)
2362 VMINMAX(ub, u8)
2363 VMINMAX(uh, u16)
2364 VMINMAX(uw, u32)
2365 #undef VMINMAX_DO
2366 #undef VMINMAX
2367
2368 #define VMINMAXFP(suffix, rT, rF)                                       \
2369     void helper_v##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)    \
2370     {                                                                   \
2371         int i;                                                          \
2372         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2373             HANDLE_NAN2(r->f[i], a->f[i], b->f[i]) {                    \
2374                 if (float32_lt_quiet(a->f[i], b->f[i], &env->vec_status)) { \
2375                     r->f[i] = rT->f[i];                                 \
2376                 } else {                                                \
2377                     r->f[i] = rF->f[i];                                 \
2378                 }                                                       \
2379             }                                                           \
2380         }                                                               \
2381     }
2382 VMINMAXFP(minfp, a, b)
2383 VMINMAXFP(maxfp, b, a)
2384 #undef VMINMAXFP
2385
2386 void helper_vmladduhm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2387 {
2388     int i;
2389     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
2390         int32_t prod = a->s16[i] * b->s16[i];
2391         r->s16[i] = (int16_t) (prod + c->s16[i]);
2392     }
2393 }
2394
2395 #define VMRG_DO(name, element, highp)                                   \
2396     void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)      \
2397     {                                                                   \
2398         ppc_avr_t result;                                               \
2399         int i;                                                          \
2400         size_t n_elems = ARRAY_SIZE(r->element);                        \
2401         for (i = 0; i < n_elems/2; i++) {                               \
2402             if (highp) {                                                \
2403                 result.element[i*2+HI_IDX] = a->element[i];             \
2404                 result.element[i*2+LO_IDX] = b->element[i];             \
2405             } else {                                                    \
2406                 result.element[n_elems - i*2 - (1+HI_IDX)] = b->element[n_elems - i - 1]; \
2407                 result.element[n_elems - i*2 - (1+LO_IDX)] = a->element[n_elems - i - 1]; \
2408             }                                                           \
2409         }                                                               \
2410         *r = result;                                                    \
2411     }
2412 #if defined(WORDS_BIGENDIAN)
2413 #define MRGHI 0
2414 #define MRGLO 1
2415 #else
2416 #define MRGHI 1
2417 #define MRGLO 0
2418 #endif
2419 #define VMRG(suffix, element)                   \
2420   VMRG_DO(mrgl##suffix, element, MRGHI)         \
2421   VMRG_DO(mrgh##suffix, element, MRGLO)
2422 VMRG(b, u8)
2423 VMRG(h, u16)
2424 VMRG(w, u32)
2425 #undef VMRG_DO
2426 #undef VMRG
2427 #undef MRGHI
2428 #undef MRGLO
2429
2430 void helper_vmsummbm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2431 {
2432     int32_t prod[16];
2433     int i;
2434
2435     for (i = 0; i < ARRAY_SIZE(r->s8); i++) {
2436         prod[i] = (int32_t)a->s8[i] * b->u8[i];
2437     }
2438
2439     VECTOR_FOR_INORDER_I(i, s32) {
2440         r->s32[i] = c->s32[i] + prod[4*i] + prod[4*i+1] + prod[4*i+2] + prod[4*i+3];
2441     }
2442 }
2443
2444 void helper_vmsumshm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2445 {
2446     int32_t prod[8];
2447     int i;
2448
2449     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
2450         prod[i] = a->s16[i] * b->s16[i];
2451     }
2452
2453     VECTOR_FOR_INORDER_I(i, s32) {
2454         r->s32[i] = c->s32[i] + prod[2*i] + prod[2*i+1];
2455     }
2456 }
2457
2458 void helper_vmsumshs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2459 {
2460     int32_t prod[8];
2461     int i;
2462     int sat = 0;
2463
2464     for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
2465         prod[i] = (int32_t)a->s16[i] * b->s16[i];
2466     }
2467
2468     VECTOR_FOR_INORDER_I (i, s32) {
2469         int64_t t = (int64_t)c->s32[i] + prod[2*i] + prod[2*i+1];
2470         r->u32[i] = cvtsdsw(t, &sat);
2471     }
2472
2473     if (sat) {
2474         env->vscr |= (1 << VSCR_SAT);
2475     }
2476 }
2477
2478 void helper_vmsumubm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2479 {
2480     uint16_t prod[16];
2481     int i;
2482
2483     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
2484         prod[i] = a->u8[i] * b->u8[i];
2485     }
2486
2487     VECTOR_FOR_INORDER_I(i, u32) {
2488         r->u32[i] = c->u32[i] + prod[4*i] + prod[4*i+1] + prod[4*i+2] + prod[4*i+3];
2489     }
2490 }
2491
2492 void helper_vmsumuhm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2493 {
2494     uint32_t prod[8];
2495     int i;
2496
2497     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
2498         prod[i] = a->u16[i] * b->u16[i];
2499     }
2500
2501     VECTOR_FOR_INORDER_I(i, u32) {
2502         r->u32[i] = c->u32[i] + prod[2*i] + prod[2*i+1];
2503     }
2504 }
2505
2506 void helper_vmsumuhs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2507 {
2508     uint32_t prod[8];
2509     int i;
2510     int sat = 0;
2511
2512     for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
2513         prod[i] = a->u16[i] * b->u16[i];
2514     }
2515
2516     VECTOR_FOR_INORDER_I (i, s32) {
2517         uint64_t t = (uint64_t)c->u32[i] + prod[2*i] + prod[2*i+1];
2518         r->u32[i] = cvtuduw(t, &sat);
2519     }
2520
2521     if (sat) {
2522         env->vscr |= (1 << VSCR_SAT);
2523     }
2524 }
2525
2526 #define VMUL_DO(name, mul_element, prod_element, evenp)                 \
2527     void helper_v##name (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)      \
2528     {                                                                   \
2529         int i;                                                          \
2530         VECTOR_FOR_INORDER_I(i, prod_element) {                         \
2531             if (evenp) {                                                \
2532                 r->prod_element[i] = a->mul_element[i*2+HI_IDX] * b->mul_element[i*2+HI_IDX]; \
2533             } else {                                                    \
2534                 r->prod_element[i] = a->mul_element[i*2+LO_IDX] * b->mul_element[i*2+LO_IDX]; \
2535             }                                                           \
2536         }                                                               \
2537     }
2538 #define VMUL(suffix, mul_element, prod_element) \
2539   VMUL_DO(mule##suffix, mul_element, prod_element, 1) \
2540   VMUL_DO(mulo##suffix, mul_element, prod_element, 0)
2541 VMUL(sb, s8, s16)
2542 VMUL(sh, s16, s32)
2543 VMUL(ub, u8, u16)
2544 VMUL(uh, u16, u32)
2545 #undef VMUL_DO
2546 #undef VMUL
2547
2548 void helper_vnmsubfp (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2549 {
2550     int i;
2551     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2552         HANDLE_NAN3(r->f[i], a->f[i], b->f[i], c->f[i]) {
2553             /* Need to do the computation is higher precision and round
2554              * once at the end.  */
2555             float64 af, bf, cf, t;
2556             af = float32_to_float64(a->f[i], &env->vec_status);
2557             bf = float32_to_float64(b->f[i], &env->vec_status);
2558             cf = float32_to_float64(c->f[i], &env->vec_status);
2559             t = float64_mul(af, cf, &env->vec_status);
2560             t = float64_sub(t, bf, &env->vec_status);
2561             t = float64_chs(t);
2562             r->f[i] = float64_to_float32(t, &env->vec_status);
2563         }
2564     }
2565 }
2566
2567 void helper_vperm (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2568 {
2569     ppc_avr_t result;
2570     int i;
2571     VECTOR_FOR_INORDER_I (i, u8) {
2572         int s = c->u8[i] & 0x1f;
2573 #if defined(WORDS_BIGENDIAN)
2574         int index = s & 0xf;
2575 #else
2576         int index = 15 - (s & 0xf);
2577 #endif
2578         if (s & 0x10) {
2579             result.u8[i] = b->u8[index];
2580         } else {
2581             result.u8[i] = a->u8[index];
2582         }
2583     }
2584     *r = result;
2585 }
2586
2587 #if defined(WORDS_BIGENDIAN)
2588 #define PKBIG 1
2589 #else
2590 #define PKBIG 0
2591 #endif
2592 void helper_vpkpx (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2593 {
2594     int i, j;
2595     ppc_avr_t result;
2596 #if defined(WORDS_BIGENDIAN)
2597     const ppc_avr_t *x[2] = { a, b };
2598 #else
2599     const ppc_avr_t *x[2] = { b, a };
2600 #endif
2601
2602     VECTOR_FOR_INORDER_I (i, u64) {
2603         VECTOR_FOR_INORDER_I (j, u32){
2604             uint32_t e = x[i]->u32[j];
2605             result.u16[4*i+j] = (((e >> 9) & 0xfc00) |
2606                                  ((e >> 6) & 0x3e0) |
2607                                  ((e >> 3) & 0x1f));
2608         }
2609     }
2610     *r = result;
2611 }
2612
2613 #define VPK(suffix, from, to, cvt, dosat)       \
2614     void helper_vpk##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
2615     {                                                                   \
2616         int i;                                                          \
2617         int sat = 0;                                                    \
2618         ppc_avr_t result;                                               \
2619         ppc_avr_t *a0 = PKBIG ? a : b;                                  \
2620         ppc_avr_t *a1 = PKBIG ? b : a;                                  \
2621         VECTOR_FOR_INORDER_I (i, from) {                                \
2622             result.to[i] = cvt(a0->from[i], &sat);                      \
2623             result.to[i+ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);  \
2624         }                                                               \
2625         *r = result;                                                    \
2626         if (dosat && sat) {                                             \
2627             env->vscr |= (1 << VSCR_SAT);                               \
2628         }                                                               \
2629     }
2630 #define I(x, y) (x)
2631 VPK(shss, s16, s8, cvtshsb, 1)
2632 VPK(shus, s16, u8, cvtshub, 1)
2633 VPK(swss, s32, s16, cvtswsh, 1)
2634 VPK(swus, s32, u16, cvtswuh, 1)
2635 VPK(uhus, u16, u8, cvtuhub, 1)
2636 VPK(uwus, u32, u16, cvtuwuh, 1)
2637 VPK(uhum, u16, u8, I, 0)
2638 VPK(uwum, u32, u16, I, 0)
2639 #undef I
2640 #undef VPK
2641 #undef PKBIG
2642
2643 void helper_vrefp (ppc_avr_t *r, ppc_avr_t *b)
2644 {
2645     int i;
2646     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2647         HANDLE_NAN1(r->f[i], b->f[i]) {
2648             r->f[i] = float32_div(float32_one, b->f[i], &env->vec_status);
2649         }
2650     }
2651 }
2652
2653 #define VRFI(suffix, rounding)                                          \
2654     void helper_vrfi##suffix (ppc_avr_t *r, ppc_avr_t *b)               \
2655     {                                                                   \
2656         int i;                                                          \
2657         float_status s = env->vec_status;                               \
2658         set_float_rounding_mode(rounding, &s);                          \
2659         for (i = 0; i < ARRAY_SIZE(r->f); i++) {                        \
2660             HANDLE_NAN1(r->f[i], b->f[i]) {                             \
2661                 r->f[i] = float32_round_to_int (b->f[i], &s);           \
2662             }                                                           \
2663         }                                                               \
2664     }
2665 VRFI(n, float_round_nearest_even)
2666 VRFI(m, float_round_down)
2667 VRFI(p, float_round_up)
2668 VRFI(z, float_round_to_zero)
2669 #undef VRFI
2670
2671 #define VROTATE(suffix, element)                                        \
2672     void helper_vrl##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
2673     {                                                                   \
2674         int i;                                                          \
2675         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2676             unsigned int mask = ((1 << (3 + (sizeof (a->element[0]) >> 1))) - 1); \
2677             unsigned int shift = b->element[i] & mask;                  \
2678             r->element[i] = (a->element[i] << shift) | (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \
2679         }                                                               \
2680     }
2681 VROTATE(b, u8)
2682 VROTATE(h, u16)
2683 VROTATE(w, u32)
2684 #undef VROTATE
2685
2686 void helper_vrsqrtefp (ppc_avr_t *r, ppc_avr_t *b)
2687 {
2688     int i;
2689     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2690         HANDLE_NAN1(r->f[i], b->f[i]) {
2691             float32 t = float32_sqrt(b->f[i], &env->vec_status);
2692             r->f[i] = float32_div(float32_one, t, &env->vec_status);
2693         }
2694     }
2695 }
2696
2697 void helper_vsel (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2698 {
2699     r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]);
2700     r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]);
2701 }
2702
2703 void helper_vlogefp (ppc_avr_t *r, ppc_avr_t *b)
2704 {
2705     int i;
2706     for (i = 0; i < ARRAY_SIZE(r->f); i++) {
2707         HANDLE_NAN1(r->f[i], b->f[i]) {
2708             r->f[i] = float32_log2(b->f[i], &env->vec_status);
2709         }
2710     }
2711 }
2712
2713 #if defined(WORDS_BIGENDIAN)
2714 #define LEFT 0
2715 #define RIGHT 1
2716 #else
2717 #define LEFT 1
2718 #define RIGHT 0
2719 #endif
2720 /* The specification says that the results are undefined if all of the
2721  * shift counts are not identical.  We check to make sure that they are
2722  * to conform to what real hardware appears to do.  */
2723 #define VSHIFT(suffix, leftp)                                           \
2724     void helper_vs##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)   \
2725     {                                                                   \
2726         int shift = b->u8[LO_IDX*15] & 0x7;                             \
2727         int doit = 1;                                                   \
2728         int i;                                                          \
2729         for (i = 0; i < ARRAY_SIZE(r->u8); i++) {                       \
2730             doit = doit && ((b->u8[i] & 0x7) == shift);                 \
2731         }                                                               \
2732         if (doit) {                                                     \
2733             if (shift == 0) {                                           \
2734                 *r = *a;                                                \
2735             } else if (leftp) {                                         \
2736                 uint64_t carry = a->u64[LO_IDX] >> (64 - shift);        \
2737                 r->u64[HI_IDX] = (a->u64[HI_IDX] << shift) | carry;     \
2738                 r->u64[LO_IDX] = a->u64[LO_IDX] << shift;               \
2739             } else {                                                    \
2740                 uint64_t carry = a->u64[HI_IDX] << (64 - shift);        \
2741                 r->u64[LO_IDX] = (a->u64[LO_IDX] >> shift) | carry;     \
2742                 r->u64[HI_IDX] = a->u64[HI_IDX] >> shift;               \
2743             }                                                           \
2744         }                                                               \
2745     }
2746 VSHIFT(l, LEFT)
2747 VSHIFT(r, RIGHT)
2748 #undef VSHIFT
2749 #undef LEFT
2750 #undef RIGHT
2751
2752 #define VSL(suffix, element)                                            \
2753     void helper_vsl##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
2754     {                                                                   \
2755         int i;                                                          \
2756         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2757             unsigned int mask = ((1 << (3 + (sizeof (a->element[0]) >> 1))) - 1); \
2758             unsigned int shift = b->element[i] & mask;                  \
2759             r->element[i] = a->element[i] << shift;                     \
2760         }                                                               \
2761     }
2762 VSL(b, u8)
2763 VSL(h, u16)
2764 VSL(w, u32)
2765 #undef VSL
2766
2767 void helper_vsldoi (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
2768 {
2769     int sh = shift & 0xf;
2770     int i;
2771     ppc_avr_t result;
2772
2773 #if defined(WORDS_BIGENDIAN)
2774     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
2775         int index = sh + i;
2776         if (index > 0xf) {
2777             result.u8[i] = b->u8[index-0x10];
2778         } else {
2779             result.u8[i] = a->u8[index];
2780         }
2781     }
2782 #else
2783     for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
2784         int index = (16 - sh) + i;
2785         if (index > 0xf) {
2786             result.u8[i] = a->u8[index-0x10];
2787         } else {
2788             result.u8[i] = b->u8[index];
2789         }
2790     }
2791 #endif
2792     *r = result;
2793 }
2794
2795 void helper_vslo (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2796 {
2797   int sh = (b->u8[LO_IDX*0xf] >> 3) & 0xf;
2798
2799 #if defined (WORDS_BIGENDIAN)
2800   memmove (&r->u8[0], &a->u8[sh], 16-sh);
2801   memset (&r->u8[16-sh], 0, sh);
2802 #else
2803   memmove (&r->u8[sh], &a->u8[0], 16-sh);
2804   memset (&r->u8[0], 0, sh);
2805 #endif
2806 }
2807
2808 /* Experimental testing shows that hardware masks the immediate.  */
2809 #define _SPLAT_MASKED(element) (splat & (ARRAY_SIZE(r->element) - 1))
2810 #if defined(WORDS_BIGENDIAN)
2811 #define SPLAT_ELEMENT(element) _SPLAT_MASKED(element)
2812 #else
2813 #define SPLAT_ELEMENT(element) (ARRAY_SIZE(r->element)-1 - _SPLAT_MASKED(element))
2814 #endif
2815 #define VSPLT(suffix, element)                                          \
2816     void helper_vsplt##suffix (ppc_avr_t *r, ppc_avr_t *b, uint32_t splat) \
2817     {                                                                   \
2818         uint32_t s = b->element[SPLAT_ELEMENT(element)];                \
2819         int i;                                                          \
2820         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2821             r->element[i] = s;                                          \
2822         }                                                               \
2823     }
2824 VSPLT(b, u8)
2825 VSPLT(h, u16)
2826 VSPLT(w, u32)
2827 #undef VSPLT
2828 #undef SPLAT_ELEMENT
2829 #undef _SPLAT_MASKED
2830
2831 #define VSPLTI(suffix, element, splat_type)                     \
2832     void helper_vspltis##suffix (ppc_avr_t *r, uint32_t splat)  \
2833     {                                                           \
2834         splat_type x = (int8_t)(splat << 3) >> 3;               \
2835         int i;                                                  \
2836         for (i = 0; i < ARRAY_SIZE(r->element); i++) {          \
2837             r->element[i] = x;                                  \
2838         }                                                       \
2839     }
2840 VSPLTI(b, s8, int8_t)
2841 VSPLTI(h, s16, int16_t)
2842 VSPLTI(w, s32, int32_t)
2843 #undef VSPLTI
2844
2845 #define VSR(suffix, element)                                            \
2846     void helper_vsr##suffix (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)  \
2847     {                                                                   \
2848         int i;                                                          \
2849         for (i = 0; i < ARRAY_SIZE(r->element); i++) {                  \
2850             unsigned int mask = ((1 << (3 + (sizeof (a->element[0]) >> 1))) - 1); \
2851             unsigned int shift = b->element[i] & mask;                  \
2852             r->element[i] = a->element[i] >> shift;                     \
2853         }                                                               \
2854     }
2855 VSR(ab, s8)
2856 VSR(ah, s16)
2857 VSR(aw, s32)
2858 VSR(b, u8)
2859 VSR(h, u16)
2860 VSR(w, u32)
2861 #undef VSR
2862
2863 void helper_vsro (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2864 {
2865   int sh = (b->u8[LO_IDX*0xf] >> 3) & 0xf;
2866
2867 #if defined (WORDS_BIGENDIAN)
2868   memmove (&r->u8[sh], &a->u8[0], 16-sh);
2869   memset (&r->u8[0], 0, sh);
2870 #else
2871   memmove (&r->u8[0], &a->u8[sh], 16-sh);
2872   memset (&r->u8[16-sh], 0, sh);
2873 #endif
2874 }
2875
2876 void helper_vsubcuw (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2877 {
2878     int i;
2879     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
2880         r->u32[i] = a->u32[i] >= b->u32[i];
2881     }
2882 }
2883
2884 void helper_vsumsws (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2885 {
2886     int64_t t;
2887     int i, upper;
2888     ppc_avr_t result;
2889     int sat = 0;
2890
2891 #if defined(WORDS_BIGENDIAN)
2892     upper = ARRAY_SIZE(r->s32)-1;
2893 #else
2894     upper = 0;
2895 #endif
2896     t = (int64_t)b->s32[upper];
2897     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
2898         t += a->s32[i];
2899         result.s32[i] = 0;
2900     }
2901     result.s32[upper] = cvtsdsw(t, &sat);
2902     *r = result;
2903
2904     if (sat) {
2905         env->vscr |= (1 << VSCR_SAT);
2906     }
2907 }
2908
2909 void helper_vsum2sws (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2910 {
2911     int i, j, upper;
2912     ppc_avr_t result;
2913     int sat = 0;
2914
2915 #if defined(WORDS_BIGENDIAN)
2916     upper = 1;
2917 #else
2918     upper = 0;
2919 #endif
2920     for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
2921         int64_t t = (int64_t)b->s32[upper+i*2];
2922         result.u64[i] = 0;
2923         for (j = 0; j < ARRAY_SIZE(r->u64); j++) {
2924             t += a->s32[2*i+j];
2925         }
2926         result.s32[upper+i*2] = cvtsdsw(t, &sat);
2927     }
2928
2929     *r = result;
2930     if (sat) {
2931         env->vscr |= (1 << VSCR_SAT);
2932     }
2933 }
2934
2935 void helper_vsum4sbs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2936 {
2937     int i, j;
2938     int sat = 0;
2939
2940     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
2941         int64_t t = (int64_t)b->s32[i];
2942         for (j = 0; j < ARRAY_SIZE(r->s32); j++) {
2943             t += a->s8[4*i+j];
2944         }
2945         r->s32[i] = cvtsdsw(t, &sat);
2946     }
2947
2948     if (sat) {
2949         env->vscr |= (1 << VSCR_SAT);
2950     }
2951 }
2952
2953 void helper_vsum4shs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2954 {
2955     int sat = 0;
2956     int i;
2957
2958     for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
2959         int64_t t = (int64_t)b->s32[i];
2960         t += a->s16[2*i] + a->s16[2*i+1];
2961         r->s32[i] = cvtsdsw(t, &sat);
2962     }
2963
2964     if (sat) {
2965         env->vscr |= (1 << VSCR_SAT);
2966     }
2967 }
2968
2969 void helper_vsum4ubs (ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2970 {
2971     int i, j;
2972     int sat = 0;
2973
2974     for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
2975         uint64_t t = (uint64_t)b->u32[i];
2976         for (j = 0; j < ARRAY_SIZE(r->u32); j++) {
2977             t += a->u8[4*i+j];
2978         }
2979         r->u32[i] = cvtuduw(t, &sat);
2980     }
2981
2982     if (sat) {
2983         env->vscr |= (1 << VSCR_SAT);
2984     }
2985 }
2986
2987 #if defined(WORDS_BIGENDIAN)
2988 #define UPKHI 1
2989 #define UPKLO 0
2990 #else
2991 #define UPKHI 0
2992 #define UPKLO 1
2993 #endif
2994 #define VUPKPX(suffix, hi)                                      \
2995     void helper_vupk##suffix (ppc_avr_t *r, ppc_avr_t *b)       \
2996     {                                                           \
2997         int i;                                                  \
2998         ppc_avr_t result;                                       \
2999         for (i = 0; i < ARRAY_SIZE(r->u32); i++) {              \
3000             uint16_t e = b->u16[hi ? i : i+4];                  \
3001             uint8_t a = (e >> 15) ? 0xff : 0;                   \
3002             uint8_t r = (e >> 10) & 0x1f;                       \
3003             uint8_t g = (e >> 5) & 0x1f;                        \
3004             uint8_t b = e & 0x1f;                               \
3005             result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b;       \
3006         }                                                               \
3007         *r = result;                                                    \
3008     }
3009 VUPKPX(lpx, UPKLO)
3010 VUPKPX(hpx, UPKHI)
3011 #undef VUPKPX
3012
3013 #define VUPK(suffix, unpacked, packee, hi)                              \
3014     void helper_vupk##suffix (ppc_avr_t *r, ppc_avr_t *b)               \
3015     {                                                                   \
3016         int i;                                                          \
3017         ppc_avr_t result;                                               \
3018         if (hi) {                                                       \
3019             for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) {             \
3020                 result.unpacked[i] = b->packee[i];                      \
3021             }                                                           \
3022         } else {                                                        \
3023             for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); i++) { \
3024                 result.unpacked[i-ARRAY_SIZE(r->unpacked)] = b->packee[i]; \
3025             }                                                           \
3026         }                                                               \
3027         *r = result;                                                    \
3028     }
3029 VUPK(hsb, s16, s8, UPKHI)
3030 VUPK(hsh, s32, s16, UPKHI)
3031 VUPK(lsb, s16, s8, UPKLO)
3032 VUPK(lsh, s32, s16, UPKLO)
3033 #undef VUPK
3034 #undef UPKHI
3035 #undef UPKLO
3036
3037 #undef DO_HANDLE_NAN
3038 #undef HANDLE_NAN1
3039 #undef HANDLE_NAN2
3040 #undef HANDLE_NAN3
3041 #undef VECTOR_FOR_INORDER_I
3042 #undef HI_IDX
3043 #undef LO_IDX
3044
3045 /*****************************************************************************/
3046 /* SPE extension helpers */
3047 /* Use a table to make this quicker */
3048 static uint8_t hbrev[16] = {
3049     0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
3050     0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
3051 };
3052
3053 static always_inline uint8_t byte_reverse (uint8_t val)
3054 {
3055     return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
3056 }
3057
3058 static always_inline uint32_t word_reverse (uint32_t val)
3059 {
3060     return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
3061         (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
3062 }
3063
3064 #define MASKBITS 16 // Random value - to be fixed (implementation dependant)
3065 target_ulong helper_brinc (target_ulong arg1, target_ulong arg2)
3066 {
3067     uint32_t a, b, d, mask;
3068
3069     mask = UINT32_MAX >> (32 - MASKBITS);
3070     a = arg1 & mask;
3071     b = arg2 & mask;
3072     d = word_reverse(1 + word_reverse(a | ~b));
3073     return (arg1 & ~mask) | (d & b);
3074 }
3075
3076 uint32_t helper_cntlsw32 (uint32_t val)
3077 {
3078     if (val & 0x80000000)
3079         return clz32(~val);
3080     else
3081         return clz32(val);
3082 }
3083
3084 uint32_t helper_cntlzw32 (uint32_t val)
3085 {
3086     return clz32(val);
3087 }
3088
3089 /* Single-precision floating-point conversions */
3090 static always_inline uint32_t efscfsi (uint32_t val)
3091 {
3092     CPU_FloatU u;
3093
3094     u.f = int32_to_float32(val, &env->vec_status);
3095
3096     return u.l;
3097 }
3098
3099 static always_inline uint32_t efscfui (uint32_t val)
3100 {
3101     CPU_FloatU u;
3102
3103     u.f = uint32_to_float32(val, &env->vec_status);
3104
3105     return u.l;
3106 }
3107
3108 static always_inline int32_t efsctsi (uint32_t val)
3109 {
3110     CPU_FloatU u;
3111
3112     u.l = val;
3113     /* NaN are not treated the same way IEEE 754 does */
3114     if (unlikely(float32_is_nan(u.f)))
3115         return 0;
3116
3117     return float32_to_int32(u.f, &env->vec_status);
3118 }
3119
3120 static always_inline uint32_t efsctui (uint32_t val)
3121 {
3122     CPU_FloatU u;
3123
3124     u.l = val;
3125     /* NaN are not treated the same way IEEE 754 does */
3126     if (unlikely(float32_is_nan(u.f)))
3127         return 0;
3128
3129     return float32_to_uint32(u.f, &env->vec_status);
3130 }
3131
3132 static always_inline uint32_t efsctsiz (uint32_t val)
3133 {
3134     CPU_FloatU u;
3135
3136     u.l = val;
3137     /* NaN are not treated the same way IEEE 754 does */
3138     if (unlikely(float32_is_nan(u.f)))
3139         return 0;
3140
3141     return float32_to_int32_round_to_zero(u.f, &env->vec_status);
3142 }
3143
3144 static always_inline uint32_t efsctuiz (uint32_t val)
3145 {
3146     CPU_FloatU u;
3147
3148     u.l = val;
3149     /* NaN are not treated the same way IEEE 754 does */
3150     if (unlikely(float32_is_nan(u.f)))
3151         return 0;
3152
3153     return float32_to_uint32_round_to_zero(u.f, &env->vec_status);
3154 }
3155
3156 static always_inline uint32_t efscfsf (uint32_t val)
3157 {
3158     CPU_FloatU u;
3159     float32 tmp;
3160
3161     u.f = int32_to_float32(val, &env->vec_status);
3162     tmp = int64_to_float32(1ULL << 32, &env->vec_status);
3163     u.f = float32_div(u.f, tmp, &env->vec_status);
3164
3165     return u.l;
3166 }
3167
3168 static always_inline uint32_t efscfuf (uint32_t val)
3169 {
3170     CPU_FloatU u;
3171     float32 tmp;
3172
3173     u.f = uint32_to_float32(val, &env->vec_status);
3174     tmp = uint64_to_float32(1ULL << 32, &env->vec_status);
3175     u.f = float32_div(u.f, tmp, &env->vec_status);
3176
3177     return u.l;
3178 }
3179
3180 static always_inline uint32_t efsctsf (uint32_t val)
3181 {
3182     CPU_FloatU u;
3183     float32 tmp;
3184
3185     u.l = val;
3186     /* NaN are not treated the same way IEEE 754 does */
3187     if (unlikely(float32_is_nan(u.f)))
3188         return 0;
3189     tmp = uint64_to_float32(1ULL << 32, &env->vec_status);
3190     u.f = float32_mul(u.f, tmp, &env->vec_status);
3191
3192     return float32_to_int32(u.f, &env->vec_status);
3193 }
3194
3195 static always_inline uint32_t efsctuf (uint32_t val)
3196 {
3197     CPU_FloatU u;
3198     float32 tmp;
3199
3200     u.l = val;
3201     /* NaN are not treated the same way IEEE 754 does */
3202     if (unlikely(float32_is_nan(u.f)))
3203         return 0;
3204     tmp = uint64_to_float32(1ULL << 32, &env->vec_status);
3205     u.f = float32_mul(u.f, tmp, &env->vec_status);
3206
3207     return float32_to_uint32(u.f, &env->vec_status);
3208 }
3209
3210 #define HELPER_SPE_SINGLE_CONV(name)                                          \
3211 uint32_t helper_e##name (uint32_t val)                                        \
3212 {                                                                             \
3213     return e##name(val);                                                      \
3214 }
3215 /* efscfsi */
3216 HELPER_SPE_SINGLE_CONV(fscfsi);
3217 /* efscfui */
3218 HELPER_SPE_SINGLE_CONV(fscfui);
3219 /* efscfuf */
3220 HELPER_SPE_SINGLE_CONV(fscfuf);
3221 /* efscfsf */
3222 HELPER_SPE_SINGLE_CONV(fscfsf);
3223 /* efsctsi */
3224 HELPER_SPE_SINGLE_CONV(fsctsi);
3225 /* efsctui */
3226 HELPER_SPE_SINGLE_CONV(fsctui);
3227 /* efsctsiz */
3228 HELPER_SPE_SINGLE_CONV(fsctsiz);
3229 /* efsctuiz */
3230 HELPER_SPE_SINGLE_CONV(fsctuiz);
3231 /* efsctsf */
3232 HELPER_SPE_SINGLE_CONV(fsctsf);
3233 /* efsctuf */
3234 HELPER_SPE_SINGLE_CONV(fsctuf);
3235
3236 #define HELPER_SPE_VECTOR_CONV(name)                                          \
3237 uint64_t helper_ev##name (uint64_t val)                                       \
3238 {                                                                             \
3239     return ((uint64_t)e##name(val >> 32) << 32) |                             \
3240             (uint64_t)e##name(val);                                           \
3241 }
3242 /* evfscfsi */
3243 HELPER_SPE_VECTOR_CONV(fscfsi);
3244 /* evfscfui */
3245 HELPER_SPE_VECTOR_CONV(fscfui);
3246 /* evfscfuf */
3247 HELPER_SPE_VECTOR_CONV(fscfuf);
3248 /* evfscfsf */
3249 HELPER_SPE_VECTOR_CONV(fscfsf);
3250 /* evfsctsi */
3251 HELPER_SPE_VECTOR_CONV(fsctsi);
3252 /* evfsctui */
3253 HELPER_SPE_VECTOR_CONV(fsctui);
3254 /* evfsctsiz */
3255 HELPER_SPE_VECTOR_CONV(fsctsiz);
3256 /* evfsctuiz */
3257 HELPER_SPE_VECTOR_CONV(fsctuiz);
3258 /* evfsctsf */
3259 HELPER_SPE_VECTOR_CONV(fsctsf);
3260 /* evfsctuf */
3261 HELPER_SPE_VECTOR_CONV(fsctuf);
3262
3263 /* Single-precision floating-point arithmetic */
3264 static always_inline uint32_t efsadd (uint32_t op1, uint32_t op2)
3265 {
3266     CPU_FloatU u1, u2;
3267     u1.l = op1;
3268     u2.l = op2;
3269     u1.f = float32_add(u1.f, u2.f, &env->vec_status);
3270     return u1.l;
3271 }
3272
3273 static always_inline uint32_t efssub (uint32_t op1, uint32_t op2)
3274 {
3275     CPU_FloatU u1, u2;
3276     u1.l = op1;
3277     u2.l = op2;
3278     u1.f = float32_sub(u1.f, u2.f, &env->vec_status);
3279     return u1.l;
3280 }
3281
3282 static always_inline uint32_t efsmul (uint32_t op1, uint32_t op2)
3283 {
3284     CPU_FloatU u1, u2;
3285     u1.l = op1;
3286     u2.l = op2;
3287     u1.f = float32_mul(u1.f, u2.f, &env->vec_status);
3288     return u1.l;
3289 }
3290
3291 static always_inline uint32_t efsdiv (uint32_t op1, uint32_t op2)
3292 {
3293     CPU_FloatU u1, u2;
3294     u1.l = op1;
3295     u2.l = op2;
3296     u1.f = float32_div(u1.f, u2.f, &env->vec_status);
3297     return u1.l;
3298 }
3299
3300 #define HELPER_SPE_SINGLE_ARITH(name)                                         \
3301 uint32_t helper_e##name (uint32_t op1, uint32_t op2)                          \
3302 {                                                                             \
3303     return e##name(op1, op2);                                                 \
3304 }
3305 /* efsadd */
3306 HELPER_SPE_SINGLE_ARITH(fsadd);
3307 /* efssub */
3308 HELPER_SPE_SINGLE_ARITH(fssub);
3309 /* efsmul */
3310 HELPER_SPE_SINGLE_ARITH(fsmul);
3311 /* efsdiv */
3312 HELPER_SPE_SINGLE_ARITH(fsdiv);
3313
3314 #define HELPER_SPE_VECTOR_ARITH(name)                                         \
3315 uint64_t helper_ev##name (uint64_t op1, uint64_t op2)                         \
3316 {                                                                             \
3317     return ((uint64_t)e##name(op1 >> 32, op2 >> 32) << 32) |                  \
3318             (uint64_t)e##name(op1, op2);                                      \
3319 }
3320 /* evfsadd */
3321 HELPER_SPE_VECTOR_ARITH(fsadd);
3322 /* evfssub */
3323 HELPER_SPE_VECTOR_ARITH(fssub);
3324 /* evfsmul */
3325 HELPER_SPE_VECTOR_ARITH(fsmul);
3326 /* evfsdiv */
3327 HELPER_SPE_VECTOR_ARITH(fsdiv);
3328
3329 /* Single-precision floating-point comparisons */
3330 static always_inline uint32_t efststlt (uint32_t op1, uint32_t op2)
3331 {
3332     CPU_FloatU u1, u2;
3333     u1.l = op1;
3334     u2.l = op2;
3335     return float32_lt(u1.f, u2.f, &env->vec_status) ? 4 : 0;
3336 }
3337
3338 static always_inline uint32_t efststgt (uint32_t op1, uint32_t op2)
3339 {
3340     CPU_FloatU u1, u2;
3341     u1.l = op1;
3342     u2.l = op2;
3343     return float32_le(u1.f, u2.f, &env->vec_status) ? 0 : 4;
3344 }
3345
3346 static always_inline uint32_t efststeq (uint32_t op1, uint32_t op2)
3347 {
3348     CPU_FloatU u1, u2;
3349     u1.l = op1;
3350     u2.l = op2;
3351     return float32_eq(u1.f, u2.f, &env->vec_status) ? 4 : 0;
3352 }
3353
3354 static always_inline uint32_t efscmplt (uint32_t op1, uint32_t op2)
3355 {
3356     /* XXX: TODO: test special values (NaN, infinites, ...) */
3357     return efststlt(op1, op2);
3358 }
3359
3360 static always_inline uint32_t efscmpgt (uint32_t op1, uint32_t op2)
3361 {
3362     /* XXX: TODO: test special values (NaN, infinites, ...) */
3363     return efststgt(op1, op2);
3364 }
3365
3366 static always_inline uint32_t efscmpeq (uint32_t op1, uint32_t op2)
3367 {
3368     /* XXX: TODO: test special values (NaN, infinites, ...) */
3369     return efststeq(op1, op2);
3370 }
3371
3372 #define HELPER_SINGLE_SPE_CMP(name)                                           \
3373 uint32_t helper_e##name (uint32_t op1, uint32_t op2)                          \
3374 {                                                                             \
3375     return e##name(op1, op2) << 2;                                            \
3376 }
3377 /* efststlt */
3378 HELPER_SINGLE_SPE_CMP(fststlt);
3379 /* efststgt */
3380 HELPER_SINGLE_SPE_CMP(fststgt);
3381 /* efststeq */
3382 HELPER_SINGLE_SPE_CMP(fststeq);
3383 /* efscmplt */
3384 HELPER_SINGLE_SPE_CMP(fscmplt);
3385 /* efscmpgt */
3386 HELPER_SINGLE_SPE_CMP(fscmpgt);
3387 /* efscmpeq */
3388 HELPER_SINGLE_SPE_CMP(fscmpeq);
3389
3390 static always_inline uint32_t evcmp_merge (int t0, int t1)
3391 {
3392     return (t0 << 3) | (t1 << 2) | ((t0 | t1) << 1) | (t0 & t1);
3393 }
3394
3395 #define HELPER_VECTOR_SPE_CMP(name)                                           \
3396 uint32_t helper_ev##name (uint64_t op1, uint64_t op2)                         \
3397 {                                                                             \
3398     return evcmp_merge(e##name(op1 >> 32, op2 >> 32), e##name(op1, op2));     \
3399 }
3400 /* evfststlt */
3401 HELPER_VECTOR_SPE_CMP(fststlt);
3402 /* evfststgt */
3403 HELPER_VECTOR_SPE_CMP(fststgt);
3404 /* evfststeq */
3405 HELPER_VECTOR_SPE_CMP(fststeq);
3406 /* evfscmplt */
3407 HELPER_VECTOR_SPE_CMP(fscmplt);
3408 /* evfscmpgt */
3409 HELPER_VECTOR_SPE_CMP(fscmpgt);
3410 /* evfscmpeq */
3411 HELPER_VECTOR_SPE_CMP(fscmpeq);
3412
3413 /* Double-precision floating-point conversion */
3414 uint64_t helper_efdcfsi (uint32_t val)
3415 {
3416     CPU_DoubleU u;
3417
3418     u.d = int32_to_float64(val, &env->vec_status);
3419
3420     return u.ll;
3421 }
3422
3423 uint64_t helper_efdcfsid (uint64_t val)
3424 {
3425     CPU_DoubleU u;
3426
3427     u.d = int64_to_float64(val, &env->vec_status);
3428
3429     return u.ll;
3430 }
3431
3432 uint64_t helper_efdcfui (uint32_t val)
3433 {
3434     CPU_DoubleU u;
3435
3436     u.d = uint32_to_float64(val, &env->vec_status);
3437
3438     return u.ll;
3439 }
3440
3441 uint64_t helper_efdcfuid (uint64_t val)
3442 {
3443     CPU_DoubleU u;
3444
3445     u.d = uint64_to_float64(val, &env->vec_status);
3446
3447     return u.ll;
3448 }
3449
3450 uint32_t helper_efdctsi (uint64_t val)
3451 {
3452     CPU_DoubleU u;
3453
3454     u.ll = val;
3455     /* NaN are not treated the same way IEEE 754 does */
3456     if (unlikely(float64_is_nan(u.d)))
3457         return 0;
3458
3459     return float64_to_int32(u.d, &env->vec_status);
3460 }
3461
3462 uint32_t helper_efdctui (uint64_t val)
3463 {
3464     CPU_DoubleU u;
3465
3466     u.ll = val;
3467     /* NaN are not treated the same way IEEE 754 does */
3468     if (unlikely(float64_is_nan(u.d)))
3469         return 0;
3470
3471     return float64_to_uint32(u.d, &env->vec_status);
3472 }
3473
3474 uint32_t helper_efdctsiz (uint64_t val)
3475 {
3476     CPU_DoubleU u;
3477
3478     u.ll = val;
3479     /* NaN are not treated the same way IEEE 754 does */
3480     if (unlikely(float64_is_nan(u.d)))
3481         return 0;
3482
3483     return float64_to_int32_round_to_zero(u.d, &env->vec_status);
3484 }
3485
3486 uint64_t helper_efdctsidz (uint64_t val)
3487 {
3488     CPU_DoubleU u;
3489
3490     u.ll = val;
3491     /* NaN are not treated the same way IEEE 754 does */
3492     if (unlikely(float64_is_nan(u.d)))
3493         return 0;
3494
3495     return float64_to_int64_round_to_zero(u.d, &env->vec_status);
3496 }
3497
3498 uint32_t helper_efdctuiz (uint64_t val)
3499 {
3500     CPU_DoubleU u;
3501
3502     u.ll = val;
3503     /* NaN are not treated the same way IEEE 754 does */
3504     if (unlikely(float64_is_nan(u.d)))
3505         return 0;
3506
3507     return float64_to_uint32_round_to_zero(u.d, &env->vec_status);
3508 }
3509
3510 uint64_t helper_efdctuidz (uint64_t val)
3511 {
3512     CPU_DoubleU u;
3513
3514     u.ll = val;
3515     /* NaN are not treated the same way IEEE 754 does */
3516     if (unlikely(float64_is_nan(u.d)))
3517         return 0;
3518
3519     return float64_to_uint64_round_to_zero(u.d, &env->vec_status);
3520 }
3521
3522 uint64_t helper_efdcfsf (uint32_t val)
3523 {
3524     CPU_DoubleU u;
3525     float64 tmp;
3526
3527     u.d = int32_to_float64(val, &env->vec_status);
3528     tmp = int64_to_float64(1ULL << 32, &env->vec_status);
3529     u.d = float64_div(u.d, tmp, &env->vec_status);
3530
3531     return u.ll;
3532 }
3533
3534 uint64_t helper_efdcfuf (uint32_t val)
3535 {
3536     CPU_DoubleU u;
3537     float64 tmp;
3538
3539     u.d = uint32_to_float64(val, &env->vec_status);
3540     tmp = int64_to_float64(1ULL << 32, &env->vec_status);
3541     u.d = float64_div(u.d, tmp, &env->vec_status);
3542
3543     return u.ll;
3544 }
3545
3546 uint32_t helper_efdctsf (uint64_t val)
3547 {
3548     CPU_DoubleU u;
3549     float64 tmp;
3550
3551     u.ll = val;
3552     /* NaN are not treated the same way IEEE 754 does */
3553     if (unlikely(float64_is_nan(u.d)))
3554         return 0;
3555     tmp = uint64_to_float64(1ULL << 32, &env->vec_status);
3556     u.d = float64_mul(u.d, tmp, &env->vec_status);
3557
3558     return float64_to_int32(u.d, &env->vec_status);
3559 }
3560
3561 uint32_t helper_efdctuf (uint64_t val)
3562 {
3563     CPU_DoubleU u;
3564     float64 tmp;
3565
3566     u.ll = val;
3567     /* NaN are not treated the same way IEEE 754 does */
3568     if (unlikely(float64_is_nan(u.d)))
3569         return 0;
3570     tmp = uint64_to_float64(1ULL << 32, &env->vec_status);
3571     u.d = float64_mul(u.d, tmp, &env->vec_status);
3572
3573     return float64_to_uint32(u.d, &env->vec_status);
3574 }
3575
3576 uint32_t helper_efscfd (uint64_t val)
3577 {
3578     CPU_DoubleU u1;
3579     CPU_FloatU u2;
3580
3581     u1.ll = val;
3582     u2.f = float64_to_float32(u1.d, &env->vec_status);
3583
3584     return u2.l;
3585 }
3586
3587 uint64_t helper_efdcfs (uint32_t val)
3588 {
3589     CPU_DoubleU u2;
3590     CPU_FloatU u1;
3591
3592     u1.l = val;
3593     u2.d = float32_to_float64(u1.f, &env->vec_status);
3594
3595     return u2.ll;
3596 }
3597
3598 /* Double precision fixed-point arithmetic */
3599 uint64_t helper_efdadd (uint64_t op1, uint64_t op2)
3600 {
3601     CPU_DoubleU u1, u2;
3602     u1.ll = op1;
3603     u2.ll = op2;
3604     u1.d = float64_add(u1.d, u2.d, &env->vec_status);
3605     return u1.ll;
3606 }
3607
3608 uint64_t helper_efdsub (uint64_t op1, uint64_t op2)
3609 {
3610     CPU_DoubleU u1, u2;
3611     u1.ll = op1;
3612     u2.ll = op2;
3613     u1.d = float64_sub(u1.d, u2.d, &env->vec_status);
3614     return u1.ll;
3615 }
3616
3617 uint64_t helper_efdmul (uint64_t op1, uint64_t op2)
3618 {
3619     CPU_DoubleU u1, u2;
3620     u1.ll = op1;
3621     u2.ll = op2;
3622     u1.d = float64_mul(u1.d, u2.d, &env->vec_status);
3623     return u1.ll;
3624 }
3625
3626 uint64_t helper_efddiv (uint64_t op1, uint64_t op2)
3627 {
3628     CPU_DoubleU u1, u2;
3629     u1.ll = op1;
3630     u2.ll = op2;
3631     u1.d = float64_div(u1.d, u2.d, &env->vec_status);
3632     return u1.ll;
3633 }
3634
3635 /* Double precision floating point helpers */
3636 uint32_t helper_efdtstlt (uint64_t op1, uint64_t op2)
3637 {
3638     CPU_DoubleU u1, u2;
3639     u1.ll = op1;
3640     u2.ll = op2;
3641     return float64_lt(u1.d, u2.d, &env->vec_status) ? 4 : 0;
3642 }
3643
3644 uint32_t helper_efdtstgt (uint64_t op1, uint64_t op2)
3645 {
3646     CPU_DoubleU u1, u2;
3647     u1.ll = op1;
3648     u2.ll = op2;
3649     return float64_le(u1.d, u2.d, &env->vec_status) ? 0 : 4;
3650 }
3651
3652 uint32_t helper_efdtsteq (uint64_t op1, uint64_t op2)
3653 {
3654     CPU_DoubleU u1, u2;
3655     u1.ll = op1;
3656     u2.ll = op2;
3657     return float64_eq(u1.d, u2.d, &env->vec_status) ? 4 : 0;
3658 }
3659
3660 uint32_t helper_efdcmplt (uint64_t op1, uint64_t op2)
3661 {
3662     /* XXX: TODO: test special values (NaN, infinites, ...) */
3663     return helper_efdtstlt(op1, op2);
3664 }
3665
3666 uint32_t helper_efdcmpgt (uint64_t op1, uint64_t op2)
3667 {
3668     /* XXX: TODO: test special values (NaN, infinites, ...) */
3669     return helper_efdtstgt(op1, op2);
3670 }
3671
3672 uint32_t helper_efdcmpeq (uint64_t op1, uint64_t op2)
3673 {
3674     /* XXX: TODO: test special values (NaN, infinites, ...) */
3675     return helper_efdtsteq(op1, op2);
3676 }
3677
3678 /*****************************************************************************/
3679 /* Softmmu support */
3680 #if !defined (CONFIG_USER_ONLY)
3681
3682 #define MMUSUFFIX _mmu
3683
3684 #define SHIFT 0
3685 #include "softmmu_template.h"
3686
3687 #define SHIFT 1
3688 #include "softmmu_template.h"
3689
3690 #define SHIFT 2
3691 #include "softmmu_template.h"
3692
3693 #define SHIFT 3
3694 #include "softmmu_template.h"
3695
3696 /* try to fill the TLB and return an exception if error. If retaddr is
3697    NULL, it means that the function was called in C code (i.e. not
3698    from generated code or from helper.c) */
3699 /* XXX: fix it to restore all registers */
3700 void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
3701 {
3702     TranslationBlock *tb;
3703     CPUState *saved_env;
3704     unsigned long pc;
3705     int ret;
3706
3707     /* XXX: hack to restore env in all cases, even if not called from
3708        generated code */
3709     saved_env = env;
3710     env = cpu_single_env;
3711     ret = cpu_ppc_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
3712     if (unlikely(ret != 0)) {
3713         if (likely(retaddr)) {
3714             /* now we have a real cpu fault */
3715             pc = (unsigned long)retaddr;
3716             tb = tb_find_pc(pc);
3717             if (likely(tb)) {
3718                 /* the PC is inside the translated code. It means that we have
3719                    a virtual CPU fault */
3720                 cpu_restore_state(tb, env, pc, NULL);
3721             }
3722         }
3723         helper_raise_exception_err(env->exception_index, env->error_code);
3724     }
3725     env = saved_env;
3726 }
3727
3728 /* Segment registers load and store */
3729 target_ulong helper_load_sr (target_ulong sr_num)
3730 {
3731 #if defined(TARGET_PPC64)
3732     if (env->mmu_model & POWERPC_MMU_64)
3733         return ppc_load_sr(env, sr_num);
3734 #endif
3735     return env->sr[sr_num];
3736 }
3737
3738 void helper_store_sr (target_ulong sr_num, target_ulong val)
3739 {
3740     ppc_store_sr(env, sr_num, val);
3741 }
3742
3743 /* SLB management */
3744 #if defined(TARGET_PPC64)
3745 target_ulong helper_load_slb (target_ulong slb_nr)
3746 {
3747     return ppc_load_slb(env, slb_nr);
3748 }
3749
3750 void helper_store_slb (target_ulong rb, target_ulong rs)
3751 {
3752     ppc_store_slb(env, rb, rs);
3753 }
3754
3755 void helper_slbia (void)
3756 {
3757     ppc_slb_invalidate_all(env);
3758 }
3759
3760 void helper_slbie (target_ulong addr)
3761 {
3762     ppc_slb_invalidate_one(env, addr);
3763 }
3764
3765 #endif /* defined(TARGET_PPC64) */
3766
3767 /* TLB management */
3768 void helper_tlbia (void)
3769 {
3770     ppc_tlb_invalidate_all(env);
3771 }
3772
3773 void helper_tlbie (target_ulong addr)
3774 {
3775     ppc_tlb_invalidate_one(env, addr);
3776 }
3777
3778 /* Software driven TLBs management */
3779 /* PowerPC 602/603 software TLB load instructions helpers */
3780 static void do_6xx_tlb (target_ulong new_EPN, int is_code)
3781 {
3782     target_ulong RPN, CMP, EPN;
3783     int way;
3784
3785     RPN = env->spr[SPR_RPA];
3786     if (is_code) {
3787         CMP = env->spr[SPR_ICMP];
3788         EPN = env->spr[SPR_IMISS];
3789     } else {
3790         CMP = env->spr[SPR_DCMP];
3791         EPN = env->spr[SPR_DMISS];
3792     }
3793     way = (env->spr[SPR_SRR1] >> 17) & 1;
3794     LOG_SWTLB("%s: EPN " ADDRX " " ADDRX " PTE0 " ADDRX
3795                 " PTE1 " ADDRX " way %d\n",
3796                 __func__, new_EPN, EPN, CMP, RPN, way);
3797     /* Store this TLB */
3798     ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
3799                      way, is_code, CMP, RPN);
3800 }
3801
3802 void helper_6xx_tlbd (target_ulong EPN)
3803 {
3804     do_6xx_tlb(EPN, 0);
3805 }
3806
3807 void helper_6xx_tlbi (target_ulong EPN)
3808 {
3809     do_6xx_tlb(EPN, 1);
3810 }
3811
3812 /* PowerPC 74xx software TLB load instructions helpers */
3813 static void do_74xx_tlb (target_ulong new_EPN, int is_code)
3814 {
3815     target_ulong RPN, CMP, EPN;
3816     int way;
3817
3818     RPN = env->spr[SPR_PTELO];
3819     CMP = env->spr[SPR_PTEHI];
3820     EPN = env->spr[SPR_TLBMISS] & ~0x3;
3821     way = env->spr[SPR_TLBMISS] & 0x3;
3822     LOG_SWTLB("%s: EPN " ADDRX " " ADDRX " PTE0 " ADDRX
3823                 " PTE1 " ADDRX " way %d\n",
3824                 __func__, new_EPN, EPN, CMP, RPN, way);
3825     /* Store this TLB */
3826     ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
3827                      way, is_code, CMP, RPN);
3828 }
3829
3830 void helper_74xx_tlbd (target_ulong EPN)
3831 {
3832     do_74xx_tlb(EPN, 0);
3833 }
3834
3835 void helper_74xx_tlbi (target_ulong EPN)
3836 {
3837     do_74xx_tlb(EPN, 1);
3838 }
3839
3840 static always_inline target_ulong booke_tlb_to_page_size (int size)
3841 {
3842     return 1024 << (2 * size);
3843 }
3844
3845 static always_inline int booke_page_size_to_tlb (target_ulong page_size)
3846 {
3847     int size;
3848
3849     switch (page_size) {
3850     case 0x00000400UL:
3851         size = 0x0;
3852         break;
3853     case 0x00001000UL:
3854         size = 0x1;
3855         break;
3856     case 0x00004000UL:
3857         size = 0x2;
3858         break;
3859     case 0x00010000UL:
3860         size = 0x3;
3861         break;
3862     case 0x00040000UL:
3863         size = 0x4;
3864         break;
3865     case 0x00100000UL:
3866         size = 0x5;
3867         break;
3868     case 0x00400000UL:
3869         size = 0x6;
3870         break;
3871     case 0x01000000UL:
3872         size = 0x7;
3873         break;
3874     case 0x04000000UL:
3875         size = 0x8;
3876         break;
3877     case 0x10000000UL:
3878         size = 0x9;
3879         break;
3880     case 0x40000000UL:
3881         size = 0xA;
3882         break;
3883 #if defined (TARGET_PPC64)
3884     case 0x000100000000ULL:
3885         size = 0xB;
3886         break;
3887     case 0x000400000000ULL:
3888         size = 0xC;
3889         break;
3890     case 0x001000000000ULL:
3891         size = 0xD;
3892         break;
3893     case 0x004000000000ULL:
3894         size = 0xE;
3895         break;
3896     case 0x010000000000ULL:
3897         size = 0xF;
3898         break;
3899 #endif
3900     default:
3901         size = -1;
3902         break;
3903     }
3904
3905     return size;
3906 }
3907
3908 /* Helpers for 4xx TLB management */
3909 target_ulong helper_4xx_tlbre_lo (target_ulong entry)
3910 {
3911     ppcemb_tlb_t *tlb;
3912     target_ulong ret;
3913     int size;
3914
3915     entry &= 0x3F;
3916     tlb = &env->tlb[entry].tlbe;
3917     ret = tlb->EPN;
3918     if (tlb->prot & PAGE_VALID)
3919         ret |= 0x400;
3920     size = booke_page_size_to_tlb(tlb->size);
3921     if (size < 0 || size > 0x7)
3922         size = 1;
3923     ret |= size << 7;
3924     env->spr[SPR_40x_PID] = tlb->PID;
3925     return ret;
3926 }
3927
3928 target_ulong helper_4xx_tlbre_hi (target_ulong entry)
3929 {
3930     ppcemb_tlb_t *tlb;
3931     target_ulong ret;
3932
3933     entry &= 0x3F;
3934     tlb = &env->tlb[entry].tlbe;
3935     ret = tlb->RPN;
3936     if (tlb->prot & PAGE_EXEC)
3937         ret |= 0x200;
3938     if (tlb->prot & PAGE_WRITE)
3939         ret |= 0x100;
3940     return ret;
3941 }
3942
3943 void helper_4xx_tlbwe_hi (target_ulong entry, target_ulong val)
3944 {
3945     ppcemb_tlb_t *tlb;
3946     target_ulong page, end;
3947
3948     LOG_SWTLB("%s entry %d val " ADDRX "\n", __func__, (int)entry, val);
3949     entry &= 0x3F;
3950     tlb = &env->tlb[entry].tlbe;
3951     /* Invalidate previous TLB (if it's valid) */
3952     if (tlb->prot & PAGE_VALID) {
3953         end = tlb->EPN + tlb->size;
3954         LOG_SWTLB("%s: invalidate old TLB %d start " ADDRX
3955                     " end " ADDRX "\n", __func__, (int)entry, tlb->EPN, end);
3956         for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
3957             tlb_flush_page(env, page);
3958     }
3959     tlb->size = booke_tlb_to_page_size((val >> 7) & 0x7);
3960     /* We cannot handle TLB size < TARGET_PAGE_SIZE.
3961      * If this ever occurs, one should use the ppcemb target instead
3962      * of the ppc or ppc64 one
3963      */
3964     if ((val & 0x40) && tlb->size < TARGET_PAGE_SIZE) {
3965         cpu_abort(env, "TLB size " TARGET_FMT_lu " < %u "
3966                   "are not supported (%d)\n",
3967                   tlb->size, TARGET_PAGE_SIZE, (int)((val >> 7) & 0x7));
3968     }
3969     tlb->EPN = val & ~(tlb->size - 1);
3970     if (val & 0x40)
3971         tlb->prot |= PAGE_VALID;
3972     else
3973         tlb->prot &= ~PAGE_VALID;
3974     if (val & 0x20) {
3975         /* XXX: TO BE FIXED */
3976         cpu_abort(env, "Little-endian TLB entries are not supported by now\n");
3977     }
3978     tlb->PID = env->spr[SPR_40x_PID]; /* PID */
3979     tlb->attr = val & 0xFF;
3980     LOG_SWTLB("%s: set up TLB %d RPN " PADDRX " EPN " ADDRX
3981                 " size " ADDRX " prot %c%c%c%c PID %d\n", __func__,
3982                 (int)entry, tlb->RPN, tlb->EPN, tlb->size,
3983                 tlb->prot & PAGE_READ ? 'r' : '-',
3984                 tlb->prot & PAGE_WRITE ? 'w' : '-',
3985                 tlb->prot & PAGE_EXEC ? 'x' : '-',
3986                 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
3987     /* Invalidate new TLB (if valid) */
3988     if (tlb->prot & PAGE_VALID) {
3989         end = tlb->EPN + tlb->size;
3990         LOG_SWTLB("%s: invalidate TLB %d start " ADDRX
3991                     " end " ADDRX "\n", __func__, (int)entry, tlb->EPN, end);
3992         for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
3993             tlb_flush_page(env, page);
3994     }
3995 }
3996
3997 void helper_4xx_tlbwe_lo (target_ulong entry, target_ulong val)
3998 {
3999     ppcemb_tlb_t *tlb;
4000
4001     LOG_SWTLB("%s entry %i val " ADDRX "\n", __func__, (int)entry, val);
4002     entry &= 0x3F;
4003     tlb = &env->tlb[entry].tlbe;
4004     tlb->RPN = val & 0xFFFFFC00;
4005     tlb->prot = PAGE_READ;
4006     if (val & 0x200)
4007         tlb->prot |= PAGE_EXEC;
4008     if (val & 0x100)
4009         tlb->prot |= PAGE_WRITE;
4010     LOG_SWTLB("%s: set up TLB %d RPN " PADDRX " EPN " ADDRX
4011                 " size " ADDRX " prot %c%c%c%c PID %d\n", __func__,
4012                 (int)entry, tlb->RPN, tlb->EPN, tlb->size,
4013                 tlb->prot & PAGE_READ ? 'r' : '-',
4014                 tlb->prot & PAGE_WRITE ? 'w' : '-',
4015                 tlb->prot & PAGE_EXEC ? 'x' : '-',
4016                 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
4017 }
4018
4019 target_ulong helper_4xx_tlbsx (target_ulong address)
4020 {
4021     return ppcemb_tlb_search(env, address, env->spr[SPR_40x_PID]);
4022 }
4023
4024 /* PowerPC 440 TLB management */
4025 void helper_440_tlbwe (uint32_t word, target_ulong entry, target_ulong value)
4026 {
4027     ppcemb_tlb_t *tlb;
4028     target_ulong EPN, RPN, size;
4029     int do_flush_tlbs;
4030
4031     LOG_SWTLB("%s word %d entry %d value " ADDRX "\n",
4032                 __func__, word, (int)entry, value);
4033     do_flush_tlbs = 0;
4034     entry &= 0x3F;
4035     tlb = &env->tlb[entry].tlbe;
4036     switch (word) {
4037     default:
4038         /* Just here to please gcc */
4039     case 0:
4040         EPN = value & 0xFFFFFC00;
4041         if ((tlb->prot & PAGE_VALID) && EPN != tlb->EPN)
4042             do_flush_tlbs = 1;
4043         tlb->EPN = EPN;
4044         size = booke_tlb_to_page_size((value >> 4) & 0xF);
4045         if ((tlb->prot & PAGE_VALID) && tlb->size < size)
4046             do_flush_tlbs = 1;
4047         tlb->size = size;
4048         tlb->attr &= ~0x1;
4049         tlb->attr |= (value >> 8) & 1;
4050         if (value & 0x200) {
4051             tlb->prot |= PAGE_VALID;
4052         } else {
4053             if (tlb->prot & PAGE_VALID) {
4054                 tlb->prot &= ~PAGE_VALID;
4055                 do_flush_tlbs = 1;
4056             }
4057         }
4058         tlb->PID = env->spr[SPR_440_MMUCR] & 0x000000FF;
4059         if (do_flush_tlbs)
4060             tlb_flush(env, 1);
4061         break;
4062     case 1:
4063         RPN = value & 0xFFFFFC0F;
4064         if ((tlb->prot & PAGE_VALID) && tlb->RPN != RPN)
4065             tlb_flush(env, 1);
4066         tlb->RPN = RPN;
4067         break;
4068     case 2:
4069         tlb->attr = (tlb->attr & 0x1) | (value & 0x0000FF00);
4070         tlb->prot = tlb->prot & PAGE_VALID;
4071         if (value & 0x1)
4072             tlb->prot |= PAGE_READ << 4;
4073         if (value & 0x2)
4074             tlb->prot |= PAGE_WRITE << 4;
4075         if (value & 0x4)
4076             tlb->prot |= PAGE_EXEC << 4;
4077         if (value & 0x8)
4078             tlb->prot |= PAGE_READ;
4079         if (value & 0x10)
4080             tlb->prot |= PAGE_WRITE;
4081         if (value & 0x20)
4082             tlb->prot |= PAGE_EXEC;
4083         break;
4084     }
4085 }
4086
4087 target_ulong helper_440_tlbre (uint32_t word, target_ulong entry)
4088 {
4089     ppcemb_tlb_t *tlb;
4090     target_ulong ret;
4091     int size;
4092
4093     entry &= 0x3F;
4094     tlb = &env->tlb[entry].tlbe;
4095     switch (word) {
4096     default:
4097         /* Just here to please gcc */
4098     case 0:
4099         ret = tlb->EPN;
4100         size = booke_page_size_to_tlb(tlb->size);
4101         if (size < 0 || size > 0xF)
4102             size = 1;
4103         ret |= size << 4;
4104         if (tlb->attr & 0x1)
4105             ret |= 0x100;
4106         if (tlb->prot & PAGE_VALID)
4107             ret |= 0x200;
4108         env->spr[SPR_440_MMUCR] &= ~0x000000FF;
4109         env->spr[SPR_440_MMUCR] |= tlb->PID;
4110         break;
4111     case 1:
4112         ret = tlb->RPN;
4113         break;
4114     case 2:
4115         ret = tlb->attr & ~0x1;
4116         if (tlb->prot & (PAGE_READ << 4))
4117             ret |= 0x1;
4118         if (tlb->prot & (PAGE_WRITE << 4))
4119             ret |= 0x2;
4120         if (tlb->prot & (PAGE_EXEC << 4))
4121             ret |= 0x4;
4122         if (tlb->prot & PAGE_READ)
4123             ret |= 0x8;
4124         if (tlb->prot & PAGE_WRITE)
4125             ret |= 0x10;
4126         if (tlb->prot & PAGE_EXEC)
4127             ret |= 0x20;
4128         break;
4129     }
4130     return ret;
4131 }
4132
4133 target_ulong helper_440_tlbsx (target_ulong address)
4134 {
4135     return ppcemb_tlb_search(env, address, env->spr[SPR_440_MMUCR] & 0xFF);
4136 }
4137
4138 #endif /* !CONFIG_USER_ONLY */