4 // <insn-word> { "+" <insn-word> }
11 // { <insn-mnemonic> }
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
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
29 // Generate separate simulators for each target
30 // :option:::multi-sim:true
33 // Models known by this simulator
34 :model:::mipsI:mips3000:
35 :model:::mipsII:mips6000:
36 :model:::mipsIII:mips4000:
37 :model:::mipsIV:mips8000:
38 :model:::mips16:mips16:
39 // start-sanitize-r5900
40 :model:::r5900:mips5900:
42 :model:::r3900:mips3900:
43 // start-sanitize-tx19
46 // start-sanitize-vr4320
47 :model:::vr4320:mips4320:
48 // end-sanitize-vr4320
49 // start-sanitize-vr5400
50 :model:::vr5400:mips5400:
52 // end-sanitize-vr5400
53 :model:::vr5000:mips5000:
57 // Pseudo instructions known by IGEN
60 SignalException (ReservedInstruction, 0);
64 // Pseudo instructions known by interp.c
65 // For grep - RSVD_INSTRUCTION, RSVD_INSTRUCTION_MASK
66 000000,5.*,5.*,5.*,5.OP,000101:SPECIAL:32::RSVD
69 SignalException (ReservedInstruction, instruction_0);
76 // Simulate a 32 bit delayslot instruction
79 :function:::address_word:delayslot32:address_word target
81 instruction_word delay_insn;
82 sim_events_slip (SD, 1);
84 CIA = CIA + 4; /* NOTE not mips16 */
85 STATE |= simDELAYSLOT;
86 delay_insn = IMEM32 (CIA); /* NOTE not mips16 */
87 idecode_issue (CPU_, delay_insn, (CIA));
88 STATE &= ~simDELAYSLOT;
92 :function:::address_word:nullify_next_insn32:
94 sim_events_slip (SD, 1);
95 dotrace (SD, CPU, tracefh, 2, CIA + 4, 4, "load instruction");
103 // Check that an access to a HI/LO register meets timing requirements
105 // The following requirements exist:
107 // - A MT {HI,LO} update was not immediatly preceeded by a MF {HI,LO} read
108 // - A OP {HI,LO} update was not immediatly preceeded by a MF {HI,LO} read
109 // - A MF {HI,LO} read was not corrupted by a preceeding MT{LO,HI} update
110 // corruption occures when MT{LO,HI} is preceeded by a OP {HI,LO}.
113 :function:::int:check_mf_cycles:hilo_history *history, signed64 time, const char *new
115 if (history->mf.timestamp + 3 > time)
117 sim_engine_abort (SD, CPU, CIA, "HILO: %s: %s at 0x%08lx too close to MF at 0x%08lx\n",
118 itable[MY_INDEX].name,
120 (long) history->mf.cia);
126 :function:::int:check_mt_hilo:hilo_history *history
127 *mipsI,mipsII,mipsIII,mipsIV:
129 // start-sanitize-vr4320
131 // end-sanitize-vr4320
132 // start-sanitize-vr5400
134 // end-sanitize-vr5400
136 signed64 time = sim_events_time (SD);
137 int ok = check_mf_cycles (SD_, history, time, "MT");
138 history->mt.timestamp = time;
139 history->mt.cia = CIA;
143 :function:::int:check_mt_hilo:hilo_history *history
145 // start-sanitize-tx19
148 // start-sanitize-r5900
150 // end-sanitize-r5900
152 signed64 time = sim_events_time (SD);
153 history->mt.timestamp = time;
154 history->mt.cia = CIA;
159 :function:::int:check_mf_hilo:hilo_history *history, hilo_history *peer
160 *mipsI,mipsII,mipsIII,mipsIV:
162 // start-sanitize-vr4320
164 // end-sanitize-vr4320
165 // start-sanitize-vr5400
167 // end-sanitize-vr5400
169 // start-sanitize-tx19
173 signed64 time = sim_events_time (SD);
176 && peer->mt.timestamp > history->op.timestamp
177 && history->mf.timestamp < history->op.timestamp)
179 /* The peer has been written to since the last OP yet we have
181 sim_engine_abort (SD, CPU, CIA, "HILO: %s: MF at 0x%08lx following OP at 0x%08lx corrupted by MT at 0x%08lx\n",
182 itable[MY_INDEX].name,
184 (long) history->op.cia,
185 (long) peer->mt.cia);
188 history->mf.timestamp = time;
189 history->mf.cia = CIA;
193 // start-sanitize-r5900
194 // The r5900 mfhi et.al insns _can_ be exectuted immediatly after a div
195 :function:::int:check_mf_hilo:hilo_history *history, hilo_history *peer
196 // end-sanitize-r5900
197 // start-sanitize-r5900
199 // end-sanitize-r5900
200 // start-sanitize-r5900
202 /* FIXME: could record the fact that a stall occured if we want */
203 signed64 time = sim_events_time (SD);
204 history->mf.timestamp = time;
205 history->mf.cia = CIA;
208 // end-sanitize-r5900
211 :function:::int:check_mult_hilo:hilo_history *hi, hilo_history *lo
212 *mipsI,mipsII,mipsIII,mipsIV:
214 // start-sanitize-vr4320
216 // end-sanitize-vr4320
217 // start-sanitize-vr5400
219 // end-sanitize-vr5400
221 signed64 time = sim_events_time (SD);
222 int ok = (check_mf_cycles (SD_, hi, time, "OP")
223 && check_mf_cycles (SD_, lo, time, "OP"));
224 hi->op.timestamp = time;
225 lo->op.timestamp = time;
231 // The r3900 mult and multu insns _can_ be exectuted immediatly after
233 :function:::int:check_mult_hilo:hilo_history *hi, hilo_history *lo
235 // start-sanitize-tx19
238 // start-sanitize-r5900
240 // end-sanitize-r5900
242 /* FIXME: could record the fact that a stall occured if we want */
243 signed64 time = sim_events_time (SD);
244 hi->op.timestamp = time;
245 lo->op.timestamp = time;
252 :function:::int:check_div_hilo:hilo_history *hi, hilo_history *lo
253 *mipsI,mipsII,mipsIII,mipsIV:
255 // start-sanitize-vr4320
257 // end-sanitize-vr4320
258 // start-sanitize-vr5400
260 // end-sanitize-vr5400
262 // start-sanitize-tx19
266 signed64 time = sim_events_time (SD);
267 int ok = (check_mf_cycles (SD_, hi, time, "OP")
268 && check_mf_cycles (SD_, lo, time, "OP"));
269 hi->op.timestamp = time;
270 lo->op.timestamp = time;
277 // start-sanitize-r5900
278 // The r5900 div et.al insns _can_ be exectuted immediatly after
280 :function:::int:check_div_hilo:hilo_history *hi, hilo_history *lo
281 // end-sanitize-r5900
282 // start-sanitize-r5900
284 // end-sanitize-r5900
285 // start-sanitize-r5900
287 /* FIXME: could record the fact that a stall occured if we want */
288 signed64 time = sim_events_time (SD);
289 hi->op.timestamp = time;
290 lo->op.timestamp = time;
295 // end-sanitize-r5900
300 // Mips Architecture:
302 // CPU Instruction Set (mipsI - mipsIV)
307 000000,5.RS,5.RT,5.RD,00000,100000:SPECIAL:32::ADD
308 "add r<RD>, r<RS>, r<RT>"
309 *mipsI,mipsII,mipsIII,mipsIV:
311 // start-sanitize-vr4320
313 // end-sanitize-vr4320
314 // start-sanitize-vr5400
316 // end-sanitize-vr5400
317 // start-sanitize-r5900
319 // end-sanitize-r5900
321 // start-sanitize-tx19
325 TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
327 ALU32_BEGIN (GPR[RS]);
331 TRACE_ALU_RESULT (GPR[RD]);
336 001000,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ADDI
337 "addi r<RT>, r<RS>, IMMEDIATE"
338 *mipsI,mipsII,mipsIII,mipsIV:
340 // start-sanitize-vr4320
342 // end-sanitize-vr4320
343 // start-sanitize-vr5400
345 // end-sanitize-vr5400
346 // start-sanitize-r5900
348 // end-sanitize-r5900
350 // start-sanitize-tx19
354 TRACE_ALU_INPUT2 (GPR[RS], EXTEND16 (IMMEDIATE));
356 ALU32_BEGIN (GPR[RS]);
357 ALU32_ADD (EXTEND16 (IMMEDIATE));
360 TRACE_ALU_RESULT (GPR[RT]);
365 :function:::void:do_addiu:int rs, int rt, unsigned16 immediate
367 TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
368 GPR[rt] = EXTEND32 (GPR[rs] + EXTEND16 (immediate));
369 TRACE_ALU_RESULT (GPR[rt]);
372 001001,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ADDIU
373 "addiu r<RT>, r<RS>, <IMMEDIATE>"
374 *mipsI,mipsII,mipsIII,mipsIV:
376 // start-sanitize-vr4320
378 // end-sanitize-vr4320
379 // start-sanitize-vr5400
381 // end-sanitize-vr5400
382 // start-sanitize-r5900
384 // end-sanitize-r5900
386 // start-sanitize-tx19
390 do_addiu (SD_, RS, RT, IMMEDIATE);
395 :function:::void:do_addu:int rs, int rt, int rd
397 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
398 GPR[rd] = EXTEND32 (GPR[rs] + GPR[rt]);
399 TRACE_ALU_RESULT (GPR[rd]);
402 000000,5.RS,5.RT,5.RD,00000,100001:SPECIAL:32::ADDU
403 "addu r<RD>, r<RS>, r<RT>"
404 *mipsI,mipsII,mipsIII,mipsIV:
406 // start-sanitize-vr4320
408 // end-sanitize-vr4320
409 // start-sanitize-vr5400
411 // end-sanitize-vr5400
412 // start-sanitize-r5900
414 // end-sanitize-r5900
416 // start-sanitize-tx19
420 do_addu (SD_, RS, RT, RD);
425 :function:::void:do_and:int rs, int rt, int rd
427 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
428 GPR[rd] = GPR[rs] & GPR[rt];
429 TRACE_ALU_RESULT (GPR[rd]);
432 000000,5.RS,5.RT,5.RD,00000,100100:SPECIAL:32::AND
433 "and r<RD>, r<RS>, r<RT>"
434 *mipsI,mipsII,mipsIII,mipsIV:
436 // start-sanitize-vr4320
438 // end-sanitize-vr4320
439 // start-sanitize-vr5400
441 // end-sanitize-vr5400
442 // start-sanitize-r5900
444 // end-sanitize-r5900
446 // start-sanitize-tx19
450 do_and (SD_, RS, RT, RD);
455 001100,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ANDI
456 "and r<RT>, r<RS>, <IMMEDIATE>"
457 *mipsI,mipsII,mipsIII,mipsIV:
459 // start-sanitize-vr4320
461 // end-sanitize-vr4320
462 // start-sanitize-vr5400
464 // end-sanitize-vr5400
465 // start-sanitize-r5900
467 // end-sanitize-r5900
469 // start-sanitize-tx19
473 TRACE_ALU_INPUT2 (GPR[RS], IMMEDIATE);
474 GPR[RT] = GPR[RS] & IMMEDIATE;
475 TRACE_ALU_RESULT (GPR[RT]);
480 000100,5.RS,5.RT,16.OFFSET:NORMAL:32::BEQ
481 "beq r<RS>, r<RT>, <OFFSET>"
482 *mipsI,mipsII,mipsIII,mipsIV:
484 // start-sanitize-vr4320
486 // end-sanitize-vr4320
487 // start-sanitize-vr5400
489 // end-sanitize-vr5400
490 // start-sanitize-r5900
492 // end-sanitize-r5900
494 // start-sanitize-tx19
498 address_word offset = EXTEND16 (OFFSET) << 2;
499 if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
500 DELAY_SLOT (NIA + offset);
505 010100,5.RS,5.RT,16.OFFSET:NORMAL:32::BEQL
506 "beql r<RS>, r<RT>, <OFFSET>"
511 // start-sanitize-vr4320
513 // end-sanitize-vr4320
514 // start-sanitize-vr5400
516 // end-sanitize-vr5400
517 // start-sanitize-r5900
519 // end-sanitize-r5900
521 // start-sanitize-tx19
525 address_word offset = EXTEND16 (OFFSET) << 2;
526 if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
527 DELAY_SLOT (NIA + offset);
529 NULLIFY_NEXT_INSTRUCTION ();
534 000001,5.RS,00001,16.OFFSET:REGIMM:32::BGEZ
535 "bgez r<RS>, <OFFSET>"
536 *mipsI,mipsII,mipsIII,mipsIV:
538 // start-sanitize-vr4320
540 // end-sanitize-vr4320
541 // start-sanitize-vr5400
543 // end-sanitize-vr5400
544 // start-sanitize-r5900
546 // end-sanitize-r5900
548 // start-sanitize-tx19
552 address_word offset = EXTEND16 (OFFSET) << 2;
553 if ((signed_word) GPR[RS] >= 0)
554 DELAY_SLOT (NIA + offset);
559 000001,5.RS!31,10001,16.OFFSET:REGIMM:32::BGEZAL
560 "bgezal r<RS>, <OFFSET>"
561 *mipsI,mipsII,mipsIII,mipsIV:
563 // start-sanitize-vr4320
565 // end-sanitize-vr4320
566 // start-sanitize-vr5400
568 // end-sanitize-vr5400
569 // start-sanitize-r5900
571 // end-sanitize-r5900
573 // start-sanitize-tx19
577 address_word offset = EXTEND16 (OFFSET) << 2;
579 if ((signed_word) GPR[RS] >= 0)
580 DELAY_SLOT (NIA + offset);
585 000001,5.RS!31,10011,16.OFFSET:REGIMM:32::BGEZALL
586 "bgezall r<RS>, <OFFSET>"
591 // start-sanitize-vr4320
593 // end-sanitize-vr4320
594 // start-sanitize-vr5400
596 // end-sanitize-vr5400
597 // start-sanitize-r5900
599 // end-sanitize-r5900
601 // start-sanitize-tx19
605 address_word offset = EXTEND16 (OFFSET) << 2;
607 /* NOTE: The branch occurs AFTER the next instruction has been
609 if ((signed_word) GPR[RS] >= 0)
610 DELAY_SLOT (NIA + offset);
612 NULLIFY_NEXT_INSTRUCTION ();
617 000001,5.RS,00011,16.OFFSET:REGIMM:32::BGEZL
618 "bgezl r<RS>, <OFFSET>"
623 // start-sanitize-vr4320
625 // end-sanitize-vr4320
626 // start-sanitize-vr5400
628 // end-sanitize-vr5400
629 // start-sanitize-r5900
631 // end-sanitize-r5900
633 // start-sanitize-tx19
637 address_word offset = EXTEND16 (OFFSET) << 2;
638 if ((signed_word) GPR[RS] >= 0)
639 DELAY_SLOT (NIA + offset);
641 NULLIFY_NEXT_INSTRUCTION ();
646 000111,5.RS,00000,16.OFFSET:NORMAL:32::BGTZ
647 "bgtz r<RS>, <OFFSET>"
648 *mipsI,mipsII,mipsIII,mipsIV:
650 // start-sanitize-vr4320
652 // end-sanitize-vr4320
653 // start-sanitize-vr5400
655 // end-sanitize-vr5400
656 // start-sanitize-r5900
658 // end-sanitize-r5900
660 // start-sanitize-tx19
664 address_word offset = EXTEND16 (OFFSET) << 2;
665 if ((signed_word) GPR[RS] > 0)
666 DELAY_SLOT (NIA + offset);
671 010111,5.RS,00000,16.OFFSET:NORMAL:32::BGTZL
672 "bgtzl r<RS>, <OFFSET>"
677 // start-sanitize-vr4320
679 // end-sanitize-vr4320
680 // start-sanitize-vr5400
682 // end-sanitize-vr5400
683 // start-sanitize-r5900
685 // end-sanitize-r5900
687 // start-sanitize-tx19
691 address_word offset = EXTEND16 (OFFSET) << 2;
692 /* NOTE: The branch occurs AFTER the next instruction has been
694 if ((signed_word) GPR[RS] > 0)
695 DELAY_SLOT (NIA + offset);
697 NULLIFY_NEXT_INSTRUCTION ();
702 000110,5.RS,00000,16.OFFSET:NORMAL:32::BLEZ
703 "blez r<RS>, <OFFSET>"
704 *mipsI,mipsII,mipsIII,mipsIV:
706 // start-sanitize-vr4320
708 // end-sanitize-vr4320
709 // start-sanitize-vr5400
711 // end-sanitize-vr5400
712 // start-sanitize-r5900
714 // end-sanitize-r5900
716 // start-sanitize-tx19
720 address_word offset = EXTEND16 (OFFSET) << 2;
721 /* NOTE: The branch occurs AFTER the next instruction has been
723 if ((signed_word) GPR[RS] <= 0)
724 DELAY_SLOT (NIA + offset);
729 010110,5.RS,00000,16.OFFSET:NORMAL:32::BLEZL
730 "bgezl r<RS>, <OFFSET>"
735 // start-sanitize-vr4320
737 // end-sanitize-vr4320
738 // start-sanitize-vr5400
740 // end-sanitize-vr5400
741 // start-sanitize-r5900
743 // end-sanitize-r5900
745 // start-sanitize-tx19
749 address_word offset = EXTEND16 (OFFSET) << 2;
750 if ((signed_word) GPR[RS] <= 0)
751 DELAY_SLOT (NIA + offset);
753 NULLIFY_NEXT_INSTRUCTION ();
758 000001,5.RS,00000,16.OFFSET:REGIMM:32::BLTZ
759 "bltz r<RS>, <OFFSET>"
760 *mipsI,mipsII,mipsIII,mipsIV:
762 // start-sanitize-vr4320
764 // end-sanitize-vr4320
765 // start-sanitize-vr5400
767 // end-sanitize-vr5400
768 // start-sanitize-r5900
770 // end-sanitize-r5900
772 // start-sanitize-tx19
776 address_word offset = EXTEND16 (OFFSET) << 2;
777 if ((signed_word) GPR[RS] < 0)
778 DELAY_SLOT (NIA + offset);
783 000001,5.RS!31,10000,16.OFFSET:REGIMM:32::BLTZAL
784 "bltzal r<RS>, <OFFSET>"
785 *mipsI,mipsII,mipsIII,mipsIV:
787 // start-sanitize-vr4320
789 // end-sanitize-vr4320
790 // start-sanitize-vr5400
792 // end-sanitize-vr5400
793 // start-sanitize-r5900
795 // end-sanitize-r5900
797 // start-sanitize-tx19
801 address_word offset = EXTEND16 (OFFSET) << 2;
803 /* NOTE: The branch occurs AFTER the next instruction has been
805 if ((signed_word) GPR[RS] < 0)
806 DELAY_SLOT (NIA + offset);
811 000001,5.RS!31,10010,16.OFFSET:REGIMM:32::BLTZALL
812 "bltzall r<RS>, <OFFSET>"
817 // start-sanitize-vr4320
819 // end-sanitize-vr4320
820 // start-sanitize-vr5400
822 // end-sanitize-vr5400
823 // start-sanitize-r5900
825 // end-sanitize-r5900
827 // start-sanitize-tx19
831 address_word offset = EXTEND16 (OFFSET) << 2;
833 if ((signed_word) GPR[RS] < 0)
834 DELAY_SLOT (NIA + offset);
836 NULLIFY_NEXT_INSTRUCTION ();
841 000001,5.RS,00010,16.OFFSET:REGIMM:32::BLTZL
842 "bltzl r<RS>, <OFFSET>"
847 // start-sanitize-vr4320
849 // end-sanitize-vr4320
850 // start-sanitize-vr5400
852 // end-sanitize-vr5400
853 // start-sanitize-r5900
855 // end-sanitize-r5900
857 // start-sanitize-tx19
861 address_word offset = EXTEND16 (OFFSET) << 2;
862 /* NOTE: The branch occurs AFTER the next instruction has been
864 if ((signed_word) GPR[RS] < 0)
865 DELAY_SLOT (NIA + offset);
867 NULLIFY_NEXT_INSTRUCTION ();
872 000101,5.RS,5.RT,16.OFFSET:NORMAL:32::BNE
873 "bne r<RS>, r<RT>, <OFFSET>"
874 *mipsI,mipsII,mipsIII,mipsIV:
876 // start-sanitize-vr4320
878 // end-sanitize-vr4320
879 // start-sanitize-vr5400
881 // end-sanitize-vr5400
882 // start-sanitize-r5900
884 // end-sanitize-r5900
886 // start-sanitize-tx19
890 address_word offset = EXTEND16 (OFFSET) << 2;
891 if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
892 DELAY_SLOT (NIA + offset);
897 010101,5.RS,5.RT,16.OFFSET:NORMAL:32::BNEL
898 "bnel r<RS>, r<RT>, <OFFSET>"
903 // start-sanitize-vr4320
905 // end-sanitize-vr4320
906 // start-sanitize-vr5400
908 // end-sanitize-vr5400
909 // start-sanitize-r5900
911 // end-sanitize-r5900
913 // start-sanitize-tx19
917 address_word offset = EXTEND16 (OFFSET) << 2;
918 if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
919 DELAY_SLOT (NIA + offset);
921 NULLIFY_NEXT_INSTRUCTION ();
926 000000,20.CODE,001101:SPECIAL:32::BREAK
928 *mipsI,mipsII,mipsIII,mipsIV:
930 // start-sanitize-vr4320
932 // end-sanitize-vr4320
933 // start-sanitize-vr5400
935 // end-sanitize-vr5400
936 // start-sanitize-r5900
938 // end-sanitize-r5900
940 // start-sanitize-tx19
944 /* Check for some break instruction which are reserved for use by the simulator. */
945 unsigned int break_code = instruction_0 & HALT_INSTRUCTION_MASK;
946 if (break_code == (HALT_INSTRUCTION & HALT_INSTRUCTION_MASK) ||
947 break_code == (HALT_INSTRUCTION2 & HALT_INSTRUCTION_MASK))
949 sim_engine_halt (SD, CPU, NULL, cia,
950 sim_exited, (unsigned int)(A0 & 0xFFFFFFFF));
952 else if (break_code == (BREAKPOINT_INSTRUCTION & HALT_INSTRUCTION_MASK) ||
953 break_code == (BREAKPOINT_INSTRUCTION2 & HALT_INSTRUCTION_MASK))
955 if (STATE & simDELAYSLOT)
956 PC = cia - 4; /* reference the branch instruction */
959 sim_engine_halt (SD, CPU, NULL, cia, sim_stopped, SIM_SIGTRAP);
961 // start-sanitize-sky
962 else if (break_code == (HALT_INSTRUCTION_PASS & HALT_INSTRUCTION_MASK))
964 sim_engine_halt (SD, CPU, NULL, cia, sim_exited, 0);
966 else if (break_code == (HALT_INSTRUCTION_FAIL & HALT_INSTRUCTION_MASK))
968 sim_engine_halt (SD, CPU, NULL, cia, sim_exited, 15);
972 /* If we get this far, we're not an instruction reserved by the sim. Raise
974 SignalException(BreakPoint, instruction_0);
982 000000,5.RS,5.RT,5.RD,00000,101100:SPECIAL:64::DADD
983 "dadd r<RD>, r<RS>, r<RT>"
987 // start-sanitize-vr4320
989 // end-sanitize-vr4320
990 // start-sanitize-vr5400
992 // end-sanitize-vr5400
993 // start-sanitize-r5900
995 // end-sanitize-r5900
996 // start-sanitize-tx19
1000 /* this check's for overflow */
1001 TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
1003 ALU64_BEGIN (GPR[RS]);
1004 ALU64_ADD (GPR[RT]);
1005 ALU64_END (GPR[RD]);
1007 TRACE_ALU_RESULT (GPR[RD]);
1012 011000,5.RS,5.RT,16.IMMEDIATE:NORMAL:64::DADDI
1013 "daddi r<RT>, r<RS>, <IMMEDIATE>"
1017 // start-sanitize-vr4320
1019 // end-sanitize-vr4320
1020 // start-sanitize-vr5400
1022 // end-sanitize-vr5400
1023 // start-sanitize-r5900
1025 // end-sanitize-r5900
1026 // start-sanitize-tx19
1028 // end-sanitize-tx19
1030 TRACE_ALU_INPUT2 (GPR[RS], EXTEND16 (IMMEDIATE));
1032 ALU64_BEGIN (GPR[RS]);
1033 ALU64_ADD (EXTEND16 (IMMEDIATE));
1034 ALU64_END (GPR[RT]);
1036 TRACE_ALU_RESULT (GPR[RT]);
1041 :function:64::void:do_daddiu:int rs, int rt, unsigned16 immediate
1043 TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
1044 GPR[rt] = GPR[rs] + EXTEND16 (immediate);
1045 TRACE_ALU_RESULT (GPR[rt]);
1048 011001,5.RS,5.RT,16.IMMEDIATE:NORMAL:64::DADDIU
1049 "daddu r<RT>, r<RS>, <IMMEDIATE>"
1053 // start-sanitize-vr4320
1055 // end-sanitize-vr4320
1056 // start-sanitize-vr5400
1058 // end-sanitize-vr5400
1059 // start-sanitize-r5900
1061 // end-sanitize-r5900
1062 // start-sanitize-tx19
1064 // end-sanitize-tx19
1066 do_daddiu (SD_, RS, RT, IMMEDIATE);
1071 :function:::void:do_daddu:int rs, int rt, int rd
1073 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1074 GPR[rd] = GPR[rs] + GPR[rt];
1075 TRACE_ALU_RESULT (GPR[rd]);
1078 000000,5.RS,5.RT,5.RD,00000,101101:SPECIAL:64::DADDU
1079 "daddu r<RD>, r<RS>, r<RT>"
1083 // start-sanitize-vr4320
1085 // end-sanitize-vr4320
1086 // start-sanitize-vr5400
1088 // end-sanitize-vr5400
1089 // start-sanitize-r5900
1091 // end-sanitize-r5900
1092 // start-sanitize-tx19
1094 // end-sanitize-tx19
1096 do_daddu (SD_, RS, RT, RD);
1101 :function:64::void:do_ddiv:int rs, int rt
1103 check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1104 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1106 signed64 n = GPR[rs];
1107 signed64 d = GPR[rt];
1110 LO = SIGNED64 (0x8000000000000000);
1113 else if (d == -1 && n == SIGNED64 (0x8000000000000000))
1115 LO = SIGNED64 (0x8000000000000000);
1124 TRACE_ALU_RESULT2 (HI, LO);
1127 000000,5.RS,5.RT,0000000000011110:SPECIAL:64::DDIV
1132 // start-sanitize-vr4320
1134 // end-sanitize-vr4320
1135 // start-sanitize-vr5400
1137 // end-sanitize-vr5400
1138 // start-sanitize-r5900
1140 // end-sanitize-r5900
1141 // start-sanitize-tx19
1143 // end-sanitize-tx19
1145 do_ddiv (SD_, RS, RT);
1150 :function:64::void:do_ddivu:int rs, int rt
1152 check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1153 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1155 unsigned64 n = GPR[rs];
1156 unsigned64 d = GPR[rt];
1159 LO = SIGNED64 (0x8000000000000000);
1168 TRACE_ALU_RESULT2 (HI, LO);
1171 000000,5.RS,5.RT,0000000000,011111:SPECIAL:64::DDIVU
1172 "ddivu r<RS>, r<RT>"
1176 // start-sanitize-vr4320
1178 // end-sanitize-vr4320
1179 // start-sanitize-vr5400
1181 // end-sanitize-vr5400
1182 // start-sanitize-tx19
1184 // end-sanitize-tx19
1186 do_ddivu (SD_, RS, RT);
1191 :function:::void:do_div:int rs, int rt
1193 check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1194 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1196 signed32 n = GPR[rs];
1197 signed32 d = GPR[rt];
1200 LO = EXTEND32 (0x80000000);
1203 else if (n == SIGNED32 (0x80000000) && d == -1)
1205 LO = EXTEND32 (0x80000000);
1210 LO = EXTEND32 (n / d);
1211 HI = EXTEND32 (n % d);
1214 TRACE_ALU_RESULT2 (HI, LO);
1217 000000,5.RS,5.RT,0000000000011010:SPECIAL:32::DIV
1219 *mipsI,mipsII,mipsIII,mipsIV:
1221 // start-sanitize-vr4320
1223 // end-sanitize-vr4320
1224 // start-sanitize-vr5400
1226 // end-sanitize-vr5400
1227 // start-sanitize-r5900
1229 // end-sanitize-r5900
1231 // start-sanitize-tx19
1233 // end-sanitize-tx19
1235 do_div (SD_, RS, RT);
1240 :function:::void:do_divu:int rs, int rt
1242 check_div_hilo (SD_, HIHISTORY, LOHISTORY);
1243 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1245 unsigned32 n = GPR[rs];
1246 unsigned32 d = GPR[rt];
1249 LO = EXTEND32 (0x80000000);
1254 LO = EXTEND32 (n / d);
1255 HI = EXTEND32 (n % d);
1258 TRACE_ALU_RESULT2 (HI, LO);
1261 000000,5.RS,5.RT,0000000000011011:SPECIAL:32::DIVU
1263 *mipsI,mipsII,mipsIII,mipsIV:
1265 // start-sanitize-vr4320
1267 // end-sanitize-vr4320
1268 // start-sanitize-vr5400
1270 // end-sanitize-vr5400
1271 // start-sanitize-r5900
1273 // end-sanitize-r5900
1275 // start-sanitize-tx19
1277 // end-sanitize-tx19
1279 do_divu (SD_, RS, RT);
1284 :function:::void:do_dmultx:int rs, int rt, int rd, int signed_p
1294 unsigned64 op1 = GPR[rs];
1295 unsigned64 op2 = GPR[rt];
1296 check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
1297 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1298 /* make signed multiply unsigned */
1313 /* multuply out the 4 sub products */
1314 m00 = ((unsigned64) VL4_8 (op1) * (unsigned64) VL4_8 (op2));
1315 m10 = ((unsigned64) VH4_8 (op1) * (unsigned64) VL4_8 (op2));
1316 m01 = ((unsigned64) VL4_8 (op1) * (unsigned64) VH4_8 (op2));
1317 m11 = ((unsigned64) VH4_8 (op1) * (unsigned64) VH4_8 (op2));
1318 /* add the products */
1319 mid = ((unsigned64) VH4_8 (m00)
1320 + (unsigned64) VL4_8 (m10)
1321 + (unsigned64) VL4_8 (m01));
1322 lo = U8_4 (mid, m00);
1324 + (unsigned64) VH4_8 (mid)
1325 + (unsigned64) VH4_8 (m01)
1326 + (unsigned64) VH4_8 (m10));
1336 /* save the result HI/LO (and a gpr) */
1341 TRACE_ALU_RESULT2 (HI, LO);
1344 :function:::void:do_dmult:int rs, int rt, int rd
1346 do_dmultx (SD_, rs, rt, rd, 1);
1349 000000,5.RS,5.RT,0000000000011100:SPECIAL:64::DMULT
1350 "dmult r<RS>, r<RT>"
1352 // start-sanitize-tx19
1354 // end-sanitize-tx19
1355 // start-sanitize-vr4320
1357 // end-sanitize-vr4320
1359 do_dmult (SD_, RS, RT, 0);
1362 000000,5.RS,5.RT,5.RD,00000011100:SPECIAL:64::DMULT
1363 "dmult r<RS>, r<RT>":RD == 0
1364 "dmult r<RD>, r<RS>, r<RT>"
1366 // start-sanitize-vr5400
1368 // end-sanitize-vr5400
1370 do_dmult (SD_, RS, RT, RD);
1375 :function:::void:do_dmultu:int rs, int rt, int rd
1377 do_dmultx (SD_, rs, rt, rd, 0);
1380 000000,5.RS,5.RT,0000000000011101:SPECIAL:64::DMULTU
1381 "dmultu r<RS>, r<RT>"
1383 // start-sanitize-tx19
1385 // end-sanitize-tx19
1386 // start-sanitize-vr4320
1388 // end-sanitize-vr4320
1390 do_dmultu (SD_, RS, RT, 0);
1393 000000,5.RS,5.RT,5.RD,00000011101:SPECIAL:64::DMULTU
1394 "dmultu r<RD>, r<RS>, r<RT>":RD == 0
1395 "dmultu r<RS>, r<RT>"
1397 // start-sanitize-vr5400
1399 // end-sanitize-vr5400
1401 do_dmultu (SD_, RS, RT, RD);
1406 00000000000,5.RT,5.RD,5.SHIFT,111000:SPECIAL:64::DSLL
1407 "dsll r<RD>, r<RT>, <SHIFT>"
1411 // start-sanitize-vr4320
1413 // end-sanitize-vr4320
1414 // start-sanitize-vr5400
1416 // end-sanitize-vr5400
1417 // start-sanitize-r5900
1419 // end-sanitize-r5900
1420 // start-sanitize-tx19
1422 // end-sanitize-tx19
1425 GPR[RD] = GPR[RT] << s;
1429 00000000000,5.RT,5.RD,5.SHIFT,111100:SPECIAL:64::DSLL32
1430 "dsll32 r<RD>, r<RT>, <SHIFT>"
1434 // start-sanitize-vr4320
1436 // end-sanitize-vr4320
1437 // start-sanitize-vr5400
1439 // end-sanitize-vr5400
1440 // start-sanitize-r5900
1442 // end-sanitize-r5900
1443 // start-sanitize-tx19
1445 // end-sanitize-tx19
1448 GPR[RD] = GPR[RT] << s;
1453 000000,5.RS,5.RT,5.RD,00000010100:SPECIAL:64::DSLLV
1454 "dsllv r<RD>, r<RT>, r<RS>"
1458 // start-sanitize-vr4320
1460 // end-sanitize-vr4320
1461 // start-sanitize-vr5400
1463 // end-sanitize-vr5400
1464 // start-sanitize-r5900
1466 // end-sanitize-r5900
1467 // start-sanitize-tx19
1469 // end-sanitize-tx19
1471 int s = MASKED64 (GPR[RS], 5, 0);
1472 GPR[RD] = GPR[RT] << s;
1477 00000000000,5.RT,5.RD,5.SHIFT,111011:SPECIAL:64::DSRA
1478 "dsra r<RD>, r<RT>, <SHIFT>"
1482 // start-sanitize-vr4320
1484 // end-sanitize-vr4320
1485 // start-sanitize-vr5400
1487 // end-sanitize-vr5400
1488 // start-sanitize-r5900
1490 // end-sanitize-r5900
1491 // start-sanitize-tx19
1493 // end-sanitize-tx19
1496 GPR[RD] = ((signed64) GPR[RT]) >> s;
1500 00000000000,5.RT,5.RD,5.SHIFT,111111:SPECIAL:64::DSRA32
1501 "dsra32 r<RT>, r<RD>, <SHIFT>"
1505 // start-sanitize-vr4320
1507 // end-sanitize-vr4320
1508 // start-sanitize-vr5400
1510 // end-sanitize-vr5400
1511 // start-sanitize-r5900
1513 // end-sanitize-r5900
1514 // start-sanitize-tx19
1516 // end-sanitize-tx19
1519 GPR[RD] = ((signed64) GPR[RT]) >> s;
1523 :function:::void:do_dsrav:int rs, int rt, int rd
1525 int s = MASKED64 (GPR[rs], 5, 0);
1526 TRACE_ALU_INPUT2 (GPR[rt], s);
1527 GPR[rd] = ((signed64) GPR[rt]) >> s;
1528 TRACE_ALU_RESULT (GPR[rd]);
1531 000000,5.RS,5.RT,5.RD,00000010111:SPECIAL:64::DSRAV
1532 "dsra32 r<RT>, r<RD>, r<RS>"
1536 // start-sanitize-vr4320
1538 // end-sanitize-vr4320
1539 // start-sanitize-vr5400
1541 // end-sanitize-vr5400
1542 // start-sanitize-r5900
1544 // end-sanitize-r5900
1545 // start-sanitize-tx19
1547 // end-sanitize-tx19
1549 do_dsrav (SD_, RS, RT, RD);
1553 00000000000,5.RT,5.RD,5.SHIFT,111010:SPECIAL:64::DSRL
1554 "dsrl r<RD>, r<RT>, <SHIFT>"
1558 // start-sanitize-vr4320
1560 // end-sanitize-vr4320
1561 // start-sanitize-vr5400
1563 // end-sanitize-vr5400
1564 // start-sanitize-r5900
1566 // end-sanitize-r5900
1567 // start-sanitize-tx19
1569 // end-sanitize-tx19
1572 GPR[RD] = (unsigned64) GPR[RT] >> s;
1576 00000000000,5.RT,5.RD,5.SHIFT,111110:SPECIAL:64::DSRL32
1577 "dsrl32 r<RD>, r<RT>, <SHIFT>"
1581 // start-sanitize-vr4320
1583 // end-sanitize-vr4320
1584 // start-sanitize-vr5400
1586 // end-sanitize-vr5400
1587 // start-sanitize-r5900
1589 // end-sanitize-r5900
1590 // start-sanitize-tx19
1592 // end-sanitize-tx19
1595 GPR[RD] = (unsigned64) GPR[RT] >> s;
1599 000000,5.RS,5.RT,5.RD,00000010110:SPECIAL:64::DSRLV
1600 "dsrl32 r<RD>, r<RT>, r<RS>"
1604 // start-sanitize-vr4320
1606 // end-sanitize-vr4320
1607 // start-sanitize-vr5400
1609 // end-sanitize-vr5400
1610 // start-sanitize-r5900
1612 // end-sanitize-r5900
1613 // start-sanitize-tx19
1615 // end-sanitize-tx19
1617 int s = MASKED64 (GPR[RS], 5, 0);
1618 GPR[RD] = (unsigned64) GPR[RT] >> s;
1622 000000,5.RS,5.RT,5.RD,00000101110:SPECIAL:64::DSUB
1623 "dsub r<RD>, r<RS>, r<RT>"
1627 // start-sanitize-vr4320
1629 // end-sanitize-vr4320
1630 // start-sanitize-vr5400
1632 // end-sanitize-vr5400
1633 // start-sanitize-r5900
1635 // end-sanitize-r5900
1636 // start-sanitize-tx19
1638 // end-sanitize-tx19
1640 TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
1642 ALU64_BEGIN (GPR[RS]);
1643 ALU64_SUB (GPR[RT]);
1644 ALU64_END (GPR[RD]);
1646 TRACE_ALU_RESULT (GPR[RD]);
1650 :function:::void:do_dsubu:int rs, int rt, int rd
1652 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
1653 GPR[rd] = GPR[rs] - GPR[rt];
1654 TRACE_ALU_RESULT (GPR[rd]);
1657 000000,5.RS,5.RT,5.RD,00000101111:SPECIAL:64::DSUBU
1658 "dsubu r<RD>, r<RS>, r<RT>"
1662 // start-sanitize-vr4320
1664 // end-sanitize-vr4320
1665 // start-sanitize-vr5400
1667 // end-sanitize-vr5400
1668 // start-sanitize-r5900
1670 // end-sanitize-r5900
1671 // start-sanitize-tx19
1673 // end-sanitize-tx19
1675 do_dsubu (SD_, RS, RT, RD);
1679 000010,26.INSTR_INDEX:NORMAL:32::J
1681 *mipsI,mipsII,mipsIII,mipsIV:
1683 // start-sanitize-vr4320
1685 // end-sanitize-vr4320
1686 // start-sanitize-vr5400
1688 // end-sanitize-vr5400
1689 // start-sanitize-r5900
1691 // end-sanitize-r5900
1693 // start-sanitize-tx19
1695 // end-sanitize-tx19
1697 /* NOTE: The region used is that of the delay slot NIA and NOT the
1698 current instruction */
1699 address_word region = (NIA & MASK (63, 28));
1700 DELAY_SLOT (region | (INSTR_INDEX << 2));
1704 000011,26.INSTR_INDEX:NORMAL:32::JAL
1706 *mipsI,mipsII,mipsIII,mipsIV:
1708 // start-sanitize-vr4320
1710 // end-sanitize-vr4320
1711 // start-sanitize-vr5400
1713 // end-sanitize-vr5400
1714 // start-sanitize-r5900
1716 // end-sanitize-r5900
1718 // start-sanitize-tx19
1720 // end-sanitize-tx19
1722 /* NOTE: The region used is that of the delay slot and NOT the
1723 current instruction */
1724 address_word region = (NIA & MASK (63, 28));
1726 DELAY_SLOT (region | (INSTR_INDEX << 2));
1730 000000,5.RS,00000,5.RD,00000001001:SPECIAL:32::JALR
1731 "jalr r<RS>":RD == 31
1733 *mipsI,mipsII,mipsIII,mipsIV:
1735 // start-sanitize-vr4320
1737 // end-sanitize-vr4320
1738 // start-sanitize-vr5400
1740 // end-sanitize-vr5400
1741 // start-sanitize-r5900
1743 // end-sanitize-r5900
1745 // start-sanitize-tx19
1747 // end-sanitize-tx19
1749 address_word temp = GPR[RS];
1755 000000,5.RS,000000000000000001000:SPECIAL:32::JR
1757 *mipsI,mipsII,mipsIII,mipsIV:
1759 // start-sanitize-vr4320
1761 // end-sanitize-vr4320
1762 // start-sanitize-vr5400
1764 // end-sanitize-vr5400
1765 // start-sanitize-r5900
1767 // end-sanitize-r5900
1769 // start-sanitize-tx19
1771 // end-sanitize-tx19
1773 DELAY_SLOT (GPR[RS]);
1777 :function:::unsigned_word:do_load:unsigned access, address_word base, address_word offset
1779 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
1780 address_word reverseendian = (ReverseEndian ? (mask ^ access) : 0);
1781 address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
1788 vaddr = base + offset;
1789 if ((vaddr & access) != 0)
1790 SignalExceptionAddressLoad ();
1791 AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
1792 paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
1793 LoadMemory (&memval, NULL, uncached, access, paddr, vaddr, isDATA, isREAL);
1794 byte = ((vaddr & mask) ^ bigendiancpu);
1795 return (memval >> (8 * byte));
1799 100000,5.BASE,5.RT,16.OFFSET:NORMAL:32::LB
1800 "lb r<RT>, <OFFSET>(r<BASE>)"
1801 *mipsI,mipsII,mipsIII,mipsIV:
1803 // start-sanitize-vr4320
1805 // end-sanitize-vr4320
1806 // start-sanitize-vr5400
1808 // end-sanitize-vr5400
1809 // start-sanitize-r5900
1811 // end-sanitize-r5900
1813 // start-sanitize-tx19
1815 // end-sanitize-tx19
1817 GPR[RT] = EXTEND8 (do_load (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET)));
1821 100100,5.BASE,5.RT,16.OFFSET:NORMAL:32::LBU
1822 "lbu r<RT>, <OFFSET>(r<BASE>)"
1823 *mipsI,mipsII,mipsIII,mipsIV:
1825 // start-sanitize-vr4320
1827 // end-sanitize-vr4320
1828 // start-sanitize-vr5400
1830 // end-sanitize-vr5400
1831 // start-sanitize-r5900
1833 // end-sanitize-r5900
1835 // start-sanitize-tx19
1837 // end-sanitize-tx19
1839 GPR[RT] = do_load (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET));
1843 110111,5.BASE,5.RT,16.OFFSET:NORMAL:64::LD
1844 "ld r<RT>, <OFFSET>(r<BASE>)"
1848 // start-sanitize-vr4320
1850 // end-sanitize-vr4320
1851 // start-sanitize-vr5400
1853 // end-sanitize-vr5400
1854 // start-sanitize-r5900
1856 // end-sanitize-r5900
1857 // start-sanitize-tx19
1859 // end-sanitize-tx19
1861 GPR[RT] = EXTEND64 (do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
1865 1101,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDCz
1866 "ldc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
1871 // start-sanitize-vr4320
1873 // end-sanitize-vr4320
1874 // start-sanitize-vr5400
1876 // end-sanitize-vr5400
1878 // start-sanitize-tx19
1880 // end-sanitize-tx19
1882 COP_LD (ZZ, RT, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
1888 011010,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDL
1889 "ldl r<RT>, <OFFSET>(r<BASE>)"
1893 // start-sanitize-vr4320
1895 // end-sanitize-vr4320
1896 // start-sanitize-vr5400
1898 // end-sanitize-vr5400
1899 // start-sanitize-r5900
1901 // end-sanitize-r5900
1902 // start-sanitize-tx19
1904 // end-sanitize-tx19
1906 GPR[RT] = do_load_left (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
1910 011011,5.BASE,5.RT,16.OFFSET:NORMAL:64::LDR
1911 "ldr r<RT>, <OFFSET>(r<BASE>)"
1915 // start-sanitize-vr4320
1917 // end-sanitize-vr4320
1918 // start-sanitize-vr5400
1920 // end-sanitize-vr5400
1921 // start-sanitize-r5900
1923 // end-sanitize-r5900
1924 // start-sanitize-tx19
1926 // end-sanitize-tx19
1928 GPR[RT] = do_load_right (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
1932 100001,5.BASE,5.RT,16.OFFSET:NORMAL:32::LH
1933 "lh r<RT>, <OFFSET>(r<BASE>)"
1934 *mipsI,mipsII,mipsIII,mipsIV:
1936 // start-sanitize-vr4320
1938 // end-sanitize-vr4320
1939 // start-sanitize-vr5400
1941 // end-sanitize-vr5400
1942 // start-sanitize-r5900
1944 // end-sanitize-r5900
1946 // start-sanitize-tx19
1948 // end-sanitize-tx19
1950 GPR[RT] = EXTEND16 (do_load (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET)));
1954 100101,5.BASE,5.RT,16.OFFSET:NORMAL:32::LHU
1955 "lhu r<RT>, <OFFSET>(r<BASE>)"
1956 *mipsI,mipsII,mipsIII,mipsIV:
1958 // start-sanitize-vr4320
1960 // end-sanitize-vr4320
1961 // start-sanitize-vr5400
1963 // end-sanitize-vr5400
1964 // start-sanitize-r5900
1966 // end-sanitize-r5900
1968 // start-sanitize-tx19
1970 // end-sanitize-tx19
1972 GPR[RT] = do_load (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET));
1976 110000,5.BASE,5.RT,16.OFFSET:NORMAL:32::LL
1977 "ll r<RT>, <OFFSET>(r<BASE>)"
1982 // start-sanitize-vr4320
1984 // end-sanitize-vr4320
1985 // start-sanitize-vr5400
1987 // end-sanitize-vr5400
1988 // start-sanitize-r5900
1990 // end-sanitize-r5900
1991 // start-sanitize-tx19
1993 // end-sanitize-tx19
1995 unsigned32 instruction = instruction_0;
1996 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
1997 int destreg = ((instruction >> 16) & 0x0000001F);
1998 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
2000 address_word vaddr = ((unsigned64)op1 + offset);
2003 if ((vaddr & 3) != 0)
2004 SignalExceptionAddressLoad();
2007 if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
2009 unsigned64 memval = 0;
2010 unsigned64 memval1 = 0;
2011 unsigned64 mask = 0x7;
2012 unsigned int shift = 2;
2013 unsigned int reverse = (ReverseEndian ? (mask >> shift) : 0);
2014 unsigned int bigend = (BigEndianCPU ? (mask >> shift) : 0);
2016 paddr = ((paddr & ~mask) | ((paddr & mask) ^ (reverse << shift)));
2017 LoadMemory(&memval,&memval1,uncached,AccessLength_WORD,paddr,vaddr,isDATA,isREAL);
2018 byte = ((vaddr & mask) ^ (bigend << shift));
2019 GPR[destreg] = (SIGNEXTEND(((memval >> (8 * byte)) & 0xFFFFFFFF),32));
2027 110100,5.BASE,5.RT,16.OFFSET:NORMAL:64::LLD
2028 "lld r<RT>, <OFFSET>(r<BASE>)"
2032 // start-sanitize-vr4320
2034 // end-sanitize-vr4320
2035 // start-sanitize-vr5400
2037 // end-sanitize-vr5400
2038 // start-sanitize-r5900
2040 // end-sanitize-r5900
2041 // start-sanitize-tx19
2043 // end-sanitize-tx19
2045 unsigned32 instruction = instruction_0;
2046 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
2047 int destreg = ((instruction >> 16) & 0x0000001F);
2048 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
2050 address_word vaddr = ((unsigned64)op1 + offset);
2053 if ((vaddr & 7) != 0)
2054 SignalExceptionAddressLoad();
2057 if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
2059 unsigned64 memval = 0;
2060 unsigned64 memval1 = 0;
2061 LoadMemory(&memval,&memval1,uncached,AccessLength_DOUBLEWORD,paddr,vaddr,isDATA,isREAL);
2062 GPR[destreg] = memval;
2070 001111,00000,5.RT,16.IMMEDIATE:NORMAL:32::LUI
2071 "lui r<RT>, <IMMEDIATE>"
2072 *mipsI,mipsII,mipsIII,mipsIV:
2074 // start-sanitize-vr4320
2076 // end-sanitize-vr4320
2077 // start-sanitize-vr5400
2079 // end-sanitize-vr5400
2080 // start-sanitize-r5900
2082 // end-sanitize-r5900
2084 // start-sanitize-tx19
2086 // end-sanitize-tx19
2088 TRACE_ALU_INPUT1 (IMMEDIATE);
2089 GPR[RT] = EXTEND32 (IMMEDIATE << 16);
2090 TRACE_ALU_RESULT (GPR[RT]);
2094 100011,5.BASE,5.RT,16.OFFSET:NORMAL:32::LW
2095 "lw r<RT>, <OFFSET>(r<BASE>)"
2096 *mipsI,mipsII,mipsIII,mipsIV:
2098 // start-sanitize-vr4320
2100 // end-sanitize-vr4320
2101 // start-sanitize-vr5400
2103 // end-sanitize-vr5400
2104 // start-sanitize-r5900
2106 // end-sanitize-r5900
2108 // start-sanitize-tx19
2110 // end-sanitize-tx19
2112 GPR[RT] = EXTEND32 (do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
2116 1100,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWCz
2117 "lwc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
2118 *mipsI,mipsII,mipsIII,mipsIV:
2120 // start-sanitize-vr4320
2122 // end-sanitize-vr4320
2123 // start-sanitize-vr5400
2125 // end-sanitize-vr5400
2126 // start-sanitize-r5900
2128 // end-sanitize-r5900
2130 // start-sanitize-tx19
2132 // end-sanitize-tx19
2134 COP_LW (ZZ, RT, do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
2138 :function:::unsigned_word:do_load_left:unsigned access, address_word base, address_word offset, unsigned_word rt
2140 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2141 address_word reverseendian = (ReverseEndian ? -1 : 0);
2142 address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
2151 unsigned_word lhs_mask;
2154 vaddr = base + offset;
2155 AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
2156 paddr = (paddr ^ (reverseendian & mask));
2157 if (BigEndianMem == 0)
2158 paddr = paddr & ~access;
2160 /* compute where within the word/mem we are */
2161 byte = ((vaddr ^ bigendiancpu) & access); /* 0..access */
2162 word = ((vaddr ^ bigendiancpu) & (mask & ~access)) / (access + 1); /* 0..1 */
2163 nr_lhs_bits = 8 * byte + 8;
2164 nr_rhs_bits = 8 * access - 8 * byte;
2165 /* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
2167 /* fprintf (stderr, "l[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
2168 (long) ((unsigned64) vaddr >> 32), (long) vaddr,
2169 (long) ((unsigned64) paddr >> 32), (long) paddr,
2170 word, byte, nr_lhs_bits, nr_rhs_bits); */
2172 LoadMemory (&memval, NULL, uncached, byte, paddr, vaddr, isDATA, isREAL);
2175 /* GPR{31..32-NR_LHS_BITS} = memval{NR_LHS_BITS-1..0} */
2176 temp = (memval << nr_rhs_bits);
2180 /* GPR{31..32-NR_LHS_BITS = memval{32+NR_LHS_BITS..32} */
2181 temp = (memval >> nr_lhs_bits);
2183 lhs_mask = LSMASK (nr_lhs_bits + nr_rhs_bits - 1, nr_rhs_bits);
2184 rt = (rt & ~lhs_mask) | (temp & lhs_mask);
2186 /* fprintf (stderr, "l[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx & 0x%08lx%08lx -> 0x%08lx%08lx\n",
2187 (long) ((unsigned64) memval >> 32), (long) memval,
2188 (long) ((unsigned64) temp >> 32), (long) temp,
2189 (long) ((unsigned64) lhs_mask >> 32), (long) lhs_mask,
2190 (long) (rt >> 32), (long) rt); */
2195 100010,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWL
2196 "lwl r<RT>, <OFFSET>(r<BASE>)"
2197 *mipsI,mipsII,mipsIII,mipsIV:
2199 // start-sanitize-vr4320
2201 // end-sanitize-vr4320
2202 // start-sanitize-vr5400
2204 // end-sanitize-vr5400
2205 // start-sanitize-r5900
2207 // end-sanitize-r5900
2209 // start-sanitize-tx19
2211 // end-sanitize-tx19
2213 GPR[RT] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND32 (OFFSET), GPR[RT]));
2217 :function:::unsigned_word:do_load_right:unsigned access, address_word base, address_word offset, unsigned_word rt
2219 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2220 address_word reverseendian = (ReverseEndian ? -1 : 0);
2221 address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
2228 vaddr = base + offset;
2229 AddressTranslation (vaddr, isDATA, isLOAD, &paddr, &uncached, isTARGET, isREAL);
2230 /* NOTE: SPEC is wrong, has `BigEndianMem == 0' not `BigEndianMem != 0' */
2231 paddr = (paddr ^ (reverseendian & mask));
2232 if (BigEndianMem != 0)
2233 paddr = paddr & ~access;
2234 byte = ((vaddr & mask) ^ (bigendiancpu & mask));
2235 /* NOTE: SPEC is wrong, had `byte' not `access - byte'. See SW. */
2236 LoadMemory (&memval, NULL, uncached, access - (access & byte), paddr, vaddr, isDATA, isREAL);
2237 /* printf ("lr: 0x%08lx %d@0x%08lx 0x%08lx\n",
2238 (long) paddr, byte, (long) paddr, (long) memval); */
2240 unsigned_word screen = LSMASK (8 * (access - (byte & access) + 1) - 1, 0);
2242 rt |= (memval >> (8 * byte)) & screen;
2248 100110,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWR
2249 "lwr r<RT>, <OFFSET>(r<BASE>)"
2250 *mipsI,mipsII,mipsIII,mipsIV:
2252 // start-sanitize-vr4320
2254 // end-sanitize-vr4320
2255 // start-sanitize-vr5400
2257 // end-sanitize-vr5400
2258 // start-sanitize-r5900
2260 // end-sanitize-r5900
2262 // start-sanitize-tx19
2264 // end-sanitize-tx19
2266 GPR[RT] = EXTEND32 (do_load_right (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]));
2270 100111,5.BASE,5.RT,16.OFFSET:NORMAL:32::LWU
2271 "lwu r<RT>, <OFFSET>(r<BASE>)"
2275 // start-sanitize-vr4320
2277 // end-sanitize-vr4320
2278 // start-sanitize-vr5400
2280 // end-sanitize-vr5400
2281 // start-sanitize-r5900
2283 // end-sanitize-r5900
2284 // start-sanitize-tx19
2286 // end-sanitize-tx19
2288 GPR[RT] = do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET));
2292 :function:::void:do_mfhi:int rd
2294 check_mf_hilo (SD_, HIHISTORY, LOHISTORY);
2295 TRACE_ALU_INPUT1 (HI);
2297 TRACE_ALU_RESULT (GPR[rd]);
2300 000000,0000000000,5.RD,00000,010000:SPECIAL:32::MFHI
2302 *mipsI,mipsII,mipsIII,mipsIV:
2304 // start-sanitize-vr4320
2306 // end-sanitize-vr4320
2307 // start-sanitize-vr5400
2309 // end-sanitize-vr5400
2310 // start-sanitize-r5900
2312 // end-sanitize-r5900
2314 // start-sanitize-tx19
2316 // end-sanitize-tx19
2323 :function:::void:do_mflo:int rd
2325 check_mf_hilo (SD_, LOHISTORY, HIHISTORY);
2326 TRACE_ALU_INPUT1 (LO);
2328 TRACE_ALU_RESULT (GPR[rd]);
2331 000000,0000000000,5.RD,00000,010010:SPECIAL:32::MFLO
2333 *mipsI,mipsII,mipsIII,mipsIV:
2335 // start-sanitize-vr4320
2337 // end-sanitize-vr4320
2338 // start-sanitize-vr5400
2340 // end-sanitize-vr5400
2341 // start-sanitize-r5900
2343 // end-sanitize-r5900
2345 // start-sanitize-tx19
2347 // end-sanitize-tx19
2354 000000,5.RS,5.RT,5.RD,00000001011:SPECIAL:32::MOVN
2355 "movn r<RD>, r<RS>, r<RT>"
2358 // start-sanitize-vr4320
2360 // end-sanitize-vr4320
2361 // start-sanitize-vr5400
2363 // end-sanitize-vr5400
2364 // start-sanitize-r5900
2366 // end-sanitize-r5900
2374 000000,5.RS,5.RT,5.RD,00000001010:SPECIAL:32::MOVZ
2375 "movz r<RD>, r<RS>, r<RT>"
2378 // start-sanitize-vr4320
2380 // end-sanitize-vr4320
2381 // start-sanitize-vr5400
2383 // end-sanitize-vr5400
2384 // start-sanitize-r5900
2386 // end-sanitize-r5900
2394 000000,5.RS,000000000000000,010001:SPECIAL:32::MTHI
2396 *mipsI,mipsII,mipsIII,mipsIV:
2398 // start-sanitize-vr4320
2400 // end-sanitize-vr4320
2401 // start-sanitize-vr5400
2403 // end-sanitize-vr5400
2404 // start-sanitize-r5900
2406 // end-sanitize-r5900
2408 // start-sanitize-tx19
2410 // end-sanitize-tx19
2412 check_mt_hilo (SD_, HIHISTORY);
2418 000000,5.RS,000000000000000010011:SPECIAL:32::MTLO
2420 *mipsI,mipsII,mipsIII,mipsIV:
2422 // start-sanitize-vr4320
2424 // end-sanitize-vr4320
2425 // start-sanitize-vr5400
2427 // end-sanitize-vr5400
2428 // start-sanitize-r5900
2430 // end-sanitize-r5900
2432 // start-sanitize-tx19
2434 // end-sanitize-tx19
2436 check_mt_hilo (SD_, LOHISTORY);
2442 :function:::void:do_mult:int rs, int rt, int rd
2445 check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2446 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2447 prod = (((signed64)(signed32) GPR[rs])
2448 * ((signed64)(signed32) GPR[rt]));
2449 LO = EXTEND32 (VL4_8 (prod));
2450 HI = EXTEND32 (VH4_8 (prod));
2453 TRACE_ALU_RESULT2 (HI, LO);
2456 000000,5.RS,5.RT,00000,00000011000:SPECIAL:32::MULT
2458 *mipsI,mipsII,mipsIII,mipsIV:
2459 // start-sanitize-vr4320
2461 // end-sanitize-vr4320
2463 do_mult (SD_, RS, RT, 0);
2467 000000,5.RS,5.RT,5.RD,00000011000:SPECIAL:32::MULT
2468 "mult r<RD>, r<RS>, r<RT>"
2470 // start-sanitize-vr5400
2472 // end-sanitize-vr5400
2473 // start-sanitize-r5900
2475 // end-sanitize-r5900
2477 // start-sanitize-tx19
2479 // end-sanitize-tx19
2481 do_mult (SD_, RS, RT, RD);
2485 :function:::void:do_multu:int rs, int rt, int rd
2488 check_mult_hilo (SD_, HIHISTORY, LOHISTORY);
2489 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2490 prod = (((unsigned64)(unsigned32) GPR[rs])
2491 * ((unsigned64)(unsigned32) GPR[rt]));
2492 LO = EXTEND32 (VL4_8 (prod));
2493 HI = EXTEND32 (VH4_8 (prod));
2496 TRACE_ALU_RESULT2 (HI, LO);
2499 000000,5.RS,5.RT,00000,00000011001:SPECIAL:32::MULTU
2500 "multu r<RS>, r<RT>"
2501 *mipsI,mipsII,mipsIII,mipsIV:
2502 // start-sanitize-vr4320
2504 // end-sanitize-vr4320
2506 do_multu (SD_, RS, RT, 0);
2509 000000,5.RS,5.RT,5.RD,00000011001:SPECIAL:32::MULTU
2510 "multu r<RD>, r<RS>, r<RT>"
2512 // start-sanitize-vr5400
2514 // end-sanitize-vr5400
2515 // start-sanitize-r5900
2517 // end-sanitize-r5900
2519 // start-sanitize-tx19
2521 // end-sanitize-tx19
2523 do_multu (SD_, RS, RT, 0);
2527 :function:::void:do_nor:int rs, int rt, int rd
2529 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2530 GPR[rd] = ~ (GPR[rs] | GPR[rt]);
2531 TRACE_ALU_RESULT (GPR[rd]);
2534 000000,5.RS,5.RT,5.RD,00000,100111:SPECIAL:32::NOR
2535 "nor r<RD>, r<RS>, r<RT>"
2536 *mipsI,mipsII,mipsIII,mipsIV:
2538 // start-sanitize-vr4320
2540 // end-sanitize-vr4320
2541 // start-sanitize-vr5400
2543 // end-sanitize-vr5400
2544 // start-sanitize-r5900
2546 // end-sanitize-r5900
2548 // start-sanitize-tx19
2550 // end-sanitize-tx19
2552 do_nor (SD_, RS, RT, RD);
2556 :function:::void:do_or:int rs, int rt, int rd
2558 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2559 GPR[rd] = (GPR[rs] | GPR[rt]);
2560 TRACE_ALU_RESULT (GPR[rd]);
2563 000000,5.RS,5.RT,5.RD,00000,100101:SPECIAL:32::OR
2564 "or r<RD>, r<RS>, r<RT>"
2565 *mipsI,mipsII,mipsIII,mipsIV:
2567 // start-sanitize-vr4320
2569 // end-sanitize-vr4320
2570 // start-sanitize-vr5400
2572 // end-sanitize-vr5400
2573 // start-sanitize-r5900
2575 // end-sanitize-r5900
2577 // start-sanitize-tx19
2579 // end-sanitize-tx19
2581 do_or (SD_, RS, RT, RD);
2586 :function:::void:do_ori:int rs, int rt, unsigned immediate
2588 TRACE_ALU_INPUT2 (GPR[rs], immediate);
2589 GPR[rt] = (GPR[rs] | immediate);
2590 TRACE_ALU_RESULT (GPR[rt]);
2593 001101,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::ORI
2594 "ori r<RT>, r<RS>, <IMMEDIATE>"
2595 *mipsI,mipsII,mipsIII,mipsIV:
2597 // start-sanitize-vr4320
2599 // end-sanitize-vr4320
2600 // start-sanitize-vr5400
2602 // end-sanitize-vr5400
2603 // start-sanitize-r5900
2605 // end-sanitize-r5900
2607 // start-sanitize-tx19
2609 // end-sanitize-tx19
2611 do_ori (SD_, RS, RT, IMMEDIATE);
2615 110011,5.RS,nnnnn,16.OFFSET:NORMAL:32::PREF
2618 // start-sanitize-vr4320
2620 // end-sanitize-vr4320
2621 // start-sanitize-vr5400
2623 // end-sanitize-vr5400
2624 // start-sanitize-r5900
2626 // end-sanitize-r5900
2628 unsigned32 instruction = instruction_0;
2629 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
2630 int hint = ((instruction >> 16) & 0x0000001F);
2631 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
2633 address_word vaddr = ((unsigned64)op1 + offset);
2637 if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
2638 Prefetch(uncached,paddr,vaddr,isDATA,hint);
2643 :function:::void:do_store:unsigned access, address_word base, address_word offset, unsigned_word word
2645 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
2646 address_word reverseendian = (ReverseEndian ? (mask ^ access) : 0);
2647 address_word bigendiancpu = (BigEndianCPU ? (mask ^ access) : 0);
2654 vaddr = base + offset;
2655 if ((vaddr & access) != 0)
2656 SignalExceptionAddressStore ();
2657 AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
2658 paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
2659 byte = ((vaddr & mask) ^ bigendiancpu);
2660 memval = (word << (8 * byte));
2661 StoreMemory (uncached, access, memval, 0, paddr, vaddr, isREAL);
2665 101000,5.BASE,5.RT,16.OFFSET:NORMAL:32::SB
2666 "sb r<RT>, <OFFSET>(r<BASE>)"
2667 *mipsI,mipsII,mipsIII,mipsIV:
2669 // start-sanitize-vr4320
2671 // end-sanitize-vr4320
2672 // start-sanitize-vr5400
2674 // end-sanitize-vr5400
2675 // start-sanitize-r5900
2677 // end-sanitize-r5900
2679 // start-sanitize-tx19
2681 // end-sanitize-tx19
2683 do_store (SD_, AccessLength_BYTE, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2687 111000,5.BASE,5.RT,16.OFFSET:NORMAL:32::SC
2688 "sc r<RT>, <OFFSET>(r<BASE>)"
2693 // start-sanitize-vr4320
2695 // end-sanitize-vr4320
2696 // start-sanitize-vr5400
2698 // end-sanitize-vr5400
2699 // start-sanitize-r5900
2701 // end-sanitize-r5900
2702 // start-sanitize-tx19
2704 // end-sanitize-tx19
2706 unsigned32 instruction = instruction_0;
2707 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
2708 signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
2709 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
2711 address_word vaddr = ((unsigned64)op1 + offset);
2714 if ((vaddr & 3) != 0)
2715 SignalExceptionAddressStore();
2718 if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
2720 unsigned64 memval = 0;
2721 unsigned64 memval1 = 0;
2722 unsigned64 mask = 0x7;
2724 paddr = ((paddr & ~mask) | ((paddr & mask) ^ (ReverseEndian << 2)));
2725 byte = ((vaddr & mask) ^ (BigEndianCPU << 2));
2726 memval = ((unsigned64) op2 << (8 * byte));
2729 StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
2731 GPR[(instruction >> 16) & 0x0000001F] = LLBIT;
2738 111100,5.BASE,5.RT,16.OFFSET:NORMAL:64::SCD
2739 "scd r<RT>, <OFFSET>(r<BASE>)"
2743 // start-sanitize-vr4320
2745 // end-sanitize-vr4320
2746 // start-sanitize-vr5400
2748 // end-sanitize-vr5400
2749 // start-sanitize-r5900
2751 // end-sanitize-r5900
2752 // start-sanitize-tx19
2754 // end-sanitize-tx19
2756 unsigned32 instruction = instruction_0;
2757 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
2758 signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
2759 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
2761 address_word vaddr = ((unsigned64)op1 + offset);
2764 if ((vaddr & 7) != 0)
2765 SignalExceptionAddressStore();
2768 if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
2770 unsigned64 memval = 0;
2771 unsigned64 memval1 = 0;
2775 StoreMemory(uncached,AccessLength_DOUBLEWORD,memval,memval1,paddr,vaddr,isREAL);
2777 GPR[(instruction >> 16) & 0x0000001F] = LLBIT;
2784 111111,5.BASE,5.RT,16.OFFSET:NORMAL:64::SD
2785 "sd r<RT>, <OFFSET>(r<BASE>)"
2789 // start-sanitize-vr4320
2791 // end-sanitize-vr4320
2792 // start-sanitize-vr5400
2794 // end-sanitize-vr5400
2795 // start-sanitize-r5900
2797 // end-sanitize-r5900
2798 // start-sanitize-tx19
2800 // end-sanitize-tx19
2802 do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2806 1111,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDCz
2807 "sdc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
2812 // start-sanitize-vr4320
2814 // end-sanitize-vr4320
2815 // start-sanitize-vr5400
2817 // end-sanitize-vr5400
2818 // start-sanitize-tx19
2820 // end-sanitize-tx19
2822 do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), COP_SD (ZZ, RT));
2826 101100,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDL
2827 "sdl r<RT>, <OFFSET>(r<BASE>)"
2831 // start-sanitize-vr4320
2833 // end-sanitize-vr4320
2834 // start-sanitize-vr5400
2836 // end-sanitize-vr5400
2837 // start-sanitize-r5900
2839 // end-sanitize-r5900
2840 // start-sanitize-tx19
2842 // end-sanitize-tx19
2844 do_store_left (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2848 101101,5.BASE,5.RT,16.OFFSET:NORMAL:64::SDR
2849 "sdr r<RT>, <OFFSET>(r<BASE>)"
2853 // start-sanitize-vr4320
2855 // end-sanitize-vr4320
2856 // start-sanitize-vr5400
2858 // end-sanitize-vr5400
2859 // start-sanitize-r5900
2861 // end-sanitize-r5900
2862 // start-sanitize-tx19
2864 // end-sanitize-tx19
2866 do_store_right (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2870 101001,5.BASE,5.RT,16.OFFSET:NORMAL:32::SH
2871 "sh r<RT>, <OFFSET>(r<BASE>)"
2872 *mipsI,mipsII,mipsIII,mipsIV:
2874 // start-sanitize-vr4320
2876 // end-sanitize-vr4320
2877 // start-sanitize-vr5400
2879 // end-sanitize-vr5400
2880 // start-sanitize-r5900
2882 // end-sanitize-r5900
2884 // start-sanitize-tx19
2886 // end-sanitize-tx19
2888 do_store (SD_, AccessLength_HALFWORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
2892 :function:::void:do_sll:int rt, int rd, int shift
2894 unsigned32 temp = (GPR[rt] << shift);
2895 TRACE_ALU_INPUT2 (GPR[rt], shift);
2896 GPR[rd] = EXTEND32 (temp);
2897 TRACE_ALU_RESULT (GPR[rd]);
2900 00000000000,5.RT,5.RD,5.SHIFT,000000:SPECIAL:32::SLL
2901 "sll r<RD>, r<RT>, <SHIFT>"
2902 *mipsI,mipsII,mipsIII,mipsIV:
2904 // start-sanitize-vr4320
2906 // end-sanitize-vr4320
2907 // start-sanitize-vr5400
2909 // end-sanitize-vr5400
2910 // start-sanitize-r5900
2912 // end-sanitize-r5900
2914 // start-sanitize-tx19
2916 // end-sanitize-tx19
2918 do_sll (SD_, RT, RD, SHIFT);
2922 :function:::void:do_sllv:int rs, int rt, int rd
2924 int s = MASKED (GPR[rs], 4, 0);
2925 unsigned32 temp = (GPR[rt] << s);
2926 TRACE_ALU_INPUT2 (GPR[rt], s);
2927 GPR[rd] = EXTEND32 (temp);
2928 TRACE_ALU_RESULT (GPR[rd]);
2931 000000,5.RS,5.RT,5.RD,00000000100:SPECIAL:32::SLLV
2932 "sllv r<RD>, r<RT>, r<RS>"
2933 *mipsI,mipsII,mipsIII,mipsIV:
2935 // start-sanitize-vr4320
2937 // end-sanitize-vr4320
2938 // start-sanitize-vr5400
2940 // end-sanitize-vr5400
2941 // start-sanitize-r5900
2943 // end-sanitize-r5900
2945 // start-sanitize-tx19
2947 // end-sanitize-tx19
2949 do_sllv (SD_, RS, RT, RD);
2953 :function:::void:do_slt:int rs, int rt, int rd
2955 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
2956 GPR[rd] = ((signed_word) GPR[rs] < (signed_word) GPR[rt]);
2957 TRACE_ALU_RESULT (GPR[rd]);
2960 000000,5.RS,5.RT,5.RD,00000101010:SPECIAL:32::SLT
2961 "slt r<RD>, r<RS>, r<RT>"
2962 *mipsI,mipsII,mipsIII,mipsIV:
2964 // start-sanitize-vr4320
2966 // end-sanitize-vr4320
2967 // start-sanitize-vr5400
2969 // end-sanitize-vr5400
2970 // start-sanitize-r5900
2972 // end-sanitize-r5900
2974 // start-sanitize-tx19
2976 // end-sanitize-tx19
2978 do_slt (SD_, RS, RT, RD);
2982 :function:::void:do_slti:int rs, int rt, unsigned16 immediate
2984 TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
2985 GPR[rt] = ((signed_word) GPR[rs] < (signed_word) EXTEND16 (immediate));
2986 TRACE_ALU_RESULT (GPR[rt]);
2989 001010,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::SLTI
2990 "slti r<RT>, r<RS>, <IMMEDIATE>"
2991 *mipsI,mipsII,mipsIII,mipsIV:
2993 // start-sanitize-vr4320
2995 // end-sanitize-vr4320
2996 // start-sanitize-vr5400
2998 // end-sanitize-vr5400
2999 // start-sanitize-r5900
3001 // end-sanitize-r5900
3003 // start-sanitize-tx19
3005 // end-sanitize-tx19
3007 do_slti (SD_, RS, RT, IMMEDIATE);
3011 :function:::void:do_sltiu:int rs, int rt, unsigned16 immediate
3013 TRACE_ALU_INPUT2 (GPR[rs], EXTEND16 (immediate));
3014 GPR[rt] = ((unsigned_word) GPR[rs] < (unsigned_word) EXTEND16 (immediate));
3015 TRACE_ALU_RESULT (GPR[rt]);
3018 001011,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::SLTIU
3019 "sltiu r<RT>, r<RS>, <IMMEDIATE>"
3020 *mipsI,mipsII,mipsIII,mipsIV:
3022 // start-sanitize-vr4320
3024 // end-sanitize-vr4320
3025 // start-sanitize-vr5400
3027 // end-sanitize-vr5400
3028 // start-sanitize-r5900
3030 // end-sanitize-r5900
3032 // start-sanitize-tx19
3034 // end-sanitize-tx19
3036 do_sltiu (SD_, RS, RT, IMMEDIATE);
3041 :function:::void:do_sltu:int rs, int rt, int rd
3043 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3044 GPR[rd] = ((unsigned_word) GPR[rs] < (unsigned_word) GPR[rt]);
3045 TRACE_ALU_RESULT (GPR[rd]);
3048 000000,5.RS,5.RT,5.RD,00000101011:SPECIAL:32::SLTU
3049 "sltu r<RD>, r<RS>, r<RT>"
3050 *mipsI,mipsII,mipsIII,mipsIV:
3052 // start-sanitize-vr4320
3054 // end-sanitize-vr4320
3055 // start-sanitize-vr5400
3057 // end-sanitize-vr5400
3058 // start-sanitize-r5900
3060 // end-sanitize-r5900
3062 // start-sanitize-tx19
3064 // end-sanitize-tx19
3066 do_sltu (SD_, RS, RT, RD);
3070 :function:::void:do_sra:int rt, int rd, int shift
3072 signed32 temp = (signed32) GPR[rt] >> shift;
3073 TRACE_ALU_INPUT2 (GPR[rt], shift);
3074 GPR[rd] = EXTEND32 (temp);
3075 TRACE_ALU_RESULT (GPR[rd]);
3078 000000,00000,5.RT,5.RD,5.SHIFT,000011:SPECIAL:32::SRA
3079 "sra r<RD>, r<RT>, <SHIFT>"
3080 *mipsI,mipsII,mipsIII,mipsIV:
3082 // start-sanitize-vr4320
3084 // end-sanitize-vr4320
3085 // start-sanitize-vr5400
3087 // end-sanitize-vr5400
3088 // start-sanitize-r5900
3090 // end-sanitize-r5900
3092 // start-sanitize-tx19
3094 // end-sanitize-tx19
3096 do_sra (SD_, RT, RD, SHIFT);
3101 :function:::void:do_srav:int rs, int rt, int rd
3103 int s = MASKED (GPR[rs], 4, 0);
3104 signed32 temp = (signed32) GPR[rt] >> s;
3105 TRACE_ALU_INPUT2 (GPR[rt], s);
3106 GPR[rd] = EXTEND32 (temp);
3107 TRACE_ALU_RESULT (GPR[rd]);
3110 000000,5.RS,5.RT,5.RD,00000000111:SPECIAL:32::SRAV
3111 "srav r<RD>, r<RT>, r<RS>"
3112 *mipsI,mipsII,mipsIII,mipsIV:
3114 // start-sanitize-vr4320
3116 // end-sanitize-vr4320
3117 // start-sanitize-vr5400
3119 // end-sanitize-vr5400
3120 // start-sanitize-r5900
3122 // end-sanitize-r5900
3124 // start-sanitize-tx19
3126 // end-sanitize-tx19
3128 do_srav (SD_, RS, RT, RD);
3133 :function:::void:do_srl:int rt, int rd, int shift
3135 unsigned32 temp = (unsigned32) GPR[rt] >> shift;
3136 TRACE_ALU_INPUT2 (GPR[rt], shift);
3137 GPR[rd] = EXTEND32 (temp);
3138 TRACE_ALU_RESULT (GPR[rd]);
3141 000000,00000,5.RT,5.RD,5.SHIFT,000010:SPECIAL:32::SRL
3142 "srl r<RD>, r<RT>, <SHIFT>"
3143 *mipsI,mipsII,mipsIII,mipsIV:
3145 // start-sanitize-vr4320
3147 // end-sanitize-vr4320
3148 // start-sanitize-vr5400
3150 // end-sanitize-vr5400
3151 // start-sanitize-r5900
3153 // end-sanitize-r5900
3155 // start-sanitize-tx19
3157 // end-sanitize-tx19
3159 do_srl (SD_, RT, RD, SHIFT);
3163 :function:::void:do_srlv:int rs, int rt, int rd
3165 int s = MASKED (GPR[rs], 4, 0);
3166 unsigned32 temp = (unsigned32) GPR[rt] >> s;
3167 TRACE_ALU_INPUT2 (GPR[rt], s);
3168 GPR[rd] = EXTEND32 (temp);
3169 TRACE_ALU_RESULT (GPR[rd]);
3172 000000,5.RS,5.RT,5.RD,00000000110:SPECIAL:32::SRLV
3173 "srlv r<RD>, r<RT>, r<RS>"
3174 *mipsI,mipsII,mipsIII,mipsIV:
3176 // start-sanitize-vr4320
3178 // end-sanitize-vr4320
3179 // start-sanitize-vr5400
3181 // end-sanitize-vr5400
3182 // start-sanitize-r5900
3184 // end-sanitize-r5900
3186 // start-sanitize-tx19
3188 // end-sanitize-tx19
3190 do_srlv (SD_, RS, RT, RD);
3194 000000,5.RS,5.RT,5.RD,00000100010:SPECIAL:32::SUB
3195 "sub r<RD>, r<RS>, r<RT>"
3196 *mipsI,mipsII,mipsIII,mipsIV:
3198 // start-sanitize-vr4320
3200 // end-sanitize-vr4320
3201 // start-sanitize-vr5400
3203 // end-sanitize-vr5400
3204 // start-sanitize-r5900
3206 // end-sanitize-r5900
3208 // start-sanitize-tx19
3210 // end-sanitize-tx19
3212 TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]);
3214 ALU32_BEGIN (GPR[RS]);
3215 ALU32_SUB (GPR[RT]);
3216 ALU32_END (GPR[RD]);
3218 TRACE_ALU_RESULT (GPR[RD]);
3222 :function:::void:do_subu:int rs, int rt, int rd
3224 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3225 GPR[rd] = EXTEND32 (GPR[rs] - GPR[rt]);
3226 TRACE_ALU_RESULT (GPR[rd]);
3229 000000,5.RS,5.RT,5.RD,00000100011:SPECIAL:32::SUBU
3230 "subu r<RD>, r<RS>, r<RT>"
3231 *mipsI,mipsII,mipsIII,mipsIV:
3233 // start-sanitize-vr4320
3235 // end-sanitize-vr4320
3236 // start-sanitize-vr5400
3238 // end-sanitize-vr5400
3239 // start-sanitize-r5900
3241 // end-sanitize-r5900
3243 // start-sanitize-tx19
3245 // end-sanitize-tx19
3247 do_subu (SD_, RS, RT, RD);
3251 101011,5.BASE,5.RT,16.OFFSET:NORMAL:32::SW
3252 "sw r<RT>, <OFFSET>(r<BASE>)"
3253 *mipsI,mipsII,mipsIII,mipsIV:
3254 // start-sanitize-tx19
3256 // end-sanitize-tx19
3258 // start-sanitize-vr4320
3260 // end-sanitize-vr4320
3262 // start-sanitize-vr5400
3264 // end-sanitize-vr5400
3265 // start-sanitize-r5900
3267 // end-sanitize-r5900
3269 do_store (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3273 1110,ZZ!0!1!3,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWCz
3274 "swc<ZZ> r<RT>, <OFFSET>(r<BASE>)"
3275 *mipsI,mipsII,mipsIII,mipsIV:
3277 // start-sanitize-vr4320
3279 // end-sanitize-vr4320
3280 // start-sanitize-vr5400
3282 // end-sanitize-vr5400
3284 // start-sanitize-tx19
3286 // end-sanitize-tx19
3288 do_store (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), COP_SW (ZZ, RT));
3293 :function:::void:do_store_left:unsigned access, address_word base, address_word offset, unsigned_word rt
3295 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3296 address_word reverseendian = (ReverseEndian ? -1 : 0);
3297 address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
3307 vaddr = base + offset;
3308 AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
3309 paddr = (paddr ^ (reverseendian & mask));
3310 if (BigEndianMem == 0)
3311 paddr = paddr & ~access;
3313 /* compute where within the word/mem we are */
3314 byte = ((vaddr ^ bigendiancpu) & access); /* 0..access */
3315 word = ((vaddr ^ bigendiancpu) & (mask & ~access)) / (access + 1); /* 0..1 */
3316 nr_lhs_bits = 8 * byte + 8;
3317 nr_rhs_bits = 8 * access - 8 * byte;
3318 /* nr_lhs_bits + nr_rhs_bits == 8 * (accesss + 1) */
3319 /* fprintf (stderr, "s[wd]l: 0x%08lx%08lx 0x%08lx%08lx %d:%d %d+%d\n",
3320 (long) ((unsigned64) vaddr >> 32), (long) vaddr,
3321 (long) ((unsigned64) paddr >> 32), (long) paddr,
3322 word, byte, nr_lhs_bits, nr_rhs_bits); */
3326 memval = (rt >> nr_rhs_bits);
3330 memval = (rt << nr_lhs_bits);
3332 /* fprintf (stderr, "s[wd]l: 0x%08lx%08lx -> 0x%08lx%08lx\n",
3333 (long) ((unsigned64) rt >> 32), (long) rt,
3334 (long) ((unsigned64) memval >> 32), (long) memval); */
3335 StoreMemory (uncached, byte, memval, 0, paddr, vaddr, isREAL);
3339 101010,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWL
3340 "swl r<RT>, <OFFSET>(r<BASE>)"
3341 *mipsI,mipsII,mipsIII,mipsIV:
3343 // start-sanitize-vr4320
3345 // end-sanitize-vr4320
3346 // start-sanitize-vr5400
3348 // end-sanitize-vr5400
3349 // start-sanitize-r5900
3351 // end-sanitize-r5900
3353 // start-sanitize-tx19
3355 // end-sanitize-tx19
3357 do_store_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3361 :function:::void:do_store_right:unsigned access, address_word base, address_word offset, unsigned_word rt
3363 address_word mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
3364 address_word reverseendian = (ReverseEndian ? -1 : 0);
3365 address_word bigendiancpu = (BigEndianCPU ? -1 : 0);
3372 vaddr = base + offset;
3373 AddressTranslation (vaddr, isDATA, isSTORE, &paddr, &uncached, isTARGET, isREAL);
3374 paddr = (paddr ^ (reverseendian & mask));
3375 if (BigEndianMem != 0)
3377 byte = ((vaddr & mask) ^ (bigendiancpu & mask));
3378 memval = (rt << (byte * 8));
3379 StoreMemory (uncached, access - (access & byte), memval, 0, paddr, vaddr, isREAL);
3382 101110,5.BASE,5.RT,16.OFFSET:NORMAL:32::SWR
3383 "swr r<RT>, <OFFSET>(r<BASE>)"
3384 *mipsI,mipsII,mipsIII,mipsIV:
3386 // start-sanitize-vr4320
3388 // end-sanitize-vr4320
3389 // start-sanitize-vr5400
3391 // end-sanitize-vr5400
3392 // start-sanitize-r5900
3394 // end-sanitize-r5900
3396 // start-sanitize-tx19
3398 // end-sanitize-tx19
3400 do_store_right (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]);
3404 000000000000000000000,5.STYPE,001111:SPECIAL:32::SYNC
3411 // start-sanitize-vr4320
3413 // end-sanitize-vr4320
3414 // start-sanitize-vr5400
3416 // end-sanitize-vr5400
3417 // start-sanitize-r5900
3419 // end-sanitize-r5900
3421 // start-sanitize-tx19
3423 // end-sanitize-tx19
3425 SyncOperation (STYPE);
3429 000000,20.CODE,001100:SPECIAL:32::SYSCALL
3431 *mipsI,mipsII,mipsIII,mipsIV:
3433 // start-sanitize-vr4320
3435 // end-sanitize-vr4320
3436 // start-sanitize-vr5400
3438 // end-sanitize-vr5400
3439 // start-sanitize-r5900
3441 // end-sanitize-r5900
3443 // start-sanitize-tx19
3445 // end-sanitize-tx19
3447 SignalException(SystemCall, instruction_0);
3451 000000,5.RS,5.RT,10.CODE,110100:SPECIAL:32::TEQ
3457 // start-sanitize-vr4320
3459 // end-sanitize-vr4320
3460 // start-sanitize-vr5400
3462 // end-sanitize-vr5400
3463 // start-sanitize-r5900
3465 // end-sanitize-r5900
3466 // start-sanitize-tx19
3468 // end-sanitize-tx19
3470 if ((signed_word) GPR[RS] == (signed_word) GPR[RT])
3471 SignalException(Trap, instruction_0);
3475 000001,5.RS,01100,16.IMMEDIATE:REGIMM:32::TEQI
3476 "teqi r<RS>, <IMMEDIATE>"
3481 // start-sanitize-vr4320
3483 // end-sanitize-vr4320
3484 // start-sanitize-vr5400
3486 // end-sanitize-vr5400
3487 // start-sanitize-r5900
3489 // end-sanitize-r5900
3490 // start-sanitize-tx19
3492 // end-sanitize-tx19
3494 if ((signed_word) GPR[RS] == (signed_word) EXTEND16 (IMMEDIATE))
3495 SignalException(Trap, instruction_0);
3499 000000,5.RS,5.RT,10.CODE,110000:SPECIAL:32::TGE
3505 // start-sanitize-vr4320
3507 // end-sanitize-vr4320
3508 // start-sanitize-vr5400
3510 // end-sanitize-vr5400
3511 // start-sanitize-r5900
3513 // end-sanitize-r5900
3514 // start-sanitize-tx19
3516 // end-sanitize-tx19
3518 if ((signed_word) GPR[RS] >= (signed_word) GPR[RT])
3519 SignalException(Trap, instruction_0);
3523 000001,5.RS,01000,16.IMMEDIATE:REGIMM:32::TGEI
3524 "tgei r<RS>, <IMMEDIATE>"
3529 // start-sanitize-vr4320
3531 // end-sanitize-vr4320
3532 // start-sanitize-vr5400
3534 // end-sanitize-vr5400
3535 // start-sanitize-r5900
3537 // end-sanitize-r5900
3538 // start-sanitize-tx19
3540 // end-sanitize-tx19
3542 if ((signed_word) GPR[RS] >= (signed_word) EXTEND16 (IMMEDIATE))
3543 SignalException(Trap, instruction_0);
3547 000001,5.RS,01001,16.IMMEDIATE:REGIMM:32::TGEIU
3548 "tgeiu r<RS>, <IMMEDIATE>"
3553 // start-sanitize-vr4320
3555 // end-sanitize-vr4320
3556 // start-sanitize-vr5400
3558 // end-sanitize-vr5400
3559 // start-sanitize-r5900
3561 // end-sanitize-r5900
3562 // start-sanitize-tx19
3564 // end-sanitize-tx19
3566 if ((unsigned_word) GPR[RS] >= (unsigned_word) EXTEND16 (IMMEDIATE))
3567 SignalException(Trap, instruction_0);
3571 000000,5.RS,5.RT,10.CODE,110001:SPECIAL:32::TGEU
3577 // start-sanitize-vr4320
3579 // end-sanitize-vr4320
3580 // start-sanitize-vr5400
3582 // end-sanitize-vr5400
3583 // start-sanitize-r5900
3585 // end-sanitize-r5900
3586 // start-sanitize-tx19
3588 // end-sanitize-tx19
3590 if ((unsigned_word) GPR[RS] >= (unsigned_word) GPR[RT])
3591 SignalException(Trap, instruction_0);
3595 000000,5.RS,5.RT,10.CODE,110010:SPECIAL:32::TLT
3601 // start-sanitize-vr4320
3603 // end-sanitize-vr4320
3604 // start-sanitize-vr5400
3606 // end-sanitize-vr5400
3607 // start-sanitize-r5900
3609 // end-sanitize-r5900
3610 // start-sanitize-tx19
3612 // end-sanitize-tx19
3614 if ((signed_word) GPR[RS] < (signed_word) GPR[RT])
3615 SignalException(Trap, instruction_0);
3619 000001,5.RS,01010,16.IMMEDIATE:REGIMM:32::TLTI
3620 "tlti r<RS>, <IMMEDIATE>"
3625 // start-sanitize-vr4320
3627 // end-sanitize-vr4320
3628 // start-sanitize-vr5400
3630 // end-sanitize-vr5400
3631 // start-sanitize-r5900
3633 // end-sanitize-r5900
3634 // start-sanitize-tx19
3636 // end-sanitize-tx19
3638 if ((signed_word) GPR[RS] < (signed_word) EXTEND16 (IMMEDIATE))
3639 SignalException(Trap, instruction_0);
3643 000001,5.RS,01011,16.IMMEDIATE:REGIMM:32::TLTIU
3644 "tltiu r<RS>, <IMMEDIATE>"
3649 // start-sanitize-vr4320
3651 // end-sanitize-vr4320
3652 // start-sanitize-vr5400
3654 // end-sanitize-vr5400
3655 // start-sanitize-r5900
3657 // end-sanitize-r5900
3658 // start-sanitize-tx19
3660 // end-sanitize-tx19
3662 if ((unsigned_word) GPR[RS] < (unsigned_word) EXTEND16 (IMMEDIATE))
3663 SignalException(Trap, instruction_0);
3667 000000,5.RS,5.RT,10.CODE,110011:SPECIAL:32::TLTU
3673 // start-sanitize-vr4320
3675 // end-sanitize-vr4320
3676 // start-sanitize-vr5400
3678 // end-sanitize-vr5400
3679 // start-sanitize-r5900
3681 // end-sanitize-r5900
3682 // start-sanitize-tx19
3684 // end-sanitize-tx19
3686 if ((unsigned_word) GPR[RS] < (unsigned_word) GPR[RT])
3687 SignalException(Trap, instruction_0);
3691 000000,5.RS,5.RT,10.CODE,110110:SPECIAL:32::TNE
3697 // start-sanitize-vr4320
3699 // end-sanitize-vr4320
3700 // start-sanitize-vr5400
3702 // end-sanitize-vr5400
3703 // start-sanitize-r5900
3705 // end-sanitize-r5900
3706 // start-sanitize-tx19
3708 // end-sanitize-tx19
3710 if ((signed_word) GPR[RS] != (signed_word) GPR[RT])
3711 SignalException(Trap, instruction_0);
3715 000001,5.RS,01110,16.IMMEDIATE:REGIMM:32::TNEI
3716 "tne r<RS>, <IMMEDIATE>"
3721 // start-sanitize-vr4320
3723 // end-sanitize-vr4320
3724 // start-sanitize-vr5400
3726 // end-sanitize-vr5400
3727 // start-sanitize-r5900
3729 // end-sanitize-r5900
3730 // start-sanitize-tx19
3732 // end-sanitize-tx19
3734 if ((signed_word) GPR[RS] != (signed_word) EXTEND16 (IMMEDIATE))
3735 SignalException(Trap, instruction_0);
3739 :function:::void:do_xor:int rs, int rt, int rd
3741 TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]);
3742 GPR[rd] = GPR[rs] ^ GPR[rt];
3743 TRACE_ALU_RESULT (GPR[rd]);
3746 000000,5.RS,5.RT,5.RD,00000100110:SPECIAL:32::XOR
3747 "xor r<RD>, r<RS>, r<RT>"
3748 *mipsI,mipsII,mipsIII,mipsIV:
3750 // start-sanitize-vr4320
3752 // end-sanitize-vr4320
3753 // start-sanitize-vr5400
3755 // end-sanitize-vr5400
3756 // start-sanitize-r5900
3758 // end-sanitize-r5900
3760 // start-sanitize-tx19
3762 // end-sanitize-tx19
3764 do_xor (SD_, RS, RT, RD);
3768 :function:::void:do_xori:int rs, int rt, unsigned16 immediate
3770 TRACE_ALU_INPUT2 (GPR[rs], immediate);
3771 GPR[rt] = GPR[rs] ^ immediate;
3772 TRACE_ALU_RESULT (GPR[rt]);
3775 001110,5.RS,5.RT,16.IMMEDIATE:NORMAL:32::XORI
3776 "xori r<RT>, r<RS>, <IMMEDIATE>"
3777 *mipsI,mipsII,mipsIII,mipsIV:
3779 // start-sanitize-vr4320
3781 // end-sanitize-vr4320
3782 // start-sanitize-vr5400
3784 // end-sanitize-vr5400
3785 // start-sanitize-r5900
3787 // end-sanitize-r5900
3789 // start-sanitize-tx19
3791 // end-sanitize-tx19
3793 do_xori (SD_, RS, RT, IMMEDIATE);
3798 // MIPS Architecture:
3800 // FPU Instruction Set (COP1 & COP1X)
3808 case fmt_single: return "s";
3809 case fmt_double: return "d";
3810 case fmt_word: return "w";
3811 case fmt_long: return "l";
3812 default: return "?";
3822 default: return "?";
3842 :%s::::COND:int cond
3846 case 00: return "f";
3847 case 01: return "un";
3848 case 02: return "eq";
3849 case 03: return "ueq";
3850 case 04: return "olt";
3851 case 05: return "ult";
3852 case 06: return "ole";
3853 case 07: return "ule";
3854 case 010: return "sf";
3855 case 011: return "ngle";
3856 case 012: return "seq";
3857 case 013: return "ngl";
3858 case 014: return "lt";
3859 case 015: return "nge";
3860 case 016: return "le";
3861 case 017: return "ngt";
3862 default: return "?";
3867 010001,10,3.FMT,00000,5.FS,5.FD,000101:COP1:32,f::ABS.fmt
3868 "abs.%s<FMT> f<FD>, f<FS>"
3869 *mipsI,mipsII,mipsIII,mipsIV:
3871 // start-sanitize-vr4320
3873 // end-sanitize-vr4320
3874 // start-sanitize-vr5400
3876 // end-sanitize-vr5400
3878 // start-sanitize-tx19
3880 // end-sanitize-tx19
3882 unsigned32 instruction = instruction_0;
3883 int destreg = ((instruction >> 6) & 0x0000001F);
3884 int fs = ((instruction >> 11) & 0x0000001F);
3885 int format = ((instruction >> 21) & 0x00000007);
3887 if ((format != fmt_single) && (format != fmt_double))
3888 SignalException(ReservedInstruction,instruction);
3890 StoreFPR(destreg,format,AbsoluteValue(ValueFPR(fs,format),format));
3896 010001,10,3.FMT,5.FT,5.FS,5.FD,000000:COP1:32,f::ADD.fmt
3897 "add.%s<FMT> f<FD>, f<FS>, f<FT>"
3898 *mipsI,mipsII,mipsIII,mipsIV:
3900 // start-sanitize-vr4320
3902 // end-sanitize-vr4320
3903 // start-sanitize-vr5400
3905 // end-sanitize-vr5400
3907 // start-sanitize-tx19
3909 // end-sanitize-tx19
3911 unsigned32 instruction = instruction_0;
3912 int destreg = ((instruction >> 6) & 0x0000001F);
3913 int fs = ((instruction >> 11) & 0x0000001F);
3914 int ft = ((instruction >> 16) & 0x0000001F);
3915 int format = ((instruction >> 21) & 0x00000007);
3917 if ((format != fmt_single) && (format != fmt_double))
3918 SignalException(ReservedInstruction, instruction);
3920 StoreFPR(destreg,format,Add(ValueFPR(fs,format),ValueFPR(ft,format),format));
3931 010001,01000,3.0,1.ND,1.TF,16.OFFSET:COP1S:32,f::BC1
3932 "bc1%s<TF>%s<ND> <OFFSET>"
3933 *mipsI,mipsII,mipsIII:
3934 // start-sanitize-r5900
3936 // end-sanitize-r5900
3938 TRACE_BRANCH_INPUT (PREVCOC1());
3939 if (PREVCOC1() == TF)
3941 address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
3942 TRACE_BRANCH_RESULT (dest);
3947 TRACE_BRANCH_RESULT (0);
3948 NULLIFY_NEXT_INSTRUCTION ();
3952 TRACE_BRANCH_RESULT (NIA);
3956 010001,01000,3.CC,1.ND,1.TF,16.OFFSET:COP1S:32,f::BC1
3957 "bc1%s<TF>%s<ND> <OFFSET>":CC == 0
3958 "bc1%s<TF>%s<ND> <CC>, <OFFSET>"
3961 // start-sanitize-vr4320
3963 // end-sanitize-vr4320
3964 // start-sanitize-vr5400
3966 // end-sanitize-vr5400
3968 // start-sanitize-tx19
3970 // end-sanitize-tx19
3972 if (GETFCC(CC) == TF)
3974 DELAY_SLOT (NIA + (EXTEND16 (OFFSET) << 2));
3978 NULLIFY_NEXT_INSTRUCTION ();
3991 :function:::void:do_c_cond_fmt:int fmt, int ft, int fs, int cc, int cond, instruction_word insn
3993 if ((fmt != fmt_single) && (fmt != fmt_double))
3994 SignalException (ReservedInstruction, insn);
4001 unsigned64 ofs = ValueFPR (fs, fmt);
4002 unsigned64 oft = ValueFPR (ft, fmt);
4003 if (NaN (ofs, fmt) || NaN (oft, fmt))
4005 if (FCSR & FP_ENABLE (IO))
4007 FCSR |= FP_CAUSE (IO);
4008 SignalExceptionFPE ();
4016 less = Less (ofs, oft, fmt);
4017 equal = Equal (ofs, oft, fmt);
4020 condition = (((cond & (1 << 2)) && less)
4021 || ((cond & (1 << 1)) && equal)
4022 || ((cond & (1 << 0)) && unordered));
4023 SETFCC (cc, condition);
4027 010001,10,3.FMT,5.FT,5.FS,3.0,00,11,4.COND:COP1:32::C.cond.fmt
4028 *mipsI,mipsII,mipsIII:
4029 "c.%s<COND>.%s<FMT> f<FS>, f<FT>":
4031 do_c_cond_fmt (SD_, FMT, FT, FS, 0, COND, instruction_0);
4034 010001,10,3.FMT,5.FT,5.FS,3.CC,00,11,4.COND:COP1:32::C.cond.fmt
4035 "c.%s<COND>.%s<FMT> f<FS>, f<FT>":CC == 0
4036 "c.%s<COND>.%s<FMT> <CC>, f<FS>, f<FT>"
4039 // start-sanitize-vr4320
4041 // end-sanitize-vr4320
4042 // start-sanitize-vr5400
4044 // end-sanitize-vr5400
4046 // start-sanitize-tx19
4048 // end-sanitize-tx19
4050 do_c_cond_fmt (SD_, FMT, FT, FS, CC, COND, instruction_0);
4054 010001,10,3.FMT,00000,5.FS,5.FD,001010:COP1:64::CEIL.L.fmt
4055 "ceil.l.%s<FMT> f<FD>, f<FS>"
4059 // start-sanitize-vr4320
4061 // end-sanitize-vr4320
4062 // start-sanitize-vr5400
4064 // end-sanitize-vr5400
4065 // start-sanitize-r5900
4067 // end-sanitize-r5900
4069 // start-sanitize-tx19
4071 // end-sanitize-tx19
4073 unsigned32 instruction = instruction_0;
4074 int destreg = ((instruction >> 6) & 0x0000001F);
4075 int fs = ((instruction >> 11) & 0x0000001F);
4076 int format = ((instruction >> 21) & 0x00000007);
4078 if ((format != fmt_single) && (format != fmt_double))
4079 SignalException(ReservedInstruction,instruction);
4081 StoreFPR(destreg,fmt_long,Convert(FP_RM_TOPINF,ValueFPR(fs,format),format,fmt_long));
4086 010001,10,3.FMT,00000,5.FS,5.FD,001110:COP1:32::CEIL.W
4091 // start-sanitize-vr4320
4093 // end-sanitize-vr4320
4094 // start-sanitize-vr5400
4096 // end-sanitize-vr5400
4097 // start-sanitize-r5900
4099 // end-sanitize-r5900
4101 // start-sanitize-tx19
4103 // end-sanitize-tx19
4105 unsigned32 instruction = instruction_0;
4106 int destreg = ((instruction >> 6) & 0x0000001F);
4107 int fs = ((instruction >> 11) & 0x0000001F);
4108 int format = ((instruction >> 21) & 0x00000007);
4110 if ((format != fmt_single) && (format != fmt_double))
4111 SignalException(ReservedInstruction,instruction);
4113 StoreFPR(destreg,fmt_word,Convert(FP_RM_TOPINF,ValueFPR(fs,format),format,fmt_word));
4120 010001,00,X,10,5.RT,5.FS,00000000000:COP1S:32::CxC1
4121 "c%s<X>c1 r<RT>, f<FS>"
4129 PENDING_FILL((FS + FCR0IDX),VL4_8(GPR[RT]));
4131 PENDING_FILL((FS + FCR31IDX),VL4_8(GPR[RT]));
4133 PENDING_FILL(COCIDX,0); /* special case */
4136 { /* control from */
4138 PENDING_FILL(RT,SIGNEXTEND(FCR0,32));
4140 PENDING_FILL(RT,SIGNEXTEND(FCR31,32));
4144 010001,00,X,10,5.RT,5.FS,00000000000:COP1S:32::CxC1
4145 "c%s<X>c1 r<RT>, f<FS>"
4148 // start-sanitize-vr4320
4150 // end-sanitize-vr4320
4151 // start-sanitize-vr5400
4153 // end-sanitize-vr5400
4155 // start-sanitize-tx19
4157 // end-sanitize-tx19
4162 TRACE_ALU_INPUT1 (GPR[RT]);
4165 FCR0 = VL4_8(GPR[RT]);
4166 TRACE_ALU_RESULT (FCR0);
4170 FCR31 = VL4_8(GPR[RT]);
4171 SETFCC(0,((FCR31 & (1 << 23)) ? 1 : 0));
4172 TRACE_ALU_RESULT (FCR31);
4176 TRACE_ALU_RESULT0 ();
4181 { /* control from */
4184 TRACE_ALU_INPUT1 (FCR0);
4185 GPR[RT] = SIGNEXTEND (FCR0, 32);
4189 TRACE_ALU_INPUT1 (FCR31);
4190 GPR[RT] = SIGNEXTEND (FCR31, 32);
4192 TRACE_ALU_RESULT (GPR[RT]);
4199 // FIXME: Does not correctly differentiate between mips*
4201 010001,10,3.FMT,00000,5.FS,5.FD,100001:COP1:32::CVT.D.fmt
4202 "cvt.d.%s<FMT> f<FD>, f<FS>"
4203 *mipsI,mipsII,mipsIII,mipsIV:
4205 // start-sanitize-vr4320
4207 // end-sanitize-vr4320
4208 // start-sanitize-vr5400
4210 // end-sanitize-vr5400
4212 // start-sanitize-tx19
4214 // end-sanitize-tx19
4216 unsigned32 instruction = instruction_0;
4217 int destreg = ((instruction >> 6) & 0x0000001F);
4218 int fs = ((instruction >> 11) & 0x0000001F);
4219 int format = ((instruction >> 21) & 0x00000007);
4221 if ((format == fmt_double) | 0)
4222 SignalException(ReservedInstruction,instruction);
4224 StoreFPR(destreg,fmt_double,Convert(GETRM(),ValueFPR(fs,format),format,fmt_double));
4229 010001,10,3.FMT,00000,5.FS,5.FD,100101:COP1:64::CVT.L.fmt
4230 "cvt.l.%s<FMT> f<FD>, f<FS>"
4234 // start-sanitize-vr4320
4236 // end-sanitize-vr4320
4237 // start-sanitize-vr5400
4239 // end-sanitize-vr5400
4241 // start-sanitize-tx19
4243 // end-sanitize-tx19
4245 unsigned32 instruction = instruction_0;
4246 int destreg = ((instruction >> 6) & 0x0000001F);
4247 int fs = ((instruction >> 11) & 0x0000001F);
4248 int format = ((instruction >> 21) & 0x00000007);
4250 if ((format == fmt_long) | ((format == fmt_long) || (format == fmt_word)))
4251 SignalException(ReservedInstruction,instruction);
4253 StoreFPR(destreg,fmt_long,Convert(GETRM(),ValueFPR(fs,format),format,fmt_long));
4259 // FIXME: Does not correctly differentiate between mips*
4261 010001,10,3.FMT,00000,5.FS,5.FD,100000:COP1:32::CVT.S.fmt
4262 "cvt.s.%s<FMT> f<FD>, f<FS>"
4263 *mipsI,mipsII,mipsIII,mipsIV:
4265 // start-sanitize-vr4320
4267 // end-sanitize-vr4320
4268 // start-sanitize-vr5400
4270 // end-sanitize-vr5400
4272 // start-sanitize-tx19
4274 // end-sanitize-tx19
4276 unsigned32 instruction = instruction_0;
4277 int destreg = ((instruction >> 6) & 0x0000001F);
4278 int fs = ((instruction >> 11) & 0x0000001F);
4279 int format = ((instruction >> 21) & 0x00000007);
4281 if ((format == fmt_single) | 0)
4282 SignalException(ReservedInstruction,instruction);
4284 StoreFPR(destreg,fmt_single,Convert(GETRM(),ValueFPR(fs,format),format,fmt_single));
4289 010001,10,3.FMT,00000,5.FS,5.FD,100100:COP1:32::CVT.W.fmt
4290 "cvt.w.%s<FMT> f<FD>, f<FS>"
4291 *mipsI,mipsII,mipsIII,mipsIV:
4293 // start-sanitize-vr4320
4295 // end-sanitize-vr4320
4296 // start-sanitize-vr5400
4298 // end-sanitize-vr5400
4300 // start-sanitize-tx19
4302 // end-sanitize-tx19
4304 unsigned32 instruction = instruction_0;
4305 int destreg = ((instruction >> 6) & 0x0000001F);
4306 int fs = ((instruction >> 11) & 0x0000001F);
4307 int format = ((instruction >> 21) & 0x00000007);
4309 if ((format == fmt_word) | ((format == fmt_long) || (format == fmt_word)))
4310 SignalException(ReservedInstruction,instruction);
4312 StoreFPR(destreg,fmt_word,Convert(GETRM(),ValueFPR(fs,format),format,fmt_word));
4317 010001,10,3.FMT,5.FT,5.FS,5.FD,000011:COP1:32::DIV.fmt
4318 "div.%s<FMT> f<FD>, f<FS>, f<FT>"
4319 *mipsI,mipsII,mipsIII,mipsIV:
4321 // start-sanitize-vr4320
4323 // end-sanitize-vr4320
4324 // start-sanitize-vr5400
4326 // end-sanitize-vr5400
4328 // start-sanitize-tx19
4330 // end-sanitize-tx19
4332 unsigned32 instruction = instruction_0;
4333 int destreg = ((instruction >> 6) & 0x0000001F);
4334 int fs = ((instruction >> 11) & 0x0000001F);
4335 int ft = ((instruction >> 16) & 0x0000001F);
4336 int format = ((instruction >> 21) & 0x00000007);
4338 if ((format != fmt_single) && (format != fmt_double))
4339 SignalException(ReservedInstruction,instruction);
4341 StoreFPR(destreg,format,Divide(ValueFPR(fs,format),ValueFPR(ft,format),format));
4348 010001,00,X,01,5.RT,5.FS,00000000000:COP1S:64::DMxC1
4349 "dm%s<X>c1 r<RT>, f<FS>"
4354 if (SizeFGR() == 64)
4355 PENDING_FILL((FS + FGRIDX),GPR[RT]);
4356 else if ((FS & 0x1) == 0)
4358 PENDING_FILL(((FS + 1) + FGRIDX),VH4_8(GPR[RT]));
4359 PENDING_FILL((FS + FGRIDX),VL4_8(GPR[RT]));
4364 if (SizeFGR() == 64)
4365 PENDING_FILL(RT,FGR[FS]);
4366 else if ((FS & 0x1) == 0)
4367 PENDING_FILL(RT,(SET64HI(FGR[FS+1]) | FGR[FS]));
4369 PENDING_FILL(RT,SET64HI(0xDEADC0DE) | 0xBAD0BAD0);
4372 010001,00,X,01,5.RT,5.FS,00000000000:COP1S:64::DMxC1
4373 "dm%s<X>c1 r<RT>, f<FS>"
4376 // start-sanitize-vr4320
4378 // end-sanitize-vr4320
4379 // start-sanitize-vr5400
4381 // end-sanitize-vr5400
4382 // start-sanitize-r5900
4384 // end-sanitize-r5900
4386 // start-sanitize-tx19
4388 // end-sanitize-tx19
4392 if (SizeFGR() == 64)
4393 StoreFPR (FS, fmt_uninterpreted_64, GPR[RT]);
4394 else if ((FS & 0x1) == 0)
4395 StoreFPR (FS, fmt_uninterpreted_64, SET64HI (FGR[FS+1]) | FGR[FS]);
4399 if (SizeFGR() == 64)
4401 else if ((FS & 0x1) == 0)
4402 GPR[RT] = SET64HI (FGR[FS+1]) | FGR[FS];
4404 GPR[RT] = SET64HI (0xDEADC0DE) | 0xBAD0BAD0;
4409 010001,10,3.FMT,00000,5.FS,5.FD,001011:COP1:64::FLOOR.L.fmt
4410 "floor.l.%s<FMT> f<FD>, f<FS>"
4414 // start-sanitize-vr4320
4416 // end-sanitize-vr4320
4417 // start-sanitize-vr5400
4419 // end-sanitize-vr5400
4420 // start-sanitize-r5900
4422 // end-sanitize-r5900
4424 // start-sanitize-tx19
4426 // end-sanitize-tx19
4428 unsigned32 instruction = instruction_0;
4429 int destreg = ((instruction >> 6) & 0x0000001F);
4430 int fs = ((instruction >> 11) & 0x0000001F);
4431 int format = ((instruction >> 21) & 0x00000007);
4433 if ((format != fmt_single) && (format != fmt_double))
4434 SignalException(ReservedInstruction,instruction);
4436 StoreFPR(destreg,fmt_long,Convert(FP_RM_TOMINF,ValueFPR(fs,format),format,fmt_long));
4441 010001,10,3.FMT,00000,5.FS,5.FD,001111:COP1:32::FLOOR.W.fmt
4442 "floor.w.%s<FMT> f<FD>, f<FS>"
4447 // start-sanitize-vr4320
4449 // end-sanitize-vr4320
4450 // start-sanitize-vr5400
4452 // end-sanitize-vr5400
4453 // start-sanitize-r5900
4455 // end-sanitize-r5900
4457 // start-sanitize-tx19
4459 // end-sanitize-tx19
4461 unsigned32 instruction = instruction_0;
4462 int destreg = ((instruction >> 6) & 0x0000001F);
4463 int fs = ((instruction >> 11) & 0x0000001F);
4464 int format = ((instruction >> 21) & 0x00000007);
4466 if ((format != fmt_single) && (format != fmt_double))
4467 SignalException(ReservedInstruction,instruction);
4469 StoreFPR(destreg,fmt_word,Convert(FP_RM_TOMINF,ValueFPR(fs,format),format,fmt_word));
4474 110101,5.BASE,5.FT,16.OFFSET:COP1:64::LDC1
4475 "ldc1 f<FT>, <OFFSET>(r<BASE>)"
4480 // start-sanitize-vr4320
4482 // end-sanitize-vr4320
4483 // start-sanitize-vr5400
4485 // end-sanitize-vr5400
4487 // start-sanitize-tx19
4489 // end-sanitize-tx19
4491 COP_LD (1, FT, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET)));
4495 010011,5.BASE,5.INDEX,5.0,5.FD,000001:COP1X:64::LDXC1
4496 "ldxc1 f<FD>, r<INDEX>(r<BASE>)"
4499 // start-sanitize-vr4320
4501 // end-sanitize-vr4320
4502 // start-sanitize-vr5400
4504 // end-sanitize-vr5400
4506 COP_LD (1, FD, do_load (SD_, AccessLength_DOUBLEWORD, GPR[BASE], GPR[INDEX]));
4511 110001,5.BASE,5.FT,16.OFFSET:COP1:32::LWC1
4512 "lwc1 f<FT>, <OFFSET>(r<BASE>)"
4513 *mipsI,mipsII,mipsIII,mipsIV:
4515 // start-sanitize-vr4320
4517 // end-sanitize-vr4320
4518 // start-sanitize-vr5400
4520 // end-sanitize-vr5400
4521 // start-sanitize-r5900
4523 // end-sanitize-r5900
4525 // start-sanitize-tx19
4527 // end-sanitize-tx19
4529 COP_LW (1, FT, do_load (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET)));
4533 010011,5.BASE,5.INDEX,5.0,5.FD,000000:COP1X:32::LWXC1
4534 "lwxc1 f<FD>, r<INDEX>(r<BASE>)"
4537 // start-sanitize-vr4320
4539 // end-sanitize-vr4320
4540 // start-sanitize-vr5400
4542 // end-sanitize-vr5400
4544 COP_LW (1, FD, do_load (SD_, AccessLength_WORD, GPR[BASE], GPR[INDEX]));
4550 // FIXME: Not correct for mips*
4552 010011,5.FR,5.FT,5.FS,5.FD,100,001:COP1X:32,f::MADD.D
4553 "madd.d f<FD>, f<FR>, f<FS>, f<FT>"
4556 // start-sanitize-vr4320
4558 // end-sanitize-vr4320
4559 // start-sanitize-vr5400
4561 // end-sanitize-vr5400
4563 unsigned32 instruction = instruction_0;
4564 int destreg = ((instruction >> 6) & 0x0000001F);
4565 int fs = ((instruction >> 11) & 0x0000001F);
4566 int ft = ((instruction >> 16) & 0x0000001F);
4567 int fr = ((instruction >> 21) & 0x0000001F);
4569 StoreFPR(destreg,fmt_double,Add(Multiply(ValueFPR(fs,fmt_double),ValueFPR(ft,fmt_double),fmt_double),ValueFPR(fr,fmt_double),fmt_double));
4574 010011,5.FR,5.FT,5.FS,5.FD,100,000:COP1X:32,f::MADD.S
4575 "madd.s f<FD>, f<FR>, f<FS>, f<FT>"
4578 // start-sanitize-vr4320
4580 // end-sanitize-vr4320
4581 // start-sanitize-vr5400
4583 // end-sanitize-vr5400
4585 unsigned32 instruction = instruction_0;
4586 int destreg = ((instruction >> 6) & 0x0000001F);
4587 int fs = ((instruction >> 11) & 0x0000001F);
4588 int ft = ((instruction >> 16) & 0x0000001F);
4589 int fr = ((instruction >> 21) & 0x0000001F);
4591 StoreFPR(destreg,fmt_single,Add(Multiply(ValueFPR(fs,fmt_single),ValueFPR(ft,fmt_single),fmt_single),ValueFPR(fr,fmt_single),fmt_single));
4598 010001,00,X,00,5.RT,5.FS,00000000000:COP1S:32::MxC1
4599 "m%s<X>c1 r<RT>, f<FS>"
4606 if (SizeFGR() == 64)
4607 PENDING_FILL ((FS + FGRIDX), (SET64HI(0xDEADC0DE) | VL4_8(GPR[RT])));
4609 PENDING_FILL ((FS + FGRIDX), VL4_8(GPR[RT]));
4612 PENDING_FILL (RT, SIGNEXTEND(FGR[FS],32));
4614 010001,00,X,00,5.RT,5.FS,00000000000:COP1S:32::MxC1
4615 "m%s<X>c1 r<RT>, f<FS>"
4618 // start-sanitize-vr4320
4620 // end-sanitize-vr4320
4621 // start-sanitize-vr5400
4623 // end-sanitize-vr5400
4625 // start-sanitize-tx19
4627 // end-sanitize-tx19
4631 StoreFPR (FS, fmt_uninterpreted_32, VL4_8 (GPR[RT]));
4633 GPR[RT] = SIGNEXTEND(FGR[FS],32);
4637 010001,10,3.FMT,00000,5.FS,5.FD,000110:COP1:32::MOV.fmt
4638 "mov.%s<FMT> f<FD>, f<FS>"
4639 *mipsI,mipsII,mipsIII,mipsIV:
4641 // start-sanitize-vr4320
4643 // end-sanitize-vr4320
4644 // start-sanitize-vr5400
4646 // end-sanitize-vr5400
4648 // start-sanitize-tx19
4650 // end-sanitize-tx19
4652 unsigned32 instruction = instruction_0;
4653 int destreg = ((instruction >> 6) & 0x0000001F);
4654 int fs = ((instruction >> 11) & 0x0000001F);
4655 int format = ((instruction >> 21) & 0x00000007);
4657 StoreFPR(destreg,format,ValueFPR(fs,format));
4663 000000,5.RS,3.CC,0,1.TF,5.RD,00000000001:SPECIAL:32::MOVtf
4664 "mov%s<TF> r<RD>, r<RS>, <CC>"
4667 // start-sanitize-vr4320
4669 // end-sanitize-vr4320
4670 // start-sanitize-vr5400
4672 // end-sanitize-vr5400
4673 // start-sanitize-r5900
4675 // end-sanitize-r5900
4677 if (GETFCC(CC) == TF)
4683 010001,10,3.FMT,3.CC,0,1.TF,5.FS,5.FD,010001:COP1:32::MOVtf.fmt
4684 "mov%s<TF>.%s<FMT> f<FD>, f<FS>, <CC>"
4687 // start-sanitize-vr4320
4689 // end-sanitize-vr4320
4690 // start-sanitize-vr5400
4692 // end-sanitize-vr5400
4693 // start-sanitize-r5900
4695 // end-sanitize-r5900
4697 unsigned32 instruction = instruction_0;
4698 int format = ((instruction >> 21) & 0x00000007);
4700 if (GETFCC(CC) == TF)
4701 StoreFPR (FD, format, ValueFPR (FS, format));
4703 StoreFPR (FD, format, ValueFPR (FD, format));
4708 010001,10,3.FMT,5.RT,5.FS,5.FD,010011:COP1:32::MOVN.fmt
4711 // start-sanitize-vr4320
4713 // end-sanitize-vr4320
4714 // start-sanitize-vr5400
4716 // end-sanitize-vr5400
4717 // start-sanitize-r5900
4719 // end-sanitize-r5900
4721 unsigned32 instruction = instruction_0;
4722 int destreg = ((instruction >> 6) & 0x0000001F);
4723 int fs = ((instruction >> 11) & 0x0000001F);
4724 int format = ((instruction >> 21) & 0x00000007);
4726 StoreFPR(destreg,format,ValueFPR(fs,format));
4734 // MOVT.fmt see MOVtf.fmt
4738 010001,10,3.FMT,5.RT,5.FS,5.FD,010010:COP1:32::MOVZ.fmt
4739 "movz.%s<FMT> f<FD>, f<FS>, r<RT>"
4742 // start-sanitize-vr4320
4744 // end-sanitize-vr4320
4745 // start-sanitize-vr5400
4747 // end-sanitize-vr5400
4748 // start-sanitize-r5900
4750 // end-sanitize-r5900
4752 unsigned32 instruction = instruction_0;
4753 int destreg = ((instruction >> 6) & 0x0000001F);
4754 int fs = ((instruction >> 11) & 0x0000001F);
4755 int format = ((instruction >> 21) & 0x00000007);
4757 StoreFPR(destreg,format,ValueFPR(fs,format));
4763 010011,5.FR,5.FT,5.FS,5.FD,101,001:COP1X:32::MSUB.D
4764 "msub.d f<FD>, f<FR>, f<FS>, f<FT>"
4767 // start-sanitize-vr4320
4769 // end-sanitize-vr4320
4770 // start-sanitize-vr5400
4772 // end-sanitize-vr5400
4773 // start-sanitize-r5900
4775 // end-sanitize-r5900
4777 unsigned32 instruction = instruction_0;
4778 int destreg = ((instruction >> 6) & 0x0000001F);
4779 int fs = ((instruction >> 11) & 0x0000001F);
4780 int ft = ((instruction >> 16) & 0x0000001F);
4781 int fr = ((instruction >> 21) & 0x0000001F);
4783 StoreFPR(destreg,fmt_double,Sub(Multiply(ValueFPR(fs,fmt_double),ValueFPR(ft,fmt_double),fmt_double),ValueFPR(fr,fmt_double),fmt_double));
4789 010011,5.FR,5.FT,5.FS,5.FD,101000:COP1X:32::MSUB.S
4790 "msub.s f<FD>, f<FR>, f<FS>, f<FT>"
4793 // start-sanitize-vr4320
4795 // end-sanitize-vr4320
4796 // start-sanitize-vr5400
4798 // end-sanitize-vr5400
4799 // start-sanitize-r5900
4801 // end-sanitize-r5900
4803 unsigned32 instruction = instruction_0;
4804 int destreg = ((instruction >> 6) & 0x0000001F);
4805 int fs = ((instruction >> 11) & 0x0000001F);
4806 int ft = ((instruction >> 16) & 0x0000001F);
4807 int fr = ((instruction >> 21) & 0x0000001F);
4809 StoreFPR(destreg,fmt_single,Sub(Multiply(ValueFPR(fs,fmt_single),ValueFPR(ft,fmt_single),fmt_single),ValueFPR(fr,fmt_single),fmt_single));
4817 010001,10,3.FMT,5.FT,5.FS,5.FD,000010:COP1:32::MUL.fmt
4818 "mul.%s<FMT> f<FD>, f<FS>, f<FT>"
4819 *mipsI,mipsII,mipsIII,mipsIV:
4821 // start-sanitize-vr4320
4823 // end-sanitize-vr4320
4824 // start-sanitize-vr5400
4826 // end-sanitize-vr5400
4828 // start-sanitize-tx19
4830 // end-sanitize-tx19
4832 unsigned32 instruction = instruction_0;
4833 int destreg = ((instruction >> 6) & 0x0000001F);
4834 int fs = ((instruction >> 11) & 0x0000001F);
4835 int ft = ((instruction >> 16) & 0x0000001F);
4836 int format = ((instruction >> 21) & 0x00000007);
4838 if ((format != fmt_single) && (format != fmt_double))
4839 SignalException(ReservedInstruction,instruction);
4841 StoreFPR(destreg,format,Multiply(ValueFPR(fs,format),ValueFPR(ft,format),format));
4846 010001,10,3.FMT,00000,5.FS,5.FD,000111:COP1:32::NEG.fmt
4847 "neg.%s<FMT> f<FD>, f<FS>"
4848 *mipsI,mipsII,mipsIII,mipsIV:
4850 // start-sanitize-vr4320
4852 // end-sanitize-vr4320
4853 // start-sanitize-vr5400
4855 // end-sanitize-vr5400
4857 // start-sanitize-tx19
4859 // end-sanitize-tx19
4861 unsigned32 instruction = instruction_0;
4862 int destreg = ((instruction >> 6) & 0x0000001F);
4863 int fs = ((instruction >> 11) & 0x0000001F);
4864 int format = ((instruction >> 21) & 0x00000007);
4866 if ((format != fmt_single) && (format != fmt_double))
4867 SignalException(ReservedInstruction,instruction);
4869 StoreFPR(destreg,format,Negate(ValueFPR(fs,format),format));
4875 010011,5.FR,5.FT,5.FS,5.FD,110001:COP1X:32::NMADD.D
4876 "nmadd.d f<FD>, f<FR>, f<FS>, f<FT>"
4879 // start-sanitize-vr4320
4881 // end-sanitize-vr4320
4882 // start-sanitize-vr5400
4884 // end-sanitize-vr5400
4886 unsigned32 instruction = instruction_0;
4887 int destreg = ((instruction >> 6) & 0x0000001F);
4888 int fs = ((instruction >> 11) & 0x0000001F);
4889 int ft = ((instruction >> 16) & 0x0000001F);
4890 int fr = ((instruction >> 21) & 0x0000001F);
4892 StoreFPR(destreg,fmt_double,Negate(Add(Multiply(ValueFPR(fs,fmt_double),ValueFPR(ft,fmt_double),fmt_double),ValueFPR(fr,fmt_double),fmt_double),fmt_double));
4898 010011,5.FR,5.FT,5.FS,5.FD,110000:COP1X:32::NMADD.S
4899 "nmadd.s f<FD>, f<FR>, f<FS>, f<FT>"
4902 // start-sanitize-vr4320
4904 // end-sanitize-vr4320
4905 // start-sanitize-vr5400
4907 // end-sanitize-vr5400
4909 unsigned32 instruction = instruction_0;
4910 int destreg = ((instruction >> 6) & 0x0000001F);
4911 int fs = ((instruction >> 11) & 0x0000001F);
4912 int ft = ((instruction >> 16) & 0x0000001F);
4913 int fr = ((instruction >> 21) & 0x0000001F);
4915 StoreFPR(destreg,fmt_single,Negate(Add(Multiply(ValueFPR(fs,fmt_single),ValueFPR(ft,fmt_single),fmt_single),ValueFPR(fr,fmt_single),fmt_single),fmt_single));
4921 010011,5.FR,5.FT,5.FS,5.FD,111001:COP1X:32::NMSUB.D
4922 "nmsub.d f<FD>, f<FR>, f<FS>, f<FT>"
4925 // start-sanitize-vr4320
4927 // end-sanitize-vr4320
4928 // start-sanitize-vr5400
4930 // end-sanitize-vr5400
4932 unsigned32 instruction = instruction_0;
4933 int destreg = ((instruction >> 6) & 0x0000001F);
4934 int fs = ((instruction >> 11) & 0x0000001F);
4935 int ft = ((instruction >> 16) & 0x0000001F);
4936 int fr = ((instruction >> 21) & 0x0000001F);
4938 StoreFPR(destreg,fmt_double,Negate(Sub(Multiply(ValueFPR(fs,fmt_double),ValueFPR(ft,fmt_double),fmt_double),ValueFPR(fr,fmt_double),fmt_double),fmt_double));
4944 010011,5.FR,5.FT,5.FS,5.FD,111000:COP1X:32::NMSUB.S
4945 "nmsub.s f<FD>, f<FR>, f<FS>, f<FT>"
4948 // start-sanitize-vr4320
4950 // end-sanitize-vr4320
4951 // start-sanitize-vr5400
4953 // end-sanitize-vr5400
4955 unsigned32 instruction = instruction_0;
4956 int destreg = ((instruction >> 6) & 0x0000001F);
4957 int fs = ((instruction >> 11) & 0x0000001F);
4958 int ft = ((instruction >> 16) & 0x0000001F);
4959 int fr = ((instruction >> 21) & 0x0000001F);
4961 StoreFPR(destreg,fmt_single,Negate(Sub(Multiply(ValueFPR(fs,fmt_single),ValueFPR(ft,fmt_single),fmt_single),ValueFPR(fr,fmt_single),fmt_single),fmt_single));
4966 010011,5.BASE,5.INDEX,5.HINT,00000001111:COP1X:32::PREFX
4967 "prefx <HINT>, r<INDEX>(r<BASE>)"
4970 // start-sanitize-vr4320
4972 // end-sanitize-vr4320
4973 // start-sanitize-vr5400
4975 // end-sanitize-vr5400
4977 unsigned32 instruction = instruction_0;
4978 int fs = ((instruction >> 11) & 0x0000001F);
4979 signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
4980 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
4982 address_word vaddr = ((unsigned64)op1 + (unsigned64)op2);
4985 if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
4986 Prefetch(uncached,paddr,vaddr,isDATA,fs);
4990 010001,10,3.FMT,00000,5.FS,5.FD,010101:COP1:32::RECIP.fmt
4992 "recip.%s<FMT> f<FD>, f<FS>"
4994 // start-sanitize-vr4320
4996 // end-sanitize-vr4320
4997 // start-sanitize-vr5400
4999 // end-sanitize-vr5400
5001 unsigned32 instruction = instruction_0;
5002 int destreg = ((instruction >> 6) & 0x0000001F);
5003 int fs = ((instruction >> 11) & 0x0000001F);
5004 int format = ((instruction >> 21) & 0x00000007);
5006 if ((format != fmt_single) && (format != fmt_double))
5007 SignalException(ReservedInstruction,instruction);
5009 StoreFPR(destreg,format,Recip(ValueFPR(fs,format),format));
5014 010001,10,3.FMT,00000,5.FS,5.FD,001000:COP1:64::ROUND.L.fmt
5015 "round.l.%s<FMT> f<FD>, f<FS>"
5019 // start-sanitize-vr4320
5021 // end-sanitize-vr4320
5022 // start-sanitize-vr5400
5024 // end-sanitize-vr5400
5025 // start-sanitize-r5900
5027 // end-sanitize-r5900
5029 // start-sanitize-tx19
5031 // end-sanitize-tx19
5033 unsigned32 instruction = instruction_0;
5034 int destreg = ((instruction >> 6) & 0x0000001F);
5035 int fs = ((instruction >> 11) & 0x0000001F);
5036 int format = ((instruction >> 21) & 0x00000007);
5038 if ((format != fmt_single) && (format != fmt_double))
5039 SignalException(ReservedInstruction,instruction);
5041 StoreFPR(destreg,fmt_long,Convert(FP_RM_NEAREST,ValueFPR(fs,format),format,fmt_long));
5046 010001,10,3.FMT,00000,5.FS,5.FD,001100:COP1:32::ROUND.W.fmt
5047 "round.w.%s<FMT> f<FD>, f<FS>"
5052 // start-sanitize-vr4320
5054 // end-sanitize-vr4320
5055 // start-sanitize-vr5400
5057 // end-sanitize-vr5400
5058 // start-sanitize-r5900
5060 // end-sanitize-r5900
5062 // start-sanitize-tx19
5064 // end-sanitize-tx19
5066 unsigned32 instruction = instruction_0;
5067 int destreg = ((instruction >> 6) & 0x0000001F);
5068 int fs = ((instruction >> 11) & 0x0000001F);
5069 int format = ((instruction >> 21) & 0x00000007);
5071 if ((format != fmt_single) && (format != fmt_double))
5072 SignalException(ReservedInstruction,instruction);
5074 StoreFPR(destreg,fmt_word,Convert(FP_RM_NEAREST,ValueFPR(fs,format),format,fmt_word));
5079 010001,10,3.FMT,00000,5.FS,5.FD,010110:COP1:32::RSQRT.fmt
5081 "rsqrt.%s<FMT> f<FD>, f<FS>"
5083 // start-sanitize-vr4320
5085 // end-sanitize-vr4320
5086 // start-sanitize-vr5400
5088 // end-sanitize-vr5400
5090 unsigned32 instruction = instruction_0;
5091 int destreg = ((instruction >> 6) & 0x0000001F);
5092 int fs = ((instruction >> 11) & 0x0000001F);
5093 int format = ((instruction >> 21) & 0x00000007);
5095 if ((format != fmt_single) && (format != fmt_double))
5096 SignalException(ReservedInstruction,instruction);
5098 StoreFPR(destreg,format,Recip(SquareRoot(ValueFPR(fs,format),format),format));
5103 111101,5.BASE,5.FT,16.OFFSET:COP1:64::SDC1
5104 "sdc1 f<FT>, <OFFSET>(r<BASE>)"
5109 // start-sanitize-vr4320
5111 // end-sanitize-vr4320
5112 // start-sanitize-vr5400
5114 // end-sanitize-vr5400
5116 // start-sanitize-tx19
5118 // end-sanitize-tx19
5120 do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], EXTEND16 (OFFSET), COP_SD (1, FT));
5124 010011,5.BASE,5.INDEX,5.FS,00000001001:COP1X:64::SDXC1
5125 "ldxc1 f<FS>, r<INDEX>(r<BASE>)"
5128 // start-sanitize-vr4320
5130 // end-sanitize-vr4320
5131 // start-sanitize-vr5400
5133 // end-sanitize-vr5400
5135 do_store (SD_, AccessLength_DOUBLEWORD, GPR[BASE], GPR[INDEX], COP_SD (1, FS));
5139 010001,10,3.FMT,00000,5.FS,5.FD,000100:COP1:32::SQRT.fmt
5140 "sqrt.%s<FMT> f<FD>, f<FS>"
5145 // start-sanitize-vr4320
5147 // end-sanitize-vr4320
5148 // start-sanitize-vr5400
5150 // end-sanitize-vr5400
5152 // start-sanitize-tx19
5154 // end-sanitize-tx19
5156 unsigned32 instruction = instruction_0;
5157 int destreg = ((instruction >> 6) & 0x0000001F);
5158 int fs = ((instruction >> 11) & 0x0000001F);
5159 int format = ((instruction >> 21) & 0x00000007);
5161 if ((format != fmt_single) && (format != fmt_double))
5162 SignalException(ReservedInstruction,instruction);
5164 StoreFPR(destreg,format,(SquareRoot(ValueFPR(fs,format),format)));
5169 010001,10,3.FMT,5.FT,5.FS,5.FD,000001:COP1:32::SUB.fmt
5170 "sub.%s<FMT> f<FD>, f<FS>, f<FT>"
5171 *mipsI,mipsII,mipsIII,mipsIV:
5173 // start-sanitize-vr4320
5175 // end-sanitize-vr4320
5176 // start-sanitize-vr5400
5178 // end-sanitize-vr5400
5180 // start-sanitize-tx19
5182 // end-sanitize-tx19
5184 unsigned32 instruction = instruction_0;
5185 int destreg = ((instruction >> 6) & 0x0000001F);
5186 int fs = ((instruction >> 11) & 0x0000001F);
5187 int ft = ((instruction >> 16) & 0x0000001F);
5188 int format = ((instruction >> 21) & 0x00000007);
5190 if ((format != fmt_single) && (format != fmt_double))
5191 SignalException(ReservedInstruction,instruction);
5193 StoreFPR(destreg,format,Sub(ValueFPR(fs,format),ValueFPR(ft,format),format));
5199 111001,5.BASE,5.FT,16.OFFSET:COP1:32::SWC1
5200 "swc1 f<FT>, <OFFSET>(r<BASE>)"
5201 *mipsI,mipsII,mipsIII,mipsIV:
5203 // start-sanitize-vr4320
5205 // end-sanitize-vr4320
5206 // start-sanitize-vr5400
5208 // end-sanitize-vr5400
5209 // start-sanitize-r5900
5211 // end-sanitize-r5900
5213 // start-sanitize-tx19
5215 // end-sanitize-tx19
5217 unsigned32 instruction = instruction_0;
5218 signed_word offset = EXTEND16 (OFFSET);
5219 int destreg UNUSED = ((instruction >> 16) & 0x0000001F);
5220 signed_word op1 UNUSED = GPR[((instruction >> 21) & 0x0000001F)];
5222 address_word vaddr = ((uword64)op1 + offset);
5225 if ((vaddr & 3) != 0)
5226 SignalExceptionAddressStore();
5229 if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
5232 uword64 memval1 = 0;
5233 uword64 mask = (WITH_TARGET_WORD_BITSIZE == 64 ? 0x7 : 0x3);
5234 address_word reverseendian = (ReverseEndian ?(mask ^ AccessLength_WORD): 0);
5235 address_word bigendiancpu = (BigEndianCPU ?(mask ^ AccessLength_WORD): 0);
5237 paddr = ((paddr & ~mask) | ((paddr & mask) ^ reverseendian));
5238 byte = ((vaddr & mask) ^ bigendiancpu);
5239 memval = (((uword64)COP_SW(((instruction >> 26) & 0x3),destreg)) << (8 * byte));
5240 StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
5247 010011,5.BASE,5.INDEX,5.FS,00000,001000:COP1X:32::SWXC1
5248 "swxc1 f<FS>, r<INDEX>(r<BASE>)"
5251 // start-sanitize-vr4320
5253 // end-sanitize-vr4320
5254 // start-sanitize-vr5400
5256 // end-sanitize-vr5400
5258 unsigned32 instruction = instruction_0;
5259 int fs = ((instruction >> 11) & 0x0000001F);
5260 signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
5261 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
5263 address_word vaddr = ((unsigned64)op1 + op2);
5266 if ((vaddr & 3) != 0)
5267 SignalExceptionAddressStore();
5270 if (AddressTranslation(vaddr,isDATA,isSTORE,&paddr,&uncached,isTARGET,isREAL))
5272 unsigned64 memval = 0;
5273 unsigned64 memval1 = 0;
5274 unsigned64 mask = 0x7;
5276 paddr = ((paddr & ~mask) | ((paddr & mask) ^ (ReverseEndian << 2)));
5277 byte = ((vaddr & mask) ^ (BigEndianCPU << 2));
5278 memval = (((unsigned64)COP_SW(1,fs)) << (8 * byte));
5280 StoreMemory(uncached,AccessLength_WORD,memval,memval1,paddr,vaddr,isREAL);
5288 010001,10,3.FMT,00000,5.FS,5.FD,001001:COP1:64::TRUNC.L.fmt
5289 "trunc.l.%s<FMT> f<FD>, f<FS>"
5293 // start-sanitize-vr4320
5295 // end-sanitize-vr4320
5296 // start-sanitize-vr5400
5298 // end-sanitize-vr5400
5299 // start-sanitize-r5900
5301 // end-sanitize-r5900
5303 // start-sanitize-tx19
5305 // end-sanitize-tx19
5307 unsigned32 instruction = instruction_0;
5308 int destreg = ((instruction >> 6) & 0x0000001F);
5309 int fs = ((instruction >> 11) & 0x0000001F);
5310 int format = ((instruction >> 21) & 0x00000007);
5312 if ((format != fmt_single) && (format != fmt_double))
5313 SignalException(ReservedInstruction,instruction);
5315 StoreFPR(destreg,fmt_long,Convert(FP_RM_TOZERO,ValueFPR(fs,format),format,fmt_long));
5320 010001,10,3.FMT,00000,5.FS,5.FD,001101:COP1:32::TRUNC.W
5321 "trunc.w.%s<FMT> f<FD>, f<FS>"
5326 // start-sanitize-vr4320
5328 // end-sanitize-vr4320
5329 // start-sanitize-vr5400
5331 // end-sanitize-vr5400
5332 // start-sanitize-r5900
5334 // end-sanitize-r5900
5336 // start-sanitize-tx19
5338 // end-sanitize-tx19
5340 unsigned32 instruction = instruction_0;
5341 int destreg = ((instruction >> 6) & 0x0000001F);
5342 int fs = ((instruction >> 11) & 0x0000001F);
5343 int format = ((instruction >> 21) & 0x00000007);
5345 if ((format != fmt_single) && (format != fmt_double))
5346 SignalException(ReservedInstruction,instruction);
5348 StoreFPR(destreg,fmt_word,Convert(FP_RM_TOZERO,ValueFPR(fs,format),format,fmt_word));
5354 // MIPS Architecture:
5356 // System Control Instruction Set (COP0)
5360 010000,01000,00000,16.OFFSET:COP0:32::BC0F
5362 *mipsI,mipsII,mipsIII,mipsIV:
5364 // start-sanitize-vr4320
5366 // end-sanitize-vr4320
5367 // start-sanitize-vr5400
5369 // end-sanitize-vr5400
5370 // start-sanitize-r5900
5372 // start-sanitize-sky
5375 extern int sky_cpcond0A;
5376 if (sky_cpcond0A == 0)
5378 address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
5379 TRACE_BRANCH_RESULT (dest);
5384 TRACE_BRANCH_RESULT (NIA);
5389 // end-sanitize-r5900
5392 010000,01000,00010,16.OFFSET:COP0:32::BC0FL
5394 *mipsI,mipsII,mipsIII,mipsIV:
5396 // start-sanitize-vr4320
5398 // end-sanitize-vr4320
5399 // start-sanitize-vr5400
5401 // end-sanitize-vr5400
5402 // start-sanitize-r5900
5404 // start-sanitize-sky
5407 extern int sky_cpcond0A;
5408 if (sky_cpcond0A == 0)
5410 address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
5411 TRACE_BRANCH_RESULT (dest);
5416 TRACE_BRANCH_RESULT (0);
5417 NULLIFY_NEXT_INSTRUCTION ();
5422 // end-sanitize-r5900
5425 010000,01000,00001,16.OFFSET:COP0:32::BC0T
5427 *mipsI,mipsII,mipsIII,mipsIV:
5428 // start-sanitize-r5900
5430 // start-sanitize-sky
5433 extern int sky_cpcond0A;
5434 if (sky_cpcond0A != 0)
5436 address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
5437 TRACE_BRANCH_RESULT (dest);
5442 TRACE_BRANCH_RESULT (NIA);
5447 // end-sanitize-r5900
5451 010000,01000,00011,16.OFFSET:COP0:32::BC0TL
5453 *mipsI,mipsII,mipsIII,mipsIV:
5455 // start-sanitize-vr4320
5457 // end-sanitize-vr4320
5458 // start-sanitize-vr5400
5460 // end-sanitize-vr5400
5461 // start-sanitize-r5900
5463 // start-sanitize-sky
5466 extern int sky_cpcond0A;
5467 if (sky_cpcond0A != 0)
5469 address_word dest = NIA + (EXTEND16 (OFFSET) << 2);
5470 TRACE_BRANCH_RESULT (dest);
5475 TRACE_BRANCH_RESULT (0);
5476 NULLIFY_NEXT_INSTRUCTION ();
5481 // end-sanitize-r5900
5484 101111,5.BASE,5.OP,16.OFFSET:NORMAL:32::CACHE
5488 // start-sanitize-vr4320
5490 // end-sanitize-vr4320
5491 // start-sanitize-vr5400
5493 // end-sanitize-vr5400
5494 // start-sanitize-r5900
5496 // end-sanitize-r5900
5498 // start-sanitize-tx19
5500 // end-sanitize-tx19
5502 unsigned32 instruction = instruction_0;
5503 signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
5504 int hint = ((instruction >> 16) & 0x0000001F);
5505 signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
5507 address_word vaddr = (op1 + offset);
5510 if (AddressTranslation(vaddr,isDATA,isLOAD,&paddr,&uncached,isTARGET,isREAL))
5511 CacheOp(hint,vaddr,paddr,instruction);
5516 010000,10000,000000000000000,111001:COP0:32::DI
5518 *mipsI,mipsII,mipsIII,mipsIV:
5520 // start-sanitize-vr4320
5522 // end-sanitize-vr4320
5523 // start-sanitize-vr5400
5525 // end-sanitize-vr5400
5526 // start-sanitize-r5900
5528 // end-sanitize-r5900
5531 010000,10000,000000000000000,111000:COP0:32::EI
5533 *mipsI,mipsII,mipsIII,mipsIV:
5535 // start-sanitize-vr4320
5537 // end-sanitize-vr4320
5538 // start-sanitize-vr5400
5540 // end-sanitize-vr5400
5541 // start-sanitize-r5900
5543 // end-sanitize-r5900
5546 010000,10000,000000000000000,011000:COP0:32::ERET
5551 // start-sanitize-vr4320
5553 // end-sanitize-vr4320
5554 // start-sanitize-vr5400
5556 // end-sanitize-vr5400
5557 // start-sanitize-r5900
5559 // end-sanitize-r5900
5561 if (SR & status_ERL)
5563 /* Oops, not yet available */
5564 sim_io_printf (SD, "Warning: ERET when SR[ERL] set not supported");
5576 010000,00000,5.RT,5.RD,00000,6.REGX:COP0:32::MFC0
5577 "mfc0 r<RT>, r<RD> # <REGX>"
5578 *mipsI,mipsII,mipsIII,mipsIV:
5581 // start-sanitize-vr4320
5583 // end-sanitize-vr4320
5584 // start-sanitize-vr5400
5586 // end-sanitize-vr5400
5587 // start-sanitize-r5900
5589 // end-sanitize-r5900
5591 TRACE_ALU_INPUT0 ();
5592 DecodeCoproc (instruction_0);
5593 TRACE_ALU_RESULT (GPR[RT]);
5596 010000,00100,5.RT,5.RD,00000,6.REGX:COP0:32::MTC0
5597 "mtc0 r<RT>, r<RD> # <REGX>"
5598 *mipsI,mipsII,mipsIII,mipsIV:
5599 // start-sanitize-tx19
5601 // end-sanitize-tx19
5603 // start-sanitize-vr4320
5605 // end-sanitize-vr4320
5607 // start-sanitize-vr5400
5609 // end-sanitize-vr5400
5610 // start-sanitize-r5900
5612 // end-sanitize-r5900
5614 DecodeCoproc (instruction_0);
5618 010000,10000,000000000000000,010000:COP0:32::RFE
5620 *mipsI,mipsII,mipsIII,mipsIV:
5621 // start-sanitize-tx19
5623 // end-sanitize-tx19
5625 // start-sanitize-vr4320
5627 // end-sanitize-vr4320
5629 // start-sanitize-vr5400
5631 // end-sanitize-vr5400
5632 // start-sanitize-r5900
5634 // end-sanitize-r5900
5636 DecodeCoproc (instruction_0);
5640 0100,ZZ!0!1!3,5.COP_FUN0!8,5.COP_FUN1,16.COP_FUN2:NORMAL:32::COPz
5641 "cop<ZZ> <COP_FUN0><COP_FUN1><COP_FUN2>"
5642 *mipsI,mipsII,mipsIII,mipsIV:
5643 // start-sanitize-r5900
5645 // end-sanitize-r5900
5647 // start-sanitize-tx19
5649 // end-sanitize-tx19
5651 DecodeCoproc (instruction_0);
5656 010000,10000,000000000000000,001000:COP0:32::TLBP
5658 *mipsI,mipsII,mipsIII,mipsIV:
5660 // start-sanitize-vr4320
5662 // end-sanitize-vr4320
5663 // start-sanitize-vr5400
5665 // end-sanitize-vr5400
5666 // start-sanitize-r5900
5668 // end-sanitize-r5900
5671 010000,10000,000000000000000,000001:COP0:32::TLBR
5673 *mipsI,mipsII,mipsIII,mipsIV:
5675 // start-sanitize-vr4320
5677 // end-sanitize-vr4320
5678 // start-sanitize-vr5400
5680 // end-sanitize-vr5400
5681 // start-sanitize-r5900
5683 // end-sanitize-r5900
5686 010000,10000,000000000000000,000010:COP0:32::TLBWI
5688 *mipsI,mipsII,mipsIII,mipsIV:
5690 // start-sanitize-vr4320
5692 // end-sanitize-vr4320
5693 // start-sanitize-vr5400
5695 // end-sanitize-vr5400
5696 // start-sanitize-r5900
5698 // end-sanitize-r5900
5701 010000,10000,000000000000000,000110:COP0:32::TLBWR
5703 *mipsI,mipsII,mipsIII,mipsIV:
5705 // start-sanitize-vr4320
5707 // end-sanitize-vr4320
5708 // start-sanitize-vr5400
5710 // end-sanitize-vr5400
5711 // start-sanitize-r5900
5713 // end-sanitize-r5900
5717 // start-sanitize-vr4320
5718 :include::vr4320:vr4320.igen
5719 // end-sanitize-vr4320
5720 // start-sanitize-vr5400
5721 :include::vr5400:vr5400.igen
5722 :include:64,f::mdmx.igen
5723 // end-sanitize-vr5400
5724 // start-sanitize-r5900
5725 :include::r5900:r5900.igen
5726 // end-sanitize-r5900
5729 // start-sanitize-cygnus-never
5731 // // FIXME FIXME FIXME What is this instruction?
5732 // 111011,5.RS,5.RT,16.OFFSET:NORMAL:32::<INT>
5737 // // start-sanitize-r5900
5739 // // end-sanitize-r5900
5741 // // start-sanitize-tx19
5743 // // end-sanitize-tx19
5745 // unsigned32 instruction = instruction_0;
5746 // signed_word offset = SIGNEXTEND((signed_word)((instruction >> 0) & 0x0000FFFF),16);
5747 // signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
5748 // signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
5750 // if (CoProcPresent(3))
5751 // SignalException(CoProcessorUnusable);
5753 // SignalException(ReservedInstruction,instruction);
5757 // end-sanitize-cygnus-never
5758 // start-sanitize-cygnus-never
5760 // // FIXME FIXME FIXME What is this?
5761 // 11100,******,00001:RR:16::SDBBP
5764 // unsigned32 instruction = instruction_0;
5765 // if (have_extendval)
5766 // SignalException (ReservedInstruction, instruction);
5768 // SignalException(DebugBreakPoint,instruction);
5772 // end-sanitize-cygnus-never
5773 // start-sanitize-cygnus-never
5775 // // FIXME FIXME FIXME What is this?
5776 // 000000,********************,001110:SPECIAL:32::SDBBP
5779 // unsigned32 instruction = instruction_0;
5781 // SignalException(DebugBreakPoint,instruction);
5785 // end-sanitize-cygnus-never
5786 // start-sanitize-cygnus-never
5788 // // FIXME FIXME FIXME This apparently belongs to the vr4100 which
5789 // // isn't yet reconized by this simulator.
5790 // 000000,5.RS,5.RT,0000000000101000:SPECIAL:32::MADD16
5793 // unsigned32 instruction = instruction_0;
5794 // signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
5795 // signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
5797 // CHECKHILO("Multiply-Add");
5799 // unsigned64 temp = (op1 * op2);
5800 // temp += (SET64HI(VL4_8(HI)) | VL4_8(LO));
5801 // LO = SIGNEXTEND((unsigned64)VL4_8(temp),32);
5802 // HI = SIGNEXTEND((unsigned64)VH4_8(temp),32);
5807 // end-sanitize-cygnus-never
5808 // start-sanitize-cygnus-never
5810 // // FIXME FIXME FIXME This apparently belongs to the vr4100 which
5811 // // isn't yet reconized by this simulator.
5812 // 000000,5.RS,5.RT,0000000000101001:SPECIAL:64::DMADD16
5815 // unsigned32 instruction = instruction_0;
5816 // signed_word op2 = GPR[((instruction >> 16) & 0x0000001F)];
5817 // signed_word op1 = GPR[((instruction >> 21) & 0x0000001F)];
5819 // CHECKHILO("Multiply-Add");
5821 // unsigned64 temp = (op1 * op2);
5827 // end-sanitize-cygnus-never