]> git.proxmox.com Git - mirror_qemu.git/blob - disas/nanomips.cpp
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
disas: nanoMIPS: Fix types and format strings
[mirror_qemu.git] / disas / nanomips.cpp
1 /*
2 * Source file for nanoMIPS disassembler component of QEMU
3 *
4 * Copyright (C) 2018 Wave Computing
5 * Copyright (C) 2018 Matthew Fortune <matthew.fortune@mips.com>
6 * Copyright (C) 2018 Aleksandar Markovic <aleksandar.markovic@wavecomp.com>
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 extern "C" {
23 #include "qemu/osdep.h"
24 #include "disas/bfd.h"
25 }
26
27 #include <cstring>
28 #include <stdexcept>
29 #include <sstream>
30 #include <stdio.h>
31 #include <stdarg.h>
32
33 #include "nanomips.h"
34
35 #define IMGASSERTONCE(test)
36
37
38 int nanomips_dis(char *buf,
39 unsigned address,
40 unsigned short one,
41 unsigned short two,
42 unsigned short three)
43 {
44 std::string disasm;
45 uint16 bits[3] = {one, two, three};
46
47 NMD::TABLE_ENTRY_TYPE type;
48 NMD d(address, NMD::ALL_ATTRIBUTES);
49 int size = d.Disassemble(bits, disasm, type);
50
51 strcpy(buf, disasm.c_str());
52 return size;
53 }
54
55 int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
56 {
57 int status;
58 bfd_byte buffer[2];
59 uint16_t insn1 = 0, insn2 = 0, insn3 = 0;
60 char buf[200];
61
62 info->bytes_per_chunk = 2;
63 info->display_endian = info->endian;
64 info->insn_info_valid = 1;
65 info->branch_delay_insns = 0;
66 info->data_size = 0;
67 info->insn_type = dis_nonbranch;
68 info->target = 0;
69 info->target2 = 0;
70
71 status = (*info->read_memory_func)(memaddr, buffer, 2, info);
72 if (status != 0) {
73 (*info->memory_error_func)(status, memaddr, info);
74 return -1;
75 }
76
77 if (info->endian == BFD_ENDIAN_BIG) {
78 insn1 = bfd_getb16(buffer);
79 } else {
80 insn1 = bfd_getl16(buffer);
81 }
82 (*info->fprintf_func)(info->stream, "%04x ", insn1);
83
84 /* Handle 32-bit opcodes. */
85 if ((insn1 & 0x1000) == 0) {
86 status = (*info->read_memory_func)(memaddr + 2, buffer, 2, info);
87 if (status != 0) {
88 (*info->memory_error_func)(status, memaddr + 2, info);
89 return -1;
90 }
91
92 if (info->endian == BFD_ENDIAN_BIG) {
93 insn2 = bfd_getb16(buffer);
94 } else {
95 insn2 = bfd_getl16(buffer);
96 }
97 (*info->fprintf_func)(info->stream, "%04x ", insn2);
98 } else {
99 (*info->fprintf_func)(info->stream, " ");
100 }
101 /* Handle 48-bit opcodes. */
102 if ((insn1 >> 10) == 0x18) {
103 status = (*info->read_memory_func)(memaddr + 4, buffer, 2, info);
104 if (status != 0) {
105 (*info->memory_error_func)(status, memaddr + 4, info);
106 return -1;
107 }
108
109 if (info->endian == BFD_ENDIAN_BIG) {
110 insn3 = bfd_getb16(buffer);
111 } else {
112 insn3 = bfd_getl16(buffer);
113 }
114 (*info->fprintf_func)(info->stream, "%04x ", insn3);
115 } else {
116 (*info->fprintf_func)(info->stream, " ");
117 }
118
119 int length = nanomips_dis(buf, memaddr, insn1, insn2, insn3);
120
121 /* FIXME: Should probably use a hash table on the major opcode here. */
122
123 (*info->fprintf_func) (info->stream, "%s", buf);
124 if (length > 0) {
125 return length / 8;
126 }
127
128 info->insn_type = dis_noninsn;
129
130 return insn3 ? 6 : insn2 ? 4 : 2;
131 }
132
133
134 namespace img
135 {
136 address addr32(address a)
137 {
138 return a;
139 }
140
141 std::string format(const char *format, ...)
142 {
143 char buffer[256];
144 va_list args;
145 va_start(args, format);
146 int err = vsprintf(buffer, format, args);
147 if (err < 0) {
148 perror(buffer);
149 }
150 va_end(args);
151 return buffer;
152 }
153
154 std::string format(const char *format,
155 std::string s)
156 {
157 char buffer[256];
158
159 sprintf(buffer, format, s.c_str());
160
161 return buffer;
162 }
163
164 std::string format(const char *format,
165 std::string s1,
166 std::string s2)
167 {
168 char buffer[256];
169
170 sprintf(buffer, format, s1.c_str(), s2.c_str());
171
172 return buffer;
173 }
174
175 std::string format(const char *format,
176 std::string s1,
177 std::string s2,
178 std::string s3)
179 {
180 char buffer[256];
181
182 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str());
183
184 return buffer;
185 }
186
187 std::string format(const char *format,
188 std::string s1,
189 std::string s2,
190 std::string s3,
191 std::string s4)
192 {
193 char buffer[256];
194
195 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
196 s4.c_str());
197
198 return buffer;
199 }
200
201 std::string format(const char *format,
202 std::string s1,
203 std::string s2,
204 std::string s3,
205 std::string s4,
206 std::string s5)
207 {
208 char buffer[256];
209
210 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
211 s4.c_str(), s5.c_str());
212
213 return buffer;
214 }
215
216 std::string format(const char *format,
217 uint64 d,
218 std::string s2)
219 {
220 char buffer[256];
221
222 sprintf(buffer, format, d, s2.c_str());
223
224 return buffer;
225 }
226
227 std::string format(const char *format,
228 std::string s1,
229 uint64 d,
230 std::string s2)
231 {
232 char buffer[256];
233
234 sprintf(buffer, format, s1.c_str(), d, s2.c_str());
235
236 return buffer;
237 }
238
239 std::string format(const char *format,
240 std::string s1,
241 std::string s2,
242 uint64 d)
243 {
244 char buffer[256];
245
246 sprintf(buffer, format, s1.c_str(), s2.c_str(), d);
247
248 return buffer;
249 }
250
251 char as_char(int c)
252 {
253 return static_cast<char>(c);
254 }
255 };
256
257
258 std::string to_string(img::address a)
259 {
260 char buffer[256];
261 sprintf(buffer, "0x%" PRIx64, a);
262 return buffer;
263 }
264
265
266 uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
267 {
268 return (data << (64 - (bit_size + bit_offset))) >> (64 - bit_size);
269 }
270
271
272 int64 sign_extend(int64 data, int msb)
273 {
274 uint64 shift = 63 - msb;
275 return (data << shift) >> shift;
276 }
277
278
279 uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
280 size_t register_list_size)
281 {
282 if (index < register_list_size) {
283 return register_list[index];
284 }
285
286 throw std::runtime_error(img::format(
287 "Invalid register mapping index %" PRIu64
288 ", size of list = %zu",
289 index, register_list_size));
290 }
291
292
293 /*
294 * these functions should be decode functions but the json does not have
295 * decode sections so they are based on the encode, the equivalent decode
296 * functions need writing eventually.
297 */
298 uint64 NMD::encode_gpr3(uint64 d)
299 {
300 static uint64 register_list[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
301 return renumber_registers(d, register_list,
302 sizeof(register_list) / sizeof(register_list[0]));
303 }
304
305
306 uint64 NMD::encode_gpr3_store(uint64 d)
307 {
308 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
309 return renumber_registers(d, register_list,
310 sizeof(register_list) / sizeof(register_list[0]));
311 }
312
313
314 uint64 NMD::encode_rd1_from_rd(uint64 d)
315 {
316 static uint64 register_list[] = { 4, 5 };
317 return renumber_registers(d, register_list,
318 sizeof(register_list) / sizeof(register_list[0]));
319 }
320
321
322 uint64 NMD::encode_gpr4_zero(uint64 d)
323 {
324 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
325 16, 17, 18, 19, 20, 21, 22, 23 };
326 return renumber_registers(d, register_list,
327 sizeof(register_list) / sizeof(register_list[0]));
328 }
329
330
331 uint64 NMD::encode_gpr4(uint64 d)
332 {
333 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
334 16, 17, 18, 19, 20, 21, 22, 23 };
335 return renumber_registers(d, register_list,
336 sizeof(register_list) / sizeof(register_list[0]));
337 }
338
339
340 uint64 NMD::encode_rd2_reg1(uint64 d)
341 {
342 static uint64 register_list[] = { 4, 5, 6, 7 };
343 return renumber_registers(d, register_list,
344 sizeof(register_list) / sizeof(register_list[0]));
345 }
346
347
348 uint64 NMD::encode_rd2_reg2(uint64 d)
349 {
350 static uint64 register_list[] = { 5, 6, 7, 8 };
351 return renumber_registers(d, register_list,
352 sizeof(register_list) / sizeof(register_list[0]));
353 }
354
355
356 uint64 NMD::copy(uint64 d)
357 {
358 return d;
359 }
360
361
362 int64 NMD::copy(int64 d)
363 {
364 return d;
365 }
366
367
368 int64 NMD::neg_copy(uint64 d)
369 {
370 return 0ll - d;
371 }
372
373
374 int64 NMD::neg_copy(int64 d)
375 {
376 return -d;
377 }
378
379
380 /* strange wrapper around gpr3 */
381 uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
382 {
383 return encode_gpr3(d);
384 }
385
386
387 /* strange wrapper around gpr3 */
388 uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
389 {
390 return encode_gpr3(d);
391 }
392
393
394 /* nop - done by extraction function */
395 uint64 NMD::encode_s_from_address(uint64 d)
396 {
397 return d;
398 }
399
400
401 /* nop - done by extraction function */
402 uint64 NMD::encode_u_from_address(uint64 d)
403 {
404 return d;
405 }
406
407
408 /* nop - done by extraction function */
409 uint64 NMD::encode_s_from_s_hi(uint64 d)
410 {
411 return d;
412 }
413
414
415 uint64 NMD::encode_count3_from_count(uint64 d)
416 {
417 IMGASSERTONCE(d < 8);
418 return d == 0ull ? 8ull : d;
419 }
420
421
422 uint64 NMD::encode_shift3_from_shift(uint64 d)
423 {
424 IMGASSERTONCE(d < 8);
425 return d == 0ull ? 8ull : d;
426 }
427
428
429 /* special value for load literal */
430 int64 NMD::encode_eu_from_s_li16(uint64 d)
431 {
432 IMGASSERTONCE(d < 128);
433 return d == 127 ? -1 : (int64)d;
434 }
435
436
437 uint64 NMD::encode_msbd_from_size(uint64 d)
438 {
439 IMGASSERTONCE(d < 32);
440 return d + 1;
441 }
442
443
444 uint64 NMD::encode_eu_from_u_andi16(uint64 d)
445 {
446 IMGASSERTONCE(d < 16);
447 if (d == 12) {
448 return 0x00ffull;
449 }
450 if (d == 13) {
451 return 0xffffull;
452 }
453 return d;
454 }
455
456
457 uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
458 {
459 IMGASSERTONCE(0);
460 return d;
461 }
462
463
464 /* save16 / restore16 ???? */
465 uint64 NMD::encode_rt1_from_rt(uint64 d)
466 {
467 return d ? 31 : 30;
468 }
469
470
471 /* ? */
472 uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
473 {
474 return d;
475 }
476
477
478 std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
479 {
480 std::string str;
481
482 for (uint64 counter = 0; counter != count; counter++) {
483 bool use_gp = gp && (counter == count - 1);
484 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
485 str += img::format(",%s", GPR(this_rt));
486 }
487
488 return str;
489 }
490
491
492 std::string NMD::GPR(uint64 reg)
493 {
494 static const char *gpr_reg[32] = {
495 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
496 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
497 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
498 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
499 };
500
501 if (reg < 32) {
502 return gpr_reg[reg];
503 }
504
505 throw std::runtime_error(img::format("Invalid GPR register index %" PRIu64,
506 reg));
507 }
508
509
510 std::string NMD::FPR(uint64 reg)
511 {
512 static const char *fpr_reg[32] = {
513 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
514 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
515 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
516 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
517 };
518
519 if (reg < 32) {
520 return fpr_reg[reg];
521 }
522
523 throw std::runtime_error(img::format("Invalid FPR register index %" PRIu64,
524 reg));
525 }
526
527
528 std::string NMD::AC(uint64 reg)
529 {
530 static const char *ac_reg[4] = {
531 "ac0", "ac1", "ac2", "ac3"
532 };
533
534 if (reg < 4) {
535 return ac_reg[reg];
536 }
537
538 throw std::runtime_error(img::format("Invalid AC register index %" PRIu64,
539 reg));
540 }
541
542
543 std::string NMD::IMMEDIATE(uint64 value)
544 {
545 return img::format("0x%" PRIx64, value);
546 }
547
548
549 std::string NMD::IMMEDIATE(int64 value)
550 {
551 return img::format("%" PRId64, value);
552 }
553
554
555 std::string NMD::CPR(uint64 reg)
556 {
557 /* needs more work */
558 return img::format("CP%" PRIu64, reg);
559 }
560
561
562 std::string NMD::ADDRESS(uint64 value, int instruction_size)
563 {
564 /* token for string replace */
565 /* const char TOKEN_REPLACE = (char)0xa2; */
566 img::address address = m_pc + value + instruction_size;
567 /* symbol replacement */
568 /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
569 return to_string(address);
570 }
571
572
573 uint64 NMD::extract_op_code_value(const uint16 * data, int size)
574 {
575 switch (size) {
576 case 16:
577 return data[0];
578 case 32:
579 return ((uint64)data[0] << 16) | data[1];
580 case 48:
581 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
582 default:
583 return data[0];
584 }
585 }
586
587
588 int NMD::Disassemble(const uint16 * data, std::string & dis,
589 NMD::TABLE_ENTRY_TYPE & type)
590 {
591 return Disassemble(data, dis, type, MAJOR, 2);
592 }
593
594
595 /*
596 * Recurse through tables until the instruction is found then return
597 * the string and size
598 *
599 * inputs:
600 * pointer to a word stream,
601 * disassember table and size
602 * returns:
603 * instruction size - negative is error
604 * disassembly string - on error will constain error string
605 */
606 int NMD::Disassemble(const uint16 * data, std::string & dis,
607 NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
608 int table_size)
609 {
610 try
611 {
612 for (int i = 0; i < table_size; i++) {
613 uint64 op_code = extract_op_code_value(data,
614 table[i].instructions_size);
615 if ((op_code & table[i].mask) == table[i].value) {
616 /* possible match */
617 conditional_function cond = table[i].condition;
618 if ((cond == 0) || (this->*cond)(op_code)) {
619 try
620 {
621 if (table[i].type == pool) {
622 return Disassemble(data, dis, type,
623 table[i].next_table,
624 table[i].next_table_size);
625 } else if ((table[i].type == instruction) ||
626 (table[i].type == call_instruction) ||
627 (table[i].type == branch_instruction) ||
628 (table[i].type == return_instruction)) {
629 if ((table[i].attributes != 0) &&
630 (m_requested_instruction_categories &
631 table[i].attributes) == 0) {
632 /*
633 * failed due to instruction having
634 * an ASE attribute and the requested version
635 * not having that attribute
636 */
637 dis = "ASE attribute missmatch";
638 return -5;
639 }
640 disassembly_function dis_fn = table[i].disassembly;
641 if (dis_fn == 0) {
642 dis = "disassembler failure - bad table entry";
643 return -6;
644 }
645 type = table[i].type;
646 dis = (this->*dis_fn)(op_code);
647 return table[i].instructions_size;
648 } else {
649 dis = "reserved instruction";
650 return -2;
651 }
652 }
653 catch (std::runtime_error & e)
654 {
655 dis = e.what();
656 return -3; /* runtime error */
657 }
658 }
659 }
660 }
661 }
662 catch (std::exception & e)
663 {
664 dis = e.what();
665 return -4; /* runtime error */
666 }
667
668 dis = "failed to disassemble";
669 return -1; /* failed to disassemble */
670 }
671
672
673 uint64 NMD::extract_code_18_to_0(uint64 instruction)
674 {
675 uint64 value = 0;
676 value |= extract_bits(instruction, 0, 19);
677 return value;
678 }
679
680
681 uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
682 {
683 uint64 value = 0;
684 value |= extract_bits(instruction, 0, 3);
685 return value;
686 }
687
688
689 uint64 NMD::extr_uil3il3bs9Fmsb11(uint64 instruction)
690 {
691 uint64 value = 0;
692 value |= extract_bits(instruction, 3, 9) << 3;
693 return value;
694 }
695
696
697 uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
698 {
699 uint64 value = 0;
700 value |= extract_bits(instruction, 0, 4);
701 return value;
702 }
703
704
705 uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
706 {
707 uint64 value = 0;
708 value |= extract_bits(instruction, 7, 3);
709 return value;
710 }
711
712
713 uint64 NMD::extr_uil1il1bs17Fmsb17(uint64 instruction)
714 {
715 uint64 value = 0;
716 value |= extract_bits(instruction, 1, 17) << 1;
717 return value;
718 }
719
720
721 int64 NMD::extr_sil11il0bs10Tmsb9(uint64 instruction)
722 {
723 int64 value = 0;
724 value |= extract_bits(instruction, 11, 10);
725 value = sign_extend(value, 9);
726 return value;
727 }
728
729
730 int64 NMD::extr_sil0il11bs1_il1il1bs10Tmsb11(uint64 instruction)
731 {
732 int64 value = 0;
733 value |= extract_bits(instruction, 0, 1) << 11;
734 value |= extract_bits(instruction, 1, 10) << 1;
735 value = sign_extend(value, 11);
736 return value;
737 }
738
739
740 uint64 NMD::extract_u_10(uint64 instruction)
741 {
742 uint64 value = 0;
743 value |= extract_bits(instruction, 10, 1);
744 return value;
745 }
746
747
748 uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
749 {
750 uint64 value = 0;
751 value |= extract_bits(instruction, 21, 3);
752 value |= extract_bits(instruction, 25, 1) << 3;
753 return value;
754 }
755
756
757 uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
758 {
759 uint64 value = 0;
760 value |= extract_bits(instruction, 11, 5);
761 return value;
762 }
763
764
765 uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
766 {
767 uint64 value = 0;
768 value |= extract_bits(instruction, 0, 5);
769 return value;
770 }
771
772
773 uint64 NMD::extr_shiftxil7il1bs4Fmsb4(uint64 instruction)
774 {
775 uint64 value = 0;
776 value |= extract_bits(instruction, 7, 4) << 1;
777 return value;
778 }
779
780
781 uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
782 {
783 uint64 value = 0;
784 value |= extract_bits(instruction, 21, 5);
785 return value;
786 }
787
788
789 uint64 NMD::extract_count3_14_13_12(uint64 instruction)
790 {
791 uint64 value = 0;
792 value |= extract_bits(instruction, 12, 3);
793 return value;
794 }
795
796
797 int64 NMD::extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(uint64 instruction)
798 {
799 int64 value = 0;
800 value |= extract_bits(instruction, 0, 1) << 31;
801 value |= extract_bits(instruction, 2, 10) << 21;
802 value |= extract_bits(instruction, 12, 9) << 12;
803 value = sign_extend(value, 31);
804 return value;
805 }
806
807
808 int64 NMD::extr_sil0il7bs1_il1il1bs6Tmsb7(uint64 instruction)
809 {
810 int64 value = 0;
811 value |= extract_bits(instruction, 0, 1) << 7;
812 value |= extract_bits(instruction, 1, 6) << 1;
813 value = sign_extend(value, 7);
814 return value;
815 }
816
817
818 uint64 NMD::extract_u2_10_9(uint64 instruction)
819 {
820 uint64 value = 0;
821 value |= extract_bits(instruction, 9, 2);
822 return value;
823 }
824
825
826 uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
827 {
828 uint64 value = 0;
829 value |= extract_bits(instruction, 16, 10);
830 return value;
831 }
832
833
834 uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
835 {
836 uint64 value = 0;
837 value |= extract_bits(instruction, 16, 5);
838 return value;
839 }
840
841
842 uint64 NMD::extr_uil1il1bs2Fmsb2(uint64 instruction)
843 {
844 uint64 value = 0;
845 value |= extract_bits(instruction, 1, 2) << 1;
846 return value;
847 }
848
849
850 uint64 NMD::extract_stripe_6(uint64 instruction)
851 {
852 uint64 value = 0;
853 value |= extract_bits(instruction, 6, 1);
854 return value;
855 }
856
857
858 uint64 NMD::extr_xil17il0bs1Fmsb0(uint64 instruction)
859 {
860 uint64 value = 0;
861 value |= extract_bits(instruction, 17, 1);
862 return value;
863 }
864
865
866 uint64 NMD::extr_xil2il0bs1_il15il0bs1Fmsb0(uint64 instruction)
867 {
868 uint64 value = 0;
869 value |= extract_bits(instruction, 2, 1);
870 value |= extract_bits(instruction, 15, 1);
871 return value;
872 }
873
874
875 uint64 NMD::extract_ac_13_12(uint64 instruction)
876 {
877 uint64 value = 0;
878 value |= extract_bits(instruction, 14, 2);
879 return value;
880 }
881
882
883 uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
884 {
885 uint64 value = 0;
886 value |= extract_bits(instruction, 16, 5);
887 return value;
888 }
889
890
891 uint64 NMD::extract_rdl_25_24(uint64 instruction)
892 {
893 uint64 value = 0;
894 value |= extract_bits(instruction, 24, 1);
895 return value;
896 }
897
898
899 int64 NMD::extr_sil0il10bs1_il1il1bs9Tmsb10(uint64 instruction)
900 {
901 int64 value = 0;
902 value |= extract_bits(instruction, 0, 1) << 10;
903 value |= extract_bits(instruction, 1, 9) << 1;
904 value = sign_extend(value, 10);
905 return value;
906 }
907
908
909 uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
910 {
911 uint64 value = 0;
912 value |= extract_bits(instruction, 0, 7);
913 return value;
914 }
915
916
917 uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
918 {
919 uint64 value = 0;
920 value |= extract_bits(instruction, 0, 6);
921 return value;
922 }
923
924
925 uint64 NMD::extr_xil10il0bs6Fmsb5(uint64 instruction)
926 {
927 uint64 value = 0;
928 value |= extract_bits(instruction, 10, 6);
929 return value;
930 }
931
932
933 uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
934 {
935 uint64 value = 0;
936 value |= extract_bits(instruction, 16, 4);
937 return value;
938 }
939
940
941 uint64 NMD::extract_code_2_1_0(uint64 instruction)
942 {
943 uint64 value = 0;
944 value |= extract_bits(instruction, 0, 3);
945 return value;
946 }
947
948
949 uint64 NMD::extr_xil10il0bs4_il22il0bs4Fmsb3(uint64 instruction)
950 {
951 uint64 value = 0;
952 value |= extract_bits(instruction, 10, 4);
953 value |= extract_bits(instruction, 22, 4);
954 return value;
955 }
956
957
958 uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
959 {
960 uint64 value = 0;
961 value |= extract_bits(instruction, 0, 12);
962 return value;
963 }
964
965
966 uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
967 {
968 uint64 value = 0;
969 value |= extract_bits(instruction, 0, 5);
970 return value;
971 }
972
973
974 uint64 NMD::extr_uil3il3bs18Fmsb20(uint64 instruction)
975 {
976 uint64 value = 0;
977 value |= extract_bits(instruction, 3, 18) << 3;
978 return value;
979 }
980
981
982 uint64 NMD::extr_xil12il0bs1Fmsb0(uint64 instruction)
983 {
984 uint64 value = 0;
985 value |= extract_bits(instruction, 12, 1);
986 return value;
987 }
988
989
990 uint64 NMD::extr_uil0il2bs4Fmsb5(uint64 instruction)
991 {
992 uint64 value = 0;
993 value |= extract_bits(instruction, 0, 4) << 2;
994 return value;
995 }
996
997
998 uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
999 {
1000 uint64 value = 0;
1001 value |= extract_bits(instruction, 3, 23);
1002 return value;
1003 }
1004
1005
1006 uint64 NMD::extr_uil0il2bs3Fmsb4(uint64 instruction)
1007 {
1008 uint64 value = 0;
1009 value |= extract_bits(instruction, 0, 3) << 2;
1010 return value;
1011 }
1012
1013
1014 uint64 NMD::extr_xil10il0bs1Fmsb0(uint64 instruction)
1015 {
1016 uint64 value = 0;
1017 value |= extract_bits(instruction, 10, 1);
1018 return value;
1019 }
1020
1021
1022 uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
1023 {
1024 uint64 value = 0;
1025 value |= extract_bits(instruction, 1, 3);
1026 return value;
1027 }
1028
1029
1030 uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
1031 {
1032 uint64 value = 0;
1033 value |= extract_bits(instruction, 12, 4);
1034 return value;
1035 }
1036
1037
1038 uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
1039 {
1040 uint64 value = 0;
1041 value |= extract_bits(instruction, 21, 5);
1042 return value;
1043 }
1044
1045
1046 uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
1047 {
1048 uint64 value = 0;
1049 value |= extract_bits(instruction, 3, 5);
1050 return value;
1051 }
1052
1053
1054 uint64 NMD::extr_xil21il0bs5Fmsb4(uint64 instruction)
1055 {
1056 uint64 value = 0;
1057 value |= extract_bits(instruction, 21, 5);
1058 return value;
1059 }
1060
1061
1062 uint64 NMD::extr_xil9il0bs3Fmsb2(uint64 instruction)
1063 {
1064 uint64 value = 0;
1065 value |= extract_bits(instruction, 9, 3);
1066 return value;
1067 }
1068
1069
1070 uint64 NMD::extract_u_17_to_0(uint64 instruction)
1071 {
1072 uint64 value = 0;
1073 value |= extract_bits(instruction, 0, 18);
1074 return value;
1075 }
1076
1077
1078 uint64 NMD::extr_xil14il0bs1_il15il0bs1Fmsb0(uint64 instruction)
1079 {
1080 uint64 value = 0;
1081 value |= extract_bits(instruction, 14, 1);
1082 value |= extract_bits(instruction, 15, 1);
1083 return value;
1084 }
1085
1086
1087 uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
1088 {
1089 uint64 value = 0;
1090 value |= extract_bits(instruction, 0, 3);
1091 value |= extract_bits(instruction, 4, 1) << 3;
1092 return value;
1093 }
1094
1095
1096 uint64 NMD::extr_xil24il0bs1Fmsb0(uint64 instruction)
1097 {
1098 uint64 value = 0;
1099 value |= extract_bits(instruction, 24, 1);
1100 return value;
1101 }
1102
1103
1104 int64 NMD::extr_sil0il21bs1_il1il1bs20Tmsb21(uint64 instruction)
1105 {
1106 int64 value = 0;
1107 value |= extract_bits(instruction, 0, 1) << 21;
1108 value |= extract_bits(instruction, 1, 20) << 1;
1109 value = sign_extend(value, 21);
1110 return value;
1111 }
1112
1113
1114 uint64 NMD::extract_op_25_to_3(uint64 instruction)
1115 {
1116 uint64 value = 0;
1117 value |= extract_bits(instruction, 3, 23);
1118 return value;
1119 }
1120
1121
1122 uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
1123 {
1124 uint64 value = 0;
1125 value |= extract_bits(instruction, 0, 3);
1126 value |= extract_bits(instruction, 4, 1) << 3;
1127 return value;
1128 }
1129
1130
1131 uint64 NMD::extract_bit_23_22_21(uint64 instruction)
1132 {
1133 uint64 value = 0;
1134 value |= extract_bits(instruction, 21, 3);
1135 return value;
1136 }
1137
1138
1139 uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
1140 {
1141 uint64 value = 0;
1142 value |= extract_bits(instruction, 37, 5);
1143 return value;
1144 }
1145
1146
1147 int64 NMD::extract_shift_21_20_19_18_17_16(uint64 instruction)
1148 {
1149 int64 value = 0;
1150 value |= extract_bits(instruction, 16, 6);
1151 value = sign_extend(value, 5);
1152 return value;
1153 }
1154
1155
1156 uint64 NMD::extr_xil6il0bs3_il10il0bs1Fmsb2(uint64 instruction)
1157 {
1158 uint64 value = 0;
1159 value |= extract_bits(instruction, 6, 3);
1160 value |= extract_bits(instruction, 10, 1);
1161 return value;
1162 }
1163
1164
1165 uint64 NMD::extract_rd2_3_8(uint64 instruction)
1166 {
1167 uint64 value = 0;
1168 value |= extract_bits(instruction, 3, 1) << 1;
1169 value |= extract_bits(instruction, 8, 1);
1170 return value;
1171 }
1172
1173
1174 uint64 NMD::extr_xil16il0bs5Fmsb4(uint64 instruction)
1175 {
1176 uint64 value = 0;
1177 value |= extract_bits(instruction, 16, 5);
1178 return value;
1179 }
1180
1181
1182 uint64 NMD::extract_code_17_to_0(uint64 instruction)
1183 {
1184 uint64 value = 0;
1185 value |= extract_bits(instruction, 0, 18);
1186 return value;
1187 }
1188
1189
1190 uint64 NMD::extr_xil0il0bs12Fmsb11(uint64 instruction)
1191 {
1192 uint64 value = 0;
1193 value |= extract_bits(instruction, 0, 12);
1194 return value;
1195 }
1196
1197
1198 uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
1199 {
1200 uint64 value = 0;
1201 value |= extract_bits(instruction, 16, 5);
1202 return value;
1203 }
1204
1205
1206 int64 NMD::extr_sil2il2bs6_il15il8bs1Tmsb8(uint64 instruction)
1207 {
1208 int64 value = 0;
1209 value |= extract_bits(instruction, 2, 6) << 2;
1210 value |= extract_bits(instruction, 15, 1) << 8;
1211 value = sign_extend(value, 8);
1212 return value;
1213 }
1214
1215
1216 uint64 NMD::extract_u_15_to_0(uint64 instruction)
1217 {
1218 uint64 value = 0;
1219 value |= extract_bits(instruction, 0, 16);
1220 return value;
1221 }
1222
1223
1224 uint64 NMD::extract_fs_15_14_13_12_11(uint64 instruction)
1225 {
1226 uint64 value = 0;
1227 value |= extract_bits(instruction, 16, 5);
1228 return value;
1229 }
1230
1231
1232 int64 NMD::extr_sil0il0bs8_il15il8bs1Tmsb8(uint64 instruction)
1233 {
1234 int64 value = 0;
1235 value |= extract_bits(instruction, 0, 8);
1236 value |= extract_bits(instruction, 15, 1) << 8;
1237 value = sign_extend(value, 8);
1238 return value;
1239 }
1240
1241
1242 uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
1243 {
1244 uint64 value = 0;
1245 value |= extract_bits(instruction, 16, 5);
1246 return value;
1247 }
1248
1249
1250 uint64 NMD::extract_rtl_11(uint64 instruction)
1251 {
1252 uint64 value = 0;
1253 value |= extract_bits(instruction, 9, 1);
1254 return value;
1255 }
1256
1257
1258 uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
1259 {
1260 uint64 value = 0;
1261 value |= extract_bits(instruction, 16, 5);
1262 return value;
1263 }
1264
1265
1266 uint64 NMD::extr_xil10il0bs1_il14il0bs2Fmsb1(uint64 instruction)
1267 {
1268 uint64 value = 0;
1269 value |= extract_bits(instruction, 10, 1);
1270 value |= extract_bits(instruction, 14, 2);
1271 return value;
1272 }
1273
1274
1275 uint64 NMD::extract_sel_13_12_11(uint64 instruction)
1276 {
1277 uint64 value = 0;
1278 value |= extract_bits(instruction, 11, 3);
1279 return value;
1280 }
1281
1282
1283 uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
1284 {
1285 uint64 value = 0;
1286 value |= extract_bits(instruction, 0, 5);
1287 return value;
1288 }
1289
1290
1291 uint64 NMD::extr_xil14il0bs2Fmsb1(uint64 instruction)
1292 {
1293 uint64 value = 0;
1294 value |= extract_bits(instruction, 14, 2);
1295 return value;
1296 }
1297
1298
1299 uint64 NMD::extract_gp_2(uint64 instruction)
1300 {
1301 uint64 value = 0;
1302 value |= extract_bits(instruction, 2, 1);
1303 return value;
1304 }
1305
1306
1307 uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
1308 {
1309 uint64 value = 0;
1310 value |= extract_bits(instruction, 7, 3);
1311 return value;
1312 }
1313
1314
1315 uint64 NMD::extract_ft_20_19_18_17_16(uint64 instruction)
1316 {
1317 uint64 value = 0;
1318 value |= extract_bits(instruction, 21, 5);
1319 return value;
1320 }
1321
1322
1323 uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
1324 {
1325 uint64 value = 0;
1326 value |= extract_bits(instruction, 11, 7);
1327 return value;
1328 }
1329
1330
1331 uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
1332 {
1333 uint64 value = 0;
1334 value |= extract_bits(instruction, 16, 5);
1335 return value;
1336 }
1337
1338
1339 uint64 NMD::extr_xil16il0bs10Fmsb9(uint64 instruction)
1340 {
1341 uint64 value = 0;
1342 value |= extract_bits(instruction, 16, 10);
1343 return value;
1344 }
1345
1346
1347 uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
1348 {
1349 uint64 value = 0;
1350 value |= extract_bits(instruction, 5, 3);
1351 value |= extract_bits(instruction, 9, 1) << 3;
1352 return value;
1353 }
1354
1355
1356 uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
1357 {
1358 uint64 value = 0;
1359 value |= extract_bits(instruction, 6, 5);
1360 return value;
1361 }
1362
1363
1364 uint64 NMD::extr_uil0il2bs6Fmsb7(uint64 instruction)
1365 {
1366 uint64 value = 0;
1367 value |= extract_bits(instruction, 0, 6) << 2;
1368 return value;
1369 }
1370
1371
1372 uint64 NMD::extr_xil17il0bs9Fmsb8(uint64 instruction)
1373 {
1374 uint64 value = 0;
1375 value |= extract_bits(instruction, 17, 9);
1376 return value;
1377 }
1378
1379
1380 uint64 NMD::extract_sa_15_14_13(uint64 instruction)
1381 {
1382 uint64 value = 0;
1383 value |= extract_bits(instruction, 13, 3);
1384 return value;
1385 }
1386
1387
1388 int64 NMD::extr_sil0il14bs1_il1il1bs13Tmsb14(uint64 instruction)
1389 {
1390 int64 value = 0;
1391 value |= extract_bits(instruction, 0, 1) << 14;
1392 value |= extract_bits(instruction, 1, 13) << 1;
1393 value = sign_extend(value, 14);
1394 return value;
1395 }
1396
1397
1398 uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
1399 {
1400 uint64 value = 0;
1401 value |= extract_bits(instruction, 4, 3);
1402 return value;
1403 }
1404
1405
1406 uint64 NMD::extr_uil0il32bs32Fmsb63(uint64 instruction)
1407 {
1408 uint64 value = 0;
1409 value |= extract_bits(instruction, 0, 32) << 32;
1410 return value;
1411 }
1412
1413
1414 uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
1415 {
1416 uint64 value = 0;
1417 value |= extract_bits(instruction, 6, 5);
1418 return value;
1419 }
1420
1421
1422 uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
1423 {
1424 uint64 value = 0;
1425 value |= extract_bits(instruction, 21, 5);
1426 return value;
1427 }
1428
1429
1430 uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1431 {
1432 uint64 value = 0;
1433 value |= extract_bits(instruction, 6, 6);
1434 return value;
1435 }
1436
1437
1438 uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
1439 {
1440 uint64 value = 0;
1441 value |= extract_bits(instruction, 5, 5);
1442 return value;
1443 }
1444
1445
1446 uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
1447 {
1448 uint64 value = 0;
1449 value |= extract_bits(instruction, 21, 5);
1450 return value;
1451 }
1452
1453
1454 uint64 NMD::extr_uil0il2bs7Fmsb8(uint64 instruction)
1455 {
1456 uint64 value = 0;
1457 value |= extract_bits(instruction, 0, 7) << 2;
1458 return value;
1459 }
1460
1461
1462 uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
1463 {
1464 uint64 value = 0;
1465 value |= extract_bits(instruction, 11, 6);
1466 return value;
1467 }
1468
1469
1470 uint64 NMD::extr_xil10il0bs1_il11il0bs5Fmsb4(uint64 instruction)
1471 {
1472 uint64 value = 0;
1473 value |= extract_bits(instruction, 10, 1);
1474 value |= extract_bits(instruction, 11, 5);
1475 return value;
1476 }
1477
1478
1479 uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1480 {
1481 uint64 value = 0;
1482 value |= extract_bits(instruction, 14, 7);
1483 return value;
1484 }
1485
1486
1487 uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
1488 {
1489 uint64 value = 0;
1490 value |= extract_bits(instruction, 0, 4);
1491 return value;
1492 }
1493
1494
1495 uint64 NMD::extr_uil4il4bs4Fmsb7(uint64 instruction)
1496 {
1497 uint64 value = 0;
1498 value |= extract_bits(instruction, 4, 4) << 4;
1499 return value;
1500 }
1501
1502
1503 int64 NMD::extr_sil3il3bs5_il15il8bs1Tmsb8(uint64 instruction)
1504 {
1505 int64 value = 0;
1506 value |= extract_bits(instruction, 3, 5) << 3;
1507 value |= extract_bits(instruction, 15, 1) << 8;
1508 value = sign_extend(value, 8);
1509 return value;
1510 }
1511
1512
1513 uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
1514 {
1515 uint64 value = 0;
1516 value |= extract_bits(instruction, 11, 5);
1517 return value;
1518 }
1519
1520
1521 int64 NMD::extr_sil0il16bs16_il16il0bs16Tmsb31(uint64 instruction)
1522 {
1523 int64 value = 0;
1524 value |= extract_bits(instruction, 0, 16) << 16;
1525 value |= extract_bits(instruction, 16, 16);
1526 value = sign_extend(value, 31);
1527 return value;
1528 }
1529
1530
1531 uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1532 {
1533 uint64 value = 0;
1534 value |= extract_bits(instruction, 13, 8);
1535 return value;
1536 }
1537
1538
1539 uint64 NMD::extr_xil15il0bs1Fmsb0(uint64 instruction)
1540 {
1541 uint64 value = 0;
1542 value |= extract_bits(instruction, 15, 1);
1543 return value;
1544 }
1545
1546
1547 uint64 NMD::extr_xil11il0bs5Fmsb4(uint64 instruction)
1548 {
1549 uint64 value = 0;
1550 value |= extract_bits(instruction, 11, 5);
1551 return value;
1552 }
1553
1554
1555 uint64 NMD::extr_uil2il2bs16Fmsb17(uint64 instruction)
1556 {
1557 uint64 value = 0;
1558 value |= extract_bits(instruction, 2, 16) << 2;
1559 return value;
1560 }
1561
1562
1563 uint64 NMD::extract_rd_20_19_18_17_16(uint64 instruction)
1564 {
1565 uint64 value = 0;
1566 value |= extract_bits(instruction, 11, 5);
1567 return value;
1568 }
1569
1570
1571 uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
1572 {
1573 uint64 value = 0;
1574 value |= extract_bits(instruction, 16, 5);
1575 return value;
1576 }
1577
1578
1579 uint64 NMD::extract_code_1_0(uint64 instruction)
1580 {
1581 uint64 value = 0;
1582 value |= extract_bits(instruction, 0, 2);
1583 return value;
1584 }
1585
1586
1587 int64 NMD::extr_sil0il25bs1_il1il1bs24Tmsb25(uint64 instruction)
1588 {
1589 int64 value = 0;
1590 value |= extract_bits(instruction, 0, 1) << 25;
1591 value |= extract_bits(instruction, 1, 24) << 1;
1592 value = sign_extend(value, 25);
1593 return value;
1594 }
1595
1596
1597 uint64 NMD::extr_xil0il0bs3_il4il0bs1Fmsb2(uint64 instruction)
1598 {
1599 uint64 value = 0;
1600 value |= extract_bits(instruction, 0, 3);
1601 value |= extract_bits(instruction, 4, 1);
1602 return value;
1603 }
1604
1605
1606 uint64 NMD::extract_u_1_0(uint64 instruction)
1607 {
1608 uint64 value = 0;
1609 value |= extract_bits(instruction, 0, 2);
1610 return value;
1611 }
1612
1613
1614 uint64 NMD::extr_uil3il3bs1_il8il2bs1Fmsb3(uint64 instruction)
1615 {
1616 uint64 value = 0;
1617 value |= extract_bits(instruction, 3, 1) << 3;
1618 value |= extract_bits(instruction, 8, 1) << 2;
1619 return value;
1620 }
1621
1622
1623 uint64 NMD::extr_xil9il0bs3_il16il0bs5Fmsb4(uint64 instruction)
1624 {
1625 uint64 value = 0;
1626 value |= extract_bits(instruction, 9, 3);
1627 value |= extract_bits(instruction, 16, 5);
1628 return value;
1629 }
1630
1631
1632 uint64 NMD::extract_fd_10_9_8_7_6(uint64 instruction)
1633 {
1634 uint64 value = 0;
1635 value |= extract_bits(instruction, 11, 5);
1636 return value;
1637 }
1638
1639
1640 uint64 NMD::extr_xil6il0bs3Fmsb2(uint64 instruction)
1641 {
1642 uint64 value = 0;
1643 value |= extract_bits(instruction, 6, 3);
1644 return value;
1645 }
1646
1647
1648 uint64 NMD::extr_uil0il2bs5Fmsb6(uint64 instruction)
1649 {
1650 uint64 value = 0;
1651 value |= extract_bits(instruction, 0, 5) << 2;
1652 return value;
1653 }
1654
1655
1656 uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
1657 {
1658 uint64 value = 0;
1659 value |= extract_bits(instruction, 5, 3);
1660 value |= extract_bits(instruction, 9, 1) << 3;
1661 return value;
1662 }
1663
1664
1665 uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
1666 {
1667 uint64 value = 0;
1668 value |= extract_bits(instruction, 11, 5);
1669 return value;
1670 }
1671
1672
1673 uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
1674 {
1675 uint64 value = 0;
1676 value |= extract_bits(instruction, 21, 5);
1677 return value;
1678 }
1679
1680
1681 uint64 NMD::extr_xil11il0bs1Fmsb0(uint64 instruction)
1682 {
1683 uint64 value = 0;
1684 value |= extract_bits(instruction, 11, 1);
1685 return value;
1686 }
1687
1688
1689 uint64 NMD::extr_uil2il2bs19Fmsb20(uint64 instruction)
1690 {
1691 uint64 value = 0;
1692 value |= extract_bits(instruction, 2, 19) << 2;
1693 return value;
1694 }
1695
1696
1697 int64 NMD::extract_s_4_2_1_0(uint64 instruction)
1698 {
1699 int64 value = 0;
1700 value |= extract_bits(instruction, 0, 3);
1701 value |= extract_bits(instruction, 4, 1) << 3;
1702 value = sign_extend(value, 3);
1703 return value;
1704 }
1705
1706
1707 uint64 NMD::extr_uil0il1bs4Fmsb4(uint64 instruction)
1708 {
1709 uint64 value = 0;
1710 value |= extract_bits(instruction, 0, 4) << 1;
1711 return value;
1712 }
1713
1714
1715 uint64 NMD::extr_xil9il0bs2Fmsb1(uint64 instruction)
1716 {
1717 uint64 value = 0;
1718 value |= extract_bits(instruction, 9, 2);
1719 return value;
1720 }
1721
1722
1723
1724 bool NMD::ADDIU_32__cond(uint64 instruction)
1725 {
1726 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1727 return rt != 0;
1728 }
1729
1730
1731 bool NMD::ADDIU_RS5__cond(uint64 instruction)
1732 {
1733 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1734 return rt != 0;
1735 }
1736
1737
1738 bool NMD::BALRSC_cond(uint64 instruction)
1739 {
1740 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1741 return rt != 0;
1742 }
1743
1744
1745 bool NMD::BEQC_16__cond(uint64 instruction)
1746 {
1747 uint64 rs3 = extract_rs3_6_5_4(instruction);
1748 uint64 rt3 = extract_rt3_9_8_7(instruction);
1749 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1750 return rs3 < rt3 && u != 0;
1751 }
1752
1753
1754 bool NMD::BNEC_16__cond(uint64 instruction)
1755 {
1756 uint64 rs3 = extract_rs3_6_5_4(instruction);
1757 uint64 rt3 = extract_rt3_9_8_7(instruction);
1758 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1759 return rs3 >= rt3 && u != 0;
1760 }
1761
1762
1763 bool NMD::MOVE_cond(uint64 instruction)
1764 {
1765 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1766 return rt != 0;
1767 }
1768
1769
1770 bool NMD::P16_BR1_cond(uint64 instruction)
1771 {
1772 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1773 return u != 0;
1774 }
1775
1776
1777 bool NMD::PREF_S9__cond(uint64 instruction)
1778 {
1779 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1780 return hint != 31;
1781 }
1782
1783
1784 bool NMD::PREFE_cond(uint64 instruction)
1785 {
1786 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1787 return hint != 31;
1788 }
1789
1790
1791 bool NMD::SLTU_cond(uint64 instruction)
1792 {
1793 uint64 rd = extract_rd_20_19_18_17_16(instruction);
1794 return rd != 0;
1795 }
1796
1797
1798
1799 /*
1800 * ABS.D fd, fs - Floating Point Absolute Value
1801 *
1802 * 3 2 1
1803 * 10987654321098765432109876543210
1804 * 010001 00000 000101
1805 * fmt -----
1806 * fs -----
1807 * fd -----
1808 */
1809 std::string NMD::ABS_D(uint64 instruction)
1810 {
1811 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1812 uint64 fd_value = extract_ft_20_19_18_17_16(instruction);
1813
1814 std::string fs = FPR(copy(fs_value));
1815 std::string fd = FPR(copy(fd_value));
1816
1817 return img::format("ABS.D %s, %s", fd, fs);
1818 }
1819
1820
1821 /*
1822 * ABS.S fd, fs - Floating Point Absolute Value
1823 *
1824 * 3 2 1
1825 * 10987654321098765432109876543210
1826 * 010001 00000 000101
1827 * fmt -----
1828 * fd -----
1829 * fs -----
1830 */
1831 std::string NMD::ABS_S(uint64 instruction)
1832 {
1833 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1834 uint64 fd_value = extract_ft_20_19_18_17_16(instruction);
1835
1836 std::string fs = FPR(copy(fs_value));
1837 std::string fd = FPR(copy(fd_value));
1838
1839 return img::format("ABS.S %s, %s", fd, fs);
1840 }
1841
1842
1843 /*
1844 * ABSQ_S.PH rt, rs - Find Absolute Value of Two Fractional Halfwords
1845 *
1846 * 3 2 1
1847 * 10987654321098765432109876543210
1848 * 001000 0001000100111111
1849 * rt -----
1850 * rs -----
1851 */
1852 std::string NMD::ABSQ_S_PH(uint64 instruction)
1853 {
1854 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1855 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1856
1857 std::string rt = GPR(copy(rt_value));
1858 std::string rs = GPR(copy(rs_value));
1859
1860 return img::format("ABSQ_S.PH %s, %s", rt, rs);
1861 }
1862
1863
1864 /*
1865 * ABSQ_S.QB rt, rs - Find Absolute Value of Four Fractional Byte Values
1866 *
1867 * 3 2 1
1868 * 10987654321098765432109876543210
1869 * 001000 0000000100111111
1870 * rt -----
1871 * rs -----
1872 */
1873 std::string NMD::ABSQ_S_QB(uint64 instruction)
1874 {
1875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1876 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1877
1878 std::string rt = GPR(copy(rt_value));
1879 std::string rs = GPR(copy(rs_value));
1880
1881 return img::format("ABSQ_S.QB %s, %s", rt, rs);
1882 }
1883
1884
1885 /*
1886 *
1887 *
1888 * 3 2 1
1889 * 10987654321098765432109876543210
1890 * 001000 0010000100111111
1891 * rt -----
1892 * rs -----
1893 */
1894 std::string NMD::ABSQ_S_W(uint64 instruction)
1895 {
1896 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1897 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1898
1899 std::string rt = GPR(copy(rt_value));
1900 std::string rs = GPR(copy(rs_value));
1901
1902 return img::format("ABSQ_S.W %s, %s", rt, rs);
1903 }
1904
1905
1906 /*
1907 *
1908 *
1909 * 3 2 1
1910 * 10987654321098765432109876543210
1911 * 001000 0010000100111111
1912 * rt -----
1913 * rs -----
1914 */
1915 std::string NMD::ACLR(uint64 instruction)
1916 {
1917 uint64 bit_value = extract_bit_23_22_21(instruction);
1918 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
1919 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1920
1921 std::string bit = IMMEDIATE(copy(bit_value));
1922 std::string s = IMMEDIATE(copy(s_value));
1923 std::string rs = GPR(copy(rs_value));
1924
1925 return img::format("ACLR %s, %s(%s)", bit, s, rs);
1926 }
1927
1928
1929 /*
1930 *
1931 *
1932 * 3 2 1
1933 * 10987654321098765432109876543210
1934 * 001000 0010000100111111
1935 * rt -----
1936 * rs -----
1937 */
1938 std::string NMD::ADD(uint64 instruction)
1939 {
1940 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1941 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
1942 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1943
1944 std::string rd = GPR(copy(rd_value));
1945 std::string rs = GPR(copy(rs_value));
1946 std::string rt = GPR(copy(rt_value));
1947
1948 return img::format("ADD %s, %s, %s", rd, rs, rt);
1949 }
1950
1951
1952 /*
1953 * ADD.D fd, fs, ft - Floating Point Add
1954 *
1955 * 3 2 1
1956 * 10987654321098765432109876543210
1957 * 010001 000101
1958 * fmt -----
1959 * ft -----
1960 * fs -----
1961 * fd -----
1962 */
1963 std::string NMD::ADD_D(uint64 instruction)
1964 {
1965 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
1966 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1967 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
1968
1969 std::string ft = FPR(copy(ft_value));
1970 std::string fs = FPR(copy(fs_value));
1971 std::string fd = FPR(copy(fd_value));
1972
1973 return img::format("ADD.D %s, %s, %s", fd, fs, ft);
1974 }
1975
1976
1977 /*
1978 * ADD.S fd, fs, ft - Floating Point Add
1979 *
1980 * 3 2 1
1981 * 10987654321098765432109876543210
1982 * 010001 000101
1983 * fmt -----
1984 * ft -----
1985 * fs -----
1986 * fd -----
1987 */
1988 std::string NMD::ADD_S(uint64 instruction)
1989 {
1990 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
1991 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1992 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
1993
1994 std::string ft = FPR(copy(ft_value));
1995 std::string fs = FPR(copy(fs_value));
1996 std::string fd = FPR(copy(fd_value));
1997
1998 return img::format("ADD.S %s, %s, %s", fd, fs, ft);
1999 }
2000
2001
2002 /*
2003 *
2004 *
2005 * 3 2 1
2006 * 10987654321098765432109876543210
2007 * 001000 0010000100111111
2008 * rt -----
2009 * rs -----
2010 */
2011 std::string NMD::ADDIU_32_(uint64 instruction)
2012 {
2013 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2014 uint64 u_value = extract_u_15_to_0(instruction);
2015 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2016
2017 std::string rt = GPR(copy(rt_value));
2018 std::string rs = GPR(copy(rs_value));
2019 std::string u = IMMEDIATE(copy(u_value));
2020
2021 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2022 }
2023
2024
2025 /*
2026 *
2027 *
2028 * 3 2 1
2029 * 10987654321098765432109876543210
2030 * 001000 0010000100111111
2031 * rt -----
2032 * rs -----
2033 */
2034 std::string NMD::ADDIU_48_(uint64 instruction)
2035 {
2036 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2037 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2038
2039 std::string rt = GPR(copy(rt_value));
2040 std::string s = IMMEDIATE(copy(s_value));
2041
2042 return img::format("ADDIU %s, %s", rt, s);
2043 }
2044
2045
2046 /*
2047 *
2048 *
2049 * 3 2 1
2050 * 10987654321098765432109876543210
2051 * 001000 0010000100111111
2052 * rt -----
2053 * rs -----
2054 */
2055 std::string NMD::ADDIU_GP48_(uint64 instruction)
2056 {
2057 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2058 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2059
2060 std::string rt = GPR(copy(rt_value));
2061 std::string s = IMMEDIATE(copy(s_value));
2062
2063 return img::format("ADDIU %s, $%d, %s", rt, 28, s);
2064 }
2065
2066
2067 /*
2068 *
2069 *
2070 * 3 2 1
2071 * 10987654321098765432109876543210
2072 * 001000 0010000100111111
2073 * rt -----
2074 * rs -----
2075 */
2076 std::string NMD::ADDIU_GP_B_(uint64 instruction)
2077 {
2078 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2079 uint64 u_value = extract_u_17_to_0(instruction);
2080
2081 std::string rt = GPR(copy(rt_value));
2082 std::string u = IMMEDIATE(copy(u_value));
2083
2084 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2085 }
2086
2087
2088 /*
2089 *
2090 *
2091 * 3 2 1
2092 * 10987654321098765432109876543210
2093 * 001000 0010000100111111
2094 * rt -----
2095 * rs -----
2096 */
2097 std::string NMD::ADDIU_GP_W_(uint64 instruction)
2098 {
2099 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2100 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
2101
2102 std::string rt = GPR(copy(rt_value));
2103 std::string u = IMMEDIATE(copy(u_value));
2104
2105 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2106 }
2107
2108
2109 /*
2110 *
2111 *
2112 * 3 2 1
2113 * 10987654321098765432109876543210
2114 * 001000 0010000100111111
2115 * rt -----
2116 * rs -----
2117 */
2118 std::string NMD::ADDIU_NEG_(uint64 instruction)
2119 {
2120 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2121 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2122 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2123
2124 std::string rt = GPR(copy(rt_value));
2125 std::string rs = GPR(copy(rs_value));
2126 std::string u = IMMEDIATE(neg_copy(u_value));
2127
2128 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2129 }
2130
2131
2132 /*
2133 *
2134 *
2135 * 3 2 1
2136 * 10987654321098765432109876543210
2137 * 001000 0010000100111111
2138 * rt -----
2139 * rs -----
2140 */
2141 std::string NMD::ADDIU_R1_SP_(uint64 instruction)
2142 {
2143 uint64 u_value = extr_uil0il2bs6Fmsb7(instruction);
2144 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2145
2146 std::string rt3 = GPR(encode_gpr3(rt3_value));
2147 std::string u = IMMEDIATE(copy(u_value));
2148
2149 return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
2150 }
2151
2152
2153 /*
2154 *
2155 *
2156 * 3 2 1
2157 * 10987654321098765432109876543210
2158 * 001000 0010000100111111
2159 * rt -----
2160 * rs -----
2161 */
2162 std::string NMD::ADDIU_R2_(uint64 instruction)
2163 {
2164 uint64 u_value = extr_uil0il2bs3Fmsb4(instruction);
2165 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2166 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2167
2168 std::string rt3 = GPR(encode_gpr3(rt3_value));
2169 std::string rs3 = GPR(encode_gpr3(rs3_value));
2170 std::string u = IMMEDIATE(copy(u_value));
2171
2172 return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
2173 }
2174
2175
2176 /*
2177 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
2178 *
2179 * 5432109876543210
2180 * 100100 1
2181 * rt -----
2182 * s - ---
2183 */
2184 std::string NMD::ADDIU_RS5_(uint64 instruction)
2185 {
2186 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
2187 int64 s_value = extract_s_4_2_1_0(instruction);
2188
2189 std::string rt = GPR(copy(rt_value));
2190 std::string s = IMMEDIATE(copy(s_value));
2191
2192 return img::format("ADDIU %s, %s", rt, s);
2193 }
2194
2195
2196 /*
2197 *
2198 *
2199 * 3 2 1
2200 * 10987654321098765432109876543210
2201 * 001000 x1110000101
2202 * rt -----
2203 * rs -----
2204 * rd -----
2205 */
2206 std::string NMD::ADDIUPC_32_(uint64 instruction)
2207 {
2208 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2209 int64 s_value = extr_sil0il21bs1_il1il1bs20Tmsb21(instruction);
2210
2211 std::string rt = GPR(copy(rt_value));
2212 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2213
2214 return img::format("ADDIUPC %s, %s", rt, s);
2215 }
2216
2217
2218 /*
2219 *
2220 *
2221 * 3 2 1
2222 * 10987654321098765432109876543210
2223 * 001000 x1110000101
2224 * rt -----
2225 * rs -----
2226 * rd -----
2227 */
2228 std::string NMD::ADDIUPC_48_(uint64 instruction)
2229 {
2230 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2231 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2232
2233 std::string rt = GPR(copy(rt_value));
2234 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
2235
2236 return img::format("ADDIUPC %s, %s", rt, s);
2237 }
2238
2239
2240 /*
2241 * ADDQ.PH rd, rt, rs - Add Fractional Halfword Vectors
2242 *
2243 * 3 2 1
2244 * 10987654321098765432109876543210
2245 * 001000 00000001101
2246 * rt -----
2247 * rs -----
2248 * rd -----
2249 */
2250 std::string NMD::ADDQ_PH(uint64 instruction)
2251 {
2252 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2253 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2254 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2255
2256 std::string rd = GPR(copy(rd_value));
2257 std::string rs = GPR(copy(rs_value));
2258 std::string rt = GPR(copy(rt_value));
2259
2260 return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
2261 }
2262
2263
2264 /*
2265 * ADDQ_S.PH rd, rt, rs - Add Fractional Halfword Vectors
2266 *
2267 * 3 2 1
2268 * 10987654321098765432109876543210
2269 * 001000 10000001101
2270 * rt -----
2271 * rs -----
2272 * rd -----
2273 */
2274 std::string NMD::ADDQ_S_PH(uint64 instruction)
2275 {
2276 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2277 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2278 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2279
2280 std::string rd = GPR(copy(rd_value));
2281 std::string rs = GPR(copy(rs_value));
2282 std::string rt = GPR(copy(rt_value));
2283
2284 return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
2285 }
2286
2287
2288 /*
2289 * ADDQ_S.W rd, rt, rs - Add Fractional Words
2290 *
2291 * 3 2 1
2292 * 10987654321098765432109876543210
2293 * 001000 x1100000101
2294 * rt -----
2295 * rs -----
2296 * rd -----
2297 */
2298 std::string NMD::ADDQ_S_W(uint64 instruction)
2299 {
2300 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2301 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2302 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2303
2304 std::string rd = GPR(copy(rd_value));
2305 std::string rs = GPR(copy(rs_value));
2306 std::string rt = GPR(copy(rt_value));
2307
2308 return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2309 }
2310
2311
2312 /*
2313 * ADDQH.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2314 * to Halve Results
2315 *
2316 * 3 2 1
2317 * 10987654321098765432109876543210
2318 * 001000 00001001101
2319 * rt -----
2320 * rs -----
2321 * rd -----
2322 */
2323 std::string NMD::ADDQH_PH(uint64 instruction)
2324 {
2325 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2326 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2327 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2328
2329 std::string rd = GPR(copy(rd_value));
2330 std::string rs = GPR(copy(rs_value));
2331 std::string rt = GPR(copy(rt_value));
2332
2333 return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2334 }
2335
2336
2337 /*
2338 * ADDQH_R.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2339 * to Halve Results
2340 *
2341 * 3 2 1
2342 * 10987654321098765432109876543210
2343 * 001000 10001001101
2344 * rt -----
2345 * rs -----
2346 * rd -----
2347 */
2348 std::string NMD::ADDQH_R_PH(uint64 instruction)
2349 {
2350 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2351 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2352 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2353
2354 std::string rd = GPR(copy(rd_value));
2355 std::string rs = GPR(copy(rs_value));
2356 std::string rt = GPR(copy(rt_value));
2357
2358 return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2359 }
2360
2361
2362 /*
2363 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2364 *
2365 * 3 2 1
2366 * 10987654321098765432109876543210
2367 * 001000 00010001101
2368 * rt -----
2369 * rs -----
2370 * rd -----
2371 */
2372 std::string NMD::ADDQH_R_W(uint64 instruction)
2373 {
2374 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2375 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2376 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2377
2378 std::string rd = GPR(copy(rd_value));
2379 std::string rs = GPR(copy(rs_value));
2380 std::string rt = GPR(copy(rt_value));
2381
2382 return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2383 }
2384
2385
2386 /*
2387 * ADDQH.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2388 *
2389 * 3 2 1
2390 * 10987654321098765432109876543210
2391 * 001000 10010001101
2392 * rt -----
2393 * rs -----
2394 * rd -----
2395 */
2396 std::string NMD::ADDQH_W(uint64 instruction)
2397 {
2398 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2399 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2400 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2401
2402 std::string rd = GPR(copy(rd_value));
2403 std::string rs = GPR(copy(rs_value));
2404 std::string rt = GPR(copy(rt_value));
2405
2406 return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
2407 }
2408
2409
2410 /*
2411 * ADDSC rd, rt, rs - Add Signed Word and Set Carry Bit
2412 *
2413 * 3 2 1
2414 * 10987654321098765432109876543210
2415 * 001000 x1110000101
2416 * rt -----
2417 * rs -----
2418 * rd -----
2419 */
2420 std::string NMD::ADDSC(uint64 instruction)
2421 {
2422 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2423 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2424 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2425
2426 std::string rd = GPR(copy(rd_value));
2427 std::string rs = GPR(copy(rs_value));
2428 std::string rt = GPR(copy(rt_value));
2429
2430 return img::format("ADDSC %s, %s, %s", rd, rs, rt);
2431 }
2432
2433
2434 /*
2435 * ADDU[16] rd3, rs3, rt3 -
2436 *
2437 * 5432109876543210
2438 * 101100 0
2439 * rt3 ---
2440 * rs3 ---
2441 * rd3 ---
2442 */
2443 std::string NMD::ADDU_16_(uint64 instruction)
2444 {
2445 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2446 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2447 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2448
2449 std::string rt3 = GPR(encode_gpr3(rt3_value));
2450 std::string rs3 = GPR(encode_gpr3(rs3_value));
2451 std::string rd3 = GPR(encode_gpr3(rd3_value));
2452
2453 return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
2454 }
2455
2456
2457 /*
2458 *
2459 *
2460 * 3 2 1
2461 * 10987654321098765432109876543210
2462 * 001000 x1110000101
2463 * rt -----
2464 * rs -----
2465 * rd -----
2466 */
2467 std::string NMD::ADDU_32_(uint64 instruction)
2468 {
2469 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2470 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2471 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2472
2473 std::string rd = GPR(copy(rd_value));
2474 std::string rs = GPR(copy(rs_value));
2475 std::string rt = GPR(copy(rt_value));
2476
2477 return img::format("ADDU %s, %s, %s", rd, rs, rt);
2478 }
2479
2480
2481 /*
2482 *
2483 *
2484 * 3 2 1
2485 * 10987654321098765432109876543210
2486 * 001000 x1110000101
2487 * rt -----
2488 * rs -----
2489 * rd -----
2490 */
2491 std::string NMD::ADDU_4X4_(uint64 instruction)
2492 {
2493 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2494 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2495
2496 std::string rs4 = GPR(encode_gpr4(rs4_value));
2497 std::string rt4 = GPR(encode_gpr4(rt4_value));
2498
2499 return img::format("ADDU %s, %s", rs4, rt4);
2500 }
2501
2502
2503 /*
2504 * ADDU.PH rd, rt, rs - Unsigned Add Integer Halfwords
2505 *
2506 * 3 2 1
2507 * 10987654321098765432109876543210
2508 * 001000 00100001101
2509 * rt -----
2510 * rs -----
2511 * rd -----
2512 */
2513 std::string NMD::ADDU_PH(uint64 instruction)
2514 {
2515 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2516 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2517 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2518
2519 std::string rd = GPR(copy(rd_value));
2520 std::string rs = GPR(copy(rs_value));
2521 std::string rt = GPR(copy(rt_value));
2522
2523 return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
2524 }
2525
2526
2527 /*
2528 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2529 *
2530 * 3 2 1
2531 * 10987654321098765432109876543210
2532 * 001000 00011001101
2533 * rt -----
2534 * rs -----
2535 * rd -----
2536 */
2537 std::string NMD::ADDU_QB(uint64 instruction)
2538 {
2539 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2540 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2541 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2542
2543 std::string rd = GPR(copy(rd_value));
2544 std::string rs = GPR(copy(rs_value));
2545 std::string rt = GPR(copy(rt_value));
2546
2547 return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
2548 }
2549
2550
2551 /*
2552 * ADDU_S.PH rd, rt, rs - Unsigned Add Integer Halfwords
2553 *
2554 * 3 2 1
2555 * 10987654321098765432109876543210
2556 * 001000 10100001101
2557 * rt -----
2558 * rs -----
2559 * rd -----
2560 */
2561 std::string NMD::ADDU_S_PH(uint64 instruction)
2562 {
2563 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2564 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2565 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2566
2567 std::string rd = GPR(copy(rd_value));
2568 std::string rs = GPR(copy(rs_value));
2569 std::string rt = GPR(copy(rt_value));
2570
2571 return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2572 }
2573
2574
2575 /*
2576 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2577 *
2578 * 3 2 1
2579 * 10987654321098765432109876543210
2580 * 001000 10011001101
2581 * rt -----
2582 * rs -----
2583 * rd -----
2584 */
2585 std::string NMD::ADDU_S_QB(uint64 instruction)
2586 {
2587 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2588 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2589 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2590
2591 std::string rd = GPR(copy(rd_value));
2592 std::string rs = GPR(copy(rs_value));
2593 std::string rt = GPR(copy(rt_value));
2594
2595 return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2596 }
2597
2598
2599 /*
2600 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2601 * to Halve Results
2602 *
2603 * 3 2 1
2604 * 10987654321098765432109876543210
2605 * 001000 00101001101
2606 * rt -----
2607 * rs -----
2608 * rd -----
2609 */
2610 std::string NMD::ADDUH_QB(uint64 instruction)
2611 {
2612 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2613 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2614 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2615
2616 std::string rd = GPR(copy(rd_value));
2617 std::string rs = GPR(copy(rs_value));
2618 std::string rt = GPR(copy(rt_value));
2619
2620 return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2621 }
2622
2623
2624 /*
2625 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2626 * to Halve Results
2627 *
2628 * 3 2 1
2629 * 10987654321098765432109876543210
2630 * 001000 10101001101
2631 * rt -----
2632 * rs -----
2633 * rd -----
2634 */
2635 std::string NMD::ADDUH_R_QB(uint64 instruction)
2636 {
2637 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2638 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2639 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2640
2641 std::string rd = GPR(copy(rd_value));
2642 std::string rs = GPR(copy(rs_value));
2643 std::string rt = GPR(copy(rt_value));
2644
2645 return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2646 }
2647
2648 /*
2649 * ADDWC rd, rt, rs - Add Word with Carry Bit
2650 *
2651 * 3 2 1
2652 * 10987654321098765432109876543210
2653 * 001000 x1111000101
2654 * rt -----
2655 * rs -----
2656 * rd -----
2657 */
2658 std::string NMD::ADDWC(uint64 instruction)
2659 {
2660 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2661 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2662 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2663
2664 std::string rd = GPR(copy(rd_value));
2665 std::string rs = GPR(copy(rs_value));
2666 std::string rt = GPR(copy(rt_value));
2667
2668 return img::format("ADDWC %s, %s, %s", rd, rs, rt);
2669 }
2670
2671
2672 /*
2673 *
2674 *
2675 * 3 2 1
2676 * 10987654321098765432109876543210
2677 * 001000 x1110000101
2678 * rt -----
2679 * rs -----
2680 * rd -----
2681 */
2682 std::string NMD::ALUIPC(uint64 instruction)
2683 {
2684 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2685 int64 s_value = extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(instruction);
2686
2687 std::string rt = GPR(copy(rt_value));
2688 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2689
2690 return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2691 }
2692
2693
2694 /*
2695 * AND[16] rt3, rs3 -
2696 *
2697 * 5432109876543210
2698 * 101100
2699 * rt3 ---
2700 * rs3 ---
2701 * eu ----
2702 */
2703 std::string NMD::AND_16_(uint64 instruction)
2704 {
2705 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2706 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2707
2708 std::string rt3 = GPR(encode_gpr3(rt3_value));
2709 std::string rs3 = GPR(encode_gpr3(rs3_value));
2710
2711 return img::format("AND %s, %s", rs3, rt3);
2712 }
2713
2714
2715 /*
2716 *
2717 *
2718 * 3 2 1
2719 * 10987654321098765432109876543210
2720 * 001000 x1110000101
2721 * rt -----
2722 * rs -----
2723 * rd -----
2724 */
2725 std::string NMD::AND_32_(uint64 instruction)
2726 {
2727 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2728 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2729 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2730
2731 std::string rd = GPR(copy(rd_value));
2732 std::string rs = GPR(copy(rs_value));
2733 std::string rt = GPR(copy(rt_value));
2734
2735 return img::format("AND %s, %s, %s", rd, rs, rt);
2736 }
2737
2738
2739 /*
2740 * ANDI rt, rs, u -
2741 *
2742 * 5432109876543210
2743 * 101100
2744 * rt3 ---
2745 * rs3 ---
2746 * eu ----
2747 */
2748 std::string NMD::ANDI_16_(uint64 instruction)
2749 {
2750 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2751 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2752 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2753
2754 std::string rt3 = GPR(encode_gpr3(rt3_value));
2755 std::string rs3 = GPR(encode_gpr3(rs3_value));
2756 std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
2757
2758 return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
2759 }
2760
2761
2762 /*
2763 *
2764 *
2765 * 3 2 1
2766 * 10987654321098765432109876543210
2767 * 001000 x1110000101
2768 * rt -----
2769 * rs -----
2770 * rd -----
2771 */
2772 std::string NMD::ANDI_32_(uint64 instruction)
2773 {
2774 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2775 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2776 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2777
2778 std::string rt = GPR(copy(rt_value));
2779 std::string rs = GPR(copy(rs_value));
2780 std::string u = IMMEDIATE(copy(u_value));
2781
2782 return img::format("ANDI %s, %s, %s", rt, rs, u);
2783 }
2784
2785
2786 /*
2787 *
2788 *
2789 * 3 2 1
2790 * 10987654321098765432109876543210
2791 * 001000 x1110000101
2792 * rt -----
2793 * rs -----
2794 * rd -----
2795 */
2796 std::string NMD::APPEND(uint64 instruction)
2797 {
2798 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2799 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2800 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2801
2802 std::string rt = GPR(copy(rt_value));
2803 std::string rs = GPR(copy(rs_value));
2804 std::string sa = IMMEDIATE(copy(sa_value));
2805
2806 return img::format("APPEND %s, %s, %s", rt, rs, sa);
2807 }
2808
2809
2810 /*
2811 *
2812 *
2813 * 3 2 1
2814 * 10987654321098765432109876543210
2815 * 001000 x1110000101
2816 * rt -----
2817 * rs -----
2818 * rd -----
2819 */
2820 std::string NMD::ASET(uint64 instruction)
2821 {
2822 uint64 bit_value = extract_bit_23_22_21(instruction);
2823 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
2824 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2825
2826 std::string bit = IMMEDIATE(copy(bit_value));
2827 std::string s = IMMEDIATE(copy(s_value));
2828 std::string rs = GPR(copy(rs_value));
2829
2830 return img::format("ASET %s, %s(%s)", bit, s, rs);
2831 }
2832
2833
2834 /*
2835 *
2836 *
2837 * 3 2 1
2838 * 10987654321098765432109876543210
2839 * 001000 x1110000101
2840 * rt -----
2841 * rs -----
2842 * rd -----
2843 */
2844 std::string NMD::BALC_16_(uint64 instruction)
2845 {
2846 int64 s_value = extr_sil0il10bs1_il1il1bs9Tmsb10(instruction);
2847
2848 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2849
2850 return img::format("BALC %s", s);
2851 }
2852
2853
2854 /*
2855 *
2856 *
2857 * 3 2 1
2858 * 10987654321098765432109876543210
2859 * 001000 x1110000101
2860 * rt -----
2861 * rs -----
2862 * rd -----
2863 */
2864 std::string NMD::BALC_32_(uint64 instruction)
2865 {
2866 int64 s_value = extr_sil0il25bs1_il1il1bs24Tmsb25(instruction);
2867
2868 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2869
2870 return img::format("BALC %s", s);
2871 }
2872
2873
2874 /*
2875 *
2876 *
2877 * 3 2 1
2878 * 10987654321098765432109876543210
2879 * 001000 x1110000101
2880 * rt -----
2881 * rs -----
2882 * rd -----
2883 */
2884 std::string NMD::BALRSC(uint64 instruction)
2885 {
2886 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2887 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2888
2889 std::string rt = GPR(copy(rt_value));
2890 std::string rs = GPR(copy(rs_value));
2891
2892 return img::format("BALRSC %s, %s", rt, rs);
2893 }
2894
2895
2896 /*
2897 *
2898 *
2899 * 3 2 1
2900 * 10987654321098765432109876543210
2901 * 001000 x1110000101
2902 * rt -----
2903 * rs -----
2904 * rd -----
2905 */
2906 std::string NMD::BBEQZC(uint64 instruction)
2907 {
2908 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2909 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2910 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
2911
2912 std::string rt = GPR(copy(rt_value));
2913 std::string bit = IMMEDIATE(copy(bit_value));
2914 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2915
2916 return img::format("BBEQZC %s, %s, %s", rt, bit, s);
2917 }
2918
2919
2920 /*
2921 *
2922 *
2923 * 3 2 1
2924 * 10987654321098765432109876543210
2925 * 001000 x1110000101
2926 * rt -----
2927 * rs -----
2928 * rd -----
2929 */
2930 std::string NMD::BBNEZC(uint64 instruction)
2931 {
2932 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2933 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2934 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
2935
2936 std::string rt = GPR(copy(rt_value));
2937 std::string bit = IMMEDIATE(copy(bit_value));
2938 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2939
2940 return img::format("BBNEZC %s, %s, %s", rt, bit, s);
2941 }
2942
2943
2944 /*
2945 *
2946 *
2947 * 3 2 1
2948 * 10987654321098765432109876543210
2949 * 001000 x1110000101
2950 * rt -----
2951 * rs -----
2952 * rd -----
2953 */
2954 std::string NMD::BC_16_(uint64 instruction)
2955 {
2956 int64 s_value = extr_sil0il10bs1_il1il1bs9Tmsb10(instruction);
2957
2958 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2959
2960 return img::format("BC %s", s);
2961 }
2962
2963
2964 /*
2965 *
2966 *
2967 * 3 2 1
2968 * 10987654321098765432109876543210
2969 * 001000 x1110000101
2970 * rt -----
2971 * rs -----
2972 * rd -----
2973 */
2974 std::string NMD::BC_32_(uint64 instruction)
2975 {
2976 int64 s_value = extr_sil0il25bs1_il1il1bs24Tmsb25(instruction);
2977
2978 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2979
2980 return img::format("BC %s", s);
2981 }
2982
2983
2984 /*
2985 *
2986 *
2987 * 3 2 1
2988 * 10987654321098765432109876543210
2989 * 001000 x1110000101
2990 * rt -----
2991 * rs -----
2992 * rd -----
2993 */
2994 std::string NMD::BC1EQZC(uint64 instruction)
2995 {
2996 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
2997 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
2998
2999 std::string ft = FPR(copy(ft_value));
3000 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3001
3002 return img::format("BC1EQZC %s, %s", ft, s);
3003 }
3004
3005
3006 /*
3007 *
3008 *
3009 * 3 2 1
3010 * 10987654321098765432109876543210
3011 * 001000 x1110000101
3012 * rt -----
3013 * rs -----
3014 * rd -----
3015 */
3016 std::string NMD::BC1NEZC(uint64 instruction)
3017 {
3018 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3019 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3020
3021 std::string ft = FPR(copy(ft_value));
3022 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3023
3024 return img::format("BC1NEZC %s, %s", ft, s);
3025 }
3026
3027
3028 /*
3029 *
3030 *
3031 * 3 2 1
3032 * 10987654321098765432109876543210
3033 * 001000 x1110000101
3034 * rt -----
3035 * rs -----
3036 * rd -----
3037 */
3038 std::string NMD::BC2EQZC(uint64 instruction)
3039 {
3040 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3041 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3042
3043 std::string ct = CPR(copy(ct_value));
3044 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3045
3046 return img::format("BC2EQZC %s, %s", ct, s);
3047 }
3048
3049
3050 /*
3051 *
3052 *
3053 * 3 2 1
3054 * 10987654321098765432109876543210
3055 * 001000 x1110000101
3056 * rt -----
3057 * rs -----
3058 * rd -----
3059 */
3060 std::string NMD::BC2NEZC(uint64 instruction)
3061 {
3062 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3063 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3064
3065 std::string ct = CPR(copy(ct_value));
3066 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3067
3068 return img::format("BC2NEZC %s, %s", ct, s);
3069 }
3070
3071
3072 /*
3073 *
3074 *
3075 * 3 2 1
3076 * 10987654321098765432109876543210
3077 * 001000 x1110000101
3078 * rt -----
3079 * rs -----
3080 * rd -----
3081 */
3082 std::string NMD::BEQC_16_(uint64 instruction)
3083 {
3084 uint64 u_value = extr_uil0il1bs4Fmsb4(instruction);
3085 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3086 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3087
3088 std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
3089 std::string rt3 = GPR(encode_gpr3(rt3_value));
3090 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3091
3092 return img::format("BEQC %s, %s, %s", rs3, rt3, u);
3093 }
3094
3095
3096 /*
3097 *
3098 *
3099 * 3 2 1
3100 * 10987654321098765432109876543210
3101 * 001000 x1110000101
3102 * rt -----
3103 * rs -----
3104 * rd -----
3105 */
3106 std::string NMD::BEQC_32_(uint64 instruction)
3107 {
3108 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3109 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3110 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3111
3112 std::string rs = GPR(copy(rs_value));
3113 std::string rt = GPR(copy(rt_value));
3114 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3115
3116 return img::format("BEQC %s, %s, %s", rs, rt, s);
3117 }
3118
3119
3120 /*
3121 *
3122 *
3123 * 3 2 1
3124 * 10987654321098765432109876543210
3125 * 001000 x1110000101
3126 * rt -----
3127 * rs -----
3128 * rd -----
3129 */
3130 std::string NMD::BEQIC(uint64 instruction)
3131 {
3132 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3133 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3134 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3135
3136 std::string rt = GPR(copy(rt_value));
3137 std::string u = IMMEDIATE(copy(u_value));
3138 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3139
3140 return img::format("BEQIC %s, %s, %s", rt, u, s);
3141 }
3142
3143
3144 /*
3145 *
3146 *
3147 * 3 2 1
3148 * 10987654321098765432109876543210
3149 * 001000 x1110000101
3150 * rt -----
3151 * rs -----
3152 * rd -----
3153 */
3154 std::string NMD::BEQZC_16_(uint64 instruction)
3155 {
3156 int64 s_value = extr_sil0il7bs1_il1il1bs6Tmsb7(instruction);
3157 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3158
3159 std::string rt3 = GPR(encode_gpr3(rt3_value));
3160 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3161
3162 return img::format("BEQZC %s, %s", rt3, s);
3163 }
3164
3165
3166 /*
3167 *
3168 *
3169 * 3 2 1
3170 * 10987654321098765432109876543210
3171 * 001000 x1110000101
3172 * rt -----
3173 * rs -----
3174 * rd -----
3175 */
3176 std::string NMD::BGEC(uint64 instruction)
3177 {
3178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3179 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3180 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3181
3182 std::string rs = GPR(copy(rs_value));
3183 std::string rt = GPR(copy(rt_value));
3184 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3185
3186 return img::format("BGEC %s, %s, %s", rs, rt, s);
3187 }
3188
3189
3190 /*
3191 *
3192 *
3193 * 3 2 1
3194 * 10987654321098765432109876543210
3195 * 001000 x1110000101
3196 * rt -----
3197 * rs -----
3198 * rd -----
3199 */
3200 std::string NMD::BGEIC(uint64 instruction)
3201 {
3202 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3203 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3204 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3205
3206 std::string rt = GPR(copy(rt_value));
3207 std::string u = IMMEDIATE(copy(u_value));
3208 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3209
3210 return img::format("BGEIC %s, %s, %s", rt, u, s);
3211 }
3212
3213
3214 /*
3215 *
3216 *
3217 * 3 2 1
3218 * 10987654321098765432109876543210
3219 * 001000 x1110000101
3220 * rt -----
3221 * rs -----
3222 * rd -----
3223 */
3224 std::string NMD::BGEIUC(uint64 instruction)
3225 {
3226 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3227 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3228 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3229
3230 std::string rt = GPR(copy(rt_value));
3231 std::string u = IMMEDIATE(copy(u_value));
3232 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3233
3234 return img::format("BGEIUC %s, %s, %s", rt, u, s);
3235 }
3236
3237
3238 /*
3239 *
3240 *
3241 * 3 2 1
3242 * 10987654321098765432109876543210
3243 * 001000 x1110000101
3244 * rt -----
3245 * rs -----
3246 * rd -----
3247 */
3248 std::string NMD::BGEUC(uint64 instruction)
3249 {
3250 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3251 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3252 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3253
3254 std::string rs = GPR(copy(rs_value));
3255 std::string rt = GPR(copy(rt_value));
3256 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3257
3258 return img::format("BGEUC %s, %s, %s", rs, rt, s);
3259 }
3260
3261
3262 /*
3263 *
3264 *
3265 * 3 2 1
3266 * 10987654321098765432109876543210
3267 * 001000 x1110000101
3268 * rt -----
3269 * rs -----
3270 * rd -----
3271 */
3272 std::string NMD::BLTC(uint64 instruction)
3273 {
3274 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3275 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3276 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3277
3278 std::string rs = GPR(copy(rs_value));
3279 std::string rt = GPR(copy(rt_value));
3280 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3281
3282 return img::format("BLTC %s, %s, %s", rs, rt, s);
3283 }
3284
3285
3286 /*
3287 *
3288 *
3289 * 3 2 1
3290 * 10987654321098765432109876543210
3291 * 001000 x1110000101
3292 * rt -----
3293 * rs -----
3294 * rd -----
3295 */
3296 std::string NMD::BLTIC(uint64 instruction)
3297 {
3298 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3299 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3300 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3301
3302 std::string rt = GPR(copy(rt_value));
3303 std::string u = IMMEDIATE(copy(u_value));
3304 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3305
3306 return img::format("BLTIC %s, %s, %s", rt, u, s);
3307 }
3308
3309
3310 /*
3311 *
3312 *
3313 * 3 2 1
3314 * 10987654321098765432109876543210
3315 * 001000 x1110000101
3316 * rt -----
3317 * rs -----
3318 * rd -----
3319 */
3320 std::string NMD::BLTIUC(uint64 instruction)
3321 {
3322 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3323 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3324 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3325
3326 std::string rt = GPR(copy(rt_value));
3327 std::string u = IMMEDIATE(copy(u_value));
3328 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3329
3330 return img::format("BLTIUC %s, %s, %s", rt, u, s);
3331 }
3332
3333
3334 /*
3335 *
3336 *
3337 * 3 2 1
3338 * 10987654321098765432109876543210
3339 * 001000 x1110000101
3340 * rt -----
3341 * rs -----
3342 * rd -----
3343 */
3344 std::string NMD::BLTUC(uint64 instruction)
3345 {
3346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3347 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3348 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3349
3350 std::string rs = GPR(copy(rs_value));
3351 std::string rt = GPR(copy(rt_value));
3352 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3353
3354 return img::format("BLTUC %s, %s, %s", rs, rt, s);
3355 }
3356
3357
3358 /*
3359 *
3360 *
3361 * 3 2 1
3362 * 10987654321098765432109876543210
3363 * 001000 x1110000101
3364 * rt -----
3365 * rs -----
3366 * rd -----
3367 */
3368 std::string NMD::BNEC_16_(uint64 instruction)
3369 {
3370 uint64 u_value = extr_uil0il1bs4Fmsb4(instruction);
3371 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3372 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3373
3374 std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
3375 std::string rt3 = GPR(encode_gpr3(rt3_value));
3376 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3377
3378 return img::format("BNEC %s, %s, %s", rs3, rt3, u);
3379 }
3380
3381
3382 /*
3383 *
3384 *
3385 * 3 2 1
3386 * 10987654321098765432109876543210
3387 * 001000 x1110000101
3388 * rt -----
3389 * rs -----
3390 * rd -----
3391 */
3392 std::string NMD::BNEC_32_(uint64 instruction)
3393 {
3394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3395 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3397
3398 std::string rs = GPR(copy(rs_value));
3399 std::string rt = GPR(copy(rt_value));
3400 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3401
3402 return img::format("BNEC %s, %s, %s", rs, rt, s);
3403 }
3404
3405
3406 /*
3407 *
3408 *
3409 * 3 2 1
3410 * 10987654321098765432109876543210
3411 * 001000 x1110000101
3412 * rt -----
3413 * rs -----
3414 * rd -----
3415 */
3416 std::string NMD::BNEIC(uint64 instruction)
3417 {
3418 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3419 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3420 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3421
3422 std::string rt = GPR(copy(rt_value));
3423 std::string u = IMMEDIATE(copy(u_value));
3424 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3425
3426 return img::format("BNEIC %s, %s, %s", rt, u, s);
3427 }
3428
3429
3430 /*
3431 *
3432 *
3433 * 3 2 1
3434 * 10987654321098765432109876543210
3435 * 001000 x1110000101
3436 * rt -----
3437 * rs -----
3438 * rd -----
3439 */
3440 std::string NMD::BNEZC_16_(uint64 instruction)
3441 {
3442 int64 s_value = extr_sil0il7bs1_il1il1bs6Tmsb7(instruction);
3443 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3444
3445 std::string rt3 = GPR(encode_gpr3(rt3_value));
3446 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3447
3448 return img::format("BNEZC %s, %s", rt3, s);
3449 }
3450
3451
3452 /*
3453 *
3454 *
3455 * 3 2 1
3456 * 10987654321098765432109876543210
3457 * 001000 x1110000101
3458 * rt -----
3459 * rs -----
3460 * rd -----
3461 */
3462 std::string NMD::BPOSGE32C(uint64 instruction)
3463 {
3464 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3465
3466 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3467
3468 return img::format("BPOSGE32C %s", s);
3469 }
3470
3471
3472 /*
3473 *
3474 *
3475 * 3 2 1
3476 * 10987654321098765432109876543210
3477 * 001000 x1110000101
3478 * rt -----
3479 * rs -----
3480 * rd -----
3481 */
3482 std::string NMD::BREAK_16_(uint64 instruction)
3483 {
3484 uint64 code_value = extract_code_2_1_0(instruction);
3485
3486 std::string code = IMMEDIATE(copy(code_value));
3487
3488 return img::format("BREAK %s", code);
3489 }
3490
3491
3492 /*
3493 * BREAK code - Break. Cause a Breakpoint exception
3494 *
3495 * 3 2 1
3496 * 10987654321098765432109876543210
3497 * 001000 x1110000101
3498 * rt -----
3499 * rs -----
3500 * rd -----
3501 */
3502 std::string NMD::BREAK_32_(uint64 instruction)
3503 {
3504 uint64 code_value = extract_code_18_to_0(instruction);
3505
3506 std::string code = IMMEDIATE(copy(code_value));
3507
3508 return img::format("BREAK %s", code);
3509 }
3510
3511
3512 /*
3513 *
3514 *
3515 * 3 2 1
3516 * 10987654321098765432109876543210
3517 * 001000 x1110000101
3518 * rt -----
3519 * rs -----
3520 * rd -----
3521 */
3522 std::string NMD::BRSC(uint64 instruction)
3523 {
3524 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3525
3526 std::string rs = GPR(copy(rs_value));
3527
3528 return img::format("BRSC %s", rs);
3529 }
3530
3531
3532 /*
3533 *
3534 *
3535 * 3 2 1
3536 * 10987654321098765432109876543210
3537 * 001000 x1110000101
3538 * rt -----
3539 * rs -----
3540 * rd -----
3541 */
3542 std::string NMD::CACHE(uint64 instruction)
3543 {
3544 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
3545 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3546 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3547
3548 std::string op = IMMEDIATE(copy(op_value));
3549 std::string s = IMMEDIATE(copy(s_value));
3550 std::string rs = GPR(copy(rs_value));
3551
3552 return img::format("CACHE %s, %s(%s)", op, s, rs);
3553 }
3554
3555
3556 /*
3557 *
3558 *
3559 * 3 2 1
3560 * 10987654321098765432109876543210
3561 * 001000 x1110000101
3562 * rt -----
3563 * rs -----
3564 * rd -----
3565 */
3566 std::string NMD::CACHEE(uint64 instruction)
3567 {
3568 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
3569 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3570 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3571
3572 std::string op = IMMEDIATE(copy(op_value));
3573 std::string s = IMMEDIATE(copy(s_value));
3574 std::string rs = GPR(copy(rs_value));
3575
3576 return img::format("CACHEE %s, %s(%s)", op, s, rs);
3577 }
3578
3579
3580 /*
3581 *
3582 *
3583 * 3 2 1
3584 * 10987654321098765432109876543210
3585 * 001000 x1110000101
3586 * rt -----
3587 * rs -----
3588 * rd -----
3589 */
3590 std::string NMD::CEIL_L_D(uint64 instruction)
3591 {
3592 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3593 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3594
3595 std::string ft = FPR(copy(ft_value));
3596 std::string fs = FPR(copy(fs_value));
3597
3598 return img::format("CEIL.L.D %s, %s", ft, fs);
3599 }
3600
3601
3602 /*
3603 *
3604 *
3605 * 3 2 1
3606 * 10987654321098765432109876543210
3607 * 001000 x1110000101
3608 * rt -----
3609 * rs -----
3610 * rd -----
3611 */
3612 std::string NMD::CEIL_L_S(uint64 instruction)
3613 {
3614 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3615 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3616
3617 std::string ft = FPR(copy(ft_value));
3618 std::string fs = FPR(copy(fs_value));
3619
3620 return img::format("CEIL.L.S %s, %s", ft, fs);
3621 }
3622
3623
3624 /*
3625 *
3626 *
3627 * 3 2 1
3628 * 10987654321098765432109876543210
3629 * 001000 x1110000101
3630 * rt -----
3631 * rs -----
3632 * rd -----
3633 */
3634 std::string NMD::CEIL_W_D(uint64 instruction)
3635 {
3636 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3637 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3638
3639 std::string ft = FPR(copy(ft_value));
3640 std::string fs = FPR(copy(fs_value));
3641
3642 return img::format("CEIL.W.D %s, %s", ft, fs);
3643 }
3644
3645
3646 /*
3647 *
3648 *
3649 * 3 2 1
3650 * 10987654321098765432109876543210
3651 * 001000 x1110000101
3652 * rt -----
3653 * rs -----
3654 * rd -----
3655 */
3656 std::string NMD::CEIL_W_S(uint64 instruction)
3657 {
3658 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3659 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3660
3661 std::string ft = FPR(copy(ft_value));
3662 std::string fs = FPR(copy(fs_value));
3663
3664 return img::format("CEIL.W.S %s, %s", ft, fs);
3665 }
3666
3667
3668 /*
3669 *
3670 *
3671 * 3 2 1
3672 * 10987654321098765432109876543210
3673 * 001000 x1110000101
3674 * rt -----
3675 * rs -----
3676 * rd -----
3677 */
3678 std::string NMD::CFC1(uint64 instruction)
3679 {
3680 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3681 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3682
3683 std::string rt = GPR(copy(rt_value));
3684 std::string cs = CPR(copy(cs_value));
3685
3686 return img::format("CFC1 %s, %s", rt, cs);
3687 }
3688
3689
3690 /*
3691 *
3692 *
3693 * 3 2 1
3694 * 10987654321098765432109876543210
3695 * 001000 x1110000101
3696 * rt -----
3697 * rs -----
3698 * rd -----
3699 */
3700 std::string NMD::CFC2(uint64 instruction)
3701 {
3702 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3703 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3704
3705 std::string rt = GPR(copy(rt_value));
3706 std::string cs = CPR(copy(cs_value));
3707
3708 return img::format("CFC2 %s, %s", rt, cs);
3709 }
3710
3711
3712 /*
3713 *
3714 *
3715 * 3 2 1
3716 * 10987654321098765432109876543210
3717 * 001000 x1110000101
3718 * rt -----
3719 * rs -----
3720 * rd -----
3721 */
3722 std::string NMD::CLASS_D(uint64 instruction)
3723 {
3724 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3725 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3726
3727 std::string ft = FPR(copy(ft_value));
3728 std::string fs = FPR(copy(fs_value));
3729
3730 return img::format("CLASS.D %s, %s", ft, fs);
3731 }
3732
3733
3734 /*
3735 *
3736 *
3737 * 3 2 1
3738 * 10987654321098765432109876543210
3739 * 001000 x1110000101
3740 * rt -----
3741 * rs -----
3742 * rd -----
3743 */
3744 std::string NMD::CLASS_S(uint64 instruction)
3745 {
3746 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3747 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3748
3749 std::string ft = FPR(copy(ft_value));
3750 std::string fs = FPR(copy(fs_value));
3751
3752 return img::format("CLASS.S %s, %s", ft, fs);
3753 }
3754
3755
3756 /*
3757 *
3758 *
3759 * 3 2 1
3760 * 10987654321098765432109876543210
3761 * 001000 x1110000101
3762 * rt -----
3763 * rs -----
3764 * rd -----
3765 */
3766 std::string NMD::CLO(uint64 instruction)
3767 {
3768 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3769 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3770
3771 std::string rt = GPR(copy(rt_value));
3772 std::string rs = GPR(copy(rs_value));
3773
3774 return img::format("CLO %s, %s", rt, rs);
3775 }
3776
3777
3778 /*
3779 *
3780 *
3781 * 3 2 1
3782 * 10987654321098765432109876543210
3783 * 001000 x1110000101
3784 * rt -----
3785 * rs -----
3786 * rd -----
3787 */
3788 std::string NMD::CLZ(uint64 instruction)
3789 {
3790 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3791 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3792
3793 std::string rt = GPR(copy(rt_value));
3794 std::string rs = GPR(copy(rs_value));
3795
3796 return img::format("CLZ %s, %s", rt, rs);
3797 }
3798
3799
3800 /*
3801 *
3802 *
3803 * 3 2 1
3804 * 10987654321098765432109876543210
3805 * 001000 x1110000101
3806 * rt -----
3807 * rs -----
3808 * rd -----
3809 */
3810 std::string NMD::CMP_AF_D(uint64 instruction)
3811 {
3812 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3813 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3814 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3815
3816 std::string fd = FPR(copy(fd_value));
3817 std::string fs = FPR(copy(fs_value));
3818 std::string ft = FPR(copy(ft_value));
3819
3820 return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3821 }
3822
3823
3824 /*
3825 *
3826 *
3827 * 3 2 1
3828 * 10987654321098765432109876543210
3829 * 001000 x1110000101
3830 * rt -----
3831 * rs -----
3832 * rd -----
3833 */
3834 std::string NMD::CMP_AF_S(uint64 instruction)
3835 {
3836 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3837 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3838 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3839
3840 std::string fd = FPR(copy(fd_value));
3841 std::string fs = FPR(copy(fs_value));
3842 std::string ft = FPR(copy(ft_value));
3843
3844 return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3845 }
3846
3847
3848 /*
3849 *
3850 *
3851 * 3 2 1
3852 * 10987654321098765432109876543210
3853 * 001000 x1110000101
3854 * rt -----
3855 * rs -----
3856 * rd -----
3857 */
3858 std::string NMD::CMP_EQ_D(uint64 instruction)
3859 {
3860 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3861 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3862 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3863
3864 std::string fd = FPR(copy(fd_value));
3865 std::string fs = FPR(copy(fs_value));
3866 std::string ft = FPR(copy(ft_value));
3867
3868 return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3869 }
3870
3871
3872 /*
3873 *
3874 *
3875 * 3 2 1
3876 * 10987654321098765432109876543210
3877 * 001000 x1110000101
3878 * rt -----
3879 * rs -----
3880 * rd -----
3881 */
3882 std::string NMD::CMP_EQ_PH(uint64 instruction)
3883 {
3884 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3885 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3886
3887 std::string rs = GPR(copy(rs_value));
3888 std::string rt = GPR(copy(rt_value));
3889
3890 return img::format("CMP.EQ.PH %s, %s", rs, rt);
3891 }
3892
3893
3894 /*
3895 *
3896 *
3897 * 3 2 1
3898 * 10987654321098765432109876543210
3899 * 001000 x1110000101
3900 * rt -----
3901 * rs -----
3902 * rd -----
3903 */
3904 std::string NMD::CMP_EQ_S(uint64 instruction)
3905 {
3906 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3907 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3908 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3909
3910 std::string fd = FPR(copy(fd_value));
3911 std::string fs = FPR(copy(fs_value));
3912 std::string ft = FPR(copy(ft_value));
3913
3914 return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3915 }
3916
3917
3918 /*
3919 *
3920 *
3921 * 3 2 1
3922 * 10987654321098765432109876543210
3923 * 001000 x1110000101
3924 * rt -----
3925 * rs -----
3926 * rd -----
3927 */
3928 std::string NMD::CMP_LE_D(uint64 instruction)
3929 {
3930 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3931 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3932 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3933
3934 std::string fd = FPR(copy(fd_value));
3935 std::string fs = FPR(copy(fs_value));
3936 std::string ft = FPR(copy(ft_value));
3937
3938 return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3939 }
3940
3941
3942 /*
3943 *
3944 *
3945 * 3 2 1
3946 * 10987654321098765432109876543210
3947 * 001000 x1110000101
3948 * rt -----
3949 * rs -----
3950 * rd -----
3951 */
3952 std::string NMD::CMP_LE_PH(uint64 instruction)
3953 {
3954 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3955 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3956
3957 std::string rs = GPR(copy(rs_value));
3958 std::string rt = GPR(copy(rt_value));
3959
3960 return img::format("CMP.LE.PH %s, %s", rs, rt);
3961 }
3962
3963
3964 /*
3965 *
3966 *
3967 * 3 2 1
3968 * 10987654321098765432109876543210
3969 * 001000 x1110000101
3970 * rt -----
3971 * rs -----
3972 * rd -----
3973 */
3974 std::string NMD::CMP_LE_S(uint64 instruction)
3975 {
3976 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3977 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3978 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3979
3980 std::string fd = FPR(copy(fd_value));
3981 std::string fs = FPR(copy(fs_value));
3982 std::string ft = FPR(copy(ft_value));
3983
3984 return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3985 }
3986
3987
3988 /*
3989 *
3990 *
3991 * 3 2 1
3992 * 10987654321098765432109876543210
3993 * 001000 x1110000101
3994 * rt -----
3995 * rs -----
3996 * rd -----
3997 */
3998 std::string NMD::CMP_LT_D(uint64 instruction)
3999 {
4000 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4001 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4002 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4003
4004 std::string fd = FPR(copy(fd_value));
4005 std::string fs = FPR(copy(fs_value));
4006 std::string ft = FPR(copy(ft_value));
4007
4008 return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
4009 }
4010
4011
4012 /*
4013 *
4014 *
4015 * 3 2 1
4016 * 10987654321098765432109876543210
4017 * 001000 x1110000101
4018 * rt -----
4019 * rs -----
4020 * rd -----
4021 */
4022 std::string NMD::CMP_LT_PH(uint64 instruction)
4023 {
4024 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4025 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4026
4027 std::string rs = GPR(copy(rs_value));
4028 std::string rt = GPR(copy(rt_value));
4029
4030 return img::format("CMP.LT.PH %s, %s", rs, rt);
4031 }
4032
4033
4034 /*
4035 *
4036 *
4037 * 3 2 1
4038 * 10987654321098765432109876543210
4039 * 001000 x1110000101
4040 * rt -----
4041 * rs -----
4042 * rd -----
4043 */
4044 std::string NMD::CMP_LT_S(uint64 instruction)
4045 {
4046 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4047 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4048 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4049
4050 std::string fd = FPR(copy(fd_value));
4051 std::string fs = FPR(copy(fs_value));
4052 std::string ft = FPR(copy(ft_value));
4053
4054 return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
4055 }
4056
4057
4058 /*
4059 *
4060 *
4061 * 3 2 1
4062 * 10987654321098765432109876543210
4063 * 001000 x1110000101
4064 * rt -----
4065 * rs -----
4066 * rd -----
4067 */
4068 std::string NMD::CMP_NE_D(uint64 instruction)
4069 {
4070 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4071 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4072 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4073
4074 std::string fd = FPR(copy(fd_value));
4075 std::string fs = FPR(copy(fs_value));
4076 std::string ft = FPR(copy(ft_value));
4077
4078 return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
4079 }
4080
4081
4082 /*
4083 *
4084 *
4085 * 3 2 1
4086 * 10987654321098765432109876543210
4087 * 001000 x1110000101
4088 * rt -----
4089 * rs -----
4090 * rd -----
4091 */
4092 std::string NMD::CMP_NE_S(uint64 instruction)
4093 {
4094 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4095 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4096 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4097
4098 std::string fd = FPR(copy(fd_value));
4099 std::string fs = FPR(copy(fs_value));
4100 std::string ft = FPR(copy(ft_value));
4101
4102 return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
4103 }
4104
4105
4106 /*
4107 *
4108 *
4109 * 3 2 1
4110 * 10987654321098765432109876543210
4111 * 001000 x1110000101
4112 * rt -----
4113 * rs -----
4114 * rd -----
4115 */
4116 std::string NMD::CMP_OR_D(uint64 instruction)
4117 {
4118 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4119 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4120 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4121
4122 std::string fd = FPR(copy(fd_value));
4123 std::string fs = FPR(copy(fs_value));
4124 std::string ft = FPR(copy(ft_value));
4125
4126 return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
4127 }
4128
4129
4130 /*
4131 *
4132 *
4133 * 3 2 1
4134 * 10987654321098765432109876543210
4135 * 001000 x1110000101
4136 * rt -----
4137 * rs -----
4138 * rd -----
4139 */
4140 std::string NMD::CMP_OR_S(uint64 instruction)
4141 {
4142 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4143 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4144 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4145
4146 std::string fd = FPR(copy(fd_value));
4147 std::string fs = FPR(copy(fs_value));
4148 std::string ft = FPR(copy(ft_value));
4149
4150 return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
4151 }
4152
4153
4154 /*
4155 *
4156 *
4157 * 3 2 1
4158 * 10987654321098765432109876543210
4159 * 001000 x1110000101
4160 * rt -----
4161 * rs -----
4162 * rd -----
4163 */
4164 std::string NMD::CMP_SAF_D(uint64 instruction)
4165 {
4166 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4167 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4168 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4169
4170 std::string fd = FPR(copy(fd_value));
4171 std::string fs = FPR(copy(fs_value));
4172 std::string ft = FPR(copy(ft_value));
4173
4174 return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
4175 }
4176
4177
4178 /*
4179 *
4180 *
4181 * 3 2 1
4182 * 10987654321098765432109876543210
4183 * 001000 x1110000101
4184 * rt -----
4185 * rs -----
4186 * rd -----
4187 */
4188 std::string NMD::CMP_SAF_S(uint64 instruction)
4189 {
4190 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4191 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4192 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4193
4194 std::string fd = FPR(copy(fd_value));
4195 std::string fs = FPR(copy(fs_value));
4196 std::string ft = FPR(copy(ft_value));
4197
4198 return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
4199 }
4200
4201
4202 /*
4203 *
4204 *
4205 * 3 2 1
4206 * 10987654321098765432109876543210
4207 * 001000 x1110000101
4208 * rt -----
4209 * rs -----
4210 * rd -----
4211 */
4212 std::string NMD::CMP_SEQ_D(uint64 instruction)
4213 {
4214 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4215 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4216 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4217
4218 std::string fd = FPR(copy(fd_value));
4219 std::string fs = FPR(copy(fs_value));
4220 std::string ft = FPR(copy(ft_value));
4221
4222 return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
4223 }
4224
4225
4226 /*
4227 *
4228 *
4229 * 3 2 1
4230 * 10987654321098765432109876543210
4231 * 001000 x1110000101
4232 * rt -----
4233 * rs -----
4234 * rd -----
4235 */
4236 std::string NMD::CMP_SEQ_S(uint64 instruction)
4237 {
4238 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4239 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4240 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4241
4242 std::string fd = FPR(copy(fd_value));
4243 std::string fs = FPR(copy(fs_value));
4244 std::string ft = FPR(copy(ft_value));
4245
4246 return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
4247 }
4248
4249
4250 /*
4251 *
4252 *
4253 * 3 2 1
4254 * 10987654321098765432109876543210
4255 * 001000 x1110000101
4256 * rt -----
4257 * rs -----
4258 * rd -----
4259 */
4260 std::string NMD::CMP_SLE_D(uint64 instruction)
4261 {
4262 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4263 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4264 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4265
4266 std::string fd = FPR(copy(fd_value));
4267 std::string fs = FPR(copy(fs_value));
4268 std::string ft = FPR(copy(ft_value));
4269
4270 return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
4271 }
4272
4273
4274 /*
4275 *
4276 *
4277 * 3 2 1
4278 * 10987654321098765432109876543210
4279 * 001000 x1110000101
4280 * rt -----
4281 * rs -----
4282 * rd -----
4283 */
4284 std::string NMD::CMP_SLE_S(uint64 instruction)
4285 {
4286 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4287 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4288 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4289
4290 std::string fd = FPR(copy(fd_value));
4291 std::string fs = FPR(copy(fs_value));
4292 std::string ft = FPR(copy(ft_value));
4293
4294 return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
4295 }
4296
4297
4298 /*
4299 *
4300 *
4301 * 3 2 1
4302 * 10987654321098765432109876543210
4303 * 001000 x1110000101
4304 * rt -----
4305 * rs -----
4306 * rd -----
4307 */
4308 std::string NMD::CMP_SLT_D(uint64 instruction)
4309 {
4310 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4311 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4312 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4313
4314 std::string fd = FPR(copy(fd_value));
4315 std::string fs = FPR(copy(fs_value));
4316 std::string ft = FPR(copy(ft_value));
4317
4318 return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4319 }
4320
4321
4322 /*
4323 *
4324 *
4325 * 3 2 1
4326 * 10987654321098765432109876543210
4327 * 001000 x1110000101
4328 * rt -----
4329 * rs -----
4330 * rd -----
4331 */
4332 std::string NMD::CMP_SLT_S(uint64 instruction)
4333 {
4334 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4335 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4336 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4337
4338 std::string fd = FPR(copy(fd_value));
4339 std::string fs = FPR(copy(fs_value));
4340 std::string ft = FPR(copy(ft_value));
4341
4342 return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4343 }
4344
4345
4346 /*
4347 *
4348 *
4349 * 3 2 1
4350 * 10987654321098765432109876543210
4351 * 001000 x1110000101
4352 * rt -----
4353 * rs -----
4354 * rd -----
4355 */
4356 std::string NMD::CMP_SNE_D(uint64 instruction)
4357 {
4358 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4359 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4360 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4361
4362 std::string fd = FPR(copy(fd_value));
4363 std::string fs = FPR(copy(fs_value));
4364 std::string ft = FPR(copy(ft_value));
4365
4366 return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4367 }
4368
4369
4370 /*
4371 *
4372 *
4373 * 3 2 1
4374 * 10987654321098765432109876543210
4375 * 001000 x1110000101
4376 * rt -----
4377 * rs -----
4378 * rd -----
4379 */
4380 std::string NMD::CMP_SNE_S(uint64 instruction)
4381 {
4382 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4383 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4384 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4385
4386 std::string fd = FPR(copy(fd_value));
4387 std::string fs = FPR(copy(fs_value));
4388 std::string ft = FPR(copy(ft_value));
4389
4390 return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4391 }
4392
4393
4394 /*
4395 *
4396 *
4397 * 3 2 1
4398 * 10987654321098765432109876543210
4399 * 001000 x1110000101
4400 * rt -----
4401 * rs -----
4402 * rd -----
4403 */
4404 std::string NMD::CMP_SOR_D(uint64 instruction)
4405 {
4406 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4407 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4408 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4409
4410 std::string fd = FPR(copy(fd_value));
4411 std::string fs = FPR(copy(fs_value));
4412 std::string ft = FPR(copy(ft_value));
4413
4414 return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4415 }
4416
4417
4418 /*
4419 *
4420 *
4421 * 3 2 1
4422 * 10987654321098765432109876543210
4423 * 001000 x1110000101
4424 * rt -----
4425 * rs -----
4426 * rd -----
4427 */
4428 std::string NMD::CMP_SOR_S(uint64 instruction)
4429 {
4430 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4431 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4432 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4433
4434 std::string fd = FPR(copy(fd_value));
4435 std::string fs = FPR(copy(fs_value));
4436 std::string ft = FPR(copy(ft_value));
4437
4438 return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4439 }
4440
4441
4442 /*
4443 *
4444 *
4445 * 3 2 1
4446 * 10987654321098765432109876543210
4447 * 001000 x1110000101
4448 * rt -----
4449 * rs -----
4450 * rd -----
4451 */
4452 std::string NMD::CMP_SUEQ_D(uint64 instruction)
4453 {
4454 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4455 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4456 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4457
4458 std::string fd = FPR(copy(fd_value));
4459 std::string fs = FPR(copy(fs_value));
4460 std::string ft = FPR(copy(ft_value));
4461
4462 return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4463 }
4464
4465
4466 /*
4467 *
4468 *
4469 * 3 2 1
4470 * 10987654321098765432109876543210
4471 * 001000 x1110000101
4472 * rt -----
4473 * rs -----
4474 * rd -----
4475 */
4476 std::string NMD::CMP_SUEQ_S(uint64 instruction)
4477 {
4478 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4479 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4480 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4481
4482 std::string fd = FPR(copy(fd_value));
4483 std::string fs = FPR(copy(fs_value));
4484 std::string ft = FPR(copy(ft_value));
4485
4486 return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4487 }
4488
4489
4490 /*
4491 *
4492 *
4493 * 3 2 1
4494 * 10987654321098765432109876543210
4495 * 001000 x1110000101
4496 * rt -----
4497 * rs -----
4498 * rd -----
4499 */
4500 std::string NMD::CMP_SULE_D(uint64 instruction)
4501 {
4502 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4503 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4504 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4505
4506 std::string fd = FPR(copy(fd_value));
4507 std::string fs = FPR(copy(fs_value));
4508 std::string ft = FPR(copy(ft_value));
4509
4510 return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4511 }
4512
4513
4514 /*
4515 *
4516 *
4517 * 3 2 1
4518 * 10987654321098765432109876543210
4519 * 001000 x1110000101
4520 * rt -----
4521 * rs -----
4522 * rd -----
4523 */
4524 std::string NMD::CMP_SULE_S(uint64 instruction)
4525 {
4526 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4527 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4528 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4529
4530 std::string fd = FPR(copy(fd_value));
4531 std::string fs = FPR(copy(fs_value));
4532 std::string ft = FPR(copy(ft_value));
4533
4534 return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4535 }
4536
4537
4538 /*
4539 *
4540 *
4541 * 3 2 1
4542 * 10987654321098765432109876543210
4543 * 001000 x1110000101
4544 * rt -----
4545 * rs -----
4546 * rd -----
4547 */
4548 std::string NMD::CMP_SULT_D(uint64 instruction)
4549 {
4550 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4551 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4552 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4553
4554 std::string fd = FPR(copy(fd_value));
4555 std::string fs = FPR(copy(fs_value));
4556 std::string ft = FPR(copy(ft_value));
4557
4558 return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4559 }
4560
4561
4562 /*
4563 *
4564 *
4565 * 3 2 1
4566 * 10987654321098765432109876543210
4567 * 001000 x1110000101
4568 * rt -----
4569 * rs -----
4570 * rd -----
4571 */
4572 std::string NMD::CMP_SULT_S(uint64 instruction)
4573 {
4574 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4575 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4576 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4577
4578 std::string fd = FPR(copy(fd_value));
4579 std::string fs = FPR(copy(fs_value));
4580 std::string ft = FPR(copy(ft_value));
4581
4582 return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4583 }
4584
4585
4586 /*
4587 *
4588 *
4589 * 3 2 1
4590 * 10987654321098765432109876543210
4591 * 001000 x1110000101
4592 * rt -----
4593 * rs -----
4594 * rd -----
4595 */
4596 std::string NMD::CMP_SUN_D(uint64 instruction)
4597 {
4598 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4599 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4600 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4601
4602 std::string fd = FPR(copy(fd_value));
4603 std::string fs = FPR(copy(fs_value));
4604 std::string ft = FPR(copy(ft_value));
4605
4606 return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4607 }
4608
4609
4610 /*
4611 *
4612 *
4613 * 3 2 1
4614 * 10987654321098765432109876543210
4615 * 001000 x1110000101
4616 * rt -----
4617 * rs -----
4618 * rd -----
4619 */
4620 std::string NMD::CMP_SUNE_D(uint64 instruction)
4621 {
4622 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4623 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4624 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4625
4626 std::string fd = FPR(copy(fd_value));
4627 std::string fs = FPR(copy(fs_value));
4628 std::string ft = FPR(copy(ft_value));
4629
4630 return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4631 }
4632
4633
4634 /*
4635 *
4636 *
4637 * 3 2 1
4638 * 10987654321098765432109876543210
4639 * 001000 x1110000101
4640 * rt -----
4641 * rs -----
4642 * rd -----
4643 */
4644 std::string NMD::CMP_SUNE_S(uint64 instruction)
4645 {
4646 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4647 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4648 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4649
4650 std::string fd = FPR(copy(fd_value));
4651 std::string fs = FPR(copy(fs_value));
4652 std::string ft = FPR(copy(ft_value));
4653
4654 return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4655 }
4656
4657
4658 /*
4659 *
4660 *
4661 * 3 2 1
4662 * 10987654321098765432109876543210
4663 * 001000 x1110000101
4664 * rt -----
4665 * rs -----
4666 * rd -----
4667 */
4668 std::string NMD::CMP_SUN_S(uint64 instruction)
4669 {
4670 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4671 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4672 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4673
4674 std::string fd = FPR(copy(fd_value));
4675 std::string fs = FPR(copy(fs_value));
4676 std::string ft = FPR(copy(ft_value));
4677
4678 return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4679 }
4680
4681
4682 /*
4683 *
4684 *
4685 * 3 2 1
4686 * 10987654321098765432109876543210
4687 * 001000 x1110000101
4688 * rt -----
4689 * rs -----
4690 * rd -----
4691 */
4692 std::string NMD::CMP_UEQ_D(uint64 instruction)
4693 {
4694 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4695 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4696 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4697
4698 std::string fd = FPR(copy(fd_value));
4699 std::string fs = FPR(copy(fs_value));
4700 std::string ft = FPR(copy(ft_value));
4701
4702 return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4703 }
4704
4705
4706 /*
4707 *
4708 *
4709 * 3 2 1
4710 * 10987654321098765432109876543210
4711 * 001000 x1110000101
4712 * rt -----
4713 * rs -----
4714 * rd -----
4715 */
4716 std::string NMD::CMP_UEQ_S(uint64 instruction)
4717 {
4718 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4719 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4720 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4721
4722 std::string fd = FPR(copy(fd_value));
4723 std::string fs = FPR(copy(fs_value));
4724 std::string ft = FPR(copy(ft_value));
4725
4726 return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4727 }
4728
4729
4730 /*
4731 *
4732 *
4733 * 3 2 1
4734 * 10987654321098765432109876543210
4735 * 001000 x1110000101
4736 * rt -----
4737 * rs -----
4738 * rd -----
4739 */
4740 std::string NMD::CMP_ULE_D(uint64 instruction)
4741 {
4742 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4743 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4744 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4745
4746 std::string fd = FPR(copy(fd_value));
4747 std::string fs = FPR(copy(fs_value));
4748 std::string ft = FPR(copy(ft_value));
4749
4750 return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4751 }
4752
4753
4754 /*
4755 *
4756 *
4757 * 3 2 1
4758 * 10987654321098765432109876543210
4759 * 001000 x1110000101
4760 * rt -----
4761 * rs -----
4762 * rd -----
4763 */
4764 std::string NMD::CMP_ULE_S(uint64 instruction)
4765 {
4766 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4767 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4768 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4769
4770 std::string fd = FPR(copy(fd_value));
4771 std::string fs = FPR(copy(fs_value));
4772 std::string ft = FPR(copy(ft_value));
4773
4774 return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4775 }
4776
4777
4778 /*
4779 *
4780 *
4781 * 3 2 1
4782 * 10987654321098765432109876543210
4783 * 001000 x1110000101
4784 * rt -----
4785 * rs -----
4786 * rd -----
4787 */
4788 std::string NMD::CMP_ULT_D(uint64 instruction)
4789 {
4790 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4791 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4792 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4793
4794 std::string fd = FPR(copy(fd_value));
4795 std::string fs = FPR(copy(fs_value));
4796 std::string ft = FPR(copy(ft_value));
4797
4798 return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4799 }
4800
4801
4802 /*
4803 *
4804 *
4805 * 3 2 1
4806 * 10987654321098765432109876543210
4807 * 001000 x1110000101
4808 * rt -----
4809 * rs -----
4810 * rd -----
4811 */
4812 std::string NMD::CMP_ULT_S(uint64 instruction)
4813 {
4814 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4815 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4816 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4817
4818 std::string fd = FPR(copy(fd_value));
4819 std::string fs = FPR(copy(fs_value));
4820 std::string ft = FPR(copy(ft_value));
4821
4822 return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4823 }
4824
4825
4826 /*
4827 *
4828 *
4829 * 3 2 1
4830 * 10987654321098765432109876543210
4831 * 001000 x1110000101
4832 * rt -----
4833 * rs -----
4834 * rd -----
4835 */
4836 std::string NMD::CMP_UN_D(uint64 instruction)
4837 {
4838 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4839 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4840 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4841
4842 std::string fd = FPR(copy(fd_value));
4843 std::string fs = FPR(copy(fs_value));
4844 std::string ft = FPR(copy(ft_value));
4845
4846 return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4847 }
4848
4849
4850 /*
4851 *
4852 *
4853 * 3 2 1
4854 * 10987654321098765432109876543210
4855 * 001000 x1110000101
4856 * rt -----
4857 * rs -----
4858 * rd -----
4859 */
4860 std::string NMD::CMP_UNE_D(uint64 instruction)
4861 {
4862 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4863 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4864 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4865
4866 std::string fd = FPR(copy(fd_value));
4867 std::string fs = FPR(copy(fs_value));
4868 std::string ft = FPR(copy(ft_value));
4869
4870 return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4871 }
4872
4873
4874 /*
4875 *
4876 *
4877 * 3 2 1
4878 * 10987654321098765432109876543210
4879 * 001000 x1110000101
4880 * rt -----
4881 * rs -----
4882 * rd -----
4883 */
4884 std::string NMD::CMP_UNE_S(uint64 instruction)
4885 {
4886 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4887 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4888 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4889
4890 std::string fd = FPR(copy(fd_value));
4891 std::string fs = FPR(copy(fs_value));
4892 std::string ft = FPR(copy(ft_value));
4893
4894 return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4895 }
4896
4897
4898 /*
4899 *
4900 *
4901 * 3 2 1
4902 * 10987654321098765432109876543210
4903 * 001000 x1110000101
4904 * rt -----
4905 * rs -----
4906 * rd -----
4907 */
4908 std::string NMD::CMP_UN_S(uint64 instruction)
4909 {
4910 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4911 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4912 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4913
4914 std::string fd = FPR(copy(fd_value));
4915 std::string fs = FPR(copy(fs_value));
4916 std::string ft = FPR(copy(ft_value));
4917
4918 return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4919 }
4920
4921
4922 /*
4923 *
4924 *
4925 * 3 2 1
4926 * 10987654321098765432109876543210
4927 * 001000 x1110000101
4928 * rt -----
4929 * rs -----
4930 * rd -----
4931 */
4932 std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
4933 {
4934 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4935 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4936 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4937
4938 std::string rd = GPR(copy(rd_value));
4939 std::string rs = GPR(copy(rs_value));
4940 std::string rt = GPR(copy(rt_value));
4941
4942 return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4943 }
4944
4945
4946 /*
4947 *
4948 *
4949 * 3 2 1
4950 * 10987654321098765432109876543210
4951 * 001000 x1110000101
4952 * rt -----
4953 * rs -----
4954 * rd -----
4955 */
4956 std::string NMD::CMPGDU_LE_QB(uint64 instruction)
4957 {
4958 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4959 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4960 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4961
4962 std::string rd = GPR(copy(rd_value));
4963 std::string rs = GPR(copy(rs_value));
4964 std::string rt = GPR(copy(rt_value));
4965
4966 return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4967 }
4968
4969
4970 /*
4971 *
4972 *
4973 * 3 2 1
4974 * 10987654321098765432109876543210
4975 * 001000 x1110000101
4976 * rt -----
4977 * rs -----
4978 * rd -----
4979 */
4980 std::string NMD::CMPGDU_LT_QB(uint64 instruction)
4981 {
4982 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4983 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4984 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4985
4986 std::string rd = GPR(copy(rd_value));
4987 std::string rs = GPR(copy(rs_value));
4988 std::string rt = GPR(copy(rt_value));
4989
4990 return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4991 }
4992
4993
4994 /*
4995 *
4996 *
4997 * 3 2 1
4998 * 10987654321098765432109876543210
4999 * 001000 x1110000101
5000 * rt -----
5001 * rs -----
5002 * rd -----
5003 */
5004 std::string NMD::CMPGU_EQ_QB(uint64 instruction)
5005 {
5006 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5007 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5008 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5009
5010 std::string rd = GPR(copy(rd_value));
5011 std::string rs = GPR(copy(rs_value));
5012 std::string rt = GPR(copy(rt_value));
5013
5014 return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
5015 }
5016
5017
5018 /*
5019 *
5020 *
5021 * 3 2 1
5022 * 10987654321098765432109876543210
5023 * 001000 x1110000101
5024 * rt -----
5025 * rs -----
5026 * rd -----
5027 */
5028 std::string NMD::CMPGU_LE_QB(uint64 instruction)
5029 {
5030 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5031 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5032 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5033
5034 std::string rd = GPR(copy(rd_value));
5035 std::string rs = GPR(copy(rs_value));
5036 std::string rt = GPR(copy(rt_value));
5037
5038 return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
5039 }
5040
5041
5042 /*
5043 *
5044 *
5045 * 3 2 1
5046 * 10987654321098765432109876543210
5047 * 001000 x1110000101
5048 * rt -----
5049 * rs -----
5050 * rd -----
5051 */
5052 std::string NMD::CMPGU_LT_QB(uint64 instruction)
5053 {
5054 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5055 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5056 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5057
5058 std::string rd = GPR(copy(rd_value));
5059 std::string rs = GPR(copy(rs_value));
5060 std::string rt = GPR(copy(rt_value));
5061
5062 return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
5063 }
5064
5065
5066 /*
5067 *
5068 *
5069 * 3 2 1
5070 * 10987654321098765432109876543210
5071 * 001000 x1110000101
5072 * rt -----
5073 * rs -----
5074 * rd -----
5075 */
5076 std::string NMD::CMPU_EQ_QB(uint64 instruction)
5077 {
5078 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5079 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5080
5081 std::string rs = GPR(copy(rs_value));
5082 std::string rt = GPR(copy(rt_value));
5083
5084 return img::format("CMPU.EQ.QB %s, %s", rs, rt);
5085 }
5086
5087
5088 /*
5089 *
5090 *
5091 * 3 2 1
5092 * 10987654321098765432109876543210
5093 * 001000 x1110000101
5094 * rt -----
5095 * rs -----
5096 * rd -----
5097 */
5098 std::string NMD::CMPU_LE_QB(uint64 instruction)
5099 {
5100 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5102
5103 std::string rs = GPR(copy(rs_value));
5104 std::string rt = GPR(copy(rt_value));
5105
5106 return img::format("CMPU.LE.QB %s, %s", rs, rt);
5107 }
5108
5109
5110 /*
5111 *
5112 *
5113 * 3 2 1
5114 * 10987654321098765432109876543210
5115 * 001000 x1110000101
5116 * rt -----
5117 * rs -----
5118 * rd -----
5119 */
5120 std::string NMD::CMPU_LT_QB(uint64 instruction)
5121 {
5122 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5123 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5124
5125 std::string rs = GPR(copy(rs_value));
5126 std::string rt = GPR(copy(rt_value));
5127
5128 return img::format("CMPU.LT.QB %s, %s", rs, rt);
5129 }
5130
5131
5132 /*
5133 *
5134 *
5135 * 3 2 1
5136 * 10987654321098765432109876543210
5137 * 001000 x1110000101
5138 * rt -----
5139 * rs -----
5140 * rd -----
5141 */
5142 std::string NMD::COP2_1(uint64 instruction)
5143 {
5144 uint64 cofun_value = extract_cofun_25_24_23(instruction);
5145
5146 std::string cofun = IMMEDIATE(copy(cofun_value));
5147
5148 return img::format("COP2_1 %s", cofun);
5149 }
5150
5151
5152 /*
5153 *
5154 *
5155 * 3 2 1
5156 * 10987654321098765432109876543210
5157 * 001000 x1110000101
5158 * rt -----
5159 * rs -----
5160 * rd -----
5161 */
5162 std::string NMD::CTC1(uint64 instruction)
5163 {
5164 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5165 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5166
5167 std::string rt = GPR(copy(rt_value));
5168 std::string cs = CPR(copy(cs_value));
5169
5170 return img::format("CTC1 %s, %s", rt, cs);
5171 }
5172
5173
5174 /*
5175 *
5176 *
5177 * 3 2 1
5178 * 10987654321098765432109876543210
5179 * 001000 x1110000101
5180 * rt -----
5181 * rs -----
5182 * rd -----
5183 */
5184 std::string NMD::CTC2(uint64 instruction)
5185 {
5186 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5187 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5188
5189 std::string rt = GPR(copy(rt_value));
5190 std::string cs = CPR(copy(cs_value));
5191
5192 return img::format("CTC2 %s, %s", rt, cs);
5193 }
5194
5195
5196 /*
5197 *
5198 *
5199 * 3 2 1
5200 * 10987654321098765432109876543210
5201 * 001000 x1110000101
5202 * rt -----
5203 * rs -----
5204 * rd -----
5205 */
5206 std::string NMD::CVT_D_L(uint64 instruction)
5207 {
5208 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5209 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5210
5211 std::string ft = FPR(copy(ft_value));
5212 std::string fs = FPR(copy(fs_value));
5213
5214 return img::format("CVT.D.L %s, %s", ft, fs);
5215 }
5216
5217
5218 /*
5219 *
5220 *
5221 * 3 2 1
5222 * 10987654321098765432109876543210
5223 * 001000 x1110000101
5224 * rt -----
5225 * rs -----
5226 * rd -----
5227 */
5228 std::string NMD::CVT_D_S(uint64 instruction)
5229 {
5230 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5231 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5232
5233 std::string ft = FPR(copy(ft_value));
5234 std::string fs = FPR(copy(fs_value));
5235
5236 return img::format("CVT.D.S %s, %s", ft, fs);
5237 }
5238
5239
5240 /*
5241 *
5242 *
5243 * 3 2 1
5244 * 10987654321098765432109876543210
5245 * 001000 x1110000101
5246 * rt -----
5247 * rs -----
5248 * rd -----
5249 */
5250 std::string NMD::CVT_D_W(uint64 instruction)
5251 {
5252 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5253 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5254
5255 std::string ft = FPR(copy(ft_value));
5256 std::string fs = FPR(copy(fs_value));
5257
5258 return img::format("CVT.D.W %s, %s", ft, fs);
5259 }
5260
5261
5262 /*
5263 *
5264 *
5265 * 3 2 1
5266 * 10987654321098765432109876543210
5267 * 001000 x1110000101
5268 * rt -----
5269 * rs -----
5270 * rd -----
5271 */
5272 std::string NMD::CVT_L_D(uint64 instruction)
5273 {
5274 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5275 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5276
5277 std::string ft = FPR(copy(ft_value));
5278 std::string fs = FPR(copy(fs_value));
5279
5280 return img::format("CVT.L.D %s, %s", ft, fs);
5281 }
5282
5283
5284 /*
5285 *
5286 *
5287 * 3 2 1
5288 * 10987654321098765432109876543210
5289 * 001000 x1110000101
5290 * rt -----
5291 * rs -----
5292 * rd -----
5293 */
5294 std::string NMD::CVT_L_S(uint64 instruction)
5295 {
5296 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5297 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5298
5299 std::string ft = FPR(copy(ft_value));
5300 std::string fs = FPR(copy(fs_value));
5301
5302 return img::format("CVT.L.S %s, %s", ft, fs);
5303 }
5304
5305
5306 /*
5307 *
5308 *
5309 * 3 2 1
5310 * 10987654321098765432109876543210
5311 * 001000 x1110000101
5312 * rt -----
5313 * rs -----
5314 * rd -----
5315 */
5316 std::string NMD::CVT_S_D(uint64 instruction)
5317 {
5318 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5319 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5320
5321 std::string ft = FPR(copy(ft_value));
5322 std::string fs = FPR(copy(fs_value));
5323
5324 return img::format("CVT.S.D %s, %s", ft, fs);
5325 }
5326
5327
5328 /*
5329 *
5330 *
5331 * 3 2 1
5332 * 10987654321098765432109876543210
5333 * 001000 x1110000101
5334 * rt -----
5335 * rs -----
5336 * rd -----
5337 */
5338 std::string NMD::CVT_S_L(uint64 instruction)
5339 {
5340 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5341 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5342
5343 std::string ft = FPR(copy(ft_value));
5344 std::string fs = FPR(copy(fs_value));
5345
5346 return img::format("CVT.S.L %s, %s", ft, fs);
5347 }
5348
5349
5350 /*
5351 *
5352 *
5353 * 3 2 1
5354 * 10987654321098765432109876543210
5355 * 001000 x1110000101
5356 * rt -----
5357 * rs -----
5358 * rd -----
5359 */
5360 std::string NMD::CVT_S_PL(uint64 instruction)
5361 {
5362 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5363 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5364
5365 std::string ft = FPR(copy(ft_value));
5366 std::string fs = FPR(copy(fs_value));
5367
5368 return img::format("CVT.S.PL %s, %s", ft, fs);
5369 }
5370
5371
5372 /*
5373 *
5374 *
5375 * 3 2 1
5376 * 10987654321098765432109876543210
5377 * 001000 x1110000101
5378 * rt -----
5379 * rs -----
5380 * rd -----
5381 */
5382 std::string NMD::CVT_S_PU(uint64 instruction)
5383 {
5384 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5385 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5386
5387 std::string ft = FPR(copy(ft_value));
5388 std::string fs = FPR(copy(fs_value));
5389
5390 return img::format("CVT.S.PU %s, %s", ft, fs);
5391 }
5392
5393
5394 /*
5395 *
5396 *
5397 * 3 2 1
5398 * 10987654321098765432109876543210
5399 * 001000 x1110000101
5400 * rt -----
5401 * rs -----
5402 * rd -----
5403 */
5404 std::string NMD::CVT_S_W(uint64 instruction)
5405 {
5406 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5407 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5408
5409 std::string ft = FPR(copy(ft_value));
5410 std::string fs = FPR(copy(fs_value));
5411
5412 return img::format("CVT.S.W %s, %s", ft, fs);
5413 }
5414
5415
5416 /*
5417 *
5418 *
5419 * 3 2 1
5420 * 10987654321098765432109876543210
5421 * 001000 x1110000101
5422 * rt -----
5423 * rs -----
5424 * rd -----
5425 */
5426 std::string NMD::CVT_W_D(uint64 instruction)
5427 {
5428 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5429 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5430
5431 std::string ft = FPR(copy(ft_value));
5432 std::string fs = FPR(copy(fs_value));
5433
5434 return img::format("CVT.W.D %s, %s", ft, fs);
5435 }
5436
5437
5438 /*
5439 *
5440 *
5441 * 3 2 1
5442 * 10987654321098765432109876543210
5443 * 001000 x1110000101
5444 * rt -----
5445 * rs -----
5446 * rd -----
5447 */
5448 std::string NMD::CVT_W_S(uint64 instruction)
5449 {
5450 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5451 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5452
5453 std::string ft = FPR(copy(ft_value));
5454 std::string fs = FPR(copy(fs_value));
5455
5456 return img::format("CVT.W.S %s, %s", ft, fs);
5457 }
5458
5459
5460 /*
5461 *
5462 *
5463 * 3 2 1
5464 * 10987654321098765432109876543210
5465 * 001000 x1110000101
5466 * rt -----
5467 * rs -----
5468 * rd -----
5469 */
5470 std::string NMD::DADDIU_48_(uint64 instruction)
5471 {
5472 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5473 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
5474
5475 std::string rt = GPR(copy(rt_value));
5476 std::string s = IMMEDIATE(copy(s_value));
5477
5478 return img::format("DADDIU %s, %s", rt, s);
5479 }
5480
5481
5482 /*
5483 *
5484 *
5485 * 3 2 1
5486 * 10987654321098765432109876543210
5487 * 001000 x1110000101
5488 * rt -----
5489 * rs -----
5490 * rd -----
5491 */
5492 std::string NMD::DADDIU_NEG_(uint64 instruction)
5493 {
5494 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5495 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5496 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5497
5498 std::string rt = GPR(copy(rt_value));
5499 std::string rs = GPR(copy(rs_value));
5500 std::string u = IMMEDIATE(neg_copy(u_value));
5501
5502 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5503 }
5504
5505
5506 /*
5507 *
5508 *
5509 * 3 2 1
5510 * 10987654321098765432109876543210
5511 * 001000 x1110000101
5512 * rt -----
5513 * rs -----
5514 * rd -----
5515 */
5516 std::string NMD::DADDIU_U12_(uint64 instruction)
5517 {
5518 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5519 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5520 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5521
5522 std::string rt = GPR(copy(rt_value));
5523 std::string rs = GPR(copy(rs_value));
5524 std::string u = IMMEDIATE(copy(u_value));
5525
5526 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5527 }
5528
5529
5530 /*
5531 *
5532 *
5533 * 3 2 1
5534 * 10987654321098765432109876543210
5535 * 001000 x1110000101
5536 * rt -----
5537 * rs -----
5538 * rd -----
5539 */
5540 std::string NMD::DADD(uint64 instruction)
5541 {
5542 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5543 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5544 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5545
5546 std::string rd = GPR(copy(rd_value));
5547 std::string rs = GPR(copy(rs_value));
5548 std::string rt = GPR(copy(rt_value));
5549
5550 return img::format("DADD %s, %s, %s", rd, rs, rt);
5551 }
5552
5553
5554 /*
5555 *
5556 *
5557 * 3 2 1
5558 * 10987654321098765432109876543210
5559 * 001000 x1110000101
5560 * rt -----
5561 * rs -----
5562 * rd -----
5563 */
5564 std::string NMD::DADDU(uint64 instruction)
5565 {
5566 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5567 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5568 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5569
5570 std::string rd = GPR(copy(rd_value));
5571 std::string rs = GPR(copy(rs_value));
5572 std::string rt = GPR(copy(rt_value));
5573
5574 return img::format("DADDU %s, %s, %s", rd, rs, rt);
5575 }
5576
5577
5578 /*
5579 *
5580 *
5581 * 3 2 1
5582 * 10987654321098765432109876543210
5583 * 001000 x1110000101
5584 * rt -----
5585 * rs -----
5586 * rd -----
5587 */
5588 std::string NMD::DCLO(uint64 instruction)
5589 {
5590 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5591 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5592
5593 std::string rt = GPR(copy(rt_value));
5594 std::string rs = GPR(copy(rs_value));
5595
5596 return img::format("DCLO %s, %s", rt, rs);
5597 }
5598
5599
5600 /*
5601 *
5602 *
5603 * 3 2 1
5604 * 10987654321098765432109876543210
5605 * 001000 x1110000101
5606 * rt -----
5607 * rs -----
5608 * rd -----
5609 */
5610 std::string NMD::DCLZ(uint64 instruction)
5611 {
5612 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5613 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5614
5615 std::string rt = GPR(copy(rt_value));
5616 std::string rs = GPR(copy(rs_value));
5617
5618 return img::format("DCLZ %s, %s", rt, rs);
5619 }
5620
5621
5622 /*
5623 *
5624 *
5625 * 3 2 1
5626 * 10987654321098765432109876543210
5627 * 001000 x1110000101
5628 * rt -----
5629 * rs -----
5630 * rd -----
5631 */
5632 std::string NMD::DDIV(uint64 instruction)
5633 {
5634 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5635 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5636 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5637
5638 std::string rd = GPR(copy(rd_value));
5639 std::string rs = GPR(copy(rs_value));
5640 std::string rt = GPR(copy(rt_value));
5641
5642 return img::format("DDIV %s, %s, %s", rd, rs, rt);
5643 }
5644
5645
5646 /*
5647 *
5648 *
5649 * 3 2 1
5650 * 10987654321098765432109876543210
5651 * 001000 x1110000101
5652 * rt -----
5653 * rs -----
5654 * rd -----
5655 */
5656 std::string NMD::DDIVU(uint64 instruction)
5657 {
5658 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5659 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5661
5662 std::string rd = GPR(copy(rd_value));
5663 std::string rs = GPR(copy(rs_value));
5664 std::string rt = GPR(copy(rt_value));
5665
5666 return img::format("DDIVU %s, %s, %s", rd, rs, rt);
5667 }
5668
5669
5670 /*
5671 *
5672 *
5673 * 3 2 1
5674 * 10987654321098765432109876543210
5675 * 001000 x1110000101
5676 * rt -----
5677 * rs -----
5678 * rd -----
5679 */
5680 std::string NMD::DERET(uint64 instruction)
5681 {
5682 (void)instruction;
5683
5684 return "DERET ";
5685 }
5686
5687
5688 /*
5689 *
5690 *
5691 * 3 2 1
5692 * 10987654321098765432109876543210
5693 * 001000 x1110000101
5694 * rt -----
5695 * rs -----
5696 * rd -----
5697 */
5698 std::string NMD::DEXTM(uint64 instruction)
5699 {
5700 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5701 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5702 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5703 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5704
5705 std::string rt = GPR(copy(rt_value));
5706 std::string rs = GPR(copy(rs_value));
5707 std::string lsb = IMMEDIATE(copy(lsb_value));
5708 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5709
5710 return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
5711 }
5712
5713
5714 /*
5715 *
5716 *
5717 * 3 2 1
5718 * 10987654321098765432109876543210
5719 * 001000 x1110000101
5720 * rt -----
5721 * rs -----
5722 * rd -----
5723 */
5724 std::string NMD::DEXT(uint64 instruction)
5725 {
5726 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5727 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5728 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5729 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5730
5731 std::string rt = GPR(copy(rt_value));
5732 std::string rs = GPR(copy(rs_value));
5733 std::string lsb = IMMEDIATE(copy(lsb_value));
5734 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5735
5736 return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
5737 }
5738
5739
5740 /*
5741 *
5742 *
5743 * 3 2 1
5744 * 10987654321098765432109876543210
5745 * 001000 x1110000101
5746 * rt -----
5747 * rs -----
5748 * rd -----
5749 */
5750 std::string NMD::DEXTU(uint64 instruction)
5751 {
5752 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5753 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5754 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5755 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5756
5757 std::string rt = GPR(copy(rt_value));
5758 std::string rs = GPR(copy(rs_value));
5759 std::string lsb = IMMEDIATE(copy(lsb_value));
5760 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5761
5762 return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
5763 }
5764
5765
5766 /*
5767 *
5768 *
5769 * 3 2 1
5770 * 10987654321098765432109876543210
5771 * 001000 x1110000101
5772 * rt -----
5773 * rs -----
5774 * rd -----
5775 */
5776 std::string NMD::DINSM(uint64 instruction)
5777 {
5778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5779 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5780 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5781 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5782
5783 std::string rt = GPR(copy(rt_value));
5784 std::string rs = GPR(copy(rs_value));
5785 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5786 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5787 /* !!!!!!!!!! - no conversion function */
5788
5789 return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
5790 /* hand edited */
5791 }
5792
5793
5794 /*
5795 *
5796 *
5797 * 3 2 1
5798 * 10987654321098765432109876543210
5799 * 001000 x1110000101
5800 * rt -----
5801 * rs -----
5802 * rd -----
5803 */
5804 std::string NMD::DINS(uint64 instruction)
5805 {
5806 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5807 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5808 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5809 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5810
5811 std::string rt = GPR(copy(rt_value));
5812 std::string rs = GPR(copy(rs_value));
5813 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5814 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5815 /* !!!!!!!!!! - no conversion function */
5816
5817 return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
5818 /* hand edited */
5819 }
5820
5821
5822 /*
5823 *
5824 *
5825 * 3 2 1
5826 * 10987654321098765432109876543210
5827 * 001000 x1110000101
5828 * rt -----
5829 * rs -----
5830 * rd -----
5831 */
5832 std::string NMD::DINSU(uint64 instruction)
5833 {
5834 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5835 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5836 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5837 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5838
5839 std::string rt = GPR(copy(rt_value));
5840 std::string rs = GPR(copy(rs_value));
5841 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5842 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5843 /* !!!!!!!!!! - no conversion function */
5844
5845 return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
5846 /* hand edited */
5847 }
5848
5849
5850 /*
5851 *
5852 *
5853 * 3 2 1
5854 * 10987654321098765432109876543210
5855 * 001000 x1110000101
5856 * rt -----
5857 * rs -----
5858 * rd -----
5859 */
5860 std::string NMD::DI(uint64 instruction)
5861 {
5862 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5863
5864 std::string rt = GPR(copy(rt_value));
5865
5866 return img::format("DI %s", rt);
5867 }
5868
5869
5870 /*
5871 *
5872 *
5873 * 3 2 1
5874 * 10987654321098765432109876543210
5875 * 001000 x1110000101
5876 * rt -----
5877 * rs -----
5878 * rd -----
5879 */
5880 std::string NMD::DIV(uint64 instruction)
5881 {
5882 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5883 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5884 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5885
5886 std::string rd = GPR(copy(rd_value));
5887 std::string rs = GPR(copy(rs_value));
5888 std::string rt = GPR(copy(rt_value));
5889
5890 return img::format("DIV %s, %s, %s", rd, rs, rt);
5891 }
5892
5893
5894 /*
5895 *
5896 *
5897 * 3 2 1
5898 * 10987654321098765432109876543210
5899 * 001000 x1110000101
5900 * rt -----
5901 * rs -----
5902 * rd -----
5903 */
5904 std::string NMD::DIV_D(uint64 instruction)
5905 {
5906 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5907 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5908 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
5909
5910 std::string fd = FPR(copy(fd_value));
5911 std::string fs = FPR(copy(fs_value));
5912 std::string ft = FPR(copy(ft_value));
5913
5914 return img::format("DIV.D %s, %s, %s", fd, fs, ft);
5915 }
5916
5917
5918 /*
5919 *
5920 *
5921 * 3 2 1
5922 * 10987654321098765432109876543210
5923 * 001000 x1110000101
5924 * rt -----
5925 * rs -----
5926 * rd -----
5927 */
5928 std::string NMD::DIV_S(uint64 instruction)
5929 {
5930 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5931 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5932 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
5933
5934 std::string fd = FPR(copy(fd_value));
5935 std::string fs = FPR(copy(fs_value));
5936 std::string ft = FPR(copy(ft_value));
5937
5938 return img::format("DIV.S %s, %s, %s", fd, fs, ft);
5939 }
5940
5941
5942 /*
5943 *
5944 *
5945 * 3 2 1
5946 * 10987654321098765432109876543210
5947 * 001000 x1110000101
5948 * rt -----
5949 * rs -----
5950 * rd -----
5951 */
5952 std::string NMD::DIVU(uint64 instruction)
5953 {
5954 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5955 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5956 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5957
5958 std::string rd = GPR(copy(rd_value));
5959 std::string rs = GPR(copy(rs_value));
5960 std::string rt = GPR(copy(rt_value));
5961
5962 return img::format("DIVU %s, %s, %s", rd, rs, rt);
5963 }
5964
5965
5966 /*
5967 *
5968 *
5969 * 3 2 1
5970 * 10987654321098765432109876543210
5971 * 001000 x1110000101
5972 * rt -----
5973 * rs -----
5974 * rd -----
5975 */
5976 std::string NMD::DLSA(uint64 instruction)
5977 {
5978 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5979 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5980 uint64 u2_value = extract_u2_10_9(instruction);
5981 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5982
5983 std::string rd = GPR(copy(rd_value));
5984 std::string rs = GPR(copy(rs_value));
5985 std::string rt = GPR(copy(rt_value));
5986 std::string u2 = IMMEDIATE(copy(u2_value));
5987
5988 return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
5989 }
5990
5991
5992 /*
5993 *
5994 *
5995 * 3 2 1
5996 * 10987654321098765432109876543210
5997 * 001000 x1110000101
5998 * rt -----
5999 * rs -----
6000 * rd -----
6001 */
6002 std::string NMD::DLUI_48_(uint64 instruction)
6003 {
6004 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
6005 uint64 u_value = extr_uil0il32bs32Fmsb63(instruction);
6006
6007 std::string rt = GPR(copy(rt_value));
6008 std::string u = IMMEDIATE(copy(u_value));
6009
6010 return img::format("DLUI %s, %s", rt, u);
6011 }
6012
6013
6014 /*
6015 *
6016 *
6017 * 3 2 1
6018 * 10987654321098765432109876543210
6019 * 001000 x1110000101
6020 * rt -----
6021 * rs -----
6022 * rd -----
6023 */
6024 std::string NMD::DMFC0(uint64 instruction)
6025 {
6026 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6027 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6028 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6029
6030 std::string rt = GPR(copy(rt_value));
6031 std::string c0s = CPR(copy(c0s_value));
6032 std::string sel = IMMEDIATE(copy(sel_value));
6033
6034 return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
6035 }
6036
6037
6038 /*
6039 *
6040 *
6041 * 3 2 1
6042 * 10987654321098765432109876543210
6043 * 001000 x1110000101
6044 * rt -----
6045 * rs -----
6046 * rd -----
6047 */
6048 std::string NMD::DMFC1(uint64 instruction)
6049 {
6050 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6051 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
6052
6053 std::string rt = GPR(copy(rt_value));
6054 std::string fs = FPR(copy(fs_value));
6055
6056 return img::format("DMFC1 %s, %s", rt, fs);
6057 }
6058
6059
6060 /*
6061 *
6062 *
6063 * 3 2 1
6064 * 10987654321098765432109876543210
6065 * 001000 x1110000101
6066 * rt -----
6067 * rs -----
6068 * rd -----
6069 */
6070 std::string NMD::DMFC2(uint64 instruction)
6071 {
6072 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6073 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6074
6075 std::string rt = GPR(copy(rt_value));
6076 std::string cs = CPR(copy(cs_value));
6077
6078 return img::format("DMFC2 %s, %s", rt, cs);
6079 }
6080
6081
6082 /*
6083 *
6084 *
6085 * 3 2 1
6086 * 10987654321098765432109876543210
6087 * 001000 x1110000101
6088 * rt -----
6089 * rs -----
6090 * rd -----
6091 */
6092 std::string NMD::DMFGC0(uint64 instruction)
6093 {
6094 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6095 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6096 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6097
6098 std::string rt = GPR(copy(rt_value));
6099 std::string c0s = CPR(copy(c0s_value));
6100 std::string sel = IMMEDIATE(copy(sel_value));
6101
6102 return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
6103 }
6104
6105
6106 /*
6107 *
6108 *
6109 * 3 2 1
6110 * 10987654321098765432109876543210
6111 * 001000 x1110000101
6112 * rt -----
6113 * rs -----
6114 * rd -----
6115 */
6116 std::string NMD::DMOD(uint64 instruction)
6117 {
6118 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6119 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6120 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6121
6122 std::string rd = GPR(copy(rd_value));
6123 std::string rs = GPR(copy(rs_value));
6124 std::string rt = GPR(copy(rt_value));
6125
6126 return img::format("DMOD %s, %s, %s", rd, rs, rt);
6127 }
6128
6129
6130 /*
6131 *
6132 *
6133 * 3 2 1
6134 * 10987654321098765432109876543210
6135 * 001000 x1110000101
6136 * rt -----
6137 * rs -----
6138 * rd -----
6139 */
6140 std::string NMD::DMODU(uint64 instruction)
6141 {
6142 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6143 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6144 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6145
6146 std::string rd = GPR(copy(rd_value));
6147 std::string rs = GPR(copy(rs_value));
6148 std::string rt = GPR(copy(rt_value));
6149
6150 return img::format("DMODU %s, %s, %s", rd, rs, rt);
6151 }
6152
6153
6154 /*
6155 *
6156 *
6157 * 3 2 1
6158 * 10987654321098765432109876543210
6159 * 001000 x1110000101
6160 * rt -----
6161 * rs -----
6162 * rd -----
6163 */
6164 std::string NMD::DMTC0(uint64 instruction)
6165 {
6166 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6167 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6168 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6169
6170 std::string rt = GPR(copy(rt_value));
6171 std::string c0s = CPR(copy(c0s_value));
6172 std::string sel = IMMEDIATE(copy(sel_value));
6173
6174 return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
6175 }
6176
6177
6178 /*
6179 *
6180 *
6181 * 3 2 1
6182 * 10987654321098765432109876543210
6183 * 001000 x1110000101
6184 * rt -----
6185 * rs -----
6186 * rd -----
6187 */
6188 std::string NMD::DMTC1(uint64 instruction)
6189 {
6190 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6191 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
6192
6193 std::string rt = GPR(copy(rt_value));
6194 std::string fs = FPR(copy(fs_value));
6195
6196 return img::format("DMTC1 %s, %s", rt, fs);
6197 }
6198
6199
6200 /*
6201 *
6202 *
6203 * 3 2 1
6204 * 10987654321098765432109876543210
6205 * 001000 x1110000101
6206 * rt -----
6207 * rs -----
6208 * rd -----
6209 */
6210 std::string NMD::DMTC2(uint64 instruction)
6211 {
6212 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6213 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6214
6215 std::string rt = GPR(copy(rt_value));
6216 std::string cs = CPR(copy(cs_value));
6217
6218 return img::format("DMTC2 %s, %s", rt, cs);
6219 }
6220
6221
6222 /*
6223 *
6224 *
6225 * 3 2 1
6226 * 10987654321098765432109876543210
6227 * 001000 x1110000101
6228 * rt -----
6229 * rs -----
6230 * rd -----
6231 */
6232 std::string NMD::DMTGC0(uint64 instruction)
6233 {
6234 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6235 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6236 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6237
6238 std::string rt = GPR(copy(rt_value));
6239 std::string c0s = CPR(copy(c0s_value));
6240 std::string sel = IMMEDIATE(copy(sel_value));
6241
6242 return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
6243 }
6244
6245
6246 /*
6247 *
6248 *
6249 * 3 2 1
6250 * 10987654321098765432109876543210
6251 * 001000 x1110000101
6252 * rt -----
6253 * rs -----
6254 * rd -----
6255 */
6256 std::string NMD::DMT(uint64 instruction)
6257 {
6258 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6259
6260 std::string rt = GPR(copy(rt_value));
6261
6262 return img::format("DMT %s", rt);
6263 }
6264
6265
6266 /*
6267 *
6268 *
6269 * 3 2 1
6270 * 10987654321098765432109876543210
6271 * 001000 x1110000101
6272 * rt -----
6273 * rs -----
6274 * rd -----
6275 */
6276 std::string NMD::DMUH(uint64 instruction)
6277 {
6278 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6279 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6280 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6281
6282 std::string rd = GPR(copy(rd_value));
6283 std::string rs = GPR(copy(rs_value));
6284 std::string rt = GPR(copy(rt_value));
6285
6286 return img::format("DMUH %s, %s, %s", rd, rs, rt);
6287 }
6288
6289
6290 /*
6291 *
6292 *
6293 * 3 2 1
6294 * 10987654321098765432109876543210
6295 * 001000 x1110000101
6296 * rt -----
6297 * rs -----
6298 * rd -----
6299 */
6300 std::string NMD::DMUHU(uint64 instruction)
6301 {
6302 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6303 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6305
6306 std::string rd = GPR(copy(rd_value));
6307 std::string rs = GPR(copy(rs_value));
6308 std::string rt = GPR(copy(rt_value));
6309
6310 return img::format("DMUHU %s, %s, %s", rd, rs, rt);
6311 }
6312
6313
6314 /*
6315 *
6316 *
6317 * 3 2 1
6318 * 10987654321098765432109876543210
6319 * 001000 x1110000101
6320 * rt -----
6321 * rs -----
6322 * rd -----
6323 */
6324 std::string NMD::DMUL(uint64 instruction)
6325 {
6326 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6327 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6328 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6329
6330 std::string rd = GPR(copy(rd_value));
6331 std::string rs = GPR(copy(rs_value));
6332 std::string rt = GPR(copy(rt_value));
6333
6334 return img::format("DMUL %s, %s, %s", rd, rs, rt);
6335 }
6336
6337
6338 /*
6339 *
6340 *
6341 * 3 2 1
6342 * 10987654321098765432109876543210
6343 * 001000 x1110000101
6344 * rt -----
6345 * rs -----
6346 * rd -----
6347 */
6348 std::string NMD::DMULU(uint64 instruction)
6349 {
6350 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6351 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6352 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6353
6354 std::string rd = GPR(copy(rd_value));
6355 std::string rs = GPR(copy(rs_value));
6356 std::string rt = GPR(copy(rt_value));
6357
6358 return img::format("DMULU %s, %s, %s", rd, rs, rt);
6359 }
6360
6361
6362 /*
6363 *
6364 *
6365 * 3 2 1
6366 * 10987654321098765432109876543210
6367 * 001000 x1110000101
6368 * rt -----
6369 * rs -----
6370 * rd -----
6371 */
6372 std::string NMD::DPA_W_PH(uint64 instruction)
6373 {
6374 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6375 uint64 ac_value = extract_ac_13_12(instruction);
6376 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6377
6378 std::string ac = AC(copy(ac_value));
6379 std::string rs = GPR(copy(rs_value));
6380 std::string rt = GPR(copy(rt_value));
6381
6382 return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6383 }
6384
6385
6386 /*
6387 *
6388 *
6389 * 3 2 1
6390 * 10987654321098765432109876543210
6391 * 001000 x1110000101
6392 * rt -----
6393 * rs -----
6394 * rd -----
6395 */
6396 std::string NMD::DPAQ_SA_L_W(uint64 instruction)
6397 {
6398 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6399 uint64 ac_value = extract_ac_13_12(instruction);
6400 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6401
6402 std::string ac = AC(copy(ac_value));
6403 std::string rs = GPR(copy(rs_value));
6404 std::string rt = GPR(copy(rt_value));
6405
6406 return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6407 }
6408
6409
6410 /*
6411 *
6412 *
6413 * 3 2 1
6414 * 10987654321098765432109876543210
6415 * 001000 x1110000101
6416 * rt -----
6417 * rs -----
6418 * rd -----
6419 */
6420 std::string NMD::DPAQ_S_W_PH(uint64 instruction)
6421 {
6422 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6423 uint64 ac_value = extract_ac_13_12(instruction);
6424 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6425
6426 std::string ac = AC(copy(ac_value));
6427 std::string rs = GPR(copy(rs_value));
6428 std::string rt = GPR(copy(rt_value));
6429
6430 return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6431 }
6432
6433
6434 /*
6435 *
6436 *
6437 * 3 2 1
6438 * 10987654321098765432109876543210
6439 * 001000 x1110000101
6440 * rt -----
6441 * rs -----
6442 * rd -----
6443 */
6444 std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
6445 {
6446 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6447 uint64 ac_value = extract_ac_13_12(instruction);
6448 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6449
6450 std::string ac = AC(copy(ac_value));
6451 std::string rs = GPR(copy(rs_value));
6452 std::string rt = GPR(copy(rt_value));
6453
6454 return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6455 }
6456
6457
6458 /*
6459 *
6460 *
6461 * 3 2 1
6462 * 10987654321098765432109876543210
6463 * 001000 x1110000101
6464 * rt -----
6465 * rs -----
6466 * rd -----
6467 */
6468 std::string NMD::DPAQX_S_W_PH(uint64 instruction)
6469 {
6470 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6471 uint64 ac_value = extract_ac_13_12(instruction);
6472 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6473
6474 std::string ac = AC(copy(ac_value));
6475 std::string rs = GPR(copy(rs_value));
6476 std::string rt = GPR(copy(rt_value));
6477
6478 return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6479 }
6480
6481
6482 /*
6483 *
6484 *
6485 * 3 2 1
6486 * 10987654321098765432109876543210
6487 * 001000 x1110000101
6488 * rt -----
6489 * rs -----
6490 * rd -----
6491 */
6492 std::string NMD::DPAU_H_QBL(uint64 instruction)
6493 {
6494 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6495 uint64 ac_value = extract_ac_13_12(instruction);
6496 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6497
6498 std::string ac = AC(copy(ac_value));
6499 std::string rs = GPR(copy(rs_value));
6500 std::string rt = GPR(copy(rt_value));
6501
6502 return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6503 }
6504
6505
6506 /*
6507 *
6508 *
6509 * 3 2 1
6510 * 10987654321098765432109876543210
6511 * 001000 x1110000101
6512 * rt -----
6513 * rs -----
6514 * rd -----
6515 */
6516 std::string NMD::DPAU_H_QBR(uint64 instruction)
6517 {
6518 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6519 uint64 ac_value = extract_ac_13_12(instruction);
6520 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6521
6522 std::string ac = AC(copy(ac_value));
6523 std::string rs = GPR(copy(rs_value));
6524 std::string rt = GPR(copy(rt_value));
6525
6526 return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6527 }
6528
6529
6530 /*
6531 *
6532 *
6533 * 3 2 1
6534 * 10987654321098765432109876543210
6535 * 001000 x1110000101
6536 * rt -----
6537 * rs -----
6538 * rd -----
6539 */
6540 std::string NMD::DPAX_W_PH(uint64 instruction)
6541 {
6542 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6543 uint64 ac_value = extract_ac_13_12(instruction);
6544 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6545
6546 std::string ac = AC(copy(ac_value));
6547 std::string rs = GPR(copy(rs_value));
6548 std::string rt = GPR(copy(rt_value));
6549
6550 return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6551 }
6552
6553
6554 /*
6555 *
6556 *
6557 * 3 2 1
6558 * 10987654321098765432109876543210
6559 * 001000 x1110000101
6560 * rt -----
6561 * rs -----
6562 * rd -----
6563 */
6564 std::string NMD::DPS_W_PH(uint64 instruction)
6565 {
6566 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6567 uint64 ac_value = extract_ac_13_12(instruction);
6568 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6569
6570 std::string ac = AC(copy(ac_value));
6571 std::string rs = GPR(copy(rs_value));
6572 std::string rt = GPR(copy(rt_value));
6573
6574 return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6575 }
6576
6577
6578 /*
6579 *
6580 *
6581 * 3 2 1
6582 * 10987654321098765432109876543210
6583 * 001000 x1110000101
6584 * rt -----
6585 * rs -----
6586 * rd -----
6587 */
6588 std::string NMD::DPSQ_SA_L_W(uint64 instruction)
6589 {
6590 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6591 uint64 ac_value = extract_ac_13_12(instruction);
6592 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6593
6594 std::string ac = AC(copy(ac_value));
6595 std::string rs = GPR(copy(rs_value));
6596 std::string rt = GPR(copy(rt_value));
6597
6598 return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6599 }
6600
6601
6602 /*
6603 *
6604 *
6605 * 3 2 1
6606 * 10987654321098765432109876543210
6607 * 001000 x1110000101
6608 * rt -----
6609 * rs -----
6610 * rd -----
6611 */
6612 std::string NMD::DPSQ_S_W_PH(uint64 instruction)
6613 {
6614 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6615 uint64 ac_value = extract_ac_13_12(instruction);
6616 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6617
6618 std::string ac = AC(copy(ac_value));
6619 std::string rs = GPR(copy(rs_value));
6620 std::string rt = GPR(copy(rt_value));
6621
6622 return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6623 }
6624
6625
6626 /*
6627 *
6628 *
6629 * 3 2 1
6630 * 10987654321098765432109876543210
6631 * 001000 x1110000101
6632 * rt -----
6633 * rs -----
6634 * rd -----
6635 */
6636 std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
6637 {
6638 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6639 uint64 ac_value = extract_ac_13_12(instruction);
6640 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6641
6642 std::string ac = AC(copy(ac_value));
6643 std::string rs = GPR(copy(rs_value));
6644 std::string rt = GPR(copy(rt_value));
6645
6646 return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6647 }
6648
6649
6650 /*
6651 *
6652 *
6653 * 3 2 1
6654 * 10987654321098765432109876543210
6655 * 001000 x1110000101
6656 * rt -----
6657 * rs -----
6658 * rd -----
6659 */
6660 std::string NMD::DPSQX_S_W_PH(uint64 instruction)
6661 {
6662 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6663 uint64 ac_value = extract_ac_13_12(instruction);
6664 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6665
6666 std::string ac = AC(copy(ac_value));
6667 std::string rs = GPR(copy(rs_value));
6668 std::string rt = GPR(copy(rt_value));
6669
6670 return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6671 }
6672
6673
6674 /*
6675 *
6676 *
6677 * 3 2 1
6678 * 10987654321098765432109876543210
6679 * 001000 x1110000101
6680 * rt -----
6681 * rs -----
6682 * rd -----
6683 */
6684 std::string NMD::DPSU_H_QBL(uint64 instruction)
6685 {
6686 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6687 uint64 ac_value = extract_ac_13_12(instruction);
6688 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6689
6690 std::string ac = AC(copy(ac_value));
6691 std::string rs = GPR(copy(rs_value));
6692 std::string rt = GPR(copy(rt_value));
6693
6694 return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6695 }
6696
6697
6698 /*
6699 *
6700 *
6701 * 3 2 1
6702 * 10987654321098765432109876543210
6703 * 001000 x1110000101
6704 * rt -----
6705 * rs -----
6706 * rd -----
6707 */
6708 std::string NMD::DPSU_H_QBR(uint64 instruction)
6709 {
6710 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6711 uint64 ac_value = extract_ac_13_12(instruction);
6712 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6713
6714 std::string ac = AC(copy(ac_value));
6715 std::string rs = GPR(copy(rs_value));
6716 std::string rt = GPR(copy(rt_value));
6717
6718 return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6719 }
6720
6721
6722 /*
6723 *
6724 *
6725 * 3 2 1
6726 * 10987654321098765432109876543210
6727 * 001000 x1110000101
6728 * rt -----
6729 * rs -----
6730 * rd -----
6731 */
6732 std::string NMD::DPSX_W_PH(uint64 instruction)
6733 {
6734 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6735 uint64 ac_value = extract_ac_13_12(instruction);
6736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6737
6738 std::string ac = AC(copy(ac_value));
6739 std::string rs = GPR(copy(rs_value));
6740 std::string rt = GPR(copy(rt_value));
6741
6742 return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6743 }
6744
6745
6746 /*
6747 * DROTR -
6748 *
6749 * 3 2 1
6750 * 10987654321098765432109876543210
6751 * 001000 x1110000101
6752 * rt -----
6753 * rs -----
6754 * rd -----
6755 */
6756 std::string NMD::DROTR(uint64 instruction)
6757 {
6758 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6759 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6760 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6761
6762 std::string rt = GPR(copy(rt_value));
6763 std::string rs = GPR(copy(rs_value));
6764 std::string shift = IMMEDIATE(copy(shift_value));
6765
6766 return img::format("DROTR %s, %s, %s", rt, rs, shift);
6767 }
6768
6769
6770 /*
6771 * DROTR[32] -
6772 *
6773 * 3 2 1
6774 * 10987654321098765432109876543210
6775 * 10o000 1100xxx0110
6776 * rt -----
6777 * rs -----
6778 * shift -----
6779 */
6780 std::string NMD::DROTR32(uint64 instruction)
6781 {
6782 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6783 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6784 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6785
6786 std::string rt = GPR(copy(rt_value));
6787 std::string rs = GPR(copy(rs_value));
6788 std::string shift = IMMEDIATE(copy(shift_value));
6789
6790 return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
6791 }
6792
6793
6794 /*
6795 *
6796 *
6797 * 3 2 1
6798 * 10987654321098765432109876543210
6799 * 001000 x1110000101
6800 * rt -----
6801 * rs -----
6802 * rd -----
6803 */
6804 std::string NMD::DROTRV(uint64 instruction)
6805 {
6806 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6807 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6808 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6809
6810 std::string rd = GPR(copy(rd_value));
6811 std::string rs = GPR(copy(rs_value));
6812 std::string rt = GPR(copy(rt_value));
6813
6814 return img::format("DROTRV %s, %s, %s", rd, rs, rt);
6815 }
6816
6817
6818 /*
6819 *
6820 *
6821 * 3 2 1
6822 * 10987654321098765432109876543210
6823 * 001000 x1110000101
6824 * rt -----
6825 * rs -----
6826 * rd -----
6827 */
6828 std::string NMD::DROTX(uint64 instruction)
6829 {
6830 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6831 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6832 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6834
6835 std::string rt = GPR(copy(rt_value));
6836 std::string rs = GPR(copy(rs_value));
6837 std::string shift = IMMEDIATE(copy(shift_value));
6838 std::string shiftx = IMMEDIATE(copy(shiftx_value));
6839
6840 return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
6841 }
6842
6843
6844 /*
6845 * DSLL -
6846 *
6847 * 3 2 1
6848 * 10987654321098765432109876543210
6849 * 10o000 1100xxx0000
6850 * rt -----
6851 * rs -----
6852 * shift -----
6853 */
6854 std::string NMD::DSLL(uint64 instruction)
6855 {
6856 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6857 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6858 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6859
6860 std::string rt = GPR(copy(rt_value));
6861 std::string rs = GPR(copy(rs_value));
6862 std::string shift = IMMEDIATE(copy(shift_value));
6863
6864 return img::format("DSLL %s, %s, %s", rt, rs, shift);
6865 }
6866
6867
6868 /*
6869 * DSLL[32] -
6870 *
6871 * 3 2 1
6872 * 10987654321098765432109876543210
6873 * 10o000 1100xxx0000
6874 * rt -----
6875 * rs -----
6876 * shift -----
6877 */
6878 std::string NMD::DSLL32(uint64 instruction)
6879 {
6880 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6881 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6882 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6883
6884 std::string rt = GPR(copy(rt_value));
6885 std::string rs = GPR(copy(rs_value));
6886 std::string shift = IMMEDIATE(copy(shift_value));
6887
6888 return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
6889 }
6890
6891
6892 /*
6893 *
6894 *
6895 * 3 2 1
6896 * 10987654321098765432109876543210
6897 * 001000 x1110000101
6898 * rt -----
6899 * rs -----
6900 * rd -----
6901 */
6902 std::string NMD::DSLLV(uint64 instruction)
6903 {
6904 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6905 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6906 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6907
6908 std::string rd = GPR(copy(rd_value));
6909 std::string rs = GPR(copy(rs_value));
6910 std::string rt = GPR(copy(rt_value));
6911
6912 return img::format("DSLLV %s, %s, %s", rd, rs, rt);
6913 }
6914
6915
6916 /*
6917 * DSRA -
6918 *
6919 * 3 2 1
6920 * 10987654321098765432109876543210
6921 * 10o000 1100xxx0100
6922 * rt -----
6923 * rs -----
6924 * shift -----
6925 */
6926 std::string NMD::DSRA(uint64 instruction)
6927 {
6928 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6929 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6930 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6931
6932 std::string rt = GPR(copy(rt_value));
6933 std::string rs = GPR(copy(rs_value));
6934 std::string shift = IMMEDIATE(copy(shift_value));
6935
6936 return img::format("DSRA %s, %s, %s", rt, rs, shift);
6937 }
6938
6939
6940 /*
6941 * DSRA[32] -
6942 *
6943 * 3 2 1
6944 * 10987654321098765432109876543210
6945 * 10o000 1100xxx0100
6946 * rt -----
6947 * rs -----
6948 * shift -----
6949 */
6950 std::string NMD::DSRA32(uint64 instruction)
6951 {
6952 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6953 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6954 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6955
6956 std::string rt = GPR(copy(rt_value));
6957 std::string rs = GPR(copy(rs_value));
6958 std::string shift = IMMEDIATE(copy(shift_value));
6959
6960 return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
6961 }
6962
6963
6964 /*
6965 *
6966 *
6967 * 3 2 1
6968 * 10987654321098765432109876543210
6969 * 001000 x1110000101
6970 * rt -----
6971 * rs -----
6972 * rd -----
6973 */
6974 std::string NMD::DSRAV(uint64 instruction)
6975 {
6976 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6977 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6978 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6979
6980 std::string rd = GPR(copy(rd_value));
6981 std::string rs = GPR(copy(rs_value));
6982 std::string rt = GPR(copy(rt_value));
6983
6984 return img::format("DSRAV %s, %s, %s", rd, rs, rt);
6985 }
6986
6987
6988 /*
6989 * DSRL -
6990 *
6991 * 3 2 1
6992 * 10987654321098765432109876543210
6993 * 10o000 1100xxx0100
6994 * rt -----
6995 * rs -----
6996 * shift -----
6997 */
6998 std::string NMD::DSRL(uint64 instruction)
6999 {
7000 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7001 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
7002 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7003
7004 std::string rt = GPR(copy(rt_value));
7005 std::string rs = GPR(copy(rs_value));
7006 std::string shift = IMMEDIATE(copy(shift_value));
7007
7008 return img::format("DSRL %s, %s, %s", rt, rs, shift);
7009 }
7010
7011
7012 /*
7013 * DSRL[32] -
7014 *
7015 * 3 2 1
7016 * 10987654321098765432109876543210
7017 * 10o000 1100xxx0010
7018 * rt -----
7019 * rs -----
7020 * shift -----
7021 */
7022 std::string NMD::DSRL32(uint64 instruction)
7023 {
7024 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7025 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
7026 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7027
7028 std::string rt = GPR(copy(rt_value));
7029 std::string rs = GPR(copy(rs_value));
7030 std::string shift = IMMEDIATE(copy(shift_value));
7031
7032 return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
7033 }
7034
7035
7036 /*
7037 *
7038 *
7039 * 3 2 1
7040 * 10987654321098765432109876543210
7041 * 001000 x1110000101
7042 * rt -----
7043 * rs -----
7044 * rd -----
7045 */
7046 std::string NMD::DSRLV(uint64 instruction)
7047 {
7048 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7049 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7050 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7051
7052 std::string rd = GPR(copy(rd_value));
7053 std::string rs = GPR(copy(rs_value));
7054 std::string rt = GPR(copy(rt_value));
7055
7056 return img::format("DSRLV %s, %s, %s", rd, rs, rt);
7057 }
7058
7059
7060 /*
7061 *
7062 *
7063 * 3 2 1
7064 * 10987654321098765432109876543210
7065 * 001000 x1110000101
7066 * rt -----
7067 * rs -----
7068 * rd -----
7069 */
7070 std::string NMD::DSUB(uint64 instruction)
7071 {
7072 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7073 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7074 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7075
7076 std::string rd = GPR(copy(rd_value));
7077 std::string rs = GPR(copy(rs_value));
7078 std::string rt = GPR(copy(rt_value));
7079
7080 return img::format("DSUB %s, %s, %s", rd, rs, rt);
7081 }
7082
7083
7084 /*
7085 *
7086 *
7087 * 3 2 1
7088 * 10987654321098765432109876543210
7089 * 001000 x1110000101
7090 * rt -----
7091 * rs -----
7092 * rd -----
7093 */
7094 std::string NMD::DSUBU(uint64 instruction)
7095 {
7096 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7097 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7098 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7099
7100 std::string rd = GPR(copy(rd_value));
7101 std::string rs = GPR(copy(rs_value));
7102 std::string rt = GPR(copy(rt_value));
7103
7104 return img::format("DSUBU %s, %s, %s", rd, rs, rt);
7105 }
7106
7107
7108 /*
7109 *
7110 *
7111 * 3 2 1
7112 * 10987654321098765432109876543210
7113 * 001000 x1110000101
7114 * rt -----
7115 * rs -----
7116 * rd -----
7117 */
7118 std::string NMD::DVPE(uint64 instruction)
7119 {
7120 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7121
7122 std::string rt = GPR(copy(rt_value));
7123
7124 return img::format("DVPE %s", rt);
7125 }
7126
7127
7128 /*
7129 *
7130 *
7131 * 3 2 1
7132 * 10987654321098765432109876543210
7133 * 001000 x1110000101
7134 * rt -----
7135 * rs -----
7136 * rd -----
7137 */
7138 std::string NMD::DVP(uint64 instruction)
7139 {
7140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7141
7142 std::string rt = GPR(copy(rt_value));
7143
7144 return img::format("DVP %s", rt);
7145 }
7146
7147
7148 /*
7149 *
7150 *
7151 * 3 2 1
7152 * 10987654321098765432109876543210
7153 * 001000 x1110000101
7154 * rt -----
7155 * rs -----
7156 * rd -----
7157 */
7158 std::string NMD::EHB(uint64 instruction)
7159 {
7160 (void)instruction;
7161
7162 return "EHB ";
7163 }
7164
7165
7166 /*
7167 *
7168 *
7169 * 3 2 1
7170 * 10987654321098765432109876543210
7171 * 001000 x1110000101
7172 * rt -----
7173 * rs -----
7174 * rd -----
7175 */
7176 std::string NMD::EI(uint64 instruction)
7177 {
7178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7179
7180 std::string rt = GPR(copy(rt_value));
7181
7182 return img::format("EI %s", rt);
7183 }
7184
7185
7186 /*
7187 *
7188 *
7189 * 3 2 1
7190 * 10987654321098765432109876543210
7191 * 001000 x1110000101
7192 * rt -----
7193 * rs -----
7194 * rd -----
7195 */
7196 std::string NMD::EMT(uint64 instruction)
7197 {
7198 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7199
7200 std::string rt = GPR(copy(rt_value));
7201
7202 return img::format("EMT %s", rt);
7203 }
7204
7205
7206 /*
7207 *
7208 *
7209 * 3 2 1
7210 * 10987654321098765432109876543210
7211 * 001000 x1110000101
7212 * rt -----
7213 * rs -----
7214 * rd -----
7215 */
7216 std::string NMD::ERET(uint64 instruction)
7217 {
7218 (void)instruction;
7219
7220 return "ERET ";
7221 }
7222
7223
7224 /*
7225 *
7226 *
7227 * 3 2 1
7228 * 10987654321098765432109876543210
7229 * 001000 x1110000101
7230 * rt -----
7231 * rs -----
7232 * rd -----
7233 */
7234 std::string NMD::ERETNC(uint64 instruction)
7235 {
7236 (void)instruction;
7237
7238 return "ERETNC ";
7239 }
7240
7241
7242 /*
7243 *
7244 *
7245 * 3 2 1
7246 * 10987654321098765432109876543210
7247 * 001000 x1110000101
7248 * rt -----
7249 * rs -----
7250 * rd -----
7251 */
7252 std::string NMD::EVP(uint64 instruction)
7253 {
7254 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7255
7256 std::string rt = GPR(copy(rt_value));
7257
7258 return img::format("EVP %s", rt);
7259 }
7260
7261
7262 /*
7263 *
7264 *
7265 * 3 2 1
7266 * 10987654321098765432109876543210
7267 * 001000 x1110000101
7268 * rt -----
7269 * rs -----
7270 * rd -----
7271 */
7272 std::string NMD::EVPE(uint64 instruction)
7273 {
7274 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7275
7276 std::string rt = GPR(copy(rt_value));
7277
7278 return img::format("EVPE %s", rt);
7279 }
7280
7281
7282 /*
7283 *
7284 *
7285 * 3 2 1
7286 * 10987654321098765432109876543210
7287 * 001000 x1110000101
7288 * rt -----
7289 * rs -----
7290 * rd -----
7291 */
7292 std::string NMD::EXT(uint64 instruction)
7293 {
7294 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7295 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7296 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7297 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7298
7299 std::string rt = GPR(copy(rt_value));
7300 std::string rs = GPR(copy(rs_value));
7301 std::string lsb = IMMEDIATE(copy(lsb_value));
7302 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
7303
7304 return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
7305 }
7306
7307
7308 /*
7309 *
7310 *
7311 * 3 2 1
7312 * 10987654321098765432109876543210
7313 * 001000 x1110000101
7314 * rt -----
7315 * rs -----
7316 * rd -----
7317 */
7318 std::string NMD::EXTD(uint64 instruction)
7319 {
7320 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7321 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7322 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7323 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7324
7325 std::string rd = GPR(copy(rd_value));
7326 std::string rs = GPR(copy(rs_value));
7327 std::string rt = GPR(copy(rt_value));
7328 std::string shift = IMMEDIATE(copy(shift_value));
7329
7330 return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
7331 }
7332
7333
7334 /*
7335 *
7336 *
7337 * 3 2 1
7338 * 10987654321098765432109876543210
7339 * 001000 x1110000101
7340 * rt -----
7341 * rs -----
7342 * rd -----
7343 */
7344 std::string NMD::EXTD32(uint64 instruction)
7345 {
7346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7347 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7348 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7349 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7350
7351 std::string rd = GPR(copy(rd_value));
7352 std::string rs = GPR(copy(rs_value));
7353 std::string rt = GPR(copy(rt_value));
7354 std::string shift = IMMEDIATE(copy(shift_value));
7355
7356 return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
7357 }
7358
7359
7360 /*
7361 *
7362 *
7363 * 3 2 1
7364 * 10987654321098765432109876543210
7365 * 001000 x1110000101
7366 * rt -----
7367 * rs -----
7368 * rd -----
7369 */
7370 std::string NMD::EXTPDP(uint64 instruction)
7371 {
7372 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7373 uint64 ac_value = extract_ac_13_12(instruction);
7374 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7375
7376 std::string rt = GPR(copy(rt_value));
7377 std::string ac = AC(copy(ac_value));
7378 std::string size = IMMEDIATE(copy(size_value));
7379
7380 return img::format("EXTPDP %s, %s, %s", rt, ac, size);
7381 }
7382
7383
7384 /*
7385 *
7386 *
7387 * 3 2 1
7388 * 10987654321098765432109876543210
7389 * 001000 x1110000101
7390 * rt -----
7391 * rs -----
7392 * rd -----
7393 */
7394 std::string NMD::EXTPDPV(uint64 instruction)
7395 {
7396 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7397 uint64 ac_value = extract_ac_13_12(instruction);
7398 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7399
7400 std::string rt = GPR(copy(rt_value));
7401 std::string ac = AC(copy(ac_value));
7402 std::string rs = GPR(copy(rs_value));
7403
7404 return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
7405 }
7406
7407
7408 /*
7409 *
7410 *
7411 * 3 2 1
7412 * 10987654321098765432109876543210
7413 * 001000 x1110000101
7414 * rt -----
7415 * rs -----
7416 * rd -----
7417 */
7418 std::string NMD::EXTP(uint64 instruction)
7419 {
7420 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7421 uint64 ac_value = extract_ac_13_12(instruction);
7422 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7423
7424 std::string rt = GPR(copy(rt_value));
7425 std::string ac = AC(copy(ac_value));
7426 std::string size = IMMEDIATE(copy(size_value));
7427
7428 return img::format("EXTP %s, %s, %s", rt, ac, size);
7429 }
7430
7431
7432 /*
7433 *
7434 *
7435 * 3 2 1
7436 * 10987654321098765432109876543210
7437 * 001000 x1110000101
7438 * rt -----
7439 * rs -----
7440 * rd -----
7441 */
7442 std::string NMD::EXTPV(uint64 instruction)
7443 {
7444 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7445 uint64 ac_value = extract_ac_13_12(instruction);
7446 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7447
7448 std::string rt = GPR(copy(rt_value));
7449 std::string ac = AC(copy(ac_value));
7450 std::string rs = GPR(copy(rs_value));
7451
7452 return img::format("EXTPV %s, %s, %s", rt, ac, rs);
7453 }
7454
7455
7456 /*
7457 *
7458 *
7459 * 3 2 1
7460 * 10987654321098765432109876543210
7461 * 001000 x1110000101
7462 * rt -----
7463 * rs -----
7464 * rd -----
7465 */
7466 std::string NMD::EXTR_RS_W(uint64 instruction)
7467 {
7468 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7469 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7470 uint64 ac_value = extract_ac_13_12(instruction);
7471
7472 std::string rt = GPR(copy(rt_value));
7473 std::string ac = AC(copy(ac_value));
7474 std::string shift = IMMEDIATE(copy(shift_value));
7475
7476 return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
7477 }
7478
7479
7480 /*
7481 *
7482 *
7483 * 3 2 1
7484 * 10987654321098765432109876543210
7485 * 001000 x1110000101
7486 * rt -----
7487 * rs -----
7488 * rd -----
7489 */
7490 std::string NMD::EXTR_R_W(uint64 instruction)
7491 {
7492 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7493 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7494 uint64 ac_value = extract_ac_13_12(instruction);
7495
7496 std::string rt = GPR(copy(rt_value));
7497 std::string ac = AC(copy(ac_value));
7498 std::string shift = IMMEDIATE(copy(shift_value));
7499
7500 return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
7501 }
7502
7503
7504 /*
7505 *
7506 *
7507 * 3 2 1
7508 * 10987654321098765432109876543210
7509 * 001000 x1110000101
7510 * rt -----
7511 * rs -----
7512 * rd -----
7513 */
7514 std::string NMD::EXTR_S_H(uint64 instruction)
7515 {
7516 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7517 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7518 uint64 ac_value = extract_ac_13_12(instruction);
7519
7520 std::string rt = GPR(copy(rt_value));
7521 std::string ac = AC(copy(ac_value));
7522 std::string shift = IMMEDIATE(copy(shift_value));
7523
7524 return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
7525 }
7526
7527
7528 /*
7529 *
7530 *
7531 * 3 2 1
7532 * 10987654321098765432109876543210
7533 * 001000 x1110000101
7534 * rt -----
7535 * rs -----
7536 * rd -----
7537 */
7538 std::string NMD::EXTR_W(uint64 instruction)
7539 {
7540 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7541 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7542 uint64 ac_value = extract_ac_13_12(instruction);
7543
7544 std::string rt = GPR(copy(rt_value));
7545 std::string ac = AC(copy(ac_value));
7546 std::string shift = IMMEDIATE(copy(shift_value));
7547
7548 return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
7549 }
7550
7551
7552 /*
7553 *
7554 *
7555 * 3 2 1
7556 * 10987654321098765432109876543210
7557 * 001000 x1110000101
7558 * rt -----
7559 * rs -----
7560 * rd -----
7561 */
7562 std::string NMD::EXTRV_RS_W(uint64 instruction)
7563 {
7564 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7565 uint64 ac_value = extract_ac_13_12(instruction);
7566 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7567
7568 std::string rt = GPR(copy(rt_value));
7569 std::string ac = AC(copy(ac_value));
7570 std::string rs = GPR(copy(rs_value));
7571
7572 return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7573 }
7574
7575
7576 /*
7577 *
7578 *
7579 * 3 2 1
7580 * 10987654321098765432109876543210
7581 * 001000 x1110000101
7582 * rt -----
7583 * rs -----
7584 * rd -----
7585 */
7586 std::string NMD::EXTRV_R_W(uint64 instruction)
7587 {
7588 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7589 uint64 ac_value = extract_ac_13_12(instruction);
7590 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7591
7592 std::string rt = GPR(copy(rt_value));
7593 std::string ac = AC(copy(ac_value));
7594 std::string rs = GPR(copy(rs_value));
7595
7596 return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7597 }
7598
7599
7600 /*
7601 *
7602 *
7603 * 3 2 1
7604 * 10987654321098765432109876543210
7605 * 001000 x1110000101
7606 * rt -----
7607 * rs -----
7608 * rd -----
7609 */
7610 std::string NMD::EXTRV_S_H(uint64 instruction)
7611 {
7612 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7613 uint64 ac_value = extract_ac_13_12(instruction);
7614 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7615
7616 std::string rt = GPR(copy(rt_value));
7617 std::string ac = AC(copy(ac_value));
7618 std::string rs = GPR(copy(rs_value));
7619
7620 return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7621 }
7622
7623
7624 /*
7625 *
7626 *
7627 * 3 2 1
7628 * 10987654321098765432109876543210
7629 * 001000 x1110000101
7630 * rt -----
7631 * rs -----
7632 * rd -----
7633 */
7634 std::string NMD::EXTRV_W(uint64 instruction)
7635 {
7636 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7637 uint64 ac_value = extract_ac_13_12(instruction);
7638 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7639
7640 std::string rt = GPR(copy(rt_value));
7641 std::string ac = AC(copy(ac_value));
7642 std::string rs = GPR(copy(rs_value));
7643
7644 return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
7645 }
7646
7647
7648 /*
7649 * EXTW - Extract Word
7650 *
7651 * 3 2 1
7652 * 10987654321098765432109876543210
7653 * 001000 011111
7654 * rt -----
7655 * rs -----
7656 * rd -----
7657 * shift -----
7658 */
7659 std::string NMD::EXTW(uint64 instruction)
7660 {
7661 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7662 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7663 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7664 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7665
7666 std::string rd = GPR(copy(rd_value));
7667 std::string rs = GPR(copy(rs_value));
7668 std::string rt = GPR(copy(rt_value));
7669 std::string shift = IMMEDIATE(copy(shift_value));
7670
7671 return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
7672 }
7673
7674
7675 /*
7676 *
7677 *
7678 * 3 2 1
7679 * 10987654321098765432109876543210
7680 * 001000 x1110000101
7681 * rt -----
7682 * rs -----
7683 * rd -----
7684 */
7685 std::string NMD::FLOOR_L_D(uint64 instruction)
7686 {
7687 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7688 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7689
7690 std::string ft = FPR(copy(ft_value));
7691 std::string fs = FPR(copy(fs_value));
7692
7693 return img::format("FLOOR.L.D %s, %s", ft, fs);
7694 }
7695
7696
7697 /*
7698 *
7699 *
7700 * 3 2 1
7701 * 10987654321098765432109876543210
7702 * 001000 x1110000101
7703 * rt -----
7704 * rs -----
7705 * rd -----
7706 */
7707 std::string NMD::FLOOR_L_S(uint64 instruction)
7708 {
7709 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7710 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7711
7712 std::string ft = FPR(copy(ft_value));
7713 std::string fs = FPR(copy(fs_value));
7714
7715 return img::format("FLOOR.L.S %s, %s", ft, fs);
7716 }
7717
7718
7719 /*
7720 *
7721 *
7722 * 3 2 1
7723 * 10987654321098765432109876543210
7724 * 001000 x1110000101
7725 * rt -----
7726 * rs -----
7727 * rd -----
7728 */
7729 std::string NMD::FLOOR_W_D(uint64 instruction)
7730 {
7731 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7732 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7733
7734 std::string ft = FPR(copy(ft_value));
7735 std::string fs = FPR(copy(fs_value));
7736
7737 return img::format("FLOOR.W.D %s, %s", ft, fs);
7738 }
7739
7740
7741 /*
7742 *
7743 *
7744 * 3 2 1
7745 * 10987654321098765432109876543210
7746 * 001000 x1110000101
7747 * rt -----
7748 * rs -----
7749 * rd -----
7750 */
7751 std::string NMD::FLOOR_W_S(uint64 instruction)
7752 {
7753 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7754 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7755
7756 std::string ft = FPR(copy(ft_value));
7757 std::string fs = FPR(copy(fs_value));
7758
7759 return img::format("FLOOR.W.S %s, %s", ft, fs);
7760 }
7761
7762
7763 /*
7764 *
7765 *
7766 * 3 2 1
7767 * 10987654321098765432109876543210
7768 * 001000 x1110000101
7769 * rt -----
7770 * rs -----
7771 * rd -----
7772 */
7773 std::string NMD::FORK(uint64 instruction)
7774 {
7775 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7776 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7777 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7778
7779 std::string rd = GPR(copy(rd_value));
7780 std::string rs = GPR(copy(rs_value));
7781 std::string rt = GPR(copy(rt_value));
7782
7783 return img::format("FORK %s, %s, %s", rd, rs, rt);
7784 }
7785
7786
7787 /*
7788 *
7789 *
7790 * 3 2 1
7791 * 10987654321098765432109876543210
7792 * 001000 x1110000101
7793 * rt -----
7794 * rs -----
7795 * rd -----
7796 */
7797 std::string NMD::HYPCALL(uint64 instruction)
7798 {
7799 uint64 code_value = extract_code_17_to_0(instruction);
7800
7801 std::string code = IMMEDIATE(copy(code_value));
7802
7803 return img::format("HYPCALL %s", code);
7804 }
7805
7806
7807 /*
7808 *
7809 *
7810 * 3 2 1
7811 * 10987654321098765432109876543210
7812 * 001000 x1110000101
7813 * rt -----
7814 * rs -----
7815 * rd -----
7816 */
7817 std::string NMD::HYPCALL_16_(uint64 instruction)
7818 {
7819 uint64 code_value = extract_code_1_0(instruction);
7820
7821 std::string code = IMMEDIATE(copy(code_value));
7822
7823 return img::format("HYPCALL %s", code);
7824 }
7825
7826
7827 /*
7828 *
7829 *
7830 * 3 2 1
7831 * 10987654321098765432109876543210
7832 * 001000 x1110000101
7833 * rt -----
7834 * rs -----
7835 * rd -----
7836 */
7837 std::string NMD::INS(uint64 instruction)
7838 {
7839 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7840 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7841 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7842 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7843
7844 std::string rt = GPR(copy(rt_value));
7845 std::string rs = GPR(copy(rs_value));
7846 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
7847 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
7848 /* !!!!!!!!!! - no conversion function */
7849
7850 return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
7851 /* hand edited */
7852 }
7853
7854
7855 /*
7856 *
7857 *
7858 * 3 2 1
7859 * 10987654321098765432109876543210
7860 * 001000 x1110000101
7861 * rt -----
7862 * rs -----
7863 * rd -----
7864 */
7865 std::string NMD::INSV(uint64 instruction)
7866 {
7867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7868 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7869
7870 std::string rt = GPR(copy(rt_value));
7871 std::string rs = GPR(copy(rs_value));
7872
7873 return img::format("INSV %s, %s", rt, rs);
7874 }
7875
7876
7877 /*
7878 *
7879 *
7880 * 3 2 1
7881 * 10987654321098765432109876543210
7882 * 001000 x1110000101
7883 * rt -----
7884 * rs -----
7885 * rd -----
7886 */
7887 std::string NMD::IRET(uint64 instruction)
7888 {
7889 (void)instruction;
7890
7891 return "IRET ";
7892 }
7893
7894
7895 /*
7896 *
7897 *
7898 * 3 2 1
7899 * 10987654321098765432109876543210
7900 * 001000 x1110000101
7901 * rt -----
7902 * rs -----
7903 * rd -----
7904 */
7905 std::string NMD::JALRC_16_(uint64 instruction)
7906 {
7907 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7908
7909 std::string rt = GPR(copy(rt_value));
7910
7911 return img::format("JALRC $%d, %s", 31, rt);
7912 }
7913
7914
7915 /*
7916 *
7917 *
7918 * 3 2 1
7919 * 10987654321098765432109876543210
7920 * 001000 x1110000101
7921 * rt -----
7922 * rs -----
7923 * rd -----
7924 */
7925 std::string NMD::JALRC_32_(uint64 instruction)
7926 {
7927 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7928 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7929
7930 std::string rt = GPR(copy(rt_value));
7931 std::string rs = GPR(copy(rs_value));
7932
7933 return img::format("JALRC %s, %s", rt, rs);
7934 }
7935
7936
7937 /*
7938 *
7939 *
7940 * 3 2 1
7941 * 10987654321098765432109876543210
7942 * 001000 x1110000101
7943 * rt -----
7944 * rs -----
7945 * rd -----
7946 */
7947 std::string NMD::JALRC_HB(uint64 instruction)
7948 {
7949 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7950 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7951
7952 std::string rt = GPR(copy(rt_value));
7953 std::string rs = GPR(copy(rs_value));
7954
7955 return img::format("JALRC.HB %s, %s", rt, rs);
7956 }
7957
7958
7959 /*
7960 *
7961 *
7962 * 3 2 1
7963 * 10987654321098765432109876543210
7964 * 001000 x1110000101
7965 * rt -----
7966 * rs -----
7967 * rd -----
7968 */
7969 std::string NMD::JRC(uint64 instruction)
7970 {
7971 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7972
7973 std::string rt = GPR(copy(rt_value));
7974
7975 return img::format("JRC %s", rt);
7976 }
7977
7978
7979 /*
7980 *
7981 *
7982 * 3 2 1
7983 * 10987654321098765432109876543210
7984 * 001000 x1110000101
7985 * rt -----
7986 * rs -----
7987 * rd -----
7988 */
7989 std::string NMD::LB_16_(uint64 instruction)
7990 {
7991 uint64 u_value = extract_u_1_0(instruction);
7992 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7993 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7994
7995 std::string rt3 = GPR(encode_gpr3(rt3_value));
7996 std::string u = IMMEDIATE(copy(u_value));
7997 std::string rs3 = GPR(encode_gpr3(rs3_value));
7998
7999 return img::format("LB %s, %s(%s)", rt3, u, rs3);
8000 }
8001
8002
8003 /*
8004 *
8005 *
8006 * 3 2 1
8007 * 10987654321098765432109876543210
8008 * 001000 x1110000101
8009 * rt -----
8010 * rs -----
8011 * rd -----
8012 */
8013 std::string NMD::LB_GP_(uint64 instruction)
8014 {
8015 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8016 uint64 u_value = extract_u_17_to_0(instruction);
8017
8018 std::string rt = GPR(copy(rt_value));
8019 std::string u = IMMEDIATE(copy(u_value));
8020
8021 return img::format("LB %s, %s($%d)", rt, u, 28);
8022 }
8023
8024
8025 /*
8026 *
8027 *
8028 * 3 2 1
8029 * 10987654321098765432109876543210
8030 * 001000 x1110000101
8031 * rt -----
8032 * rs -----
8033 * rd -----
8034 */
8035 std::string NMD::LB_S9_(uint64 instruction)
8036 {
8037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8038 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8039 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8040
8041 std::string rt = GPR(copy(rt_value));
8042 std::string s = IMMEDIATE(copy(s_value));
8043 std::string rs = GPR(copy(rs_value));
8044
8045 return img::format("LB %s, %s(%s)", rt, s, rs);
8046 }
8047
8048
8049 /*
8050 *
8051 *
8052 * 3 2 1
8053 * 10987654321098765432109876543210
8054 * 001000 x1110000101
8055 * rt -----
8056 * rs -----
8057 * rd -----
8058 */
8059 std::string NMD::LB_U12_(uint64 instruction)
8060 {
8061 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8062 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8063 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8064
8065 std::string rt = GPR(copy(rt_value));
8066 std::string u = IMMEDIATE(copy(u_value));
8067 std::string rs = GPR(copy(rs_value));
8068
8069 return img::format("LB %s, %s(%s)", rt, u, rs);
8070 }
8071
8072
8073 /*
8074 *
8075 *
8076 * 3 2 1
8077 * 10987654321098765432109876543210
8078 * 001000 x1110000101
8079 * rt -----
8080 * rs -----
8081 * rd -----
8082 */
8083 std::string NMD::LBE(uint64 instruction)
8084 {
8085 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8086 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8087 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8088
8089 std::string rt = GPR(copy(rt_value));
8090 std::string s = IMMEDIATE(copy(s_value));
8091 std::string rs = GPR(copy(rs_value));
8092
8093 return img::format("LBE %s, %s(%s)", rt, s, rs);
8094 }
8095
8096
8097 /*
8098 *
8099 *
8100 * 3 2 1
8101 * 10987654321098765432109876543210
8102 * 001000 x1110000101
8103 * rt -----
8104 * rs -----
8105 * rd -----
8106 */
8107 std::string NMD::LBU_16_(uint64 instruction)
8108 {
8109 uint64 u_value = extract_u_1_0(instruction);
8110 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8111 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8112
8113 std::string rt3 = GPR(encode_gpr3(rt3_value));
8114 std::string u = IMMEDIATE(copy(u_value));
8115 std::string rs3 = GPR(encode_gpr3(rs3_value));
8116
8117 return img::format("LBU %s, %s(%s)", rt3, u, rs3);
8118 }
8119
8120
8121 /*
8122 *
8123 *
8124 * 3 2 1
8125 * 10987654321098765432109876543210
8126 * 001000 x1110000101
8127 * rt -----
8128 * rs -----
8129 * rd -----
8130 */
8131 std::string NMD::LBU_GP_(uint64 instruction)
8132 {
8133 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8134 uint64 u_value = extract_u_17_to_0(instruction);
8135
8136 std::string rt = GPR(copy(rt_value));
8137 std::string u = IMMEDIATE(copy(u_value));
8138
8139 return img::format("LBU %s, %s($%d)", rt, u, 28);
8140 }
8141
8142
8143 /*
8144 *
8145 *
8146 * 3 2 1
8147 * 10987654321098765432109876543210
8148 * 001000 x1110000101
8149 * rt -----
8150 * rs -----
8151 * rd -----
8152 */
8153 std::string NMD::LBU_S9_(uint64 instruction)
8154 {
8155 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8156 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8157 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8158
8159 std::string rt = GPR(copy(rt_value));
8160 std::string s = IMMEDIATE(copy(s_value));
8161 std::string rs = GPR(copy(rs_value));
8162
8163 return img::format("LBU %s, %s(%s)", rt, s, rs);
8164 }
8165
8166
8167 /*
8168 *
8169 *
8170 * 3 2 1
8171 * 10987654321098765432109876543210
8172 * 001000 x1110000101
8173 * rt -----
8174 * rs -----
8175 * rd -----
8176 */
8177 std::string NMD::LBU_U12_(uint64 instruction)
8178 {
8179 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8180 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8181 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8182
8183 std::string rt = GPR(copy(rt_value));
8184 std::string u = IMMEDIATE(copy(u_value));
8185 std::string rs = GPR(copy(rs_value));
8186
8187 return img::format("LBU %s, %s(%s)", rt, u, rs);
8188 }
8189
8190
8191 /*
8192 *
8193 *
8194 * 3 2 1
8195 * 10987654321098765432109876543210
8196 * 001000 x1110000101
8197 * rt -----
8198 * rs -----
8199 * rd -----
8200 */
8201 std::string NMD::LBUE(uint64 instruction)
8202 {
8203 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8204 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8205 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8206
8207 std::string rt = GPR(copy(rt_value));
8208 std::string s = IMMEDIATE(copy(s_value));
8209 std::string rs = GPR(copy(rs_value));
8210
8211 return img::format("LBUE %s, %s(%s)", rt, s, rs);
8212 }
8213
8214
8215 /*
8216 *
8217 *
8218 * 3 2 1
8219 * 10987654321098765432109876543210
8220 * 001000 x1110000101
8221 * rt -----
8222 * rs -----
8223 * rd -----
8224 */
8225 std::string NMD::LBUX(uint64 instruction)
8226 {
8227 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8228 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8229 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8230
8231 std::string rd = GPR(copy(rd_value));
8232 std::string rs = GPR(copy(rs_value));
8233 std::string rt = GPR(copy(rt_value));
8234
8235 return img::format("LBUX %s, %s(%s)", rd, rs, rt);
8236 }
8237
8238
8239 /*
8240 *
8241 *
8242 * 3 2 1
8243 * 10987654321098765432109876543210
8244 * 001000 x1110000101
8245 * rt -----
8246 * rs -----
8247 * rd -----
8248 */
8249 std::string NMD::LBX(uint64 instruction)
8250 {
8251 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8252 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8253 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8254
8255 std::string rd = GPR(copy(rd_value));
8256 std::string rs = GPR(copy(rs_value));
8257 std::string rt = GPR(copy(rt_value));
8258
8259 return img::format("LBX %s, %s(%s)", rd, rs, rt);
8260 }
8261
8262
8263 /*
8264 *
8265 *
8266 * 3 2 1
8267 * 10987654321098765432109876543210
8268 * 001000 x1110000101
8269 * rt -----
8270 * rs -----
8271 * rd -----
8272 */
8273 std::string NMD::LD_GP_(uint64 instruction)
8274 {
8275 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8276 uint64 u_value = extr_uil3il3bs18Fmsb20(instruction);
8277
8278 std::string rt = GPR(copy(rt_value));
8279 std::string u = IMMEDIATE(copy(u_value));
8280
8281 return img::format("LD %s, %s($%d)", rt, u, 28);
8282 }
8283
8284
8285 /*
8286 *
8287 *
8288 * 3 2 1
8289 * 10987654321098765432109876543210
8290 * 001000 x1110000101
8291 * rt -----
8292 * rs -----
8293 * rd -----
8294 */
8295 std::string NMD::LD_S9_(uint64 instruction)
8296 {
8297 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8298 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8299 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8300
8301 std::string rt = GPR(copy(rt_value));
8302 std::string s = IMMEDIATE(copy(s_value));
8303 std::string rs = GPR(copy(rs_value));
8304
8305 return img::format("LD %s, %s(%s)", rt, s, rs);
8306 }
8307
8308
8309 /*
8310 *
8311 *
8312 * 3 2 1
8313 * 10987654321098765432109876543210
8314 * 001000 x1110000101
8315 * rt -----
8316 * rs -----
8317 * rd -----
8318 */
8319 std::string NMD::LD_U12_(uint64 instruction)
8320 {
8321 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8322 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8323 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8324
8325 std::string rt = GPR(copy(rt_value));
8326 std::string u = IMMEDIATE(copy(u_value));
8327 std::string rs = GPR(copy(rs_value));
8328
8329 return img::format("LD %s, %s(%s)", rt, u, rs);
8330 }
8331
8332
8333 /*
8334 *
8335 *
8336 * 3 2 1
8337 * 10987654321098765432109876543210
8338 * 001000 x1110000101
8339 * rt -----
8340 * rs -----
8341 * rd -----
8342 */
8343 std::string NMD::LDC1_GP_(uint64 instruction)
8344 {
8345 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8346 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
8347
8348 std::string ft = FPR(copy(ft_value));
8349 std::string u = IMMEDIATE(copy(u_value));
8350
8351 return img::format("LDC1 %s, %s($%d)", ft, u, 28);
8352 }
8353
8354
8355 /*
8356 *
8357 *
8358 * 3 2 1
8359 * 10987654321098765432109876543210
8360 * 001000 x1110000101
8361 * rt -----
8362 * rs -----
8363 * rd -----
8364 */
8365 std::string NMD::LDC1_S9_(uint64 instruction)
8366 {
8367 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8368 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8369 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8370
8371 std::string ft = FPR(copy(ft_value));
8372 std::string s = IMMEDIATE(copy(s_value));
8373 std::string rs = GPR(copy(rs_value));
8374
8375 return img::format("LDC1 %s, %s(%s)", ft, s, rs);
8376 }
8377
8378
8379 /*
8380 *
8381 *
8382 * 3 2 1
8383 * 10987654321098765432109876543210
8384 * 001000 x1110000101
8385 * rt -----
8386 * rs -----
8387 * rd -----
8388 */
8389 std::string NMD::LDC1_U12_(uint64 instruction)
8390 {
8391 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8392 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8393 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8394
8395 std::string ft = FPR(copy(ft_value));
8396 std::string u = IMMEDIATE(copy(u_value));
8397 std::string rs = GPR(copy(rs_value));
8398
8399 return img::format("LDC1 %s, %s(%s)", ft, u, rs);
8400 }
8401
8402
8403 /*
8404 *
8405 *
8406 * 3 2 1
8407 * 10987654321098765432109876543210
8408 * 001000 x1110000101
8409 * rt -----
8410 * rs -----
8411 * rd -----
8412 */
8413 std::string NMD::LDC1XS(uint64 instruction)
8414 {
8415 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8416 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8417 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8418
8419 std::string ft = FPR(copy(ft_value));
8420 std::string rs = GPR(copy(rs_value));
8421 std::string rt = GPR(copy(rt_value));
8422
8423 return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
8424 }
8425
8426
8427 /*
8428 *
8429 *
8430 * 3 2 1
8431 * 10987654321098765432109876543210
8432 * 001000 x1110000101
8433 * rt -----
8434 * rs -----
8435 * rd -----
8436 */
8437 std::string NMD::LDC1X(uint64 instruction)
8438 {
8439 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8440 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8441 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8442
8443 std::string ft = FPR(copy(ft_value));
8444 std::string rs = GPR(copy(rs_value));
8445 std::string rt = GPR(copy(rt_value));
8446
8447 return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
8448 }
8449
8450
8451 /*
8452 *
8453 *
8454 * 3 2 1
8455 * 10987654321098765432109876543210
8456 * 001000 x1110000101
8457 * rt -----
8458 * rs -----
8459 * rd -----
8460 */
8461 std::string NMD::LDC2(uint64 instruction)
8462 {
8463 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8464 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8465 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8466
8467 std::string ct = CPR(copy(ct_value));
8468 std::string s = IMMEDIATE(copy(s_value));
8469 std::string rs = GPR(copy(rs_value));
8470
8471 return img::format("LDC2 %s, %s(%s)", ct, s, rs);
8472 }
8473
8474
8475 /*
8476 *
8477 *
8478 * 3 2 1
8479 * 10987654321098765432109876543210
8480 * 001000 x1110000101
8481 * rt -----
8482 * rs -----
8483 * rd -----
8484 */
8485 std::string NMD::LDM(uint64 instruction)
8486 {
8487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8488 uint64 count3_value = extract_count3_14_13_12(instruction);
8489 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8490 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8491
8492 std::string rt = GPR(copy(rt_value));
8493 std::string s = IMMEDIATE(copy(s_value));
8494 std::string rs = GPR(copy(rs_value));
8495 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
8496
8497 return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
8498 }
8499
8500
8501 /*
8502 *
8503 *
8504 * 3 2 1
8505 * 10987654321098765432109876543210
8506 * 001000 x1110000101
8507 * rt -----
8508 * rs -----
8509 * rd -----
8510 */
8511 std::string NMD::LDPC_48_(uint64 instruction)
8512 {
8513 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8514 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
8515
8516 std::string rt = GPR(copy(rt_value));
8517 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
8518
8519 return img::format("LDPC %s, %s", rt, s);
8520 }
8521
8522
8523 /*
8524 *
8525 *
8526 * 3 2 1
8527 * 10987654321098765432109876543210
8528 * 001000 x1110000101
8529 * rt -----
8530 * rs -----
8531 * rd -----
8532 */
8533 std::string NMD::LDX(uint64 instruction)
8534 {
8535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8536 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8537 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8538
8539 std::string rd = GPR(copy(rd_value));
8540 std::string rs = GPR(copy(rs_value));
8541 std::string rt = GPR(copy(rt_value));
8542
8543 return img::format("LDX %s, %s(%s)", rd, rs, rt);
8544 }
8545
8546
8547 /*
8548 *
8549 *
8550 * 3 2 1
8551 * 10987654321098765432109876543210
8552 * 001000 x1110000101
8553 * rt -----
8554 * rs -----
8555 * rd -----
8556 */
8557 std::string NMD::LDXS(uint64 instruction)
8558 {
8559 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8560 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8561 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8562
8563 std::string rd = GPR(copy(rd_value));
8564 std::string rs = GPR(copy(rs_value));
8565 std::string rt = GPR(copy(rt_value));
8566
8567 return img::format("LDXS %s, %s(%s)", rd, rs, rt);
8568 }
8569
8570
8571 /*
8572 *
8573 *
8574 * 3 2 1
8575 * 10987654321098765432109876543210
8576 * 001000 x1110000101
8577 * rt -----
8578 * rs -----
8579 * rd -----
8580 */
8581 std::string NMD::LH_16_(uint64 instruction)
8582 {
8583 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
8584 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8585 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8586
8587 std::string rt3 = GPR(encode_gpr3(rt3_value));
8588 std::string u = IMMEDIATE(copy(u_value));
8589 std::string rs3 = GPR(encode_gpr3(rs3_value));
8590
8591 return img::format("LH %s, %s(%s)", rt3, u, rs3);
8592 }
8593
8594
8595 /*
8596 *
8597 *
8598 * 3 2 1
8599 * 10987654321098765432109876543210
8600 * 001000 x1110000101
8601 * rt -----
8602 * rs -----
8603 * rd -----
8604 */
8605 std::string NMD::LH_GP_(uint64 instruction)
8606 {
8607 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8608 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
8609
8610 std::string rt = GPR(copy(rt_value));
8611 std::string u = IMMEDIATE(copy(u_value));
8612
8613 return img::format("LH %s, %s($%d)", rt, u, 28);
8614 }
8615
8616
8617 /*
8618 *
8619 *
8620 * 3 2 1
8621 * 10987654321098765432109876543210
8622 * 001000 x1110000101
8623 * rt -----
8624 * rs -----
8625 * rd -----
8626 */
8627 std::string NMD::LH_S9_(uint64 instruction)
8628 {
8629 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8630 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8631 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8632
8633 std::string rt = GPR(copy(rt_value));
8634 std::string s = IMMEDIATE(copy(s_value));
8635 std::string rs = GPR(copy(rs_value));
8636
8637 return img::format("LH %s, %s(%s)", rt, s, rs);
8638 }
8639
8640
8641 /*
8642 *
8643 *
8644 * 3 2 1
8645 * 10987654321098765432109876543210
8646 * 001000 x1110000101
8647 * rt -----
8648 * rs -----
8649 * rd -----
8650 */
8651 std::string NMD::LH_U12_(uint64 instruction)
8652 {
8653 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8654 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8655 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8656
8657 std::string rt = GPR(copy(rt_value));
8658 std::string u = IMMEDIATE(copy(u_value));
8659 std::string rs = GPR(copy(rs_value));
8660
8661 return img::format("LH %s, %s(%s)", rt, u, rs);
8662 }
8663
8664
8665 /*
8666 *
8667 *
8668 * 3 2 1
8669 * 10987654321098765432109876543210
8670 * 001000 x1110000101
8671 * rt -----
8672 * rs -----
8673 * rd -----
8674 */
8675 std::string NMD::LHE(uint64 instruction)
8676 {
8677 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8678 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8679 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8680
8681 std::string rt = GPR(copy(rt_value));
8682 std::string s = IMMEDIATE(copy(s_value));
8683 std::string rs = GPR(copy(rs_value));
8684
8685 return img::format("LHE %s, %s(%s)", rt, s, rs);
8686 }
8687
8688
8689 /*
8690 *
8691 *
8692 * 3 2 1
8693 * 10987654321098765432109876543210
8694 * 001000 x1110000101
8695 * rt -----
8696 * rs -----
8697 * rd -----
8698 */
8699 std::string NMD::LHU_16_(uint64 instruction)
8700 {
8701 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
8702 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8703 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8704
8705 std::string rt3 = GPR(encode_gpr3(rt3_value));
8706 std::string u = IMMEDIATE(copy(u_value));
8707 std::string rs3 = GPR(encode_gpr3(rs3_value));
8708
8709 return img::format("LHU %s, %s(%s)", rt3, u, rs3);
8710 }
8711
8712
8713 /*
8714 *
8715 *
8716 * 3 2 1
8717 * 10987654321098765432109876543210
8718 * 001000 x1110000101
8719 * rt -----
8720 * rs -----
8721 * rd -----
8722 */
8723 std::string NMD::LHU_GP_(uint64 instruction)
8724 {
8725 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8726 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
8727
8728 std::string rt = GPR(copy(rt_value));
8729 std::string u = IMMEDIATE(copy(u_value));
8730
8731 return img::format("LHU %s, %s($%d)", rt, u, 28);
8732 }
8733
8734
8735 /*
8736 *
8737 *
8738 * 3 2 1
8739 * 10987654321098765432109876543210
8740 * 001000 x1110000101
8741 * rt -----
8742 * rs -----
8743 * rd -----
8744 */
8745 std::string NMD::LHU_S9_(uint64 instruction)
8746 {
8747 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8748 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8749 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8750
8751 std::string rt = GPR(copy(rt_value));
8752 std::string s = IMMEDIATE(copy(s_value));
8753 std::string rs = GPR(copy(rs_value));
8754
8755 return img::format("LHU %s, %s(%s)", rt, s, rs);
8756 }
8757
8758
8759 /*
8760 *
8761 *
8762 * 3 2 1
8763 * 10987654321098765432109876543210
8764 * 001000 x1110000101
8765 * rt -----
8766 * rs -----
8767 * rd -----
8768 */
8769 std::string NMD::LHU_U12_(uint64 instruction)
8770 {
8771 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8772 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8773 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8774
8775 std::string rt = GPR(copy(rt_value));
8776 std::string u = IMMEDIATE(copy(u_value));
8777 std::string rs = GPR(copy(rs_value));
8778
8779 return img::format("LHU %s, %s(%s)", rt, u, rs);
8780 }
8781
8782
8783 /*
8784 *
8785 *
8786 * 3 2 1
8787 * 10987654321098765432109876543210
8788 * 001000 x1110000101
8789 * rt -----
8790 * rs -----
8791 * rd -----
8792 */
8793 std::string NMD::LHUE(uint64 instruction)
8794 {
8795 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8796 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8797 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8798
8799 std::string rt = GPR(copy(rt_value));
8800 std::string s = IMMEDIATE(copy(s_value));
8801 std::string rs = GPR(copy(rs_value));
8802
8803 return img::format("LHUE %s, %s(%s)", rt, s, rs);
8804 }
8805
8806
8807 /*
8808 *
8809 *
8810 * 3 2 1
8811 * 10987654321098765432109876543210
8812 * 001000 x1110000101
8813 * rt -----
8814 * rs -----
8815 * rd -----
8816 */
8817 std::string NMD::LHUX(uint64 instruction)
8818 {
8819 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8820 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8821 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8822
8823 std::string rd = GPR(copy(rd_value));
8824 std::string rs = GPR(copy(rs_value));
8825 std::string rt = GPR(copy(rt_value));
8826
8827 return img::format("LHUX %s, %s(%s)", rd, rs, rt);
8828 }
8829
8830
8831 /*
8832 *
8833 *
8834 * 3 2 1
8835 * 10987654321098765432109876543210
8836 * 001000 x1110000101
8837 * rt -----
8838 * rs -----
8839 * rd -----
8840 */
8841 std::string NMD::LHUXS(uint64 instruction)
8842 {
8843 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8844 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8845 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8846
8847 std::string rd = GPR(copy(rd_value));
8848 std::string rs = GPR(copy(rs_value));
8849 std::string rt = GPR(copy(rt_value));
8850
8851 return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
8852 }
8853
8854
8855 /*
8856 *
8857 *
8858 * 3 2 1
8859 * 10987654321098765432109876543210
8860 * 001000 x1110000101
8861 * rt -----
8862 * rs -----
8863 * rd -----
8864 */
8865 std::string NMD::LHXS(uint64 instruction)
8866 {
8867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8868 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8869 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8870
8871 std::string rd = GPR(copy(rd_value));
8872 std::string rs = GPR(copy(rs_value));
8873 std::string rt = GPR(copy(rt_value));
8874
8875 return img::format("LHXS %s, %s(%s)", rd, rs, rt);
8876 }
8877
8878
8879 /*
8880 *
8881 *
8882 * 3 2 1
8883 * 10987654321098765432109876543210
8884 * 001000 x1110000101
8885 * rt -----
8886 * rs -----
8887 * rd -----
8888 */
8889 std::string NMD::LHX(uint64 instruction)
8890 {
8891 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8892 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8893 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8894
8895 std::string rd = GPR(copy(rd_value));
8896 std::string rs = GPR(copy(rs_value));
8897 std::string rt = GPR(copy(rt_value));
8898
8899 return img::format("LHX %s, %s(%s)", rd, rs, rt);
8900 }
8901
8902
8903 /*
8904 *
8905 *
8906 * 3 2 1
8907 * 10987654321098765432109876543210
8908 * 001000 x1110000101
8909 * rt -----
8910 * rs -----
8911 * rd -----
8912 */
8913 std::string NMD::LI_16_(uint64 instruction)
8914 {
8915 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8916 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8917
8918 std::string rt3 = GPR(encode_gpr3(rt3_value));
8919 std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
8920
8921 return img::format("LI %s, %s", rt3, eu);
8922 }
8923
8924
8925 /*
8926 *
8927 *
8928 * 3 2 1
8929 * 10987654321098765432109876543210
8930 * 001000 x1110000101
8931 * rt -----
8932 * rs -----
8933 * rd -----
8934 */
8935 std::string NMD::LI_48_(uint64 instruction)
8936 {
8937 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8938 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
8939
8940 std::string rt = GPR(copy(rt_value));
8941 std::string s = IMMEDIATE(copy(s_value));
8942
8943 return img::format("LI %s, %s", rt, s);
8944 }
8945
8946
8947 /*
8948 *
8949 *
8950 * 3 2 1
8951 * 10987654321098765432109876543210
8952 * 001000 x1110000101
8953 * rt -----
8954 * rs -----
8955 * rd -----
8956 */
8957 std::string NMD::LL(uint64 instruction)
8958 {
8959 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8960 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
8961 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8962
8963 std::string rt = GPR(copy(rt_value));
8964 std::string s = IMMEDIATE(copy(s_value));
8965 std::string rs = GPR(copy(rs_value));
8966
8967 return img::format("LL %s, %s(%s)", rt, s, rs);
8968 }
8969
8970
8971 /*
8972 *
8973 *
8974 * 3 2 1
8975 * 10987654321098765432109876543210
8976 * 001000 x1110000101
8977 * rt -----
8978 * rs -----
8979 * rd -----
8980 */
8981 std::string NMD::LLD(uint64 instruction)
8982 {
8983 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8984 int64 s_value = extr_sil3il3bs5_il15il8bs1Tmsb8(instruction);
8985 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8986
8987 std::string rt = GPR(copy(rt_value));
8988 std::string s = IMMEDIATE(copy(s_value));
8989 std::string rs = GPR(copy(rs_value));
8990
8991 return img::format("LLD %s, %s(%s)", rt, s, rs);
8992 }
8993
8994
8995 /*
8996 *
8997 *
8998 * 3 2 1
8999 * 10987654321098765432109876543210
9000 * 001000 x1110000101
9001 * rt -----
9002 * rs -----
9003 * rd -----
9004 */
9005 std::string NMD::LLDP(uint64 instruction)
9006 {
9007 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9008 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9009 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9010
9011 std::string rt = GPR(copy(rt_value));
9012 std::string ru = GPR(copy(ru_value));
9013 std::string rs = GPR(copy(rs_value));
9014
9015 return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
9016 }
9017
9018
9019 /*
9020 *
9021 *
9022 * 3 2 1
9023 * 10987654321098765432109876543210
9024 * 001000 x1110000101
9025 * rt -----
9026 * rs -----
9027 * rd -----
9028 */
9029 std::string NMD::LLE(uint64 instruction)
9030 {
9031 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9032 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
9033 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9034
9035 std::string rt = GPR(copy(rt_value));
9036 std::string s = IMMEDIATE(copy(s_value));
9037 std::string rs = GPR(copy(rs_value));
9038
9039 return img::format("LLE %s, %s(%s)", rt, s, rs);
9040 }
9041
9042
9043 /*
9044 *
9045 *
9046 * 3 2 1
9047 * 10987654321098765432109876543210
9048 * 001000 x1110000101
9049 * rt -----
9050 * rs -----
9051 * rd -----
9052 */
9053 std::string NMD::LLWP(uint64 instruction)
9054 {
9055 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9056 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9057 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9058
9059 std::string rt = GPR(copy(rt_value));
9060 std::string ru = GPR(copy(ru_value));
9061 std::string rs = GPR(copy(rs_value));
9062
9063 return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
9064 }
9065
9066
9067 /*
9068 *
9069 *
9070 * 3 2 1
9071 * 10987654321098765432109876543210
9072 * 001000 x1110000101
9073 * rt -----
9074 * rs -----
9075 * rd -----
9076 */
9077 std::string NMD::LLWPE(uint64 instruction)
9078 {
9079 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9080 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9081 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9082
9083 std::string rt = GPR(copy(rt_value));
9084 std::string ru = GPR(copy(ru_value));
9085 std::string rs = GPR(copy(rs_value));
9086
9087 return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
9088 }
9089
9090
9091 /*
9092 *
9093 *
9094 * 3 2 1
9095 * 10987654321098765432109876543210
9096 * 001000 x1110000101
9097 * rt -----
9098 * rs -----
9099 * rd -----
9100 */
9101 std::string NMD::LSA(uint64 instruction)
9102 {
9103 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9104 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9105 uint64 u2_value = extract_u2_10_9(instruction);
9106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9107
9108 std::string rd = GPR(copy(rd_value));
9109 std::string rs = GPR(copy(rs_value));
9110 std::string rt = GPR(copy(rt_value));
9111 std::string u2 = IMMEDIATE(copy(u2_value));
9112
9113 return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
9114 }
9115
9116
9117 /*
9118 *
9119 *
9120 * 3 2 1
9121 * 10987654321098765432109876543210
9122 * 001000 x1110000101
9123 * rt -----
9124 * rs -----
9125 * rd -----
9126 */
9127 std::string NMD::LUI(uint64 instruction)
9128 {
9129 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9130 int64 s_value = extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(instruction);
9131
9132 std::string rt = GPR(copy(rt_value));
9133 std::string s = IMMEDIATE(copy(s_value));
9134
9135 return img::format("LUI %s, %%hi(%s)", rt, s);
9136 }
9137
9138
9139 /*
9140 *
9141 *
9142 * 3 2 1
9143 * 10987654321098765432109876543210
9144 * 001000 x1110000101
9145 * rt -----
9146 * rs -----
9147 * rd -----
9148 */
9149 std::string NMD::LW_16_(uint64 instruction)
9150 {
9151 uint64 u_value = extr_uil0il2bs4Fmsb5(instruction);
9152 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9153 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9154
9155 std::string rt3 = GPR(encode_gpr3(rt3_value));
9156 std::string u = IMMEDIATE(copy(u_value));
9157 std::string rs3 = GPR(encode_gpr3(rs3_value));
9158
9159 return img::format("LW %s, %s(%s)", rt3, u, rs3);
9160 }
9161
9162
9163 /*
9164 *
9165 *
9166 * 3 2 1
9167 * 10987654321098765432109876543210
9168 * 001000 x1110000101
9169 * rt -----
9170 * rs -----
9171 * rd -----
9172 */
9173 std::string NMD::LW_4X4_(uint64 instruction)
9174 {
9175 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
9176 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
9177 uint64 u_value = extr_uil3il3bs1_il8il2bs1Fmsb3(instruction);
9178
9179 std::string rt4 = GPR(encode_gpr4(rt4_value));
9180 std::string u = IMMEDIATE(copy(u_value));
9181 std::string rs4 = GPR(encode_gpr4(rs4_value));
9182
9183 return img::format("LW %s, %s(%s)", rt4, u, rs4);
9184 }
9185
9186
9187 /*
9188 *
9189 *
9190 * 3 2 1
9191 * 10987654321098765432109876543210
9192 * 001000 x1110000101
9193 * rt -----
9194 * rs -----
9195 * rd -----
9196 */
9197 std::string NMD::LW_GP_(uint64 instruction)
9198 {
9199 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9200 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
9201
9202 std::string rt = GPR(copy(rt_value));
9203 std::string u = IMMEDIATE(copy(u_value));
9204
9205 return img::format("LW %s, %s($%d)", rt, u, 28);
9206 }
9207
9208
9209 /*
9210 *
9211 *
9212 * 3 2 1
9213 * 10987654321098765432109876543210
9214 * 001000 x1110000101
9215 * rt -----
9216 * rs -----
9217 * rd -----
9218 */
9219 std::string NMD::LW_GP16_(uint64 instruction)
9220 {
9221 uint64 u_value = extr_uil0il2bs7Fmsb8(instruction);
9222 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9223
9224 std::string rt3 = GPR(encode_gpr3(rt3_value));
9225 std::string u = IMMEDIATE(copy(u_value));
9226
9227 return img::format("LW %s, %s($%d)", rt3, u, 28);
9228 }
9229
9230
9231 /*
9232 *
9233 *
9234 * 3 2 1
9235 * 10987654321098765432109876543210
9236 * 001000 x1110000101
9237 * rt -----
9238 * rs -----
9239 * rd -----
9240 */
9241 std::string NMD::LW_S9_(uint64 instruction)
9242 {
9243 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9244 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9245 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9246
9247 std::string rt = GPR(copy(rt_value));
9248 std::string s = IMMEDIATE(copy(s_value));
9249 std::string rs = GPR(copy(rs_value));
9250
9251 return img::format("LW %s, %s(%s)", rt, s, rs);
9252 }
9253
9254
9255 /*
9256 *
9257 *
9258 * 3 2 1
9259 * 10987654321098765432109876543210
9260 * 001000 x1110000101
9261 * rt -----
9262 * rs -----
9263 * rd -----
9264 */
9265 std::string NMD::LW_SP_(uint64 instruction)
9266 {
9267 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
9268 uint64 u_value = extr_uil0il2bs5Fmsb6(instruction);
9269
9270 std::string rt = GPR(copy(rt_value));
9271 std::string u = IMMEDIATE(copy(u_value));
9272
9273 return img::format("LW %s, %s($%d)", rt, u, 29);
9274 }
9275
9276
9277 /*
9278 *
9279 *
9280 * 3 2 1
9281 * 10987654321098765432109876543210
9282 * 001000 x1110000101
9283 * rt -----
9284 * rs -----
9285 * rd -----
9286 */
9287 std::string NMD::LW_U12_(uint64 instruction)
9288 {
9289 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9290 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9291 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9292
9293 std::string rt = GPR(copy(rt_value));
9294 std::string u = IMMEDIATE(copy(u_value));
9295 std::string rs = GPR(copy(rs_value));
9296
9297 return img::format("LW %s, %s(%s)", rt, u, rs);
9298 }
9299
9300
9301 /*
9302 *
9303 *
9304 * 3 2 1
9305 * 10987654321098765432109876543210
9306 * 001000 x1110000101
9307 * rt -----
9308 * rs -----
9309 * rd -----
9310 */
9311 std::string NMD::LWC1_GP_(uint64 instruction)
9312 {
9313 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9314 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
9315
9316 std::string ft = FPR(copy(ft_value));
9317 std::string u = IMMEDIATE(copy(u_value));
9318
9319 return img::format("LWC1 %s, %s($%d)", ft, u, 28);
9320 }
9321
9322
9323 /*
9324 *
9325 *
9326 * 3 2 1
9327 * 10987654321098765432109876543210
9328 * 001000 x1110000101
9329 * rt -----
9330 * rs -----
9331 * rd -----
9332 */
9333 std::string NMD::LWC1_S9_(uint64 instruction)
9334 {
9335 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9336 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9337 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9338
9339 std::string ft = FPR(copy(ft_value));
9340 std::string s = IMMEDIATE(copy(s_value));
9341 std::string rs = GPR(copy(rs_value));
9342
9343 return img::format("LWC1 %s, %s(%s)", ft, s, rs);
9344 }
9345
9346
9347 /*
9348 *
9349 *
9350 * 3 2 1
9351 * 10987654321098765432109876543210
9352 * 001000 x1110000101
9353 * rt -----
9354 * rs -----
9355 * rd -----
9356 */
9357 std::string NMD::LWC1_U12_(uint64 instruction)
9358 {
9359 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9360 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9361 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9362
9363 std::string ft = FPR(copy(ft_value));
9364 std::string u = IMMEDIATE(copy(u_value));
9365 std::string rs = GPR(copy(rs_value));
9366
9367 return img::format("LWC1 %s, %s(%s)", ft, u, rs);
9368 }
9369
9370
9371 /*
9372 *
9373 *
9374 * 3 2 1
9375 * 10987654321098765432109876543210
9376 * 001000 x1110000101
9377 * rt -----
9378 * rs -----
9379 * rd -----
9380 */
9381 std::string NMD::LWC1X(uint64 instruction)
9382 {
9383 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9384 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9385 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9386
9387 std::string ft = FPR(copy(ft_value));
9388 std::string rs = GPR(copy(rs_value));
9389 std::string rt = GPR(copy(rt_value));
9390
9391 return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
9392 }
9393
9394
9395 /*
9396 *
9397 *
9398 * 3 2 1
9399 * 10987654321098765432109876543210
9400 * 001000 x1110000101
9401 * rt -----
9402 * rs -----
9403 * rd -----
9404 */
9405 std::string NMD::LWC1XS(uint64 instruction)
9406 {
9407 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9408 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9409 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9410
9411 std::string ft = FPR(copy(ft_value));
9412 std::string rs = GPR(copy(rs_value));
9413 std::string rt = GPR(copy(rt_value));
9414
9415 return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
9416 }
9417
9418
9419 /*
9420 *
9421 *
9422 * 3 2 1
9423 * 10987654321098765432109876543210
9424 * 001000 x1110000101
9425 * rt -----
9426 * rs -----
9427 * rd -----
9428 */
9429 std::string NMD::LWC2(uint64 instruction)
9430 {
9431 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9432 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9433 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9434
9435 std::string ct = CPR(copy(ct_value));
9436 std::string s = IMMEDIATE(copy(s_value));
9437 std::string rs = GPR(copy(rs_value));
9438
9439 return img::format("LWC2 %s, %s(%s)", ct, s, rs);
9440 }
9441
9442
9443 /*
9444 *
9445 *
9446 * 3 2 1
9447 * 10987654321098765432109876543210
9448 * 001000 x1110000101
9449 * rt -----
9450 * rs -----
9451 * rd -----
9452 */
9453 std::string NMD::LWE(uint64 instruction)
9454 {
9455 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9456 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9457 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9458
9459 std::string rt = GPR(copy(rt_value));
9460 std::string s = IMMEDIATE(copy(s_value));
9461 std::string rs = GPR(copy(rs_value));
9462
9463 return img::format("LWE %s, %s(%s)", rt, s, rs);
9464 }
9465
9466
9467 /*
9468 *
9469 *
9470 * 3 2 1
9471 * 10987654321098765432109876543210
9472 * 001000 x1110000101
9473 * rt -----
9474 * rs -----
9475 * rd -----
9476 */
9477 std::string NMD::LWM(uint64 instruction)
9478 {
9479 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9480 uint64 count3_value = extract_count3_14_13_12(instruction);
9481 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9482 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9483
9484 std::string rt = GPR(copy(rt_value));
9485 std::string s = IMMEDIATE(copy(s_value));
9486 std::string rs = GPR(copy(rs_value));
9487 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
9488
9489 return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
9490 }
9491
9492
9493 /*
9494 *
9495 *
9496 * 3 2 1
9497 * 10987654321098765432109876543210
9498 * 001000 x1110000101
9499 * rt -----
9500 * rs -----
9501 * rd -----
9502 */
9503 std::string NMD::LWPC_48_(uint64 instruction)
9504 {
9505 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9506 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
9507
9508 std::string rt = GPR(copy(rt_value));
9509 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
9510
9511 return img::format("LWPC %s, %s", rt, s);
9512 }
9513
9514
9515 /*
9516 *
9517 *
9518 * 3 2 1
9519 * 10987654321098765432109876543210
9520 * 001000 x1110000101
9521 * rt -----
9522 * rs -----
9523 * rd -----
9524 */
9525 std::string NMD::LWU_GP_(uint64 instruction)
9526 {
9527 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9528 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
9529
9530 std::string rt = GPR(copy(rt_value));
9531 std::string u = IMMEDIATE(copy(u_value));
9532
9533 return img::format("LWU %s, %s($%d)", rt, u, 28);
9534 }
9535
9536
9537 /*
9538 *
9539 *
9540 * 3 2 1
9541 * 10987654321098765432109876543210
9542 * 001000 x1110000101
9543 * rt -----
9544 * rs -----
9545 * rd -----
9546 */
9547 std::string NMD::LWU_S9_(uint64 instruction)
9548 {
9549 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9550 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9551 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9552
9553 std::string rt = GPR(copy(rt_value));
9554 std::string s = IMMEDIATE(copy(s_value));
9555 std::string rs = GPR(copy(rs_value));
9556
9557 return img::format("LWU %s, %s(%s)", rt, s, rs);
9558 }
9559
9560
9561 /*
9562 *
9563 *
9564 * 3 2 1
9565 * 10987654321098765432109876543210
9566 * 001000 x1110000101
9567 * rt -----
9568 * rs -----
9569 * rd -----
9570 */
9571 std::string NMD::LWU_U12_(uint64 instruction)
9572 {
9573 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9574 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9575 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9576
9577 std::string rt = GPR(copy(rt_value));
9578 std::string u = IMMEDIATE(copy(u_value));
9579 std::string rs = GPR(copy(rs_value));
9580
9581 return img::format("LWU %s, %s(%s)", rt, u, rs);
9582 }
9583
9584
9585 /*
9586 *
9587 *
9588 * 3 2 1
9589 * 10987654321098765432109876543210
9590 * 001000 x1110000101
9591 * rt -----
9592 * rs -----
9593 * rd -----
9594 */
9595 std::string NMD::LWUX(uint64 instruction)
9596 {
9597 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9598 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9600
9601 std::string rd = GPR(copy(rd_value));
9602 std::string rs = GPR(copy(rs_value));
9603 std::string rt = GPR(copy(rt_value));
9604
9605 return img::format("LWUX %s, %s(%s)", rd, rs, rt);
9606 }
9607
9608
9609 /*
9610 *
9611 *
9612 * 3 2 1
9613 * 10987654321098765432109876543210
9614 * 001000 x1110000101
9615 * rt -----
9616 * rs -----
9617 * rd -----
9618 */
9619 std::string NMD::LWUXS(uint64 instruction)
9620 {
9621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9622 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9624
9625 std::string rd = GPR(copy(rd_value));
9626 std::string rs = GPR(copy(rs_value));
9627 std::string rt = GPR(copy(rt_value));
9628
9629 return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
9630 }
9631
9632
9633 /*
9634 *
9635 *
9636 * 3 2 1
9637 * 10987654321098765432109876543210
9638 * 001000 x1110000101
9639 * rt -----
9640 * rs -----
9641 * rd -----
9642 */
9643 std::string NMD::LWX(uint64 instruction)
9644 {
9645 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9646 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9647 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9648
9649 std::string rd = GPR(copy(rd_value));
9650 std::string rs = GPR(copy(rs_value));
9651 std::string rt = GPR(copy(rt_value));
9652
9653 return img::format("LWX %s, %s(%s)", rd, rs, rt);
9654 }
9655
9656
9657 /*
9658 *
9659 *
9660 * 3 2 1
9661 * 10987654321098765432109876543210
9662 * 001000 x1110000101
9663 * rt -----
9664 * rs -----
9665 * rd -----
9666 */
9667 std::string NMD::LWXS_16_(uint64 instruction)
9668 {
9669 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9670 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9671 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9672
9673 std::string rd3 = GPR(encode_gpr3(rd3_value));
9674 std::string rs3 = GPR(encode_gpr3(rs3_value));
9675 std::string rt3 = IMMEDIATE(encode_gpr3(rt3_value));
9676
9677 return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
9678 }
9679
9680
9681 /*
9682 *
9683 *
9684 * 3 2 1
9685 * 10987654321098765432109876543210
9686 * 001000 x1110000101
9687 * rt -----
9688 * rs -----
9689 * rd -----
9690 */
9691 std::string NMD::LWXS_32_(uint64 instruction)
9692 {
9693 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9694 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9695 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9696
9697 std::string rd = GPR(copy(rd_value));
9698 std::string rs = GPR(copy(rs_value));
9699 std::string rt = GPR(copy(rt_value));
9700
9701 return img::format("LWXS %s, %s(%s)", rd, rs, rt);
9702 }
9703
9704
9705 /*
9706 *
9707 *
9708 * 3 2 1
9709 * 10987654321098765432109876543210
9710 * 001000 x1110000101
9711 * rt -----
9712 * rs -----
9713 * rd -----
9714 */
9715 std::string NMD::MADD_DSP_(uint64 instruction)
9716 {
9717 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9718 uint64 ac_value = extract_ac_13_12(instruction);
9719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9720
9721 std::string ac = AC(copy(ac_value));
9722 std::string rs = GPR(copy(rs_value));
9723 std::string rt = GPR(copy(rt_value));
9724
9725 return img::format("MADD %s, %s, %s", ac, rs, rt);
9726 }
9727
9728
9729 /*
9730 *
9731 *
9732 * 3 2 1
9733 * 10987654321098765432109876543210
9734 * 001000 x1110000101
9735 * rt -----
9736 * rs -----
9737 * rd -----
9738 */
9739 std::string NMD::MADDF_D(uint64 instruction)
9740 {
9741 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9742 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9743 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9744
9745 std::string fd = FPR(copy(fd_value));
9746 std::string fs = FPR(copy(fs_value));
9747 std::string ft = FPR(copy(ft_value));
9748
9749 return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
9750 }
9751
9752
9753 /*
9754 *
9755 *
9756 * 3 2 1
9757 * 10987654321098765432109876543210
9758 * 001000 x1110000101
9759 * rt -----
9760 * rs -----
9761 * rd -----
9762 */
9763 std::string NMD::MADDF_S(uint64 instruction)
9764 {
9765 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9766 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9767 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9768
9769 std::string fd = FPR(copy(fd_value));
9770 std::string fs = FPR(copy(fs_value));
9771 std::string ft = FPR(copy(ft_value));
9772
9773 return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
9774 }
9775
9776
9777 /*
9778 *
9779 *
9780 * 3 2 1
9781 * 10987654321098765432109876543210
9782 * 001000 x1110000101
9783 * rt -----
9784 * rs -----
9785 * rd -----
9786 */
9787 std::string NMD::MADDU_DSP_(uint64 instruction)
9788 {
9789 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9790 uint64 ac_value = extract_ac_13_12(instruction);
9791 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9792
9793 std::string ac = AC(copy(ac_value));
9794 std::string rs = GPR(copy(rs_value));
9795 std::string rt = GPR(copy(rt_value));
9796
9797 return img::format("MADDU %s, %s, %s", ac, rs, rt);
9798 }
9799
9800
9801 /*
9802 *
9803 *
9804 * 3 2 1
9805 * 10987654321098765432109876543210
9806 * 001000 x1110000101
9807 * rt -----
9808 * rs -----
9809 * rd -----
9810 */
9811 std::string NMD::MAQ_S_W_PHL(uint64 instruction)
9812 {
9813 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9814 uint64 ac_value = extract_ac_13_12(instruction);
9815 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9816
9817 std::string ac = AC(copy(ac_value));
9818 std::string rs = GPR(copy(rs_value));
9819 std::string rt = GPR(copy(rt_value));
9820
9821 return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9822 }
9823
9824
9825 /*
9826 *
9827 *
9828 * 3 2 1
9829 * 10987654321098765432109876543210
9830 * 001000 x1110000101
9831 * rt -----
9832 * rs -----
9833 * rd -----
9834 */
9835 std::string NMD::MAQ_S_W_PHR(uint64 instruction)
9836 {
9837 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9838 uint64 ac_value = extract_ac_13_12(instruction);
9839 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9840
9841 std::string ac = AC(copy(ac_value));
9842 std::string rs = GPR(copy(rs_value));
9843 std::string rt = GPR(copy(rt_value));
9844
9845 return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9846 }
9847
9848
9849 /*
9850 *
9851 *
9852 * 3 2 1
9853 * 10987654321098765432109876543210
9854 * 001000 x1110000101
9855 * rt -----
9856 * rs -----
9857 * rd -----
9858 */
9859 std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
9860 {
9861 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9862 uint64 ac_value = extract_ac_13_12(instruction);
9863 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9864
9865 std::string ac = AC(copy(ac_value));
9866 std::string rs = GPR(copy(rs_value));
9867 std::string rt = GPR(copy(rt_value));
9868
9869 return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9870 }
9871
9872
9873 /*
9874 *
9875 *
9876 * 3 2 1
9877 * 10987654321098765432109876543210
9878 * 001000 x1110000101
9879 * rt -----
9880 * rs -----
9881 * rd -----
9882 */
9883 std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
9884 {
9885 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9886 uint64 ac_value = extract_ac_13_12(instruction);
9887 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9888
9889 std::string ac = AC(copy(ac_value));
9890 std::string rs = GPR(copy(rs_value));
9891 std::string rt = GPR(copy(rt_value));
9892
9893 return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9894 }
9895
9896
9897 /*
9898 *
9899 *
9900 * 3 2 1
9901 * 10987654321098765432109876543210
9902 * 001000 x1110000101
9903 * rt -----
9904 * rs -----
9905 * rd -----
9906 */
9907 std::string NMD::MAX_D(uint64 instruction)
9908 {
9909 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9910 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9911 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9912
9913 std::string fd = FPR(copy(fd_value));
9914 std::string fs = FPR(copy(fs_value));
9915 std::string ft = FPR(copy(ft_value));
9916
9917 return img::format("MAX.D %s, %s, %s", fd, fs, ft);
9918 }
9919
9920
9921 /*
9922 *
9923 *
9924 * 3 2 1
9925 * 10987654321098765432109876543210
9926 * 001000 x1110000101
9927 * rt -----
9928 * rs -----
9929 * rd -----
9930 */
9931 std::string NMD::MAX_S(uint64 instruction)
9932 {
9933 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9934 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9935 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9936
9937 std::string fd = FPR(copy(fd_value));
9938 std::string fs = FPR(copy(fs_value));
9939 std::string ft = FPR(copy(ft_value));
9940
9941 return img::format("MAX.S %s, %s, %s", fd, fs, ft);
9942 }
9943
9944
9945 /*
9946 *
9947 *
9948 * 3 2 1
9949 * 10987654321098765432109876543210
9950 * 001000 x1110000101
9951 * rt -----
9952 * rs -----
9953 * rd -----
9954 */
9955 std::string NMD::MAXA_D(uint64 instruction)
9956 {
9957 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9958 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9959 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9960
9961 std::string fd = FPR(copy(fd_value));
9962 std::string fs = FPR(copy(fs_value));
9963 std::string ft = FPR(copy(ft_value));
9964
9965 return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
9966 }
9967
9968
9969 /*
9970 *
9971 *
9972 * 3 2 1
9973 * 10987654321098765432109876543210
9974 * 001000 x1110000101
9975 * rt -----
9976 * rs -----
9977 * rd -----
9978 */
9979 std::string NMD::MAXA_S(uint64 instruction)
9980 {
9981 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9982 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9983 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9984
9985 std::string fd = FPR(copy(fd_value));
9986 std::string fs = FPR(copy(fs_value));
9987 std::string ft = FPR(copy(ft_value));
9988
9989 return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
9990 }
9991
9992
9993 /*
9994 *
9995 *
9996 * 3 2 1
9997 * 10987654321098765432109876543210
9998 * 001000 x1110000101
9999 * rt -----
10000 * rs -----
10001 * rd -----
10002 */
10003 std::string NMD::MFC0(uint64 instruction)
10004 {
10005 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10006 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10007 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10008
10009 std::string rt = GPR(copy(rt_value));
10010 std::string c0s = CPR(copy(c0s_value));
10011 std::string sel = IMMEDIATE(copy(sel_value));
10012
10013 return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
10014 }
10015
10016
10017 /*
10018 *
10019 *
10020 * 3 2 1
10021 * 10987654321098765432109876543210
10022 * 001000 x1110000101
10023 * rt -----
10024 * rs -----
10025 * rd -----
10026 */
10027 std::string NMD::MFC1(uint64 instruction)
10028 {
10029 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10030 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10031
10032 std::string rt = GPR(copy(rt_value));
10033 std::string fs = FPR(copy(fs_value));
10034
10035 return img::format("MFC1 %s, %s", rt, fs);
10036 }
10037
10038
10039 /*
10040 *
10041 *
10042 * 3 2 1
10043 * 10987654321098765432109876543210
10044 * 001000 x1110000101
10045 * rt -----
10046 * rs -----
10047 * rd -----
10048 */
10049 std::string NMD::MFC2(uint64 instruction)
10050 {
10051 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10052 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10053
10054 std::string rt = GPR(copy(rt_value));
10055 std::string cs = CPR(copy(cs_value));
10056
10057 return img::format("MFC2 %s, %s", rt, cs);
10058 }
10059
10060
10061 /*
10062 *
10063 *
10064 * 3 2 1
10065 * 10987654321098765432109876543210
10066 * 001000 x1110000101
10067 * rt -----
10068 * rs -----
10069 * rd -----
10070 */
10071 std::string NMD::MFGC0(uint64 instruction)
10072 {
10073 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10074 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10075 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10076
10077 std::string rt = GPR(copy(rt_value));
10078 std::string c0s = CPR(copy(c0s_value));
10079 std::string sel = IMMEDIATE(copy(sel_value));
10080
10081 return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
10082 }
10083
10084
10085 /*
10086 *
10087 *
10088 * 3 2 1
10089 * 10987654321098765432109876543210
10090 * 001000 x1110000101
10091 * rt -----
10092 * rs -----
10093 * rd -----
10094 */
10095 std::string NMD::MFHC0(uint64 instruction)
10096 {
10097 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10098 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10099 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10100
10101 std::string rt = GPR(copy(rt_value));
10102 std::string c0s = CPR(copy(c0s_value));
10103 std::string sel = IMMEDIATE(copy(sel_value));
10104
10105 return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
10106 }
10107
10108
10109 /*
10110 *
10111 *
10112 * 3 2 1
10113 * 10987654321098765432109876543210
10114 * 001000 x1110000101
10115 * rt -----
10116 * rs -----
10117 * rd -----
10118 */
10119 std::string NMD::MFHC1(uint64 instruction)
10120 {
10121 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10122 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10123
10124 std::string rt = GPR(copy(rt_value));
10125 std::string fs = FPR(copy(fs_value));
10126
10127 return img::format("MFHC1 %s, %s", rt, fs);
10128 }
10129
10130
10131 /*
10132 *
10133 *
10134 * 3 2 1
10135 * 10987654321098765432109876543210
10136 * 001000 x1110000101
10137 * rt -----
10138 * rs -----
10139 * rd -----
10140 */
10141 std::string NMD::MFHC2(uint64 instruction)
10142 {
10143 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10144 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10145
10146 std::string rt = GPR(copy(rt_value));
10147 std::string cs = CPR(copy(cs_value));
10148
10149 return img::format("MFHC2 %s, %s", rt, cs);
10150 }
10151
10152
10153 /*
10154 *
10155 *
10156 * 3 2 1
10157 * 10987654321098765432109876543210
10158 * 001000 x1110000101
10159 * rt -----
10160 * rs -----
10161 * rd -----
10162 */
10163 std::string NMD::MFHGC0(uint64 instruction)
10164 {
10165 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10166 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10167 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10168
10169 std::string rt = GPR(copy(rt_value));
10170 std::string c0s = CPR(copy(c0s_value));
10171 std::string sel = IMMEDIATE(copy(sel_value));
10172
10173 return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
10174 }
10175
10176
10177 /*
10178 *
10179 *
10180 * 3 2 1
10181 * 10987654321098765432109876543210
10182 * 001000 x1110000101
10183 * rt -----
10184 * rs -----
10185 * rd -----
10186 */
10187 std::string NMD::MFHI_DSP_(uint64 instruction)
10188 {
10189 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10190 uint64 ac_value = extract_ac_13_12(instruction);
10191
10192 std::string rt = GPR(copy(rt_value));
10193 std::string ac = AC(copy(ac_value));
10194
10195 return img::format("MFHI %s, %s", rt, ac);
10196 }
10197
10198
10199 /*
10200 *
10201 *
10202 * 3 2 1
10203 * 10987654321098765432109876543210
10204 * 001000 x1110000101
10205 * rt -----
10206 * rs -----
10207 * rd -----
10208 */
10209 std::string NMD::MFHTR(uint64 instruction)
10210 {
10211 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10212 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10213 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10214 uint64 u_value = extract_u_10(instruction);
10215
10216 std::string rt = GPR(copy(rt_value));
10217 std::string c0s = IMMEDIATE(copy(c0s_value));
10218 std::string u = IMMEDIATE(copy(u_value));
10219 std::string sel = IMMEDIATE(copy(sel_value));
10220
10221 return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
10222 }
10223
10224
10225 /*
10226 *
10227 *
10228 * 3 2 1
10229 * 10987654321098765432109876543210
10230 * 001000 x1110000101
10231 * rt -----
10232 * rs -----
10233 * rd -----
10234 */
10235 std::string NMD::MFLO_DSP_(uint64 instruction)
10236 {
10237 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10238 uint64 ac_value = extract_ac_13_12(instruction);
10239
10240 std::string rt = GPR(copy(rt_value));
10241 std::string ac = AC(copy(ac_value));
10242
10243 return img::format("MFLO %s, %s", rt, ac);
10244 }
10245
10246
10247 /*
10248 *
10249 *
10250 * 3 2 1
10251 * 10987654321098765432109876543210
10252 * 001000 x1110000101
10253 * rt -----
10254 * rs -----
10255 * rd -----
10256 */
10257 std::string NMD::MFTR(uint64 instruction)
10258 {
10259 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10260 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10261 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10262 uint64 u_value = extract_u_10(instruction);
10263
10264 std::string rt = GPR(copy(rt_value));
10265 std::string c0s = IMMEDIATE(copy(c0s_value));
10266 std::string u = IMMEDIATE(copy(u_value));
10267 std::string sel = IMMEDIATE(copy(sel_value));
10268
10269 return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
10270 }
10271
10272
10273 /*
10274 *
10275 *
10276 * 3 2 1
10277 * 10987654321098765432109876543210
10278 * 001000 x1110000101
10279 * rt -----
10280 * rs -----
10281 * rd -----
10282 */
10283 std::string NMD::MIN_D(uint64 instruction)
10284 {
10285 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10286 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10287 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10288
10289 std::string fd = FPR(copy(fd_value));
10290 std::string fs = FPR(copy(fs_value));
10291 std::string ft = FPR(copy(ft_value));
10292
10293 return img::format("MIN.D %s, %s, %s", fd, fs, ft);
10294 }
10295
10296
10297 /*
10298 *
10299 *
10300 * 3 2 1
10301 * 10987654321098765432109876543210
10302 * 001000 x1110000101
10303 * rt -----
10304 * rs -----
10305 * rd -----
10306 */
10307 std::string NMD::MIN_S(uint64 instruction)
10308 {
10309 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10310 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10311 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10312
10313 std::string fd = FPR(copy(fd_value));
10314 std::string fs = FPR(copy(fs_value));
10315 std::string ft = FPR(copy(ft_value));
10316
10317 return img::format("MIN.S %s, %s, %s", fd, fs, ft);
10318 }
10319
10320
10321 /*
10322 *
10323 *
10324 * 3 2 1
10325 * 10987654321098765432109876543210
10326 * 001000 x1110000101
10327 * rt -----
10328 * rs -----
10329 * rd -----
10330 */
10331 std::string NMD::MINA_D(uint64 instruction)
10332 {
10333 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10334 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10335 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10336
10337 std::string fd = FPR(copy(fd_value));
10338 std::string fs = FPR(copy(fs_value));
10339 std::string ft = FPR(copy(ft_value));
10340
10341 return img::format("MINA.D %s, %s, %s", fd, fs, ft);
10342 }
10343
10344
10345 /*
10346 *
10347 *
10348 * 3 2 1
10349 * 10987654321098765432109876543210
10350 * 001000 x1110000101
10351 * rt -----
10352 * rs -----
10353 * rd -----
10354 */
10355 std::string NMD::MINA_S(uint64 instruction)
10356 {
10357 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10358 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10359 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10360
10361 std::string fd = FPR(copy(fd_value));
10362 std::string fs = FPR(copy(fs_value));
10363 std::string ft = FPR(copy(ft_value));
10364
10365 return img::format("MINA.S %s, %s, %s", fd, fs, ft);
10366 }
10367
10368
10369 /*
10370 *
10371 *
10372 * 3 2 1
10373 * 10987654321098765432109876543210
10374 * 001000 x1110000101
10375 * rt -----
10376 * rs -----
10377 * rd -----
10378 */
10379 std::string NMD::MOD(uint64 instruction)
10380 {
10381 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10382 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10383 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10384
10385 std::string rd = GPR(copy(rd_value));
10386 std::string rs = GPR(copy(rs_value));
10387 std::string rt = GPR(copy(rt_value));
10388
10389 return img::format("MOD %s, %s, %s", rd, rs, rt);
10390 }
10391
10392
10393 /*
10394 *
10395 *
10396 * 3 2 1
10397 * 10987654321098765432109876543210
10398 * 001000 x1110000101
10399 * rt -----
10400 * rs -----
10401 * rd -----
10402 */
10403 std::string NMD::MODSUB(uint64 instruction)
10404 {
10405 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10406 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10407 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10408
10409 std::string rd = GPR(copy(rd_value));
10410 std::string rs = GPR(copy(rs_value));
10411 std::string rt = GPR(copy(rt_value));
10412
10413 return img::format("MODSUB %s, %s, %s", rd, rs, rt);
10414 }
10415
10416
10417 /*
10418 *
10419 *
10420 * 3 2 1
10421 * 10987654321098765432109876543210
10422 * 001000 x1110000101
10423 * rt -----
10424 * rs -----
10425 * rd -----
10426 */
10427 std::string NMD::MODU(uint64 instruction)
10428 {
10429 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10430 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10431 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10432
10433 std::string rd = GPR(copy(rd_value));
10434 std::string rs = GPR(copy(rs_value));
10435 std::string rt = GPR(copy(rt_value));
10436
10437 return img::format("MODU %s, %s, %s", rd, rs, rt);
10438 }
10439
10440
10441 /*
10442 *
10443 *
10444 * 3 2 1
10445 * 10987654321098765432109876543210
10446 * 001000 x1110000101
10447 * rt -----
10448 * rs -----
10449 * rd -----
10450 */
10451 std::string NMD::MOV_D(uint64 instruction)
10452 {
10453 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10454 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10455
10456 std::string ft = FPR(copy(ft_value));
10457 std::string fs = FPR(copy(fs_value));
10458
10459 return img::format("MOV.D %s, %s", ft, fs);
10460 }
10461
10462
10463 /*
10464 *
10465 *
10466 * 3 2 1
10467 * 10987654321098765432109876543210
10468 * 001000 x1110000101
10469 * rt -----
10470 * rs -----
10471 * rd -----
10472 */
10473 std::string NMD::MOV_S(uint64 instruction)
10474 {
10475 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10476 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10477
10478 std::string ft = FPR(copy(ft_value));
10479 std::string fs = FPR(copy(fs_value));
10480
10481 return img::format("MOV.S %s, %s", ft, fs);
10482 }
10483
10484
10485 /*
10486 *
10487 *
10488 * 3 2 1
10489 * 10987654321098765432109876543210
10490 * 001000 x1110000101
10491 * rt -----
10492 * rs -----
10493 * rd -----
10494 */
10495 std::string NMD::MOVE_BALC(uint64 instruction)
10496 {
10497 uint64 rd1_value = extract_rdl_25_24(instruction);
10498 int64 s_value = extr_sil0il21bs1_il1il1bs20Tmsb21(instruction);
10499 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10500
10501 std::string rd1 = GPR(encode_rd1_from_rd(rd1_value));
10502 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10503 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
10504
10505 return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10506 }
10507
10508
10509 /*
10510 *
10511 *
10512 * 3 2 1
10513 * 10987654321098765432109876543210
10514 * 001000 x1110000101
10515 * rt -----
10516 * rs -----
10517 * rd -----
10518 */
10519 std::string NMD::MOVEP(uint64 instruction)
10520 {
10521 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10522 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10523 uint64 rd2_value = extract_rd2_3_8(instruction);
10524
10525 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10526 std::string re2 = GPR(encode_rd2_reg2(rd2_value));
10527 /* !!!!!!!!!! - no conversion function */
10528 std::string rsz4 = GPR(encode_gpr4_zero(rsz4_value));
10529 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10530
10531 return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10532 /* hand edited */
10533 }
10534
10535
10536 /*
10537 *
10538 *
10539 * 3 2 1
10540 * 10987654321098765432109876543210
10541 * 001000 x1110000101
10542 * rt -----
10543 * rs -----
10544 * rd -----
10545 */
10546 std::string NMD::MOVEP_REV_(uint64 instruction)
10547 {
10548 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10549 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10550 uint64 rd2_value = extract_rd2_3_8(instruction);
10551
10552 std::string rs4 = GPR(encode_gpr4(rs4_value));
10553 std::string rt4 = GPR(encode_gpr4(rt4_value));
10554 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10555 std::string rs2 = GPR(encode_rd2_reg2(rd2_value));
10556 /* !!!!!!!!!! - no conversion function */
10557
10558 return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10559 /* hand edited */
10560 }
10561
10562
10563 /*
10564 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10565 *
10566 * 3 2 1
10567 * 10987654321098765432109876543210
10568 * 001000 00010001101
10569 * rt -----
10570 * rs -----
10571 * rd -----
10572 */
10573 std::string NMD::MOVE(uint64 instruction)
10574 {
10575 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10576 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10577
10578 std::string rt = GPR(copy(rt_value));
10579 std::string rs = GPR(copy(rs_value));
10580
10581 return img::format("MOVE %s, %s", rt, rs);
10582 }
10583
10584
10585 /*
10586 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10587 *
10588 * 3 2 1
10589 * 10987654321098765432109876543210
10590 * 001000 00010001101
10591 * rt -----
10592 * rs -----
10593 * rd -----
10594 */
10595 std::string NMD::MOVN(uint64 instruction)
10596 {
10597 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10598 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10600
10601 std::string rd = GPR(copy(rd_value));
10602 std::string rs = GPR(copy(rs_value));
10603 std::string rt = GPR(copy(rt_value));
10604
10605 return img::format("MOVN %s, %s, %s", rd, rs, rt);
10606 }
10607
10608
10609 /*
10610 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10611 *
10612 * 3 2 1
10613 * 10987654321098765432109876543210
10614 * 001000 00010001101
10615 * rt -----
10616 * rs -----
10617 * rd -----
10618 */
10619 std::string NMD::MOVZ(uint64 instruction)
10620 {
10621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10622 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10624
10625 std::string rd = GPR(copy(rd_value));
10626 std::string rs = GPR(copy(rs_value));
10627 std::string rt = GPR(copy(rt_value));
10628
10629 return img::format("MOVZ %s, %s, %s", rd, rs, rt);
10630 }
10631
10632
10633 /*
10634 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10635 *
10636 * 3 2 1
10637 * 10987654321098765432109876543210
10638 * 001000 00010001101
10639 * rt -----
10640 * rs -----
10641 * rd -----
10642 */
10643 std::string NMD::MSUB_DSP_(uint64 instruction)
10644 {
10645 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10646 uint64 ac_value = extract_ac_13_12(instruction);
10647 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10648
10649 std::string ac = AC(copy(ac_value));
10650 std::string rs = GPR(copy(rs_value));
10651 std::string rt = GPR(copy(rt_value));
10652
10653 return img::format("MSUB %s, %s, %s", ac, rs, rt);
10654 }
10655
10656
10657 /*
10658 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10659 *
10660 * 3 2 1
10661 * 10987654321098765432109876543210
10662 * 001000 00010001101
10663 * rt -----
10664 * rs -----
10665 * rd -----
10666 */
10667 std::string NMD::MSUBF_D(uint64 instruction)
10668 {
10669 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10670 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10671 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10672
10673 std::string fd = FPR(copy(fd_value));
10674 std::string fs = FPR(copy(fs_value));
10675 std::string ft = FPR(copy(ft_value));
10676
10677 return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
10678 }
10679
10680
10681 /*
10682 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10683 *
10684 * 3 2 1
10685 * 10987654321098765432109876543210
10686 * 001000 00010001101
10687 * rt -----
10688 * rs -----
10689 * rd -----
10690 */
10691 std::string NMD::MSUBF_S(uint64 instruction)
10692 {
10693 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10694 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10695 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10696
10697 std::string fd = FPR(copy(fd_value));
10698 std::string fs = FPR(copy(fs_value));
10699 std::string ft = FPR(copy(ft_value));
10700
10701 return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
10702 }
10703
10704
10705 /*
10706 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10707 *
10708 * 3 2 1
10709 * 10987654321098765432109876543210
10710 * 001000 00010001101
10711 * rt -----
10712 * rs -----
10713 * rd -----
10714 */
10715 std::string NMD::MSUBU_DSP_(uint64 instruction)
10716 {
10717 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10718 uint64 ac_value = extract_ac_13_12(instruction);
10719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10720
10721 std::string ac = AC(copy(ac_value));
10722 std::string rs = GPR(copy(rs_value));
10723 std::string rt = GPR(copy(rt_value));
10724
10725 return img::format("MSUBU %s, %s, %s", ac, rs, rt);
10726 }
10727
10728
10729 /*
10730 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10731 *
10732 * 3 2 1
10733 * 10987654321098765432109876543210
10734 * 001000 00010001101
10735 * rt -----
10736 * rs -----
10737 * rd -----
10738 */
10739 std::string NMD::MTC0(uint64 instruction)
10740 {
10741 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10742 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10743 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10744
10745 std::string rt = GPR(copy(rt_value));
10746 std::string c0s = CPR(copy(c0s_value));
10747 std::string sel = IMMEDIATE(copy(sel_value));
10748
10749 return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
10750 }
10751
10752
10753 /*
10754 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10755 *
10756 * 3 2 1
10757 * 10987654321098765432109876543210
10758 * 001000 00010001101
10759 * rt -----
10760 * rs -----
10761 * rd -----
10762 */
10763 std::string NMD::MTC1(uint64 instruction)
10764 {
10765 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10766 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10767
10768 std::string rt = GPR(copy(rt_value));
10769 std::string fs = FPR(copy(fs_value));
10770
10771 return img::format("MTC1 %s, %s", rt, fs);
10772 }
10773
10774
10775 /*
10776 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10777 *
10778 * 3 2 1
10779 * 10987654321098765432109876543210
10780 * 001000 00010001101
10781 * rt -----
10782 * rs -----
10783 * rd -----
10784 */
10785 std::string NMD::MTC2(uint64 instruction)
10786 {
10787 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10788 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10789
10790 std::string rt = GPR(copy(rt_value));
10791 std::string cs = CPR(copy(cs_value));
10792
10793 return img::format("MTC2 %s, %s", rt, cs);
10794 }
10795
10796
10797 /*
10798 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10799 *
10800 * 3 2 1
10801 * 10987654321098765432109876543210
10802 * 001000 00010001101
10803 * rt -----
10804 * rs -----
10805 * rd -----
10806 */
10807 std::string NMD::MTGC0(uint64 instruction)
10808 {
10809 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10810 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10811 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10812
10813 std::string rt = GPR(copy(rt_value));
10814 std::string c0s = CPR(copy(c0s_value));
10815 std::string sel = IMMEDIATE(copy(sel_value));
10816
10817 return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
10818 }
10819
10820
10821 /*
10822 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10823 *
10824 * 3 2 1
10825 * 10987654321098765432109876543210
10826 * 001000 00010001101
10827 * rt -----
10828 * rs -----
10829 * rd -----
10830 */
10831 std::string NMD::MTHC0(uint64 instruction)
10832 {
10833 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10834 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10835 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10836
10837 std::string rt = GPR(copy(rt_value));
10838 std::string c0s = CPR(copy(c0s_value));
10839 std::string sel = IMMEDIATE(copy(sel_value));
10840
10841 return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
10842 }
10843
10844
10845 /*
10846 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10847 *
10848 * 3 2 1
10849 * 10987654321098765432109876543210
10850 * 001000 00010001101
10851 * rt -----
10852 * rs -----
10853 * rd -----
10854 */
10855 std::string NMD::MTHC1(uint64 instruction)
10856 {
10857 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10858 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10859
10860 std::string rt = GPR(copy(rt_value));
10861 std::string fs = FPR(copy(fs_value));
10862
10863 return img::format("MTHC1 %s, %s", rt, fs);
10864 }
10865
10866
10867 /*
10868 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10869 *
10870 * 3 2 1
10871 * 10987654321098765432109876543210
10872 * 001000 00010001101
10873 * rt -----
10874 * rs -----
10875 * rd -----
10876 */
10877 std::string NMD::MTHC2(uint64 instruction)
10878 {
10879 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10880 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10881
10882 std::string rt = GPR(copy(rt_value));
10883 std::string cs = CPR(copy(cs_value));
10884
10885 return img::format("MTHC2 %s, %s", rt, cs);
10886 }
10887
10888
10889 /*
10890 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10891 *
10892 * 3 2 1
10893 * 10987654321098765432109876543210
10894 * 001000 00010001101
10895 * rt -----
10896 * rs -----
10897 * rd -----
10898 */
10899 std::string NMD::MTHGC0(uint64 instruction)
10900 {
10901 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10902 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10903 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10904
10905 std::string rt = GPR(copy(rt_value));
10906 std::string c0s = CPR(copy(c0s_value));
10907 std::string sel = IMMEDIATE(copy(sel_value));
10908
10909 return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
10910 }
10911
10912
10913 /*
10914 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10915 *
10916 * 3 2 1
10917 * 10987654321098765432109876543210
10918 * 001000 00010001101
10919 * rt -----
10920 * rs -----
10921 * rd -----
10922 */
10923 std::string NMD::MTHI_DSP_(uint64 instruction)
10924 {
10925 uint64 ac_value = extract_ac_13_12(instruction);
10926 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10927
10928 std::string rs = GPR(copy(rs_value));
10929 std::string ac = AC(copy(ac_value));
10930
10931 return img::format("MTHI %s, %s", rs, ac);
10932 }
10933
10934
10935 /*
10936 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10937 *
10938 * 3 2 1
10939 * 10987654321098765432109876543210
10940 * 001000 00010001101
10941 * rt -----
10942 * rs -----
10943 * rd -----
10944 */
10945 std::string NMD::MTHLIP(uint64 instruction)
10946 {
10947 uint64 ac_value = extract_ac_13_12(instruction);
10948 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10949
10950 std::string rs = GPR(copy(rs_value));
10951 std::string ac = AC(copy(ac_value));
10952
10953 return img::format("MTHLIP %s, %s", rs, ac);
10954 }
10955
10956
10957 /*
10958 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10959 *
10960 * 3 2 1
10961 * 10987654321098765432109876543210
10962 * 001000 00010001101
10963 * rt -----
10964 * rs -----
10965 * rd -----
10966 */
10967 std::string NMD::MTHTR(uint64 instruction)
10968 {
10969 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10970 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10971 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10972 uint64 u_value = extract_u_10(instruction);
10973
10974 std::string rt = GPR(copy(rt_value));
10975 std::string c0s = IMMEDIATE(copy(c0s_value));
10976 std::string u = IMMEDIATE(copy(u_value));
10977 std::string sel = IMMEDIATE(copy(sel_value));
10978
10979 return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
10980 }
10981
10982
10983 /*
10984 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10985 *
10986 * 3 2 1
10987 * 10987654321098765432109876543210
10988 * 001000 00010001101
10989 * rt -----
10990 * rs -----
10991 * rd -----
10992 */
10993 std::string NMD::MTLO_DSP_(uint64 instruction)
10994 {
10995 uint64 ac_value = extract_ac_13_12(instruction);
10996 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10997
10998 std::string rs = GPR(copy(rs_value));
10999 std::string ac = AC(copy(ac_value));
11000
11001 return img::format("MTLO %s, %s", rs, ac);
11002 }
11003
11004
11005 /*
11006 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11007 *
11008 * 3 2 1
11009 * 10987654321098765432109876543210
11010 * 001000 00010001101
11011 * rt -----
11012 * rs -----
11013 * rd -----
11014 */
11015 std::string NMD::MTTR(uint64 instruction)
11016 {
11017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11018 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
11019 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
11020 uint64 u_value = extract_u_10(instruction);
11021
11022 std::string rt = GPR(copy(rt_value));
11023 std::string c0s = IMMEDIATE(copy(c0s_value));
11024 std::string u = IMMEDIATE(copy(u_value));
11025 std::string sel = IMMEDIATE(copy(sel_value));
11026
11027 return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
11028 }
11029
11030
11031 /*
11032 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11033 *
11034 * 3 2 1
11035 * 10987654321098765432109876543210
11036 * 001000 00010001101
11037 * rt -----
11038 * rs -----
11039 * rd -----
11040 */
11041 std::string NMD::MUH(uint64 instruction)
11042 {
11043 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11044 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11045 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11046
11047 std::string rd = GPR(copy(rd_value));
11048 std::string rs = GPR(copy(rs_value));
11049 std::string rt = GPR(copy(rt_value));
11050
11051 return img::format("MUH %s, %s, %s", rd, rs, rt);
11052 }
11053
11054
11055 /*
11056 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11057 *
11058 * 3 2 1
11059 * 10987654321098765432109876543210
11060 * 001000 00010001101
11061 * rt -----
11062 * rs -----
11063 * rd -----
11064 */
11065 std::string NMD::MUHU(uint64 instruction)
11066 {
11067 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11068 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11069 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11070
11071 std::string rd = GPR(copy(rd_value));
11072 std::string rs = GPR(copy(rs_value));
11073 std::string rt = GPR(copy(rt_value));
11074
11075 return img::format("MUHU %s, %s, %s", rd, rs, rt);
11076 }
11077
11078
11079 /*
11080 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11081 *
11082 * 3 2 1
11083 * 10987654321098765432109876543210
11084 * 001000 00010001101
11085 * rt -----
11086 * rs -----
11087 * rd -----
11088 */
11089 std::string NMD::MUL_32_(uint64 instruction)
11090 {
11091 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11092 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11093 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11094
11095 std::string rd = GPR(copy(rd_value));
11096 std::string rs = GPR(copy(rs_value));
11097 std::string rt = GPR(copy(rt_value));
11098
11099 return img::format("MUL %s, %s, %s", rd, rs, rt);
11100 }
11101
11102
11103 /*
11104 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11105 *
11106 * 3 2 1
11107 * 10987654321098765432109876543210
11108 * 001000 00010001101
11109 * rt -----
11110 * rs -----
11111 * rd -----
11112 */
11113 std::string NMD::MUL_4X4_(uint64 instruction)
11114 {
11115 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11116 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
11117
11118 std::string rs4 = GPR(encode_gpr4(rs4_value));
11119 std::string rt4 = GPR(encode_gpr4(rt4_value));
11120
11121 return img::format("MUL %s, %s", rs4, rt4);
11122 }
11123
11124
11125 /*
11126 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11127 *
11128 * 3 2 1
11129 * 10987654321098765432109876543210
11130 * 001000 00010001101
11131 * rt -----
11132 * rs -----
11133 * rd -----
11134 */
11135 std::string NMD::MUL_D(uint64 instruction)
11136 {
11137 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11138 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11139 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
11140
11141 std::string fd = FPR(copy(fd_value));
11142 std::string fs = FPR(copy(fs_value));
11143 std::string ft = FPR(copy(ft_value));
11144
11145 return img::format("MUL.D %s, %s, %s", fd, fs, ft);
11146 }
11147
11148
11149 /*
11150 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11151 *
11152 * 3 2 1
11153 * 10987654321098765432109876543210
11154 * 001000 00010001101
11155 * rt -----
11156 * rs -----
11157 * rd -----
11158 */
11159 std::string NMD::MUL_PH(uint64 instruction)
11160 {
11161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11162 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11163 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11164
11165 std::string rd = GPR(copy(rd_value));
11166 std::string rs = GPR(copy(rs_value));
11167 std::string rt = GPR(copy(rt_value));
11168
11169 return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
11170 }
11171
11172
11173 /*
11174 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11175 *
11176 * 3 2 1
11177 * 10987654321098765432109876543210
11178 * 001000 00010001101
11179 * rt -----
11180 * rs -----
11181 * rd -----
11182 */
11183 std::string NMD::MUL_S_PH(uint64 instruction)
11184 {
11185 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11186 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11187 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11188
11189 std::string rd = GPR(copy(rd_value));
11190 std::string rs = GPR(copy(rs_value));
11191 std::string rt = GPR(copy(rt_value));
11192
11193 return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
11194 }
11195
11196
11197 /*
11198 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11199 *
11200 * 3 2 1
11201 * 10987654321098765432109876543210
11202 * 001000 00010001101
11203 * rt -----
11204 * rs -----
11205 * rd -----
11206 */
11207 std::string NMD::MUL_S(uint64 instruction)
11208 {
11209 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11210 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11211 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
11212
11213 std::string fd = FPR(copy(fd_value));
11214 std::string fs = FPR(copy(fs_value));
11215 std::string ft = FPR(copy(ft_value));
11216
11217 return img::format("MUL.S %s, %s, %s", fd, fs, ft);
11218 }
11219
11220
11221 /*
11222 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11223 *
11224 * 3 2 1
11225 * 10987654321098765432109876543210
11226 * 001000 00010001101
11227 * rt -----
11228 * rs -----
11229 * rd -----
11230 */
11231 std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
11232 {
11233 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11234 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11235 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11236
11237 std::string rd = GPR(copy(rd_value));
11238 std::string rs = GPR(copy(rs_value));
11239 std::string rt = GPR(copy(rt_value));
11240
11241 return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
11242 }
11243
11244
11245 /*
11246 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11247 *
11248 * 3 2 1
11249 * 10987654321098765432109876543210
11250 * 001000 00010001101
11251 * rt -----
11252 * rs -----
11253 * rd -----
11254 */
11255 std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
11256 {
11257 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11258 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11259 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11260
11261 std::string rd = GPR(copy(rd_value));
11262 std::string rs = GPR(copy(rs_value));
11263 std::string rt = GPR(copy(rt_value));
11264
11265 return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
11266 }
11267
11268
11269 /*
11270 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11271 *
11272 * 3 2 1
11273 * 10987654321098765432109876543210
11274 * 001000 00010001101
11275 * rt -----
11276 * rs -----
11277 * rd -----
11278 */
11279 std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
11280 {
11281 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11282 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11283 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11284
11285 std::string rd = GPR(copy(rd_value));
11286 std::string rs = GPR(copy(rs_value));
11287 std::string rt = GPR(copy(rt_value));
11288
11289 return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
11290 }
11291
11292
11293 /*
11294 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11295 *
11296 * 3 2 1
11297 * 10987654321098765432109876543210
11298 * 001000 00010001101
11299 * rt -----
11300 * rs -----
11301 * rd -----
11302 */
11303 std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
11304 {
11305 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11306 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11307 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11308
11309 std::string rd = GPR(copy(rd_value));
11310 std::string rs = GPR(copy(rs_value));
11311 std::string rt = GPR(copy(rt_value));
11312
11313 return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
11314 }
11315
11316
11317 /*
11318 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11319 *
11320 * 3 2 1
11321 * 10987654321098765432109876543210
11322 * 001000 00010001101
11323 * rt -----
11324 * rs -----
11325 * rd -----
11326 */
11327 std::string NMD::MULQ_RS_PH(uint64 instruction)
11328 {
11329 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11330 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11331 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11332
11333 std::string rd = GPR(copy(rd_value));
11334 std::string rs = GPR(copy(rs_value));
11335 std::string rt = GPR(copy(rt_value));
11336
11337 return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
11338 }
11339
11340
11341 /*
11342 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11343 *
11344 * 3 2 1
11345 * 10987654321098765432109876543210
11346 * 001000 00010001101
11347 * rt -----
11348 * rs -----
11349 * rd -----
11350 */
11351 std::string NMD::MULQ_RS_W(uint64 instruction)
11352 {
11353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11354 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11355 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11356
11357 std::string rd = GPR(copy(rd_value));
11358 std::string rs = GPR(copy(rs_value));
11359 std::string rt = GPR(copy(rt_value));
11360
11361 return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
11362 }
11363
11364
11365 /*
11366 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11367 *
11368 * 3 2 1
11369 * 10987654321098765432109876543210
11370 * 001000 00010001101
11371 * rt -----
11372 * rs -----
11373 * rd -----
11374 */
11375 std::string NMD::MULQ_S_PH(uint64 instruction)
11376 {
11377 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11378 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11379 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11380
11381 std::string rd = GPR(copy(rd_value));
11382 std::string rs = GPR(copy(rs_value));
11383 std::string rt = GPR(copy(rt_value));
11384
11385 return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
11386 }
11387
11388
11389 /*
11390 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11391 *
11392 * 3 2 1
11393 * 10987654321098765432109876543210
11394 * 001000 00010001101
11395 * rt -----
11396 * rs -----
11397 * rd -----
11398 */
11399 std::string NMD::MULQ_S_W(uint64 instruction)
11400 {
11401 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11402 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11403 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11404
11405 std::string rd = GPR(copy(rd_value));
11406 std::string rs = GPR(copy(rs_value));
11407 std::string rt = GPR(copy(rt_value));
11408
11409 return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11410 }
11411
11412
11413 /*
11414 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11415 *
11416 * 3 2 1
11417 * 10987654321098765432109876543210
11418 * 001000 00010001101
11419 * rt -----
11420 * rs -----
11421 * rd -----
11422 */
11423 std::string NMD::MULSA_W_PH(uint64 instruction)
11424 {
11425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11426 uint64 ac_value = extract_ac_13_12(instruction);
11427 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11428
11429 std::string ac = AC(copy(ac_value));
11430 std::string rs = GPR(copy(rs_value));
11431 std::string rt = GPR(copy(rt_value));
11432
11433 return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11434 }
11435
11436
11437 /*
11438 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11439 *
11440 * 3 2 1
11441 * 10987654321098765432109876543210
11442 * 001000 00010001101
11443 * rt -----
11444 * rs -----
11445 * rd -----
11446 */
11447 std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
11448 {
11449 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11450 uint64 ac_value = extract_ac_13_12(instruction);
11451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11452
11453 std::string ac = AC(copy(ac_value));
11454 std::string rs = GPR(copy(rs_value));
11455 std::string rt = GPR(copy(rt_value));
11456
11457 return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11458 }
11459
11460
11461 /*
11462 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11463 *
11464 * 3 2 1
11465 * 10987654321098765432109876543210
11466 * 001000 00010001101
11467 * rt -----
11468 * rs -----
11469 * rd -----
11470 */
11471 std::string NMD::MULT_DSP_(uint64 instruction)
11472 {
11473 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11474 uint64 ac_value = extract_ac_13_12(instruction);
11475 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11476
11477 std::string ac = AC(copy(ac_value));
11478 std::string rs = GPR(copy(rs_value));
11479 std::string rt = GPR(copy(rt_value));
11480
11481 return img::format("MULT %s, %s, %s", ac, rs, rt);
11482 }
11483
11484
11485 /*
11486 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11487 *
11488 * 3 2 1
11489 * 10987654321098765432109876543210
11490 * 001000 00010001101
11491 * rt -----
11492 * rs -----
11493 * rd -----
11494 */
11495 std::string NMD::MULTU_DSP_(uint64 instruction)
11496 {
11497 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11498 uint64 ac_value = extract_ac_13_12(instruction);
11499 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11500
11501 std::string ac = AC(copy(ac_value));
11502 std::string rs = GPR(copy(rs_value));
11503 std::string rt = GPR(copy(rt_value));
11504
11505 return img::format("MULTU %s, %s, %s", ac, rs, rt);
11506 }
11507
11508
11509 /*
11510 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11511 *
11512 * 3 2 1
11513 * 10987654321098765432109876543210
11514 * 001000 00010001101
11515 * rt -----
11516 * rs -----
11517 * rd -----
11518 */
11519 std::string NMD::MULU(uint64 instruction)
11520 {
11521 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11522 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11523 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11524
11525 std::string rd = GPR(copy(rd_value));
11526 std::string rs = GPR(copy(rs_value));
11527 std::string rt = GPR(copy(rt_value));
11528
11529 return img::format("MULU %s, %s, %s", rd, rs, rt);
11530 }
11531
11532
11533 /*
11534 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11535 *
11536 * 3 2 1
11537 * 10987654321098765432109876543210
11538 * 001000 00010001101
11539 * rt -----
11540 * rs -----
11541 * rd -----
11542 */
11543 std::string NMD::NEG_D(uint64 instruction)
11544 {
11545 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11546 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11547
11548 std::string ft = FPR(copy(ft_value));
11549 std::string fs = FPR(copy(fs_value));
11550
11551 return img::format("NEG.D %s, %s", ft, fs);
11552 }
11553
11554
11555 /*
11556 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11557 *
11558 * 3 2 1
11559 * 10987654321098765432109876543210
11560 * 001000 00010001101
11561 * rt -----
11562 * rs -----
11563 * rd -----
11564 */
11565 std::string NMD::NEG_S(uint64 instruction)
11566 {
11567 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11568 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11569
11570 std::string ft = FPR(copy(ft_value));
11571 std::string fs = FPR(copy(fs_value));
11572
11573 return img::format("NEG.S %s, %s", ft, fs);
11574 }
11575
11576
11577 /*
11578 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11579 *
11580 * 3 2 1
11581 * 10987654321098765432109876543210
11582 * 001000 00010001101
11583 * rt -----
11584 * rs -----
11585 * rd -----
11586 */
11587 std::string NMD::NOP_16_(uint64 instruction)
11588 {
11589 (void)instruction;
11590
11591 return "NOP ";
11592 }
11593
11594
11595 /*
11596 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11597 *
11598 * 3 2 1
11599 * 10987654321098765432109876543210
11600 * 001000 00010001101
11601 * rt -----
11602 * rs -----
11603 * rd -----
11604 */
11605 std::string NMD::NOP_32_(uint64 instruction)
11606 {
11607 (void)instruction;
11608
11609 return "NOP ";
11610 }
11611
11612
11613 /*
11614 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11615 *
11616 * 3 2 1
11617 * 10987654321098765432109876543210
11618 * 001000 00010001101
11619 * rt -----
11620 * rs -----
11621 * rd -----
11622 */
11623 std::string NMD::NOR(uint64 instruction)
11624 {
11625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11626 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11627 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11628
11629 std::string rd = GPR(copy(rd_value));
11630 std::string rs = GPR(copy(rs_value));
11631 std::string rt = GPR(copy(rt_value));
11632
11633 return img::format("NOR %s, %s, %s", rd, rs, rt);
11634 }
11635
11636
11637 /*
11638 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11639 *
11640 * 3 2 1
11641 * 10987654321098765432109876543210
11642 * 001000 00010001101
11643 * rt -----
11644 * rs -----
11645 * rd -----
11646 */
11647 std::string NMD::NOT_16_(uint64 instruction)
11648 {
11649 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11650 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11651
11652 std::string rt3 = GPR(encode_gpr3(rt3_value));
11653 std::string rs3 = GPR(encode_gpr3(rs3_value));
11654
11655 return img::format("NOT %s, %s", rt3, rs3);
11656 }
11657
11658
11659 /*
11660 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11661 *
11662 * 3 2 1
11663 * 10987654321098765432109876543210
11664 * 001000 00010001101
11665 * rt -----
11666 * rs -----
11667 * rd -----
11668 */
11669 std::string NMD::OR_16_(uint64 instruction)
11670 {
11671 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11672 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11673
11674 std::string rs3 = GPR(encode_gpr3(rs3_value));
11675 std::string rt3 = GPR(encode_gpr3(rt3_value));
11676
11677 return img::format("OR %s, %s", rs3, rt3);
11678 }
11679
11680
11681 /*
11682 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11683 *
11684 * 3 2 1
11685 * 10987654321098765432109876543210
11686 * 001000 00010001101
11687 * rt -----
11688 * rs -----
11689 * rd -----
11690 */
11691 std::string NMD::OR_32_(uint64 instruction)
11692 {
11693 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11694 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11695 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11696
11697 std::string rd = GPR(copy(rd_value));
11698 std::string rs = GPR(copy(rs_value));
11699 std::string rt = GPR(copy(rt_value));
11700
11701 return img::format("OR %s, %s, %s", rd, rs, rt);
11702 }
11703
11704
11705 /*
11706 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11707 *
11708 * 3 2 1
11709 * 10987654321098765432109876543210
11710 * 001000 00010001101
11711 * rt -----
11712 * rs -----
11713 * rd -----
11714 */
11715 std::string NMD::ORI(uint64 instruction)
11716 {
11717 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11718 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11720
11721 std::string rt = GPR(copy(rt_value));
11722 std::string rs = GPR(copy(rs_value));
11723 std::string u = IMMEDIATE(copy(u_value));
11724
11725 return img::format("ORI %s, %s, %s", rt, rs, u);
11726 }
11727
11728
11729 /*
11730 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11731 *
11732 * 3 2 1
11733 * 10987654321098765432109876543210
11734 * 001000 00010001101
11735 * rt -----
11736 * rs -----
11737 * rd -----
11738 */
11739 std::string NMD::PACKRL_PH(uint64 instruction)
11740 {
11741 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11742 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11743 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11744
11745 std::string rd = GPR(copy(rd_value));
11746 std::string rs = GPR(copy(rs_value));
11747 std::string rt = GPR(copy(rt_value));
11748
11749 return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11750 }
11751
11752
11753 /*
11754 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11755 *
11756 * 3 2 1
11757 * 10987654321098765432109876543210
11758 * 001000 00010001101
11759 * rt -----
11760 * rs -----
11761 * rd -----
11762 */
11763 std::string NMD::PAUSE(uint64 instruction)
11764 {
11765 (void)instruction;
11766
11767 return "PAUSE ";
11768 }
11769
11770
11771 /*
11772 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11773 *
11774 * 3 2 1
11775 * 10987654321098765432109876543210
11776 * 001000 00010001101
11777 * rt -----
11778 * rs -----
11779 * rd -----
11780 */
11781 std::string NMD::PICK_PH(uint64 instruction)
11782 {
11783 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11784 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11785 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11786
11787 std::string rd = GPR(copy(rd_value));
11788 std::string rs = GPR(copy(rs_value));
11789 std::string rt = GPR(copy(rt_value));
11790
11791 return img::format("PICK.PH %s, %s, %s", rd, rs, rt);
11792 }
11793
11794
11795 /*
11796 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11797 *
11798 * 3 2 1
11799 * 10987654321098765432109876543210
11800 * 001000 00010001101
11801 * rt -----
11802 * rs -----
11803 * rd -----
11804 */
11805 std::string NMD::PICK_QB(uint64 instruction)
11806 {
11807 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11808 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11809 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11810
11811 std::string rd = GPR(copy(rd_value));
11812 std::string rs = GPR(copy(rs_value));
11813 std::string rt = GPR(copy(rt_value));
11814
11815 return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
11816 }
11817
11818
11819 /*
11820 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11821 *
11822 * 3 2 1
11823 * 10987654321098765432109876543210
11824 * 001000 00010001101
11825 * rt -----
11826 * rs -----
11827 * rd -----
11828 */
11829 std::string NMD::PRECEQ_W_PHL(uint64 instruction)
11830 {
11831 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11832 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11833
11834 std::string rt = GPR(copy(rt_value));
11835 std::string rs = GPR(copy(rs_value));
11836
11837 return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
11838 }
11839
11840
11841 /*
11842 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11843 *
11844 * 3 2 1
11845 * 10987654321098765432109876543210
11846 * 001000 00010001101
11847 * rt -----
11848 * rs -----
11849 * rd -----
11850 */
11851 std::string NMD::PRECEQ_W_PHR(uint64 instruction)
11852 {
11853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11854 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11855
11856 std::string rt = GPR(copy(rt_value));
11857 std::string rs = GPR(copy(rs_value));
11858
11859 return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
11860 }
11861
11862
11863 /*
11864 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11865 *
11866 * 3 2 1
11867 * 10987654321098765432109876543210
11868 * 001000 00010001101
11869 * rt -----
11870 * rs -----
11871 * rd -----
11872 */
11873 std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
11874 {
11875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11876 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11877
11878 std::string rt = GPR(copy(rt_value));
11879 std::string rs = GPR(copy(rs_value));
11880
11881 return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11882 }
11883
11884
11885 /*
11886 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11887 *
11888 * 3 2 1
11889 * 10987654321098765432109876543210
11890 * 001000 00010001101
11891 * rt -----
11892 * rs -----
11893 * rd -----
11894 */
11895 std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
11896 {
11897 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11898 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11899
11900 std::string rt = GPR(copy(rt_value));
11901 std::string rs = GPR(copy(rs_value));
11902
11903 return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
11904 }
11905
11906
11907 /*
11908 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11909 *
11910 * 3 2 1
11911 * 10987654321098765432109876543210
11912 * 001000 00010001101
11913 * rt -----
11914 * rs -----
11915 * rd -----
11916 */
11917 std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
11918 {
11919 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11920 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11921
11922 std::string rt = GPR(copy(rt_value));
11923 std::string rs = GPR(copy(rs_value));
11924
11925 return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11926 }
11927
11928
11929 /*
11930 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11931 *
11932 * 3 2 1
11933 * 10987654321098765432109876543210
11934 * 001000 00010001101
11935 * rt -----
11936 * rs -----
11937 * rd -----
11938 */
11939 std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
11940 {
11941 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11942 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11943
11944 std::string rt = GPR(copy(rt_value));
11945 std::string rs = GPR(copy(rs_value));
11946
11947 return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
11948 }
11949
11950
11951 /*
11952 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11953 *
11954 * 3 2 1
11955 * 10987654321098765432109876543210
11956 * 001000 00010001101
11957 * rt -----
11958 * rs -----
11959 * rd -----
11960 */
11961 std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
11962 {
11963 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11964 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11965
11966 std::string rt = GPR(copy(rt_value));
11967 std::string rs = GPR(copy(rs_value));
11968
11969 return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
11970 }
11971
11972
11973 /*
11974 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11975 *
11976 * 3 2 1
11977 * 10987654321098765432109876543210
11978 * 001000 00010001101
11979 * rt -----
11980 * rs -----
11981 * rd -----
11982 */
11983 std::string NMD::PRECEU_PH_QBL(uint64 instruction)
11984 {
11985 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11986 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11987
11988 std::string rt = GPR(copy(rt_value));
11989 std::string rs = GPR(copy(rs_value));
11990
11991 return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
11992 }
11993
11994
11995 /*
11996 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11997 *
11998 * 3 2 1
11999 * 10987654321098765432109876543210
12000 * 001000 00010001101
12001 * rt -----
12002 * rs -----
12003 * rd -----
12004 */
12005 std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
12006 {
12007 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12008 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12009
12010 std::string rt = GPR(copy(rt_value));
12011 std::string rs = GPR(copy(rs_value));
12012
12013 return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
12014 }
12015
12016
12017 /*
12018 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12019 *
12020 * 3 2 1
12021 * 10987654321098765432109876543210
12022 * 001000 00010001101
12023 * rt -----
12024 * rs -----
12025 * rd -----
12026 */
12027 std::string NMD::PRECEU_PH_QBR(uint64 instruction)
12028 {
12029 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12030 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12031
12032 std::string rt = GPR(copy(rt_value));
12033 std::string rs = GPR(copy(rs_value));
12034
12035 return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
12036 }
12037
12038
12039 /*
12040 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12041 *
12042 * 3 2 1
12043 * 10987654321098765432109876543210
12044 * 001000 00010001101
12045 * rt -----
12046 * rs -----
12047 * rd -----
12048 */
12049 std::string NMD::PRECR_QB_PH(uint64 instruction)
12050 {
12051 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12052 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12053 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12054
12055 std::string rd = GPR(copy(rd_value));
12056 std::string rs = GPR(copy(rs_value));
12057 std::string rt = GPR(copy(rt_value));
12058
12059 return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
12060 }
12061
12062
12063 /*
12064 *
12065 *
12066 * 3 2 1
12067 * 10987654321098765432109876543210
12068 * 001000 x1110000101
12069 * rt -----
12070 * rs -----
12071 * rd -----
12072 */
12073 std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
12074 {
12075 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12076 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12077 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12078
12079 std::string rt = GPR(copy(rt_value));
12080 std::string rs = GPR(copy(rs_value));
12081 std::string sa = IMMEDIATE(copy(sa_value));
12082
12083 return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
12084 }
12085
12086
12087 /*
12088 *
12089 *
12090 * 3 2 1
12091 * 10987654321098765432109876543210
12092 * 001000 x1110000101
12093 * rt -----
12094 * rs -----
12095 * rd -----
12096 */
12097 std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
12098 {
12099 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12100 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12102
12103 std::string rt = GPR(copy(rt_value));
12104 std::string rs = GPR(copy(rs_value));
12105 std::string sa = IMMEDIATE(copy(sa_value));
12106
12107 return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
12108 }
12109
12110
12111 /*
12112 *
12113 *
12114 * 3 2 1
12115 * 10987654321098765432109876543210
12116 * 001000 x1110000101
12117 * rt -----
12118 * rs -----
12119 * rd -----
12120 */
12121 std::string NMD::PRECRQ_PH_W(uint64 instruction)
12122 {
12123 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12124 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12125 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12126
12127 std::string rd = GPR(copy(rd_value));
12128 std::string rs = GPR(copy(rs_value));
12129 std::string rt = GPR(copy(rt_value));
12130
12131 return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
12132 }
12133
12134
12135 /*
12136 *
12137 *
12138 * 3 2 1
12139 * 10987654321098765432109876543210
12140 * 001000 x1110000101
12141 * rt -----
12142 * rs -----
12143 * rd -----
12144 */
12145 std::string NMD::PRECRQ_QB_PH(uint64 instruction)
12146 {
12147 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12148 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12149 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12150
12151 std::string rd = GPR(copy(rd_value));
12152 std::string rs = GPR(copy(rs_value));
12153 std::string rt = GPR(copy(rt_value));
12154
12155 return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
12156 }
12157
12158
12159 /*
12160 *
12161 *
12162 * 3 2 1
12163 * 10987654321098765432109876543210
12164 * 001000 x1110000101
12165 * rt -----
12166 * rs -----
12167 * rd -----
12168 */
12169 std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
12170 {
12171 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12172 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12173 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12174
12175 std::string rd = GPR(copy(rd_value));
12176 std::string rs = GPR(copy(rs_value));
12177 std::string rt = GPR(copy(rt_value));
12178
12179 return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
12180 }
12181
12182
12183 /*
12184 *
12185 *
12186 * 3 2 1
12187 * 10987654321098765432109876543210
12188 * 001000 x1110000101
12189 * rt -----
12190 * rs -----
12191 * rd -----
12192 */
12193 std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
12194 {
12195 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12196 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12197 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12198
12199 std::string rd = GPR(copy(rd_value));
12200 std::string rs = GPR(copy(rs_value));
12201 std::string rt = GPR(copy(rt_value));
12202
12203 return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
12204 }
12205
12206
12207 /*
12208 *
12209 *
12210 * 3 2 1
12211 * 10987654321098765432109876543210
12212 * 001000 x1110000101
12213 * rt -----
12214 * rs -----
12215 * rd -----
12216 */
12217 std::string NMD::PREF_S9_(uint64 instruction)
12218 {
12219 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12220 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12221 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12222
12223 std::string hint = IMMEDIATE(copy(hint_value));
12224 std::string s = IMMEDIATE(copy(s_value));
12225 std::string rs = GPR(copy(rs_value));
12226
12227 return img::format("PREF %s, %s(%s)", hint, s, rs);
12228 }
12229
12230
12231 /*
12232 *
12233 *
12234 * 3 2 1
12235 * 10987654321098765432109876543210
12236 * 001000 x1110000101
12237 * rt -----
12238 * rs -----
12239 * rd -----
12240 */
12241 std::string NMD::PREF_U12_(uint64 instruction)
12242 {
12243 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12244 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12245 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12246
12247 std::string hint = IMMEDIATE(copy(hint_value));
12248 std::string u = IMMEDIATE(copy(u_value));
12249 std::string rs = GPR(copy(rs_value));
12250
12251 return img::format("PREF %s, %s(%s)", hint, u, rs);
12252 }
12253
12254
12255 /*
12256 *
12257 *
12258 * 3 2 1
12259 * 10987654321098765432109876543210
12260 * 001000 x1110000101
12261 * rt -----
12262 * rs -----
12263 * rd -----
12264 */
12265 std::string NMD::PREFE(uint64 instruction)
12266 {
12267 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12268 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12269 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12270
12271 std::string hint = IMMEDIATE(copy(hint_value));
12272 std::string s = IMMEDIATE(copy(s_value));
12273 std::string rs = GPR(copy(rs_value));
12274
12275 return img::format("PREFE %s, %s(%s)", hint, s, rs);
12276 }
12277
12278
12279 /*
12280 *
12281 *
12282 * 3 2 1
12283 * 10987654321098765432109876543210
12284 * 001000 x1110000101
12285 * rt -----
12286 * rs -----
12287 * rd -----
12288 */
12289 std::string NMD::PREPEND(uint64 instruction)
12290 {
12291 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12292 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12293 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12294
12295 std::string rt = GPR(copy(rt_value));
12296 std::string rs = GPR(copy(rs_value));
12297 std::string sa = IMMEDIATE(copy(sa_value));
12298
12299 return img::format("PREPEND %s, %s, %s", rt, rs, sa);
12300 }
12301
12302
12303 /*
12304 *
12305 *
12306 * 3 2 1
12307 * 10987654321098765432109876543210
12308 * 001000 x1110000101
12309 * rt -----
12310 * rs -----
12311 * rd -----
12312 */
12313 std::string NMD::RADDU_W_QB(uint64 instruction)
12314 {
12315 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12316 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12317
12318 std::string rt = GPR(copy(rt_value));
12319 std::string rs = GPR(copy(rs_value));
12320
12321 return img::format("RADDU.W.QB %s, %s", rt, rs);
12322 }
12323
12324
12325 /*
12326 *
12327 *
12328 * 3 2 1
12329 * 10987654321098765432109876543210
12330 * 001000 x1110000101
12331 * rt -----
12332 * rs -----
12333 * rd -----
12334 */
12335 std::string NMD::RDDSP(uint64 instruction)
12336 {
12337 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12338 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
12339
12340 std::string rt = GPR(copy(rt_value));
12341 std::string mask = IMMEDIATE(copy(mask_value));
12342
12343 return img::format("RDDSP %s, %s", rt, mask);
12344 }
12345
12346
12347 /*
12348 *
12349 *
12350 * 3 2 1
12351 * 10987654321098765432109876543210
12352 * 001000 x1110000101
12353 * rt -----
12354 * rs -----
12355 * rd -----
12356 */
12357 std::string NMD::RDHWR(uint64 instruction)
12358 {
12359 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12360 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
12361 uint64 sel_value = extract_sel_13_12_11(instruction);
12362
12363 std::string rt = GPR(copy(rt_value));
12364 std::string hs = CPR(copy(hs_value));
12365 std::string sel = IMMEDIATE(copy(sel_value));
12366
12367 return img::format("RDHWR %s, %s, %s", rt, hs, sel);
12368 }
12369
12370
12371 /*
12372 *
12373 *
12374 * 3 2 1
12375 * 10987654321098765432109876543210
12376 * 001000 x1110000101
12377 * rt -----
12378 * rs -----
12379 * rd -----
12380 */
12381 std::string NMD::RDPGPR(uint64 instruction)
12382 {
12383 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12384 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12385
12386 std::string rt = GPR(copy(rt_value));
12387 std::string rs = GPR(copy(rs_value));
12388
12389 return img::format("RDPGPR %s, %s", rt, rs);
12390 }
12391
12392
12393 /*
12394 *
12395 *
12396 * 3 2 1
12397 * 10987654321098765432109876543210
12398 * 001000 x1110000101
12399 * rt -----
12400 * rs -----
12401 * rd -----
12402 */
12403 std::string NMD::RECIP_D(uint64 instruction)
12404 {
12405 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12406 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12407
12408 std::string ft = FPR(copy(ft_value));
12409 std::string fs = FPR(copy(fs_value));
12410
12411 return img::format("RECIP.D %s, %s", ft, fs);
12412 }
12413
12414
12415 /*
12416 *
12417 *
12418 * 3 2 1
12419 * 10987654321098765432109876543210
12420 * 001000 x1110000101
12421 * rt -----
12422 * rs -----
12423 * rd -----
12424 */
12425 std::string NMD::RECIP_S(uint64 instruction)
12426 {
12427 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12428 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12429
12430 std::string ft = FPR(copy(ft_value));
12431 std::string fs = FPR(copy(fs_value));
12432
12433 return img::format("RECIP.S %s, %s", ft, fs);
12434 }
12435
12436
12437 /*
12438 *
12439 *
12440 * 3 2 1
12441 * 10987654321098765432109876543210
12442 * 001000 x1110000101
12443 * rt -----
12444 * rs -----
12445 * rd -----
12446 */
12447 std::string NMD::REPL_PH(uint64 instruction)
12448 {
12449 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12450 int64 s_value = extr_sil11il0bs10Tmsb9(instruction);
12451
12452 std::string rt = GPR(copy(rt_value));
12453 std::string s = IMMEDIATE(copy(s_value));
12454
12455 return img::format("REPL.PH %s, %s", rt, s);
12456 }
12457
12458
12459 /*
12460 *
12461 *
12462 * 3 2 1
12463 * 10987654321098765432109876543210
12464 * 001000 x1110000101
12465 * rt -----
12466 * rs -----
12467 * rd -----
12468 */
12469 std::string NMD::REPL_QB(uint64 instruction)
12470 {
12471 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12472 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12473
12474 std::string rt = GPR(copy(rt_value));
12475 std::string u = IMMEDIATE(copy(u_value));
12476
12477 return img::format("REPL.QB %s, %s", rt, u);
12478 }
12479
12480
12481 /*
12482 *
12483 *
12484 * 3 2 1
12485 * 10987654321098765432109876543210
12486 * 001000 x1110000101
12487 * rt -----
12488 * rs -----
12489 * rd -----
12490 */
12491 std::string NMD::REPLV_PH(uint64 instruction)
12492 {
12493 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12494 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12495
12496 std::string rt = GPR(copy(rt_value));
12497 std::string rs = GPR(copy(rs_value));
12498
12499 return img::format("REPLV.PH %s, %s", rt, rs);
12500 }
12501
12502
12503 /*
12504 *
12505 *
12506 * 3 2 1
12507 * 10987654321098765432109876543210
12508 * 001000 x1110000101
12509 * rt -----
12510 * rs -----
12511 * rd -----
12512 */
12513 std::string NMD::REPLV_QB(uint64 instruction)
12514 {
12515 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12516 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12517
12518 std::string rt = GPR(copy(rt_value));
12519 std::string rs = GPR(copy(rs_value));
12520
12521 return img::format("REPLV.QB %s, %s", rt, rs);
12522 }
12523
12524
12525 /*
12526 *
12527 *
12528 * 3 2 1
12529 * 10987654321098765432109876543210
12530 * 001000 x1110000101
12531 * rt -----
12532 * rs -----
12533 * rd -----
12534 */
12535 std::string NMD::RESTORE_32_(uint64 instruction)
12536 {
12537 uint64 count_value = extract_count_19_18_17_16(instruction);
12538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12539 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12540 uint64 gp_value = extract_gp_2(instruction);
12541
12542 std::string u = IMMEDIATE(copy(u_value));
12543 return img::format("RESTORE %s%s", u,
12544 save_restore_list(rt_value, count_value, gp_value));
12545 }
12546
12547
12548 /*
12549 *
12550 *
12551 * 3 2 1
12552 * 10987654321098765432109876543210
12553 * 001000 x1110000101
12554 * rt -----
12555 * rs -----
12556 * rd -----
12557 */
12558 std::string NMD::RESTORE_JRC_16_(uint64 instruction)
12559 {
12560 uint64 count_value = extract_count_3_2_1_0(instruction);
12561 uint64 rt1_value = extract_rtl_11(instruction);
12562 uint64 u_value = extr_uil4il4bs4Fmsb7(instruction);
12563
12564 std::string u = IMMEDIATE(copy(u_value));
12565 return img::format("RESTORE.JRC %s%s", u,
12566 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12567 }
12568
12569
12570 /*
12571 *
12572 *
12573 * 3 2 1
12574 * 10987654321098765432109876543210
12575 * 001000 x1110000101
12576 * rt -----
12577 * rs -----
12578 * rd -----
12579 */
12580 std::string NMD::RESTORE_JRC_32_(uint64 instruction)
12581 {
12582 uint64 count_value = extract_count_19_18_17_16(instruction);
12583 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12584 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12585 uint64 gp_value = extract_gp_2(instruction);
12586
12587 std::string u = IMMEDIATE(copy(u_value));
12588 return img::format("RESTORE.JRC %s%s", u,
12589 save_restore_list(rt_value, count_value, gp_value));
12590 }
12591
12592
12593 /*
12594 *
12595 *
12596 * 3 2 1
12597 * 10987654321098765432109876543210
12598 * 001000 x1110000101
12599 * rt -----
12600 * rs -----
12601 * rd -----
12602 */
12603 std::string NMD::RESTOREF(uint64 instruction)
12604 {
12605 uint64 count_value = extract_count_19_18_17_16(instruction);
12606 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12607
12608 std::string u = IMMEDIATE(copy(u_value));
12609 std::string count = IMMEDIATE(copy(count_value));
12610
12611 return img::format("RESTOREF %s, %s", u, count);
12612 }
12613
12614
12615 /*
12616 *
12617 *
12618 * 3 2 1
12619 * 10987654321098765432109876543210
12620 * 001000 x1110000101
12621 * rt -----
12622 * rs -----
12623 * rd -----
12624 */
12625 std::string NMD::RINT_D(uint64 instruction)
12626 {
12627 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12628 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12629
12630 std::string ft = FPR(copy(ft_value));
12631 std::string fs = FPR(copy(fs_value));
12632
12633 return img::format("RINT.D %s, %s", ft, fs);
12634 }
12635
12636
12637 /*
12638 *
12639 *
12640 * 3 2 1
12641 * 10987654321098765432109876543210
12642 * 001000 x1110000101
12643 * rt -----
12644 * rs -----
12645 * rd -----
12646 */
12647 std::string NMD::RINT_S(uint64 instruction)
12648 {
12649 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12650 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12651
12652 std::string ft = FPR(copy(ft_value));
12653 std::string fs = FPR(copy(fs_value));
12654
12655 return img::format("RINT.S %s, %s", ft, fs);
12656 }
12657
12658
12659 /*
12660 *
12661 *
12662 * 3 2 1
12663 * 10987654321098765432109876543210
12664 * 001000 x1110000101
12665 * rt -----
12666 * rs -----
12667 * rd -----
12668 */
12669 std::string NMD::ROTR(uint64 instruction)
12670 {
12671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12672 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12674
12675 std::string rt = GPR(copy(rt_value));
12676 std::string rs = GPR(copy(rs_value));
12677 std::string shift = IMMEDIATE(copy(shift_value));
12678
12679 return img::format("ROTR %s, %s, %s", rt, rs, shift);
12680 }
12681
12682
12683 /*
12684 *
12685 *
12686 * 3 2 1
12687 * 10987654321098765432109876543210
12688 * 001000 x1110000101
12689 * rt -----
12690 * rs -----
12691 * rd -----
12692 */
12693 std::string NMD::ROTRV(uint64 instruction)
12694 {
12695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12696 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12697 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12698
12699 std::string rd = GPR(copy(rd_value));
12700 std::string rs = GPR(copy(rs_value));
12701 std::string rt = GPR(copy(rt_value));
12702
12703 return img::format("ROTRV %s, %s, %s", rd, rs, rt);
12704 }
12705
12706
12707 /*
12708 *
12709 *
12710 * 3 2 1
12711 * 10987654321098765432109876543210
12712 * 001000 x1110000101
12713 * rt -----
12714 * rs -----
12715 * rd -----
12716 */
12717 std::string NMD::ROTX(uint64 instruction)
12718 {
12719 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12720 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12721 uint64 shiftx_value = extr_shiftxil7il1bs4Fmsb4(instruction);
12722 uint64 stripe_value = extract_stripe_6(instruction);
12723 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12724
12725 std::string rt = GPR(copy(rt_value));
12726 std::string rs = GPR(copy(rs_value));
12727 std::string shift = IMMEDIATE(copy(shift_value));
12728 std::string shiftx = IMMEDIATE(copy(shiftx_value));
12729 std::string stripe = IMMEDIATE(copy(stripe_value));
12730
12731 return img::format("ROTX %s, %s, %s, %s, %s",
12732 rt, rs, shift, shiftx, stripe);
12733 }
12734
12735
12736 /*
12737 *
12738 *
12739 * 3 2 1
12740 * 10987654321098765432109876543210
12741 * 001000 x1110000101
12742 * rt -----
12743 * rs -----
12744 * rd -----
12745 */
12746 std::string NMD::ROUND_L_D(uint64 instruction)
12747 {
12748 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12749 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12750
12751 std::string ft = FPR(copy(ft_value));
12752 std::string fs = FPR(copy(fs_value));
12753
12754 return img::format("ROUND.L.D %s, %s", ft, fs);
12755 }
12756
12757
12758 /*
12759 *
12760 *
12761 * 3 2 1
12762 * 10987654321098765432109876543210
12763 * 001000 x1110000101
12764 * rt -----
12765 * rs -----
12766 * rd -----
12767 */
12768 std::string NMD::ROUND_L_S(uint64 instruction)
12769 {
12770 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12771 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12772
12773 std::string ft = FPR(copy(ft_value));
12774 std::string fs = FPR(copy(fs_value));
12775
12776 return img::format("ROUND.L.S %s, %s", ft, fs);
12777 }
12778
12779
12780 /*
12781 *
12782 *
12783 * 3 2 1
12784 * 10987654321098765432109876543210
12785 * 001000 x1110000101
12786 * rt -----
12787 * rs -----
12788 * rd -----
12789 */
12790 std::string NMD::ROUND_W_D(uint64 instruction)
12791 {
12792 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12793 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12794
12795 std::string ft = FPR(copy(ft_value));
12796 std::string fs = FPR(copy(fs_value));
12797
12798 return img::format("ROUND.W.D %s, %s", ft, fs);
12799 }
12800
12801
12802 /*
12803 *
12804 *
12805 * 3 2 1
12806 * 10987654321098765432109876543210
12807 * 001000 x1110000101
12808 * rt -----
12809 * rs -----
12810 * rd -----
12811 */
12812 std::string NMD::ROUND_W_S(uint64 instruction)
12813 {
12814 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12815 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12816
12817 std::string ft = FPR(copy(ft_value));
12818 std::string fs = FPR(copy(fs_value));
12819
12820 return img::format("ROUND.W.S %s, %s", ft, fs);
12821 }
12822
12823
12824 /*
12825 *
12826 *
12827 * 3 2 1
12828 * 10987654321098765432109876543210
12829 * 001000 x1110000101
12830 * rt -----
12831 * rs -----
12832 * rd -----
12833 */
12834 std::string NMD::RSQRT_D(uint64 instruction)
12835 {
12836 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12837 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12838
12839 std::string ft = FPR(copy(ft_value));
12840 std::string fs = FPR(copy(fs_value));
12841
12842 return img::format("RSQRT.D %s, %s", ft, fs);
12843 }
12844
12845
12846 /*
12847 *
12848 *
12849 * 3 2 1
12850 * 10987654321098765432109876543210
12851 * 001000 x1110000101
12852 * rt -----
12853 * rs -----
12854 * rd -----
12855 */
12856 std::string NMD::RSQRT_S(uint64 instruction)
12857 {
12858 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12859 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12860
12861 std::string ft = FPR(copy(ft_value));
12862 std::string fs = FPR(copy(fs_value));
12863
12864 return img::format("RSQRT.S %s, %s", ft, fs);
12865 }
12866
12867
12868 /*
12869 *
12870 *
12871 * 3 2 1
12872 * 10987654321098765432109876543210
12873 * 001000 01001001101
12874 * rt -----
12875 * rs -----
12876 * rd -----
12877 */
12878 std::string NMD::SAVE_16_(uint64 instruction)
12879 {
12880 uint64 count_value = extract_count_3_2_1_0(instruction);
12881 uint64 rt1_value = extract_rtl_11(instruction);
12882 uint64 u_value = extr_uil4il4bs4Fmsb7(instruction);
12883
12884 std::string u = IMMEDIATE(copy(u_value));
12885 return img::format("SAVE %s%s", u,
12886 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12887 }
12888
12889
12890 /*
12891 *
12892 *
12893 * 3 2 1
12894 * 10987654321098765432109876543210
12895 * 001000 01001001101
12896 * rt -----
12897 * rs -----
12898 * rd -----
12899 */
12900 std::string NMD::SAVE_32_(uint64 instruction)
12901 {
12902 uint64 count_value = extract_count_19_18_17_16(instruction);
12903 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12904 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12905 uint64 gp_value = extract_gp_2(instruction);
12906
12907 std::string u = IMMEDIATE(copy(u_value));
12908 return img::format("SAVE %s%s", u,
12909 save_restore_list(rt_value, count_value, gp_value));
12910 }
12911
12912
12913 /*
12914 *
12915 *
12916 * 3 2 1
12917 * 10987654321098765432109876543210
12918 * 001000 01001001101
12919 * rt -----
12920 * rs -----
12921 * rd -----
12922 */
12923 std::string NMD::SAVEF(uint64 instruction)
12924 {
12925 uint64 count_value = extract_count_19_18_17_16(instruction);
12926 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12927
12928 std::string u = IMMEDIATE(copy(u_value));
12929 std::string count = IMMEDIATE(copy(count_value));
12930
12931 return img::format("SAVEF %s, %s", u, count);
12932 }
12933
12934
12935 /*
12936 *
12937 *
12938 * 3 2 1
12939 * 10987654321098765432109876543210
12940 * 001000 01001001101
12941 * rt -----
12942 * rs -----
12943 * rd -----
12944 */
12945 std::string NMD::SB_16_(uint64 instruction)
12946 {
12947 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12948 uint64 u_value = extract_u_1_0(instruction);
12949 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12950
12951 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
12952 std::string u = IMMEDIATE(copy(u_value));
12953 std::string rs3 = GPR(encode_gpr3(rs3_value));
12954
12955 return img::format("SB %s, %s(%s)", rtz3, u, rs3);
12956 }
12957
12958
12959 /*
12960 *
12961 *
12962 * 3 2 1
12963 * 10987654321098765432109876543210
12964 * 001000 01001001101
12965 * rt -----
12966 * rs -----
12967 * rd -----
12968 */
12969 std::string NMD::SB_GP_(uint64 instruction)
12970 {
12971 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12972 uint64 u_value = extract_u_17_to_0(instruction);
12973
12974 std::string rt = GPR(copy(rt_value));
12975 std::string u = IMMEDIATE(copy(u_value));
12976
12977 return img::format("SB %s, %s($%d)", rt, u, 28);
12978 }
12979
12980
12981 /*
12982 *
12983 *
12984 * 3 2 1
12985 * 10987654321098765432109876543210
12986 * 001000 01001001101
12987 * rt -----
12988 * rs -----
12989 * rd -----
12990 */
12991 std::string NMD::SB_S9_(uint64 instruction)
12992 {
12993 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12994 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12995 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12996
12997 std::string rt = GPR(copy(rt_value));
12998 std::string s = IMMEDIATE(copy(s_value));
12999 std::string rs = GPR(copy(rs_value));
13000
13001 return img::format("SB %s, %s(%s)", rt, s, rs);
13002 }
13003
13004
13005 /*
13006 *
13007 *
13008 * 3 2 1
13009 * 10987654321098765432109876543210
13010 * 001000 01001001101
13011 * rt -----
13012 * rs -----
13013 * rd -----
13014 */
13015 std::string NMD::SB_U12_(uint64 instruction)
13016 {
13017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13018 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13019 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13020
13021 std::string rt = GPR(copy(rt_value));
13022 std::string u = IMMEDIATE(copy(u_value));
13023 std::string rs = GPR(copy(rs_value));
13024
13025 return img::format("SB %s, %s(%s)", rt, u, rs);
13026 }
13027
13028
13029 /*
13030 *
13031 *
13032 * 3 2 1
13033 * 10987654321098765432109876543210
13034 * 001000 01001001101
13035 * rt -----
13036 * rs -----
13037 * rd -----
13038 */
13039 std::string NMD::SBE(uint64 instruction)
13040 {
13041 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13042 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13043 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13044
13045 std::string rt = GPR(copy(rt_value));
13046 std::string s = IMMEDIATE(copy(s_value));
13047 std::string rs = GPR(copy(rs_value));
13048
13049 return img::format("SBE %s, %s(%s)", rt, s, rs);
13050 }
13051
13052
13053 /*
13054 *
13055 *
13056 * 3 2 1
13057 * 10987654321098765432109876543210
13058 * 001000 01001001101
13059 * rt -----
13060 * rs -----
13061 * rd -----
13062 */
13063 std::string NMD::SBX(uint64 instruction)
13064 {
13065 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13066 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13067 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13068
13069 std::string rd = GPR(copy(rd_value));
13070 std::string rs = GPR(copy(rs_value));
13071 std::string rt = GPR(copy(rt_value));
13072
13073 return img::format("SBX %s, %s(%s)", rd, rs, rt);
13074 }
13075
13076
13077 /*
13078 *
13079 *
13080 * 3 2 1
13081 * 10987654321098765432109876543210
13082 * 001000 01001001101
13083 * rt -----
13084 * rs -----
13085 * rd -----
13086 */
13087 std::string NMD::SC(uint64 instruction)
13088 {
13089 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13090 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
13091 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13092
13093 std::string rt = GPR(copy(rt_value));
13094 std::string s = IMMEDIATE(copy(s_value));
13095 std::string rs = GPR(copy(rs_value));
13096
13097 return img::format("SC %s, %s(%s)", rt, s, rs);
13098 }
13099
13100
13101 /*
13102 *
13103 *
13104 * 3 2 1
13105 * 10987654321098765432109876543210
13106 * 001000 01001001101
13107 * rt -----
13108 * rs -----
13109 * rd -----
13110 */
13111 std::string NMD::SCD(uint64 instruction)
13112 {
13113 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13114 int64 s_value = extr_sil3il3bs5_il15il8bs1Tmsb8(instruction);
13115 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13116
13117 std::string rt = GPR(copy(rt_value));
13118 std::string s = IMMEDIATE(copy(s_value));
13119 std::string rs = GPR(copy(rs_value));
13120
13121 return img::format("SCD %s, %s(%s)", rt, s, rs);
13122 }
13123
13124
13125 /*
13126 *
13127 *
13128 * 3 2 1
13129 * 10987654321098765432109876543210
13130 * 001000 01001001101
13131 * rt -----
13132 * rs -----
13133 * rd -----
13134 */
13135 std::string NMD::SCDP(uint64 instruction)
13136 {
13137 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13138 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13139 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13140
13141 std::string rt = GPR(copy(rt_value));
13142 std::string ru = GPR(copy(ru_value));
13143 std::string rs = GPR(copy(rs_value));
13144
13145 return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
13146 }
13147
13148
13149 /*
13150 *
13151 *
13152 * 3 2 1
13153 * 10987654321098765432109876543210
13154 * 001000 01001001101
13155 * rt -----
13156 * rs -----
13157 * rd -----
13158 */
13159 std::string NMD::SCE(uint64 instruction)
13160 {
13161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13162 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
13163 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13164
13165 std::string rt = GPR(copy(rt_value));
13166 std::string s = IMMEDIATE(copy(s_value));
13167 std::string rs = GPR(copy(rs_value));
13168
13169 return img::format("SCE %s, %s(%s)", rt, s, rs);
13170 }
13171
13172
13173 /*
13174 *
13175 *
13176 * 3 2 1
13177 * 10987654321098765432109876543210
13178 * 001000 01001001101
13179 * rt -----
13180 * rs -----
13181 * rd -----
13182 */
13183 std::string NMD::SCWP(uint64 instruction)
13184 {
13185 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13186 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13187 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13188
13189 std::string rt = GPR(copy(rt_value));
13190 std::string ru = GPR(copy(ru_value));
13191 std::string rs = GPR(copy(rs_value));
13192
13193 return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
13194 }
13195
13196
13197 /*
13198 *
13199 *
13200 * 3 2 1
13201 * 10987654321098765432109876543210
13202 * 001000 01001001101
13203 * rt -----
13204 * rs -----
13205 * rd -----
13206 */
13207 std::string NMD::SCWPE(uint64 instruction)
13208 {
13209 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13210 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13211 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13212
13213 std::string rt = GPR(copy(rt_value));
13214 std::string ru = GPR(copy(ru_value));
13215 std::string rs = GPR(copy(rs_value));
13216
13217 return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
13218 }
13219
13220
13221 /*
13222 *
13223 *
13224 * 3 2 1
13225 * 10987654321098765432109876543210
13226 * 001000 01001001101
13227 * rt -----
13228 * rs -----
13229 * rd -----
13230 */
13231 std::string NMD::SD_GP_(uint64 instruction)
13232 {
13233 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13234 uint64 u_value = extr_uil3il3bs18Fmsb20(instruction);
13235
13236 std::string rt = GPR(copy(rt_value));
13237 std::string u = IMMEDIATE(copy(u_value));
13238
13239 return img::format("SD %s, %s($%d)", rt, u, 28);
13240 }
13241
13242
13243 /*
13244 *
13245 *
13246 * 3 2 1
13247 * 10987654321098765432109876543210
13248 * 001000 01001001101
13249 * rt -----
13250 * rs -----
13251 * rd -----
13252 */
13253 std::string NMD::SD_S9_(uint64 instruction)
13254 {
13255 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13256 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13257 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13258
13259 std::string rt = GPR(copy(rt_value));
13260 std::string s = IMMEDIATE(copy(s_value));
13261 std::string rs = GPR(copy(rs_value));
13262
13263 return img::format("SD %s, %s(%s)", rt, s, rs);
13264 }
13265
13266
13267 /*
13268 *
13269 *
13270 * 3 2 1
13271 * 10987654321098765432109876543210
13272 * 001000 01001001101
13273 * rt -----
13274 * rs -----
13275 * rd -----
13276 */
13277 std::string NMD::SD_U12_(uint64 instruction)
13278 {
13279 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13280 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13281 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13282
13283 std::string rt = GPR(copy(rt_value));
13284 std::string u = IMMEDIATE(copy(u_value));
13285 std::string rs = GPR(copy(rs_value));
13286
13287 return img::format("SD %s, %s(%s)", rt, u, rs);
13288 }
13289
13290
13291 /*
13292 *
13293 *
13294 * 3 2 1
13295 * 10987654321098765432109876543210
13296 * 001000 01001001101
13297 * rt -----
13298 * rs -----
13299 * rd -----
13300 */
13301 std::string NMD::SDBBP_16_(uint64 instruction)
13302 {
13303 uint64 code_value = extract_code_2_1_0(instruction);
13304
13305 std::string code = IMMEDIATE(copy(code_value));
13306
13307 return img::format("SDBBP %s", code);
13308 }
13309
13310
13311 /*
13312 *
13313 *
13314 * 3 2 1
13315 * 10987654321098765432109876543210
13316 * 001000 01001001101
13317 * rt -----
13318 * rs -----
13319 * rd -----
13320 */
13321 std::string NMD::SDBBP_32_(uint64 instruction)
13322 {
13323 uint64 code_value = extract_code_18_to_0(instruction);
13324
13325 std::string code = IMMEDIATE(copy(code_value));
13326
13327 return img::format("SDBBP %s", code);
13328 }
13329
13330
13331 /*
13332 *
13333 *
13334 * 3 2 1
13335 * 10987654321098765432109876543210
13336 * 001000 01001001101
13337 * rt -----
13338 * rs -----
13339 * rd -----
13340 */
13341 std::string NMD::SDC1_GP_(uint64 instruction)
13342 {
13343 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13344 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
13345
13346 std::string ft = FPR(copy(ft_value));
13347 std::string u = IMMEDIATE(copy(u_value));
13348
13349 return img::format("SDC1 %s, %s($%d)", ft, u, 28);
13350 }
13351
13352
13353 /*
13354 *
13355 *
13356 * 3 2 1
13357 * 10987654321098765432109876543210
13358 * 001000 01001001101
13359 * rt -----
13360 * rs -----
13361 * rd -----
13362 */
13363 std::string NMD::SDC1_S9_(uint64 instruction)
13364 {
13365 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13366 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13367 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13368
13369 std::string ft = FPR(copy(ft_value));
13370 std::string s = IMMEDIATE(copy(s_value));
13371 std::string rs = GPR(copy(rs_value));
13372
13373 return img::format("SDC1 %s, %s(%s)", ft, s, rs);
13374 }
13375
13376
13377 /*
13378 *
13379 *
13380 * 3 2 1
13381 * 10987654321098765432109876543210
13382 * 001000 01001001101
13383 * rt -----
13384 * rs -----
13385 * rd -----
13386 */
13387 std::string NMD::SDC1_U12_(uint64 instruction)
13388 {
13389 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13390 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13391 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13392
13393 std::string ft = FPR(copy(ft_value));
13394 std::string u = IMMEDIATE(copy(u_value));
13395 std::string rs = GPR(copy(rs_value));
13396
13397 return img::format("SDC1 %s, %s(%s)", ft, u, rs);
13398 }
13399
13400
13401 /*
13402 *
13403 *
13404 * 3 2 1
13405 * 10987654321098765432109876543210
13406 * 001000 01001001101
13407 * rt -----
13408 * rs -----
13409 * rd -----
13410 */
13411 std::string NMD::SDC1X(uint64 instruction)
13412 {
13413 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13414 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13415 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13416
13417 std::string ft = FPR(copy(ft_value));
13418 std::string rs = GPR(copy(rs_value));
13419 std::string rt = GPR(copy(rt_value));
13420
13421 return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
13422 }
13423
13424
13425 /*
13426 *
13427 *
13428 * 3 2 1
13429 * 10987654321098765432109876543210
13430 * 001000 01001001101
13431 * rt -----
13432 * rs -----
13433 * rd -----
13434 */
13435 std::string NMD::SDC1XS(uint64 instruction)
13436 {
13437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13438 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13439 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13440
13441 std::string ft = FPR(copy(ft_value));
13442 std::string rs = GPR(copy(rs_value));
13443 std::string rt = GPR(copy(rt_value));
13444
13445 return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
13446 }
13447
13448
13449 /*
13450 *
13451 *
13452 * 3 2 1
13453 * 10987654321098765432109876543210
13454 * 001000 01001001101
13455 * rt -----
13456 * rs -----
13457 * rd -----
13458 */
13459 std::string NMD::SDC2(uint64 instruction)
13460 {
13461 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
13462 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13463 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13464
13465 std::string cs = CPR(copy(cs_value));
13466 std::string s = IMMEDIATE(copy(s_value));
13467 std::string rs = GPR(copy(rs_value));
13468
13469 return img::format("SDC2 %s, %s(%s)", cs, s, rs);
13470 }
13471
13472
13473 /*
13474 *
13475 *
13476 * 3 2 1
13477 * 10987654321098765432109876543210
13478 * 001000 01001001101
13479 * rt -----
13480 * rs -----
13481 * rd -----
13482 */
13483 std::string NMD::SDM(uint64 instruction)
13484 {
13485 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13486 uint64 count3_value = extract_count3_14_13_12(instruction);
13487 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13489
13490 std::string rt = GPR(copy(rt_value));
13491 std::string s = IMMEDIATE(copy(s_value));
13492 std::string rs = GPR(copy(rs_value));
13493 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
13494
13495 return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
13496 }
13497
13498
13499 /*
13500 *
13501 *
13502 * 3 2 1
13503 * 10987654321098765432109876543210
13504 * 001000 01001001101
13505 * rt -----
13506 * rs -----
13507 * rd -----
13508 */
13509 std::string NMD::SDPC_48_(uint64 instruction)
13510 {
13511 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13512 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
13513
13514 std::string rt = GPR(copy(rt_value));
13515 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
13516
13517 return img::format("SDPC %s, %s", rt, s);
13518 }
13519
13520
13521 /*
13522 *
13523 *
13524 * 3 2 1
13525 * 10987654321098765432109876543210
13526 * 001000 01001001101
13527 * rt -----
13528 * rs -----
13529 * rd -----
13530 */
13531 std::string NMD::SDXS(uint64 instruction)
13532 {
13533 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13534 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13535 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13536
13537 std::string rd = GPR(copy(rd_value));
13538 std::string rs = GPR(copy(rs_value));
13539 std::string rt = GPR(copy(rt_value));
13540
13541 return img::format("SDXS %s, %s(%s)", rd, rs, rt);
13542 }
13543
13544
13545 /*
13546 *
13547 *
13548 * 3 2 1
13549 * 10987654321098765432109876543210
13550 * 001000 01001001101
13551 * rt -----
13552 * rs -----
13553 * rd -----
13554 */
13555 std::string NMD::SDX(uint64 instruction)
13556 {
13557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13558 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13559 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13560
13561 std::string rd = GPR(copy(rd_value));
13562 std::string rs = GPR(copy(rs_value));
13563 std::string rt = GPR(copy(rt_value));
13564
13565 return img::format("SDX %s, %s(%s)", rd, rs, rt);
13566 }
13567
13568
13569 /*
13570 *
13571 *
13572 * 3 2 1
13573 * 10987654321098765432109876543210
13574 * 001000 01001001101
13575 * rt -----
13576 * rs -----
13577 * rd -----
13578 */
13579 std::string NMD::SEB(uint64 instruction)
13580 {
13581 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13582 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13583
13584 std::string rt = GPR(copy(rt_value));
13585 std::string rs = GPR(copy(rs_value));
13586
13587 return img::format("SEB %s, %s", rt, rs);
13588 }
13589
13590
13591 /*
13592 *
13593 *
13594 * 3 2 1
13595 * 10987654321098765432109876543210
13596 * 001000 01001001101
13597 * rt -----
13598 * rs -----
13599 * rd -----
13600 */
13601 std::string NMD::SEH(uint64 instruction)
13602 {
13603 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13604 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13605
13606 std::string rt = GPR(copy(rt_value));
13607 std::string rs = GPR(copy(rs_value));
13608
13609 return img::format("SEH %s, %s", rt, rs);
13610 }
13611
13612
13613 /*
13614 *
13615 *
13616 * 3 2 1
13617 * 10987654321098765432109876543210
13618 * 001000 01001001101
13619 * rt -----
13620 * rs -----
13621 * rd -----
13622 */
13623 std::string NMD::SEL_D(uint64 instruction)
13624 {
13625 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13626 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13627 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13628
13629 std::string fd = FPR(copy(fd_value));
13630 std::string fs = FPR(copy(fs_value));
13631 std::string ft = FPR(copy(ft_value));
13632
13633 return img::format("SEL.D %s, %s, %s", fd, fs, ft);
13634 }
13635
13636
13637 /*
13638 *
13639 *
13640 * 3 2 1
13641 * 10987654321098765432109876543210
13642 * 001000 01001001101
13643 * rt -----
13644 * rs -----
13645 * rd -----
13646 */
13647 std::string NMD::SEL_S(uint64 instruction)
13648 {
13649 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13650 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13651 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13652
13653 std::string fd = FPR(copy(fd_value));
13654 std::string fs = FPR(copy(fs_value));
13655 std::string ft = FPR(copy(ft_value));
13656
13657 return img::format("SEL.S %s, %s, %s", fd, fs, ft);
13658 }
13659
13660
13661 /*
13662 *
13663 *
13664 * 3 2 1
13665 * 10987654321098765432109876543210
13666 * 001000 01001001101
13667 * rt -----
13668 * rs -----
13669 * rd -----
13670 */
13671 std::string NMD::SELEQZ_D(uint64 instruction)
13672 {
13673 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13674 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13675 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13676
13677 std::string fd = FPR(copy(fd_value));
13678 std::string fs = FPR(copy(fs_value));
13679 std::string ft = FPR(copy(ft_value));
13680
13681 return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13682 }
13683
13684
13685 /*
13686 *
13687 *
13688 * 3 2 1
13689 * 10987654321098765432109876543210
13690 * 001000 01001001101
13691 * rt -----
13692 * rs -----
13693 * rd -----
13694 */
13695 std::string NMD::SELEQZ_S(uint64 instruction)
13696 {
13697 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13698 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13699 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13700
13701 std::string fd = FPR(copy(fd_value));
13702 std::string fs = FPR(copy(fs_value));
13703 std::string ft = FPR(copy(ft_value));
13704
13705 return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13706 }
13707
13708
13709 /*
13710 *
13711 *
13712 * 3 2 1
13713 * 10987654321098765432109876543210
13714 * 001000 01001001101
13715 * rt -----
13716 * rs -----
13717 * rd -----
13718 */
13719 std::string NMD::SELNEZ_D(uint64 instruction)
13720 {
13721 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13722 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13723 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13724
13725 std::string fd = FPR(copy(fd_value));
13726 std::string fs = FPR(copy(fs_value));
13727 std::string ft = FPR(copy(ft_value));
13728
13729 return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13730 }
13731
13732
13733 /*
13734 *
13735 *
13736 * 3 2 1
13737 * 10987654321098765432109876543210
13738 * 001000 01001001101
13739 * rt -----
13740 * rs -----
13741 * rd -----
13742 */
13743 std::string NMD::SELNEZ_S(uint64 instruction)
13744 {
13745 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13746 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13747 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13748
13749 std::string fd = FPR(copy(fd_value));
13750 std::string fs = FPR(copy(fs_value));
13751 std::string ft = FPR(copy(ft_value));
13752
13753 return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13754 }
13755
13756
13757 /*
13758 *
13759 *
13760 * 3 2 1
13761 * 10987654321098765432109876543210
13762 * 001000 01001001101
13763 * rt -----
13764 * rs -----
13765 * rd -----
13766 */
13767 std::string NMD::SEQI(uint64 instruction)
13768 {
13769 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13770 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13771 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13772
13773 std::string rt = GPR(copy(rt_value));
13774 std::string rs = GPR(copy(rs_value));
13775 std::string u = IMMEDIATE(copy(u_value));
13776
13777 return img::format("SEQI %s, %s, %s", rt, rs, u);
13778 }
13779
13780
13781 /*
13782 *
13783 *
13784 * 3 2 1
13785 * 10987654321098765432109876543210
13786 * 001000 01001001101
13787 * rt -----
13788 * rs -----
13789 * rd -----
13790 */
13791 std::string NMD::SH_16_(uint64 instruction)
13792 {
13793 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13794 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
13795 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13796
13797 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
13798 std::string u = IMMEDIATE(copy(u_value));
13799 std::string rs3 = GPR(encode_gpr3(rs3_value));
13800
13801 return img::format("SH %s, %s(%s)", rtz3, u, rs3);
13802 }
13803
13804
13805 /*
13806 *
13807 *
13808 * 3 2 1
13809 * 10987654321098765432109876543210
13810 * 001000 01001001101
13811 * rt -----
13812 * rs -----
13813 * rd -----
13814 */
13815 std::string NMD::SH_GP_(uint64 instruction)
13816 {
13817 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13818 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
13819
13820 std::string rt = GPR(copy(rt_value));
13821 std::string u = IMMEDIATE(copy(u_value));
13822
13823 return img::format("SH %s, %s($%d)", rt, u, 28);
13824 }
13825
13826
13827 /*
13828 *
13829 *
13830 * 3 2 1
13831 * 10987654321098765432109876543210
13832 * 001000 01001001101
13833 * rt -----
13834 * rs -----
13835 * rd -----
13836 */
13837 std::string NMD::SH_S9_(uint64 instruction)
13838 {
13839 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13840 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13841 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13842
13843 std::string rt = GPR(copy(rt_value));
13844 std::string s = IMMEDIATE(copy(s_value));
13845 std::string rs = GPR(copy(rs_value));
13846
13847 return img::format("SH %s, %s(%s)", rt, s, rs);
13848 }
13849
13850
13851 /*
13852 *
13853 *
13854 * 3 2 1
13855 * 10987654321098765432109876543210
13856 * 001000 01001001101
13857 * rt -----
13858 * rs -----
13859 * rd -----
13860 */
13861 std::string NMD::SH_U12_(uint64 instruction)
13862 {
13863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13864 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13865 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13866
13867 std::string rt = GPR(copy(rt_value));
13868 std::string u = IMMEDIATE(copy(u_value));
13869 std::string rs = GPR(copy(rs_value));
13870
13871 return img::format("SH %s, %s(%s)", rt, u, rs);
13872 }
13873
13874
13875 /*
13876 *
13877 *
13878 * 3 2 1
13879 * 10987654321098765432109876543210
13880 * 001000 01001001101
13881 * rt -----
13882 * rs -----
13883 * rd -----
13884 */
13885 std::string NMD::SHE(uint64 instruction)
13886 {
13887 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13888 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13889 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13890
13891 std::string rt = GPR(copy(rt_value));
13892 std::string s = IMMEDIATE(copy(s_value));
13893 std::string rs = GPR(copy(rs_value));
13894
13895 return img::format("SHE %s, %s(%s)", rt, s, rs);
13896 }
13897
13898
13899 /*
13900 * SHILO ac, shift - Shift an Accumulator Value Leaving the Result in the Same
13901 * Accumulator
13902 *
13903 * 3 2 1
13904 * 10987654321098765432109876543210
13905 * 001000xxxx xxxx0000011101
13906 * shift ------
13907 * ac --
13908 */
13909 std::string NMD::SHILO(uint64 instruction)
13910 {
13911 int64 shift_value = extract_shift_21_20_19_18_17_16(instruction);
13912 uint64 ac_value = extract_ac_13_12(instruction);
13913
13914 std::string shift = IMMEDIATE(copy(shift_value));
13915 std::string ac = AC(copy(ac_value));
13916
13917 return img::format("SHILO %s, %s", ac, shift);
13918 }
13919
13920
13921 /*
13922 * SHILOV ac, rs - Variable Shift of Accumulator Value Leaving the Result in
13923 * the Same Accumulator
13924 *
13925 * 3 2 1
13926 * 10987654321098765432109876543210
13927 * 001000xxxxx 01001001111111
13928 * rs -----
13929 * ac --
13930 */
13931 std::string NMD::SHILOV(uint64 instruction)
13932 {
13933 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13934 uint64 ac_value = extract_ac_13_12(instruction);
13935
13936 std::string rs = GPR(copy(rs_value));
13937 std::string ac = AC(copy(ac_value));
13938
13939 return img::format("SHILOV %s, %s", ac, rs);
13940 }
13941
13942
13943 /*
13944 * SHLL.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords
13945 *
13946 * 3 2 1
13947 * 10987654321098765432109876543210
13948 * 001000 001110110101
13949 * rt -----
13950 * rs -----
13951 * sa ----
13952 */
13953 std::string NMD::SHLL_PH(uint64 instruction)
13954 {
13955 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13956 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13957 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13958
13959 std::string rt = GPR(copy(rt_value));
13960 std::string rs = GPR(copy(rs_value));
13961 std::string sa = IMMEDIATE(copy(sa_value));
13962
13963 return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
13964 }
13965
13966
13967 /*
13968 * SHLL.QB rt, rs, sa - Shift Left Logical Vector Quad Bytes
13969 *
13970 * 3 2 1
13971 * 10987654321098765432109876543210
13972 * 001000 0100001111111
13973 * rt -----
13974 * rs -----
13975 * sa ---
13976 */
13977 std::string NMD::SHLL_QB(uint64 instruction)
13978 {
13979 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13980 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13981 uint64 sa_value = extract_sa_15_14_13(instruction);
13982
13983 std::string rt = GPR(copy(rt_value));
13984 std::string rs = GPR(copy(rs_value));
13985 std::string sa = IMMEDIATE(copy(sa_value));
13986
13987 return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
13988 }
13989
13990
13991 /*
13992 * SHLL_S.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords (saturated)
13993 *
13994 * 3 2 1
13995 * 10987654321098765432109876543210
13996 * 001000 001110110101
13997 * rt -----
13998 * rs -----
13999 * sa ----
14000 */
14001 std::string NMD::SHLL_S_PH(uint64 instruction)
14002 {
14003 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14004 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14005 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14006
14007 std::string rt = GPR(copy(rt_value));
14008 std::string rs = GPR(copy(rs_value));
14009 std::string sa = IMMEDIATE(copy(sa_value));
14010
14011 return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
14012 }
14013
14014
14015 /*
14016 *
14017 *
14018 * 3 2 1
14019 * 10987654321098765432109876543210
14020 * 001000 01001001101
14021 * rt -----
14022 * rs -----
14023 * rd -----
14024 */
14025 std::string NMD::SHLL_S_W(uint64 instruction)
14026 {
14027 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14028 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14029 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14030
14031 std::string rt = GPR(copy(rt_value));
14032 std::string rs = GPR(copy(rs_value));
14033 std::string sa = IMMEDIATE(copy(sa_value));
14034
14035 return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
14036 }
14037
14038
14039 /*
14040 *
14041 *
14042 * 3 2 1
14043 * 10987654321098765432109876543210
14044 * 001000 01001001101
14045 * rt -----
14046 * rs -----
14047 * rd -----
14048 */
14049 std::string NMD::SHLLV_PH(uint64 instruction)
14050 {
14051 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14052 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14053 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14054
14055 std::string rd = GPR(copy(rd_value));
14056 std::string rt = GPR(copy(rt_value));
14057 std::string rs = GPR(copy(rs_value));
14058
14059 return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
14060 }
14061
14062
14063 /*
14064 *
14065 *
14066 * 3 2 1
14067 * 10987654321098765432109876543210
14068 * 001000 01001001101
14069 * rt -----
14070 * rs -----
14071 * rd -----
14072 */
14073 std::string NMD::SHLLV_QB(uint64 instruction)
14074 {
14075 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14076 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14077 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14078
14079 std::string rd = GPR(copy(rd_value));
14080 std::string rt = GPR(copy(rt_value));
14081 std::string rs = GPR(copy(rs_value));
14082
14083 return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
14084 }
14085
14086
14087 /*
14088 *
14089 *
14090 * 3 2 1
14091 * 10987654321098765432109876543210
14092 * 001000 01001001101
14093 * rt -----
14094 * rs -----
14095 * rd -----
14096 */
14097 std::string NMD::SHLLV_S_PH(uint64 instruction)
14098 {
14099 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14100 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14102
14103 std::string rd = GPR(copy(rd_value));
14104 std::string rt = GPR(copy(rt_value));
14105 std::string rs = GPR(copy(rs_value));
14106
14107 return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
14108 }
14109
14110
14111 /*
14112 *
14113 *
14114 * 3 2 1
14115 * 10987654321098765432109876543210
14116 * 001000 01001001101
14117 * rt -----
14118 * rs -----
14119 * rd -----
14120 */
14121 std::string NMD::SHLLV_S_W(uint64 instruction)
14122 {
14123 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14124 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14125 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14126
14127 std::string rd = GPR(copy(rd_value));
14128 std::string rt = GPR(copy(rt_value));
14129 std::string rs = GPR(copy(rs_value));
14130
14131 return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
14132 }
14133
14134
14135 /*
14136 *
14137 *
14138 * 3 2 1
14139 * 10987654321098765432109876543210
14140 * 001000 01001001101
14141 * rt -----
14142 * rs -----
14143 * rd -----
14144 */
14145 std::string NMD::SHRA_PH(uint64 instruction)
14146 {
14147 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14148 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14149 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14150
14151 std::string rt = GPR(copy(rt_value));
14152 std::string rs = GPR(copy(rs_value));
14153 std::string sa = IMMEDIATE(copy(sa_value));
14154
14155 return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
14156 }
14157
14158
14159 /*
14160 *
14161 *
14162 * 3 2 1
14163 * 10987654321098765432109876543210
14164 * 001000 01001001101
14165 * rt -----
14166 * rs -----
14167 * rd -----
14168 */
14169 std::string NMD::SHRA_QB(uint64 instruction)
14170 {
14171 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14172 uint64 sa_value = extract_sa_15_14_13(instruction);
14173 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14174
14175 std::string rt = GPR(copy(rt_value));
14176 std::string rs = GPR(copy(rs_value));
14177 std::string sa = IMMEDIATE(copy(sa_value));
14178
14179 return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
14180 }
14181
14182
14183 /*
14184 *
14185 *
14186 * 3 2 1
14187 * 10987654321098765432109876543210
14188 * 001000 01001001101
14189 * rt -----
14190 * rs -----
14191 * rd -----
14192 */
14193 std::string NMD::SHRA_R_PH(uint64 instruction)
14194 {
14195 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14196 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14197 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14198
14199 std::string rt = GPR(copy(rt_value));
14200 std::string rs = GPR(copy(rs_value));
14201 std::string sa = IMMEDIATE(copy(sa_value));
14202
14203 return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
14204 }
14205
14206
14207 /*
14208 *
14209 *
14210 * 3 2 1
14211 * 10987654321098765432109876543210
14212 * 001000 01001001101
14213 * rt -----
14214 * rs -----
14215 * rd -----
14216 */
14217 std::string NMD::SHRA_R_QB(uint64 instruction)
14218 {
14219 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14220 uint64 sa_value = extract_sa_15_14_13(instruction);
14221 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14222
14223 std::string rt = GPR(copy(rt_value));
14224 std::string rs = GPR(copy(rs_value));
14225 std::string sa = IMMEDIATE(copy(sa_value));
14226
14227 return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
14228 }
14229
14230
14231 /*
14232 *
14233 *
14234 * 3 2 1
14235 * 10987654321098765432109876543210
14236 * 001000 01001001101
14237 * rt -----
14238 * rs -----
14239 * rd -----
14240 */
14241 std::string NMD::SHRA_R_W(uint64 instruction)
14242 {
14243 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14244 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14245 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14246
14247 std::string rt = GPR(copy(rt_value));
14248 std::string rs = GPR(copy(rs_value));
14249 std::string sa = IMMEDIATE(copy(sa_value));
14250
14251 return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
14252 }
14253
14254
14255 /*
14256 *
14257 *
14258 * 3 2 1
14259 * 10987654321098765432109876543210
14260 * 001000 01001001101
14261 * rt -----
14262 * rs -----
14263 * rd -----
14264 */
14265 std::string NMD::SHRAV_PH(uint64 instruction)
14266 {
14267 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14268 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14269 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14270
14271 std::string rd = GPR(copy(rd_value));
14272 std::string rt = GPR(copy(rt_value));
14273 std::string rs = GPR(copy(rs_value));
14274
14275 return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
14276 }
14277
14278
14279 /*
14280 *
14281 *
14282 * 3 2 1
14283 * 10987654321098765432109876543210
14284 * 001000 01001001101
14285 * rt -----
14286 * rs -----
14287 * rd -----
14288 */
14289 std::string NMD::SHRAV_QB(uint64 instruction)
14290 {
14291 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14292 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14293 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14294
14295 std::string rd = GPR(copy(rd_value));
14296 std::string rt = GPR(copy(rt_value));
14297 std::string rs = GPR(copy(rs_value));
14298
14299 return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
14300 }
14301
14302
14303 /*
14304 *
14305 *
14306 * 3 2 1
14307 * 10987654321098765432109876543210
14308 * 001000 01001001101
14309 * rt -----
14310 * rs -----
14311 * rd -----
14312 */
14313 std::string NMD::SHRAV_R_PH(uint64 instruction)
14314 {
14315 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14316 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14317 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14318
14319 std::string rd = GPR(copy(rd_value));
14320 std::string rt = GPR(copy(rt_value));
14321 std::string rs = GPR(copy(rs_value));
14322
14323 return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
14324 }
14325
14326
14327 /*
14328 *
14329 *
14330 * 3 2 1
14331 * 10987654321098765432109876543210
14332 * 001000 01001001101
14333 * rt -----
14334 * rs -----
14335 * rd -----
14336 */
14337 std::string NMD::SHRAV_R_QB(uint64 instruction)
14338 {
14339 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14340 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14341 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14342
14343 std::string rd = GPR(copy(rd_value));
14344 std::string rt = GPR(copy(rt_value));
14345 std::string rs = GPR(copy(rs_value));
14346
14347 return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
14348 }
14349
14350
14351 /*
14352 *
14353 *
14354 * 3 2 1
14355 * 10987654321098765432109876543210
14356 * 001000 01001001101
14357 * rt -----
14358 * rs -----
14359 * rd -----
14360 */
14361 std::string NMD::SHRAV_R_W(uint64 instruction)
14362 {
14363 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14364 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14365 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14366
14367 std::string rd = GPR(copy(rd_value));
14368 std::string rt = GPR(copy(rt_value));
14369 std::string rs = GPR(copy(rs_value));
14370
14371 return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
14372 }
14373
14374
14375 /*
14376 *
14377 *
14378 * 3 2 1
14379 * 10987654321098765432109876543210
14380 * 001000 01001001101
14381 * rt -----
14382 * rs -----
14383 * rd -----
14384 */
14385 std::string NMD::SHRL_PH(uint64 instruction)
14386 {
14387 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14388 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14389 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14390
14391 std::string rt = GPR(copy(rt_value));
14392 std::string rs = GPR(copy(rs_value));
14393 std::string sa = IMMEDIATE(copy(sa_value));
14394
14395 return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
14396 }
14397
14398
14399 /*
14400 *
14401 *
14402 * 3 2 1
14403 * 10987654321098765432109876543210
14404 * 001000 01001001101
14405 * rt -----
14406 * rs -----
14407 * rd -----
14408 */
14409 std::string NMD::SHRL_QB(uint64 instruction)
14410 {
14411 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14412 uint64 sa_value = extract_sa_15_14_13(instruction);
14413 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14414
14415 std::string rt = GPR(copy(rt_value));
14416 std::string rs = GPR(copy(rs_value));
14417 std::string sa = IMMEDIATE(copy(sa_value));
14418
14419 return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
14420 }
14421
14422
14423 /*
14424 *
14425 *
14426 * 3 2 1
14427 * 10987654321098765432109876543210
14428 * 001000 01001001101
14429 * rt -----
14430 * rs -----
14431 * rd -----
14432 */
14433 std::string NMD::SHRLV_PH(uint64 instruction)
14434 {
14435 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14436 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14437 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14438
14439 std::string rd = GPR(copy(rd_value));
14440 std::string rt = GPR(copy(rt_value));
14441 std::string rs = GPR(copy(rs_value));
14442
14443 return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14444 }
14445
14446
14447 /*
14448 *
14449 *
14450 * 3 2 1
14451 * 10987654321098765432109876543210
14452 * 001000 01001001101
14453 * rt -----
14454 * rs -----
14455 * rd -----
14456 */
14457 std::string NMD::SHRLV_QB(uint64 instruction)
14458 {
14459 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14460 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14462
14463 std::string rd = GPR(copy(rd_value));
14464 std::string rt = GPR(copy(rt_value));
14465 std::string rs = GPR(copy(rs_value));
14466
14467 return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14468 }
14469
14470
14471 /*
14472 *
14473 *
14474 * 3 2 1
14475 * 10987654321098765432109876543210
14476 * 001000 01001001101
14477 * rt -----
14478 * rs -----
14479 * rd -----
14480 */
14481 std::string NMD::SHX(uint64 instruction)
14482 {
14483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14484 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14485 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14486
14487 std::string rd = GPR(copy(rd_value));
14488 std::string rs = GPR(copy(rs_value));
14489 std::string rt = GPR(copy(rt_value));
14490
14491 return img::format("SHX %s, %s(%s)", rd, rs, rt);
14492 }
14493
14494
14495 /*
14496 *
14497 *
14498 * 3 2 1
14499 * 10987654321098765432109876543210
14500 * 001000 01001001101
14501 * rt -----
14502 * rs -----
14503 * rd -----
14504 */
14505 std::string NMD::SHXS(uint64 instruction)
14506 {
14507 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14508 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14509 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14510
14511 std::string rd = GPR(copy(rd_value));
14512 std::string rs = GPR(copy(rs_value));
14513 std::string rt = GPR(copy(rt_value));
14514
14515 return img::format("SHXS %s, %s(%s)", rd, rs, rt);
14516 }
14517
14518
14519 /*
14520 *
14521 *
14522 * 3 2 1
14523 * 10987654321098765432109876543210
14524 * 001000 01001001101
14525 * rt -----
14526 * rs -----
14527 * rd -----
14528 */
14529 std::string NMD::SIGRIE(uint64 instruction)
14530 {
14531 uint64 code_value = extract_code_18_to_0(instruction);
14532
14533 std::string code = IMMEDIATE(copy(code_value));
14534
14535 return img::format("SIGRIE %s", code);
14536 }
14537
14538
14539 /*
14540 *
14541 *
14542 * 3 2 1
14543 * 10987654321098765432109876543210
14544 * 001000 01001001101
14545 * rt -----
14546 * rs -----
14547 * rd -----
14548 */
14549 std::string NMD::SLL_16_(uint64 instruction)
14550 {
14551 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14552 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14553 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14554
14555 std::string rt3 = GPR(encode_gpr3(rt3_value));
14556 std::string rs3 = GPR(encode_gpr3(rs3_value));
14557 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14558
14559 return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
14560 }
14561
14562
14563 /*
14564 *
14565 *
14566 * 3 2 1
14567 * 10987654321098765432109876543210
14568 * 001000 01001001101
14569 * rt -----
14570 * rs -----
14571 * rd -----
14572 */
14573 std::string NMD::SLL_32_(uint64 instruction)
14574 {
14575 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14576 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14577 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14578
14579 std::string rt = GPR(copy(rt_value));
14580 std::string rs = GPR(copy(rs_value));
14581 std::string shift = IMMEDIATE(copy(shift_value));
14582
14583 return img::format("SLL %s, %s, %s", rt, rs, shift);
14584 }
14585
14586
14587 /*
14588 *
14589 *
14590 * 3 2 1
14591 * 10987654321098765432109876543210
14592 * 001000 01001001101
14593 * rt -----
14594 * rs -----
14595 * rd -----
14596 */
14597 std::string NMD::SLLV(uint64 instruction)
14598 {
14599 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14600 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14602
14603 std::string rd = GPR(copy(rd_value));
14604 std::string rs = GPR(copy(rs_value));
14605 std::string rt = GPR(copy(rt_value));
14606
14607 return img::format("SLLV %s, %s, %s", rd, rs, rt);
14608 }
14609
14610
14611 /*
14612 *
14613 *
14614 * 3 2 1
14615 * 10987654321098765432109876543210
14616 * 001000 01001001101
14617 * rt -----
14618 * rs -----
14619 * rd -----
14620 */
14621 std::string NMD::SLT(uint64 instruction)
14622 {
14623 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14624 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14625 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14626
14627 std::string rd = GPR(copy(rd_value));
14628 std::string rs = GPR(copy(rs_value));
14629 std::string rt = GPR(copy(rt_value));
14630
14631 return img::format("SLT %s, %s, %s", rd, rs, rt);
14632 }
14633
14634
14635 /*
14636 *
14637 *
14638 * 3 2 1
14639 * 10987654321098765432109876543210
14640 * 001000 01001001101
14641 * rt -----
14642 * rs -----
14643 * rd -----
14644 */
14645 std::string NMD::SLTI(uint64 instruction)
14646 {
14647 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14648 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14649 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14650
14651 std::string rt = GPR(copy(rt_value));
14652 std::string rs = GPR(copy(rs_value));
14653 std::string u = IMMEDIATE(copy(u_value));
14654
14655 return img::format("SLTI %s, %s, %s", rt, rs, u);
14656 }
14657
14658
14659 /*
14660 *
14661 *
14662 * 3 2 1
14663 * 10987654321098765432109876543210
14664 * 001000 01001001101
14665 * rt -----
14666 * rs -----
14667 * rd -----
14668 */
14669 std::string NMD::SLTIU(uint64 instruction)
14670 {
14671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14672 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14674
14675 std::string rt = GPR(copy(rt_value));
14676 std::string rs = GPR(copy(rs_value));
14677 std::string u = IMMEDIATE(copy(u_value));
14678
14679 return img::format("SLTIU %s, %s, %s", rt, rs, u);
14680 }
14681
14682
14683 /*
14684 *
14685 *
14686 * 3 2 1
14687 * 10987654321098765432109876543210
14688 * 001000 01001001101
14689 * rt -----
14690 * rs -----
14691 * rd -----
14692 */
14693 std::string NMD::SLTU(uint64 instruction)
14694 {
14695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14696 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14697 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14698
14699 std::string rd = GPR(copy(rd_value));
14700 std::string rs = GPR(copy(rs_value));
14701 std::string rt = GPR(copy(rt_value));
14702
14703 return img::format("SLTU %s, %s, %s", rd, rs, rt);
14704 }
14705
14706
14707 /*
14708 *
14709 *
14710 * 3 2 1
14711 * 10987654321098765432109876543210
14712 * 001000 01001001101
14713 * rt -----
14714 * rs -----
14715 * rd -----
14716 */
14717 std::string NMD::SOV(uint64 instruction)
14718 {
14719 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14720 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14721 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14722
14723 std::string rd = GPR(copy(rd_value));
14724 std::string rs = GPR(copy(rs_value));
14725 std::string rt = GPR(copy(rt_value));
14726
14727 return img::format("SOV %s, %s, %s", rd, rs, rt);
14728 }
14729
14730
14731 /*
14732 *
14733 *
14734 * 3 2 1
14735 * 10987654321098765432109876543210
14736 * 001000 01001001101
14737 * rt -----
14738 * rs -----
14739 * rd -----
14740 */
14741 std::string NMD::SPECIAL2(uint64 instruction)
14742 {
14743 uint64 op_value = extract_op_25_to_3(instruction);
14744
14745 std::string op = IMMEDIATE(copy(op_value));
14746
14747 return img::format("SPECIAL2 %s", op);
14748 }
14749
14750
14751 /*
14752 *
14753 *
14754 * 3 2 1
14755 * 10987654321098765432109876543210
14756 * 001000 01001001101
14757 * rt -----
14758 * rs -----
14759 * rd -----
14760 */
14761 std::string NMD::SQRT_D(uint64 instruction)
14762 {
14763 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14764 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14765
14766 std::string ft = FPR(copy(ft_value));
14767 std::string fs = FPR(copy(fs_value));
14768
14769 return img::format("SQRT.D %s, %s", ft, fs);
14770 }
14771
14772
14773 /*
14774 *
14775 *
14776 * 3 2 1
14777 * 10987654321098765432109876543210
14778 * 001000 01001001101
14779 * rt -----
14780 * rs -----
14781 * rd -----
14782 */
14783 std::string NMD::SQRT_S(uint64 instruction)
14784 {
14785 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14786 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14787
14788 std::string ft = FPR(copy(ft_value));
14789 std::string fs = FPR(copy(fs_value));
14790
14791 return img::format("SQRT.S %s, %s", ft, fs);
14792 }
14793
14794
14795 /*
14796 * SRA rd, rt, sa - Shift Word Right Arithmetic
14797 *
14798 * 3 2 1
14799 * 10987654321098765432109876543210
14800 * 00000000000 000011
14801 * rt -----
14802 * rd -----
14803 * sa -----
14804 */
14805 std::string NMD::SRA(uint64 instruction)
14806 {
14807 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14808 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14809 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14810
14811 std::string rt = GPR(copy(rt_value));
14812 std::string rs = GPR(copy(rs_value));
14813 std::string shift = IMMEDIATE(copy(shift_value));
14814
14815 return img::format("SRA %s, %s, %s", rt, rs, shift);
14816 }
14817
14818
14819 /*
14820 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14821 *
14822 * 3 2 1
14823 * 10987654321098765432109876543210
14824 * 001000 00000000111
14825 * rs -----
14826 * rt -----
14827 * rd -----
14828 */
14829 std::string NMD::SRAV(uint64 instruction)
14830 {
14831 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14832 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14834
14835 std::string rd = GPR(copy(rd_value));
14836 std::string rs = GPR(copy(rs_value));
14837 std::string rt = GPR(copy(rt_value));
14838
14839 return img::format("SRAV %s, %s, %s", rd, rs, rt);
14840 }
14841
14842
14843 /*
14844 *
14845 *
14846 * 3 2 1
14847 * 10987654321098765432109876543210
14848 * 001000 00000000111
14849 * rs -----
14850 * rt -----
14851 * rd -----
14852 */
14853 std::string NMD::SRL_16_(uint64 instruction)
14854 {
14855 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14856 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14857 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14858
14859 std::string rt3 = GPR(encode_gpr3(rt3_value));
14860 std::string rs3 = GPR(encode_gpr3(rs3_value));
14861 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14862
14863 return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
14864 }
14865
14866
14867 /*
14868 *
14869 *
14870 * 3 2 1
14871 * 10987654321098765432109876543210
14872 * 001000 01001001101
14873 * rt -----
14874 * rs -----
14875 * rd -----
14876 */
14877 std::string NMD::SRL_32_(uint64 instruction)
14878 {
14879 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14880 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14881 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14882
14883 std::string rt = GPR(copy(rt_value));
14884 std::string rs = GPR(copy(rs_value));
14885 std::string shift = IMMEDIATE(copy(shift_value));
14886
14887 return img::format("SRL %s, %s, %s", rt, rs, shift);
14888 }
14889
14890
14891 /*
14892 *
14893 *
14894 * 3 2 1
14895 * 10987654321098765432109876543210
14896 * 001000 01001001101
14897 * rt -----
14898 * rs -----
14899 * rd -----
14900 */
14901 std::string NMD::SRLV(uint64 instruction)
14902 {
14903 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14904 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14905 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14906
14907 std::string rd = GPR(copy(rd_value));
14908 std::string rs = GPR(copy(rs_value));
14909 std::string rt = GPR(copy(rt_value));
14910
14911 return img::format("SRLV %s, %s, %s", rd, rs, rt);
14912 }
14913
14914
14915 /*
14916 *
14917 *
14918 * 3 2 1
14919 * 10987654321098765432109876543210
14920 * 001000 01001001101
14921 * rt -----
14922 * rs -----
14923 * rd -----
14924 */
14925 std::string NMD::SUB(uint64 instruction)
14926 {
14927 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14928 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14929 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14930
14931 std::string rd = GPR(copy(rd_value));
14932 std::string rs = GPR(copy(rs_value));
14933 std::string rt = GPR(copy(rt_value));
14934
14935 return img::format("SUB %s, %s, %s", rd, rs, rt);
14936 }
14937
14938
14939 /*
14940 *
14941 *
14942 * 3 2 1
14943 * 10987654321098765432109876543210
14944 * 001000 01001001101
14945 * rt -----
14946 * rs -----
14947 * rd -----
14948 */
14949 std::string NMD::SUB_D(uint64 instruction)
14950 {
14951 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14952 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14953 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
14954
14955 std::string fd = FPR(copy(fd_value));
14956 std::string fs = FPR(copy(fs_value));
14957 std::string ft = FPR(copy(ft_value));
14958
14959 return img::format("SUB.D %s, %s, %s", fd, fs, ft);
14960 }
14961
14962
14963 /*
14964 *
14965 *
14966 * 3 2 1
14967 * 10987654321098765432109876543210
14968 * 001000 01001001101
14969 * rt -----
14970 * rs -----
14971 * rd -----
14972 */
14973 std::string NMD::SUB_S(uint64 instruction)
14974 {
14975 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14976 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14977 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
14978
14979 std::string fd = FPR(copy(fd_value));
14980 std::string fs = FPR(copy(fs_value));
14981 std::string ft = FPR(copy(ft_value));
14982
14983 return img::format("SUB.S %s, %s, %s", fd, fs, ft);
14984 }
14985
14986
14987 /*
14988 *
14989 *
14990 * 3 2 1
14991 * 10987654321098765432109876543210
14992 * 001000 01001001101
14993 * rt -----
14994 * rs -----
14995 * rd -----
14996 */
14997 std::string NMD::SUBQ_PH(uint64 instruction)
14998 {
14999 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15000 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15001 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15002
15003 std::string rd = GPR(copy(rd_value));
15004 std::string rs = GPR(copy(rs_value));
15005 std::string rt = GPR(copy(rt_value));
15006
15007 return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
15008 }
15009
15010
15011 /*
15012 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15013 * to Halve Results
15014 *
15015 * 3 2 1
15016 * 10987654321098765432109876543210
15017 * 001000 01001001101
15018 * rt -----
15019 * rs -----
15020 * rd -----
15021 */
15022 std::string NMD::SUBQ_S_PH(uint64 instruction)
15023 {
15024 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15025 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15026 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15027
15028 std::string rd = GPR(copy(rd_value));
15029 std::string rs = GPR(copy(rs_value));
15030 std::string rt = GPR(copy(rt_value));
15031
15032 return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
15033 }
15034
15035
15036 /*
15037 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15038 * to Halve Results
15039 *
15040 * 3 2 1
15041 * 10987654321098765432109876543210
15042 * 001000 01001001101
15043 * rt -----
15044 * rs -----
15045 * rd -----
15046 */
15047 std::string NMD::SUBQ_S_W(uint64 instruction)
15048 {
15049 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15050 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15051 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15052
15053 std::string rd = GPR(copy(rd_value));
15054 std::string rs = GPR(copy(rs_value));
15055 std::string rt = GPR(copy(rt_value));
15056
15057 return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
15058 }
15059
15060
15061 /*
15062 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15063 * to Halve Results
15064 *
15065 * 3 2 1
15066 * 10987654321098765432109876543210
15067 * 001000 01001001101
15068 * rt -----
15069 * rs -----
15070 * rd -----
15071 */
15072 std::string NMD::SUBQH_PH(uint64 instruction)
15073 {
15074 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15075 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15076 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15077
15078 std::string rd = GPR(copy(rd_value));
15079 std::string rs = GPR(copy(rs_value));
15080 std::string rt = GPR(copy(rt_value));
15081
15082 return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
15083 }
15084
15085
15086 /*
15087 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15088 * to Halve Results
15089 *
15090 * 3 2 1
15091 * 10987654321098765432109876543210
15092 * 001000 01001001101
15093 * rt -----
15094 * rs -----
15095 * rd -----
15096 */
15097 std::string NMD::SUBQH_R_PH(uint64 instruction)
15098 {
15099 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15100 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15102
15103 std::string rd = GPR(copy(rd_value));
15104 std::string rs = GPR(copy(rs_value));
15105 std::string rt = GPR(copy(rt_value));
15106
15107 return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
15108 }
15109
15110
15111 /*
15112 * SUBQH_R.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15113 * to Halve Results (rounding)
15114 *
15115 * 3 2 1
15116 * 10987654321098765432109876543210
15117 * 001000 11001001101
15118 * rt -----
15119 * rs -----
15120 * rd -----
15121 */
15122 std::string NMD::SUBQH_R_W(uint64 instruction)
15123 {
15124 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15125 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15126 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15127
15128 std::string rd = GPR(copy(rd_value));
15129 std::string rs = GPR(copy(rs_value));
15130 std::string rt = GPR(copy(rt_value));
15131
15132 return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
15133 }
15134
15135
15136 /*
15137 * SUBQH.W rd, rs, rt - Subtract Fractional Words And Shift Right to Halve
15138 * Results
15139 *
15140 * 3 2 1
15141 * 10987654321098765432109876543210
15142 * 001000 01010001101
15143 * rt -----
15144 * rs -----
15145 * rd -----
15146 */
15147 std::string NMD::SUBQH_W(uint64 instruction)
15148 {
15149 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15150 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15151 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15152
15153 std::string rd = GPR(copy(rd_value));
15154 std::string rs = GPR(copy(rs_value));
15155 std::string rt = GPR(copy(rt_value));
15156
15157 return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
15158 }
15159
15160
15161 /*
15162 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15163 *
15164 * 3 2 1
15165 * 10987654321098765432109876543210
15166 * 001000 00010001101
15167 * rt -----
15168 * rs -----
15169 * rd -----
15170 */
15171 std::string NMD::SUBU_16_(uint64 instruction)
15172 {
15173 uint64 rd3_value = extract_rd3_3_2_1(instruction);
15174 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15175 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15176
15177 std::string rd3 = GPR(encode_gpr3(rd3_value));
15178 std::string rs3 = GPR(encode_gpr3(rs3_value));
15179 std::string rt3 = GPR(encode_gpr3(rt3_value));
15180
15181 return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
15182 }
15183
15184
15185 /*
15186 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15187 *
15188 * 3 2 1
15189 * 10987654321098765432109876543210
15190 * 001000 00010001101
15191 * rt -----
15192 * rs -----
15193 * rd -----
15194 */
15195 std::string NMD::SUBU_32_(uint64 instruction)
15196 {
15197 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15198 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15199 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15200
15201 std::string rd = GPR(copy(rd_value));
15202 std::string rs = GPR(copy(rs_value));
15203 std::string rt = GPR(copy(rt_value));
15204
15205 return img::format("SUBU %s, %s, %s", rd, rs, rt);
15206 }
15207
15208
15209 /*
15210 * SUBU.PH rd, rs, rt - Subtract Unsigned Integer Halfwords
15211 *
15212 * 3 2 1
15213 * 10987654321098765432109876543210
15214 * 001000 01100001101
15215 * rt -----
15216 * rs -----
15217 * rd -----
15218 */
15219 std::string NMD::SUBU_PH(uint64 instruction)
15220 {
15221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15222 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15223 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15224
15225 std::string rd = GPR(copy(rd_value));
15226 std::string rs = GPR(copy(rs_value));
15227 std::string rt = GPR(copy(rt_value));
15228
15229 return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
15230 }
15231
15232
15233 /*
15234 * SUBU.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector
15235 *
15236 * 3 2 1
15237 * 10987654321098765432109876543210
15238 * 001000 01011001101
15239 * rt -----
15240 * rs -----
15241 * rd -----
15242 */
15243 std::string NMD::SUBU_QB(uint64 instruction)
15244 {
15245 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15246 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15247 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15248
15249 std::string rd = GPR(copy(rd_value));
15250 std::string rs = GPR(copy(rs_value));
15251 std::string rt = GPR(copy(rt_value));
15252
15253 return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
15254 }
15255
15256
15257 /*
15258 * SUBU_S.PH rd, rs, rt - Subtract Unsigned Integer Halfwords (saturating)
15259 *
15260 * 3 2 1
15261 * 10987654321098765432109876543210
15262 * 001000 11100001101
15263 * rt -----
15264 * rs -----
15265 * rd -----
15266 */
15267 std::string NMD::SUBU_S_PH(uint64 instruction)
15268 {
15269 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15270 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15271 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15272
15273 std::string rd = GPR(copy(rd_value));
15274 std::string rs = GPR(copy(rs_value));
15275 std::string rt = GPR(copy(rt_value));
15276
15277 return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
15278 }
15279
15280
15281 /*
15282 * SUBU_S.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector (saturating)
15283 *
15284 * 3 2 1
15285 * 10987654321098765432109876543210
15286 * 001000 11011001101
15287 * rt -----
15288 * rs -----
15289 * rd -----
15290 */
15291 std::string NMD::SUBU_S_QB(uint64 instruction)
15292 {
15293 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15294 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15295 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15296
15297 std::string rd = GPR(copy(rd_value));
15298 std::string rs = GPR(copy(rs_value));
15299 std::string rt = GPR(copy(rt_value));
15300
15301 return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
15302 }
15303
15304
15305 /*
15306 * SUBUH.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15307 * Results
15308 *
15309 * 3 2 1
15310 * 10987654321098765432109876543210
15311 * 001000 01101001101
15312 * rt -----
15313 * rs -----
15314 * rd -----
15315 */
15316 std::string NMD::SUBUH_QB(uint64 instruction)
15317 {
15318 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15319 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15320 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15321
15322 std::string rd = GPR(copy(rd_value));
15323 std::string rs = GPR(copy(rs_value));
15324 std::string rt = GPR(copy(rt_value));
15325
15326 return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
15327 }
15328
15329
15330 /*
15331 * SUBUH_R.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15332 * Results (rounding)
15333 *
15334 * 3 2 1
15335 * 10987654321098765432109876543210
15336 * 001000 11101001101
15337 * rt -----
15338 * rs -----
15339 * rd -----
15340 */
15341 std::string NMD::SUBUH_R_QB(uint64 instruction)
15342 {
15343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15344 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15345 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15346
15347 std::string rd = GPR(copy(rd_value));
15348 std::string rs = GPR(copy(rs_value));
15349 std::string rt = GPR(copy(rt_value));
15350
15351 return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
15352 }
15353
15354
15355 /*
15356 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15357 *
15358 * 3 2 1
15359 * 10987654321098765432109876543210
15360 * 001000 00010001101
15361 * rt -----
15362 * rs -----
15363 * rd -----
15364 */
15365 std::string NMD::SW_16_(uint64 instruction)
15366 {
15367 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15368 uint64 u_value = extr_uil0il2bs4Fmsb5(instruction);
15369 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15370
15371 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
15372 std::string u = IMMEDIATE(copy(u_value));
15373 std::string rs3 = GPR(encode_gpr3(rs3_value));
15374
15375 return img::format("SW %s, %s(%s)", rtz3, u, rs3);
15376 }
15377
15378
15379 /*
15380 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15381 *
15382 * 3 2 1
15383 * 10987654321098765432109876543210
15384 * 001000 00010001101
15385 * rt -----
15386 * rs -----
15387 * rd -----
15388 */
15389 std::string NMD::SW_4X4_(uint64 instruction)
15390 {
15391 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
15392 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
15393 uint64 u_value = extr_uil3il3bs1_il8il2bs1Fmsb3(instruction);
15394
15395 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
15396 std::string u = IMMEDIATE(copy(u_value));
15397 std::string rs4 = GPR(encode_gpr4(rs4_value));
15398
15399 return img::format("SW %s, %s(%s)", rtz4, u, rs4);
15400 }
15401
15402
15403 /*
15404 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15405 *
15406 * 3 2 1
15407 * 10987654321098765432109876543210
15408 * 001000 00010001101
15409 * rt -----
15410 * rs -----
15411 * rd -----
15412 */
15413 std::string NMD::SW_GP16_(uint64 instruction)
15414 {
15415 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15416 uint64 u_value = extr_uil0il2bs7Fmsb8(instruction);
15417
15418 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
15419 std::string u = IMMEDIATE(copy(u_value));
15420
15421 return img::format("SW %s, %s($%d)", rtz3, u, 28);
15422 }
15423
15424
15425 /*
15426 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15427 *
15428 * 3 2 1
15429 * 10987654321098765432109876543210
15430 * 001000 00010001101
15431 * rt -----
15432 * rs -----
15433 * rd -----
15434 */
15435 std::string NMD::SW_GP_(uint64 instruction)
15436 {
15437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15438 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
15439
15440 std::string rt = GPR(copy(rt_value));
15441 std::string u = IMMEDIATE(copy(u_value));
15442
15443 return img::format("SW %s, %s($%d)", rt, u, 28);
15444 }
15445
15446
15447 /*
15448 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15449 *
15450 * 3 2 1
15451 * 10987654321098765432109876543210
15452 * 001000 00010001101
15453 * rt -----
15454 * rs -----
15455 * rd -----
15456 */
15457 std::string NMD::SW_S9_(uint64 instruction)
15458 {
15459 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15460 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15462
15463 std::string rt = GPR(copy(rt_value));
15464 std::string s = IMMEDIATE(copy(s_value));
15465 std::string rs = GPR(copy(rs_value));
15466
15467 return img::format("SW %s, %s(%s)", rt, s, rs);
15468 }
15469
15470
15471 /*
15472 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15473 *
15474 * 3 2 1
15475 * 10987654321098765432109876543210
15476 * 001000 00010001101
15477 * rt -----
15478 * rs -----
15479 * rd -----
15480 */
15481 std::string NMD::SW_SP_(uint64 instruction)
15482 {
15483 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
15484 uint64 u_value = extr_uil0il2bs5Fmsb6(instruction);
15485
15486 std::string rt = GPR(copy(rt_value));
15487 std::string u = IMMEDIATE(copy(u_value));
15488
15489 return img::format("SW %s, %s($%d)", rt, u, 29);
15490 }
15491
15492
15493 /*
15494 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15495 *
15496 * 3 2 1
15497 * 10987654321098765432109876543210
15498 * 001000 00010001101
15499 * rt -----
15500 * rs -----
15501 * rd -----
15502 */
15503 std::string NMD::SW_U12_(uint64 instruction)
15504 {
15505 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15506 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15507 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15508
15509 std::string rt = GPR(copy(rt_value));
15510 std::string u = IMMEDIATE(copy(u_value));
15511 std::string rs = GPR(copy(rs_value));
15512
15513 return img::format("SW %s, %s(%s)", rt, u, rs);
15514 }
15515
15516
15517 /*
15518 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15519 *
15520 * 3 2 1
15521 * 10987654321098765432109876543210
15522 * 001000 00010001101
15523 * rt -----
15524 * rs -----
15525 * rd -----
15526 */
15527 std::string NMD::SWC1_GP_(uint64 instruction)
15528 {
15529 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15530 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
15531
15532 std::string ft = FPR(copy(ft_value));
15533 std::string u = IMMEDIATE(copy(u_value));
15534
15535 return img::format("SWC1 %s, %s($%d)", ft, u, 28);
15536 }
15537
15538
15539 /*
15540 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15541 *
15542 * 3 2 1
15543 * 10987654321098765432109876543210
15544 * 001000 00010001101
15545 * rt -----
15546 * rs -----
15547 * rd -----
15548 */
15549 std::string NMD::SWC1_S9_(uint64 instruction)
15550 {
15551 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15552 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15553 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15554
15555 std::string ft = FPR(copy(ft_value));
15556 std::string s = IMMEDIATE(copy(s_value));
15557 std::string rs = GPR(copy(rs_value));
15558
15559 return img::format("SWC1 %s, %s(%s)", ft, s, rs);
15560 }
15561
15562
15563 /*
15564 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15565 *
15566 * 3 2 1
15567 * 10987654321098765432109876543210
15568 * 001000 00010001101
15569 * rt -----
15570 * rs -----
15571 * rd -----
15572 */
15573 std::string NMD::SWC1_U12_(uint64 instruction)
15574 {
15575 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15576 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15577 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15578
15579 std::string ft = FPR(copy(ft_value));
15580 std::string u = IMMEDIATE(copy(u_value));
15581 std::string rs = GPR(copy(rs_value));
15582
15583 return img::format("SWC1 %s, %s(%s)", ft, u, rs);
15584 }
15585
15586
15587 /*
15588 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15589 *
15590 * 3 2 1
15591 * 10987654321098765432109876543210
15592 * 001000 00010001101
15593 * rt -----
15594 * rs -----
15595 * rd -----
15596 */
15597 std::string NMD::SWC1X(uint64 instruction)
15598 {
15599 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15600 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15602
15603 std::string ft = FPR(copy(ft_value));
15604 std::string rs = GPR(copy(rs_value));
15605 std::string rt = GPR(copy(rt_value));
15606
15607 return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
15608 }
15609
15610
15611 /*
15612 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15613 *
15614 * 3 2 1
15615 * 10987654321098765432109876543210
15616 * 001000 00010001101
15617 * rt -----
15618 * rs -----
15619 * rd -----
15620 */
15621 std::string NMD::SWC1XS(uint64 instruction)
15622 {
15623 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15624 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15625 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15626
15627 std::string ft = FPR(copy(ft_value));
15628 std::string rs = GPR(copy(rs_value));
15629 std::string rt = GPR(copy(rt_value));
15630
15631 return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
15632 }
15633
15634
15635 /*
15636 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15637 *
15638 * 3 2 1
15639 * 10987654321098765432109876543210
15640 * 001000 00010001101
15641 * rt -----
15642 * rs -----
15643 * rd -----
15644 */
15645 std::string NMD::SWC2(uint64 instruction)
15646 {
15647 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15648 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15649 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15650
15651 std::string cs = CPR(copy(cs_value));
15652 std::string s = IMMEDIATE(copy(s_value));
15653 std::string rs = GPR(copy(rs_value));
15654
15655 return img::format("SWC2 %s, %s(%s)", cs, s, rs);
15656 }
15657
15658
15659 /*
15660 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15661 *
15662 * 3 2 1
15663 * 10987654321098765432109876543210
15664 * 001000 00010001101
15665 * rt -----
15666 * rs -----
15667 * rd -----
15668 */
15669 std::string NMD::SWE(uint64 instruction)
15670 {
15671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15672 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15674
15675 std::string rt = GPR(copy(rt_value));
15676 std::string s = IMMEDIATE(copy(s_value));
15677 std::string rs = GPR(copy(rs_value));
15678
15679 return img::format("SWE %s, %s(%s)", rt, s, rs);
15680 }
15681
15682
15683 /*
15684 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15685 *
15686 * 3 2 1
15687 * 10987654321098765432109876543210
15688 * 001000 00010001101
15689 * rt -----
15690 * rs -----
15691 * rd -----
15692 */
15693 std::string NMD::SWM(uint64 instruction)
15694 {
15695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15696 uint64 count3_value = extract_count3_14_13_12(instruction);
15697 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15698 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15699
15700 std::string rt = GPR(copy(rt_value));
15701 std::string s = IMMEDIATE(copy(s_value));
15702 std::string rs = GPR(copy(rs_value));
15703 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
15704
15705 return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
15706 }
15707
15708
15709 /*
15710 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15711 *
15712 * 3 2 1
15713 * 10987654321098765432109876543210
15714 * 001000 00010001101
15715 * rt -----
15716 * rs -----
15717 * rd -----
15718 */
15719 std::string NMD::SWPC_48_(uint64 instruction)
15720 {
15721 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15722 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
15723
15724 std::string rt = GPR(copy(rt_value));
15725 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
15726
15727 return img::format("SWPC %s, %s", rt, s);
15728 }
15729
15730
15731 /*
15732 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15733 *
15734 * 3 2 1
15735 * 10987654321098765432109876543210
15736 * 001000 00010001101
15737 * rt -----
15738 * rs -----
15739 * rd -----
15740 */
15741 std::string NMD::SWX(uint64 instruction)
15742 {
15743 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15744 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15745 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15746
15747 std::string rd = GPR(copy(rd_value));
15748 std::string rs = GPR(copy(rs_value));
15749 std::string rt = GPR(copy(rt_value));
15750
15751 return img::format("SWX %s, %s(%s)", rd, rs, rt);
15752 }
15753
15754
15755 /*
15756 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15757 *
15758 * 3 2 1
15759 * 10987654321098765432109876543210
15760 * 001000 00010001101
15761 * rt -----
15762 * rs -----
15763 * rd -----
15764 */
15765 std::string NMD::SWXS(uint64 instruction)
15766 {
15767 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15768 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15769 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15770
15771 std::string rd = GPR(copy(rd_value));
15772 std::string rs = GPR(copy(rs_value));
15773 std::string rt = GPR(copy(rt_value));
15774
15775 return img::format("SWXS %s, %s(%s)", rd, rs, rt);
15776 }
15777
15778
15779 /*
15780 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15781 *
15782 * 3 2 1
15783 * 10987654321098765432109876543210
15784 * 001000 00010001101
15785 * rt -----
15786 * rs -----
15787 * rd -----
15788 */
15789 std::string NMD::SYNC(uint64 instruction)
15790 {
15791 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15792
15793 std::string stype = IMMEDIATE(copy(stype_value));
15794
15795 return img::format("SYNC %s", stype);
15796 }
15797
15798
15799 /*
15800 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15801 *
15802 * 3 2 1
15803 * 10987654321098765432109876543210
15804 * 001000 00010001101
15805 * rt -----
15806 * rs -----
15807 * rd -----
15808 */
15809 std::string NMD::SYNCI(uint64 instruction)
15810 {
15811 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15812 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15813
15814 std::string s = IMMEDIATE(copy(s_value));
15815 std::string rs = GPR(copy(rs_value));
15816
15817 return img::format("SYNCI %s(%s)", s, rs);
15818 }
15819
15820
15821 /*
15822 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15823 *
15824 * 3 2 1
15825 * 10987654321098765432109876543210
15826 * 001000 00010001101
15827 * rt -----
15828 * rs -----
15829 * rd -----
15830 */
15831 std::string NMD::SYNCIE(uint64 instruction)
15832 {
15833 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15834 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15835
15836 std::string s = IMMEDIATE(copy(s_value));
15837 std::string rs = GPR(copy(rs_value));
15838
15839 return img::format("SYNCIE %s(%s)", s, rs);
15840 }
15841
15842
15843 /*
15844 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15845 *
15846 * 3 2 1
15847 * 10987654321098765432109876543210
15848 * 001000 00010001101
15849 * rt -----
15850 * rs -----
15851 * rd -----
15852 */
15853 std::string NMD::SYSCALL_16_(uint64 instruction)
15854 {
15855 uint64 code_value = extract_code_1_0(instruction);
15856
15857 std::string code = IMMEDIATE(copy(code_value));
15858
15859 return img::format("SYSCALL %s", code);
15860 }
15861
15862
15863 /*
15864 * SYSCALL code - System Call. Cause a System Call Exception
15865 *
15866 * 3 2 1
15867 * 10987654321098765432109876543210
15868 * 00000000000010
15869 * code ------------------
15870 */
15871 std::string NMD::SYSCALL_32_(uint64 instruction)
15872 {
15873 uint64 code_value = extract_code_17_to_0(instruction);
15874
15875 std::string code = IMMEDIATE(copy(code_value));
15876
15877 return img::format("SYSCALL %s", code);
15878 }
15879
15880
15881 /*
15882 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15883 *
15884 * 3 2 1
15885 * 10987654321098765432109876543210
15886 * 001000 00010001101
15887 * rt -----
15888 * rs -----
15889 * rd -----
15890 */
15891 std::string NMD::TEQ(uint64 instruction)
15892 {
15893 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15894 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15895
15896 std::string rs = GPR(copy(rs_value));
15897 std::string rt = GPR(copy(rt_value));
15898
15899 return img::format("TEQ %s, %s", rs, rt);
15900 }
15901
15902
15903 /*
15904 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15905 *
15906 * 3 2 1
15907 * 10987654321098765432109876543210
15908 * 001000 00010001101
15909 * rt -----
15910 * rs -----
15911 * rd -----
15912 */
15913 std::string NMD::TLBGINV(uint64 instruction)
15914 {
15915 (void)instruction;
15916
15917 return "TLBGINV ";
15918 }
15919
15920
15921 /*
15922 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15923 *
15924 * 3 2 1
15925 * 10987654321098765432109876543210
15926 * 001000 00010001101
15927 * rt -----
15928 * rs -----
15929 * rd -----
15930 */
15931 std::string NMD::TLBGINVF(uint64 instruction)
15932 {
15933 (void)instruction;
15934
15935 return "TLBGINVF ";
15936 }
15937
15938
15939 /*
15940 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15941 *
15942 * 3 2 1
15943 * 10987654321098765432109876543210
15944 * 001000 00010001101
15945 * rt -----
15946 * rs -----
15947 * rd -----
15948 */
15949 std::string NMD::TLBGP(uint64 instruction)
15950 {
15951 (void)instruction;
15952
15953 return "TLBGP ";
15954 }
15955
15956
15957 /*
15958 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15959 *
15960 * 3 2 1
15961 * 10987654321098765432109876543210
15962 * 001000 00010001101
15963 * rt -----
15964 * rs -----
15965 * rd -----
15966 */
15967 std::string NMD::TLBGR(uint64 instruction)
15968 {
15969 (void)instruction;
15970
15971 return "TLBGR ";
15972 }
15973
15974
15975 /*
15976 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15977 *
15978 * 3 2 1
15979 * 10987654321098765432109876543210
15980 * 001000 00010001101
15981 * rt -----
15982 * rs -----
15983 * rd -----
15984 */
15985 std::string NMD::TLBGWI(uint64 instruction)
15986 {
15987 (void)instruction;
15988
15989 return "TLBGWI ";
15990 }
15991
15992
15993 /*
15994 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15995 *
15996 * 3 2 1
15997 * 10987654321098765432109876543210
15998 * 001000 00010001101
15999 * rt -----
16000 * rs -----
16001 * rd -----
16002 */
16003 std::string NMD::TLBGWR(uint64 instruction)
16004 {
16005 (void)instruction;
16006
16007 return "TLBGWR ";
16008 }
16009
16010
16011 /*
16012 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16013 *
16014 * 3 2 1
16015 * 10987654321098765432109876543210
16016 * 001000 00010001101
16017 * rt -----
16018 * rs -----
16019 * rd -----
16020 */
16021 std::string NMD::TLBINV(uint64 instruction)
16022 {
16023 (void)instruction;
16024
16025 return "TLBINV ";
16026 }
16027
16028
16029 /*
16030 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16031 *
16032 * 3 2 1
16033 * 10987654321098765432109876543210
16034 * 001000 00010001101
16035 * rt -----
16036 * rs -----
16037 * rd -----
16038 */
16039 std::string NMD::TLBINVF(uint64 instruction)
16040 {
16041 (void)instruction;
16042
16043 return "TLBINVF ";
16044 }
16045
16046
16047 /*
16048 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16049 *
16050 * 3 2 1
16051 * 10987654321098765432109876543210
16052 * 001000 00010001101
16053 * rt -----
16054 * rs -----
16055 * rd -----
16056 */
16057 std::string NMD::TLBP(uint64 instruction)
16058 {
16059 (void)instruction;
16060
16061 return "TLBP ";
16062 }
16063
16064
16065 /*
16066 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16067 *
16068 * 3 2 1
16069 * 10987654321098765432109876543210
16070 * 001000 00010001101
16071 * rt -----
16072 * rs -----
16073 * rd -----
16074 */
16075 std::string NMD::TLBR(uint64 instruction)
16076 {
16077 (void)instruction;
16078
16079 return "TLBR ";
16080 }
16081
16082
16083 /*
16084 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16085 *
16086 * 3 2 1
16087 * 10987654321098765432109876543210
16088 * 001000 00010001101
16089 * rt -----
16090 * rs -----
16091 * rd -----
16092 */
16093 std::string NMD::TLBWI(uint64 instruction)
16094 {
16095 (void)instruction;
16096
16097 return "TLBWI ";
16098 }
16099
16100
16101 /*
16102 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16103 *
16104 * 3 2 1
16105 * 10987654321098765432109876543210
16106 * 001000 00010001101
16107 * rt -----
16108 * rs -----
16109 * rd -----
16110 */
16111 std::string NMD::TLBWR(uint64 instruction)
16112 {
16113 (void)instruction;
16114
16115 return "TLBWR ";
16116 }
16117
16118
16119 /*
16120 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16121 *
16122 * 3 2 1
16123 * 10987654321098765432109876543210
16124 * 001000 00010001101
16125 * rt -----
16126 * rs -----
16127 * rd -----
16128 */
16129 std::string NMD::TNE(uint64 instruction)
16130 {
16131 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16132 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16133
16134 std::string rs = GPR(copy(rs_value));
16135 std::string rt = GPR(copy(rt_value));
16136
16137 return img::format("TNE %s, %s", rs, rt);
16138 }
16139
16140
16141 /*
16142 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16143 *
16144 * 3 2 1
16145 * 10987654321098765432109876543210
16146 * 001000 00010001101
16147 * rt -----
16148 * rs -----
16149 * rd -----
16150 */
16151 std::string NMD::TRUNC_L_D(uint64 instruction)
16152 {
16153 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16154 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16155
16156 std::string ft = FPR(copy(ft_value));
16157 std::string fs = FPR(copy(fs_value));
16158
16159 return img::format("TRUNC.L.D %s, %s", ft, fs);
16160 }
16161
16162
16163 /*
16164 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16165 *
16166 * 3 2 1
16167 * 10987654321098765432109876543210
16168 * 001000 00010001101
16169 * rt -----
16170 * rs -----
16171 * rd -----
16172 */
16173 std::string NMD::TRUNC_L_S(uint64 instruction)
16174 {
16175 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16176 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16177
16178 std::string ft = FPR(copy(ft_value));
16179 std::string fs = FPR(copy(fs_value));
16180
16181 return img::format("TRUNC.L.S %s, %s", ft, fs);
16182 }
16183
16184
16185 /*
16186 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16187 *
16188 * 3 2 1
16189 * 10987654321098765432109876543210
16190 * 001000 00010001101
16191 * rt -----
16192 * rs -----
16193 * rd -----
16194 */
16195 std::string NMD::TRUNC_W_D(uint64 instruction)
16196 {
16197 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16198 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16199
16200 std::string ft = FPR(copy(ft_value));
16201 std::string fs = FPR(copy(fs_value));
16202
16203 return img::format("TRUNC.W.D %s, %s", ft, fs);
16204 }
16205
16206
16207 /*
16208 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16209 *
16210 * 3 2 1
16211 * 10987654321098765432109876543210
16212 * 001000 00010001101
16213 * rt -----
16214 * rs -----
16215 * rd -----
16216 */
16217 std::string NMD::TRUNC_W_S(uint64 instruction)
16218 {
16219 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16220 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16221
16222 std::string ft = FPR(copy(ft_value));
16223 std::string fs = FPR(copy(fs_value));
16224
16225 return img::format("TRUNC.W.S %s, %s", ft, fs);
16226 }
16227
16228
16229 /*
16230 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16231 *
16232 * 3 2 1
16233 * 10987654321098765432109876543210
16234 * 001000 00010001101
16235 * rt -----
16236 * rs -----
16237 * rd -----
16238 */
16239 std::string NMD::UALDM(uint64 instruction)
16240 {
16241 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16242 uint64 count3_value = extract_count3_14_13_12(instruction);
16243 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16244 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16245
16246 std::string rt = GPR(copy(rt_value));
16247 std::string s = IMMEDIATE(copy(s_value));
16248 std::string rs = GPR(copy(rs_value));
16249 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16250
16251 return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
16252 }
16253
16254
16255 /*
16256 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16257 *
16258 * 3 2 1
16259 * 10987654321098765432109876543210
16260 * 001000 00010001101
16261 * rt -----
16262 * rs -----
16263 * rd -----
16264 */
16265 std::string NMD::UALH(uint64 instruction)
16266 {
16267 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16268 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16269 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16270
16271 std::string rt = GPR(copy(rt_value));
16272 std::string s = IMMEDIATE(copy(s_value));
16273 std::string rs = GPR(copy(rs_value));
16274
16275 return img::format("UALH %s, %s(%s)", rt, s, rs);
16276 }
16277
16278
16279 /*
16280 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16281 *
16282 * 3 2 1
16283 * 10987654321098765432109876543210
16284 * 001000 00010001101
16285 * rt -----
16286 * rs -----
16287 * rd -----
16288 */
16289 std::string NMD::UALWM(uint64 instruction)
16290 {
16291 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16292 uint64 count3_value = extract_count3_14_13_12(instruction);
16293 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16294 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16295
16296 std::string rt = GPR(copy(rt_value));
16297 std::string s = IMMEDIATE(copy(s_value));
16298 std::string rs = GPR(copy(rs_value));
16299 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16300
16301 return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
16302 }
16303
16304
16305 /*
16306 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16307 *
16308 * 3 2 1
16309 * 10987654321098765432109876543210
16310 * 001000 00010001101
16311 * rt -----
16312 * rs -----
16313 * rd -----
16314 */
16315 std::string NMD::UASDM(uint64 instruction)
16316 {
16317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16318 uint64 count3_value = extract_count3_14_13_12(instruction);
16319 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16320 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16321
16322 std::string rt = GPR(copy(rt_value));
16323 std::string s = IMMEDIATE(copy(s_value));
16324 std::string rs = GPR(copy(rs_value));
16325 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16326
16327 return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
16328 }
16329
16330
16331 /*
16332 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16333 *
16334 * 3 2 1
16335 * 10987654321098765432109876543210
16336 * 001000 00010001101
16337 * rt -----
16338 * rs -----
16339 * rd -----
16340 */
16341 std::string NMD::UASH(uint64 instruction)
16342 {
16343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16344 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16345 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16346
16347 std::string rt = GPR(copy(rt_value));
16348 std::string s = IMMEDIATE(copy(s_value));
16349 std::string rs = GPR(copy(rs_value));
16350
16351 return img::format("UASH %s, %s(%s)", rt, s, rs);
16352 }
16353
16354
16355 /*
16356 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16357 *
16358 * 3 2 1
16359 * 10987654321098765432109876543210
16360 * 001000 00010001101
16361 * rt -----
16362 * rs -----
16363 * rd -----
16364 */
16365 std::string NMD::UASWM(uint64 instruction)
16366 {
16367 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16368 uint64 count3_value = extract_count3_14_13_12(instruction);
16369 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16370 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16371
16372 std::string rt = GPR(copy(rt_value));
16373 std::string s = IMMEDIATE(copy(s_value));
16374 std::string rs = GPR(copy(rs_value));
16375 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16376
16377 return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
16378 }
16379
16380
16381 /*
16382 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16383 *
16384 * 3 2 1
16385 * 10987654321098765432109876543210
16386 * 001000 00010001101
16387 * rt -----
16388 * rs -----
16389 * rd -----
16390 */
16391 std::string NMD::UDI(uint64 instruction)
16392 {
16393 uint64 op_value = extract_op_25_to_3(instruction);
16394
16395 std::string op = IMMEDIATE(copy(op_value));
16396
16397 return img::format("UDI %s", op);
16398 }
16399
16400
16401 /*
16402 * WAIT code - Enter Wait State
16403 *
16404 * 3 2 1
16405 * 10987654321098765432109876543210
16406 * 001000 1100001101111111
16407 * code ----------
16408 */
16409 std::string NMD::WAIT(uint64 instruction)
16410 {
16411 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
16412
16413 std::string code = IMMEDIATE(copy(code_value));
16414
16415 return img::format("WAIT %s", code);
16416 }
16417
16418
16419 /*
16420 * WRDSP rt, mask - Write Fields to DSPControl Register from a GPR
16421 *
16422 * 3 2 1
16423 * 10987654321098765432109876543210
16424 * 001000 01011001111111
16425 * rt -----
16426 * mask -------
16427 */
16428 std::string NMD::WRDSP(uint64 instruction)
16429 {
16430 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16431 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
16432
16433 std::string rt = GPR(copy(rt_value));
16434 std::string mask = IMMEDIATE(copy(mask_value));
16435
16436 return img::format("WRDSP %s, %s", rt, mask);
16437 }
16438
16439
16440 /*
16441 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16442 *
16443 * 3 2 1
16444 * 10987654321098765432109876543210
16445 * 001000 00010001101
16446 * rt -----
16447 * rs -----
16448 * rd -----
16449 */
16450 std::string NMD::WRPGPR(uint64 instruction)
16451 {
16452 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16453 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16454
16455 std::string rt = GPR(copy(rt_value));
16456 std::string rs = GPR(copy(rs_value));
16457
16458 return img::format("WRPGPR %s, %s", rt, rs);
16459 }
16460
16461
16462 /*
16463 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16464 *
16465 * 3 2 1
16466 * 10987654321098765432109876543210
16467 * 001000 00010001101
16468 * rt -----
16469 * rs -----
16470 * rd -----
16471 */
16472 std::string NMD::XOR_16_(uint64 instruction)
16473 {
16474 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16475 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16476
16477 std::string rs3 = GPR(encode_gpr3(rs3_value));
16478 std::string rt3 = GPR(encode_gpr3(rt3_value));
16479
16480 return img::format("XOR %s, %s", rs3, rt3);
16481 }
16482
16483
16484 /*
16485 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16486 *
16487 * 3 2 1
16488 * 10987654321098765432109876543210
16489 * 001000 00010001101
16490 * rt -----
16491 * rs -----
16492 * rd -----
16493 */
16494 std::string NMD::XOR_32_(uint64 instruction)
16495 {
16496 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16497 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
16498 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16499
16500 std::string rd = GPR(copy(rd_value));
16501 std::string rs = GPR(copy(rs_value));
16502 std::string rt = GPR(copy(rt_value));
16503
16504 return img::format("XOR %s, %s, %s", rd, rs, rt);
16505 }
16506
16507
16508 /*
16509 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16510 *
16511 * 3 2 1
16512 * 10987654321098765432109876543210
16513 * 001000 00010001101
16514 * rt -----
16515 * rs -----
16516 * rd -----
16517 */
16518 std::string NMD::XORI(uint64 instruction)
16519 {
16520 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16521 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
16522 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16523
16524 std::string rt = GPR(copy(rt_value));
16525 std::string rs = GPR(copy(rs_value));
16526 std::string u = IMMEDIATE(copy(u_value));
16527
16528 return img::format("XORI %s, %s, %s", rt, rs, u);
16529 }
16530
16531
16532 /*
16533 * YIELD rt, rs -
16534 *
16535 * 3 2 1
16536 * 10987654321098765432109876543210
16537 * 001000 00010001101
16538 * rt -----
16539 * rs -----
16540 */
16541 std::string NMD::YIELD(uint64 instruction)
16542 {
16543 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16544 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16545
16546 std::string rt = GPR(copy(rt_value));
16547 std::string rs = GPR(copy(rs_value));
16548
16549 return img::format("YIELD %s, %s", rt, rs);
16550 }
16551
16552
16553
16554 NMD::Pool NMD::P_SYSCALL[2] = {
16555 { instruction , 0 , 0 , 32,
16556 0xfffc0000, 0x00080000, &NMD::SYSCALL_32_ , 0,
16557 0x0 }, /* SYSCALL[32] */
16558 { instruction , 0 , 0 , 32,
16559 0xfffc0000, 0x000c0000, &NMD::HYPCALL , 0,
16560 CP0_ | VZ_ }, /* HYPCALL */
16561 };
16562
16563
16564 NMD::Pool NMD::P_RI[4] = {
16565 { instruction , 0 , 0 , 32,
16566 0xfff80000, 0x00000000, &NMD::SIGRIE , 0,
16567 0x0 }, /* SIGRIE */
16568 { pool , P_SYSCALL , 2 , 32,
16569 0xfff80000, 0x00080000, 0 , 0,
16570 0x0 }, /* P.SYSCALL */
16571 { instruction , 0 , 0 , 32,
16572 0xfff80000, 0x00100000, &NMD::BREAK_32_ , 0,
16573 0x0 }, /* BREAK[32] */
16574 { instruction , 0 , 0 , 32,
16575 0xfff80000, 0x00180000, &NMD::SDBBP_32_ , 0,
16576 EJTAG_ }, /* SDBBP[32] */
16577 };
16578
16579
16580 NMD::Pool NMD::P_ADDIU[2] = {
16581 { pool , P_RI , 4 , 32,
16582 0xffe00000, 0x00000000, 0 , 0,
16583 0x0 }, /* P.RI */
16584 { instruction , 0 , 0 , 32,
16585 0xfc000000, 0x00000000, &NMD::ADDIU_32_ , &NMD::ADDIU_32__cond ,
16586 0x0 }, /* ADDIU[32] */
16587 };
16588
16589
16590 NMD::Pool NMD::P_TRAP[2] = {
16591 { instruction , 0 , 0 , 32,
16592 0xfc0007ff, 0x20000000, &NMD::TEQ , 0,
16593 XMMS_ }, /* TEQ */
16594 { instruction , 0 , 0 , 32,
16595 0xfc0007ff, 0x20000400, &NMD::TNE , 0,
16596 XMMS_ }, /* TNE */
16597 };
16598
16599
16600 NMD::Pool NMD::P_CMOVE[2] = {
16601 { instruction , 0 , 0 , 32,
16602 0xfc0007ff, 0x20000210, &NMD::MOVZ , 0,
16603 0x0 }, /* MOVZ */
16604 { instruction , 0 , 0 , 32,
16605 0xfc0007ff, 0x20000610, &NMD::MOVN , 0,
16606 0x0 }, /* MOVN */
16607 };
16608
16609
16610 NMD::Pool NMD::P_D_MT_VPE[2] = {
16611 { instruction , 0 , 0 , 32,
16612 0xfc1f3fff, 0x20010ab0, &NMD::DMT , 0,
16613 MT_ }, /* DMT */
16614 { instruction , 0 , 0 , 32,
16615 0xfc1f3fff, 0x20000ab0, &NMD::DVPE , 0,
16616 MT_ }, /* DVPE */
16617 };
16618
16619
16620 NMD::Pool NMD::P_E_MT_VPE[2] = {
16621 { instruction , 0 , 0 , 32,
16622 0xfc1f3fff, 0x20010eb0, &NMD::EMT , 0,
16623 MT_ }, /* EMT */
16624 { instruction , 0 , 0 , 32,
16625 0xfc1f3fff, 0x20000eb0, &NMD::EVPE , 0,
16626 MT_ }, /* EVPE */
16627 };
16628
16629
16630 NMD::Pool NMD::_P_MT_VPE[2] = {
16631 { pool , P_D_MT_VPE , 2 , 32,
16632 0xfc003fff, 0x20000ab0, 0 , 0,
16633 0x0 }, /* P.D_MT_VPE */
16634 { pool , P_E_MT_VPE , 2 , 32,
16635 0xfc003fff, 0x20000eb0, 0 , 0,
16636 0x0 }, /* P.E_MT_VPE */
16637 };
16638
16639
16640 NMD::Pool NMD::P_MT_VPE[8] = {
16641 { reserved_block , 0 , 0 , 32,
16642 0xfc003bff, 0x200002b0, 0 , 0,
16643 0x0 }, /* P.MT_VPE~*(0) */
16644 { pool , _P_MT_VPE , 2 , 32,
16645 0xfc003bff, 0x20000ab0, 0 , 0,
16646 0x0 }, /* _P.MT_VPE */
16647 { reserved_block , 0 , 0 , 32,
16648 0xfc003bff, 0x200012b0, 0 , 0,
16649 0x0 }, /* P.MT_VPE~*(2) */
16650 { reserved_block , 0 , 0 , 32,
16651 0xfc003bff, 0x20001ab0, 0 , 0,
16652 0x0 }, /* P.MT_VPE~*(3) */
16653 { reserved_block , 0 , 0 , 32,
16654 0xfc003bff, 0x200022b0, 0 , 0,
16655 0x0 }, /* P.MT_VPE~*(4) */
16656 { reserved_block , 0 , 0 , 32,
16657 0xfc003bff, 0x20002ab0, 0 , 0,
16658 0x0 }, /* P.MT_VPE~*(5) */
16659 { reserved_block , 0 , 0 , 32,
16660 0xfc003bff, 0x200032b0, 0 , 0,
16661 0x0 }, /* P.MT_VPE~*(6) */
16662 { reserved_block , 0 , 0 , 32,
16663 0xfc003bff, 0x20003ab0, 0 , 0,
16664 0x0 }, /* P.MT_VPE~*(7) */
16665 };
16666
16667
16668 NMD::Pool NMD::P_DVP[2] = {
16669 { instruction , 0 , 0 , 32,
16670 0xfc00ffff, 0x20000390, &NMD::DVP , 0,
16671 0x0 }, /* DVP */
16672 { instruction , 0 , 0 , 32,
16673 0xfc00ffff, 0x20000790, &NMD::EVP , 0,
16674 0x0 }, /* EVP */
16675 };
16676
16677
16678 NMD::Pool NMD::P_SLTU[2] = {
16679 { pool , P_DVP , 2 , 32,
16680 0xfc00fbff, 0x20000390, 0 , 0,
16681 0x0 }, /* P.DVP */
16682 { instruction , 0 , 0 , 32,
16683 0xfc0003ff, 0x20000390, &NMD::SLTU , &NMD::SLTU_cond ,
16684 0x0 }, /* SLTU */
16685 };
16686
16687
16688 NMD::Pool NMD::_POOL32A0[128] = {
16689 { pool , P_TRAP , 2 , 32,
16690 0xfc0003ff, 0x20000000, 0 , 0,
16691 0x0 }, /* P.TRAP */
16692 { instruction , 0 , 0 , 32,
16693 0xfc0003ff, 0x20000008, &NMD::SEB , 0,
16694 XMMS_ }, /* SEB */
16695 { instruction , 0 , 0 , 32,
16696 0xfc0003ff, 0x20000010, &NMD::SLLV , 0,
16697 0x0 }, /* SLLV */
16698 { instruction , 0 , 0 , 32,
16699 0xfc0003ff, 0x20000018, &NMD::MUL_32_ , 0,
16700 0x0 }, /* MUL[32] */
16701 { reserved_block , 0 , 0 , 32,
16702 0xfc0003ff, 0x20000020, 0 , 0,
16703 0x0 }, /* _POOL32A0~*(4) */
16704 { reserved_block , 0 , 0 , 32,
16705 0xfc0003ff, 0x20000028, 0 , 0,
16706 0x0 }, /* _POOL32A0~*(5) */
16707 { instruction , 0 , 0 , 32,
16708 0xfc0003ff, 0x20000030, &NMD::MFC0 , 0,
16709 0x0 }, /* MFC0 */
16710 { instruction , 0 , 0 , 32,
16711 0xfc0003ff, 0x20000038, &NMD::MFHC0 , 0,
16712 CP0_ | MVH_ }, /* MFHC0 */
16713 { reserved_block , 0 , 0 , 32,
16714 0xfc0003ff, 0x20000040, 0 , 0,
16715 0x0 }, /* _POOL32A0~*(8) */
16716 { instruction , 0 , 0 , 32,
16717 0xfc0003ff, 0x20000048, &NMD::SEH , 0,
16718 0x0 }, /* SEH */
16719 { instruction , 0 , 0 , 32,
16720 0xfc0003ff, 0x20000050, &NMD::SRLV , 0,
16721 0x0 }, /* SRLV */
16722 { instruction , 0 , 0 , 32,
16723 0xfc0003ff, 0x20000058, &NMD::MUH , 0,
16724 0x0 }, /* MUH */
16725 { reserved_block , 0 , 0 , 32,
16726 0xfc0003ff, 0x20000060, 0 , 0,
16727 0x0 }, /* _POOL32A0~*(12) */
16728 { reserved_block , 0 , 0 , 32,
16729 0xfc0003ff, 0x20000068, 0 , 0,
16730 0x0 }, /* _POOL32A0~*(13) */
16731 { instruction , 0 , 0 , 32,
16732 0xfc0003ff, 0x20000070, &NMD::MTC0 , 0,
16733 CP0_ }, /* MTC0 */
16734 { instruction , 0 , 0 , 32,
16735 0xfc0003ff, 0x20000078, &NMD::MTHC0 , 0,
16736 CP0_ | MVH_ }, /* MTHC0 */
16737 { reserved_block , 0 , 0 , 32,
16738 0xfc0003ff, 0x20000080, 0 , 0,
16739 0x0 }, /* _POOL32A0~*(16) */
16740 { reserved_block , 0 , 0 , 32,
16741 0xfc0003ff, 0x20000088, 0 , 0,
16742 0x0 }, /* _POOL32A0~*(17) */
16743 { instruction , 0 , 0 , 32,
16744 0xfc0003ff, 0x20000090, &NMD::SRAV , 0,
16745 0x0 }, /* SRAV */
16746 { instruction , 0 , 0 , 32,
16747 0xfc0003ff, 0x20000098, &NMD::MULU , 0,
16748 0x0 }, /* MULU */
16749 { reserved_block , 0 , 0 , 32,
16750 0xfc0003ff, 0x200000a0, 0 , 0,
16751 0x0 }, /* _POOL32A0~*(20) */
16752 { reserved_block , 0 , 0 , 32,
16753 0xfc0003ff, 0x200000a8, 0 , 0,
16754 0x0 }, /* _POOL32A0~*(21) */
16755 { instruction , 0 , 0 , 32,
16756 0xfc0003ff, 0x200000b0, &NMD::MFGC0 , 0,
16757 CP0_ | VZ_ }, /* MFGC0 */
16758 { instruction , 0 , 0 , 32,
16759 0xfc0003ff, 0x200000b8, &NMD::MFHGC0 , 0,
16760 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16761 { reserved_block , 0 , 0 , 32,
16762 0xfc0003ff, 0x200000c0, 0 , 0,
16763 0x0 }, /* _POOL32A0~*(24) */
16764 { reserved_block , 0 , 0 , 32,
16765 0xfc0003ff, 0x200000c8, 0 , 0,
16766 0x0 }, /* _POOL32A0~*(25) */
16767 { instruction , 0 , 0 , 32,
16768 0xfc0003ff, 0x200000d0, &NMD::ROTRV , 0,
16769 0x0 }, /* ROTRV */
16770 { instruction , 0 , 0 , 32,
16771 0xfc0003ff, 0x200000d8, &NMD::MUHU , 0,
16772 0x0 }, /* MUHU */
16773 { reserved_block , 0 , 0 , 32,
16774 0xfc0003ff, 0x200000e0, 0 , 0,
16775 0x0 }, /* _POOL32A0~*(28) */
16776 { reserved_block , 0 , 0 , 32,
16777 0xfc0003ff, 0x200000e8, 0 , 0,
16778 0x0 }, /* _POOL32A0~*(29) */
16779 { instruction , 0 , 0 , 32,
16780 0xfc0003ff, 0x200000f0, &NMD::MTGC0 , 0,
16781 CP0_ | VZ_ }, /* MTGC0 */
16782 { instruction , 0 , 0 , 32,
16783 0xfc0003ff, 0x200000f8, &NMD::MTHGC0 , 0,
16784 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16785 { reserved_block , 0 , 0 , 32,
16786 0xfc0003ff, 0x20000100, 0 , 0,
16787 0x0 }, /* _POOL32A0~*(32) */
16788 { reserved_block , 0 , 0 , 32,
16789 0xfc0003ff, 0x20000108, 0 , 0,
16790 0x0 }, /* _POOL32A0~*(33) */
16791 { instruction , 0 , 0 , 32,
16792 0xfc0003ff, 0x20000110, &NMD::ADD , 0,
16793 XMMS_ }, /* ADD */
16794 { instruction , 0 , 0 , 32,
16795 0xfc0003ff, 0x20000118, &NMD::DIV , 0,
16796 0x0 }, /* DIV */
16797 { reserved_block , 0 , 0 , 32,
16798 0xfc0003ff, 0x20000120, 0 , 0,
16799 0x0 }, /* _POOL32A0~*(36) */
16800 { reserved_block , 0 , 0 , 32,
16801 0xfc0003ff, 0x20000128, 0 , 0,
16802 0x0 }, /* _POOL32A0~*(37) */
16803 { instruction , 0 , 0 , 32,
16804 0xfc0003ff, 0x20000130, &NMD::DMFC0 , 0,
16805 CP0_ | MIPS64_ }, /* DMFC0 */
16806 { reserved_block , 0 , 0 , 32,
16807 0xfc0003ff, 0x20000138, 0 , 0,
16808 0x0 }, /* _POOL32A0~*(39) */
16809 { reserved_block , 0 , 0 , 32,
16810 0xfc0003ff, 0x20000140, 0 , 0,
16811 0x0 }, /* _POOL32A0~*(40) */
16812 { reserved_block , 0 , 0 , 32,
16813 0xfc0003ff, 0x20000148, 0 , 0,
16814 0x0 }, /* _POOL32A0~*(41) */
16815 { instruction , 0 , 0 , 32,
16816 0xfc0003ff, 0x20000150, &NMD::ADDU_32_ , 0,
16817 0x0 }, /* ADDU[32] */
16818 { instruction , 0 , 0 , 32,
16819 0xfc0003ff, 0x20000158, &NMD::MOD , 0,
16820 0x0 }, /* MOD */
16821 { reserved_block , 0 , 0 , 32,
16822 0xfc0003ff, 0x20000160, 0 , 0,
16823 0x0 }, /* _POOL32A0~*(44) */
16824 { reserved_block , 0 , 0 , 32,
16825 0xfc0003ff, 0x20000168, 0 , 0,
16826 0x0 }, /* _POOL32A0~*(45) */
16827 { instruction , 0 , 0 , 32,
16828 0xfc0003ff, 0x20000170, &NMD::DMTC0 , 0,
16829 CP0_ | MIPS64_ }, /* DMTC0 */
16830 { reserved_block , 0 , 0 , 32,
16831 0xfc0003ff, 0x20000178, 0 , 0,
16832 0x0 }, /* _POOL32A0~*(47) */
16833 { reserved_block , 0 , 0 , 32,
16834 0xfc0003ff, 0x20000180, 0 , 0,
16835 0x0 }, /* _POOL32A0~*(48) */
16836 { reserved_block , 0 , 0 , 32,
16837 0xfc0003ff, 0x20000188, 0 , 0,
16838 0x0 }, /* _POOL32A0~*(49) */
16839 { instruction , 0 , 0 , 32,
16840 0xfc0003ff, 0x20000190, &NMD::SUB , 0,
16841 XMMS_ }, /* SUB */
16842 { instruction , 0 , 0 , 32,
16843 0xfc0003ff, 0x20000198, &NMD::DIVU , 0,
16844 0x0 }, /* DIVU */
16845 { reserved_block , 0 , 0 , 32,
16846 0xfc0003ff, 0x200001a0, 0 , 0,
16847 0x0 }, /* _POOL32A0~*(52) */
16848 { reserved_block , 0 , 0 , 32,
16849 0xfc0003ff, 0x200001a8, 0 , 0,
16850 0x0 }, /* _POOL32A0~*(53) */
16851 { instruction , 0 , 0 , 32,
16852 0xfc0003ff, 0x200001b0, &NMD::DMFGC0 , 0,
16853 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16854 { reserved_block , 0 , 0 , 32,
16855 0xfc0003ff, 0x200001b8, 0 , 0,
16856 0x0 }, /* _POOL32A0~*(55) */
16857 { instruction , 0 , 0 , 32,
16858 0xfc0003ff, 0x200001c0, &NMD::RDHWR , 0,
16859 XMMS_ }, /* RDHWR */
16860 { reserved_block , 0 , 0 , 32,
16861 0xfc0003ff, 0x200001c8, 0 , 0,
16862 0x0 }, /* _POOL32A0~*(57) */
16863 { instruction , 0 , 0 , 32,
16864 0xfc0003ff, 0x200001d0, &NMD::SUBU_32_ , 0,
16865 0x0 }, /* SUBU[32] */
16866 { instruction , 0 , 0 , 32,
16867 0xfc0003ff, 0x200001d8, &NMD::MODU , 0,
16868 0x0 }, /* MODU */
16869 { reserved_block , 0 , 0 , 32,
16870 0xfc0003ff, 0x200001e0, 0 , 0,
16871 0x0 }, /* _POOL32A0~*(60) */
16872 { reserved_block , 0 , 0 , 32,
16873 0xfc0003ff, 0x200001e8, 0 , 0,
16874 0x0 }, /* _POOL32A0~*(61) */
16875 { instruction , 0 , 0 , 32,
16876 0xfc0003ff, 0x200001f0, &NMD::DMTGC0 , 0,
16877 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16878 { reserved_block , 0 , 0 , 32,
16879 0xfc0003ff, 0x200001f8, 0 , 0,
16880 0x0 }, /* _POOL32A0~*(63) */
16881 { reserved_block , 0 , 0 , 32,
16882 0xfc0003ff, 0x20000200, 0 , 0,
16883 0x0 }, /* _POOL32A0~*(64) */
16884 { reserved_block , 0 , 0 , 32,
16885 0xfc0003ff, 0x20000208, 0 , 0,
16886 0x0 }, /* _POOL32A0~*(65) */
16887 { pool , P_CMOVE , 2 , 32,
16888 0xfc0003ff, 0x20000210, 0 , 0,
16889 0x0 }, /* P.CMOVE */
16890 { reserved_block , 0 , 0 , 32,
16891 0xfc0003ff, 0x20000218, 0 , 0,
16892 0x0 }, /* _POOL32A0~*(67) */
16893 { reserved_block , 0 , 0 , 32,
16894 0xfc0003ff, 0x20000220, 0 , 0,
16895 0x0 }, /* _POOL32A0~*(68) */
16896 { instruction , 0 , 0 , 32,
16897 0xfc0003ff, 0x20000228, &NMD::FORK , 0,
16898 MT_ }, /* FORK */
16899 { instruction , 0 , 0 , 32,
16900 0xfc0003ff, 0x20000230, &NMD::MFTR , 0,
16901 MT_ }, /* MFTR */
16902 { instruction , 0 , 0 , 32,
16903 0xfc0003ff, 0x20000238, &NMD::MFHTR , 0,
16904 MT_ }, /* MFHTR */
16905 { reserved_block , 0 , 0 , 32,
16906 0xfc0003ff, 0x20000240, 0 , 0,
16907 0x0 }, /* _POOL32A0~*(72) */
16908 { reserved_block , 0 , 0 , 32,
16909 0xfc0003ff, 0x20000248, 0 , 0,
16910 0x0 }, /* _POOL32A0~*(73) */
16911 { instruction , 0 , 0 , 32,
16912 0xfc0003ff, 0x20000250, &NMD::AND_32_ , 0,
16913 0x0 }, /* AND[32] */
16914 { reserved_block , 0 , 0 , 32,
16915 0xfc0003ff, 0x20000258, 0 , 0,
16916 0x0 }, /* _POOL32A0~*(75) */
16917 { reserved_block , 0 , 0 , 32,
16918 0xfc0003ff, 0x20000260, 0 , 0,
16919 0x0 }, /* _POOL32A0~*(76) */
16920 { instruction , 0 , 0 , 32,
16921 0xfc0003ff, 0x20000268, &NMD::YIELD , 0,
16922 MT_ }, /* YIELD */
16923 { instruction , 0 , 0 , 32,
16924 0xfc0003ff, 0x20000270, &NMD::MTTR , 0,
16925 MT_ }, /* MTTR */
16926 { instruction , 0 , 0 , 32,
16927 0xfc0003ff, 0x20000278, &NMD::MTHTR , 0,
16928 MT_ }, /* MTHTR */
16929 { reserved_block , 0 , 0 , 32,
16930 0xfc0003ff, 0x20000280, 0 , 0,
16931 0x0 }, /* _POOL32A0~*(80) */
16932 { reserved_block , 0 , 0 , 32,
16933 0xfc0003ff, 0x20000288, 0 , 0,
16934 0x0 }, /* _POOL32A0~*(81) */
16935 { instruction , 0 , 0 , 32,
16936 0xfc0003ff, 0x20000290, &NMD::OR_32_ , 0,
16937 0x0 }, /* OR[32] */
16938 { reserved_block , 0 , 0 , 32,
16939 0xfc0003ff, 0x20000298, 0 , 0,
16940 0x0 }, /* _POOL32A0~*(83) */
16941 { reserved_block , 0 , 0 , 32,
16942 0xfc0003ff, 0x200002a0, 0 , 0,
16943 0x0 }, /* _POOL32A0~*(84) */
16944 { reserved_block , 0 , 0 , 32,
16945 0xfc0003ff, 0x200002a8, 0 , 0,
16946 0x0 }, /* _POOL32A0~*(85) */
16947 { pool , P_MT_VPE , 8 , 32,
16948 0xfc0003ff, 0x200002b0, 0 , 0,
16949 0x0 }, /* P.MT_VPE */
16950 { reserved_block , 0 , 0 , 32,
16951 0xfc0003ff, 0x200002b8, 0 , 0,
16952 0x0 }, /* _POOL32A0~*(87) */
16953 { reserved_block , 0 , 0 , 32,
16954 0xfc0003ff, 0x200002c0, 0 , 0,
16955 0x0 }, /* _POOL32A0~*(88) */
16956 { reserved_block , 0 , 0 , 32,
16957 0xfc0003ff, 0x200002c8, 0 , 0,
16958 0x0 }, /* _POOL32A0~*(89) */
16959 { instruction , 0 , 0 , 32,
16960 0xfc0003ff, 0x200002d0, &NMD::NOR , 0,
16961 0x0 }, /* NOR */
16962 { reserved_block , 0 , 0 , 32,
16963 0xfc0003ff, 0x200002d8, 0 , 0,
16964 0x0 }, /* _POOL32A0~*(91) */
16965 { reserved_block , 0 , 0 , 32,
16966 0xfc0003ff, 0x200002e0, 0 , 0,
16967 0x0 }, /* _POOL32A0~*(92) */
16968 { reserved_block , 0 , 0 , 32,
16969 0xfc0003ff, 0x200002e8, 0 , 0,
16970 0x0 }, /* _POOL32A0~*(93) */
16971 { reserved_block , 0 , 0 , 32,
16972 0xfc0003ff, 0x200002f0, 0 , 0,
16973 0x0 }, /* _POOL32A0~*(94) */
16974 { reserved_block , 0 , 0 , 32,
16975 0xfc0003ff, 0x200002f8, 0 , 0,
16976 0x0 }, /* _POOL32A0~*(95) */
16977 { reserved_block , 0 , 0 , 32,
16978 0xfc0003ff, 0x20000300, 0 , 0,
16979 0x0 }, /* _POOL32A0~*(96) */
16980 { reserved_block , 0 , 0 , 32,
16981 0xfc0003ff, 0x20000308, 0 , 0,
16982 0x0 }, /* _POOL32A0~*(97) */
16983 { instruction , 0 , 0 , 32,
16984 0xfc0003ff, 0x20000310, &NMD::XOR_32_ , 0,
16985 0x0 }, /* XOR[32] */
16986 { reserved_block , 0 , 0 , 32,
16987 0xfc0003ff, 0x20000318, 0 , 0,
16988 0x0 }, /* _POOL32A0~*(99) */
16989 { reserved_block , 0 , 0 , 32,
16990 0xfc0003ff, 0x20000320, 0 , 0,
16991 0x0 }, /* _POOL32A0~*(100) */
16992 { reserved_block , 0 , 0 , 32,
16993 0xfc0003ff, 0x20000328, 0 , 0,
16994 0x0 }, /* _POOL32A0~*(101) */
16995 { reserved_block , 0 , 0 , 32,
16996 0xfc0003ff, 0x20000330, 0 , 0,
16997 0x0 }, /* _POOL32A0~*(102) */
16998 { reserved_block , 0 , 0 , 32,
16999 0xfc0003ff, 0x20000338, 0 , 0,
17000 0x0 }, /* _POOL32A0~*(103) */
17001 { reserved_block , 0 , 0 , 32,
17002 0xfc0003ff, 0x20000340, 0 , 0,
17003 0x0 }, /* _POOL32A0~*(104) */
17004 { reserved_block , 0 , 0 , 32,
17005 0xfc0003ff, 0x20000348, 0 , 0,
17006 0x0 }, /* _POOL32A0~*(105) */
17007 { instruction , 0 , 0 , 32,
17008 0xfc0003ff, 0x20000350, &NMD::SLT , 0,
17009 0x0 }, /* SLT */
17010 { reserved_block , 0 , 0 , 32,
17011 0xfc0003ff, 0x20000358, 0 , 0,
17012 0x0 }, /* _POOL32A0~*(107) */
17013 { reserved_block , 0 , 0 , 32,
17014 0xfc0003ff, 0x20000360, 0 , 0,
17015 0x0 }, /* _POOL32A0~*(108) */
17016 { reserved_block , 0 , 0 , 32,
17017 0xfc0003ff, 0x20000368, 0 , 0,
17018 0x0 }, /* _POOL32A0~*(109) */
17019 { reserved_block , 0 , 0 , 32,
17020 0xfc0003ff, 0x20000370, 0 , 0,
17021 0x0 }, /* _POOL32A0~*(110) */
17022 { reserved_block , 0 , 0 , 32,
17023 0xfc0003ff, 0x20000378, 0 , 0,
17024 0x0 }, /* _POOL32A0~*(111) */
17025 { reserved_block , 0 , 0 , 32,
17026 0xfc0003ff, 0x20000380, 0 , 0,
17027 0x0 }, /* _POOL32A0~*(112) */
17028 { reserved_block , 0 , 0 , 32,
17029 0xfc0003ff, 0x20000388, 0 , 0,
17030 0x0 }, /* _POOL32A0~*(113) */
17031 { pool , P_SLTU , 2 , 32,
17032 0xfc0003ff, 0x20000390, 0 , 0,
17033 0x0 }, /* P.SLTU */
17034 { reserved_block , 0 , 0 , 32,
17035 0xfc0003ff, 0x20000398, 0 , 0,
17036 0x0 }, /* _POOL32A0~*(115) */
17037 { reserved_block , 0 , 0 , 32,
17038 0xfc0003ff, 0x200003a0, 0 , 0,
17039 0x0 }, /* _POOL32A0~*(116) */
17040 { reserved_block , 0 , 0 , 32,
17041 0xfc0003ff, 0x200003a8, 0 , 0,
17042 0x0 }, /* _POOL32A0~*(117) */
17043 { reserved_block , 0 , 0 , 32,
17044 0xfc0003ff, 0x200003b0, 0 , 0,
17045 0x0 }, /* _POOL32A0~*(118) */
17046 { reserved_block , 0 , 0 , 32,
17047 0xfc0003ff, 0x200003b8, 0 , 0,
17048 0x0 }, /* _POOL32A0~*(119) */
17049 { reserved_block , 0 , 0 , 32,
17050 0xfc0003ff, 0x200003c0, 0 , 0,
17051 0x0 }, /* _POOL32A0~*(120) */
17052 { reserved_block , 0 , 0 , 32,
17053 0xfc0003ff, 0x200003c8, 0 , 0,
17054 0x0 }, /* _POOL32A0~*(121) */
17055 { instruction , 0 , 0 , 32,
17056 0xfc0003ff, 0x200003d0, &NMD::SOV , 0,
17057 0x0 }, /* SOV */
17058 { reserved_block , 0 , 0 , 32,
17059 0xfc0003ff, 0x200003d8, 0 , 0,
17060 0x0 }, /* _POOL32A0~*(123) */
17061 { reserved_block , 0 , 0 , 32,
17062 0xfc0003ff, 0x200003e0, 0 , 0,
17063 0x0 }, /* _POOL32A0~*(124) */
17064 { reserved_block , 0 , 0 , 32,
17065 0xfc0003ff, 0x200003e8, 0 , 0,
17066 0x0 }, /* _POOL32A0~*(125) */
17067 { reserved_block , 0 , 0 , 32,
17068 0xfc0003ff, 0x200003f0, 0 , 0,
17069 0x0 }, /* _POOL32A0~*(126) */
17070 { reserved_block , 0 , 0 , 32,
17071 0xfc0003ff, 0x200003f8, 0 , 0,
17072 0x0 }, /* _POOL32A0~*(127) */
17073 };
17074
17075
17076 NMD::Pool NMD::ADDQ__S__PH[2] = {
17077 { instruction , 0 , 0 , 32,
17078 0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH , 0,
17079 DSP_ }, /* ADDQ.PH */
17080 { instruction , 0 , 0 , 32,
17081 0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH , 0,
17082 DSP_ }, /* ADDQ_S.PH */
17083 };
17084
17085
17086 NMD::Pool NMD::MUL__S__PH[2] = {
17087 { instruction , 0 , 0 , 32,
17088 0xfc0007ff, 0x2000002d, &NMD::MUL_PH , 0,
17089 DSP_ }, /* MUL.PH */
17090 { instruction , 0 , 0 , 32,
17091 0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH , 0,
17092 DSP_ }, /* MUL_S.PH */
17093 };
17094
17095
17096 NMD::Pool NMD::ADDQH__R__PH[2] = {
17097 { instruction , 0 , 0 , 32,
17098 0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH , 0,
17099 DSP_ }, /* ADDQH.PH */
17100 { instruction , 0 , 0 , 32,
17101 0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH , 0,
17102 DSP_ }, /* ADDQH_R.PH */
17103 };
17104
17105
17106 NMD::Pool NMD::ADDQH__R__W[2] = {
17107 { instruction , 0 , 0 , 32,
17108 0xfc0007ff, 0x2000008d, &NMD::ADDQH_W , 0,
17109 DSP_ }, /* ADDQH.W */
17110 { instruction , 0 , 0 , 32,
17111 0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W , 0,
17112 DSP_ }, /* ADDQH_R.W */
17113 };
17114
17115
17116 NMD::Pool NMD::ADDU__S__QB[2] = {
17117 { instruction , 0 , 0 , 32,
17118 0xfc0007ff, 0x200000cd, &NMD::ADDU_QB , 0,
17119 DSP_ }, /* ADDU.QB */
17120 { instruction , 0 , 0 , 32,
17121 0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB , 0,
17122 DSP_ }, /* ADDU_S.QB */
17123 };
17124
17125
17126 NMD::Pool NMD::ADDU__S__PH[2] = {
17127 { instruction , 0 , 0 , 32,
17128 0xfc0007ff, 0x2000010d, &NMD::ADDU_PH , 0,
17129 DSP_ }, /* ADDU.PH */
17130 { instruction , 0 , 0 , 32,
17131 0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH , 0,
17132 DSP_ }, /* ADDU_S.PH */
17133 };
17134
17135
17136 NMD::Pool NMD::ADDUH__R__QB[2] = {
17137 { instruction , 0 , 0 , 32,
17138 0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB , 0,
17139 DSP_ }, /* ADDUH.QB */
17140 { instruction , 0 , 0 , 32,
17141 0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB , 0,
17142 DSP_ }, /* ADDUH_R.QB */
17143 };
17144
17145
17146 NMD::Pool NMD::SHRAV__R__PH[2] = {
17147 { instruction , 0 , 0 , 32,
17148 0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH , 0,
17149 DSP_ }, /* SHRAV.PH */
17150 { instruction , 0 , 0 , 32,
17151 0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH , 0,
17152 DSP_ }, /* SHRAV_R.PH */
17153 };
17154
17155
17156 NMD::Pool NMD::SHRAV__R__QB[2] = {
17157 { instruction , 0 , 0 , 32,
17158 0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB , 0,
17159 DSP_ }, /* SHRAV.QB */
17160 { instruction , 0 , 0 , 32,
17161 0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB , 0,
17162 DSP_ }, /* SHRAV_R.QB */
17163 };
17164
17165
17166 NMD::Pool NMD::SUBQ__S__PH[2] = {
17167 { instruction , 0 , 0 , 32,
17168 0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH , 0,
17169 DSP_ }, /* SUBQ.PH */
17170 { instruction , 0 , 0 , 32,
17171 0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH , 0,
17172 DSP_ }, /* SUBQ_S.PH */
17173 };
17174
17175
17176 NMD::Pool NMD::SUBQH__R__PH[2] = {
17177 { instruction , 0 , 0 , 32,
17178 0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH , 0,
17179 DSP_ }, /* SUBQH.PH */
17180 { instruction , 0 , 0 , 32,
17181 0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH , 0,
17182 DSP_ }, /* SUBQH_R.PH */
17183 };
17184
17185
17186 NMD::Pool NMD::SUBQH__R__W[2] = {
17187 { instruction , 0 , 0 , 32,
17188 0xfc0007ff, 0x2000028d, &NMD::SUBQH_W , 0,
17189 DSP_ }, /* SUBQH.W */
17190 { instruction , 0 , 0 , 32,
17191 0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W , 0,
17192 DSP_ }, /* SUBQH_R.W */
17193 };
17194
17195
17196 NMD::Pool NMD::SUBU__S__QB[2] = {
17197 { instruction , 0 , 0 , 32,
17198 0xfc0007ff, 0x200002cd, &NMD::SUBU_QB , 0,
17199 DSP_ }, /* SUBU.QB */
17200 { instruction , 0 , 0 , 32,
17201 0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB , 0,
17202 DSP_ }, /* SUBU_S.QB */
17203 };
17204
17205
17206 NMD::Pool NMD::SUBU__S__PH[2] = {
17207 { instruction , 0 , 0 , 32,
17208 0xfc0007ff, 0x2000030d, &NMD::SUBU_PH , 0,
17209 DSP_ }, /* SUBU.PH */
17210 { instruction , 0 , 0 , 32,
17211 0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH , 0,
17212 DSP_ }, /* SUBU_S.PH */
17213 };
17214
17215
17216 NMD::Pool NMD::SHRA__R__PH[2] = {
17217 { instruction , 0 , 0 , 32,
17218 0xfc0007ff, 0x20000335, &NMD::SHRA_PH , 0,
17219 DSP_ }, /* SHRA.PH */
17220 { instruction , 0 , 0 , 32,
17221 0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH , 0,
17222 DSP_ }, /* SHRA_R.PH */
17223 };
17224
17225
17226 NMD::Pool NMD::SUBUH__R__QB[2] = {
17227 { instruction , 0 , 0 , 32,
17228 0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB , 0,
17229 DSP_ }, /* SUBUH.QB */
17230 { instruction , 0 , 0 , 32,
17231 0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB , 0,
17232 DSP_ }, /* SUBUH_R.QB */
17233 };
17234
17235
17236 NMD::Pool NMD::SHLLV__S__PH[2] = {
17237 { instruction , 0 , 0 , 32,
17238 0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH , 0,
17239 DSP_ }, /* SHLLV.PH */
17240 { instruction , 0 , 0 , 32,
17241 0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH , 0,
17242 DSP_ }, /* SHLLV_S.PH */
17243 };
17244
17245
17246 NMD::Pool NMD::SHLL__S__PH[4] = {
17247 { instruction , 0 , 0 , 32,
17248 0xfc000fff, 0x200003b5, &NMD::SHLL_PH , 0,
17249 DSP_ }, /* SHLL.PH */
17250 { reserved_block , 0 , 0 , 32,
17251 0xfc000fff, 0x200007b5, 0 , 0,
17252 0x0 }, /* SHLL[_S].PH~*(1) */
17253 { instruction , 0 , 0 , 32,
17254 0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH , 0,
17255 DSP_ }, /* SHLL_S.PH */
17256 { reserved_block , 0 , 0 , 32,
17257 0xfc000fff, 0x20000fb5, 0 , 0,
17258 0x0 }, /* SHLL[_S].PH~*(3) */
17259 };
17260
17261
17262 NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
17263 { instruction , 0 , 0 , 32,
17264 0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W , 0,
17265 DSP_ }, /* PRECR_SRA.PH.W */
17266 { instruction , 0 , 0 , 32,
17267 0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
17268 DSP_ }, /* PRECR_SRA_R.PH.W */
17269 };
17270
17271
17272 NMD::Pool NMD::_POOL32A5[128] = {
17273 { instruction , 0 , 0 , 32,
17274 0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH , 0,
17275 DSP_ }, /* CMP.EQ.PH */
17276 { pool , ADDQ__S__PH , 2 , 32,
17277 0xfc0003ff, 0x2000000d, 0 , 0,
17278 0x0 }, /* ADDQ[_S].PH */
17279 { reserved_block , 0 , 0 , 32,
17280 0xfc0003ff, 0x20000015, 0 , 0,
17281 0x0 }, /* _POOL32A5~*(2) */
17282 { instruction , 0 , 0 , 32,
17283 0xfc0003ff, 0x2000001d, &NMD::SHILO , 0,
17284 DSP_ }, /* SHILO */
17285 { instruction , 0 , 0 , 32,
17286 0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL , 0,
17287 DSP_ }, /* MULEQ_S.W.PHL */
17288 { pool , MUL__S__PH , 2 , 32,
17289 0xfc0003ff, 0x2000002d, 0 , 0,
17290 0x0 }, /* MUL[_S].PH */
17291 { reserved_block , 0 , 0 , 32,
17292 0xfc0003ff, 0x20000035, 0 , 0,
17293 0x0 }, /* _POOL32A5~*(6) */
17294 { instruction , 0 , 0 , 32,
17295 0xfc0003ff, 0x2000003d, &NMD::REPL_PH , 0,
17296 DSP_ }, /* REPL.PH */
17297 { instruction , 0 , 0 , 32,
17298 0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH , 0,
17299 DSP_ }, /* CMP.LT.PH */
17300 { pool , ADDQH__R__PH , 2 , 32,
17301 0xfc0003ff, 0x2000004d, 0 , 0,
17302 0x0 }, /* ADDQH[_R].PH */
17303 { reserved_block , 0 , 0 , 32,
17304 0xfc0003ff, 0x20000055, 0 , 0,
17305 0x0 }, /* _POOL32A5~*(10) */
17306 { reserved_block , 0 , 0 , 32,
17307 0xfc0003ff, 0x2000005d, 0 , 0,
17308 0x0 }, /* _POOL32A5~*(11) */
17309 { instruction , 0 , 0 , 32,
17310 0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR , 0,
17311 DSP_ }, /* MULEQ_S.W.PHR */
17312 { instruction , 0 , 0 , 32,
17313 0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH , 0,
17314 DSP_ }, /* PRECR.QB.PH */
17315 { reserved_block , 0 , 0 , 32,
17316 0xfc0003ff, 0x20000075, 0 , 0,
17317 0x0 }, /* _POOL32A5~*(14) */
17318 { reserved_block , 0 , 0 , 32,
17319 0xfc0003ff, 0x2000007d, 0 , 0,
17320 0x0 }, /* _POOL32A5~*(15) */
17321 { instruction , 0 , 0 , 32,
17322 0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH , 0,
17323 DSP_ }, /* CMP.LE.PH */
17324 { pool , ADDQH__R__W , 2 , 32,
17325 0xfc0003ff, 0x2000008d, 0 , 0,
17326 0x0 }, /* ADDQH[_R].W */
17327 { instruction , 0 , 0 , 32,
17328 0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL , 0,
17329 DSP_ }, /* MULEU_S.PH.QBL */
17330 { reserved_block , 0 , 0 , 32,
17331 0xfc0003ff, 0x2000009d, 0 , 0,
17332 0x0 }, /* _POOL32A5~*(19) */
17333 { reserved_block , 0 , 0 , 32,
17334 0xfc0003ff, 0x200000a5, 0 , 0,
17335 0x0 }, /* _POOL32A5~*(20) */
17336 { instruction , 0 , 0 , 32,
17337 0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH , 0,
17338 DSP_ }, /* PRECRQ.QB.PH */
17339 { reserved_block , 0 , 0 , 32,
17340 0xfc0003ff, 0x200000b5, 0 , 0,
17341 0x0 }, /* _POOL32A5~*(22) */
17342 { reserved_block , 0 , 0 , 32,
17343 0xfc0003ff, 0x200000bd, 0 , 0,
17344 0x0 }, /* _POOL32A5~*(23) */
17345 { instruction , 0 , 0 , 32,
17346 0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB , 0,
17347 DSP_ }, /* CMPGU.EQ.QB */
17348 { pool , ADDU__S__QB , 2 , 32,
17349 0xfc0003ff, 0x200000cd, 0 , 0,
17350 0x0 }, /* ADDU[_S].QB */
17351 { instruction , 0 , 0 , 32,
17352 0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR , 0,
17353 DSP_ }, /* MULEU_S.PH.QBR */
17354 { reserved_block , 0 , 0 , 32,
17355 0xfc0003ff, 0x200000dd, 0 , 0,
17356 0x0 }, /* _POOL32A5~*(27) */
17357 { reserved_block , 0 , 0 , 32,
17358 0xfc0003ff, 0x200000e5, 0 , 0,
17359 0x0 }, /* _POOL32A5~*(28) */
17360 { instruction , 0 , 0 , 32,
17361 0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W , 0,
17362 DSP_ }, /* PRECRQ.PH.W */
17363 { reserved_block , 0 , 0 , 32,
17364 0xfc0003ff, 0x200000f5, 0 , 0,
17365 0x0 }, /* _POOL32A5~*(30) */
17366 { reserved_block , 0 , 0 , 32,
17367 0xfc0003ff, 0x200000fd, 0 , 0,
17368 0x0 }, /* _POOL32A5~*(31) */
17369 { instruction , 0 , 0 , 32,
17370 0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB , 0,
17371 DSP_ }, /* CMPGU.LT.QB */
17372 { pool , ADDU__S__PH , 2 , 32,
17373 0xfc0003ff, 0x2000010d, 0 , 0,
17374 0x0 }, /* ADDU[_S].PH */
17375 { instruction , 0 , 0 , 32,
17376 0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH , 0,
17377 DSP_ }, /* MULQ_RS.PH */
17378 { reserved_block , 0 , 0 , 32,
17379 0xfc0003ff, 0x2000011d, 0 , 0,
17380 0x0 }, /* _POOL32A5~*(35) */
17381 { reserved_block , 0 , 0 , 32,
17382 0xfc0003ff, 0x20000125, 0 , 0,
17383 0x0 }, /* _POOL32A5~*(36) */
17384 { instruction , 0 , 0 , 32,
17385 0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W , 0,
17386 DSP_ }, /* PRECRQ_RS.PH.W */
17387 { reserved_block , 0 , 0 , 32,
17388 0xfc0003ff, 0x20000135, 0 , 0,
17389 0x0 }, /* _POOL32A5~*(38) */
17390 { reserved_block , 0 , 0 , 32,
17391 0xfc0003ff, 0x2000013d, 0 , 0,
17392 0x0 }, /* _POOL32A5~*(39) */
17393 { instruction , 0 , 0 , 32,
17394 0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB , 0,
17395 DSP_ }, /* CMPGU.LE.QB */
17396 { pool , ADDUH__R__QB , 2 , 32,
17397 0xfc0003ff, 0x2000014d, 0 , 0,
17398 0x0 }, /* ADDUH[_R].QB */
17399 { instruction , 0 , 0 , 32,
17400 0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH , 0,
17401 DSP_ }, /* MULQ_S.PH */
17402 { reserved_block , 0 , 0 , 32,
17403 0xfc0003ff, 0x2000015d, 0 , 0,
17404 0x0 }, /* _POOL32A5~*(43) */
17405 { reserved_block , 0 , 0 , 32,
17406 0xfc0003ff, 0x20000165, 0 , 0,
17407 0x0 }, /* _POOL32A5~*(44) */
17408 { instruction , 0 , 0 , 32,
17409 0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH , 0,
17410 DSP_ }, /* PRECRQU_S.QB.PH */
17411 { reserved_block , 0 , 0 , 32,
17412 0xfc0003ff, 0x20000175, 0 , 0,
17413 0x0 }, /* _POOL32A5~*(46) */
17414 { reserved_block , 0 , 0 , 32,
17415 0xfc0003ff, 0x2000017d, 0 , 0,
17416 0x0 }, /* _POOL32A5~*(47) */
17417 { instruction , 0 , 0 , 32,
17418 0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB , 0,
17419 DSP_ }, /* CMPGDU.EQ.QB */
17420 { pool , SHRAV__R__PH , 2 , 32,
17421 0xfc0003ff, 0x2000018d, 0 , 0,
17422 0x0 }, /* SHRAV[_R].PH */
17423 { instruction , 0 , 0 , 32,
17424 0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W , 0,
17425 DSP_ }, /* MULQ_RS.W */
17426 { reserved_block , 0 , 0 , 32,
17427 0xfc0003ff, 0x2000019d, 0 , 0,
17428 0x0 }, /* _POOL32A5~*(51) */
17429 { reserved_block , 0 , 0 , 32,
17430 0xfc0003ff, 0x200001a5, 0 , 0,
17431 0x0 }, /* _POOL32A5~*(52) */
17432 { instruction , 0 , 0 , 32,
17433 0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH , 0,
17434 DSP_ }, /* PACKRL.PH */
17435 { reserved_block , 0 , 0 , 32,
17436 0xfc0003ff, 0x200001b5, 0 , 0,
17437 0x0 }, /* _POOL32A5~*(54) */
17438 { reserved_block , 0 , 0 , 32,
17439 0xfc0003ff, 0x200001bd, 0 , 0,
17440 0x0 }, /* _POOL32A5~*(55) */
17441 { instruction , 0 , 0 , 32,
17442 0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB , 0,
17443 DSP_ }, /* CMPGDU.LT.QB */
17444 { pool , SHRAV__R__QB , 2 , 32,
17445 0xfc0003ff, 0x200001cd, 0 , 0,
17446 0x0 }, /* SHRAV[_R].QB */
17447 { instruction , 0 , 0 , 32,
17448 0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W , 0,
17449 DSP_ }, /* MULQ_S.W */
17450 { reserved_block , 0 , 0 , 32,
17451 0xfc0003ff, 0x200001dd, 0 , 0,
17452 0x0 }, /* _POOL32A5~*(59) */
17453 { reserved_block , 0 , 0 , 32,
17454 0xfc0003ff, 0x200001e5, 0 , 0,
17455 0x0 }, /* _POOL32A5~*(60) */
17456 { instruction , 0 , 0 , 32,
17457 0xfc0003ff, 0x200001ed, &NMD::PICK_QB , 0,
17458 DSP_ }, /* PICK.QB */
17459 { reserved_block , 0 , 0 , 32,
17460 0xfc0003ff, 0x200001f5, 0 , 0,
17461 0x0 }, /* _POOL32A5~*(62) */
17462 { reserved_block , 0 , 0 , 32,
17463 0xfc0003ff, 0x200001fd, 0 , 0,
17464 0x0 }, /* _POOL32A5~*(63) */
17465 { instruction , 0 , 0 , 32,
17466 0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB , 0,
17467 DSP_ }, /* CMPGDU.LE.QB */
17468 { pool , SUBQ__S__PH , 2 , 32,
17469 0xfc0003ff, 0x2000020d, 0 , 0,
17470 0x0 }, /* SUBQ[_S].PH */
17471 { instruction , 0 , 0 , 32,
17472 0xfc0003ff, 0x20000215, &NMD::APPEND , 0,
17473 DSP_ }, /* APPEND */
17474 { reserved_block , 0 , 0 , 32,
17475 0xfc0003ff, 0x2000021d, 0 , 0,
17476 0x0 }, /* _POOL32A5~*(67) */
17477 { reserved_block , 0 , 0 , 32,
17478 0xfc0003ff, 0x20000225, 0 , 0,
17479 0x0 }, /* _POOL32A5~*(68) */
17480 { instruction , 0 , 0 , 32,
17481 0xfc0003ff, 0x2000022d, &NMD::PICK_PH , 0,
17482 DSP_ }, /* PICK.PH */
17483 { reserved_block , 0 , 0 , 32,
17484 0xfc0003ff, 0x20000235, 0 , 0,
17485 0x0 }, /* _POOL32A5~*(70) */
17486 { reserved_block , 0 , 0 , 32,
17487 0xfc0003ff, 0x2000023d, 0 , 0,
17488 0x0 }, /* _POOL32A5~*(71) */
17489 { instruction , 0 , 0 , 32,
17490 0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB , 0,
17491 DSP_ }, /* CMPU.EQ.QB */
17492 { pool , SUBQH__R__PH , 2 , 32,
17493 0xfc0003ff, 0x2000024d, 0 , 0,
17494 0x0 }, /* SUBQH[_R].PH */
17495 { instruction , 0 , 0 , 32,
17496 0xfc0003ff, 0x20000255, &NMD::PREPEND , 0,
17497 DSP_ }, /* PREPEND */
17498 { reserved_block , 0 , 0 , 32,
17499 0xfc0003ff, 0x2000025d, 0 , 0,
17500 0x0 }, /* _POOL32A5~*(75) */
17501 { reserved_block , 0 , 0 , 32,
17502 0xfc0003ff, 0x20000265, 0 , 0,
17503 0x0 }, /* _POOL32A5~*(76) */
17504 { reserved_block , 0 , 0 , 32,
17505 0xfc0003ff, 0x2000026d, 0 , 0,
17506 0x0 }, /* _POOL32A5~*(77) */
17507 { reserved_block , 0 , 0 , 32,
17508 0xfc0003ff, 0x20000275, 0 , 0,
17509 0x0 }, /* _POOL32A5~*(78) */
17510 { reserved_block , 0 , 0 , 32,
17511 0xfc0003ff, 0x2000027d, 0 , 0,
17512 0x0 }, /* _POOL32A5~*(79) */
17513 { instruction , 0 , 0 , 32,
17514 0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB , 0,
17515 DSP_ }, /* CMPU.LT.QB */
17516 { pool , SUBQH__R__W , 2 , 32,
17517 0xfc0003ff, 0x2000028d, 0 , 0,
17518 0x0 }, /* SUBQH[_R].W */
17519 { instruction , 0 , 0 , 32,
17520 0xfc0003ff, 0x20000295, &NMD::MODSUB , 0,
17521 DSP_ }, /* MODSUB */
17522 { reserved_block , 0 , 0 , 32,
17523 0xfc0003ff, 0x2000029d, 0 , 0,
17524 0x0 }, /* _POOL32A5~*(83) */
17525 { reserved_block , 0 , 0 , 32,
17526 0xfc0003ff, 0x200002a5, 0 , 0,
17527 0x0 }, /* _POOL32A5~*(84) */
17528 { reserved_block , 0 , 0 , 32,
17529 0xfc0003ff, 0x200002ad, 0 , 0,
17530 0x0 }, /* _POOL32A5~*(85) */
17531 { reserved_block , 0 , 0 , 32,
17532 0xfc0003ff, 0x200002b5, 0 , 0,
17533 0x0 }, /* _POOL32A5~*(86) */
17534 { reserved_block , 0 , 0 , 32,
17535 0xfc0003ff, 0x200002bd, 0 , 0,
17536 0x0 }, /* _POOL32A5~*(87) */
17537 { instruction , 0 , 0 , 32,
17538 0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB , 0,
17539 DSP_ }, /* CMPU.LE.QB */
17540 { pool , SUBU__S__QB , 2 , 32,
17541 0xfc0003ff, 0x200002cd, 0 , 0,
17542 0x0 }, /* SUBU[_S].QB */
17543 { instruction , 0 , 0 , 32,
17544 0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W , 0,
17545 DSP_ }, /* SHRAV_R.W */
17546 { reserved_block , 0 , 0 , 32,
17547 0xfc0003ff, 0x200002dd, 0 , 0,
17548 0x0 }, /* _POOL32A5~*(91) */
17549 { reserved_block , 0 , 0 , 32,
17550 0xfc0003ff, 0x200002e5, 0 , 0,
17551 0x0 }, /* _POOL32A5~*(92) */
17552 { reserved_block , 0 , 0 , 32,
17553 0xfc0003ff, 0x200002ed, 0 , 0,
17554 0x0 }, /* _POOL32A5~*(93) */
17555 { instruction , 0 , 0 , 32,
17556 0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W , 0,
17557 DSP_ }, /* SHRA_R.W */
17558 { reserved_block , 0 , 0 , 32,
17559 0xfc0003ff, 0x200002fd, 0 , 0,
17560 0x0 }, /* _POOL32A5~*(95) */
17561 { instruction , 0 , 0 , 32,
17562 0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W , 0,
17563 DSP_ }, /* ADDQ_S.W */
17564 { pool , SUBU__S__PH , 2 , 32,
17565 0xfc0003ff, 0x2000030d, 0 , 0,
17566 0x0 }, /* SUBU[_S].PH */
17567 { instruction , 0 , 0 , 32,
17568 0xfc0003ff, 0x20000315, &NMD::SHRLV_PH , 0,
17569 DSP_ }, /* SHRLV.PH */
17570 { reserved_block , 0 , 0 , 32,
17571 0xfc0003ff, 0x2000031d, 0 , 0,
17572 0x0 }, /* _POOL32A5~*(99) */
17573 { reserved_block , 0 , 0 , 32,
17574 0xfc0003ff, 0x20000325, 0 , 0,
17575 0x0 }, /* _POOL32A5~*(100) */
17576 { reserved_block , 0 , 0 , 32,
17577 0xfc0003ff, 0x2000032d, 0 , 0,
17578 0x0 }, /* _POOL32A5~*(101) */
17579 { pool , SHRA__R__PH , 2 , 32,
17580 0xfc0003ff, 0x20000335, 0 , 0,
17581 0x0 }, /* SHRA[_R].PH */
17582 { reserved_block , 0 , 0 , 32,
17583 0xfc0003ff, 0x2000033d, 0 , 0,
17584 0x0 }, /* _POOL32A5~*(103) */
17585 { instruction , 0 , 0 , 32,
17586 0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W , 0,
17587 DSP_ }, /* SUBQ_S.W */
17588 { pool , SUBUH__R__QB , 2 , 32,
17589 0xfc0003ff, 0x2000034d, 0 , 0,
17590 0x0 }, /* SUBUH[_R].QB */
17591 { instruction , 0 , 0 , 32,
17592 0xfc0003ff, 0x20000355, &NMD::SHRLV_QB , 0,
17593 DSP_ }, /* SHRLV.QB */
17594 { reserved_block , 0 , 0 , 32,
17595 0xfc0003ff, 0x2000035d, 0 , 0,
17596 0x0 }, /* _POOL32A5~*(107) */
17597 { reserved_block , 0 , 0 , 32,
17598 0xfc0003ff, 0x20000365, 0 , 0,
17599 0x0 }, /* _POOL32A5~*(108) */
17600 { reserved_block , 0 , 0 , 32,
17601 0xfc0003ff, 0x2000036d, 0 , 0,
17602 0x0 }, /* _POOL32A5~*(109) */
17603 { reserved_block , 0 , 0 , 32,
17604 0xfc0003ff, 0x20000375, 0 , 0,
17605 0x0 }, /* _POOL32A5~*(110) */
17606 { reserved_block , 0 , 0 , 32,
17607 0xfc0003ff, 0x2000037d, 0 , 0,
17608 0x0 }, /* _POOL32A5~*(111) */
17609 { instruction , 0 , 0 , 32,
17610 0xfc0003ff, 0x20000385, &NMD::ADDSC , 0,
17611 DSP_ }, /* ADDSC */
17612 { pool , SHLLV__S__PH , 2 , 32,
17613 0xfc0003ff, 0x2000038d, 0 , 0,
17614 0x0 }, /* SHLLV[_S].PH */
17615 { instruction , 0 , 0 , 32,
17616 0xfc0003ff, 0x20000395, &NMD::SHLLV_QB , 0,
17617 DSP_ }, /* SHLLV.QB */
17618 { reserved_block , 0 , 0 , 32,
17619 0xfc0003ff, 0x2000039d, 0 , 0,
17620 0x0 }, /* _POOL32A5~*(115) */
17621 { reserved_block , 0 , 0 , 32,
17622 0xfc0003ff, 0x200003a5, 0 , 0,
17623 0x0 }, /* _POOL32A5~*(116) */
17624 { reserved_block , 0 , 0 , 32,
17625 0xfc0003ff, 0x200003ad, 0 , 0,
17626 0x0 }, /* _POOL32A5~*(117) */
17627 { pool , SHLL__S__PH , 4 , 32,
17628 0xfc0003ff, 0x200003b5, 0 , 0,
17629 0x0 }, /* SHLL[_S].PH */
17630 { reserved_block , 0 , 0 , 32,
17631 0xfc0003ff, 0x200003bd, 0 , 0,
17632 0x0 }, /* _POOL32A5~*(119) */
17633 { instruction , 0 , 0 , 32,
17634 0xfc0003ff, 0x200003c5, &NMD::ADDWC , 0,
17635 DSP_ }, /* ADDWC */
17636 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17637 0xfc0003ff, 0x200003cd, 0 , 0,
17638 0x0 }, /* PRECR_SRA[_R].PH.W */
17639 { instruction , 0 , 0 , 32,
17640 0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W , 0,
17641 DSP_ }, /* SHLLV_S.W */
17642 { reserved_block , 0 , 0 , 32,
17643 0xfc0003ff, 0x200003dd, 0 , 0,
17644 0x0 }, /* _POOL32A5~*(123) */
17645 { reserved_block , 0 , 0 , 32,
17646 0xfc0003ff, 0x200003e5, 0 , 0,
17647 0x0 }, /* _POOL32A5~*(124) */
17648 { reserved_block , 0 , 0 , 32,
17649 0xfc0003ff, 0x200003ed, 0 , 0,
17650 0x0 }, /* _POOL32A5~*(125) */
17651 { instruction , 0 , 0 , 32,
17652 0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W , 0,
17653 DSP_ }, /* SHLL_S.W */
17654 { reserved_block , 0 , 0 , 32,
17655 0xfc0003ff, 0x200003fd, 0 , 0,
17656 0x0 }, /* _POOL32A5~*(127) */
17657 };
17658
17659
17660 NMD::Pool NMD::PP_LSX[16] = {
17661 { instruction , 0 , 0 , 32,
17662 0xfc0007ff, 0x20000007, &NMD::LBX , 0,
17663 0x0 }, /* LBX */
17664 { instruction , 0 , 0 , 32,
17665 0xfc0007ff, 0x20000087, &NMD::SBX , 0,
17666 XMMS_ }, /* SBX */
17667 { instruction , 0 , 0 , 32,
17668 0xfc0007ff, 0x20000107, &NMD::LBUX , 0,
17669 0x0 }, /* LBUX */
17670 { reserved_block , 0 , 0 , 32,
17671 0xfc0007ff, 0x20000187, 0 , 0,
17672 0x0 }, /* PP.LSX~*(3) */
17673 { instruction , 0 , 0 , 32,
17674 0xfc0007ff, 0x20000207, &NMD::LHX , 0,
17675 0x0 }, /* LHX */
17676 { instruction , 0 , 0 , 32,
17677 0xfc0007ff, 0x20000287, &NMD::SHX , 0,
17678 XMMS_ }, /* SHX */
17679 { instruction , 0 , 0 , 32,
17680 0xfc0007ff, 0x20000307, &NMD::LHUX , 0,
17681 0x0 }, /* LHUX */
17682 { instruction , 0 , 0 , 32,
17683 0xfc0007ff, 0x20000387, &NMD::LWUX , 0,
17684 MIPS64_ }, /* LWUX */
17685 { instruction , 0 , 0 , 32,
17686 0xfc0007ff, 0x20000407, &NMD::LWX , 0,
17687 0x0 }, /* LWX */
17688 { instruction , 0 , 0 , 32,
17689 0xfc0007ff, 0x20000487, &NMD::SWX , 0,
17690 XMMS_ }, /* SWX */
17691 { instruction , 0 , 0 , 32,
17692 0xfc0007ff, 0x20000507, &NMD::LWC1X , 0,
17693 CP1_ }, /* LWC1X */
17694 { instruction , 0 , 0 , 32,
17695 0xfc0007ff, 0x20000587, &NMD::SWC1X , 0,
17696 CP1_ }, /* SWC1X */
17697 { instruction , 0 , 0 , 32,
17698 0xfc0007ff, 0x20000607, &NMD::LDX , 0,
17699 MIPS64_ }, /* LDX */
17700 { instruction , 0 , 0 , 32,
17701 0xfc0007ff, 0x20000687, &NMD::SDX , 0,
17702 MIPS64_ }, /* SDX */
17703 { instruction , 0 , 0 , 32,
17704 0xfc0007ff, 0x20000707, &NMD::LDC1X , 0,
17705 CP1_ }, /* LDC1X */
17706 { instruction , 0 , 0 , 32,
17707 0xfc0007ff, 0x20000787, &NMD::SDC1X , 0,
17708 CP1_ }, /* SDC1X */
17709 };
17710
17711
17712 NMD::Pool NMD::PP_LSXS[16] = {
17713 { reserved_block , 0 , 0 , 32,
17714 0xfc0007ff, 0x20000047, 0 , 0,
17715 0x0 }, /* PP.LSXS~*(0) */
17716 { reserved_block , 0 , 0 , 32,
17717 0xfc0007ff, 0x200000c7, 0 , 0,
17718 0x0 }, /* PP.LSXS~*(1) */
17719 { reserved_block , 0 , 0 , 32,
17720 0xfc0007ff, 0x20000147, 0 , 0,
17721 0x0 }, /* PP.LSXS~*(2) */
17722 { reserved_block , 0 , 0 , 32,
17723 0xfc0007ff, 0x200001c7, 0 , 0,
17724 0x0 }, /* PP.LSXS~*(3) */
17725 { instruction , 0 , 0 , 32,
17726 0xfc0007ff, 0x20000247, &NMD::LHXS , 0,
17727 0x0 }, /* LHXS */
17728 { instruction , 0 , 0 , 32,
17729 0xfc0007ff, 0x200002c7, &NMD::SHXS , 0,
17730 XMMS_ }, /* SHXS */
17731 { instruction , 0 , 0 , 32,
17732 0xfc0007ff, 0x20000347, &NMD::LHUXS , 0,
17733 0x0 }, /* LHUXS */
17734 { instruction , 0 , 0 , 32,
17735 0xfc0007ff, 0x200003c7, &NMD::LWUXS , 0,
17736 MIPS64_ }, /* LWUXS */
17737 { instruction , 0 , 0 , 32,
17738 0xfc0007ff, 0x20000447, &NMD::LWXS_32_ , 0,
17739 0x0 }, /* LWXS[32] */
17740 { instruction , 0 , 0 , 32,
17741 0xfc0007ff, 0x200004c7, &NMD::SWXS , 0,
17742 XMMS_ }, /* SWXS */
17743 { instruction , 0 , 0 , 32,
17744 0xfc0007ff, 0x20000547, &NMD::LWC1XS , 0,
17745 CP1_ }, /* LWC1XS */
17746 { instruction , 0 , 0 , 32,
17747 0xfc0007ff, 0x200005c7, &NMD::SWC1XS , 0,
17748 CP1_ }, /* SWC1XS */
17749 { instruction , 0 , 0 , 32,
17750 0xfc0007ff, 0x20000647, &NMD::LDXS , 0,
17751 MIPS64_ }, /* LDXS */
17752 { instruction , 0 , 0 , 32,
17753 0xfc0007ff, 0x200006c7, &NMD::SDXS , 0,
17754 MIPS64_ }, /* SDXS */
17755 { instruction , 0 , 0 , 32,
17756 0xfc0007ff, 0x20000747, &NMD::LDC1XS , 0,
17757 CP1_ }, /* LDC1XS */
17758 { instruction , 0 , 0 , 32,
17759 0xfc0007ff, 0x200007c7, &NMD::SDC1XS , 0,
17760 CP1_ }, /* SDC1XS */
17761 };
17762
17763
17764 NMD::Pool NMD::P_LSX[2] = {
17765 { pool , PP_LSX , 16 , 32,
17766 0xfc00007f, 0x20000007, 0 , 0,
17767 0x0 }, /* PP.LSX */
17768 { pool , PP_LSXS , 16 , 32,
17769 0xfc00007f, 0x20000047, 0 , 0,
17770 0x0 }, /* PP.LSXS */
17771 };
17772
17773
17774 NMD::Pool NMD::POOL32Axf_1_0[4] = {
17775 { instruction , 0 , 0 , 32,
17776 0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_ , 0,
17777 DSP_ }, /* MFHI[DSP] */
17778 { instruction , 0 , 0 , 32,
17779 0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_ , 0,
17780 DSP_ }, /* MFLO[DSP] */
17781 { instruction , 0 , 0 , 32,
17782 0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_ , 0,
17783 DSP_ }, /* MTHI[DSP] */
17784 { instruction , 0 , 0 , 32,
17785 0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_ , 0,
17786 DSP_ }, /* MTLO[DSP] */
17787 };
17788
17789
17790 NMD::Pool NMD::POOL32Axf_1_1[4] = {
17791 { instruction , 0 , 0 , 32,
17792 0xfc003fff, 0x2000027f, &NMD::MTHLIP , 0,
17793 DSP_ }, /* MTHLIP */
17794 { instruction , 0 , 0 , 32,
17795 0xfc003fff, 0x2000127f, &NMD::SHILOV , 0,
17796 DSP_ }, /* SHILOV */
17797 { reserved_block , 0 , 0 , 32,
17798 0xfc003fff, 0x2000227f, 0 , 0,
17799 0x0 }, /* POOL32Axf_1_1~*(2) */
17800 { reserved_block , 0 , 0 , 32,
17801 0xfc003fff, 0x2000327f, 0 , 0,
17802 0x0 }, /* POOL32Axf_1_1~*(3) */
17803 };
17804
17805
17806 NMD::Pool NMD::POOL32Axf_1_3[4] = {
17807 { instruction , 0 , 0 , 32,
17808 0xfc003fff, 0x2000067f, &NMD::RDDSP , 0,
17809 DSP_ }, /* RDDSP */
17810 { instruction , 0 , 0 , 32,
17811 0xfc003fff, 0x2000167f, &NMD::WRDSP , 0,
17812 DSP_ }, /* WRDSP */
17813 { instruction , 0 , 0 , 32,
17814 0xfc003fff, 0x2000267f, &NMD::EXTP , 0,
17815 DSP_ }, /* EXTP */
17816 { instruction , 0 , 0 , 32,
17817 0xfc003fff, 0x2000367f, &NMD::EXTPDP , 0,
17818 DSP_ }, /* EXTPDP */
17819 };
17820
17821
17822 NMD::Pool NMD::POOL32Axf_1_4[2] = {
17823 { instruction , 0 , 0 , 32,
17824 0xfc001fff, 0x2000087f, &NMD::SHLL_QB , 0,
17825 DSP_ }, /* SHLL.QB */
17826 { instruction , 0 , 0 , 32,
17827 0xfc001fff, 0x2000187f, &NMD::SHRL_QB , 0,
17828 DSP_ }, /* SHRL.QB */
17829 };
17830
17831
17832 NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
17833 { instruction , 0 , 0 , 32,
17834 0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR , 0,
17835 DSP_ }, /* MAQ_S.W.PHR */
17836 { instruction , 0 , 0 , 32,
17837 0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR , 0,
17838 DSP_ }, /* MAQ_SA.W.PHR */
17839 };
17840
17841
17842 NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
17843 { instruction , 0 , 0 , 32,
17844 0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL , 0,
17845 DSP_ }, /* MAQ_S.W.PHL */
17846 { instruction , 0 , 0 , 32,
17847 0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL , 0,
17848 DSP_ }, /* MAQ_SA.W.PHL */
17849 };
17850
17851
17852 NMD::Pool NMD::POOL32Axf_1_5[2] = {
17853 { pool , MAQ_S_A__W_PHR , 2 , 32,
17854 0xfc001fff, 0x20000a7f, 0 , 0,
17855 0x0 }, /* MAQ_S[A].W.PHR */
17856 { pool , MAQ_S_A__W_PHL , 2 , 32,
17857 0xfc001fff, 0x20001a7f, 0 , 0,
17858 0x0 }, /* MAQ_S[A].W.PHL */
17859 };
17860
17861
17862 NMD::Pool NMD::POOL32Axf_1_7[4] = {
17863 { instruction , 0 , 0 , 32,
17864 0xfc003fff, 0x20000e7f, &NMD::EXTR_W , 0,
17865 DSP_ }, /* EXTR.W */
17866 { instruction , 0 , 0 , 32,
17867 0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W , 0,
17868 DSP_ }, /* EXTR_R.W */
17869 { instruction , 0 , 0 , 32,
17870 0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W , 0,
17871 DSP_ }, /* EXTR_RS.W */
17872 { instruction , 0 , 0 , 32,
17873 0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H , 0,
17874 DSP_ }, /* EXTR_S.H */
17875 };
17876
17877
17878 NMD::Pool NMD::POOL32Axf_1[8] = {
17879 { pool , POOL32Axf_1_0 , 4 , 32,
17880 0xfc000fff, 0x2000007f, 0 , 0,
17881 0x0 }, /* POOL32Axf_1_0 */
17882 { pool , POOL32Axf_1_1 , 4 , 32,
17883 0xfc000fff, 0x2000027f, 0 , 0,
17884 0x0 }, /* POOL32Axf_1_1 */
17885 { reserved_block , 0 , 0 , 32,
17886 0xfc000fff, 0x2000047f, 0 , 0,
17887 0x0 }, /* POOL32Axf_1~*(2) */
17888 { pool , POOL32Axf_1_3 , 4 , 32,
17889 0xfc000fff, 0x2000067f, 0 , 0,
17890 0x0 }, /* POOL32Axf_1_3 */
17891 { pool , POOL32Axf_1_4 , 2 , 32,
17892 0xfc000fff, 0x2000087f, 0 , 0,
17893 0x0 }, /* POOL32Axf_1_4 */
17894 { pool , POOL32Axf_1_5 , 2 , 32,
17895 0xfc000fff, 0x20000a7f, 0 , 0,
17896 0x0 }, /* POOL32Axf_1_5 */
17897 { reserved_block , 0 , 0 , 32,
17898 0xfc000fff, 0x20000c7f, 0 , 0,
17899 0x0 }, /* POOL32Axf_1~*(6) */
17900 { pool , POOL32Axf_1_7 , 4 , 32,
17901 0xfc000fff, 0x20000e7f, 0 , 0,
17902 0x0 }, /* POOL32Axf_1_7 */
17903 };
17904
17905
17906 NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
17907 { instruction , 0 , 0 , 32,
17908 0xfc003fff, 0x200000bf, &NMD::DPA_W_PH , 0,
17909 DSP_ }, /* DPA.W.PH */
17910 { instruction , 0 , 0 , 32,
17911 0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH , 0,
17912 DSP_ }, /* DPAQ_S.W.PH */
17913 { instruction , 0 , 0 , 32,
17914 0xfc003fff, 0x200004bf, &NMD::DPS_W_PH , 0,
17915 DSP_ }, /* DPS.W.PH */
17916 { instruction , 0 , 0 , 32,
17917 0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH , 0,
17918 DSP_ }, /* DPSQ_S.W.PH */
17919 { reserved_block , 0 , 0 , 32,
17920 0xfc003fff, 0x200008bf, 0 , 0,
17921 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17922 { instruction , 0 , 0 , 32,
17923 0xfc003fff, 0x20000abf, &NMD::MADD_DSP_ , 0,
17924 DSP_ }, /* MADD[DSP] */
17925 { instruction , 0 , 0 , 32,
17926 0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_ , 0,
17927 DSP_ }, /* MULT[DSP] */
17928 { instruction , 0 , 0 , 32,
17929 0xfc003fff, 0x20000ebf, &NMD::EXTRV_W , 0,
17930 DSP_ }, /* EXTRV.W */
17931 };
17932
17933
17934 NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
17935 { instruction , 0 , 0 , 32,
17936 0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH , 0,
17937 DSP_ }, /* DPAX.W.PH */
17938 { instruction , 0 , 0 , 32,
17939 0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W , 0,
17940 DSP_ }, /* DPAQ_SA.L.W */
17941 { instruction , 0 , 0 , 32,
17942 0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH , 0,
17943 DSP_ }, /* DPSX.W.PH */
17944 { instruction , 0 , 0 , 32,
17945 0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W , 0,
17946 DSP_ }, /* DPSQ_SA.L.W */
17947 { reserved_block , 0 , 0 , 32,
17948 0xfc003fff, 0x200018bf, 0 , 0,
17949 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17950 { instruction , 0 , 0 , 32,
17951 0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_ , 0,
17952 DSP_ }, /* MADDU[DSP] */
17953 { instruction , 0 , 0 , 32,
17954 0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_ , 0,
17955 DSP_ }, /* MULTU[DSP] */
17956 { instruction , 0 , 0 , 32,
17957 0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W , 0,
17958 DSP_ }, /* EXTRV_R.W */
17959 };
17960
17961
17962 NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
17963 { instruction , 0 , 0 , 32,
17964 0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL , 0,
17965 DSP_ }, /* DPAU.H.QBL */
17966 { instruction , 0 , 0 , 32,
17967 0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH , 0,
17968 DSP_ }, /* DPAQX_S.W.PH */
17969 { instruction , 0 , 0 , 32,
17970 0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL , 0,
17971 DSP_ }, /* DPSU.H.QBL */
17972 { instruction , 0 , 0 , 32,
17973 0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH , 0,
17974 DSP_ }, /* DPSQX_S.W.PH */
17975 { instruction , 0 , 0 , 32,
17976 0xfc003fff, 0x200028bf, &NMD::EXTPV , 0,
17977 DSP_ }, /* EXTPV */
17978 { instruction , 0 , 0 , 32,
17979 0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_ , 0,
17980 DSP_ }, /* MSUB[DSP] */
17981 { instruction , 0 , 0 , 32,
17982 0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH , 0,
17983 DSP_ }, /* MULSA.W.PH */
17984 { instruction , 0 , 0 , 32,
17985 0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W , 0,
17986 DSP_ }, /* EXTRV_RS.W */
17987 };
17988
17989
17990 NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
17991 { instruction , 0 , 0 , 32,
17992 0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR , 0,
17993 DSP_ }, /* DPAU.H.QBR */
17994 { instruction , 0 , 0 , 32,
17995 0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH , 0,
17996 DSP_ }, /* DPAQX_SA.W.PH */
17997 { instruction , 0 , 0 , 32,
17998 0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR , 0,
17999 DSP_ }, /* DPSU.H.QBR */
18000 { instruction , 0 , 0 , 32,
18001 0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH , 0,
18002 DSP_ }, /* DPSQX_SA.W.PH */
18003 { instruction , 0 , 0 , 32,
18004 0xfc003fff, 0x200038bf, &NMD::EXTPDPV , 0,
18005 DSP_ }, /* EXTPDPV */
18006 { instruction , 0 , 0 , 32,
18007 0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_ , 0,
18008 DSP_ }, /* MSUBU[DSP] */
18009 { instruction , 0 , 0 , 32,
18010 0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH , 0,
18011 DSP_ }, /* MULSAQ_S.W.PH */
18012 { instruction , 0 , 0 , 32,
18013 0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H , 0,
18014 DSP_ }, /* EXTRV_S.H */
18015 };
18016
18017
18018 NMD::Pool NMD::POOL32Axf_2[4] = {
18019 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
18020 0xfc0031ff, 0x200000bf, 0 , 0,
18021 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
18022 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
18023 0xfc0031ff, 0x200010bf, 0 , 0,
18024 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
18025 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
18026 0xfc0031ff, 0x200020bf, 0 , 0,
18027 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
18028 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
18029 0xfc0031ff, 0x200030bf, 0 , 0,
18030 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
18031 };
18032
18033
18034 NMD::Pool NMD::POOL32Axf_4[128] = {
18035 { instruction , 0 , 0 , 32,
18036 0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB , 0,
18037 DSP_ }, /* ABSQ_S.QB */
18038 { instruction , 0 , 0 , 32,
18039 0xfc00ffff, 0x2000033f, &NMD::REPLV_PH , 0,
18040 DSP_ }, /* REPLV.PH */
18041 { reserved_block , 0 , 0 , 32,
18042 0xfc00ffff, 0x2000053f, 0 , 0,
18043 0x0 }, /* POOL32Axf_4~*(2) */
18044 { reserved_block , 0 , 0 , 32,
18045 0xfc00ffff, 0x2000073f, 0 , 0,
18046 0x0 }, /* POOL32Axf_4~*(3) */
18047 { reserved_block , 0 , 0 , 32,
18048 0xfc00ffff, 0x2000093f, 0 , 0,
18049 0x0 }, /* POOL32Axf_4~*(4) */
18050 { reserved_block , 0 , 0 , 32,
18051 0xfc00ffff, 0x20000b3f, 0 , 0,
18052 0x0 }, /* POOL32Axf_4~*(5) */
18053 { reserved_block , 0 , 0 , 32,
18054 0xfc00ffff, 0x20000d3f, 0 , 0,
18055 0x0 }, /* POOL32Axf_4~*(6) */
18056 { reserved_block , 0 , 0 , 32,
18057 0xfc00ffff, 0x20000f3f, 0 , 0,
18058 0x0 }, /* POOL32Axf_4~*(7) */
18059 { instruction , 0 , 0 , 32,
18060 0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH , 0,
18061 DSP_ }, /* ABSQ_S.PH */
18062 { instruction , 0 , 0 , 32,
18063 0xfc00ffff, 0x2000133f, &NMD::REPLV_QB , 0,
18064 DSP_ }, /* REPLV.QB */
18065 { reserved_block , 0 , 0 , 32,
18066 0xfc00ffff, 0x2000153f, 0 , 0,
18067 0x0 }, /* POOL32Axf_4~*(10) */
18068 { reserved_block , 0 , 0 , 32,
18069 0xfc00ffff, 0x2000173f, 0 , 0,
18070 0x0 }, /* POOL32Axf_4~*(11) */
18071 { reserved_block , 0 , 0 , 32,
18072 0xfc00ffff, 0x2000193f, 0 , 0,
18073 0x0 }, /* POOL32Axf_4~*(12) */
18074 { reserved_block , 0 , 0 , 32,
18075 0xfc00ffff, 0x20001b3f, 0 , 0,
18076 0x0 }, /* POOL32Axf_4~*(13) */
18077 { reserved_block , 0 , 0 , 32,
18078 0xfc00ffff, 0x20001d3f, 0 , 0,
18079 0x0 }, /* POOL32Axf_4~*(14) */
18080 { reserved_block , 0 , 0 , 32,
18081 0xfc00ffff, 0x20001f3f, 0 , 0,
18082 0x0 }, /* POOL32Axf_4~*(15) */
18083 { instruction , 0 , 0 , 32,
18084 0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W , 0,
18085 DSP_ }, /* ABSQ_S.W */
18086 { reserved_block , 0 , 0 , 32,
18087 0xfc00ffff, 0x2000233f, 0 , 0,
18088 0x0 }, /* POOL32Axf_4~*(17) */
18089 { reserved_block , 0 , 0 , 32,
18090 0xfc00ffff, 0x2000253f, 0 , 0,
18091 0x0 }, /* POOL32Axf_4~*(18) */
18092 { reserved_block , 0 , 0 , 32,
18093 0xfc00ffff, 0x2000273f, 0 , 0,
18094 0x0 }, /* POOL32Axf_4~*(19) */
18095 { reserved_block , 0 , 0 , 32,
18096 0xfc00ffff, 0x2000293f, 0 , 0,
18097 0x0 }, /* POOL32Axf_4~*(20) */
18098 { reserved_block , 0 , 0 , 32,
18099 0xfc00ffff, 0x20002b3f, 0 , 0,
18100 0x0 }, /* POOL32Axf_4~*(21) */
18101 { reserved_block , 0 , 0 , 32,
18102 0xfc00ffff, 0x20002d3f, 0 , 0,
18103 0x0 }, /* POOL32Axf_4~*(22) */
18104 { reserved_block , 0 , 0 , 32,
18105 0xfc00ffff, 0x20002f3f, 0 , 0,
18106 0x0 }, /* POOL32Axf_4~*(23) */
18107 { reserved_block , 0 , 0 , 32,
18108 0xfc00ffff, 0x2000313f, 0 , 0,
18109 0x0 }, /* POOL32Axf_4~*(24) */
18110 { reserved_block , 0 , 0 , 32,
18111 0xfc00ffff, 0x2000333f, 0 , 0,
18112 0x0 }, /* POOL32Axf_4~*(25) */
18113 { reserved_block , 0 , 0 , 32,
18114 0xfc00ffff, 0x2000353f, 0 , 0,
18115 0x0 }, /* POOL32Axf_4~*(26) */
18116 { reserved_block , 0 , 0 , 32,
18117 0xfc00ffff, 0x2000373f, 0 , 0,
18118 0x0 }, /* POOL32Axf_4~*(27) */
18119 { reserved_block , 0 , 0 , 32,
18120 0xfc00ffff, 0x2000393f, 0 , 0,
18121 0x0 }, /* POOL32Axf_4~*(28) */
18122 { reserved_block , 0 , 0 , 32,
18123 0xfc00ffff, 0x20003b3f, 0 , 0,
18124 0x0 }, /* POOL32Axf_4~*(29) */
18125 { reserved_block , 0 , 0 , 32,
18126 0xfc00ffff, 0x20003d3f, 0 , 0,
18127 0x0 }, /* POOL32Axf_4~*(30) */
18128 { reserved_block , 0 , 0 , 32,
18129 0xfc00ffff, 0x20003f3f, 0 , 0,
18130 0x0 }, /* POOL32Axf_4~*(31) */
18131 { instruction , 0 , 0 , 32,
18132 0xfc00ffff, 0x2000413f, &NMD::INSV , 0,
18133 DSP_ }, /* INSV */
18134 { reserved_block , 0 , 0 , 32,
18135 0xfc00ffff, 0x2000433f, 0 , 0,
18136 0x0 }, /* POOL32Axf_4~*(33) */
18137 { reserved_block , 0 , 0 , 32,
18138 0xfc00ffff, 0x2000453f, 0 , 0,
18139 0x0 }, /* POOL32Axf_4~*(34) */
18140 { reserved_block , 0 , 0 , 32,
18141 0xfc00ffff, 0x2000473f, 0 , 0,
18142 0x0 }, /* POOL32Axf_4~*(35) */
18143 { reserved_block , 0 , 0 , 32,
18144 0xfc00ffff, 0x2000493f, 0 , 0,
18145 0x0 }, /* POOL32Axf_4~*(36) */
18146 { instruction , 0 , 0 , 32,
18147 0xfc00ffff, 0x20004b3f, &NMD::CLO , 0,
18148 XMMS_ }, /* CLO */
18149 { instruction , 0 , 0 , 32,
18150 0xfc00ffff, 0x20004d3f, &NMD::MFC2 , 0,
18151 CP2_ }, /* MFC2 */
18152 { reserved_block , 0 , 0 , 32,
18153 0xfc00ffff, 0x20004f3f, 0 , 0,
18154 0x0 }, /* POOL32Axf_4~*(39) */
18155 { instruction , 0 , 0 , 32,
18156 0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL , 0,
18157 DSP_ }, /* PRECEQ.W.PHL */
18158 { reserved_block , 0 , 0 , 32,
18159 0xfc00ffff, 0x2000533f, 0 , 0,
18160 0x0 }, /* POOL32Axf_4~*(41) */
18161 { reserved_block , 0 , 0 , 32,
18162 0xfc00ffff, 0x2000553f, 0 , 0,
18163 0x0 }, /* POOL32Axf_4~*(42) */
18164 { reserved_block , 0 , 0 , 32,
18165 0xfc00ffff, 0x2000573f, 0 , 0,
18166 0x0 }, /* POOL32Axf_4~*(43) */
18167 { reserved_block , 0 , 0 , 32,
18168 0xfc00ffff, 0x2000593f, 0 , 0,
18169 0x0 }, /* POOL32Axf_4~*(44) */
18170 { instruction , 0 , 0 , 32,
18171 0xfc00ffff, 0x20005b3f, &NMD::CLZ , 0,
18172 XMMS_ }, /* CLZ */
18173 { instruction , 0 , 0 , 32,
18174 0xfc00ffff, 0x20005d3f, &NMD::MTC2 , 0,
18175 CP2_ }, /* MTC2 */
18176 { reserved_block , 0 , 0 , 32,
18177 0xfc00ffff, 0x20005f3f, 0 , 0,
18178 0x0 }, /* POOL32Axf_4~*(47) */
18179 { instruction , 0 , 0 , 32,
18180 0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR , 0,
18181 DSP_ }, /* PRECEQ.W.PHR */
18182 { reserved_block , 0 , 0 , 32,
18183 0xfc00ffff, 0x2000633f, 0 , 0,
18184 0x0 }, /* POOL32Axf_4~*(49) */
18185 { reserved_block , 0 , 0 , 32,
18186 0xfc00ffff, 0x2000653f, 0 , 0,
18187 0x0 }, /* POOL32Axf_4~*(50) */
18188 { reserved_block , 0 , 0 , 32,
18189 0xfc00ffff, 0x2000673f, 0 , 0,
18190 0x0 }, /* POOL32Axf_4~*(51) */
18191 { reserved_block , 0 , 0 , 32,
18192 0xfc00ffff, 0x2000693f, 0 , 0,
18193 0x0 }, /* POOL32Axf_4~*(52) */
18194 { reserved_block , 0 , 0 , 32,
18195 0xfc00ffff, 0x20006b3f, 0 , 0,
18196 0x0 }, /* POOL32Axf_4~*(53) */
18197 { instruction , 0 , 0 , 32,
18198 0xfc00ffff, 0x20006d3f, &NMD::DMFC2 , 0,
18199 CP2_ }, /* DMFC2 */
18200 { reserved_block , 0 , 0 , 32,
18201 0xfc00ffff, 0x20006f3f, 0 , 0,
18202 0x0 }, /* POOL32Axf_4~*(55) */
18203 { instruction , 0 , 0 , 32,
18204 0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL , 0,
18205 DSP_ }, /* PRECEQU.PH.QBL */
18206 { instruction , 0 , 0 , 32,
18207 0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA , 0,
18208 DSP_ }, /* PRECEQU.PH.QBLA */
18209 { reserved_block , 0 , 0 , 32,
18210 0xfc00ffff, 0x2000753f, 0 , 0,
18211 0x0 }, /* POOL32Axf_4~*(58) */
18212 { reserved_block , 0 , 0 , 32,
18213 0xfc00ffff, 0x2000773f, 0 , 0,
18214 0x0 }, /* POOL32Axf_4~*(59) */
18215 { reserved_block , 0 , 0 , 32,
18216 0xfc00ffff, 0x2000793f, 0 , 0,
18217 0x0 }, /* POOL32Axf_4~*(60) */
18218 { reserved_block , 0 , 0 , 32,
18219 0xfc00ffff, 0x20007b3f, 0 , 0,
18220 0x0 }, /* POOL32Axf_4~*(61) */
18221 { instruction , 0 , 0 , 32,
18222 0xfc00ffff, 0x20007d3f, &NMD::DMTC2 , 0,
18223 CP2_ }, /* DMTC2 */
18224 { reserved_block , 0 , 0 , 32,
18225 0xfc00ffff, 0x20007f3f, 0 , 0,
18226 0x0 }, /* POOL32Axf_4~*(63) */
18227 { reserved_block , 0 , 0 , 32,
18228 0xfc00ffff, 0x2000813f, 0 , 0,
18229 0x0 }, /* POOL32Axf_4~*(64) */
18230 { reserved_block , 0 , 0 , 32,
18231 0xfc00ffff, 0x2000833f, 0 , 0,
18232 0x0 }, /* POOL32Axf_4~*(65) */
18233 { reserved_block , 0 , 0 , 32,
18234 0xfc00ffff, 0x2000853f, 0 , 0,
18235 0x0 }, /* POOL32Axf_4~*(66) */
18236 { reserved_block , 0 , 0 , 32,
18237 0xfc00ffff, 0x2000873f, 0 , 0,
18238 0x0 }, /* POOL32Axf_4~*(67) */
18239 { reserved_block , 0 , 0 , 32,
18240 0xfc00ffff, 0x2000893f, 0 , 0,
18241 0x0 }, /* POOL32Axf_4~*(68) */
18242 { reserved_block , 0 , 0 , 32,
18243 0xfc00ffff, 0x20008b3f, 0 , 0,
18244 0x0 }, /* POOL32Axf_4~*(69) */
18245 { instruction , 0 , 0 , 32,
18246 0xfc00ffff, 0x20008d3f, &NMD::MFHC2 , 0,
18247 CP2_ }, /* MFHC2 */
18248 { reserved_block , 0 , 0 , 32,
18249 0xfc00ffff, 0x20008f3f, 0 , 0,
18250 0x0 }, /* POOL32Axf_4~*(71) */
18251 { instruction , 0 , 0 , 32,
18252 0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR , 0,
18253 DSP_ }, /* PRECEQU.PH.QBR */
18254 { instruction , 0 , 0 , 32,
18255 0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA , 0,
18256 DSP_ }, /* PRECEQU.PH.QBRA */
18257 { reserved_block , 0 , 0 , 32,
18258 0xfc00ffff, 0x2000953f, 0 , 0,
18259 0x0 }, /* POOL32Axf_4~*(74) */
18260 { reserved_block , 0 , 0 , 32,
18261 0xfc00ffff, 0x2000973f, 0 , 0,
18262 0x0 }, /* POOL32Axf_4~*(75) */
18263 { reserved_block , 0 , 0 , 32,
18264 0xfc00ffff, 0x2000993f, 0 , 0,
18265 0x0 }, /* POOL32Axf_4~*(76) */
18266 { reserved_block , 0 , 0 , 32,
18267 0xfc00ffff, 0x20009b3f, 0 , 0,
18268 0x0 }, /* POOL32Axf_4~*(77) */
18269 { instruction , 0 , 0 , 32,
18270 0xfc00ffff, 0x20009d3f, &NMD::MTHC2 , 0,
18271 CP2_ }, /* MTHC2 */
18272 { reserved_block , 0 , 0 , 32,
18273 0xfc00ffff, 0x20009f3f, 0 , 0,
18274 0x0 }, /* POOL32Axf_4~*(79) */
18275 { reserved_block , 0 , 0 , 32,
18276 0xfc00ffff, 0x2000a13f, 0 , 0,
18277 0x0 }, /* POOL32Axf_4~*(80) */
18278 { reserved_block , 0 , 0 , 32,
18279 0xfc00ffff, 0x2000a33f, 0 , 0,
18280 0x0 }, /* POOL32Axf_4~*(81) */
18281 { reserved_block , 0 , 0 , 32,
18282 0xfc00ffff, 0x2000a53f, 0 , 0,
18283 0x0 }, /* POOL32Axf_4~*(82) */
18284 { reserved_block , 0 , 0 , 32,
18285 0xfc00ffff, 0x2000a73f, 0 , 0,
18286 0x0 }, /* POOL32Axf_4~*(83) */
18287 { reserved_block , 0 , 0 , 32,
18288 0xfc00ffff, 0x2000a93f, 0 , 0,
18289 0x0 }, /* POOL32Axf_4~*(84) */
18290 { reserved_block , 0 , 0 , 32,
18291 0xfc00ffff, 0x2000ab3f, 0 , 0,
18292 0x0 }, /* POOL32Axf_4~*(85) */
18293 { reserved_block , 0 , 0 , 32,
18294 0xfc00ffff, 0x2000ad3f, 0 , 0,
18295 0x0 }, /* POOL32Axf_4~*(86) */
18296 { reserved_block , 0 , 0 , 32,
18297 0xfc00ffff, 0x2000af3f, 0 , 0,
18298 0x0 }, /* POOL32Axf_4~*(87) */
18299 { instruction , 0 , 0 , 32,
18300 0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL , 0,
18301 DSP_ }, /* PRECEU.PH.QBL */
18302 { instruction , 0 , 0 , 32,
18303 0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA , 0,
18304 DSP_ }, /* PRECEU.PH.QBLA */
18305 { reserved_block , 0 , 0 , 32,
18306 0xfc00ffff, 0x2000b53f, 0 , 0,
18307 0x0 }, /* POOL32Axf_4~*(90) */
18308 { reserved_block , 0 , 0 , 32,
18309 0xfc00ffff, 0x2000b73f, 0 , 0,
18310 0x0 }, /* POOL32Axf_4~*(91) */
18311 { reserved_block , 0 , 0 , 32,
18312 0xfc00ffff, 0x2000b93f, 0 , 0,
18313 0x0 }, /* POOL32Axf_4~*(92) */
18314 { reserved_block , 0 , 0 , 32,
18315 0xfc00ffff, 0x2000bb3f, 0 , 0,
18316 0x0 }, /* POOL32Axf_4~*(93) */
18317 { reserved_block , 0 , 0 , 32,
18318 0xfc00ffff, 0x2000bd3f, 0 , 0,
18319 0x0 }, /* POOL32Axf_4~*(94) */
18320 { reserved_block , 0 , 0 , 32,
18321 0xfc00ffff, 0x2000bf3f, 0 , 0,
18322 0x0 }, /* POOL32Axf_4~*(95) */
18323 { reserved_block , 0 , 0 , 32,
18324 0xfc00ffff, 0x2000c13f, 0 , 0,
18325 0x0 }, /* POOL32Axf_4~*(96) */
18326 { reserved_block , 0 , 0 , 32,
18327 0xfc00ffff, 0x2000c33f, 0 , 0,
18328 0x0 }, /* POOL32Axf_4~*(97) */
18329 { reserved_block , 0 , 0 , 32,
18330 0xfc00ffff, 0x2000c53f, 0 , 0,
18331 0x0 }, /* POOL32Axf_4~*(98) */
18332 { reserved_block , 0 , 0 , 32,
18333 0xfc00ffff, 0x2000c73f, 0 , 0,
18334 0x0 }, /* POOL32Axf_4~*(99) */
18335 { reserved_block , 0 , 0 , 32,
18336 0xfc00ffff, 0x2000c93f, 0 , 0,
18337 0x0 }, /* POOL32Axf_4~*(100) */
18338 { reserved_block , 0 , 0 , 32,
18339 0xfc00ffff, 0x2000cb3f, 0 , 0,
18340 0x0 }, /* POOL32Axf_4~*(101) */
18341 { instruction , 0 , 0 , 32,
18342 0xfc00ffff, 0x2000cd3f, &NMD::CFC2 , 0,
18343 CP2_ }, /* CFC2 */
18344 { reserved_block , 0 , 0 , 32,
18345 0xfc00ffff, 0x2000cf3f, 0 , 0,
18346 0x0 }, /* POOL32Axf_4~*(103) */
18347 { instruction , 0 , 0 , 32,
18348 0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR , 0,
18349 DSP_ }, /* PRECEU.PH.QBR */
18350 { instruction , 0 , 0 , 32,
18351 0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA , 0,
18352 DSP_ }, /* PRECEU.PH.QBRA */
18353 { reserved_block , 0 , 0 , 32,
18354 0xfc00ffff, 0x2000d53f, 0 , 0,
18355 0x0 }, /* POOL32Axf_4~*(106) */
18356 { reserved_block , 0 , 0 , 32,
18357 0xfc00ffff, 0x2000d73f, 0 , 0,
18358 0x0 }, /* POOL32Axf_4~*(107) */
18359 { reserved_block , 0 , 0 , 32,
18360 0xfc00ffff, 0x2000d93f, 0 , 0,
18361 0x0 }, /* POOL32Axf_4~*(108) */
18362 { reserved_block , 0 , 0 , 32,
18363 0xfc00ffff, 0x2000db3f, 0 , 0,
18364 0x0 }, /* POOL32Axf_4~*(109) */
18365 { instruction , 0 , 0 , 32,
18366 0xfc00ffff, 0x2000dd3f, &NMD::CTC2 , 0,
18367 CP2_ }, /* CTC2 */
18368 { reserved_block , 0 , 0 , 32,
18369 0xfc00ffff, 0x2000df3f, 0 , 0,
18370 0x0 }, /* POOL32Axf_4~*(111) */
18371 { reserved_block , 0 , 0 , 32,
18372 0xfc00ffff, 0x2000e13f, 0 , 0,
18373 0x0 }, /* POOL32Axf_4~*(112) */
18374 { reserved_block , 0 , 0 , 32,
18375 0xfc00ffff, 0x2000e33f, 0 , 0,
18376 0x0 }, /* POOL32Axf_4~*(113) */
18377 { reserved_block , 0 , 0 , 32,
18378 0xfc00ffff, 0x2000e53f, 0 , 0,
18379 0x0 }, /* POOL32Axf_4~*(114) */
18380 { reserved_block , 0 , 0 , 32,
18381 0xfc00ffff, 0x2000e73f, 0 , 0,
18382 0x0 }, /* POOL32Axf_4~*(115) */
18383 { reserved_block , 0 , 0 , 32,
18384 0xfc00ffff, 0x2000e93f, 0 , 0,
18385 0x0 }, /* POOL32Axf_4~*(116) */
18386 { reserved_block , 0 , 0 , 32,
18387 0xfc00ffff, 0x2000eb3f, 0 , 0,
18388 0x0 }, /* POOL32Axf_4~*(117) */
18389 { reserved_block , 0 , 0 , 32,
18390 0xfc00ffff, 0x2000ed3f, 0 , 0,
18391 0x0 }, /* POOL32Axf_4~*(118) */
18392 { reserved_block , 0 , 0 , 32,
18393 0xfc00ffff, 0x2000ef3f, 0 , 0,
18394 0x0 }, /* POOL32Axf_4~*(119) */
18395 { instruction , 0 , 0 , 32,
18396 0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB , 0,
18397 DSP_ }, /* RADDU.W.QB */
18398 { reserved_block , 0 , 0 , 32,
18399 0xfc00ffff, 0x2000f33f, 0 , 0,
18400 0x0 }, /* POOL32Axf_4~*(121) */
18401 { reserved_block , 0 , 0 , 32,
18402 0xfc00ffff, 0x2000f53f, 0 , 0,
18403 0x0 }, /* POOL32Axf_4~*(122) */
18404 { reserved_block , 0 , 0 , 32,
18405 0xfc00ffff, 0x2000f73f, 0 , 0,
18406 0x0 }, /* POOL32Axf_4~*(123) */
18407 { reserved_block , 0 , 0 , 32,
18408 0xfc00ffff, 0x2000f93f, 0 , 0,
18409 0x0 }, /* POOL32Axf_4~*(124) */
18410 { reserved_block , 0 , 0 , 32,
18411 0xfc00ffff, 0x2000fb3f, 0 , 0,
18412 0x0 }, /* POOL32Axf_4~*(125) */
18413 { reserved_block , 0 , 0 , 32,
18414 0xfc00ffff, 0x2000fd3f, 0 , 0,
18415 0x0 }, /* POOL32Axf_4~*(126) */
18416 { reserved_block , 0 , 0 , 32,
18417 0xfc00ffff, 0x2000ff3f, 0 , 0,
18418 0x0 }, /* POOL32Axf_4~*(127) */
18419 };
18420
18421
18422 NMD::Pool NMD::POOL32Axf_5_group0[32] = {
18423 { instruction , 0 , 0 , 32,
18424 0xfc00ffff, 0x2000017f, &NMD::TLBGP , 0,
18425 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18426 { instruction , 0 , 0 , 32,
18427 0xfc00ffff, 0x2000037f, &NMD::TLBP , 0,
18428 CP0_ | TLB_ }, /* TLBP */
18429 { instruction , 0 , 0 , 32,
18430 0xfc00ffff, 0x2000057f, &NMD::TLBGINV , 0,
18431 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18432 { instruction , 0 , 0 , 32,
18433 0xfc00ffff, 0x2000077f, &NMD::TLBINV , 0,
18434 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18435 { reserved_block , 0 , 0 , 32,
18436 0xfc00ffff, 0x2000097f, 0 , 0,
18437 0x0 }, /* POOL32Axf_5_group0~*(4) */
18438 { reserved_block , 0 , 0 , 32,
18439 0xfc00ffff, 0x20000b7f, 0 , 0,
18440 0x0 }, /* POOL32Axf_5_group0~*(5) */
18441 { reserved_block , 0 , 0 , 32,
18442 0xfc00ffff, 0x20000d7f, 0 , 0,
18443 0x0 }, /* POOL32Axf_5_group0~*(6) */
18444 { reserved_block , 0 , 0 , 32,
18445 0xfc00ffff, 0x20000f7f, 0 , 0,
18446 0x0 }, /* POOL32Axf_5_group0~*(7) */
18447 { instruction , 0 , 0 , 32,
18448 0xfc00ffff, 0x2000117f, &NMD::TLBGR , 0,
18449 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18450 { instruction , 0 , 0 , 32,
18451 0xfc00ffff, 0x2000137f, &NMD::TLBR , 0,
18452 CP0_ | TLB_ }, /* TLBR */
18453 { instruction , 0 , 0 , 32,
18454 0xfc00ffff, 0x2000157f, &NMD::TLBGINVF , 0,
18455 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18456 { instruction , 0 , 0 , 32,
18457 0xfc00ffff, 0x2000177f, &NMD::TLBINVF , 0,
18458 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18459 { reserved_block , 0 , 0 , 32,
18460 0xfc00ffff, 0x2000197f, 0 , 0,
18461 0x0 }, /* POOL32Axf_5_group0~*(12) */
18462 { reserved_block , 0 , 0 , 32,
18463 0xfc00ffff, 0x20001b7f, 0 , 0,
18464 0x0 }, /* POOL32Axf_5_group0~*(13) */
18465 { reserved_block , 0 , 0 , 32,
18466 0xfc00ffff, 0x20001d7f, 0 , 0,
18467 0x0 }, /* POOL32Axf_5_group0~*(14) */
18468 { reserved_block , 0 , 0 , 32,
18469 0xfc00ffff, 0x20001f7f, 0 , 0,
18470 0x0 }, /* POOL32Axf_5_group0~*(15) */
18471 { instruction , 0 , 0 , 32,
18472 0xfc00ffff, 0x2000217f, &NMD::TLBGWI , 0,
18473 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18474 { instruction , 0 , 0 , 32,
18475 0xfc00ffff, 0x2000237f, &NMD::TLBWI , 0,
18476 CP0_ | TLB_ }, /* TLBWI */
18477 { reserved_block , 0 , 0 , 32,
18478 0xfc00ffff, 0x2000257f, 0 , 0,
18479 0x0 }, /* POOL32Axf_5_group0~*(18) */
18480 { reserved_block , 0 , 0 , 32,
18481 0xfc00ffff, 0x2000277f, 0 , 0,
18482 0x0 }, /* POOL32Axf_5_group0~*(19) */
18483 { reserved_block , 0 , 0 , 32,
18484 0xfc00ffff, 0x2000297f, 0 , 0,
18485 0x0 }, /* POOL32Axf_5_group0~*(20) */
18486 { reserved_block , 0 , 0 , 32,
18487 0xfc00ffff, 0x20002b7f, 0 , 0,
18488 0x0 }, /* POOL32Axf_5_group0~*(21) */
18489 { reserved_block , 0 , 0 , 32,
18490 0xfc00ffff, 0x20002d7f, 0 , 0,
18491 0x0 }, /* POOL32Axf_5_group0~*(22) */
18492 { reserved_block , 0 , 0 , 32,
18493 0xfc00ffff, 0x20002f7f, 0 , 0,
18494 0x0 }, /* POOL32Axf_5_group0~*(23) */
18495 { instruction , 0 , 0 , 32,
18496 0xfc00ffff, 0x2000317f, &NMD::TLBGWR , 0,
18497 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18498 { instruction , 0 , 0 , 32,
18499 0xfc00ffff, 0x2000337f, &NMD::TLBWR , 0,
18500 CP0_ | TLB_ }, /* TLBWR */
18501 { reserved_block , 0 , 0 , 32,
18502 0xfc00ffff, 0x2000357f, 0 , 0,
18503 0x0 }, /* POOL32Axf_5_group0~*(26) */
18504 { reserved_block , 0 , 0 , 32,
18505 0xfc00ffff, 0x2000377f, 0 , 0,
18506 0x0 }, /* POOL32Axf_5_group0~*(27) */
18507 { reserved_block , 0 , 0 , 32,
18508 0xfc00ffff, 0x2000397f, 0 , 0,
18509 0x0 }, /* POOL32Axf_5_group0~*(28) */
18510 { reserved_block , 0 , 0 , 32,
18511 0xfc00ffff, 0x20003b7f, 0 , 0,
18512 0x0 }, /* POOL32Axf_5_group0~*(29) */
18513 { reserved_block , 0 , 0 , 32,
18514 0xfc00ffff, 0x20003d7f, 0 , 0,
18515 0x0 }, /* POOL32Axf_5_group0~*(30) */
18516 { reserved_block , 0 , 0 , 32,
18517 0xfc00ffff, 0x20003f7f, 0 , 0,
18518 0x0 }, /* POOL32Axf_5_group0~*(31) */
18519 };
18520
18521
18522 NMD::Pool NMD::POOL32Axf_5_group1[32] = {
18523 { reserved_block , 0 , 0 , 32,
18524 0xfc00ffff, 0x2000417f, 0 , 0,
18525 0x0 }, /* POOL32Axf_5_group1~*(0) */
18526 { reserved_block , 0 , 0 , 32,
18527 0xfc00ffff, 0x2000437f, 0 , 0,
18528 0x0 }, /* POOL32Axf_5_group1~*(1) */
18529 { reserved_block , 0 , 0 , 32,
18530 0xfc00ffff, 0x2000457f, 0 , 0,
18531 0x0 }, /* POOL32Axf_5_group1~*(2) */
18532 { instruction , 0 , 0 , 32,
18533 0xfc00ffff, 0x2000477f, &NMD::DI , 0,
18534 0x0 }, /* DI */
18535 { reserved_block , 0 , 0 , 32,
18536 0xfc00ffff, 0x2000497f, 0 , 0,
18537 0x0 }, /* POOL32Axf_5_group1~*(4) */
18538 { reserved_block , 0 , 0 , 32,
18539 0xfc00ffff, 0x20004b7f, 0 , 0,
18540 0x0 }, /* POOL32Axf_5_group1~*(5) */
18541 { reserved_block , 0 , 0 , 32,
18542 0xfc00ffff, 0x20004d7f, 0 , 0,
18543 0x0 }, /* POOL32Axf_5_group1~*(6) */
18544 { reserved_block , 0 , 0 , 32,
18545 0xfc00ffff, 0x20004f7f, 0 , 0,
18546 0x0 }, /* POOL32Axf_5_group1~*(7) */
18547 { reserved_block , 0 , 0 , 32,
18548 0xfc00ffff, 0x2000517f, 0 , 0,
18549 0x0 }, /* POOL32Axf_5_group1~*(8) */
18550 { reserved_block , 0 , 0 , 32,
18551 0xfc00ffff, 0x2000537f, 0 , 0,
18552 0x0 }, /* POOL32Axf_5_group1~*(9) */
18553 { reserved_block , 0 , 0 , 32,
18554 0xfc00ffff, 0x2000557f, 0 , 0,
18555 0x0 }, /* POOL32Axf_5_group1~*(10) */
18556 { instruction , 0 , 0 , 32,
18557 0xfc00ffff, 0x2000577f, &NMD::EI , 0,
18558 0x0 }, /* EI */
18559 { reserved_block , 0 , 0 , 32,
18560 0xfc00ffff, 0x2000597f, 0 , 0,
18561 0x0 }, /* POOL32Axf_5_group1~*(12) */
18562 { reserved_block , 0 , 0 , 32,
18563 0xfc00ffff, 0x20005b7f, 0 , 0,
18564 0x0 }, /* POOL32Axf_5_group1~*(13) */
18565 { reserved_block , 0 , 0 , 32,
18566 0xfc00ffff, 0x20005d7f, 0 , 0,
18567 0x0 }, /* POOL32Axf_5_group1~*(14) */
18568 { reserved_block , 0 , 0 , 32,
18569 0xfc00ffff, 0x20005f7f, 0 , 0,
18570 0x0 }, /* POOL32Axf_5_group1~*(15) */
18571 { reserved_block , 0 , 0 , 32,
18572 0xfc00ffff, 0x2000617f, 0 , 0,
18573 0x0 }, /* POOL32Axf_5_group1~*(16) */
18574 { reserved_block , 0 , 0 , 32,
18575 0xfc00ffff, 0x2000637f, 0 , 0,
18576 0x0 }, /* POOL32Axf_5_group1~*(17) */
18577 { reserved_block , 0 , 0 , 32,
18578 0xfc00ffff, 0x2000657f, 0 , 0,
18579 0x0 }, /* POOL32Axf_5_group1~*(18) */
18580 { reserved_block , 0 , 0 , 32,
18581 0xfc00ffff, 0x2000677f, 0 , 0,
18582 0x0 }, /* POOL32Axf_5_group1~*(19) */
18583 { reserved_block , 0 , 0 , 32,
18584 0xfc00ffff, 0x2000697f, 0 , 0,
18585 0x0 }, /* POOL32Axf_5_group1~*(20) */
18586 { reserved_block , 0 , 0 , 32,
18587 0xfc00ffff, 0x20006b7f, 0 , 0,
18588 0x0 }, /* POOL32Axf_5_group1~*(21) */
18589 { reserved_block , 0 , 0 , 32,
18590 0xfc00ffff, 0x20006d7f, 0 , 0,
18591 0x0 }, /* POOL32Axf_5_group1~*(22) */
18592 { reserved_block , 0 , 0 , 32,
18593 0xfc00ffff, 0x20006f7f, 0 , 0,
18594 0x0 }, /* POOL32Axf_5_group1~*(23) */
18595 { reserved_block , 0 , 0 , 32,
18596 0xfc00ffff, 0x2000717f, 0 , 0,
18597 0x0 }, /* POOL32Axf_5_group1~*(24) */
18598 { reserved_block , 0 , 0 , 32,
18599 0xfc00ffff, 0x2000737f, 0 , 0,
18600 0x0 }, /* POOL32Axf_5_group1~*(25) */
18601 { reserved_block , 0 , 0 , 32,
18602 0xfc00ffff, 0x2000757f, 0 , 0,
18603 0x0 }, /* POOL32Axf_5_group1~*(26) */
18604 { reserved_block , 0 , 0 , 32,
18605 0xfc00ffff, 0x2000777f, 0 , 0,
18606 0x0 }, /* POOL32Axf_5_group1~*(27) */
18607 { reserved_block , 0 , 0 , 32,
18608 0xfc00ffff, 0x2000797f, 0 , 0,
18609 0x0 }, /* POOL32Axf_5_group1~*(28) */
18610 { reserved_block , 0 , 0 , 32,
18611 0xfc00ffff, 0x20007b7f, 0 , 0,
18612 0x0 }, /* POOL32Axf_5_group1~*(29) */
18613 { reserved_block , 0 , 0 , 32,
18614 0xfc00ffff, 0x20007d7f, 0 , 0,
18615 0x0 }, /* POOL32Axf_5_group1~*(30) */
18616 { reserved_block , 0 , 0 , 32,
18617 0xfc00ffff, 0x20007f7f, 0 , 0,
18618 0x0 }, /* POOL32Axf_5_group1~*(31) */
18619 };
18620
18621
18622 NMD::Pool NMD::ERETx[2] = {
18623 { instruction , 0 , 0 , 32,
18624 0xfc01ffff, 0x2000f37f, &NMD::ERET , 0,
18625 0x0 }, /* ERET */
18626 { instruction , 0 , 0 , 32,
18627 0xfc01ffff, 0x2001f37f, &NMD::ERETNC , 0,
18628 0x0 }, /* ERETNC */
18629 };
18630
18631
18632 NMD::Pool NMD::POOL32Axf_5_group3[32] = {
18633 { reserved_block , 0 , 0 , 32,
18634 0xfc00ffff, 0x2000c17f, 0 , 0,
18635 0x0 }, /* POOL32Axf_5_group3~*(0) */
18636 { instruction , 0 , 0 , 32,
18637 0xfc00ffff, 0x2000c37f, &NMD::WAIT , 0,
18638 0x0 }, /* WAIT */
18639 { reserved_block , 0 , 0 , 32,
18640 0xfc00ffff, 0x2000c57f, 0 , 0,
18641 0x0 }, /* POOL32Axf_5_group3~*(2) */
18642 { reserved_block , 0 , 0 , 32,
18643 0xfc00ffff, 0x2000c77f, 0 , 0,
18644 0x0 }, /* POOL32Axf_5_group3~*(3) */
18645 { reserved_block , 0 , 0 , 32,
18646 0xfc00ffff, 0x2000c97f, 0 , 0,
18647 0x0 }, /* POOL32Axf_5_group3~*(4) */
18648 { reserved_block , 0 , 0 , 32,
18649 0xfc00ffff, 0x2000cb7f, 0 , 0,
18650 0x0 }, /* POOL32Axf_5_group3~*(5) */
18651 { reserved_block , 0 , 0 , 32,
18652 0xfc00ffff, 0x2000cd7f, 0 , 0,
18653 0x0 }, /* POOL32Axf_5_group3~*(6) */
18654 { reserved_block , 0 , 0 , 32,
18655 0xfc00ffff, 0x2000cf7f, 0 , 0,
18656 0x0 }, /* POOL32Axf_5_group3~*(7) */
18657 { reserved_block , 0 , 0 , 32,
18658 0xfc00ffff, 0x2000d17f, 0 , 0,
18659 0x0 }, /* POOL32Axf_5_group3~*(8) */
18660 { instruction , 0 , 0 , 32,
18661 0xfc00ffff, 0x2000d37f, &NMD::IRET , 0,
18662 MCU_ }, /* IRET */
18663 { reserved_block , 0 , 0 , 32,
18664 0xfc00ffff, 0x2000d57f, 0 , 0,
18665 0x0 }, /* POOL32Axf_5_group3~*(10) */
18666 { reserved_block , 0 , 0 , 32,
18667 0xfc00ffff, 0x2000d77f, 0 , 0,
18668 0x0 }, /* POOL32Axf_5_group3~*(11) */
18669 { reserved_block , 0 , 0 , 32,
18670 0xfc00ffff, 0x2000d97f, 0 , 0,
18671 0x0 }, /* POOL32Axf_5_group3~*(12) */
18672 { reserved_block , 0 , 0 , 32,
18673 0xfc00ffff, 0x2000db7f, 0 , 0,
18674 0x0 }, /* POOL32Axf_5_group3~*(13) */
18675 { reserved_block , 0 , 0 , 32,
18676 0xfc00ffff, 0x2000dd7f, 0 , 0,
18677 0x0 }, /* POOL32Axf_5_group3~*(14) */
18678 { reserved_block , 0 , 0 , 32,
18679 0xfc00ffff, 0x2000df7f, 0 , 0,
18680 0x0 }, /* POOL32Axf_5_group3~*(15) */
18681 { instruction , 0 , 0 , 32,
18682 0xfc00ffff, 0x2000e17f, &NMD::RDPGPR , 0,
18683 CP0_ }, /* RDPGPR */
18684 { instruction , 0 , 0 , 32,
18685 0xfc00ffff, 0x2000e37f, &NMD::DERET , 0,
18686 EJTAG_ }, /* DERET */
18687 { reserved_block , 0 , 0 , 32,
18688 0xfc00ffff, 0x2000e57f, 0 , 0,
18689 0x0 }, /* POOL32Axf_5_group3~*(18) */
18690 { reserved_block , 0 , 0 , 32,
18691 0xfc00ffff, 0x2000e77f, 0 , 0,
18692 0x0 }, /* POOL32Axf_5_group3~*(19) */
18693 { reserved_block , 0 , 0 , 32,
18694 0xfc00ffff, 0x2000e97f, 0 , 0,
18695 0x0 }, /* POOL32Axf_5_group3~*(20) */
18696 { reserved_block , 0 , 0 , 32,
18697 0xfc00ffff, 0x2000eb7f, 0 , 0,
18698 0x0 }, /* POOL32Axf_5_group3~*(21) */
18699 { reserved_block , 0 , 0 , 32,
18700 0xfc00ffff, 0x2000ed7f, 0 , 0,
18701 0x0 }, /* POOL32Axf_5_group3~*(22) */
18702 { reserved_block , 0 , 0 , 32,
18703 0xfc00ffff, 0x2000ef7f, 0 , 0,
18704 0x0 }, /* POOL32Axf_5_group3~*(23) */
18705 { instruction , 0 , 0 , 32,
18706 0xfc00ffff, 0x2000f17f, &NMD::WRPGPR , 0,
18707 CP0_ }, /* WRPGPR */
18708 { pool , ERETx , 2 , 32,
18709 0xfc00ffff, 0x2000f37f, 0 , 0,
18710 0x0 }, /* ERETx */
18711 { reserved_block , 0 , 0 , 32,
18712 0xfc00ffff, 0x2000f57f, 0 , 0,
18713 0x0 }, /* POOL32Axf_5_group3~*(26) */
18714 { reserved_block , 0 , 0 , 32,
18715 0xfc00ffff, 0x2000f77f, 0 , 0,
18716 0x0 }, /* POOL32Axf_5_group3~*(27) */
18717 { reserved_block , 0 , 0 , 32,
18718 0xfc00ffff, 0x2000f97f, 0 , 0,
18719 0x0 }, /* POOL32Axf_5_group3~*(28) */
18720 { reserved_block , 0 , 0 , 32,
18721 0xfc00ffff, 0x2000fb7f, 0 , 0,
18722 0x0 }, /* POOL32Axf_5_group3~*(29) */
18723 { reserved_block , 0 , 0 , 32,
18724 0xfc00ffff, 0x2000fd7f, 0 , 0,
18725 0x0 }, /* POOL32Axf_5_group3~*(30) */
18726 { reserved_block , 0 , 0 , 32,
18727 0xfc00ffff, 0x2000ff7f, 0 , 0,
18728 0x0 }, /* POOL32Axf_5_group3~*(31) */
18729 };
18730
18731
18732 NMD::Pool NMD::POOL32Axf_5[4] = {
18733 { pool , POOL32Axf_5_group0 , 32 , 32,
18734 0xfc00c1ff, 0x2000017f, 0 , 0,
18735 0x0 }, /* POOL32Axf_5_group0 */
18736 { pool , POOL32Axf_5_group1 , 32 , 32,
18737 0xfc00c1ff, 0x2000417f, 0 , 0,
18738 0x0 }, /* POOL32Axf_5_group1 */
18739 { reserved_block , 0 , 0 , 32,
18740 0xfc00c1ff, 0x2000817f, 0 , 0,
18741 0x0 }, /* POOL32Axf_5~*(2) */
18742 { pool , POOL32Axf_5_group3 , 32 , 32,
18743 0xfc00c1ff, 0x2000c17f, 0 , 0,
18744 0x0 }, /* POOL32Axf_5_group3 */
18745 };
18746
18747
18748 NMD::Pool NMD::SHRA__R__QB[2] = {
18749 { instruction , 0 , 0 , 32,
18750 0xfc001fff, 0x200001ff, &NMD::SHRA_QB , 0,
18751 DSP_ }, /* SHRA.QB */
18752 { instruction , 0 , 0 , 32,
18753 0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB , 0,
18754 DSP_ }, /* SHRA_R.QB */
18755 };
18756
18757
18758 NMD::Pool NMD::POOL32Axf_7[8] = {
18759 { pool , SHRA__R__QB , 2 , 32,
18760 0xfc000fff, 0x200001ff, 0 , 0,
18761 0x0 }, /* SHRA[_R].QB */
18762 { instruction , 0 , 0 , 32,
18763 0xfc000fff, 0x200003ff, &NMD::SHRL_PH , 0,
18764 DSP_ }, /* SHRL.PH */
18765 { instruction , 0 , 0 , 32,
18766 0xfc000fff, 0x200005ff, &NMD::REPL_QB , 0,
18767 DSP_ }, /* REPL.QB */
18768 { reserved_block , 0 , 0 , 32,
18769 0xfc000fff, 0x200007ff, 0 , 0,
18770 0x0 }, /* POOL32Axf_7~*(3) */
18771 { reserved_block , 0 , 0 , 32,
18772 0xfc000fff, 0x200009ff, 0 , 0,
18773 0x0 }, /* POOL32Axf_7~*(4) */
18774 { reserved_block , 0 , 0 , 32,
18775 0xfc000fff, 0x20000bff, 0 , 0,
18776 0x0 }, /* POOL32Axf_7~*(5) */
18777 { reserved_block , 0 , 0 , 32,
18778 0xfc000fff, 0x20000dff, 0 , 0,
18779 0x0 }, /* POOL32Axf_7~*(6) */
18780 { reserved_block , 0 , 0 , 32,
18781 0xfc000fff, 0x20000fff, 0 , 0,
18782 0x0 }, /* POOL32Axf_7~*(7) */
18783 };
18784
18785
18786 NMD::Pool NMD::POOL32Axf[8] = {
18787 { reserved_block , 0 , 0 , 32,
18788 0xfc0001ff, 0x2000003f, 0 , 0,
18789 0x0 }, /* POOL32Axf~*(0) */
18790 { pool , POOL32Axf_1 , 8 , 32,
18791 0xfc0001ff, 0x2000007f, 0 , 0,
18792 0x0 }, /* POOL32Axf_1 */
18793 { pool , POOL32Axf_2 , 4 , 32,
18794 0xfc0001ff, 0x200000bf, 0 , 0,
18795 0x0 }, /* POOL32Axf_2 */
18796 { reserved_block , 0 , 0 , 32,
18797 0xfc0001ff, 0x200000ff, 0 , 0,
18798 0x0 }, /* POOL32Axf~*(3) */
18799 { pool , POOL32Axf_4 , 128 , 32,
18800 0xfc0001ff, 0x2000013f, 0 , 0,
18801 0x0 }, /* POOL32Axf_4 */
18802 { pool , POOL32Axf_5 , 4 , 32,
18803 0xfc0001ff, 0x2000017f, 0 , 0,
18804 0x0 }, /* POOL32Axf_5 */
18805 { reserved_block , 0 , 0 , 32,
18806 0xfc0001ff, 0x200001bf, 0 , 0,
18807 0x0 }, /* POOL32Axf~*(6) */
18808 { pool , POOL32Axf_7 , 8 , 32,
18809 0xfc0001ff, 0x200001ff, 0 , 0,
18810 0x0 }, /* POOL32Axf_7 */
18811 };
18812
18813
18814 NMD::Pool NMD::_POOL32A7[8] = {
18815 { pool , P_LSX , 2 , 32,
18816 0xfc00003f, 0x20000007, 0 , 0,
18817 0x0 }, /* P.LSX */
18818 { instruction , 0 , 0 , 32,
18819 0xfc00003f, 0x2000000f, &NMD::LSA , 0,
18820 0x0 }, /* LSA */
18821 { reserved_block , 0 , 0 , 32,
18822 0xfc00003f, 0x20000017, 0 , 0,
18823 0x0 }, /* _POOL32A7~*(2) */
18824 { instruction , 0 , 0 , 32,
18825 0xfc00003f, 0x2000001f, &NMD::EXTW , 0,
18826 0x0 }, /* EXTW */
18827 { reserved_block , 0 , 0 , 32,
18828 0xfc00003f, 0x20000027, 0 , 0,
18829 0x0 }, /* _POOL32A7~*(4) */
18830 { reserved_block , 0 , 0 , 32,
18831 0xfc00003f, 0x2000002f, 0 , 0,
18832 0x0 }, /* _POOL32A7~*(5) */
18833 { reserved_block , 0 , 0 , 32,
18834 0xfc00003f, 0x20000037, 0 , 0,
18835 0x0 }, /* _POOL32A7~*(6) */
18836 { pool , POOL32Axf , 8 , 32,
18837 0xfc00003f, 0x2000003f, 0 , 0,
18838 0x0 }, /* POOL32Axf */
18839 };
18840
18841
18842 NMD::Pool NMD::P32A[8] = {
18843 { pool , _POOL32A0 , 128 , 32,
18844 0xfc000007, 0x20000000, 0 , 0,
18845 0x0 }, /* _POOL32A0 */
18846 { instruction , 0 , 0 , 32,
18847 0xfc000007, 0x20000001, &NMD::SPECIAL2 , 0,
18848 UDI_ }, /* SPECIAL2 */
18849 { instruction , 0 , 0 , 32,
18850 0xfc000007, 0x20000002, &NMD::COP2_1 , 0,
18851 CP2_ }, /* COP2_1 */
18852 { instruction , 0 , 0 , 32,
18853 0xfc000007, 0x20000003, &NMD::UDI , 0,
18854 UDI_ }, /* UDI */
18855 { reserved_block , 0 , 0 , 32,
18856 0xfc000007, 0x20000004, 0 , 0,
18857 0x0 }, /* P32A~*(4) */
18858 { pool , _POOL32A5 , 128 , 32,
18859 0xfc000007, 0x20000005, 0 , 0,
18860 0x0 }, /* _POOL32A5 */
18861 { reserved_block , 0 , 0 , 32,
18862 0xfc000007, 0x20000006, 0 , 0,
18863 0x0 }, /* P32A~*(6) */
18864 { pool , _POOL32A7 , 8 , 32,
18865 0xfc000007, 0x20000007, 0 , 0,
18866 0x0 }, /* _POOL32A7 */
18867 };
18868
18869
18870 NMD::Pool NMD::P_GP_D[2] = {
18871 { instruction , 0 , 0 , 32,
18872 0xfc000007, 0x40000001, &NMD::LD_GP_ , 0,
18873 MIPS64_ }, /* LD[GP] */
18874 { instruction , 0 , 0 , 32,
18875 0xfc000007, 0x40000005, &NMD::SD_GP_ , 0,
18876 MIPS64_ }, /* SD[GP] */
18877 };
18878
18879
18880 NMD::Pool NMD::P_GP_W[4] = {
18881 { instruction , 0 , 0 , 32,
18882 0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_ , 0,
18883 0x0 }, /* ADDIU[GP.W] */
18884 { pool , P_GP_D , 2 , 32,
18885 0xfc000003, 0x40000001, 0 , 0,
18886 0x0 }, /* P.GP.D */
18887 { instruction , 0 , 0 , 32,
18888 0xfc000003, 0x40000002, &NMD::LW_GP_ , 0,
18889 0x0 }, /* LW[GP] */
18890 { instruction , 0 , 0 , 32,
18891 0xfc000003, 0x40000003, &NMD::SW_GP_ , 0,
18892 0x0 }, /* SW[GP] */
18893 };
18894
18895
18896 NMD::Pool NMD::POOL48I[32] = {
18897 { instruction , 0 , 0 , 48,
18898 0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_ , 0,
18899 XMMS_ }, /* LI[48] */
18900 { instruction , 0 , 0 , 48,
18901 0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_ , 0,
18902 XMMS_ }, /* ADDIU[48] */
18903 { instruction , 0 , 0 , 48,
18904 0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_ , 0,
18905 XMMS_ }, /* ADDIU[GP48] */
18906 { instruction , 0 , 0 , 48,
18907 0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_ , 0,
18908 XMMS_ }, /* ADDIUPC[48] */
18909 { reserved_block , 0 , 0 , 48,
18910 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18911 0x0 }, /* POOL48I~*(4) */
18912 { reserved_block , 0 , 0 , 48,
18913 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18914 0x0 }, /* POOL48I~*(5) */
18915 { reserved_block , 0 , 0 , 48,
18916 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18917 0x0 }, /* POOL48I~*(6) */
18918 { reserved_block , 0 , 0 , 48,
18919 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18920 0x0 }, /* POOL48I~*(7) */
18921 { reserved_block , 0 , 0 , 48,
18922 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18923 0x0 }, /* POOL48I~*(8) */
18924 { reserved_block , 0 , 0 , 48,
18925 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18926 0x0 }, /* POOL48I~*(9) */
18927 { reserved_block , 0 , 0 , 48,
18928 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18929 0x0 }, /* POOL48I~*(10) */
18930 { instruction , 0 , 0 , 48,
18931 0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_ , 0,
18932 XMMS_ }, /* LWPC[48] */
18933 { reserved_block , 0 , 0 , 48,
18934 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18935 0x0 }, /* POOL48I~*(12) */
18936 { reserved_block , 0 , 0 , 48,
18937 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18938 0x0 }, /* POOL48I~*(13) */
18939 { reserved_block , 0 , 0 , 48,
18940 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18941 0x0 }, /* POOL48I~*(14) */
18942 { instruction , 0 , 0 , 48,
18943 0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_ , 0,
18944 XMMS_ }, /* SWPC[48] */
18945 { reserved_block , 0 , 0 , 48,
18946 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18947 0x0 }, /* POOL48I~*(16) */
18948 { instruction , 0 , 0 , 48,
18949 0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_ , 0,
18950 MIPS64_ }, /* DADDIU[48] */
18951 { reserved_block , 0 , 0 , 48,
18952 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18953 0x0 }, /* POOL48I~*(18) */
18954 { reserved_block , 0 , 0 , 48,
18955 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18956 0x0 }, /* POOL48I~*(19) */
18957 { instruction , 0 , 0 , 48,
18958 0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_ , 0,
18959 MIPS64_ }, /* DLUI[48] */
18960 { reserved_block , 0 , 0 , 48,
18961 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18962 0x0 }, /* POOL48I~*(21) */
18963 { reserved_block , 0 , 0 , 48,
18964 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18965 0x0 }, /* POOL48I~*(22) */
18966 { reserved_block , 0 , 0 , 48,
18967 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18968 0x0 }, /* POOL48I~*(23) */
18969 { reserved_block , 0 , 0 , 48,
18970 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18971 0x0 }, /* POOL48I~*(24) */
18972 { reserved_block , 0 , 0 , 48,
18973 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18974 0x0 }, /* POOL48I~*(25) */
18975 { reserved_block , 0 , 0 , 48,
18976 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18977 0x0 }, /* POOL48I~*(26) */
18978 { instruction , 0 , 0 , 48,
18979 0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_ , 0,
18980 MIPS64_ }, /* LDPC[48] */
18981 { reserved_block , 0 , 0 , 48,
18982 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18983 0x0 }, /* POOL48I~*(28) */
18984 { reserved_block , 0 , 0 , 48,
18985 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18986 0x0 }, /* POOL48I~*(29) */
18987 { reserved_block , 0 , 0 , 48,
18988 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18989 0x0 }, /* POOL48I~*(30) */
18990 { instruction , 0 , 0 , 48,
18991 0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_ , 0,
18992 MIPS64_ }, /* SDPC[48] */
18993 };
18994
18995
18996 NMD::Pool NMD::PP_SR[4] = {
18997 { instruction , 0 , 0 , 32,
18998 0xfc10f003, 0x80003000, &NMD::SAVE_32_ , 0,
18999 0x0 }, /* SAVE[32] */
19000 { reserved_block , 0 , 0 , 32,
19001 0xfc10f003, 0x80003001, 0 , 0,
19002 0x0 }, /* PP.SR~*(1) */
19003 { instruction , 0 , 0 , 32,
19004 0xfc10f003, 0x80003002, &NMD::RESTORE_32_ , 0,
19005 0x0 }, /* RESTORE[32] */
19006 { return_instruction , 0 , 0 , 32,
19007 0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_ , 0,
19008 0x0 }, /* RESTORE.JRC[32] */
19009 };
19010
19011
19012 NMD::Pool NMD::P_SR_F[8] = {
19013 { instruction , 0 , 0 , 32,
19014 0xfc10f007, 0x80103000, &NMD::SAVEF , 0,
19015 CP1_ }, /* SAVEF */
19016 { instruction , 0 , 0 , 32,
19017 0xfc10f007, 0x80103001, &NMD::RESTOREF , 0,
19018 CP1_ }, /* RESTOREF */
19019 { reserved_block , 0 , 0 , 32,
19020 0xfc10f007, 0x80103002, 0 , 0,
19021 0x0 }, /* P.SR.F~*(2) */
19022 { reserved_block , 0 , 0 , 32,
19023 0xfc10f007, 0x80103003, 0 , 0,
19024 0x0 }, /* P.SR.F~*(3) */
19025 { reserved_block , 0 , 0 , 32,
19026 0xfc10f007, 0x80103004, 0 , 0,
19027 0x0 }, /* P.SR.F~*(4) */
19028 { reserved_block , 0 , 0 , 32,
19029 0xfc10f007, 0x80103005, 0 , 0,
19030 0x0 }, /* P.SR.F~*(5) */
19031 { reserved_block , 0 , 0 , 32,
19032 0xfc10f007, 0x80103006, 0 , 0,
19033 0x0 }, /* P.SR.F~*(6) */
19034 { reserved_block , 0 , 0 , 32,
19035 0xfc10f007, 0x80103007, 0 , 0,
19036 0x0 }, /* P.SR.F~*(7) */
19037 };
19038
19039
19040 NMD::Pool NMD::P_SR[2] = {
19041 { pool , PP_SR , 4 , 32,
19042 0xfc10f000, 0x80003000, 0 , 0,
19043 0x0 }, /* PP.SR */
19044 { pool , P_SR_F , 8 , 32,
19045 0xfc10f000, 0x80103000, 0 , 0,
19046 0x0 }, /* P.SR.F */
19047 };
19048
19049
19050 NMD::Pool NMD::P_SLL[5] = {
19051 { instruction , 0 , 0 , 32,
19052 0xffe0f1ff, 0x8000c000, &NMD::NOP_32_ , 0,
19053 0x0 }, /* NOP[32] */
19054 { instruction , 0 , 0 , 32,
19055 0xffe0f1ff, 0x8000c003, &NMD::EHB , 0,
19056 0x0 }, /* EHB */
19057 { instruction , 0 , 0 , 32,
19058 0xffe0f1ff, 0x8000c005, &NMD::PAUSE , 0,
19059 0x0 }, /* PAUSE */
19060 { instruction , 0 , 0 , 32,
19061 0xffe0f1ff, 0x8000c006, &NMD::SYNC , 0,
19062 0x0 }, /* SYNC */
19063 { instruction , 0 , 0 , 32,
19064 0xfc00f1e0, 0x8000c000, &NMD::SLL_32_ , 0,
19065 0x0 }, /* SLL[32] */
19066 };
19067
19068
19069 NMD::Pool NMD::P_SHIFT[16] = {
19070 { pool , P_SLL , 5 , 32,
19071 0xfc00f1e0, 0x8000c000, 0 , 0,
19072 0x0 }, /* P.SLL */
19073 { reserved_block , 0 , 0 , 32,
19074 0xfc00f1e0, 0x8000c020, 0 , 0,
19075 0x0 }, /* P.SHIFT~*(1) */
19076 { instruction , 0 , 0 , 32,
19077 0xfc00f1e0, 0x8000c040, &NMD::SRL_32_ , 0,
19078 0x0 }, /* SRL[32] */
19079 { reserved_block , 0 , 0 , 32,
19080 0xfc00f1e0, 0x8000c060, 0 , 0,
19081 0x0 }, /* P.SHIFT~*(3) */
19082 { instruction , 0 , 0 , 32,
19083 0xfc00f1e0, 0x8000c080, &NMD::SRA , 0,
19084 0x0 }, /* SRA */
19085 { reserved_block , 0 , 0 , 32,
19086 0xfc00f1e0, 0x8000c0a0, 0 , 0,
19087 0x0 }, /* P.SHIFT~*(5) */
19088 { instruction , 0 , 0 , 32,
19089 0xfc00f1e0, 0x8000c0c0, &NMD::ROTR , 0,
19090 0x0 }, /* ROTR */
19091 { reserved_block , 0 , 0 , 32,
19092 0xfc00f1e0, 0x8000c0e0, 0 , 0,
19093 0x0 }, /* P.SHIFT~*(7) */
19094 { instruction , 0 , 0 , 32,
19095 0xfc00f1e0, 0x8000c100, &NMD::DSLL , 0,
19096 MIPS64_ }, /* DSLL */
19097 { instruction , 0 , 0 , 32,
19098 0xfc00f1e0, 0x8000c120, &NMD::DSLL32 , 0,
19099 MIPS64_ }, /* DSLL32 */
19100 { instruction , 0 , 0 , 32,
19101 0xfc00f1e0, 0x8000c140, &NMD::DSRL , 0,
19102 MIPS64_ }, /* DSRL */
19103 { instruction , 0 , 0 , 32,
19104 0xfc00f1e0, 0x8000c160, &NMD::DSRL32 , 0,
19105 MIPS64_ }, /* DSRL32 */
19106 { instruction , 0 , 0 , 32,
19107 0xfc00f1e0, 0x8000c180, &NMD::DSRA , 0,
19108 MIPS64_ }, /* DSRA */
19109 { instruction , 0 , 0 , 32,
19110 0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32 , 0,
19111 MIPS64_ }, /* DSRA32 */
19112 { instruction , 0 , 0 , 32,
19113 0xfc00f1e0, 0x8000c1c0, &NMD::DROTR , 0,
19114 MIPS64_ }, /* DROTR */
19115 { instruction , 0 , 0 , 32,
19116 0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32 , 0,
19117 MIPS64_ }, /* DROTR32 */
19118 };
19119
19120
19121 NMD::Pool NMD::P_ROTX[4] = {
19122 { instruction , 0 , 0 , 32,
19123 0xfc00f820, 0x8000d000, &NMD::ROTX , 0,
19124 XMMS_ }, /* ROTX */
19125 { reserved_block , 0 , 0 , 32,
19126 0xfc00f820, 0x8000d020, 0 , 0,
19127 0x0 }, /* P.ROTX~*(1) */
19128 { reserved_block , 0 , 0 , 32,
19129 0xfc00f820, 0x8000d800, 0 , 0,
19130 0x0 }, /* P.ROTX~*(2) */
19131 { reserved_block , 0 , 0 , 32,
19132 0xfc00f820, 0x8000d820, 0 , 0,
19133 0x0 }, /* P.ROTX~*(3) */
19134 };
19135
19136
19137 NMD::Pool NMD::P_INS[4] = {
19138 { instruction , 0 , 0 , 32,
19139 0xfc00f820, 0x8000e000, &NMD::INS , 0,
19140 XMMS_ }, /* INS */
19141 { instruction , 0 , 0 , 32,
19142 0xfc00f820, 0x8000e020, &NMD::DINSU , 0,
19143 MIPS64_ }, /* DINSU */
19144 { instruction , 0 , 0 , 32,
19145 0xfc00f820, 0x8000e800, &NMD::DINSM , 0,
19146 MIPS64_ }, /* DINSM */
19147 { instruction , 0 , 0 , 32,
19148 0xfc00f820, 0x8000e820, &NMD::DINS , 0,
19149 MIPS64_ }, /* DINS */
19150 };
19151
19152
19153 NMD::Pool NMD::P_EXT[4] = {
19154 { instruction , 0 , 0 , 32,
19155 0xfc00f820, 0x8000f000, &NMD::EXT , 0,
19156 XMMS_ }, /* EXT */
19157 { instruction , 0 , 0 , 32,
19158 0xfc00f820, 0x8000f020, &NMD::DEXTU , 0,
19159 MIPS64_ }, /* DEXTU */
19160 { instruction , 0 , 0 , 32,
19161 0xfc00f820, 0x8000f800, &NMD::DEXTM , 0,
19162 MIPS64_ }, /* DEXTM */
19163 { instruction , 0 , 0 , 32,
19164 0xfc00f820, 0x8000f820, &NMD::DEXT , 0,
19165 MIPS64_ }, /* DEXT */
19166 };
19167
19168
19169 NMD::Pool NMD::P_U12[16] = {
19170 { instruction , 0 , 0 , 32,
19171 0xfc00f000, 0x80000000, &NMD::ORI , 0,
19172 0x0 }, /* ORI */
19173 { instruction , 0 , 0 , 32,
19174 0xfc00f000, 0x80001000, &NMD::XORI , 0,
19175 0x0 }, /* XORI */
19176 { instruction , 0 , 0 , 32,
19177 0xfc00f000, 0x80002000, &NMD::ANDI_32_ , 0,
19178 0x0 }, /* ANDI[32] */
19179 { pool , P_SR , 2 , 32,
19180 0xfc00f000, 0x80003000, 0 , 0,
19181 0x0 }, /* P.SR */
19182 { instruction , 0 , 0 , 32,
19183 0xfc00f000, 0x80004000, &NMD::SLTI , 0,
19184 0x0 }, /* SLTI */
19185 { instruction , 0 , 0 , 32,
19186 0xfc00f000, 0x80005000, &NMD::SLTIU , 0,
19187 0x0 }, /* SLTIU */
19188 { instruction , 0 , 0 , 32,
19189 0xfc00f000, 0x80006000, &NMD::SEQI , 0,
19190 0x0 }, /* SEQI */
19191 { reserved_block , 0 , 0 , 32,
19192 0xfc00f000, 0x80007000, 0 , 0,
19193 0x0 }, /* P.U12~*(7) */
19194 { instruction , 0 , 0 , 32,
19195 0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_ , 0,
19196 0x0 }, /* ADDIU[NEG] */
19197 { instruction , 0 , 0 , 32,
19198 0xfc00f000, 0x80009000, &NMD::DADDIU_U12_ , 0,
19199 MIPS64_ }, /* DADDIU[U12] */
19200 { instruction , 0 , 0 , 32,
19201 0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_ , 0,
19202 MIPS64_ }, /* DADDIU[NEG] */
19203 { instruction , 0 , 0 , 32,
19204 0xfc00f000, 0x8000b000, &NMD::DROTX , 0,
19205 MIPS64_ }, /* DROTX */
19206 { pool , P_SHIFT , 16 , 32,
19207 0xfc00f000, 0x8000c000, 0 , 0,
19208 0x0 }, /* P.SHIFT */
19209 { pool , P_ROTX , 4 , 32,
19210 0xfc00f000, 0x8000d000, 0 , 0,
19211 0x0 }, /* P.ROTX */
19212 { pool , P_INS , 4 , 32,
19213 0xfc00f000, 0x8000e000, 0 , 0,
19214 0x0 }, /* P.INS */
19215 { pool , P_EXT , 4 , 32,
19216 0xfc00f000, 0x8000f000, 0 , 0,
19217 0x0 }, /* P.EXT */
19218 };
19219
19220
19221 NMD::Pool NMD::RINT_fmt[2] = {
19222 { instruction , 0 , 0 , 32,
19223 0xfc0003ff, 0xa0000020, &NMD::RINT_S , 0,
19224 CP1_ }, /* RINT.S */
19225 { instruction , 0 , 0 , 32,
19226 0xfc0003ff, 0xa0000220, &NMD::RINT_D , 0,
19227 CP1_ }, /* RINT.D */
19228 };
19229
19230
19231 NMD::Pool NMD::ADD_fmt0[2] = {
19232 { instruction , 0 , 0 , 32,
19233 0xfc0003ff, 0xa0000030, &NMD::ADD_S , 0,
19234 CP1_ }, /* ADD.S */
19235 { reserved_block , 0 , 0 , 32,
19236 0xfc0003ff, 0xa0000230, 0 , 0,
19237 CP1_ }, /* ADD.fmt0~*(1) */
19238 };
19239
19240
19241 NMD::Pool NMD::SELEQZ_fmt[2] = {
19242 { instruction , 0 , 0 , 32,
19243 0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S , 0,
19244 CP1_ }, /* SELEQZ.S */
19245 { instruction , 0 , 0 , 32,
19246 0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D , 0,
19247 CP1_ }, /* SELEQZ.D */
19248 };
19249
19250
19251 NMD::Pool NMD::CLASS_fmt[2] = {
19252 { instruction , 0 , 0 , 32,
19253 0xfc0003ff, 0xa0000060, &NMD::CLASS_S , 0,
19254 CP1_ }, /* CLASS.S */
19255 { instruction , 0 , 0 , 32,
19256 0xfc0003ff, 0xa0000260, &NMD::CLASS_D , 0,
19257 CP1_ }, /* CLASS.D */
19258 };
19259
19260
19261 NMD::Pool NMD::SUB_fmt0[2] = {
19262 { instruction , 0 , 0 , 32,
19263 0xfc0003ff, 0xa0000070, &NMD::SUB_S , 0,
19264 CP1_ }, /* SUB.S */
19265 { reserved_block , 0 , 0 , 32,
19266 0xfc0003ff, 0xa0000270, 0 , 0,
19267 CP1_ }, /* SUB.fmt0~*(1) */
19268 };
19269
19270
19271 NMD::Pool NMD::SELNEZ_fmt[2] = {
19272 { instruction , 0 , 0 , 32,
19273 0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S , 0,
19274 CP1_ }, /* SELNEZ.S */
19275 { instruction , 0 , 0 , 32,
19276 0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D , 0,
19277 CP1_ }, /* SELNEZ.D */
19278 };
19279
19280
19281 NMD::Pool NMD::MUL_fmt0[2] = {
19282 { instruction , 0 , 0 , 32,
19283 0xfc0003ff, 0xa00000b0, &NMD::MUL_S , 0,
19284 CP1_ }, /* MUL.S */
19285 { reserved_block , 0 , 0 , 32,
19286 0xfc0003ff, 0xa00002b0, 0 , 0,
19287 CP1_ }, /* MUL.fmt0~*(1) */
19288 };
19289
19290
19291 NMD::Pool NMD::SEL_fmt[2] = {
19292 { instruction , 0 , 0 , 32,
19293 0xfc0003ff, 0xa00000b8, &NMD::SEL_S , 0,
19294 CP1_ }, /* SEL.S */
19295 { instruction , 0 , 0 , 32,
19296 0xfc0003ff, 0xa00002b8, &NMD::SEL_D , 0,
19297 CP1_ }, /* SEL.D */
19298 };
19299
19300
19301 NMD::Pool NMD::DIV_fmt0[2] = {
19302 { instruction , 0 , 0 , 32,
19303 0xfc0003ff, 0xa00000f0, &NMD::DIV_S , 0,
19304 CP1_ }, /* DIV.S */
19305 { reserved_block , 0 , 0 , 32,
19306 0xfc0003ff, 0xa00002f0, 0 , 0,
19307 CP1_ }, /* DIV.fmt0~*(1) */
19308 };
19309
19310
19311 NMD::Pool NMD::ADD_fmt1[2] = {
19312 { instruction , 0 , 0 , 32,
19313 0xfc0003ff, 0xa0000130, &NMD::ADD_D , 0,
19314 CP1_ }, /* ADD.D */
19315 { reserved_block , 0 , 0 , 32,
19316 0xfc0003ff, 0xa0000330, 0 , 0,
19317 CP1_ }, /* ADD.fmt1~*(1) */
19318 };
19319
19320
19321 NMD::Pool NMD::SUB_fmt1[2] = {
19322 { instruction , 0 , 0 , 32,
19323 0xfc0003ff, 0xa0000170, &NMD::SUB_D , 0,
19324 CP1_ }, /* SUB.D */
19325 { reserved_block , 0 , 0 , 32,
19326 0xfc0003ff, 0xa0000370, 0 , 0,
19327 CP1_ }, /* SUB.fmt1~*(1) */
19328 };
19329
19330
19331 NMD::Pool NMD::MUL_fmt1[2] = {
19332 { instruction , 0 , 0 , 32,
19333 0xfc0003ff, 0xa00001b0, &NMD::MUL_D , 0,
19334 CP1_ }, /* MUL.D */
19335 { reserved_block , 0 , 0 , 32,
19336 0xfc0003ff, 0xa00003b0, 0 , 0,
19337 CP1_ }, /* MUL.fmt1~*(1) */
19338 };
19339
19340
19341 NMD::Pool NMD::MADDF_fmt[2] = {
19342 { instruction , 0 , 0 , 32,
19343 0xfc0003ff, 0xa00001b8, &NMD::MADDF_S , 0,
19344 CP1_ }, /* MADDF.S */
19345 { instruction , 0 , 0 , 32,
19346 0xfc0003ff, 0xa00003b8, &NMD::MADDF_D , 0,
19347 CP1_ }, /* MADDF.D */
19348 };
19349
19350
19351 NMD::Pool NMD::DIV_fmt1[2] = {
19352 { instruction , 0 , 0 , 32,
19353 0xfc0003ff, 0xa00001f0, &NMD::DIV_D , 0,
19354 CP1_ }, /* DIV.D */
19355 { reserved_block , 0 , 0 , 32,
19356 0xfc0003ff, 0xa00003f0, 0 , 0,
19357 CP1_ }, /* DIV.fmt1~*(1) */
19358 };
19359
19360
19361 NMD::Pool NMD::MSUBF_fmt[2] = {
19362 { instruction , 0 , 0 , 32,
19363 0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S , 0,
19364 CP1_ }, /* MSUBF.S */
19365 { instruction , 0 , 0 , 32,
19366 0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D , 0,
19367 CP1_ }, /* MSUBF.D */
19368 };
19369
19370
19371 NMD::Pool NMD::POOL32F_0[64] = {
19372 { reserved_block , 0 , 0 , 32,
19373 0xfc0001ff, 0xa0000000, 0 , 0,
19374 CP1_ }, /* POOL32F_0~*(0) */
19375 { reserved_block , 0 , 0 , 32,
19376 0xfc0001ff, 0xa0000008, 0 , 0,
19377 CP1_ }, /* POOL32F_0~*(1) */
19378 { reserved_block , 0 , 0 , 32,
19379 0xfc0001ff, 0xa0000010, 0 , 0,
19380 CP1_ }, /* POOL32F_0~*(2) */
19381 { reserved_block , 0 , 0 , 32,
19382 0xfc0001ff, 0xa0000018, 0 , 0,
19383 CP1_ }, /* POOL32F_0~*(3) */
19384 { pool , RINT_fmt , 2 , 32,
19385 0xfc0001ff, 0xa0000020, 0 , 0,
19386 CP1_ }, /* RINT.fmt */
19387 { reserved_block , 0 , 0 , 32,
19388 0xfc0001ff, 0xa0000028, 0 , 0,
19389 CP1_ }, /* POOL32F_0~*(5) */
19390 { pool , ADD_fmt0 , 2 , 32,
19391 0xfc0001ff, 0xa0000030, 0 , 0,
19392 CP1_ }, /* ADD.fmt0 */
19393 { pool , SELEQZ_fmt , 2 , 32,
19394 0xfc0001ff, 0xa0000038, 0 , 0,
19395 CP1_ }, /* SELEQZ.fmt */
19396 { reserved_block , 0 , 0 , 32,
19397 0xfc0001ff, 0xa0000040, 0 , 0,
19398 CP1_ }, /* POOL32F_0~*(8) */
19399 { reserved_block , 0 , 0 , 32,
19400 0xfc0001ff, 0xa0000048, 0 , 0,
19401 CP1_ }, /* POOL32F_0~*(9) */
19402 { reserved_block , 0 , 0 , 32,
19403 0xfc0001ff, 0xa0000050, 0 , 0,
19404 CP1_ }, /* POOL32F_0~*(10) */
19405 { reserved_block , 0 , 0 , 32,
19406 0xfc0001ff, 0xa0000058, 0 , 0,
19407 CP1_ }, /* POOL32F_0~*(11) */
19408 { pool , CLASS_fmt , 2 , 32,
19409 0xfc0001ff, 0xa0000060, 0 , 0,
19410 CP1_ }, /* CLASS.fmt */
19411 { reserved_block , 0 , 0 , 32,
19412 0xfc0001ff, 0xa0000068, 0 , 0,
19413 CP1_ }, /* POOL32F_0~*(13) */
19414 { pool , SUB_fmt0 , 2 , 32,
19415 0xfc0001ff, 0xa0000070, 0 , 0,
19416 CP1_ }, /* SUB.fmt0 */
19417 { pool , SELNEZ_fmt , 2 , 32,
19418 0xfc0001ff, 0xa0000078, 0 , 0,
19419 CP1_ }, /* SELNEZ.fmt */
19420 { reserved_block , 0 , 0 , 32,
19421 0xfc0001ff, 0xa0000080, 0 , 0,
19422 CP1_ }, /* POOL32F_0~*(16) */
19423 { reserved_block , 0 , 0 , 32,
19424 0xfc0001ff, 0xa0000088, 0 , 0,
19425 CP1_ }, /* POOL32F_0~*(17) */
19426 { reserved_block , 0 , 0 , 32,
19427 0xfc0001ff, 0xa0000090, 0 , 0,
19428 CP1_ }, /* POOL32F_0~*(18) */
19429 { reserved_block , 0 , 0 , 32,
19430 0xfc0001ff, 0xa0000098, 0 , 0,
19431 CP1_ }, /* POOL32F_0~*(19) */
19432 { reserved_block , 0 , 0 , 32,
19433 0xfc0001ff, 0xa00000a0, 0 , 0,
19434 CP1_ }, /* POOL32F_0~*(20) */
19435 { reserved_block , 0 , 0 , 32,
19436 0xfc0001ff, 0xa00000a8, 0 , 0,
19437 CP1_ }, /* POOL32F_0~*(21) */
19438 { pool , MUL_fmt0 , 2 , 32,
19439 0xfc0001ff, 0xa00000b0, 0 , 0,
19440 CP1_ }, /* MUL.fmt0 */
19441 { pool , SEL_fmt , 2 , 32,
19442 0xfc0001ff, 0xa00000b8, 0 , 0,
19443 CP1_ }, /* SEL.fmt */
19444 { reserved_block , 0 , 0 , 32,
19445 0xfc0001ff, 0xa00000c0, 0 , 0,
19446 CP1_ }, /* POOL32F_0~*(24) */
19447 { reserved_block , 0 , 0 , 32,
19448 0xfc0001ff, 0xa00000c8, 0 , 0,
19449 CP1_ }, /* POOL32F_0~*(25) */
19450 { reserved_block , 0 , 0 , 32,
19451 0xfc0001ff, 0xa00000d0, 0 , 0,
19452 CP1_ }, /* POOL32F_0~*(26) */
19453 { reserved_block , 0 , 0 , 32,
19454 0xfc0001ff, 0xa00000d8, 0 , 0,
19455 CP1_ }, /* POOL32F_0~*(27) */
19456 { reserved_block , 0 , 0 , 32,
19457 0xfc0001ff, 0xa00000e0, 0 , 0,
19458 CP1_ }, /* POOL32F_0~*(28) */
19459 { reserved_block , 0 , 0 , 32,
19460 0xfc0001ff, 0xa00000e8, 0 , 0,
19461 CP1_ }, /* POOL32F_0~*(29) */
19462 { pool , DIV_fmt0 , 2 , 32,
19463 0xfc0001ff, 0xa00000f0, 0 , 0,
19464 CP1_ }, /* DIV.fmt0 */
19465 { reserved_block , 0 , 0 , 32,
19466 0xfc0001ff, 0xa00000f8, 0 , 0,
19467 CP1_ }, /* POOL32F_0~*(31) */
19468 { reserved_block , 0 , 0 , 32,
19469 0xfc0001ff, 0xa0000100, 0 , 0,
19470 CP1_ }, /* POOL32F_0~*(32) */
19471 { reserved_block , 0 , 0 , 32,
19472 0xfc0001ff, 0xa0000108, 0 , 0,
19473 CP1_ }, /* POOL32F_0~*(33) */
19474 { reserved_block , 0 , 0 , 32,
19475 0xfc0001ff, 0xa0000110, 0 , 0,
19476 CP1_ }, /* POOL32F_0~*(34) */
19477 { reserved_block , 0 , 0 , 32,
19478 0xfc0001ff, 0xa0000118, 0 , 0,
19479 CP1_ }, /* POOL32F_0~*(35) */
19480 { reserved_block , 0 , 0 , 32,
19481 0xfc0001ff, 0xa0000120, 0 , 0,
19482 CP1_ }, /* POOL32F_0~*(36) */
19483 { reserved_block , 0 , 0 , 32,
19484 0xfc0001ff, 0xa0000128, 0 , 0,
19485 CP1_ }, /* POOL32F_0~*(37) */
19486 { pool , ADD_fmt1 , 2 , 32,
19487 0xfc0001ff, 0xa0000130, 0 , 0,
19488 CP1_ }, /* ADD.fmt1 */
19489 { reserved_block , 0 , 0 , 32,
19490 0xfc0001ff, 0xa0000138, 0 , 0,
19491 CP1_ }, /* POOL32F_0~*(39) */
19492 { reserved_block , 0 , 0 , 32,
19493 0xfc0001ff, 0xa0000140, 0 , 0,
19494 CP1_ }, /* POOL32F_0~*(40) */
19495 { reserved_block , 0 , 0 , 32,
19496 0xfc0001ff, 0xa0000148, 0 , 0,
19497 CP1_ }, /* POOL32F_0~*(41) */
19498 { reserved_block , 0 , 0 , 32,
19499 0xfc0001ff, 0xa0000150, 0 , 0,
19500 CP1_ }, /* POOL32F_0~*(42) */
19501 { reserved_block , 0 , 0 , 32,
19502 0xfc0001ff, 0xa0000158, 0 , 0,
19503 CP1_ }, /* POOL32F_0~*(43) */
19504 { reserved_block , 0 , 0 , 32,
19505 0xfc0001ff, 0xa0000160, 0 , 0,
19506 CP1_ }, /* POOL32F_0~*(44) */
19507 { reserved_block , 0 , 0 , 32,
19508 0xfc0001ff, 0xa0000168, 0 , 0,
19509 CP1_ }, /* POOL32F_0~*(45) */
19510 { pool , SUB_fmt1 , 2 , 32,
19511 0xfc0001ff, 0xa0000170, 0 , 0,
19512 CP1_ }, /* SUB.fmt1 */
19513 { reserved_block , 0 , 0 , 32,
19514 0xfc0001ff, 0xa0000178, 0 , 0,
19515 CP1_ }, /* POOL32F_0~*(47) */
19516 { reserved_block , 0 , 0 , 32,
19517 0xfc0001ff, 0xa0000180, 0 , 0,
19518 CP1_ }, /* POOL32F_0~*(48) */
19519 { reserved_block , 0 , 0 , 32,
19520 0xfc0001ff, 0xa0000188, 0 , 0,
19521 CP1_ }, /* POOL32F_0~*(49) */
19522 { reserved_block , 0 , 0 , 32,
19523 0xfc0001ff, 0xa0000190, 0 , 0,
19524 CP1_ }, /* POOL32F_0~*(50) */
19525 { reserved_block , 0 , 0 , 32,
19526 0xfc0001ff, 0xa0000198, 0 , 0,
19527 CP1_ }, /* POOL32F_0~*(51) */
19528 { reserved_block , 0 , 0 , 32,
19529 0xfc0001ff, 0xa00001a0, 0 , 0,
19530 CP1_ }, /* POOL32F_0~*(52) */
19531 { reserved_block , 0 , 0 , 32,
19532 0xfc0001ff, 0xa00001a8, 0 , 0,
19533 CP1_ }, /* POOL32F_0~*(53) */
19534 { pool , MUL_fmt1 , 2 , 32,
19535 0xfc0001ff, 0xa00001b0, 0 , 0,
19536 CP1_ }, /* MUL.fmt1 */
19537 { pool , MADDF_fmt , 2 , 32,
19538 0xfc0001ff, 0xa00001b8, 0 , 0,
19539 CP1_ }, /* MADDF.fmt */
19540 { reserved_block , 0 , 0 , 32,
19541 0xfc0001ff, 0xa00001c0, 0 , 0,
19542 CP1_ }, /* POOL32F_0~*(56) */
19543 { reserved_block , 0 , 0 , 32,
19544 0xfc0001ff, 0xa00001c8, 0 , 0,
19545 CP1_ }, /* POOL32F_0~*(57) */
19546 { reserved_block , 0 , 0 , 32,
19547 0xfc0001ff, 0xa00001d0, 0 , 0,
19548 CP1_ }, /* POOL32F_0~*(58) */
19549 { reserved_block , 0 , 0 , 32,
19550 0xfc0001ff, 0xa00001d8, 0 , 0,
19551 CP1_ }, /* POOL32F_0~*(59) */
19552 { reserved_block , 0 , 0 , 32,
19553 0xfc0001ff, 0xa00001e0, 0 , 0,
19554 CP1_ }, /* POOL32F_0~*(60) */
19555 { reserved_block , 0 , 0 , 32,
19556 0xfc0001ff, 0xa00001e8, 0 , 0,
19557 CP1_ }, /* POOL32F_0~*(61) */
19558 { pool , DIV_fmt1 , 2 , 32,
19559 0xfc0001ff, 0xa00001f0, 0 , 0,
19560 CP1_ }, /* DIV.fmt1 */
19561 { pool , MSUBF_fmt , 2 , 32,
19562 0xfc0001ff, 0xa00001f8, 0 , 0,
19563 CP1_ }, /* MSUBF.fmt */
19564 };
19565
19566
19567 NMD::Pool NMD::MIN_fmt[2] = {
19568 { instruction , 0 , 0 , 32,
19569 0xfc00023f, 0xa0000003, &NMD::MIN_S , 0,
19570 CP1_ }, /* MIN.S */
19571 { instruction , 0 , 0 , 32,
19572 0xfc00023f, 0xa0000203, &NMD::MIN_D , 0,
19573 CP1_ }, /* MIN.D */
19574 };
19575
19576
19577 NMD::Pool NMD::MAX_fmt[2] = {
19578 { instruction , 0 , 0 , 32,
19579 0xfc00023f, 0xa000000b, &NMD::MAX_S , 0,
19580 CP1_ }, /* MAX.S */
19581 { instruction , 0 , 0 , 32,
19582 0xfc00023f, 0xa000020b, &NMD::MAX_D , 0,
19583 CP1_ }, /* MAX.D */
19584 };
19585
19586
19587 NMD::Pool NMD::MINA_fmt[2] = {
19588 { instruction , 0 , 0 , 32,
19589 0xfc00023f, 0xa0000023, &NMD::MINA_S , 0,
19590 CP1_ }, /* MINA.S */
19591 { instruction , 0 , 0 , 32,
19592 0xfc00023f, 0xa0000223, &NMD::MINA_D , 0,
19593 CP1_ }, /* MINA.D */
19594 };
19595
19596
19597 NMD::Pool NMD::MAXA_fmt[2] = {
19598 { instruction , 0 , 0 , 32,
19599 0xfc00023f, 0xa000002b, &NMD::MAXA_S , 0,
19600 CP1_ }, /* MAXA.S */
19601 { instruction , 0 , 0 , 32,
19602 0xfc00023f, 0xa000022b, &NMD::MAXA_D , 0,
19603 CP1_ }, /* MAXA.D */
19604 };
19605
19606
19607 NMD::Pool NMD::CVT_L_fmt[2] = {
19608 { instruction , 0 , 0 , 32,
19609 0xfc007fff, 0xa000013b, &NMD::CVT_L_S , 0,
19610 CP1_ }, /* CVT.L.S */
19611 { instruction , 0 , 0 , 32,
19612 0xfc007fff, 0xa000413b, &NMD::CVT_L_D , 0,
19613 CP1_ }, /* CVT.L.D */
19614 };
19615
19616
19617 NMD::Pool NMD::RSQRT_fmt[2] = {
19618 { instruction , 0 , 0 , 32,
19619 0xfc007fff, 0xa000023b, &NMD::RSQRT_S , 0,
19620 CP1_ }, /* RSQRT.S */
19621 { instruction , 0 , 0 , 32,
19622 0xfc007fff, 0xa000423b, &NMD::RSQRT_D , 0,
19623 CP1_ }, /* RSQRT.D */
19624 };
19625
19626
19627 NMD::Pool NMD::FLOOR_L_fmt[2] = {
19628 { instruction , 0 , 0 , 32,
19629 0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S , 0,
19630 CP1_ }, /* FLOOR.L.S */
19631 { instruction , 0 , 0 , 32,
19632 0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D , 0,
19633 CP1_ }, /* FLOOR.L.D */
19634 };
19635
19636
19637 NMD::Pool NMD::CVT_W_fmt[2] = {
19638 { instruction , 0 , 0 , 32,
19639 0xfc007fff, 0xa000093b, &NMD::CVT_W_S , 0,
19640 CP1_ }, /* CVT.W.S */
19641 { instruction , 0 , 0 , 32,
19642 0xfc007fff, 0xa000493b, &NMD::CVT_W_D , 0,
19643 CP1_ }, /* CVT.W.D */
19644 };
19645
19646
19647 NMD::Pool NMD::SQRT_fmt[2] = {
19648 { instruction , 0 , 0 , 32,
19649 0xfc007fff, 0xa0000a3b, &NMD::SQRT_S , 0,
19650 CP1_ }, /* SQRT.S */
19651 { instruction , 0 , 0 , 32,
19652 0xfc007fff, 0xa0004a3b, &NMD::SQRT_D , 0,
19653 CP1_ }, /* SQRT.D */
19654 };
19655
19656
19657 NMD::Pool NMD::FLOOR_W_fmt[2] = {
19658 { instruction , 0 , 0 , 32,
19659 0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S , 0,
19660 CP1_ }, /* FLOOR.W.S */
19661 { instruction , 0 , 0 , 32,
19662 0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D , 0,
19663 CP1_ }, /* FLOOR.W.D */
19664 };
19665
19666
19667 NMD::Pool NMD::RECIP_fmt[2] = {
19668 { instruction , 0 , 0 , 32,
19669 0xfc007fff, 0xa000123b, &NMD::RECIP_S , 0,
19670 CP1_ }, /* RECIP.S */
19671 { instruction , 0 , 0 , 32,
19672 0xfc007fff, 0xa000523b, &NMD::RECIP_D , 0,
19673 CP1_ }, /* RECIP.D */
19674 };
19675
19676
19677 NMD::Pool NMD::CEIL_L_fmt[2] = {
19678 { instruction , 0 , 0 , 32,
19679 0xfc007fff, 0xa000133b, &NMD::CEIL_L_S , 0,
19680 CP1_ }, /* CEIL.L.S */
19681 { instruction , 0 , 0 , 32,
19682 0xfc007fff, 0xa000533b, &NMD::CEIL_L_D , 0,
19683 CP1_ }, /* CEIL.L.D */
19684 };
19685
19686
19687 NMD::Pool NMD::CEIL_W_fmt[2] = {
19688 { instruction , 0 , 0 , 32,
19689 0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S , 0,
19690 CP1_ }, /* CEIL.W.S */
19691 { instruction , 0 , 0 , 32,
19692 0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D , 0,
19693 CP1_ }, /* CEIL.W.D */
19694 };
19695
19696
19697 NMD::Pool NMD::TRUNC_L_fmt[2] = {
19698 { instruction , 0 , 0 , 32,
19699 0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S , 0,
19700 CP1_ }, /* TRUNC.L.S */
19701 { instruction , 0 , 0 , 32,
19702 0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D , 0,
19703 CP1_ }, /* TRUNC.L.D */
19704 };
19705
19706
19707 NMD::Pool NMD::TRUNC_W_fmt[2] = {
19708 { instruction , 0 , 0 , 32,
19709 0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S , 0,
19710 CP1_ }, /* TRUNC.W.S */
19711 { instruction , 0 , 0 , 32,
19712 0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D , 0,
19713 CP1_ }, /* TRUNC.W.D */
19714 };
19715
19716
19717 NMD::Pool NMD::ROUND_L_fmt[2] = {
19718 { instruction , 0 , 0 , 32,
19719 0xfc007fff, 0xa000333b, &NMD::ROUND_L_S , 0,
19720 CP1_ }, /* ROUND.L.S */
19721 { instruction , 0 , 0 , 32,
19722 0xfc007fff, 0xa000733b, &NMD::ROUND_L_D , 0,
19723 CP1_ }, /* ROUND.L.D */
19724 };
19725
19726
19727 NMD::Pool NMD::ROUND_W_fmt[2] = {
19728 { instruction , 0 , 0 , 32,
19729 0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S , 0,
19730 CP1_ }, /* ROUND.W.S */
19731 { instruction , 0 , 0 , 32,
19732 0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D , 0,
19733 CP1_ }, /* ROUND.W.D */
19734 };
19735
19736
19737 NMD::Pool NMD::POOL32Fxf_0[64] = {
19738 { reserved_block , 0 , 0 , 32,
19739 0xfc003fff, 0xa000003b, 0 , 0,
19740 CP1_ }, /* POOL32Fxf_0~*(0) */
19741 { pool , CVT_L_fmt , 2 , 32,
19742 0xfc003fff, 0xa000013b, 0 , 0,
19743 CP1_ }, /* CVT.L.fmt */
19744 { pool , RSQRT_fmt , 2 , 32,
19745 0xfc003fff, 0xa000023b, 0 , 0,
19746 CP1_ }, /* RSQRT.fmt */
19747 { pool , FLOOR_L_fmt , 2 , 32,
19748 0xfc003fff, 0xa000033b, 0 , 0,
19749 CP1_ }, /* FLOOR.L.fmt */
19750 { reserved_block , 0 , 0 , 32,
19751 0xfc003fff, 0xa000043b, 0 , 0,
19752 CP1_ }, /* POOL32Fxf_0~*(4) */
19753 { reserved_block , 0 , 0 , 32,
19754 0xfc003fff, 0xa000053b, 0 , 0,
19755 CP1_ }, /* POOL32Fxf_0~*(5) */
19756 { reserved_block , 0 , 0 , 32,
19757 0xfc003fff, 0xa000063b, 0 , 0,
19758 CP1_ }, /* POOL32Fxf_0~*(6) */
19759 { reserved_block , 0 , 0 , 32,
19760 0xfc003fff, 0xa000073b, 0 , 0,
19761 CP1_ }, /* POOL32Fxf_0~*(7) */
19762 { reserved_block , 0 , 0 , 32,
19763 0xfc003fff, 0xa000083b, 0 , 0,
19764 CP1_ }, /* POOL32Fxf_0~*(8) */
19765 { pool , CVT_W_fmt , 2 , 32,
19766 0xfc003fff, 0xa000093b, 0 , 0,
19767 CP1_ }, /* CVT.W.fmt */
19768 { pool , SQRT_fmt , 2 , 32,
19769 0xfc003fff, 0xa0000a3b, 0 , 0,
19770 CP1_ }, /* SQRT.fmt */
19771 { pool , FLOOR_W_fmt , 2 , 32,
19772 0xfc003fff, 0xa0000b3b, 0 , 0,
19773 CP1_ }, /* FLOOR.W.fmt */
19774 { reserved_block , 0 , 0 , 32,
19775 0xfc003fff, 0xa0000c3b, 0 , 0,
19776 CP1_ }, /* POOL32Fxf_0~*(12) */
19777 { reserved_block , 0 , 0 , 32,
19778 0xfc003fff, 0xa0000d3b, 0 , 0,
19779 CP1_ }, /* POOL32Fxf_0~*(13) */
19780 { reserved_block , 0 , 0 , 32,
19781 0xfc003fff, 0xa0000e3b, 0 , 0,
19782 CP1_ }, /* POOL32Fxf_0~*(14) */
19783 { reserved_block , 0 , 0 , 32,
19784 0xfc003fff, 0xa0000f3b, 0 , 0,
19785 CP1_ }, /* POOL32Fxf_0~*(15) */
19786 { instruction , 0 , 0 , 32,
19787 0xfc003fff, 0xa000103b, &NMD::CFC1 , 0,
19788 CP1_ }, /* CFC1 */
19789 { reserved_block , 0 , 0 , 32,
19790 0xfc003fff, 0xa000113b, 0 , 0,
19791 CP1_ }, /* POOL32Fxf_0~*(17) */
19792 { pool , RECIP_fmt , 2 , 32,
19793 0xfc003fff, 0xa000123b, 0 , 0,
19794 CP1_ }, /* RECIP.fmt */
19795 { pool , CEIL_L_fmt , 2 , 32,
19796 0xfc003fff, 0xa000133b, 0 , 0,
19797 CP1_ }, /* CEIL.L.fmt */
19798 { reserved_block , 0 , 0 , 32,
19799 0xfc003fff, 0xa000143b, 0 , 0,
19800 CP1_ }, /* POOL32Fxf_0~*(20) */
19801 { reserved_block , 0 , 0 , 32,
19802 0xfc003fff, 0xa000153b, 0 , 0,
19803 CP1_ }, /* POOL32Fxf_0~*(21) */
19804 { reserved_block , 0 , 0 , 32,
19805 0xfc003fff, 0xa000163b, 0 , 0,
19806 CP1_ }, /* POOL32Fxf_0~*(22) */
19807 { reserved_block , 0 , 0 , 32,
19808 0xfc003fff, 0xa000173b, 0 , 0,
19809 CP1_ }, /* POOL32Fxf_0~*(23) */
19810 { instruction , 0 , 0 , 32,
19811 0xfc003fff, 0xa000183b, &NMD::CTC1 , 0,
19812 CP1_ }, /* CTC1 */
19813 { reserved_block , 0 , 0 , 32,
19814 0xfc003fff, 0xa000193b, 0 , 0,
19815 CP1_ }, /* POOL32Fxf_0~*(25) */
19816 { reserved_block , 0 , 0 , 32,
19817 0xfc003fff, 0xa0001a3b, 0 , 0,
19818 CP1_ }, /* POOL32Fxf_0~*(26) */
19819 { pool , CEIL_W_fmt , 2 , 32,
19820 0xfc003fff, 0xa0001b3b, 0 , 0,
19821 CP1_ }, /* CEIL.W.fmt */
19822 { reserved_block , 0 , 0 , 32,
19823 0xfc003fff, 0xa0001c3b, 0 , 0,
19824 CP1_ }, /* POOL32Fxf_0~*(28) */
19825 { reserved_block , 0 , 0 , 32,
19826 0xfc003fff, 0xa0001d3b, 0 , 0,
19827 CP1_ }, /* POOL32Fxf_0~*(29) */
19828 { reserved_block , 0 , 0 , 32,
19829 0xfc003fff, 0xa0001e3b, 0 , 0,
19830 CP1_ }, /* POOL32Fxf_0~*(30) */
19831 { reserved_block , 0 , 0 , 32,
19832 0xfc003fff, 0xa0001f3b, 0 , 0,
19833 CP1_ }, /* POOL32Fxf_0~*(31) */
19834 { instruction , 0 , 0 , 32,
19835 0xfc003fff, 0xa000203b, &NMD::MFC1 , 0,
19836 CP1_ }, /* MFC1 */
19837 { instruction , 0 , 0 , 32,
19838 0xfc003fff, 0xa000213b, &NMD::CVT_S_PL , 0,
19839 CP1_ }, /* CVT.S.PL */
19840 { reserved_block , 0 , 0 , 32,
19841 0xfc003fff, 0xa000223b, 0 , 0,
19842 CP1_ }, /* POOL32Fxf_0~*(34) */
19843 { pool , TRUNC_L_fmt , 2 , 32,
19844 0xfc003fff, 0xa000233b, 0 , 0,
19845 CP1_ }, /* TRUNC.L.fmt */
19846 { instruction , 0 , 0 , 32,
19847 0xfc003fff, 0xa000243b, &NMD::DMFC1 , 0,
19848 CP1_ | MIPS64_ }, /* DMFC1 */
19849 { reserved_block , 0 , 0 , 32,
19850 0xfc003fff, 0xa000253b, 0 , 0,
19851 CP1_ }, /* POOL32Fxf_0~*(37) */
19852 { reserved_block , 0 , 0 , 32,
19853 0xfc003fff, 0xa000263b, 0 , 0,
19854 CP1_ }, /* POOL32Fxf_0~*(38) */
19855 { reserved_block , 0 , 0 , 32,
19856 0xfc003fff, 0xa000273b, 0 , 0,
19857 CP1_ }, /* POOL32Fxf_0~*(39) */
19858 { instruction , 0 , 0 , 32,
19859 0xfc003fff, 0xa000283b, &NMD::MTC1 , 0,
19860 CP1_ }, /* MTC1 */
19861 { instruction , 0 , 0 , 32,
19862 0xfc003fff, 0xa000293b, &NMD::CVT_S_PU , 0,
19863 CP1_ }, /* CVT.S.PU */
19864 { reserved_block , 0 , 0 , 32,
19865 0xfc003fff, 0xa0002a3b, 0 , 0,
19866 CP1_ }, /* POOL32Fxf_0~*(42) */
19867 { pool , TRUNC_W_fmt , 2 , 32,
19868 0xfc003fff, 0xa0002b3b, 0 , 0,
19869 CP1_ }, /* TRUNC.W.fmt */
19870 { instruction , 0 , 0 , 32,
19871 0xfc003fff, 0xa0002c3b, &NMD::DMTC1 , 0,
19872 CP1_ | MIPS64_ }, /* DMTC1 */
19873 { reserved_block , 0 , 0 , 32,
19874 0xfc003fff, 0xa0002d3b, 0 , 0,
19875 CP1_ }, /* POOL32Fxf_0~*(45) */
19876 { reserved_block , 0 , 0 , 32,
19877 0xfc003fff, 0xa0002e3b, 0 , 0,
19878 CP1_ }, /* POOL32Fxf_0~*(46) */
19879 { reserved_block , 0 , 0 , 32,
19880 0xfc003fff, 0xa0002f3b, 0 , 0,
19881 CP1_ }, /* POOL32Fxf_0~*(47) */
19882 { instruction , 0 , 0 , 32,
19883 0xfc003fff, 0xa000303b, &NMD::MFHC1 , 0,
19884 CP1_ }, /* MFHC1 */
19885 { reserved_block , 0 , 0 , 32,
19886 0xfc003fff, 0xa000313b, 0 , 0,
19887 CP1_ }, /* POOL32Fxf_0~*(49) */
19888 { reserved_block , 0 , 0 , 32,
19889 0xfc003fff, 0xa000323b, 0 , 0,
19890 CP1_ }, /* POOL32Fxf_0~*(50) */
19891 { pool , ROUND_L_fmt , 2 , 32,
19892 0xfc003fff, 0xa000333b, 0 , 0,
19893 CP1_ }, /* ROUND.L.fmt */
19894 { reserved_block , 0 , 0 , 32,
19895 0xfc003fff, 0xa000343b, 0 , 0,
19896 CP1_ }, /* POOL32Fxf_0~*(52) */
19897 { reserved_block , 0 , 0 , 32,
19898 0xfc003fff, 0xa000353b, 0 , 0,
19899 CP1_ }, /* POOL32Fxf_0~*(53) */
19900 { reserved_block , 0 , 0 , 32,
19901 0xfc003fff, 0xa000363b, 0 , 0,
19902 CP1_ }, /* POOL32Fxf_0~*(54) */
19903 { reserved_block , 0 , 0 , 32,
19904 0xfc003fff, 0xa000373b, 0 , 0,
19905 CP1_ }, /* POOL32Fxf_0~*(55) */
19906 { instruction , 0 , 0 , 32,
19907 0xfc003fff, 0xa000383b, &NMD::MTHC1 , 0,
19908 CP1_ }, /* MTHC1 */
19909 { reserved_block , 0 , 0 , 32,
19910 0xfc003fff, 0xa000393b, 0 , 0,
19911 CP1_ }, /* POOL32Fxf_0~*(57) */
19912 { reserved_block , 0 , 0 , 32,
19913 0xfc003fff, 0xa0003a3b, 0 , 0,
19914 CP1_ }, /* POOL32Fxf_0~*(58) */
19915 { pool , ROUND_W_fmt , 2 , 32,
19916 0xfc003fff, 0xa0003b3b, 0 , 0,
19917 CP1_ }, /* ROUND.W.fmt */
19918 { reserved_block , 0 , 0 , 32,
19919 0xfc003fff, 0xa0003c3b, 0 , 0,
19920 CP1_ }, /* POOL32Fxf_0~*(60) */
19921 { reserved_block , 0 , 0 , 32,
19922 0xfc003fff, 0xa0003d3b, 0 , 0,
19923 CP1_ }, /* POOL32Fxf_0~*(61) */
19924 { reserved_block , 0 , 0 , 32,
19925 0xfc003fff, 0xa0003e3b, 0 , 0,
19926 CP1_ }, /* POOL32Fxf_0~*(62) */
19927 { reserved_block , 0 , 0 , 32,
19928 0xfc003fff, 0xa0003f3b, 0 , 0,
19929 CP1_ }, /* POOL32Fxf_0~*(63) */
19930 };
19931
19932
19933 NMD::Pool NMD::MOV_fmt[4] = {
19934 { instruction , 0 , 0 , 32,
19935 0xfc007fff, 0xa000007b, &NMD::MOV_S , 0,
19936 CP1_ }, /* MOV.S */
19937 { instruction , 0 , 0 , 32,
19938 0xfc007fff, 0xa000207b, &NMD::MOV_D , 0,
19939 CP1_ }, /* MOV.D */
19940 { reserved_block , 0 , 0 , 32,
19941 0xfc007fff, 0xa000407b, 0 , 0,
19942 CP1_ }, /* MOV.fmt~*(2) */
19943 { reserved_block , 0 , 0 , 32,
19944 0xfc007fff, 0xa000607b, 0 , 0,
19945 CP1_ }, /* MOV.fmt~*(3) */
19946 };
19947
19948
19949 NMD::Pool NMD::ABS_fmt[4] = {
19950 { instruction , 0 , 0 , 32,
19951 0xfc007fff, 0xa000037b, &NMD::ABS_S , 0,
19952 CP1_ }, /* ABS.S */
19953 { instruction , 0 , 0 , 32,
19954 0xfc007fff, 0xa000237b, &NMD::ABS_D , 0,
19955 CP1_ }, /* ABS.D */
19956 { reserved_block , 0 , 0 , 32,
19957 0xfc007fff, 0xa000437b, 0 , 0,
19958 CP1_ }, /* ABS.fmt~*(2) */
19959 { reserved_block , 0 , 0 , 32,
19960 0xfc007fff, 0xa000637b, 0 , 0,
19961 CP1_ }, /* ABS.fmt~*(3) */
19962 };
19963
19964
19965 NMD::Pool NMD::NEG_fmt[4] = {
19966 { instruction , 0 , 0 , 32,
19967 0xfc007fff, 0xa0000b7b, &NMD::NEG_S , 0,
19968 CP1_ }, /* NEG.S */
19969 { instruction , 0 , 0 , 32,
19970 0xfc007fff, 0xa0002b7b, &NMD::NEG_D , 0,
19971 CP1_ }, /* NEG.D */
19972 { reserved_block , 0 , 0 , 32,
19973 0xfc007fff, 0xa0004b7b, 0 , 0,
19974 CP1_ }, /* NEG.fmt~*(2) */
19975 { reserved_block , 0 , 0 , 32,
19976 0xfc007fff, 0xa0006b7b, 0 , 0,
19977 CP1_ }, /* NEG.fmt~*(3) */
19978 };
19979
19980
19981 NMD::Pool NMD::CVT_D_fmt[4] = {
19982 { instruction , 0 , 0 , 32,
19983 0xfc007fff, 0xa000137b, &NMD::CVT_D_S , 0,
19984 CP1_ }, /* CVT.D.S */
19985 { instruction , 0 , 0 , 32,
19986 0xfc007fff, 0xa000337b, &NMD::CVT_D_W , 0,
19987 CP1_ }, /* CVT.D.W */
19988 { instruction , 0 , 0 , 32,
19989 0xfc007fff, 0xa000537b, &NMD::CVT_D_L , 0,
19990 CP1_ }, /* CVT.D.L */
19991 { reserved_block , 0 , 0 , 32,
19992 0xfc007fff, 0xa000737b, 0 , 0,
19993 CP1_ }, /* CVT.D.fmt~*(3) */
19994 };
19995
19996
19997 NMD::Pool NMD::CVT_S_fmt[4] = {
19998 { instruction , 0 , 0 , 32,
19999 0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D , 0,
20000 CP1_ }, /* CVT.S.D */
20001 { instruction , 0 , 0 , 32,
20002 0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W , 0,
20003 CP1_ }, /* CVT.S.W */
20004 { instruction , 0 , 0 , 32,
20005 0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L , 0,
20006 CP1_ }, /* CVT.S.L */
20007 { reserved_block , 0 , 0 , 32,
20008 0xfc007fff, 0xa0007b7b, 0 , 0,
20009 CP1_ }, /* CVT.S.fmt~*(3) */
20010 };
20011
20012
20013 NMD::Pool NMD::POOL32Fxf_1[32] = {
20014 { pool , MOV_fmt , 4 , 32,
20015 0xfc001fff, 0xa000007b, 0 , 0,
20016 CP1_ }, /* MOV.fmt */
20017 { reserved_block , 0 , 0 , 32,
20018 0xfc001fff, 0xa000017b, 0 , 0,
20019 CP1_ }, /* POOL32Fxf_1~*(1) */
20020 { reserved_block , 0 , 0 , 32,
20021 0xfc001fff, 0xa000027b, 0 , 0,
20022 CP1_ }, /* POOL32Fxf_1~*(2) */
20023 { pool , ABS_fmt , 4 , 32,
20024 0xfc001fff, 0xa000037b, 0 , 0,
20025 CP1_ }, /* ABS.fmt */
20026 { reserved_block , 0 , 0 , 32,
20027 0xfc001fff, 0xa000047b, 0 , 0,
20028 CP1_ }, /* POOL32Fxf_1~*(4) */
20029 { reserved_block , 0 , 0 , 32,
20030 0xfc001fff, 0xa000057b, 0 , 0,
20031 CP1_ }, /* POOL32Fxf_1~*(5) */
20032 { reserved_block , 0 , 0 , 32,
20033 0xfc001fff, 0xa000067b, 0 , 0,
20034 CP1_ }, /* POOL32Fxf_1~*(6) */
20035 { reserved_block , 0 , 0 , 32,
20036 0xfc001fff, 0xa000077b, 0 , 0,
20037 CP1_ }, /* POOL32Fxf_1~*(7) */
20038 { reserved_block , 0 , 0 , 32,
20039 0xfc001fff, 0xa000087b, 0 , 0,
20040 CP1_ }, /* POOL32Fxf_1~*(8) */
20041 { reserved_block , 0 , 0 , 32,
20042 0xfc001fff, 0xa000097b, 0 , 0,
20043 CP1_ }, /* POOL32Fxf_1~*(9) */
20044 { reserved_block , 0 , 0 , 32,
20045 0xfc001fff, 0xa0000a7b, 0 , 0,
20046 CP1_ }, /* POOL32Fxf_1~*(10) */
20047 { pool , NEG_fmt , 4 , 32,
20048 0xfc001fff, 0xa0000b7b, 0 , 0,
20049 CP1_ }, /* NEG.fmt */
20050 { reserved_block , 0 , 0 , 32,
20051 0xfc001fff, 0xa0000c7b, 0 , 0,
20052 CP1_ }, /* POOL32Fxf_1~*(12) */
20053 { reserved_block , 0 , 0 , 32,
20054 0xfc001fff, 0xa0000d7b, 0 , 0,
20055 CP1_ }, /* POOL32Fxf_1~*(13) */
20056 { reserved_block , 0 , 0 , 32,
20057 0xfc001fff, 0xa0000e7b, 0 , 0,
20058 CP1_ }, /* POOL32Fxf_1~*(14) */
20059 { reserved_block , 0 , 0 , 32,
20060 0xfc001fff, 0xa0000f7b, 0 , 0,
20061 CP1_ }, /* POOL32Fxf_1~*(15) */
20062 { reserved_block , 0 , 0 , 32,
20063 0xfc001fff, 0xa000107b, 0 , 0,
20064 CP1_ }, /* POOL32Fxf_1~*(16) */
20065 { reserved_block , 0 , 0 , 32,
20066 0xfc001fff, 0xa000117b, 0 , 0,
20067 CP1_ }, /* POOL32Fxf_1~*(17) */
20068 { reserved_block , 0 , 0 , 32,
20069 0xfc001fff, 0xa000127b, 0 , 0,
20070 CP1_ }, /* POOL32Fxf_1~*(18) */
20071 { pool , CVT_D_fmt , 4 , 32,
20072 0xfc001fff, 0xa000137b, 0 , 0,
20073 CP1_ }, /* CVT.D.fmt */
20074 { reserved_block , 0 , 0 , 32,
20075 0xfc001fff, 0xa000147b, 0 , 0,
20076 CP1_ }, /* POOL32Fxf_1~*(20) */
20077 { reserved_block , 0 , 0 , 32,
20078 0xfc001fff, 0xa000157b, 0 , 0,
20079 CP1_ }, /* POOL32Fxf_1~*(21) */
20080 { reserved_block , 0 , 0 , 32,
20081 0xfc001fff, 0xa000167b, 0 , 0,
20082 CP1_ }, /* POOL32Fxf_1~*(22) */
20083 { reserved_block , 0 , 0 , 32,
20084 0xfc001fff, 0xa000177b, 0 , 0,
20085 CP1_ }, /* POOL32Fxf_1~*(23) */
20086 { reserved_block , 0 , 0 , 32,
20087 0xfc001fff, 0xa000187b, 0 , 0,
20088 CP1_ }, /* POOL32Fxf_1~*(24) */
20089 { reserved_block , 0 , 0 , 32,
20090 0xfc001fff, 0xa000197b, 0 , 0,
20091 CP1_ }, /* POOL32Fxf_1~*(25) */
20092 { reserved_block , 0 , 0 , 32,
20093 0xfc001fff, 0xa0001a7b, 0 , 0,
20094 CP1_ }, /* POOL32Fxf_1~*(26) */
20095 { pool , CVT_S_fmt , 4 , 32,
20096 0xfc001fff, 0xa0001b7b, 0 , 0,
20097 CP1_ }, /* CVT.S.fmt */
20098 { reserved_block , 0 , 0 , 32,
20099 0xfc001fff, 0xa0001c7b, 0 , 0,
20100 CP1_ }, /* POOL32Fxf_1~*(28) */
20101 { reserved_block , 0 , 0 , 32,
20102 0xfc001fff, 0xa0001d7b, 0 , 0,
20103 CP1_ }, /* POOL32Fxf_1~*(29) */
20104 { reserved_block , 0 , 0 , 32,
20105 0xfc001fff, 0xa0001e7b, 0 , 0,
20106 CP1_ }, /* POOL32Fxf_1~*(30) */
20107 { reserved_block , 0 , 0 , 32,
20108 0xfc001fff, 0xa0001f7b, 0 , 0,
20109 CP1_ }, /* POOL32Fxf_1~*(31) */
20110 };
20111
20112
20113 NMD::Pool NMD::POOL32Fxf[4] = {
20114 { pool , POOL32Fxf_0 , 64 , 32,
20115 0xfc0000ff, 0xa000003b, 0 , 0,
20116 CP1_ }, /* POOL32Fxf_0 */
20117 { pool , POOL32Fxf_1 , 32 , 32,
20118 0xfc0000ff, 0xa000007b, 0 , 0,
20119 CP1_ }, /* POOL32Fxf_1 */
20120 { reserved_block , 0 , 0 , 32,
20121 0xfc0000ff, 0xa00000bb, 0 , 0,
20122 CP1_ }, /* POOL32Fxf~*(2) */
20123 { reserved_block , 0 , 0 , 32,
20124 0xfc0000ff, 0xa00000fb, 0 , 0,
20125 CP1_ }, /* POOL32Fxf~*(3) */
20126 };
20127
20128
20129 NMD::Pool NMD::POOL32F_3[8] = {
20130 { pool , MIN_fmt , 2 , 32,
20131 0xfc00003f, 0xa0000003, 0 , 0,
20132 CP1_ }, /* MIN.fmt */
20133 { pool , MAX_fmt , 2 , 32,
20134 0xfc00003f, 0xa000000b, 0 , 0,
20135 CP1_ }, /* MAX.fmt */
20136 { reserved_block , 0 , 0 , 32,
20137 0xfc00003f, 0xa0000013, 0 , 0,
20138 CP1_ }, /* POOL32F_3~*(2) */
20139 { reserved_block , 0 , 0 , 32,
20140 0xfc00003f, 0xa000001b, 0 , 0,
20141 CP1_ }, /* POOL32F_3~*(3) */
20142 { pool , MINA_fmt , 2 , 32,
20143 0xfc00003f, 0xa0000023, 0 , 0,
20144 CP1_ }, /* MINA.fmt */
20145 { pool , MAXA_fmt , 2 , 32,
20146 0xfc00003f, 0xa000002b, 0 , 0,
20147 CP1_ }, /* MAXA.fmt */
20148 { reserved_block , 0 , 0 , 32,
20149 0xfc00003f, 0xa0000033, 0 , 0,
20150 CP1_ }, /* POOL32F_3~*(6) */
20151 { pool , POOL32Fxf , 4 , 32,
20152 0xfc00003f, 0xa000003b, 0 , 0,
20153 CP1_ }, /* POOL32Fxf */
20154 };
20155
20156
20157 NMD::Pool NMD::CMP_condn_S[32] = {
20158 { instruction , 0 , 0 , 32,
20159 0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S , 0,
20160 CP1_ }, /* CMP.AF.S */
20161 { instruction , 0 , 0 , 32,
20162 0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S , 0,
20163 CP1_ }, /* CMP.UN.S */
20164 { instruction , 0 , 0 , 32,
20165 0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S , 0,
20166 CP1_ }, /* CMP.EQ.S */
20167 { instruction , 0 , 0 , 32,
20168 0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S , 0,
20169 CP1_ }, /* CMP.UEQ.S */
20170 { instruction , 0 , 0 , 32,
20171 0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S , 0,
20172 CP1_ }, /* CMP.LT.S */
20173 { instruction , 0 , 0 , 32,
20174 0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S , 0,
20175 CP1_ }, /* CMP.ULT.S */
20176 { instruction , 0 , 0 , 32,
20177 0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S , 0,
20178 CP1_ }, /* CMP.LE.S */
20179 { instruction , 0 , 0 , 32,
20180 0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S , 0,
20181 CP1_ }, /* CMP.ULE.S */
20182 { instruction , 0 , 0 , 32,
20183 0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S , 0,
20184 CP1_ }, /* CMP.SAF.S */
20185 { instruction , 0 , 0 , 32,
20186 0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S , 0,
20187 CP1_ }, /* CMP.SUN.S */
20188 { instruction , 0 , 0 , 32,
20189 0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S , 0,
20190 CP1_ }, /* CMP.SEQ.S */
20191 { instruction , 0 , 0 , 32,
20192 0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S , 0,
20193 CP1_ }, /* CMP.SUEQ.S */
20194 { instruction , 0 , 0 , 32,
20195 0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S , 0,
20196 CP1_ }, /* CMP.SLT.S */
20197 { instruction , 0 , 0 , 32,
20198 0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S , 0,
20199 CP1_ }, /* CMP.SULT.S */
20200 { instruction , 0 , 0 , 32,
20201 0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S , 0,
20202 CP1_ }, /* CMP.SLE.S */
20203 { instruction , 0 , 0 , 32,
20204 0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S , 0,
20205 CP1_ }, /* CMP.SULE.S */
20206 { reserved_block , 0 , 0 , 32,
20207 0xfc0007ff, 0xa0000405, 0 , 0,
20208 CP1_ }, /* CMP.condn.S~*(16) */
20209 { instruction , 0 , 0 , 32,
20210 0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S , 0,
20211 CP1_ }, /* CMP.OR.S */
20212 { instruction , 0 , 0 , 32,
20213 0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S , 0,
20214 CP1_ }, /* CMP.UNE.S */
20215 { instruction , 0 , 0 , 32,
20216 0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S , 0,
20217 CP1_ }, /* CMP.NE.S */
20218 { reserved_block , 0 , 0 , 32,
20219 0xfc0007ff, 0xa0000505, 0 , 0,
20220 CP1_ }, /* CMP.condn.S~*(20) */
20221 { reserved_block , 0 , 0 , 32,
20222 0xfc0007ff, 0xa0000545, 0 , 0,
20223 CP1_ }, /* CMP.condn.S~*(21) */
20224 { reserved_block , 0 , 0 , 32,
20225 0xfc0007ff, 0xa0000585, 0 , 0,
20226 CP1_ }, /* CMP.condn.S~*(22) */
20227 { reserved_block , 0 , 0 , 32,
20228 0xfc0007ff, 0xa00005c5, 0 , 0,
20229 CP1_ }, /* CMP.condn.S~*(23) */
20230 { reserved_block , 0 , 0 , 32,
20231 0xfc0007ff, 0xa0000605, 0 , 0,
20232 CP1_ }, /* CMP.condn.S~*(24) */
20233 { instruction , 0 , 0 , 32,
20234 0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S , 0,
20235 CP1_ }, /* CMP.SOR.S */
20236 { instruction , 0 , 0 , 32,
20237 0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S , 0,
20238 CP1_ }, /* CMP.SUNE.S */
20239 { instruction , 0 , 0 , 32,
20240 0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S , 0,
20241 CP1_ }, /* CMP.SNE.S */
20242 { reserved_block , 0 , 0 , 32,
20243 0xfc0007ff, 0xa0000705, 0 , 0,
20244 CP1_ }, /* CMP.condn.S~*(28) */
20245 { reserved_block , 0 , 0 , 32,
20246 0xfc0007ff, 0xa0000745, 0 , 0,
20247 CP1_ }, /* CMP.condn.S~*(29) */
20248 { reserved_block , 0 , 0 , 32,
20249 0xfc0007ff, 0xa0000785, 0 , 0,
20250 CP1_ }, /* CMP.condn.S~*(30) */
20251 { reserved_block , 0 , 0 , 32,
20252 0xfc0007ff, 0xa00007c5, 0 , 0,
20253 CP1_ }, /* CMP.condn.S~*(31) */
20254 };
20255
20256
20257 NMD::Pool NMD::CMP_condn_D[32] = {
20258 { instruction , 0 , 0 , 32,
20259 0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D , 0,
20260 CP1_ }, /* CMP.AF.D */
20261 { instruction , 0 , 0 , 32,
20262 0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D , 0,
20263 CP1_ }, /* CMP.UN.D */
20264 { instruction , 0 , 0 , 32,
20265 0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D , 0,
20266 CP1_ }, /* CMP.EQ.D */
20267 { instruction , 0 , 0 , 32,
20268 0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D , 0,
20269 CP1_ }, /* CMP.UEQ.D */
20270 { instruction , 0 , 0 , 32,
20271 0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D , 0,
20272 CP1_ }, /* CMP.LT.D */
20273 { instruction , 0 , 0 , 32,
20274 0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D , 0,
20275 CP1_ }, /* CMP.ULT.D */
20276 { instruction , 0 , 0 , 32,
20277 0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D , 0,
20278 CP1_ }, /* CMP.LE.D */
20279 { instruction , 0 , 0 , 32,
20280 0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D , 0,
20281 CP1_ }, /* CMP.ULE.D */
20282 { instruction , 0 , 0 , 32,
20283 0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D , 0,
20284 CP1_ }, /* CMP.SAF.D */
20285 { instruction , 0 , 0 , 32,
20286 0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D , 0,
20287 CP1_ }, /* CMP.SUN.D */
20288 { instruction , 0 , 0 , 32,
20289 0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D , 0,
20290 CP1_ }, /* CMP.SEQ.D */
20291 { instruction , 0 , 0 , 32,
20292 0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D , 0,
20293 CP1_ }, /* CMP.SUEQ.D */
20294 { instruction , 0 , 0 , 32,
20295 0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D , 0,
20296 CP1_ }, /* CMP.SLT.D */
20297 { instruction , 0 , 0 , 32,
20298 0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D , 0,
20299 CP1_ }, /* CMP.SULT.D */
20300 { instruction , 0 , 0 , 32,
20301 0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D , 0,
20302 CP1_ }, /* CMP.SLE.D */
20303 { instruction , 0 , 0 , 32,
20304 0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D , 0,
20305 CP1_ }, /* CMP.SULE.D */
20306 { reserved_block , 0 , 0 , 32,
20307 0xfc0007ff, 0xa0000415, 0 , 0,
20308 CP1_ }, /* CMP.condn.D~*(16) */
20309 { instruction , 0 , 0 , 32,
20310 0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D , 0,
20311 CP1_ }, /* CMP.OR.D */
20312 { instruction , 0 , 0 , 32,
20313 0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D , 0,
20314 CP1_ }, /* CMP.UNE.D */
20315 { instruction , 0 , 0 , 32,
20316 0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D , 0,
20317 CP1_ }, /* CMP.NE.D */
20318 { reserved_block , 0 , 0 , 32,
20319 0xfc0007ff, 0xa0000515, 0 , 0,
20320 CP1_ }, /* CMP.condn.D~*(20) */
20321 { reserved_block , 0 , 0 , 32,
20322 0xfc0007ff, 0xa0000555, 0 , 0,
20323 CP1_ }, /* CMP.condn.D~*(21) */
20324 { reserved_block , 0 , 0 , 32,
20325 0xfc0007ff, 0xa0000595, 0 , 0,
20326 CP1_ }, /* CMP.condn.D~*(22) */
20327 { reserved_block , 0 , 0 , 32,
20328 0xfc0007ff, 0xa00005d5, 0 , 0,
20329 CP1_ }, /* CMP.condn.D~*(23) */
20330 { reserved_block , 0 , 0 , 32,
20331 0xfc0007ff, 0xa0000615, 0 , 0,
20332 CP1_ }, /* CMP.condn.D~*(24) */
20333 { instruction , 0 , 0 , 32,
20334 0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D , 0,
20335 CP1_ }, /* CMP.SOR.D */
20336 { instruction , 0 , 0 , 32,
20337 0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D , 0,
20338 CP1_ }, /* CMP.SUNE.D */
20339 { instruction , 0 , 0 , 32,
20340 0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D , 0,
20341 CP1_ }, /* CMP.SNE.D */
20342 { reserved_block , 0 , 0 , 32,
20343 0xfc0007ff, 0xa0000715, 0 , 0,
20344 CP1_ }, /* CMP.condn.D~*(28) */
20345 { reserved_block , 0 , 0 , 32,
20346 0xfc0007ff, 0xa0000755, 0 , 0,
20347 CP1_ }, /* CMP.condn.D~*(29) */
20348 { reserved_block , 0 , 0 , 32,
20349 0xfc0007ff, 0xa0000795, 0 , 0,
20350 CP1_ }, /* CMP.condn.D~*(30) */
20351 { reserved_block , 0 , 0 , 32,
20352 0xfc0007ff, 0xa00007d5, 0 , 0,
20353 CP1_ }, /* CMP.condn.D~*(31) */
20354 };
20355
20356
20357 NMD::Pool NMD::POOL32F_5[8] = {
20358 { pool , CMP_condn_S , 32 , 32,
20359 0xfc00003f, 0xa0000005, 0 , 0,
20360 CP1_ }, /* CMP.condn.S */
20361 { reserved_block , 0 , 0 , 32,
20362 0xfc00003f, 0xa000000d, 0 , 0,
20363 CP1_ }, /* POOL32F_5~*(1) */
20364 { pool , CMP_condn_D , 32 , 32,
20365 0xfc00003f, 0xa0000015, 0 , 0,
20366 CP1_ }, /* CMP.condn.D */
20367 { reserved_block , 0 , 0 , 32,
20368 0xfc00003f, 0xa000001d, 0 , 0,
20369 CP1_ }, /* POOL32F_5~*(3) */
20370 { reserved_block , 0 , 0 , 32,
20371 0xfc00003f, 0xa0000025, 0 , 0,
20372 CP1_ }, /* POOL32F_5~*(4) */
20373 { reserved_block , 0 , 0 , 32,
20374 0xfc00003f, 0xa000002d, 0 , 0,
20375 CP1_ }, /* POOL32F_5~*(5) */
20376 { reserved_block , 0 , 0 , 32,
20377 0xfc00003f, 0xa0000035, 0 , 0,
20378 CP1_ }, /* POOL32F_5~*(6) */
20379 { reserved_block , 0 , 0 , 32,
20380 0xfc00003f, 0xa000003d, 0 , 0,
20381 CP1_ }, /* POOL32F_5~*(7) */
20382 };
20383
20384
20385 NMD::Pool NMD::POOL32F[8] = {
20386 { pool , POOL32F_0 , 64 , 32,
20387 0xfc000007, 0xa0000000, 0 , 0,
20388 CP1_ }, /* POOL32F_0 */
20389 { reserved_block , 0 , 0 , 32,
20390 0xfc000007, 0xa0000001, 0 , 0,
20391 CP1_ }, /* POOL32F~*(1) */
20392 { reserved_block , 0 , 0 , 32,
20393 0xfc000007, 0xa0000002, 0 , 0,
20394 CP1_ }, /* POOL32F~*(2) */
20395 { pool , POOL32F_3 , 8 , 32,
20396 0xfc000007, 0xa0000003, 0 , 0,
20397 CP1_ }, /* POOL32F_3 */
20398 { reserved_block , 0 , 0 , 32,
20399 0xfc000007, 0xa0000004, 0 , 0,
20400 CP1_ }, /* POOL32F~*(4) */
20401 { pool , POOL32F_5 , 8 , 32,
20402 0xfc000007, 0xa0000005, 0 , 0,
20403 CP1_ }, /* POOL32F_5 */
20404 { reserved_block , 0 , 0 , 32,
20405 0xfc000007, 0xa0000006, 0 , 0,
20406 CP1_ }, /* POOL32F~*(6) */
20407 { reserved_block , 0 , 0 , 32,
20408 0xfc000007, 0xa0000007, 0 , 0,
20409 CP1_ }, /* POOL32F~*(7) */
20410 };
20411
20412
20413 NMD::Pool NMD::POOL32S_0[64] = {
20414 { reserved_block , 0 , 0 , 32,
20415 0xfc0001ff, 0xc0000000, 0 , 0,
20416 0x0 }, /* POOL32S_0~*(0) */
20417 { instruction , 0 , 0 , 32,
20418 0xfc0001ff, 0xc0000008, &NMD::DLSA , 0,
20419 MIPS64_ }, /* DLSA */
20420 { instruction , 0 , 0 , 32,
20421 0xfc0001ff, 0xc0000010, &NMD::DSLLV , 0,
20422 MIPS64_ }, /* DSLLV */
20423 { instruction , 0 , 0 , 32,
20424 0xfc0001ff, 0xc0000018, &NMD::DMUL , 0,
20425 MIPS64_ }, /* DMUL */
20426 { reserved_block , 0 , 0 , 32,
20427 0xfc0001ff, 0xc0000020, 0 , 0,
20428 0x0 }, /* POOL32S_0~*(4) */
20429 { reserved_block , 0 , 0 , 32,
20430 0xfc0001ff, 0xc0000028, 0 , 0,
20431 0x0 }, /* POOL32S_0~*(5) */
20432 { reserved_block , 0 , 0 , 32,
20433 0xfc0001ff, 0xc0000030, 0 , 0,
20434 0x0 }, /* POOL32S_0~*(6) */
20435 { reserved_block , 0 , 0 , 32,
20436 0xfc0001ff, 0xc0000038, 0 , 0,
20437 0x0 }, /* POOL32S_0~*(7) */
20438 { reserved_block , 0 , 0 , 32,
20439 0xfc0001ff, 0xc0000040, 0 , 0,
20440 0x0 }, /* POOL32S_0~*(8) */
20441 { reserved_block , 0 , 0 , 32,
20442 0xfc0001ff, 0xc0000048, 0 , 0,
20443 0x0 }, /* POOL32S_0~*(9) */
20444 { instruction , 0 , 0 , 32,
20445 0xfc0001ff, 0xc0000050, &NMD::DSRLV , 0,
20446 MIPS64_ }, /* DSRLV */
20447 { instruction , 0 , 0 , 32,
20448 0xfc0001ff, 0xc0000058, &NMD::DMUH , 0,
20449 MIPS64_ }, /* DMUH */
20450 { reserved_block , 0 , 0 , 32,
20451 0xfc0001ff, 0xc0000060, 0 , 0,
20452 0x0 }, /* POOL32S_0~*(12) */
20453 { reserved_block , 0 , 0 , 32,
20454 0xfc0001ff, 0xc0000068, 0 , 0,
20455 0x0 }, /* POOL32S_0~*(13) */
20456 { reserved_block , 0 , 0 , 32,
20457 0xfc0001ff, 0xc0000070, 0 , 0,
20458 0x0 }, /* POOL32S_0~*(14) */
20459 { reserved_block , 0 , 0 , 32,
20460 0xfc0001ff, 0xc0000078, 0 , 0,
20461 0x0 }, /* POOL32S_0~*(15) */
20462 { reserved_block , 0 , 0 , 32,
20463 0xfc0001ff, 0xc0000080, 0 , 0,
20464 0x0 }, /* POOL32S_0~*(16) */
20465 { reserved_block , 0 , 0 , 32,
20466 0xfc0001ff, 0xc0000088, 0 , 0,
20467 0x0 }, /* POOL32S_0~*(17) */
20468 { instruction , 0 , 0 , 32,
20469 0xfc0001ff, 0xc0000090, &NMD::DSRAV , 0,
20470 MIPS64_ }, /* DSRAV */
20471 { instruction , 0 , 0 , 32,
20472 0xfc0001ff, 0xc0000098, &NMD::DMULU , 0,
20473 MIPS64_ }, /* DMULU */
20474 { reserved_block , 0 , 0 , 32,
20475 0xfc0001ff, 0xc00000a0, 0 , 0,
20476 0x0 }, /* POOL32S_0~*(20) */
20477 { reserved_block , 0 , 0 , 32,
20478 0xfc0001ff, 0xc00000a8, 0 , 0,
20479 0x0 }, /* POOL32S_0~*(21) */
20480 { reserved_block , 0 , 0 , 32,
20481 0xfc0001ff, 0xc00000b0, 0 , 0,
20482 0x0 }, /* POOL32S_0~*(22) */
20483 { reserved_block , 0 , 0 , 32,
20484 0xfc0001ff, 0xc00000b8, 0 , 0,
20485 0x0 }, /* POOL32S_0~*(23) */
20486 { reserved_block , 0 , 0 , 32,
20487 0xfc0001ff, 0xc00000c0, 0 , 0,
20488 0x0 }, /* POOL32S_0~*(24) */
20489 { reserved_block , 0 , 0 , 32,
20490 0xfc0001ff, 0xc00000c8, 0 , 0,
20491 0x0 }, /* POOL32S_0~*(25) */
20492 { instruction , 0 , 0 , 32,
20493 0xfc0001ff, 0xc00000d0, &NMD::DROTRV , 0,
20494 MIPS64_ }, /* DROTRV */
20495 { instruction , 0 , 0 , 32,
20496 0xfc0001ff, 0xc00000d8, &NMD::DMUHU , 0,
20497 MIPS64_ }, /* DMUHU */
20498 { reserved_block , 0 , 0 , 32,
20499 0xfc0001ff, 0xc00000e0, 0 , 0,
20500 0x0 }, /* POOL32S_0~*(28) */
20501 { reserved_block , 0 , 0 , 32,
20502 0xfc0001ff, 0xc00000e8, 0 , 0,
20503 0x0 }, /* POOL32S_0~*(29) */
20504 { reserved_block , 0 , 0 , 32,
20505 0xfc0001ff, 0xc00000f0, 0 , 0,
20506 0x0 }, /* POOL32S_0~*(30) */
20507 { reserved_block , 0 , 0 , 32,
20508 0xfc0001ff, 0xc00000f8, 0 , 0,
20509 0x0 }, /* POOL32S_0~*(31) */
20510 { reserved_block , 0 , 0 , 32,
20511 0xfc0001ff, 0xc0000100, 0 , 0,
20512 0x0 }, /* POOL32S_0~*(32) */
20513 { reserved_block , 0 , 0 , 32,
20514 0xfc0001ff, 0xc0000108, 0 , 0,
20515 0x0 }, /* POOL32S_0~*(33) */
20516 { instruction , 0 , 0 , 32,
20517 0xfc0001ff, 0xc0000110, &NMD::DADD , 0,
20518 MIPS64_ }, /* DADD */
20519 { instruction , 0 , 0 , 32,
20520 0xfc0001ff, 0xc0000118, &NMD::DDIV , 0,
20521 MIPS64_ }, /* DDIV */
20522 { reserved_block , 0 , 0 , 32,
20523 0xfc0001ff, 0xc0000120, 0 , 0,
20524 0x0 }, /* POOL32S_0~*(36) */
20525 { reserved_block , 0 , 0 , 32,
20526 0xfc0001ff, 0xc0000128, 0 , 0,
20527 0x0 }, /* POOL32S_0~*(37) */
20528 { reserved_block , 0 , 0 , 32,
20529 0xfc0001ff, 0xc0000130, 0 , 0,
20530 0x0 }, /* POOL32S_0~*(38) */
20531 { reserved_block , 0 , 0 , 32,
20532 0xfc0001ff, 0xc0000138, 0 , 0,
20533 0x0 }, /* POOL32S_0~*(39) */
20534 { reserved_block , 0 , 0 , 32,
20535 0xfc0001ff, 0xc0000140, 0 , 0,
20536 0x0 }, /* POOL32S_0~*(40) */
20537 { reserved_block , 0 , 0 , 32,
20538 0xfc0001ff, 0xc0000148, 0 , 0,
20539 0x0 }, /* POOL32S_0~*(41) */
20540 { instruction , 0 , 0 , 32,
20541 0xfc0001ff, 0xc0000150, &NMD::DADDU , 0,
20542 MIPS64_ }, /* DADDU */
20543 { instruction , 0 , 0 , 32,
20544 0xfc0001ff, 0xc0000158, &NMD::DMOD , 0,
20545 MIPS64_ }, /* DMOD */
20546 { reserved_block , 0 , 0 , 32,
20547 0xfc0001ff, 0xc0000160, 0 , 0,
20548 0x0 }, /* POOL32S_0~*(44) */
20549 { reserved_block , 0 , 0 , 32,
20550 0xfc0001ff, 0xc0000168, 0 , 0,
20551 0x0 }, /* POOL32S_0~*(45) */
20552 { reserved_block , 0 , 0 , 32,
20553 0xfc0001ff, 0xc0000170, 0 , 0,
20554 0x0 }, /* POOL32S_0~*(46) */
20555 { reserved_block , 0 , 0 , 32,
20556 0xfc0001ff, 0xc0000178, 0 , 0,
20557 0x0 }, /* POOL32S_0~*(47) */
20558 { reserved_block , 0 , 0 , 32,
20559 0xfc0001ff, 0xc0000180, 0 , 0,
20560 0x0 }, /* POOL32S_0~*(48) */
20561 { reserved_block , 0 , 0 , 32,
20562 0xfc0001ff, 0xc0000188, 0 , 0,
20563 0x0 }, /* POOL32S_0~*(49) */
20564 { instruction , 0 , 0 , 32,
20565 0xfc0001ff, 0xc0000190, &NMD::DSUB , 0,
20566 MIPS64_ }, /* DSUB */
20567 { instruction , 0 , 0 , 32,
20568 0xfc0001ff, 0xc0000198, &NMD::DDIVU , 0,
20569 MIPS64_ }, /* DDIVU */
20570 { reserved_block , 0 , 0 , 32,
20571 0xfc0001ff, 0xc00001a0, 0 , 0,
20572 0x0 }, /* POOL32S_0~*(52) */
20573 { reserved_block , 0 , 0 , 32,
20574 0xfc0001ff, 0xc00001a8, 0 , 0,
20575 0x0 }, /* POOL32S_0~*(53) */
20576 { reserved_block , 0 , 0 , 32,
20577 0xfc0001ff, 0xc00001b0, 0 , 0,
20578 0x0 }, /* POOL32S_0~*(54) */
20579 { reserved_block , 0 , 0 , 32,
20580 0xfc0001ff, 0xc00001b8, 0 , 0,
20581 0x0 }, /* POOL32S_0~*(55) */
20582 { reserved_block , 0 , 0 , 32,
20583 0xfc0001ff, 0xc00001c0, 0 , 0,
20584 0x0 }, /* POOL32S_0~*(56) */
20585 { reserved_block , 0 , 0 , 32,
20586 0xfc0001ff, 0xc00001c8, 0 , 0,
20587 0x0 }, /* POOL32S_0~*(57) */
20588 { instruction , 0 , 0 , 32,
20589 0xfc0001ff, 0xc00001d0, &NMD::DSUBU , 0,
20590 MIPS64_ }, /* DSUBU */
20591 { instruction , 0 , 0 , 32,
20592 0xfc0001ff, 0xc00001d8, &NMD::DMODU , 0,
20593 MIPS64_ }, /* DMODU */
20594 { reserved_block , 0 , 0 , 32,
20595 0xfc0001ff, 0xc00001e0, 0 , 0,
20596 0x0 }, /* POOL32S_0~*(60) */
20597 { reserved_block , 0 , 0 , 32,
20598 0xfc0001ff, 0xc00001e8, 0 , 0,
20599 0x0 }, /* POOL32S_0~*(61) */
20600 { reserved_block , 0 , 0 , 32,
20601 0xfc0001ff, 0xc00001f0, 0 , 0,
20602 0x0 }, /* POOL32S_0~*(62) */
20603 { reserved_block , 0 , 0 , 32,
20604 0xfc0001ff, 0xc00001f8, 0 , 0,
20605 0x0 }, /* POOL32S_0~*(63) */
20606 };
20607
20608
20609 NMD::Pool NMD::POOL32Sxf_4[128] = {
20610 { reserved_block , 0 , 0 , 32,
20611 0xfc00ffff, 0xc000013c, 0 , 0,
20612 0x0 }, /* POOL32Sxf_4~*(0) */
20613 { reserved_block , 0 , 0 , 32,
20614 0xfc00ffff, 0xc000033c, 0 , 0,
20615 0x0 }, /* POOL32Sxf_4~*(1) */
20616 { reserved_block , 0 , 0 , 32,
20617 0xfc00ffff, 0xc000053c, 0 , 0,
20618 0x0 }, /* POOL32Sxf_4~*(2) */
20619 { reserved_block , 0 , 0 , 32,
20620 0xfc00ffff, 0xc000073c, 0 , 0,
20621 0x0 }, /* POOL32Sxf_4~*(3) */
20622 { reserved_block , 0 , 0 , 32,
20623 0xfc00ffff, 0xc000093c, 0 , 0,
20624 0x0 }, /* POOL32Sxf_4~*(4) */
20625 { reserved_block , 0 , 0 , 32,
20626 0xfc00ffff, 0xc0000b3c, 0 , 0,
20627 0x0 }, /* POOL32Sxf_4~*(5) */
20628 { reserved_block , 0 , 0 , 32,
20629 0xfc00ffff, 0xc0000d3c, 0 , 0,
20630 0x0 }, /* POOL32Sxf_4~*(6) */
20631 { reserved_block , 0 , 0 , 32,
20632 0xfc00ffff, 0xc0000f3c, 0 , 0,
20633 0x0 }, /* POOL32Sxf_4~*(7) */
20634 { reserved_block , 0 , 0 , 32,
20635 0xfc00ffff, 0xc000113c, 0 , 0,
20636 0x0 }, /* POOL32Sxf_4~*(8) */
20637 { reserved_block , 0 , 0 , 32,
20638 0xfc00ffff, 0xc000133c, 0 , 0,
20639 0x0 }, /* POOL32Sxf_4~*(9) */
20640 { reserved_block , 0 , 0 , 32,
20641 0xfc00ffff, 0xc000153c, 0 , 0,
20642 0x0 }, /* POOL32Sxf_4~*(10) */
20643 { reserved_block , 0 , 0 , 32,
20644 0xfc00ffff, 0xc000173c, 0 , 0,
20645 0x0 }, /* POOL32Sxf_4~*(11) */
20646 { reserved_block , 0 , 0 , 32,
20647 0xfc00ffff, 0xc000193c, 0 , 0,
20648 0x0 }, /* POOL32Sxf_4~*(12) */
20649 { reserved_block , 0 , 0 , 32,
20650 0xfc00ffff, 0xc0001b3c, 0 , 0,
20651 0x0 }, /* POOL32Sxf_4~*(13) */
20652 { reserved_block , 0 , 0 , 32,
20653 0xfc00ffff, 0xc0001d3c, 0 , 0,
20654 0x0 }, /* POOL32Sxf_4~*(14) */
20655 { reserved_block , 0 , 0 , 32,
20656 0xfc00ffff, 0xc0001f3c, 0 , 0,
20657 0x0 }, /* POOL32Sxf_4~*(15) */
20658 { reserved_block , 0 , 0 , 32,
20659 0xfc00ffff, 0xc000213c, 0 , 0,
20660 0x0 }, /* POOL32Sxf_4~*(16) */
20661 { reserved_block , 0 , 0 , 32,
20662 0xfc00ffff, 0xc000233c, 0 , 0,
20663 0x0 }, /* POOL32Sxf_4~*(17) */
20664 { reserved_block , 0 , 0 , 32,
20665 0xfc00ffff, 0xc000253c, 0 , 0,
20666 0x0 }, /* POOL32Sxf_4~*(18) */
20667 { reserved_block , 0 , 0 , 32,
20668 0xfc00ffff, 0xc000273c, 0 , 0,
20669 0x0 }, /* POOL32Sxf_4~*(19) */
20670 { reserved_block , 0 , 0 , 32,
20671 0xfc00ffff, 0xc000293c, 0 , 0,
20672 0x0 }, /* POOL32Sxf_4~*(20) */
20673 { reserved_block , 0 , 0 , 32,
20674 0xfc00ffff, 0xc0002b3c, 0 , 0,
20675 0x0 }, /* POOL32Sxf_4~*(21) */
20676 { reserved_block , 0 , 0 , 32,
20677 0xfc00ffff, 0xc0002d3c, 0 , 0,
20678 0x0 }, /* POOL32Sxf_4~*(22) */
20679 { reserved_block , 0 , 0 , 32,
20680 0xfc00ffff, 0xc0002f3c, 0 , 0,
20681 0x0 }, /* POOL32Sxf_4~*(23) */
20682 { reserved_block , 0 , 0 , 32,
20683 0xfc00ffff, 0xc000313c, 0 , 0,
20684 0x0 }, /* POOL32Sxf_4~*(24) */
20685 { reserved_block , 0 , 0 , 32,
20686 0xfc00ffff, 0xc000333c, 0 , 0,
20687 0x0 }, /* POOL32Sxf_4~*(25) */
20688 { reserved_block , 0 , 0 , 32,
20689 0xfc00ffff, 0xc000353c, 0 , 0,
20690 0x0 }, /* POOL32Sxf_4~*(26) */
20691 { reserved_block , 0 , 0 , 32,
20692 0xfc00ffff, 0xc000373c, 0 , 0,
20693 0x0 }, /* POOL32Sxf_4~*(27) */
20694 { reserved_block , 0 , 0 , 32,
20695 0xfc00ffff, 0xc000393c, 0 , 0,
20696 0x0 }, /* POOL32Sxf_4~*(28) */
20697 { reserved_block , 0 , 0 , 32,
20698 0xfc00ffff, 0xc0003b3c, 0 , 0,
20699 0x0 }, /* POOL32Sxf_4~*(29) */
20700 { reserved_block , 0 , 0 , 32,
20701 0xfc00ffff, 0xc0003d3c, 0 , 0,
20702 0x0 }, /* POOL32Sxf_4~*(30) */
20703 { reserved_block , 0 , 0 , 32,
20704 0xfc00ffff, 0xc0003f3c, 0 , 0,
20705 0x0 }, /* POOL32Sxf_4~*(31) */
20706 { reserved_block , 0 , 0 , 32,
20707 0xfc00ffff, 0xc000413c, 0 , 0,
20708 0x0 }, /* POOL32Sxf_4~*(32) */
20709 { reserved_block , 0 , 0 , 32,
20710 0xfc00ffff, 0xc000433c, 0 , 0,
20711 0x0 }, /* POOL32Sxf_4~*(33) */
20712 { reserved_block , 0 , 0 , 32,
20713 0xfc00ffff, 0xc000453c, 0 , 0,
20714 0x0 }, /* POOL32Sxf_4~*(34) */
20715 { reserved_block , 0 , 0 , 32,
20716 0xfc00ffff, 0xc000473c, 0 , 0,
20717 0x0 }, /* POOL32Sxf_4~*(35) */
20718 { reserved_block , 0 , 0 , 32,
20719 0xfc00ffff, 0xc000493c, 0 , 0,
20720 0x0 }, /* POOL32Sxf_4~*(36) */
20721 { instruction , 0 , 0 , 32,
20722 0xfc00ffff, 0xc0004b3c, &NMD::DCLO , 0,
20723 MIPS64_ }, /* DCLO */
20724 { reserved_block , 0 , 0 , 32,
20725 0xfc00ffff, 0xc0004d3c, 0 , 0,
20726 0x0 }, /* POOL32Sxf_4~*(38) */
20727 { reserved_block , 0 , 0 , 32,
20728 0xfc00ffff, 0xc0004f3c, 0 , 0,
20729 0x0 }, /* POOL32Sxf_4~*(39) */
20730 { reserved_block , 0 , 0 , 32,
20731 0xfc00ffff, 0xc000513c, 0 , 0,
20732 0x0 }, /* POOL32Sxf_4~*(40) */
20733 { reserved_block , 0 , 0 , 32,
20734 0xfc00ffff, 0xc000533c, 0 , 0,
20735 0x0 }, /* POOL32Sxf_4~*(41) */
20736 { reserved_block , 0 , 0 , 32,
20737 0xfc00ffff, 0xc000553c, 0 , 0,
20738 0x0 }, /* POOL32Sxf_4~*(42) */
20739 { reserved_block , 0 , 0 , 32,
20740 0xfc00ffff, 0xc000573c, 0 , 0,
20741 0x0 }, /* POOL32Sxf_4~*(43) */
20742 { reserved_block , 0 , 0 , 32,
20743 0xfc00ffff, 0xc000593c, 0 , 0,
20744 0x0 }, /* POOL32Sxf_4~*(44) */
20745 { instruction , 0 , 0 , 32,
20746 0xfc00ffff, 0xc0005b3c, &NMD::DCLZ , 0,
20747 MIPS64_ }, /* DCLZ */
20748 { reserved_block , 0 , 0 , 32,
20749 0xfc00ffff, 0xc0005d3c, 0 , 0,
20750 0x0 }, /* POOL32Sxf_4~*(46) */
20751 { reserved_block , 0 , 0 , 32,
20752 0xfc00ffff, 0xc0005f3c, 0 , 0,
20753 0x0 }, /* POOL32Sxf_4~*(47) */
20754 { reserved_block , 0 , 0 , 32,
20755 0xfc00ffff, 0xc000613c, 0 , 0,
20756 0x0 }, /* POOL32Sxf_4~*(48) */
20757 { reserved_block , 0 , 0 , 32,
20758 0xfc00ffff, 0xc000633c, 0 , 0,
20759 0x0 }, /* POOL32Sxf_4~*(49) */
20760 { reserved_block , 0 , 0 , 32,
20761 0xfc00ffff, 0xc000653c, 0 , 0,
20762 0x0 }, /* POOL32Sxf_4~*(50) */
20763 { reserved_block , 0 , 0 , 32,
20764 0xfc00ffff, 0xc000673c, 0 , 0,
20765 0x0 }, /* POOL32Sxf_4~*(51) */
20766 { reserved_block , 0 , 0 , 32,
20767 0xfc00ffff, 0xc000693c, 0 , 0,
20768 0x0 }, /* POOL32Sxf_4~*(52) */
20769 { reserved_block , 0 , 0 , 32,
20770 0xfc00ffff, 0xc0006b3c, 0 , 0,
20771 0x0 }, /* POOL32Sxf_4~*(53) */
20772 { reserved_block , 0 , 0 , 32,
20773 0xfc00ffff, 0xc0006d3c, 0 , 0,
20774 0x0 }, /* POOL32Sxf_4~*(54) */
20775 { reserved_block , 0 , 0 , 32,
20776 0xfc00ffff, 0xc0006f3c, 0 , 0,
20777 0x0 }, /* POOL32Sxf_4~*(55) */
20778 { reserved_block , 0 , 0 , 32,
20779 0xfc00ffff, 0xc000713c, 0 , 0,
20780 0x0 }, /* POOL32Sxf_4~*(56) */
20781 { reserved_block , 0 , 0 , 32,
20782 0xfc00ffff, 0xc000733c, 0 , 0,
20783 0x0 }, /* POOL32Sxf_4~*(57) */
20784 { reserved_block , 0 , 0 , 32,
20785 0xfc00ffff, 0xc000753c, 0 , 0,
20786 0x0 }, /* POOL32Sxf_4~*(58) */
20787 { reserved_block , 0 , 0 , 32,
20788 0xfc00ffff, 0xc000773c, 0 , 0,
20789 0x0 }, /* POOL32Sxf_4~*(59) */
20790 { reserved_block , 0 , 0 , 32,
20791 0xfc00ffff, 0xc000793c, 0 , 0,
20792 0x0 }, /* POOL32Sxf_4~*(60) */
20793 { reserved_block , 0 , 0 , 32,
20794 0xfc00ffff, 0xc0007b3c, 0 , 0,
20795 0x0 }, /* POOL32Sxf_4~*(61) */
20796 { reserved_block , 0 , 0 , 32,
20797 0xfc00ffff, 0xc0007d3c, 0 , 0,
20798 0x0 }, /* POOL32Sxf_4~*(62) */
20799 { reserved_block , 0 , 0 , 32,
20800 0xfc00ffff, 0xc0007f3c, 0 , 0,
20801 0x0 }, /* POOL32Sxf_4~*(63) */
20802 { reserved_block , 0 , 0 , 32,
20803 0xfc00ffff, 0xc000813c, 0 , 0,
20804 0x0 }, /* POOL32Sxf_4~*(64) */
20805 { reserved_block , 0 , 0 , 32,
20806 0xfc00ffff, 0xc000833c, 0 , 0,
20807 0x0 }, /* POOL32Sxf_4~*(65) */
20808 { reserved_block , 0 , 0 , 32,
20809 0xfc00ffff, 0xc000853c, 0 , 0,
20810 0x0 }, /* POOL32Sxf_4~*(66) */
20811 { reserved_block , 0 , 0 , 32,
20812 0xfc00ffff, 0xc000873c, 0 , 0,
20813 0x0 }, /* POOL32Sxf_4~*(67) */
20814 { reserved_block , 0 , 0 , 32,
20815 0xfc00ffff, 0xc000893c, 0 , 0,
20816 0x0 }, /* POOL32Sxf_4~*(68) */
20817 { reserved_block , 0 , 0 , 32,
20818 0xfc00ffff, 0xc0008b3c, 0 , 0,
20819 0x0 }, /* POOL32Sxf_4~*(69) */
20820 { reserved_block , 0 , 0 , 32,
20821 0xfc00ffff, 0xc0008d3c, 0 , 0,
20822 0x0 }, /* POOL32Sxf_4~*(70) */
20823 { reserved_block , 0 , 0 , 32,
20824 0xfc00ffff, 0xc0008f3c, 0 , 0,
20825 0x0 }, /* POOL32Sxf_4~*(71) */
20826 { reserved_block , 0 , 0 , 32,
20827 0xfc00ffff, 0xc000913c, 0 , 0,
20828 0x0 }, /* POOL32Sxf_4~*(72) */
20829 { reserved_block , 0 , 0 , 32,
20830 0xfc00ffff, 0xc000933c, 0 , 0,
20831 0x0 }, /* POOL32Sxf_4~*(73) */
20832 { reserved_block , 0 , 0 , 32,
20833 0xfc00ffff, 0xc000953c, 0 , 0,
20834 0x0 }, /* POOL32Sxf_4~*(74) */
20835 { reserved_block , 0 , 0 , 32,
20836 0xfc00ffff, 0xc000973c, 0 , 0,
20837 0x0 }, /* POOL32Sxf_4~*(75) */
20838 { reserved_block , 0 , 0 , 32,
20839 0xfc00ffff, 0xc000993c, 0 , 0,
20840 0x0 }, /* POOL32Sxf_4~*(76) */
20841 { reserved_block , 0 , 0 , 32,
20842 0xfc00ffff, 0xc0009b3c, 0 , 0,
20843 0x0 }, /* POOL32Sxf_4~*(77) */
20844 { reserved_block , 0 , 0 , 32,
20845 0xfc00ffff, 0xc0009d3c, 0 , 0,
20846 0x0 }, /* POOL32Sxf_4~*(78) */
20847 { reserved_block , 0 , 0 , 32,
20848 0xfc00ffff, 0xc0009f3c, 0 , 0,
20849 0x0 }, /* POOL32Sxf_4~*(79) */
20850 { reserved_block , 0 , 0 , 32,
20851 0xfc00ffff, 0xc000a13c, 0 , 0,
20852 0x0 }, /* POOL32Sxf_4~*(80) */
20853 { reserved_block , 0 , 0 , 32,
20854 0xfc00ffff, 0xc000a33c, 0 , 0,
20855 0x0 }, /* POOL32Sxf_4~*(81) */
20856 { reserved_block , 0 , 0 , 32,
20857 0xfc00ffff, 0xc000a53c, 0 , 0,
20858 0x0 }, /* POOL32Sxf_4~*(82) */
20859 { reserved_block , 0 , 0 , 32,
20860 0xfc00ffff, 0xc000a73c, 0 , 0,
20861 0x0 }, /* POOL32Sxf_4~*(83) */
20862 { reserved_block , 0 , 0 , 32,
20863 0xfc00ffff, 0xc000a93c, 0 , 0,
20864 0x0 }, /* POOL32Sxf_4~*(84) */
20865 { reserved_block , 0 , 0 , 32,
20866 0xfc00ffff, 0xc000ab3c, 0 , 0,
20867 0x0 }, /* POOL32Sxf_4~*(85) */
20868 { reserved_block , 0 , 0 , 32,
20869 0xfc00ffff, 0xc000ad3c, 0 , 0,
20870 0x0 }, /* POOL32Sxf_4~*(86) */
20871 { reserved_block , 0 , 0 , 32,
20872 0xfc00ffff, 0xc000af3c, 0 , 0,
20873 0x0 }, /* POOL32Sxf_4~*(87) */
20874 { reserved_block , 0 , 0 , 32,
20875 0xfc00ffff, 0xc000b13c, 0 , 0,
20876 0x0 }, /* POOL32Sxf_4~*(88) */
20877 { reserved_block , 0 , 0 , 32,
20878 0xfc00ffff, 0xc000b33c, 0 , 0,
20879 0x0 }, /* POOL32Sxf_4~*(89) */
20880 { reserved_block , 0 , 0 , 32,
20881 0xfc00ffff, 0xc000b53c, 0 , 0,
20882 0x0 }, /* POOL32Sxf_4~*(90) */
20883 { reserved_block , 0 , 0 , 32,
20884 0xfc00ffff, 0xc000b73c, 0 , 0,
20885 0x0 }, /* POOL32Sxf_4~*(91) */
20886 { reserved_block , 0 , 0 , 32,
20887 0xfc00ffff, 0xc000b93c, 0 , 0,
20888 0x0 }, /* POOL32Sxf_4~*(92) */
20889 { reserved_block , 0 , 0 , 32,
20890 0xfc00ffff, 0xc000bb3c, 0 , 0,
20891 0x0 }, /* POOL32Sxf_4~*(93) */
20892 { reserved_block , 0 , 0 , 32,
20893 0xfc00ffff, 0xc000bd3c, 0 , 0,
20894 0x0 }, /* POOL32Sxf_4~*(94) */
20895 { reserved_block , 0 , 0 , 32,
20896 0xfc00ffff, 0xc000bf3c, 0 , 0,
20897 0x0 }, /* POOL32Sxf_4~*(95) */
20898 { reserved_block , 0 , 0 , 32,
20899 0xfc00ffff, 0xc000c13c, 0 , 0,
20900 0x0 }, /* POOL32Sxf_4~*(96) */
20901 { reserved_block , 0 , 0 , 32,
20902 0xfc00ffff, 0xc000c33c, 0 , 0,
20903 0x0 }, /* POOL32Sxf_4~*(97) */
20904 { reserved_block , 0 , 0 , 32,
20905 0xfc00ffff, 0xc000c53c, 0 , 0,
20906 0x0 }, /* POOL32Sxf_4~*(98) */
20907 { reserved_block , 0 , 0 , 32,
20908 0xfc00ffff, 0xc000c73c, 0 , 0,
20909 0x0 }, /* POOL32Sxf_4~*(99) */
20910 { reserved_block , 0 , 0 , 32,
20911 0xfc00ffff, 0xc000c93c, 0 , 0,
20912 0x0 }, /* POOL32Sxf_4~*(100) */
20913 { reserved_block , 0 , 0 , 32,
20914 0xfc00ffff, 0xc000cb3c, 0 , 0,
20915 0x0 }, /* POOL32Sxf_4~*(101) */
20916 { reserved_block , 0 , 0 , 32,
20917 0xfc00ffff, 0xc000cd3c, 0 , 0,
20918 0x0 }, /* POOL32Sxf_4~*(102) */
20919 { reserved_block , 0 , 0 , 32,
20920 0xfc00ffff, 0xc000cf3c, 0 , 0,
20921 0x0 }, /* POOL32Sxf_4~*(103) */
20922 { reserved_block , 0 , 0 , 32,
20923 0xfc00ffff, 0xc000d13c, 0 , 0,
20924 0x0 }, /* POOL32Sxf_4~*(104) */
20925 { reserved_block , 0 , 0 , 32,
20926 0xfc00ffff, 0xc000d33c, 0 , 0,
20927 0x0 }, /* POOL32Sxf_4~*(105) */
20928 { reserved_block , 0 , 0 , 32,
20929 0xfc00ffff, 0xc000d53c, 0 , 0,
20930 0x0 }, /* POOL32Sxf_4~*(106) */
20931 { reserved_block , 0 , 0 , 32,
20932 0xfc00ffff, 0xc000d73c, 0 , 0,
20933 0x0 }, /* POOL32Sxf_4~*(107) */
20934 { reserved_block , 0 , 0 , 32,
20935 0xfc00ffff, 0xc000d93c, 0 , 0,
20936 0x0 }, /* POOL32Sxf_4~*(108) */
20937 { reserved_block , 0 , 0 , 32,
20938 0xfc00ffff, 0xc000db3c, 0 , 0,
20939 0x0 }, /* POOL32Sxf_4~*(109) */
20940 { reserved_block , 0 , 0 , 32,
20941 0xfc00ffff, 0xc000dd3c, 0 , 0,
20942 0x0 }, /* POOL32Sxf_4~*(110) */
20943 { reserved_block , 0 , 0 , 32,
20944 0xfc00ffff, 0xc000df3c, 0 , 0,
20945 0x0 }, /* POOL32Sxf_4~*(111) */
20946 { reserved_block , 0 , 0 , 32,
20947 0xfc00ffff, 0xc000e13c, 0 , 0,
20948 0x0 }, /* POOL32Sxf_4~*(112) */
20949 { reserved_block , 0 , 0 , 32,
20950 0xfc00ffff, 0xc000e33c, 0 , 0,
20951 0x0 }, /* POOL32Sxf_4~*(113) */
20952 { reserved_block , 0 , 0 , 32,
20953 0xfc00ffff, 0xc000e53c, 0 , 0,
20954 0x0 }, /* POOL32Sxf_4~*(114) */
20955 { reserved_block , 0 , 0 , 32,
20956 0xfc00ffff, 0xc000e73c, 0 , 0,
20957 0x0 }, /* POOL32Sxf_4~*(115) */
20958 { reserved_block , 0 , 0 , 32,
20959 0xfc00ffff, 0xc000e93c, 0 , 0,
20960 0x0 }, /* POOL32Sxf_4~*(116) */
20961 { reserved_block , 0 , 0 , 32,
20962 0xfc00ffff, 0xc000eb3c, 0 , 0,
20963 0x0 }, /* POOL32Sxf_4~*(117) */
20964 { reserved_block , 0 , 0 , 32,
20965 0xfc00ffff, 0xc000ed3c, 0 , 0,
20966 0x0 }, /* POOL32Sxf_4~*(118) */
20967 { reserved_block , 0 , 0 , 32,
20968 0xfc00ffff, 0xc000ef3c, 0 , 0,
20969 0x0 }, /* POOL32Sxf_4~*(119) */
20970 { reserved_block , 0 , 0 , 32,
20971 0xfc00ffff, 0xc000f13c, 0 , 0,
20972 0x0 }, /* POOL32Sxf_4~*(120) */
20973 { reserved_block , 0 , 0 , 32,
20974 0xfc00ffff, 0xc000f33c, 0 , 0,
20975 0x0 }, /* POOL32Sxf_4~*(121) */
20976 { reserved_block , 0 , 0 , 32,
20977 0xfc00ffff, 0xc000f53c, 0 , 0,
20978 0x0 }, /* POOL32Sxf_4~*(122) */
20979 { reserved_block , 0 , 0 , 32,
20980 0xfc00ffff, 0xc000f73c, 0 , 0,
20981 0x0 }, /* POOL32Sxf_4~*(123) */
20982 { reserved_block , 0 , 0 , 32,
20983 0xfc00ffff, 0xc000f93c, 0 , 0,
20984 0x0 }, /* POOL32Sxf_4~*(124) */
20985 { reserved_block , 0 , 0 , 32,
20986 0xfc00ffff, 0xc000fb3c, 0 , 0,
20987 0x0 }, /* POOL32Sxf_4~*(125) */
20988 { reserved_block , 0 , 0 , 32,
20989 0xfc00ffff, 0xc000fd3c, 0 , 0,
20990 0x0 }, /* POOL32Sxf_4~*(126) */
20991 { reserved_block , 0 , 0 , 32,
20992 0xfc00ffff, 0xc000ff3c, 0 , 0,
20993 0x0 }, /* POOL32Sxf_4~*(127) */
20994 };
20995
20996
20997 NMD::Pool NMD::POOL32Sxf[8] = {
20998 { reserved_block , 0 , 0 , 32,
20999 0xfc0001ff, 0xc000003c, 0 , 0,
21000 0x0 }, /* POOL32Sxf~*(0) */
21001 { reserved_block , 0 , 0 , 32,
21002 0xfc0001ff, 0xc000007c, 0 , 0,
21003 0x0 }, /* POOL32Sxf~*(1) */
21004 { reserved_block , 0 , 0 , 32,
21005 0xfc0001ff, 0xc00000bc, 0 , 0,
21006 0x0 }, /* POOL32Sxf~*(2) */
21007 { reserved_block , 0 , 0 , 32,
21008 0xfc0001ff, 0xc00000fc, 0 , 0,
21009 0x0 }, /* POOL32Sxf~*(3) */
21010 { pool , POOL32Sxf_4 , 128 , 32,
21011 0xfc0001ff, 0xc000013c, 0 , 0,
21012 0x0 }, /* POOL32Sxf_4 */
21013 { reserved_block , 0 , 0 , 32,
21014 0xfc0001ff, 0xc000017c, 0 , 0,
21015 0x0 }, /* POOL32Sxf~*(5) */
21016 { reserved_block , 0 , 0 , 32,
21017 0xfc0001ff, 0xc00001bc, 0 , 0,
21018 0x0 }, /* POOL32Sxf~*(6) */
21019 { reserved_block , 0 , 0 , 32,
21020 0xfc0001ff, 0xc00001fc, 0 , 0,
21021 0x0 }, /* POOL32Sxf~*(7) */
21022 };
21023
21024
21025 NMD::Pool NMD::POOL32S_4[8] = {
21026 { instruction , 0 , 0 , 32,
21027 0xfc00003f, 0xc0000004, &NMD::EXTD , 0,
21028 MIPS64_ }, /* EXTD */
21029 { instruction , 0 , 0 , 32,
21030 0xfc00003f, 0xc000000c, &NMD::EXTD32 , 0,
21031 MIPS64_ }, /* EXTD32 */
21032 { reserved_block , 0 , 0 , 32,
21033 0xfc00003f, 0xc0000014, 0 , 0,
21034 0x0 }, /* POOL32S_4~*(2) */
21035 { reserved_block , 0 , 0 , 32,
21036 0xfc00003f, 0xc000001c, 0 , 0,
21037 0x0 }, /* POOL32S_4~*(3) */
21038 { reserved_block , 0 , 0 , 32,
21039 0xfc00003f, 0xc0000024, 0 , 0,
21040 0x0 }, /* POOL32S_4~*(4) */
21041 { reserved_block , 0 , 0 , 32,
21042 0xfc00003f, 0xc000002c, 0 , 0,
21043 0x0 }, /* POOL32S_4~*(5) */
21044 { reserved_block , 0 , 0 , 32,
21045 0xfc00003f, 0xc0000034, 0 , 0,
21046 0x0 }, /* POOL32S_4~*(6) */
21047 { pool , POOL32Sxf , 8 , 32,
21048 0xfc00003f, 0xc000003c, 0 , 0,
21049 0x0 }, /* POOL32Sxf */
21050 };
21051
21052
21053 NMD::Pool NMD::POOL32S[8] = {
21054 { pool , POOL32S_0 , 64 , 32,
21055 0xfc000007, 0xc0000000, 0 , 0,
21056 0x0 }, /* POOL32S_0 */
21057 { reserved_block , 0 , 0 , 32,
21058 0xfc000007, 0xc0000001, 0 , 0,
21059 0x0 }, /* POOL32S~*(1) */
21060 { reserved_block , 0 , 0 , 32,
21061 0xfc000007, 0xc0000002, 0 , 0,
21062 0x0 }, /* POOL32S~*(2) */
21063 { reserved_block , 0 , 0 , 32,
21064 0xfc000007, 0xc0000003, 0 , 0,
21065 0x0 }, /* POOL32S~*(3) */
21066 { pool , POOL32S_4 , 8 , 32,
21067 0xfc000007, 0xc0000004, 0 , 0,
21068 0x0 }, /* POOL32S_4 */
21069 { reserved_block , 0 , 0 , 32,
21070 0xfc000007, 0xc0000005, 0 , 0,
21071 0x0 }, /* POOL32S~*(5) */
21072 { reserved_block , 0 , 0 , 32,
21073 0xfc000007, 0xc0000006, 0 , 0,
21074 0x0 }, /* POOL32S~*(6) */
21075 { reserved_block , 0 , 0 , 32,
21076 0xfc000007, 0xc0000007, 0 , 0,
21077 0x0 }, /* POOL32S~*(7) */
21078 };
21079
21080
21081 NMD::Pool NMD::P_LUI[2] = {
21082 { instruction , 0 , 0 , 32,
21083 0xfc000002, 0xe0000000, &NMD::LUI , 0,
21084 0x0 }, /* LUI */
21085 { instruction , 0 , 0 , 32,
21086 0xfc000002, 0xe0000002, &NMD::ALUIPC , 0,
21087 0x0 }, /* ALUIPC */
21088 };
21089
21090
21091 NMD::Pool NMD::P_GP_LH[2] = {
21092 { instruction , 0 , 0 , 32,
21093 0xfc1c0001, 0x44100000, &NMD::LH_GP_ , 0,
21094 0x0 }, /* LH[GP] */
21095 { instruction , 0 , 0 , 32,
21096 0xfc1c0001, 0x44100001, &NMD::LHU_GP_ , 0,
21097 0x0 }, /* LHU[GP] */
21098 };
21099
21100
21101 NMD::Pool NMD::P_GP_SH[2] = {
21102 { instruction , 0 , 0 , 32,
21103 0xfc1c0001, 0x44140000, &NMD::SH_GP_ , 0,
21104 0x0 }, /* SH[GP] */
21105 { reserved_block , 0 , 0 , 32,
21106 0xfc1c0001, 0x44140001, 0 , 0,
21107 0x0 }, /* P.GP.SH~*(1) */
21108 };
21109
21110
21111 NMD::Pool NMD::P_GP_CP1[4] = {
21112 { instruction , 0 , 0 , 32,
21113 0xfc1c0003, 0x44180000, &NMD::LWC1_GP_ , 0,
21114 CP1_ }, /* LWC1[GP] */
21115 { instruction , 0 , 0 , 32,
21116 0xfc1c0003, 0x44180001, &NMD::SWC1_GP_ , 0,
21117 CP1_ }, /* SWC1[GP] */
21118 { instruction , 0 , 0 , 32,
21119 0xfc1c0003, 0x44180002, &NMD::LDC1_GP_ , 0,
21120 CP1_ }, /* LDC1[GP] */
21121 { instruction , 0 , 0 , 32,
21122 0xfc1c0003, 0x44180003, &NMD::SDC1_GP_ , 0,
21123 CP1_ }, /* SDC1[GP] */
21124 };
21125
21126
21127 NMD::Pool NMD::P_GP_M64[4] = {
21128 { instruction , 0 , 0 , 32,
21129 0xfc1c0003, 0x441c0000, &NMD::LWU_GP_ , 0,
21130 MIPS64_ }, /* LWU[GP] */
21131 { reserved_block , 0 , 0 , 32,
21132 0xfc1c0003, 0x441c0001, 0 , 0,
21133 0x0 }, /* P.GP.M64~*(1) */
21134 { reserved_block , 0 , 0 , 32,
21135 0xfc1c0003, 0x441c0002, 0 , 0,
21136 0x0 }, /* P.GP.M64~*(2) */
21137 { reserved_block , 0 , 0 , 32,
21138 0xfc1c0003, 0x441c0003, 0 , 0,
21139 0x0 }, /* P.GP.M64~*(3) */
21140 };
21141
21142
21143 NMD::Pool NMD::P_GP_BH[8] = {
21144 { instruction , 0 , 0 , 32,
21145 0xfc1c0000, 0x44000000, &NMD::LB_GP_ , 0,
21146 0x0 }, /* LB[GP] */
21147 { instruction , 0 , 0 , 32,
21148 0xfc1c0000, 0x44040000, &NMD::SB_GP_ , 0,
21149 0x0 }, /* SB[GP] */
21150 { instruction , 0 , 0 , 32,
21151 0xfc1c0000, 0x44080000, &NMD::LBU_GP_ , 0,
21152 0x0 }, /* LBU[GP] */
21153 { instruction , 0 , 0 , 32,
21154 0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_ , 0,
21155 0x0 }, /* ADDIU[GP.B] */
21156 { pool , P_GP_LH , 2 , 32,
21157 0xfc1c0000, 0x44100000, 0 , 0,
21158 0x0 }, /* P.GP.LH */
21159 { pool , P_GP_SH , 2 , 32,
21160 0xfc1c0000, 0x44140000, 0 , 0,
21161 0x0 }, /* P.GP.SH */
21162 { pool , P_GP_CP1 , 4 , 32,
21163 0xfc1c0000, 0x44180000, 0 , 0,
21164 0x0 }, /* P.GP.CP1 */
21165 { pool , P_GP_M64 , 4 , 32,
21166 0xfc1c0000, 0x441c0000, 0 , 0,
21167 0x0 }, /* P.GP.M64 */
21168 };
21169
21170
21171 NMD::Pool NMD::P_LS_U12[16] = {
21172 { instruction , 0 , 0 , 32,
21173 0xfc00f000, 0x84000000, &NMD::LB_U12_ , 0,
21174 0x0 }, /* LB[U12] */
21175 { instruction , 0 , 0 , 32,
21176 0xfc00f000, 0x84001000, &NMD::SB_U12_ , 0,
21177 0x0 }, /* SB[U12] */
21178 { instruction , 0 , 0 , 32,
21179 0xfc00f000, 0x84002000, &NMD::LBU_U12_ , 0,
21180 0x0 }, /* LBU[U12] */
21181 { instruction , 0 , 0 , 32,
21182 0xfc00f000, 0x84003000, &NMD::PREF_U12_ , 0,
21183 0x0 }, /* PREF[U12] */
21184 { instruction , 0 , 0 , 32,
21185 0xfc00f000, 0x84004000, &NMD::LH_U12_ , 0,
21186 0x0 }, /* LH[U12] */
21187 { instruction , 0 , 0 , 32,
21188 0xfc00f000, 0x84005000, &NMD::SH_U12_ , 0,
21189 0x0 }, /* SH[U12] */
21190 { instruction , 0 , 0 , 32,
21191 0xfc00f000, 0x84006000, &NMD::LHU_U12_ , 0,
21192 0x0 }, /* LHU[U12] */
21193 { instruction , 0 , 0 , 32,
21194 0xfc00f000, 0x84007000, &NMD::LWU_U12_ , 0,
21195 MIPS64_ }, /* LWU[U12] */
21196 { instruction , 0 , 0 , 32,
21197 0xfc00f000, 0x84008000, &NMD::LW_U12_ , 0,
21198 0x0 }, /* LW[U12] */
21199 { instruction , 0 , 0 , 32,
21200 0xfc00f000, 0x84009000, &NMD::SW_U12_ , 0,
21201 0x0 }, /* SW[U12] */
21202 { instruction , 0 , 0 , 32,
21203 0xfc00f000, 0x8400a000, &NMD::LWC1_U12_ , 0,
21204 CP1_ }, /* LWC1[U12] */
21205 { instruction , 0 , 0 , 32,
21206 0xfc00f000, 0x8400b000, &NMD::SWC1_U12_ , 0,
21207 CP1_ }, /* SWC1[U12] */
21208 { instruction , 0 , 0 , 32,
21209 0xfc00f000, 0x8400c000, &NMD::LD_U12_ , 0,
21210 MIPS64_ }, /* LD[U12] */
21211 { instruction , 0 , 0 , 32,
21212 0xfc00f000, 0x8400d000, &NMD::SD_U12_ , 0,
21213 MIPS64_ }, /* SD[U12] */
21214 { instruction , 0 , 0 , 32,
21215 0xfc00f000, 0x8400e000, &NMD::LDC1_U12_ , 0,
21216 CP1_ }, /* LDC1[U12] */
21217 { instruction , 0 , 0 , 32,
21218 0xfc00f000, 0x8400f000, &NMD::SDC1_U12_ , 0,
21219 CP1_ }, /* SDC1[U12] */
21220 };
21221
21222
21223 NMD::Pool NMD::P_PREF_S9_[2] = {
21224 { instruction , 0 , 0 , 32,
21225 0xffe07f00, 0xa7e01800, &NMD::SYNCI , 0,
21226 0x0 }, /* SYNCI */
21227 { instruction , 0 , 0 , 32,
21228 0xfc007f00, 0xa4001800, &NMD::PREF_S9_ , &NMD::PREF_S9__cond ,
21229 0x0 }, /* PREF[S9] */
21230 };
21231
21232
21233 NMD::Pool NMD::P_LS_S0[16] = {
21234 { instruction , 0 , 0 , 32,
21235 0xfc007f00, 0xa4000000, &NMD::LB_S9_ , 0,
21236 0x0 }, /* LB[S9] */
21237 { instruction , 0 , 0 , 32,
21238 0xfc007f00, 0xa4000800, &NMD::SB_S9_ , 0,
21239 0x0 }, /* SB[S9] */
21240 { instruction , 0 , 0 , 32,
21241 0xfc007f00, 0xa4001000, &NMD::LBU_S9_ , 0,
21242 0x0 }, /* LBU[S9] */
21243 { pool , P_PREF_S9_ , 2 , 32,
21244 0xfc007f00, 0xa4001800, 0 , 0,
21245 0x0 }, /* P.PREF[S9] */
21246 { instruction , 0 , 0 , 32,
21247 0xfc007f00, 0xa4002000, &NMD::LH_S9_ , 0,
21248 0x0 }, /* LH[S9] */
21249 { instruction , 0 , 0 , 32,
21250 0xfc007f00, 0xa4002800, &NMD::SH_S9_ , 0,
21251 0x0 }, /* SH[S9] */
21252 { instruction , 0 , 0 , 32,
21253 0xfc007f00, 0xa4003000, &NMD::LHU_S9_ , 0,
21254 0x0 }, /* LHU[S9] */
21255 { instruction , 0 , 0 , 32,
21256 0xfc007f00, 0xa4003800, &NMD::LWU_S9_ , 0,
21257 MIPS64_ }, /* LWU[S9] */
21258 { instruction , 0 , 0 , 32,
21259 0xfc007f00, 0xa4004000, &NMD::LW_S9_ , 0,
21260 0x0 }, /* LW[S9] */
21261 { instruction , 0 , 0 , 32,
21262 0xfc007f00, 0xa4004800, &NMD::SW_S9_ , 0,
21263 0x0 }, /* SW[S9] */
21264 { instruction , 0 , 0 , 32,
21265 0xfc007f00, 0xa4005000, &NMD::LWC1_S9_ , 0,
21266 CP1_ }, /* LWC1[S9] */
21267 { instruction , 0 , 0 , 32,
21268 0xfc007f00, 0xa4005800, &NMD::SWC1_S9_ , 0,
21269 CP1_ }, /* SWC1[S9] */
21270 { instruction , 0 , 0 , 32,
21271 0xfc007f00, 0xa4006000, &NMD::LD_S9_ , 0,
21272 MIPS64_ }, /* LD[S9] */
21273 { instruction , 0 , 0 , 32,
21274 0xfc007f00, 0xa4006800, &NMD::SD_S9_ , 0,
21275 MIPS64_ }, /* SD[S9] */
21276 { instruction , 0 , 0 , 32,
21277 0xfc007f00, 0xa4007000, &NMD::LDC1_S9_ , 0,
21278 CP1_ }, /* LDC1[S9] */
21279 { instruction , 0 , 0 , 32,
21280 0xfc007f00, 0xa4007800, &NMD::SDC1_S9_ , 0,
21281 CP1_ }, /* SDC1[S9] */
21282 };
21283
21284
21285 NMD::Pool NMD::ASET_ACLR[2] = {
21286 { instruction , 0 , 0 , 32,
21287 0xfe007f00, 0xa4001100, &NMD::ASET , 0,
21288 MCU_ }, /* ASET */
21289 { instruction , 0 , 0 , 32,
21290 0xfe007f00, 0xa6001100, &NMD::ACLR , 0,
21291 MCU_ }, /* ACLR */
21292 };
21293
21294
21295 NMD::Pool NMD::P_LL[4] = {
21296 { instruction , 0 , 0 , 32,
21297 0xfc007f03, 0xa4005100, &NMD::LL , 0,
21298 0x0 }, /* LL */
21299 { instruction , 0 , 0 , 32,
21300 0xfc007f03, 0xa4005101, &NMD::LLWP , 0,
21301 XNP_ }, /* LLWP */
21302 { reserved_block , 0 , 0 , 32,
21303 0xfc007f03, 0xa4005102, 0 , 0,
21304 0x0 }, /* P.LL~*(2) */
21305 { reserved_block , 0 , 0 , 32,
21306 0xfc007f03, 0xa4005103, 0 , 0,
21307 0x0 }, /* P.LL~*(3) */
21308 };
21309
21310
21311 NMD::Pool NMD::P_SC[4] = {
21312 { instruction , 0 , 0 , 32,
21313 0xfc007f03, 0xa4005900, &NMD::SC , 0,
21314 0x0 }, /* SC */
21315 { instruction , 0 , 0 , 32,
21316 0xfc007f03, 0xa4005901, &NMD::SCWP , 0,
21317 XNP_ }, /* SCWP */
21318 { reserved_block , 0 , 0 , 32,
21319 0xfc007f03, 0xa4005902, 0 , 0,
21320 0x0 }, /* P.SC~*(2) */
21321 { reserved_block , 0 , 0 , 32,
21322 0xfc007f03, 0xa4005903, 0 , 0,
21323 0x0 }, /* P.SC~*(3) */
21324 };
21325
21326
21327 NMD::Pool NMD::P_LLD[8] = {
21328 { instruction , 0 , 0 , 32,
21329 0xfc007f07, 0xa4007100, &NMD::LLD , 0,
21330 MIPS64_ }, /* LLD */
21331 { instruction , 0 , 0 , 32,
21332 0xfc007f07, 0xa4007101, &NMD::LLDP , 0,
21333 MIPS64_ }, /* LLDP */
21334 { reserved_block , 0 , 0 , 32,
21335 0xfc007f07, 0xa4007102, 0 , 0,
21336 0x0 }, /* P.LLD~*(2) */
21337 { reserved_block , 0 , 0 , 32,
21338 0xfc007f07, 0xa4007103, 0 , 0,
21339 0x0 }, /* P.LLD~*(3) */
21340 { reserved_block , 0 , 0 , 32,
21341 0xfc007f07, 0xa4007104, 0 , 0,
21342 0x0 }, /* P.LLD~*(4) */
21343 { reserved_block , 0 , 0 , 32,
21344 0xfc007f07, 0xa4007105, 0 , 0,
21345 0x0 }, /* P.LLD~*(5) */
21346 { reserved_block , 0 , 0 , 32,
21347 0xfc007f07, 0xa4007106, 0 , 0,
21348 0x0 }, /* P.LLD~*(6) */
21349 { reserved_block , 0 , 0 , 32,
21350 0xfc007f07, 0xa4007107, 0 , 0,
21351 0x0 }, /* P.LLD~*(7) */
21352 };
21353
21354
21355 NMD::Pool NMD::P_SCD[8] = {
21356 { instruction , 0 , 0 , 32,
21357 0xfc007f07, 0xa4007900, &NMD::SCD , 0,
21358 MIPS64_ }, /* SCD */
21359 { instruction , 0 , 0 , 32,
21360 0xfc007f07, 0xa4007901, &NMD::SCDP , 0,
21361 MIPS64_ }, /* SCDP */
21362 { reserved_block , 0 , 0 , 32,
21363 0xfc007f07, 0xa4007902, 0 , 0,
21364 0x0 }, /* P.SCD~*(2) */
21365 { reserved_block , 0 , 0 , 32,
21366 0xfc007f07, 0xa4007903, 0 , 0,
21367 0x0 }, /* P.SCD~*(3) */
21368 { reserved_block , 0 , 0 , 32,
21369 0xfc007f07, 0xa4007904, 0 , 0,
21370 0x0 }, /* P.SCD~*(4) */
21371 { reserved_block , 0 , 0 , 32,
21372 0xfc007f07, 0xa4007905, 0 , 0,
21373 0x0 }, /* P.SCD~*(5) */
21374 { reserved_block , 0 , 0 , 32,
21375 0xfc007f07, 0xa4007906, 0 , 0,
21376 0x0 }, /* P.SCD~*(6) */
21377 { reserved_block , 0 , 0 , 32,
21378 0xfc007f07, 0xa4007907, 0 , 0,
21379 0x0 }, /* P.SCD~*(7) */
21380 };
21381
21382
21383 NMD::Pool NMD::P_LS_S1[16] = {
21384 { reserved_block , 0 , 0 , 32,
21385 0xfc007f00, 0xa4000100, 0 , 0,
21386 0x0 }, /* P.LS.S1~*(0) */
21387 { reserved_block , 0 , 0 , 32,
21388 0xfc007f00, 0xa4000900, 0 , 0,
21389 0x0 }, /* P.LS.S1~*(1) */
21390 { pool , ASET_ACLR , 2 , 32,
21391 0xfc007f00, 0xa4001100, 0 , 0,
21392 0x0 }, /* ASET_ACLR */
21393 { reserved_block , 0 , 0 , 32,
21394 0xfc007f00, 0xa4001900, 0 , 0,
21395 0x0 }, /* P.LS.S1~*(3) */
21396 { instruction , 0 , 0 , 32,
21397 0xfc007f00, 0xa4002100, &NMD::UALH , 0,
21398 XMMS_ }, /* UALH */
21399 { instruction , 0 , 0 , 32,
21400 0xfc007f00, 0xa4002900, &NMD::UASH , 0,
21401 XMMS_ }, /* UASH */
21402 { reserved_block , 0 , 0 , 32,
21403 0xfc007f00, 0xa4003100, 0 , 0,
21404 0x0 }, /* P.LS.S1~*(6) */
21405 { instruction , 0 , 0 , 32,
21406 0xfc007f00, 0xa4003900, &NMD::CACHE , 0,
21407 CP0_ }, /* CACHE */
21408 { instruction , 0 , 0 , 32,
21409 0xfc007f00, 0xa4004100, &NMD::LWC2 , 0,
21410 CP2_ }, /* LWC2 */
21411 { instruction , 0 , 0 , 32,
21412 0xfc007f00, 0xa4004900, &NMD::SWC2 , 0,
21413 CP2_ }, /* SWC2 */
21414 { pool , P_LL , 4 , 32,
21415 0xfc007f00, 0xa4005100, 0 , 0,
21416 0x0 }, /* P.LL */
21417 { pool , P_SC , 4 , 32,
21418 0xfc007f00, 0xa4005900, 0 , 0,
21419 0x0 }, /* P.SC */
21420 { instruction , 0 , 0 , 32,
21421 0xfc007f00, 0xa4006100, &NMD::LDC2 , 0,
21422 CP2_ }, /* LDC2 */
21423 { instruction , 0 , 0 , 32,
21424 0xfc007f00, 0xa4006900, &NMD::SDC2 , 0,
21425 CP2_ }, /* SDC2 */
21426 { pool , P_LLD , 8 , 32,
21427 0xfc007f00, 0xa4007100, 0 , 0,
21428 0x0 }, /* P.LLD */
21429 { pool , P_SCD , 8 , 32,
21430 0xfc007f00, 0xa4007900, 0 , 0,
21431 0x0 }, /* P.SCD */
21432 };
21433
21434
21435 NMD::Pool NMD::P_PREFE[2] = {
21436 { instruction , 0 , 0 , 32,
21437 0xffe07f00, 0xa7e01a00, &NMD::SYNCIE , 0,
21438 CP0_ | EVA_ }, /* SYNCIE */
21439 { instruction , 0 , 0 , 32,
21440 0xfc007f00, 0xa4001a00, &NMD::PREFE , &NMD::PREFE_cond ,
21441 CP0_ | EVA_ }, /* PREFE */
21442 };
21443
21444
21445 NMD::Pool NMD::P_LLE[4] = {
21446 { instruction , 0 , 0 , 32,
21447 0xfc007f03, 0xa4005200, &NMD::LLE , 0,
21448 CP0_ | EVA_ }, /* LLE */
21449 { instruction , 0 , 0 , 32,
21450 0xfc007f03, 0xa4005201, &NMD::LLWPE , 0,
21451 CP0_ | EVA_ }, /* LLWPE */
21452 { reserved_block , 0 , 0 , 32,
21453 0xfc007f03, 0xa4005202, 0 , 0,
21454 0x0 }, /* P.LLE~*(2) */
21455 { reserved_block , 0 , 0 , 32,
21456 0xfc007f03, 0xa4005203, 0 , 0,
21457 0x0 }, /* P.LLE~*(3) */
21458 };
21459
21460
21461 NMD::Pool NMD::P_SCE[4] = {
21462 { instruction , 0 , 0 , 32,
21463 0xfc007f03, 0xa4005a00, &NMD::SCE , 0,
21464 CP0_ | EVA_ }, /* SCE */
21465 { instruction , 0 , 0 , 32,
21466 0xfc007f03, 0xa4005a01, &NMD::SCWPE , 0,
21467 CP0_ | EVA_ }, /* SCWPE */
21468 { reserved_block , 0 , 0 , 32,
21469 0xfc007f03, 0xa4005a02, 0 , 0,
21470 0x0 }, /* P.SCE~*(2) */
21471 { reserved_block , 0 , 0 , 32,
21472 0xfc007f03, 0xa4005a03, 0 , 0,
21473 0x0 }, /* P.SCE~*(3) */
21474 };
21475
21476
21477 NMD::Pool NMD::P_LS_E0[16] = {
21478 { instruction , 0 , 0 , 32,
21479 0xfc007f00, 0xa4000200, &NMD::LBE , 0,
21480 CP0_ | EVA_ }, /* LBE */
21481 { instruction , 0 , 0 , 32,
21482 0xfc007f00, 0xa4000a00, &NMD::SBE , 0,
21483 CP0_ | EVA_ }, /* SBE */
21484 { instruction , 0 , 0 , 32,
21485 0xfc007f00, 0xa4001200, &NMD::LBUE , 0,
21486 CP0_ | EVA_ }, /* LBUE */
21487 { pool , P_PREFE , 2 , 32,
21488 0xfc007f00, 0xa4001a00, 0 , 0,
21489 0x0 }, /* P.PREFE */
21490 { instruction , 0 , 0 , 32,
21491 0xfc007f00, 0xa4002200, &NMD::LHE , 0,
21492 CP0_ | EVA_ }, /* LHE */
21493 { instruction , 0 , 0 , 32,
21494 0xfc007f00, 0xa4002a00, &NMD::SHE , 0,
21495 CP0_ | EVA_ }, /* SHE */
21496 { instruction , 0 , 0 , 32,
21497 0xfc007f00, 0xa4003200, &NMD::LHUE , 0,
21498 CP0_ | EVA_ }, /* LHUE */
21499 { instruction , 0 , 0 , 32,
21500 0xfc007f00, 0xa4003a00, &NMD::CACHEE , 0,
21501 CP0_ | EVA_ }, /* CACHEE */
21502 { instruction , 0 , 0 , 32,
21503 0xfc007f00, 0xa4004200, &NMD::LWE , 0,
21504 CP0_ | EVA_ }, /* LWE */
21505 { instruction , 0 , 0 , 32,
21506 0xfc007f00, 0xa4004a00, &NMD::SWE , 0,
21507 CP0_ | EVA_ }, /* SWE */
21508 { pool , P_LLE , 4 , 32,
21509 0xfc007f00, 0xa4005200, 0 , 0,
21510 0x0 }, /* P.LLE */
21511 { pool , P_SCE , 4 , 32,
21512 0xfc007f00, 0xa4005a00, 0 , 0,
21513 0x0 }, /* P.SCE */
21514 { reserved_block , 0 , 0 , 32,
21515 0xfc007f00, 0xa4006200, 0 , 0,
21516 0x0 }, /* P.LS.E0~*(12) */
21517 { reserved_block , 0 , 0 , 32,
21518 0xfc007f00, 0xa4006a00, 0 , 0,
21519 0x0 }, /* P.LS.E0~*(13) */
21520 { reserved_block , 0 , 0 , 32,
21521 0xfc007f00, 0xa4007200, 0 , 0,
21522 0x0 }, /* P.LS.E0~*(14) */
21523 { reserved_block , 0 , 0 , 32,
21524 0xfc007f00, 0xa4007a00, 0 , 0,
21525 0x0 }, /* P.LS.E0~*(15) */
21526 };
21527
21528
21529 NMD::Pool NMD::P_LS_WM[2] = {
21530 { instruction , 0 , 0 , 32,
21531 0xfc000f00, 0xa4000400, &NMD::LWM , 0,
21532 XMMS_ }, /* LWM */
21533 { instruction , 0 , 0 , 32,
21534 0xfc000f00, 0xa4000c00, &NMD::SWM , 0,
21535 XMMS_ }, /* SWM */
21536 };
21537
21538
21539 NMD::Pool NMD::P_LS_UAWM[2] = {
21540 { instruction , 0 , 0 , 32,
21541 0xfc000f00, 0xa4000500, &NMD::UALWM , 0,
21542 XMMS_ }, /* UALWM */
21543 { instruction , 0 , 0 , 32,
21544 0xfc000f00, 0xa4000d00, &NMD::UASWM , 0,
21545 XMMS_ }, /* UASWM */
21546 };
21547
21548
21549 NMD::Pool NMD::P_LS_DM[2] = {
21550 { instruction , 0 , 0 , 32,
21551 0xfc000f00, 0xa4000600, &NMD::LDM , 0,
21552 MIPS64_ }, /* LDM */
21553 { instruction , 0 , 0 , 32,
21554 0xfc000f00, 0xa4000e00, &NMD::SDM , 0,
21555 MIPS64_ }, /* SDM */
21556 };
21557
21558
21559 NMD::Pool NMD::P_LS_UADM[2] = {
21560 { instruction , 0 , 0 , 32,
21561 0xfc000f00, 0xa4000700, &NMD::UALDM , 0,
21562 MIPS64_ }, /* UALDM */
21563 { instruction , 0 , 0 , 32,
21564 0xfc000f00, 0xa4000f00, &NMD::UASDM , 0,
21565 MIPS64_ }, /* UASDM */
21566 };
21567
21568
21569 NMD::Pool NMD::P_LS_S9[8] = {
21570 { pool , P_LS_S0 , 16 , 32,
21571 0xfc000700, 0xa4000000, 0 , 0,
21572 0x0 }, /* P.LS.S0 */
21573 { pool , P_LS_S1 , 16 , 32,
21574 0xfc000700, 0xa4000100, 0 , 0,
21575 0x0 }, /* P.LS.S1 */
21576 { pool , P_LS_E0 , 16 , 32,
21577 0xfc000700, 0xa4000200, 0 , 0,
21578 0x0 }, /* P.LS.E0 */
21579 { reserved_block , 0 , 0 , 32,
21580 0xfc000700, 0xa4000300, 0 , 0,
21581 0x0 }, /* P.LS.S9~*(3) */
21582 { pool , P_LS_WM , 2 , 32,
21583 0xfc000700, 0xa4000400, 0 , 0,
21584 0x0 }, /* P.LS.WM */
21585 { pool , P_LS_UAWM , 2 , 32,
21586 0xfc000700, 0xa4000500, 0 , 0,
21587 0x0 }, /* P.LS.UAWM */
21588 { pool , P_LS_DM , 2 , 32,
21589 0xfc000700, 0xa4000600, 0 , 0,
21590 0x0 }, /* P.LS.DM */
21591 { pool , P_LS_UADM , 2 , 32,
21592 0xfc000700, 0xa4000700, 0 , 0,
21593 0x0 }, /* P.LS.UADM */
21594 };
21595
21596
21597 NMD::Pool NMD::P_BAL[2] = {
21598 { branch_instruction , 0 , 0 , 32,
21599 0xfe000000, 0x28000000, &NMD::BC_32_ , 0,
21600 0x0 }, /* BC[32] */
21601 { call_instruction , 0 , 0 , 32,
21602 0xfe000000, 0x2a000000, &NMD::BALC_32_ , 0,
21603 0x0 }, /* BALC[32] */
21604 };
21605
21606
21607 NMD::Pool NMD::P_BALRSC[2] = {
21608 { branch_instruction , 0 , 0 , 32,
21609 0xffe0f000, 0x48008000, &NMD::BRSC , 0,
21610 0x0 }, /* BRSC */
21611 { call_instruction , 0 , 0 , 32,
21612 0xfc00f000, 0x48008000, &NMD::BALRSC , &NMD::BALRSC_cond ,
21613 0x0 }, /* BALRSC */
21614 };
21615
21616
21617 NMD::Pool NMD::P_J[16] = {
21618 { call_instruction , 0 , 0 , 32,
21619 0xfc00f000, 0x48000000, &NMD::JALRC_32_ , 0,
21620 0x0 }, /* JALRC[32] */
21621 { call_instruction , 0 , 0 , 32,
21622 0xfc00f000, 0x48001000, &NMD::JALRC_HB , 0,
21623 0x0 }, /* JALRC.HB */
21624 { reserved_block , 0 , 0 , 32,
21625 0xfc00f000, 0x48002000, 0 , 0,
21626 0x0 }, /* P.J~*(2) */
21627 { reserved_block , 0 , 0 , 32,
21628 0xfc00f000, 0x48003000, 0 , 0,
21629 0x0 }, /* P.J~*(3) */
21630 { reserved_block , 0 , 0 , 32,
21631 0xfc00f000, 0x48004000, 0 , 0,
21632 0x0 }, /* P.J~*(4) */
21633 { reserved_block , 0 , 0 , 32,
21634 0xfc00f000, 0x48005000, 0 , 0,
21635 0x0 }, /* P.J~*(5) */
21636 { reserved_block , 0 , 0 , 32,
21637 0xfc00f000, 0x48006000, 0 , 0,
21638 0x0 }, /* P.J~*(6) */
21639 { reserved_block , 0 , 0 , 32,
21640 0xfc00f000, 0x48007000, 0 , 0,
21641 0x0 }, /* P.J~*(7) */
21642 { pool , P_BALRSC , 2 , 32,
21643 0xfc00f000, 0x48008000, 0 , 0,
21644 0x0 }, /* P.BALRSC */
21645 { reserved_block , 0 , 0 , 32,
21646 0xfc00f000, 0x48009000, 0 , 0,
21647 0x0 }, /* P.J~*(9) */
21648 { reserved_block , 0 , 0 , 32,
21649 0xfc00f000, 0x4800a000, 0 , 0,
21650 0x0 }, /* P.J~*(10) */
21651 { reserved_block , 0 , 0 , 32,
21652 0xfc00f000, 0x4800b000, 0 , 0,
21653 0x0 }, /* P.J~*(11) */
21654 { reserved_block , 0 , 0 , 32,
21655 0xfc00f000, 0x4800c000, 0 , 0,
21656 0x0 }, /* P.J~*(12) */
21657 { reserved_block , 0 , 0 , 32,
21658 0xfc00f000, 0x4800d000, 0 , 0,
21659 0x0 }, /* P.J~*(13) */
21660 { reserved_block , 0 , 0 , 32,
21661 0xfc00f000, 0x4800e000, 0 , 0,
21662 0x0 }, /* P.J~*(14) */
21663 { reserved_block , 0 , 0 , 32,
21664 0xfc00f000, 0x4800f000, 0 , 0,
21665 0x0 }, /* P.J~*(15) */
21666 };
21667
21668
21669 NMD::Pool NMD::P_BR3A[32] = {
21670 { branch_instruction , 0 , 0 , 32,
21671 0xfc1fc000, 0x88004000, &NMD::BC1EQZC , 0,
21672 CP1_ }, /* BC1EQZC */
21673 { branch_instruction , 0 , 0 , 32,
21674 0xfc1fc000, 0x88014000, &NMD::BC1NEZC , 0,
21675 CP1_ }, /* BC1NEZC */
21676 { branch_instruction , 0 , 0 , 32,
21677 0xfc1fc000, 0x88024000, &NMD::BC2EQZC , 0,
21678 CP2_ }, /* BC2EQZC */
21679 { branch_instruction , 0 , 0 , 32,
21680 0xfc1fc000, 0x88034000, &NMD::BC2NEZC , 0,
21681 CP2_ }, /* BC2NEZC */
21682 { branch_instruction , 0 , 0 , 32,
21683 0xfc1fc000, 0x88044000, &NMD::BPOSGE32C , 0,
21684 DSP_ }, /* BPOSGE32C */
21685 { reserved_block , 0 , 0 , 32,
21686 0xfc1fc000, 0x88054000, 0 , 0,
21687 0x0 }, /* P.BR3A~*(5) */
21688 { reserved_block , 0 , 0 , 32,
21689 0xfc1fc000, 0x88064000, 0 , 0,
21690 0x0 }, /* P.BR3A~*(6) */
21691 { reserved_block , 0 , 0 , 32,
21692 0xfc1fc000, 0x88074000, 0 , 0,
21693 0x0 }, /* P.BR3A~*(7) */
21694 { reserved_block , 0 , 0 , 32,
21695 0xfc1fc000, 0x88084000, 0 , 0,
21696 0x0 }, /* P.BR3A~*(8) */
21697 { reserved_block , 0 , 0 , 32,
21698 0xfc1fc000, 0x88094000, 0 , 0,
21699 0x0 }, /* P.BR3A~*(9) */
21700 { reserved_block , 0 , 0 , 32,
21701 0xfc1fc000, 0x880a4000, 0 , 0,
21702 0x0 }, /* P.BR3A~*(10) */
21703 { reserved_block , 0 , 0 , 32,
21704 0xfc1fc000, 0x880b4000, 0 , 0,
21705 0x0 }, /* P.BR3A~*(11) */
21706 { reserved_block , 0 , 0 , 32,
21707 0xfc1fc000, 0x880c4000, 0 , 0,
21708 0x0 }, /* P.BR3A~*(12) */
21709 { reserved_block , 0 , 0 , 32,
21710 0xfc1fc000, 0x880d4000, 0 , 0,
21711 0x0 }, /* P.BR3A~*(13) */
21712 { reserved_block , 0 , 0 , 32,
21713 0xfc1fc000, 0x880e4000, 0 , 0,
21714 0x0 }, /* P.BR3A~*(14) */
21715 { reserved_block , 0 , 0 , 32,
21716 0xfc1fc000, 0x880f4000, 0 , 0,
21717 0x0 }, /* P.BR3A~*(15) */
21718 { reserved_block , 0 , 0 , 32,
21719 0xfc1fc000, 0x88104000, 0 , 0,
21720 0x0 }, /* P.BR3A~*(16) */
21721 { reserved_block , 0 , 0 , 32,
21722 0xfc1fc000, 0x88114000, 0 , 0,
21723 0x0 }, /* P.BR3A~*(17) */
21724 { reserved_block , 0 , 0 , 32,
21725 0xfc1fc000, 0x88124000, 0 , 0,
21726 0x0 }, /* P.BR3A~*(18) */
21727 { reserved_block , 0 , 0 , 32,
21728 0xfc1fc000, 0x88134000, 0 , 0,
21729 0x0 }, /* P.BR3A~*(19) */
21730 { reserved_block , 0 , 0 , 32,
21731 0xfc1fc000, 0x88144000, 0 , 0,
21732 0x0 }, /* P.BR3A~*(20) */
21733 { reserved_block , 0 , 0 , 32,
21734 0xfc1fc000, 0x88154000, 0 , 0,
21735 0x0 }, /* P.BR3A~*(21) */
21736 { reserved_block , 0 , 0 , 32,
21737 0xfc1fc000, 0x88164000, 0 , 0,
21738 0x0 }, /* P.BR3A~*(22) */
21739 { reserved_block , 0 , 0 , 32,
21740 0xfc1fc000, 0x88174000, 0 , 0,
21741 0x0 }, /* P.BR3A~*(23) */
21742 { reserved_block , 0 , 0 , 32,
21743 0xfc1fc000, 0x88184000, 0 , 0,
21744 0x0 }, /* P.BR3A~*(24) */
21745 { reserved_block , 0 , 0 , 32,
21746 0xfc1fc000, 0x88194000, 0 , 0,
21747 0x0 }, /* P.BR3A~*(25) */
21748 { reserved_block , 0 , 0 , 32,
21749 0xfc1fc000, 0x881a4000, 0 , 0,
21750 0x0 }, /* P.BR3A~*(26) */
21751 { reserved_block , 0 , 0 , 32,
21752 0xfc1fc000, 0x881b4000, 0 , 0,
21753 0x0 }, /* P.BR3A~*(27) */
21754 { reserved_block , 0 , 0 , 32,
21755 0xfc1fc000, 0x881c4000, 0 , 0,
21756 0x0 }, /* P.BR3A~*(28) */
21757 { reserved_block , 0 , 0 , 32,
21758 0xfc1fc000, 0x881d4000, 0 , 0,
21759 0x0 }, /* P.BR3A~*(29) */
21760 { reserved_block , 0 , 0 , 32,
21761 0xfc1fc000, 0x881e4000, 0 , 0,
21762 0x0 }, /* P.BR3A~*(30) */
21763 { reserved_block , 0 , 0 , 32,
21764 0xfc1fc000, 0x881f4000, 0 , 0,
21765 0x0 }, /* P.BR3A~*(31) */
21766 };
21767
21768
21769 NMD::Pool NMD::P_BR1[4] = {
21770 { branch_instruction , 0 , 0 , 32,
21771 0xfc00c000, 0x88000000, &NMD::BEQC_32_ , 0,
21772 0x0 }, /* BEQC[32] */
21773 { pool , P_BR3A , 32 , 32,
21774 0xfc00c000, 0x88004000, 0 , 0,
21775 0x0 }, /* P.BR3A */
21776 { branch_instruction , 0 , 0 , 32,
21777 0xfc00c000, 0x88008000, &NMD::BGEC , 0,
21778 0x0 }, /* BGEC */
21779 { branch_instruction , 0 , 0 , 32,
21780 0xfc00c000, 0x8800c000, &NMD::BGEUC , 0,
21781 0x0 }, /* BGEUC */
21782 };
21783
21784
21785 NMD::Pool NMD::P_BR2[4] = {
21786 { branch_instruction , 0 , 0 , 32,
21787 0xfc00c000, 0xa8000000, &NMD::BNEC_32_ , 0,
21788 0x0 }, /* BNEC[32] */
21789 { reserved_block , 0 , 0 , 32,
21790 0xfc00c000, 0xa8004000, 0 , 0,
21791 0x0 }, /* P.BR2~*(1) */
21792 { branch_instruction , 0 , 0 , 32,
21793 0xfc00c000, 0xa8008000, &NMD::BLTC , 0,
21794 0x0 }, /* BLTC */
21795 { branch_instruction , 0 , 0 , 32,
21796 0xfc00c000, 0xa800c000, &NMD::BLTUC , 0,
21797 0x0 }, /* BLTUC */
21798 };
21799
21800
21801 NMD::Pool NMD::P_BRI[8] = {
21802 { branch_instruction , 0 , 0 , 32,
21803 0xfc1c0000, 0xc8000000, &NMD::BEQIC , 0,
21804 0x0 }, /* BEQIC */
21805 { branch_instruction , 0 , 0 , 32,
21806 0xfc1c0000, 0xc8040000, &NMD::BBEQZC , 0,
21807 XMMS_ }, /* BBEQZC */
21808 { branch_instruction , 0 , 0 , 32,
21809 0xfc1c0000, 0xc8080000, &NMD::BGEIC , 0,
21810 0x0 }, /* BGEIC */
21811 { branch_instruction , 0 , 0 , 32,
21812 0xfc1c0000, 0xc80c0000, &NMD::BGEIUC , 0,
21813 0x0 }, /* BGEIUC */
21814 { branch_instruction , 0 , 0 , 32,
21815 0xfc1c0000, 0xc8100000, &NMD::BNEIC , 0,
21816 0x0 }, /* BNEIC */
21817 { branch_instruction , 0 , 0 , 32,
21818 0xfc1c0000, 0xc8140000, &NMD::BBNEZC , 0,
21819 XMMS_ }, /* BBNEZC */
21820 { branch_instruction , 0 , 0 , 32,
21821 0xfc1c0000, 0xc8180000, &NMD::BLTIC , 0,
21822 0x0 }, /* BLTIC */
21823 { branch_instruction , 0 , 0 , 32,
21824 0xfc1c0000, 0xc81c0000, &NMD::BLTIUC , 0,
21825 0x0 }, /* BLTIUC */
21826 };
21827
21828
21829 NMD::Pool NMD::P32[32] = {
21830 { pool , P_ADDIU , 2 , 32,
21831 0xfc000000, 0x00000000, 0 , 0,
21832 0x0 }, /* P.ADDIU */
21833 { pool , P32A , 8 , 32,
21834 0xfc000000, 0x20000000, 0 , 0,
21835 0x0 }, /* P32A */
21836 { pool , P_GP_W , 4 , 32,
21837 0xfc000000, 0x40000000, 0 , 0,
21838 0x0 }, /* P.GP.W */
21839 { pool , POOL48I , 32 , 48,
21840 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21841 0x0 }, /* POOL48I */
21842 { pool , P_U12 , 16 , 32,
21843 0xfc000000, 0x80000000, 0 , 0,
21844 0x0 }, /* P.U12 */
21845 { pool , POOL32F , 8 , 32,
21846 0xfc000000, 0xa0000000, 0 , 0,
21847 CP1_ }, /* POOL32F */
21848 { pool , POOL32S , 8 , 32,
21849 0xfc000000, 0xc0000000, 0 , 0,
21850 0x0 }, /* POOL32S */
21851 { pool , P_LUI , 2 , 32,
21852 0xfc000000, 0xe0000000, 0 , 0,
21853 0x0 }, /* P.LUI */
21854 { instruction , 0 , 0 , 32,
21855 0xfc000000, 0x04000000, &NMD::ADDIUPC_32_ , 0,
21856 0x0 }, /* ADDIUPC[32] */
21857 { reserved_block , 0 , 0 , 32,
21858 0xfc000000, 0x24000000, 0 , 0,
21859 0x0 }, /* P32~*(5) */
21860 { pool , P_GP_BH , 8 , 32,
21861 0xfc000000, 0x44000000, 0 , 0,
21862 0x0 }, /* P.GP.BH */
21863 { reserved_block , 0 , 0 , 32,
21864 0xfc000000, 0x64000000, 0 , 0,
21865 0x0 }, /* P32~*(13) */
21866 { pool , P_LS_U12 , 16 , 32,
21867 0xfc000000, 0x84000000, 0 , 0,
21868 0x0 }, /* P.LS.U12 */
21869 { pool , P_LS_S9 , 8 , 32,
21870 0xfc000000, 0xa4000000, 0 , 0,
21871 0x0 }, /* P.LS.S9 */
21872 { reserved_block , 0 , 0 , 32,
21873 0xfc000000, 0xc4000000, 0 , 0,
21874 0x0 }, /* P32~*(25) */
21875 { reserved_block , 0 , 0 , 32,
21876 0xfc000000, 0xe4000000, 0 , 0,
21877 0x0 }, /* P32~*(29) */
21878 { call_instruction , 0 , 0 , 32,
21879 0xfc000000, 0x08000000, &NMD::MOVE_BALC , 0,
21880 XMMS_ }, /* MOVE.BALC */
21881 { pool , P_BAL , 2 , 32,
21882 0xfc000000, 0x28000000, 0 , 0,
21883 0x0 }, /* P.BAL */
21884 { pool , P_J , 16 , 32,
21885 0xfc000000, 0x48000000, 0 , 0,
21886 0x0 }, /* P.J */
21887 { reserved_block , 0 , 0 , 32,
21888 0xfc000000, 0x68000000, 0 , 0,
21889 0x0 }, /* P32~*(14) */
21890 { pool , P_BR1 , 4 , 32,
21891 0xfc000000, 0x88000000, 0 , 0,
21892 0x0 }, /* P.BR1 */
21893 { pool , P_BR2 , 4 , 32,
21894 0xfc000000, 0xa8000000, 0 , 0,
21895 0x0 }, /* P.BR2 */
21896 { pool , P_BRI , 8 , 32,
21897 0xfc000000, 0xc8000000, 0 , 0,
21898 0x0 }, /* P.BRI */
21899 { reserved_block , 0 , 0 , 32,
21900 0xfc000000, 0xe8000000, 0 , 0,
21901 0x0 }, /* P32~*(30) */
21902 { reserved_block , 0 , 0 , 32,
21903 0xfc000000, 0x0c000000, 0 , 0,
21904 0x0 }, /* P32~*(3) */
21905 { reserved_block , 0 , 0 , 32,
21906 0xfc000000, 0x2c000000, 0 , 0,
21907 0x0 }, /* P32~*(7) */
21908 { reserved_block , 0 , 0 , 32,
21909 0xfc000000, 0x4c000000, 0 , 0,
21910 0x0 }, /* P32~*(11) */
21911 { reserved_block , 0 , 0 , 32,
21912 0xfc000000, 0x6c000000, 0 , 0,
21913 0x0 }, /* P32~*(15) */
21914 { reserved_block , 0 , 0 , 32,
21915 0xfc000000, 0x8c000000, 0 , 0,
21916 0x0 }, /* P32~*(19) */
21917 { reserved_block , 0 , 0 , 32,
21918 0xfc000000, 0xac000000, 0 , 0,
21919 0x0 }, /* P32~*(23) */
21920 { reserved_block , 0 , 0 , 32,
21921 0xfc000000, 0xcc000000, 0 , 0,
21922 0x0 }, /* P32~*(27) */
21923 { reserved_block , 0 , 0 , 32,
21924 0xfc000000, 0xec000000, 0 , 0,
21925 0x0 }, /* P32~*(31) */
21926 };
21927
21928
21929 NMD::Pool NMD::P16_SYSCALL[2] = {
21930 { instruction , 0 , 0 , 16,
21931 0xfffc , 0x1008 , &NMD::SYSCALL_16_ , 0,
21932 0x0 }, /* SYSCALL[16] */
21933 { instruction , 0 , 0 , 16,
21934 0xfffc , 0x100c , &NMD::HYPCALL_16_ , 0,
21935 CP0_ | VZ_ }, /* HYPCALL[16] */
21936 };
21937
21938
21939 NMD::Pool NMD::P16_RI[4] = {
21940 { reserved_block , 0 , 0 , 16,
21941 0xfff8 , 0x1000 , 0 , 0,
21942 0x0 }, /* P16.RI~*(0) */
21943 { pool , P16_SYSCALL , 2 , 16,
21944 0xfff8 , 0x1008 , 0 , 0,
21945 0x0 }, /* P16.SYSCALL */
21946 { instruction , 0 , 0 , 16,
21947 0xfff8 , 0x1010 , &NMD::BREAK_16_ , 0,
21948 0x0 }, /* BREAK[16] */
21949 { instruction , 0 , 0 , 16,
21950 0xfff8 , 0x1018 , &NMD::SDBBP_16_ , 0,
21951 EJTAG_ }, /* SDBBP[16] */
21952 };
21953
21954
21955 NMD::Pool NMD::P16_MV[2] = {
21956 { pool , P16_RI , 4 , 16,
21957 0xffe0 , 0x1000 , 0 , 0,
21958 0x0 }, /* P16.RI */
21959 { instruction , 0 , 0 , 16,
21960 0xfc00 , 0x1000 , &NMD::MOVE , &NMD::MOVE_cond ,
21961 0x0 }, /* MOVE */
21962 };
21963
21964
21965 NMD::Pool NMD::P16_SHIFT[2] = {
21966 { instruction , 0 , 0 , 16,
21967 0xfc08 , 0x3000 , &NMD::SLL_16_ , 0,
21968 0x0 }, /* SLL[16] */
21969 { instruction , 0 , 0 , 16,
21970 0xfc08 , 0x3008 , &NMD::SRL_16_ , 0,
21971 0x0 }, /* SRL[16] */
21972 };
21973
21974
21975 NMD::Pool NMD::POOL16C_00[4] = {
21976 { instruction , 0 , 0 , 16,
21977 0xfc0f , 0x5000 , &NMD::NOT_16_ , 0,
21978 0x0 }, /* NOT[16] */
21979 { instruction , 0 , 0 , 16,
21980 0xfc0f , 0x5004 , &NMD::XOR_16_ , 0,
21981 0x0 }, /* XOR[16] */
21982 { instruction , 0 , 0 , 16,
21983 0xfc0f , 0x5008 , &NMD::AND_16_ , 0,
21984 0x0 }, /* AND[16] */
21985 { instruction , 0 , 0 , 16,
21986 0xfc0f , 0x500c , &NMD::OR_16_ , 0,
21987 0x0 }, /* OR[16] */
21988 };
21989
21990
21991 NMD::Pool NMD::POOL16C_0[2] = {
21992 { pool , POOL16C_00 , 4 , 16,
21993 0xfc03 , 0x5000 , 0 , 0,
21994 0x0 }, /* POOL16C_00 */
21995 { reserved_block , 0 , 0 , 16,
21996 0xfc03 , 0x5002 , 0 , 0,
21997 0x0 }, /* POOL16C_0~*(1) */
21998 };
21999
22000
22001 NMD::Pool NMD::P16C[2] = {
22002 { pool , POOL16C_0 , 2 , 16,
22003 0xfc01 , 0x5000 , 0 , 0,
22004 0x0 }, /* POOL16C_0 */
22005 { instruction , 0 , 0 , 16,
22006 0xfc01 , 0x5001 , &NMD::LWXS_16_ , 0,
22007 0x0 }, /* LWXS[16] */
22008 };
22009
22010
22011 NMD::Pool NMD::P16_A1[2] = {
22012 { reserved_block , 0 , 0 , 16,
22013 0xfc40 , 0x7000 , 0 , 0,
22014 0x0 }, /* P16.A1~*(0) */
22015 { instruction , 0 , 0 , 16,
22016 0xfc40 , 0x7040 , &NMD::ADDIU_R1_SP_ , 0,
22017 0x0 }, /* ADDIU[R1.SP] */
22018 };
22019
22020
22021 NMD::Pool NMD::P_ADDIU_RS5_[2] = {
22022 { instruction , 0 , 0 , 16,
22023 0xffe8 , 0x9008 , &NMD::NOP_16_ , 0,
22024 0x0 }, /* NOP[16] */
22025 { instruction , 0 , 0 , 16,
22026 0xfc08 , 0x9008 , &NMD::ADDIU_RS5_ , &NMD::ADDIU_RS5__cond ,
22027 0x0 }, /* ADDIU[RS5] */
22028 };
22029
22030
22031 NMD::Pool NMD::P16_A2[2] = {
22032 { instruction , 0 , 0 , 16,
22033 0xfc08 , 0x9000 , &NMD::ADDIU_R2_ , 0,
22034 0x0 }, /* ADDIU[R2] */
22035 { pool , P_ADDIU_RS5_ , 2 , 16,
22036 0xfc08 , 0x9008 , 0 , 0,
22037 0x0 }, /* P.ADDIU[RS5] */
22038 };
22039
22040
22041 NMD::Pool NMD::P16_ADDU[2] = {
22042 { instruction , 0 , 0 , 16,
22043 0xfc01 , 0xb000 , &NMD::ADDU_16_ , 0,
22044 0x0 }, /* ADDU[16] */
22045 { instruction , 0 , 0 , 16,
22046 0xfc01 , 0xb001 , &NMD::SUBU_16_ , 0,
22047 0x0 }, /* SUBU[16] */
22048 };
22049
22050
22051 NMD::Pool NMD::P16_JRC[2] = {
22052 { branch_instruction , 0 , 0 , 16,
22053 0xfc1f , 0xd800 , &NMD::JRC , 0,
22054 0x0 }, /* JRC */
22055 { call_instruction , 0 , 0 , 16,
22056 0xfc1f , 0xd810 , &NMD::JALRC_16_ , 0,
22057 0x0 }, /* JALRC[16] */
22058 };
22059
22060
22061 NMD::Pool NMD::P16_BR1[2] = {
22062 { branch_instruction , 0 , 0 , 16,
22063 0xfc00 , 0xd800 , &NMD::BEQC_16_ , &NMD::BEQC_16__cond ,
22064 XMMS_ }, /* BEQC[16] */
22065 { branch_instruction , 0 , 0 , 16,
22066 0xfc00 , 0xd800 , &NMD::BNEC_16_ , &NMD::BNEC_16__cond ,
22067 XMMS_ }, /* BNEC[16] */
22068 };
22069
22070
22071 NMD::Pool NMD::P16_BR[2] = {
22072 { pool , P16_JRC , 2 , 16,
22073 0xfc0f , 0xd800 , 0 , 0,
22074 0x0 }, /* P16.JRC */
22075 { pool , P16_BR1 , 2 , 16,
22076 0xfc00 , 0xd800 , 0 , &NMD::P16_BR1_cond ,
22077 0x0 }, /* P16.BR1 */
22078 };
22079
22080
22081 NMD::Pool NMD::P16_SR[2] = {
22082 { instruction , 0 , 0 , 16,
22083 0xfd00 , 0x1c00 , &NMD::SAVE_16_ , 0,
22084 0x0 }, /* SAVE[16] */
22085 { return_instruction , 0 , 0 , 16,
22086 0xfd00 , 0x1d00 , &NMD::RESTORE_JRC_16_ , 0,
22087 0x0 }, /* RESTORE.JRC[16] */
22088 };
22089
22090
22091 NMD::Pool NMD::P16_4X4[4] = {
22092 { instruction , 0 , 0 , 16,
22093 0xfd08 , 0x3c00 , &NMD::ADDU_4X4_ , 0,
22094 XMMS_ }, /* ADDU[4X4] */
22095 { instruction , 0 , 0 , 16,
22096 0xfd08 , 0x3c08 , &NMD::MUL_4X4_ , 0,
22097 XMMS_ }, /* MUL[4X4] */
22098 { reserved_block , 0 , 0 , 16,
22099 0xfd08 , 0x3d00 , 0 , 0,
22100 0x0 }, /* P16.4X4~*(2) */
22101 { reserved_block , 0 , 0 , 16,
22102 0xfd08 , 0x3d08 , 0 , 0,
22103 0x0 }, /* P16.4X4~*(3) */
22104 };
22105
22106
22107 NMD::Pool NMD::P16_LB[4] = {
22108 { instruction , 0 , 0 , 16,
22109 0xfc0c , 0x5c00 , &NMD::LB_16_ , 0,
22110 0x0 }, /* LB[16] */
22111 { instruction , 0 , 0 , 16,
22112 0xfc0c , 0x5c04 , &NMD::SB_16_ , 0,
22113 0x0 }, /* SB[16] */
22114 { instruction , 0 , 0 , 16,
22115 0xfc0c , 0x5c08 , &NMD::LBU_16_ , 0,
22116 0x0 }, /* LBU[16] */
22117 { reserved_block , 0 , 0 , 16,
22118 0xfc0c , 0x5c0c , 0 , 0,
22119 0x0 }, /* P16.LB~*(3) */
22120 };
22121
22122
22123 NMD::Pool NMD::P16_LH[4] = {
22124 { instruction , 0 , 0 , 16,
22125 0xfc09 , 0x7c00 , &NMD::LH_16_ , 0,
22126 0x0 }, /* LH[16] */
22127 { instruction , 0 , 0 , 16,
22128 0xfc09 , 0x7c01 , &NMD::SH_16_ , 0,
22129 0x0 }, /* SH[16] */
22130 { instruction , 0 , 0 , 16,
22131 0xfc09 , 0x7c08 , &NMD::LHU_16_ , 0,
22132 0x0 }, /* LHU[16] */
22133 { reserved_block , 0 , 0 , 16,
22134 0xfc09 , 0x7c09 , 0 , 0,
22135 0x0 }, /* P16.LH~*(3) */
22136 };
22137
22138
22139 NMD::Pool NMD::P16[32] = {
22140 { pool , P16_MV , 2 , 16,
22141 0xfc00 , 0x1000 , 0 , 0,
22142 0x0 }, /* P16.MV */
22143 { pool , P16_SHIFT , 2 , 16,
22144 0xfc00 , 0x3000 , 0 , 0,
22145 0x0 }, /* P16.SHIFT */
22146 { pool , P16C , 2 , 16,
22147 0xfc00 , 0x5000 , 0 , 0,
22148 0x0 }, /* P16C */
22149 { pool , P16_A1 , 2 , 16,
22150 0xfc00 , 0x7000 , 0 , 0,
22151 0x0 }, /* P16.A1 */
22152 { pool , P16_A2 , 2 , 16,
22153 0xfc00 , 0x9000 , 0 , 0,
22154 0x0 }, /* P16.A2 */
22155 { pool , P16_ADDU , 2 , 16,
22156 0xfc00 , 0xb000 , 0 , 0,
22157 0x0 }, /* P16.ADDU */
22158 { instruction , 0 , 0 , 16,
22159 0xfc00 , 0xd000 , &NMD::LI_16_ , 0,
22160 0x0 }, /* LI[16] */
22161 { instruction , 0 , 0 , 16,
22162 0xfc00 , 0xf000 , &NMD::ANDI_16_ , 0,
22163 0x0 }, /* ANDI[16] */
22164 { instruction , 0 , 0 , 16,
22165 0xfc00 , 0x1400 , &NMD::LW_16_ , 0,
22166 0x0 }, /* LW[16] */
22167 { instruction , 0 , 0 , 16,
22168 0xfc00 , 0x3400 , &NMD::LW_SP_ , 0,
22169 0x0 }, /* LW[SP] */
22170 { instruction , 0 , 0 , 16,
22171 0xfc00 , 0x5400 , &NMD::LW_GP16_ , 0,
22172 0x0 }, /* LW[GP16] */
22173 { instruction , 0 , 0 , 16,
22174 0xfc00 , 0x7400 , &NMD::LW_4X4_ , 0,
22175 XMMS_ }, /* LW[4X4] */
22176 { instruction , 0 , 0 , 16,
22177 0xfc00 , 0x9400 , &NMD::SW_16_ , 0,
22178 0x0 }, /* SW[16] */
22179 { instruction , 0 , 0 , 16,
22180 0xfc00 , 0xb400 , &NMD::SW_SP_ , 0,
22181 0x0 }, /* SW[SP] */
22182 { instruction , 0 , 0 , 16,
22183 0xfc00 , 0xd400 , &NMD::SW_GP16_ , 0,
22184 0x0 }, /* SW[GP16] */
22185 { instruction , 0 , 0 , 16,
22186 0xfc00 , 0xf400 , &NMD::SW_4X4_ , 0,
22187 XMMS_ }, /* SW[4X4] */
22188 { branch_instruction , 0 , 0 , 16,
22189 0xfc00 , 0x1800 , &NMD::BC_16_ , 0,
22190 0x0 }, /* BC[16] */
22191 { call_instruction , 0 , 0 , 16,
22192 0xfc00 , 0x3800 , &NMD::BALC_16_ , 0,
22193 0x0 }, /* BALC[16] */
22194 { reserved_block , 0 , 0 , 16,
22195 0xfc00 , 0x5800 , 0 , 0,
22196 0x0 }, /* P16~*(10) */
22197 { reserved_block , 0 , 0 , 16,
22198 0xfc00 , 0x7800 , 0 , 0,
22199 0x0 }, /* P16~*(14) */
22200 { branch_instruction , 0 , 0 , 16,
22201 0xfc00 , 0x9800 , &NMD::BEQZC_16_ , 0,
22202 0x0 }, /* BEQZC[16] */
22203 { branch_instruction , 0 , 0 , 16,
22204 0xfc00 , 0xb800 , &NMD::BNEZC_16_ , 0,
22205 0x0 }, /* BNEZC[16] */
22206 { pool , P16_BR , 2 , 16,
22207 0xfc00 , 0xd800 , 0 , 0,
22208 0x0 }, /* P16.BR */
22209 { reserved_block , 0 , 0 , 16,
22210 0xfc00 , 0xf800 , 0 , 0,
22211 0x0 }, /* P16~*(30) */
22212 { pool , P16_SR , 2 , 16,
22213 0xfc00 , 0x1c00 , 0 , 0,
22214 0x0 }, /* P16.SR */
22215 { pool , P16_4X4 , 4 , 16,
22216 0xfc00 , 0x3c00 , 0 , 0,
22217 0x0 }, /* P16.4X4 */
22218 { pool , P16_LB , 4 , 16,
22219 0xfc00 , 0x5c00 , 0 , 0,
22220 0x0 }, /* P16.LB */
22221 { pool , P16_LH , 4 , 16,
22222 0xfc00 , 0x7c00 , 0 , 0,
22223 0x0 }, /* P16.LH */
22224 { reserved_block , 0 , 0 , 16,
22225 0xfc00 , 0x9c00 , 0 , 0,
22226 0x0 }, /* P16~*(19) */
22227 { instruction , 0 , 0 , 16,
22228 0xfc00 , 0xbc00 , &NMD::MOVEP , 0,
22229 XMMS_ }, /* MOVEP */
22230 { reserved_block , 0 , 0 , 16,
22231 0xfc00 , 0xdc00 , 0 , 0,
22232 0x0 }, /* P16~*(27) */
22233 { instruction , 0 , 0 , 16,
22234 0xfc00 , 0xfc00 , &NMD::MOVEP_REV_ , 0,
22235 XMMS_ }, /* MOVEP[REV] */
22236 };
22237
22238
22239 NMD::Pool NMD::MAJOR[2] = {
22240 { pool , P32 , 32 , 32,
22241 0x10000000, 0x00000000, 0 , 0,
22242 0x0 }, /* P32 */
22243 { pool , P16 , 32 , 16,
22244 0x1000 , 0x1000 , 0 , 0,
22245 0x0 }, /* P16 */
22246 };
QEMU mirror