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