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 MIPS_HAS_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 /* MIPS_HAS_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 MIPS_HAS_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 MIPS_HAS_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     if (env->hflags & MIPS_HFLAG_UM)
1109         T0 |= (1 << CP0St_UM);
1110     if (env->hflags & MIPS_HFLAG_ERL)
1111         T0 |= (1 << CP0St_ERL);
1112     if (env->hflags & MIPS_HFLAG_EXL)
1113         T0 |= (1 << CP0St_EXL);
1114     RETURN();
1115 }
1116
1117 void op_mfc0_intctl (void)
1118 {
1119     T0 = env->CP0_IntCtl;
1120     RETURN();
1121 }
1122
1123 void op_mfc0_srsctl (void)
1124 {
1125     T0 = env->CP0_SRSCtl;
1126     RETURN();
1127 }
1128
1129 void op_mfc0_srsmap (void)
1130 {
1131     T0 = env->CP0_SRSMap;
1132     RETURN();
1133 }
1134
1135 void op_mfc0_cause (void)
1136 {
1137     T0 = env->CP0_Cause;
1138     RETURN();
1139 }
1140
1141 void op_mfc0_epc (void)
1142 {
1143     T0 = (int32_t)env->CP0_EPC;
1144     RETURN();
1145 }
1146
1147 void op_mfc0_prid (void)
1148 {
1149     T0 = env->CP0_PRid;
1150     RETURN();
1151 }
1152
1153 void op_mfc0_ebase (void)
1154 {
1155     T0 = env->CP0_EBase;
1156     RETURN();
1157 }
1158
1159 void op_mfc0_config0 (void)
1160 {
1161     T0 = env->CP0_Config0;
1162     RETURN();
1163 }
1164
1165 void op_mfc0_config1 (void)
1166 {
1167     T0 = env->CP0_Config1;
1168     RETURN();
1169 }
1170
1171 void op_mfc0_config2 (void)
1172 {
1173     T0 = env->CP0_Config2;
1174     RETURN();
1175 }
1176
1177 void op_mfc0_config3 (void)
1178 {
1179     T0 = env->CP0_Config3;
1180     RETURN();
1181 }
1182
1183 void op_mfc0_lladdr (void)
1184 {
1185     T0 = (int32_t)env->CP0_LLAddr >> 4;
1186     RETURN();
1187 }
1188
1189 void op_mfc0_watchlo0 (void)
1190 {
1191     T0 = (int32_t)env->CP0_WatchLo;
1192     RETURN();
1193 }
1194
1195 void op_mfc0_watchhi0 (void)
1196 {
1197     T0 = env->CP0_WatchHi;
1198     RETURN();
1199 }
1200
1201 void op_mfc0_xcontext (void)
1202 {
1203     T0 = (int32_t)env->CP0_XContext;
1204     RETURN();
1205 }
1206
1207 void op_mfc0_framemask (void)
1208 {
1209     T0 = env->CP0_Framemask;
1210     RETURN();
1211 }
1212
1213 void op_mfc0_debug (void)
1214 {
1215     T0 = env->CP0_Debug;
1216     if (env->hflags & MIPS_HFLAG_DM)
1217         T0 |= 1 << CP0DB_DM;
1218     RETURN();
1219 }
1220
1221 void op_mfc0_depc (void)
1222 {
1223     T0 = (int32_t)env->CP0_DEPC;
1224     RETURN();
1225 }
1226
1227 void op_mfc0_performance0 (void)
1228 {
1229     T0 = env->CP0_Performance0;
1230     RETURN();
1231 }
1232
1233 void op_mfc0_taglo (void)
1234 {
1235     T0 = env->CP0_TagLo;
1236     RETURN();
1237 }
1238
1239 void op_mfc0_datalo (void)
1240 {
1241     T0 = env->CP0_DataLo;
1242     RETURN();
1243 }
1244
1245 void op_mfc0_taghi (void)
1246 {
1247     T0 = env->CP0_TagHi;
1248     RETURN();
1249 }
1250
1251 void op_mfc0_datahi (void)
1252 {
1253     T0 = env->CP0_DataHi;
1254     RETURN();
1255 }
1256
1257 void op_mfc0_errorepc (void)
1258 {
1259     T0 = (int32_t)env->CP0_ErrorEPC;
1260     RETURN();
1261 }
1262
1263 void op_mfc0_desave (void)
1264 {
1265     T0 = env->CP0_DESAVE;
1266     RETURN();
1267 }
1268
1269 void op_mtc0_index (void)
1270 {
1271     env->CP0_Index = (env->CP0_Index & 0x80000000) | (T0 & (MIPS_TLB_NB - 1));
1272     RETURN();
1273 }
1274
1275 void op_mtc0_entrylo0 (void)
1276 {
1277     /* Large physaddr not implemented */
1278     /* 1k pages not implemented */
1279     env->CP0_EntryLo0 = (int32_t)T0 & 0x3FFFFFFF;
1280     RETURN();
1281 }
1282
1283 void op_mtc0_entrylo1 (void)
1284 {
1285     /* Large physaddr not implemented */
1286     /* 1k pages not implemented */
1287     env->CP0_EntryLo1 = (int32_t)T0 & 0x3FFFFFFF;
1288     RETURN();
1289 }
1290
1291 void op_mtc0_context (void)
1292 {
1293     env->CP0_Context = (env->CP0_Context & ~0x007FFFFF) | (T0 & 0x007FFFF0);
1294     RETURN();
1295 }
1296
1297 void op_mtc0_pagemask (void)
1298 {
1299     /* 1k pages not implemented */
1300     env->CP0_PageMask = T0 & 0x1FFFE000;
1301     RETURN();
1302 }
1303
1304 void op_mtc0_pagegrain (void)
1305 {
1306     /* SmartMIPS not implemented */
1307     /* Large physaddr not implemented */
1308     /* 1k pages not implemented */
1309     env->CP0_PageGrain = 0;
1310     RETURN();
1311 }
1312
1313 void op_mtc0_wired (void)
1314 {
1315     env->CP0_Wired = T0 & (MIPS_TLB_NB - 1);
1316     RETURN();
1317 }
1318
1319 void op_mtc0_hwrena (void)
1320 {
1321     env->CP0_HWREna = T0 & 0x0000000F;
1322     RETURN();
1323 }
1324
1325 void op_mtc0_count (void)
1326 {
1327     CALL_FROM_TB2(cpu_mips_store_count, env, T0);
1328     RETURN();
1329 }
1330
1331 void op_mtc0_entryhi (void)
1332 {
1333     target_ulong old, val;
1334
1335     /* 1k pages not implemented */
1336     /* Ignore MIPS64 TLB for now */
1337     val = (target_ulong)(int32_t)T0 & ~(target_ulong)0x1F00;
1338     old = env->CP0_EntryHi;
1339     env->CP0_EntryHi = val;
1340     /* If the ASID changes, flush qemu's TLB.  */
1341     if ((old & 0xFF) != (val & 0xFF))
1342         CALL_FROM_TB2(cpu_mips_tlb_flush, env, 1);
1343     RETURN();
1344 }
1345
1346 void op_mtc0_compare (void)
1347 {
1348     CALL_FROM_TB2(cpu_mips_store_compare, env, T0);
1349     RETURN();
1350 }
1351
1352 void op_mtc0_status (void)
1353 {
1354     uint32_t val, old;
1355
1356     val = (int32_t)T0 & 0xFA78FF01;
1357     old = env->CP0_Status;
1358     if (T0 & (1 << CP0St_UM))
1359         env->hflags |= MIPS_HFLAG_UM;
1360     else
1361         env->hflags &= ~MIPS_HFLAG_UM;
1362     if (T0 & (1 << CP0St_ERL))
1363         env->hflags |= MIPS_HFLAG_ERL;
1364     else
1365         env->hflags &= ~MIPS_HFLAG_ERL;
1366     if (T0 & (1 << CP0St_EXL))
1367         env->hflags |= MIPS_HFLAG_EXL;
1368     else
1369         env->hflags &= ~MIPS_HFLAG_EXL;
1370     env->CP0_Status = val;
1371     if (loglevel & CPU_LOG_TB_IN_ASM)
1372        CALL_FROM_TB2(do_mtc0_status_debug, old, val);
1373     CALL_FROM_TB1(cpu_mips_update_irq, env);
1374     RETURN();
1375 }
1376
1377 void op_mtc0_intctl (void)
1378 {
1379     /* vectored interrupts not implemented */
1380     env->CP0_IntCtl = 0;
1381     RETURN();
1382 }
1383
1384 void op_mtc0_srsctl (void)
1385 {
1386     /* shadow registers not implemented */
1387     env->CP0_SRSCtl = 0;
1388     RETURN();
1389 }
1390
1391 void op_mtc0_srsmap (void)
1392 {
1393     /* shadow registers not implemented */
1394     env->CP0_SRSMap = 0;
1395     RETURN();
1396 }
1397
1398 void op_mtc0_cause (void)
1399 {
1400     env->CP0_Cause = (env->CP0_Cause & 0xB000F87C) | (T0 & 0x00C00300);
1401
1402     /* Handle the software interrupt as an hardware one, as they
1403        are very similar */
1404     if (T0 & CP0Ca_IP_mask) {
1405         CALL_FROM_TB1(cpu_mips_update_irq, env);
1406     }
1407     RETURN();
1408 }
1409
1410 void op_mtc0_epc (void)
1411 {
1412     env->CP0_EPC = (int32_t)T0;
1413     RETURN();
1414 }
1415
1416 void op_mtc0_ebase (void)
1417 {
1418     /* vectored interrupts not implemented */
1419     /* Multi-CPU not implemented */
1420     env->CP0_EBase = 0x80000000 | (T0 & 0x3FFFF000);
1421     RETURN();
1422 }
1423
1424 void op_mtc0_config0 (void)
1425 {
1426 #if defined(MIPS_USES_R4K_TLB)
1427      /* Fixed mapping MMU not implemented */
1428     env->CP0_Config0 = (env->CP0_Config0 & 0x8017FF88) | (T0 & 0x00000001);
1429 #else
1430     env->CP0_Config0 = (env->CP0_Config0 & 0xFE17FF88) | (T0 & 0x00000001);
1431 #endif
1432     RETURN();
1433 }
1434
1435 void op_mtc0_config2 (void)
1436 {
1437     /* tertiary/secondary caches not implemented */
1438     env->CP0_Config2 = (env->CP0_Config2 & 0x8FFF0FFF);
1439     RETURN();
1440 }
1441
1442 void op_mtc0_watchlo0 (void)
1443 {
1444     env->CP0_WatchLo = (int32_t)T0;
1445     RETURN();
1446 }
1447
1448 void op_mtc0_watchhi0 (void)
1449 {
1450     env->CP0_WatchHi = T0 & 0x40FF0FF8;
1451     RETURN();
1452 }
1453
1454 void op_mtc0_xcontext (void)
1455 {
1456     env->CP0_XContext = (int32_t)T0; /* XXX */
1457     RETURN();
1458 }
1459
1460 void op_mtc0_framemask (void)
1461 {
1462     env->CP0_Framemask = T0; /* XXX */
1463     RETURN();
1464 }
1465
1466 void op_mtc0_debug (void)
1467 {
1468     env->CP0_Debug = (env->CP0_Debug & 0x8C03FC1F) | (T0 & 0x13300120);
1469     if (T0 & (1 << CP0DB_DM))
1470         env->hflags |= MIPS_HFLAG_DM;
1471     else
1472         env->hflags &= ~MIPS_HFLAG_DM;
1473     RETURN();
1474 }
1475
1476 void op_mtc0_depc (void)
1477 {
1478     env->CP0_DEPC = (int32_t)T0;
1479     RETURN();
1480 }
1481
1482 void op_mtc0_performance0 (void)
1483 {
1484     env->CP0_Performance0 = T0; /* XXX */
1485     RETURN();
1486 }
1487
1488 void op_mtc0_taglo (void)
1489 {
1490     env->CP0_TagLo = T0 & 0xFFFFFCF6;
1491     RETURN();
1492 }
1493
1494 void op_mtc0_datalo (void)
1495 {
1496     env->CP0_DataLo = T0; /* XXX */
1497     RETURN();
1498 }
1499
1500 void op_mtc0_taghi (void)
1501 {
1502     env->CP0_TagHi = T0; /* XXX */
1503     RETURN();
1504 }
1505
1506 void op_mtc0_datahi (void)
1507 {
1508     env->CP0_DataHi = T0; /* XXX */
1509     RETURN();
1510 }
1511
1512 void op_mtc0_errorepc (void)
1513 {
1514     env->CP0_ErrorEPC = (int32_t)T0;
1515     RETURN();
1516 }
1517
1518 void op_mtc0_desave (void)
1519 {
1520     env->CP0_DESAVE = T0;
1521     RETURN();
1522 }
1523
1524 void op_dmfc0_entrylo0 (void)
1525 {
1526     T0 = env->CP0_EntryLo0;
1527     RETURN();
1528 }
1529
1530 void op_dmfc0_entrylo1 (void)
1531 {
1532     T0 = env->CP0_EntryLo1;
1533     RETURN();
1534 }
1535
1536 void op_dmfc0_context (void)
1537 {
1538     T0 = env->CP0_Context;
1539     RETURN();
1540 }
1541
1542 void op_dmfc0_badvaddr (void)
1543 {
1544     T0 = env->CP0_BadVAddr;
1545     RETURN();
1546 }
1547
1548 void op_dmfc0_entryhi (void)
1549 {
1550     T0 = env->CP0_EntryHi;
1551     RETURN();
1552 }
1553
1554 void op_dmfc0_epc (void)
1555 {
1556     T0 = env->CP0_EPC;
1557     RETURN();
1558 }
1559
1560 void op_dmfc0_lladdr (void)
1561 {
1562     T0 = env->CP0_LLAddr >> 4;
1563     RETURN();
1564 }
1565
1566 void op_dmfc0_watchlo0 (void)
1567 {
1568     T0 = env->CP0_WatchLo;
1569     RETURN();
1570 }
1571
1572 void op_dmfc0_xcontext (void)
1573 {
1574     T0 = env->CP0_XContext;
1575     RETURN();
1576 }
1577
1578 void op_dmfc0_depc (void)
1579 {
1580     T0 = env->CP0_DEPC;
1581     RETURN();
1582 }
1583
1584 void op_dmfc0_errorepc (void)
1585 {
1586     T0 = env->CP0_ErrorEPC;
1587     RETURN();
1588 }
1589
1590 void op_dmtc0_entrylo0 (void)
1591 {
1592     /* Large physaddr not implemented */
1593     /* 1k pages not implemented */
1594     env->CP0_EntryLo0 = T0 & 0x3FFFFFFF;
1595     RETURN();
1596 }
1597
1598 void op_dmtc0_entrylo1 (void)
1599 {
1600     /* Large physaddr not implemented */
1601     /* 1k pages not implemented */
1602     env->CP0_EntryLo1 = T0 & 0x3FFFFFFF;
1603     RETURN();
1604 }
1605
1606 void op_dmtc0_context (void)
1607 {
1608     env->CP0_Context = (env->CP0_Context & ~0x007FFFFF) | (T0 & 0x007FFFF0);
1609     RETURN();
1610 }
1611
1612 void op_dmtc0_epc (void)
1613 {
1614     env->CP0_EPC = T0;
1615     RETURN();
1616 }
1617
1618 void op_dmtc0_watchlo0 (void)
1619 {
1620     env->CP0_WatchLo = T0;
1621     RETURN();
1622 }
1623
1624 void op_dmtc0_xcontext (void)
1625 {
1626     env->CP0_XContext = T0; /* XXX */
1627     RETURN();
1628 }
1629
1630 void op_dmtc0_depc (void)
1631 {
1632     env->CP0_DEPC = T0;
1633     RETURN();
1634 }
1635
1636 void op_dmtc0_errorepc (void)
1637 {
1638     env->CP0_ErrorEPC = T0;
1639     RETURN();
1640 }
1641
1642 #if 0
1643 # define DEBUG_FPU_STATE() CALL_FROM_TB1(dump_fpu, env)
1644 #else
1645 # define DEBUG_FPU_STATE() do { } while(0)
1646 #endif
1647
1648 void op_cp1_enabled(void)
1649 {
1650     if (!(env->CP0_Status & (1 << CP0St_CU1))) {
1651         CALL_FROM_TB2(do_raise_exception_err, EXCP_CpU, 1);
1652     }
1653     RETURN();
1654 }
1655
1656 /* CP1 functions */
1657 void op_cfc1 (void)
1658 {
1659     if (T1 == 0) {
1660         T0 = env->fcr0;
1661     }
1662     else {
1663         /* fetch fcr31, masking unused bits */
1664         T0 = env->fcr31 & 0x0183FFFF;
1665     }
1666     DEBUG_FPU_STATE();
1667     RETURN();
1668 }
1669
1670 /* convert MIPS rounding mode in FCR31 to IEEE library */
1671 unsigned int ieee_rm[] = {
1672     float_round_nearest_even,
1673     float_round_to_zero,
1674     float_round_up,
1675     float_round_down
1676 };
1677
1678 #define RESTORE_ROUNDING_MODE \
1679     set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
1680
1681 void op_ctc1 (void)
1682 {
1683     if (T1 == 0) {
1684         /* XXX should this throw an exception?
1685          * don't write to FCR0.
1686          * env->fcr0 = T0;
1687          */
1688     }
1689     else {
1690         /* store new fcr31, masking unused bits */
1691         env->fcr31 = T0 & 0x0183FFFF;
1692
1693         /* set rounding mode */
1694         RESTORE_ROUNDING_MODE;
1695
1696 #ifndef CONFIG_SOFTFLOAT
1697         /* no floating point exception for native float */
1698         SET_FP_ENABLE(env->fcr31, 0);
1699 #endif
1700     }
1701     DEBUG_FPU_STATE();
1702     RETURN();
1703 }
1704
1705 void op_mfc1 (void)
1706 {
1707     T0 = WT0;
1708     DEBUG_FPU_STATE();
1709     RETURN();
1710 }
1711
1712 void op_mtc1 (void)
1713 {
1714     WT0 = T0;
1715     DEBUG_FPU_STATE();
1716     RETURN();
1717 }
1718
1719 /* Float support.
1720    Single precition routines have a "s" suffix, double precision a
1721    "d" suffix.  */
1722
1723 #define FLOAT_OP(name, p) void OPPROTO op_float_##name##_##p(void)
1724
1725 FLOAT_OP(cvtd, s)
1726 {
1727     FDT2 = float32_to_float64(FST0, &env->fp_status);
1728     DEBUG_FPU_STATE();
1729     RETURN();
1730 }
1731 FLOAT_OP(cvtd, w)
1732 {
1733     FDT2 = int32_to_float64(WT0, &env->fp_status);
1734     DEBUG_FPU_STATE();
1735     RETURN();
1736 }
1737 FLOAT_OP(cvts, d)
1738 {
1739     FST2 = float64_to_float32(FDT0, &env->fp_status);
1740     DEBUG_FPU_STATE();
1741     RETURN();
1742 }
1743 FLOAT_OP(cvts, w)
1744 {
1745     FST2 = int32_to_float32(WT0, &env->fp_status);
1746     DEBUG_FPU_STATE();
1747     RETURN();
1748 }
1749 FLOAT_OP(cvtw, s)
1750 {
1751     WT2 = float32_to_int32(FST0, &env->fp_status);
1752     DEBUG_FPU_STATE();
1753     RETURN();
1754 }
1755 FLOAT_OP(cvtw, d)
1756 {
1757     WT2 = float64_to_int32(FDT0, &env->fp_status);
1758     DEBUG_FPU_STATE();
1759     RETURN();
1760 }
1761
1762 FLOAT_OP(roundw, d)
1763 {
1764     set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
1765     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1766     RESTORE_ROUNDING_MODE;
1767
1768     DEBUG_FPU_STATE();
1769     RETURN();
1770 }
1771 FLOAT_OP(roundw, s)
1772 {
1773     set_float_rounding_mode(float_round_nearest_even, &env->fp_status);
1774     WT2 = float32_round_to_int(FST0, &env->fp_status);
1775     RESTORE_ROUNDING_MODE;
1776     DEBUG_FPU_STATE();
1777     RETURN();
1778 }
1779
1780 FLOAT_OP(truncw, d)
1781 {
1782     WT2 = float64_to_int32_round_to_zero(FDT0, &env->fp_status);
1783     DEBUG_FPU_STATE();
1784     RETURN();
1785 }
1786 FLOAT_OP(truncw, s)
1787 {
1788     WT2 = float32_to_int32_round_to_zero(FST0, &env->fp_status);
1789     DEBUG_FPU_STATE();
1790     RETURN();
1791 }
1792
1793 FLOAT_OP(ceilw, d)
1794 {
1795     set_float_rounding_mode(float_round_up, &env->fp_status);
1796     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1797     RESTORE_ROUNDING_MODE;
1798
1799     DEBUG_FPU_STATE();
1800     RETURN();
1801 }
1802 FLOAT_OP(ceilw, s)
1803 {
1804     set_float_rounding_mode(float_round_up, &env->fp_status);
1805     WT2 = float32_round_to_int(FST0, &env->fp_status);
1806     RESTORE_ROUNDING_MODE;
1807     DEBUG_FPU_STATE();
1808     RETURN();
1809 }
1810
1811 FLOAT_OP(floorw, d)
1812 {
1813     set_float_rounding_mode(float_round_down, &env->fp_status);
1814     WT2 = float64_round_to_int(FDT0, &env->fp_status);
1815     RESTORE_ROUNDING_MODE;
1816
1817     DEBUG_FPU_STATE();
1818     RETURN();
1819 }
1820 FLOAT_OP(floorw, s)
1821 {
1822     set_float_rounding_mode(float_round_down, &env->fp_status);
1823     WT2 = float32_round_to_int(FST0, &env->fp_status);
1824     RESTORE_ROUNDING_MODE;
1825     DEBUG_FPU_STATE();
1826     RETURN();
1827 }
1828
1829 /* binary operations */
1830 #define FLOAT_BINOP(name) \
1831 FLOAT_OP(name, d)         \
1832 {                         \
1833     FDT2 = float64_ ## name (FDT0, FDT1, &env->fp_status);    \
1834     DEBUG_FPU_STATE();    \
1835 }                         \
1836 FLOAT_OP(name, s)         \
1837 {                         \
1838     FST2 = float32_ ## name (FST0, FST1, &env->fp_status);    \
1839     DEBUG_FPU_STATE();    \
1840 }
1841 FLOAT_BINOP(add)
1842 FLOAT_BINOP(sub)
1843 FLOAT_BINOP(mul)
1844 FLOAT_BINOP(div)
1845 #undef FLOAT_BINOP
1846
1847 /* unary operations, modifying fp status  */
1848 #define FLOAT_UNOP(name)  \
1849 FLOAT_OP(name, d)         \
1850 {                         \
1851     FDT2 = float64_ ## name(FDT0, &env->fp_status);   \
1852     DEBUG_FPU_STATE();    \
1853 }                         \
1854 FLOAT_OP(name, s)         \
1855 {                         \
1856     FST2 = float32_ ## name(FST0, &env->fp_status);   \
1857     DEBUG_FPU_STATE();    \
1858 }
1859 FLOAT_UNOP(sqrt)
1860 #undef FLOAT_UNOP
1861
1862 /* unary operations, not modifying fp status  */
1863 #define FLOAT_UNOP(name)  \
1864 FLOAT_OP(name, d)         \
1865 {                         \
1866     FDT2 = float64_ ## name(FDT0);   \
1867     DEBUG_FPU_STATE();    \
1868 }                         \
1869 FLOAT_OP(name, s)         \
1870 {                         \
1871     FST2 = float32_ ## name(FST0);   \
1872     DEBUG_FPU_STATE();    \
1873 }
1874 FLOAT_UNOP(abs)
1875 FLOAT_UNOP(chs)
1876 #undef FLOAT_UNOP
1877
1878 FLOAT_OP(mov, d)
1879 {
1880     FDT2 = FDT0;
1881     DEBUG_FPU_STATE();
1882     RETURN();
1883 }
1884 FLOAT_OP(mov, s)
1885 {
1886     FST2 = FST0;
1887     DEBUG_FPU_STATE();
1888     RETURN();
1889 }
1890
1891 #ifdef CONFIG_SOFTFLOAT
1892 #define clear_invalid() do {                                \
1893     int flags = get_float_exception_flags(&env->fp_status); \
1894     flags &= ~float_flag_invalid;                           \
1895     set_float_exception_flags(flags, &env->fp_status);      \
1896 } while(0)
1897 #else
1898 #define clear_invalid() do { } while(0)
1899 #endif
1900
1901 extern void dump_fpu_s(CPUState *env);
1902
1903 #define FOP_COND(fmt, op, sig, cond)           \
1904 void op_cmp_ ## fmt ## _ ## op (void)          \
1905 {                                              \
1906     if (cond)                                  \
1907         SET_FP_COND(env->fcr31);               \
1908     else                                       \
1909         CLEAR_FP_COND(env->fcr31);             \
1910     if (!sig)                                  \
1911         clear_invalid();                       \
1912     /*CALL_FROM_TB1(dump_fpu_s, env);*/ \
1913     DEBUG_FPU_STATE();                         \
1914     RETURN();                                  \
1915 }
1916
1917 int float64_is_unordered(float64 a, float64 b STATUS_PARAM)
1918 {
1919     if (float64_is_nan(a) || float64_is_nan(b)) {
1920         float_raise(float_flag_invalid, status);
1921         return 1;
1922     }
1923     else {
1924         return 0;
1925     }
1926 }
1927
1928 FOP_COND(d, f,   0,                                                      0)
1929 FOP_COND(d, un,  0, float64_is_unordered(FDT1, FDT0, &env->fp_status))
1930 FOP_COND(d, eq,  0,                                                      float64_eq(FDT0, FDT1, &env->fp_status))
1931 FOP_COND(d, ueq, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_eq(FDT0, FDT1, &env->fp_status))
1932 FOP_COND(d, olt, 0,                                                      float64_lt(FDT0, FDT1, &env->fp_status))
1933 FOP_COND(d, ult, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_lt(FDT0, FDT1, &env->fp_status))
1934 FOP_COND(d, ole, 0,                                                      float64_le(FDT0, FDT1, &env->fp_status))
1935 FOP_COND(d, ule, 0, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_le(FDT0, FDT1, &env->fp_status))
1936 /* NOTE: the comma operator will make "cond" to eval to false,
1937  * but float*_is_unordered() is still called
1938  */
1939 FOP_COND(d, sf,  1,                                                      (float64_is_unordered(FDT0, FDT1, &env->fp_status), 0))
1940 FOP_COND(d, ngle,1, float64_is_unordered(FDT1, FDT0, &env->fp_status))
1941 FOP_COND(d, seq, 1,                                                      float64_eq(FDT0, FDT1, &env->fp_status))
1942 FOP_COND(d, ngl, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_eq(FDT0, FDT1, &env->fp_status))
1943 FOP_COND(d, lt,  1,                                                      float64_lt(FDT0, FDT1, &env->fp_status))
1944 FOP_COND(d, nge, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_lt(FDT0, FDT1, &env->fp_status))
1945 FOP_COND(d, le,  1,                                                      float64_le(FDT0, FDT1, &env->fp_status))
1946 FOP_COND(d, ngt, 1, float64_is_unordered(FDT1, FDT0, &env->fp_status) || float64_le(FDT0, FDT1, &env->fp_status))
1947
1948 flag float32_is_unordered(float32 a, float32 b STATUS_PARAM)
1949 {
1950     extern flag float32_is_nan( float32 a );
1951     if (float32_is_nan(a) || float32_is_nan(b)) {
1952         float_raise(float_flag_invalid, status);
1953         return 1;
1954     }
1955     else {
1956         return 0;
1957     }
1958 }
1959
1960 /* NOTE: the comma operator will make "cond" to eval to false,
1961  * but float*_is_unordered() is still called
1962  */
1963 FOP_COND(s, f,   0,                                                      0)
1964 FOP_COND(s, un,  0, float32_is_unordered(FST1, FST0, &env->fp_status))
1965 FOP_COND(s, eq,  0,                                                      float32_eq(FST0, FST1, &env->fp_status))
1966 FOP_COND(s, ueq, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_eq(FST0, FST1, &env->fp_status))
1967 FOP_COND(s, olt, 0,                                                      float32_lt(FST0, FST1, &env->fp_status))
1968 FOP_COND(s, ult, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_lt(FST0, FST1, &env->fp_status))
1969 FOP_COND(s, ole, 0,                                                      float32_le(FST0, FST1, &env->fp_status))
1970 FOP_COND(s, ule, 0, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_le(FST0, FST1, &env->fp_status))
1971 /* NOTE: the comma operator will make "cond" to eval to false,
1972  * but float*_is_unordered() is still called
1973  */
1974 FOP_COND(s, sf,  1,                                                      (float32_is_unordered(FST0, FST1, &env->fp_status), 0))
1975 FOP_COND(s, ngle,1, float32_is_unordered(FST1, FST0, &env->fp_status))
1976 FOP_COND(s, seq, 1,                                                      float32_eq(FST0, FST1, &env->fp_status))
1977 FOP_COND(s, ngl, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_eq(FST0, FST1, &env->fp_status))
1978 FOP_COND(s, lt,  1,                                                      float32_lt(FST0, FST1, &env->fp_status))
1979 FOP_COND(s, nge, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_lt(FST0, FST1, &env->fp_status))
1980 FOP_COND(s, le,  1,                                                      float32_le(FST0, FST1, &env->fp_status))
1981 FOP_COND(s, ngt, 1, float32_is_unordered(FST1, FST0, &env->fp_status) || float32_le(FST0, FST1, &env->fp_status))
1982
1983 void op_bc1f (void)
1984 {
1985     T0 = ! IS_FP_COND_SET(env->fcr31);
1986     DEBUG_FPU_STATE();
1987     RETURN();
1988 }
1989
1990 void op_bc1t (void)
1991 {
1992     T0 = IS_FP_COND_SET(env->fcr31);
1993     DEBUG_FPU_STATE();
1994     RETURN();
1995 }
1996
1997 #if defined(MIPS_USES_R4K_TLB)
1998 void op_tlbwi (void)
1999 {
2000     CALL_FROM_TB0(do_tlbwi);
2001     RETURN();
2002 }
2003
2004 void op_tlbwr (void)
2005 {
2006     CALL_FROM_TB0(do_tlbwr);
2007     RETURN();
2008 }
2009
2010 void op_tlbp (void)
2011 {
2012     CALL_FROM_TB0(do_tlbp);
2013     RETURN();
2014 }
2015
2016 void op_tlbr (void)
2017 {
2018     CALL_FROM_TB0(do_tlbr);
2019     RETURN();
2020 }
2021 #endif
2022
2023 /* Specials */
2024 #if defined (CONFIG_USER_ONLY)
2025 void op_tls_value (void)
2026 {
2027   T0 = env->tls_value;
2028 }
2029 #endif
2030
2031 void op_pmon (void)
2032 {
2033     CALL_FROM_TB1(do_pmon, PARAM1);
2034     RETURN();
2035 }
2036
2037 void op_di (void)
2038 {
2039     T0 = env->CP0_Status;
2040     env->CP0_Status = T0 & ~(1 << CP0St_IE);
2041     CALL_FROM_TB1(cpu_mips_update_irq, env);
2042     RETURN();
2043 }
2044
2045 void op_ei (void)
2046 {
2047     T0 = env->CP0_Status;
2048     env->CP0_Status = T0 | (1 << CP0St_IE);
2049     CALL_FROM_TB1(cpu_mips_update_irq, env);
2050     RETURN();
2051 }
2052
2053 void op_trap (void)
2054 {
2055     if (T0) {
2056         CALL_FROM_TB1(do_raise_exception_direct, EXCP_TRAP);
2057     }
2058     RETURN();
2059 }
2060
2061 void op_debug (void)
2062 {
2063     CALL_FROM_TB1(do_raise_exception, EXCP_DEBUG);
2064     RETURN();
2065 }
2066
2067 void op_set_lladdr (void)
2068 {
2069     env->CP0_LLAddr = T2;
2070     RETURN();
2071 }
2072
2073 void debug_eret (void);
2074 void op_eret (void)
2075 {
2076     CALL_FROM_TB0(debug_eret);
2077     if (env->hflags & MIPS_HFLAG_ERL) {
2078         env->PC = env->CP0_ErrorEPC;
2079         env->hflags &= ~MIPS_HFLAG_ERL;
2080         env->CP0_Status &= ~(1 << CP0St_ERL);
2081     } else {
2082         env->PC = env->CP0_EPC;
2083         env->hflags &= ~MIPS_HFLAG_EXL;
2084         env->CP0_Status &= ~(1 << CP0St_EXL);
2085     }
2086     env->CP0_LLAddr = 1;
2087     RETURN();
2088 }
2089
2090 void op_deret (void)
2091 {
2092     CALL_FROM_TB0(debug_eret);
2093     env->PC = env->CP0_DEPC;
2094     RETURN();
2095 }
2096
2097 void op_rdhwr_cpunum(void)
2098 {
2099     if (env->CP0_HWREna & (1 << 0))
2100        T0 = env->CP0_EBase & 0x2ff;
2101     else
2102        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2103     RETURN();
2104 }
2105
2106 void op_rdhwr_synci_step(void)
2107 {
2108     if (env->CP0_HWREna & (1 << 1))
2109        T0 = env->SYNCI_Step;
2110     else
2111        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2112     RETURN();
2113 }
2114
2115 void op_rdhwr_cc(void)
2116 {
2117     if (env->CP0_HWREna & (1 << 2))
2118        T0 = env->CP0_Count;
2119     else
2120        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2121     RETURN();
2122 }
2123
2124 void op_rdhwr_ccres(void)
2125 {
2126     if (env->CP0_HWREna & (1 << 3))
2127        T0 = env->CCRes;
2128     else
2129        CALL_FROM_TB1(do_raise_exception_direct, EXCP_RI);
2130     RETURN();
2131 }
2132
2133 void op_save_state (void)
2134 {
2135     env->hflags = PARAM1;
2136     RETURN();
2137 }
2138
2139 void op_save_pc (void)
2140 {
2141     env->PC = PARAM1;
2142     RETURN();
2143 }
2144
2145 void op_raise_exception (void)
2146 {
2147     CALL_FROM_TB1(do_raise_exception, PARAM1);
2148     RETURN();
2149 }
2150
2151 void op_raise_exception_err (void)
2152 {
2153     CALL_FROM_TB2(do_raise_exception_err, PARAM1, PARAM2);
2154     RETURN();
2155 }
2156
2157 void op_exit_tb (void)
2158 {
2159     EXIT_TB();
2160     RETURN();
2161 }
2162
2163 void op_wait (void)
2164 {
2165     env->halted = 1;
2166     CALL_FROM_TB1(do_raise_exception, EXCP_HLT);
2167     RETURN();
2168 }
2169
2170 /* Bitfield operations. */
2171 void op_ext(void)
2172 {
2173     unsigned int pos = PARAM1;
2174     unsigned int size = PARAM2;
2175
2176     T0 = ((uint32_t)T1 >> pos) & ((1 << size) - 1);
2177     RETURN();
2178 }
2179
2180 void op_ins(void)
2181 {
2182     unsigned int pos = PARAM1;
2183     unsigned int size = PARAM2;
2184     target_ulong mask = ((1 << size) - 1) << pos;
2185
2186     T0 = (T2 & ~mask) | (((uint32_t)T1 << pos) & mask);
2187     RETURN();
2188 }
2189
2190 void op_wsbh(void)
2191 {
2192     T0 = ((T1 << 8) & ~0x00FF00FF) | ((T1 >> 8) & 0x00FF00FF);
2193     RETURN();
2194 }
2195
2196 #ifdef MIPS_HAS_MIPS64
2197 void op_dext(void)
2198 {
2199     unsigned int pos = PARAM1;
2200     unsigned int size = PARAM2;
2201
2202     T0 = (T1 >> pos) & ((1 << size) - 1);
2203     RETURN();
2204 }
2205
2206 void op_dins(void)
2207 {
2208     unsigned int pos = PARAM1;
2209     unsigned int size = PARAM2;
2210     target_ulong mask = ((1 << size) - 1) << pos;
2211
2212     T0 = (T2 & ~mask) | ((T1 << pos) & mask);
2213     RETURN();
2214 }
2215
2216 void op_dsbh(void)
2217 {
2218     T0 = ((T1 << 8) & ~0x00FF00FF00FF00FFULL) | ((T1 >> 8) & 0x00FF00FF00FF00FFULL);
2219     RETURN();
2220 }
2221
2222 void op_dshd(void)
2223 {
2224     T0 = ((T1 << 16) & ~0x0000FFFF0000FFFFULL) | ((T1 >> 16) & 0x0000FFFF0000FFFFULL);
2225     RETURN();
2226 }
2227 #endif
2228
2229 void op_seb(void)
2230 {
2231     T0 = ((T1 & 0xFF) ^ 0x80) - 0x80;
2232     RETURN();
2233 }
2234
2235 void op_seh(void)
2236 {
2237     T0 = ((T1 & 0xFFFF) ^ 0x8000) - 0x8000;
2238     RETURN();
2239 }