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 #if defined(TARGET_PPC64H)
1991 #define MEMSUFFIX _hypv
1992 #include "op_helper.h"
1993 #include "op_mem.h"
1994 #endif
1995 #endif
1996
1997 /* Special op to check and maybe clear reservation */
1998 void OPPROTO op_check_reservation (void)
1999 {
2000     if ((uint32_t)env->reserve == (uint32_t)(T0 & ~0x00000003))
2001         env->reserve = (target_ulong)-1ULL;
2002     RETURN();
2003 }
2004
2005 #if defined(TARGET_PPC64)
2006 void OPPROTO op_check_reservation_64 (void)
2007 {
2008     if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003))
2009         env->reserve = (target_ulong)-1ULL;
2010     RETURN();
2011 }
2012 #endif
2013
2014 void OPPROTO op_wait (void)
2015 {
2016     env->halted = 1;
2017     RETURN();
2018 }
2019
2020 /* Return from interrupt */
2021 #if !defined(CONFIG_USER_ONLY)
2022 void OPPROTO op_rfi (void)
2023 {
2024     do_rfi();
2025     RETURN();
2026 }
2027
2028 #if defined(TARGET_PPC64)
2029 void OPPROTO op_rfid (void)
2030 {
2031     do_rfid();
2032     RETURN();
2033 }
2034 #endif
2035
2036 #if defined(TARGET_PPC64H)
2037 void OPPROTO op_hrfid (void)
2038 {
2039     do_hrfid();
2040     RETURN();
2041 }
2042 #endif
2043
2044 /* Exception vectors */
2045 void OPPROTO op_store_excp_prefix (void)
2046 {
2047     T0 &= env->ivpr_mask;
2048     env->excp_prefix = T0;
2049     RETURN();
2050 }
2051
2052 void OPPROTO op_store_excp_vector (void)
2053 {
2054     T0 &= env->ivor_mask;
2055     env->excp_vectors[PARAM1] = T0;
2056     RETURN();
2057 }
2058 #endif
2059
2060 /* Trap word */
2061 void OPPROTO op_tw (void)
2062 {
2063     do_tw(PARAM1);
2064     RETURN();
2065 }
2066
2067 #if defined(TARGET_PPC64)
2068 void OPPROTO op_td (void)
2069 {
2070     do_td(PARAM1);
2071     RETURN();
2072 }
2073 #endif
2074
2075 #if !defined(CONFIG_USER_ONLY)
2076 /* tlbia */
2077 void OPPROTO op_tlbia (void)
2078 {
2079     ppc_tlb_invalidate_all(env);
2080     RETURN();
2081 }
2082
2083 /* tlbie */
2084 void OPPROTO op_tlbie (void)
2085 {
2086     ppc_tlb_invalidate_one(env, (uint32_t)T0);
2087     RETURN();
2088 }
2089
2090 #if defined(TARGET_PPC64)
2091 void OPPROTO op_tlbie_64 (void)
2092 {
2093     ppc_tlb_invalidate_one(env, T0);
2094     RETURN();
2095 }
2096 #endif
2097
2098 #if defined(TARGET_PPC64)
2099 void OPPROTO op_slbia (void)
2100 {
2101     ppc_slb_invalidate_all(env);
2102     RETURN();
2103 }
2104
2105 void OPPROTO op_slbie (void)
2106 {
2107     ppc_slb_invalidate_one(env, (uint32_t)T0);
2108     RETURN();
2109 }
2110
2111 void OPPROTO op_slbie_64 (void)
2112 {
2113     ppc_slb_invalidate_one(env, T0);
2114     RETURN();
2115 }
2116 #endif
2117 #endif
2118
2119 #if !defined(CONFIG_USER_ONLY)
2120 /* PowerPC 602/603/755 software TLB load instructions */
2121 void OPPROTO op_6xx_tlbld (void)
2122 {
2123     do_load_6xx_tlb(0);
2124     RETURN();
2125 }
2126
2127 void OPPROTO op_6xx_tlbli (void)
2128 {
2129     do_load_6xx_tlb(1);
2130     RETURN();
2131 }
2132
2133 /* PowerPC 74xx software TLB load instructions */
2134 void OPPROTO op_74xx_tlbld (void)
2135 {
2136     do_load_74xx_tlb(0);
2137     RETURN();
2138 }
2139
2140 void OPPROTO op_74xx_tlbli (void)
2141 {
2142     do_load_74xx_tlb(1);
2143     RETURN();
2144 }
2145 #endif
2146
2147 /* 601 specific */
2148 void OPPROTO op_load_601_rtcl (void)
2149 {
2150     T0 = cpu_ppc601_load_rtcl(env);
2151     RETURN();
2152 }
2153
2154 void OPPROTO op_load_601_rtcu (void)
2155 {
2156     T0 = cpu_ppc601_load_rtcu(env);
2157     RETURN();
2158 }
2159
2160 #if !defined(CONFIG_USER_ONLY)
2161 void OPPROTO op_store_601_rtcl (void)
2162 {
2163     cpu_ppc601_store_rtcl(env, T0);
2164     RETURN();
2165 }
2166
2167 void OPPROTO op_store_601_rtcu (void)
2168 {
2169     cpu_ppc601_store_rtcu(env, T0);
2170     RETURN();
2171 }
2172
2173 void OPPROTO op_store_hid0_601 (void)
2174 {
2175     do_store_hid0_601();
2176     RETURN();
2177 }
2178
2179 void OPPROTO op_load_601_bat (void)
2180 {
2181     T0 = env->IBAT[PARAM1][PARAM2];
2182     RETURN();
2183 }
2184
2185 void OPPROTO op_store_601_batl (void)
2186 {
2187     do_store_ibatl_601(env, PARAM1, T0);
2188     RETURN();
2189 }
2190
2191 void OPPROTO op_store_601_batu (void)
2192 {
2193     do_store_ibatu_601(env, PARAM1, T0);
2194     RETURN();
2195 }
2196 #endif /* !defined(CONFIG_USER_ONLY) */
2197
2198 /* PowerPC 601 specific instructions (POWER bridge) */
2199 /* XXX: those micro-ops need tests ! */
2200 void OPPROTO op_POWER_abs (void)
2201 {
2202     if ((int32_t)T0 == INT32_MIN)
2203         T0 = INT32_MAX;
2204     else if ((int32_t)T0 < 0)
2205         T0 = -T0;
2206     RETURN();
2207 }
2208
2209 void OPPROTO op_POWER_abso (void)
2210 {
2211     do_POWER_abso();
2212     RETURN();
2213 }
2214
2215 void OPPROTO op_POWER_clcs (void)
2216 {
2217     do_POWER_clcs();
2218     RETURN();
2219 }
2220
2221 void OPPROTO op_POWER_div (void)
2222 {
2223     do_POWER_div();
2224     RETURN();
2225 }
2226
2227 void OPPROTO op_POWER_divo (void)
2228 {
2229     do_POWER_divo();
2230     RETURN();
2231 }
2232
2233 void OPPROTO op_POWER_divs (void)
2234 {
2235     do_POWER_divs();
2236     RETURN();
2237 }
2238
2239 void OPPROTO op_POWER_divso (void)
2240 {
2241     do_POWER_divso();
2242     RETURN();
2243 }
2244
2245 void OPPROTO op_POWER_doz (void)
2246 {
2247     if ((int32_t)T1 > (int32_t)T0)
2248         T0 = T1 - T0;
2249     else
2250         T0 = 0;
2251     RETURN();
2252 }
2253
2254 void OPPROTO op_POWER_dozo (void)
2255 {
2256     do_POWER_dozo();
2257     RETURN();
2258 }
2259
2260 void OPPROTO op_load_xer_cmp (void)
2261 {
2262     T2 = xer_cmp;
2263     RETURN();
2264 }
2265
2266 void OPPROTO op_POWER_maskg (void)
2267 {
2268     do_POWER_maskg();
2269     RETURN();
2270 }
2271
2272 void OPPROTO op_POWER_maskir (void)
2273 {
2274     T0 = (T0 & ~T2) | (T1 & T2);
2275     RETURN();
2276 }
2277
2278 void OPPROTO op_POWER_mul (void)
2279 {
2280     uint64_t tmp;
2281
2282     tmp = (uint64_t)T0 * (uint64_t)T1;
2283     env->spr[SPR_MQ] = tmp >> 32;
2284     T0 = tmp;
2285     RETURN();
2286 }
2287
2288 void OPPROTO op_POWER_mulo (void)
2289 {
2290     do_POWER_mulo();
2291     RETURN();
2292 }
2293
2294 void OPPROTO op_POWER_nabs (void)
2295 {
2296     if (T0 > 0)
2297         T0 = -T0;
2298     RETURN();
2299 }
2300
2301 void OPPROTO op_POWER_nabso (void)
2302 {
2303     /* nabs never overflows */
2304     if (T0 > 0)
2305         T0 = -T0;
2306     xer_ov = 0;
2307     RETURN();
2308 }
2309
2310 /* XXX: factorise POWER rotates... */
2311 void OPPROTO op_POWER_rlmi (void)
2312 {
2313     T0 = rotl32(T0, T2) & PARAM1;
2314     T0 |= T1 & (uint32_t)PARAM2;
2315     RETURN();
2316 }
2317
2318 void OPPROTO op_POWER_rrib (void)
2319 {
2320     T2 &= 0x1FUL;
2321     T0 = rotl32(T0 & INT32_MIN, T2);
2322     T0 |= T1 & ~rotl32(INT32_MIN, T2);
2323     RETURN();
2324 }
2325
2326 void OPPROTO op_POWER_sle (void)
2327 {
2328     T1 &= 0x1FUL;
2329     env->spr[SPR_MQ] = rotl32(T0, T1);
2330     T0 = T0 << T1;
2331     RETURN();
2332 }
2333
2334 void OPPROTO op_POWER_sleq (void)
2335 {
2336     uint32_t tmp = env->spr[SPR_MQ];
2337
2338     T1 &= 0x1FUL;
2339     env->spr[SPR_MQ] = rotl32(T0, T1);
2340     T0 = T0 << T1;
2341     T0 |= tmp >> (32 - T1);
2342     RETURN();
2343 }
2344
2345 void OPPROTO op_POWER_sllq (void)
2346 {
2347     uint32_t msk = UINT32_MAX;
2348
2349     msk = msk << (T1 & 0x1FUL);
2350     if (T1 & 0x20UL)
2351         msk = ~msk;
2352     T1 &= 0x1FUL;
2353     T0 = (T0 << T1) & msk;
2354     T0 |= env->spr[SPR_MQ] & ~msk;
2355     RETURN();
2356 }
2357
2358 void OPPROTO op_POWER_slq (void)
2359 {
2360     uint32_t msk = UINT32_MAX, tmp;
2361
2362     msk = msk << (T1 & 0x1FUL);
2363     if (T1 & 0x20UL)
2364         msk = ~msk;
2365     T1 &= 0x1FUL;
2366     tmp = rotl32(T0, T1);
2367     T0 = tmp & msk;
2368     env->spr[SPR_MQ] = tmp;
2369     RETURN();
2370 }
2371
2372 void OPPROTO op_POWER_sraq (void)
2373 {
2374     env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL));
2375     if (T1 & 0x20UL)
2376         T0 = UINT32_MAX;
2377     else
2378         T0 = (int32_t)T0 >> T1;
2379     RETURN();
2380 }
2381
2382 void OPPROTO op_POWER_sre (void)
2383 {
2384     T1 &= 0x1FUL;
2385     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2386     T0 = (int32_t)T0 >> T1;
2387     RETURN();
2388 }
2389
2390 void OPPROTO op_POWER_srea (void)
2391 {
2392     T1 &= 0x1FUL;
2393     env->spr[SPR_MQ] = T0 >> T1;
2394     T0 = (int32_t)T0 >> T1;
2395     RETURN();
2396 }
2397
2398 void OPPROTO op_POWER_sreq (void)
2399 {
2400     uint32_t tmp;
2401     int32_t msk;
2402
2403     T1 &= 0x1FUL;
2404     msk = INT32_MIN >> T1;
2405     tmp = env->spr[SPR_MQ];
2406     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2407     T0 = T0 >> T1;
2408     T0 |= tmp & msk;
2409     RETURN();
2410 }
2411
2412 void OPPROTO op_POWER_srlq (void)
2413 {
2414     uint32_t tmp;
2415     int32_t msk;
2416
2417     msk = INT32_MIN >> (T1 & 0x1FUL);
2418     if (T1 & 0x20UL)
2419         msk = ~msk;
2420     T1 &= 0x1FUL;
2421     tmp = env->spr[SPR_MQ];
2422     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2423     T0 = T0 >> T1;
2424     T0 &= msk;
2425     T0 |= tmp & ~msk;
2426     RETURN();
2427 }
2428
2429 void OPPROTO op_POWER_srq (void)
2430 {
2431     T1 &= 0x1FUL;
2432     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
2433     T0 = T0 >> T1;
2434     RETURN();
2435 }
2436
2437 /* POWER instructions not implemented in PowerPC 601 */
2438 #if !defined(CONFIG_USER_ONLY)
2439 void OPPROTO op_POWER_mfsri (void)
2440 {
2441     T1 = T0 >> 28;
2442     T0 = env->sr[T1];
2443     RETURN();
2444 }
2445
2446 void OPPROTO op_POWER_rac (void)
2447 {
2448     do_POWER_rac();
2449     RETURN();
2450 }
2451
2452 void OPPROTO op_POWER_rfsvc (void)
2453 {
2454     do_POWER_rfsvc();
2455     RETURN();
2456 }
2457 #endif
2458
2459 /* PowerPC 602 specific instruction */
2460 #if !defined(CONFIG_USER_ONLY)
2461 void OPPROTO op_602_mfrom (void)
2462 {
2463     do_op_602_mfrom();
2464     RETURN();
2465 }
2466 #endif
2467
2468 /* PowerPC 4xx specific micro-ops */
2469 void OPPROTO op_405_add_T0_T2 (void)
2470 {
2471     T0 = (int32_t)T0 + (int32_t)T2;
2472     RETURN();
2473 }
2474
2475 void OPPROTO op_405_mulchw (void)
2476 {
2477     T0 = ((int16_t)T0) * ((int16_t)(T1 >> 16));
2478     RETURN();
2479 }
2480
2481 void OPPROTO op_405_mulchwu (void)
2482 {
2483     T0 = ((uint16_t)T0) * ((uint16_t)(T1 >> 16));
2484     RETURN();
2485 }
2486
2487 void OPPROTO op_405_mulhhw (void)
2488 {
2489     T0 = ((int16_t)(T0 >> 16)) * ((int16_t)(T1 >> 16));
2490     RETURN();
2491 }
2492
2493 void OPPROTO op_405_mulhhwu (void)
2494 {
2495     T0 = ((uint16_t)(T0 >> 16)) * ((uint16_t)(T1 >> 16));
2496     RETURN();
2497 }
2498
2499 void OPPROTO op_405_mullhw (void)
2500 {
2501     T0 = ((int16_t)T0) * ((int16_t)T1);
2502     RETURN();
2503 }
2504
2505 void OPPROTO op_405_mullhwu (void)
2506 {
2507     T0 = ((uint16_t)T0) * ((uint16_t)T1);
2508     RETURN();
2509 }
2510
2511 void OPPROTO op_405_check_sat (void)
2512 {
2513     do_405_check_sat();
2514     RETURN();
2515 }
2516
2517 void OPPROTO op_405_check_ovu (void)
2518 {
2519     if (likely(T0 >= T2)) {
2520         xer_ov = 0;
2521     } else {
2522         xer_ov = 1;
2523         xer_so = 1;
2524     }
2525     RETURN();
2526 }
2527
2528 void OPPROTO op_405_check_satu (void)
2529 {
2530     if (unlikely(T0 < T2)) {
2531         /* Saturate result */
2532         T0 = UINT32_MAX;
2533     }
2534     RETURN();
2535 }
2536
2537 void OPPROTO op_load_dcr (void)
2538 {
2539     do_load_dcr();
2540     RETURN();
2541 }
2542
2543 void OPPROTO op_store_dcr (void)
2544 {
2545     do_store_dcr();
2546     RETURN();
2547 }
2548
2549 #if !defined(CONFIG_USER_ONLY)
2550 /* Return from critical interrupt :
2551  * same as rfi, except nip & MSR are loaded from SRR2/3 instead of SRR0/1
2552  */
2553 void OPPROTO op_40x_rfci (void)
2554 {
2555     do_40x_rfci();
2556     RETURN();
2557 }
2558
2559 void OPPROTO op_rfci (void)
2560 {
2561     do_rfci();
2562     RETURN();
2563 }
2564
2565 void OPPROTO op_rfdi (void)
2566 {
2567     do_rfdi();
2568     RETURN();
2569 }
2570
2571 void OPPROTO op_rfmci (void)
2572 {
2573     do_rfmci();
2574     RETURN();
2575 }
2576
2577 void OPPROTO op_wrte (void)
2578 {
2579     /* We don't call do_store_msr here as we won't trigger
2580      * any special case nor change hflags
2581      */
2582     T0 &= 1 << MSR_EE;
2583     env->msr &= ~(1 << MSR_EE);
2584     env->msr |= T0;
2585     RETURN();
2586 }
2587
2588 void OPPROTO op_440_tlbre (void)
2589 {
2590     do_440_tlbre(PARAM1);
2591     RETURN();
2592 }
2593
2594 void OPPROTO op_440_tlbsx (void)
2595 {
2596     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_440_MMUCR] & 0xFF);
2597     RETURN();
2598 }
2599
2600 void OPPROTO op_4xx_tlbsx_check (void)
2601 {
2602     int tmp;
2603
2604     tmp = xer_so;
2605     if ((int)T0 != -1)
2606         tmp |= 0x02;
2607     env->crf[0] = tmp;
2608     RETURN();
2609 }
2610
2611 void OPPROTO op_440_tlbwe (void)
2612 {
2613     do_440_tlbwe(PARAM1);
2614     RETURN();
2615 }
2616
2617 void OPPROTO op_4xx_tlbre_lo (void)
2618 {
2619     do_4xx_tlbre_lo();
2620     RETURN();
2621 }
2622
2623 void OPPROTO op_4xx_tlbre_hi (void)
2624 {
2625     do_4xx_tlbre_hi();
2626     RETURN();
2627 }
2628
2629 void OPPROTO op_4xx_tlbsx (void)
2630 {
2631     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_40x_PID]);
2632     RETURN();
2633 }
2634
2635 void OPPROTO op_4xx_tlbwe_lo (void)
2636 {
2637     do_4xx_tlbwe_lo();
2638     RETURN();
2639 }
2640
2641 void OPPROTO op_4xx_tlbwe_hi (void)
2642 {
2643     do_4xx_tlbwe_hi();
2644     RETURN();
2645 }
2646 #endif
2647
2648 /* SPR micro-ops */
2649 /* 440 specific */
2650 void OPPROTO op_440_dlmzb (void)
2651 {
2652     do_440_dlmzb();
2653     RETURN();
2654 }
2655
2656 void OPPROTO op_440_dlmzb_update_Rc (void)
2657 {
2658     if (T0 == 8)
2659         T0 = 0x2;
2660     else if (T0 < 4)
2661         T0 = 0x4;
2662     else
2663         T0 = 0x8;
2664     RETURN();
2665 }
2666
2667 #if !defined(CONFIG_USER_ONLY)
2668 void OPPROTO op_store_pir (void)
2669 {
2670     env->spr[SPR_PIR] = T0 & 0x0000000FUL;
2671     RETURN();
2672 }
2673
2674 void OPPROTO op_load_403_pb (void)
2675 {
2676     do_load_403_pb(PARAM1);
2677     RETURN();
2678 }
2679
2680 void OPPROTO op_store_403_pb (void)
2681 {
2682     do_store_403_pb(PARAM1);
2683     RETURN();
2684 }
2685
2686 void OPPROTO op_load_40x_pit (void)
2687 {
2688     T0 = load_40x_pit(env);
2689     RETURN();
2690 }
2691
2692 void OPPROTO op_store_40x_pit (void)
2693 {
2694     store_40x_pit(env, T0);
2695     RETURN();
2696 }
2697
2698 void OPPROTO op_store_40x_dbcr0 (void)
2699 {
2700     store_40x_dbcr0(env, T0);
2701     RETURN();
2702 }
2703
2704 void OPPROTO op_store_40x_sler (void)
2705 {
2706     store_40x_sler(env, T0);
2707     RETURN();
2708 }
2709
2710 void OPPROTO op_store_booke_tcr (void)
2711 {
2712     store_booke_tcr(env, T0);
2713     RETURN();
2714 }
2715
2716 void OPPROTO op_store_booke_tsr (void)
2717 {
2718     store_booke_tsr(env, T0);
2719     RETURN();
2720 }
2721 #endif /* !defined(CONFIG_USER_ONLY) */
2722
2723 /* SPE extension */
2724 void OPPROTO op_splatw_T1_64 (void)
2725 {
2726     T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2727     RETURN();
2728 }
2729
2730 void OPPROTO op_splatwi_T0_64 (void)
2731 {
2732     uint64_t tmp = PARAM1;
2733
2734     T0_64 = (tmp << 32) | tmp;
2735     RETURN();
2736 }
2737
2738 void OPPROTO op_splatwi_T1_64 (void)
2739 {
2740     uint64_t tmp = PARAM1;
2741
2742     T1_64 = (tmp << 32) | tmp;
2743     RETURN();
2744 }
2745
2746 void OPPROTO op_extsh_T1_64 (void)
2747 {
2748     T1_64 = (int32_t)((int16_t)T1_64);
2749     RETURN();
2750 }
2751
2752 void OPPROTO op_sli16_T1_64 (void)
2753 {
2754     T1_64 = T1_64 << 16;
2755     RETURN();
2756 }
2757
2758 void OPPROTO op_sli32_T1_64 (void)
2759 {
2760     T1_64 = T1_64 << 32;
2761     RETURN();
2762 }
2763
2764 void OPPROTO op_srli32_T1_64 (void)
2765 {
2766     T1_64 = T1_64 >> 32;
2767     RETURN();
2768 }
2769
2770 void OPPROTO op_evsel (void)
2771 {
2772     do_evsel();
2773     RETURN();
2774 }
2775
2776 void OPPROTO op_evaddw (void)
2777 {
2778     do_evaddw();
2779     RETURN();
2780 }
2781
2782 void OPPROTO op_evsubfw (void)
2783 {
2784     do_evsubfw();
2785     RETURN();
2786 }
2787
2788 void OPPROTO op_evneg (void)
2789 {
2790     do_evneg();
2791     RETURN();
2792 }
2793
2794 void OPPROTO op_evabs (void)
2795 {
2796     do_evabs();
2797     RETURN();
2798 }
2799
2800 void OPPROTO op_evextsh (void)
2801 {
2802     T0_64 = ((uint64_t)((int32_t)(int16_t)(T0_64 >> 32)) << 32) |
2803         (uint64_t)((int32_t)(int16_t)T0_64);
2804     RETURN();
2805 }
2806
2807 void OPPROTO op_evextsb (void)
2808 {
2809     T0_64 = ((uint64_t)((int32_t)(int8_t)(T0_64 >> 32)) << 32) |
2810         (uint64_t)((int32_t)(int8_t)T0_64);
2811     RETURN();
2812 }
2813
2814 void OPPROTO op_evcntlzw (void)
2815 {
2816     do_evcntlzw();
2817     RETURN();
2818 }
2819
2820 void OPPROTO op_evrndw (void)
2821 {
2822     do_evrndw();
2823     RETURN();
2824 }
2825
2826 void OPPROTO op_brinc (void)
2827 {
2828     do_brinc();
2829     RETURN();
2830 }
2831
2832 void OPPROTO op_evcntlsw (void)
2833 {
2834     do_evcntlsw();
2835     RETURN();
2836 }
2837
2838 void OPPROTO op_evand (void)
2839 {
2840     T0_64 &= T1_64;
2841     RETURN();
2842 }
2843
2844 void OPPROTO op_evandc (void)
2845 {
2846     T0_64 &= ~T1_64;
2847     RETURN();
2848 }
2849
2850 void OPPROTO op_evor (void)
2851 {
2852     T0_64 |= T1_64;
2853     RETURN();
2854 }
2855
2856 void OPPROTO op_evxor (void)
2857 {
2858     T0_64 ^= T1_64;
2859     RETURN();
2860 }
2861
2862 void OPPROTO op_eveqv (void)
2863 {
2864     T0_64 = ~(T0_64 ^ T1_64);
2865     RETURN();
2866 }
2867
2868 void OPPROTO op_evnor (void)
2869 {
2870     T0_64 = ~(T0_64 | T1_64);
2871     RETURN();
2872 }
2873
2874 void OPPROTO op_evorc (void)
2875 {
2876     T0_64 |= ~T1_64;
2877     RETURN();
2878 }
2879
2880 void OPPROTO op_evnand (void)
2881 {
2882     T0_64 = ~(T0_64 & T1_64);
2883     RETURN();
2884 }
2885
2886 void OPPROTO op_evsrws (void)
2887 {
2888     do_evsrws();
2889     RETURN();
2890 }
2891
2892 void OPPROTO op_evsrwu (void)
2893 {
2894     do_evsrwu();
2895     RETURN();
2896 }
2897
2898 void OPPROTO op_evslw (void)
2899 {
2900     do_evslw();
2901     RETURN();
2902 }
2903
2904 void OPPROTO op_evrlw (void)
2905 {
2906     do_evrlw();
2907     RETURN();
2908 }
2909
2910 void OPPROTO op_evmergelo (void)
2911 {
2912     T0_64 = (T0_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2913     RETURN();
2914 }
2915
2916 void OPPROTO op_evmergehi (void)
2917 {
2918     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 >> 32);
2919     RETURN();
2920 }
2921
2922 void OPPROTO op_evmergelohi (void)
2923 {
2924     T0_64 = (T0_64 << 32) | (T1_64 >> 32);
2925     RETURN();
2926 }
2927
2928 void OPPROTO op_evmergehilo (void)
2929 {
2930     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 & 0x00000000FFFFFFFFULL);
2931     RETURN();
2932 }
2933
2934 void OPPROTO op_evcmpgts (void)
2935 {
2936     do_evcmpgts();
2937     RETURN();
2938 }
2939
2940 void OPPROTO op_evcmpgtu (void)
2941 {
2942     do_evcmpgtu();
2943     RETURN();
2944 }
2945
2946 void OPPROTO op_evcmplts (void)
2947 {
2948     do_evcmplts();
2949     RETURN();
2950 }
2951
2952 void OPPROTO op_evcmpltu (void)
2953 {
2954     do_evcmpltu();
2955     RETURN();
2956 }
2957
2958 void OPPROTO op_evcmpeq (void)
2959 {
2960     do_evcmpeq();
2961     RETURN();
2962 }
2963
2964 void OPPROTO op_evfssub (void)
2965 {
2966     do_evfssub();
2967     RETURN();
2968 }
2969
2970 void OPPROTO op_evfsadd (void)
2971 {
2972     do_evfsadd();
2973     RETURN();
2974 }
2975
2976 void OPPROTO op_evfsnabs (void)
2977 {
2978     do_evfsnabs();
2979     RETURN();
2980 }
2981
2982 void OPPROTO op_evfsabs (void)
2983 {
2984     do_evfsabs();
2985     RETURN();
2986 }
2987
2988 void OPPROTO op_evfsneg (void)
2989 {
2990     do_evfsneg();
2991     RETURN();
2992 }
2993
2994 void OPPROTO op_evfsdiv (void)
2995 {
2996     do_evfsdiv();
2997     RETURN();
2998 }
2999
3000 void OPPROTO op_evfsmul (void)
3001 {
3002     do_evfsmul();
3003     RETURN();
3004 }
3005
3006 void OPPROTO op_evfscmplt (void)
3007 {
3008     do_evfscmplt();
3009     RETURN();
3010 }
3011
3012 void OPPROTO op_evfscmpgt (void)
3013 {
3014     do_evfscmpgt();
3015     RETURN();
3016 }
3017
3018 void OPPROTO op_evfscmpeq (void)
3019 {
3020     do_evfscmpeq();
3021     RETURN();
3022 }
3023
3024 void OPPROTO op_evfscfsi (void)
3025 {
3026     do_evfscfsi();
3027     RETURN();
3028 }
3029
3030 void OPPROTO op_evfscfui (void)
3031 {
3032     do_evfscfui();
3033     RETURN();
3034 }
3035
3036 void OPPROTO op_evfscfsf (void)
3037 {
3038     do_evfscfsf();
3039     RETURN();
3040 }
3041
3042 void OPPROTO op_evfscfuf (void)
3043 {
3044     do_evfscfuf();
3045     RETURN();
3046 }
3047
3048 void OPPROTO op_evfsctsi (void)
3049 {
3050     do_evfsctsi();
3051     RETURN();
3052 }
3053
3054 void OPPROTO op_evfsctui (void)
3055 {
3056     do_evfsctui();
3057     RETURN();
3058 }
3059
3060 void OPPROTO op_evfsctsf (void)
3061 {
3062     do_evfsctsf();
3063     RETURN();
3064 }
3065
3066 void OPPROTO op_evfsctuf (void)
3067 {
3068     do_evfsctuf();
3069     RETURN();
3070 }
3071
3072 void OPPROTO op_evfsctuiz (void)
3073 {
3074     do_evfsctuiz();
3075     RETURN();
3076 }
3077
3078 void OPPROTO op_evfsctsiz (void)
3079 {
3080     do_evfsctsiz();
3081     RETURN();
3082 }
3083
3084 void OPPROTO op_evfststlt (void)
3085 {
3086     do_evfststlt();
3087     RETURN();
3088 }
3089
3090 void OPPROTO op_evfststgt (void)
3091 {
3092     do_evfststgt();
3093     RETURN();
3094 }
3095
3096 void OPPROTO op_evfststeq (void)
3097 {
3098     do_evfststeq();
3099     RETURN();
3100 }
3101
3102 void OPPROTO op_efssub (void)
3103 {
3104     T0_64 = _do_efssub(T0_64, T1_64);
3105     RETURN();
3106 }
3107
3108 void OPPROTO op_efsadd (void)
3109 {
3110     T0_64 = _do_efsadd(T0_64, T1_64);
3111     RETURN();
3112 }
3113
3114 void OPPROTO op_efsnabs (void)
3115 {
3116     T0_64 = _do_efsnabs(T0_64);
3117     RETURN();
3118 }
3119
3120 void OPPROTO op_efsabs (void)
3121 {
3122     T0_64 = _do_efsabs(T0_64);
3123     RETURN();
3124 }
3125
3126 void OPPROTO op_efsneg (void)
3127 {
3128     T0_64 = _do_efsneg(T0_64);
3129     RETURN();
3130 }
3131
3132 void OPPROTO op_efsdiv (void)
3133 {
3134     T0_64 = _do_efsdiv(T0_64, T1_64);
3135     RETURN();
3136 }
3137
3138 void OPPROTO op_efsmul (void)
3139 {
3140     T0_64 = _do_efsmul(T0_64, T1_64);
3141     RETURN();
3142 }
3143
3144 void OPPROTO op_efscmplt (void)
3145 {
3146     do_efscmplt();
3147     RETURN();
3148 }
3149
3150 void OPPROTO op_efscmpgt (void)
3151 {
3152     do_efscmpgt();
3153     RETURN();
3154 }
3155
3156 void OPPROTO op_efscfd (void)
3157 {
3158     do_efscfd();
3159     RETURN();
3160 }
3161
3162 void OPPROTO op_efscmpeq (void)
3163 {
3164     do_efscmpeq();
3165     RETURN();
3166 }
3167
3168 void OPPROTO op_efscfsi (void)
3169 {
3170     do_efscfsi();
3171     RETURN();
3172 }
3173
3174 void OPPROTO op_efscfui (void)
3175 {
3176     do_efscfui();
3177     RETURN();
3178 }
3179
3180 void OPPROTO op_efscfsf (void)
3181 {
3182     do_efscfsf();
3183     RETURN();
3184 }
3185
3186 void OPPROTO op_efscfuf (void)
3187 {
3188     do_efscfuf();
3189     RETURN();
3190 }
3191
3192 void OPPROTO op_efsctsi (void)
3193 {
3194     do_efsctsi();
3195     RETURN();
3196 }
3197
3198 void OPPROTO op_efsctui (void)
3199 {
3200     do_efsctui();
3201     RETURN();
3202 }
3203
3204 void OPPROTO op_efsctsf (void)
3205 {
3206     do_efsctsf();
3207     RETURN();
3208 }
3209
3210 void OPPROTO op_efsctuf (void)
3211 {
3212     do_efsctuf();
3213     RETURN();
3214 }
3215
3216 void OPPROTO op_efsctsiz (void)
3217 {
3218     do_efsctsiz();
3219     RETURN();
3220 }
3221
3222 void OPPROTO op_efsctuiz (void)
3223 {
3224     do_efsctuiz();
3225     RETURN();
3226 }
3227
3228 void OPPROTO op_efststlt (void)
3229 {
3230     T0 = _do_efststlt(T0_64, T1_64);
3231     RETURN();
3232 }
3233
3234 void OPPROTO op_efststgt (void)
3235 {
3236     T0 = _do_efststgt(T0_64, T1_64);
3237     RETURN();
3238 }
3239
3240 void OPPROTO op_efststeq (void)
3241 {
3242     T0 = _do_efststeq(T0_64, T1_64);
3243     RETURN();
3244 }
3245
3246 void OPPROTO op_efdsub (void)
3247 {
3248     union {
3249         uint64_t u;
3250         float64 f;
3251     } u1, u2;
3252     u1.u = T0_64;
3253     u2.u = T1_64;
3254     u1.f = float64_sub(u1.f, u2.f, &env->spe_status);
3255     T0_64 = u1.u;
3256     RETURN();
3257 }
3258
3259 void OPPROTO op_efdadd (void)
3260 {
3261     union {
3262         uint64_t u;
3263         float64 f;
3264     } u1, u2;
3265     u1.u = T0_64;
3266     u2.u = T1_64;
3267     u1.f = float64_add(u1.f, u2.f, &env->spe_status);
3268     T0_64 = u1.u;
3269     RETURN();
3270 }
3271
3272 void OPPROTO op_efdcfsid (void)
3273 {
3274     do_efdcfsi();
3275     RETURN();
3276 }
3277
3278 void OPPROTO op_efdcfuid (void)
3279 {
3280     do_efdcfui();
3281     RETURN();
3282 }
3283
3284 void OPPROTO op_efdnabs (void)
3285 {
3286     T0_64 |= 0x8000000000000000ULL;
3287     RETURN();
3288 }
3289
3290 void OPPROTO op_efdabs (void)
3291 {
3292     T0_64 &= ~0x8000000000000000ULL;
3293     RETURN();
3294 }
3295
3296 void OPPROTO op_efdneg (void)
3297 {
3298     T0_64 ^= 0x8000000000000000ULL;
3299     RETURN();
3300 }
3301
3302 void OPPROTO op_efddiv (void)
3303 {
3304     union {
3305         uint64_t u;
3306         float64 f;
3307     } u1, u2;
3308     u1.u = T0_64;
3309     u2.u = T1_64;
3310     u1.f = float64_div(u1.f, u2.f, &env->spe_status);
3311     T0_64 = u1.u;
3312     RETURN();
3313 }
3314
3315 void OPPROTO op_efdmul (void)
3316 {
3317     union {
3318         uint64_t u;
3319         float64 f;
3320     } u1, u2;
3321     u1.u = T0_64;
3322     u2.u = T1_64;
3323     u1.f = float64_mul(u1.f, u2.f, &env->spe_status);
3324     T0_64 = u1.u;
3325     RETURN();
3326 }
3327
3328 void OPPROTO op_efdctsidz (void)
3329 {
3330     do_efdctsiz();
3331     RETURN();
3332 }
3333
3334 void OPPROTO op_efdctuidz (void)
3335 {
3336     do_efdctuiz();
3337     RETURN();
3338 }
3339
3340 void OPPROTO op_efdcmplt (void)
3341 {
3342     do_efdcmplt();
3343     RETURN();
3344 }
3345
3346 void OPPROTO op_efdcmpgt (void)
3347 {
3348     do_efdcmpgt();
3349     RETURN();
3350 }
3351
3352 void OPPROTO op_efdcfs (void)
3353 {
3354     do_efdcfs();
3355     RETURN();
3356 }
3357
3358 void OPPROTO op_efdcmpeq (void)
3359 {
3360     do_efdcmpeq();
3361     RETURN();
3362 }
3363
3364 void OPPROTO op_efdcfsi (void)
3365 {
3366     do_efdcfsi();
3367     RETURN();
3368 }
3369
3370 void OPPROTO op_efdcfui (void)
3371 {
3372     do_efdcfui();
3373     RETURN();
3374 }
3375
3376 void OPPROTO op_efdcfsf (void)
3377 {
3378     do_efdcfsf();
3379     RETURN();
3380 }
3381
3382 void OPPROTO op_efdcfuf (void)
3383 {
3384     do_efdcfuf();
3385     RETURN();
3386 }
3387
3388 void OPPROTO op_efdctsi (void)
3389 {
3390     do_efdctsi();
3391     RETURN();
3392 }
3393
3394 void OPPROTO op_efdctui (void)
3395 {
3396     do_efdctui();
3397     RETURN();
3398 }
3399
3400 void OPPROTO op_efdctsf (void)
3401 {
3402     do_efdctsf();
3403     RETURN();
3404 }
3405
3406 void OPPROTO op_efdctuf (void)
3407 {
3408     do_efdctuf();
3409     RETURN();
3410 }
3411
3412 void OPPROTO op_efdctuiz (void)
3413 {
3414     do_efdctuiz();
3415     RETURN();
3416 }
3417
3418 void OPPROTO op_efdctsiz (void)
3419 {
3420     do_efdctsiz();
3421     RETURN();
3422 }
3423
3424 void OPPROTO op_efdtstlt (void)
3425 {
3426     T0 = _do_efdtstlt(T0_64, T1_64);
3427     RETURN();
3428 }
3429
3430 void OPPROTO op_efdtstgt (void)
3431 {
3432     T0 = _do_efdtstgt(T0_64, T1_64);
3433     RETURN();
3434 }
3435
3436 void OPPROTO op_efdtsteq (void)
3437 {
3438     T0 = _do_efdtsteq(T0_64, T1_64);
3439     RETURN();
3440 }