sim/mips/mips.igen

   1 // -*- C -*-
   2 //
   3 //    <insn> ::=
   4 //        <insn-word> { "+" <insn-word> }
   5 //        ":" <format-name>
   6 //        ":" <filter-flags>
   7 //        ":" <options>
   8 //        ":" <name>
   9 //        <nl>
  10 //        { <insn-model> }
  11 //        { <insn-mnemonic> }
  12 //        <code-block>
  13 //
  14
  15
  16 // IGEN config - mips16
  17 // :option:16::insn-bit-size:16
  18 // :option:16::hi-bit-nr:15
  19 :option:16::insn-specifying-widths:true
  20 :option:16::gen-delayed-branch:false
  21
  22 // IGEN config - mips32/64..
  23 // :option:32::insn-bit-size:32
  24 // :option:32::hi-bit-nr:31
  25 :option:32::insn-specifying-widths:true
  26 :option:32::gen-delayed-branch:false
  27
  28
  29 // Generate separate simulators for each target
  30 // :option:::multi-sim:true
  31
  32
  33 // Models known by this simulator are defined below.
  34 //
  35 // When placing models in the instruction descriptions, please place
  36 // them one per line, in the order given here.
  37
  38 //  MIPS ISAs:
  39 //
  40 //  Instructions and related functions for these models are included in
  41 //  this file.
  42 :model:::mipsI:mips3000:
  43 :model:::mipsII:mips6000:
  44 :model:::mipsIII:mips4000:
  45 :model:::mipsIV:mips8000:
  46 :model:::mipsV:mipsisaV:
  47 :model:::mips32:mipsisa32:
  48 :model:::mips32r2:mipsisa32r2:
  49 :model:::mips64:mipsisa64:
  50 :model:::mips64r2:mipsisa64r2:
  51
  52 //  Vendor ISAs:
  53 //
  54 //  Standard MIPS ISA instructions used for these models are listed here,
  55 //  as are functions needed by those standard instructions.  Instructions
  56 //  which are model-dependent and which are not in the standard MIPS ISAs
  57 //  (or which pre-date or use different encodings than the standard
  58 //  instructions) are (for the most part) in separate .igen files.
  59 :model:::vr4100:mips4100:               // vr.igen
  60 :model:::vr4120:mips4120:
  61 :model:::vr5000:mips5000:
  62 :model:::vr5400:mips5400:
  63 :model:::vr5500:mips5500:
  64 :model:::r3900:mips3900:                // tx.igen
  65
  66 //  MIPS Application Specific Extensions (ASEs)
  67 //
  68 //  Instructions for the ASEs are in separate .igen files.
  69 //  ASEs add instructions on to a base ISA.
  70 :model:::mips16:mips16:                 // m16.igen (and m16.dc)
  71 :model:::mips16e:mips16e:               // m16e.igen
  72 :model:::mips3d:mips3d:                 // mips3d.igen
  73 :model:::mdmx:mdmx:                     // mdmx.igen
  74 :model:::dsp:dsp:                       // dsp.igen
  75 :model:::dsp2:dsp2:                     // dsp2.igen
  76 :model:::smartmips:smartmips:           // smartmips.igen
  77
  78 //  Vendor Extensions
  79 //
  80 //  Instructions specific to these extensions are in separate .igen files.
  81 //  Extensions add instructions on to a base ISA.
  82 :model:::sb1:sb1:                       // sb1.igen
  83
  84
  85 // Pseudo instructions known by IGEN
  86 :internal::::illegal:
  87 {
  88   SignalException (ReservedInstruction, 0);
  89 }
  90
  91
  92 // Pseudo instructions known by interp.c
  93 // For grep - RSVD_INSTRUCTION, RSVD_INSTRUCTION_MASK
  94 000000,5.*,5.*,5.*,5.OP,000101:SPECIAL:32::RSVD
  95 "rsvd <OP>"
  96 {
  97   SignalException (ReservedInstruction, instruction_0);
  98 }
  99
 100
 101
 102 // Helper:
 103 //
 104 // Simulate a 32 bit delayslot instruction
 105 //
 106
 107 :function:::address_word:delayslot32:address_word target
 108 {
 109   instruction_word delay_insn;
 110   sim_events_slip (SD, 1);
 111   DSPC = CIA;
 112   CIA = CIA + 4; /* NOTE not mips16 */
 113   STATE |= simDELAYSLOT;
 114   delay_insn = IMEM32 (CIA); /* NOTE not mips16 */
 115   ENGINE_ISSUE_PREFIX_HOOK();
 116   idecode_issue (CPU_, delay_insn, (CIA));
 117   STATE &= ~simDELAYSLOT;
 118   return target;
 119 }
 120
 121 :function:::address_word:nullify_next_insn32:
 122 {
 123   sim_events_slip (SD, 1);
 124   dotrace (SD, CPU, tracefh, 2, CIA + 4, 4, "load instruction");
 125   return CIA + 8;
 126 }
 127
 128
 129 // Helper:
 130 //
 131 // Calculate an effective address given a base and an offset.
 132 //
 133
 134 :function:::address_word:loadstore_ea:address_word base, address_word offset
 135 *mipsI:
 136 *mipsII:
 137 *mipsIII:
 138 *mipsIV:
 139 *mipsV:
 140 *mips32:
 141 *mips32r2:
 142 *vr4100:
 143 *vr5000:
 144 *r3900:
 145 {
 146   return base + offset;
 147 }
 148
 149 :function:::address_word:loadstore_ea:address_word base, address_word offset
 150 *mips64:
 151 *mips64r2:
 152 {
 153 #if 0 /* XXX FIXME: enable this only after some additional testing.  */
 154   /* If in user mode and UX is not set, use 32-bit compatibility effective
 155      address computations as defined in the MIPS64 Architecture for
 156      Programmers Volume III, Revision 0.95, section 4.9.  */
 157   if ((SR & (status_KSU_mask|status_EXL|status_ERL|status_UX))
 158       == (ksu_user << status_KSU_shift))
 159     return (address_word)((signed32)base + (signed32)offset);
 160 #endif
 161   return base + offset;
 162 }
 163
 164
 165 // Helper:
 166 //
 167 // Check that a 32-bit register value is properly sign-extended.
 168 // (See NotWordValue in ISA spec.)
 169 //
 170
 171 :function:::int:not_word_value:unsigned_word value
 172 *mipsI:
 173 *mipsII:
 174 *mipsIII:
 175 *mipsIV:
 176 *mipsV:
 177 *vr4100:
 178 *vr5000:
 179 *r3900:
 180 *mips32:
 181 *mips32r2:
 182 *mips64:
 183 *mips64r2:
 184 {
 185 #if WITH_TARGET_WORD_BITSIZE == 64
 186   return value != (((value & 0xffffffff) ^ 0x80000000) - 0x80000000);
 187 #else
 188   return 0;
 189 #endif
 190 }
 191
 192 // Helper:
 193 //
 194 // Handle UNPREDICTABLE operation behaviour.  The goal here is to prevent
 195 // theoretically portable code which invokes non-portable behaviour from
 196 // running with no indication of the portability issue.
 197 // (See definition of UNPREDICTABLE in ISA spec.)
 198 //
 199
 200 :function:::void:unpredictable:
 201 *mipsI:
 202 *mipsII:
 203 *mipsIII:
 204 *mipsIV:
 205 *mipsV:
 206 *vr4100:
 207 *vr5000:
 208 *r3900:
 209 {
 210 }
 211
 212 :function:::void:unpredictable:
 213 *mips32:
 214 *mips32r2:
 215 *mips64:
 216 *mips64r2:
 217 {
 218   unpredictable_action (CPU, CIA);
 219 }
 220
 221
 222 // Helpers:
 223 //
 224 // Check that an access to a HI/LO register meets timing requirements
 225 //
 226 // In all MIPS ISAs,
 227 //
 228 //      OP {HI and LO} followed by MT{LO or HI} (and not MT{HI or LO})
 229 //      makes subsequent MF{HI or LO} UNPREDICTABLE. (1)
 230 //
 231 // The following restrictions exist for MIPS I - MIPS III:
 232 //
 233 //      MF{HI or LO} followed by MT{HI or LO} w/ less than 2 instructions
 234 //      in between makes MF UNPREDICTABLE. (2)
 235 //
 236 //      MF{HI or LO} followed by OP {HI and LO} w/ less than 2 instructions
 237 //      in between makes MF UNPREDICTABLE. (3)
 238 //
 239 // On the r3900, restriction (2) is not present, and restriction (3) is not
 240 // present for multiplication.
 241 //
 242 // Unfortunately, there seems to be some confusion about whether the last
 243 // two restrictions should apply to "MIPS IV" as well.  One edition of
 244 // the MIPS IV ISA says they do, but references in later ISA documents
 245 // suggest they don't.
 246 //
 247 // In reality, some MIPS IV parts, such as the VR5000 and VR5400, do have
 248 // these restrictions, while others, like the VR5500, don't.  To accomodate
 249 // such differences, the MIPS IV and MIPS V version of these helper functions
 250 // use auxillary routines to determine whether the restriction applies.
 251
 252 // check_mf_cycles:
 253 //
 254 // Helper used by check_mt_hilo, check_mult_hilo, and check_div_hilo
 255 // to check for restrictions (2) and (3) above.
 256 //
 257 :function:::int:check_mf_cycles:hilo_history *history, signed64 time, const char *new
 258 {
 259   if (history->mf.timestamp + 3 > time)
 260     {
 261       sim_engine_abort (SD, CPU, CIA, "HILO: %s: %s at 0x%08lx too close to MF at 0x%08lx\n",
 262                         itable[MY_INDEX].name,
 263                         new, (long) CIA,
 264                         (long) history->mf.cia);
 265       return 0;
 266     }
 267   return 1;
 268 }
 269
 270
 271 // check_mt_hilo:
 272 //
 273 // Check for restriction (2) above (for ISAs/processors that have it),
 274 // and record timestamps for restriction (1) above.
 275 //
 276 :function:::int:check_mt_hilo:hilo_history *history
 277 *mipsI:
 278 *mipsII:
 279 *mipsIII:
 280 *vr4100:
 281 *vr5000:
 282 {
 283   signed64 time = sim_events_time (SD);
 284   int ok = check_mf_cycles (SD_, history, time, "MT");
 285   history->mt.timestamp = time;
 286   history->mt.cia = CIA;
 287   return ok;
 288 }
 289
 290 :function:::int:check_mt_hilo:hilo_history *history
 291 *mipsIV:
 292 *mipsV:
 293 {
 294   signed64 time = sim_events_time (SD);
 295   int ok = (! MIPS_MACH_HAS_MT_HILO_HAZARD (SD)
 296             || check_mf_cycles (SD_, history, time, "MT"));
 297   history->mt.timestamp = time;
 298   history->mt.cia = CIA;
 299   return ok;
 300 }
 301
 302 :function:::int:check_mt_hilo:hilo_history *history
 303 *mips32:
 304 *mips32r2:
 305 *mips64:
 306 *mips64r2:
 307 *r3900:
 308 {
 309   signed64 time = sim_events_time (SD);
 310   history->mt.timestamp = time;
 311   history->mt.cia = CIA;
 312   return 1;
 313 }
 314
 315
 316 // check_mf_hilo:
 317 //
 318 // Check for restriction (1) above, and record timestamps for
 319 // restriction (2) and (3) above.
 320 //
 321 :function:::int:check_mf_hilo:hilo_history *history, hilo_history *peer
 322 *mipsI:
 323 *mipsII:
 324 *mipsIII:
 325 *mipsIV:
 326 *mipsV:
 327 *mips32:
 328 *mips32r2:
 329 *mips64:
 330 *mips64r2:
 331 *vr4100:
 332 *vr5000:
 333 *r3900:
 334 {
 335   signed64 time = sim_events_time (SD);
 336   int ok = 1;
 337   if (peer != NULL
 338       && peer->mt.timestamp > history->op.timestamp
 339       && history->mt.timestamp < history->op.timestamp
 340       && ! (history->mf.timestamp > history->op.timestamp
 341             && history->mf.timestamp < peer->mt.timestamp)
 342       && ! (peer->mf.timestamp > history->op.timestamp
 343             && peer->mf.timestamp < peer->mt.timestamp))
 344     {
 345       /* The peer has been written to since the last OP yet we have
 346          not */
 347       sim_engine_abort (SD, CPU, CIA, "HILO: %s: MF at 0x%08lx following OP at 0x%08lx corrupted by MT at 0x%08lx\n",
 348                         itable[MY_INDEX].name,
 349                         (long) CIA,
 350                         (long) history->op.cia,
 351                         (long) peer->mt.cia);
 352       ok = 0;
 353     }
 354   history->mf.timestamp = time;
 355   history->mf.cia = CIA;
 356   return ok;
 357 }
 358
 359
 360
 361 // check_mult_hilo:
 362 //
 363 // Check for restriction (3) above (for ISAs/processors that have it)
 364 // for MULT ops, and record timestamps for restriction (1) above.
 365 //
 366 :function:::int:check_mult_hilo:hilo_history *hi, hilo_history *lo
 367 *mipsI:
 368 *mipsII:
 369 *mipsIII:
 370 *vr4100:
 371 *vr5000:
 372 {
 373   signed64 time = sim_events_time (SD);
 374   int ok = (check_mf_cycles (SD_, hi, time, "OP")
 375             && check_mf_cycles (SD_, lo, time, "OP"));
 376   hi->op.timestamp = time;
 377   lo->op.timestamp = time;
 378   hi->op.cia = CIA;
 379   lo->op.cia = CIA;
 380   return ok;
 381 }
 382
 383 :function:::int:check_mult_hilo:hilo_history *hi, hilo_history *lo
 384 *mipsIV:
 385 *mipsV:
 386 {
 387   signed64 time = sim_events_time (SD);
 388   int ok = (! MIPS_MACH_HAS_MULT_HILO_HAZARD (SD)
 389             || (check_mf_cycles (SD_, hi, time, "OP")
 390                 && check_mf_cycles (SD_, lo, time, "OP")));
 391   hi->op.timestamp = time;
 392   lo->op.timestamp = time;
 393   hi->op.cia = CIA;
 394   lo->op.cia = CIA;
 395   return ok;
 396 }
 397
 398 :function:::int:check_mult_hilo:hilo_history *hi, hilo_history *lo
 399 *mips32:
 400 *mips32r2:
 401 *mips64:
 402 *mips64r2:
 403 *r3900:
 404 {
 405   /* FIXME: could record the fact that a stall occured if we want */
 406   signed64 time = sim_events_time (SD);
 407   hi->op.timestamp = time;
 408   lo->op.timestamp = time;
 409   hi->op.cia = CIA;
 410   lo->op.cia = CIA;
 411   return 1;
 412 }
 413
 414
 415 // check_div_hilo:
 416 //
 417 // Check for restriction (3) above (for ISAs/processors that have it)
 418 // for DIV ops, and record timestamps for restriction (1) above.
 419 //
 420 :function:::int:check_div_hilo:hilo_history *hi, hilo_history *lo
 421 *mipsI:
 422 *mipsII:
 423 *mipsIII:
 424 *vr4100:
 425 *vr5000:
 426 *r3900:
 427 {
 428   signed64 time = sim_events_time (SD);
 429   int ok = (check_mf_cycles (SD_, hi, time, "OP")
 430             && check_mf_cycles (SD_, lo, time, "OP"));
 431   hi->op.timestamp = time;
 432   lo->op.timestamp = time;
 433   hi->op.cia = CIA;
 434   lo->op.cia = CIA;
 435   return ok;
 436 }
 437
 438 :function:::int:check_div_hilo:hilo_history *hi, hilo_history *lo
 439 *mipsIV:
 440 *mipsV:
 441 {
 442   signed64 time = sim_events_time (SD);
 443   int ok = (! MIPS_MACH_HAS_DIV_HILO_HAZARD (SD)
 444             || (check_mf_cycles (SD_, hi, time, "OP")
 445                 && check_mf_cycles (SD_, lo, time, "OP")));
 446   hi->op.timestamp = time;
 447   lo->op.timestamp = time;
 448   hi->op.cia = CIA;
 449   lo->op.cia = CIA;
 450   return ok;
 451 }
 452
 453 :function:::int:check_div_hilo:hilo_history *hi, hilo_history *lo
 454 *mips32:
 455 *mips32r2:
 456 *mips64:
 457 *mips64r2:
 458 {
 459   signed64 time = sim_events_time (SD);
 460   hi->op.timestamp = time;
 461   lo->op.timestamp = time;
 462   hi->op.cia = CIA;
 463   lo->op.cia = CIA;
 464   return 1;
 465 }
 466
 467
 468 // Helper:
 469 //
 470 // Check that the 64-bit instruction can currently be used, and signal
 471 // a ReservedInstruction exception if not.
 472 //
 473
 474 :function:::void:check_u64:instruction_word insn
 475 *mipsIII:
 476 *mipsIV:
 477 *mipsV:
 478 *vr4100:
 479 *vr5000:
 480 *vr5400:
 481 *vr5500:
 482 {
 483   // The check should be similar to mips64 for any with PX/UX bit equivalents.
 484 }
 485
 486 :function:::void:check_u64:instruction_word insn
 487 *mips16e:
 488 *mips64:
 489 *mips64r2:
 490 {
 491 #if 0 /* XXX FIXME: enable this only after some additional testing.  */
 492   if (UserMode && (SR & (status_UX|status_PX)) == 0)
 493     SignalException (ReservedInstruction, insn);
 494 #endif
 495 }
 496
 497
 498
 499 //
 500 // MIPS Architecture:
 501 //
 502 //        CPU Instruction Set (mipsI - mipsV, mips32/r2, mips64/r2)
 503 //
 504
 505
 506
 507 000000,5.RS,5.RT,5.RD,00000,100000:SPECIAL:32::ADD
 508 "add r<RD>, r<RS>, r<RT>"
 509 *mipsI:
 510 *mipsII:
 511 *mipsIII:
 512 *mipsIV:
 513 *mipsV:
 514 *mips32:
 515 *mips32r2:
 516 *mips64:
 517 *mips64r2:
 518 *vr4100:
 519 *vr5000:
 520 *r3900:
 521 {
 522   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
 523     Unpredictable ();
 524   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
 525   {
 526     ALU32_BEGIN (GPR[RS]);
 527     ALU32_ADD (GPR[RT]);
 528     ALU32_END (GPR[RD]);   /* This checks for overflow.  */
 529   }
 530   TRACE_ALU_RESULT (GPR[RD]);
 531 }
 532
 533
 534
 535 001000,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ADDI
 536 "addi r<RT>, r<RS>, <IMMEDIATE>"
 537 *mipsI:
 538 *mipsII:
 539 *mipsIII:
 540 *mipsIV:
 541 *mipsV:
 542 *mips32:
 543 *mips32r2:
 544 *mips64:
 545 *mips64r2:
 546 *vr4100:
 547 *vr5000:
 548 *r3900:
 549 {
 550   if (NotWordValue (GPR[RS]))
 551     Unpredictable ();
 552   TRACE_ALU_INPUT2 (GPR[RS], EXTEND16 (IMMEDIATE));
 553   {
 554     ALU32_BEGIN (GPR[RS]);
 555     ALU32_ADD (EXTEND16 (IMMEDIATE));
 556     ALU32_END (GPR[RT]);   /* This checks for overflow.  */
 557   }
 558   TRACE_ALU_RESULT (GPR[RT]);
 559 }
 560
 561
 562
 563 :function:::void:do_addiu:int rs, int rt, unsigned16 immediate
 564 {
 565   if (NotWordValue (GPR[rs]))
 566     Unpredictable ();
 567   TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
 568   GPR[rt] = EXTEND32 (GPR[rs] + EXTEND16 (immediate));
 569   TRACE_ALU_RESULT (GPR[rt]);
 570 }
 571
 572 001001,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ADDIU
 573 "addiu r<RT>, r<RS>, <IMMEDIATE>"
 574 *mipsI:
 575 *mipsII:
 576 *mipsIII:
 577 *mipsIV:
 578 *mipsV:
 579 *mips32:
 580 *mips32r2:
 581 *mips64:
 582 *mips64r2:
 583 *vr4100:
 584 *vr5000:
 585 *r3900:
 586 {
 587   do_addiu (SD_, RS, RT, IMMEDIATE);
 588 }
 589
 590
 591
 592 :function:::void:do_addu:int rs, int rt, int rd
 593 {
 594   if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
 595     Unpredictable ();
 596   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
 597   GPR[rd] = EXTEND32 (GPR[rs] + GPR[rt]);
 598   TRACE_ALU_RESULT (GPR[rd]);
 599 }
 600
 601 000000,5.RS,5.RT,5.RD,00000,100001:SPECIAL:32::ADDU
 602 "addu r<RD>, r<RS>, r<RT>"
 603 *mipsI:
 604 *mipsII:
 605 *mipsIII:
 606 *mipsIV:
 607 *mipsV:
 608 *mips32:
 609 *mips32r2:
 610 *mips64:
 611 *mips64r2:
 612 *vr4100:
 613 *vr5000:
 614 *r3900:
 615 {
 616   do_addu (SD_, RS, RT, RD);
 617 }
 618
 619
 620
 621 :function:::void:do_and:int rs, int rt, int rd
 622 {
 623   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
 624   GPR[rd] = GPR[rs] & GPR[rt];
 625   TRACE_ALU_RESULT (GPR[rd]);
 626 }
 627
 628 000000,5.RS,5.RT,5.RD,00000,100100:SPECIAL:32::AND
 629 "and r<RD>, r<RS>, r<RT>"
 630 *mipsI:
 631 *mipsII:
 632 *mipsIII:
 633 *mipsIV:
 634 *mipsV:
 635 *mips32:
 636 *mips32r2:
 637 *mips64:
 638 *mips64r2:
 639 *vr4100:
 640 *vr5000:
 641 *r3900:
 642 {
 643   do_and (SD_, RS, RT, RD);
 644 }
 645
 646
 647
 648 001100,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ANDI
 649 "andi r<RT>, r<RS>, %#lx<IMMEDIATE>"
 650 *mipsI:
 651 *mipsII:
 652 *mipsIII:
 653 *mipsIV:
 654 *mipsV:
 655 *mips32:
 656 *mips32r2:
 657 *mips64:
 658 *mips64r2:
 659 *vr4100:
 660 *vr5000:
 661 *r3900:
 662 {
 663   TRACE_ALU_INPUT2 (GPR[RS], IMMEDIATE);
 664   GPR[RT] = GPR[RS] & IMMEDIATE;
 665   TRACE_ALU_RESULT (GPR[RT]);
 666 }
 667
 668
 669
 670 000100,5.RS,5.RT,16.OFFSET:NORMAL:32::BEQ
 671 "beq r<RS>, r<RT>, <OFFSET>"
 672 *mipsI:
 673 *mipsII:
 674 *mipsIII:
 675 *mipsIV:
 676 *mipsV:
 677 *mips32:
 678 *mips32r2:
 679 *mips64:
 680 *mips64r2:
 681 *vr4100:
 682 *vr5000:
 683 *r3900:
 684 {
 685   address_word offset = EXTEND16 (OFFSET) << 2;
 686   if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
 687     {
 688       DELAY_SLOT (NIA + offset);
 689     }
 690 }
 691
 692
 693
 694 010100,5.RS,5.RT,16.OFFSET:NORMAL:32::BEQL
 695 "beql r<RS>, r<RT>, <OFFSET>"
 696 *mipsII:
 697 *mipsIII:
 698 *mipsIV:
 699 *mipsV:
 700 *mips32:
 701 *mips32r2:
 702 *mips64:
 703 *mips64r2:
 704 *vr4100:
 705 *vr5000:
 706 *r3900:
 707 {
 708   address_word offset = EXTEND16 (OFFSET) << 2;
 709   if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
 710     {
 711       DELAY_SLOT (NIA + offset);
 712     }
 713   else
 714     NULLIFY_NEXT_INSTRUCTION ();
 715 }
 716
 717
 718
 719 000001,5.RS,00001,16.OFFSET:REGIMM:32::BGEZ
 720 "bgez r<RS>, <OFFSET>"
 721 *mipsI:
 722 *mipsII:
 723 *mipsIII:
 724 *mipsIV:
 725 *mipsV:
 726 *mips32:
 727 *mips32r2:
 728 *mips64:
 729 *mips64r2:
 730 *vr4100:
 731 *vr5000:
 732 *r3900:
 733 {
 734   address_word offset = EXTEND16 (OFFSET) << 2;
 735   if ((signed_word) GPR[RS] >= 0)
 736     {
 737       DELAY_SLOT (NIA + offset);
 738     }
 739 }
 740
 741
 742
 743 000001,5.RS!31,10001,16.OFFSET:REGIMM:32::BGEZAL
 744 "bgezal r<RS>, <OFFSET>"
 745 *mipsI:
 746 *mipsII:
 747 *mipsIII:
 748 *mipsIV:
 749 *mipsV:
 750 *mips32:
 751 *mips32r2:
 752 *mips64:
 753 *mips64r2:
 754 *vr4100:
 755 *vr5000:
 756 *r3900:
 757 {
 758   address_word offset = EXTEND16 (OFFSET) << 2;
 759   if (RS == 31)
 760     Unpredictable ();
 761   RA = (CIA + 8);
 762   if ((signed_word) GPR[RS] >= 0)
 763     {
 764       DELAY_SLOT (NIA + offset);
 765     }
 766 }
 767
 768
 769
 770 000001,5.RS!31,10011,16.OFFSET:REGIMM:32::BGEZALL
 771 "bgezall r<RS>, <OFFSET>"
 772 *mipsII:
 773 *mipsIII:
 774 *mipsIV:
 775 *mipsV:
 776 *mips32:
 777 *mips32r2:
 778 *mips64:
 779 *mips64r2:
 780 *vr4100:
 781 *vr5000:
 782 *r3900:
 783 {
 784   address_word offset = EXTEND16 (OFFSET) << 2;
 785   if (RS == 31)
 786     Unpredictable ();
 787   RA = (CIA + 8);
 788   /* NOTE: The branch occurs AFTER the next instruction has been
 789      executed */
 790   if ((signed_word) GPR[RS] >= 0)
 791     {
 792       DELAY_SLOT (NIA + offset);
 793     }
 794   else
 795     NULLIFY_NEXT_INSTRUCTION ();
 796 }
 797
 798
 799
 800 000001,5.RS,00011,16.OFFSET:REGIMM:32::BGEZL
 801 "bgezl r<RS>, <OFFSET>"
 802 *mipsII:
 803 *mipsIII:
 804 *mipsIV:
 805 *mipsV:
 806 *mips32:
 807 *mips32r2:
 808 *mips64:
 809 *mips64r2:
 810 *vr4100:
 811 *vr5000:
 812 *r3900:
 813 {
 814   address_word offset = EXTEND16 (OFFSET) << 2;
 815   if ((signed_word) GPR[RS] >= 0)
 816     {
 817       DELAY_SLOT (NIA + offset);
 818     }
 819   else
 820     NULLIFY_NEXT_INSTRUCTION ();
 821 }
 822
 823
 824
 825 000111,5.RS,00000,16.OFFSET:NORMAL:32::BGTZ
 826 "bgtz r<RS>, <OFFSET>"
 827 *mipsI:
 828 *mipsII:
 829 *mipsIII:
 830 *mipsIV:
 831 *mipsV:
 832 *mips32:
 833 *mips32r2:
 834 *mips64:
 835 *mips64r2:
 836 *vr4100:
 837 *vr5000:
 838 *r3900:
 839 {
 840   address_word offset = EXTEND16 (OFFSET) << 2;
 841   if ((signed_word) GPR[RS] > 0)
 842     {
 843       DELAY_SLOT (NIA + offset);
 844     }
 845 }
 846
 847
 848
 849 010111,5.RS,00000,16.OFFSET:NORMAL:32::BGTZL
 850 "bgtzl r<RS>, <OFFSET>"
 851 *mipsII:
 852 *mipsIII:
 853 *mipsIV:
 854 *mipsV:
 855 *mips32:
 856 *mips32r2:
 857 *mips64:
 858 *mips64r2:
 859 *vr4100:
 860 *vr5000:
 861 *r3900:
 862 {
 863   address_word offset = EXTEND16 (OFFSET) << 2;
 864   /* NOTE: The branch occurs AFTER the next instruction has been
 865      executed */
 866   if ((signed_word) GPR[RS] > 0)
 867     {
 868       DELAY_SLOT (NIA + offset);
 869     }
 870   else
 871     NULLIFY_NEXT_INSTRUCTION ();
 872 }
 873
 874
 875
 876 000110,5.RS,00000,16.OFFSET:NORMAL:32::BLEZ
 877 "blez r<RS>, <OFFSET>"
 878 *mipsI:
 879 *mipsII:
 880 *mipsIII:
 881 *mipsIV:
 882 *mipsV:
 883 *mips32:
 884 *mips32r2:
 885 *mips64:
 886 *mips64r2:
 887 *vr4100:
 888 *vr5000:
 889 *r3900:
 890 {
 891   address_word offset = EXTEND16 (OFFSET) << 2;
 892   /* NOTE: The branch occurs AFTER the next instruction has been
 893      executed */
 894   if ((signed_word) GPR[RS] <= 0)
 895     {
 896       DELAY_SLOT (NIA + offset);
 897     }
 898 }
 899
 900
 901
 902 010110,5.RS,00000,16.OFFSET:NORMAL:32::BLEZL
 903 "bgezl r<RS>, <OFFSET>"
 904 *mipsII:
 905 *mipsIII:
 906 *mipsIV:
 907 *mipsV:
 908 *mips32:
 909 *mips32r2:
 910 *mips64:
 911 *mips64r2:
 912 *vr4100:
 913 *vr5000:
 914 *r3900:
 915 {
 916   address_word offset = EXTEND16 (OFFSET) << 2;
 917   if ((signed_word) GPR[RS] <= 0)
 918     {
 919       DELAY_SLOT (NIA + offset);
 920     }
 921   else
 922     NULLIFY_NEXT_INSTRUCTION ();
 923 }
 924
 925
 926
 927 000001,5.RS,00000,16.OFFSET:REGIMM:32::BLTZ
 928 "bltz r<RS>, <OFFSET>"
 929 *mipsI:
 930 *mipsII:
 931 *mipsIII:
 932 *mipsIV:
 933 *mipsV:
 934 *mips32:
 935 *mips32r2:
 936 *mips64:
 937 *mips64r2:
 938 *vr4100:
 939 *vr5000:
 940 *r3900:
 941 {
 942   address_word offset = EXTEND16 (OFFSET) << 2;
 943   if ((signed_word) GPR[RS] < 0)
 944     {
 945       DELAY_SLOT (NIA + offset);
 946     }
 947 }
 948
 949
 950
 951 000001,5.RS!31,10000,16.OFFSET:REGIMM:32::BLTZAL
 952 "bltzal r<RS>, <OFFSET>"
 953 *mipsI:
 954 *mipsII:
 955 *mipsIII:
 956 *mipsIV:
 957 *mipsV:
 958 *mips32:
 959 *mips32r2:
 960 *mips64:
 961 *mips64r2:
 962 *vr4100:
 963 *vr5000:
 964 *r3900:
 965 {
 966   address_word offset = EXTEND16 (OFFSET) << 2;
 967   if (RS == 31)
 968     Unpredictable ();
 969   RA = (CIA + 8);
 970   /* NOTE: The branch occurs AFTER the next instruction has been
 971      executed */
 972   if ((signed_word) GPR[RS] < 0)
 973     {
 974       DELAY_SLOT (NIA + offset);
 975     }
 976 }
 977
 978
 979
 980 000001,5.RS!31,10010,16.OFFSET:REGIMM:32::BLTZALL
 981 "bltzall r<RS>, <OFFSET>"
 982 *mipsII:
 983 *mipsIII:
 984 *mipsIV:
 985 *mipsV:
 986 *mips32:
 987 *mips32r2:
 988 *mips64:
 989 *mips64r2:
 990 *vr4100:
 991 *vr5000:
 992 *r3900:
 993 {
 994   address_word offset = EXTEND16 (OFFSET) << 2;
 995   if (RS == 31)
 996     Unpredictable ();
 997   RA = (CIA + 8);
 998   if ((signed_word) GPR[RS] < 0)
 999     {
1000       DELAY_SLOT (NIA + offset);
1001     }
1002   else
1003     NULLIFY_NEXT_INSTRUCTION ();
1004 }
1005
1006
1007
1008 000001,5.RS,00010,16.OFFSET:REGIMM:32::BLTZL
1009 "bltzl r<RS>, <OFFSET>"
1010 *mipsII:
1011 *mipsIII:
1012 *mipsIV:
1013 *mipsV:
1014 *mips32:
1015 *mips32r2:
1016 *mips64:
1017 *mips64r2:
1018 *vr4100:
1019 *vr5000:
1020 *r3900:
1021 {
1022   address_word offset = EXTEND16 (OFFSET) << 2;
1023   /* NOTE: The branch occurs AFTER the next instruction has been
1024      executed */
1025   if ((signed_word) GPR[RS] < 0)
1026     {
1027       DELAY_SLOT (NIA + offset);
1028     }
1029   else
1030     NULLIFY_NEXT_INSTRUCTION ();
1031 }
1032
1033
1034
1035 000101,5.RS,5.RT,16.OFFSET:NORMAL:32::BNE
1036 "bne r<RS>, r<RT>, <OFFSET>"
1037 *mipsI:
1038 *mipsII:
1039 *mipsIII:
1040 *mipsIV:
1041 *mipsV:
1042 *mips32:
1043 *mips32r2:
1044 *mips64:
1045 *mips64r2:
1046 *vr4100:
1047 *vr5000:
1048 *r3900:
1049 {
1050   address_word offset = EXTEND16 (OFFSET) << 2;
1051   if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
1052     {
1053       DELAY_SLOT (NIA + offset);
1054     }
1055 }
1056
1057
1058
1059 010101,5.RS,5.RT,16.OFFSET:NORMAL:32::BNEL
1060 "bnel r<RS>, r<RT>, <OFFSET>"
1061 *mipsII:
1062 *mipsIII:
1063 *mipsIV:
1064 *mipsV:
1065 *mips32:
1066 *mips32r2:
1067 *mips64:
1068 *mips64r2:
1069 *vr4100:
1070 *vr5000:
1071 *r3900:
1072 {
1073   address_word offset = EXTEND16 (OFFSET) << 2;
1074   if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
1075     {
1076       DELAY_SLOT (NIA + offset);
1077     }
1078   else
1079     NULLIFY_NEXT_INSTRUCTION ();
1080 }
1081
1082
1083
1084 000000,20.CODE,001101:SPECIAL:32::BREAK
1085 "break %#lx<CODE>"
1086 *mipsI:
1087 *mipsII:
1088 *mipsIII:
1089 *mipsIV:
1090 *mipsV:
1091 *mips32:
1092 *mips32r2:
1093 *mips64:
1094 *mips64r2:
1095 *vr4100:
1096 *vr5000:
1097 *r3900:
1098 {
1099   /* Check for some break instruction which are reserved for use by the simulator.  */
1100   unsigned int break_code = instruction_0 & HALT_INSTRUCTION_MASK;
1101   if (break_code == (HALT_INSTRUCTION  & HALT_INSTRUCTION_MASK) ||
1102       break_code == (HALT_INSTRUCTION2 & HALT_INSTRUCTION_MASK))
1103     {
1104       sim_engine_halt (SD, CPU, NULL, cia,
1105                        sim_exited, (unsigned int)(A0 & 0xFFFFFFFF));
1106     }
1107   else if (break_code == (BREAKPOINT_INSTRUCTION  & HALT_INSTRUCTION_MASK) ||
1108            break_code == (BREAKPOINT_INSTRUCTION2 & HALT_INSTRUCTION_MASK))
1109     {
1110       if (STATE & simDELAYSLOT)
1111         PC = cia - 4; /* reference the branch instruction */
1112       else
1113         PC = cia;
1114       SignalException (BreakPoint, instruction_0);
1115     }
1116
1117   else
1118     {
1119       /* If we get this far, we're not an instruction reserved by the sim.  Raise
1120          the exception. */
1121       SignalException (BreakPoint, instruction_0);
1122     }
1123 }
1124
1125
1126
1127 011100,5.RS,5.RT,5.RD,00000,100001:SPECIAL2:32::CLO
1128 "clo r<RD>, r<RS>"
1129 *mips32:
1130 *mips32r2:
1131 *mips64:
1132 *mips64r2:
1133 *vr5500:
1134 {
1135   unsigned32 temp = GPR[RS];
1136   unsigned32 i, mask;
1137   if (RT != RD)
1138     Unpredictable ();
1139   if (NotWordValue (GPR[RS]))
1140     Unpredictable ();
1141   TRACE_ALU_INPUT1 (GPR[RS]);
1142   for (mask = ((unsigned32)1<<31), i = 0; i < 32; ++i)
1143     {
1144       if ((temp & mask) == 0)
1145         break;
1146       mask >>= 1;
1147     }
1148   GPR[RD] = EXTEND32 (i);
1149   TRACE_ALU_RESULT (GPR[RD]);
1150 }
1151
1152
1153
1154 011100,5.RS,5.RT,5.RD,00000,100000:SPECIAL2:32::CLZ
1155 "clz r<RD>, r<RS>"
1156 *mips32:
1157 *mips32r2:
1158 *mips64:
1159 *mips64r2:
1160 *vr5500:
1161 {
1162   unsigned32 temp = GPR[RS];
1163   unsigned32 i, mask;
1164   if (RT != RD)
1165     Unpredictable ();
1166   if (NotWordValue (GPR[RS]))
1167     Unpredictable ();
1168   TRACE_ALU_INPUT1 (GPR[RS]);
1169   for (mask = ((unsigned32)1<<31), i = 0; i < 32; ++i)
1170     {
1171       if ((temp & mask) != 0)
1172         break;
1173       mask >>= 1;
1174     }
1175   GPR[RD] = EXTEND32 (i);
1176   TRACE_ALU_RESULT (GPR[RD]);
1177 }
1178
1179
1180
1181 000000,5.RS,5.RT,5.RD,00000,101100:SPECIAL:64::DADD
1182 "dadd r<RD>, r<RS>, r<RT>"
1183 *mipsIII:
1184 *mipsIV:
1185 *mipsV:
1186 *mips64:
1187 *mips64r2:
1188 *vr4100:
1189 *vr5000:
1190 {
1191   check_u64 (SD_, instruction_0);
1192   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
1193   {
1194     ALU64_BEGIN (GPR[RS]);
1195     ALU64_ADD (GPR[RT]);
1196     ALU64_END (GPR[RD]);   /* This checks for overflow.  */
1197   }
1198   TRACE_ALU_RESULT (GPR[RD]);
1199 }
1200
1201
1202
1203 011000,5.RS,5.RT,16.IMMEDIATE:NORMAL:64::DADDI
1204 "daddi r<RT>, r<RS>, <IMMEDIATE>"
1205 *mipsIII:
1206 *mipsIV:
1207 *mipsV:
1208 *mips64:
1209 *mips64r2:
1210 *vr4100:
1211 *vr5000:
1212 {
1213   check_u64 (SD_, instruction_0);
1214   TRACE_ALU_INPUT2 (GPR[RS], EXTEND16 (IMMEDIATE));
1215   {
1216     ALU64_BEGIN (GPR[RS]);
1217     ALU64_ADD (EXTEND16 (IMMEDIATE));
1218     ALU64_END (GPR[RT]);   /* This checks for overflow.  */
1219   }
1220   TRACE_ALU_RESULT (GPR[RT]);
1221 }
1222
1223
1224
1225 :function:::void:do_daddiu:int rs, int rt, unsigned16 immediate
1226 {
1227   TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
1228   GPR[rt] = GPR[rs] + EXTEND16 (immediate);
1229   TRACE_ALU_RESULT (GPR[rt]);
1230 }
1231
1232 011001,5.RS,5.RT,16.IMMEDIATE:NORMAL:64::DADDIU
1233 "daddiu r<RT>, r<RS>, <IMMEDIATE>"
1234 *mipsIII:
1235 *mipsIV:
1236 *mipsV:
1237 *mips64:
1238 *mips64r2:
1239 *vr4100:
1240 *vr5000:
1241 {
1242   check_u64 (SD_, instruction_0);
1243   do_daddiu (SD_, RS, RT, IMMEDIATE);
1244 }
1245
1246
1247
1248 :function:::void:do_daddu:int rs, int rt, int rd
1249 {
1250   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1251   GPR[rd] = GPR[rs] + GPR[rt];
1252   TRACE_ALU_RESULT (GPR[rd]);
1253 }
1254
1255 000000,5.RS,5.RT,5.RD,00000,101101:SPECIAL:64::DADDU
1256 "daddu r<RD>, r<RS>, r<RT>"
1257 *mipsIII:
1258 *mipsIV:
1259 *mipsV:
1260 *mips64:
1261 *mips64r2:
1262 *vr4100:
1263 *vr5000:
1264 {
1265   check_u64 (SD_, instruction_0);
1266   do_daddu (SD_, RS, RT, RD);
1267 }
1268
1269
1270
1271 011100,5.RS,5.RT,5.RD,00000,100101:SPECIAL2:64::DCLO
1272 "dclo r<RD>, r<RS>"
1273 *mips64:
1274 *mips64r2:
1275 *vr5500:
1276 {
1277   unsigned64 temp = GPR[RS];
1278   unsigned32 i;
1279   unsigned64 mask;
1280   check_u64 (SD_, instruction_0);
1281   if (RT != RD)
1282     Unpredictable ();
1283   TRACE_ALU_INPUT1 (GPR[RS]);
1284   for (mask = ((unsigned64)1<<63), i = 0; i < 64; ++i)
1285     {
1286       if ((temp & mask) == 0)
1287         break;
1288       mask >>= 1;
1289     }
1290   GPR[RD] = EXTEND32 (i);
1291   TRACE_ALU_RESULT (GPR[RD]);
1292 }
1293
1294
1295
1296 011100,5.RS,5.RT,5.RD,00000,100100:SPECIAL2:64::DCLZ
1297 "dclz r<RD>, r<RS>"
1298 *mips64:
1299 *mips64r2:
1300 *vr5500:
1301 {
1302   unsigned64 temp = GPR[RS];
1303   unsigned32 i;
1304   unsigned64 mask;
1305   check_u64 (SD_, instruction_0);
1306   if (RT != RD)
1307     Unpredictable ();
1308   TRACE_ALU_INPUT1 (GPR[RS]);
1309   for (mask = ((unsigned64)1<<63), i = 0; i < 64; ++i)
1310     {
1311       if ((temp & mask) != 0)
1312         break;
1313       mask >>= 1;
1314     }
1315   GPR[RD] = EXTEND32 (i);
1316   TRACE_ALU_RESULT (GPR[RD]);
1317 }
1318
1319
1320
1321 :function:::void:do_ddiv:int rs, int rt
1322 {
1323   check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1324   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1325   {
1326     signed64 n = GPR[rs];
1327     signed64 d = GPR[rt];
1328     signed64 hi;
1329     signed64 lo;
1330     if (d == 0)
1331       {
1332         lo = SIGNED64 (0x8000000000000000);
1333         hi = 0;
1334       }
1335     else if (d == -1 && n == SIGNED64 (0x8000000000000000))
1336       {
1337         lo = SIGNED64 (0x8000000000000000);
1338         hi = 0;
1339       }
1340     else
1341       {
1342         lo = (n / d);
1343         hi = (n % d);
1344       }
1345     HI = hi;
1346     LO = lo;
1347   }
1348   TRACE_ALU_RESULT2 (HI, LO);
1349 }
1350
1351 000000,5.RS,5.RT,0000000000,011110:SPECIAL:64::DDIV
1352 "ddiv r<RS>, r<RT>"
1353 *mipsIII:
1354 *mipsIV:
1355 *mipsV:
1356 *mips64:
1357 *mips64r2:
1358 *vr4100:
1359 *vr5000:
1360 {
1361   check_u64 (SD_, instruction_0);
1362   do_ddiv (SD_, RS, RT);
1363 }
1364
1365
1366
1367 :function:::void:do_ddivu:int rs, int rt
1368 {
1369   check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1370   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1371   {
1372     unsigned64 n = GPR[rs];
1373     unsigned64 d = GPR[rt];
1374     unsigned64 hi;
1375     unsigned64 lo;
1376     if (d == 0)
1377       {
1378         lo = SIGNED64 (0x8000000000000000);
1379         hi = 0;
1380       }
1381     else
1382       {
1383         lo = (n / d);
1384         hi = (n % d);
1385       }
1386     HI = hi;
1387     LO = lo;
1388   }
1389   TRACE_ALU_RESULT2 (HI, LO);
1390 }
1391
1392 000000,5.RS,5.RT,0000000000,011111:SPECIAL:64::DDIVU
1393 "ddivu r<RS>, r<RT>"
1394 *mipsIII:
1395 *mipsIV:
1396 *mipsV:
1397 *mips64:
1398 *mips64r2:
1399 *vr4100:
1400 *vr5000:
1401 {
1402   check_u64 (SD_, instruction_0);
1403   do_ddivu (SD_, RS, RT);
1404 }
1405
1406 :function:::void:do_div:int rs, int rt
1407 {
1408   check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1409   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1410   {
1411     signed32 n = GPR[rs];
1412     signed32 d = GPR[rt];
1413     if (d == 0)
1414       {
1415         LO = EXTEND32 (0x80000000);
1416         HI = EXTEND32 (0);
1417       }
1418     else if (n == SIGNED32 (0x80000000) && d == -1)
1419       {
1420         LO = EXTEND32 (0x80000000);
1421         HI = EXTEND32 (0);
1422       }
1423     else
1424       {
1425         LO = EXTEND32 (n / d);
1426         HI = EXTEND32 (n % d);
1427       }
1428   }
1429   TRACE_ALU_RESULT2 (HI, LO);
1430 }
1431
1432 000000,5.RS,5.RT,0000000000,011010:SPECIAL:32::DIV
1433 "div r<RS>, r<RT>"
1434 *mipsI:
1435 *mipsII:
1436 *mipsIII:
1437 *mipsIV:
1438 *mipsV:
1439 *mips32:
1440 *mips32r2:
1441 *mips64:
1442 *mips64r2:
1443 *vr4100:
1444 *vr5000:
1445 *r3900:
1446 {
1447   do_div (SD_, RS, RT);
1448 }
1449
1450
1451
1452 :function:::void:do_divu:int rs, int rt
1453 {
1454   check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1455   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1456   {
1457     unsigned32 n = GPR[rs];
1458     unsigned32 d = GPR[rt];
1459     if (d == 0)
1460       {
1461         LO = EXTEND32 (0x80000000);
1462         HI = EXTEND32 (0);
1463       }
1464     else
1465       {
1466         LO = EXTEND32 (n / d);
1467         HI = EXTEND32 (n % d);
1468       }
1469   }
1470   TRACE_ALU_RESULT2 (HI, LO);
1471 }
1472
1473 000000,5.RS,5.RT,0000000000,011011:SPECIAL:32::DIVU
1474 "divu r<RS>, r<RT>"
1475 *mipsI:
1476 *mipsII:
1477 *mipsIII:
1478 *mipsIV:
1479 *mipsV:
1480 *mips32:
1481 *mips32r2:
1482 *mips64:
1483 *mips64r2:
1484 *vr4100:
1485 *vr5000:
1486 *r3900:
1487 {
1488   do_divu (SD_, RS, RT);
1489 }
1490
1491
1492 :function:::void:do_dmultx:int rs, int rt, int rd, int signed_p
1493 {
1494   unsigned64 lo;
1495   unsigned64 hi;
1496   unsigned64 m00;
1497   unsigned64 m01;
1498   unsigned64 m10;
1499   unsigned64 m11;
1500   unsigned64 mid;
1501   int sign;
1502   unsigned64 op1 = GPR[rs];
1503   unsigned64 op2 = GPR[rt];
1504   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
1505   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1506   /* make signed multiply unsigned */
1507   sign = 0;
1508   if (signed_p)
1509     {
1510       if ((signed64) op1 < 0)
1511         {
1512           op1 = - op1;
1513           ++sign;
1514         }
1515       if ((signed64) op2 < 0)
1516         {
1517           op2 = - op2;
1518           ++sign;
1519         }
1520     }
1521   /* multiply out the 4 sub products */
1522   m00 = ((unsigned64) VL4_8 (op1) * (unsigned64) VL4_8 (op2));
1523   m10 = ((unsigned64) VH4_8 (op1) * (unsigned64) VL4_8 (op2));
1524   m01 = ((unsigned64) VL4_8 (op1) * (unsigned64) VH4_8 (op2));
1525   m11 = ((unsigned64) VH4_8 (op1) * (unsigned64) VH4_8 (op2));
1526   /* add the products */
1527   mid = ((unsigned64) VH4_8 (m00)
1528          + (unsigned64) VL4_8 (m10)
1529          + (unsigned64) VL4_8 (m01));
1530   lo = U8_4 (mid, m00);
1531   hi = (m11
1532         + (unsigned64) VH4_8 (mid)
1533         + (unsigned64) VH4_8 (m01)
1534         + (unsigned64) VH4_8 (m10));
1535   /* fix the sign */
1536   if (sign & 1)
1537     {
1538       lo = -lo;
1539       if (lo == 0)
1540         hi = -hi;
1541       else
1542         hi = -hi - 1;
1543     }
1544   /* save the result HI/LO (and a gpr) */
1545   LO = lo;
1546   HI = hi;
1547   if (rd != 0)
1548     GPR[rd] = lo;
1549   TRACE_ALU_RESULT2 (HI, LO);
1550 }
1551
1552 :function:::void:do_dmult:int rs, int rt, int rd
1553 {
1554   do_dmultx (SD_, rs, rt, rd, 1);
1555 }
1556
1557 000000,5.RS,5.RT,0000000000,011100:SPECIAL:64::DMULT
1558 "dmult r<RS>, r<RT>"
1559 *mipsIII:
1560 *mipsIV:
1561 *mipsV:
1562 *mips64:
1563 *mips64r2:
1564 *vr4100:
1565 {
1566   check_u64 (SD_, instruction_0);
1567   do_dmult (SD_, RS, RT, 0);
1568 }
1569
1570 000000,5.RS,5.RT,5.RD,00000,011100:SPECIAL:64::DMULT
1571 "dmult r<RS>, r<RT>":RD == 0
1572 "dmult r<RD>, r<RS>, r<RT>"
1573 *vr5000:
1574 {
1575   check_u64 (SD_, instruction_0);
1576   do_dmult (SD_, RS, RT, RD);
1577 }
1578
1579
1580
1581 :function:::void:do_dmultu:int rs, int rt, int rd
1582 {
1583   do_dmultx (SD_, rs, rt, rd, 0);
1584 }
1585
1586 000000,5.RS,5.RT,0000000000,011101:SPECIAL:64::DMULTU
1587 "dmultu r<RS>, r<RT>"
1588 *mipsIII:
1589 *mipsIV:
1590 *mipsV:
1591 *mips64:
1592 *mips64r2:
1593 *vr4100:
1594 {
1595   check_u64 (SD_, instruction_0);
1596   do_dmultu (SD_, RS, RT, 0);
1597 }
1598
1599 000000,5.RS,5.RT,5.RD,00000,011101:SPECIAL:64::DMULTU
1600 "dmultu r<RD>, r<RS>, r<RT>":RD == 0
1601 "dmultu r<RS>, r<RT>"
1602 *vr5000:
1603 {
1604   check_u64 (SD_, instruction_0);
1605   do_dmultu (SD_, RS, RT, RD);
1606 }
1607
1608
1609 :function:::unsigned64:do_dror:unsigned64 x,unsigned64 y
1610 {
1611   unsigned64 result;
1612
1613   y &= 63;
1614   TRACE_ALU_INPUT2 (x, y);
1615   result = ROTR64 (x, y);
1616   TRACE_ALU_RESULT (result);
1617   return result;
1618 }
1619
1620 000000,00001,5.RT,5.RD,5.SHIFT,111010::64::DROR
1621 "dror r<RD>, r<RT>, <SHIFT>"
1622 *mips64r2:
1623 *vr5400:
1624 *vr5500:
1625 {
1626   check_u64 (SD_, instruction_0);
1627   GPR[RD] = do_dror (SD_, GPR[RT], SHIFT);
1628 }
1629
1630 000000,00001,5.RT,5.RD,5.SHIFT,111110::64::DROR32
1631 "dror32 r<RD>, r<RT>, <SHIFT>"
1632 *mips64r2:
1633 *vr5400:
1634 *vr5500:
1635 {
1636   check_u64 (SD_, instruction_0);
1637   GPR[RD] = do_dror (SD_, GPR[RT], SHIFT + 32);
1638 }
1639
1640 000000,5.RS,5.RT,5.RD,00001,010110::64::DRORV
1641 "drorv r<RD>, r<RT>, r<RS>"
1642 *mips64r2:
1643 *vr5400:
1644 *vr5500:
1645 {
1646   check_u64 (SD_, instruction_0);
1647   GPR[RD] = do_dror (SD_, GPR[RT], GPR[RS]);
1648 }
1649
1650
1651 :function:::void:do_dsll:int rt, int rd, int shift
1652 {
1653   TRACE_ALU_INPUT2 (GPR[rt], shift);
1654   GPR[rd] = GPR[rt] << shift;
1655   TRACE_ALU_RESULT (GPR[rd]);
1656 }
1657
1658 000000,00000,5.RT,5.RD,5.SHIFT,111000:SPECIAL:64::DSLL
1659 "dsll r<RD>, r<RT>, <SHIFT>"
1660 *mipsIII:
1661 *mipsIV:
1662 *mipsV:
1663 *mips64:
1664 *mips64r2:
1665 *vr4100:
1666 *vr5000:
1667 {
1668   check_u64 (SD_, instruction_0);
1669   do_dsll (SD_, RT, RD, SHIFT);
1670 }
1671
1672
1673 000000,00000,5.RT,5.RD,5.SHIFT,111100:SPECIAL:64::DSLL32
1674 "dsll32 r<RD>, r<RT>, <SHIFT>"
1675 *mipsIII:
1676 *mipsIV:
1677 *mipsV:
1678 *mips64:
1679 *mips64r2:
1680 *vr4100:
1681 *vr5000:
1682 {
1683   int s = 32 + SHIFT;
1684   check_u64 (SD_, instruction_0);
1685   TRACE_ALU_INPUT2 (GPR[RT], s);
1686   GPR[RD] = GPR[RT] << s;
1687   TRACE_ALU_RESULT (GPR[RD]);
1688 }
1689
1690 :function:::void:do_dsllv:int rs, int rt, int rd
1691 {
1692   int s = MASKED64 (GPR[rs], 5, 0);
1693   TRACE_ALU_INPUT2 (GPR[rt], s);
1694   GPR[rd] = GPR[rt] << s;
1695   TRACE_ALU_RESULT (GPR[rd]);
1696 }
1697
1698 000000,5.RS,5.RT,5.RD,00000,010100:SPECIAL:64::DSLLV
1699 "dsllv r<RD>, r<RT>, r<RS>"
1700 *mipsIII:
1701 *mipsIV:
1702 *mipsV:
1703 *mips64:
1704 *mips64r2:
1705 *vr4100:
1706 *vr5000:
1707 {
1708   check_u64 (SD_, instruction_0);
1709   do_dsllv (SD_, RS, RT, RD);
1710 }
1711
1712 :function:::void:do_dsra:int rt, int rd, int shift
1713 {
1714   TRACE_ALU_INPUT2 (GPR[rt], shift);
1715   GPR[rd] = ((signed64) GPR[rt]) >> shift;
1716   TRACE_ALU_RESULT (GPR[rd]);
1717 }
1718
1719
1720 000000,00000,5.RT,5.RD,5.SHIFT,111011:SPECIAL:64::DSRA
1721 "dsra r<RD>, r<RT>, <SHIFT>"
1722 *mipsIII:
1723 *mipsIV:
1724 *mipsV:
1725 *mips64:
1726 *mips64r2:
1727 *vr4100:
1728 *vr5000:
1729 {
1730   check_u64 (SD_, instruction_0);
1731   do_dsra (SD_, RT, RD, SHIFT);
1732 }
1733
1734
1735 000000,00000,5.RT,5.RD,5.SHIFT,111111:SPECIAL:64::DSRA32
1736 "dsra32 r<RD>, r<RT>, <SHIFT>"
1737 *mipsIII:
1738 *mipsIV:
1739 *mipsV:
1740 *mips64:
1741 *mips64r2:
1742 *vr4100:
1743 *vr5000:
1744 {
1745   int s = 32 + SHIFT;
1746   check_u64 (SD_, instruction_0);
1747   TRACE_ALU_INPUT2 (GPR[RT], s);
1748   GPR[RD] = ((signed64) GPR[RT]) >> s;
1749   TRACE_ALU_RESULT (GPR[RD]);
1750 }
1751
1752
1753 :function:::void:do_dsrav:int rs, int rt, int rd
1754 {
1755   int s = MASKED64 (GPR[rs], 5, 0);
1756   TRACE_ALU_INPUT2 (GPR[rt], s);
1757   GPR[rd] = ((signed64) GPR[rt]) >> s;
1758   TRACE_ALU_RESULT (GPR[rd]);
1759 }
1760
1761 000000,5.RS,5.RT,5.RD,00000,010111:SPECIAL:64::DSRAV
1762 "dsrav r<RD>, r<RT>, r<RS>"
1763 *mipsIII:
1764 *mipsIV:
1765 *mipsV:
1766 *mips64:
1767 *mips64r2:
1768 *vr4100:
1769 *vr5000:
1770 {
1771   check_u64 (SD_, instruction_0);
1772   do_dsrav (SD_, RS, RT, RD);
1773 }
1774
1775 :function:::void:do_dsrl:int rt, int rd, int shift
1776 {
1777   TRACE_ALU_INPUT2 (GPR[rt], shift);
1778   GPR[rd] = (unsigned64) GPR[rt] >> shift;
1779   TRACE_ALU_RESULT (GPR[rd]);
1780 }
1781
1782
1783 000000,00000,5.RT,5.RD,5.SHIFT,111010:SPECIAL:64::DSRL
1784 "dsrl r<RD>, r<RT>, <SHIFT>"
1785 *mipsIII:
1786 *mipsIV:
1787 *mipsV:
1788 *mips64:
1789 *mips64r2:
1790 *vr4100:
1791 *vr5000:
1792 {
1793   check_u64 (SD_, instruction_0);
1794   do_dsrl (SD_, RT, RD, SHIFT);
1795 }
1796
1797
1798 000000,00000,5.RT,5.RD,5.SHIFT,111110:SPECIAL:64::DSRL32
1799 "dsrl32 r<RD>, r<RT>, <SHIFT>"
1800 *mipsIII:
1801 *mipsIV:
1802 *mipsV:
1803 *mips64:
1804 *mips64r2:
1805 *vr4100:
1806 *vr5000:
1807 {
1808   int s = 32 + SHIFT;
1809   check_u64 (SD_, instruction_0);
1810   TRACE_ALU_INPUT2 (GPR[RT], s);
1811   GPR[RD] = (unsigned64) GPR[RT] >> s;
1812   TRACE_ALU_RESULT (GPR[RD]);
1813 }
1814
1815
1816 :function:::void:do_dsrlv:int rs, int rt, int rd
1817 {
1818   int s = MASKED64 (GPR[rs], 5, 0);
1819   TRACE_ALU_INPUT2 (GPR[rt], s);
1820   GPR[rd] = (unsigned64) GPR[rt] >> s;
1821   TRACE_ALU_RESULT (GPR[rd]);
1822 }
1823
1824
1825
1826 000000,5.RS,5.RT,5.RD,00000,010110:SPECIAL:64::DSRLV
1827 "dsrlv r<RD>, r<RT>, r<RS>"
1828 *mipsIII:
1829 *mipsIV:
1830 *mipsV:
1831 *mips64:
1832 *mips64r2:
1833 *vr4100:
1834 *vr5000:
1835 {
1836   check_u64 (SD_, instruction_0);
1837   do_dsrlv (SD_, RS, RT, RD);
1838 }
1839
1840
1841 000000,5.RS,5.RT,5.RD,00000,101110:SPECIAL:64::DSUB
1842 "dsub r<RD>, r<RS>, r<RT>"
1843 *mipsIII:
1844 *mipsIV:
1845 *mipsV:
1846 *mips64:
1847 *mips64r2:
1848 *vr4100:
1849 *vr5000:
1850 {
1851   check_u64 (SD_, instruction_0);
1852   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
1853   {
1854     ALU64_BEGIN (GPR[RS]);
1855     ALU64_SUB (GPR[RT]);
1856     ALU64_END (GPR[RD]);   /* This checks for overflow.  */
1857   }
1858   TRACE_ALU_RESULT (GPR[RD]);
1859 }
1860
1861
1862 :function:::void:do_dsubu:int rs, int rt, int rd
1863 {
1864   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1865   GPR[rd] = GPR[rs] - GPR[rt];
1866   TRACE_ALU_RESULT (GPR[rd]);
1867 }
1868
1869 000000,5.RS,5.RT,5.RD,00000,101111:SPECIAL:64::DSUBU
1870 "dsubu r<RD>, r<RS>, r<RT>"
1871 *mipsIII:
1872 *mipsIV:
1873 *mipsV:
1874 *mips64:
1875 *mips64r2:
1876 *vr4100:
1877 *vr5000:
1878 {
1879   check_u64 (SD_, instruction_0);
1880   do_dsubu (SD_, RS, RT, RD);
1881 }
1882
1883
1884 000010,26.INSTR_INDEX:NORMAL:32::J
1885 "j <INSTR_INDEX>"
1886 *mipsI:
1887 *mipsII:
1888 *mipsIII:
1889 *mipsIV:
1890 *mipsV:
1891 *mips32:
1892 *mips32r2:
1893 *mips64:
1894 *mips64r2:
1895 *vr4100:
1896 *vr5000:
1897 *r3900:
1898 {
1899   /* NOTE: The region used is that of the delay slot NIA and NOT the
1900      current instruction */
1901   address_word region = (NIA & MASK (63, 28));
1902   DELAY_SLOT (region | (INSTR_INDEX << 2));
1903 }
1904
1905
1906 000011,26.INSTR_INDEX:NORMAL:32::JAL
1907 "jal <INSTR_INDEX>"
1908 *mipsI:
1909 *mipsII:
1910 *mipsIII:
1911 *mipsIV:
1912 *mipsV:
1913 *mips32:
1914 *mips32r2:
1915 *mips64:
1916 *mips64r2:
1917 *vr4100:
1918 *vr5000:
1919 *r3900:
1920 {
1921   /* NOTE: The region used is that of the delay slot and NOT the
1922      current instruction */
1923   address_word region = (NIA & MASK (63, 28));
1924   GPR[31] = CIA + 8;
1925   DELAY_SLOT (region | (INSTR_INDEX << 2));
1926 }
1927
1928 000000,5.RS,00000,5.RD,00000,001001:SPECIAL:32::JALR
1929 "jalr r<RS>":RD == 31
1930 "jalr r<RD>, r<RS>"
1931 *mipsI:
1932 *mipsII:
1933 *mipsIII:
1934 *mipsIV:
1935 *mipsV:
1936 *mips32:
1937 *mips32r2:
1938 *mips64:
1939 *mips64r2:
1940 *vr4100:
1941 *vr5000:
1942 *r3900:
1943 {
1944   address_word temp = GPR[RS];
1945   GPR[RD] = CIA + 8;
1946   DELAY_SLOT (temp);
1947 }
1948
1949 000000,5.RS,00000,5.RD,10000,001001:SPECIAL:32::JALR_HB
1950 "jalr.hb r<RS>":RD == 31
1951 "jalr.hb r<RD>, r<RS>"
1952 *mips32r2:
1953 *mips64r2:
1954 {
1955   address_word temp = GPR[RS];
1956   GPR[RD] = CIA + 8;
1957   DELAY_SLOT (temp);
1958 }
1959
1960 000000,5.RS,0000000000,00000,001000:SPECIAL:32::JR
1961 "jr r<RS>"
1962 *mipsI:
1963 *mipsII:
1964 *mipsIII:
1965 *mipsIV:
1966 *mipsV:
1967 *mips32:
1968 *mips32r2:
1969 *mips64:
1970 *mips64r2:
1971 *vr4100:
1972 *vr5000:
1973 *r3900:
1974 {
1975   DELAY_SLOT (GPR[RS]);
1976 }
1977
1978 000000,5.RS,0000000000,10000,001000:SPECIAL:32::JR_HB
1979 "jr.hb r<RS>"
1980 *mips32r2:
1981 *mips64r2:
1982 {
1983   DELAY_SLOT (GPR[RS]);
1984 }
1985
1986 :function:::unsigned_word:do_load:unsigned access, address_word base, address_word offset
1987 {
1988   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
1989   address_word reverseendian = (ReverseEndian ? (mask ^ access) : 0);
1990   address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
1991   unsigned int byte;
1992   address_word paddr;
1993   int uncached;
1994   unsigned64 memval;
1995   address_word vaddr;
1996
1997   vaddr = loadstore_ea (SD_, base, offset);
1998   if ((vaddr & access) != 0)
1999     {
2000       SIM_CORE_SIGNAL (SD, STATE_CPU (SD, 0), cia, read_map, access+1, vaddr, read_transfer, sim_core_unaligned_signal);
2001     }
2002   AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
2003   paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
2004   LoadMemory (&memval, NULL, uncached, access, paddr, vaddr, isDATA, isREAL);
2005   byte = ((vaddr & mask) ^ bigendiancpu);
2006   return (memval >> (8 * byte));
2007 }
2008
2009 :function:::unsigned_word:do_load_left:unsigned access, address_word base, address_word offset, unsigned_word rt
2010 {
2011   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2012   address_word reverseendian = (ReverseEndian ? -1 : 0);
2013   address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
2014   unsigned int byte;
2015   unsigned int word;
2016   address_word paddr;
2017   int uncached;
2018   unsigned64 memval;
2019   address_word vaddr;
2020   int nr_lhs_bits;
2021   int nr_rhs_bits;
2022   unsigned_word lhs_mask;
2023   unsigned_word temp;
2024
2025   vaddr = loadstore_ea (SD_, base, offset);
2026   AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
2027   paddr = (paddr ^ (reverseendian & mask));
2028   if (BigEndianMem == 0)
2029     paddr = paddr & ~access;
2030
2031   /* compute where within the word/mem we are */
2032   byte = ((vaddr ^ bigendiancpu) & access); /* 0..access */
2033   word = ((vaddr ^ bigendiancpu) & (mask & ~access)) / (access + 1); /* 0..1 */
2034   nr_lhs_bits = 8 * byte + 8;
2035   nr_rhs_bits = 8 * access - 8 * byte;
2036   /* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
2037
2038   /* fprintf (stderr, "l[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
2039            (long) ((unsigned64) vaddr >> 32), (long) vaddr,
2040            (long) ((unsigned64) paddr >> 32), (long) paddr,
2041            word, byte, nr_lhs_bits, nr_rhs_bits); */
2042
2043   LoadMemory (&memval, NULL, uncached, byte, paddr, vaddr, isDATA, isREAL);
2044   if (word == 0)
2045     {
2046       /* GPR{31..32-NR_LHS_BITS} = memval{NR_LHS_BITS-1..0} */
2047       temp = (memval << nr_rhs_bits);
2048     }
2049   else
2050     {
2051       /* GPR{31..32-NR_LHS_BITS = memval{32+NR_LHS_BITS..32} */
2052       temp = (memval >> nr_lhs_bits);
2053     }
2054   lhs_mask = LSMASK (nr_lhs_bits + nr_rhs_bits - 1, nr_rhs_bits);
2055   rt = (rt & ~lhs_mask) | (temp & lhs_mask);
2056
2057   /* fprintf (stderr, "l[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx & 0x%08lx%08lx -> 0x%08lx%08lx\n",
2058            (long) ((unsigned64) memval >> 32), (long) memval,
2059            (long) ((unsigned64) temp >> 32), (long) temp,
2060            (long) ((unsigned64) lhs_mask >> 32), (long) lhs_mask,
2061            (long) (rt >> 32), (long) rt); */
2062   return rt;
2063 }
2064
2065 :function:::unsigned_word:do_load_right:unsigned access, address_word base, address_word offset, unsigned_word rt
2066 {
2067   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2068   address_word reverseendian = (ReverseEndian ? -1 : 0);
2069   address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
2070   unsigned int byte;
2071   address_word paddr;
2072   int uncached;
2073   unsigned64 memval;
2074   address_word vaddr;
2075
2076   vaddr = loadstore_ea (SD_, base, offset);
2077   AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
2078   /* NOTE: SPEC is wrong, has `BigEndianMem == 0' not `BigEndianMem != 0' */
2079   paddr = (paddr ^ (reverseendian & mask));
2080   if (BigEndianMem != 0)
2081     paddr = paddr & ~access;
2082   byte = ((vaddr & mask) ^ (bigendiancpu & mask));
2083   /* NOTE: SPEC is wrong, had `byte' not `access - byte'.  See SW. */
2084   LoadMemory (&memval, NULL, uncached, access - (access & byte), paddr, vaddr, isDATA, isREAL);
2085   /* printf ("lr: 0x%08lx %d@0x%08lx 0x%08lx\n",
2086      (long) paddr, byte, (long) paddr, (long) memval); */
2087   {
2088     unsigned_word screen = LSMASK (8 * (access - (byte & access) + 1) - 1, 0);
2089     rt &= ~screen;
2090     rt |= (memval >> (8 * byte)) & screen;
2091   }
2092   return rt;
2093 }
2094
2095
2096 100000,5.BASE,5.RT,16.OFFSET:NORMAL:32::LB
2097 "lb r<RT>, <OFFSET>(r<BASE>)"
2098 *mipsI:
2099 *mipsII:
2100 *mipsIII:
2101 *mipsIV:
2102 *mipsV:
2103 *mips32:
2104 *mips32r2:
2105 *mips64:
2106 *mips64r2:
2107 *vr4100:
2108 *vr5000:
2109 *r3900:
2110 {
2111   GPR[RT] = EXTEND8 (do_load (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET)));
2112 }
2113
2114
2115 100100,5.BASE,5.RT,16.OFFSET:NORMAL:32::LBU
2116 "lbu r<RT>, <OFFSET>(r<BASE>)"
2117 *mipsI:
2118 *mipsII:
2119 *mipsIII:
2120 *mipsIV:
2121 *mipsV:
2122 *mips32:
2123 *mips32r2:
2124 *mips64:
2125 *mips64r2:
2126 *vr4100:
2127 *vr5000:
2128 *r3900:
2129 {
2130   GPR[RT] = do_load (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET));
2131 }
2132
2133
2134 110111,5.BASE,5.RT,16.OFFSET:NORMAL:64::LD
2135 "ld r<RT>, <OFFSET>(r<BASE>)"
2136 *mipsIII:
2137 *mipsIV:
2138 *mipsV:
2139 *mips64:
2140 *mips64r2:
2141 *vr4100:
2142 *vr5000:
2143 {
2144   check_u64 (SD_, instruction_0);
2145   GPR[RT] = EXTEND64 (do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
2146 }
2147
2148
2149 1101,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDCz
2150 "ldc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
2151 *mipsII:
2152 *mipsIII:
2153 *mipsIV:
2154 *mipsV:
2155 *mips32:
2156 *mips32r2:
2157 *mips64:
2158 *mips64r2:
2159 *vr4100:
2160 *vr5000:
2161 *r3900:
2162 {
2163   COP_LD (ZZ, RT, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
2164 }
2165
2166
2167
2168
2169 011010,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDL
2170 "ldl r<RT>, <OFFSET>(r<BASE>)"
2171 *mipsIII:
2172 *mipsIV:
2173 *mipsV:
2174 *mips64:
2175 *mips64r2:
2176 *vr4100:
2177 *vr5000:
2178 {
2179   check_u64 (SD_, instruction_0);
2180   GPR[RT] = do_load_left (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2181 }
2182
2183
2184 011011,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDR
2185 "ldr r<RT>, <OFFSET>(r<BASE>)"
2186 *mipsIII:
2187 *mipsIV:
2188 *mipsV:
2189 *mips64:
2190 *mips64r2:
2191 *vr4100:
2192 *vr5000:
2193 {
2194   check_u64 (SD_, instruction_0);
2195   GPR[RT] = do_load_right (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2196 }
2197
2198
2199 100001,5.BASE,5.RT,16.OFFSET:NORMAL:32::LH
2200 "lh r<RT>, <OFFSET>(r<BASE>)"
2201 *mipsI:
2202 *mipsII:
2203 *mipsIII:
2204 *mipsIV:
2205 *mipsV:
2206 *mips32:
2207 *mips32r2:
2208 *mips64:
2209 *mips64r2:
2210 *vr4100:
2211 *vr5000:
2212 *r3900:
2213 {
2214   GPR[RT] = EXTEND16 (do_load (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET)));
2215 }
2216
2217
2218 100101,5.BASE,5.RT,16.OFFSET:NORMAL:32::LHU
2219 "lhu r<RT>, <OFFSET>(r<BASE>)"
2220 *mipsI:
2221 *mipsII:
2222 *mipsIII:
2223 *mipsIV:
2224 *mipsV:
2225 *mips32:
2226 *mips32r2:
2227 *mips64:
2228 *mips64r2:
2229 *vr4100:
2230 *vr5000:
2231 *r3900:
2232 {
2233   GPR[RT] = do_load (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET));
2234 }
2235
2236
2237 110000,5.BASE,5.RT,16.OFFSET:NORMAL:32::LL
2238 "ll r<RT>, <OFFSET>(r<BASE>)"
2239 *mipsII:
2240 *mipsIII:
2241 *mipsIV:
2242 *mipsV:
2243 *mips32:
2244 *mips32r2:
2245 *mips64:
2246 *mips64r2:
2247 *vr4100:
2248 *vr5000:
2249 {
2250   address_word base = GPR[BASE];
2251   address_word offset = EXTEND16 (OFFSET);
2252   {
2253     address_word vaddr = loadstore_ea (SD_, base, offset);
2254     address_word paddr;
2255     int uncached;
2256     if ((vaddr & 3) != 0)
2257       {
2258         SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 4, vaddr, read_transfer, sim_core_unaligned_signal);
2259       }
2260     else
2261       {
2262         if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
2263           {
2264             unsigned64 memval = 0;
2265             unsigned64 memval1 = 0;
2266             unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2267             unsigned int shift = 2;
2268             unsigned int reverse = (ReverseEndian ? (mask >> shift) : 0);
2269             unsigned int bigend = (BigEndianCPU ? (mask >> shift) : 0);
2270             unsigned int byte;
2271             paddr = ((paddr & ~mask) | ((paddr & mask) ^ (reverse << shift)));
2272             LoadMemory(&memval,&memval1,uncached,AccessLength_WORD,paddr,vaddr,isDATA,isREAL);
2273             byte = ((vaddr & mask) ^ (bigend << shift));
2274             GPR[RT] = EXTEND32 (memval >> (8 * byte));
2275             LLBIT = 1;
2276           }
2277       }
2278   }
2279 }
2280
2281
2282 110100,5.BASE,5.RT,16.OFFSET:NORMAL:64::LLD
2283 "lld r<RT>, <OFFSET>(r<BASE>)"
2284 *mipsIII:
2285 *mipsIV:
2286 *mipsV:
2287 *mips64:
2288 *mips64r2:
2289 *vr4100:
2290 *vr5000:
2291 {
2292   address_word base = GPR[BASE];
2293   address_word offset = EXTEND16 (OFFSET);
2294   check_u64 (SD_, instruction_0);
2295   {
2296     address_word vaddr = loadstore_ea (SD_, base, offset);
2297     address_word paddr;
2298     int uncached;
2299     if ((vaddr & 7) != 0)
2300       {
2301         SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 8, vaddr, read_transfer, sim_core_unaligned_signal);
2302       }
2303     else
2304       {
2305         if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
2306           {
2307             unsigned64 memval = 0;
2308             unsigned64 memval1 = 0;
2309             LoadMemory(&memval,&memval1,uncached,AccessLength_DOUBLEWORD,paddr,vaddr,isDATA,isREAL);
2310             GPR[RT] = memval;
2311             LLBIT = 1;
2312           }
2313       }
2314   }
2315 }
2316
2317
2318 001111,00000,5.RT,16.IMMEDIATE:NORMAL:32::LUI
2319 "lui r<RT>, %#lx<IMMEDIATE>"
2320 *mipsI:
2321 *mipsII:
2322 *mipsIII:
2323 *mipsIV:
2324 *mipsV:
2325 *mips32:
2326 *mips32r2:
2327 *mips64:
2328 *mips64r2:
2329 *vr4100:
2330 *vr5000:
2331 *r3900:
2332 {
2333   TRACE_ALU_INPUT1 (IMMEDIATE);
2334   GPR[RT] = EXTEND32 (IMMEDIATE << 16);
2335   TRACE_ALU_RESULT (GPR[RT]);
2336 }
2337
2338
2339 100011,5.BASE,5.RT,16.OFFSET:NORMAL:32::LW
2340 "lw r<RT>, <OFFSET>(r<BASE>)"
2341 *mipsI:
2342 *mipsII:
2343 *mipsIII:
2344 *mipsIV:
2345 *mipsV:
2346 *mips32:
2347 *mips32r2:
2348 *mips64:
2349 *mips64r2:
2350 *vr4100:
2351 *vr5000:
2352 *r3900:
2353 {
2354   GPR[RT] = EXTEND32 (do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
2355 }
2356
2357
2358 1100,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWCz
2359 "lwc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
2360 *mipsI:
2361 *mipsII:
2362 *mipsIII:
2363 *mipsIV:
2364 *mipsV:
2365 *mips32:
2366 *mips32r2:
2367 *mips64:
2368 *mips64r2:
2369 *vr4100:
2370 *vr5000:
2371 *r3900:
2372 {
2373   COP_LW (ZZ, RT, do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
2374 }
2375
2376
2377 100010,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWL
2378 "lwl r<RT>, <OFFSET>(r<BASE>)"
2379 *mipsI:
2380 *mipsII:
2381 *mipsIII:
2382 *mipsIV:
2383 *mipsV:
2384 *mips32:
2385 *mips32r2:
2386 *mips64:
2387 *mips64r2:
2388 *vr4100:
2389 *vr5000:
2390 *r3900:
2391 {
2392   GPR[RT] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]));
2393 }
2394
2395
2396 100110,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWR
2397 "lwr r<RT>, <OFFSET>(r<BASE>)"
2398 *mipsI:
2399 *mipsII:
2400 *mipsIII:
2401 *mipsIV:
2402 *mipsV:
2403 *mips32:
2404 *mips32r2:
2405 *mips64:
2406 *mips64r2:
2407 *vr4100:
2408 *vr5000:
2409 *r3900:
2410 {
2411   GPR[RT] = EXTEND32 (do_load_right (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]));
2412 }
2413
2414
2415 100111,5.BASE,5.RT,16.OFFSET:NORMAL:64::LWU
2416 "lwu r<RT>, <OFFSET>(r<BASE>)"
2417 *mipsIII:
2418 *mipsIV:
2419 *mipsV:
2420 *mips64:
2421 *mips64r2:
2422 *vr4100:
2423 *vr5000:
2424 {
2425   check_u64 (SD_, instruction_0);
2426   GPR[RT] = do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET));
2427 }
2428
2429
2430
2431 011100,5.RS,5.RT,00000,00000,000000:SPECIAL2:32::MADD
2432 "madd r<RS>, r<RT>"
2433 *mips32:
2434 *mips64:
2435 *vr5500:
2436 {
2437   signed64 temp;
2438   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2439   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2440     Unpredictable ();
2441   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2442   temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
2443           + ((signed64) EXTEND32 (GPR[RT]) * (signed64) EXTEND32 (GPR[RS])));
2444   LO = EXTEND32 (temp);
2445   HI = EXTEND32 (VH4_8 (temp));
2446   TRACE_ALU_RESULT2 (HI, LO);
2447 }
2448
2449
2450 011100,5.RS,5.RT,000,2.AC,00000,000000:SPECIAL2:32::MADD
2451 "madd r<RS>, r<RT>":AC == 0
2452 "madd ac<AC>, r<RS>, r<RT>"
2453 *mips32r2:
2454 *mips64r2:
2455 *dsp2:
2456 {
2457   signed64 temp;
2458   if (AC == 0)
2459     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2460   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2461     Unpredictable ();
2462   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2463   temp = (U8_4 (VL4_8 (DSPHI(AC)), VL4_8 (DSPLO(AC)))
2464           + ((signed64) EXTEND32 (GPR[RT]) * (signed64) EXTEND32 (GPR[RS])));
2465   DSPLO(AC) = EXTEND32 (temp);
2466   DSPHI(AC) = EXTEND32 (VH4_8 (temp));
2467   if (AC == 0)
2468     TRACE_ALU_RESULT2 (HI, LO);
2469 }
2470
2471
2472 011100,5.RS,5.RT,00000,00000,000001:SPECIAL2:32::MADDU
2473 "maddu r<RS>, r<RT>"
2474 *mips32:
2475 *mips64:
2476 *vr5500:
2477 {
2478   unsigned64 temp;
2479   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2480   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2481     Unpredictable ();
2482   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2483   temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
2484           + ((unsigned64) VL4_8 (GPR[RS]) * (unsigned64) VL4_8 (GPR[RT])));
2485   ACX += U8_4 (VL4_8 (HI), VL4_8 (LO)) < temp;  /* SmartMIPS */
2486   LO = EXTEND32 (temp);
2487   HI = EXTEND32 (VH4_8 (temp));
2488   TRACE_ALU_RESULT2 (HI, LO);
2489 }
2490
2491
2492 011100,5.RS,5.RT,000,2.AC,00000,000001:SPECIAL2:32::MADDU
2493 "maddu r<RS>, r<RT>":AC == 0
2494 "maddu ac<AC>, r<RS>, r<RT>"
2495 *mips32r2:
2496 *mips64r2:
2497 *dsp2:
2498 {
2499   unsigned64 temp;
2500   if (AC == 0)
2501     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2502   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2503     Unpredictable ();
2504   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2505   temp = (U8_4 (VL4_8 (DSPHI(AC)), VL4_8 (DSPLO(AC)))
2506           + ((unsigned64) VL4_8 (GPR[RS]) * (unsigned64) VL4_8 (GPR[RT])));
2507   if (AC == 0)
2508     ACX += U8_4 (VL4_8 (HI), VL4_8 (LO)) < temp;  /* SmartMIPS */
2509   DSPLO(AC) = EXTEND32 (temp);
2510   DSPHI(AC) = EXTEND32 (VH4_8 (temp));
2511   if (AC == 0)
2512     TRACE_ALU_RESULT2 (HI, LO);
2513 }
2514
2515
2516 :function:::void:do_mfhi:int rd
2517 {
2518   check_mf_hilo (SD_, HIHISTORY, LOHISTORY);
2519   TRACE_ALU_INPUT1 (HI);
2520   GPR[rd] = HI;
2521   TRACE_ALU_RESULT (GPR[rd]);
2522 }
2523
2524 000000,0000000000,5.RD,00000,010000:SPECIAL:32::MFHI
2525 "mfhi r<RD>"
2526 *mipsI:
2527 *mipsII:
2528 *mipsIII:
2529 *mipsIV:
2530 *mipsV:
2531 *vr4100:
2532 *vr5000:
2533 *r3900:
2534 *mips32:
2535 *mips64:
2536 {
2537   do_mfhi (SD_, RD);
2538 }
2539
2540
2541 000000,000,2.AC,00000,5.RD,00000,010000:SPECIAL:32::MFHI
2542 "mfhi r<RD>":AC == 0
2543 "mfhi r<RD>, ac<AC>"
2544 *mips32r2:
2545 *mips64r2:
2546 *dsp:
2547 {
2548   if (AC == 0)
2549     do_mfhi (SD_, RD);
2550   else
2551     GPR[RD] = DSPHI(AC);
2552 }
2553
2554
2555 :function:::void:do_mflo:int rd
2556 {
2557   check_mf_hilo (SD_, LOHISTORY, HIHISTORY);
2558   TRACE_ALU_INPUT1 (LO);
2559   GPR[rd] = LO;
2560   TRACE_ALU_RESULT (GPR[rd]);
2561 }
2562
2563 000000,0000000000,5.RD,00000,010010:SPECIAL:32::MFLO
2564 "mflo r<RD>"
2565 *mipsI:
2566 *mipsII:
2567 *mipsIII:
2568 *mipsIV:
2569 *mipsV:
2570 *vr4100:
2571 *vr5000:
2572 *r3900:
2573 *mips32:
2574 *mips64:
2575 {
2576   do_mflo (SD_, RD);
2577 }
2578
2579
2580 000000,000,2.AC,00000,5.RD,00000,010010:SPECIAL:32::MFLO
2581 "mflo r<RD>":AC == 0
2582 "mflo r<RD>, ac<AC>"
2583 *mips32r2:
2584 *mips64r2:
2585 *dsp:
2586 {
2587   if (AC == 0)
2588     do_mflo (SD_, RD);
2589   else
2590     GPR[RD] = DSPLO(AC);
2591 }
2592
2593
2594 000000,5.RS,5.RT,5.RD,00000,001011:SPECIAL:32::MOVN
2595 "movn r<RD>, r<RS>, r<RT>"
2596 *mipsIV:
2597 *mipsV:
2598 *mips32:
2599 *mips32r2:
2600 *mips64:
2601 *mips64r2:
2602 *vr5000:
2603 {
2604   if (GPR[RT] != 0)
2605     {
2606       GPR[RD] = GPR[RS];
2607       TRACE_ALU_RESULT (GPR[RD]);
2608     }
2609 }
2610
2611
2612
2613 000000,5.RS,5.RT,5.RD,00000,001010:SPECIAL:32::MOVZ
2614 "movz r<RD>, r<RS>, r<RT>"
2615 *mipsIV:
2616 *mipsV:
2617 *mips32:
2618 *mips32r2:
2619 *mips64:
2620 *mips64r2:
2621 *vr5000:
2622 {
2623   if (GPR[RT] == 0)
2624     {
2625       GPR[RD] = GPR[RS];
2626       TRACE_ALU_RESULT (GPR[RD]);
2627     }
2628 }
2629
2630
2631
2632 011100,5.RS,5.RT,00000,00000,000100:SPECIAL2:32::MSUB
2633 "msub r<RS>, r<RT>"
2634 *mips32:
2635 *mips64:
2636 *vr5500:
2637 {
2638   signed64 temp;
2639   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2640   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2641     Unpredictable ();
2642   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2643   temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
2644           - ((signed64) EXTEND32 (GPR[RT]) * (signed64) EXTEND32 (GPR[RS])));
2645   LO = EXTEND32 (temp);
2646   HI = EXTEND32 (VH4_8 (temp));
2647   TRACE_ALU_RESULT2 (HI, LO);
2648 }
2649
2650
2651 011100,5.RS,5.RT,000,2.AC,00000,000100:SPECIAL2:32::MSUB
2652 "msub r<RS>, r<RT>":AC == 0
2653 "msub ac<AC>, r<RS>, r<RT>"
2654 *mips32r2:
2655 *mips64r2:
2656 *dsp2:
2657 {
2658   signed64 temp;
2659   if (AC == 0)
2660     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2661   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2662     Unpredictable ();
2663   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2664   temp = (U8_4 (VL4_8 (DSPHI(AC)), VL4_8 (DSPLO(AC)))
2665           - ((signed64) EXTEND32 (GPR[RT]) * (signed64) EXTEND32 (GPR[RS])));
2666   DSPLO(AC) = EXTEND32 (temp);
2667   DSPHI(AC) = EXTEND32 (VH4_8 (temp));
2668   if (AC == 0)
2669     TRACE_ALU_RESULT2 (HI, LO);
2670 }
2671
2672
2673 011100,5.RS,5.RT,00000,00000,000101:SPECIAL2:32::MSUBU
2674 "msubu r<RS>, r<RT>"
2675 *mips32:
2676 *mips64:
2677 *vr5500:
2678 {
2679   unsigned64 temp;
2680   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2681   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2682     Unpredictable ();
2683   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2684   temp = (U8_4 (VL4_8 (HI), VL4_8 (LO))
2685           - ((unsigned64) VL4_8 (GPR[RS]) * (unsigned64) VL4_8 (GPR[RT])));
2686   LO = EXTEND32 (temp);
2687   HI = EXTEND32 (VH4_8 (temp));
2688   TRACE_ALU_RESULT2 (HI, LO);
2689 }
2690
2691
2692 011100,5.RS,5.RT,000,2.AC,00000,000101:SPECIAL2:32::MSUBU
2693 "msubu r<RS>, r<RT>":AC == 0
2694 "msubu ac<AC>, r<RS>, r<RT>"
2695 *mips32r2:
2696 *mips64r2:
2697 *dsp2:
2698 {
2699   unsigned64 temp;
2700   if (AC == 0)
2701     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2702   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2703     Unpredictable ();
2704   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2705   temp = (U8_4 (VL4_8 (DSPHI(AC)), VL4_8 (DSPLO(AC)))
2706           - ((unsigned64) VL4_8 (GPR[RS]) * (unsigned64) VL4_8 (GPR[RT])));
2707   DSPLO(AC) = EXTEND32 (temp);
2708   DSPHI(AC) = EXTEND32 (VH4_8 (temp));
2709   if (AC == 0)
2710     TRACE_ALU_RESULT2 (HI, LO);
2711 }
2712
2713
2714 000000,5.RS,000000000000000,010001:SPECIAL:32::MTHI
2715 "mthi r<RS>"
2716 *mipsI:
2717 *mipsII:
2718 *mipsIII:
2719 *mipsIV:
2720 *mipsV:
2721 *vr4100:
2722 *vr5000:
2723 *r3900:
2724 *mips32:
2725 *mips64:
2726 {
2727   check_mt_hilo (SD_, HIHISTORY);
2728   HI = GPR[RS];
2729 }
2730
2731
2732 000000,5.RS,00000,000,2.AC,00000,010001:SPECIAL:32::MTHI
2733 "mthi r<RS>":AC == 0
2734 "mthi r<RS>, ac<AC>"
2735 *mips32r2:
2736 *mips64r2:
2737 *dsp:
2738 {
2739   if (AC == 0)
2740     check_mt_hilo (SD_, HIHISTORY);
2741   DSPHI(AC) = GPR[RS];
2742 }
2743
2744
2745 000000,5.RS,000000000000000,010011:SPECIAL:32::MTLO
2746 "mtlo r<RS>"
2747 *mipsI:
2748 *mipsII:
2749 *mipsIII:
2750 *mipsIV:
2751 *mipsV:
2752 *vr4100:
2753 *vr5000:
2754 *r3900:
2755 *mips32:
2756 *mips64:
2757 {
2758   check_mt_hilo (SD_, LOHISTORY);
2759   LO = GPR[RS];
2760 }
2761
2762
2763 000000,5.RS,00000,000,2.AC,00000,010011:SPECIAL:32::MTLO
2764 "mtlo r<RS>":AC == 0
2765 "mtlo r<RS>, ac<AC>"
2766 *mips32r2:
2767 *mips64r2:
2768 *dsp:
2769 {
2770   if (AC == 0)
2771     check_mt_hilo (SD_, LOHISTORY);
2772   DSPLO(AC) = GPR[RS];
2773 }
2774
2775
2776 011100,5.RS,5.RT,5.RD,00000,000010:SPECIAL2:32::MUL
2777 "mul r<RD>, r<RS>, r<RT>"
2778 *mips32:
2779 *mips32r2:
2780 *mips64:
2781 *mips64r2:
2782 *vr5500:
2783 {
2784   signed64 prod;
2785   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2786     Unpredictable ();
2787   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2788   prod = (((signed64)(signed32) GPR[RS])
2789           * ((signed64)(signed32) GPR[RT]));
2790   GPR[RD] = EXTEND32 (VL4_8 (prod));
2791   TRACE_ALU_RESULT (GPR[RD]);
2792 }
2793
2794
2795
2796 :function:::void:do_mult:int rs, int rt, int rd
2797 {
2798   signed64 prod;
2799   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2800   if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
2801     Unpredictable ();
2802   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2803   prod = (((signed64)(signed32) GPR[rs])
2804           * ((signed64)(signed32) GPR[rt]));
2805   LO = EXTEND32 (VL4_8 (prod));
2806   HI = EXTEND32 (VH4_8 (prod));
2807   ACX = 0;  /* SmartMIPS */
2808   if (rd != 0)
2809     GPR[rd] = LO;
2810   TRACE_ALU_RESULT2 (HI, LO);
2811 }
2812
2813 000000,5.RS,5.RT,0000000000,011000:SPECIAL:32::MULT
2814 "mult r<RS>, r<RT>"
2815 *mipsI:
2816 *mipsII:
2817 *mipsIII:
2818 *mipsIV:
2819 *mipsV:
2820 *mips32:
2821 *mips64:
2822 *vr4100:
2823 {
2824   do_mult (SD_, RS, RT, 0);
2825 }
2826
2827
2828 000000,5.RS,5.RT,000,2.AC,00000,011000:SPECIAL:32::MULT
2829 "mult r<RS>, r<RT>":AC == 0
2830 "mult ac<AC>, r<RS>, r<RT>"
2831 *mips32r2:
2832 *mips64r2:
2833 *dsp2:
2834 {
2835   signed64 prod;
2836   if (AC == 0)
2837     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2838   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2839     Unpredictable ();
2840   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2841   prod = ((signed64)(signed32) GPR[RS])
2842           * ((signed64)(signed32) GPR[RT]);
2843   DSPLO(AC) = EXTEND32 (VL4_8 (prod));
2844   DSPHI(AC) = EXTEND32 (VH4_8 (prod));
2845   if (AC == 0)
2846     {
2847       ACX = 0;  /* SmartMIPS */
2848       TRACE_ALU_RESULT2 (HI, LO);
2849     }
2850 }
2851
2852
2853 000000,5.RS,5.RT,5.RD,00000,011000:SPECIAL:32::MULT
2854 "mult r<RS>, r<RT>":RD == 0
2855 "mult r<RD>, r<RS>, r<RT>"
2856 *vr5000:
2857 *r3900:
2858 {
2859   do_mult (SD_, RS, RT, RD);
2860 }
2861
2862
2863 :function:::void:do_multu:int rs, int rt, int rd
2864 {
2865   unsigned64 prod;
2866   check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2867   if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
2868     Unpredictable ();
2869   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2870   prod = (((unsigned64)(unsigned32) GPR[rs])
2871           * ((unsigned64)(unsigned32) GPR[rt]));
2872   LO = EXTEND32 (VL4_8 (prod));
2873   HI = EXTEND32 (VH4_8 (prod));
2874   if (rd != 0)
2875     GPR[rd] = LO;
2876   TRACE_ALU_RESULT2 (HI, LO);
2877 }
2878
2879 000000,5.RS,5.RT,0000000000,011001:SPECIAL:32::MULTU
2880 "multu r<RS>, r<RT>"
2881 *mipsI:
2882 *mipsII:
2883 *mipsIII:
2884 *mipsIV:
2885 *mipsV:
2886 *mips32:
2887 *mips64:
2888 *vr4100:
2889 {
2890   do_multu (SD_, RS, RT, 0);
2891 }
2892
2893
2894 000000,5.RS,5.RT,000,2.AC,00000,011001:SPECIAL:32::MULTU
2895 "multu r<RS>, r<RT>":AC == 0
2896 "multu r<RS>, r<RT>"
2897 *mips32r2:
2898 *mips64r2:
2899 *dsp2:
2900 {
2901   unsigned64 prod;
2902   if (AC == 0)
2903     check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2904   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
2905     Unpredictable ();
2906   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
2907   prod = ((unsigned64)(unsigned32) GPR[RS])
2908           * ((unsigned64)(unsigned32) GPR[RT]);
2909   DSPLO(AC) = EXTEND32 (VL4_8 (prod));
2910   DSPHI(AC) = EXTEND32 (VH4_8 (prod));
2911   if (AC == 0)
2912     TRACE_ALU_RESULT2 (HI, LO);
2913 }
2914
2915
2916 000000,5.RS,5.RT,5.RD,00000,011001:SPECIAL:32::MULTU
2917 "multu r<RS>, r<RT>":RD == 0
2918 "multu r<RD>, r<RS>, r<RT>"
2919 *vr5000:
2920 *r3900:
2921 {
2922   do_multu (SD_, RS, RT, RD);
2923 }
2924
2925
2926 :function:::void:do_nor:int rs, int rt, int rd
2927 {
2928   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2929   GPR[rd] = ~ (GPR[rs] | GPR[rt]);
2930   TRACE_ALU_RESULT (GPR[rd]);
2931 }
2932
2933 000000,5.RS,5.RT,5.RD,00000,100111:SPECIAL:32::NOR
2934 "nor r<RD>, r<RS>, r<RT>"
2935 *mipsI:
2936 *mipsII:
2937 *mipsIII:
2938 *mipsIV:
2939 *mipsV:
2940 *mips32:
2941 *mips32r2:
2942 *mips64:
2943 *mips64r2:
2944 *vr4100:
2945 *vr5000:
2946 *r3900:
2947 {
2948   do_nor (SD_, RS, RT, RD);
2949 }
2950
2951
2952 :function:::void:do_or:int rs, int rt, int rd
2953 {
2954   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2955   GPR[rd] = (GPR[rs] | GPR[rt]);
2956   TRACE_ALU_RESULT (GPR[rd]);
2957 }
2958
2959 000000,5.RS,5.RT,5.RD,00000,100101:SPECIAL:32::OR
2960 "or r<RD>, r<RS>, r<RT>"
2961 *mipsI:
2962 *mipsII:
2963 *mipsIII:
2964 *mipsIV:
2965 *mipsV:
2966 *mips32:
2967 *mips32r2:
2968 *mips64:
2969 *mips64r2:
2970 *vr4100:
2971 *vr5000:
2972 *r3900:
2973 {
2974   do_or (SD_, RS, RT, RD);
2975 }
2976
2977
2978
2979 :function:::void:do_ori:int rs, int rt, unsigned immediate
2980 {
2981   TRACE_ALU_INPUT2 (GPR[rs], immediate);
2982   GPR[rt] = (GPR[rs] | immediate);
2983   TRACE_ALU_RESULT (GPR[rt]);
2984 }
2985
2986 001101,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ORI
2987 "ori r<RT>, r<RS>, %#lx<IMMEDIATE>"
2988 *mipsI:
2989 *mipsII:
2990 *mipsIII:
2991 *mipsIV:
2992 *mipsV:
2993 *mips32:
2994 *mips32r2:
2995 *mips64:
2996 *mips64r2:
2997 *vr4100:
2998 *vr5000:
2999 *r3900:
3000 {
3001   do_ori (SD_, RS, RT, IMMEDIATE);
3002 }
3003
3004
3005 110011,5.BASE,5.HINT,16.OFFSET:NORMAL:32::PREF
3006 "pref <HINT>, <OFFSET>(r<BASE>)"
3007 *mipsIV:
3008 *mipsV:
3009 *mips32:
3010 *mips32r2:
3011 *mips64:
3012 *mips64r2:
3013 *vr5000:
3014 {
3015   address_word base = GPR[BASE];
3016   address_word offset = EXTEND16 (OFFSET);
3017   {
3018     address_word vaddr = loadstore_ea (SD_, base, offset);
3019     address_word paddr;
3020     int uncached;
3021     {
3022       if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
3023         Prefetch(uncached,paddr,vaddr,isDATA,HINT);
3024     }
3025   }
3026 }
3027
3028
3029 :function:::unsigned64:do_ror:unsigned32 x,unsigned32 y
3030 {
3031   unsigned64 result;
3032
3033   y &= 31;
3034   TRACE_ALU_INPUT2 (x, y);
3035   result = EXTEND32 (ROTR32 (x, y));
3036   TRACE_ALU_RESULT (result);
3037   return result;
3038 }
3039
3040 000000,00001,5.RT,5.RD,5.SHIFT,000010::32::ROR
3041 "ror r<RD>, r<RT>, <SHIFT>"
3042 *mips32r2:
3043 *mips64r2:
3044 *smartmips:
3045 *vr5400:
3046 *vr5500:
3047 {
3048   GPR[RD] = do_ror (SD_, GPR[RT], SHIFT);
3049 }
3050
3051 000000,5.RS,5.RT,5.RD,00001,000110::32::RORV
3052 "rorv r<RD>, r<RT>, r<RS>"
3053 *mips32r2:
3054 *mips64r2:
3055 *smartmips:
3056 *vr5400:
3057 *vr5500:
3058 {
3059   GPR[RD] = do_ror (SD_, GPR[RT], GPR[RS]);
3060 }
3061
3062
3063 :function:::void:do_store:unsigned access, address_word base, address_word offset, unsigned_word word
3064 {
3065   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3066   address_word reverseendian = (ReverseEndian ? (mask ^ access) : 0);
3067   address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
3068   unsigned int byte;
3069   address_word paddr;
3070   int uncached;
3071   unsigned64 memval;
3072   address_word vaddr;
3073
3074   vaddr = loadstore_ea (SD_, base, offset);
3075   if ((vaddr & access) != 0)
3076     {
3077       SIM_CORE_SIGNAL (SD, STATE_CPU(SD, 0), cia, read_map, access+1, vaddr, write_transfer, sim_core_unaligned_signal);
3078     }
3079   AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
3080   paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
3081   byte = ((vaddr & mask) ^ bigendiancpu);
3082   memval = (word << (8 * byte));
3083   StoreMemory (uncached, access, memval, 0, paddr, vaddr, isREAL);
3084 }
3085
3086 :function:::void:do_store_left:unsigned access, address_word base, address_word offset, unsigned_word rt
3087 {
3088   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3089   address_word reverseendian = (ReverseEndian ? -1 : 0);
3090   address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
3091   unsigned int byte;
3092   unsigned int word;
3093   address_word paddr;
3094   int uncached;
3095   unsigned64 memval;
3096   address_word vaddr;
3097   int nr_lhs_bits;
3098   int nr_rhs_bits;
3099
3100   vaddr = loadstore_ea (SD_, base, offset);
3101   AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
3102   paddr = (paddr ^ (reverseendian & mask));
3103   if (BigEndianMem == 0)
3104     paddr = paddr & ~access;
3105
3106   /* compute where within the word/mem we are */
3107   byte = ((vaddr ^ bigendiancpu) & access); /* 0..access */
3108   word = ((vaddr ^ bigendiancpu) & (mask & ~access)) / (access + 1); /* 0..1 */
3109   nr_lhs_bits = 8 * byte + 8;
3110   nr_rhs_bits = 8 * access - 8 * byte;
3111   /* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
3112   /* fprintf (stderr, "s[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
3113            (long) ((unsigned64) vaddr >> 32), (long) vaddr,
3114            (long) ((unsigned64) paddr >> 32), (long) paddr,
3115            word, byte, nr_lhs_bits, nr_rhs_bits); */
3116
3117   if (word == 0)
3118     {
3119       memval = (rt >> nr_rhs_bits);
3120     }
3121   else
3122     {
3123       memval = (rt << nr_lhs_bits);
3124     }
3125   /* fprintf (stderr, "s[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx\n",
3126            (long) ((unsigned64) rt >> 32), (long) rt,
3127            (long) ((unsigned64) memval >> 32), (long) memval); */
3128   StoreMemory (uncached, byte, memval, 0, paddr, vaddr, isREAL);
3129 }
3130
3131 :function:::void:do_store_right:unsigned access, address_word base, address_word offset, unsigned_word rt
3132 {
3133   address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3134   address_word reverseendian = (ReverseEndian ? -1 : 0);
3135   address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
3136   unsigned int byte;
3137   address_word paddr;
3138   int uncached;
3139   unsigned64 memval;
3140   address_word vaddr;
3141
3142   vaddr = loadstore_ea (SD_, base, offset);
3143   AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
3144   paddr = (paddr ^ (reverseendian & mask));
3145   if (BigEndianMem != 0)
3146     paddr &= ~access;
3147   byte = ((vaddr & mask) ^ (bigendiancpu & mask));
3148   memval = (rt << (byte * 8));
3149   StoreMemory (uncached, access - (access & byte), memval, 0, paddr, vaddr, isREAL);
3150 }
3151
3152
3153 101000,5.BASE,5.RT,16.OFFSET:NORMAL:32::SB
3154 "sb r<RT>, <OFFSET>(r<BASE>)"
3155 *mipsI:
3156 *mipsII:
3157 *mipsIII:
3158 *mipsIV:
3159 *mipsV:
3160 *mips32:
3161 *mips32r2:
3162 *mips64:
3163 *mips64r2:
3164 *vr4100:
3165 *vr5000:
3166 *r3900:
3167 {
3168   do_store (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3169 }
3170
3171
3172 111000,5.BASE,5.RT,16.OFFSET:NORMAL:32::SC
3173 "sc r<RT>, <OFFSET>(r<BASE>)"
3174 *mipsII:
3175 *mipsIII:
3176 *mipsIV:
3177 *mipsV:
3178 *mips32:
3179 *mips32r2:
3180 *mips64:
3181 *mips64r2:
3182 *vr4100:
3183 *vr5000:
3184 {
3185   unsigned32 instruction = instruction_0;
3186   address_word base = GPR[BASE];
3187   address_word offset = EXTEND16 (OFFSET);
3188   {
3189     address_word vaddr = loadstore_ea (SD_, base, offset);
3190     address_word paddr;
3191     int uncached;
3192     if ((vaddr & 3) != 0)
3193       {
3194         SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 4, vaddr, write_transfer, sim_core_unaligned_signal);
3195       }
3196     else
3197       {
3198         if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
3199           {
3200             unsigned64 memval = 0;
3201             unsigned64 memval1 = 0;
3202             unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3203             address_word reverseendian = (ReverseEndian ? (mask ^ AccessLength_WORD) : 0);
3204             address_word bigendiancpu = (BigEndianCPU ? (mask ^ AccessLength_WORD) : 0);
3205             unsigned int byte;
3206             paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
3207             byte = ((vaddr & mask) ^ bigendiancpu);
3208             memval = ((unsigned64) GPR[RT] << (8 * byte));
3209             if (LLBIT)
3210               {
3211                 StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
3212               }
3213             GPR[RT] = LLBIT;
3214           }
3215       }
3216   }
3217 }
3218
3219
3220 111100,5.BASE,5.RT,16.OFFSET:NORMAL:64::SCD
3221 "scd r<RT>, <OFFSET>(r<BASE>)"
3222 *mipsIII:
3223 *mipsIV:
3224 *mipsV:
3225 *mips64:
3226 *mips64r2:
3227 *vr4100:
3228 *vr5000:
3229 {
3230   address_word base = GPR[BASE];
3231   address_word offset = EXTEND16 (OFFSET);
3232   check_u64 (SD_, instruction_0);
3233   {
3234     address_word vaddr = loadstore_ea (SD_, base, offset);
3235     address_word paddr;
3236     int uncached;
3237     if ((vaddr & 7) != 0)
3238       {
3239         SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 8, vaddr, write_transfer, sim_core_unaligned_signal);
3240       }
3241     else
3242       {
3243         if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
3244           {
3245             unsigned64 memval = 0;
3246             unsigned64 memval1 = 0;
3247             memval = GPR[RT];
3248             if (LLBIT)
3249               {
3250                 StoreMemory(uncached,AccessLength_DOUBLEWORD,memval,memval1,paddr,vaddr,isREAL);
3251               }
3252             GPR[RT] = LLBIT;
3253           }
3254       }
3255   }
3256 }
3257
3258
3259 111111,5.BASE,5.RT,16.OFFSET:NORMAL:64::SD
3260 "sd r<RT>, <OFFSET>(r<BASE>)"
3261 *mipsIII:
3262 *mipsIV:
3263 *mipsV:
3264 *mips64:
3265 *mips64r2:
3266 *vr4100:
3267 *vr5000:
3268 {
3269   check_u64 (SD_, instruction_0);
3270   do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3271 }
3272
3273
3274 1111,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDCz
3275 "sdc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
3276 *mipsII:
3277 *mipsIII:
3278 *mipsIV:
3279 *mipsV:
3280 *mips32:
3281 *mips32r2:
3282 *mips64:
3283 *mips64r2:
3284 *vr4100:
3285 *vr5000:
3286 {
3287   do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), COP_SD (ZZ, RT));
3288 }
3289
3290
3291 101100,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDL
3292 "sdl r<RT>, <OFFSET>(r<BASE>)"
3293 *mipsIII:
3294 *mipsIV:
3295 *mipsV:
3296 *mips64:
3297 *mips64r2:
3298 *vr4100:
3299 *vr5000:
3300 {
3301   check_u64 (SD_, instruction_0);
3302   do_store_left (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3303 }
3304
3305
3306 101101,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDR
3307 "sdr r<RT>, <OFFSET>(r<BASE>)"
3308 *mipsIII:
3309 *mipsIV:
3310 *mipsV:
3311 *mips64:
3312 *mips64r2:
3313 *vr4100:
3314 *vr5000:
3315 {
3316   check_u64 (SD_, instruction_0);
3317   do_store_right (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3318 }
3319
3320
3321
3322 101001,5.BASE,5.RT,16.OFFSET:NORMAL:32::SH
3323 "sh r<RT>, <OFFSET>(r<BASE>)"
3324 *mipsI:
3325 *mipsII:
3326 *mipsIII:
3327 *mipsIV:
3328 *mipsV:
3329 *mips32:
3330 *mips32r2:
3331 *mips64:
3332 *mips64r2:
3333 *vr4100:
3334 *vr5000:
3335 *r3900:
3336 {
3337   do_store (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3338 }
3339
3340
3341 :function:::void:do_sll:int rt, int rd, int shift
3342 {
3343   unsigned32 temp = (GPR[rt] << shift);
3344   TRACE_ALU_INPUT2 (GPR[rt], shift);
3345   GPR[rd] = EXTEND32 (temp);
3346   TRACE_ALU_RESULT (GPR[rd]);
3347 }
3348
3349 000000,00000,5.RT,5.RD,5.SHIFT,000000:SPECIAL:32::SLLa
3350 "nop":RD == 0 && RT == 0 && SHIFT == 0
3351 "sll r<RD>, r<RT>, <SHIFT>"
3352 *mipsI:
3353 *mipsII:
3354 *mipsIII:
3355 *mipsIV:
3356 *mipsV:
3357 *vr4100:
3358 *vr5000:
3359 *r3900:
3360 {
3361   /* Skip shift for NOP, so that there won't be lots of extraneous
3362      trace output.  */
3363   if (RD != 0 || RT != 0 || SHIFT != 0)
3364     do_sll (SD_, RT, RD, SHIFT);
3365 }
3366
3367 000000,00000,5.RT,5.RD,5.SHIFT,000000:SPECIAL:32::SLLb
3368 "nop":RD == 0 && RT == 0 && SHIFT == 0
3369 "ssnop":RD == 0 && RT == 0 && SHIFT == 1
3370 "sll r<RD>, r<RT>, <SHIFT>"
3371 *mips32:
3372 *mips32r2:
3373 *mips64:
3374 *mips64r2:
3375 {
3376   /* Skip shift for NOP and SSNOP, so that there won't be lots of
3377      extraneous trace output.  */
3378   if (RD != 0 || RT != 0 || (SHIFT != 0 && SHIFT != 1))
3379     do_sll (SD_, RT, RD, SHIFT);
3380 }
3381
3382
3383 :function:::void:do_sllv:int rs, int rt, int rd
3384 {
3385   int s = MASKED (GPR[rs], 4, 0);
3386   unsigned32 temp = (GPR[rt] << s);
3387   TRACE_ALU_INPUT2 (GPR[rt], s);
3388   GPR[rd] = EXTEND32 (temp);
3389   TRACE_ALU_RESULT (GPR[rd]);
3390 }
3391
3392 000000,5.RS,5.RT,5.RD,00000,000100:SPECIAL:32::SLLV
3393 "sllv r<RD>, r<RT>, r<RS>"
3394 *mipsI:
3395 *mipsII:
3396 *mipsIII:
3397 *mipsIV:
3398 *mipsV:
3399 *mips32:
3400 *mips32r2:
3401 *mips64:
3402 *mips64r2:
3403 *vr4100:
3404 *vr5000:
3405 *r3900:
3406 {
3407   do_sllv (SD_, RS, RT, RD);
3408 }
3409
3410
3411 :function:::void:do_slt:int rs, int rt, int rd
3412 {
3413   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3414   GPR[rd] = ((signed_word) GPR[rs] < (signed_word) GPR[rt]);
3415   TRACE_ALU_RESULT (GPR[rd]);
3416 }
3417
3418 000000,5.RS,5.RT,5.RD,00000,101010:SPECIAL:32::SLT
3419 "slt r<RD>, r<RS>, r<RT>"
3420 *mipsI:
3421 *mipsII:
3422 *mipsIII:
3423 *mipsIV:
3424 *mipsV:
3425 *mips32:
3426 *mips32r2:
3427 *mips64:
3428 *mips64r2:
3429 *vr4100:
3430 *vr5000:
3431 *r3900:
3432 {
3433   do_slt (SD_, RS, RT, RD);
3434 }
3435
3436
3437 :function:::void:do_slti:int rs, int rt, unsigned16 immediate
3438 {
3439   TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
3440   GPR[rt] = ((signed_word) GPR[rs] < (signed_word) EXTEND16 (immediate));
3441   TRACE_ALU_RESULT (GPR[rt]);
3442 }
3443
3444 001010,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::SLTI
3445 "slti r<RT>, r<RS>, <IMMEDIATE>"
3446 *mipsI:
3447 *mipsII:
3448 *mipsIII:
3449 *mipsIV:
3450 *mipsV:
3451 *mips32:
3452 *mips32r2:
3453 *mips64:
3454 *mips64r2:
3455 *vr4100:
3456 *vr5000:
3457 *r3900:
3458 {
3459   do_slti (SD_, RS, RT, IMMEDIATE);
3460 }
3461
3462
3463 :function:::void:do_sltiu:int rs, int rt, unsigned16 immediate
3464 {
3465   TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
3466   GPR[rt] = ((unsigned_word) GPR[rs] < (unsigned_word) EXTEND16 (immediate));
3467   TRACE_ALU_RESULT (GPR[rt]);
3468 }
3469
3470 001011,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::SLTIU
3471 "sltiu r<RT>, r<RS>, <IMMEDIATE>"
3472 *mipsI:
3473 *mipsII:
3474 *mipsIII:
3475 *mipsIV:
3476 *mipsV:
3477 *mips32:
3478 *mips32r2:
3479 *mips64:
3480 *mips64r2:
3481 *vr4100:
3482 *vr5000:
3483 *r3900:
3484 {
3485   do_sltiu (SD_, RS, RT, IMMEDIATE);
3486 }
3487
3488
3489
3490 :function:::void:do_sltu:int rs, int rt, int rd
3491 {
3492   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3493   GPR[rd] = ((unsigned_word) GPR[rs] < (unsigned_word) GPR[rt]);
3494   TRACE_ALU_RESULT (GPR[rd]);
3495 }
3496
3497 000000,5.RS,5.RT,5.RD,00000,101011:SPECIAL:32::SLTU
3498 "sltu r<RD>, r<RS>, r<RT>"
3499 *mipsI:
3500 *mipsII:
3501 *mipsIII:
3502 *mipsIV:
3503 *mipsV:
3504 *mips32:
3505 *mips32r2:
3506 *mips64:
3507 *mips64r2:
3508 *vr4100:
3509 *vr5000:
3510 *r3900:
3511 {
3512   do_sltu (SD_, RS, RT, RD);
3513 }
3514
3515
3516 :function:::void:do_sra:int rt, int rd, int shift
3517 {
3518   signed32 temp = (signed32) GPR[rt] >> shift;
3519   if (NotWordValue (GPR[rt]))
3520     Unpredictable ();
3521   TRACE_ALU_INPUT2 (GPR[rt], shift);
3522   GPR[rd] = EXTEND32 (temp);
3523   TRACE_ALU_RESULT (GPR[rd]);
3524 }
3525
3526 000000,00000,5.RT,5.RD,5.SHIFT,000011:SPECIAL:32::SRA
3527 "sra r<RD>, r<RT>, <SHIFT>"
3528 *mipsI:
3529 *mipsII:
3530 *mipsIII:
3531 *mipsIV:
3532 *mipsV:
3533 *mips32:
3534 *mips32r2:
3535 *mips64:
3536 *mips64r2:
3537 *vr4100:
3538 *vr5000:
3539 *r3900:
3540 {
3541   do_sra (SD_, RT, RD, SHIFT);
3542 }
3543
3544
3545
3546 :function:::void:do_srav:int rs, int rt, int rd
3547 {
3548   int s = MASKED (GPR[rs], 4, 0);
3549   signed32 temp = (signed32) GPR[rt] >> s;
3550   if (NotWordValue (GPR[rt]))
3551     Unpredictable ();
3552   TRACE_ALU_INPUT2 (GPR[rt], s);
3553   GPR[rd] = EXTEND32 (temp);
3554   TRACE_ALU_RESULT (GPR[rd]);
3555 }
3556
3557 000000,5.RS,5.RT,5.RD,00000,000111:SPECIAL:32::SRAV
3558 "srav r<RD>, r<RT>, r<RS>"
3559 *mipsI:
3560 *mipsII:
3561 *mipsIII:
3562 *mipsIV:
3563 *mipsV:
3564 *mips32:
3565 *mips32r2:
3566 *mips64:
3567 *mips64r2:
3568 *vr4100:
3569 *vr5000:
3570 *r3900:
3571 {
3572   do_srav (SD_, RS, RT, RD);
3573 }
3574
3575
3576
3577 :function:::void:do_srl:int rt, int rd, int shift
3578 {
3579   unsigned32 temp = (unsigned32) GPR[rt] >> shift;
3580   if (NotWordValue (GPR[rt]))
3581     Unpredictable ();
3582   TRACE_ALU_INPUT2 (GPR[rt], shift);
3583   GPR[rd] = EXTEND32 (temp);
3584   TRACE_ALU_RESULT (GPR[rd]);
3585 }
3586
3587 000000,00000,5.RT,5.RD,5.SHIFT,000010:SPECIAL:32::SRL
3588 "srl r<RD>, r<RT>, <SHIFT>"
3589 *mipsI:
3590 *mipsII:
3591 *mipsIII:
3592 *mipsIV:
3593 *mipsV:
3594 *mips32:
3595 *mips32r2:
3596 *mips64:
3597 *mips64r2:
3598 *vr4100:
3599 *vr5000:
3600 *r3900:
3601 {
3602   do_srl (SD_, RT, RD, SHIFT);
3603 }
3604
3605
3606 :function:::void:do_srlv:int rs, int rt, int rd
3607 {
3608   int s = MASKED (GPR[rs], 4, 0);
3609   unsigned32 temp = (unsigned32) GPR[rt] >> s;
3610   if (NotWordValue (GPR[rt]))
3611     Unpredictable ();
3612   TRACE_ALU_INPUT2 (GPR[rt], s);
3613   GPR[rd] = EXTEND32 (temp);
3614   TRACE_ALU_RESULT (GPR[rd]);
3615 }
3616
3617 000000,5.RS,5.RT,5.RD,00000,000110:SPECIAL:32::SRLV
3618 "srlv r<RD>, r<RT>, r<RS>"
3619 *mipsI:
3620 *mipsII:
3621 *mipsIII:
3622 *mipsIV:
3623 *mipsV:
3624 *mips32:
3625 *mips32r2:
3626 *mips64:
3627 *mips64r2:
3628 *vr4100:
3629 *vr5000:
3630 *r3900:
3631 {
3632   do_srlv (SD_, RS, RT, RD);
3633 }
3634
3635
3636 000000,5.RS,5.RT,5.RD,00000,100010:SPECIAL:32::SUB
3637 "sub r<RD>, r<RS>, r<RT>"
3638 *mipsI:
3639 *mipsII:
3640 *mipsIII:
3641 *mipsIV:
3642 *mipsV:
3643 *mips32:
3644 *mips32r2:
3645 *mips64:
3646 *mips64r2:
3647 *vr4100:
3648 *vr5000:
3649 *r3900:
3650 {
3651   if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT]))
3652     Unpredictable ();
3653   TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
3654   {
3655     ALU32_BEGIN (GPR[RS]);
3656     ALU32_SUB (GPR[RT]);
3657     ALU32_END (GPR[RD]);   /* This checks for overflow.  */
3658   }
3659   TRACE_ALU_RESULT (GPR[RD]);
3660 }
3661
3662
3663 :function:::void:do_subu:int rs, int rt, int rd
3664 {
3665   if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt]))
3666     Unpredictable ();
3667   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3668   GPR[rd] = EXTEND32 (GPR[rs] - GPR[rt]);
3669   TRACE_ALU_RESULT (GPR[rd]);
3670 }
3671
3672 000000,5.RS,5.RT,5.RD,00000,100011:SPECIAL:32::SUBU
3673 "subu r<RD>, r<RS>, r<RT>"
3674 *mipsI:
3675 *mipsII:
3676 *mipsIII:
3677 *mipsIV:
3678 *mipsV:
3679 *mips32:
3680 *mips32r2:
3681 *mips64:
3682 *mips64r2:
3683 *vr4100:
3684 *vr5000:
3685 *r3900:
3686 {
3687   do_subu (SD_, RS, RT, RD);
3688 }
3689
3690
3691 101011,5.BASE,5.RT,16.OFFSET:NORMAL:32::SW
3692 "sw r<RT>, <OFFSET>(r<BASE>)"
3693 *mipsI:
3694 *mipsII:
3695 *mipsIII:
3696 *mipsIV:
3697 *mipsV:
3698 *mips32:
3699 *mips32r2:
3700 *mips64:
3701 *mips64r2:
3702 *vr4100:
3703 *r3900:
3704 *vr5000:
3705 {
3706   do_store (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3707 }
3708
3709
3710 1110,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWCz
3711 "swc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
3712 *mipsI:
3713 *mipsII:
3714 *mipsIII:
3715 *mipsIV:
3716 *mipsV:
3717 *mips32:
3718 *mips32r2:
3719 *mips64:
3720 *mips64r2:
3721 *vr4100:
3722 *vr5000:
3723 *r3900:
3724 {
3725   do_store (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), COP_SW (ZZ, RT));
3726 }
3727
3728
3729 101010,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWL
3730 "swl r<RT>, <OFFSET>(r<BASE>)"
3731 *mipsI:
3732 *mipsII:
3733 *mipsIII:
3734 *mipsIV:
3735 *mipsV:
3736 *mips32:
3737 *mips32r2:
3738 *mips64:
3739 *mips64r2:
3740 *vr4100:
3741 *vr5000:
3742 *r3900:
3743 {
3744   do_store_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3745 }
3746
3747
3748 101110,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWR
3749 "swr r<RT>, <OFFSET>(r<BASE>)"
3750 *mipsI:
3751 *mipsII:
3752 *mipsIII:
3753 *mipsIV:
3754 *mipsV:
3755 *mips32:
3756 *mips32r2:
3757 *mips64:
3758 *mips64r2:
3759 *vr4100:
3760 *vr5000:
3761 *r3900:
3762 {
3763   do_store_right (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3764 }
3765
3766
3767 000000,000000000000000,5.STYPE,001111:SPECIAL:32::SYNC
3768 "sync":STYPE == 0
3769 "sync <STYPE>"
3770 *mipsII:
3771 *mipsIII:
3772 *mipsIV:
3773 *mipsV:
3774 *mips32:
3775 *mips32r2:
3776 *mips64:
3777 *mips64r2:
3778 *vr4100:
3779 *vr5000:
3780 *r3900:
3781 {
3782   SyncOperation (STYPE);
3783 }
3784
3785
3786 000000,20.CODE,001100:SPECIAL:32::SYSCALL
3787 "syscall %#lx<CODE>"
3788 *mipsI:
3789 *mipsII:
3790 *mipsIII:
3791 *mipsIV:
3792 *mipsV:
3793 *mips32:
3794 *mips32r2:
3795 *mips64:
3796 *mips64r2:
3797 *vr4100:
3798 *vr5000:
3799 *r3900:
3800 {
3801   SignalException (SystemCall, instruction_0);
3802 }
3803
3804
3805 000000,5.RS,5.RT,10.CODE,110100:SPECIAL:32::TEQ
3806 "teq r<RS>, r<RT>"
3807 *mipsII:
3808 *mipsIII:
3809 *mipsIV:
3810 *mipsV:
3811 *mips32:
3812 *mips32r2:
3813 *mips64:
3814 *mips64r2:
3815 *vr4100:
3816 *vr5000:
3817 {
3818   if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
3819     SignalException (Trap, instruction_0);
3820 }
3821
3822
3823 000001,5.RS,01100,16.IMMEDIATE:REGIMM:32::TEQI
3824 "teqi r<RS>, <IMMEDIATE>"
3825 *mipsII:
3826 *mipsIII:
3827 *mipsIV:
3828 *mipsV:
3829 *mips32:
3830 *mips32r2:
3831 *mips64:
3832 *mips64r2:
3833 *vr4100:
3834 *vr5000:
3835 {
3836   if ((signed_word) GPR[RS] == (signed_word) EXTEND16 (IMMEDIATE))
3837     SignalException (Trap, instruction_0);
3838 }
3839
3840
3841 000000,5.RS,5.RT,10.CODE,110000:SPECIAL:32::TGE
3842 "tge r<RS>, r<RT>"
3843 *mipsII:
3844 *mipsIII:
3845 *mipsIV:
3846 *mipsV:
3847 *mips32:
3848 *mips32r2:
3849 *mips64:
3850 *mips64r2:
3851 *vr4100:
3852 *vr5000:
3853 {
3854   if ((signed_word) GPR[RS] >= (signed_word) GPR[RT])
3855     SignalException (Trap, instruction_0);
3856 }
3857
3858
3859 000001,5.RS,01000,16.IMMEDIATE:REGIMM:32::TGEI
3860 "tgei r<RS>, <IMMEDIATE>"
3861 *mipsII:
3862 *mipsIII:
3863 *mipsIV:
3864 *mipsV:
3865 *mips32:
3866 *mips32r2:
3867 *mips64:
3868 *mips64r2:
3869 *vr4100:
3870 *vr5000:
3871 {
3872   if ((signed_word) GPR[RS] >= (signed_word) EXTEND16 (IMMEDIATE))
3873     SignalException (Trap, instruction_0);
3874 }
3875
3876
3877 000001,5.RS,01001,16.IMMEDIATE:REGIMM:32::TGEIU
3878 "tgeiu r<RS>, <IMMEDIATE>"
3879 *mipsII:
3880 *mipsIII:
3881 *mipsIV:
3882 *mipsV:
3883 *mips32:
3884 *mips32r2:
3885 *mips64:
3886 *mips64r2:
3887 *vr4100:
3888 *vr5000:
3889 {
3890   if ((unsigned_word) GPR[RS] >= (unsigned_word) EXTEND16 (IMMEDIATE))
3891     SignalException (Trap, instruction_0);
3892 }
3893
3894
3895 000000,5.RS,5.RT,10.CODE,110001:SPECIAL:32::TGEU
3896 "tgeu r<RS>, r<RT>"
3897 *mipsII:
3898 *mipsIII:
3899 *mipsIV:
3900 *mipsV:
3901 *mips32:
3902 *mips32r2:
3903 *mips64:
3904 *mips64r2:
3905 *vr4100:
3906 *vr5000:
3907 {
3908   if ((unsigned_word) GPR[RS] >= (unsigned_word) GPR[RT])
3909     SignalException (Trap, instruction_0);
3910 }
3911
3912
3913 000000,5.RS,5.RT,10.CODE,110010:SPECIAL:32::TLT
3914 "tlt r<RS>, r<RT>"
3915 *mipsII:
3916 *mipsIII:
3917 *mipsIV:
3918 *mipsV:
3919 *mips32:
3920 *mips32r2:
3921 *mips64:
3922 *mips64r2:
3923 *vr4100:
3924 *vr5000:
3925 {
3926   if ((signed_word) GPR[RS] < (signed_word) GPR[RT])
3927     SignalException (Trap, instruction_0);
3928 }
3929
3930
3931 000001,5.RS,01010,16.IMMEDIATE:REGIMM:32::TLTI
3932 "tlti r<RS>, <IMMEDIATE>"
3933 *mipsII:
3934 *mipsIII:
3935 *mipsIV:
3936 *mipsV:
3937 *mips32:
3938 *mips32r2:
3939 *mips64:
3940 *mips64r2:
3941 *vr4100:
3942 *vr5000:
3943 {
3944   if ((signed_word) GPR[RS] < (signed_word) EXTEND16 (IMMEDIATE))
3945     SignalException (Trap, instruction_0);
3946 }
3947
3948
3949 000001,5.RS,01011,16.IMMEDIATE:REGIMM:32::TLTIU
3950 "tltiu r<RS>, <IMMEDIATE>"
3951 *mipsII:
3952 *mipsIII:
3953 *mipsIV:
3954 *mipsV:
3955 *mips32:
3956 *mips32r2:
3957 *mips64:
3958 *mips64r2:
3959 *vr4100:
3960 *vr5000:
3961 {
3962   if ((unsigned_word) GPR[RS] < (unsigned_word) EXTEND16 (IMMEDIATE))
3963     SignalException (Trap, instruction_0);
3964 }
3965
3966
3967 000000,5.RS,5.RT,10.CODE,110011:SPECIAL:32::TLTU
3968 "tltu r<RS>, r<RT>"
3969 *mipsII:
3970 *mipsIII:
3971 *mipsIV:
3972 *mipsV:
3973 *mips32:
3974 *mips32r2:
3975 *mips64:
3976 *mips64r2:
3977 *vr4100:
3978 *vr5000:
3979 {
3980   if ((unsigned_word) GPR[RS] < (unsigned_word) GPR[RT])
3981     SignalException (Trap, instruction_0);
3982 }
3983
3984
3985 000000,5.RS,5.RT,10.CODE,110110:SPECIAL:32::TNE
3986 "tne r<RS>, r<RT>"
3987 *mipsII:
3988 *mipsIII:
3989 *mipsIV:
3990 *mipsV:
3991 *mips32:
3992 *mips32r2:
3993 *mips64:
3994 *mips64r2:
3995 *vr4100:
3996 *vr5000:
3997 {
3998   if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
3999     SignalException (Trap, instruction_0);
4000 }
4001
4002
4003 000001,5.RS,01110,16.IMMEDIATE:REGIMM:32::TNEI
4004 "tnei r<RS>, <IMMEDIATE>"
4005 *mipsII:
4006 *mipsIII:
4007 *mipsIV:
4008 *mipsV:
4009 *mips32:
4010 *mips32r2:
4011 *mips64:
4012 *mips64r2:
4013 *vr4100:
4014 *vr5000:
4015 {
4016   if ((signed_word) GPR[RS] != (signed_word) EXTEND16 (IMMEDIATE))
4017     SignalException (Trap, instruction_0);
4018 }
4019
4020
4021 :function:::void:do_xor:int rs, int rt, int rd
4022 {
4023   TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
4024   GPR[rd] = GPR[rs] ^ GPR[rt];
4025   TRACE_ALU_RESULT (GPR[rd]);
4026 }
4027
4028 000000,5.RS,5.RT,5.RD,00000,100110:SPECIAL:32::XOR
4029 "xor r<RD>, r<RS>, r<RT>"
4030 *mipsI:
4031 *mipsII:
4032 *mipsIII:
4033 *mipsIV:
4034 *mipsV:
4035 *mips32:
4036 *mips32r2:
4037 *mips64:
4038 *mips64r2:
4039 *vr4100:
4040 *vr5000:
4041 *r3900:
4042 {
4043   do_xor (SD_, RS, RT, RD);
4044 }
4045
4046
4047 :function:::void:do_xori:int rs, int rt, unsigned16 immediate
4048 {
4049   TRACE_ALU_INPUT2 (GPR[rs], immediate);
4050   GPR[rt] = GPR[rs] ^ immediate;
4051   TRACE_ALU_RESULT (GPR[rt]);
4052 }
4053
4054 001110,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::XORI
4055 "xori r<RT>, r<RS>, %#lx<IMMEDIATE>"
4056 *mipsI:
4057 *mipsII:
4058 *mipsIII:
4059 *mipsIV:
4060 *mipsV:
4061 *mips32:
4062 *mips32r2:
4063 *mips64:
4064 *mips64r2:
4065 *vr4100:
4066 *vr5000:
4067 *r3900:
4068 {
4069   do_xori (SD_, RS, RT, IMMEDIATE);
4070 }
4071
4072 \f
4073 //
4074 // MIPS Architecture:
4075 //
4076 //        FPU Instruction Set (COP1 & COP1X)
4077 //
4078
4079
4080 :%s::::FMT:int fmt
4081 {
4082   switch (fmt)
4083     {
4084     case fmt_single: return "s";
4085     case fmt_double: return "d";
4086     case fmt_word: return "w";
4087     case fmt_long: return "l";
4088     case fmt_ps: return "ps";
4089     default: return "?";
4090     }
4091 }
4092
4093 :%s::::TF:int tf
4094 {
4095   if (tf)
4096     return "t";
4097   else
4098     return "f";
4099 }
4100
4101 :%s::::ND:int nd
4102 {
4103   if (nd)
4104     return "l";
4105   else
4106     return "";
4107 }
4108
4109 :%s::::COND:int cond
4110 {
4111   switch (cond)
4112     {
4113     case 00: return "f";
4114     case 01: return "un";
4115     case 02: return "eq";
4116     case 03: return "ueq";
4117     case 04: return "olt";
4118     case 05: return "ult";
4119     case 06: return "ole";
4120     case 07: return "ule";
4121     case 010: return "sf";
4122     case 011: return "ngle";
4123     case 012: return "seq";
4124     case 013: return "ngl";
4125     case 014: return "lt";
4126     case 015: return "nge";
4127     case 016: return "le";
4128     case 017: return "ngt";
4129     default: return "?";
4130     }
4131 }
4132
4133
4134 // Helpers:
4135 //
4136 // Check that the given FPU format is usable, and signal a
4137 // ReservedInstruction exception if not.
4138 //
4139
4140 // check_fmt_p checks that the format is single, double, or paired single.
4141 :function:::void:check_fmt_p:int fmt, instruction_word insn
4142 *mipsI:
4143 *mipsII:
4144 *mipsIII:
4145 *mipsIV:
4146 *mips32:
4147 *mips32r2:
4148 *vr4100:
4149 *vr5000:
4150 *r3900:
4151 {
4152   /* None of these ISAs support Paired Single, so just fall back to
4153      the single/double check.  */
4154   if ((fmt != fmt_single) && (fmt != fmt_double))
4155     SignalException (ReservedInstruction, insn);
4156 }
4157
4158 :function:::void:check_fmt_p:int fmt, instruction_word insn
4159 *mipsV:
4160 *mips64:
4161 *mips64r2:
4162 {
4163   if ((fmt != fmt_single) && (fmt != fmt_double)
4164       && (fmt != fmt_ps || (UserMode && (SR & (status_UX|status_PX)) == 0)))
4165     SignalException (ReservedInstruction, insn);
4166 }
4167
4168
4169 // Helper:
4170 //
4171 // Check that the FPU is currently usable, and signal a CoProcessorUnusable
4172 // exception if not.
4173 //
4174
4175 :function:::void:check_fpu:
4176 *mipsI:
4177 *mipsII:
4178 *mipsIII:
4179 *mipsIV:
4180 *mipsV:
4181 *mips32:
4182 *mips32r2:
4183 *mips64:
4184 *mips64r2:
4185 *vr4100:
4186 *vr5000:
4187 *r3900:
4188 {
4189   if (! COP_Usable (1))
4190     SignalExceptionCoProcessorUnusable (1);
4191 }
4192
4193
4194 // Helper:
4195 //
4196 // Load a double word FP value using 2 32-bit memory cycles a la MIPS II
4197 // or MIPS32.  do_load cannot be used instead because it returns an
4198 // unsigned_word, which is limited to the size of the machine's registers.
4199 //
4200
4201 :function:::unsigned64:do_load_double:address_word base, address_word offset
4202 *mipsII:
4203 *mips32:
4204 *mips32r2:
4205 {
4206   int bigendian = (BigEndianCPU ? ! ReverseEndian : ReverseEndian);
4207   address_word vaddr;
4208   address_word paddr;
4209   int uncached;
4210   unsigned64 memval;
4211   unsigned64 v;
4212
4213   vaddr = loadstore_ea (SD_, base, offset);
4214   if ((vaddr & AccessLength_DOUBLEWORD) != 0)
4215     {
4216       SIM_CORE_SIGNAL (SD, STATE_CPU (SD, 0), cia, read_map,
4217                        AccessLength_DOUBLEWORD + 1, vaddr, read_transfer,
4218                        sim_core_unaligned_signal);
4219     }
4220   AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET,
4221                       isREAL);
4222   LoadMemory (&memval, NULL, uncached, AccessLength_WORD, paddr, vaddr,
4223               isDATA, isREAL);
4224   v = (unsigned64)memval;
4225   LoadMemory (&memval, NULL, uncached, AccessLength_WORD, paddr + 4, vaddr + 4,
4226               isDATA, isREAL);
4227   return (bigendian ? ((v << 32) | memval) : (v | (memval << 32)));
4228 }
4229
4230
4231 // Helper:
4232 //
4233 // Store a double word FP value using 2 32-bit memory cycles a la MIPS II
4234 // or MIPS32.  do_load cannot be used instead because it returns an
4235 // unsigned_word, which is limited to the size of the machine's registers.
4236 //
4237
4238 :function:::void:do_store_double:address_word base, address_word offset, unsigned64 v
4239 *mipsII:
4240 *mips32:
4241 *mips32r2:
4242 {
4243   int bigendian = (BigEndianCPU ? ! ReverseEndian : ReverseEndian);
4244   address_word vaddr;
4245   address_word paddr;
4246   int uncached;
4247   unsigned64 memval;
4248
4249   vaddr = loadstore_ea (SD_, base, offset);
4250   if ((vaddr & AccessLength_DOUBLEWORD) != 0)
4251     {
4252       SIM_CORE_SIGNAL (SD, STATE_CPU(SD, 0), cia, read_map,
4253                        AccessLength_DOUBLEWORD + 1, vaddr, write_transfer,
4254                        sim_core_unaligned_signal);
4255     }
4256   AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET,
4257                       isREAL);
4258   memval = (bigendian ? (v >> 32) : (v & 0xFFFFFFFF));
4259   StoreMemory (uncached, AccessLength_WORD, memval, 0, paddr, vaddr,
4260                isREAL);
4261   memval = (bigendian ? (v & 0xFFFFFFFF) : (v >> 32));
4262   StoreMemory (uncached, AccessLength_WORD, memval, 0, paddr + 4, vaddr + 4,
4263                isREAL);
4264 }
4265
4266
4267 010001,10,3.FMT!2!3!4!5!7,00000,5.FS,5.FD,000101:COP1:32,f::ABS.fmt
4268 "abs.%s<FMT> f<FD>, f<FS>"
4269 *mipsI:
4270 *mipsII:
4271 *mipsIII:
4272 *mipsIV:
4273 *mipsV:
4274 *mips32:
4275 *mips32r2:
4276 *mips64:
4277 *mips64r2:
4278 *vr4100:
4279 *vr5000:
4280 *r3900:
4281 {
4282   int fmt = FMT;
4283   check_fpu (SD_);
4284   check_fmt_p (SD_, fmt, instruction_0);
4285   StoreFPR (FD, fmt, AbsoluteValue (ValueFPR (FS, fmt), fmt));
4286 }
4287
4288
4289
4290 010001,10,3.FMT!2!3!4!5!7,5.FT,5.FS,5.FD,000000:COP1:32,f::ADD.fmt
4291 "add.%s<FMT> f<FD>, f<FS>, f<FT>"
4292 *mipsI:
4293 *mipsII:
4294 *mipsIII:
4295 *mipsIV:
4296 *mipsV:
4297 *mips32:
4298 *mips32r2:
4299 *mips64:
4300 *mips64r2:
4301 *vr4100:
4302 *vr5000:
4303 *r3900:
4304 {
4305   int fmt = FMT;
4306   check_fpu (SD_);
4307   check_fmt_p (SD_, fmt, instruction_0);
4308   StoreFPR (FD, fmt, Add (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt));
4309 }
4310
4311
4312 010011,5.RS,5.FT,5.FS,5.FD,011,110:COP1X:64,f::ALNV.PS
4313 "alnv.ps f<FD>, f<FS>, f<FT>, r<RS>"
4314 *mipsV:
4315 *mips32r2:
4316 *mips64:
4317 *mips64r2:
4318 {
4319   unsigned64 fs;
4320   unsigned64 ft;
4321   unsigned64 fd;
4322   check_fpu (SD_);
4323   check_u64 (SD_, instruction_0);
4324   fs = ValueFPR (FS, fmt_ps);
4325   if ((GPR[RS] & 0x3) != 0)
4326     Unpredictable ();
4327   if ((GPR[RS] & 0x4) == 0)
4328     fd = fs;
4329   else
4330     {
4331       ft = ValueFPR (FT, fmt_ps);
4332       if (BigEndianCPU)
4333         fd = PackPS (PSLower (fs), PSUpper (ft));
4334       else
4335         fd = PackPS (PSLower (ft), PSUpper (fs));
4336     }
4337   StoreFPR (FD, fmt_ps, fd);
4338 }
4339
4340
4341 // BC1F
4342 // BC1FL
4343 // BC1T
4344 // BC1TL
4345
4346 010001,01000,3.0,1.ND,1.TF,16.OFFSET:COP1S:32,f::BC1a
4347 "bc1%s<TF>%s<ND> <OFFSET>"
4348 *mipsI:
4349 *mipsII:
4350 *mipsIII:
4351 {
4352   check_fpu (SD_);
4353   TRACE_BRANCH_INPUT (PREVCOC1());
4354   if (PREVCOC1() == TF)
4355     {
4356       address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
4357       TRACE_BRANCH_RESULT (dest);
4358       DELAY_SLOT (dest);
4359     }
4360   else if (ND)
4361     {
4362       TRACE_BRANCH_RESULT (0);
4363       NULLIFY_NEXT_INSTRUCTION ();
4364     }
4365   else
4366     {
4367       TRACE_BRANCH_RESULT (NIA);
4368     }
4369 }
4370
4371 010001,01000,3.CC,1.ND,1.TF,16.OFFSET:COP1S:32,f::BC1b
4372 "bc1%s<TF>%s<ND> <OFFSET>":CC == 0
4373 "bc1%s<TF>%s<ND> <CC>, <OFFSET>"
4374 *mipsIV:
4375 *mipsV:
4376 *mips32:
4377 *mips32r2:
4378 *mips64:
4379 *mips64r2:
4380 #*vr4100:
4381 *vr5000:
4382 *r3900:
4383 {
4384   check_fpu (SD_);
4385   if (GETFCC(CC) == TF)
4386     {
4387       address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
4388       DELAY_SLOT (dest);
4389     }
4390   else if (ND)
4391     {
4392       NULLIFY_NEXT_INSTRUCTION ();
4393     }
4394 }
4395
4396
4397 010001,10,3.FMT!2!3!4!5!6!7,5.FT,5.FS,3.0,00,11,4.COND:COP1:32,f::C.cond.fmta
4398 "c.%s<COND>.%s<FMT> f<FS>, f<FT>"
4399 *mipsI:
4400 *mipsII:
4401 *mipsIII:
4402 {
4403   int fmt = FMT;
4404   check_fpu (SD_);
4405   Compare (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt, COND, 0);
4406   TRACE_ALU_RESULT (ValueFCR (31));
4407 }
4408
4409 010001,10,3.FMT!2!3!4!5!7,5.FT,5.FS,3.CC,00,11,4.COND:COP1:32,f::C.cond.fmtb
4410 "c.%s<COND>.%s<FMT> f<FS>, f<FT>":CC == 0
4411 "c.%s<COND>.%s<FMT> <CC>, f<FS>, f<FT>"
4412 *mipsIV:
4413 *mipsV:
4414 *mips32:
4415 *mips32r2:
4416 *mips64:
4417 *mips64r2:
4418 *vr4100:
4419 *vr5000:
4420 *r3900:
4421 {
4422   int fmt = FMT;
4423   check_fpu (SD_);
4424   check_fmt_p (SD_, fmt, instruction_0);
4425   Compare (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt, COND, CC);
4426   TRACE_ALU_RESULT (ValueFCR (31));
4427 }
4428
4429
4430 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001010:COP1:64,f::CEIL.L.fmt
4431 "ceil.l.%s<FMT> f<FD>, f<FS>"
4432 *mipsIII:
4433 *mipsIV:
4434 *mipsV:
4435 *mips32r2:
4436 *mips64:
4437 *mips64r2:
4438 *vr4100:
4439 *vr5000:
4440 *r3900:
4441 {
4442   int fmt = FMT;
4443   check_fpu (SD_);
4444   StoreFPR (FD, fmt_long, Convert (FP_RM_TOPINF, ValueFPR (FS, fmt), fmt,
4445             fmt_long));
4446 }
4447
4448
4449 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001110:COP1:32,f::CEIL.W
4450 "ceil.w.%s<FMT> f<FD>, f<FS>"
4451 *mipsII:
4452 *mipsIII:
4453 *mipsIV:
4454 *mipsV:
4455 *mips32:
4456 *mips32r2:
4457 *mips64:
4458 *mips64r2:
4459 *vr4100:
4460 *vr5000:
4461 *r3900:
4462 {
4463   int fmt = FMT;
4464   check_fpu (SD_);
4465   StoreFPR (FD, fmt_word, Convert (FP_RM_TOPINF, ValueFPR (FS, fmt), fmt,
4466             fmt_word));
4467 }
4468
4469
4470 010001,00010,5.RT,5.FS,00000000000:COP1:32,f::CFC1a
4471 "cfc1 r<RT>, f<FS>"
4472 *mipsI:
4473 *mipsII:
4474 *mipsIII:
4475 {
4476   check_fpu (SD_);
4477   if (FS == 0)
4478     PENDING_FILL (RT, EXTEND32 (FCR0));
4479   else if (FS == 31)
4480     PENDING_FILL (RT, EXTEND32 (FCR31));
4481   /* else NOP */
4482 }
4483
4484 010001,00010,5.RT,5.FS,00000000000:COP1:32,f::CFC1b
4485 "cfc1 r<RT>, f<FS>"
4486 *mipsIV:
4487 *vr4100:
4488 *vr5000:
4489 *r3900:
4490 {
4491   check_fpu (SD_);
4492   if (FS == 0 || FS == 31)
4493     {
4494       unsigned_word  fcr = ValueFCR (FS);
4495       TRACE_ALU_INPUT1 (fcr);
4496       GPR[RT] = fcr;
4497     }
4498   /* else NOP */
4499   TRACE_ALU_RESULT (GPR[RT]);
4500 }
4501
4502 010001,00010,5.RT,5.FS,00000000000:COP1:32,f::CFC1c
4503 "cfc1 r<RT>, f<FS>"
4504 *mipsV:
4505 *mips32:
4506 *mips32r2:
4507 *mips64:
4508 *mips64r2:
4509 {
4510   check_fpu (SD_);
4511   if (FS == 0 || FS == 25 || FS == 26 || FS == 28 || FS == 31)
4512     {
4513       unsigned_word  fcr = ValueFCR (FS);
4514       TRACE_ALU_INPUT1 (fcr);
4515       GPR[RT] = fcr;
4516     }
4517   /* else NOP */
4518   TRACE_ALU_RESULT (GPR[RT]);
4519 }
4520
4521 010001,00110,5.RT,5.FS,00000000000:COP1:32,f::CTC1a
4522 "ctc1 r<RT>, f<FS>"
4523 *mipsI:
4524 *mipsII:
4525 *mipsIII:
4526 {
4527   check_fpu (SD_);
4528   if (FS == 31)
4529     PENDING_FILL (FCRCS_REGNUM, VL4_8 (GPR[RT]));
4530   /* else NOP */
4531 }
4532
4533 010001,00110,5.RT,5.FS,00000000000:COP1:32,f::CTC1b
4534 "ctc1 r<RT>, f<FS>"
4535 *mipsIV:
4536 *vr4100:
4537 *vr5000:
4538 *r3900:
4539 {
4540   check_fpu (SD_);
4541   TRACE_ALU_INPUT1 (GPR[RT]);
4542   if (FS == 31)
4543     StoreFCR (FS, GPR[RT]);
4544   /* else NOP */
4545 }
4546
4547 010001,00110,5.RT,5.FS,00000000000:COP1:32,f::CTC1c
4548 "ctc1 r<RT>, f<FS>"
4549 *mipsV:
4550 *mips32:
4551 *mips32r2:
4552 *mips64:
4553 *mips64r2:
4554 {
4555   check_fpu (SD_);
4556   TRACE_ALU_INPUT1 (GPR[RT]);
4557   if (FS == 25 || FS == 26 || FS == 28 || FS == 31)
4558       StoreFCR (FS, GPR[RT]);
4559   /* else NOP */
4560 }
4561
4562
4563 //
4564 // FIXME: Does not correctly differentiate between mips*
4565 //
4566 010001,10,3.FMT!1!2!3!6!7,00000,5.FS,5.FD,100001:COP1:32,f::CVT.D.fmt
4567 "cvt.d.%s<FMT> f<FD>, f<FS>"
4568 *mipsI:
4569 *mipsII:
4570 *mipsIII:
4571 *mipsIV:
4572 *mipsV:
4573 *mips32:
4574 *mips32r2:
4575 *mips64:
4576 *mips64r2:
4577 *vr4100:
4578 *vr5000:
4579 *r3900:
4580 {
4581   int fmt = FMT;
4582   check_fpu (SD_);
4583   if ((fmt == fmt_double) | 0)
4584     SignalException (ReservedInstruction, instruction_0);
4585   StoreFPR (FD, fmt_double, Convert (GETRM (), ValueFPR (FS, fmt), fmt,
4586             fmt_double));
4587 }
4588
4589
4590 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,100101:COP1:64,f::CVT.L.fmt
4591 "cvt.l.%s<FMT> f<FD>, f<FS>"
4592 *mipsIII:
4593 *mipsIV:
4594 *mipsV:
4595 *mips32r2:
4596 *mips64:
4597 *mips64r2:
4598 *vr4100:
4599 *vr5000:
4600 *r3900:
4601 {
4602   int fmt = FMT;
4603   check_fpu (SD_);
4604   if ((fmt == fmt_long) | ((fmt == fmt_long) || (fmt == fmt_word)))
4605     SignalException (ReservedInstruction, instruction_0);
4606   StoreFPR (FD, fmt_long, Convert (GETRM (), ValueFPR (FS, fmt), fmt,
4607             fmt_long));
4608 }
4609
4610
4611 010001,10,000,5.FT,5.FS,5.FD,100110:COP1:64,f::CVT.PS.S
4612 "cvt.ps.s f<FD>, f<FS>, f<FT>"
4613 *mipsV:
4614 *mips32r2:
4615 *mips64:
4616 *mips64r2:
4617 {
4618   check_fpu (SD_);
4619   check_u64 (SD_, instruction_0);
4620   StoreFPR (FD, fmt_ps, PackPS (ValueFPR (FS, fmt_single),
4621                                 ValueFPR (FT, fmt_single)));
4622 }
4623
4624
4625 //
4626 // FIXME: Does not correctly differentiate between mips*
4627 //
4628 010001,10,3.FMT!0!2!3!6!7,00000,5.FS,5.FD,100000:COP1:32,f::CVT.S.fmt
4629 "cvt.s.%s<FMT> f<FD>, f<FS>"
4630 *mipsI:
4631 *mipsII:
4632 *mipsIII:
4633 *mipsIV:
4634 *mipsV:
4635 *mips32:
4636 *mips32r2:
4637 *mips64:
4638 *mips64r2:
4639 *vr4100:
4640 *vr5000:
4641 *r3900:
4642 {
4643   int fmt = FMT;
4644   check_fpu (SD_);
4645   if ((fmt == fmt_single) | 0)
4646     SignalException (ReservedInstruction, instruction_0);
4647   StoreFPR (FD, fmt_single, Convert (GETRM (), ValueFPR (FS, fmt), fmt,
4648             fmt_single));
4649 }
4650
4651
4652 010001,10,110,00000,5.FS,5.FD,101000:COP1:64,f::CVT.S.PL
4653 "cvt.s.pl f<FD>, f<FS>"
4654 *mipsV:
4655 *mips32r2:
4656 *mips64:
4657 *mips64r2:
4658 {
4659   check_fpu (SD_);
4660   check_u64 (SD_, instruction_0);
4661   StoreFPR (FD, fmt_single, PSLower (ValueFPR (FS, fmt_ps)));
4662 }
4663
4664
4665 010001,10,110,00000,5.FS,5.FD,100000:COP1:64,f::CVT.S.PU
4666 "cvt.s.pu f<FD>, f<FS>"
4667 *mipsV:
4668 *mips32r2:
4669 *mips64:
4670 *mips64r2:
4671 {
4672   check_fpu (SD_);
4673   check_u64 (SD_, instruction_0);
4674   StoreFPR (FD, fmt_single, PSUpper (ValueFPR (FS, fmt_ps)));
4675 }
4676
4677
4678 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,100100:COP1:32,f::CVT.W.fmt
4679 "cvt.w.%s<FMT> f<FD>, f<FS>"
4680 *mipsI:
4681 *mipsII:
4682 *mipsIII:
4683 *mipsIV:
4684 *mipsV:
4685 *mips32:
4686 *mips32r2:
4687 *mips64:
4688 *mips64r2:
4689 *vr4100:
4690 *vr5000:
4691 *r3900:
4692 {
4693   int fmt = FMT;
4694   check_fpu (SD_);
4695   if ((fmt == fmt_word) | ((fmt == fmt_long) || (fmt == fmt_word)))
4696     SignalException (ReservedInstruction, instruction_0);
4697   StoreFPR (FD, fmt_word, Convert (GETRM (), ValueFPR (FS, fmt), fmt,
4698             fmt_word));
4699 }
4700
4701
4702 010001,10,3.FMT!2!3!4!5!6!7,5.FT,5.FS,5.FD,000011:COP1:32,f::DIV.fmt
4703 "div.%s<FMT> f<FD>, f<FS>, f<FT>"
4704 *mipsI:
4705 *mipsII:
4706 *mipsIII:
4707 *mipsIV:
4708 *mipsV:
4709 *mips32:
4710 *mips32r2:
4711 *mips64:
4712 *mips64r2:
4713 *vr4100:
4714 *vr5000:
4715 *r3900:
4716 {
4717   int fmt = FMT;
4718   check_fpu (SD_);
4719   StoreFPR (FD, fmt, Divide (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt));
4720 }
4721
4722
4723 010001,00001,5.RT,5.FS,00000000000:COP1:64,f::DMFC1a
4724 "dmfc1 r<RT>, f<FS>"
4725 *mipsIII:
4726 {
4727   unsigned64 v;
4728   check_fpu (SD_);
4729   check_u64 (SD_, instruction_0);
4730   if (SizeFGR () == 64)
4731     v = FGR[FS];
4732   else if ((FS & 0x1) == 0)
4733     v = SET64HI (FGR[FS+1]) | FGR[FS];
4734   else
4735     v = SET64HI (0xDEADC0DE) | 0xBAD0BAD0;
4736   PENDING_FILL (RT, v);
4737   TRACE_ALU_RESULT (v);
4738 }
4739
4740 010001,00001,5.RT,5.FS,00000000000:COP1:64,f::DMFC1b
4741 "dmfc1 r<RT>, f<FS>"
4742 *mipsIV:
4743 *mipsV:
4744 *mips64:
4745 *mips64r2:
4746 *vr4100:
4747 *vr5000:
4748 *r3900:
4749 {
4750   check_fpu (SD_);
4751   check_u64 (SD_, instruction_0);
4752   if (SizeFGR () == 64)
4753     GPR[RT] = FGR[FS];
4754   else if ((FS & 0x1) == 0)
4755     GPR[RT] = SET64HI (FGR[FS+1]) | FGR[FS];
4756   else
4757     GPR[RT] = SET64HI (0xDEADC0DE) | 0xBAD0BAD0;
4758   TRACE_ALU_RESULT (GPR[RT]);
4759 }
4760
4761
4762 010001,00101,5.RT,5.FS,00000000000:COP1:64,f::DMTC1a
4763 "dmtc1 r<RT>, f<FS>"
4764 *mipsIII:
4765 {
4766   unsigned64 v;
4767   check_fpu (SD_);
4768   check_u64 (SD_, instruction_0);
4769   if (SizeFGR () == 64)
4770     PENDING_FILL ((FS + FGR_BASE), GPR[RT]);
4771   else if ((FS & 0x1) == 0)
4772     {
4773       PENDING_FILL (((FS + 1) + FGR_BASE), VH4_8 (GPR[RT]));
4774       PENDING_FILL ((FS + FGR_BASE), VL4_8 (GPR[RT]));
4775     }
4776   else
4777     Unpredictable ();
4778   TRACE_FP_RESULT (GPR[RT]);
4779 }
4780
4781 010001,00101,5.RT,5.FS,00000000000:COP1:64,f::DMTC1b
4782 "dmtc1 r<RT>, f<FS>"
4783 *mipsIV:
4784 *mipsV:
4785 *mips64:
4786 *mips64r2:
4787 *vr4100:
4788 *vr5000:
4789 *r3900:
4790 {
4791   check_fpu (SD_);
4792   check_u64 (SD_, instruction_0);
4793   if (SizeFGR () == 64)
4794     StoreFPR (FS, fmt_uninterpreted_64, GPR[RT]);
4795   else if ((FS & 0x1) == 0)
4796     StoreFPR (FS, fmt_uninterpreted_64, GPR[RT]);
4797   else
4798     Unpredictable ();
4799 }
4800
4801
4802 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001011:COP1:64,f::FLOOR.L.fmt
4803 "floor.l.%s<FMT> f<FD>, f<FS>"
4804 *mipsIII:
4805 *mipsIV:
4806 *mipsV:
4807 *mips32r2:
4808 *mips64:
4809 *mips64r2:
4810 *vr4100:
4811 *vr5000:
4812 *r3900:
4813 {
4814   int fmt = FMT;
4815   check_fpu (SD_);
4816   StoreFPR (FD, fmt_long, Convert (FP_RM_TOMINF, ValueFPR (FS, fmt), fmt,
4817             fmt_long));
4818 }
4819
4820
4821 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001111:COP1:32,f::FLOOR.W.fmt
4822 "floor.w.%s<FMT> f<FD>, f<FS>"
4823 *mipsII:
4824 *mipsIII:
4825 *mipsIV:
4826 *mipsV:
4827 *mips32:
4828 *mips32r2:
4829 *mips64:
4830 *mips64r2:
4831 *vr4100:
4832 *vr5000:
4833 *r3900:
4834 {
4835   int fmt = FMT;
4836   check_fpu (SD_);
4837   StoreFPR (FD, fmt_word, Convert (FP_RM_TOMINF, ValueFPR (FS, fmt), fmt,
4838             fmt_word));
4839 }
4840
4841
4842 110101,5.BASE,5.FT,16.OFFSET:COP1:32,f::LDC1a
4843 "ldc1 f<FT>, <OFFSET>(r<BASE>)"
4844 *mipsII:
4845 *mips32:
4846 *mips32r2:
4847 {
4848   check_fpu (SD_);
4849   COP_LD (1, FT, do_load_double (SD_, GPR[BASE], EXTEND16 (OFFSET)));
4850 }
4851
4852
4853 110101,5.BASE,5.FT,16.OFFSET:COP1:32,f::LDC1b
4854 "ldc1 f<FT>, <OFFSET>(r<BASE>)"
4855 *mipsIII:
4856 *mipsIV:
4857 *mipsV:
4858 *mips64:
4859 *mips64r2:
4860 *vr4100:
4861 *vr5000:
4862 *r3900:
4863 {
4864   check_fpu (SD_);
4865   COP_LD (1, FT, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
4866 }
4867
4868
4869 010011,5.BASE,5.INDEX,5.0,5.FD,000001:COP1X:64,f::LDXC1
4870 "ldxc1 f<FD>, r<INDEX>(r<BASE>)"
4871 *mipsIV:
4872 *mipsV:
4873 *mips32r2:
4874 *mips64:
4875 *mips64r2:
4876 *vr5000:
4877 {
4878   check_fpu (SD_);
4879   check_u64 (SD_, instruction_0);
4880   COP_LD (1, FD, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], GPR[INDEX]));
4881 }
4882
4883
4884 010011,5.BASE,5.INDEX,5.0,5.FD,000101:COP1X:64,f::LUXC1
4885 "luxc1 f<FD>, r<INDEX>(r<BASE>)"
4886 *mipsV:
4887 *mips32r2:
4888 *mips64:
4889 *mips64r2:
4890 {
4891   address_word base = GPR[BASE];
4892   address_word index = GPR[INDEX];
4893   address_word vaddr = base + index;
4894   check_fpu (SD_);
4895   check_u64 (SD_, instruction_0);
4896   /* Arrange for the bottom 3 bits of (base + index) to be 0.  */
4897   if ((vaddr & 0x7) != 0)
4898     index -= (vaddr & 0x7);
4899   COP_LD (1, FD, do_load (SD_, AccessLength_DOUBLEWORD, base, index));
4900 }
4901
4902
4903 110001,5.BASE,5.FT,16.OFFSET:COP1:32,f::LWC1
4904 "lwc1 f<FT>, <OFFSET>(r<BASE>)"
4905 *mipsI:
4906 *mipsII:
4907 *mipsIII:
4908 *mipsIV:
4909 *mipsV:
4910 *mips32:
4911 *mips32r2:
4912 *mips64:
4913 *mips64r2:
4914 *vr4100:
4915 *vr5000:
4916 *r3900:
4917 {
4918   check_fpu (SD_);
4919   COP_LW (1, FT, do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
4920 }
4921
4922
4923 010011,5.BASE,5.INDEX,5.0,5.FD,000000:COP1X:64,f::LWXC1
4924 "lwxc1 f<FD>, r<INDEX>(r<BASE>)"
4925 *mipsIV:
4926 *mipsV:
4927 *mips32r2:
4928 *mips64:
4929 *mips64r2:
4930 *vr5000:
4931 {
4932   check_fpu (SD_);
4933   check_u64 (SD_, instruction_0);
4934   COP_LW (1, FD, do_load (SD_, AccessLength_WORD, GPR[BASE], GPR[INDEX]));
4935 }
4936
4937
4938
4939 010011,5.FR,5.FT,5.FS,5.FD,100,3.FMT!2!3!4!5!7:COP1X:64,f::MADD.fmt
4940 "madd.%s<FMT> f<FD>, f<FR>, f<FS>, f<FT>"
4941 *mipsIV:
4942 *mipsV:
4943 *mips32r2:
4944 *mips64:
4945 *mips64r2:
4946 *vr5000:
4947 {
4948   int fmt = FMT;
4949   check_fpu (SD_);
4950   check_u64 (SD_, instruction_0);
4951   check_fmt_p (SD_, fmt, instruction_0);
4952   StoreFPR (FD, fmt, MultiplyAdd (ValueFPR (FS, fmt), ValueFPR (FT, fmt),
4953                                   ValueFPR (FR, fmt), fmt));
4954 }
4955
4956
4957 010001,00000,5.RT,5.FS,00000000000:COP1:32,f::MFC1a
4958 "mfc1 r<RT>, f<FS>"
4959 *mipsI:
4960 *mipsII:
4961 *mipsIII:
4962 {
4963   unsigned64 v;
4964   check_fpu (SD_);
4965   v = EXTEND32 (FGR[FS]);
4966   PENDING_FILL (RT, v);
4967   TRACE_ALU_RESULT (v);
4968 }
4969
4970 010001,00000,5.RT,5.FS,00000000000:COP1:32,f::MFC1b
4971 "mfc1 r<RT>, f<FS>"
4972 *mipsIV:
4973 *mipsV:
4974 *mips32:
4975 *mips32r2:
4976 *mips64:
4977 *mips64r2:
4978 *vr4100:
4979 *vr5000:
4980 *r3900:
4981 {
4982   check_fpu (SD_);
4983   GPR[RT] = EXTEND32 (FGR[FS]);
4984   TRACE_ALU_RESULT (GPR[RT]);
4985 }
4986
4987
4988 010001,10,3.FMT!2!3!4!5!7,00000,5.FS,5.FD,000110:COP1:32,f::MOV.fmt
4989 "mov.%s<FMT> f<FD>, f<FS>"
4990 *mipsI:
4991 *mipsII:
4992 *mipsIII:
4993 *mipsIV:
4994 *mipsV:
4995 *mips32:
4996 *mips32r2:
4997 *mips64:
4998 *mips64r2:
4999 *vr4100:
5000 *vr5000:
5001 *r3900:
5002 {
5003   int fmt = FMT;
5004   check_fpu (SD_);
5005   check_fmt_p (SD_, fmt, instruction_0);
5006   StoreFPR (FD, fmt, ValueFPR (FS, fmt));
5007 }
5008
5009
5010 // MOVF
5011 // MOVT
5012 000000,5.RS,3.CC,0,1.TF,5.RD,00000,000001:SPECIAL:32,f::MOVtf
5013 "mov%s<TF> r<RD>, r<RS>, <CC>"
5014 *mipsIV:
5015 *mipsV:
5016 *mips32:
5017 *mips32r2:
5018 *mips64:
5019 *mips64r2:
5020 *vr5000:
5021 {
5022   check_fpu (SD_);
5023   if (GETFCC(CC) == TF)
5024     GPR[RD] = GPR[RS];
5025 }
5026
5027
5028 // MOVF.fmt
5029 // MOVT.fmt
5030 010001,10,3.FMT!2!3!4!5!7,3.CC,0,1.TF,5.FS,5.FD,010001:COP1:32,f::MOVtf.fmt
5031 "mov%s<TF>.%s<FMT> f<FD>, f<FS>, <CC>"
5032 *mipsIV:
5033 *mipsV:
5034 *mips32:
5035 *mips32r2:
5036 *mips64:
5037 *mips64r2:
5038 *vr5000:
5039 {
5040   int fmt = FMT;
5041   check_fpu (SD_);
5042   if (fmt != fmt_ps)
5043     {
5044       if (GETFCC(CC) == TF)
5045         StoreFPR (FD, fmt, ValueFPR (FS, fmt));
5046       else
5047         StoreFPR (FD, fmt, ValueFPR (FD, fmt));   /* set fmt */
5048     }
5049   else
5050     {
5051       unsigned64 fd;
5052       fd = PackPS (PSUpper (ValueFPR ((GETFCC (CC+1) == TF) ? FS : FD,
5053                                       fmt_ps)),
5054                    PSLower (ValueFPR ((GETFCC (CC+0) == TF) ? FS : FD,
5055                                       fmt_ps)));
5056       StoreFPR (FD, fmt_ps, fd);
5057     }
5058 }
5059
5060
5061 010001,10,3.FMT!2!3!4!5!7,5.RT,5.FS,5.FD,010011:COP1:32,f::MOVN.fmt
5062 "movn.%s<FMT> f<FD>, f<FS>, r<RT>"
5063 *mipsIV:
5064 *mipsV:
5065 *mips32:
5066 *mips32r2:
5067 *mips64:
5068 *mips64r2:
5069 *vr5000:
5070 {
5071   check_fpu (SD_);
5072   if (GPR[RT] != 0)
5073     StoreFPR (FD, FMT, ValueFPR (FS, FMT));
5074   else
5075     StoreFPR (FD, FMT, ValueFPR (FD, FMT));
5076 }
5077
5078
5079 // MOVT see MOVtf
5080
5081
5082 // MOVT.fmt see MOVtf.fmt
5083
5084
5085
5086 010001,10,3.FMT!2!3!4!5!7,5.RT,5.FS,5.FD,010010:COP1:32,f::MOVZ.fmt
5087 "movz.%s<FMT> f<FD>, f<FS>, r<RT>"
5088 *mipsIV:
5089 *mipsV:
5090 *mips32:
5091 *mips32r2:
5092 *mips64:
5093 *mips64r2:
5094 *vr5000:
5095 {
5096   check_fpu (SD_);
5097   if (GPR[RT] == 0)
5098     StoreFPR (FD, FMT, ValueFPR (FS, FMT));
5099   else
5100     StoreFPR (FD, FMT, ValueFPR (FD, FMT));
5101 }
5102
5103
5104 010011,5.FR,5.FT,5.FS,5.FD,101,3.FMT!2!3!4!5!7:COP1X:64,f::MSUB.fmt
5105 "msub.%s<FMT> f<FD>, f<FR>, f<FS>, f<FT>"
5106 *mipsIV:
5107 *mipsV:
5108 *mips32r2:
5109 *mips64:
5110 *mips64r2:
5111 *vr5000:
5112 {
5113   int fmt = FMT;
5114   check_fpu (SD_);
5115   check_u64 (SD_, instruction_0);
5116   check_fmt_p (SD_, fmt, instruction_0);
5117   StoreFPR (FD, fmt, MultiplySub (ValueFPR (FS, fmt), ValueFPR (FT, fmt),
5118                                   ValueFPR (FR, fmt), fmt));
5119 }
5120
5121
5122 010001,00100,5.RT,5.FS,00000000000:COP1:32,f::MTC1a
5123 "mtc1 r<RT>, f<FS>"
5124 *mipsI:
5125 *mipsII:
5126 *mipsIII:
5127 {
5128   check_fpu (SD_);
5129   if (SizeFGR () == 64)
5130     PENDING_FILL ((FS + FGR_BASE), (SET64HI (0xDEADC0DE) | VL4_8 (GPR[RT])));
5131   else
5132     PENDING_FILL ((FS + FGR_BASE), VL4_8 (GPR[RT]));
5133   TRACE_FP_RESULT (GPR[RT]);
5134 }
5135
5136 010001,00100,5.RT,5.FS,00000000000:COP1:32,f::MTC1b
5137 "mtc1 r<RT>, f<FS>"
5138 *mipsIV:
5139 *mipsV:
5140 *mips32:
5141 *mips32r2:
5142 *mips64:
5143 *mips64r2:
5144 *vr4100:
5145 *vr5000:
5146 *r3900:
5147 {
5148   check_fpu (SD_);
5149   StoreFPR (FS, fmt_uninterpreted_32, VL4_8 (GPR[RT]));
5150 }
5151
5152
5153 010001,10,3.FMT!2!3!4!5!7,5.FT,5.FS,5.FD,000010:COP1:32,f::MUL.fmt
5154 "mul.%s<FMT> f<FD>, f<FS>, f<FT>"
5155 *mipsI:
5156 *mipsII:
5157 *mipsIII:
5158 *mipsIV:
5159 *mipsV:
5160 *mips32:
5161 *mips32r2:
5162 *mips64:
5163 *mips64r2:
5164 *vr4100:
5165 *vr5000:
5166 *r3900:
5167 {
5168   int fmt = FMT;
5169   check_fpu (SD_);
5170   check_fmt_p (SD_, fmt, instruction_0);
5171   StoreFPR (FD, fmt, Multiply (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt));
5172 }
5173
5174
5175 010001,10,3.FMT!2!3!4!5!7,00000,5.FS,5.FD,000111:COP1:32,f::NEG.fmt
5176 "neg.%s<FMT> f<FD>, f<FS>"
5177 *mipsI:
5178 *mipsII:
5179 *mipsIII:
5180 *mipsIV:
5181 *mipsV:
5182 *mips32:
5183 *mips32r2:
5184 *mips64:
5185 *mips64r2:
5186 *vr4100:
5187 *vr5000:
5188 *r3900:
5189 {
5190   int fmt = FMT;
5191   check_fpu (SD_);
5192   check_fmt_p (SD_, fmt, instruction_0);
5193   StoreFPR (FD, fmt, Negate (ValueFPR (FS, fmt), fmt));
5194 }
5195
5196
5197 010011,5.FR,5.FT,5.FS,5.FD,110,3.FMT!2!3!4!5!7:COP1X:64,f::NMADD.fmt
5198 "nmadd.%s<FMT> f<FD>, f<FR>, f<FS>, f<FT>"
5199 *mipsIV:
5200 *mipsV:
5201 *mips32r2:
5202 *mips64:
5203 *mips64r2:
5204 *vr5000:
5205 {
5206   int fmt = FMT;
5207   check_fpu (SD_);
5208   check_u64 (SD_, instruction_0);
5209   check_fmt_p (SD_, fmt, instruction_0);
5210   StoreFPR (FD, fmt, NegMultiplyAdd (ValueFPR (FS, fmt), ValueFPR (FT, fmt),
5211                                      ValueFPR (FR, fmt), fmt));
5212 }
5213
5214
5215 010011,5.FR,5.FT,5.FS,5.FD,111,3.FMT!2!3!4!5!7:COP1X:64,f::NMSUB.fmt
5216 "nmsub.%s<FMT> f<FD>, f<FR>, f<FS>, f<FT>"
5217 *mipsIV:
5218 *mipsV:
5219 *mips32r2:
5220 *mips64:
5221 *mips64r2:
5222 *vr5000:
5223 {
5224   int fmt = FMT;
5225   check_fpu (SD_);
5226   check_u64 (SD_, instruction_0);
5227   check_fmt_p (SD_, fmt, instruction_0);
5228   StoreFPR (FD, fmt, NegMultiplySub (ValueFPR (FS, fmt), ValueFPR (FT, fmt),
5229                                      ValueFPR (FR, fmt), fmt));
5230 }
5231
5232
5233 010001,10,110,5.FT,5.FS,5.FD,101100:COP1:64,f::PLL.PS
5234 "pll.ps f<FD>, f<FS>, f<FT>"
5235 *mipsV:
5236 *mips32r2:
5237 *mips64:
5238 *mips64r2:
5239 {
5240   check_fpu (SD_);
5241   check_u64 (SD_, instruction_0);
5242   StoreFPR (FD, fmt_ps, PackPS (PSLower (ValueFPR (FS, fmt_ps)),
5243                                 PSLower (ValueFPR (FT, fmt_ps))));
5244 }
5245
5246
5247 010001,10,110,5.FT,5.FS,5.FD,101101:COP1:64,f::PLU.PS
5248 "plu.ps f<FD>, f<FS>, f<FT>"
5249 *mipsV:
5250 *mips32r2:
5251 *mips64:
5252 *mips64r2:
5253 {
5254   check_fpu (SD_);
5255   check_u64 (SD_, instruction_0);
5256   StoreFPR (FD, fmt_ps, PackPS (PSLower (ValueFPR (FS, fmt_ps)),
5257                                 PSUpper (ValueFPR (FT, fmt_ps))));
5258 }
5259
5260
5261 010011,5.BASE,5.INDEX,5.HINT,00000,001111:COP1X:64::PREFX
5262 "prefx <HINT>, r<INDEX>(r<BASE>)"
5263 *mipsIV:
5264 *mipsV:
5265 *mips32r2:
5266 *mips64:
5267 *mips64r2:
5268 *vr5000:
5269 {
5270   address_word base = GPR[BASE];
5271   address_word index = GPR[INDEX];
5272   {
5273     address_word vaddr = loadstore_ea (SD_, base, index);
5274     address_word paddr;
5275     int uncached;
5276     if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
5277       Prefetch(uncached,paddr,vaddr,isDATA,HINT);
5278   }
5279 }
5280
5281
5282 010001,10,110,5.FT,5.FS,5.FD,101110:COP1:64,f::PUL.PS
5283 "pul.ps f<FD>, f<FS>, f<FT>"
5284 *mipsV:
5285 *mips32r2:
5286 *mips64:
5287 *mips64r2:
5288 {
5289   check_fpu (SD_);
5290   check_u64 (SD_, instruction_0);
5291   StoreFPR (FD, fmt_ps, PackPS (PSUpper (ValueFPR (FS, fmt_ps)),
5292                                 PSLower (ValueFPR (FT, fmt_ps))));
5293 }
5294
5295
5296 010001,10,110,5.FT,5.FS,5.FD,101111:COP1:64,f::PUU.PS
5297 "puu.ps f<FD>, f<FS>, f<FT>"
5298 *mipsV:
5299 *mips32r2:
5300 *mips64:
5301 *mips64r2:
5302 {
5303   check_fpu (SD_);
5304   check_u64 (SD_, instruction_0);
5305   StoreFPR (FD, fmt_ps, PackPS (PSUpper (ValueFPR (FS, fmt_ps)),
5306                                 PSUpper (ValueFPR (FT, fmt_ps))));
5307 }
5308
5309
5310 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,010101:COP1:32,f::RECIP.fmt
5311 "recip.%s<FMT> f<FD>, f<FS>"
5312 *mipsIV:
5313 *mipsV:
5314 *mips32r2:
5315 *mips64:
5316 *mips64r2:
5317 *vr5000:
5318 {
5319   int fmt = FMT;
5320   check_fpu (SD_);
5321   StoreFPR (FD, fmt, Recip (ValueFPR (FS, fmt), fmt));
5322 }
5323
5324
5325 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001000:COP1:64,f::ROUND.L.fmt
5326 "round.l.%s<FMT> f<FD>, f<FS>"
5327 *mipsIII:
5328 *mipsIV:
5329 *mipsV:
5330 *mips32r2:
5331 *mips64:
5332 *mips64r2:
5333 *vr4100:
5334 *vr5000:
5335 *r3900:
5336 {
5337   int fmt = FMT;
5338   check_fpu (SD_);
5339   StoreFPR (FD, fmt_long, Convert (FP_RM_NEAREST, ValueFPR (FS, fmt), fmt,
5340             fmt_long));
5341 }
5342
5343
5344 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001100:COP1:32,f::ROUND.W.fmt
5345 "round.w.%s<FMT> f<FD>, f<FS>"
5346 *mipsII:
5347 *mipsIII:
5348 *mipsIV:
5349 *mipsV:
5350 *mips32:
5351 *mips32r2:
5352 *mips64:
5353 *mips64r2:
5354 *vr4100:
5355 *vr5000:
5356 *r3900:
5357 {
5358   int fmt = FMT;
5359   check_fpu (SD_);
5360   StoreFPR (FD, fmt_word, Convert (FP_RM_NEAREST, ValueFPR (FS, fmt), fmt,
5361             fmt_word));
5362 }
5363
5364
5365 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,010110:COP1:32,f::RSQRT.fmt
5366 "rsqrt.%s<FMT> f<FD>, f<FS>"
5367 *mipsIV:
5368 *mipsV:
5369 *mips32r2:
5370 *mips64:
5371 *mips64r2:
5372 *vr5000:
5373 {
5374   int fmt = FMT;
5375   check_fpu (SD_);
5376   StoreFPR (FD, fmt, RSquareRoot (ValueFPR (FS, fmt), fmt));
5377 }
5378
5379
5380 111101,5.BASE,5.FT,16.OFFSET:COP1:32,f::SDC1a
5381 "sdc1 f<FT>, <OFFSET>(r<BASE>)"
5382 *mipsII:
5383 *mips32:
5384 *mips32r2:
5385 {
5386   check_fpu (SD_);
5387   do_store_double (SD_, GPR[BASE], EXTEND16 (OFFSET), COP_SD (1, FT));
5388 }
5389
5390
5391 111101,5.BASE,5.FT,16.OFFSET:COP1:32,f::SDC1b
5392 "sdc1 f<FT>, <OFFSET>(r<BASE>)"
5393 *mipsIII:
5394 *mipsIV:
5395 *mipsV:
5396 *mips64:
5397 *mips64r2:
5398 *vr4100:
5399 *vr5000:
5400 *r3900:
5401 {
5402   check_fpu (SD_);
5403   do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), COP_SD (1, FT));
5404 }
5405
5406
5407 010011,5.BASE,5.INDEX,5.FS,00000001001:COP1X:64,f::SDXC1
5408 "sdxc1 f<FS>, r<INDEX>(r<BASE>)"
5409 *mipsIV:
5410 *mipsV:
5411 *mips64:
5412 *mips64r2:
5413 *vr5000:
5414 {
5415   check_fpu (SD_);
5416   check_u64 (SD_, instruction_0);
5417   do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], GPR[INDEX], COP_SD (1, FS));
5418 }
5419
5420
5421 010011,5.BASE,5.INDEX,5.FS,00000,001101:COP1X:64,f::SUXC1
5422 "suxc1 f<FS>, r<INDEX>(r<BASE>)"
5423 *mipsV:
5424 *mips64:
5425 *mips64r2:
5426 {
5427   unsigned64 v;
5428   address_word base = GPR[BASE];
5429   address_word index = GPR[INDEX];
5430   address_word vaddr = base + index;
5431   check_fpu (SD_);
5432   check_u64 (SD_, instruction_0);
5433   /* Arrange for the bottom 3 bits of (base + index) to be 0.  */
5434   if ((vaddr & 0x7) != 0)
5435     index -= (vaddr & 0x7);
5436   do_store (SD_, AccessLength_DOUBLEWORD, base, index, COP_SD (1, FS));
5437 }
5438
5439
5440 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,000100:COP1:32,f::SQRT.fmt
5441 "sqrt.%s<FMT> f<FD>, f<FS>"
5442 *mipsII:
5443 *mipsIII:
5444 *mipsIV:
5445 *mipsV:
5446 *mips32:
5447 *mips32r2:
5448 *mips64:
5449 *mips64r2:
5450 *vr4100:
5451 *vr5000:
5452 *r3900:
5453 {
5454   int fmt = FMT;
5455   check_fpu (SD_);
5456   StoreFPR (FD, fmt,  (SquareRoot (ValueFPR (FS, fmt), fmt)));
5457 }
5458
5459
5460 010001,10,3.FMT!2!3!4!5!7,5.FT,5.FS,5.FD,000001:COP1:32,f::SUB.fmt
5461 "sub.%s<FMT> f<FD>, f<FS>, f<FT>"
5462 *mipsI:
5463 *mipsII:
5464 *mipsIII:
5465 *mipsIV:
5466 *mipsV:
5467 *mips32:
5468 *mips32r2:
5469 *mips64:
5470 *mips64r2:
5471 *vr4100:
5472 *vr5000:
5473 *r3900:
5474 {
5475   int fmt = FMT;
5476   check_fpu (SD_);
5477   check_fmt_p (SD_, fmt, instruction_0);
5478   StoreFPR (FD, fmt, Sub (ValueFPR (FS, fmt), ValueFPR (FT, fmt), fmt));
5479 }
5480
5481
5482
5483 111001,5.BASE,5.FT,16.OFFSET:COP1:32,f::SWC1
5484 "swc1 f<FT>, <OFFSET>(r<BASE>)"
5485 *mipsI:
5486 *mipsII:
5487 *mipsIII:
5488 *mipsIV:
5489 *mipsV:
5490 *mips32:
5491 *mips32r2:
5492 *mips64:
5493 *mips64r2:
5494 *vr4100:
5495 *vr5000:
5496 *r3900:
5497 {
5498   address_word base = GPR[BASE];
5499   address_word offset = EXTEND16 (OFFSET);
5500   check_fpu (SD_);
5501   {
5502     address_word vaddr = loadstore_ea (SD_, base, offset);
5503     address_word paddr;
5504     int uncached;
5505     if ((vaddr & 3) != 0)
5506       {
5507         SIM_CORE_SIGNAL (SD, CPU, cia, read_map, AccessLength_WORD+1, vaddr, write_transfer, sim_core_unaligned_signal);
5508       }
5509     else
5510       {
5511         if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
5512           {
5513             uword64 memval = 0;
5514             uword64 memval1 = 0;
5515             uword64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
5516             address_word reverseendian = (ReverseEndian ?(mask ^ AccessLength_WORD): 0);
5517             address_word bigendiancpu = (BigEndianCPU ?(mask ^ AccessLength_WORD): 0);
5518             unsigned int byte;
5519             paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
5520             byte = ((vaddr & mask) ^ bigendiancpu);
5521             memval = (((uword64)COP_SW(((instruction_0 >> 26) & 0x3),FT)) << (8 * byte));
5522             StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
5523           }
5524       }
5525   }
5526 }
5527
5528
5529 010011,5.BASE,5.INDEX,5.FS,00000,001000:COP1X:32,f::SWXC1
5530 "swxc1 f<FS>, r<INDEX>(r<BASE>)"
5531 *mipsIV:
5532 *mipsV:
5533 *mips32r2:
5534 *mips64:
5535 *mips64r2:
5536 *vr5000:
5537 {
5538
5539   address_word base = GPR[BASE];
5540   address_word index = GPR[INDEX];
5541   check_fpu (SD_);
5542   check_u64 (SD_, instruction_0);
5543   {
5544    address_word vaddr = loadstore_ea (SD_, base, index);
5545    address_word paddr;
5546    int uncached;
5547    if ((vaddr & 3) != 0)
5548      {
5549        SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 4, vaddr, write_transfer, sim_core_unaligned_signal);
5550      }
5551    else
5552    {
5553     if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
5554     {
5555      unsigned64 memval = 0;
5556      unsigned64 memval1 = 0;
5557      unsigned64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
5558      address_word reverseendian = (ReverseEndian ? (mask ^ AccessLength_WORD) : 0);
5559      address_word bigendiancpu = (BigEndianCPU ? (mask ^ AccessLength_WORD) : 0);
5560      unsigned int byte;
5561      paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
5562      byte = ((vaddr & mask) ^ bigendiancpu);
5563      memval = (((unsigned64)COP_SW(1,FS)) << (8 * byte));
5564       {
5565        StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
5566       }
5567     }
5568    }
5569   }
5570 }
5571
5572
5573 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001001:COP1:64,f::TRUNC.L.fmt
5574 "trunc.l.%s<FMT> f<FD>, f<FS>"
5575 *mipsIII:
5576 *mipsIV:
5577 *mipsV:
5578 *mips32r2:
5579 *mips64:
5580 *mips64r2:
5581 *vr4100:
5582 *vr5000:
5583 *r3900:
5584 {
5585   int fmt = FMT;
5586   check_fpu (SD_);
5587   StoreFPR (FD, fmt_long, Convert (FP_RM_TOZERO, ValueFPR (FS, fmt), fmt,
5588             fmt_long));
5589 }
5590
5591
5592 010001,10,3.FMT!2!3!4!5!6!7,00000,5.FS,5.FD,001101:COP1:32,f::TRUNC.W
5593 "trunc.w.%s<FMT> f<FD>, f<FS>"
5594 *mipsII:
5595 *mipsIII:
5596 *mipsIV:
5597 *mipsV:
5598 *mips32:
5599 *mips32r2:
5600 *mips64:
5601 *mips64r2:
5602 *vr4100:
5603 *vr5000:
5604 *r3900:
5605 {
5606   int fmt = FMT;
5607   check_fpu (SD_);
5608   StoreFPR (FD, fmt_word, Convert (FP_RM_TOZERO, ValueFPR (FS, fmt), fmt,
5609             fmt_word));
5610 }
5611
5612 \f
5613 //
5614 // MIPS Architecture:
5615 //
5616 //        System Control Instruction Set (COP0)
5617 //
5618
5619
5620 010000,01000,00000,16.OFFSET:COP0:32::BC0F
5621 "bc0f <OFFSET>"
5622 *mipsI:
5623 *mipsII:
5624 *mipsIII:
5625 *mipsIV:
5626 *mipsV:
5627 *mips32:
5628 *mips32r2:
5629 *mips64:
5630 *mips64r2:
5631 *vr4100:
5632 *vr5000:
5633
5634 010000,01000,00000,16.OFFSET:COP0:32::BC0F
5635 "bc0f <OFFSET>"
5636 // stub needed for eCos as tx39 hardware bug workaround
5637 *r3900:
5638 {
5639   /* do nothing */
5640 }
5641
5642
5643 010000,01000,00010,16.OFFSET:COP0:32::BC0FL
5644 "bc0fl <OFFSET>"
5645 *mipsI:
5646 *mipsII:
5647 *mipsIII:
5648 *mipsIV:
5649 *mipsV:
5650 *mips32:
5651 *mips32r2:
5652 *mips64:
5653 *mips64r2:
5654 *vr4100:
5655 *vr5000:
5656
5657
5658 010000,01000,00001,16.OFFSET:COP0:32::BC0T
5659 "bc0t <OFFSET>"
5660 *mipsI:
5661 *mipsII:
5662 *mipsIII:
5663 *mipsIV:
5664 *mipsV:
5665 *mips32:
5666 *mips32r2:
5667 *mips64:
5668 *mips64r2:
5669 *vr4100:
5670
5671
5672 010000,01000,00011,16.OFFSET:COP0:32::BC0TL
5673 "bc0tl <OFFSET>"
5674 *mipsI:
5675 *mipsII:
5676 *mipsIII:
5677 *mipsIV:
5678 *mipsV:
5679 *mips32:
5680 *mips32r2:
5681 *mips64:
5682 *mips64r2:
5683 *vr4100:
5684 *vr5000:
5685
5686
5687 101111,5.BASE,5.OP,16.OFFSET:NORMAL:32::CACHE
5688 "cache <OP>, <OFFSET>(r<BASE>)"
5689 *mipsIII:
5690 *mipsIV:
5691 *mipsV:
5692 *mips32:
5693 *mips32r2:
5694 *mips64:
5695 *mips64r2:
5696 *vr4100:
5697 *vr5000:
5698 *r3900:
5699 {
5700   address_word base = GPR[BASE];
5701   address_word offset = EXTEND16 (OFFSET);
5702   {
5703     address_word vaddr = loadstore_ea (SD_, base, offset);
5704     address_word paddr;
5705     int uncached;
5706     if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
5707       CacheOp(OP,vaddr,paddr,instruction_0);
5708   }
5709 }
5710
5711
5712 010000,00001,5.RT,5.RD,00000000000:COP0:64::DMFC0
5713 "dmfc0 r<RT>, r<RD>"
5714 *mipsIII:
5715 *mipsIV:
5716 *mipsV:
5717 *mips64:
5718 *mips64r2:
5719 {
5720   check_u64 (SD_, instruction_0);
5721   DecodeCoproc (instruction_0);
5722 }
5723
5724
5725 010000,00101,5.RT,5.RD,00000000000:COP0:64::DMTC0
5726 "dmtc0 r<RT>, r<RD>"
5727 *mipsIII:
5728 *mipsIV:
5729 *mipsV:
5730 *mips64:
5731 *mips64r2:
5732 {
5733   check_u64 (SD_, instruction_0);
5734   DecodeCoproc (instruction_0);
5735 }
5736
5737
5738 010000,1,0000000000000000000,011000:COP0:32::ERET
5739 "eret"
5740 *mipsIII:
5741 *mipsIV:
5742 *mipsV:
5743 *mips32:
5744 *mips32r2:
5745 *mips64:
5746 *mips64r2:
5747 *vr4100:
5748 *vr5000:
5749 {
5750   if (SR & status_ERL)
5751     {
5752       /* Oops, not yet available */
5753       sim_io_printf (SD, "Warning: ERET when SR[ERL] set not supported");
5754       NIA = EPC;
5755       SR &= ~status_ERL;
5756     }
5757   else
5758     {
5759       NIA = EPC;
5760       SR &= ~status_EXL;
5761     }
5762 }
5763
5764
5765 010000,00000,5.RT,5.RD,00000,6.REGX:COP0:32::MFC0
5766 "mfc0 r<RT>, r<RD> # <REGX>"
5767 *mipsI:
5768 *mipsII:
5769 *mipsIII:
5770 *mipsIV:
5771 *mipsV:
5772 *mips32:
5773 *mips32r2:
5774 *mips64:
5775 *mips64r2:
5776 *vr4100:
5777 *vr5000:
5778 *r3900:
5779 {
5780   TRACE_ALU_INPUT0 ();
5781   DecodeCoproc (instruction_0);
5782   TRACE_ALU_RESULT (GPR[RT]);
5783 }
5784
5785 010000,00100,5.RT,5.RD,00000,6.REGX:COP0:32::MTC0
5786 "mtc0 r<RT>, r<RD> # <REGX>"
5787 *mipsI:
5788 *mipsII:
5789 *mipsIII:
5790 *mipsIV:
5791 *mipsV:
5792 *mips32:
5793 *mips32r2:
5794 *mips64:
5795 *mips64r2:
5796 *vr4100:
5797 *vr5000:
5798 *r3900:
5799 {
5800   DecodeCoproc (instruction_0);
5801 }
5802
5803
5804 010000,1,0000000000000000000,010000:COP0:32::RFE
5805 "rfe"
5806 *mipsI:
5807 *mipsII:
5808 *mipsIII:
5809 *mipsIV:
5810 *mipsV:
5811 *vr4100:
5812 *vr5000:
5813 *r3900:
5814 {
5815   DecodeCoproc (instruction_0);
5816 }
5817
5818
5819 0100,ZZ!0!1!3,5.COP_FUN0!8,5.COP_FUN1,16.COP_FUN2:NORMAL:32::COPz
5820 "cop<ZZ> <COP_FUN0><COP_FUN1><COP_FUN2>"
5821 *mipsI:
5822 *mipsII:
5823 *mipsIII:
5824 *mipsIV:
5825 *mipsV:
5826 *mips32:
5827 *mips32r2:
5828 *mips64:
5829 *mips64r2:
5830 *vr4100:
5831 *r3900:
5832 {
5833   DecodeCoproc (instruction_0);
5834 }
5835
5836
5837
5838 010000,1,0000000000000000000,001000:COP0:32::TLBP
5839 "tlbp"
5840 *mipsI:
5841 *mipsII:
5842 *mipsIII:
5843 *mipsIV:
5844 *mipsV:
5845 *mips32:
5846 *mips32r2:
5847 *mips64:
5848 *mips64r2:
5849 *vr4100:
5850 *vr5000:
5851
5852
5853 010000,1,0000000000000000000,000001:COP0:32::TLBR
5854 "tlbr"
5855 *mipsI:
5856 *mipsII:
5857 *mipsIII:
5858 *mipsIV:
5859 *mipsV:
5860 *mips32:
5861 *mips32r2:
5862 *mips64:
5863 *mips64r2:
5864 *vr4100:
5865 *vr5000:
5866
5867
5868 010000,1,0000000000000000000,000010:COP0:32::TLBWI
5869 "tlbwi"
5870 *mipsI:
5871 *mipsII:
5872 *mipsIII:
5873 *mipsIV:
5874 *mipsV:
5875 *mips32:
5876 *mips32r2:
5877 *mips64:
5878 *mips64r2:
5879 *vr4100:
5880 *vr5000:
5881
5882
5883 010000,1,0000000000000000000,000110:COP0:32::TLBWR
5884 "tlbwr"
5885 *mipsI:
5886 *mipsII:
5887 *mipsIII:
5888 *mipsIV:
5889 *mipsV:
5890 *mips32:
5891 *mips32r2:
5892 *mips64:
5893 *mips64r2:
5894 *vr4100:
5895 *vr5000:
5896
5897
5898 :include:::mips3264r2.igen
5899 :include:::m16.igen
5900 :include:::m16e.igen
5901 :include:::mdmx.igen
5902 :include:::mips3d.igen
5903 :include:::sb1.igen
5904 :include:::tx.igen
5905 :include:::vr.igen
5906 :include:::dsp.igen
5907 :include:::dsp2.igen
5908 :include:::smartmips.igen
5909