vcs.maemo.org Git - qemu/blob - target-mips/op.c

   1 /*
   2  *  MIPS emulation micro-operations for qemu.
   3  *
   4  *  Copyright (c) 2004-2005 Jocelyn Mayer
   5  *  Copyright (c) 2006 Marius Groeger (FPU operations)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "exec.h"
  24
  25 #ifndef CALL_FROM_TB0
  26 #define CALL_FROM_TB0(func) func();
  27 #endif
  28 #ifndef CALL_FROM_TB1
  29 #define CALL_FROM_TB1(func, arg0) func(arg0);
  30 #endif
  31 #ifndef CALL_FROM_TB1_CONST16
  32 #define CALL_FROM_TB1_CONST16(func, arg0) CALL_FROM_TB1(func, arg0);
  33 #endif
  34 #ifndef CALL_FROM_TB2
  35 #define CALL_FROM_TB2(func, arg0, arg1) func(arg0, arg1);
  36 #endif
  37 #ifndef CALL_FROM_TB2_CONST16
  38 #define CALL_FROM_TB2_CONST16(func, arg0, arg1)     \
  39 CALL_FROM_TB2(func, arg0, arg1);
  40 #endif
  41 #ifndef CALL_FROM_TB3
  42 #define CALL_FROM_TB3(func, arg0, arg1, arg2) func(arg0, arg1, arg2);
  43 #endif
  44 #ifndef CALL_FROM_TB4
  45 #define CALL_FROM_TB4(func, arg0, arg1, arg2, arg3) \
  46         func(arg0, arg1, arg2, arg3);
  47 #endif
  48
  49 #define REG 1
  50 #include "op_template.c"
  51 #undef REG
  52 #define REG 2
  53 #include "op_template.c"
  54 #undef REG
  55 #define REG 3
  56 #include "op_template.c"
  57 #undef REG
  58 #define REG 4
  59 #include "op_template.c"
  60 #undef REG
  61 #define REG 5
  62 #include "op_template.c"
  63 #undef REG
  64 #define REG 6
  65 #include "op_template.c"
  66 #undef REG
  67 #define REG 7
  68 #include "op_template.c"
  69 #undef REG
  70 #define REG 8
  71 #include "op_template.c"
  72 #undef REG
  73 #define REG 9
  74 #include "op_template.c"
  75 #undef REG
  76 #define REG 10
  77 #include "op_template.c"
  78 #undef REG
  79 #define REG 11
  80 #include "op_template.c"
  81 #undef REG
  82 #define REG 12
  83 #include "op_template.c"
  84 #undef REG
  85 #define REG 13
  86 #include "op_template.c"
  87 #undef REG
  88 #define REG 14
  89 #include "op_template.c"
  90 #undef REG
  91 #define REG 15
  92 #include "op_template.c"
  93 #undef REG
  94 #define REG 16
  95 #include "op_template.c"
  96 #undef REG
  97 #define REG 17
  98 #include "op_template.c"
  99 #undef REG
 100 #define REG 18
 101 #include "op_template.c"
 102 #undef REG
 103 #define REG 19
 104 #include "op_template.c"
 105 #undef REG
 106 #define REG 20
 107 #include "op_template.c"
 108 #undef REG
 109 #define REG 21
 110 #include "op_template.c"
 111 #undef REG
 112 #define REG 22
 113 #include "op_template.c"
 114 #undef REG
 115 #define REG 23
 116 #include "op_template.c"
 117 #undef REG
 118 #define REG 24
 119 #include "op_template.c"
 120 #undef REG
 121 #define REG 25
 122 #include "op_template.c"
 123 #undef REG
 124 #define REG 26
 125 #include "op_template.c"
 126 #undef REG
 127 #define REG 27
 128 #include "op_template.c"
 129 #undef REG
 130 #define REG 28
 131 #include "op_template.c"
 132 #undef REG
 133 #define REG 29
 134 #include "op_template.c"
 135 #undef REG
 136 #define REG 30
 137 #include "op_template.c"
 138 #undef REG
 139 #define REG 31
 140 #include "op_template.c"
 141 #undef REG
 142
 143 #define TN
 144 #include "op_template.c"
 145 #undef TN
 146
 147 #define SFREG 0
 148 #define DFREG 0
 149 #include "fop_template.c"
 150 #undef SFREG
 151 #undef DFREG
 152 #define SFREG 1
 153 #include "fop_template.c"
 154 #undef SFREG
 155 #define SFREG 2
 156 #define DFREG 2
 157 #include "fop_template.c"
 158 #undef SFREG
 159 #undef DFREG
 160 #define SFREG 3
 161 #include "fop_template.c"
 162 #undef SFREG
 163 #define SFREG 4
 164 #define DFREG 4
 165 #include "fop_template.c"
 166 #undef SFREG
 167 #undef DFREG
 168 #define SFREG 5
 169 #include "fop_template.c"
 170 #undef SFREG
 171 #define SFREG 6
 172 #define DFREG 6
 173 #include "fop_template.c"
 174 #undef SFREG
 175 #undef DFREG
 176 #define SFREG 7
 177 #include "fop_template.c"
 178 #undef SFREG
 179 #define SFREG 8
 180 #define DFREG 8
 181 #include "fop_template.c"
 182 #undef SFREG
 183 #undef DFREG
 184 #define SFREG 9
 185 #include "fop_template.c"
 186 #undef SFREG
 187 #define SFREG 10
 188 #define DFREG 10
 189 #include "fop_template.c"
 190 #undef SFREG
 191 #undef DFREG
 192 #define SFREG 11
 193 #include "fop_template.c"
 194 #undef SFREG
 195 #define SFREG 12
 196 #define DFREG 12
 197 #include "fop_template.c"
 198 #undef SFREG
 199 #undef DFREG
 200 #define SFREG 13
 201 #include "fop_template.c"
 202 #undef SFREG
 203 #define SFREG 14
 204 #define DFREG 14
 205 #include "fop_template.c"
 206 #undef SFREG
 207 #undef DFREG
 208 #define SFREG 15
 209 #include "fop_template.c"
 210 #undef SFREG
 211 #define SFREG 16
 212 #define DFREG 16
 213 #include "fop_template.c"
 214 #undef SFREG
 215 #undef DFREG
 216 #define SFREG 17
 217 #include "fop_template.c"
 218 #undef SFREG
 219 #define SFREG 18
 220 #define DFREG 18
 221 #include "fop_template.c"
 222 #undef SFREG
 223 #undef DFREG
 224 #define SFREG 19
 225 #include "fop_template.c"
 226 #undef SFREG
 227 #define SFREG 20
 228 #define DFREG 20
 229 #include "fop_template.c"
 230 #undef SFREG
 231 #undef DFREG
 232 #define SFREG 21
 233 #include "fop_template.c"
 234 #undef SFREG
 235 #define SFREG 22
 236 #define DFREG 22
 237 #include "fop_template.c"
 238 #undef SFREG
 239 #undef DFREG
 240 #define SFREG 23
 241 #include "fop_template.c"
 242 #undef SFREG
 243 #define SFREG 24
 244 #define DFREG 24
 245 #include "fop_template.c"
 246 #undef SFREG
 247 #undef DFREG
 248 #define SFREG 25
 249 #include "fop_template.c"
 250 #undef SFREG
 251 #define SFREG 26
 252 #define DFREG 26
 253 #include "fop_template.c"
 254 #undef SFREG
 255 #undef DFREG
 256 #define SFREG 27
 257 #include "fop_template.c"
 258 #undef SFREG
 259 #define SFREG 28
 260 #define DFREG 28
 261 #include "fop_template.c"
 262 #undef SFREG
 263 #undef DFREG
 264 #define SFREG 29
 265 #include "fop_template.c"
 266 #undef SFREG
 267 #define SFREG 30
 268 #define DFREG 30
 269 #include "fop_template.c"
 270 #undef SFREG
 271 #undef DFREG
 272 #define SFREG 31
 273 #include "fop_template.c"
 274 #undef SFREG
 275
 276 #define FTN
 277 #include "fop_template.c"
 278 #undef FTN
 279
 280 void op_dup_T0 (void)
 281 {
 282     T2 = T0;
 283     RETURN();
 284 }
 285
 286 void op_load_HI (void)
 287 {
 288     T0 = env->HI;
 289     RETURN();
 290 }
 291
 292 void op_store_HI (void)
 293 {
 294     env->HI = T0;
 295     RETURN();
 296 }
 297
 298 void op_load_LO (void)
 299 {
 300     T0 = env->LO;
 301     RETURN();
 302 }
 303
 304 void op_store_LO (void)
 305 {
 306     env->LO = T0;
 307     RETURN();
 308 }
 309
 310 /* Load and store */
 311 #define MEMSUFFIX _raw
 312 #include "op_mem.c"
 313 #undef MEMSUFFIX
 314 #if !defined(CONFIG_USER_ONLY)
 315 #define MEMSUFFIX _user
 316 #include "op_mem.c"
 317 #undef MEMSUFFIX
 318
 319 #define MEMSUFFIX _kernel
 320 #include "op_mem.c"
 321 #undef MEMSUFFIX
 322 #endif
 323
 324 /* Arithmetic */
 325 void op_add (void)
 326 {
 327     T0 = (int32_t)((int32_t)T0 + (int32_t)T1);
 328     RETURN();
 329 }
 330
 331 void op_addo (void)
 332 {
 333     target_ulong tmp;
 334
 335     tmp = (int32_t)T0;
 336     T0 = (int32_t)T0 + (int32_t)T1;
 337     if (((tmp ^ T1 ^ (-1)) & (T0 ^ T1)) >> 31) {
 338         /* operands of same sign, result different sign */
 339         CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW);
 340     }
 341     T0 = (int32_t)T0;
 342     RETURN();
 343 }
 344
 345 void op_sub (void)
 346 {
 347     T0 = (int32_t)((int32_t)T0 - (int32_t)T1);
 348     RETURN();
 349 }
 350
 351 void op_subo (void)
 352 {
 353     target_ulong tmp;
 354
 355     tmp = (int32_t)T0;
 356     T0 = (int32_t)T0 - (int32_t)T1;
 357     if (((tmp ^ T1) & (tmp ^ T0)) >> 31) {
 358         /* operands of different sign, first operand and result different sign */
 359         CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW);
 360     }
 361     T0 = (int32_t)T0;
 362     RETURN();
 363 }
 364
 365 void op_mul (void)
 366 {
 367     T0 = (int32_t)((int32_t)T0 * (int32_t)T1);
 368     RETURN();
 369 }
 370
 371 void op_div (void)
 372 {
 373     if (T1 != 0) {
 374         env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);
 375         env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);
 376     }
 377     RETURN();
 378 }
 379
 380 void op_divu (void)
 381 {
 382     if (T1 != 0) {
 383         env->LO = (int32_t)((uint32_t)T0 / (uint32_t)T1);
 384         env->HI = (int32_t)((uint32_t)T0 % (uint32_t)T1);
 385     }
 386     RETURN();
 387 }
 388
 389 #ifdef TARGET_MIPS64
 390 /* Arithmetic */
 391 void op_dadd (void)
 392 {
 393     T0 += T1;
 394     RETURN();
 395 }
 396
 397 void op_daddo (void)
 398 {
 399     target_long tmp;
 400
 401     tmp = T0;
 402     T0 += T1;
 403     if (((tmp ^ T1 ^ (-1)) & (T0 ^ T1)) >> 63) {
 404         /* operands of same sign, result different sign */
 405         CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW);
 406     }
 407     RETURN();
 408 }
 409
 410 void op_dsub (void)
 411 {
 412     T0 -= T1;
 413     RETURN();
 414 }
 415
 416 void op_dsubo (void)
 417 {
 418     target_long tmp;
 419
 420     tmp = T0;
 421     T0 = (int64_t)T0 - (int64_t)T1;
 422     if (((tmp ^ T1) & (tmp ^ T0)) >> 63) {
 423         /* operands of different sign, first operand and result different sign */
 424         CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW);
 425     }
 426     RETURN();
 427 }
 428
 429 void op_dmul (void)
 430 {
 431     T0 = (int64_t)T0 * (int64_t)T1;
 432     RETURN();
 433 }
 434
 435 #if TARGET_LONG_BITS > HOST_LONG_BITS
 436 /* Those might call libgcc functions.  */
 437 void op_ddiv (void)
 438 {
 439     do_ddiv();
 440     RETURN();
 441 }
 442
 443 void op_ddivu (void)
 444 {
 445     do_ddivu();
 446     RETURN();
 447 }
 448 #else
 449 void op_ddiv (void)
 450 {
 451     if (T1 != 0) {
 452         env->LO = (int64_t)T0 / (int64_t)T1;
 453         env->HI = (int64_t)T0 % (int64_t)T1;
 454     }
 455     RETURN();
 456 }
 457
 458 void op_ddivu (void)
 459 {
 460     if (T1 != 0) {
 461         env->LO = T0 / T1;
 462         env->HI = T0 % T1;
 463     }
 464     RETURN();
 465 }
 466 #endif
 467 #endif /* TARGET_MIPS64 */
 468
 469 /* Logical */
 470 void op_and (void)
 471 {
 472     T0 &= T1;
 473     RETURN();
 474 }
 475
 476 void op_nor (void)
 477 {
 478     T0 = ~(T0 | T1);
 479     RETURN();
 480 }
 481
 482 void op_or (void)
 483 {
 484     T0 |= T1;
 485     RETURN();
 486 }
 487
 488 void op_xor (void)
 489 {
 490     T0 ^= T1;
 491     RETURN();
 492 }
 493
 494 void op_sll (void)
 495 {
 496     T0 = (int32_t)((uint32_t)T0 << (uint32_t)T1);
 497     RETURN();
 498 }
 499
 500 void op_sra (void)
 501 {
 502     T0 = (int32_t)((int32_t)T0 >> (uint32_t)T1);
 503     RETURN();
 504 }
 505
 506 void op_srl (void)
 507 {
 508     T0 = (int32_t)((uint32_t)T0 >> (uint32_t)T1);
 509     RETURN();
 510 }
 511
 512 void op_rotr (void)
 513 {
 514     target_ulong tmp;
 515
 516     if (T1) {
 517        tmp = (int32_t)((uint32_t)T0 << (0x20 - (uint32_t)T1));
 518        T0 = (int32_t)((uint32_t)T0 >> (uint32_t)T1) | tmp;
 519     } else
 520        T0 = T1;
 521     RETURN();
 522 }
 523
 524 void op_sllv (void)
 525 {
 526     T0 = (int32_t)((uint32_t)T1 << ((uint32_t)T0 & 0x1F));
 527     RETURN();
 528 }
 529
 530 void op_srav (void)
 531 {
 532     T0 = (int32_t)((int32_t)T1 >> (T0 & 0x1F));
 533     RETURN();
 534 }
 535
 536 void op_srlv (void)
 537 {
 538     T0 = (int32_t)((uint32_t)T1 >> (T0 & 0x1F));
 539     RETURN();
 540 }
 541
 542 void op_rotrv (void)
 543 {
 544     target_ulong tmp;
 545
 546     T0 &= 0x1F;
 547     if (T0) {
 548        tmp = (int32_t)((uint32_t)T1 << (0x20 - T0));
 549        T0 = (int32_t)((uint32_t)T1 >> T0) | tmp;
 550     } else
 551        T0 = T1;
 552     RETURN();
 553 }
 554
 555 void op_clo (void)
 556 {
 557     int n;
 558
 559     if (T0 == ~((target_ulong)0)) {
 560         T0 = 32;
 561     } else {
 562         for (n = 0; n < 32; n++) {
 563             if (!(T0 & (1 << 31)))
 564                 break;
 565             T0 = T0 << 1;
 566         }
 567         T0 = n;
 568     }
 569     RETURN();
 570 }
 571
 572 void op_clz (void)
 573 {
 574     int n;
 575
 576     if (T0 == 0) {
 577         T0 = 32;
 578     } else {
 579         for (n = 0; n < 32; n++) {
 580             if (T0 & (1 << 31))
 581                 break;
 582             T0 = T0 << 1;
 583         }
 584         T0 = n;
 585     }
 586     RETURN();
 587 }
 588
 589 #ifdef TARGET_MIPS64
 590
 591 #if TARGET_LONG_BITS > HOST_LONG_BITS
 592 /* Those might call libgcc functions.  */
 593 void op_dsll (void)
 594 {
 595     CALL_FROM_TB0(do_dsll);
 596     RETURN();
 597 }
 598
 599 void op_dsll32 (void)
 600 {
 601     CALL_FROM_TB0(do_dsll32);
 602     RETURN();
 603 }
 604
 605 void op_dsra (void)
 606 {
 607     CALL_FROM_TB0(do_dsra);
 608     RETURN();
 609 }
 610
 611 void op_dsra32 (void)
 612 {
 613     CALL_FROM_TB0(do_dsra32);
 614     RETURN();
 615 }
 616
 617 void op_dsrl (void)
 618 {
 619     CALL_FROM_TB0(do_dsrl);
 620     RETURN();
 621 }
 622
 623 void op_dsrl32 (void)
 624 {
 625     CALL_FROM_TB0(do_dsrl32);
 626     RETURN();
 627 }
 628
 629 void op_drotr (void)
 630 {
 631     CALL_FROM_TB0(do_drotr);
 632     RETURN();
 633 }
 634
 635 void op_drotr32 (void)
 636 {
 637     CALL_FROM_TB0(do_drotr32);
 638     RETURN();
 639 }
 640
 641 void op_dsllv (void)
 642 {
 643     CALL_FROM_TB0(do_dsllv);
 644     RETURN();
 645 }
 646
 647 void op_dsrav (void)
 648 {
 649     CALL_FROM_TB0(do_dsrav);
 650     RETURN();
 651 }
 652
 653 void op_dsrlv (void)
 654 {
 655     CALL_FROM_TB0(do_dsrlv);
 656     RETURN();
 657 }
 658
 659 void op_drotrv (void)
 660 {
 661     CALL_FROM_TB0(do_drotrv);
 662     RETURN();
 663 }
 664
 665 #else /* TARGET_LONG_BITS > HOST_LONG_BITS */
 666
 667 void op_dsll (void)
 668 {
 669     T0 = T0 << T1;
 670     RETURN();
 671 }
 672
 673 void op_dsll32 (void)
 674 {
 675     T0 = T0 << (T1 + 32);
 676     RETURN();
 677 }
 678
 679 void op_dsra (void)
 680 {
 681     T0 = (int64_t)T0 >> T1;
 682     RETURN();
 683 }
 684
 685 void op_dsra32 (void)
 686 {
 687     T0 = (int64_t)T0 >> (T1 + 32);
 688     RETURN();
 689 }
 690
 691 void op_dsrl (void)
 692 {
 693     T0 = T0 >> T1;
 694     RETURN();
 695 }
 696
 697 void op_dsrl32 (void)
 698 {
 699     T0 = T0 >> (T1 + 32);
 700     RETURN();
 701 }
 702
 703 void op_drotr (void)
 704 {
 705     target_ulong tmp;
 706
 707     if (T1) {
 708        tmp = T0 << (0x40 - T1);
 709        T0 = (T0 >> T1) | tmp;
 710     } else
 711        T0 = T1;
 712     RETURN();
 713 }
 714
 715 void op_drotr32 (void)
 716 {
 717     target_ulong tmp;
 718
 719     if (T1) {
 720        tmp = T0 << (0x40 - (32 + T1));
 721        T0 = (T0 >> (32 + T1)) | tmp;
 722     } else
 723        T0 = T1;
 724     RETURN();
 725 }
 726
 727 void op_dsllv (void)
 728 {
 729     T0 = T1 << (T0 & 0x3F);
 730     RETURN();
 731 }
 732
 733 void op_dsrav (void)
 734 {
 735     T0 = (int64_t)T1 >> (T0 & 0x3F);
 736     RETURN();
 737 }
 738
 739 void op_dsrlv (void)
 740 {
 741     T0 = T1 >> (T0 & 0x3F);
 742     RETURN();
 743 }
 744
 745 void op_drotrv (void)
 746 {
 747     target_ulong tmp;
 748
 749     T0 &= 0x3F;
 750     if (T0) {
 751        tmp = T1 << (0x40 - T0);
 752        T0 = (T1 >> T0) | tmp;
 753     } else
 754        T0 = T1;
 755     RETURN();
 756 }
 757 #endif /* TARGET_LONG_BITS > HOST_LONG_BITS */
 758
 759 void op_dclo (void)
 760 {
 761     int n;
 762
 763     if (T0 == ~((target_ulong)0)) {
 764         T0 = 64;
 765     } else {
 766         for (n = 0; n < 64; n++) {
 767             if (!(T0 & (1ULL << 63)))
 768                 break;
 769             T0 = T0 << 1;
 770         }
 771         T0 = n;
 772     }
 773     RETURN();
 774 }
 775
 776 void op_dclz (void)
 777 {
 778     int n;
 779
 780     if (T0 == 0) {
 781         T0 = 64;
 782     } else {
 783         for (n = 0; n < 64; n++) {
 784             if (T0 & (1ULL << 63))
 785                 break;
 786             T0 = T0 << 1;
 787         }
 788         T0 = n;
 789     }
 790     RETURN();
 791 }
 792 #endif
 793
 794 /* 64 bits arithmetic */
 795 #if TARGET_LONG_BITS > HOST_LONG_BITS
 796 void op_mult (void)
 797 {
 798     CALL_FROM_TB0(do_mult);
 799     RETURN();
 800 }
 801
 802 void op_multu (void)
 803 {
 804     CALL_FROM_TB0(do_multu);
 805     RETURN();
 806 }
 807
 808 void op_madd (void)
 809 {
 810     CALL_FROM_TB0(do_madd);
 811     RETURN();
 812 }
 813
 814 void op_maddu (void)
 815 {
 816     CALL_FROM_TB0(do_maddu);
 817     RETURN();
 818 }
 819
 820 void op_msub (void)
 821 {
 822     CALL_FROM_TB0(do_msub);
 823     RETURN();
 824 }
 825
 826 void op_msubu (void)
 827 {
 828     CALL_FROM_TB0(do_msubu);
 829     RETURN();
 830 }
 831
 832 #else /* TARGET_LONG_BITS > HOST_LONG_BITS */
 833
 834 static inline uint64_t get_HILO (void)
 835 {
 836     return ((uint64_t)env->HI << 32) | ((uint64_t)(uint32_t)env->LO);
 837 }
 838
 839 static inline void set_HILO (uint64_t HILO)
 840 {
 841     env->LO = (int32_t)(HILO & 0xFFFFFFFF);
 842     env->HI = (int32_t)(HILO >> 32);
 843 }
 844
 845 void op_mult (void)
 846 {
 847     set_HILO((int64_t)(int32_t)T0 * (int64_t)(int32_t)T1);
 848     RETURN();
 849 }
 850
 851 void op_multu (void)
 852 {
 853     set_HILO((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1);
 854     RETURN();
 855 }
 856
 857 void op_madd (void)
 858 {
 859     int64_t tmp;
 860
 861     tmp = ((int64_t)(int32_t)T0 * (int64_t)(int32_t)T1);
 862     set_HILO((int64_t)get_HILO() + tmp);
 863     RETURN();
 864 }
 865
 866 void op_maddu (void)
 867 {
 868     uint64_t tmp;
 869
 870     tmp = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1);
 871     set_HILO(get_HILO() + tmp);
 872     RETURN();
 873 }
 874
 875 void op_msub (void)
 876 {
 877     int64_t tmp;
 878
 879     tmp = ((int64_t)(int32_t)T0 * (int64_t)(int32_t)T1);
 880     set_HILO((int64_t)get_HILO() - tmp);
 881     RETURN();
 882 }
 883
 884 void op_msubu (void)
 885 {
 886     uint64_t tmp;
 887
 888     tmp = ((uint64_t)(uint32_t)T0 * (uint64_t)(uint32_t)T1);
 889     set_HILO(get_HILO() - tmp);
 890     RETURN();
 891 }
 892 #endif /* TARGET_LONG_BITS > HOST_LONG_BITS */
 893
 894 #ifdef TARGET_MIPS64
 895 void op_dmult (void)
 896 {
 897     CALL_FROM_TB0(do_dmult);
 898     RETURN();
 899 }
 900
 901 void op_dmultu (void)
 902 {
 903     CALL_FROM_TB0(do_dmultu);
 904     RETURN();
 905 }
 906 #endif
 907
 908 /* Conditional moves */
 909 void op_movn (void)
 910 {
 911     if (T1 != 0)
 912         env->gpr[PARAM1] = T0;
 913     RETURN();
 914 }
 915
 916 void op_movz (void)
 917 {
 918     if (T1 == 0)
 919         env->gpr[PARAM1] = T0;
 920     RETURN();
 921 }
 922
 923 void op_movf (void)
 924 {
 925     if (!(env->fcr31 & PARAM1))
 926         env->gpr[PARAM2] = env->gpr[PARAM3];
 927     RETURN();
 928 }
 929
 930 void op_movt (void)
 931 {
 932     if (env->fcr31 & PARAM1)
 933         env->gpr[PARAM2] = env->gpr[PARAM3];
 934     RETURN();
 935 }
 936
 937 /* Tests */
 938 #define OP_COND(name, cond) \
 939 void glue(op_, name) (void) \
 940 {                           \
 941     if (cond) {             \
 942         T0 = 1;             \
 943     } else {                \
 944         T0 = 0;             \
 945     }                       \
 946     RETURN();               \
 947 }
 948
 949 OP_COND(eq, T0 == T1);
 950 OP_COND(ne, T0 != T1);
 951 OP_COND(ge, (int32_t)T0 >= (int32_t)T1);
 952 OP_COND(geu, T0 >= T1);
 953 OP_COND(lt, (int32_t)T0 < (int32_t)T1);
 954 OP_COND(ltu, T0 < T1);
 955 OP_COND(gez, (int32_t)T0 >= 0);
 956 OP_COND(gtz, (int32_t)T0 > 0);
 957 OP_COND(lez, (int32_t)T0 <= 0);
 958 OP_COND(ltz, (int32_t)T0 < 0);
 959
 960 /* Branches */
 961 //#undef USE_DIRECT_JUMP
 962
 963 void OPPROTO op_goto_tb0(void)
 964 {
 965     GOTO_TB(op_goto_tb0, PARAM1, 0);
 966     RETURN();
 967 }
 968
 969 void OPPROTO op_goto_tb1(void)
 970 {
 971     GOTO_TB(op_goto_tb1, PARAM1, 1);
 972     RETURN();
 973 }
 974
 975 /* Branch to register */
 976 void op_save_breg_target (void)
 977 {
 978     env->btarget = T2;
 979     RETURN();
 980 }
 981
 982 void op_restore_breg_target (void)
 983 {
 984     T2 = env->btarget;
 985     RETURN();
 986 }
 987
 988 void op_breg (void)
 989 {
 990     env->PC = T2;
 991     RETURN();
 992 }
 993
 994 void op_save_btarget (void)
 995 {
 996     env->btarget = PARAM1;
 997     RETURN();
 998 }
 999
