target-sh4/op.c

   1 /*
   2  *  SH4 emulation
   3  *
   4  *  Copyright (c) 2005 Samuel Tardieu
   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 #include "exec.h"
  21
  22 static inline void set_t(void)
  23 {
  24     env->sr |= SR_T;
  25 }
  26
  27 static inline void clr_t(void)
  28 {
  29     env->sr &= ~SR_T;
  30 }
  31
  32 static inline void cond_t(int cond)
  33 {
  34     if (cond)
  35         set_t();
  36     else
  37         clr_t();
  38 }
  39
  40 void OPPROTO op_movl_imm_T0(void)
  41 {
  42     T0 = (uint32_t) PARAM1;
  43     RETURN();
  44 }
  45
  46 void OPPROTO op_movl_imm_T1(void)
  47 {
  48     T1 = (uint32_t) PARAM1;
  49     RETURN();
  50 }
  51
  52 void OPPROTO op_cmp_eq_imm_T0(void)
  53 {
  54     cond_t((int32_t) T0 == (int32_t) PARAM1);
  55     RETURN();
  56 }
  57
  58 void OPPROTO op_cmd_eq_T0_T1(void)
  59 {
  60     cond_t(T0 == T1);
  61     RETURN();
  62 }
  63
  64 void OPPROTO op_cmd_hs_T0_T1(void)
  65 {
  66     cond_t((uint32_t) T0 <= (uint32_t) T1);
  67     RETURN();
  68 }
  69
  70 void OPPROTO op_cmd_ge_T0_T1(void)
  71 {
  72     cond_t((int32_t) T0 <= (int32_t) T1);
  73     RETURN();
  74 }
  75
  76 void OPPROTO op_cmd_hi_T0_T1(void)
  77 {
  78     cond_t((uint32_t) T0 < (uint32_t) T1);
  79     RETURN();
  80 }
  81
  82 void OPPROTO op_cmd_gt_T0_T1(void)
  83 {
  84     cond_t((int32_t) T0 < (int32_t) T1);
  85     RETURN();
  86 }
  87
  88 void OPPROTO op_not_T0(void)
  89 {
  90     T0 = ~T0;
  91     RETURN();
  92 }
  93
  94 void OPPROTO op_bf_s(void)
  95 {
  96     env->delayed_pc = PARAM1;
  97     if (!(env->sr & SR_T)) {
  98         env->flags |= DELAY_SLOT_TRUE;
  99     }
 100     RETURN();
 101 }
 102
 103 void OPPROTO op_bt_s(void)
 104 {
 105     env->delayed_pc = PARAM1;
 106     if (env->sr & SR_T) {
 107         env->flags |= DELAY_SLOT_TRUE;
 108     }
 109     RETURN();
 110 }
 111
 112 void OPPROTO op_store_flags(void)
 113 {
 114     env->flags &= DELAY_SLOT_TRUE;
 115     env->flags |= PARAM1;
 116     RETURN();
 117 }
 118
 119 void OPPROTO op_bra(void)
 120 {
 121     env->delayed_pc = PARAM1;
 122     RETURN();
 123 }
 124
 125 void OPPROTO op_braf_T0(void)
 126 {
 127     env->delayed_pc = PARAM1 + T0;
 128     RETURN();
 129 }
 130
 131 void OPPROTO op_bsr(void)
 132 {
 133     env->pr = PARAM1;
 134     env->delayed_pc = PARAM2;
 135     RETURN();
 136 }
 137
 138 void OPPROTO op_bsrf_T0(void)
 139 {
 140     env->pr = PARAM1;
 141     env->delayed_pc = PARAM1 + T0;
 142     RETURN();
 143 }
 144
 145 void OPPROTO op_jsr_T0(void)
 146 {
 147     env->pr = PARAM1;
 148     env->delayed_pc = T0;
 149     RETURN();
 150 }
 151
 152 void OPPROTO op_rts(void)
 153 {
 154     env->delayed_pc = env->pr;
 155     RETURN();
 156 }
 157
 158 void OPPROTO op_addl_imm_T0(void)
 159 {
 160     T0 += PARAM1;
 161     RETURN();
 162 }
 163
 164 void OPPROTO op_addl_imm_T1(void)
 165 {
 166     T1 += PARAM1;
 167     RETURN();
 168 }
 169
 170 void OPPROTO op_clrmac(void)
 171 {
 172     env->mach = env->macl = 0;
 173     RETURN();
 174 }
 175
 176 void OPPROTO op_clrs(void)
 177 {
 178     env->sr &= ~SR_S;
 179     RETURN();
 180 }
 181
 182 void OPPROTO op_clrt(void)
 183 {
 184     env->sr &= ~SR_T;
 185     RETURN();
 186 }
 187
 188 void OPPROTO op_ldtlb(void)
 189 {
 190     helper_ldtlb();
 191     RETURN();
 192 }
 193
 194 void OPPROTO op_sets(void)
 195 {
 196     env->sr |= SR_S;
 197     RETURN();
 198 }
 199
 200 void OPPROTO op_sett(void)
 201 {
 202     env->sr |= SR_T;
 203     RETURN();
 204 }
 205
 206 void OPPROTO op_frchg(void)
 207 {
 208     env->fpscr ^= FPSCR_FR;
 209     RETURN();
 210 }
 211
 212 void OPPROTO op_fschg(void)
 213 {
 214     env->fpscr ^= FPSCR_SZ;
 215     RETURN();
 216 }
 217
 218 void OPPROTO op_rte(void)
 219 {
 220     env->sr = env->ssr;
 221     env->delayed_pc = env->spc;
 222     RETURN();
 223 }
 224
 225 void OPPROTO op_swapb_T0(void)
 226 {
 227     T0 = (T0 & 0xffff0000) | ((T0 & 0xff) << 8) | ((T0 >> 8) & 0xff);
 228     RETURN();
 229 }
 230
 231 void OPPROTO op_swapw_T0(void)
 232 {
 233     T0 = ((T0 & 0xffff) << 16) | ((T0 >> 16) & 0xffff);
 234     RETURN();
 235 }
 236
 237 void OPPROTO op_xtrct_T0_T1(void)
 238 {
 239     T1 = ((T0 & 0xffff) << 16) | ((T1 >> 16) & 0xffff);
 240     RETURN();
 241 }
 242
 243 void OPPROTO op_add_T0_T1(void)
 244 {
 245     T1 += T0;
 246     RETURN();
 247 }
 248
 249 void OPPROTO op_addc_T0_T1(void)
 250 {
 251     helper_addc_T0_T1();
 252     RETURN();
 253 }
 254
 255 void OPPROTO op_addv_T0_T1(void)
 256 {
 257     helper_addv_T0_T1();
 258     RETURN();
 259 }
 260
 261 void OPPROTO op_cmp_eq_T0_T1(void)
 262 {
 263     cond_t(T1 == T0);
 264     RETURN();
 265 }
 266
 267 void OPPROTO op_cmp_ge_T0_T1(void)
 268 {
 269     cond_t((int32_t) T1 >= (int32_t) T0);
 270     RETURN();
 271 }
 272
 273 void OPPROTO op_cmp_gt_T0_T1(void)
 274 {
 275     cond_t((int32_t) T1 > (int32_t) T0);
 276     RETURN();
 277 }
 278
 279 void OPPROTO op_cmp_hi_T0_T1(void)
 280 {
 281     cond_t((uint32_t) T1 > (uint32_t) T0);
 282     RETURN();
 283 }
 284
 285 void OPPROTO op_cmp_hs_T0_T1(void)
 286 {
 287     cond_t((uint32_t) T1 >= (uint32_t) T0);
 288     RETURN();
 289 }
 290
 291 void OPPROTO op_cmp_str_T0_T1(void)
 292 {
 293     cond_t((T0 & 0x000000ff) == (T1 & 0x000000ff) ||
 294            (T0 & 0x0000ff00) == (T1 & 0x0000ff00) ||
 295            (T0 & 0x00ff0000) == (T1 & 0x00ff0000) ||
 296            (T0 & 0xff000000) == (T1 & 0xff000000));
 297     RETURN();
 298 }
 299
 300 void OPPROTO op_tst_T0_T1(void)
 301 {
 302     cond_t((T1 & T0) == 0);
 303     RETURN();
 304 }
 305
 306 void OPPROTO op_div0s_T0_T1(void)
 307 {
 308     if (T1 & 0x80000000)
 309         env->sr |= SR_Q;
 310     else
 311         env->sr &= ~SR_Q;
 312     if (T0 & 0x80000000)
 313         env->sr |= SR_M;
 314     else
 315         env->sr &= ~SR_M;
 316     cond_t((T1 ^ T0) & 0x80000000);
 317     RETURN();
 318 }
 319
 320 void OPPROTO op_div0u(void)
 321 {
 322     env->sr &= ~(SR_M | SR_Q | SR_T);
 323     RETURN();
 324 }
 325
 326 void OPPROTO op_div1_T0_T1(void)
 327 {
 328     helper_div1_T0_T1();
 329     RETURN();
 330 }
 331
 332 void OPPROTO op_dmulsl_T0_T1(void)
 333 {
 334     helper_dmulsl_T0_T1();
 335     RETURN();
 336 }
 337
 338 void OPPROTO op_dmulul_T0_T1(void)
 339 {
 340     helper_dmulul_T0_T1();
 341     RETURN();
 342 }
 343
 344 void OPPROTO op_macl_T0_T1(void)
 345 {
 346     helper_macl_T0_T1();
 347     RETURN();
 348 }
 349
 350 void OPPROTO op_macw_T0_T1(void)
 351 {
 352     helper_macw_T0_T1();
 353     RETURN();
 354 }
 355
 356 void OPPROTO op_mull_T0_T1(void)
 357 {
 358     env->macl = (T0 * T1) & 0xffffffff;
 359     RETURN();
 360 }
 361
 362 void OPPROTO op_mulsw_T0_T1(void)
 363 {
 364     env->macl = (int32_t)(int16_t) T0 *(int32_t)(int16_t) T1;
 365     RETURN();
 366 }
 367
 368 void OPPROTO op_muluw_T0_T1(void)
 369 {
 370     env->macl = (uint32_t)(uint16_t) T0 *(uint32_t)(uint16_t) T1;
 371     RETURN();
 372 }
 373
 374 void OPPROTO op_neg_T0(void)
 375 {
 376     T0 = -T0;
 377     RETURN();
 378 }
 379
 380 void OPPROTO op_negc_T0(void)
 381 {
 382     helper_negc_T0();
 383     RETURN();
 384 }
 385
 386 void OPPROTO op_shad_T0_T1(void)
 387 {
 388     if ((T0 & 0x80000000) == 0)
 389         T1 <<= (T0 & 0x1f);
 390     else if ((T0 & 0x1f) == 0)
 391         T1 = (T1 & 0x80000000)? 0xffffffff : 0;
 392     else
 393         T1 = ((int32_t) T1) >> ((~T0 & 0x1f) + 1);
 394     RETURN();
 395 }
 396
 397 void OPPROTO op_shld_T0_T1(void)
 398 {
 399     if ((T0 & 0x80000000) == 0)
 400         T1 <<= (T0 & 0x1f);
 401     else if ((T0 & 0x1f) == 0)
 402         T1 = 0;
 403     else
 404         T1 = ((uint32_t) T1) >> ((~T0 & 0x1f) + 1);
 405     RETURN();
 406 }
 407
 408 void OPPROTO op_subc_T0_T1(void)
 409 {
 410     helper_subc_T0_T1();
 411     RETURN();
 412 }
 413
 414 void OPPROTO op_subv_T0_T1(void)
 415 {
 416     helper_subv_T0_T1();
 417     RETURN();
 418 }
 419
 420 void OPPROTO op_trapa(void)
 421 {
 422     env->tra = PARAM1 << 2;
 423     env->exception_index = 0x160;
 424     do_raise_exception();
 425     RETURN();
 426 }
 427
 428 void OPPROTO op_cmp_pl_T0(void)
 429 {
 430     cond_t((int32_t) T0 > 0);
 431     RETURN();
 432 }
 433
 434 void OPPROTO op_cmp_pz_T0(void)
 435 {
 436     cond_t((int32_t) T0 >= 0);
 437     RETURN();
 438 }
 439
 440 void OPPROTO op_jmp_T0(void)
 441 {
 442     env->delayed_pc = T0;
 443     RETURN();
 444 }
 445
 446 void OPPROTO op_movl_rN_rN(void)
 447 {
 448     env->gregs[PARAM2] = env->gregs[PARAM1];
 449     RETURN();
 450 }
 451
 452 void OPPROTO op_ldcl_rMplus_rN_bank(void)
 453 {
 454     env->gregs[PARAM2] = env->gregs[PARAM1];
 455     env->gregs[PARAM1] += 4;
 456     RETURN();
 457 }
 458
 459 void OPPROTO op_ldc_T0_sr(void)
 460 {
 461     env->sr = T0 & 0x700083f3;
 462     RETURN();
 463 }
 464
 465 void OPPROTO op_stc_sr_T0(void)
 466 {
 467     T0 = env->sr;
 468     RETURN();
 469 }
 470
 471 #define LDSTOPS(target,load,store) \
 472 void OPPROTO op_##load##_T0_##target (void) \
 473 { env ->target = T0;   RETURN(); \
 474 } \
 475 void OPPROTO op_##store##_##target##_T0 (void) \
 476 { T0 = env->target;   RETURN(); \
 477 } \
 478
 479     LDSTOPS(gbr, ldc, stc)
 480     LDSTOPS(vbr, ldc, stc)
 481     LDSTOPS(ssr, ldc, stc)
 482     LDSTOPS(spc, ldc, stc)
 483     LDSTOPS(sgr, ldc, stc)
 484     LDSTOPS(dbr, ldc, stc)
 485     LDSTOPS(mach, lds, sts)
 486     LDSTOPS(macl, lds, sts)
 487     LDSTOPS(pr, lds, sts)
 488     LDSTOPS(fpul, lds, sts)
 489
 490 void OPPROTO op_lds_T0_fpscr(void)
 491 {
 492     env->fpscr = T0 & 0x003fffff;
 493     env->fp_status.float_rounding_mode = T0 & 0x01 ?
 494       float_round_to_zero : float_round_nearest_even;
 495
 496     RETURN();
 497 }
 498
 499 void OPPROTO op_sts_fpscr_T0(void)
 500 {
 501     T0 = env->fpscr & 0x003fffff;
 502     RETURN();
 503 }
 504
 505 void OPPROTO op_movt_rN(void)
 506 {
 507     env->gregs[PARAM1] = env->sr & SR_T;
 508     RETURN();
 509 }
 510
 511 void OPPROTO op_rotcl_Rn(void)
 512 {
 513     helper_rotcl(&env->gregs[PARAM1]);
 514     RETURN();
 515 }
 516
 517 void OPPROTO op_rotcr_Rn(void)
 518 {
 519     helper_rotcr(&env->gregs[PARAM1]);
 520     RETURN();
 521 }
 522
 523 void OPPROTO op_rotl_Rn(void)
 524 {
 525     cond_t(env->gregs[PARAM1] & 0x80000000);
 526     env->gregs[PARAM1] = (env->gregs[PARAM1] << 1) | (env->sr & SR_T);
 527     RETURN();
 528 }
 529
 530 void OPPROTO op_rotr_Rn(void)
 531 {
 532     cond_t(env->gregs[PARAM1] & 1);
 533     env->gregs[PARAM1] = (env->gregs[PARAM1] >> 1) |
 534         ((env->sr & SR_T) ? 0x80000000 : 0);
 535     RETURN();
 536 }
 537
 538 void OPPROTO op_shal_Rn(void)
 539 {
 540     cond_t(env->gregs[PARAM1] & 0x80000000);
 541     env->gregs[PARAM1] <<= 1;
 542     RETURN();
 543 }
 544
 545 void OPPROTO op_shar_Rn(void)
 546 {
 547     cond_t(env->gregs[PARAM1] & 1);
 548     *(int32_t *)&env->gregs[PARAM1] >>= 1;
 549     RETURN();
 550 }
 551
 552 void OPPROTO op_shlr_Rn(void)
 553 {
 554     cond_t(env->gregs[PARAM1] & 1);
 555     env->gregs[PARAM1] >>= 1;
 556     RETURN();
 557 }
 558
 559 void OPPROTO op_shll2_Rn(void)
 560 {
 561     env->gregs[PARAM1] <<= 2;
 562     RETURN();
 563 }
 564
 565 void OPPROTO op_shll8_Rn(void)
 566 {
 567     env->gregs[PARAM1] <<= 8;
 568     RETURN();
 569 }
 570
 571 void OPPROTO op_shll16_Rn(void)
 572 {
 573     env->gregs[PARAM1] <<= 16;
 574     RETURN();
 575 }
 576
 577 void OPPROTO op_shlr2_Rn(void)
 578 {
 579     env->gregs[PARAM1] >>= 2;
 580     RETURN();
 581 }
 582
 583 void OPPROTO op_shlr8_Rn(void)
 584 {
 585     env->gregs[PARAM1] >>= 8;
 586     RETURN();
 587 }
 588
 589 void OPPROTO op_shlr16_Rn(void)
 590 {
 591     env->gregs[PARAM1] >>= 16;
 592     RETURN();
 593 }
 594
 595 void OPPROTO op_movl_T0_rN(void)
 596 {
 597     env->gregs[PARAM1] = T0;
 598     RETURN();
 599 }
 600
 601 void OPPROTO op_movl_T1_rN(void)
 602 {
 603     env->gregs[PARAM1] = T1;
 604     RETURN();
 605 }
 606
 607 void OPPROTO op_movb_rN_T0(void)
 608 {
 609     T0 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
 610     RETURN();
 611 }
 612
 613 void OPPROTO op_movub_rN_T0(void)
 614 {
 615     T0 = env->gregs[PARAM1] & 0xff;
 616     RETURN();
 617 }
 618
 619 void OPPROTO op_movw_rN_T0(void)
 620 {
 621     T0 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
 622     RETURN();
 623 }
 624
 625 void OPPROTO op_movuw_rN_T0(void)
 626 {
 627     T0 = env->gregs[PARAM1] & 0xffff;
 628     RETURN();
 629 }
 630
 631 void OPPROTO op_movl_rN_T0(void)
 632 {
 633     T0 = env->gregs[PARAM1];
 634     RETURN();
 635 }
 636
 637 void OPPROTO op_movb_rN_T1(void)
 638 {
 639     T1 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
 640     RETURN();
 641 }
 642
 643 void OPPROTO op_movub_rN_T1(void)
 644 {
 645     T1 = env->gregs[PARAM1] & 0xff;
 646     RETURN();
 647 }
 648
 649 void OPPROTO op_movw_rN_T1(void)
 650 {
 651     T1 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
 652     RETURN();
 653 }
 654
 655 void OPPROTO op_movuw_rN_T1(void)
 656 {
 657     T1 = env->gregs[PARAM1] & 0xffff;
 658     RETURN();
 659 }
 660
 661 void OPPROTO op_movl_rN_T1(void)
 662 {
 663     T1 = env->gregs[PARAM1];
 664     RETURN();
 665 }
 666
 667 void OPPROTO op_movl_imm_rN(void)
 668 {
 669     env->gregs[PARAM2] = PARAM1;
 670     RETURN();
 671 }
 672
 673 void OPPROTO op_fmov_frN_FT0(void)
 674 {
 675     FT0 = env->fregs[PARAM1];
 676     RETURN();
 677 }
 678
 679 void OPPROTO op_fmov_drN_DT0(void)
 680 {
 681     CPU_DoubleU d;
 682
 683     d.l.upper = *(uint32_t *)&env->fregs[PARAM1];
 684     d.l.lower = *(uint32_t *)&env->fregs[PARAM1 + 1];
 685     DT0 = d.d;
 686     RETURN();
 687 }
 688
 689 void OPPROTO op_fmov_frN_FT1(void)
 690 {
 691     FT1 = env->fregs[PARAM1];
 692     RETURN();
 693 }
 694
 695 void OPPROTO op_fmov_drN_DT1(void)
 696 {
 697     CPU_DoubleU d;
 698
 699     d.l.upper = *(uint32_t *)&env->fregs[PARAM1];
 700     d.l.lower = *(uint32_t *)&env->fregs[PARAM1 + 1];
 701     DT1 = d.d;
 702     RETURN();
 703 }
 704
 705 void OPPROTO op_fmov_FT0_frN(void)
 706 {
 707     env->fregs[PARAM1] = FT0;
 708     RETURN();
 709 }
 710
 711 void OPPROTO op_fmov_DT0_drN(void)
 712 {
 713     CPU_DoubleU d;
 714
 715     d.d = DT0;
 716     *(uint32_t *)&env->fregs[PARAM1] = d.l.upper;
 717     *(uint32_t *)&env->fregs[PARAM1 + 1] = d.l.lower;
 718     RETURN();
 719 }
 720
 721 void OPPROTO op_fadd_FT(void)
 722 {
 723     FT0 = float32_add(FT0, FT1, &env->fp_status);
 724     RETURN();
 725 }
 726
 727 void OPPROTO op_fadd_DT(void)
 728 {
 729     DT0 = float64_add(DT0, DT1, &env->fp_status);
 730     RETURN();
 731 }
 732
 733 void OPPROTO op_fsub_FT(void)
 734 {
 735     FT0 = float32_sub(FT0, FT1, &env->fp_status);
 736     RETURN();
 737 }
 738
 739 void OPPROTO op_fsub_DT(void)
 740 {
 741     DT0 = float64_sub(DT0, DT1, &env->fp_status);
 742     RETURN();
 743 }
 744
 745 void OPPROTO op_fmul_FT(void)
 746 {
 747     FT0 = float32_mul(FT0, FT1, &env->fp_status);
 748     RETURN();
 749 }
 750
 751 void OPPROTO op_fmul_DT(void)
 752 {
 753     DT0 = float64_mul(DT0, DT1, &env->fp_status);
 754     RETURN();
 755 }
 756
 757 void OPPROTO op_fdiv_FT(void)
 758 {
 759     FT0 = float32_div(FT0, FT1, &env->fp_status);
 760     RETURN();
 761 }
 762
 763 void OPPROTO op_fdiv_DT(void)
 764 {
 765     DT0 = float64_div(DT0, DT1, &env->fp_status);
 766     RETURN();
 767 }
 768
 769 void OPPROTO op_fcmp_eq_FT(void)
 770 {
 771     cond_t(float32_compare(FT0, FT1, &env->fp_status) == 0);
 772     RETURN();
 773 }
 774
 775 void OPPROTO op_fcmp_eq_DT(void)
 776 {
 777     cond_t(float64_compare(DT0, DT1, &env->fp_status) == 0);
 778     RETURN();
 779 }
 780
 781 void OPPROTO op_fcmp_gt_FT(void)
 782 {
 783     cond_t(float32_compare(FT0, FT1, &env->fp_status) == 1);
 784     RETURN();
 785 }
 786
 787 void OPPROTO op_fcmp_gt_DT(void)
 788 {
 789     cond_t(float64_compare(DT0, DT1, &env->fp_status) == 1);
 790     RETURN();
 791 }
 792
 793 void OPPROTO op_float_FT(void)
 794 {
 795     FT0 = int32_to_float32(env->fpul, &env->fp_status);
 796     RETURN();
 797 }
 798
 799 void OPPROTO op_float_DT(void)
 800 {
 801     DT0 = int32_to_float64(env->fpul, &env->fp_status);
 802     RETURN();
 803 }
 804
 805 void OPPROTO op_ftrc_FT(void)
 806 {
 807     env->fpul = float32_to_int32_round_to_zero(FT0, &env->fp_status);
 808     RETURN();
 809 }
 810
 811 void OPPROTO op_ftrc_DT(void)
 812 {
 813     env->fpul = float64_to_int32_round_to_zero(DT0, &env->fp_status);
 814     RETURN();
 815 }
 816
 817 void OPPROTO op_fneg_frN(void)
 818 {
 819     env->fregs[PARAM1] = float32_chs(env->fregs[PARAM1]);
 820     RETURN();
 821 }
 822
 823 void OPPROTO op_fabs_FT(void)
 824 {
 825     FT0 = float32_abs(FT0);
 826     RETURN();
 827 }
 828
 829 void OPPROTO op_fabs_DT(void)
 830 {
 831     DT0 = float64_abs(DT0);
 832     RETURN();
 833 }
 834
 835 void OPPROTO op_fcnvsd_FT_DT(void)
 836 {
 837     DT0 = float32_to_float64(FT0, &env->fp_status);
 838     RETURN();
 839 }
 840
 841 void OPPROTO op_fcnvds_DT_FT(void)
 842 {
 843     FT0 = float64_to_float32(DT0, &env->fp_status);
 844     RETURN();
 845 }
 846
 847 void OPPROTO op_fsqrt_FT(void)
 848 {
 849     FT0 = float32_sqrt(FT0, &env->fp_status);
 850     RETURN();
 851 }
 852
 853 void OPPROTO op_fsqrt_DT(void)
 854 {
 855     DT0 = float64_sqrt(DT0, &env->fp_status);
 856     RETURN();
 857 }
 858
 859 void OPPROTO op_fmov_T0_frN(void)
 860 {
 861     *(uint32_t *)&env->fregs[PARAM1] = T0;
 862     RETURN();
 863 }
 864
 865 void OPPROTO op_dec1_rN(void)
 866 {
 867     env->gregs[PARAM1] -= 1;
 868     RETURN();
 869 }
 870
 871 void OPPROTO op_dec2_rN(void)
 872 {
 873     env->gregs[PARAM1] -= 2;
 874     RETURN();
 875 }
 876
 877 void OPPROTO op_dec4_rN(void)
 878 {
 879     env->gregs[PARAM1] -= 4;
 880     RETURN();
 881 }
 882
 883 void OPPROTO op_dec8_rN(void)
 884 {
 885     env->gregs[PARAM1] -= 8;
 886     RETURN();
 887 }
 888
 889 void OPPROTO op_inc1_rN(void)
 890 {
 891     env->gregs[PARAM1] += 1;
 892     RETURN();
 893 }
 894
 895 void OPPROTO op_inc2_rN(void)
 896 {
 897     env->gregs[PARAM1] += 2;
 898     RETURN();
 899 }
 900
 901 void OPPROTO op_inc4_rN(void)
 902 {
 903     env->gregs[PARAM1] += 4;
 904     RETURN();
 905 }
 906
 907 void OPPROTO op_inc8_rN(void)
 908 {
 909     env->gregs[PARAM1] += 8;
 910     RETURN();
 911 }
 912
 913 void OPPROTO op_add_T0_rN(void)
 914 {
 915     env->gregs[PARAM1] += T0;
 916     RETURN();
 917 }
 918
 919 void OPPROTO op_sub_T0_rN(void)
 920 {
 921     env->gregs[PARAM1] -= T0;
 922     RETURN();
 923 }
 924
 925 void OPPROTO op_and_T0_rN(void)
 926 {
 927     env->gregs[PARAM1] &= T0;
 928     RETURN();
 929 }
 930
 931 void OPPROTO op_or_T0_rN(void)
 932 {
 933     env->gregs[PARAM1] |= T0;
 934     RETURN();
 935 }
 936
 937 void OPPROTO op_xor_T0_rN(void)
 938 {
 939     env->gregs[PARAM1] ^= T0;
 940     RETURN();
 941 }
 942
 943 void OPPROTO op_add_rN_T0(void)
 944 {
 945     T0 += env->gregs[PARAM1];
 946     RETURN();
 947 }
 948
 949 void OPPROTO op_add_rN_T1(void)
 950 {
 951     T1 += env->gregs[PARAM1];
 952     RETURN();
 953 }
 954
 955 void OPPROTO op_add_imm_rN(void)
 956 {
 957     env->gregs[PARAM2] += PARAM1;
 958     RETURN();
 959 }
 960
 961 void OPPROTO op_and_imm_rN(void)
 962 {
 963     env->gregs[PARAM2] &= PARAM1;
 964     RETURN();
 965 }
 966
 967 void OPPROTO op_or_imm_rN(void)
 968 {
 969     env->gregs[PARAM2] |= PARAM1;
 970     RETURN();
 971 }
 972
 973 void OPPROTO op_xor_imm_rN(void)
 974 {
 975     env->gregs[PARAM2] ^= PARAM1;
 976     RETURN();
 977 }
 978
 979 void OPPROTO op_dt_rN(void)
 980 {
 981     cond_t((--env->gregs[PARAM1]) == 0);
 982     RETURN();
 983 }
 984
 985 void OPPROTO op_tst_imm_rN(void)
 986 {
 987     cond_t((env->gregs[PARAM2] & PARAM1) == 0);
 988     RETURN();
 989 }
 990
 991 void OPPROTO op_movl_T0_T1(void)
 992 {
 993     T1 = T0;
 994     RETURN();
 995 }
 996
 997 void OPPROTO op_movl_fpul_FT0(void)
 998 {
 999     FT0 = *(float32 *)&env->fpul;
1000     RETURN();
1001 }
1002
1003 void OPPROTO op_movl_FT0_fpul(void)
1004 {
1005     *(float32 *)&env->fpul = FT0;
1006     RETURN();
1007 }
1008
1009 void OPPROTO op_movl_imm_PC(void)
1010 {
1011     env->pc = PARAM1;
1012     RETURN();
1013 }
1014
1015 void OPPROTO op_jT(void)
1016 {
1017     if (env->sr & SR_T)
1018         GOTO_LABEL_PARAM(1);
1019     RETURN();
1020 }
1021
1022 void OPPROTO op_jdelayed(void)
1023 {
1024     if (env->flags & DELAY_SLOT_TRUE) {
1025         env->flags &= ~DELAY_SLOT_TRUE;
1026         GOTO_LABEL_PARAM(1);
1027     }
1028     RETURN();
1029 }
1030
1031 void OPPROTO op_movl_delayed_pc_PC(void)
1032 {
1033     env->pc = env->delayed_pc;
1034     RETURN();
1035 }
1036
1037 void OPPROTO op_addl_GBR_T0(void)
1038 {
1039     T0 += env->gbr;
1040     RETURN();
1041 }
1042
1043 void OPPROTO op_and_imm_T0(void)
1044 {
1045     T0 &= PARAM1;
1046     RETURN();
1047 }
1048
1049 void OPPROTO op_or_imm_T0(void)
1050 {
1051     T0 |= PARAM1;
1052     RETURN();
1053 }
1054
1055 void OPPROTO op_xor_imm_T0(void)
1056 {
1057     T0 ^= PARAM1;
1058     RETURN();
1059 }
1060
1061 void OPPROTO op_tst_imm_T0(void)
1062 {
1063     cond_t((T0 & PARAM1) == 0);
1064     RETURN();
1065 }
1066
1067 void OPPROTO op_raise_illegal_instruction(void)
1068 {
1069     env->exception_index = 0x180;
1070     do_raise_exception();
1071     RETURN();
1072 }
1073
1074 void OPPROTO op_raise_slot_illegal_instruction(void)
1075 {
1076     env->exception_index = 0x1a0;
1077     do_raise_exception();
1078     RETURN();
1079 }
1080
1081 void OPPROTO op_debug(void)
1082 {
1083     env->exception_index = EXCP_DEBUG;
1084     cpu_loop_exit();
1085 }
1086
1087 void OPPROTO op_sleep(void)
1088 {
1089     env->halted = 1;
1090     env->exception_index = EXCP_HLT;
1091     cpu_loop_exit();
1092 }
1093
1094 /* Load and store */
1095 #define MEMSUFFIX _raw
1096 #include "op_mem.c"
1097 #undef MEMSUFFIX
1098 #if !defined(CONFIG_USER_ONLY)
1099 #define MEMSUFFIX _user
1100 #include "op_mem.c"
1101 #undef MEMSUFFIX
1102
1103 #define MEMSUFFIX _kernel
1104 #include "op_mem.c"
1105 #undef MEMSUFFIX
1106 #endif