target-ppc/op.c

   1 /*
   2  *  PowerPC emulation micro-operations 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 //#define DEBUG_OP
  22
  23 #include "config.h"
  24 #include "exec.h"
  25 #include "host-utils.h"
  26 #include "helper_regs.h"
  27 #include "op_helper.h"
  28
  29 /* Generate exceptions */
  30 void OPPROTO op_raise_exception_err (void)
  31 {
  32     do_raise_exception_err(PARAM1, PARAM2);
  33 }
  34
  35 void OPPROTO op_debug (void)
  36 {
  37     do_raise_exception(EXCP_DEBUG);
  38 }
  39
  40 #if !defined(CONFIG_USER_ONLY)
  41 /* Segment registers load and store */
  42 void OPPROTO op_load_sr (void)
  43 {
  44     T0 = env->sr[T1];
  45     RETURN();
  46 }
  47
  48 void OPPROTO op_store_sr (void)
  49 {
  50     do_store_sr(env, T1, T0);
  51     RETURN();
  52 }
  53
  54 #if defined(TARGET_PPC64)
  55 void OPPROTO op_load_slb (void)
  56 {
  57     T0 = ppc_load_slb(env, T1);
  58     RETURN();
  59 }
  60
  61 void OPPROTO op_store_slb (void)
  62 {
  63     ppc_store_slb(env, T1, T0);
  64     RETURN();
  65 }
  66 #endif /* defined(TARGET_PPC64) */
  67
  68 void OPPROTO op_load_sdr1 (void)
  69 {
  70     T0 = env->sdr1;
  71     RETURN();
  72 }
  73
  74 void OPPROTO op_store_sdr1 (void)
  75 {
  76     do_store_sdr1(env, T0);
  77     RETURN();
  78 }
  79
  80 #if defined (TARGET_PPC64)
  81 void OPPROTO op_load_asr (void)
  82 {
  83     T0 = env->asr;
  84     RETURN();
  85 }
  86
  87 void OPPROTO op_store_asr (void)
  88 {
  89     ppc_store_asr(env, T0);
  90     RETURN();
  91 }
  92 #endif
  93
  94 void OPPROTO op_load_msr (void)
  95 {
  96     T0 = env->msr;
  97     RETURN();
  98 }
  99
 100 void OPPROTO op_store_msr (void)
 101 {
 102     do_store_msr();
 103     RETURN();
 104 }
 105
 106 #if defined (TARGET_PPC64)
 107 void OPPROTO op_store_msr_32 (void)
 108 {
 109     T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);
 110     do_store_msr();
 111     RETURN();
 112 }
 113 #endif
 114
 115 void OPPROTO op_update_riee (void)
 116 {
 117     /* We don't call do_store_msr here as we won't trigger
 118      * any special case nor change hflags
 119      */
 120     T0 &= (1 << MSR_RI) | (1 << MSR_EE);
 121     env->msr &= ~(1 << MSR_RI) | (1 << MSR_EE);
 122     env->msr |= T0;
 123     RETURN();
 124 }
 125 #endif
 126
 127 /* SPR */
 128 void OPPROTO op_load_spr (void)
 129 {
 130     T0 = env->spr[PARAM1];
 131     RETURN();
 132 }
 133
 134 void OPPROTO op_store_spr (void)
 135 {
 136     env->spr[PARAM1] = T0;
 137     RETURN();
 138 }
 139
 140 void OPPROTO op_load_dump_spr (void)
 141 {
 142     T0 = ppc_load_dump_spr(PARAM1);
 143     RETURN();
 144 }
 145
 146 void OPPROTO op_store_dump_spr (void)
 147 {
 148     ppc_store_dump_spr(PARAM1, T0);
 149     RETURN();
 150 }
 151
 152 void OPPROTO op_mask_spr (void)
 153 {
 154     env->spr[PARAM1] &= ~T0;
 155     RETURN();
 156 }
 157
 158 void OPPROTO op_load_tbl (void)
 159 {
 160     T0 = cpu_ppc_load_tbl(env);
 161     RETURN();
 162 }
 163
 164 void OPPROTO op_load_tbu (void)
 165 {
 166     T0 = cpu_ppc_load_tbu(env);
 167     RETURN();
 168 }
 169
 170 void OPPROTO op_load_atbl (void)
 171 {
 172     T0 = cpu_ppc_load_atbl(env);
 173     RETURN();
 174 }
 175
 176 void OPPROTO op_load_atbu (void)
 177 {
 178     T0 = cpu_ppc_load_atbu(env);
 179     RETURN();
 180 }
 181
 182 #if !defined(CONFIG_USER_ONLY)
 183 void OPPROTO op_store_tbl (void)
 184 {
 185     cpu_ppc_store_tbl(env, T0);
 186     RETURN();
 187 }
 188
 189 void OPPROTO op_store_tbu (void)
 190 {
 191     cpu_ppc_store_tbu(env, T0);
 192     RETURN();
 193 }
 194
 195 void OPPROTO op_store_atbl (void)
 196 {
 197     cpu_ppc_store_atbl(env, T0);
 198     RETURN();
 199 }
 200
 201 void OPPROTO op_store_atbu (void)
 202 {
 203     cpu_ppc_store_atbu(env, T0);
 204     RETURN();
 205 }
 206
 207 void OPPROTO op_load_decr (void)
 208 {
 209     T0 = cpu_ppc_load_decr(env);
 210     RETURN();
 211 }
 212
 213 void OPPROTO op_store_decr (void)
 214 {
 215     cpu_ppc_store_decr(env, T0);
 216     RETURN();
 217 }
 218
 219 void OPPROTO op_load_ibat (void)
 220 {
 221     T0 = env->IBAT[PARAM1][PARAM2];
 222     RETURN();
 223 }
 224
 225 void OPPROTO op_store_ibatu (void)
 226 {
 227     do_store_ibatu(env, PARAM1, T0);
 228     RETURN();
 229 }
 230
 231 void OPPROTO op_store_ibatl (void)
 232 {
 233 #if 1
 234     env->IBAT[1][PARAM1] = T0;
 235 #else
 236     do_store_ibatl(env, PARAM1, T0);
 237 #endif
 238     RETURN();
 239 }
 240
 241 void OPPROTO op_load_dbat (void)
 242 {
 243     T0 = env->DBAT[PARAM1][PARAM2];
 244     RETURN();
 245 }
 246
 247 void OPPROTO op_store_dbatu (void)
 248 {
 249     do_store_dbatu(env, PARAM1, T0);
 250     RETURN();
 251 }
 252
 253 void OPPROTO op_store_dbatl (void)
 254 {
 255 #if 1
 256     env->DBAT[1][PARAM1] = T0;
 257 #else
 258     do_store_dbatl(env, PARAM1, T0);
 259 #endif
 260     RETURN();
 261 }
 262 #endif /* !defined(CONFIG_USER_ONLY) */
 263
 264 /* FPSCR */
 265 #ifdef CONFIG_SOFTFLOAT
 266 void OPPROTO op_reset_fpstatus (void)
 267 {
 268     env->fp_status.float_exception_flags = 0;
 269     RETURN();
 270 }
 271 #endif
 272
 273 void OPPROTO op_compute_fprf (void)
 274 {
 275     do_compute_fprf(PARAM1);
 276     RETURN();
 277 }
 278
 279 #ifdef CONFIG_SOFTFLOAT
 280 void OPPROTO op_float_check_status (void)
 281 {
 282     do_float_check_status();
 283     RETURN();
 284 }
 285 #else
 286 void OPPROTO op_float_check_status (void)
 287 {
 288     if (env->exception_index == POWERPC_EXCP_PROGRAM &&
 289         (env->error_code & POWERPC_EXCP_FP)) {
 290         /* Differred floating-point exception after target FPR update */
 291         if (msr_fe0 != 0 || msr_fe1 != 0)
 292             do_raise_exception_err(env->exception_index, env->error_code);
 293     }
 294     RETURN();
 295 }
 296 #endif
 297
 298 void OPPROTO op_load_fpscr_FT0 (void)
 299 {
 300     /* The 32 MSB of the target fpr are undefined.
 301      * They'll be zero...
 302      */
 303     CPU_DoubleU u;
 304
 305     u.l.upper = 0;
 306     u.l.lower = env->fpscr;
 307     FT0 = u.d;
 308     RETURN();
 309 }
 310
 311 void OPPROTO op_fpscr_resetbit (void)
 312 {
 313     env->fpscr &= PARAM1;
 314     RETURN();
 315 }
 316
 317 void OPPROTO op_fpscr_setbit (void)
 318 {
 319     do_fpscr_setbit(PARAM1);
 320     RETURN();
 321 }
 322
 323 void OPPROTO op_store_fpscr (void)
 324 {
 325     do_store_fpscr(PARAM1);
 326     RETURN();
 327 }
 328
 329 /***                           Integer arithmetic                          ***/
 330 /* add */
 331 void OPPROTO op_check_addo (void)
 332 {
 333     int ov = (((uint32_t)T2 ^ (uint32_t)T1 ^ UINT32_MAX) &
 334               ((uint32_t)T2 ^ (uint32_t)T0)) >> 31;
 335     if (ov) {
 336         env->xer |= (1 << XER_OV) | (1 << XER_SO);
 337     } else {
 338         env->xer &= ~(1 << XER_OV);
 339     }
 340     RETURN();
 341 }
 342
 343 #if defined(TARGET_PPC64)
 344 void OPPROTO op_check_addo_64 (void)
 345 {
 346     int ov = (((uint64_t)T2 ^ (uint64_t)T1 ^ UINT64_MAX) &
 347               ((uint64_t)T2 ^ (uint64_t)T0)) >> 63;
 348     if (ov) {
 349         env->xer |= (1 << XER_OV) | (1 << XER_SO);
 350     } else {
 351         env->xer &= ~(1 << XER_OV);
 352     }
 353     RETURN();
 354 }
 355 #endif
 356
 357 /* add carrying */
 358 void OPPROTO op_check_addc (void)
 359 {
 360     if (likely((uint32_t)T0 >= (uint32_t)T2)) {
 361         env->xer &= ~(1 << XER_CA);
 362     } else {
 363         env->xer |= (1 << XER_CA);
 364     }
 365     RETURN();
 366 }
 367
 368 #if defined(TARGET_PPC64)
 369 void OPPROTO op_check_addc_64 (void)
 370 {
 371     if (likely((uint64_t)T0 >= (uint64_t)T2)) {
 372         env->xer &= ~(1 << XER_CA);
 373     } else {
 374         env->xer |= (1 << XER_CA);
 375     }
 376     RETURN();
 377 }
 378 #endif
 379
 380 /* add extended */
 381 void OPPROTO op_adde (void)
 382 {
 383     do_adde();
 384     RETURN();
 385 }
 386
 387 #if defined(TARGET_PPC64)
 388 void OPPROTO op_adde_64 (void)
 389 {
 390     do_adde_64();
 391     RETURN();
 392 }
 393 #endif
 394
 395 /* add to minus one extended */
 396 void OPPROTO op_add_me (void)
 397 {
 398     T0 += xer_ca + (-1);
 399     if (likely((uint32_t)T1 != 0))
 400         env->xer |= (1 << XER_CA);
 401     RETURN();
 402 }
 403
 404 #if defined(TARGET_PPC64)
 405 void OPPROTO op_add_me_64 (void)
 406 {
 407     T0 += xer_ca + (-1);
 408     if (likely((uint64_t)T1 != 0))
 409         env->xer |= (1 << XER_CA);
 410     RETURN();
 411 }
 412 #endif
 413
 414 void OPPROTO op_addmeo (void)
 415 {
 416     do_addmeo();
 417     RETURN();
 418 }
 419
 420 void OPPROTO op_addmeo_64 (void)
 421 {
 422     do_addmeo();
 423     RETURN();
 424 }
 425
 426 /* add to zero extended */
 427 void OPPROTO op_add_ze (void)
 428 {
 429     T0 += xer_ca;
 430     RETURN();
 431 }
 432
 433 /* divide word */
 434 void OPPROTO op_divw (void)
 435 {
 436     if (unlikely(((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
 437                  (int32_t)T1 == 0)) {
 438         T0 = (int32_t)(UINT32_MAX * ((uint32_t)T0 >> 31));
 439     } else {
 440         T0 = (int32_t)T0 / (int32_t)T1;
 441     }
 442     RETURN();
 443 }
 444
 445 #if defined(TARGET_PPC64)
 446 void OPPROTO op_divd (void)
 447 {
 448     if (unlikely(((int64_t)T0 == INT64_MIN && (int64_t)T1 == (int64_t)-1LL) ||
 449                  (int64_t)T1 == 0)) {
 450         T0 = (int64_t)(UINT64_MAX * ((uint64_t)T0 >> 63));
 451     } else {
 452         T0 = (int64_t)T0 / (int64_t)T1;
 453     }
 454     RETURN();
 455 }
 456 #endif
 457
 458 void OPPROTO op_divwo (void)
 459 {
 460     do_divwo();
 461     RETURN();
 462 }
 463
 464 #if defined(TARGET_PPC64)
 465 void OPPROTO op_divdo (void)
 466 {
 467     do_divdo();
 468     RETURN();
 469 }
 470 #endif
 471
 472 /* divide word unsigned */
 473 void OPPROTO op_divwu (void)
 474 {
 475     if (unlikely(T1 == 0)) {
 476         T0 = 0;
 477     } else {
 478         T0 = (uint32_t)T0 / (uint32_t)T1;
 479     }
 480     RETURN();
 481 }
 482
 483 #if defined(TARGET_PPC64)
 484 void OPPROTO op_divdu (void)
 485 {
 486     if (unlikely(T1 == 0)) {
 487         T0 = 0;
 488     } else {
 489         T0 /= T1;
 490     }
 491     RETURN();
 492 }
 493 #endif
 494
 495 void OPPROTO op_divwuo (void)
 496 {
 497     do_divwuo();
 498     RETURN();
 499 }
 500
 501 #if defined(TARGET_PPC64)
 502 void OPPROTO op_divduo (void)
 503 {
 504     do_divduo();
 505     RETURN();
 506 }
 507 #endif
 508
 509 /* multiply high word */
 510 void OPPROTO op_mulhw (void)
 511 {
 512     T0 = ((int64_t)((int32_t)T0) * (int64_t)((int32_t)T1)) >> 32;
 513     RETURN();
 514 }
 515
 516 #if defined(TARGET_PPC64)
 517 void OPPROTO op_mulhd (void)
 518 {
 519     uint64_t tl, th;
 520
 521     muls64(&tl, &th, T0, T1);
 522     T0 = th;
 523     RETURN();
 524 }
 525 #endif
 526
 527 /* multiply high word unsigned */
 528 void OPPROTO op_mulhwu (void)
 529 {
 530     T0 = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1) >> 32;
 531     RETURN();
 532 }
 533
 534 #if defined(TARGET_PPC64)
 535 void OPPROTO op_mulhdu (void)
 536 {
 537     uint64_t tl, th;
 538
 539     mulu64(&tl, &th, T0, T1);
 540     T0 = th;
 541     RETURN();
 542 }
 543 #endif
 544
 545 /* multiply low immediate */
 546 void OPPROTO op_mulli (void)
 547 {
 548     T0 = ((int32_t)T0 * (int32_t)PARAM1);
 549     RETURN();
 550 }
 551
 552 /* multiply low word */
 553 void OPPROTO op_mullw (void)
 554 {
 555 #if defined(TARGET_PPC64)
 556     T0 = (int64_t)(int32_t)T0 * (int64_t)(int32_t)T1;
 557 #else
 558     T0 = (int32_t)(T0 * T1);
 559 #endif
 560     RETURN();
 561 }
 562
 563 #if defined(TARGET_PPC64)
 564 void OPPROTO op_mulld (void)
 565 {
 566     T0 *= T1;
 567     RETURN();
 568 }
 569 #endif
 570
 571 void OPPROTO op_mullwo (void)
 572 {
 573     do_mullwo();
 574     RETURN();
 575 }
 576
 577 #if defined(TARGET_PPC64)
 578 void OPPROTO op_mulldo (void)
 579 {
 580     do_mulldo();
 581     RETURN();
 582 }
 583 #endif
 584
 585 /* negate */
 586 void OPPROTO op_neg (void)
 587 {
 588     if (likely(T0 != INT32_MIN)) {
 589         T0 = -(int32_t)T0;
 590     }
 591     RETURN();
 592 }
 593
 594 #if defined(TARGET_PPC64)
 595 void OPPROTO op_neg_64 (void)
 596 {
 597     if (likely(T0 != INT64_MIN)) {
 598         T0 = -(int64_t)T0;
 599     }
 600     RETURN();
 601 }
 602 #endif
 603
 604 void OPPROTO op_nego (void)
 605 {
 606     do_nego();
 607     RETURN();
 608 }
 609
 610 #if defined(TARGET_PPC64)
 611 void OPPROTO op_nego_64 (void)
 612 {
 613     do_nego_64();
 614     RETURN();
 615 }
 616 #endif
 617
 618 /* subtract from carrying */
 619 void OPPROTO op_check_subfc (void)
 620 {
 621     if (likely((uint32_t)T0 > (uint32_t)T1)) {
 622         env->xer &= ~(1 << XER_CA);
 623     } else {
 624         env->xer |= (1 << XER_CA);
 625     }
 626     RETURN();
 627 }
 628
 629 #if defined(TARGET_PPC64)
 630 void OPPROTO op_check_subfc_64 (void)
 631 {
 632     if (likely((uint64_t)T0 > (uint64_t)T1)) {
 633         env->xer &= ~(1 << XER_CA);
 634     } else {
 635         env->xer |= (1 << XER_CA);
 636     }
 637     RETURN();
 638 }
 639 #endif
 640
 641 /* subtract from extended */
 642 void OPPROTO op_subfe (void)
 643 {
 644     do_subfe();
 645     RETURN();
 646 }
 647
 648 #if defined(TARGET_PPC64)
 649 void OPPROTO op_subfe_64 (void)
 650 {
 651     do_subfe_64();
 652     RETURN();
 653 }
 654 #endif
 655
 656 /* subtract from immediate carrying */
 657 void OPPROTO op_subfic (void)
 658 {
 659     T0 = (int32_t)PARAM1 + ~T0 + 1;
 660     if ((uint32_t)T0 <= (uint32_t)PARAM1) {
 661         env->xer |= (1 << XER_CA);
 662     } else {
 663         env->xer &= ~(1 << XER_CA);
 664     }
 665     RETURN();
 666 }
 667
 668 #if defined(TARGET_PPC64)
 669 void OPPROTO op_subfic_64 (void)
 670 {
 671     T0 = (int64_t)PARAM1 + ~T0 + 1;
 672     if ((uint64_t)T0 <= (uint64_t)PARAM1) {
 673         env->xer |= (1 << XER_CA);
 674     } else {
 675         env->xer &= ~(1 << XER_CA);
 676     }
 677     RETURN();
 678 }
 679 #endif
 680
 681 /* subtract from minus one extended */
 682 void OPPROTO op_subfme (void)
 683 {
 684     T0 = ~T0 + xer_ca - 1;
 685     if (likely((uint32_t)T0 != UINT32_MAX))
 686         env->xer |= (1 << XER_CA);
 687     RETURN();
 688 }
 689
 690 #if defined(TARGET_PPC64)
 691 void OPPROTO op_subfme_64 (void)
 692 {
 693     T0 = ~T0 + xer_ca - 1;
 694     if (likely((uint64_t)T0 != UINT64_MAX))
 695         env->xer |= (1 << XER_CA);
 696     RETURN();
 697 }
 698 #endif
 699
 700 void OPPROTO op_subfmeo (void)
 701 {
 702     do_subfmeo();
 703     RETURN();
 704 }
 705
 706 #if defined(TARGET_PPC64)
 707 void OPPROTO op_subfmeo_64 (void)
 708 {
 709     do_subfmeo_64();
 710     RETURN();
 711 }
 712 #endif
 713
 714 /* subtract from zero extended */
 715 void OPPROTO op_subfze (void)
 716 {
 717     T1 = ~T0;
 718     T0 = T1 + xer_ca;
 719     if ((uint32_t)T0 < (uint32_t)T1) {
 720         env->xer |= (1 << XER_CA);
 721     } else {
 722         env->xer &= ~(1 << XER_CA);
 723     }
 724     RETURN();
 725 }
 726
 727 #if defined(TARGET_PPC64)
 728 void OPPROTO op_subfze_64 (void)
 729 {
 730     T1 = ~T0;
 731     T0 = T1 + xer_ca;
 732     if ((uint64_t)T0 < (uint64_t)T1) {
 733         env->xer |= (1 << XER_CA);
 734     } else {
 735         env->xer &= ~(1 << XER_CA);
 736     }
 737     RETURN();
 738 }
 739 #endif
 740
 741 void OPPROTO op_subfzeo (void)
 742 {
 743     do_subfzeo();
 744     RETURN();
 745 }
 746
 747 #if defined(TARGET_PPC64)
 748 void OPPROTO op_subfzeo_64 (void)
 749 {
 750     do_subfzeo_64();
 751     RETURN();
 752 }
 753 #endif
 754
 755 /***                             Integer shift                             ***/
 756 void OPPROTO op_srli_T1 (void)
 757 {
 758     T1 = (uint32_t)T1 >> PARAM1;
 759     RETURN();
 760 }
 761
 762 /***                       Floating-Point arithmetic                       ***/
 763 /* fadd - fadd. */
 764 void OPPROTO op_fadd (void)
 765 {
 766 #if USE_PRECISE_EMULATION
 767     do_fadd();
 768 #else
 769     FT0 = float64_add(FT0, FT1, &env->fp_status);
 770 #endif
 771     RETURN();
 772 }
 773
 774 /* fsub - fsub. */
 775 void OPPROTO op_fsub (void)
 776 {
 777 #if USE_PRECISE_EMULATION
 778     do_fsub();
 779 #else
 780     FT0 = float64_sub(FT0, FT1, &env->fp_status);
 781 #endif
 782     RETURN();
 783 }
 784
 785 /* fmul - fmul. */
 786 void OPPROTO op_fmul (void)
 787 {
 788 #if USE_PRECISE_EMULATION
 789     do_fmul();
 790 #else
 791     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 792 #endif
 793     RETURN();
 794 }
 795
 796 /* fdiv - fdiv. */
 797 void OPPROTO op_fdiv (void)
 798 {
 799 #if USE_PRECISE_EMULATION
 800     do_fdiv();
 801 #else
 802     FT0 = float64_div(FT0, FT1, &env->fp_status);
 803 #endif
 804     RETURN();
 805 }
 806
 807 /* fsqrt - fsqrt. */
 808 void OPPROTO op_fsqrt (void)
 809 {
 810     do_fsqrt();
 811     RETURN();
 812 }
 813
 814 /* fre - fre. */
 815 void OPPROTO op_fre (void)
 816 {
 817     do_fre();
 818     RETURN();
 819 }
 820
 821 /* fres - fres. */
 822 void OPPROTO op_fres (void)
 823 {
 824     do_fres();
 825     RETURN();
 826 }
 827
 828 /* frsqrte  - frsqrte. */
 829 void OPPROTO op_frsqrte (void)
 830 {
 831     do_frsqrte();
 832     RETURN();
 833 }
 834
 835 /* fsel - fsel. */
 836 void OPPROTO op_fsel (void)
 837 {
 838     do_fsel();
 839     RETURN();
 840 }
 841
 842 /***                     Floating-Point multiply-and-add                   ***/
 843 /* fmadd - fmadd. */
 844 void OPPROTO op_fmadd (void)
 845 {
 846 #if USE_PRECISE_EMULATION
 847     do_fmadd();
 848 #else
 849     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 850     FT0 = float64_add(FT0, FT2, &env->fp_status);
 851 #endif
 852     RETURN();
 853 }
 854
 855 /* fmsub - fmsub. */
 856 void OPPROTO op_fmsub (void)
 857 {
 858 #if USE_PRECISE_EMULATION
 859     do_fmsub();
 860 #else
 861     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 862     FT0 = float64_sub(FT0, FT2, &env->fp_status);
 863 #endif
 864     RETURN();
 865 }
 866
 867 /* fnmadd - fnmadd. - fnmadds - fnmadds. */
 868 void OPPROTO op_fnmadd (void)
 869 {
 870     do_fnmadd();
 871     RETURN();
 872 }
 873
 874 /* fnmsub - fnmsub. */
 875 void OPPROTO op_fnmsub (void)
 876 {
 877     do_fnmsub();
 878     RETURN();
 879 }
 880
 881 /***                     Floating-Point round & convert                    ***/
 882 /* frsp - frsp. */
 883 void OPPROTO op_frsp (void)
 884 {
 885 #if USE_PRECISE_EMULATION
 886     do_frsp();
 887 #else
 888     FT0 = float64_to_float32(FT0, &env->fp_status);
 889 #endif
 890     RETURN();
 891 }
 892
 893 /* fctiw - fctiw. */
 894 void OPPROTO op_fctiw (void)
 895 {
 896     do_fctiw();
 897     RETURN();
 898 }
 899
 900 /* fctiwz - fctiwz. */
 901 void OPPROTO op_fctiwz (void)
 902 {
 903     do_fctiwz();
 904     RETURN();
 905 }
 906
 907 #if defined(TARGET_PPC64)
 908 /* fcfid - fcfid. */
 909 void OPPROTO op_fcfid (void)
 910 {
 911     do_fcfid();
 912     RETURN();
 913 }
 914
 915 /* fctid - fctid. */
 916 void OPPROTO op_fctid (void)
 917 {
 918     do_fctid();
 919     RETURN();
 920 }
 921
 922 /* fctidz - fctidz. */
 923 void OPPROTO op_fctidz (void)
 924 {
 925     do_fctidz();
 926     RETURN();
 927 }
 928 #endif
 929
 930 void OPPROTO op_frin (void)
 931 {
 932     do_frin();
 933     RETURN();
 934 }
 935
 936 void OPPROTO op_friz (void)
 937 {
 938     do_friz();
 939     RETURN();
 940 }
 941
 942 void OPPROTO op_frip (void)
 943 {
 944     do_frip();
 945     RETURN();
 946 }
 947
 948 void OPPROTO op_frim (void)
 949 {
 950     do_frim();
 951     RETURN();
 952 }
 953
 954 /***                         Floating-point move                           ***/
 955 /* fabs */
 956 void OPPROTO op_fabs (void)
 957 {
 958     FT0 = float64_abs(FT0);
 959     RETURN();
 960 }
 961
 962 /* fnabs */
 963 void OPPROTO op_fnabs (void)
 964 {
 965     FT0 = float64_abs(FT0);
 966     FT0 = float64_chs(FT0);
 967     RETURN();
 968 }
 969
 970 /* fneg */
 971 void OPPROTO op_fneg (void)
 972 {
 973     FT0 = float64_chs(FT0);
 974     RETURN();
 975 }
 976
 977 /* Load and store */
 978 #define MEMSUFFIX _raw
 979 #include "op_helper.h"
 980 #include "op_mem.h"
 981 #if !defined(CONFIG_USER_ONLY)
 982 #define MEMSUFFIX _user
 983 #include "op_helper.h"
 984 #include "op_mem.h"
 985 #define MEMSUFFIX _kernel
 986 #include "op_helper.h"
 987 #include "op_mem.h"
 988 #define MEMSUFFIX _hypv
 989 #include "op_helper.h"
 990 #include "op_mem.h"
 991 #endif
 992
 993 /* Special op to check and maybe clear reservation */
 994 void OPPROTO op_check_reservation (void)
 995 {
 996     if ((uint32_t)env->reserve == (uint32_t)(T0 & ~0x00000003))
 997         env->reserve = (target_ulong)-1ULL;
 998     RETURN();
 999 }
1000
1001 #if defined(TARGET_PPC64)
1002 void OPPROTO op_check_reservation_64 (void)
1003 {
1004     if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003))
1005         env->reserve = (target_ulong)-1ULL;
1006     RETURN();
1007 }
1008 #endif
1009
1010 void OPPROTO op_wait (void)
1011 {
1012     env->halted = 1;
1013     RETURN();
1014 }
1015
1016 /* Return from interrupt */
1017 #if !defined(CONFIG_USER_ONLY)
1018 void OPPROTO op_rfi (void)
1019 {
1020     do_rfi();
1021     RETURN();
1022 }
1023
1024 #if defined(TARGET_PPC64)
1025 void OPPROTO op_rfid (void)
1026 {
1027     do_rfid();
1028     RETURN();
1029 }
1030
1031 void OPPROTO op_hrfid (void)
1032 {
1033     do_hrfid();
1034     RETURN();
1035 }
1036 #endif
1037
1038 /* Exception vectors */
1039 void OPPROTO op_store_excp_prefix (void)
1040 {
1041     T0 &= env->ivpr_mask;
1042     env->excp_prefix = T0;
1043     RETURN();
1044 }
1045
1046 void OPPROTO op_store_excp_vector (void)
1047 {
1048     T0 &= env->ivor_mask;
1049     env->excp_vectors[PARAM1] = T0;
1050     RETURN();
1051 }
1052 #endif
1053
1054 /* Trap word */
1055 void OPPROTO op_tw (void)
1056 {
1057     do_tw(PARAM1);
1058     RETURN();
1059 }
1060
1061 #if defined(TARGET_PPC64)
1062 void OPPROTO op_td (void)
1063 {
1064     do_td(PARAM1);
1065     RETURN();
1066 }
1067 #endif
1068
1069 #if !defined(CONFIG_USER_ONLY)
1070 /* tlbia */
1071 void OPPROTO op_tlbia (void)
1072 {
1073     ppc_tlb_invalidate_all(env);
1074     RETURN();
1075 }
1076
1077 /* tlbie */
1078 void OPPROTO op_tlbie (void)
1079 {
1080     ppc_tlb_invalidate_one(env, (uint32_t)T0);
1081     RETURN();
1082 }
1083
1084 #if defined(TARGET_PPC64)
1085 void OPPROTO op_tlbie_64 (void)
1086 {
1087     ppc_tlb_invalidate_one(env, T0);
1088     RETURN();
1089 }
1090 #endif
1091
1092 #if defined(TARGET_PPC64)
1093 void OPPROTO op_slbia (void)
1094 {
1095     ppc_slb_invalidate_all(env);
1096     RETURN();
1097 }
1098
1099 void OPPROTO op_slbie (void)
1100 {
1101     ppc_slb_invalidate_one(env, (uint32_t)T0);
1102     RETURN();
1103 }
1104
1105 void OPPROTO op_slbie_64 (void)
1106 {
1107     ppc_slb_invalidate_one(env, T0);
1108     RETURN();
1109 }
1110 #endif
1111 #endif
1112
1113 #if !defined(CONFIG_USER_ONLY)
1114 /* PowerPC 602/603/755 software TLB load instructions */
1115 void OPPROTO op_6xx_tlbld (void)
1116 {
1117     do_load_6xx_tlb(0);
1118     RETURN();
1119 }
1120
1121 void OPPROTO op_6xx_tlbli (void)
1122 {
1123     do_load_6xx_tlb(1);
1124     RETURN();
1125 }
1126
1127 /* PowerPC 74xx software TLB load instructions */
1128 void OPPROTO op_74xx_tlbld (void)
1129 {
1130     do_load_74xx_tlb(0);
1131     RETURN();
1132 }
1133
1134 void OPPROTO op_74xx_tlbli (void)
1135 {
1136     do_load_74xx_tlb(1);
1137     RETURN();
1138 }
1139 #endif
1140
1141 /* 601 specific */
1142 void OPPROTO op_load_601_rtcl (void)
1143 {
1144     T0 = cpu_ppc601_load_rtcl(env);
1145     RETURN();
1146 }
1147
1148 void OPPROTO op_load_601_rtcu (void)
1149 {
1150     T0 = cpu_ppc601_load_rtcu(env);
1151     RETURN();
1152 }
1153
1154 #if !defined(CONFIG_USER_ONLY)
1155 void OPPROTO op_store_601_rtcl (void)
1156 {
1157     cpu_ppc601_store_rtcl(env, T0);
1158     RETURN();
1159 }
1160
1161 void OPPROTO op_store_601_rtcu (void)
1162 {
1163     cpu_ppc601_store_rtcu(env, T0);
1164     RETURN();
1165 }
1166
1167 void OPPROTO op_store_hid0_601 (void)
1168 {
1169     do_store_hid0_601();
1170     RETURN();
1171 }
1172
1173 void OPPROTO op_load_601_bat (void)
1174 {
1175     T0 = env->IBAT[PARAM1][PARAM2];
1176     RETURN();
1177 }
1178
1179 void OPPROTO op_store_601_batl (void)
1180 {
1181     do_store_ibatl_601(env, PARAM1, T0);
1182     RETURN();
1183 }
1184
1185 void OPPROTO op_store_601_batu (void)
1186 {
1187     do_store_ibatu_601(env, PARAM1, T0);
1188     RETURN();
1189 }
1190 #endif /* !defined(CONFIG_USER_ONLY) */
1191
1192 /* PowerPC 601 specific instructions (POWER bridge) */
1193 /* XXX: those micro-ops need tests ! */
1194 void OPPROTO op_POWER_abs (void)
1195 {
1196     if ((int32_t)T0 == INT32_MIN)
1197         T0 = INT32_MAX;
1198     else if ((int32_t)T0 < 0)
1199         T0 = -T0;
1200     RETURN();
1201 }
1202
1203 void OPPROTO op_POWER_abso (void)
1204 {
1205     do_POWER_abso();
1206     RETURN();
1207 }
1208
1209 void OPPROTO op_POWER_clcs (void)
1210 {
1211     do_POWER_clcs();
1212     RETURN();
1213 }
1214
1215 void OPPROTO op_POWER_div (void)
1216 {
1217     do_POWER_div();
1218     RETURN();
1219 }
1220
1221 void OPPROTO op_POWER_divo (void)
1222 {
1223     do_POWER_divo();
1224     RETURN();
1225 }
1226
1227 void OPPROTO op_POWER_divs (void)
1228 {
1229     do_POWER_divs();
1230     RETURN();
1231 }
1232
1233 void OPPROTO op_POWER_divso (void)
1234 {
1235     do_POWER_divso();
1236     RETURN();
1237 }
1238
1239 void OPPROTO op_POWER_doz (void)
1240 {
1241     if ((int32_t)T1 > (int32_t)T0)
1242         T0 = T1 - T0;
1243     else
1244         T0 = 0;
1245     RETURN();
1246 }
1247
1248 void OPPROTO op_POWER_dozo (void)
1249 {
1250     do_POWER_dozo();
1251     RETURN();
1252 }
1253
1254 void OPPROTO op_load_xer_cmp (void)
1255 {
1256     T2 = xer_cmp;
1257     RETURN();
1258 }
1259
1260 void OPPROTO op_POWER_maskg (void)
1261 {
1262     do_POWER_maskg();
1263     RETURN();
1264 }
1265
1266 void OPPROTO op_POWER_maskir (void)
1267 {
1268     T0 = (T0 & ~T2) | (T1 & T2);
1269     RETURN();
1270 }
1271
1272 void OPPROTO op_POWER_mul (void)
1273 {
1274     uint64_t tmp;
1275
1276     tmp = (uint64_t)T0 * (uint64_t)T1;
1277     env->spr[SPR_MQ] = tmp >> 32;
1278     T0 = tmp;
1279     RETURN();
1280 }
1281
1282 void OPPROTO op_POWER_mulo (void)
1283 {
1284     do_POWER_mulo();
1285     RETURN();
1286 }
1287
1288 void OPPROTO op_POWER_nabs (void)
1289 {
1290     if (T0 > 0)
1291         T0 = -T0;
1292     RETURN();
1293 }
1294
1295 void OPPROTO op_POWER_nabso (void)
1296 {
1297     /* nabs never overflows */
1298     if (T0 > 0)
1299         T0 = -T0;
1300     env->xer &= ~(1 << XER_OV);
1301     RETURN();
1302 }
1303
1304 /* XXX: factorise POWER rotates... */
1305 void OPPROTO op_POWER_rlmi (void)
1306 {
1307     T0 = rotl32(T0, T2) & PARAM1;
1308     T0 |= T1 & (uint32_t)PARAM2;
1309     RETURN();
1310 }
1311
1312 void OPPROTO op_POWER_rrib (void)
1313 {
1314     T2 &= 0x1FUL;
1315     T0 = rotl32(T0 & INT32_MIN, T2);
1316     T0 |= T1 & ~rotl32(INT32_MIN, T2);
1317     RETURN();
1318 }
1319
1320 void OPPROTO op_POWER_sle (void)
1321 {
1322     T1 &= 0x1FUL;
1323     env->spr[SPR_MQ] = rotl32(T0, T1);
1324     T0 = T0 << T1;
1325     RETURN();
1326 }
1327
1328 void OPPROTO op_POWER_sleq (void)
1329 {
1330     uint32_t tmp = env->spr[SPR_MQ];
1331
1332     T1 &= 0x1FUL;
1333     env->spr[SPR_MQ] = rotl32(T0, T1);
1334     T0 = T0 << T1;
1335     T0 |= tmp >> (32 - T1);
1336     RETURN();
1337 }
1338
1339 void OPPROTO op_POWER_sllq (void)
1340 {
1341     uint32_t msk = UINT32_MAX;
1342
1343     msk = msk << (T1 & 0x1FUL);
1344     if (T1 & 0x20UL)
1345         msk = ~msk;
1346     T1 &= 0x1FUL;
1347     T0 = (T0 << T1) & msk;
1348     T0 |= env->spr[SPR_MQ] & ~msk;
1349     RETURN();
1350 }
1351
1352 void OPPROTO op_POWER_slq (void)
1353 {
1354     uint32_t msk = UINT32_MAX, tmp;
1355
1356     msk = msk << (T1 & 0x1FUL);
1357     if (T1 & 0x20UL)
1358         msk = ~msk;
1359     T1 &= 0x1FUL;
1360     tmp = rotl32(T0, T1);
1361     T0 = tmp & msk;
1362     env->spr[SPR_MQ] = tmp;
1363     RETURN();
1364 }
1365
1366 void OPPROTO op_POWER_sraq (void)
1367 {
1368     env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL));
1369     if (T1 & 0x20UL)
1370         T0 = UINT32_MAX;
1371     else
1372         T0 = (int32_t)T0 >> T1;
1373     RETURN();
1374 }
1375
1376 void OPPROTO op_POWER_sre (void)
1377 {
1378     T1 &= 0x1FUL;
1379     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
1380     T0 = (int32_t)T0 >> T1;
1381     RETURN();
1382 }
1383
1384 void OPPROTO op_POWER_srea (void)
1385 {
1386     T1 &= 0x1FUL;
1387     env->spr[SPR_MQ] = T0 >> T1;
1388     T0 = (int32_t)T0 >> T1;
1389     RETURN();
1390 }
1391
1392 void OPPROTO op_POWER_sreq (void)
1393 {
1394     uint32_t tmp;
1395     int32_t msk;
1396
1397     T1 &= 0x1FUL;
1398     msk = INT32_MIN >> T1;
1399     tmp = env->spr[SPR_MQ];
1400     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
1401     T0 = T0 >> T1;
1402     T0 |= tmp & msk;
1403     RETURN();
1404 }
1405
1406 void OPPROTO op_POWER_srlq (void)
1407 {
1408     uint32_t tmp;
1409     int32_t msk;
1410
1411     msk = INT32_MIN >> (T1 & 0x1FUL);
1412     if (T1 & 0x20UL)
1413         msk = ~msk;
1414     T1 &= 0x1FUL;
1415     tmp = env->spr[SPR_MQ];
1416     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
1417     T0 = T0 >> T1;
1418     T0 &= msk;
1419     T0 |= tmp & ~msk;
1420     RETURN();
1421 }
1422
1423 void OPPROTO op_POWER_srq (void)
1424 {
1425     T1 &= 0x1FUL;
1426     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
1427     T0 = T0 >> T1;
1428     RETURN();
1429 }
1430
1431 /* POWER instructions not implemented in PowerPC 601 */
1432 #if !defined(CONFIG_USER_ONLY)
1433 void OPPROTO op_POWER_mfsri (void)
1434 {
1435     T1 = T0 >> 28;
1436     T0 = env->sr[T1];
1437     RETURN();
1438 }
1439
1440 void OPPROTO op_POWER_rac (void)
1441 {
1442     do_POWER_rac();
1443     RETURN();
1444 }
1445
1446 void OPPROTO op_POWER_rfsvc (void)
1447 {
1448     do_POWER_rfsvc();
1449     RETURN();
1450 }
1451 #endif
1452
1453 /* PowerPC 602 specific instruction */
1454 #if !defined(CONFIG_USER_ONLY)
1455 void OPPROTO op_602_mfrom (void)
1456 {
1457     do_op_602_mfrom();
1458     RETURN();
1459 }
1460 #endif
1461
1462 /* PowerPC 4xx specific micro-ops */
1463 void OPPROTO op_405_add_T0_T2 (void)
1464 {
1465     T0 = (int32_t)T0 + (int32_t)T2;
1466     RETURN();
1467 }
1468
1469 void OPPROTO op_405_mulchw (void)
1470 {
1471     T0 = ((int16_t)T0) * ((int16_t)(T1 >> 16));
1472     RETURN();
1473 }
1474
1475 void OPPROTO op_405_mulchwu (void)
1476 {
1477     T0 = ((uint16_t)T0) * ((uint16_t)(T1 >> 16));
1478     RETURN();
1479 }
1480
1481 void OPPROTO op_405_mulhhw (void)
1482 {
1483     T0 = ((int16_t)(T0 >> 16)) * ((int16_t)(T1 >> 16));
1484     RETURN();
1485 }
1486
1487 void OPPROTO op_405_mulhhwu (void)
1488 {
1489     T0 = ((uint16_t)(T0 >> 16)) * ((uint16_t)(T1 >> 16));
1490     RETURN();
1491 }
1492
1493 void OPPROTO op_405_mullhw (void)
1494 {
1495     T0 = ((int16_t)T0) * ((int16_t)T1);
1496     RETURN();
1497 }
1498
1499 void OPPROTO op_405_mullhwu (void)
1500 {
1501     T0 = ((uint16_t)T0) * ((uint16_t)T1);
1502     RETURN();
1503 }
1504
1505 void OPPROTO op_405_check_sat (void)
1506 {
1507     do_405_check_sat();
1508     RETURN();
1509 }
1510
1511 void OPPROTO op_405_check_ovu (void)
1512 {
1513     if (likely(T0 >= T2)) {
1514         env->xer &= ~(1 << XER_OV);
1515     } else {
1516         env->xer |= (1 << XER_OV) | (1 << XER_SO);
1517     }
1518     RETURN();
1519 }
1520
1521 void OPPROTO op_405_check_satu (void)
1522 {
1523     if (unlikely(T0 < T2)) {
1524         /* Saturate result */
1525         T0 = UINT32_MAX;
1526     }
1527     RETURN();
1528 }
1529
1530 void OPPROTO op_load_dcr (void)
1531 {
1532     do_load_dcr();
1533     RETURN();
1534 }
1535
1536 void OPPROTO op_store_dcr (void)
1537 {
1538     do_store_dcr();
1539     RETURN();
1540 }
1541
1542 #if !defined(CONFIG_USER_ONLY)
1543 /* Return from critical interrupt :
1544  * same as rfi, except nip & MSR are loaded from SRR2/3 instead of SRR0/1
1545  */
1546 void OPPROTO op_40x_rfci (void)
1547 {
1548     do_40x_rfci();
1549     RETURN();
1550 }
1551
1552 void OPPROTO op_rfci (void)
1553 {
1554     do_rfci();
1555     RETURN();
1556 }
1557
1558 void OPPROTO op_rfdi (void)
1559 {
1560     do_rfdi();
1561     RETURN();
1562 }
1563
1564 void OPPROTO op_rfmci (void)
1565 {
1566     do_rfmci();
1567     RETURN();
1568 }
1569
1570 void OPPROTO op_wrte (void)
1571 {
1572     /* We don't call do_store_msr here as we won't trigger
1573      * any special case nor change hflags
1574      */
1575     T0 &= 1 << MSR_EE;
1576     env->msr &= ~(1 << MSR_EE);
1577     env->msr |= T0;
1578     RETURN();
1579 }
1580
1581 void OPPROTO op_440_tlbre (void)
1582 {
1583     do_440_tlbre(PARAM1);
1584     RETURN();
1585 }
1586
1587 void OPPROTO op_440_tlbsx (void)
1588 {
1589     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_440_MMUCR] & 0xFF);
1590     RETURN();
1591 }
1592
1593 void OPPROTO op_4xx_tlbsx_check (void)
1594 {
1595     int tmp;
1596
1597     tmp = xer_so;
1598     if ((int)T0 != -1)
1599         tmp |= 0x02;
1600     env->crf[0] = tmp;
1601     RETURN();
1602 }
1603
1604 void OPPROTO op_440_tlbwe (void)
1605 {
1606     do_440_tlbwe(PARAM1);
1607     RETURN();
1608 }
1609
1610 void OPPROTO op_4xx_tlbre_lo (void)
1611 {
1612     do_4xx_tlbre_lo();
1613     RETURN();
1614 }
1615
1616 void OPPROTO op_4xx_tlbre_hi (void)
1617 {
1618     do_4xx_tlbre_hi();
1619     RETURN();
1620 }
1621
1622 void OPPROTO op_4xx_tlbsx (void)
1623 {
1624     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_40x_PID]);
1625     RETURN();
1626 }
1627
1628 void OPPROTO op_4xx_tlbwe_lo (void)
1629 {
1630     do_4xx_tlbwe_lo();
1631     RETURN();
1632 }
1633
1634 void OPPROTO op_4xx_tlbwe_hi (void)
1635 {
1636     do_4xx_tlbwe_hi();
1637     RETURN();
1638 }
1639 #endif
1640
1641 /* SPR micro-ops */
1642 /* 440 specific */
1643 void OPPROTO op_440_dlmzb (void)
1644 {
1645     do_440_dlmzb();
1646     RETURN();
1647 }
1648
1649 void OPPROTO op_440_dlmzb_update_Rc (void)
1650 {
1651     if (T0 == 8)
1652         T0 = 0x2;
1653     else if (T0 < 4)
1654         T0 = 0x4;
1655     else
1656         T0 = 0x8;
1657     RETURN();
1658 }
1659
1660 #if !defined(CONFIG_USER_ONLY)
1661 void OPPROTO op_store_pir (void)
1662 {
1663     env->spr[SPR_PIR] = T0 & 0x0000000FUL;
1664     RETURN();
1665 }
1666
1667 void OPPROTO op_load_403_pb (void)
1668 {
1669     do_load_403_pb(PARAM1);
1670     RETURN();
1671 }
1672
1673 void OPPROTO op_store_403_pb (void)
1674 {
1675     do_store_403_pb(PARAM1);
1676     RETURN();
1677 }
1678
1679 void OPPROTO op_load_40x_pit (void)
1680 {
1681     T0 = load_40x_pit(env);
1682     RETURN();
1683 }
1684
1685 void OPPROTO op_store_40x_pit (void)
1686 {
1687     store_40x_pit(env, T0);
1688     RETURN();
1689 }
1690
1691 void OPPROTO op_store_40x_dbcr0 (void)
1692 {
1693     store_40x_dbcr0(env, T0);
1694     RETURN();
1695 }
1696
1697 void OPPROTO op_store_40x_sler (void)
1698 {
1699     store_40x_sler(env, T0);
1700     RETURN();
1701 }
1702
1703 void OPPROTO op_store_booke_tcr (void)
1704 {
1705     store_booke_tcr(env, T0);
1706     RETURN();
1707 }
1708
1709 void OPPROTO op_store_booke_tsr (void)
1710 {
1711     store_booke_tsr(env, T0);
1712     RETURN();
1713 }
1714 #endif /* !defined(CONFIG_USER_ONLY) */
1715
1716 /* SPE extension */
1717 void OPPROTO op_splatw_T1_64 (void)
1718 {
1719     T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
1720     RETURN();
1721 }
1722
1723 void OPPROTO op_splatwi_T0_64 (void)
1724 {
1725     uint64_t tmp = PARAM1;
1726
1727     T0_64 = (tmp << 32) | tmp;
1728     RETURN();
1729 }
1730
1731 void OPPROTO op_splatwi_T1_64 (void)
1732 {
1733     uint64_t tmp = PARAM1;
1734
1735     T1_64 = (tmp << 32) | tmp;
1736     RETURN();
1737 }
1738
1739 void OPPROTO op_extsh_T1_64 (void)
1740 {
1741     T1_64 = (int32_t)((int16_t)T1_64);
1742     RETURN();
1743 }
1744
1745 void OPPROTO op_sli16_T1_64 (void)
1746 {
1747     T1_64 = T1_64 << 16;
1748     RETURN();
1749 }
1750
1751 void OPPROTO op_sli32_T1_64 (void)
1752 {
1753     T1_64 = T1_64 << 32;
1754     RETURN();
1755 }
1756
1757 void OPPROTO op_srli32_T1_64 (void)
1758 {
1759     T1_64 = T1_64 >> 32;
1760     RETURN();
1761 }
1762
1763 void OPPROTO op_evsel (void)
1764 {
1765     do_evsel();
1766     RETURN();
1767 }
1768
1769 void OPPROTO op_evaddw (void)
1770 {
1771     do_evaddw();
1772     RETURN();
1773 }
1774
1775 void OPPROTO op_evsubfw (void)
1776 {
1777     do_evsubfw();
1778     RETURN();
1779 }
1780
1781 void OPPROTO op_evneg (void)
1782 {
1783     do_evneg();
1784     RETURN();
1785 }
1786
1787 void OPPROTO op_evabs (void)
1788 {
1789     do_evabs();
1790     RETURN();
1791 }
1792
1793 void OPPROTO op_evextsh (void)
1794 {
1795     T0_64 = ((uint64_t)((int32_t)(int16_t)(T0_64 >> 32)) << 32) |
1796         (uint64_t)((int32_t)(int16_t)T0_64);
1797     RETURN();
1798 }
1799
1800 void OPPROTO op_evextsb (void)
1801 {
1802     T0_64 = ((uint64_t)((int32_t)(int8_t)(T0_64 >> 32)) << 32) |
1803         (uint64_t)((int32_t)(int8_t)T0_64);
1804     RETURN();
1805 }
1806
1807 void OPPROTO op_evcntlzw (void)
1808 {
1809     do_evcntlzw();
1810     RETURN();
1811 }
1812
1813 void OPPROTO op_evrndw (void)
1814 {
1815     do_evrndw();
1816     RETURN();
1817 }
1818
1819 void OPPROTO op_brinc (void)
1820 {
1821     do_brinc();
1822     RETURN();
1823 }
1824
1825 void OPPROTO op_evcntlsw (void)
1826 {
1827     do_evcntlsw();
1828     RETURN();
1829 }
1830
1831 void OPPROTO op_evsrws (void)
1832 {
1833     do_evsrws();
1834     RETURN();
1835 }
1836
1837 void OPPROTO op_evsrwu (void)
1838 {
1839     do_evsrwu();
1840     RETURN();
1841 }
1842
1843 void OPPROTO op_evslw (void)
1844 {
1845     do_evslw();
1846     RETURN();
1847 }
1848
1849 void OPPROTO op_evrlw (void)
1850 {
1851     do_evrlw();
1852     RETURN();
1853 }
1854
1855 void OPPROTO op_evmergelo (void)
1856 {
1857     T0_64 = (T0_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
1858     RETURN();
1859 }
1860
1861 void OPPROTO op_evmergehi (void)
1862 {
1863     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 >> 32);
1864     RETURN();
1865 }
1866
1867 void OPPROTO op_evmergelohi (void)
1868 {
1869     T0_64 = (T0_64 << 32) | (T1_64 >> 32);
1870     RETURN();
1871 }
1872
1873 void OPPROTO op_evmergehilo (void)
1874 {
1875     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 & 0x00000000FFFFFFFFULL);
1876     RETURN();
1877 }
1878
1879 void OPPROTO op_evcmpgts (void)
1880 {
1881     do_evcmpgts();
1882     RETURN();
1883 }
1884
1885 void OPPROTO op_evcmpgtu (void)
1886 {
1887     do_evcmpgtu();
1888     RETURN();
1889 }
1890
1891 void OPPROTO op_evcmplts (void)
1892 {
1893     do_evcmplts();
1894     RETURN();
1895 }
1896
1897 void OPPROTO op_evcmpltu (void)
1898 {
1899     do_evcmpltu();
1900     RETURN();
1901 }
1902
1903 void OPPROTO op_evcmpeq (void)
1904 {
1905     do_evcmpeq();
1906     RETURN();
1907 }
1908
1909 void OPPROTO op_evfssub (void)
1910 {
1911     do_evfssub();
1912     RETURN();
1913 }
1914
1915 void OPPROTO op_evfsadd (void)
1916 {
1917     do_evfsadd();
1918     RETURN();
1919 }
1920
1921 void OPPROTO op_evfsnabs (void)
1922 {
1923     do_evfsnabs();
1924     RETURN();
1925 }
1926
1927 void OPPROTO op_evfsabs (void)
1928 {
1929     do_evfsabs();
1930     RETURN();
1931 }
1932
1933 void OPPROTO op_evfsneg (void)
1934 {
1935     do_evfsneg();
1936     RETURN();
1937 }
1938
1939 void OPPROTO op_evfsdiv (void)
1940 {
1941     do_evfsdiv();
1942     RETURN();
1943 }
1944
1945 void OPPROTO op_evfsmul (void)
1946 {
1947     do_evfsmul();
1948     RETURN();
1949 }
1950
1951 void OPPROTO op_evfscmplt (void)
1952 {
1953     do_evfscmplt();
1954     RETURN();
1955 }
1956
1957 void OPPROTO op_evfscmpgt (void)
1958 {
1959     do_evfscmpgt();
1960     RETURN();
1961 }
1962
1963 void OPPROTO op_evfscmpeq (void)
1964 {
1965     do_evfscmpeq();
1966     RETURN();
1967 }
1968
1969 void OPPROTO op_evfscfsi (void)
1970 {
1971     do_evfscfsi();
1972     RETURN();
1973 }
1974
1975 void OPPROTO op_evfscfui (void)
1976 {
1977     do_evfscfui();
1978     RETURN();
1979 }
1980
1981 void OPPROTO op_evfscfsf (void)
1982 {
1983     do_evfscfsf();
1984     RETURN();
1985 }
1986
1987 void OPPROTO op_evfscfuf (void)
1988 {
1989     do_evfscfuf();
1990     RETURN();
1991 }
1992
1993 void OPPROTO op_evfsctsi (void)
1994 {
1995     do_evfsctsi();
1996     RETURN();
1997 }
1998
1999 void OPPROTO op_evfsctui (void)
2000 {
2001     do_evfsctui();
2002     RETURN();
2003 }
2004
2005 void OPPROTO op_evfsctsf (void)
2006 {
2007     do_evfsctsf();
2008     RETURN();
2009 }
2010
2011 void OPPROTO op_evfsctuf (void)
2012 {
2013     do_evfsctuf();
2014     RETURN();
2015 }
2016
2017 void OPPROTO op_evfsctuiz (void)
2018 {
2019     do_evfsctuiz();
2020     RETURN();
2021 }
2022
2023 void OPPROTO op_evfsctsiz (void)
2024 {
2025     do_evfsctsiz();
2026     RETURN();
2027 }
2028
2029 void OPPROTO op_evfststlt (void)
2030 {
2031     do_evfststlt();
2032     RETURN();
2033 }
2034
2035 void OPPROTO op_evfststgt (void)
2036 {
2037     do_evfststgt();
2038     RETURN();
2039 }
2040
2041 void OPPROTO op_evfststeq (void)
2042 {
2043     do_evfststeq();
2044     RETURN();
2045 }
2046
2047 void OPPROTO op_efssub (void)
2048 {
2049     T0_64 = _do_efssub(T0_64, T1_64);
2050     RETURN();
2051 }
2052
2053 void OPPROTO op_efsadd (void)
2054 {
2055     T0_64 = _do_efsadd(T0_64, T1_64);
2056     RETURN();
2057 }
2058
2059 void OPPROTO op_efsnabs (void)
2060 {
2061     T0_64 = _do_efsnabs(T0_64);
2062     RETURN();
2063 }
2064
2065 void OPPROTO op_efsabs (void)
2066 {
2067     T0_64 = _do_efsabs(T0_64);
2068     RETURN();
2069 }
2070
2071 void OPPROTO op_efsneg (void)
2072 {
2073     T0_64 = _do_efsneg(T0_64);
2074     RETURN();
2075 }
2076
2077 void OPPROTO op_efsdiv (void)
2078 {
2079     T0_64 = _do_efsdiv(T0_64, T1_64);
2080     RETURN();
2081 }
2082
2083 void OPPROTO op_efsmul (void)
2084 {
2085     T0_64 = _do_efsmul(T0_64, T1_64);
2086     RETURN();
2087 }
2088
2089 void OPPROTO op_efscmplt (void)
2090 {
2091     do_efscmplt();
2092     RETURN();
2093 }
2094
2095 void OPPROTO op_efscmpgt (void)
2096 {
2097     do_efscmpgt();
2098     RETURN();
2099 }
2100
2101 void OPPROTO op_efscfd (void)
2102 {
2103     do_efscfd();
2104     RETURN();
2105 }
2106
2107 void OPPROTO op_efscmpeq (void)
2108 {
2109     do_efscmpeq();
2110     RETURN();
2111 }
2112
2113 void OPPROTO op_efscfsi (void)
2114 {
2115     do_efscfsi();
2116     RETURN();
2117 }
2118
2119 void OPPROTO op_efscfui (void)
2120 {
2121     do_efscfui();
2122     RETURN();
2123 }
2124
2125 void OPPROTO op_efscfsf (void)
2126 {
2127     do_efscfsf();
2128     RETURN();
2129 }
2130
2131 void OPPROTO op_efscfuf (void)
2132 {
2133     do_efscfuf();
2134     RETURN();
2135 }
2136
2137 void OPPROTO op_efsctsi (void)
2138 {
2139     do_efsctsi();
2140     RETURN();
2141 }
2142
2143 void OPPROTO op_efsctui (void)
2144 {
2145     do_efsctui();
2146     RETURN();
2147 }
2148
2149 void OPPROTO op_efsctsf (void)
2150 {
2151     do_efsctsf();
2152     RETURN();
2153 }
2154
2155 void OPPROTO op_efsctuf (void)
2156 {
2157     do_efsctuf();
2158     RETURN();
2159 }
2160
2161 void OPPROTO op_efsctsiz (void)
2162 {
2163     do_efsctsiz();
2164     RETURN();
2165 }
2166
2167 void OPPROTO op_efsctuiz (void)
2168 {
2169     do_efsctuiz();
2170     RETURN();
2171 }
2172
2173 void OPPROTO op_efststlt (void)
2174 {
2175     T0 = _do_efststlt(T0_64, T1_64);
2176     RETURN();
2177 }
2178
2179 void OPPROTO op_efststgt (void)
2180 {
2181     T0 = _do_efststgt(T0_64, T1_64);
2182     RETURN();
2183 }
2184
2185 void OPPROTO op_efststeq (void)
2186 {
2187     T0 = _do_efststeq(T0_64, T1_64);
2188     RETURN();
2189 }
2190
2191 void OPPROTO op_efdsub (void)
2192 {
2193     CPU_DoubleU u1, u2;
2194     u1.ll = T0_64;
2195     u2.ll = T1_64;
2196     u1.d = float64_sub(u1.d, u2.d, &env->spe_status);
2197     T0_64 = u1.ll;
2198     RETURN();
2199 }
2200
2201 void OPPROTO op_efdadd (void)
2202 {
2203     CPU_DoubleU u1, u2;
2204     u1.ll = T0_64;
2205     u2.ll = T1_64;
2206     u1.d = float64_add(u1.d, u2.d, &env->spe_status);
2207     T0_64 = u1.ll;
2208     RETURN();
2209 }
2210
2211 void OPPROTO op_efdcfsid (void)
2212 {
2213     do_efdcfsi();
2214     RETURN();
2215 }
2216
2217 void OPPROTO op_efdcfuid (void)
2218 {
2219     do_efdcfui();
2220     RETURN();
2221 }
2222
2223 void OPPROTO op_efdnabs (void)
2224 {
2225     T0_64 |= 0x8000000000000000ULL;
2226     RETURN();
2227 }
2228
2229 void OPPROTO op_efdabs (void)
2230 {
2231     T0_64 &= ~0x8000000000000000ULL;
2232     RETURN();
2233 }
2234
2235 void OPPROTO op_efdneg (void)
2236 {
2237     T0_64 ^= 0x8000000000000000ULL;
2238     RETURN();
2239 }
2240
2241 void OPPROTO op_efddiv (void)
2242 {
2243     CPU_DoubleU u1, u2;
2244     u1.ll = T0_64;
2245     u2.ll = T1_64;
2246     u1.d = float64_div(u1.d, u2.d, &env->spe_status);
2247     T0_64 = u1.ll;
2248     RETURN();
2249 }
2250
2251 void OPPROTO op_efdmul (void)
2252 {
2253     CPU_DoubleU u1, u2;
2254     u1.ll = T0_64;
2255     u2.ll = T1_64;
2256     u1.d = float64_mul(u1.d, u2.d, &env->spe_status);
2257     T0_64 = u1.ll;
2258     RETURN();
2259 }
2260
2261 void OPPROTO op_efdctsidz (void)
2262 {
2263     do_efdctsiz();
2264     RETURN();
2265 }
2266
2267 void OPPROTO op_efdctuidz (void)
2268 {
2269     do_efdctuiz();
2270     RETURN();
2271 }
2272
2273 void OPPROTO op_efdcmplt (void)
2274 {
2275     do_efdcmplt();
2276     RETURN();
2277 }
2278
2279 void OPPROTO op_efdcmpgt (void)
2280 {
2281     do_efdcmpgt();
2282     RETURN();
2283 }
2284
2285 void OPPROTO op_efdcfs (void)
2286 {
2287     do_efdcfs();
2288     RETURN();
2289 }
2290
2291 void OPPROTO op_efdcmpeq (void)
2292 {
2293     do_efdcmpeq();
2294     RETURN();
2295 }
2296
2297 void OPPROTO op_efdcfsi (void)
2298 {
2299     do_efdcfsi();
2300     RETURN();
2301 }
2302
2303 void OPPROTO op_efdcfui (void)
2304 {
2305     do_efdcfui();
2306     RETURN();
2307 }
2308
2309 void OPPROTO op_efdcfsf (void)
2310 {
2311     do_efdcfsf();
2312     RETURN();
2313 }
2314
2315 void OPPROTO op_efdcfuf (void)
2316 {
2317     do_efdcfuf();
2318     RETURN();
2319 }
2320
2321 void OPPROTO op_efdctsi (void)
2322 {
2323     do_efdctsi();
2324     RETURN();
2325 }
2326
2327 void OPPROTO op_efdctui (void)
2328 {
2329     do_efdctui();
2330     RETURN();
2331 }
2332
2333 void OPPROTO op_efdctsf (void)
2334 {
2335     do_efdctsf();
2336     RETURN();
2337 }
2338
2339 void OPPROTO op_efdctuf (void)
2340 {
2341     do_efdctuf();
2342     RETURN();
2343 }
2344
2345 void OPPROTO op_efdctuiz (void)
2346 {
2347     do_efdctuiz();
2348     RETURN();
2349 }
2350
2351 void OPPROTO op_efdctsiz (void)
2352 {
2353     do_efdctsiz();
2354     RETURN();
2355 }
2356
2357 void OPPROTO op_efdtstlt (void)
2358 {
2359     T0 = _do_efdtstlt(T0_64, T1_64);
2360     RETURN();
2361 }
2362
2363 void OPPROTO op_efdtstgt (void)
2364 {
2365     T0 = _do_efdtstgt(T0_64, T1_64);
2366     RETURN();
2367 }
2368
2369 void OPPROTO op_efdtsteq (void)
2370 {
2371     T0 = _do_efdtsteq(T0_64, T1_64);
2372     RETURN();
2373 }