target-ppc/op.c

   1 /*
   2  *  PowerPC emulation micro-operations for qemu.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 //#define DEBUG_OP
  22
  23 #include "config.h"
  24 #include "exec.h"
  25 #include "host-utils.h"
  26 #include "helper_regs.h"
  27 #include "op_helper.h"
  28
  29 /* Generate exceptions */
  30 void OPPROTO op_raise_exception_err (void)
  31 {
  32     do_raise_exception_err(PARAM1, PARAM2);
  33 }
  34
  35 void OPPROTO op_debug (void)
  36 {
  37     do_raise_exception(EXCP_DEBUG);
  38 }
  39
  40 #if !defined(CONFIG_USER_ONLY)
  41 /* Segment registers load and store */
  42 void OPPROTO op_load_sr (void)
  43 {
  44     T0 = env->sr[T1];
  45     RETURN();
  46 }
  47
  48 void OPPROTO op_store_sr (void)
  49 {
  50     do_store_sr(env, T1, T0);
  51     RETURN();
  52 }
  53
  54 #if defined(TARGET_PPC64)
  55 void OPPROTO op_load_slb (void)
  56 {
  57     T0 = ppc_load_slb(env, T1);
  58     RETURN();
  59 }
  60
  61 void OPPROTO op_store_slb (void)
  62 {
  63     ppc_store_slb(env, T1, T0);
  64     RETURN();
  65 }
  66 #endif /* defined(TARGET_PPC64) */
  67
  68 void OPPROTO op_load_sdr1 (void)
  69 {
  70     T0 = env->sdr1;
  71     RETURN();
  72 }
  73
  74 void OPPROTO op_store_sdr1 (void)
  75 {
  76     do_store_sdr1(env, T0);
  77     RETURN();
  78 }
  79
  80 #if defined (TARGET_PPC64)
  81 void OPPROTO op_load_asr (void)
  82 {
  83     T0 = env->asr;
  84     RETURN();
  85 }
  86
  87 void OPPROTO op_store_asr (void)
  88 {
  89     ppc_store_asr(env, T0);
  90     RETURN();
  91 }
  92 #endif
  93
  94 void OPPROTO op_load_msr (void)
  95 {
  96     T0 = env->msr;
  97     RETURN();
  98 }
  99
 100 void OPPROTO op_store_msr (void)
 101 {
 102     do_store_msr();
 103     RETURN();
 104 }
 105
 106 #if defined (TARGET_PPC64)
 107 void OPPROTO op_store_msr_32 (void)
 108 {
 109     T0 = (env->msr & ~0xFFFFFFFFULL) | (T0 & 0xFFFFFFFF);
 110     do_store_msr();
 111     RETURN();
 112 }
 113 #endif
 114
 115 void OPPROTO op_update_riee (void)
 116 {
 117     /* We don't call do_store_msr here as we won't trigger
 118      * any special case nor change hflags
 119      */
 120     T0 &= (1 << MSR_RI) | (1 << MSR_EE);
 121     env->msr &= ~(1 << MSR_RI) | (1 << MSR_EE);
 122     env->msr |= T0;
 123     RETURN();
 124 }
 125 #endif
 126
 127 /* SPR */
 128 void OPPROTO op_load_spr (void)
 129 {
 130     T0 = env->spr[PARAM1];
 131     RETURN();
 132 }
 133
 134 void OPPROTO op_store_spr (void)
 135 {
 136     env->spr[PARAM1] = T0;
 137     RETURN();
 138 }
 139
 140 void OPPROTO op_load_dump_spr (void)
 141 {
 142     T0 = ppc_load_dump_spr(PARAM1);
 143     RETURN();
 144 }
 145
 146 void OPPROTO op_store_dump_spr (void)
 147 {
 148     ppc_store_dump_spr(PARAM1, T0);
 149     RETURN();
 150 }
 151
 152 void OPPROTO op_mask_spr (void)
 153 {
 154     env->spr[PARAM1] &= ~T0;
 155     RETURN();
 156 }
 157
 158 void OPPROTO op_load_tbl (void)
 159 {
 160     T0 = cpu_ppc_load_tbl(env);
 161     RETURN();
 162 }
 163
 164 void OPPROTO op_load_tbu (void)
 165 {
 166     T0 = cpu_ppc_load_tbu(env);
 167     RETURN();
 168 }
 169
 170 void OPPROTO op_load_atbl (void)
 171 {
 172     T0 = cpu_ppc_load_atbl(env);
 173     RETURN();
 174 }
 175
 176 void OPPROTO op_load_atbu (void)
 177 {
 178     T0 = cpu_ppc_load_atbu(env);
 179     RETURN();
 180 }
 181
 182 #if !defined(CONFIG_USER_ONLY)
 183 void OPPROTO op_store_tbl (void)
 184 {
 185     cpu_ppc_store_tbl(env, T0);
 186     RETURN();
 187 }
 188
 189 void OPPROTO op_store_tbu (void)
 190 {
 191     cpu_ppc_store_tbu(env, T0);
 192     RETURN();
 193 }
 194
 195 void OPPROTO op_store_atbl (void)
 196 {
 197     cpu_ppc_store_atbl(env, T0);
 198     RETURN();
 199 }
 200
 201 void OPPROTO op_store_atbu (void)
 202 {
 203     cpu_ppc_store_atbu(env, T0);
 204     RETURN();
 205 }
 206
 207 void OPPROTO op_load_decr (void)
 208 {
 209     T0 = cpu_ppc_load_decr(env);
 210     RETURN();
 211 }
 212
 213 void OPPROTO op_store_decr (void)
 214 {
 215     cpu_ppc_store_decr(env, T0);
 216     RETURN();
 217 }
 218
 219 void OPPROTO op_load_ibat (void)
 220 {
 221     T0 = env->IBAT[PARAM1][PARAM2];
 222     RETURN();
 223 }
 224
 225 void OPPROTO op_store_ibatu (void)
 226 {
 227     do_store_ibatu(env, PARAM1, T0);
 228     RETURN();
 229 }
 230
 231 void OPPROTO op_store_ibatl (void)
 232 {
 233 #if 1
 234     env->IBAT[1][PARAM1] = T0;
 235 #else
 236     do_store_ibatl(env, PARAM1, T0);
 237 #endif
 238     RETURN();
 239 }
 240
 241 void OPPROTO op_load_dbat (void)
 242 {
 243     T0 = env->DBAT[PARAM1][PARAM2];
 244     RETURN();
 245 }
 246
 247 void OPPROTO op_store_dbatu (void)
 248 {
 249     do_store_dbatu(env, PARAM1, T0);
 250     RETURN();
 251 }
 252
 253 void OPPROTO op_store_dbatl (void)
 254 {
 255 #if 1
 256     env->DBAT[1][PARAM1] = T0;
 257 #else
 258     do_store_dbatl(env, PARAM1, T0);
 259 #endif
 260     RETURN();
 261 }
 262 #endif /* !defined(CONFIG_USER_ONLY) */
 263
 264 /* FPSCR */
 265 #ifdef CONFIG_SOFTFLOAT
 266 void OPPROTO op_reset_fpstatus (void)
 267 {
 268     env->fp_status.float_exception_flags = 0;
 269     RETURN();
 270 }
 271 #endif
 272
 273 void OPPROTO op_compute_fprf (void)
 274 {
 275     do_compute_fprf(PARAM1);
 276     RETURN();
 277 }
 278
 279 #ifdef CONFIG_SOFTFLOAT
 280 void OPPROTO op_float_check_status (void)
 281 {
 282     do_float_check_status();
 283     RETURN();
 284 }
 285 #else
 286 void OPPROTO op_float_check_status (void)
 287 {
 288     if (env->exception_index == POWERPC_EXCP_PROGRAM &&
 289         (env->error_code & POWERPC_EXCP_FP)) {
 290         /* Differred floating-point exception after target FPR update */
 291         if (msr_fe0 != 0 || msr_fe1 != 0)
 292             do_raise_exception_err(env->exception_index, env->error_code);
 293     }
 294     RETURN();
 295 }
 296 #endif
 297
 298 void OPPROTO op_load_fpscr_FT0 (void)
 299 {
 300     /* The 32 MSB of the target fpr are undefined.
 301      * They'll be zero...
 302      */
 303     CPU_DoubleU u;
 304
 305     u.l.upper = 0;
 306     u.l.lower = env->fpscr;
 307     FT0 = u.d;
 308     RETURN();
 309 }
 310
 311 void OPPROTO op_fpscr_resetbit (void)
 312 {
 313     env->fpscr &= PARAM1;
 314     RETURN();
 315 }
 316
 317 void OPPROTO op_fpscr_setbit (void)
 318 {
 319     do_fpscr_setbit(PARAM1);
 320     RETURN();
 321 }
 322
 323 void OPPROTO op_store_fpscr (void)
 324 {
 325     do_store_fpscr(PARAM1);
 326     RETURN();
 327 }
 328
 329 /***                             Integer shift                             ***/
 330 void OPPROTO op_srli_T1 (void)
 331 {
 332     T1 = (uint32_t)T1 >> PARAM1;
 333     RETURN();
 334 }
 335
 336 /***                       Floating-Point arithmetic                       ***/
 337 /* fadd - fadd. */
 338 void OPPROTO op_fadd (void)
 339 {
 340 #if USE_PRECISE_EMULATION
 341     do_fadd();
 342 #else
 343     FT0 = float64_add(FT0, FT1, &env->fp_status);
 344 #endif
 345     RETURN();
 346 }
 347
 348 /* fsub - fsub. */
 349 void OPPROTO op_fsub (void)
 350 {
 351 #if USE_PRECISE_EMULATION
 352     do_fsub();
 353 #else
 354     FT0 = float64_sub(FT0, FT1, &env->fp_status);
 355 #endif
 356     RETURN();
 357 }
 358
 359 /* fmul - fmul. */
 360 void OPPROTO op_fmul (void)
 361 {
 362 #if USE_PRECISE_EMULATION
 363     do_fmul();
 364 #else
 365     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 366 #endif
 367     RETURN();
 368 }
 369
 370 /* fdiv - fdiv. */
 371 void OPPROTO op_fdiv (void)
 372 {
 373 #if USE_PRECISE_EMULATION
 374     do_fdiv();
 375 #else
 376     FT0 = float64_div(FT0, FT1, &env->fp_status);
 377 #endif
 378     RETURN();
 379 }
 380
 381 /* fsqrt - fsqrt. */
 382 void OPPROTO op_fsqrt (void)
 383 {
 384     do_fsqrt();
 385     RETURN();
 386 }
 387
 388 /* fre - fre. */
 389 void OPPROTO op_fre (void)
 390 {
 391     do_fre();
 392     RETURN();
 393 }
 394
 395 /* fres - fres. */
 396 void OPPROTO op_fres (void)
 397 {
 398     do_fres();
 399     RETURN();
 400 }
 401
 402 /* frsqrte  - frsqrte. */
 403 void OPPROTO op_frsqrte (void)
 404 {
 405     do_frsqrte();
 406     RETURN();
 407 }
 408
 409 /* fsel - fsel. */
 410 void OPPROTO op_fsel (void)
 411 {
 412     do_fsel();
 413     RETURN();
 414 }
 415
 416 /***                     Floating-Point multiply-and-add                   ***/
 417 /* fmadd - fmadd. */
 418 void OPPROTO op_fmadd (void)
 419 {
 420 #if USE_PRECISE_EMULATION
 421     do_fmadd();
 422 #else
 423     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 424     FT0 = float64_add(FT0, FT2, &env->fp_status);
 425 #endif
 426     RETURN();
 427 }
 428
 429 /* fmsub - fmsub. */
 430 void OPPROTO op_fmsub (void)
 431 {
 432 #if USE_PRECISE_EMULATION
 433     do_fmsub();
 434 #else
 435     FT0 = float64_mul(FT0, FT1, &env->fp_status);
 436     FT0 = float64_sub(FT0, FT2, &env->fp_status);
 437 #endif
 438     RETURN();
 439 }
 440
 441 /* fnmadd - fnmadd. - fnmadds - fnmadds. */
 442 void OPPROTO op_fnmadd (void)
 443 {
 444     do_fnmadd();
 445     RETURN();
 446 }
 447
 448 /* fnmsub - fnmsub. */
 449 void OPPROTO op_fnmsub (void)
 450 {
 451     do_fnmsub();
 452     RETURN();
 453 }
 454
 455 /***                     Floating-Point round & convert                    ***/
 456 /* frsp - frsp. */
 457 void OPPROTO op_frsp (void)
 458 {
 459 #if USE_PRECISE_EMULATION
 460     do_frsp();
 461 #else
 462     FT0 = float64_to_float32(FT0, &env->fp_status);
 463 #endif
 464     RETURN();
 465 }
 466
 467 /* fctiw - fctiw. */
 468 void OPPROTO op_fctiw (void)
 469 {
 470     do_fctiw();
 471     RETURN();
 472 }
 473
 474 /* fctiwz - fctiwz. */
 475 void OPPROTO op_fctiwz (void)
 476 {
 477     do_fctiwz();
 478     RETURN();
 479 }
 480
 481 #if defined(TARGET_PPC64)
 482 /* fcfid - fcfid. */
 483 void OPPROTO op_fcfid (void)
 484 {
 485     do_fcfid();
 486     RETURN();
 487 }
 488
 489 /* fctid - fctid. */
 490 void OPPROTO op_fctid (void)
 491 {
 492     do_fctid();
 493     RETURN();
 494 }
 495
 496 /* fctidz - fctidz. */
 497 void OPPROTO op_fctidz (void)
 498 {
 499     do_fctidz();
 500     RETURN();
 501 }
 502 #endif
 503
 504 void OPPROTO op_frin (void)
 505 {
 506     do_frin();
 507     RETURN();
 508 }
 509
 510 void OPPROTO op_friz (void)
 511 {
 512     do_friz();
 513     RETURN();
 514 }
 515
 516 void OPPROTO op_frip (void)
 517 {
 518     do_frip();
 519     RETURN();
 520 }
 521
 522 void OPPROTO op_frim (void)
 523 {
 524     do_frim();
 525     RETURN();
 526 }
 527
 528 /***                         Floating-point move                           ***/
 529 /* fabs */
 530 void OPPROTO op_fabs (void)
 531 {
 532     FT0 = float64_abs(FT0);
 533     RETURN();
 534 }
 535
 536 /* fnabs */
 537 void OPPROTO op_fnabs (void)
 538 {
 539     FT0 = float64_abs(FT0);
 540     FT0 = float64_chs(FT0);
 541     RETURN();
 542 }
 543
 544 /* fneg */
 545 void OPPROTO op_fneg (void)
 546 {
 547     FT0 = float64_chs(FT0);
 548     RETURN();
 549 }
 550
 551 /* Load and store */
 552 #define MEMSUFFIX _raw
 553 #include "op_helper.h"
 554 #include "op_mem.h"
 555 #if !defined(CONFIG_USER_ONLY)
 556 #define MEMSUFFIX _user
 557 #include "op_helper.h"
 558 #include "op_mem.h"
 559 #define MEMSUFFIX _kernel
 560 #include "op_helper.h"
 561 #include "op_mem.h"
 562 #define MEMSUFFIX _hypv
 563 #include "op_helper.h"
 564 #include "op_mem.h"
 565 #endif
 566
 567 /* Special op to check and maybe clear reservation */
 568 void OPPROTO op_check_reservation (void)
 569 {
 570     if ((uint32_t)env->reserve == (uint32_t)(T0 & ~0x00000003))
 571         env->reserve = (target_ulong)-1ULL;
 572     RETURN();
 573 }
 574
 575 #if defined(TARGET_PPC64)
 576 void OPPROTO op_check_reservation_64 (void)
 577 {
 578     if ((uint64_t)env->reserve == (uint64_t)(T0 & ~0x00000003))
 579         env->reserve = (target_ulong)-1ULL;
 580     RETURN();
 581 }
 582 #endif
 583
 584 void OPPROTO op_wait (void)
 585 {
 586     env->halted = 1;
 587     RETURN();
 588 }
 589
 590 /* Return from interrupt */
 591 #if !defined(CONFIG_USER_ONLY)
 592 void OPPROTO op_rfi (void)
 593 {
 594     do_rfi();
 595     RETURN();
 596 }
 597
 598 #if defined(TARGET_PPC64)
 599 void OPPROTO op_rfid (void)
 600 {
 601     do_rfid();
 602     RETURN();
 603 }
 604
 605 void OPPROTO op_hrfid (void)
 606 {
 607     do_hrfid();
 608     RETURN();
 609 }
 610 #endif
 611
 612 /* Exception vectors */
 613 void OPPROTO op_store_excp_prefix (void)
 614 {
 615     T0 &= env->ivpr_mask;
 616     env->excp_prefix = T0;
 617     RETURN();
 618 }
 619
 620 void OPPROTO op_store_excp_vector (void)
 621 {
 622     T0 &= env->ivor_mask;
 623     env->excp_vectors[PARAM1] = T0;
 624     RETURN();
 625 }
 626 #endif
 627
 628 /* Trap word */
 629 void OPPROTO op_tw (void)
 630 {
 631     do_tw(PARAM1);
 632     RETURN();
 633 }
 634
 635 #if defined(TARGET_PPC64)
 636 void OPPROTO op_td (void)
 637 {
 638     do_td(PARAM1);
 639     RETURN();
 640 }
 641 #endif
 642
 643 #if !defined(CONFIG_USER_ONLY)
 644 /* tlbia */
 645 void OPPROTO op_tlbia (void)
 646 {
 647     ppc_tlb_invalidate_all(env);
 648     RETURN();
 649 }
 650
 651 /* tlbie */
 652 void OPPROTO op_tlbie (void)
 653 {
 654     ppc_tlb_invalidate_one(env, (uint32_t)T0);
 655     RETURN();
 656 }
 657
 658 #if defined(TARGET_PPC64)
 659 void OPPROTO op_tlbie_64 (void)
 660 {
 661     ppc_tlb_invalidate_one(env, T0);
 662     RETURN();
 663 }
 664 #endif
 665
 666 #if defined(TARGET_PPC64)
 667 void OPPROTO op_slbia (void)
 668 {
 669     ppc_slb_invalidate_all(env);
 670     RETURN();
 671 }
 672
 673 void OPPROTO op_slbie (void)
 674 {
 675     ppc_slb_invalidate_one(env, (uint32_t)T0);
 676     RETURN();
 677 }
 678
 679 void OPPROTO op_slbie_64 (void)
 680 {
 681     ppc_slb_invalidate_one(env, T0);
 682     RETURN();
 683 }
 684 #endif
 685 #endif
 686
 687 #if !defined(CONFIG_USER_ONLY)
 688 /* PowerPC 602/603/755 software TLB load instructions */
 689 void OPPROTO op_6xx_tlbld (void)
 690 {
 691     do_load_6xx_tlb(0);
 692     RETURN();
 693 }
 694
 695 void OPPROTO op_6xx_tlbli (void)
 696 {
 697     do_load_6xx_tlb(1);
 698     RETURN();
 699 }
 700
 701 /* PowerPC 74xx software TLB load instructions */
 702 void OPPROTO op_74xx_tlbld (void)
 703 {
 704     do_load_74xx_tlb(0);
 705     RETURN();
 706 }
 707
 708 void OPPROTO op_74xx_tlbli (void)
 709 {
 710     do_load_74xx_tlb(1);
 711     RETURN();
 712 }
 713 #endif
 714
 715 /* 601 specific */
 716 void OPPROTO op_load_601_rtcl (void)
 717 {
 718     T0 = cpu_ppc601_load_rtcl(env);
 719     RETURN();
 720 }
 721
 722 void OPPROTO op_load_601_rtcu (void)
 723 {
 724     T0 = cpu_ppc601_load_rtcu(env);
 725     RETURN();
 726 }
 727
 728 #if !defined(CONFIG_USER_ONLY)
 729 void OPPROTO op_store_601_rtcl (void)
 730 {
 731     cpu_ppc601_store_rtcl(env, T0);
 732     RETURN();
 733 }
 734
 735 void OPPROTO op_store_601_rtcu (void)
 736 {
 737     cpu_ppc601_store_rtcu(env, T0);
 738     RETURN();
 739 }
 740
 741 void OPPROTO op_store_hid0_601 (void)
 742 {
 743     do_store_hid0_601();
 744     RETURN();
 745 }
 746
 747 void OPPROTO op_load_601_bat (void)
 748 {
 749     T0 = env->IBAT[PARAM1][PARAM2];
 750     RETURN();
 751 }
 752
 753 void OPPROTO op_store_601_batl (void)
 754 {
 755     do_store_ibatl_601(env, PARAM1, T0);
 756     RETURN();
 757 }
 758
 759 void OPPROTO op_store_601_batu (void)
 760 {
 761     do_store_ibatu_601(env, PARAM1, T0);
 762     RETURN();
 763 }
 764 #endif /* !defined(CONFIG_USER_ONLY) */
 765
 766 /* PowerPC 601 specific instructions (POWER bridge) */
 767 /* XXX: those micro-ops need tests ! */
 768 void OPPROTO op_POWER_abs (void)
 769 {
 770     if ((int32_t)T0 == INT32_MIN)
 771         T0 = INT32_MAX;
 772     else if ((int32_t)T0 < 0)
 773         T0 = -T0;
 774     RETURN();
 775 }
 776
 777 void OPPROTO op_POWER_abso (void)
 778 {
 779     do_POWER_abso();
 780     RETURN();
 781 }
 782
 783 void OPPROTO op_POWER_clcs (void)
 784 {
 785     do_POWER_clcs();
 786     RETURN();
 787 }
 788
 789 void OPPROTO op_POWER_div (void)
 790 {
 791     do_POWER_div();
 792     RETURN();
 793 }
 794
 795 void OPPROTO op_POWER_divo (void)
 796 {
 797     do_POWER_divo();
 798     RETURN();
 799 }
 800
 801 void OPPROTO op_POWER_divs (void)
 802 {
 803     do_POWER_divs();
 804     RETURN();
 805 }
 806
 807 void OPPROTO op_POWER_divso (void)
 808 {
 809     do_POWER_divso();
 810     RETURN();
 811 }
 812
 813 void OPPROTO op_POWER_doz (void)
 814 {
 815     if ((int32_t)T1 > (int32_t)T0)
 816         T0 = T1 - T0;
 817     else
 818         T0 = 0;
 819     RETURN();
 820 }
 821
 822 void OPPROTO op_POWER_dozo (void)
 823 {
 824     do_POWER_dozo();
 825     RETURN();
 826 }
 827
 828 void OPPROTO op_load_xer_cmp (void)
 829 {
 830     T2 = xer_cmp;
 831     RETURN();
 832 }
 833
 834 void OPPROTO op_POWER_maskg (void)
 835 {
 836     do_POWER_maskg();
 837     RETURN();
 838 }
 839
 840 void OPPROTO op_POWER_maskir (void)
 841 {
 842     T0 = (T0 & ~T2) | (T1 & T2);
 843     RETURN();
 844 }
 845
 846 void OPPROTO op_POWER_mul (void)
 847 {
 848     uint64_t tmp;
 849
 850     tmp = (uint64_t)T0 * (uint64_t)T1;
 851     env->spr[SPR_MQ] = tmp >> 32;
 852     T0 = tmp;
 853     RETURN();
 854 }
 855
 856 void OPPROTO op_POWER_mulo (void)
 857 {
 858     do_POWER_mulo();
 859     RETURN();
 860 }
 861
 862 void OPPROTO op_POWER_nabs (void)
 863 {
 864     if (T0 > 0)
 865         T0 = -T0;
 866     RETURN();
 867 }
 868
 869 void OPPROTO op_POWER_nabso (void)
 870 {
 871     /* nabs never overflows */
 872     if (T0 > 0)
 873         T0 = -T0;
 874     env->xer &= ~(1 << XER_OV);
 875     RETURN();
 876 }
 877
 878 /* XXX: factorise POWER rotates... */
 879 void OPPROTO op_POWER_rlmi (void)
 880 {
 881     T0 = rotl32(T0, T2) & PARAM1;
 882     T0 |= T1 & (uint32_t)PARAM2;
 883     RETURN();
 884 }
 885
 886 void OPPROTO op_POWER_rrib (void)
 887 {
 888     T2 &= 0x1FUL;
 889     T0 = rotl32(T0 & INT32_MIN, T2);
 890     T0 |= T1 & ~rotl32(INT32_MIN, T2);
 891     RETURN();
 892 }
 893
 894 void OPPROTO op_POWER_sle (void)
 895 {
 896     T1 &= 0x1FUL;
 897     env->spr[SPR_MQ] = rotl32(T0, T1);
 898     T0 = T0 << T1;
 899     RETURN();
 900 }
 901
 902 void OPPROTO op_POWER_sleq (void)
 903 {
 904     uint32_t tmp = env->spr[SPR_MQ];
 905
 906     T1 &= 0x1FUL;
 907     env->spr[SPR_MQ] = rotl32(T0, T1);
 908     T0 = T0 << T1;
 909     T0 |= tmp >> (32 - T1);
 910     RETURN();
 911 }
 912
 913 void OPPROTO op_POWER_sllq (void)
 914 {
 915     uint32_t msk = UINT32_MAX;
 916
 917     msk = msk << (T1 & 0x1FUL);
 918     if (T1 & 0x20UL)
 919         msk = ~msk;
 920     T1 &= 0x1FUL;
 921     T0 = (T0 << T1) & msk;
 922     T0 |= env->spr[SPR_MQ] & ~msk;
 923     RETURN();
 924 }
 925
 926 void OPPROTO op_POWER_slq (void)
 927 {
 928     uint32_t msk = UINT32_MAX, tmp;
 929
 930     msk = msk << (T1 & 0x1FUL);
 931     if (T1 & 0x20UL)
 932         msk = ~msk;
 933     T1 &= 0x1FUL;
 934     tmp = rotl32(T0, T1);
 935     T0 = tmp & msk;
 936     env->spr[SPR_MQ] = tmp;
 937     RETURN();
 938 }
 939
 940 void OPPROTO op_POWER_sraq (void)
 941 {
 942     env->spr[SPR_MQ] = rotl32(T0, 32 - (T1 & 0x1FUL));
 943     if (T1 & 0x20UL)
 944         T0 = UINT32_MAX;
 945     else
 946         T0 = (int32_t)T0 >> T1;
 947     RETURN();
 948 }
 949
 950 void OPPROTO op_POWER_sre (void)
 951 {
 952     T1 &= 0x1FUL;
 953     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
 954     T0 = (int32_t)T0 >> T1;
 955     RETURN();
 956 }
 957
 958 void OPPROTO op_POWER_srea (void)
 959 {
 960     T1 &= 0x1FUL;
 961     env->spr[SPR_MQ] = T0 >> T1;
 962     T0 = (int32_t)T0 >> T1;
 963     RETURN();
 964 }
 965
 966 void OPPROTO op_POWER_sreq (void)
 967 {
 968     uint32_t tmp;
 969     int32_t msk;
 970
 971     T1 &= 0x1FUL;
 972     msk = INT32_MIN >> T1;
 973     tmp = env->spr[SPR_MQ];
 974     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
 975     T0 = T0 >> T1;
 976     T0 |= tmp & msk;
 977     RETURN();
 978 }
 979
 980 void OPPROTO op_POWER_srlq (void)
 981 {
 982     uint32_t tmp;
 983     int32_t msk;
 984
 985     msk = INT32_MIN >> (T1 & 0x1FUL);
 986     if (T1 & 0x20UL)
 987         msk = ~msk;
 988     T1 &= 0x1FUL;
 989     tmp = env->spr[SPR_MQ];
 990     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
 991     T0 = T0 >> T1;
 992     T0 &= msk;
 993     T0 |= tmp & ~msk;
 994     RETURN();
 995 }
 996
 997 void OPPROTO op_POWER_srq (void)
 998 {
 999     T1 &= 0x1FUL;
1000     env->spr[SPR_MQ] = rotl32(T0, 32 - T1);
1001     T0 = T0 >> T1;
1002     RETURN();
1003 }
1004
1005 /* POWER instructions not implemented in PowerPC 601 */
1006 #if !defined(CONFIG_USER_ONLY)
1007 void OPPROTO op_POWER_mfsri (void)
1008 {
1009     T1 = T0 >> 28;
1010     T0 = env->sr[T1];
1011     RETURN();
1012 }
1013
1014 void OPPROTO op_POWER_rac (void)
1015 {
1016     do_POWER_rac();
1017     RETURN();
1018 }
1019
1020 void OPPROTO op_POWER_rfsvc (void)
1021 {
1022     do_POWER_rfsvc();
1023     RETURN();
1024 }
1025 #endif
1026
1027 /* PowerPC 602 specific instruction */
1028 #if !defined(CONFIG_USER_ONLY)
1029 void OPPROTO op_602_mfrom (void)
1030 {
1031     do_op_602_mfrom();
1032     RETURN();
1033 }
1034 #endif
1035
1036 /* PowerPC 4xx specific micro-ops */
1037 void OPPROTO op_load_dcr (void)
1038 {
1039     do_load_dcr();
1040     RETURN();
1041 }
1042
1043 void OPPROTO op_store_dcr (void)
1044 {
1045     do_store_dcr();
1046     RETURN();
1047 }
1048
1049 #if !defined(CONFIG_USER_ONLY)
1050 /* Return from critical interrupt :
1051  * same as rfi, except nip & MSR are loaded from SRR2/3 instead of SRR0/1
1052  */
1053 void OPPROTO op_40x_rfci (void)
1054 {
1055     do_40x_rfci();
1056     RETURN();
1057 }
1058
1059 void OPPROTO op_rfci (void)
1060 {
1061     do_rfci();
1062     RETURN();
1063 }
1064
1065 void OPPROTO op_rfdi (void)
1066 {
1067     do_rfdi();
1068     RETURN();
1069 }
1070
1071 void OPPROTO op_rfmci (void)
1072 {
1073     do_rfmci();
1074     RETURN();
1075 }
1076
1077 void OPPROTO op_wrte (void)
1078 {
1079     /* We don't call do_store_msr here as we won't trigger
1080      * any special case nor change hflags
1081      */
1082     T0 &= 1 << MSR_EE;
1083     env->msr &= ~(1 << MSR_EE);
1084     env->msr |= T0;
1085     RETURN();
1086 }
1087
1088 void OPPROTO op_440_tlbre (void)
1089 {
1090     do_440_tlbre(PARAM1);
1091     RETURN();
1092 }
1093
1094 void OPPROTO op_440_tlbsx (void)
1095 {
1096     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_440_MMUCR] & 0xFF);
1097     RETURN();
1098 }
1099
1100 void OPPROTO op_4xx_tlbsx_check (void)
1101 {
1102     int tmp;
1103
1104     tmp = xer_so;
1105     if ((int)T0 != -1)
1106         tmp |= 0x02;
1107     env->crf[0] = tmp;
1108     RETURN();
1109 }
1110
1111 void OPPROTO op_440_tlbwe (void)
1112 {
1113     do_440_tlbwe(PARAM1);
1114     RETURN();
1115 }
1116
1117 void OPPROTO op_4xx_tlbre_lo (void)
1118 {
1119     do_4xx_tlbre_lo();
1120     RETURN();
1121 }
1122
1123 void OPPROTO op_4xx_tlbre_hi (void)
1124 {
1125     do_4xx_tlbre_hi();
1126     RETURN();
1127 }
1128
1129 void OPPROTO op_4xx_tlbsx (void)
1130 {
1131     T0 = ppcemb_tlb_search(env, T0, env->spr[SPR_40x_PID]);
1132     RETURN();
1133 }
1134
1135 void OPPROTO op_4xx_tlbwe_lo (void)
1136 {
1137     do_4xx_tlbwe_lo();
1138     RETURN();
1139 }
1140
1141 void OPPROTO op_4xx_tlbwe_hi (void)
1142 {
1143     do_4xx_tlbwe_hi();
1144     RETURN();
1145 }
1146 #endif
1147
1148 /* SPR micro-ops */
1149 /* 440 specific */
1150 void OPPROTO op_440_dlmzb (void)
1151 {
1152     do_440_dlmzb();
1153     RETURN();
1154 }
1155
1156 void OPPROTO op_440_dlmzb_update_Rc (void)
1157 {
1158     if (T0 == 8)
1159         T0 = 0x2;
1160     else if (T0 < 4)
1161         T0 = 0x4;
1162     else
1163         T0 = 0x8;
1164     RETURN();
1165 }
1166
1167 #if !defined(CONFIG_USER_ONLY)
1168 void OPPROTO op_store_pir (void)
1169 {
1170     env->spr[SPR_PIR] = T0 & 0x0000000FUL;
1171     RETURN();
1172 }
1173
1174 void OPPROTO op_load_403_pb (void)
1175 {
1176     do_load_403_pb(PARAM1);
1177     RETURN();
1178 }
1179
1180 void OPPROTO op_store_403_pb (void)
1181 {
1182     do_store_403_pb(PARAM1);
1183     RETURN();
1184 }
1185
1186 void OPPROTO op_load_40x_pit (void)
1187 {
1188     T0 = load_40x_pit(env);
1189     RETURN();
1190 }
1191
1192 void OPPROTO op_store_40x_pit (void)
1193 {
1194     store_40x_pit(env, T0);
1195     RETURN();
1196 }
1197
1198 void OPPROTO op_store_40x_dbcr0 (void)
1199 {
1200     store_40x_dbcr0(env, T0);
1201     RETURN();
1202 }
1203
1204 void OPPROTO op_store_40x_sler (void)
1205 {
1206     store_40x_sler(env, T0);
1207     RETURN();
1208 }
1209
1210 void OPPROTO op_store_booke_tcr (void)
1211 {
1212     store_booke_tcr(env, T0);
1213     RETURN();
1214 }
1215
1216 void OPPROTO op_store_booke_tsr (void)
1217 {
1218     store_booke_tsr(env, T0);
1219     RETURN();
1220 }
1221 #endif /* !defined(CONFIG_USER_ONLY) */
1222
1223 /* SPE extension */
1224 void OPPROTO op_splatw_T1_64 (void)
1225 {
1226     T1_64 = (T1_64 << 32) | (T1_64 & 0x00000000FFFFFFFFULL);
1227     RETURN();
1228 }
1229
1230 void OPPROTO op_extsh_T1_64 (void)
1231 {
1232     T1_64 = (int32_t)((int16_t)T1_64);
1233     RETURN();
1234 }
1235
1236 void OPPROTO op_sli16_T1_64 (void)
1237 {
1238     T1_64 = T1_64 << 16;
1239     RETURN();
1240 }
1241
1242 void OPPROTO op_sli32_T1_64 (void)
1243 {
1244     T1_64 = T1_64 << 32;
1245     RETURN();
1246 }
1247
1248 void OPPROTO op_srli32_T1_64 (void)
1249 {
1250     T1_64 = T1_64 >> 32;
1251     RETURN();
1252 }
1253
1254 void OPPROTO op_evfssub (void)
1255 {
1256     do_evfssub();
1257     RETURN();
1258 }
1259
1260 void OPPROTO op_evfsadd (void)
1261 {
1262     do_evfsadd();
1263     RETURN();
1264 }
1265
1266 void OPPROTO op_evfsnabs (void)
1267 {
1268     do_evfsnabs();
1269     RETURN();
1270 }
1271
1272 void OPPROTO op_evfsabs (void)
1273 {
1274     do_evfsabs();
1275     RETURN();
1276 }
1277
1278 void OPPROTO op_evfsneg (void)
1279 {
1280     do_evfsneg();
1281     RETURN();
1282 }
1283
1284 void OPPROTO op_evfsdiv (void)
1285 {
1286     do_evfsdiv();
1287     RETURN();
1288 }
1289
1290 void OPPROTO op_evfsmul (void)
1291 {
1292     do_evfsmul();
1293     RETURN();
1294 }
1295
1296 void OPPROTO op_evfscmplt (void)
1297 {
1298     do_evfscmplt();
1299     RETURN();
1300 }
1301
1302 void OPPROTO op_evfscmpgt (void)
1303 {
1304     do_evfscmpgt();
1305     RETURN();
1306 }
1307
1308 void OPPROTO op_evfscmpeq (void)
1309 {
1310     do_evfscmpeq();
1311     RETURN();
1312 }
1313
1314 void OPPROTO op_evfscfsi (void)
1315 {
1316     do_evfscfsi();
1317     RETURN();
1318 }
1319
1320 void OPPROTO op_evfscfui (void)
1321 {
1322     do_evfscfui();
1323     RETURN();
1324 }
1325
1326 void OPPROTO op_evfscfsf (void)
1327 {
1328     do_evfscfsf();
1329     RETURN();
1330 }
1331
1332 void OPPROTO op_evfscfuf (void)
1333 {
1334     do_evfscfuf();
1335     RETURN();
1336 }
1337
1338 void OPPROTO op_evfsctsi (void)
1339 {
1340     do_evfsctsi();
1341     RETURN();
1342 }
1343
1344 void OPPROTO op_evfsctui (void)
1345 {
1346     do_evfsctui();
1347     RETURN();
1348 }
1349
1350 void OPPROTO op_evfsctsf (void)
1351 {
1352     do_evfsctsf();
1353     RETURN();
1354 }
1355
1356 void OPPROTO op_evfsctuf (void)
1357 {
1358     do_evfsctuf();
1359     RETURN();
1360 }
1361
1362 void OPPROTO op_evfsctuiz (void)
1363 {
1364     do_evfsctuiz();
1365     RETURN();
1366 }
1367
1368 void OPPROTO op_evfsctsiz (void)
1369 {
1370     do_evfsctsiz();
1371     RETURN();
1372 }
1373
1374 void OPPROTO op_evfststlt (void)
1375 {
1376     do_evfststlt();
1377     RETURN();
1378 }
1379
1380 void OPPROTO op_evfststgt (void)
1381 {
1382     do_evfststgt();
1383     RETURN();
1384 }
1385
1386 void OPPROTO op_evfststeq (void)
1387 {
1388     do_evfststeq();
1389     RETURN();
1390 }
1391
1392 void OPPROTO op_efssub (void)
1393 {
1394     T0_64 = _do_efssub(T0_64, T1_64);
1395     RETURN();
1396 }
1397
1398 void OPPROTO op_efsadd (void)
1399 {
1400     T0_64 = _do_efsadd(T0_64, T1_64);
1401     RETURN();
1402 }
1403
1404 void OPPROTO op_efsnabs (void)
1405 {
1406     T0_64 = _do_efsnabs(T0_64);
1407     RETURN();
1408 }
1409
1410 void OPPROTO op_efsabs (void)
1411 {
1412     T0_64 = _do_efsabs(T0_64);
1413     RETURN();
1414 }
1415
1416 void OPPROTO op_efsneg (void)
1417 {
1418     T0_64 = _do_efsneg(T0_64);
1419     RETURN();
1420 }
1421
1422 void OPPROTO op_efsdiv (void)
1423 {
1424     T0_64 = _do_efsdiv(T0_64, T1_64);
1425     RETURN();
1426 }
1427
1428 void OPPROTO op_efsmul (void)
1429 {
1430     T0_64 = _do_efsmul(T0_64, T1_64);
1431     RETURN();
1432 }
1433
1434 void OPPROTO op_efscmplt (void)
1435 {
1436     do_efscmplt();
1437     RETURN();
1438 }
1439
1440 void OPPROTO op_efscmpgt (void)
1441 {
1442     do_efscmpgt();
1443     RETURN();
1444 }
1445
1446 void OPPROTO op_efscfd (void)
1447 {
1448     do_efscfd();
1449     RETURN();
1450 }
1451
1452 void OPPROTO op_efscmpeq (void)
1453 {
1454     do_efscmpeq();
1455     RETURN();
1456 }
1457
1458 void OPPROTO op_efscfsi (void)
1459 {
1460     do_efscfsi();
1461     RETURN();
1462 }
1463
1464 void OPPROTO op_efscfui (void)
1465 {
1466     do_efscfui();
1467     RETURN();
1468 }
1469
1470 void OPPROTO op_efscfsf (void)
1471 {
1472     do_efscfsf();
1473     RETURN();
1474 }
1475
1476 void OPPROTO op_efscfuf (void)
1477 {
1478     do_efscfuf();
1479     RETURN();
1480 }
1481
1482 void OPPROTO op_efsctsi (void)
1483 {
1484     do_efsctsi();
1485     RETURN();
1486 }
1487
1488 void OPPROTO op_efsctui (void)
1489 {
1490     do_efsctui();
1491     RETURN();
1492 }
1493
1494 void OPPROTO op_efsctsf (void)
1495 {
1496     do_efsctsf();
1497     RETURN();
1498 }
1499
1500 void OPPROTO op_efsctuf (void)
1501 {
1502     do_efsctuf();
1503     RETURN();
1504 }
1505
1506 void OPPROTO op_efsctsiz (void)
1507 {
1508     do_efsctsiz();
1509     RETURN();
1510 }
1511
1512 void OPPROTO op_efsctuiz (void)
1513 {
1514     do_efsctuiz();
1515     RETURN();
1516 }
1517
1518 void OPPROTO op_efststlt (void)
1519 {
1520     T0 = _do_efststlt(T0_64, T1_64);
1521     RETURN();
1522 }
1523
1524 void OPPROTO op_efststgt (void)
1525 {
1526     T0 = _do_efststgt(T0_64, T1_64);
1527     RETURN();
1528 }
1529
1530 void OPPROTO op_efststeq (void)
1531 {
1532     T0 = _do_efststeq(T0_64, T1_64);
1533     RETURN();
1534 }
1535
1536 void OPPROTO op_efdsub (void)
1537 {
1538     CPU_DoubleU u1, u2;
1539     u1.ll = T0_64;
1540     u2.ll = T1_64;
1541     u1.d = float64_sub(u1.d, u2.d, &env->spe_status);
1542     T0_64 = u1.ll;
1543     RETURN();
1544 }
1545
1546 void OPPROTO op_efdadd (void)
1547 {
1548     CPU_DoubleU u1, u2;
1549     u1.ll = T0_64;
1550     u2.ll = T1_64;
1551     u1.d = float64_add(u1.d, u2.d, &env->spe_status);
1552     T0_64 = u1.ll;
1553     RETURN();
1554 }
1555
1556 void OPPROTO op_efdcfsid (void)
1557 {
1558     do_efdcfsi();
1559     RETURN();
1560 }
1561
1562 void OPPROTO op_efdcfuid (void)
1563 {
1564     do_efdcfui();
1565     RETURN();
1566 }
1567
1568 void OPPROTO op_efdnabs (void)
1569 {
1570     T0_64 |= 0x8000000000000000ULL;
1571     RETURN();
1572 }
1573
1574 void OPPROTO op_efdabs (void)
1575 {
1576     T0_64 &= ~0x8000000000000000ULL;
1577     RETURN();
1578 }
1579
1580 void OPPROTO op_efdneg (void)
1581 {
1582     T0_64 ^= 0x8000000000000000ULL;
1583     RETURN();
1584 }
1585
1586 void OPPROTO op_efddiv (void)
1587 {
1588     CPU_DoubleU u1, u2;
1589     u1.ll = T0_64;
1590     u2.ll = T1_64;
1591     u1.d = float64_div(u1.d, u2.d, &env->spe_status);
1592     T0_64 = u1.ll;
1593     RETURN();
1594 }
1595
1596 void OPPROTO op_efdmul (void)
1597 {
1598     CPU_DoubleU u1, u2;
1599     u1.ll = T0_64;
1600     u2.ll = T1_64;
1601     u1.d = float64_mul(u1.d, u2.d, &env->spe_status);
1602     T0_64 = u1.ll;
1603     RETURN();
1604 }
1605
1606 void OPPROTO op_efdctsidz (void)
1607 {
1608     do_efdctsiz();
1609     RETURN();
1610 }
1611
1612 void OPPROTO op_efdctuidz (void)
1613 {
1614     do_efdctuiz();
1615     RETURN();
1616 }
1617
1618 void OPPROTO op_efdcmplt (void)
1619 {
1620     do_efdcmplt();
1621     RETURN();
1622 }
1623
1624 void OPPROTO op_efdcmpgt (void)
1625 {
1626     do_efdcmpgt();
1627     RETURN();
1628 }
1629
1630 void OPPROTO op_efdcfs (void)
1631 {
1632     do_efdcfs();
1633     RETURN();
1634 }
1635
1636 void OPPROTO op_efdcmpeq (void)
1637 {
1638     do_efdcmpeq();
1639     RETURN();
1640 }
1641
1642 void OPPROTO op_efdcfsi (void)
1643 {
1644     do_efdcfsi();
1645     RETURN();
1646 }
1647
1648 void OPPROTO op_efdcfui (void)
1649 {
1650     do_efdcfui();
1651     RETURN();
1652 }
1653
1654 void OPPROTO op_efdcfsf (void)
1655 {
1656     do_efdcfsf();
1657     RETURN();
1658 }
1659
1660 void OPPROTO op_efdcfuf (void)
1661 {
1662     do_efdcfuf();
1663     RETURN();
1664 }
1665
1666 void OPPROTO op_efdctsi (void)
1667 {
1668     do_efdctsi();
1669     RETURN();
1670 }
1671
1672 void OPPROTO op_efdctui (void)
1673 {
1674     do_efdctui();
1675     RETURN();
1676 }
1677
1678 void OPPROTO op_efdctsf (void)
1679 {
1680     do_efdctsf();
1681     RETURN();
1682 }
1683
1684 void OPPROTO op_efdctuf (void)
1685 {
1686     do_efdctuf();
1687     RETURN();
1688 }
1689
1690 void OPPROTO op_efdctuiz (void)
1691 {
1692     do_efdctuiz();
1693     RETURN();
1694 }
1695
1696 void OPPROTO op_efdctsiz (void)
1697 {
1698     do_efdctsiz();
1699     RETURN();
1700 }
1701
1702 void OPPROTO op_efdtstlt (void)
1703 {
1704     T0 = _do_efdtstlt(T0_64, T1_64);
1705     RETURN();
1706 }
1707
1708 void OPPROTO op_efdtstgt (void)
1709 {
1710     T0 = _do_efdtstgt(T0_64, T1_64);
1711     RETURN();
1712 }
1713
1714 void OPPROTO op_efdtsteq (void)
1715 {
1716     T0 = _do_efdtsteq(T0_64, T1_64);
1717     RETURN();
1718 }