1000 /* Conditional branch */
1001 void op_set_bcond (void)
1002 {
1003     T2 = T0;
1004     RETURN();
1005 }
1006
1007 void op_save_bcond (void)
1008 {
1009     env->bcond = T2;
1010     RETURN();
1011 }
1012
1013 void op_restore_bcond (void)
1014 {
1015     T2 = env->bcond;
1016     RETURN();
1017 }
1018
1019 void op_jnz_T2 (void)
1020 {
1021     if (T2)
1022         GOTO_LABEL_PARAM(1);
1023     RETURN();
1024 }
1025
1026 /* CP0 functions */
1027 void op_mfc0_index (void)
1028 {
1029     T0 = env->CP0_Index;
1030     RETURN();
1031 }
1032
1033 void op_mfc0_random (void)
1034 {
1035     CALL_FROM_TB0(do_mfc0_random);
1036     RETURN();
1037 }
1038
1039 void op_mfc0_entrylo0 (void)
1040 {
1041     T0 = (int32_t)env->CP0_EntryLo0;
1042     RETURN();
1043 }
1044
1045 void op_mfc0_entrylo1 (void)
1046 {
1047     T0 = (int32_t)env->CP0_EntryLo1;
1048     RETURN();
1049 }
1050
1051 void op_mfc0_context (void)
1052 {
1053     T0 = (int32_t)env->CP0_Context;
1054     RETURN();
1055 }
1056
1057 void op_mfc0_pagemask (void)
1058 {
1059     T0 = env->CP0_PageMask;
1060     RETURN();
1061 }
1062
1063 void op_mfc0_pagegrain (void)
1064 {
1065     T0 = env->CP0_PageGrain;
1066     RETURN();
1067 }
1068
1069 void op_mfc0_wired (void)
1070 {
1071     T0 = env->CP0_Wired;
1072     RETURN();
1073 }
1074
1075 void op_mfc0_hwrena (void)
1076 {
1077     T0 = env->CP0_HWREna;
1078     RETURN();
1079 }
1080
1081 void op_mfc0_badvaddr (void)
1082 {
1083     T0 = (int32_t)env->CP0_BadVAddr;
1084     RETURN();
1085 }
1086
1087 void op_mfc0_count (void)
1088 {
1089     CALL_FROM_TB0(do_mfc0_count);
1090     RETURN();
1091 }
1092
1093 void op_mfc0_entryhi (void)
1094 {
1095     T0 = (int32_t)env->CP0_EntryHi;
1096     RETURN();
1097 }
1098
1099 void op_mfc0_compare (void)
1100 {
1101     T0 = env->CP0_Compare;
1102     RETURN();
1103 }
1104
1105 void op_mfc0_status (void)
1106 {
1107     T0 = env->CP0_Status;
1108     RETURN();
1109 }
1110
1111 void op_mfc0_intctl (void)
1112 {
1113     T0 = env->CP0_IntCtl;
1114     RETURN();
1115 }
1116
1117 void op_mfc0_srsctl (void)
1118 {
1119     T0 = env->CP0_SRSCtl;
1120     RETURN();
1121 }
1122
1123 void op_mfc0_srsmap (void)
1124 {
1125     T0 = env->CP0_SRSMap;
1126     RETURN();
1127 }
1128
1129 void op_mfc0_cause (void)
1130 {
1131     T0 = env->CP0_Cause;
1132     RETURN();
1133 }
1134
1135 void op_mfc0_epc (void)
1136 {
1137     T0 = (int32_t)env->CP0_EPC;
1138     RETURN();
1139 }
1140
1141 void op_mfc0_prid (void)
1142 {
1143     T0 = env->CP0_PRid;
1144     RETURN();
1145 }
1146
1147 void op_mfc0_ebase (void)
1148 {
1149     T0 = env->CP0_EBase;
1150     RETURN();
1151 }
1152
1153 void op_mfc0_config0 (void)
1154 {
1155     T0 = env->CP0_Config0;
1156     RETURN();
1157 }
1158
1159 void op_mfc0_config1 (void)
1160 {
1161     T0 = env->CP0_Config1;
1162     RETURN();
1163 }
1164
1165 void op_mfc0_config2 (void)
1166 {
1167     T0 = env->CP0_Config2;
1168     RETURN();
1169 }
1170
1171 void op_mfc0_config3 (void)
1172 {
1173     T0 = env->CP0_Config3;
1174     RETURN();
1175 }
1176
1177 void op_mfc0_config6 (void)
1178 {
1179     T0 = env->CP0_Config6;
1180     RETURN();
1181 }
1182
1183 void op_mfc0_config7 (void)
1184 {
1185     T0 = env->CP0_Config7;
1186     RETURN();
1187 }
1188
1189 void op_mfc0_lladdr (void)
1190 {
1191     T0 = (int32_t)env->CP0_LLAddr >> 4;
1192     RETURN();
1193 }
1194
1195 void op_mfc0_watchlo0 (void)
1196 {
1197     T0 = (int32_t)env->CP0_WatchLo;
1198     RETURN();
1199 }
1200
1201 void op_mfc0_watchhi0 (void)
1202 {
1203     T0 = env->CP0_WatchHi;
1204     RETURN();
1205 }
1206
1207 void op_mfc0_xcontext (void)
1208 {
1209     T0 = (int32_t)env->CP0_XContext;
1210     RETURN();
1211 }
1212
1213 void op_mfc0_framemask (void)
1214 {
1215     T0 = env->CP0_Framemask;
1216     RETURN();
1217 }
1218
1219 void op_mfc0_debug (void)
1220 {
1221     T0 = env->CP0_Debug;
1222     if (env->hflags & MIPS_HFLAG_DM)
1223         T0 |= 1 << CP0DB_DM;
1224     RETURN();
1225 }
1226
1227 void op_mfc0_depc (void)
1228 {
1229     T0 = (int32_t)env->CP0_DEPC;
1230     RETURN();
1231 }
1232
1233 void op_mfc0_performance0 (void)
1234 {
1235     T0 = env->CP0_Performance0;
1236     RETURN();
1237 }
1238
1239 void op_mfc0_taglo (void)
1240 {
1241     T0 = env->CP0_TagLo;
1242     RETURN();
1243 }
1244
1245 void op_mfc0_datalo (void)
1246 {
1247     T0 = env->CP0_DataLo;
1248     RETURN();
1249 }
1250
1251 void op_mfc0_taghi (void)
1252 {
1253     T0 = env->CP0_TagHi;
1254     RETURN();
1255 }
1256
1257 void op_mfc0_datahi (void)
1258 {
1259     T0 = env->CP0_DataHi;
1260     RETURN();
1261 }
1262
1263 void op_mfc0_errorepc (void)
1264 {
1265     T0 = (int32_t)env->CP0_ErrorEPC;
1266     RETURN();
1267 }
1268
1269 void op_mfc0_desave (void)
1270 {
1271     T0 = env->CP0_DESAVE;
1272     RETURN();
1273 }
1274
1275 void op_mtc0_index (void)
1276 {
1277     env->CP0_Index = (env->CP0_Index & 0x80000000) | (T0 & (MIPS_TLB_NB - 1));
1278     RETURN();
1279 }
1280
1281 void op_mtc0_entrylo0 (void)
1282 {
1283     /* Large physaddr not implemented */
1284     /* 1k pages not implemented */
1285     env->CP0_EntryLo0 = (int32_t)T0 & 0x3FFFFFFF;
1286     RETURN();
1287 }
1288
1289 void op_mtc0_entrylo1 (void)
1290 {
1291     /* Large physaddr not implemented */
1292     /* 1k pages not implemented */
1293     env->CP0_EntryLo1 = (int32_t)T0 & 0x3FFFFFFF;
1294     RETURN();
1295 }
1296
1297 void op_mtc0_context (void)
1298 {
1299     env->CP0_Context = (env->CP0_Context & ~0x007FFFFF) | (T0 & 0x007FFFF0);
1300     RETURN();
1301 }
1302
1303 void op_mtc0_pagemask (void)
1304 {
1305     /* 1k pages not implemented */
1306     env->CP0_PageMask = T0 & 0x1FFFE000;
1307     RETURN();
1308 }
1309
1310 void op_mtc0_pagegrain (void)
1311 {
1312     /* SmartMIPS not implemented */
1313     /* Large physaddr not implemented */
1314     /* 1k pages not implemented */
1315     env->CP0_PageGrain = 0;
1316     RETURN();
1317 }
1318
1319 void op_mtc0_wired (void)
1320 {
1321     env->CP0_Wired = T0 & (MIPS_TLB_NB - 1);
1322     RETURN();
1323 }
1324
1325 void op_mtc0_hwrena (void)
1326 {
1327     env->CP0_HWREna = T0 & 0x0000000F;
1328     RETURN();
1329 }
1330
1331 void op_mtc0_count (void)
1332 {
1333     CALL_FROM_TB2(cpu_mips_store_count, env, T0);
1334     RETURN();
1335 }
1336
1337 void op_mtc0_entryhi (void)
1338 {
1339     target_ulong old, val;
1340
1341     /* 1k pages not implemented */
1342     /* Ignore MIPS64 TLB for now */
1343     val = (target_ulong)(int32_t)T0 & ~(target_ulong)0x1F00;
1344     old = env->CP0_EntryHi;
1345     env->CP0_EntryHi = val;
1346     /* If the ASID changes, flush qemu's TLB.  */
1347     if ((old & 0xFF) != (val & 0xFF))
1348         CALL_FROM_TB2(cpu_mips_tlb_flush, env, 1);
1349     RETURN();
1350 }
1351
1352 void op_mtc0_compare (void)
1353 {
1354     CALL_FROM_TB2(cpu_mips_store_compare, env, T0);
1355     RETURN();
1356 }
1357
1358 void op_mtc0_status (void)
1359 {
1360     uint32_t val, old;
1361
1362     /* No 64bit FPU, no reverse endianness, no MDMX/DSP, no 64bit ops,
1363        no 64bit addressing implemented. */
1364     val = (int32_t)T0 & 0xF878FF17;
1365     old = env->CP0_Status;
1366     env->CP0_Status = val;
1367     if (loglevel & CPU_LOG_TB_IN_ASM)
1368        CALL_FROM_TB2(do_mtc0_status_debug, old, val);
1369     CALL_FROM_TB1(cpu_mips_update_irq, env);
1370     RETURN();
1371 }
1372
1373 void op_mtc0_intctl (void)
1374 {
1375     /* vectored interrupts not implemented */
1376     env->CP0_IntCtl = 0;
1377     RETURN();
1378 }
1379
1380 void op_mtc0_srsctl (void)
1381 {
1382     /* shadow registers not implemented */
1383     env->CP0_SRSCtl = 0;
1384     RETURN();
1385 }
1386
1387 void op_mtc0_srsmap (void)
1388 {
1389     /* shadow registers not implemented */
1390     env->CP0_SRSMap = 0;
1391     RETURN();
1392 }
1393
1394 void op_mtc0_cause (void)
1395 {
1396     uint32_t mask = 0x00C00300;
1397
1398     if ((env->CP0_Config0 & (0x7 << CP0C0_AR)) == (1 << CP0C0_AR))
1399         mask |= 1 << CP0Ca_DC;
1400
1401     env->CP0_Cause = (env->CP0_Cause & 0xFCC0FF7C) | (T0 & mask);
1402
1403     /* Handle the software interrupt as an hardware one, as they
1404        are very similar */
1405     if (T0 & CP0Ca_IP_mask) {
1406         CALL_FROM_TB1(cpu_mips_update_irq, env);
1407     }
1408     RETURN();
1409 }
1410
1411 void op_mtc0_epc (void)
1412 {
1413     env->CP0_EPC = (int32_t)T0;
1414     RETURN();
1415 }
1416
1417 void op_mtc0_ebase (void)
1418 {
1419     /* vectored interrupts not implemented */
1420     /* Multi-CPU not implemented */
1421     env->CP0_EBase = 0x80000000 | (T0 & 0x3FFFF000);
1422     RETURN();
1423 }
1424
1425 void op_mtc0_config0 (void)
1426 {
1427 #if defined(MIPS_USES_R4K_TLB)
1428      /* Fixed mapping MMU not implemented */
1429     env->CP0_Config0 = (env->CP0_Config0 & 0x8017FF88) | (T0 & 0x00000001);
1430 #else
1431     env->CP0_Config0 = (env->CP0_Config0 & 0xFE17FF88) | (T0 & 0x00000001);
1432 #endif
1433     RETURN();
1434 }
1435
1436 void op_mtc0_config2 (void)
1437 {
1438     /* tertiary/secondary caches not implemented */
1439     env->CP0_Config2 = (env->CP0_Config2 & 0x8FFF0FFF);
1440     RETURN();
1441 }
1442
1443 void op_mtc0_watchlo0 (void)
1444 {
1445     env->CP0_WatchLo = (int32_t)T0;
1446     RETURN();
1447 }
1448
1449 void op_mtc0_watchhi0 (void)
1450 {
1451     env->CP0_WatchHi = T0 & 0x40FF0FF8;
1452     RETURN();
1453 }
1454
1455 void op_mtc0_xcontext (void)
1456 {
1457     env->CP0_XContext = (int32_t)T0; /* XXX */
1458     RETURN();
1459 }
1460
1461 void op_mtc0_framemask (void)
1462 {
1463     env->CP0_Framemask = T0; /* XXX */
1464     RETURN();
1465 }
1466
1467 void op_mtc0_debug (void)
1468 {
1469     env->CP0_Debug = (env->CP0_Debug & 0x8C03FC1F) | (T0 & 0x13300120);
1470     if (T0 & (1 << CP0DB_DM))
1471         env->hflags |= MIPS_HFLAG_DM;
1472     else
1473         env->hflags &= ~MIPS_HFLAG_DM;
1474     RETURN();
1475 }
1476
1477 void op_mtc0_depc (void)
1478 {
1479     env->CP0_DEPC = (int32_t)T0;
1480     RETURN();
1481 }
1482
1483 void op_mtc0_performance0 (void)
1484 {
1485     env->CP0_Performance0 = T0; /* XXX */
1486     RETURN();
1487 }
1488
1489 void op_mtc0_taglo (void)
1490 {
1491     env->CP0_TagLo = T0 & 0xFFFFFCF6;
1492     RETURN();
1493 }
1494
1495 void op_mtc0_datalo (void)
1496 {
1497     env->CP0_DataLo = T0; /* XXX */
1498     RETURN();
1499 }
1500
1501 void op_mtc0_taghi (void)
1502 {
1503     env->CP0_TagHi = T0; /* XXX */
1504     RETURN();
1505 }
1506
1507 void op_mtc0_datahi (void)
1508 {
1509     env->CP0_DataHi = T0; /* XXX */
1510     RETURN();
1511 }
1512
1513 void op_mtc0_errorepc (void)
1514 {
1515     env->CP0_ErrorEPC = (int32_t)T0;
1516     RETURN();
1517 }
1518
1519 void op_mtc0_desave (void)
1520 {
1521     env->CP0_DESAVE = T0;
1522     RETURN();
1523 }
1524
1525 void op_dmfc0_entrylo0 (void)
1526 {
1527     T0 = env->CP0_EntryLo0;
1528     RETURN();
1529 }
1530
1531 void op_dmfc0_entrylo1 (void)
1532 {
1533     T0 = env->CP0_EntryLo1;
1534     RETURN();
1535 }
1536
1537 void op_dmfc0_context (void)
1538 {
1539     T0 = env->CP0_Context;
1540     RETURN();
1541 }
1542
1543 void op_dmfc0_badvaddr (void)
1544 {
1545     T0 = env->CP0_BadVAddr;
1546     RETURN();
1547 }
1548
1549 void op_dmfc0_entryhi (void)
1550 {
1551     T0 = env->CP0_EntryHi;
1552     RETURN();
1553 }
1554
1555 void op_dmfc0_epc (void)
1556 {
1557     T0 = env->CP0_EPC;
1558     RETURN();
1559 }
1560
1561 void op_dmfc0_lladdr (void)
1562 {
1563     T0 = env->CP0_LLAddr >> 4;
1564     RETURN();
1565 }
1566
1567 void op_dmfc0_watchlo0 (void)
1568 {
1569     T0 = env->CP0_WatchLo;
1570     RETURN();
1571 }
1572
1573 void op_dmfc0_xcontext (void)
1574 {
1575     T0 = env->CP0_XContext;
1576     RETURN();
1577 }
1578
1579 void op_dmfc0_depc (void)
1580 {
1581     T0 = env->CP0_DEPC;
1582     RETURN();
1583 }
1584
1585 void op_dmfc0_errorepc (void)
1586 {
1587     T0 = env->CP0_ErrorEPC;
1588     RETURN();
1589 }
1590
1591 void op_dmtc0_entrylo0 (void)
1592 {
1593     /* Large physaddr not implemented */
1594     /* 1k pages not implemented */
1595     env->CP0_EntryLo0 = T0 & 0x3FFFFFFF;
1596     RETURN();
1597 }
1598
1599 void op_dmtc0_entrylo1 (void)
1600 {
1601     /* Large physaddr not implemented */
1602     /* 1k pages not implemented */
1603     env->CP0_EntryLo1 = T0 & 0x3FFFFFFF;
1604     RETURN();
1605 }
1606
1607 void op_dmtc0_context (void)
1608 {
1609     env->CP0_Context = (env->CP0_Context & ~0x007FFFFF) | (T0 & 0x007FFFF0);
1610     RETURN();
1611 }
1612
1613 void op_dmtc0_epc (void)
1614 {
1615     env->CP0_EPC = T0;
1616     RETURN();
1617 }
1618
1619 void op_dmtc0_watchlo0 (void)
1620 {
1621     env->CP0_WatchLo = T0;
1622     RETURN();
1623 }
1624
1625 void op_dmtc0_xcontext (void)
1626 {
1627     env->CP0_XContext = T0; /* XXX */
1628     RETURN();
1629 }
1630
1631 void op_dmtc0_depc (void)
1632 {
1633     env->CP0_DEPC = T0;
1634     RETURN();
1635 }
1636
1637 void op_dmtc0_errorepc (void)
1638 {
1639     env->CP0_ErrorEPC = T0;
1640     RETURN();
1641 }
1642
1643 #if 0
1644 # define DEBUG_FPU_STATE() CALL_FROM_TB1(dump_fpu, env)
1645 #else
1646 # define DEBUG_FPU_STATE() do { } while(0)
1647 #endif
1648
1649 void op_cp0_enabled(void)
1650 {
1651     if (!(env->CP0_Status & (1 << CP0St_CU0)) &&
1652         (env->hflags & MIPS_HFLAG_UM)) {
1653         CALL_FROM_TB2(do_raise_exception_direct_err, EXCP_CpU, 0);
1654     }
1655     RETURN();
1656 }
1657
1658 void op_cp1_enabled(void)
1659 {
1660     if (!(env->CP0_Status & (1 << CP0St_CU1))) {
1661         CALL_FROM_TB2(do_raise_exception_direct_err, EXCP_CpU, 1);
1662     }
1663     RETURN();
1664 }
1665
1666 /* CP1 functions */
1667 void op_cfc1 (void)
1668 {
1669     if (T1 == 0) {
1670         T0 = env->fcr0;
1671     }
1672     else {
1673         /* fetch fcr31, masking unused bits */
1674         T0 = env->fcr31 & 0x0183FFFF;
1675     }
1676     DEBUG_FPU_STATE();
1677     RETURN();
1678 }
1679
1680 /* convert MIPS rounding mode in FCR31 to IEEE library */
1681 unsigned int ieee_rm[] = {
1682     float_round_nearest_even,
1683     float_round_to_zero,
1684     float_round_up,
1685     float_round_down
1686 };
1687
1688 #define RESTORE_ROUNDING_MODE \
1689     set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
1690
1691 void op_ctc1 (void)
1692 {
1693     if (T1 == 0) {
1694         /* XXX should this throw an exception?
1695          * don't write to FCR0.
1696          * env->fcr0 = T0;
1697          */
1698     }
1699     else {
1700         /* store new fcr31, masking unused bits */
1701         env->fcr31 = T0 & 0x0183FFFF;
1702
1703         /* set rounding mode */
1704         RESTORE_ROUNDING_MODE;
1705
1706 #ifndef CONFIG_SOFTFLOAT
1707         /* no floating point exception for native float */
1708         SET_FP_ENABLE(env->fcr31, 0);
1709 #endif
1710     }
1711     DEBUG_FPU_STATE();
1712     RETURN();
1713 }
1714
1715 void op_mfc1 (void)
1716 {
1717     T0 = WT0;
1718     DEBUG_FPU_STATE();
1719     RETURN();
1720 }
1721
1722 void op_mtc1 (void)
1723 {
1724     WT0 = T0;
1725     DEBUG_FPU_STATE();
1726     RETURN();
1727 }
1728
1729 /* Float support.
1730    Single precition routines have a "s" suffix, double precision a
1731    "d" suffix.  */
1732
1733 #define FLOAT_OP(name, p) void OPPROTO op_float_##name##_##p(void)
1734
1735 FLOAT_OP(cvtd, s)
1736 {
1737     FDT2 = float32_to_float64(FST0, &env->fp_status);
1738     DEBUG_FPU_STATE();
1739     RETURN();
1740 }
1741 FLOAT_OP(cvtd, w)
1742 {
1743     FDT2 = int32_to_float64(WT0, &env->fp_status);
1744     DEBUG_FPU_STATE();
1745     RETURN();
1746 }
1747 FLOAT_OP(cvts, d)
1748 {
1749     FST2 = float64_to_float32(FDT0, &env->fp_status);
1750     DEBUG_FPU_STATE();
1751     RETURN();
1752 }
1753 FLOAT_OP(cvts, w)
1754 {
1755     FST2 = int32_to_float32(WT0, &env->fp_status);
1756     DEBUG_FPU_STATE();
1757     RETURN();
1758 }
1759 FLOAT_OP(cvtw, s)
1760 {
1761     WT2 = float32_to_int32(FST0, &env->fp_status);
1762     DEBUG_FPU_STATE();
1763     RETURN();
1764 }
1765 FLOAT_OP(cvtw, d)
1766 {
1767     WT2 = float64_to_int32(FDT0, &env->fp_status);
1768     DEBUG_FPU_STATE();
1769     RETURN();
1770 }
1771
1772 FLOAT_OP(roundw, d)
1773 {
1774     set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
1775     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1776     RESTORE_ROUNDING_MODE;
1777
1778     DEBUG_FPU_STATE();
1779     RETURN();
1780 }
1781 FLOAT_OP(roundw, s)
1782 {
1783     set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
1784     WT2 = float32_round_to_int(FST0, &env->fp_status);
1785     RESTORE_ROUNDING_MODE;
1786     DEBUG_FPU_STATE();
1787     RETURN();
1788 }
1789
1790 FLOAT_OP(truncw, d)
1791 {
1792     WT2 = float64_to_int32_round_to_zero(FDT0, &env->fp_status);
1793     DEBUG_FPU_STATE();
1794     RETURN();
1795 }
1796 FLOAT_OP(truncw, s)
1797 {
1798     WT2 = float32_to_int32_round_to_zero(FST0, &env->fp_status);
1799     DEBUG_FPU_STATE();
1800     RETURN();
1801 }
1802
1803 FLOAT_OP(ceilw, d)
1804 {
1805     set_float_rounding_mode(float_round_up, &env->fp_status);
1806     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1807     RESTORE_ROUNDING_MODE;
1808
1809     DEBUG_FPU_STATE();
1810     RETURN();
1811 }
1812 FLOAT_OP(ceilw, s)
1813 {
1814     set_float_rounding_mode(float_round_up, &env->fp_status);
1815     WT2 = float32_round_to_int(FST0, &env->fp_status);
1816     RESTORE_ROUNDING_MODE;
1817     DEBUG_FPU_STATE();
1818     RETURN();
1819 }
1820
1821 FLOAT_OP(floorw, d)
1822 {
1823     set_float_rounding_mode(float_round_down, &env->fp_status);
1824     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1825     RESTORE_ROUNDING_MODE;
1826
1827     DEBUG_FPU_STATE();
1828     RETURN();
1829 }
1830 FLOAT_OP(floorw, s)
1831 {
1832     set_float_rounding_mode(float_round_down, &env->fp_status);
1833     WT2 = float32_round_to_int(FST0, &env->fp_status);
1834     RESTORE_ROUNDING_MODE;
1835     DEBUG_FPU_STATE();
1836     RETURN();
1837 }
1838
1839 /* binary operations */
1840 #define FLOAT_BINOP(name) \
1841 FLOAT_OP(name, d)         \
1842 {                         \
1843     FDT2 = float64_ ## name (FDT0, FDT1, &env->fp_status);    \
1844     DEBUG_FPU_STATE();    \
1845 }                         \
1846 FLOAT_OP(name, s)         \
1847 {                         \
1848     FST2 = float32_ ## name (FST0, FST1, &env->fp_status);    \
1849     DEBUG_FPU_STATE();    \
1850 }
1851 FLOAT_BINOP(add)
1852 FLOAT_BINOP(sub)
1853 FLOAT_BINOP(mul)
1854 FLOAT_BINOP(div)
1855 #undef FLOAT_BINOP
1856
1857 /* unary operations, modifying fp status  */
1858 #define FLOAT_UNOP(name)  \
1859 FLOAT_OP(name, d)         \
1860 {                         \
1861     FDT2 = float64_ ## name(FDT0, &env->fp_status);   \
1862     DEBUG_FPU_STATE();    \
1863 }                         \
1864 FLOAT_OP(name, s)         \
1865 {                         \
1866     FST2 = float32_ ## name(FST0, &env->fp_status);   \
1867     DEBUG_FPU_STATE();    \
1868 }
1869 FLOAT_UNOP(sqrt)
1870 #undef FLOAT_UNOP
1871
1872 /* unary operations, not modifying fp status  */
1873 #define FLOAT_UNOP(name)  \
1874 FLOAT_OP(name, d)         \
1875 {                         \
1876     FDT2 = float64_ ## name(FDT0);   \
1877     DEBUG_FPU_STATE();    \
1878 }                         \
1879 FLOAT_OP(name, s)         \
1880 {                         \
1881     FST2 = float32_ ## name(FST0);   \
1882     DEBUG_FPU_STATE();    \
1883 }
1884 FLOAT_UNOP(abs)
1885 FLOAT_UNOP(chs)
1886 #undef FLOAT_UNOP
1887
1888 FLOAT_OP(mov, d)
1889 {
1890     FDT2 = FDT0;
1891     DEBUG_FPU_STATE();
1892     RETURN();
1893 }
1894 FLOAT_OP(mov, s)
1895 {
1896     FST2 = FST0;
1897     DEBUG_FPU_STATE();
1898     RETURN();
1899 }
1900
1901 #ifdef CONFIG_SOFTFLOAT
1902 #define clear_invalid() do {                                \
1903     int flags = get_float_exception_flags(&env->fp_status); \
1904     flags &= ~float_flag_invalid;                           \
1905     set_float_exception_flags(flags, &env->fp_status);      \
1906 } while(0)
1907 #else
1908 #define clear_invalid() do { } while(0)
1909 #endif
1910
1911 extern void dump_fpu_s(CPUState *env);
1912
1913 #define FOP_COND(fmt, op, sig, cond)           \
1914 void op_cmp_ ## fmt ## _ ## op (void)          \
1915 {                                              \
1916     if (cond)                                  \
1917         SET_FP_COND(env->fcr31);               \
1918     else                                       \
1919         CLEAR_FP_COND(env->fcr31);             \
1920     if (!sig)                                  \
1921         clear_invalid();                       \
1922     /*CALL_FROM_TB1(dump_fpu_s, env);*/ \
1923     DEBUG_FPU_STATE();                         \
1924     RETURN();                                  \
1925 }
1926
1927 int float64_is_unordered(float64 a, float64 b STATUS_PARAM)
1928 {
1929     if (float64_is_nan(a) || float64_is_nan(b)) {
1930         float_raise(float_flag_invalid, status);
1931         return 1;
1932     }
1933     else {
1934         return 0;
1935     }
1936 }
1937
1938 FOP_COND(d, f,   0,                                                      0)
1939 FOP_COND(d, un,  0, float64_is_unordered(FDT1, FDT0, &env->fp_status))
1940 FOP_COND(d, eq,  0,                                                      float64_eq(FDT0, FDT1, &env->fp_status))
1941 FOP_COND(d, ueq, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_eq(FDT0, FDT1, &env->fp_status))
1942 FOP_COND(d, olt, 0,                                                      float64_lt(FDT0, FDT1, &env->fp_status))
1943 FOP_COND(d, ult, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_lt(FDT0, FDT1, &env->fp_status))
1944 FOP_COND(d, ole, 0,                                                      float64_le(FDT0, FDT1, &env->fp_status))
1945 FOP_COND(d, ule, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_le(FDT0, FDT1, &env->fp_status))
1946 /* NOTE: the comma operator will make "cond" to eval to false,
1947  * but float*_is_unordered() is still called
1948  */
1949 FOP_COND(d, sf,  1,                                                      (float64_is_unordered(FDT0, FDT1, &env->fp_status), 0))
1950 FOP_COND(d, ngle,1, float64_is_unordered(FDT1, FDT0, &env->fp_status))
1951 FOP_COND(d, seq, 1,                                                      float64_eq(FDT0, FDT1, &env->fp_status))
1952 FOP_COND(d, ngl, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_eq(FDT0, FDT1, &env->fp_status))
1953 FOP_COND(d, lt,  1,                                                      float64_lt(FDT0, FDT1, &env->fp_status))
1954 FOP_COND(d, nge, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_lt(FDT0, FDT1, &env->fp_status))
1955 FOP_COND(d, le,  1,                                                      float64_le(FDT0, FDT1, &env->fp_status))
1956 FOP_COND(d, ngt, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_le(FDT0, FDT1, &env->fp_status))
1957
1958 flag float32_is_unordered(float32 a, float32 b STATUS_PARAM)
1959 {
1960     extern flag float32_is_nan( float32 a );
1961     if (float32_is_nan(a) || float32_is_nan(b)) {
1962         float_raise(float_flag_invalid, status);
1963         return 1;
1964     }
1965     else {
1966         return 0;
1967     }
1968 }
1969
1970 /* NOTE: the comma operator will make "cond" to eval to false,
1971  * but float*_is_unordered() is still called
1972  */
1973 FOP_COND(s, f,   0,                                                      0)
1974 FOP_COND(s, un,  0, float32_is_unordered(FST1, FST0, &env->fp_status))
1975 FOP_COND(s, eq,  0,                                                      float32_eq(FST0, FST1, &env->fp_status))
1976 FOP_COND(s, ueq, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_eq(FST0, FST1, &env->fp_status))
1977 FOP_COND(s, olt, 0,                                                      float32_lt(FST0, FST1, &env->fp_status))
1978 FOP_COND(s, ult, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_lt(FST0, FST1, &env->fp_status))
1979 FOP_COND(s, ole, 0,                                                      float32_le(FST0, FST1, &env->fp_status))
1980 FOP_COND(s, ule, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_le(FST0, FST1, &env->fp_status))
1981 /* NOTE: the comma operator will make "cond" to eval to false,
1982  * but float*_is_unordered() is still called
1983  */
1984 FOP_COND(s, sf,  1,                                                      (float32_is_unordered(FST0, FST1, &env->fp_status), 0))
1985 FOP_COND(s, ngle,1, float32_is_unordered(FST1, FST0, &env->fp_status))
1986 FOP_COND(s, seq, 1,                                                      float32_eq(FST0, FST1, &env->fp_status))
1987 FOP_COND(s, ngl, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_eq(FST0, FST1, &env->fp_status))
1988 FOP_COND(s, lt,  1,                                                      float32_lt(FST0, FST1, &env->fp_status))
1989 FOP_COND(s, nge, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_lt(FST0, FST1, &env->fp_status))
1990 FOP_COND(s, le,  1,                                                      float32_le(FST0, FST1, &env->fp_status))
1991 FOP_COND(s, ngt, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_le(FST0, FST1, &env->fp_status))
1992
1993 void op_bc1f (void)
1994 {
1995     T0 = ! IS_FP_COND_SET(env->fcr31);
1996     DEBUG_FPU_STATE();
1997     RETURN();
1998 }
1999
2000 void op_bc1t (void)
2001 {
2002     T0 = IS_FP_COND_SET(env->fcr31);
2003     DEBUG_FPU_STATE();
2004     RETURN();
2005 }
2006
2007 #if defined(MIPS_USES_R4K_TLB)
2008 void op_tlbwi (void)
2009 {
2010     CALL_FROM_TB0(do_tlbwi);
2011     RETURN();
2012 }
2013
2014 void op_tlbwr (void)
2015 {
2016     CALL_FROM_TB0(do_tlbwr);
2017     RETURN();
2018 }
2019
2020 void op_tlbp (void)
2021 {
2022     CALL_FROM_TB0(do_tlbp);
2023     RETURN();
2024 }
2025
2026 void op_tlbr (void)
2027 {
2028     CALL_FROM_TB0(do_tlbr);
2029     RETURN();
2030 }
2031 #endif
2032
2033 /* Specials */
2034 #if defined (CONFIG_USER_ONLY)
2035 void op_tls_value (void)
2036 {
2037   T0 = env->tls_value;
2038 }
2039 #endif
2040
2041 void op_pmon (void)
2042 {
2043     CALL_FROM_TB1(do_pmon, PARAM1);
2044     RETURN();
2045 }
2046
2047 void op_di (void)
2048 {
2049     T0 = env->CP0_Status;
2050     env->CP0_Status = T0 & ~(1 << CP0St_IE);
2051     CALL_FROM_TB1(cpu_mips_update_irq, env);
2052     RETURN();
2053 }
2054
2055 void op_ei (void)
2056 {
2057     T0 = env->CP0_Status;
2058     env->CP0_Status = T0 | (1 << CP0St_IE);
2059     CALL_FROM_TB1(cpu_mips_update_irq, env);
2060     RETURN();
2061 }
2062
2063 void op_trap (void)
2064 {
2065     if (T0) {
2066         CALL_FROM_TB1(do_raise_exception_direct, EXCP_TRAP);
2067     }
2068     RETURN();
2069 }
2070
2071 void op_debug (void)
2072 {
2073     CALL_FROM_TB1(do_raise_exception, EXCP_DEBUG);
2074     RETURN();
2075 }
2076
2077 void op_set_lladdr (void)
2078 {
2079     env->CP0_LLAddr = T2;
2080     RETURN();
2081 }
2082
2083 void debug_eret (void);
2084 void op_eret (void)
2085 {
2086     CALL_FROM_TB0(debug_eret);
2087     if (env->CP0_Status & (1 << CP0St_ERL)) {
2088         env->PC = env->CP0_ErrorEPC;
2089         env->CP0_Status &= ~(1 << CP0St_ERL);
2090     } else {
2091         env->PC = env->CP0_EPC;
2092         env->CP0_Status &= ~(1 << CP0St_EXL);
2093     }
2094     if (!(env->CP0_Status & (1 << CP0St_EXL)) &&
2095         !(env->CP0_Status & (1 << CP0St_ERL)) &&
2096         !(env->hflags & MIPS_HFLAG_DM) &&
2097         (env->CP0_Status & (1 << CP0St_UM)))
2098         env->hflags |= MIPS_HFLAG_UM;
2099     env->CP0_LLAddr = 1;
2100     RETURN();
2101 }
2102
2103 void op_deret (void)
2104 {
2105     CALL_FROM_TB0(debug_eret);
2106     env->PC = env->CP0_DEPC;
2107     env->hflags |= MIPS_HFLAG_DM;
2108     if (!(env->CP0_Status & (1 << CP0St_EXL)) &&
2109         !(env->CP0_Status & (1 << CP0St_ERL)) &&
2110         !(env->hflags & MIPS_HFLAG_DM) &&
2111         (env->CP0_Status & (1 << CP0St_UM)))
2112         env->hflags |= MIPS_HFLAG_UM;
2113     env->CP0_LLAddr = 1;
2114     RETURN();
2115 }
2116
2117 void op_rdhwr_cpunum(void)
2118 {
2119     if (env->CP0_HWREna & (1 << 0))
2120        T0 = env->CP0_EBase & 0x2ff;
2121     else
2122        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2123     RETURN();
2124 }
2125
2126 void op_rdhwr_synci_step(void)
2127 {
2128     if (env->CP0_HWREna & (1 << 1))
2129        T0 = env->SYNCI_Step;
2130     else
2131        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2132     RETURN();
2133 }
2134
2135 void op_rdhwr_cc(void)
2136 {
2137     if (env->CP0_HWREna & (1 << 2))
2138        T0 = env->CP0_Count;
2139     else
2140        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2141     RETURN();
2142 }
2143
2144 void op_rdhwr_ccres(void)
2145 {
2146     if (env->CP0_HWREna & (1 << 3))
2147        T0 = env->CCRes;
2148     else
2149        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2150     RETURN();
2151 }
2152
2153 void op_save_state (void)
2154 {
2155     env->hflags = PARAM1;
2156     RETURN();
2157 }
2158
2159 void op_save_pc (void)
2160 {
2161     env->PC = PARAM1;
2162     RETURN();
2163 }
2164
2165 void op_raise_exception (void)
2166 {
2167     CALL_FROM_TB1(do_raise_exception, PARAM1);
2168     RETURN();
2169 }
2170
2171 void op_raise_exception_err (void)
2172 {
2173     CALL_FROM_TB2(do_raise_exception_err, PARAM1, PARAM2);
2174     RETURN();
2175 }
2176
2177 void op_exit_tb (void)
2178 {
2179     EXIT_TB();
2180     RETURN();
2181 }
2182
2183 void op_wait (void)
2184 {
2185     env->halted = 1;
2186     CALL_FROM_TB1(do_raise_exception, EXCP_HLT);
2187     RETURN();
2188 }
2189
2190 /* Bitfield operations. */
2191 void op_ext(void)
2192 {
2193     unsigned int pos = PARAM1;
2194     unsigned int size = PARAM2;
2195
2196     T0 = ((uint32_t)T1 >> pos) & ((1 << size) - 1);
2197     RETURN();
2198 }
2199
2200 void op_ins(void)
2201 {
2202     unsigned int pos = PARAM1;
2203     unsigned int size = PARAM2;
2204     target_ulong mask = ((1 << size) - 1) << pos;
2205
2206     T0 = (T2 & ~mask) | (((uint32_t)T1 << pos) & mask);
2207     RETURN();
2208 }
2209
2210 void op_wsbh(void)
2211 {
2212     T0 = ((T1 << 8) & ~0x00FF00FF) | ((T1 >> 8) & 0x00FF00FF);
2213     RETURN();
2214 }
2215
2216 #ifdef TARGET_MIPS64
2217 void op_dext(void)
2218 {
2219     unsigned int pos = PARAM1;
2220     unsigned int size = PARAM2;
2221
2222     T0 = (T1 >> pos) & ((1 << size) - 1);
2223     RETURN();
2224 }
2225
2226 void op_dins(void)
2227 {
2228     unsigned int pos = PARAM1;
2229     unsigned int size = PARAM2;
2230     target_ulong mask = ((1 << size) - 1) << pos;
2231
2232     T0 = (T2 & ~mask) | ((T1 << pos) & mask);
2233     RETURN();
2234 }
2235
2236 void op_dsbh(void)
2237 {
2238     T0 = ((T1 << 8) & ~0x00FF00FF00FF00FFULL) | ((T1 >> 8) & 0x00FF00FF00FF00FFULL);
2239     RETURN();
2240 }
2241
2242 void op_dshd(void)
2243 {
2244     T0 = ((T1 << 16) & ~0x0000FFFF0000FFFFULL) | ((T1 >> 16) & 0x0000FFFF0000FFFFULL);
2245     RETURN();
2246 }
2247 #endif
2248
2249 void op_seb(void)
2250 {
2251     T0 = ((T1 & 0xFF) ^ 0x80) - 0x80;
2252     RETURN();
2253 }
2254
2255 void op_seh(void)
2256 {
2257     T0 = ((T1 & 0xFFFF) ^ 0x8000) - 0x8000;
2258     RETURN();
2259 }