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 /* PowerPC state maintenance operations */
  30 /* set_Rc0 */
  31 void OPPROTO op_set_Rc0 (void)
  32 {
  33     env->crf[0] = T0 | xer_so;
  34     RETURN();
  35 }
  36
  37 /* Generate exceptions */
  38 void OPPROTO op_raise_exception_err (void)
  39 {
  40     do_raise_exception_err(PARAM1, PARAM2);
  41 }
  42
  43 void OPPROTO op_debug (void)
  44 {
  45     do_raise_exception(EXCP_DEBUG);
  46 }
  47
  48 /* Load/store special registers */
  49 void OPPROTO op_load_cr (void)
  50 {
  51     do_load_cr();
  52     RETURN();
  53 }
  54
  55 void OPPROTO op_store_cr (void)
  56 {
  57     do_store_cr(PARAM1);
  58     RETURN();
  59 }
  60
  61 #if defined(TARGET_PPC64)
  62 void OPPROTO op_store_pri (void)
  63 {
  64     do_store_pri(PARAM1);
  65     RETURN();
  66 }
  67 #endif
  68
  69 #if !defined(CONFIG_USER_ONLY)
  70 /* Segment registers load and store */
  71 void OPPROTO op_load_sr (void)
  72 {
  73     T0 = env->sr[T1];
  74     RETURN();
  75 }
  76
  77 void OPPROTO op_store_sr (void)
  78 {
  79     do_store_sr(env, T1, T0);
  80     RETURN();
  81 }
  82
  83 #if defined(TARGET_PPC64)
  84 void OPPROTO op_load_slb (void)
  85 {
  86     T0 = ppc_load_slb(env, T1);
  87     RETURN();
  88 }
  89
  90 void OPPROTO op_store_slb (void)
  91 {
  92     ppc_store_slb(env, T1, T0);
  93     RETURN();
  94 }
  95 #endif /* defined(TARGET_PPC64) */
  96
  97 void OPPROTO op_load_sdr1 (void)
  98 {
  99     T0 = env->sdr1;
 100     RETURN();
 101 }
 102
 103 void OPPROTO op_store_sdr1 (void)
 104 {
 105     do_store_sdr1(env, T0);
 106     RETURN();
 107 }
 108
 109 #if defined (TARGET_PPC64)
 110 void OPPROTO op_load_asr (void)
 111 {
 112     T0 = env->asr;
 113     RETURN();
 114 }
 115
 116 void OPPROTO op_store_asr (void)
 117 {
 118     ppc_store_asr(env, T0);
 119     RETURN();
 120 }
 121 #endif
 122
 123 void OPPROTO op_load_msr (void)
 124 {
 125     T0 = env->msr;
 126     RETURN();
 127 }
 128
 129 void OPPROTO op_store_msr (void)
 130 {
 131     do_store_msr();
 132     RETURN();
 133 }
 134
 135 #if defined (TARGET_PPC64)
 136 void OPPROTO op_store_msr_32 (void)
 137 {
 138     T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);
 139     do_store_msr();
 140     RETURN();
 141 }
 142 #endif
 143
 144 void OPPROTO op_update_riee (void)
 145 {
 146     /* We don't call do_store_msr here as we won't trigger
 147      * any special case nor change hflags
 148      */
 149     T0 &= (1 << MSR_RI) | (1 << MSR_EE);
 150     env->msr &= ~(1 << MSR_RI) | (1 << MSR_EE);
 151     env->msr |= T0;
 152     RETURN();
 153 }
 154 #endif
 155
 156 /* SPR */
 157 void OPPROTO op_load_spr (void)
 158 {
 159     T0 = env->spr[PARAM1];
 160     RETURN();
 161 }
 162
 163 void OPPROTO op_store_spr (void)
 164 {
 165     env->spr[PARAM1] = T0;
 166     RETURN();
 167 }
 168
 169 void OPPROTO op_load_dump_spr (void)
 170 {
 171     T0 = ppc_load_dump_spr(PARAM1);
 172     RETURN();
 173 }
 174
 175 void OPPROTO op_store_dump_spr (void)
 176 {
 177     ppc_store_dump_spr(PARAM1, T0);
 178     RETURN();
 179 }
 180
 181 void OPPROTO op_mask_spr (void)
 182 {
 183     env->spr[PARAM1] &= ~T0;
 184     RETURN();
 185 }
 186
 187 void OPPROTO op_load_tbl (void)
 188 {
 189     T0 = cpu_ppc_load_tbl(env);
 190     RETURN();
 191 }
 192
 193 void OPPROTO op_load_tbu (void)
 194 {
 195     T0 = cpu_ppc_load_tbu(env);
 196     RETURN();
 197 }
 198
 199 void OPPROTO op_load_atbl (void)
 200 {
 201     T0 = cpu_ppc_load_atbl(env);
 202     RETURN();
 203 }
 204
 205 void OPPROTO op_load_atbu (void)
 206 {
 207     T0 = cpu_ppc_load_atbu(env);
 208     RETURN();
 209 }
 210
 211 #if !defined(CONFIG_USER_ONLY)
 212 void OPPROTO op_store_tbl (void)
 213 {
 214     cpu_ppc_store_tbl(env, T0);
 215     RETURN();
 216 }
 217
 218 void OPPROTO op_store_tbu (void)
 219 {
 220     cpu_ppc_store_tbu(env, T0);
 221     RETURN();
 222 }
 223
 224 void OPPROTO op_store_atbl (void)
 225 {
 226     cpu_ppc_store_atbl(env, T0);
 227     RETURN();
 228 }
 229
 230 void OPPROTO op_store_atbu (void)
 231 {
 232     cpu_ppc_store_atbu(env, T0);
 233     RETURN();
 234 }
 235
 236 void OPPROTO op_load_decr (void)
 237 {
 238     T0 = cpu_ppc_load_decr(env);
 239     RETURN();
 240 }
 241
 242 void OPPROTO op_store_decr (void)
 243 {
 244     cpu_ppc_store_decr(env, T0);
 245     RETURN();
 246 }
 247
 248 void OPPROTO op_load_ibat (void)
 249 {
 250     T0 = env->IBAT[PARAM1][PARAM2];
 251     RETURN();
 252 }
 253
 254 void OPPROTO op_store_ibatu (void)
 255 {
 256     do_store_ibatu(env, PARAM1, T0);
 257     RETURN();
 258 }
 259
 260 void OPPROTO op_store_ibatl (void)
 261 {
 262 #if 1
 263     env->IBAT[1][PARAM1] = T0;
 264 #else
 265     do_store_ibatl(env, PARAM1, T0);
 266 #endif
 267     RETURN();
 268 }
 269
 270 void OPPROTO op_load_dbat (void)
 271 {
 272     T0 = env->DBAT[PARAM1][PARAM2];
 273     RETURN();
 274 }
 275
 276 void OPPROTO op_store_dbatu (void)
 277 {
 278     do_store_dbatu(env, PARAM1, T0);
 279     RETURN();
 280 }
 281
 282 void OPPROTO op_store_dbatl (void)
 283 {
 284 #if 1
 285     env->DBAT[1][PARAM1] = T0;
 286 #else
 287     do_store_dbatl(env, PARAM1, T0);
 288 #endif
 289     RETURN();
 290 }
 291 #endif /* !defined(CONFIG_USER_ONLY) */
 292
 293 /* FPSCR */
 294 #ifdef CONFIG_SOFTFLOAT
 295 void OPPROTO op_reset_fpstatus (void)
 296 {
 297     env->fp_status.float_exception_flags = 0;
 298     RETURN();
 299 }
 300 #endif
 301
 302 void OPPROTO op_compute_fprf (void)
 303 {
 304     do_compute_fprf(PARAM1);
 305     RETURN();
 306 }
 307
 308 #ifdef CONFIG_SOFTFLOAT
 309 void OPPROTO op_float_check_status (void)
 310 {
 311     do_float_check_status();
 312     RETURN();
 313 }
 314 #else
 315 void OPPROTO op_float_check_status (void)
 316 {
 317     if (env->exception_index == POWERPC_EXCP_PROGRAM &&
 318         (env->error_code & POWERPC_EXCP_FP)) {
 319         /* Differred floating-point exception after target FPR update */
 320         if (msr_fe0 != 0 || msr_fe1 != 0)
 321             do_raise_exception_err(env->exception_index, env->error_code);
 322     }
 323     RETURN();
 324 }
 325 #endif
 326
 327 void OPPROTO op_load_fpscr_FT0 (void)
 328 {
 329     /* The 32 MSB of the target fpr are undefined.
 330      * They'll be zero...
 331      */
 332     CPU_DoubleU u;
 333
 334     u.l.upper = 0;
 335     u.l.lower = env->fpscr;
 336     FT0 = u.d;
 337     RETURN();
 338 }
 339
 340 void OPPROTO op_load_fpscr_T0 (void)
 341 {
 342     T0 = (env->fpscr >> PARAM1) & 0xF;
 343     RETURN();
 344 }
 345
 346 void OPPROTO op_load_fpcc (void)
 347 {
 348     T0 = fpscr_fpcc;
 349     RETURN();
 350 }
 351
 352 void OPPROTO op_fpscr_resetbit (void)
 353 {
 354     env->fpscr &= PARAM1;
 355     RETURN();
 356 }
 357
 358 void OPPROTO op_fpscr_setbit (void)
 359 {
 360     do_fpscr_setbit(PARAM1);
 361     RETURN();
 362 }
 363
 364 void OPPROTO op_store_fpscr (void)
 365 {
 366     do_store_fpscr(PARAM1);
 367     RETURN();
 368 }
 369
 370 /* Branch */
 371 void OPPROTO op_setlr (void)
 372 {
 373     env->lr = (uint32_t)PARAM1;
 374     RETURN();
 375 }
 376
 377 #if defined (TARGET_PPC64)
 378 void OPPROTO op_setlr_64 (void)
 379 {
 380     env->lr = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
 381     RETURN();
 382 }
 383 #endif
 384
 385 void OPPROTO op_jz_T0 (void)
 386 {
 387     if (!T0)
 388         GOTO_LABEL_PARAM(1);
 389     RETURN();
 390 }
 391
 392 void OPPROTO op_btest_T1 (void)
 393 {
 394     if (T0) {
 395         env->nip = (uint32_t)(T1 & ~3);
 396     } else {
 397         env->nip = (uint32_t)PARAM1;
 398     }
 399     RETURN();
 400 }
 401
 402 #if defined (TARGET_PPC64)
 403 void OPPROTO op_btest_T1_64 (void)
 404 {
 405     if (T0) {
 406         env->nip = (uint64_t)(T1 & ~3);
 407     } else {
 408         env->nip = ((uint64_t)PARAM1 << 32) | (uint64_t)PARAM2;
 409     }
 410     RETURN();
 411 }
 412 #endif
 413
 414 void OPPROTO op_movl_T1_ctr (void)
 415 {
 416     T1 = env->ctr;
 417     RETURN();
 418 }
 419
 420 void OPPROTO op_movl_T1_lr (void)
 421 {
 422     T1 = env->lr;
 423     RETURN();
 424 }
 425
 426 /* tests with result in T0 */
 427 void OPPROTO op_test_ctr (void)
 428 {
 429     T0 = (uint32_t)env->ctr;
 430     RETURN();
 431 }
 432
 433 #if defined(TARGET_PPC64)
 434 void OPPROTO op_test_ctr_64 (void)
 435 {
 436     T0 = (uint64_t)env->ctr;
 437     RETURN();
 438 }
 439 #endif
 440
 441 void OPPROTO op_test_ctr_true (void)
 442 {
 443     T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) != 0);
 444     RETURN();
 445 }
 446
 447 #if defined(TARGET_PPC64)
 448 void OPPROTO op_test_ctr_true_64 (void)
 449 {
 450     T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) != 0);
 451     RETURN();
 452 }
 453 #endif
 454
 455 void OPPROTO op_test_ctr_false (void)
 456 {
 457     T0 = ((uint32_t)env->ctr != 0 && (T0 & PARAM1) == 0);
 458     RETURN();
 459 }
 460
 461 #if defined(TARGET_PPC64)
 462 void OPPROTO op_test_ctr_false_64 (void)
 463 {
 464     T0 = ((uint64_t)env->ctr != 0 && (T0 & PARAM1) == 0);
 465     RETURN();
 466 }
 467 #endif
 468
 469 void OPPROTO op_test_ctrz (void)
 470 {
 471     T0 = ((uint32_t)env->ctr == 0);
 472     RETURN();
 473 }
 474
 475 #if defined(TARGET_PPC64)
 476 void OPPROTO op_test_ctrz_64 (void)
 477 {
 478     T0 = ((uint64_t)env->ctr == 0);
 479     RETURN();
 480 }
 481 #endif
 482
 483 void OPPROTO op_test_ctrz_true (void)
 484 {
 485     T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) != 0);
 486     RETURN();
 487 }
 488
 489 #if defined(TARGET_PPC64)
 490 void OPPROTO op_test_ctrz_true_64 (void)
 491 {
 492     T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) != 0);
 493     RETURN();
 494 }
 495 #endif
 496
 497 void OPPROTO op_test_ctrz_false (void)
 498 {
 499     T0 = ((uint32_t)env->ctr == 0 && (T0 & PARAM1) == 0);
 500     RETURN();
 501 }
 502
 503 #if defined(TARGET_PPC64)
 504 void OPPROTO op_test_ctrz_false_64 (void)
 505 {
 506     T0 = ((uint64_t)env->ctr == 0 && (T0 & PARAM1) == 0);
 507     RETURN();
 508 }
 509 #endif
 510
 511 void OPPROTO op_test_true (void)
 512 {
 513     T0 = (T0 & PARAM1);
 514     RETURN();
 515 }
 516
 517 void OPPROTO op_test_false (void)
 518 {
 519     T0 = ((T0 & PARAM1) == 0);
 520     RETURN();
 521 }
 522
 523 /* CTR maintenance */
 524 void OPPROTO op_dec_ctr (void)
 525 {
 526     env->ctr--;
 527     RETURN();
 528 }
 529
 530 /***                           Integer arithmetic                          ***/
 531 /* add */
 532 void OPPROTO op_check_addo (void)
 533 {
 534     int ov = (((uint32_t)T2 ^ (uint32_t)T1 ^ UINT32_MAX) &
 535               ((uint32_t)T2 ^ (uint32_t)T0)) >> 31;
 536     if (ov) {
 537         env->xer |= (1 << XER_OV) | (1 << XER_SO);
 538     } else {
 539         env->xer &= ~(1 << XER_OV);
 540     }
 541     RETURN();
 542 }
 543
 544 #if defined(TARGET_PPC64)
 545 void OPPROTO op_check_addo_64 (void)
 546 {
 547     int ov = (((uint64_t)T2 ^ (uint64_t)T1 ^ UINT64_MAX) &
 548               ((uint64_t)T2 ^ (uint64_t)T0)) >> 63;
 549     if (ov) {
 550         env->xer |= (1 << XER_OV) | (1 << XER_SO);
 551     } else {
 552         env->xer &= ~(1 << XER_OV);
 553     }
 554     RETURN();
 555 }
 556 #endif
 557
 558 /* add carrying */
 559 void OPPROTO op_check_addc (void)
 560 {
 561     if (likely((uint32_t)T0 >= (uint32_t)T2)) {
 562         env->xer &= ~(1 << XER_CA);
 563     } else {
 564         env->xer |= (1 << XER_CA);
 565     }
 566     RETURN();
 567 }
 568
 569 #if defined(TARGET_PPC64)
 570 void OPPROTO op_check_addc_64 (void)
 571 {
 572     if (likely((uint64_t)T0 >= (uint64_t)T2)) {
 573         env->xer &= ~(1 << XER_CA);
 574     } else {
 575         env->xer |= (1 << XER_CA);
 576     }
 577     RETURN();
 578 }
 579 #endif
 580
 581 /* add extended */
 582 void OPPROTO op_adde (void)
 583 {
 584     do_adde();
 585     RETURN();
 586 }
 587
 588 #if defined(TARGET_PPC64)
 589 void OPPROTO op_adde_64 (void)
 590 {
 591     do_adde_64();
 592     RETURN();
 593 }
 594 #endif
 595
 596 /* add to minus one extended */
 597 void OPPROTO op_add_me (void)
 598 {
 599     T0 += xer_ca + (-1);
 600     if (likely((uint32_t)T1 != 0))
 601         env->xer |= (1 << XER_CA);
 602     RETURN();
 603 }
 604
 605 #if defined(TARGET_PPC64)
 606 void OPPROTO op_add_me_64 (void)
 607 {
 608     T0 += xer_ca + (-1);
 609     if (likely((uint64_t)T1 != 0))
 610         env->xer |= (1 << XER_CA);
 611     RETURN();
 612 }
 613 #endif
 614
 615 void OPPROTO op_addmeo (void)
 616 {
 617     do_addmeo();
 618     RETURN();
 619 }
 620
 621 void OPPROTO op_addmeo_64 (void)
 622 {
 623     do_addmeo();
 624     RETURN();
 625 }
 626
 627 /* add to zero extended */
 628 void OPPROTO op_add_ze (void)
 629 {
 630     T0 += xer_ca;
 631     RETURN();
 632 }
 633
 634 /* divide word */
 635 void OPPROTO op_divw (void)
 636 {
 637     if (unlikely(((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
 638                  (int32_t)T1 == 0)) {
 639         T0 = (int32_t)(UINT32_MAX * ((uint32_t)T0 >> 31));
 640     } else {
 641         T0 = (int32_t)T0 / (int32_t)T1;
 642     }
 643     RETURN();
 644 }
 645
 646 #if defined(TARGET_PPC64)
 647 void OPPROTO op_divd (void)
 648 {
 649     if (unlikely(((int64_t)T0 == INT64_MIN && (int64_t)T1 == (int64_t)-1LL) ||
 650                  (int64_t)T1 == 0)) {
 651         T0 = (int64_t)(UINT64_MAX * ((uint64_t)T0 >> 63));
 652     } else {
 653         T0 = (int64_t)T0 / (int64_t)T1;
 654     }
 655     RETURN();
 656 }
 657 #endif
 658
 659 void OPPROTO op_divwo (void)
 660 {
 661     do_divwo();
 662     RETURN();
 663 }
 664
 665 #if defined(TARGET_PPC64)
 666 void OPPROTO op_divdo (void)
 667 {
 668     do_divdo();
 669     RETURN();
 670 }
 671 #endif
 672
 673 /* divide word unsigned */
 674 void OPPROTO op_divwu (void)
 675 {
 676     if (unlikely(T1 == 0)) {
 677         T0 = 0;
 678     } else {
 679         T0 = (uint32_t)T0 / (uint32_t)T1;
 680     }
 681     RETURN();
 682 }
 683
 684 #if defined(TARGET_PPC64)
 685 void OPPROTO op_divdu (void)
 686 {
 687     if (unlikely(T1 == 0)) {
 688         T0 = 0;
 689     } else {
 690         T0 /= T1;
 691     }
 692     RETURN();
 693 }
 694 #endif
 695
 696 void OPPROTO op_divwuo (void)
 697 {
 698     do_divwuo();
 699     RETURN();
 700 }
 701
 702 #if defined(TARGET_PPC64)
 703 void OPPROTO op_divduo (void)
 704 {
 705     do_divduo();
 706     RETURN();
 707 }
 708 #endif
 709
 710 /* multiply high word */
 711 void OPPROTO op_mulhw (void)
 712 {
 713     T0 = ((int64_t)((int32_t)T0) * (int64_t)((int32_t)T1)) >> 32;
 714     RETURN();
 715 }
 716
 717 #if defined(TARGET_PPC64)
 718 void OPPROTO op_mulhd (void)
 719 {
 720     uint64_t tl, th;
 721
 722     muls64(&tl, &th, T0, T1);
 723     T0 = th;
 724     RETURN();
 725 }
 726 #endif
 727
 728 /* multiply high word unsigned */
 729 void OPPROTO op_mulhwu (void)
 730 {
 731     T0 = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1) >> 32;
 732     RETURN();
 733 }
 734
 735 #if defined(TARGET_PPC64)
 736 void OPPROTO op_mulhdu (void)
 737 {
 738     uint64_t tl, th;
 739
 740     mulu64(&tl, &th, T0, T1);
 741     T0 = th;
 742     RETURN();
 743 }
 744 #endif
 745
 746 /* multiply low immediate */
 747 void OPPROTO op_mulli (void)
 748 {
 749     T0 = ((int32_t)T0 * (int32_t)PARAM1);
 750     RETURN();
 751 }
 752
 753 /* multiply low word */
 754 void OPPROTO op_mullw (void)
 755 {
 756 #if defined(TARGET_PPC64)
 757     T0 = (int64_t)(int32_t)T0 * (int64_t)(int32_t)T1;
 758 #else
 759     T0 = (int32_t)(T0 * T1);
 760 #endif
 761     RETURN();
 762 }
 763
 764 #if defined(TARGET_PPC64)
 765 void OPPROTO op_mulld (void)
 766 {
 767     T0 *= T1;
 768     RETURN();
 769 }
 770 #endif
 771
 772 void OPPROTO op_mullwo (void)
 773 {
 774     do_mullwo();
 775     RETURN();
 776 }
 777
 778 #if defined(TARGET_PPC64)
 779 void OPPROTO op_mulldo (void)
 780 {
 781     do_mulldo();
 782     RETURN();
 783 }
 784 #endif
 785
 786 /* negate */
 787 void OPPROTO op_neg (void)
 788 {
 789     if (likely(T0 != INT32_MIN)) {
 790         T0 = -(int32_t)T0;
 791     }
 792     RETURN();
 793 }
 794
 795 #if defined(TARGET_PPC64)
 796 void OPPROTO op_neg_64 (void)
 797 {
 798     if (likely(T0 != INT64_MIN)) {
 799         T0 = -(int64_t)T0;
 800     }
 801     RETURN();
 802 }
 803 #endif
 804
 805 void OPPROTO op_nego (void)
 806 {
 807     do_nego();
 808     RETURN();
 809 }
 810
 811 #if defined(TARGET_PPC64)
 812 void OPPROTO op_nego_64 (void)
 813 {
 814     do_nego_64();
 815     RETURN();
 816 }
 817 #endif
 818
 819 /* subtract from carrying */
 820 void OPPROTO op_check_subfc (void)
 821 {
 822     if (likely((uint32_t)T0 > (uint32_t)T1)) {
 823         env->xer &= ~(1 << XER_CA);
 824     } else {
 825         env->xer |= (1 << XER_CA);
 826     }
 827     RETURN();
 828 }
 829
 830 #if defined(TARGET_PPC64)
 831 void OPPROTO op_check_subfc_64 (void)
 832 {
 833     if (likely((uint64_t)T0 > (uint64_t)T1)) {
 834         env->xer &= ~(1 << XER_CA);
 835     } else {
 836         env->xer |= (1 << XER_CA);
 837     }
 838     RETURN();
 839 }
 840 #endif
 841
 842 /* subtract from extended */
 843 void OPPROTO op_subfe (void)
 844 {
 845     do_subfe();
 846     RETURN();
 847 }
 848
 849 #if defined(TARGET_PPC64)
 850 void OPPROTO op_subfe_64 (void)
 851 {
 852     do_subfe_64();
 853     RETURN();
 854 }
 855 #endif
 856
 857 /* subtract from immediate carrying */
 858 void OPPROTO op_subfic (void)
 859 {
 860     T0 = (int32_t)PARAM1 + ~T0 + 1;
 861     if ((uint32_t)T0 <= (uint32_t)PARAM1) {
 862         env->xer |= (1 << XER_CA);
 863     } else {
 864         env->xer &= ~(1 << XER_CA);
 865     }
 866     RETURN();
 867 }
 868
 869 #if defined(TARGET_PPC64)
 870 void OPPROTO op_subfic_64 (void)
 871 {
 872     T0 = (int64_t)PARAM1 + ~T0 + 1;
 873     if ((uint64_t)T0 <= (uint64_t)PARAM1) {
 874         env->xer |= (1 << XER_CA);
 875     } else {
 876         env->xer &= ~(1 << XER_CA);
 877     }
 878     RETURN();
 879 }
 880 #endif
 881
 882 /* subtract from minus one extended */
 883 void OPPROTO op_subfme (void)
 884 {
 885     T0 = ~T0 + xer_ca - 1;
 886     if (likely((uint32_t)T0 != UINT32_MAX))
 887         env->xer |= (1 << XER_CA);
 888     RETURN();
 889 }
 890
 891 #if defined(TARGET_PPC64)
 892 void OPPROTO op_subfme_64 (void)
 893 {
 894     T0 = ~T0 + xer_ca - 1;
 895     if (likely((uint64_t)T0 != UINT64_MAX))
 896         env->xer |= (1 << XER_CA);
 897     RETURN();
 898 }
 899 #endif
 900
 901 void OPPROTO op_subfmeo (void)
 902 {
 903     do_subfmeo();
 904     RETURN();
 905 }
 906
 907 #if defined(TARGET_PPC64)
 908 void OPPROTO op_subfmeo_64 (void)
 909 {
 910     do_subfmeo_64();
 911     RETURN();
 912 }
 913 #endif
 914
 915 /* subtract from zero extended */
 916 void OPPROTO op_subfze (void)
 917 {
 918     T1 = ~T0;
 919     T0 = T1 + xer_ca;
 920     if ((uint32_t)T0 < (uint32_t)T1) {
 921         env->xer |= (1 << XER_CA);
 922     } else {
 923         env->xer &= ~(1 << XER_CA);
 924     }
 925     RETURN();
 926 }
 927
 928 #if defined(TARGET_PPC64)
 929 void OPPROTO op_subfze_64 (void)
 930 {
 931     T1 = ~T0;
 932     T0 = T1 + xer_ca;
 933     if ((uint64_t)T0 < (uint64_t)T1) {
 934         env->xer |= (1 << XER_CA);
 935     } else {
 936         env->xer &= ~(1 << XER_CA);
 937     }
 938     RETURN();
 939 }
 940 #endif
 941
 942 void OPPROTO op_subfzeo (void)
 943 {
 944     do_subfzeo();
 945     RETURN();
 946 }
 947
 948 #if defined(TARGET_PPC64)
 949 void OPPROTO op_subfzeo_64 (void)
 950 {
 951     do_subfzeo_64();
 952     RETURN();
 953 }
 954 #endif
 955
 956 /***                           Integer comparison                          ***/
 957 /* compare */
 958 void OPPROTO op_cmp (void)
 959 {
 960     if ((int32_t)T0 < (int32_t)T1) {
 961         T0 = 0x08;
 962     } else if ((int32_t)T0 > (int32_t)T1) {
 963         T0 = 0x04;
 964     } else {
 965         T0 = 0x02;
 966     }
 967     T0 |= xer_so;
 968     RETURN();
 969 }
 970
 971 #if defined(TARGET_PPC64)
 972 void OPPROTO op_cmp_64 (void)
 973 {
 974     if ((int64_t)T0 < (int64_t)T1) {
 975         T0 = 0x08;
 976     } else if ((int64_t)T0 > (int64_t)T1) {
 977         T0 = 0x04;
 978     } else {
 979         T0 = 0x02;
 980     }
 981     T0 |= xer_so;
 982     RETURN();
 983 }
 984 #endif
 985
 986 /* compare immediate */
 987 void OPPROTO op_cmpi (void)
 988 {
 989     if ((int32_t)T0 < (int32_t)PARAM1) {
 990         T0 = 0x08;
 991     } else if ((int32_t)T0 > (int32_t)PARAM1) {
 992         T0 = 0x04;
 993     } else {
 994         T0 = 0x02;
 995     }
 996     T0 |= xer_so;
 997     RETURN();
 998 }
 999
1000 #if defined(TARGET_PPC64)
1001 void OPPROTO op_cmpi_64 (void)
1002 {
1003     if ((int64_t)T0 < (int64_t)((int32_t)PARAM1)) {
1004         T0 = 0x08;
1005     } else if ((int64_t)T0 > (int64_t)((int32_t)PARAM1)) {
1006         T0 = 0x04;
1007     } else {
1008         T0 = 0x02;
1009     }
1010     T0 |= xer_so;
1011     RETURN();
1012 }
1013 #endif
1014
1015 /* compare logical */
1016 void OPPROTO op_cmpl (void)
1017 {
1018     if ((uint32_t)T0 < (uint32_t)T1) {
1019         T0 = 0x08;
1020     } else if ((uint32_t)T0 > (uint32_t)T1) {
1021         T0 = 0x04;
1022     } else {
1023         T0 = 0x02;
1024     }
1025     T0 |= xer_so;
1026     RETURN();
1027 }
1028
1029 #if defined(TARGET_PPC64)
1030 void OPPROTO op_cmpl_64 (void)
1031 {
1032     if ((uint64_t)T0 < (uint64_t)T1) {
1033         T0 = 0x08;
1034     } else if ((uint64_t)T0 > (uint64_t)T1) {
1035         T0 = 0x04;
1036     } else {
1037         T0 = 0x02;
1038     }
1039     T0 |= xer_so;
1040     RETURN();
1041 }
1042 #endif
1043
1044 /* compare logical immediate */
1045 void OPPROTO op_cmpli (void)
1046 {
1047     if ((uint32_t)T0 < (uint32_t)PARAM1) {
1048         T0 = 0x08;
1049     } else if ((uint32_t)T0 > (uint32_t)PARAM1) {
1050         T0 = 0x04;
1051     } else {
1052         T0 = 0x02;
1053     }
1054     T0 |= xer_so;
1055     RETURN();
1056 }
1057
1058 #if defined(TARGET_PPC64)
1059 void OPPROTO op_cmpli_64 (void)
1060 {
1061     if ((uint64_t)T0 < (uint64_t)PARAM1) {
1062         T0 = 0x08;
1063     } else if ((uint64_t)T0 > (uint64_t)PARAM1) {
1064         T0 = 0x04;
1065     } else {
1066         T0 = 0x02;
1067     }
1068     T0 |= xer_so;
1069     RETURN();
1070 }
1071 #endif
1072
1073 void OPPROTO op_isel (void)
1074 {
1075     if (T0)
1076         T0 = T1;
1077     else
1078         T0 = T2;
1079     RETURN();
1080 }
1081
1082 void OPPROTO op_popcntb (void)
1083 {
1084     do_popcntb();
1085     RETURN();
1086 }
1087
1088 #if defined(TARGET_PPC64)
1089 void OPPROTO op_popcntb_64 (void)
1090 {
1091     do_popcntb_64();
1092     RETURN();
1093 }
1094 #endif
1095
1096 /***                            Integer logical                            ***/
1097 /* and */
1098 void OPPROTO op_and (void)
1099 {
1100     T0 &= T1;
1101     RETURN();
1102 }
1103
1104 /* andc */
1105 void OPPROTO op_andc (void)
1106 {
1107     T0 &= ~T1;
1108     RETURN();
1109 }
1110
1111 /* count leading zero */
1112 void OPPROTO op_cntlzw (void)
1113 {
1114     do_cntlzw();
1115     RETURN();
1116 }
1117
1118 #if defined(TARGET_PPC64)
1119 void OPPROTO op_cntlzd (void)
1120 {
1121     do_cntlzd();
1122     RETURN();
1123 }
1124 #endif
1125
1126 /* eqv */
1127 void OPPROTO op_eqv (void)
1128 {
1129     T0 = ~(T0 ^ T1);
1130     RETURN();
1131 }
1132
1133 /* extend sign byte */
1134 void OPPROTO op_extsb (void)
1135 {
1136 #if defined (TARGET_PPC64)
1137     T0 = (int64_t)((int8_t)T0);
1138 #else
1139     T0 = (int32_t)((int8_t)T0);
1140 #endif
1141     RETURN();
1142 }
1143
1144 /* extend sign half word */
1145 void OPPROTO op_extsh (void)
1146 {
1147 #if defined (TARGET_PPC64)
1148     T0 = (int64_t)((int16_t)T0);
1149 #else
1150     T0 = (int32_t)((int16_t)T0);
1151 #endif
1152     RETURN();
1153 }
1154
1155 #if defined (TARGET_PPC64)
1156 void OPPROTO op_extsw (void)
1157 {
1158     T0 = (int64_t)((int32_t)T0);
1159     RETURN();
1160 }
1161 #endif
1162
1163 /* nand */
1164 void OPPROTO op_nand (void)
1165 {
1166     T0 = ~(T0 & T1);
1167     RETURN();
1168 }
1169
1170 /* nor */
1171 void OPPROTO op_nor (void)
1172 {
1173     T0 = ~(T0 | T1);
1174     RETURN();
1175 }
1176
1177 /* or */
1178 void OPPROTO op_or (void)
1179 {
1180     T0 |= T1;
1181     RETURN();
1182 }
1183
1184 /* orc */
1185 void OPPROTO op_orc (void)
1186 {
1187     T0 |= ~T1;
1188     RETURN();
1189 }
1190
1191 /* ori */
1192 void OPPROTO op_ori (void)
1193 {
1194     T0 |= (uint32_t)PARAM1;
1195     RETURN();
1196 }
1197
1198 /* xor */
1199 void OPPROTO op_xor (void)
1200 {
1201     T0 ^= T1;
1202     RETURN();
1203 }
1204
1205 /* xori */
1206 void OPPROTO op_xori (void)
1207 {
1208     T0 ^= (uint32_t)PARAM1;
1209     RETURN();
1210 }
1211
1212 /***                             Integer rotate                            ***/
1213 void OPPROTO op_rotl32_T0_T1 (void)
1214 {
1215     T0 = rotl32(T0, T1 & 0x1F);
1216     RETURN();
1217 }
1218
1219 void OPPROTO op_rotli32_T0 (void)
1220 {
1221     T0 = rotl32(T0, PARAM1);
1222     RETURN();
1223 }
1224
1225 #if defined(TARGET_PPC64)
1226 void OPPROTO op_rotl64_T0_T1 (void)
1227 {
1228     T0 = rotl64(T0, T1 & 0x3F);
1229     RETURN();
1230 }
1231
1232 void OPPROTO op_rotli64_T0 (void)
1233 {
1234     T0 = rotl64(T0, PARAM1);
1235     RETURN();
1236 }
1237 #endif
1238
1239 /***                             Integer shift                             ***/
1240 /* shift left word */
1241 void OPPROTO op_slw (void)
1242 {
1243     if (T1 & 0x20) {
1244         T0 = 0;
1245     } else {
1246         T0 = (uint32_t)(T0 << T1);
1247     }
1248     RETURN();
1249 }
1250
1251 #if defined(TARGET_PPC64)
1252 void OPPROTO op_sld (void)
1253 {
1254     if (T1 & 0x40) {
1255         T0 = 0;
1256     } else {
1257         T0 = T0 << T1;
1258     }
1259     RETURN();
1260 }
1261 #endif
1262
1263 /* shift right algebraic word */
1264 void OPPROTO op_sraw (void)
1265 {
1266     do_sraw();
1267     RETURN();
1268 }
1269
1270 #if defined(TARGET_PPC64)
1271 void OPPROTO op_srad (void)
1272 {
1273     do_srad();
1274     RETURN();
1275 }
1276 #endif
1277
1278 /* shift right algebraic word immediate */
1279 void OPPROTO op_srawi (void)
1280 {
1281     uint32_t mask = (uint32_t)PARAM2;
1282
1283     T0 = (int32_t)T0 >> PARAM1;
1284     if ((int32_t)T1 < 0 && (T1 & mask) != 0) {
1285         env->xer |= (1 << XER_CA);
1286     } else {
1287         env->xer &= ~(1 << XER_CA);
1288     }
1289     RETURN();
1290 }
1291
1292 #if defined(TARGET_PPC64)
1293 void OPPROTO op_sradi (void)
1294 {
1295     uint64_t mask = ((uint64_t)PARAM2 << 32) | (uint64_t)PARAM3;
1296
1297     T0 = (int64_t)T0 >> PARAM1;
1298     if ((int64_t)T1 < 0 && ((uint64_t)T1 & mask) != 0) {
1299         env->xer |= (1 << XER_CA);
1300     } else {
1301         env->xer &= ~(1 << XER_CA);
1302     }
1303     RETURN();
1304 }
1305 #endif
1306
1307 /* shift right word */
1308 void OPPROTO op_srw (void)
1309 {
1310     if (T1 & 0x20) {
1311         T0 = 0;
1312     } else {
1313         T0 = (uint32_t)T0 >> T1;
1314     }
1315     RETURN();
1316 }
1317
1318 #if defined(TARGET_PPC64)
1319 void OPPROTO op_srd (void)
1320 {
1321     if (T1 & 0x40) {
1322         T0 = 0;
1323     } else {
1324         T0 = (uint64_t)T0 >> T1;
1325     }
1326     RETURN();
1327 }
1328 #endif
1329
1330 void OPPROTO op_sl_T0_T1 (void)
1331 {
1332     T0 = T0 << T1;
1333     RETURN();
1334 }
1335
1336 void OPPROTO op_sli_T0 (void)
1337 {
1338     T0 = T0 << PARAM1;
1339     RETURN();
1340 }
1341
1342 void OPPROTO op_sli_T1 (void)
1343 {
1344     T1 = T1 << PARAM1;
1345     RETURN();
1346 }
1347
1348 void OPPROTO op_srl_T0_T1 (void)
1349 {
1350     T0 = (uint32_t)T0 >> T1;
1351     RETURN();
1352 }
1353
1354 #if defined(TARGET_PPC64)
1355 void OPPROTO op_srl_T0_T1_64 (void)
1356 {
1357     T0 = (uint32_t)T0 >> T1;
1358     RETURN();
1359 }
1360 #endif
1361
1362 void OPPROTO op_srli_T0 (void)
1363 {
1364     T0 = (uint32_t)T0 >> PARAM1;
1365     RETURN();
1366 }
1367
1368 #if defined(TARGET_PPC64)
1369 void OPPROTO op_srli_T0_64 (void)
1370 {
1371     T0 = (uint64_t)T0 >> PARAM1;
1372     RETURN();
1373 }
1374 #endif
1375
1376 void OPPROTO op_srli_T1 (void)
1377 {
1378     T1 = (uint32_t)T1 >> PARAM1;
1379     RETURN();
1380 }
1381
1382 #if defined(TARGET_PPC64)
1383 void OPPROTO op_srli_T1_64 (void)
1384 {
1385     T1 = (uint64_t)T1 >> PARAM1;
1386     RETURN();
1387 }
1388 #endif
1389
1390 /***                       Floating-Point arithmetic                       ***/
1391 /* fadd - fadd. */
1392 void OPPROTO op_fadd (void)
1393 {
1394 #if USE_PRECISE_EMULATION
1395     do_fadd();
1396 #else
1397     FT0 = float64_add(FT0, FT1, &env->fp_status);
1398 #endif
1399     RETURN();
1400 }
1401
1402 /* fsub - fsub. */
1403 void OPPROTO op_fsub (void)
1404 {
1405 #if USE_PRECISE_EMULATION
1406     do_fsub();
1407 #else
1408     FT0 = float64_sub(FT0, FT1, &env->fp_status);
1409 #endif
1410     RETURN();
1411 }
1412
1413 /* fmul - fmul. */
1414 void OPPROTO op_fmul (void)
1415 {
1416 #if USE_PRECISE_EMULATION
1417     do_fmul();
1418 #else
1419     FT0 = float64_mul(FT0, FT1, &env->fp_status);
1420 #endif
1421     RETURN();
1422 }
1423
1424 /* fdiv - fdiv. */
1425 void OPPROTO op_fdiv (void)
1426 {
1427 #if USE_PRECISE_EMULATION
1428     do_fdiv();
1429 #else
1430     FT0 = float64_div(FT0, FT1, &env->fp_status);
1431 #endif
1432     RETURN();
1433 }
1434
1435 /* fsqrt - fsqrt. */
1436 void OPPROTO op_fsqrt (void)
1437 {
1438     do_fsqrt();
1439     RETURN();
1440 }
1441
1442 /* fre - fre. */
1443 void OPPROTO op_fre (void)
1444 {
1445     do_fre();
1446     RETURN();
1447 }
1448
1449 /* fres - fres. */
1450 void OPPROTO op_fres (void)
1451 {
1452     do_fres();
1453     RETURN();
1454 }
1455
1456 /* frsqrte  - frsqrte. */
1457 void OPPROTO op_frsqrte (void)
1458 {
1459     do_frsqrte();
1460     RETURN();
1461 }
1462
1463 /* fsel - fsel. */
1464 void OPPROTO op_fsel (void)
1465 {
1466     do_fsel();
1467     RETURN();
1468 }
1469
1470 /***                     Floating-Point multiply-and-add                   ***/
1471 /* fmadd - fmadd. */
1472 void OPPROTO op_fmadd (void)
1473 {
1474 #if USE_PRECISE_EMULATION
1475     do_fmadd();
1476 #else
1477     FT0 = float64_mul(FT0, FT1, &env->fp_status);
1478     FT0 = float64_add(FT0, FT2, &env->fp_status);
1479 #endif
1480     RETURN();
1481 }
1482
1483 /* fmsub - fmsub. */
1484 void OPPROTO op_fmsub (void)
1485 {
1486 #if USE_PRECISE_EMULATION
1487     do_fmsub();
1488 #else
1489     FT0 = float64_mul(FT0, FT1, &env->fp_status);
1490     FT0 = float64_sub(FT0, FT2, &env->fp_status);
1491 #endif
1492     RETURN();
1493 }
1494
1495 /* fnmadd - fnmadd. - fnmadds - fnmadds. */
1496 void OPPROTO op_fnmadd (void)
1497 {
1498     do_fnmadd();
1499     RETURN();
1500 }
1501
1502 /* fnmsub - fnmsub. */
1503 void OPPROTO op_fnmsub (void)
1504 {
1505     do_fnmsub();
1506     RETURN();
1507 }
1508
1509 /***                     Floating-Point round & convert                    ***/
1510 /* frsp - frsp. */
1511 void OPPROTO op_frsp (void)
1512 {
1513 #if USE_PRECISE_EMULATION
1514     do_frsp();
1515 #else
1516     FT0 = float64_to_float32(FT0, &env->fp_status);
1517 #endif
1518     RETURN();
1519 }
1520
1521 /* fctiw - fctiw. */
1522 void OPPROTO op_fctiw (void)
1523 {
1524     do_fctiw();
1525     RETURN();
1526 }
1527
1528 /* fctiwz - fctiwz. */
1529 void OPPROTO op_fctiwz (void)
1530 {
1531     do_fctiwz();
1532     RETURN();
1533 }
1534
1535 #if defined(TARGET_PPC64)
1536 /* fcfid - fcfid. */
1537 void OPPROTO op_fcfid (void)
1538 {
1539     do_fcfid();
1540     RETURN();
1541 }
1542
1543 /* fctid - fctid. */
1544 void OPPROTO op_fctid (void)
1545 {
1546     do_fctid();
1547     RETURN();
1548 }
1549
1550 /* fctidz - fctidz. */
1551 void OPPROTO op_fctidz (void)
1552 {
1553     do_fctidz();
1554     RETURN();
1555 }
1556 #endif
1557
1558 void OPPROTO op_frin (void)
1559 {
1560     do_frin();
1561     RETURN();
1562 }
1563
1564 void OPPROTO op_friz (void)
1565 {
1566     do_friz();
1567     RETURN();
1568 }
1569
1570 void OPPROTO op_frip (void)
1571 {
1572     do_frip();
1573     RETURN();
1574 }
1575
1576 void OPPROTO op_frim (void)
1577 {
1578     do_frim();
1579     RETURN();
1580 }
1581
1582 /***                         Floating-Point compare                        ***/
1583 /* fcmpu */
1584 void OPPROTO op_fcmpu (void)
1585 {
1586     do_fcmpu();
1587     RETURN();
1588 }
1589
1590 /* fcmpo */
1591 void OPPROTO op_fcmpo (void)
1592 {
1593     do_fcmpo();
1594     RETURN();
1595 }
1596
1597 /***                         Floating-point move                           ***/
1598 /* fabs */
1599 void OPPROTO op_fabs (void)
1600 {
1601     FT0 = float64_abs(FT0);
1602     RETURN();
1603 }
1604
1605 /* fnabs */
1606 void OPPROTO op_fnabs (void)
1607 {
1608     FT0 = float64_abs(FT0);
1609     FT0 = float64_chs(FT0);
1610     RETURN();
1611 }
1612
1613 /* fneg */
1614 void OPPROTO op_fneg (void)
1615 {
1616     FT0 = float64_chs(FT0);
1617     RETURN();
1618 }
1619
1620 /* Load and store */
1621 #define MEMSUFFIX _raw
1622 #include "op_helper.h"
1623 #include "op_mem.h"
1624 #if !defined(CONFIG_USER_ONLY)
1625 #define MEMSUFFIX _user
1626 #include "op_helper.h"
1627 #include "op_mem.h"
1628 #define MEMSUFFIX _kernel
1629 #include "op_helper.h"
1630 #include "op_mem.h"
1631 #define MEMSUFFIX _hypv
1632 #include "op_helper.h"
1633 #include "op_mem.h"
1634 #endif
1635
1636 /* Special op to check and maybe clear reservation */
1637 void OPPROTO op_check_reservation (void)
1638 {
1639     if ((uint32_t)env->reserve == (uint32_t)(T0 & ~0x00000003))
1640         env->reserve = (target_ulong)-1ULL;
1641     RETURN();
1642 }
1643
1644 #if defined(TARGET_PPC64)
1645 void OPPROTO op_check_reservation_64 (void)
1646 {
1647     if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003))
1648         env->reserve = (target_ulong)-1ULL;
1649     RETURN();
1650 }
1651 #endif
1652
1653 void OPPROTO op_wait (void)
1654 {
1655     env->halted = 1;
1656     RETURN();
1657 }
1658
1659 /* Return from interrupt */
1660 #if !defined(CONFIG_USER_ONLY)
1661 void OPPROTO op_rfi (void)
1662 {
1663     do_rfi();
1664     RETURN();
1665 }
1666
1667 #if defined(TARGET_PPC64)
1668 void OPPROTO op_rfid (void)
1669 {
1670     do_rfid();
1671     RETURN();
1672 }
1673
1674 void OPPROTO op_hrfid (void)
1675 {
1676     do_hrfid();
1677     RETURN();
1678 }
1679 #endif
1680
1681 /* Exception vectors */
1682 void OPPROTO op_store_excp_prefix (void)
1683 {
1684     T0 &= env->ivpr_mask;
1685     env->excp_prefix = T0;
1686     RETURN();
1687 }
1688
1689 void OPPROTO op_store_excp_vector (void)
1690 {
1691     T0 &= env->ivor_mask;
1692     env->excp_vectors[PARAM1] = T0;
1693     RETURN();
1694 }
1695 #endif
1696
1697 /* Trap word */
1698 void OPPROTO op_tw (void)
1699 {
1700     do_tw(PARAM1);
1701     RETURN();
1702 }
1703
1704 #if defined(TARGET_PPC64)
1705 void OPPROTO op_td (void)
1706 {
1707     do_td(PARAM1);
1708     RETURN();
1709 }
1710 #endif
1711
1712 #if !defined(CONFIG_USER_ONLY)
1713 /* tlbia */
1714 void OPPROTO op_tlbia (void)
1715 {
1716     ppc_tlb_invalidate_all(env);
1717     RETURN();
1718 }
1719
1720 /* tlbie */
1721 void OPPROTO op_tlbie (void)
1722 {
1723     ppc_tlb_invalidate_one(env, (uint32_t)T0);
1724     RETURN();
1725 }
1726
1727 #if defined(TARGET_PPC64)
1728 void OPPROTO op_tlbie_64 (void)
1729 {
1730     ppc_tlb_invalidate_one(env, T0);
1731     RETURN();
1732 }
1733 #endif
1734
1735 #if defined(TARGET_PPC64)
1736 void OPPROTO op_slbia (void)
1737 {
1738     ppc_slb_invalidate_all(env);
1739     RETURN();
1740 }
1741
1742 void OPPROTO op_slbie (void)
1743 {
1744     ppc_slb_invalidate_one(env, (uint32_t)T0);
1745     RETURN();
1746 }
1747
1748 void OPPROTO op_slbie_64 (void)
1749 {
1750     ppc_slb_invalidate_one(env, T0);
1751     RETURN();
1752 }
1753 #endif
1754 #endif
1755
1756 #if !defined(CONFIG_USER_ONLY)
1757 /* PowerPC 602/603/755 software TLB load instructions */
1758 void OPPROTO op_6xx_tlbld (void)
1759 {
1760     do_load_6xx_tlb(0);
1761     RETURN();
1762 }
1763
1764 void OPPROTO op_6xx_tlbli (void)
1765 {
1766     do_load_6xx_tlb(1);
1767     RETURN();
1768 }
1769
1770 /* PowerPC 74xx software TLB load instructions */
1771 void OPPROTO op_74xx_tlbld (void)
1772 {
1773     do_load_74xx_tlb(0);
1774     RETURN();
1775 }
1776
1777 void OPPROTO op_74xx_tlbli (void)
1778 {
1779     do_load_74xx_tlb(1);
1780     RETURN();
1781 }
1782 #endif
1783
1784 /* 601 specific */
1785 void OPPROTO op_load_601_rtcl (void)
1786 {
1787     T0 = cpu_ppc601_load_rtcl(env);
1788     RETURN();
1789 }
1790
1791 void OPPROTO op_load_601_rtcu (void)
1792 {
1793     T0 = cpu_ppc601_load_rtcu(env);
1794     RETURN();
1795 }
1796
1797 #if !defined(CONFIG_USER_ONLY)
1798 void OPPROTO op_store_601_rtcl (void)
1799 {
1800     cpu_ppc601_store_rtcl(env, T0);
1801     RETURN();
1802 }
1803
1804 void OPPROTO op_store_601_rtcu (void)
1805 {
1806     cpu_ppc601_store_rtcu(env, T0);
1807     RETURN();
1808 }
1809
1810 void OPPROTO op_store_hid0_601 (void)
1811 {
1812     do_store_hid0_601();
1813     RETURN();
1814 }
1815
1816 void OPPROTO op_load_601_bat (void)
1817 {
1818     T0 = env->IBAT[PARAM1][PARAM2];
1819     RETURN();
1820 }
1821
1822 void OPPROTO op_store_601_batl (void)
1823 {
1824     do_store_ibatl_601(env, PARAM1, T0);
1825     RETURN();
1826 }
1827
1828 void OPPROTO op_store_601_batu (void)
1829 {
1830     do_store_ibatu_601(env, PARAM1, T0);
1831     RETURN();
1832 }
1833 #endif /* !defined(CONFIG_USER_ONLY) */
1834
1835 /* PowerPC 601 specific instructions (POWER bridge) */
1836 /* XXX: those micro-ops need tests ! */
1837 void OPPROTO op_POWER_abs (void)
1838 {
1839     if ((int32_t)T0 == INT32_MIN)
1840         T0 = INT32_MAX;
1841     else if ((int32_t)T0 < 0)
1842         T0 = -T0;
1843     RETURN();
1844 }
1845
1846 void OPPROTO op_POWER_abso (void)
1847 {
1848     do_POWER_abso();
1849     RETURN();
1850 }
1851
1852 void OPPROTO op_POWER_clcs (void)
1853 {
1854     do_POWER_clcs();
1855     RETURN();
1856 }
1857
1858 void OPPROTO op_POWER_div (void)
1859 {
1860     do_POWER_div();
1861     RETURN();
1862 }
1863
1864 void OPPROTO op_POWER_divo (void)
1865 {
1866     do_POWER_divo();
1867     RETURN();
1868 }
1869
1870 void OPPROTO op_POWER_divs (void)
1871 {
1872     do_POWER_divs();
1873     RETURN();
1874 }
1875
1876 void OPPROTO op_POWER_divso (void)
1877 {
1878     do_POWER_divso();
1879     RETURN();
1880 }
1881
1882 void OPPROTO op_POWER_doz (void)
1883 {
1884     if ((int32_t)T1 > (int32_t)T0)
1885         T0 = T1 - T0;
1886     else
1887         T0 = 0;
1888     RETURN();
1889 }
1890
1891 void OPPROTO op_POWER_dozo (void)
1892 {
1893     do_POWER_dozo();
1894     RETURN();
1895 }
1896
1897 void OPPROTO op_load_xer_cmp (void)
1898 {
1899     T2 = xer_cmp;
1900     RETURN();
1901 }
1902
1903 void OPPROTO op_POWER_maskg (void)
1904 {
1905     do_POWER_maskg();
1906     RETURN();
1907 }
1908
1909 void OPPROTO op_POWER_maskir (void)
1910 {
1911     T0 = (T0 & ~T2) | (T1 & T2);
1912     RETURN();
1913 }
1914
1915 void OPPROTO op_POWER_mul (void)
1916 {
1917     uint64_t tmp;
1918
1919     tmp = (uint64_t)T0 * (uint64_t)T1;
1920     env->spr[SPR_MQ] = tmp >> 32;
1921     T0 = tmp;
1922     RETURN();
1923 }
1924
1925 void OPPROTO op_POWER_mulo (void)
1926 {
1927     do_POWER_mulo();
1928     RETURN();
1929 }
1930
1931 void OPPROTO op_POWER_nabs (void)
1932 {
1933     if (T0 > 0)
1934         T0 = -T0;
1935     RETURN();
1936 }
1937
1938 void OPPROTO op_POWER_nabso (void)
1939 {
1940     /* nabs never overflows */
1941     if (T0 > 0)
1942         T0 = -T0;
1943     env->xer &= ~(1 << XER_OV);
1944     RETURN();
1945 }
1946
1947 /* XXX: factorise POWER rotates... */
1948 void OPPROTO op_POWER_rlmi (void)
1949 {
1950     T0 = rotl32(T0, T2) & PARAM1;
1951     T0 |= T1 & (uint32_t)PARAM2;
1952     RETURN();
1953 }
1954
1955 void OPPROTO op_POWER_rrib (void)
1956 {
1957     T2 &= 0x1FUL;
1958     T0 = rotl32(T0 & INT32_MIN, T2);
1959     T0 |= T1 & ~rotl32(INT32_MIN, T2);
1960     RETURN();
1961 }
1962
1963 void OPPROTO op_POWER_sle (void)
1964 {
1965     T1 &= 0x1FUL;
1966     env->spr[SPR_MQ] = rotl32(T0, T1);
1967     T0 = T0 << T1;
1968     RETURN();
1969 }
1970
1971 void OPPROTO op_POWER_sleq (void)
1972 {
1973     uint32_t tmp = env->spr[SPR_MQ];
1974
1975     T1 &= 0x1FUL;
1976     env->spr[SPR_MQ] = rotl32(T0, T1);
1977     T0 = T0 << T1;
1978     T0 |= tmp >> (32 - T1);
1979     RETURN();
1980 }
1981
1982 void OPPROTO op_POWER_sllq (void)
1983 {
1984     uint32_t msk = UINT32_MAX;
1985
1986     msk = msk << (T1 & 0x1FUL);
1987     if (T1 & 0x20UL)
1988         msk = ~msk;
1989     T1 &= 0x1FUL;
1990     T0 = (T0 << T1) & msk;
1991     T0 |= env->spr[SPR_MQ] & ~msk;
1992     RETURN();
1993 }
1994
1995 void OPPROTO op_POWER_slq (void)
1996 {
1997     uint32_t msk = UINT32_MAX, tmp;
1998
1999     msk = msk << (T1 & 0x1FUL);
2000     if (T1 & 0x20UL)
2001         msk = ~msk;
2002     T1 &= 0x1FUL;
2003     tmp = rotl32(T0, T1);
2004     T0 = tmp & msk;
2005     env->spr[SPR_MQ] = tmp;
2006     RETURN();
2007 }
2008
2009 void OPPROTO op_POWER_sraq (void)
2010 {
2011     env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL));
2012     if (T1 & 0x20UL)
2013         T0 = UINT32_MAX;
2014     else
2015         T0 = (int32_t)T0 >> T1;
2016     RETURN();
2017 }
2018
2019 void OPPROTO op_POWER_sre (void)
2020 {
2021     T1 &= 0x1FUL;
2022     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2023     T0 = (int32_t)T0 >> T1;
2024     RETURN();
2025 }
2026
2027 void OPPROTO op_POWER_srea (void)
2028 {
2029     T1 &= 0x1FUL;
2030     env->spr[SPR_MQ] = T0 >> T1;
2031     T0 = (int32_t)T0 >> T1;
2032     RETURN();
2033 }
2034
2035 void OPPROTO op_POWER_sreq (void)
2036 {
2037     uint32_t tmp;
2038     int32_t msk;
2039
2040     T1 &= 0x1FUL;
2041     msk = INT32_MIN >> T1;
2042     tmp = env->spr[SPR_MQ];
2043     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2044     T0 = T0 >> T1;
2045     T0 |= tmp & msk;
2046     RETURN();
2047 }
2048
2049 void OPPROTO op_POWER_srlq (void)
2050 {
2051     uint32_t tmp;
2052     int32_t msk;
2053
2054     msk = INT32_MIN >> (T1 & 0x1FUL);
2055     if (T1 & 0x20UL)
2056         msk = ~msk;
2057     T1 &= 0x1FUL;
2058     tmp = env->spr[SPR_MQ];
2059     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2060     T0 = T0 >> T1;
2061     T0 &= msk;
2062     T0 |= tmp & ~msk;
2063     RETURN();
2064 }
2065
2066 void OPPROTO op_POWER_srq (void)
2067 {
2068     T1 &= 0x1FUL;
2069     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2070     T0 = T0 >> T1;
2071     RETURN();
2072 }
2073
2074 /* POWER instructions not implemented in PowerPC 601 */
2075 #if !defined(CONFIG_USER_ONLY)
2076 void OPPROTO op_POWER_mfsri (void)
2077 {
2078     T1 = T0 >> 28;
2079     T0 = env->sr[T1];
2080     RETURN();
2081 }
2082
2083 void OPPROTO op_POWER_rac (void)
2084 {
2085     do_POWER_rac();
2086     RETURN();
2087 }
2088
2089 void OPPROTO op_POWER_rfsvc (void)
2090 {
2091     do_POWER_rfsvc();
2092     RETURN();
2093 }
2094 #endif
2095
2096 /* PowerPC 602 specific instruction */
2097 #if !defined(CONFIG_USER_ONLY)
2098 void OPPROTO op_602_mfrom (void)
2099 {
2100     do_op_602_mfrom();
2101     RETURN();
2102 }
2103 #endif
2104
2105 /* PowerPC 4xx specific micro-ops */
2106 void OPPROTO op_405_add_T0_T2 (void)
2107 {
2108     T0 = (int32_t)T0 + (int32_t)T2;
2109     RETURN();
2110 }
2111
2112 void OPPROTO op_405_mulchw (void)
2113 {
2114     T0 = ((int16_t)T0) * ((int16_t)(T1 >> 16));
2115     RETURN();
2116 }
2117
2118 void OPPROTO op_405_mulchwu (void)
2119 {
2120     T0 = ((uint16_t)T0) * ((uint16_t)(T1 >> 16));
2121     RETURN();
2122 }
2123
2124 void OPPROTO op_405_mulhhw (void)
2125 {
2126     T0 = ((int16_t)(T0 >> 16)) * ((int16_t)(T1 >> 16));
2127     RETURN();
2128 }
2129
2130 void OPPROTO op_405_mulhhwu (void)
2131 {
2132     T0 = ((uint16_t)(T0 >> 16)) * ((uint16_t)(T1 >> 16));
2133     RETURN();
2134 }
2135
2136 void OPPROTO op_405_mullhw (void)
2137 {
2138     T0 = ((int16_t)T0) * ((int16_t)T1);
2139     RETURN();
2140 }
2141
2142 void OPPROTO op_405_mullhwu (void)
2143 {
2144     T0 = ((uint16_t)T0) * ((uint16_t)T1);
2145     RETURN();
2146 }
2147
2148 void OPPROTO op_405_check_sat (void)
2149 {
2150     do_405_check_sat();
2151     RETURN();
2152 }
2153
2154 void OPPROTO op_405_check_ovu (void)
2155 {
2156     if (likely(T0 >= T2)) {
2157         env->xer &= ~(1 << XER_OV);
2158     } else {
2159         env->xer |= (1 << XER_OV) | (1 << XER_SO);
2160     }
2161     RETURN();
2162 }
2163
2164 void OPPROTO op_405_check_satu (void)
2165 {
2166     if (unlikely(T0 < T2)) {
2167         /* Saturate result */
2168         T0 = UINT32_MAX;
2169     }
2170     RETURN();
2171 }
2172
2173 void OPPROTO op_load_dcr (void)
2174 {
2175     do_load_dcr();
2176     RETURN();
2177 }
2178
2179 void OPPROTO op_store_dcr (void)
2180 {
2181     do_store_dcr();
2182     RETURN();
2183 }
2184
2185 #if !defined(CONFIG_USER_ONLY)
2186 /* Return from critical interrupt :
2187  * same as rfi, except nip & MSR are loaded from SRR2/3 instead of SRR0/1
2188  */
2189 void OPPROTO op_40x_rfci (void)
2190 {
2191     do_40x_rfci();
2192     RETURN();
2193 }
2194
2195 void OPPROTO op_rfci (void)
2196 {
2197     do_rfci();
2198     RETURN();
2199 }
2200
2201 void OPPROTO op_rfdi (void)
2202 {
2203     do_rfdi();
2204     RETURN();
2205 }
2206
2207 void OPPROTO op_rfmci (void)
2208 {
2209     do_rfmci();
2210     RETURN();
2211 }
2212
2213 void OPPROTO op_wrte (void)
2214 {
2215     /* We don't call do_store_msr here as we won't trigger
2216      * any special case nor change hflags
2217      */
2218     T0 &= 1 << MSR_EE;
2219     env->msr &= ~(1 << MSR_EE);
2220     env->msr |= T0;
2221     RETURN();
2222 }
2223
2224 void OPPROTO op_440_tlbre (void)
2225 {
2226     do_440_tlbre(PARAM1);
2227     RETURN();
2228 }
2229
2230 void OPPROTO op_440_tlbsx (void)
2231 {
2232     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_440_MMUCR] & 0xFF);
2233     RETURN();
2234 }
2235
2236 void OPPROTO op_4xx_tlbsx_check (void)
2237 {
2238     int tmp;
2239
2240     tmp = xer_so;
2241     if ((int)T0 != -1)
2242         tmp |= 0x02;
2243     env->crf[0] = tmp;
2244     RETURN();
2245 }
2246
2247 void OPPROTO op_440_tlbwe (void)
2248 {
2249     do_440_tlbwe(PARAM1);
2250     RETURN();
2251 }
2252
2253 void OPPROTO op_4xx_tlbre_lo (void)
2254 {
2255     do_4xx_tlbre_lo();
2256     RETURN();
2257 }
2258
2259 void OPPROTO op_4xx_tlbre_hi (void)
2260 {
2261     do_4xx_tlbre_hi();
2262     RETURN();
2263 }
2264
2265 void OPPROTO op_4xx_tlbsx (void)
2266 {
2267     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_40x_PID]);
2268     RETURN();
2269 }
2270
2271 void OPPROTO op_4xx_tlbwe_lo (void)
2272 {
2273     do_4xx_tlbwe_lo();
2274     RETURN();
2275 }
2276
2277 void OPPROTO op_4xx_tlbwe_hi (void)
2278 {
2279     do_4xx_tlbwe_hi();
2280     RETURN();
2281 }
2282 #endif
2283
2284 /* SPR micro-ops */
2285 /* 440 specific */
2286 void OPPROTO op_440_dlmzb (void)
2287 {
2288     do_440_dlmzb();
2289     RETURN();
2290 }
2291
2292 void OPPROTO op_440_dlmzb_update_Rc (void)
2293 {
2294     if (T0 == 8)
2295         T0 = 0x2;
2296     else if (T0 < 4)
2297         T0 = 0x4;
2298     else
2299         T0 = 0x8;
2300     RETURN();
2301 }
2302
2303 #if !defined(CONFIG_USER_ONLY)
2304 void OPPROTO op_store_pir (void)
2305 {
2306     env->spr[SPR_PIR] = T0 & 0x0000000FUL;
2307     RETURN();
2308 }
2309
2310 void OPPROTO op_load_403_pb (void)
2311 {
2312     do_load_403_pb(PARAM1);
2313     RETURN();
2314 }
2315
2316 void OPPROTO op_store_403_pb (void)
2317 {
2318     do_store_403_pb(PARAM1);
2319     RETURN();
2320 }
2321
2322 void OPPROTO op_load_40x_pit (void)
2323 {
2324     T0 = load_40x_pit(env);
2325     RETURN();
2326 }
2327
2328 void OPPROTO op_store_40x_pit (void)
2329 {
2330     store_40x_pit(env, T0);
2331     RETURN();
2332 }
2333
2334 void OPPROTO op_store_40x_dbcr0 (void)
2335 {
2336     store_40x_dbcr0(env, T0);
2337     RETURN();
2338 }
2339
2340 void OPPROTO op_store_40x_sler (void)
2341 {
2342     store_40x_sler(env, T0);
2343     RETURN();
2344 }
2345
2346 void OPPROTO op_store_booke_tcr (void)
2347 {
2348     store_booke_tcr(env, T0);
2349     RETURN();
2350 }
2351
2352 void OPPROTO op_store_booke_tsr (void)
2353 {
2354     store_booke_tsr(env, T0);
2355     RETURN();
2356 }
2357 #endif /* !defined(CONFIG_USER_ONLY) */
2358
2359 /* SPE extension */
2360 void OPPROTO op_splatw_T1_64 (void)
2361 {
2362     T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2363     RETURN();
2364 }
2365
2366 void OPPROTO op_splatwi_T0_64 (void)
2367 {
2368     uint64_t tmp = PARAM1;
2369
2370     T0_64 = (tmp << 32) | tmp;
2371     RETURN();
2372 }
2373
2374 void OPPROTO op_splatwi_T1_64 (void)
2375 {
2376     uint64_t tmp = PARAM1;
2377
2378     T1_64 = (tmp << 32) | tmp;
2379     RETURN();
2380 }
2381
2382 void OPPROTO op_extsh_T1_64 (void)
2383 {
2384     T1_64 = (int32_t)((int16_t)T1_64);
2385     RETURN();
2386 }
2387
2388 void OPPROTO op_sli16_T1_64 (void)
2389 {
2390     T1_64 = T1_64 << 16;
2391     RETURN();
2392 }
2393
2394 void OPPROTO op_sli32_T1_64 (void)
2395 {
2396     T1_64 = T1_64 << 32;
2397     RETURN();
2398 }
2399
2400 void OPPROTO op_srli32_T1_64 (void)
2401 {
2402     T1_64 = T1_64 >> 32;
2403     RETURN();
2404 }
2405
2406 void OPPROTO op_evsel (void)
2407 {
2408     do_evsel();
2409     RETURN();
2410 }
2411
2412 void OPPROTO op_evaddw (void)
2413 {
2414     do_evaddw();
2415     RETURN();
2416 }
2417
2418 void OPPROTO op_evsubfw (void)
2419 {
2420     do_evsubfw();
2421     RETURN();
2422 }
2423
2424 void OPPROTO op_evneg (void)
2425 {
2426     do_evneg();
2427     RETURN();
2428 }
2429
2430 void OPPROTO op_evabs (void)
2431 {
2432     do_evabs();
2433     RETURN();
2434 }
2435
2436 void OPPROTO op_evextsh (void)
2437 {
2438     T0_64 = ((uint64_t)((int32_t)(int16_t)(T0_64 >> 32)) << 32) |
2439         (uint64_t)((int32_t)(int16_t)T0_64);
2440     RETURN();
2441 }
2442
2443 void OPPROTO op_evextsb (void)
2444 {
2445     T0_64 = ((uint64_t)((int32_t)(int8_t)(T0_64 >> 32)) << 32) |
2446         (uint64_t)((int32_t)(int8_t)T0_64);
2447     RETURN();
2448 }
2449
2450 void OPPROTO op_evcntlzw (void)
2451 {
2452     do_evcntlzw();
2453     RETURN();
2454 }
2455
2456 void OPPROTO op_evrndw (void)
2457 {
2458     do_evrndw();
2459     RETURN();
2460 }
2461
2462 void OPPROTO op_brinc (void)
2463 {
2464     do_brinc();
2465     RETURN();
2466 }
2467
2468 void OPPROTO op_evcntlsw (void)
2469 {
2470     do_evcntlsw();
2471     RETURN();
2472 }
2473
2474 void OPPROTO op_evsrws (void)
2475 {
2476     do_evsrws();
2477     RETURN();
2478 }
2479
2480 void OPPROTO op_evsrwu (void)
2481 {
2482     do_evsrwu();
2483     RETURN();
2484 }
2485
2486 void OPPROTO op_evslw (void)
2487 {
2488     do_evslw();
2489     RETURN();
2490 }
2491
2492 void OPPROTO op_evrlw (void)
2493 {
2494     do_evrlw();
2495     RETURN();
2496 }
2497
2498 void OPPROTO op_evmergelo (void)
2499 {
2500     T0_64 = (T0_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2501     RETURN();
2502 }
2503
2504 void OPPROTO op_evmergehi (void)
2505 {
2506     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 >> 32);
2507     RETURN();
2508 }
2509
2510 void OPPROTO op_evmergelohi (void)
2511 {
2512     T0_64 = (T0_64 << 32) | (T1_64 >> 32);
2513     RETURN();
2514 }
2515
2516 void OPPROTO op_evmergehilo (void)
2517 {
2518     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 & 0x00000000FFFFFFFFULL);
2519     RETURN();
2520 }
2521
2522 void OPPROTO op_evcmpgts (void)
2523 {
2524     do_evcmpgts();
2525     RETURN();
2526 }
2527
2528 void OPPROTO op_evcmpgtu (void)
2529 {
2530     do_evcmpgtu();
2531     RETURN();
2532 }
2533
2534 void OPPROTO op_evcmplts (void)
2535 {
2536     do_evcmplts();
2537     RETURN();
2538 }
2539
2540 void OPPROTO op_evcmpltu (void)
2541 {
2542     do_evcmpltu();
2543     RETURN();
2544 }
2545
2546 void OPPROTO op_evcmpeq (void)
2547 {
2548     do_evcmpeq();
2549     RETURN();
2550 }
2551
2552 void OPPROTO op_evfssub (void)
2553 {
2554     do_evfssub();
2555     RETURN();
2556 }
2557
2558 void OPPROTO op_evfsadd (void)
2559 {
2560     do_evfsadd();
2561     RETURN();
2562 }
2563
2564 void OPPROTO op_evfsnabs (void)
2565 {
2566     do_evfsnabs();
2567     RETURN();
2568 }
2569
2570 void OPPROTO op_evfsabs (void)
2571 {
2572     do_evfsabs();
2573     RETURN();
2574 }
2575
2576 void OPPROTO op_evfsneg (void)
2577 {
2578     do_evfsneg();
2579     RETURN();
2580 }
2581
2582 void OPPROTO op_evfsdiv (void)
2583 {
2584     do_evfsdiv();
2585     RETURN();
2586 }
2587
2588 void OPPROTO op_evfsmul (void)
2589 {
2590     do_evfsmul();
2591     RETURN();
2592 }
2593
2594 void OPPROTO op_evfscmplt (void)
2595 {
2596     do_evfscmplt();
2597     RETURN();
2598 }
2599
2600 void OPPROTO op_evfscmpgt (void)
2601 {
2602     do_evfscmpgt();
2603     RETURN();
2604 }
2605
2606 void OPPROTO op_evfscmpeq (void)
2607 {
2608     do_evfscmpeq();
2609     RETURN();
2610 }
2611
2612 void OPPROTO op_evfscfsi (void)
2613 {
2614     do_evfscfsi();
2615     RETURN();
2616 }
2617
2618 void OPPROTO op_evfscfui (void)
2619 {
2620     do_evfscfui();
2621     RETURN();
2622 }
2623
2624 void OPPROTO op_evfscfsf (void)
2625 {
2626     do_evfscfsf();
2627     RETURN();
2628 }
2629
2630 void OPPROTO op_evfscfuf (void)
2631 {
2632     do_evfscfuf();
2633     RETURN();
2634 }
2635
2636 void OPPROTO op_evfsctsi (void)
2637 {
2638     do_evfsctsi();
2639     RETURN();
2640 }
2641
2642 void OPPROTO op_evfsctui (void)
2643 {
2644     do_evfsctui();
2645     RETURN();
2646 }
2647
2648 void OPPROTO op_evfsctsf (void)
2649 {
2650     do_evfsctsf();
2651     RETURN();
2652 }
2653
2654 void OPPROTO op_evfsctuf (void)
2655 {
2656     do_evfsctuf();
2657     RETURN();
2658 }
2659
2660 void OPPROTO op_evfsctuiz (void)
2661 {
2662     do_evfsctuiz();
2663     RETURN();
2664 }
2665
2666 void OPPROTO op_evfsctsiz (void)
2667 {
2668     do_evfsctsiz();
2669     RETURN();
2670 }
2671
2672 void OPPROTO op_evfststlt (void)
2673 {
2674     do_evfststlt();
2675     RETURN();
2676 }
2677
2678 void OPPROTO op_evfststgt (void)
2679 {
2680     do_evfststgt();
2681     RETURN();
2682 }
2683
2684 void OPPROTO op_evfststeq (void)
2685 {
2686     do_evfststeq();
2687     RETURN();
2688 }
2689
2690 void OPPROTO op_efssub (void)
2691 {
2692     T0_64 = _do_efssub(T0_64, T1_64);
2693     RETURN();
2694 }
2695
2696 void OPPROTO op_efsadd (void)
2697 {
2698     T0_64 = _do_efsadd(T0_64, T1_64);
2699     RETURN();
2700 }
2701
2702 void OPPROTO op_efsnabs (void)
2703 {
2704     T0_64 = _do_efsnabs(T0_64);
2705     RETURN();
2706 }
2707
2708 void OPPROTO op_efsabs (void)
2709 {
2710     T0_64 = _do_efsabs(T0_64);
2711     RETURN();
2712 }
2713
2714 void OPPROTO op_efsneg (void)
2715 {
2716     T0_64 = _do_efsneg(T0_64);
2717     RETURN();
2718 }
2719
2720 void OPPROTO op_efsdiv (void)
2721 {
2722     T0_64 = _do_efsdiv(T0_64, T1_64);
2723     RETURN();
2724 }
2725
2726 void OPPROTO op_efsmul (void)
2727 {
2728     T0_64 = _do_efsmul(T0_64, T1_64);
2729     RETURN();
2730 }
2731
2732 void OPPROTO op_efscmplt (void)
2733 {
2734     do_efscmplt();
2735     RETURN();
2736 }
2737
2738 void OPPROTO op_efscmpgt (void)
2739 {
2740     do_efscmpgt();
2741     RETURN();
2742 }
2743
2744 void OPPROTO op_efscfd (void)
2745 {
2746     do_efscfd();
2747     RETURN();
2748 }
2749
2750 void OPPROTO op_efscmpeq (void)
2751 {
2752     do_efscmpeq();
2753     RETURN();
2754 }
2755
2756 void OPPROTO op_efscfsi (void)
2757 {
2758     do_efscfsi();
2759     RETURN();
2760 }
2761
2762 void OPPROTO op_efscfui (void)
2763 {
2764     do_efscfui();
2765     RETURN();
2766 }
2767
2768 void OPPROTO op_efscfsf (void)
2769 {
2770     do_efscfsf();
2771     RETURN();
2772 }
2773
2774 void OPPROTO op_efscfuf (void)
2775 {
2776     do_efscfuf();
2777     RETURN();
2778 }
2779
2780 void OPPROTO op_efsctsi (void)
2781 {
2782     do_efsctsi();
2783     RETURN();
2784 }
2785
2786 void OPPROTO op_efsctui (void)
2787 {
2788     do_efsctui();
2789     RETURN();
2790 }
2791
2792 void OPPROTO op_efsctsf (void)
2793 {
2794     do_efsctsf();
2795     RETURN();
2796 }
2797
2798 void OPPROTO op_efsctuf (void)
2799 {
2800     do_efsctuf();
2801     RETURN();
2802 }
2803
2804 void OPPROTO op_efsctsiz (void)
2805 {
2806     do_efsctsiz();
2807     RETURN();
2808 }
2809
2810 void OPPROTO op_efsctuiz (void)
2811 {
2812     do_efsctuiz();
2813     RETURN();
2814 }
2815
2816 void OPPROTO op_efststlt (void)
2817 {
2818     T0 = _do_efststlt(T0_64, T1_64);
2819     RETURN();
2820 }
2821
2822 void OPPROTO op_efststgt (void)
2823 {
2824     T0 = _do_efststgt(T0_64, T1_64);
2825     RETURN();
2826 }
2827
2828 void OPPROTO op_efststeq (void)
2829 {
2830     T0 = _do_efststeq(T0_64, T1_64);
2831     RETURN();
2832 }
2833
2834 void OPPROTO op_efdsub (void)
2835 {
2836     CPU_DoubleU u1, u2;
2837     u1.ll = T0_64;
2838     u2.ll = T1_64;
2839     u1.d = float64_sub(u1.d, u2.d, &env->spe_status);
2840     T0_64 = u1.ll;
2841     RETURN();
2842 }
2843
2844 void OPPROTO op_efdadd (void)
2845 {
2846     CPU_DoubleU u1, u2;
2847     u1.ll = T0_64;
2848     u2.ll = T1_64;
2849     u1.d = float64_add(u1.d, u2.d, &env->spe_status);
2850     T0_64 = u1.ll;
2851     RETURN();
2852 }
2853
2854 void OPPROTO op_efdcfsid (void)
2855 {
2856     do_efdcfsi();
2857     RETURN();
2858 }
2859
2860 void OPPROTO op_efdcfuid (void)
2861 {
2862     do_efdcfui();
2863     RETURN();
2864 }
2865
2866 void OPPROTO op_efdnabs (void)
2867 {
2868     T0_64 |= 0x8000000000000000ULL;
2869     RETURN();
2870 }
2871
2872 void OPPROTO op_efdabs (void)
2873 {
2874     T0_64 &= ~0x8000000000000000ULL;
2875     RETURN();
2876 }
2877
2878 void OPPROTO op_efdneg (void)
2879 {
2880     T0_64 ^= 0x8000000000000000ULL;
2881     RETURN();
2882 }
2883
2884 void OPPROTO op_efddiv (void)
2885 {
2886     CPU_DoubleU u1, u2;
2887     u1.ll = T0_64;
2888     u2.ll = T1_64;
2889     u1.d = float64_div(u1.d, u2.d, &env->spe_status);
2890     T0_64 = u1.ll;
2891     RETURN();
2892 }
2893
2894 void OPPROTO op_efdmul (void)
2895 {
2896     CPU_DoubleU u1, u2;
2897     u1.ll = T0_64;
2898     u2.ll = T1_64;
2899     u1.d = float64_mul(u1.d, u2.d, &env->spe_status);
2900     T0_64 = u1.ll;
2901     RETURN();
2902 }
2903
2904 void OPPROTO op_efdctsidz (void)
2905 {
2906     do_efdctsiz();
2907     RETURN();
2908 }
2909
2910 void OPPROTO op_efdctuidz (void)
2911 {
2912     do_efdctuiz();
2913     RETURN();
2914 }
2915
2916 void OPPROTO op_efdcmplt (void)
2917 {
2918     do_efdcmplt();
2919     RETURN();
2920 }
2921
2922 void OPPROTO op_efdcmpgt (void)
2923 {
2924     do_efdcmpgt();
2925     RETURN();
2926 }
2927
2928 void OPPROTO op_efdcfs (void)
2929 {
2930     do_efdcfs();
2931     RETURN();
2932 }
2933
2934 void OPPROTO op_efdcmpeq (void)
2935 {
2936     do_efdcmpeq();
2937     RETURN();
2938 }
2939
2940 void OPPROTO op_efdcfsi (void)
2941 {
2942     do_efdcfsi();
2943     RETURN();
2944 }
2945
2946 void OPPROTO op_efdcfui (void)
2947 {
2948     do_efdcfui();
2949     RETURN();
2950 }
2951
2952 void OPPROTO op_efdcfsf (void)
2953 {
2954     do_efdcfsf();
2955     RETURN();
2956 }
2957
2958 void OPPROTO op_efdcfuf (void)
2959 {
2960     do_efdcfuf();
2961     RETURN();
2962 }
2963
2964 void OPPROTO op_efdctsi (void)
2965 {
2966     do_efdctsi();
2967     RETURN();
2968 }
2969
2970 void OPPROTO op_efdctui (void)
2971 {
2972     do_efdctui();
2973     RETURN();
2974 }
2975
2976 void OPPROTO op_efdctsf (void)
2977 {
2978     do_efdctsf();
2979     RETURN();
2980 }
2981
2982 void OPPROTO op_efdctuf (void)
2983 {
2984     do_efdctuf();
2985     RETURN();
2986 }
2987
2988 void OPPROTO op_efdctuiz (void)
2989 {
2990     do_efdctuiz();
2991     RETURN();
2992 }
2993
2994 void OPPROTO op_efdctsiz (void)
2995 {
2996     do_efdctsiz();
2997     RETURN();
2998 }
2999
3000 void OPPROTO op_efdtstlt (void)
3001 {
3002     T0 = _do_efdtstlt(T0_64, T1_64);
3003     RETURN();
3004 }
3005
3006 void OPPROTO op_efdtstgt (void)
3007 {
3008     T0 = _do_efdtstgt(T0_64, T1_64);
3009     RETURN();
3010 }
3011
3012 void OPPROTO op_efdtsteq (void)
3013 {
3014     T0 = _do_efdtsteq(T0_64, T1_64);
3015     RETURN();
3016 }