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 #if defined(TARGET_PPCEMB)
2724 /* SPE extension */
2725 void OPPROTO op_splatw_T1_64 (void)
2726 {
2727     T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2728     RETURN();
2729 }
2730
2731 void OPPROTO op_splatwi_T0_64 (void)
2732 {
2733     uint64_t tmp = PARAM1;
2734
2735     T0_64 = (tmp << 32) | tmp;
2736     RETURN();
2737 }
2738
2739 void OPPROTO op_splatwi_T1_64 (void)
2740 {
2741     uint64_t tmp = PARAM1;
2742
2743     T1_64 = (tmp << 32) | tmp;
2744     RETURN();
2745 }
2746
2747 void OPPROTO op_extsh_T1_64 (void)
2748 {
2749     T1_64 = (int32_t)((int16_t)T1_64);
2750     RETURN();
2751 }
2752
2753 void OPPROTO op_sli16_T1_64 (void)
2754 {
2755     T1_64 = T1_64 << 16;
2756     RETURN();
2757 }
2758
2759 void OPPROTO op_sli32_T1_64 (void)
2760 {
2761     T1_64 = T1_64 << 32;
2762     RETURN();
2763 }
2764
2765 void OPPROTO op_srli32_T1_64 (void)
2766 {
2767     T1_64 = T1_64 >> 32;
2768     RETURN();
2769 }
2770
2771 void OPPROTO op_evsel (void)
2772 {
2773     do_evsel();
2774     RETURN();
2775 }
2776
2777 void OPPROTO op_evaddw (void)
2778 {
2779     do_evaddw();
2780     RETURN();
2781 }
2782
2783 void OPPROTO op_evsubfw (void)
2784 {
2785     do_evsubfw();
2786     RETURN();
2787 }
2788
2789 void OPPROTO op_evneg (void)
2790 {
2791     do_evneg();
2792     RETURN();
2793 }
2794
2795 void OPPROTO op_evabs (void)
2796 {
2797     do_evabs();
2798     RETURN();
2799 }
2800
2801 void OPPROTO op_evextsh (void)
2802 {
2803     T0_64 = ((uint64_t)((int32_t)(int16_t)(T0_64 >> 32)) << 32) |
2804         (uint64_t)((int32_t)(int16_t)T0_64);
2805     RETURN();
2806 }
2807
2808 void OPPROTO op_evextsb (void)
2809 {
2810     T0_64 = ((uint64_t)((int32_t)(int8_t)(T0_64 >> 32)) << 32) |
2811         (uint64_t)((int32_t)(int8_t)T0_64);
2812     RETURN();
2813 }
2814
2815 void OPPROTO op_evcntlzw (void)
2816 {
2817     do_evcntlzw();
2818     RETURN();
2819 }
2820
2821 void OPPROTO op_evrndw (void)
2822 {
2823     do_evrndw();
2824     RETURN();
2825 }
2826
2827 void OPPROTO op_brinc (void)
2828 {
2829     do_brinc();
2830     RETURN();
2831 }
2832
2833 void OPPROTO op_evcntlsw (void)
2834 {
2835     do_evcntlsw();
2836     RETURN();
2837 }
2838
2839 void OPPROTO op_evand (void)
2840 {
2841     T0_64 &= T1_64;
2842     RETURN();
2843 }
2844
2845 void OPPROTO op_evandc (void)
2846 {
2847     T0_64 &= ~T1_64;
2848     RETURN();
2849 }
2850
2851 void OPPROTO op_evor (void)
2852 {
2853     T0_64 |= T1_64;
2854     RETURN();
2855 }
2856
2857 void OPPROTO op_evxor (void)
2858 {
2859     T0_64 ^= T1_64;
2860     RETURN();
2861 }
2862
2863 void OPPROTO op_eveqv (void)
2864 {
2865     T0_64 = ~(T0_64 ^ T1_64);
2866     RETURN();
2867 }
2868
2869 void OPPROTO op_evnor (void)
2870 {
2871     T0_64 = ~(T0_64 | T1_64);
2872     RETURN();
2873 }
2874
2875 void OPPROTO op_evorc (void)
2876 {
2877     T0_64 |= ~T1_64;
2878     RETURN();
2879 }
2880
2881 void OPPROTO op_evnand (void)
2882 {
2883     T0_64 = ~(T0_64 & T1_64);
2884     RETURN();
2885 }
2886
2887 void OPPROTO op_evsrws (void)
2888 {
2889     do_evsrws();
2890     RETURN();
2891 }
2892
2893 void OPPROTO op_evsrwu (void)
2894 {
2895     do_evsrwu();
2896     RETURN();
2897 }
2898
2899 void OPPROTO op_evslw (void)
2900 {
2901     do_evslw();
2902     RETURN();
2903 }
2904
2905 void OPPROTO op_evrlw (void)
2906 {
2907     do_evrlw();
2908     RETURN();
2909 }
2910
2911 void OPPROTO op_evmergelo (void)
2912 {
2913     T0_64 = (T0_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
2914     RETURN();
2915 }
2916
2917 void OPPROTO op_evmergehi (void)
2918 {
2919     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 >> 32);
2920     RETURN();
2921 }
2922
2923 void OPPROTO op_evmergelohi (void)
2924 {
2925     T0_64 = (T0_64 << 32) | (T1_64 >> 32);
2926     RETURN();
2927 }
2928
2929 void OPPROTO op_evmergehilo (void)
2930 {
2931     T0_64 = (T0_64 & 0xFFFFFFFF00000000ULL) | (T1_64 & 0x00000000FFFFFFFFULL);
2932     RETURN();
2933 }
2934
2935 void OPPROTO op_evcmpgts (void)
2936 {
2937     do_evcmpgts();
2938     RETURN();
2939 }
2940
2941 void OPPROTO op_evcmpgtu (void)
2942 {
2943     do_evcmpgtu();
2944     RETURN();
2945 }
2946
2947 void OPPROTO op_evcmplts (void)
2948 {
2949     do_evcmplts();
2950     RETURN();
2951 }
2952
2953 void OPPROTO op_evcmpltu (void)
2954 {
2955     do_evcmpltu();
2956     RETURN();
2957 }
2958
2959 void OPPROTO op_evcmpeq (void)
2960 {
2961     do_evcmpeq();
2962     RETURN();
2963 }
2964
2965 void OPPROTO op_evfssub (void)
2966 {
2967     do_evfssub();
2968     RETURN();
2969 }
2970
2971 void OPPROTO op_evfsadd (void)
2972 {
2973     do_evfsadd();
2974     RETURN();
2975 }
2976
2977 void OPPROTO op_evfsnabs (void)
2978 {
2979     do_evfsnabs();
2980     RETURN();
2981 }
2982
2983 void OPPROTO op_evfsabs (void)
2984 {
2985     do_evfsabs();
2986     RETURN();
2987 }
2988
2989 void OPPROTO op_evfsneg (void)
2990 {
2991     do_evfsneg();
2992     RETURN();
2993 }
2994
2995 void OPPROTO op_evfsdiv (void)
2996 {
2997     do_evfsdiv();
2998     RETURN();
2999 }
3000
3001 void OPPROTO op_evfsmul (void)
3002 {
3003     do_evfsmul();
3004     RETURN();
3005 }
3006
3007 void OPPROTO op_evfscmplt (void)
3008 {
3009     do_evfscmplt();
3010     RETURN();
3011 }
3012
3013 void OPPROTO op_evfscmpgt (void)
3014 {
3015     do_evfscmpgt();
3016     RETURN();
3017 }
3018
3019 void OPPROTO op_evfscmpeq (void)
3020 {
3021     do_evfscmpeq();
3022     RETURN();
3023 }
3024
3025 void OPPROTO op_evfscfsi (void)
3026 {
3027     do_evfscfsi();
3028     RETURN();
3029 }
3030
3031 void OPPROTO op_evfscfui (void)
3032 {
3033     do_evfscfui();
3034     RETURN();
3035 }
3036
3037 void OPPROTO op_evfscfsf (void)
3038 {
3039     do_evfscfsf();
3040     RETURN();
3041 }
3042
3043 void OPPROTO op_evfscfuf (void)
3044 {
3045     do_evfscfuf();
3046     RETURN();
3047 }
3048
3049 void OPPROTO op_evfsctsi (void)
3050 {
3051     do_evfsctsi();
3052     RETURN();
3053 }
3054
3055 void OPPROTO op_evfsctui (void)
3056 {
3057     do_evfsctui();
3058     RETURN();
3059 }
3060
3061 void OPPROTO op_evfsctsf (void)
3062 {
3063     do_evfsctsf();
3064     RETURN();
3065 }
3066
3067 void OPPROTO op_evfsctuf (void)
3068 {
3069     do_evfsctuf();
3070     RETURN();
3071 }
3072
3073 void OPPROTO op_evfsctuiz (void)
3074 {
3075     do_evfsctuiz();
3076     RETURN();
3077 }
3078
3079 void OPPROTO op_evfsctsiz (void)
3080 {
3081     do_evfsctsiz();
3082     RETURN();
3083 }
3084
3085 void OPPROTO op_evfststlt (void)
3086 {
3087     do_evfststlt();
3088     RETURN();
3089 }
3090
3091 void OPPROTO op_evfststgt (void)
3092 {
3093     do_evfststgt();
3094     RETURN();
3095 }
3096
3097 void OPPROTO op_evfststeq (void)
3098 {
3099     do_evfststeq();
3100     RETURN();
3101 }
3102
3103 void OPPROTO op_efssub (void)
3104 {
3105     T0_64 = _do_efssub(T0_64, T1_64);
3106     RETURN();
3107 }
3108
3109 void OPPROTO op_efsadd (void)
3110 {
3111     T0_64 = _do_efsadd(T0_64, T1_64);
3112     RETURN();
3113 }
3114
3115 void OPPROTO op_efsnabs (void)
3116 {
3117     T0_64 = _do_efsnabs(T0_64);
3118     RETURN();
3119 }
3120
3121 void OPPROTO op_efsabs (void)
3122 {
3123     T0_64 = _do_efsabs(T0_64);
3124     RETURN();
3125 }
3126
3127 void OPPROTO op_efsneg (void)
3128 {
3129     T0_64 = _do_efsneg(T0_64);
3130     RETURN();
3131 }
3132
3133 void OPPROTO op_efsdiv (void)
3134 {
3135     T0_64 = _do_efsdiv(T0_64, T1_64);
3136     RETURN();
3137 }
3138
3139 void OPPROTO op_efsmul (void)
3140 {
3141     T0_64 = _do_efsmul(T0_64, T1_64);
3142     RETURN();
3143 }
3144
3145 void OPPROTO op_efscmplt (void)
3146 {
3147     do_efscmplt();
3148     RETURN();
3149 }
3150
3151 void OPPROTO op_efscmpgt (void)
3152 {
3153     do_efscmpgt();
3154     RETURN();
3155 }
3156
3157 void OPPROTO op_efscfd (void)
3158 {
3159     do_efscfd();
3160     RETURN();
3161 }
3162
3163 void OPPROTO op_efscmpeq (void)
3164 {
3165     do_efscmpeq();
3166     RETURN();
3167 }
3168
3169 void OPPROTO op_efscfsi (void)
3170 {
3171     do_efscfsi();
3172     RETURN();
3173 }
3174
3175 void OPPROTO op_efscfui (void)
3176 {
3177     do_efscfui();
3178     RETURN();
3179 }
3180
3181 void OPPROTO op_efscfsf (void)
3182 {
3183     do_efscfsf();
3184     RETURN();
3185 }
3186
3187 void OPPROTO op_efscfuf (void)
3188 {
3189     do_efscfuf();
3190     RETURN();
3191 }
3192
3193 void OPPROTO op_efsctsi (void)
3194 {
3195     do_efsctsi();
3196     RETURN();
3197 }
3198
3199 void OPPROTO op_efsctui (void)
3200 {
3201     do_efsctui();
3202     RETURN();
3203 }
3204
3205 void OPPROTO op_efsctsf (void)
3206 {
3207     do_efsctsf();
3208     RETURN();
3209 }
3210
3211 void OPPROTO op_efsctuf (void)
3212 {
3213     do_efsctuf();
3214     RETURN();
3215 }
3216
3217 void OPPROTO op_efsctsiz (void)
3218 {
3219     do_efsctsiz();
3220     RETURN();
3221 }
3222
3223 void OPPROTO op_efsctuiz (void)
3224 {
3225     do_efsctuiz();
3226     RETURN();
3227 }
3228
3229 void OPPROTO op_efststlt (void)
3230 {
3231     T0 = _do_efststlt(T0_64, T1_64);
3232     RETURN();
3233 }
3234
3235 void OPPROTO op_efststgt (void)
3236 {
3237     T0 = _do_efststgt(T0_64, T1_64);
3238     RETURN();
3239 }
3240
3241 void OPPROTO op_efststeq (void)
3242 {
3243     T0 = _do_efststeq(T0_64, T1_64);
3244     RETURN();
3245 }
3246
3247 void OPPROTO op_efdsub (void)
3248 {
3249     union {
3250         uint64_t u;
3251         float64 f;
3252     } u1, u2;
3253     u1.u = T0_64;
3254     u2.u = T1_64;
3255     u1.f = float64_sub(u1.f, u2.f, &env->spe_status);
3256     T0_64 = u1.u;
3257     RETURN();
3258 }
3259
3260 void OPPROTO op_efdadd (void)
3261 {
3262     union {
3263         uint64_t u;
3264         float64 f;
3265     } u1, u2;
3266     u1.u = T0_64;
3267     u2.u = T1_64;
3268     u1.f = float64_add(u1.f, u2.f, &env->spe_status);
3269     T0_64 = u1.u;
3270     RETURN();
3271 }
3272
3273 void OPPROTO op_efdcfsid (void)
3274 {
3275     do_efdcfsi();
3276     RETURN();
3277 }
3278
3279 void OPPROTO op_efdcfuid (void)
3280 {
3281     do_efdcfui();
3282     RETURN();
3283 }
3284
3285 void OPPROTO op_efdnabs (void)
3286 {
3287     T0_64 |= 0x8000000000000000ULL;
3288     RETURN();
3289 }
3290
3291 void OPPROTO op_efdabs (void)
3292 {
3293     T0_64 &= ~0x8000000000000000ULL;
3294     RETURN();
3295 }
3296
3297 void OPPROTO op_efdneg (void)
3298 {
3299     T0_64 ^= 0x8000000000000000ULL;
3300     RETURN();
3301 }
3302
3303 void OPPROTO op_efddiv (void)
3304 {
3305     union {
3306         uint64_t u;
3307         float64 f;
3308     } u1, u2;
3309     u1.u = T0_64;
3310     u2.u = T1_64;
3311     u1.f = float64_div(u1.f, u2.f, &env->spe_status);
3312     T0_64 = u1.u;
3313     RETURN();
3314 }
3315
3316 void OPPROTO op_efdmul (void)
3317 {
3318     union {
3319         uint64_t u;
3320         float64 f;
3321     } u1, u2;
3322     u1.u = T0_64;
3323     u2.u = T1_64;
3324     u1.f = float64_mul(u1.f, u2.f, &env->spe_status);
3325     T0_64 = u1.u;
3326     RETURN();
3327 }
3328
3329 void OPPROTO op_efdctsidz (void)
3330 {
3331     do_efdctsiz();
3332     RETURN();
3333 }
3334
3335 void OPPROTO op_efdctuidz (void)
3336 {
3337     do_efdctuiz();
3338     RETURN();
3339 }
3340
3341 void OPPROTO op_efdcmplt (void)
3342 {
3343     do_efdcmplt();
3344     RETURN();
3345 }
3346
3347 void OPPROTO op_efdcmpgt (void)
3348 {
3349     do_efdcmpgt();
3350     RETURN();
3351 }
3352
3353 void OPPROTO op_efdcfs (void)
3354 {
3355     do_efdcfs();
3356     RETURN();
3357 }
3358
3359 void OPPROTO op_efdcmpeq (void)
3360 {
3361     do_efdcmpeq();
3362     RETURN();
3363 }
3364
3365 void OPPROTO op_efdcfsi (void)
3366 {
3367     do_efdcfsi();
3368     RETURN();
3369 }
3370
3371 void OPPROTO op_efdcfui (void)
3372 {
3373     do_efdcfui();
3374     RETURN();
3375 }
3376
3377 void OPPROTO op_efdcfsf (void)
3378 {
3379     do_efdcfsf();
3380     RETURN();
3381 }
3382
3383 void OPPROTO op_efdcfuf (void)
3384 {
3385     do_efdcfuf();
3386     RETURN();
3387 }
3388
3389 void OPPROTO op_efdctsi (void)
3390 {
3391     do_efdctsi();
3392     RETURN();
3393 }
3394
3395 void OPPROTO op_efdctui (void)
3396 {
3397     do_efdctui();
3398     RETURN();
3399 }
3400
3401 void OPPROTO op_efdctsf (void)
3402 {
3403     do_efdctsf();
3404     RETURN();
3405 }
3406
3407 void OPPROTO op_efdctuf (void)
3408 {
3409     do_efdctuf();
3410     RETURN();
3411 }
3412
3413 void OPPROTO op_efdctuiz (void)
3414 {
3415     do_efdctuiz();
3416     RETURN();
3417 }
3418
3419 void OPPROTO op_efdctsiz (void)
3420 {
3421     do_efdctsiz();
3422     RETURN();
3423 }
3424
3425 void OPPROTO op_efdtstlt (void)
3426 {
3427     T0 = _do_efdtstlt(T0_64, T1_64);
3428     RETURN();
3429 }
3430
3431 void OPPROTO op_efdtstgt (void)
3432 {
3433     T0 = _do_efdtstgt(T0_64, T1_64);
3434     RETURN();
3435 }
3436
3437 void OPPROTO op_efdtsteq (void)
3438 {
3439     T0 = _do_efdtsteq(T0_64, T1_64);
3440     RETURN();
3441 }
3442 #endif /* defined(TARGET_PPCEMB) */