vcs.maemo.org Git - qemu/blob - 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     T0 = (uint32_t) PARAM1;
  49     RETURN();
  50 }
  51
  52 void OPPROTO op_movl_imm_T2(void)
  53 {
  54     T0 = (uint32_t) PARAM1;
  55     RETURN();
  56 }
  57
  58 void OPPROTO op_cmp_eq_imm_T0(void)
  59 {
  60     cond_t((int32_t) T0 == (int32_t) PARAM1);
  61     RETURN();
  62 }
  63
  64 void OPPROTO op_cmd_eq_T0_T1(void)
  65 {
  66     cond_t(T0 == T1);
  67     RETURN();
  68 }
  69
  70 void OPPROTO op_cmd_hs_T0_T1(void)
  71 {
  72     cond_t((uint32_t) T0 <= (uint32_t) T1);
  73     RETURN();
  74 }
  75
  76 void OPPROTO op_cmd_ge_T0_T1(void)
  77 {
  78     cond_t((int32_t) T0 <= (int32_t) T1);
  79     RETURN();
  80 }
  81
  82 void OPPROTO op_cmd_hi_T0_T1(void)
  83 {
  84     cond_t((uint32_t) T0 < (uint32_t) T1);
  85     RETURN();
  86 }
  87
  88 void OPPROTO op_cmd_gt_T0_T1(void)
  89 {
  90     cond_t((int32_t) T0 < (int32_t) T1);
  91     RETURN();
  92 }
  93
  94 void OPPROTO op_not_T0(void)
  95 {
  96     T0 = ~T0;
  97     RETURN();
  98 }
  99
 100 void OPPROTO op_bf_s(void)
 101 {
 102     env->delayed_pc = PARAM1;
 103     if (!(env->sr & SR_T)) {
 104         env->flags |= DELAY_SLOT_TRUE;
 105     }
 106     RETURN();
 107 }
 108
 109 void OPPROTO op_bt_s(void)
 110 {
 111     env->delayed_pc = PARAM1;
 112     if (env->sr & SR_T) {
 113         env->flags |= DELAY_SLOT_TRUE;
 114     }
 115     RETURN();
 116 }
 117
 118 void OPPROTO op_store_flags(void)
 119 {
 120     env->flags &= DELAY_SLOT_TRUE;
 121     env->flags |= PARAM1;
 122     RETURN();
 123 }
 124
 125 void OPPROTO op_bra(void)
 126 {
 127     env->delayed_pc = PARAM1;
 128     RETURN();
 129 }
 130
 131 void OPPROTO op_braf_T0(void)
 132 {
 133     env->delayed_pc = PARAM1 + T0;
 134     RETURN();
 135 }
 136
 137 void OPPROTO op_bsr(void)
 138 {
 139     env->pr = PARAM1;
 140     env->delayed_pc = PARAM2;
 141     RETURN();
 142 }
 143
 144 void OPPROTO op_bsrf_T0(void)
 145 {
 146     env->pr = PARAM1;
 147     env->delayed_pc = PARAM1 + T0;
 148     RETURN();
 149 }
 150
 151 void OPPROTO op_jsr_T0(void)
 152 {
 153     env->pr = PARAM1;
 154     env->delayed_pc = T0;
 155     RETURN();
 156 }
 157
 158 void OPPROTO op_rts(void)
 159 {
 160     env->delayed_pc = env->pr;
 161     RETURN();
 162 }
 163
 164 void OPPROTO op_exit_tb(void)
 165 {
 166     EXIT_TB();
 167     RETURN();
 168 }
 169
 170 void OPPROTO op_addl_imm_T0(void)
 171 {
 172     T0 += PARAM1;
 173     RETURN();
 174 }
 175
 176 void OPPROTO op_addl_imm_T1(void)
 177 {
 178     T1 += PARAM1;
 179     RETURN();
 180 }
 181
 182 void OPPROTO op_clrmac(void)
 183 {
 184     env->mach = env->macl = 0;
 185     RETURN();
 186 }
 187
 188 void OPPROTO op_clrs(void)
 189 {
 190     env->sr &= ~SR_S;
 191     RETURN();
 192 }
 193
 194 void OPPROTO op_clrt(void)
 195 {
 196     env->sr &= ~SR_T;
 197     RETURN();
 198 }
 199
 200 void OPPROTO op_sets(void)
 201 {
 202     env->sr |= SR_S;
 203     RETURN();
 204 }
 205
 206 void OPPROTO op_sett(void)
 207 {
 208     env->sr |= SR_T;
 209     RETURN();
 210 }
 211
 212 void OPPROTO op_frchg(void)
 213 {
 214     env->fpscr ^= FPSCR_FR;
 215     RETURN();
 216 }
 217
 218 void OPPROTO op_fschg(void)
 219 {
 220     env->fpscr ^= FPSCR_SZ;
 221     RETURN();
 222 }
 223
 224 void OPPROTO op_rte(void)
 225 {
 226     env->sr = env->ssr;
 227     env->delayed_pc = env->spc;
 228     RETURN();
 229 }
 230
 231 void OPPROTO op_swapb_T0(void)
 232 {
 233     T0 = (T0 & 0xffff0000) | ((T0 & 0xff) << 8) | ((T0 >> 8) & 0xff);
 234     RETURN();
 235 }
 236
 237 void OPPROTO op_swapw_T0(void)
 238 {
 239     T0 = ((T0 & 0xffff) << 16) | ((T0 >> 16) & 0xffff);
 240     RETURN();
 241 }
 242
 243 void OPPROTO op_xtrct_T0_T1(void)
 244 {
 245     T1 = ((T0 & 0xffff) << 16) | ((T1 >> 16) & 0xffff);
 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) T0 *(int32_t) T1;
 365     RETURN();
 366 }
 367
 368 void OPPROTO op_muluw_T0_T1(void)
 369 {
 370     env->macl = (uint32_t) T0 *(uint32_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 = 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     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_tasb_rN(void)
 596 {
 597     cond_t(*(int8_t *) env->gregs[PARAM1] == 0);
 598     *(int8_t *) env->gregs[PARAM1] |= 0x80;
 599     RETURN();
 600 }
 601
 602 void OPPROTO op_movl_T0_rN(void)
 603 {
 604     env->gregs[PARAM1] = T0;
 605     RETURN();
 606 }
 607
 608 void OPPROTO op_movl_T1_rN(void)
 609 {
 610     env->gregs[PARAM1] = T1;
 611     RETURN();
 612 }
 613
 614 void OPPROTO op_movb_rN_T0(void)
 615 {
 616     T0 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
 617     RETURN();
 618 }
 619
 620 void OPPROTO op_movub_rN_T0(void)
 621 {
 622     T0 = env->gregs[PARAM1] & 0xff;
 623     RETURN();
 624 }
 625
 626 void OPPROTO op_movw_rN_T0(void)
 627 {
 628     T0 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
 629     RETURN();
 630 }
 631
 632 void OPPROTO op_movuw_rN_T0(void)
 633 {
 634     T0 = env->gregs[PARAM1] & 0xffff;
 635     RETURN();
 636 }
 637
 638 void OPPROTO op_movl_rN_T0(void)
 639 {
 640     T0 = env->gregs[PARAM1];
 641     RETURN();
 642 }
 643
 644 void OPPROTO op_movb_rN_T1(void)
 645 {
 646     T1 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
 647     RETURN();
 648 }
 649
 650 void OPPROTO op_movub_rN_T1(void)
 651 {
 652     T1 = env->gregs[PARAM1] & 0xff;
 653     RETURN();
 654 }
 655
 656 void OPPROTO op_movw_rN_T1(void)
 657 {
 658     T1 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
 659     RETURN();
 660 }
 661
 662 void OPPROTO op_movuw_rN_T1(void)
 663 {
 664     T1 = env->gregs[PARAM1] & 0xffff;
 665     RETURN();
 666 }
 667
 668 void OPPROTO op_movl_rN_T1(void)
 669 {
 670     T1 = env->gregs[PARAM1];
 671     RETURN();
 672 }
 673
 674 void OPPROTO op_movl_imm_rN(void)
 675 {
 676     env->gregs[PARAM2] = PARAM1;
 677     RETURN();
 678 }
 679
 680 void OPPROTO op_fmov_frN_FT0(void)
 681 {
 682     FT0 = env->fregs[PARAM1];
 683     RETURN();
 684 }
 685
 686 void OPPROTO op_fmov_drN_DT0(void)
 687 {
 688     CPU_DoubleU d;
 689
 690     d.l.upper = *(uint32_t *)&env->fregs[PARAM1];
 691     d.l.lower = *(uint32_t *)&env->fregs[PARAM1 + 1];
 692     DT0 = d.d;
 693     RETURN();
 694 }
 695
 696 void OPPROTO op_fmov_frN_FT1(void)
 697 {
 698     FT1 = env->fregs[PARAM1];
 699     RETURN();
 700 }
 701
 702 void OPPROTO op_fmov_drN_DT1(void)
 703 {
 704     CPU_DoubleU d;
 705
 706     d.l.upper = *(uint32_t *)&env->fregs[PARAM1];
 707     d.l.lower = *(uint32_t *)&env->fregs[PARAM1 + 1];
 708     DT1 = d.d;
 709     RETURN();
 710 }
 711
 712 void OPPROTO op_fmov_FT0_frN(void)
 713 {
 714     env->fregs[PARAM1] = FT0;
 715     RETURN();
 716 }
 717
 718 void OPPROTO op_fmov_DT0_drN(void)
 719 {
 720     CPU_DoubleU d;
 721
 722     d.d = DT0;
 723     *(uint32_t *)&env->fregs[PARAM1] = d.l.upper;
 724     *(uint32_t *)&env->fregs[PARAM1 + 1] = d.l.lower;
 725     RETURN();
 726 }
 727
 728 void OPPROTO op_fadd_FT(void)
 729 {
 730     FT0 = float32_add(FT0, FT1, &env->fp_status);
 731     RETURN();
 732 }
 733
 734 void OPPROTO op_fadd_DT(void)
 735 {
 736     DT0 = float64_add(DT0, DT1, &env->fp_status);
 737     RETURN();
 738 }
 739
 740 void OPPROTO op_fsub_FT(void)
 741 {
 742     FT0 = float32_sub(FT0, FT1, &env->fp_status);
 743     RETURN();
 744 }
 745
 746 void OPPROTO op_fsub_DT(void)
 747 {
 748     DT0 = float64_sub(DT0, DT1, &env->fp_status);
 749     RETURN();
 750 }
 751
 752 void OPPROTO op_fmul_FT(void)
 753 {
 754     FT0 = float32_mul(FT0, FT1, &env->fp_status);
 755     RETURN();
 756 }
 757
 758 void OPPROTO op_fmul_DT(void)
 759 {
 760     DT0 = float64_mul(DT0, DT1, &env->fp_status);
 761     RETURN();
 762 }
 763
 764 void OPPROTO op_fdiv_FT(void)
 765 {
 766     FT0 = float32_div(FT0, FT1, &env->fp_status);
 767     RETURN();
 768 }
 769
 770 void OPPROTO op_fdiv_DT(void)
 771 {
 772     DT0 = float64_div(DT0, DT1, &env->fp_status);
 773     RETURN();
 774 }
 775
 776 void OPPROTO op_float_FT(void)
 777 {
 778     FT0 = int32_to_float32(env->fpul, &env->fp_status);
 779     RETURN();
 780 }
 781
 782 void OPPROTO op_float_DT(void)
 783 {
 784     DT0 = int32_to_float64(env->fpul, &env->fp_status);
 785     RETURN();
 786 }
 787
 788 void OPPROTO op_ftrc_FT(void)
 789 {
 790     env->fpul = float32_to_int32_round_to_zero(FT0, &env->fp_status);
 791     RETURN();
 792 }
 793
 794 void OPPROTO op_ftrc_DT(void)
 795 {
 796     env->fpul = float64_to_int32_round_to_zero(DT0, &env->fp_status);
 797     RETURN();
 798 }
 799
 800 void OPPROTO op_fmov_T0_frN(void)
 801 {
 802     *(unsigned int *)&env->fregs[PARAM1] = T0;
 803     RETURN();
 804 }
 805
 806 void OPPROTO op_dec1_rN(void)
 807 {
 808     env->gregs[PARAM1] -= 1;
 809     RETURN();
 810 }
 811
 812 void OPPROTO op_dec2_rN(void)
 813 {
 814     env->gregs[PARAM1] -= 2;
 815     RETURN();
 816 }
 817
 818 void OPPROTO op_dec4_rN(void)
 819 {
 820     env->gregs[PARAM1] -= 4;
 821     RETURN();
 822 }
 823
 824 void OPPROTO op_dec8_rN(void)
 825 {
 826     env->gregs[PARAM1] -= 8;
 827     RETURN();
 828 }
 829
 830 void OPPROTO op_inc1_rN(void)
 831 {
 832     env->gregs[PARAM1] += 1;
 833     RETURN();
 834 }
 835
 836 void OPPROTO op_inc2_rN(void)
 837 {
 838     env->gregs[PARAM1] += 2;
 839     RETURN();
 840 }
 841
 842 void OPPROTO op_inc4_rN(void)
 843 {
 844     env->gregs[PARAM1] += 4;
 845     RETURN();
 846 }
 847
 848 void OPPROTO op_inc8_rN(void)
 849 {
 850     env->gregs[PARAM1] += 8;
 851     RETURN();
 852 }
 853
 854 void OPPROTO op_add_T0_rN(void)
 855 {
 856     env->gregs[PARAM1] += T0;
 857     RETURN();
 858 }
 859
 860 void OPPROTO op_sub_T0_rN(void)
 861 {
 862     env->gregs[PARAM1] -= T0;
 863     RETURN();
 864 }
 865
 866 void OPPROTO op_and_T0_rN(void)
 867 {
 868     env->gregs[PARAM1] &= T0;
 869     RETURN();
 870 }
 871
 872 void OPPROTO op_or_T0_rN(void)
 873 {
 874     env->gregs[PARAM1] |= T0;
 875     RETURN();
 876 }
 877
 878 void OPPROTO op_xor_T0_rN(void)
 879 {
 880     env->gregs[PARAM1] ^= T0;
 881     RETURN();
 882 }
 883
 884 void OPPROTO op_add_rN_T0(void)
 885 {
 886     T0 += env->gregs[PARAM1];
 887     RETURN();
 888 }
 889
 890 void OPPROTO op_add_rN_T1(void)
 891 {
 892     T1 += env->gregs[PARAM1];
 893     RETURN();
 894 }
 895
 896 void OPPROTO op_add_imm_rN(void)
 897 {
 898     env->gregs[PARAM2] += PARAM1;
 899     RETURN();
 900 }
 901
 902 void OPPROTO op_and_imm_rN(void)
 903 {
 904     env->gregs[PARAM2] &= PARAM1;
 905     RETURN();
 906 }
 907
 908 void OPPROTO op_or_imm_rN(void)
 909 {
 910     env->gregs[PARAM2] |= PARAM1;
 911     RETURN();
 912 }
 913
 914 void OPPROTO op_xor_imm_rN(void)
 915 {
 916     env->gregs[PARAM2] ^= PARAM1;
 917     RETURN();
 918 }
 919
 920 void OPPROTO op_dt_rN(void)
 921 {
 922     cond_t((--env->gregs[PARAM1]) == 0);
 923     RETURN();
 924 }
 925
 926 void OPPROTO op_tst_imm_rN(void)
 927 {
 928     cond_t((env->gregs[PARAM2] & PARAM1) == 0);
 929     RETURN();
 930 }
 931
 932 void OPPROTO op_movl_T0_T1(void)
 933 {
 934     T1 = T0;
 935     RETURN();
 936 }
 937
 938 void OPPROTO op_movl_fpul_FT0(void)
 939 {
 940     FT0 = *(float32 *)&env->fpul;
 941     RETURN();
 942 }
 943
 944 void OPPROTO op_movl_FT0_fpul(void)
 945 {
 946     *(float32 *)&env->fpul = FT0;
 947     RETURN();
 948 }
 949
 950 void OPPROTO op_goto_tb0(void)
 951 {
 952     GOTO_TB(op_goto_tb0, PARAM1, 0);
 953     RETURN();
 954 }
 955
 956 void OPPROTO op_goto_tb1(void)
 957 {
 958     GOTO_TB(op_goto_tb1, PARAM1, 1);
 959     RETURN();
 960 }
 961
 962 void OPPROTO op_movl_imm_PC(void)
 963 {
 964     env->pc = PARAM1;
 965     RETURN();
 966 }
 967
 968 void OPPROTO op_jT(void)
 969 {
 970     if (env->sr & SR_T)
 971         GOTO_LABEL_PARAM(1);
 972     RETURN();
 973 }
 974
 975 void OPPROTO op_jdelayed(void)
 976 {
 977     if (env->flags & DELAY_SLOT_TRUE) {
 978         env->flags &= ~DELAY_SLOT_TRUE;
 979         GOTO_LABEL_PARAM(1);
 980     }
 981     RETURN();
 982 }
 983
 984 void OPPROTO op_movl_delayed_pc_PC(void)
 985 {
 986     env->pc = env->delayed_pc;
 987     RETURN();
 988 }
 989
 990 void OPPROTO op_addl_GBR_T0(void)
 991 {
 992     T0 += env->gbr;
 993     RETURN();
 994 }
 995
 996 void OPPROTO op_and_imm_T0(void)
 997 {
 998     T0 &= PARAM1;
 999     RETURN();
1000 }
1001
1002 void OPPROTO op_or_imm_T0(void)
1003 {
1004     T0 |= PARAM1;
1005     RETURN();
1006 }
1007
1008 void OPPROTO op_xor_imm_T0(void)
1009 {
1010     T0 ^= PARAM1;
1011     RETURN();
1012 }
1013
1014 void OPPROTO op_tst_imm_T0(void)
1015 {
1016     cond_t((T0 & PARAM1) == 0);
1017     RETURN();
1018 }
1019
1020 void OPPROTO op_raise_illegal_instruction(void)
1021 {
1022     env->exception_index = 0x180;
1023     do_raise_exception();
1024     RETURN();
1025 }
1026
1027 void OPPROTO op_raise_slot_illegal_instruction(void)
1028 {
1029     env->exception_index = 0x1a0;
1030     do_raise_exception();
1031     RETURN();
1032 }
1033
1034 void OPPROTO op_debug(void)
1035 {
1036     env->exception_index = EXCP_DEBUG;
1037     cpu_loop_exit();
1038 }
1039
1040 /* Load and store */
1041 #define MEMSUFFIX _raw
1042 #include "op_mem.c"
1043 #undef MEMSUFFIX
1044 #if !defined(CONFIG_USER_ONLY)
1045 #define MEMSUFFIX _user
1046 #include "op_mem.c"
1047 #undef MEMSUFFIX
1048
1049 #define MEMSUFFIX _kernel
1050 #include "op_mem.c"
1051 #undef MEMSUFFIX
1052 #endif