]> Git Repo - qemu.git/blame - disas/nanomips.cpp
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
virtio-net-test: add large tx buffer test
[qemu.git] / disas / nanomips.cpp
CommitLineData
89a955e8
AM		 1/*
2 * Source file for nanoMIPS disassembler component of QEMU
3 *
4 * Copyright (C) 2018 Wave Computing
5 * Copyright (C) 2018 Matthew Fortune <[email protected]>
6 * Copyright (C) 2018 Aleksandar Markovic <[email protected]>
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
22extern "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
38int 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
55int 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
134namespace 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
258std::string to_string(img::address a)
259{
260 char buffer[256];
261 sprintf(buffer, "0x%08llx", a);
262 return buffer;
263}
264
265
266uint64 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
272int64 sign_extend(int64 data, int msb)
273{
274 uint64 shift = 63 - msb;
275 return (data << shift) >> shift;
276}
277
278
279uint64 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 %d, size of list = %d",
288 index, register_list_size));
289}
290
291
292/*
293 * these functions should be decode functions but the json does not have
294 * decode sections so they are based on the encode, the equivalent decode
295 * functions need writing eventually.
296 */
297uint64 NMD::encode_gpr3(uint64 d)
298{
299 static uint64 register_list[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
300 return renumber_registers(d, register_list,
301 sizeof(register_list) / sizeof(register_list[0]));
302}
303
304
305uint64 NMD::encode_gpr3_store(uint64 d)
306{
307 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
308 return renumber_registers(d, register_list,
309 sizeof(register_list) / sizeof(register_list[0]));
310}
311
312
313uint64 NMD::encode_rd1_from_rd(uint64 d)
314{
315 static uint64 register_list[] = { 4, 5 };
316 return renumber_registers(d, register_list,
317 sizeof(register_list) / sizeof(register_list[0]));
318}
319
320
321uint64 NMD::encode_gpr4_zero(uint64 d)
322{
323 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
324 16, 17, 18, 19, 20, 21, 22, 23 };
325 return renumber_registers(d, register_list,
326 sizeof(register_list) / sizeof(register_list[0]));
327}
328
329
330uint64 NMD::encode_gpr4(uint64 d)
331{
332 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
333 16, 17, 18, 19, 20, 21, 22, 23 };
334 return renumber_registers(d, register_list,
335 sizeof(register_list) / sizeof(register_list[0]));
336}
337
338
339uint64 NMD::encode_rd2_reg1(uint64 d)
340{
341 static uint64 register_list[] = { 4, 5, 6, 7 };
342 return renumber_registers(d, register_list,
343 sizeof(register_list) / sizeof(register_list[0]));
344}
345
346
347uint64 NMD::encode_rd2_reg2(uint64 d)
348{
349 static uint64 register_list[] = { 5, 6, 7, 8 };
350 return renumber_registers(d, register_list,
351 sizeof(register_list) / sizeof(register_list[0]));
352}
353
354
355uint64 NMD::copy(uint64 d)
356{
357 return d;
358}
359
360
361int64 NMD::copy(int64 d)
362{
363 return d;
364}
365
366
367int64 NMD::neg_copy(uint64 d)
368{
369 return 0ll - d;
370}
371
372
373int64 NMD::neg_copy(int64 d)
374{
375 return -d;
376}
377
378
379/* strange wrapper around gpr3 */
380uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
381{
382return encode_gpr3(d);
383}
384
385
386/* strange wrapper around gpr3 */
387uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
388{
389 return encode_gpr3(d);
390}
391
392
393/* nop - done by extraction function */
394uint64 NMD::encode_s_from_address(uint64 d)
395{
396 return d;
397}
398
399
400/* nop - done by extraction function */
401uint64 NMD::encode_u_from_address(uint64 d)
402{
403 return d;
404}
405
406
407/* nop - done by extraction function */
408uint64 NMD::encode_s_from_s_hi(uint64 d)
409{
410 return d;
411}
412
413
414uint64 NMD::encode_count3_from_count(uint64 d)
415{
416 IMGASSERTONCE(d < 8);
417 return d == 0ull ? 8ull : d;
418}
419
420
421uint64 NMD::encode_shift3_from_shift(uint64 d)
422{
423 IMGASSERTONCE(d < 8);
424 return d == 0ull ? 8ull : d;
425}
426
427
428/* special value for load literal */
429int64 NMD::encode_eu_from_s_li16(uint64 d)
430{
431 IMGASSERTONCE(d < 128);
432 return d == 127 ? -1 : (int64)d;
433}
434
435
436uint64 NMD::encode_msbd_from_size(uint64 d)
437{
438 IMGASSERTONCE(d < 32);
439 return d + 1;
440}
441
442
443uint64 NMD::encode_eu_from_u_andi16(uint64 d)
444{
445 IMGASSERTONCE(d < 16);
446 if (d == 12) {
447 return 0x00ffull;
448 }
449 if (d == 13) {
450 return 0xffffull;
451 }
452 return d;
453}
454
455
456uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
457{
458 IMGASSERTONCE(0);
459 return d;
460}
461
462
463/* save16 / restore16 ???? */
464uint64 NMD::encode_rt1_from_rt(uint64 d)
465{
466 return d ? 31 : 30;
467}
468
469
470/* ? */
471uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
472{
473 return d;
474}
475
476
477std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
478{
479 std::string str;
480
481 for (uint64 counter = 0; counter != count; counter++) {
482 bool use_gp = gp && (counter == count - 1);
483 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
484 str += img::format(",%s", GPR(this_rt));
485 }
486
487 return str;
488}
489
490
491std::string NMD::GPR(uint64 reg)
492{
493 static const char *gpr_reg[32] = {
494 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
495 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
496 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
497 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
498 };
499
500 if (reg < 32) {
501 return gpr_reg[reg];
502 }
503
504 throw std::runtime_error(img::format("Invalid GPR register index %d", reg));
505}
506
507
508std::string NMD::FPR(uint64 reg)
509{
510 static const char *fpr_reg[32] = {
511 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
512 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
513 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
514 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
515 };
516
517 if (reg < 32) {
518 return fpr_reg[reg];
519 }
520
521 throw std::runtime_error(img::format("Invalid FPR register index %d", reg));
522}
523
524
525std::string NMD::AC(uint64 reg)
526{
527 static const char *ac_reg[4] = {
528 "ac0", "ac1", "ac2", "ac3"
529 };
530
531 if (reg < 4) {
532 return ac_reg[reg];
533 }
534
535 throw std::runtime_error(img::format("Invalid AC register index %d", reg));
536}
537
538
539std::string NMD::IMMEDIATE(uint64 value)
540{
541 return img::format("0x%x", value);
542}
543
544
545std::string NMD::IMMEDIATE(int64 value)
546{
547 return img::format("%d", value);
548}
549
550
551std::string NMD::CPR(uint64 reg)
552{
553 /* needs more work */
554 return img::format("CP%d", reg);
555}
556
557
558std::string NMD::ADDRESS(uint64 value, int instruction_size)
559{
560 /* token for string replace */
561 /* const char TOKEN_REPLACE = (char)0xa2; */
562 img::address address = m_pc + value + instruction_size;
563 /* symbol replacement */
564 /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
565 return to_string(address);
566}
567
568
569uint64 NMD::extract_op_code_value(const uint16 * data, int size)
570{
571 switch (size) {
572 case 16:
573 return data[0];
574 case 32:
575 return ((uint64)data[0] << 16) | data[1];
576 case 48:
577 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
578 default:
579 return data[0];
580 }
581}
582
583
584int NMD::Disassemble(const uint16 * data, std::string & dis,
585 NMD::TABLE_ENTRY_TYPE & type)
586{
587 return Disassemble(data, dis, type, MAJOR, 2);
588}
589
590
591/*
592 * Recurse through tables until the instruction is found then return
593 * the string and size
594 *
595 * inputs:
596 * pointer to a word stream,
597 * disassember table and size
598 * returns:
599 * instruction size - negative is error
600 * disassembly string - on error will constain error string
601 */
602int NMD::Disassemble(const uint16 * data, std::string & dis,
603 NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
604 int table_size)
605{
606 try
607 {
608 for (int i = 0; i < table_size; i++) {
609 uint64 op_code = extract_op_code_value(data,
610 table[i].instructions_size);
611 if ((op_code & table[i].mask) == table[i].value) {
612 /* possible match */
613 conditional_function cond = table[i].condition;
614 if ((cond == 0) || (this->*cond)(op_code)) {
615 try
616 {
617 if (table[i].type == pool) {
618 return Disassemble(data, dis, type,
619 table[i].next_table,
620 table[i].next_table_size);
621 } else if ((table[i].type == instruction) ||
622 (table[i].type == call_instruction) ||
623 (table[i].type == branch_instruction) ||
624 (table[i].type == return_instruction)) {
625 if ((table[i].attributes != 0) &&
626 (m_requested_instruction_categories &
627 table[i].attributes) == 0) {
628 /*
629 * failed due to instruction having
630 * an ASE attribute and the requested version
631 * not having that attribute
632 */
633 dis = "ASE attribute missmatch";
634 return -5;
635 }
636 disassembly_function dis_fn = table[i].disassembly;
637 if (dis_fn == 0) {
638 dis = "disassembler failure - bad table entry";
639 return -6;
640 }
641 type = table[i].type;
642 dis = (this->*dis_fn)(op_code);
643 return table[i].instructions_size;
644 } else {
645 dis = "reserved instruction";
646 return -2;
647 }
648 }
649 catch (std::runtime_error & e)
650 {
651 dis = e.what();
652 return -3; /* runtime error */
653 }
654 }
655 }
656 }
657 }
658 catch (std::exception & e)
659 {
660 dis = e.what();
661 return -4; /* runtime error */
662 }
663
664 dis = "failed to disassemble";
665 return -1; /* failed to disassemble */
666}
667
668
669uint64 NMD::extract_code_18_to_0(uint64 instruction)
670{
671 uint64 value = 0;
672 value |= extract_bits(instruction, 0, 19);
673 return value;
674}
675
676
677uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
678{
679 uint64 value = 0;
680 value |= extract_bits(instruction, 0, 3);
681 return value;
682}
683
684
685uint64 NMD::extr_uil3il3bs9Fmsb11(uint64 instruction)
686{
687 uint64 value = 0;
688 value |= extract_bits(instruction, 3, 9) << 3;
689 return value;
690}
691
692
693uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
694{
695 uint64 value = 0;
696 value |= extract_bits(instruction, 0, 4);
697 return value;
698}
699
700
701uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
702{
703 uint64 value = 0;
704 value |= extract_bits(instruction, 7, 3);
705 return value;
706}
707
708
709uint64 NMD::extr_uil1il1bs17Fmsb17(uint64 instruction)
710{
711 uint64 value = 0;
712 value |= extract_bits(instruction, 1, 17) << 1;
713 return value;
714}
715
716
717int64 NMD::extr_sil11il0bs10Tmsb9(uint64 instruction)
718{
719 int64 value = 0;
720 value |= extract_bits(instruction, 11, 10);
721 value = sign_extend(value, 9);
722 return value;
723}
724
725
726int64 NMD::extr_sil0il11bs1_il1il1bs10Tmsb11(uint64 instruction)
727{
728 int64 value = 0;
729 value |= extract_bits(instruction, 0, 1) << 11;
730 value |= extract_bits(instruction, 1, 10) << 1;
731 value = sign_extend(value, 11);
732 return value;
733}
734
735
736uint64 NMD::extract_u_10(uint64 instruction)
737{
738 uint64 value = 0;
739 value |= extract_bits(instruction, 10, 1);
740 return value;
741}
742
743
744uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
745{
746 uint64 value = 0;
747 value |= extract_bits(instruction, 21, 3);
748 value |= extract_bits(instruction, 25, 1) << 3;
749 return value;
750}
751
752
753uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
754{
755 uint64 value = 0;
756 value |= extract_bits(instruction, 11, 5);
757 return value;
758}
759
760
761uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
762{
763 uint64 value = 0;
764 value |= extract_bits(instruction, 0, 5);
765 return value;
766}
767
768
769uint64 NMD::extr_shiftxil7il1bs4Fmsb4(uint64 instruction)
770{
771 uint64 value = 0;
772 value |= extract_bits(instruction, 7, 4) << 1;
773 return value;
774}
775
776
777uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
778{
779 uint64 value = 0;
780 value |= extract_bits(instruction, 21, 5);
781 return value;
782}
783
784
785uint64 NMD::extract_count3_14_13_12(uint64 instruction)
786{
787 uint64 value = 0;
788 value |= extract_bits(instruction, 12, 3);
789 return value;
790}
791
792
793int64 NMD::extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(uint64 instruction)
794{
795 int64 value = 0;
796 value |= extract_bits(instruction, 0, 1) << 31;
797 value |= extract_bits(instruction, 2, 10) << 21;
798 value |= extract_bits(instruction, 12, 9) << 12;
799 value = sign_extend(value, 31);
800 return value;
801}
802
803
804int64 NMD::extr_sil0il7bs1_il1il1bs6Tmsb7(uint64 instruction)
805{
806 int64 value = 0;
807 value |= extract_bits(instruction, 0, 1) << 7;
808 value |= extract_bits(instruction, 1, 6) << 1;
809 value = sign_extend(value, 7);
810 return value;
811}
812
813
814uint64 NMD::extract_u2_10_9(uint64 instruction)
815{
816 uint64 value = 0;
817 value |= extract_bits(instruction, 9, 2);
818 return value;
819}
820
821
822uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
823{
824 uint64 value = 0;
825 value |= extract_bits(instruction, 16, 10);
826 return value;
827}
828
829
830uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
831{
832 uint64 value = 0;
833 value |= extract_bits(instruction, 16, 5);
834 return value;
835}
836
837
838uint64 NMD::extr_uil1il1bs2Fmsb2(uint64 instruction)
839{
840 uint64 value = 0;
841 value |= extract_bits(instruction, 1, 2) << 1;
842 return value;
843}
844
845
846uint64 NMD::extract_stripe_6(uint64 instruction)
847{
848 uint64 value = 0;
849 value |= extract_bits(instruction, 6, 1);
850 return value;
851}
852
853
854uint64 NMD::extr_xil17il0bs1Fmsb0(uint64 instruction)
855{
856 uint64 value = 0;
857 value |= extract_bits(instruction, 17, 1);
858 return value;
859}
860
861
862uint64 NMD::extr_xil2il0bs1_il15il0bs1Fmsb0(uint64 instruction)
863{
864 uint64 value = 0;
865 value |= extract_bits(instruction, 2, 1);
866 value |= extract_bits(instruction, 15, 1);
867 return value;
868}
869
870
871uint64 NMD::extract_ac_13_12(uint64 instruction)
872{
873 uint64 value = 0;
874 value |= extract_bits(instruction, 14, 2);
875 return value;
876}
877
878
879uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
880{
881 uint64 value = 0;
882 value |= extract_bits(instruction, 16, 5);
883 return value;
884}
885
886
887uint64 NMD::extract_rdl_25_24(uint64 instruction)
888{
889 uint64 value = 0;
890 value |= extract_bits(instruction, 24, 1);
891 return value;
892}
893
894
895int64 NMD::extr_sil0il10bs1_il1il1bs9Tmsb10(uint64 instruction)
896{
897 int64 value = 0;
898 value |= extract_bits(instruction, 0, 1) << 10;
899 value |= extract_bits(instruction, 1, 9) << 1;
900 value = sign_extend(value, 10);
901 return value;
902}
903
904
905uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
906{
907 uint64 value = 0;
908 value |= extract_bits(instruction, 0, 7);
909 return value;
910}
911
912
913uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
914{
915 uint64 value = 0;
916 value |= extract_bits(instruction, 0, 6);
917 return value;
918}
919
920
921uint64 NMD::extr_xil10il0bs6Fmsb5(uint64 instruction)
922{
923 uint64 value = 0;
924 value |= extract_bits(instruction, 10, 6);
925 return value;
926}
927
928
929uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
930{
931 uint64 value = 0;
932 value |= extract_bits(instruction, 16, 4);
933 return value;
934}
935
936
937uint64 NMD::extract_code_2_1_0(uint64 instruction)
938{
939 uint64 value = 0;
940 value |= extract_bits(instruction, 0, 3);
941 return value;
942}
943
944
945uint64 NMD::extr_xil10il0bs4_il22il0bs4Fmsb3(uint64 instruction)
946{
947 uint64 value = 0;
948 value |= extract_bits(instruction, 10, 4);
949 value |= extract_bits(instruction, 22, 4);
950 return value;
951}
952
953
954uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
955{
956 uint64 value = 0;
957 value |= extract_bits(instruction, 0, 12);
958 return value;
959}
960
961
962uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
963{
964 uint64 value = 0;
965 value |= extract_bits(instruction, 0, 5);
966 return value;
967}
968
969
970uint64 NMD::extr_uil3il3bs18Fmsb20(uint64 instruction)
971{
972 uint64 value = 0;
973 value |= extract_bits(instruction, 3, 18) << 3;
974 return value;
975}
976
977
978uint64 NMD::extr_xil12il0bs1Fmsb0(uint64 instruction)
979{
980 uint64 value = 0;
981 value |= extract_bits(instruction, 12, 1);
982 return value;
983}
984
985
986uint64 NMD::extr_uil0il2bs4Fmsb5(uint64 instruction)
987{
988 uint64 value = 0;
989 value |= extract_bits(instruction, 0, 4) << 2;
990 return value;
991}
992
993
994uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
995{
996 uint64 value = 0;
997 value |= extract_bits(instruction, 3, 23);
998 return value;
999}
1000
1001
1002uint64 NMD::extr_uil0il2bs3Fmsb4(uint64 instruction)
1003{
1004 uint64 value = 0;
1005 value |= extract_bits(instruction, 0, 3) << 2;
1006 return value;
1007}
1008
1009
1010uint64 NMD::extr_xil10il0bs1Fmsb0(uint64 instruction)
1011{
1012 uint64 value = 0;
1013 value |= extract_bits(instruction, 10, 1);
1014 return value;
1015}
1016
1017
1018uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
1019{
1020 uint64 value = 0;
1021 value |= extract_bits(instruction, 1, 3);
1022 return value;
1023}
1024
1025
1026uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
1027{
1028 uint64 value = 0;
1029 value |= extract_bits(instruction, 12, 4);
1030 return value;
1031}
1032
1033
1034uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
1035{
1036 uint64 value = 0;
1037 value |= extract_bits(instruction, 21, 5);
1038 return value;
1039}
1040
1041
1042uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
1043{
1044 uint64 value = 0;
1045 value |= extract_bits(instruction, 3, 5);
1046 return value;
1047}
1048
1049
1050uint64 NMD::extr_xil21il0bs5Fmsb4(uint64 instruction)
1051{
1052 uint64 value = 0;
1053 value |= extract_bits(instruction, 21, 5);
1054 return value;
1055}
1056
1057
1058uint64 NMD::extr_xil9il0bs3Fmsb2(uint64 instruction)
1059{
1060 uint64 value = 0;
1061 value |= extract_bits(instruction, 9, 3);
1062 return value;
1063}
1064
1065
1066uint64 NMD::extract_u_17_to_0(uint64 instruction)
1067{
1068 uint64 value = 0;
1069 value |= extract_bits(instruction, 0, 18);
1070 return value;
1071}
1072
1073
1074uint64 NMD::extr_xil14il0bs1_il15il0bs1Fmsb0(uint64 instruction)
1075{
1076 uint64 value = 0;
1077 value |= extract_bits(instruction, 14, 1);
1078 value |= extract_bits(instruction, 15, 1);
1079 return value;
1080}
1081
1082
1083uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
1084{
1085 uint64 value = 0;
1086 value |= extract_bits(instruction, 0, 3);
1087 value |= extract_bits(instruction, 4, 1) << 3;
1088 return value;
1089}
1090
1091
1092uint64 NMD::extr_xil24il0bs1Fmsb0(uint64 instruction)
1093{
1094 uint64 value = 0;
1095 value |= extract_bits(instruction, 24, 1);
1096 return value;
1097}
1098
1099
1100int64 NMD::extr_sil0il21bs1_il1il1bs20Tmsb21(uint64 instruction)
1101{
1102 int64 value = 0;
1103 value |= extract_bits(instruction, 0, 1) << 21;
1104 value |= extract_bits(instruction, 1, 20) << 1;
1105 value = sign_extend(value, 21);
1106 return value;
1107}
1108
1109
1110uint64 NMD::extract_op_25_to_3(uint64 instruction)
1111{
1112 uint64 value = 0;
1113 value |= extract_bits(instruction, 3, 23);
1114 return value;
1115}
1116
1117
1118uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
1119{
1120 uint64 value = 0;
1121 value |= extract_bits(instruction, 0, 3);
1122 value |= extract_bits(instruction, 4, 1) << 3;
1123 return value;
1124}
1125
1126
1127uint64 NMD::extract_bit_23_22_21(uint64 instruction)
1128{
1129 uint64 value = 0;
1130 value |= extract_bits(instruction, 21, 3);
1131 return value;
1132}
1133
1134
1135uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
1136{
1137 uint64 value = 0;
1138 value |= extract_bits(instruction, 37, 5);
1139 return value;
1140}
1141
1142
1143int64 NMD::extract_shift_21_20_19_18_17_16(uint64 instruction)
1144{
1145 int64 value = 0;
1146 value |= extract_bits(instruction, 16, 6);
1147 value = sign_extend(value, 5);
1148 return value;
1149}
1150
1151
1152uint64 NMD::extr_xil6il0bs3_il10il0bs1Fmsb2(uint64 instruction)
1153{
1154 uint64 value = 0;
1155 value |= extract_bits(instruction, 6, 3);
1156 value |= extract_bits(instruction, 10, 1);
1157 return value;
1158}
1159
1160
1161uint64 NMD::extract_rd2_3_8(uint64 instruction)
1162{
1163 uint64 value = 0;
1164 value |= extract_bits(instruction, 3, 1) << 1;
1165 value |= extract_bits(instruction, 8, 1);
1166 return value;
1167}
1168
1169
1170uint64 NMD::extr_xil16il0bs5Fmsb4(uint64 instruction)
1171{
1172 uint64 value = 0;
1173 value |= extract_bits(instruction, 16, 5);
1174 return value;
1175}
1176
1177
1178uint64 NMD::extract_code_17_to_0(uint64 instruction)
1179{
1180 uint64 value = 0;
1181 value |= extract_bits(instruction, 0, 18);
1182 return value;
1183}
1184
1185
1186uint64 NMD::extr_xil0il0bs12Fmsb11(uint64 instruction)
1187{
1188 uint64 value = 0;
1189 value |= extract_bits(instruction, 0, 12);
1190 return value;
1191}
1192
1193
1194uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
1195{
1196 uint64 value = 0;
1197 value |= extract_bits(instruction, 16, 5);
1198 return value;
1199}
1200
1201
1202int64 NMD::extr_sil2il2bs6_il15il8bs1Tmsb8(uint64 instruction)
1203{
1204 int64 value = 0;
1205 value |= extract_bits(instruction, 2, 6) << 2;
1206 value |= extract_bits(instruction, 15, 1) << 8;
1207 value = sign_extend(value, 8);
1208 return value;
1209}
1210
1211
1212uint64 NMD::extract_u_15_to_0(uint64 instruction)
1213{
1214 uint64 value = 0;
1215 value |= extract_bits(instruction, 0, 16);
1216 return value;
1217}
1218
1219
1220uint64 NMD::extract_fs_15_14_13_12_11(uint64 instruction)
1221{
1222 uint64 value = 0;
1223 value |= extract_bits(instruction, 16, 5);
1224 return value;
1225}
1226
1227
1228int64 NMD::extr_sil0il0bs8_il15il8bs1Tmsb8(uint64 instruction)
1229{
1230 int64 value = 0;
1231 value |= extract_bits(instruction, 0, 8);
1232 value |= extract_bits(instruction, 15, 1) << 8;
1233 value = sign_extend(value, 8);
1234 return value;
1235}
1236
1237
1238uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
1239{
1240 uint64 value = 0;
1241 value |= extract_bits(instruction, 16, 5);
1242 return value;
1243}
1244
1245
1246uint64 NMD::extract_rtl_11(uint64 instruction)
1247{
1248 uint64 value = 0;
1249 value |= extract_bits(instruction, 9, 1);
1250 return value;
1251}
1252
1253
1254uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
1255{
1256 uint64 value = 0;
1257 value |= extract_bits(instruction, 16, 5);
1258 return value;
1259}
1260
1261
1262uint64 NMD::extr_xil10il0bs1_il14il0bs2Fmsb1(uint64 instruction)
1263{
1264 uint64 value = 0;
1265 value |= extract_bits(instruction, 10, 1);
1266 value |= extract_bits(instruction, 14, 2);
1267 return value;
1268}
1269
1270
1271uint64 NMD::extract_sel_13_12_11(uint64 instruction)
1272{
1273 uint64 value = 0;
1274 value |= extract_bits(instruction, 11, 3);
1275 return value;
1276}
1277
1278
1279uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
1280{
1281 uint64 value = 0;
1282 value |= extract_bits(instruction, 0, 5);
1283 return value;
1284}
1285
1286
1287uint64 NMD::extr_xil14il0bs2Fmsb1(uint64 instruction)
1288{
1289 uint64 value = 0;
1290 value |= extract_bits(instruction, 14, 2);
1291 return value;
1292}
1293
1294
1295uint64 NMD::extract_gp_2(uint64 instruction)
1296{
1297 uint64 value = 0;
1298 value |= extract_bits(instruction, 2, 1);
1299 return value;
1300}
1301
1302
1303uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
1304{
1305 uint64 value = 0;
1306 value |= extract_bits(instruction, 7, 3);
1307 return value;
1308}
1309
1310
1311uint64 NMD::extract_ft_20_19_18_17_16(uint64 instruction)
1312{
1313 uint64 value = 0;
1314 value |= extract_bits(instruction, 21, 5);
1315 return value;
1316}
1317
1318
1319uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
1320{
1321 uint64 value = 0;
1322 value |= extract_bits(instruction, 11, 7);
1323 return value;
1324}
1325
1326
1327uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
1328{
1329 uint64 value = 0;
1330 value |= extract_bits(instruction, 16, 5);
1331 return value;
1332}
1333
1334
1335uint64 NMD::extr_xil16il0bs10Fmsb9(uint64 instruction)
1336{
1337 uint64 value = 0;
1338 value |= extract_bits(instruction, 16, 10);
1339 return value;
1340}
1341
1342
1343uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
1344{
1345 uint64 value = 0;
1346 value |= extract_bits(instruction, 5, 3);
1347 value |= extract_bits(instruction, 9, 1) << 3;
1348 return value;
1349}
1350
1351
1352uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
1353{
1354 uint64 value = 0;
1355 value |= extract_bits(instruction, 6, 5);
1356 return value;
1357}
1358
1359
1360uint64 NMD::extr_uil0il2bs6Fmsb7(uint64 instruction)
1361{
1362 uint64 value = 0;
1363 value |= extract_bits(instruction, 0, 6) << 2;
1364 return value;
1365}
1366
1367
1368uint64 NMD::extr_xil17il0bs9Fmsb8(uint64 instruction)
1369{
1370 uint64 value = 0;
1371 value |= extract_bits(instruction, 17, 9);
1372 return value;
1373}
1374
1375
1376uint64 NMD::extract_sa_15_14_13(uint64 instruction)
1377{
1378 uint64 value = 0;
1379 value |= extract_bits(instruction, 13, 3);
1380 return value;
1381}
1382
1383
1384int64 NMD::extr_sil0il14bs1_il1il1bs13Tmsb14(uint64 instruction)
1385{
1386 int64 value = 0;
1387 value |= extract_bits(instruction, 0, 1) << 14;
1388 value |= extract_bits(instruction, 1, 13) << 1;
1389 value = sign_extend(value, 14);
1390 return value;
1391}
1392
1393
1394uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
1395{
1396 uint64 value = 0;
1397 value |= extract_bits(instruction, 4, 3);
1398 return value;
1399}
1400
1401
1402uint64 NMD::extr_uil0il32bs32Fmsb63(uint64 instruction)
1403{
1404 uint64 value = 0;
1405 value |= extract_bits(instruction, 0, 32) << 32;
1406 return value;
1407}
1408
1409
1410uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
1411{
1412 uint64 value = 0;
1413 value |= extract_bits(instruction, 6, 5);
1414 return value;
1415}
1416
1417
1418uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
1419{
1420 uint64 value = 0;
1421 value |= extract_bits(instruction, 21, 5);
1422 return value;
1423}
1424
1425
1426uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1427{
1428 uint64 value = 0;
1429 value |= extract_bits(instruction, 6, 6);
1430 return value;
1431}
1432
1433
1434uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
1435{
1436 uint64 value = 0;
1437 value |= extract_bits(instruction, 5, 5);
1438 return value;
1439}
1440
1441
1442uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
1443{
1444 uint64 value = 0;
1445 value |= extract_bits(instruction, 21, 5);
1446 return value;
1447}
1448
1449
1450uint64 NMD::extr_uil0il2bs7Fmsb8(uint64 instruction)
1451{
1452 uint64 value = 0;
1453 value |= extract_bits(instruction, 0, 7) << 2;
1454 return value;
1455}
1456
1457
1458uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
1459{
1460 uint64 value = 0;
1461 value |= extract_bits(instruction, 11, 6);
1462 return value;
1463}
1464
1465
1466uint64 NMD::extr_xil10il0bs1_il11il0bs5Fmsb4(uint64 instruction)
1467{
1468 uint64 value = 0;
1469 value |= extract_bits(instruction, 10, 1);
1470 value |= extract_bits(instruction, 11, 5);
1471 return value;
1472}
1473
1474
1475uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1476{
1477 uint64 value = 0;
1478 value |= extract_bits(instruction, 14, 7);
1479 return value;
1480}
1481
1482
1483uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
1484{
1485 uint64 value = 0;
1486 value |= extract_bits(instruction, 0, 4);
1487 return value;
1488}
1489
1490
1491uint64 NMD::extr_uil4il4bs4Fmsb7(uint64 instruction)
1492{
1493 uint64 value = 0;
1494 value |= extract_bits(instruction, 4, 4) << 4;
1495 return value;
1496}
1497
1498
1499int64 NMD::extr_sil3il3bs5_il15il8bs1Tmsb8(uint64 instruction)
1500{
1501 int64 value = 0;
1502 value |= extract_bits(instruction, 3, 5) << 3;
1503 value |= extract_bits(instruction, 15, 1) << 8;
1504 value = sign_extend(value, 8);
1505 return value;
1506}
1507
1508
1509uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
1510{
1511 uint64 value = 0;
1512 value |= extract_bits(instruction, 11, 5);
1513 return value;
1514}
1515
1516
1517int64 NMD::extr_sil0il16bs16_il16il0bs16Tmsb31(uint64 instruction)
1518{
1519 int64 value = 0;
1520 value |= extract_bits(instruction, 0, 16) << 16;
1521 value |= extract_bits(instruction, 16, 16);
1522 value = sign_extend(value, 31);
1523 return value;
1524}
1525
1526
1527uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1528{
1529 uint64 value = 0;
1530 value |= extract_bits(instruction, 13, 8);
1531 return value;
1532}
1533
1534
1535uint64 NMD::extr_xil15il0bs1Fmsb0(uint64 instruction)
1536{
1537 uint64 value = 0;
1538 value |= extract_bits(instruction, 15, 1);
1539 return value;
1540}
1541
1542
1543uint64 NMD::extr_xil11il0bs5Fmsb4(uint64 instruction)
1544{
1545 uint64 value = 0;
1546 value |= extract_bits(instruction, 11, 5);
1547 return value;
1548}
1549
1550
1551uint64 NMD::extr_uil2il2bs16Fmsb17(uint64 instruction)
1552{
1553 uint64 value = 0;
1554 value |= extract_bits(instruction, 2, 16) << 2;
1555 return value;
1556}
1557
1558
1559uint64 NMD::extract_rd_20_19_18_17_16(uint64 instruction)
1560{
1561 uint64 value = 0;
1562 value |= extract_bits(instruction, 11, 5);
1563 return value;
1564}
1565
1566
1567uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
1568{
1569 uint64 value = 0;
1570 value |= extract_bits(instruction, 16, 5);
1571 return value;
1572}
1573
1574
1575uint64 NMD::extract_code_1_0(uint64 instruction)
1576{
1577 uint64 value = 0;
1578 value |= extract_bits(instruction, 0, 2);
1579 return value;
1580}
1581
1582
1583int64 NMD::extr_sil0il25bs1_il1il1bs24Tmsb25(uint64 instruction)
1584{
1585 int64 value = 0;
1586 value |= extract_bits(instruction, 0, 1) << 25;
1587 value |= extract_bits(instruction, 1, 24) << 1;
1588 value = sign_extend(value, 25);
1589 return value;
1590}
1591
1592
1593uint64 NMD::extr_xil0il0bs3_il4il0bs1Fmsb2(uint64 instruction)
1594{
1595 uint64 value = 0;
1596 value |= extract_bits(instruction, 0, 3);
1597 value |= extract_bits(instruction, 4, 1);
1598 return value;
1599}
1600
1601
1602uint64 NMD::extract_u_1_0(uint64 instruction)
1603{
1604 uint64 value = 0;
1605 value |= extract_bits(instruction, 0, 2);
1606 return value;
1607}
1608
1609
1610uint64 NMD::extr_uil3il3bs1_il8il2bs1Fmsb3(uint64 instruction)
1611{
1612 uint64 value = 0;
1613 value |= extract_bits(instruction, 3, 1) << 3;
1614 value |= extract_bits(instruction, 8, 1) << 2;
1615 return value;
1616}
1617
1618
1619uint64 NMD::extr_xil9il0bs3_il16il0bs5Fmsb4(uint64 instruction)
1620{
1621 uint64 value = 0;
1622 value |= extract_bits(instruction, 9, 3);
1623 value |= extract_bits(instruction, 16, 5);
1624 return value;
1625}
1626
1627
1628uint64 NMD::extract_fd_10_9_8_7_6(uint64 instruction)
1629{
1630 uint64 value = 0;
1631 value |= extract_bits(instruction, 11, 5);
1632 return value;
1633}
1634
1635
1636uint64 NMD::extr_xil6il0bs3Fmsb2(uint64 instruction)
1637{
1638 uint64 value = 0;
1639 value |= extract_bits(instruction, 6, 3);
1640 return value;
1641}
1642
1643
1644uint64 NMD::extr_uil0il2bs5Fmsb6(uint64 instruction)
1645{
1646 uint64 value = 0;
1647 value |= extract_bits(instruction, 0, 5) << 2;
1648 return value;
1649}
1650
1651
1652uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
1653{
1654 uint64 value = 0;
1655 value |= extract_bits(instruction, 5, 3);
1656 value |= extract_bits(instruction, 9, 1) << 3;
1657 return value;
1658}
1659
1660
1661uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
1662{
1663 uint64 value = 0;
1664 value |= extract_bits(instruction, 11, 5);
1665 return value;
1666}
1667
1668
1669uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
1670{
1671 uint64 value = 0;
1672 value |= extract_bits(instruction, 21, 5);
1673 return value;
1674}
1675
1676
1677uint64 NMD::extr_xil11il0bs1Fmsb0(uint64 instruction)
1678{
1679 uint64 value = 0;
1680 value |= extract_bits(instruction, 11, 1);
1681 return value;
1682}
1683
1684
1685uint64 NMD::extr_uil2il2bs19Fmsb20(uint64 instruction)
1686{
1687 uint64 value = 0;
1688 value |= extract_bits(instruction, 2, 19) << 2;
1689 return value;
1690}
1691
1692
1693int64 NMD::extract_s_4_2_1_0(uint64 instruction)
1694{
1695 int64 value = 0;
1696 value |= extract_bits(instruction, 0, 3);
1697 value |= extract_bits(instruction, 4, 1) << 3;
1698 value = sign_extend(value, 3);
1699 return value;
1700}
1701
1702
1703uint64 NMD::extr_uil0il1bs4Fmsb4(uint64 instruction)
1704{
1705 uint64 value = 0;
1706 value |= extract_bits(instruction, 0, 4) << 1;
1707 return value;
1708}
1709
1710
1711uint64 NMD::extr_xil9il0bs2Fmsb1(uint64 instruction)
1712{
1713 uint64 value = 0;
1714 value |= extract_bits(instruction, 9, 2);
1715 return value;
1716}
1717
1718
1719
1720bool NMD::ADDIU_32__cond(uint64 instruction)
1721{
1722 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1723 return rt != 0;
1724}
1725
1726
1727bool NMD::ADDIU_RS5__cond(uint64 instruction)
1728{
1729 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1730 return rt != 0;
1731}
1732
1733
1734bool NMD::BALRSC_cond(uint64 instruction)
1735{
1736 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1737 return rt != 0;
1738}
1739
1740
1741bool NMD::BEQC_16__cond(uint64 instruction)
1742{
1743 uint64 rs3 = extract_rs3_6_5_4(instruction);
1744 uint64 rt3 = extract_rt3_9_8_7(instruction);
1745 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1746 return rs3 < rt3 && u != 0;
1747}
1748
1749
1750bool NMD::BNEC_16__cond(uint64 instruction)
1751{
1752 uint64 rs3 = extract_rs3_6_5_4(instruction);
1753 uint64 rt3 = extract_rt3_9_8_7(instruction);
1754 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1755 return rs3 >= rt3 && u != 0;
1756}
1757
1758
1759bool NMD::MOVE_cond(uint64 instruction)
1760{
1761 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1762 return rt != 0;
1763}
1764
1765
1766bool NMD::P16_BR1_cond(uint64 instruction)
1767{
1768 uint64 u = extr_uil0il1bs4Fmsb4(instruction);
1769 return u != 0;
1770}
1771
1772
1773bool NMD::PREF_S9__cond(uint64 instruction)
1774{
1775 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1776 return hint != 31;
1777}
1778
1779
1780bool NMD::PREFE_cond(uint64 instruction)
1781{
1782 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1783 return hint != 31;
1784}
1785
1786
1787bool NMD::SLTU_cond(uint64 instruction)
1788{
1789 uint64 rd = extract_rd_20_19_18_17_16(instruction);
1790 return rd != 0;
1791}
1792
1793
1794
1795/*
1796 * ABS.D fd, fs - Floating Point Absolute Value
1797 *
1798 * 3 2 1
1799 * 10987654321098765432109876543210
1800 * 010001 00000 000101
1801 * fmt -----
1802 * fs -----
1803 * fd -----
1804 */
1805std::string NMD::ABS_D(uint64 instruction)
1806{
1807 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1808 uint64 fd_value = extract_ft_20_19_18_17_16(instruction);
1809
1810 std::string fs = FPR(copy(fs_value));
1811 std::string fd = FPR(copy(fd_value));
1812
1813 return img::format("ABS.D %s, %s", fd, fs);
1814}
1815
1816
1817/*
1818 * ABS.S fd, fs - Floating Point Absolute Value
1819 *
1820 * 3 2 1
1821 * 10987654321098765432109876543210
1822 * 010001 00000 000101
1823 * fmt -----
1824 * fd -----
1825 * fs -----
1826 */
1827std::string NMD::ABS_S(uint64 instruction)
1828{
1829 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1830 uint64 fd_value = extract_ft_20_19_18_17_16(instruction);
1831
1832 std::string fs = FPR(copy(fs_value));
1833 std::string fd = FPR(copy(fd_value));
1834
1835 return img::format("ABS.S %s, %s", fd, fs);
1836}
1837
1838
1839/*
1840 * ABSQ_S.PH rt, rs - Find Absolute Value of Two Fractional Halfwords
1841 *
1842 * 3 2 1
1843 * 10987654321098765432109876543210
1844 * 001000 0001000100111111
1845 * rt -----
1846 * rs -----
1847 */
1848std::string NMD::ABSQ_S_PH(uint64 instruction)
1849{
1850 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1851 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1852
1853 std::string rt = GPR(copy(rt_value));
1854 std::string rs = GPR(copy(rs_value));
1855
1856 return img::format("ABSQ_S.PH %s, %s", rt, rs);
1857}
1858
1859
1860/*
1861 * ABSQ_S.QB rt, rs - Find Absolute Value of Four Fractional Byte Values
1862 *
1863 * 3 2 1
1864 * 10987654321098765432109876543210
1865 * 001000 0000000100111111
1866 * rt -----
1867 * rs -----
1868 */
1869std::string NMD::ABSQ_S_QB(uint64 instruction)
1870{
1871 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1872 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1873
1874 std::string rt = GPR(copy(rt_value));
1875 std::string rs = GPR(copy(rs_value));
1876
1877 return img::format("ABSQ_S.QB %s, %s", rt, rs);
1878}
1879
1880
1881/*
1882 *
1883 *
1884 * 3 2 1
1885 * 10987654321098765432109876543210
1886 * 001000 0010000100111111
1887 * rt -----
1888 * rs -----
1889 */
1890std::string NMD::ABSQ_S_W(uint64 instruction)
1891{
1892 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1893 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1894
1895 std::string rt = GPR(copy(rt_value));
1896 std::string rs = GPR(copy(rs_value));
1897
1898 return img::format("ABSQ_S.W %s, %s", rt, rs);
1899}
1900
1901
1902/*
1903 *
1904 *
1905 * 3 2 1
1906 * 10987654321098765432109876543210
1907 * 001000 0010000100111111
1908 * rt -----
1909 * rs -----
1910 */
1911std::string NMD::ACLR(uint64 instruction)
1912{
1913 uint64 bit_value = extract_bit_23_22_21(instruction);
1914 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
1915 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1916
1917 std::string bit = IMMEDIATE(copy(bit_value));
1918 std::string s = IMMEDIATE(copy(s_value));
1919 std::string rs = GPR(copy(rs_value));
1920
1921 return img::format("ACLR %s, %s(%s)", bit, s, rs);
1922}
1923
1924
1925/*
1926 *
1927 *
1928 * 3 2 1
1929 * 10987654321098765432109876543210
1930 * 001000 0010000100111111
1931 * rt -----
1932 * rs -----
1933 */
1934std::string NMD::ADD(uint64 instruction)
1935{
1936 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1937 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
1938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1939
1940 std::string rd = GPR(copy(rd_value));
1941 std::string rs = GPR(copy(rs_value));
1942 std::string rt = GPR(copy(rt_value));
1943
1944 return img::format("ADD %s, %s, %s", rd, rs, rt);
1945}
1946
1947
1948/*
1949 * ADD.D fd, fs, ft - Floating Point Add
1950 *
1951 * 3 2 1
1952 * 10987654321098765432109876543210
1953 * 010001 000101
1954 * fmt -----
1955 * ft -----
1956 * fs -----
1957 * fd -----
1958 */
1959std::string NMD::ADD_D(uint64 instruction)
1960{
1961 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
1962 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1963 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
1964
1965 std::string ft = FPR(copy(ft_value));
1966 std::string fs = FPR(copy(fs_value));
1967 std::string fd = FPR(copy(fd_value));
1968
1969 return img::format("ADD.D %s, %s, %s", fd, fs, ft);
1970}
1971
1972
1973/*
1974 * ADD.S fd, fs, ft - Floating Point Add
1975 *
1976 * 3 2 1
1977 * 10987654321098765432109876543210
1978 * 010001 000101
1979 * fmt -----
1980 * ft -----
1981 * fs -----
1982 * fd -----
1983 */
1984std::string NMD::ADD_S(uint64 instruction)
1985{
1986 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
1987 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
1988 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
1989
1990 std::string ft = FPR(copy(ft_value));
1991 std::string fs = FPR(copy(fs_value));
1992 std::string fd = FPR(copy(fd_value));
1993
1994 return img::format("ADD.S %s, %s, %s", fd, fs, ft);
1995}
1996
1997
1998/*
1999 *
2000 *
2001 * 3 2 1
2002 * 10987654321098765432109876543210
2003 * 001000 0010000100111111
2004 * rt -----
2005 * rs -----
2006 */
2007std::string NMD::ADDIU_32_(uint64 instruction)
2008{
2009 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2010 uint64 u_value = extract_u_15_to_0(instruction);
2011 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2012
2013 std::string rt = GPR(copy(rt_value));
2014 std::string rs = GPR(copy(rs_value));
2015 std::string u = IMMEDIATE(copy(u_value));
2016
2017 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2018}
2019
2020
2021/*
2022 *
2023 *
2024 * 3 2 1
2025 * 10987654321098765432109876543210
2026 * 001000 0010000100111111
2027 * rt -----
2028 * rs -----
2029 */
2030std::string NMD::ADDIU_48_(uint64 instruction)
2031{
2032 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2033 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2034
2035 std::string rt = GPR(copy(rt_value));
2036 std::string s = IMMEDIATE(copy(s_value));
2037
2038 return img::format("ADDIU %s, %s", rt, s);
2039}
2040
2041
2042/*
2043 *
2044 *
2045 * 3 2 1
2046 * 10987654321098765432109876543210
2047 * 001000 0010000100111111
2048 * rt -----
2049 * rs -----
2050 */
2051std::string NMD::ADDIU_GP48_(uint64 instruction)
2052{
2053 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2054 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2055
2056 std::string rt = GPR(copy(rt_value));
2057 std::string s = IMMEDIATE(copy(s_value));
2058
2059 return img::format("ADDIU %s, $%d, %s", rt, 28, s);
2060}
2061
2062
2063/*
2064 *
2065 *
2066 * 3 2 1
2067 * 10987654321098765432109876543210
2068 * 001000 0010000100111111
2069 * rt -----
2070 * rs -----
2071 */
2072std::string NMD::ADDIU_GP_B_(uint64 instruction)
2073{
2074 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2075 uint64 u_value = extract_u_17_to_0(instruction);
2076
2077 std::string rt = GPR(copy(rt_value));
2078 std::string u = IMMEDIATE(copy(u_value));
2079
2080 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2081}
2082
2083
2084/*
2085 *
2086 *
2087 * 3 2 1
2088 * 10987654321098765432109876543210
2089 * 001000 0010000100111111
2090 * rt -----
2091 * rs -----
2092 */
2093std::string NMD::ADDIU_GP_W_(uint64 instruction)
2094{
2095 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2096 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
2097
2098 std::string rt = GPR(copy(rt_value));
2099 std::string u = IMMEDIATE(copy(u_value));
2100
2101 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2102}
2103
2104
2105/*
2106 *
2107 *
2108 * 3 2 1
2109 * 10987654321098765432109876543210
2110 * 001000 0010000100111111
2111 * rt -----
2112 * rs -----
2113 */
2114std::string NMD::ADDIU_NEG_(uint64 instruction)
2115{
2116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2117 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2118 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2119
2120 std::string rt = GPR(copy(rt_value));
2121 std::string rs = GPR(copy(rs_value));
2122 std::string u = IMMEDIATE(neg_copy(u_value));
2123
2124 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2125}
2126
2127
2128/*
2129 *
2130 *
2131 * 3 2 1
2132 * 10987654321098765432109876543210
2133 * 001000 0010000100111111
2134 * rt -----
2135 * rs -----
2136 */
2137std::string NMD::ADDIU_R1_SP_(uint64 instruction)
2138{
2139 uint64 u_value = extr_uil0il2bs6Fmsb7(instruction);
2140 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2141
2142 std::string rt3 = GPR(encode_gpr3(rt3_value));
2143 std::string u = IMMEDIATE(copy(u_value));
2144
2145 return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
2146}
2147
2148
2149/*
2150 *
2151 *
2152 * 3 2 1
2153 * 10987654321098765432109876543210
2154 * 001000 0010000100111111
2155 * rt -----
2156 * rs -----
2157 */
2158std::string NMD::ADDIU_R2_(uint64 instruction)
2159{
2160 uint64 u_value = extr_uil0il2bs3Fmsb4(instruction);
2161 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2162 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2163
2164 std::string rt3 = GPR(encode_gpr3(rt3_value));
2165 std::string rs3 = GPR(encode_gpr3(rs3_value));
2166 std::string u = IMMEDIATE(copy(u_value));
2167
2168 return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
2169}
2170
2171
2172/*
2173 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
2174 *
2175 * 5432109876543210
2176 * 100100 1
2177 * rt -----
2178 * s - ---
2179 */
2180std::string NMD::ADDIU_RS5_(uint64 instruction)
2181{
2182 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
2183 int64 s_value = extract_s_4_2_1_0(instruction);
2184
2185 std::string rt = GPR(copy(rt_value));
2186 std::string s = IMMEDIATE(copy(s_value));
2187
2188 return img::format("ADDIU %s, %s", rt, s);
2189}
2190
2191
2192/*
2193 *
2194 *
2195 * 3 2 1
2196 * 10987654321098765432109876543210
2197 * 001000 x1110000101
2198 * rt -----
2199 * rs -----
2200 * rd -----
2201 */
2202std::string NMD::ADDIUPC_32_(uint64 instruction)
2203{
2204 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2205 int64 s_value = extr_sil0il21bs1_il1il1bs20Tmsb21(instruction);
2206
2207 std::string rt = GPR(copy(rt_value));
2208 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2209
2210 return img::format("ADDIUPC %s, %s", rt, s);
2211}
2212
2213
2214/*
2215 *
2216 *
2217 * 3 2 1
2218 * 10987654321098765432109876543210
2219 * 001000 x1110000101
2220 * rt -----
2221 * rs -----
2222 * rd -----
2223 */
2224std::string NMD::ADDIUPC_48_(uint64 instruction)
2225{
2226 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2227 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
2228
2229 std::string rt = GPR(copy(rt_value));
2230 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
2231
2232 return img::format("ADDIUPC %s, %s", rt, s);
2233}
2234
2235
2236/*
2237 * ADDQ.PH rd, rt, rs - Add Fractional Halfword Vectors
2238 *
2239 * 3 2 1
2240 * 10987654321098765432109876543210
2241 * 001000 00000001101
2242 * rt -----
2243 * rs -----
2244 * rd -----
2245 */
2246std::string NMD::ADDQ_PH(uint64 instruction)
2247{
2248 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2249 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2250 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2251
2252 std::string rd = GPR(copy(rd_value));
2253 std::string rs = GPR(copy(rs_value));
2254 std::string rt = GPR(copy(rt_value));
2255
2256 return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
2257}
2258
2259
2260/*
2261 * ADDQ_S.PH rd, rt, rs - Add Fractional Halfword Vectors
2262 *
2263 * 3 2 1
2264 * 10987654321098765432109876543210
2265 * 001000 10000001101
2266 * rt -----
2267 * rs -----
2268 * rd -----
2269 */
2270std::string NMD::ADDQ_S_PH(uint64 instruction)
2271{
2272 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2273 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2274 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2275
2276 std::string rd = GPR(copy(rd_value));
2277 std::string rs = GPR(copy(rs_value));
2278 std::string rt = GPR(copy(rt_value));
2279
2280 return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
2281}
2282
2283
2284/*
2285 * ADDQ_S.W rd, rt, rs - Add Fractional Words
2286 *
2287 * 3 2 1
2288 * 10987654321098765432109876543210
2289 * 001000 x1100000101
2290 * rt -----
2291 * rs -----
2292 * rd -----
2293 */
2294std::string NMD::ADDQ_S_W(uint64 instruction)
2295{
2296 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2297 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2298 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2299
2300 std::string rd = GPR(copy(rd_value));
2301 std::string rs = GPR(copy(rs_value));
2302 std::string rt = GPR(copy(rt_value));
2303
2304 return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2305}
2306
2307
2308/*
2309 * ADDQH.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2310 * to Halve Results
2311 *
2312 * 3 2 1
2313 * 10987654321098765432109876543210
2314 * 001000 00001001101
2315 * rt -----
2316 * rs -----
2317 * rd -----
2318 */
2319std::string NMD::ADDQH_PH(uint64 instruction)
2320{
2321 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2322 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2323 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2324
2325 std::string rd = GPR(copy(rd_value));
2326 std::string rs = GPR(copy(rs_value));
2327 std::string rt = GPR(copy(rt_value));
2328
2329 return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2330}
2331
2332
2333/*
2334 * ADDQH_R.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2335 * to Halve Results
2336 *
2337 * 3 2 1
2338 * 10987654321098765432109876543210
2339 * 001000 10001001101
2340 * rt -----
2341 * rs -----
2342 * rd -----
2343 */
2344std::string NMD::ADDQH_R_PH(uint64 instruction)
2345{
2346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2347 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2348 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2349
2350 std::string rd = GPR(copy(rd_value));
2351 std::string rs = GPR(copy(rs_value));
2352 std::string rt = GPR(copy(rt_value));
2353
2354 return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2355}
2356
2357
2358/*
2359 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2360 *
2361 * 3 2 1
2362 * 10987654321098765432109876543210
2363 * 001000 00010001101
2364 * rt -----
2365 * rs -----
2366 * rd -----
2367 */
2368std::string NMD::ADDQH_R_W(uint64 instruction)
2369{
2370 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2371 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2373
2374 std::string rd = GPR(copy(rd_value));
2375 std::string rs = GPR(copy(rs_value));
2376 std::string rt = GPR(copy(rt_value));
2377
2378 return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2379}
2380
2381
2382/*
2383 * ADDQH.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2384 *
2385 * 3 2 1
2386 * 10987654321098765432109876543210
2387 * 001000 10010001101
2388 * rt -----
2389 * rs -----
2390 * rd -----
2391 */
2392std::string NMD::ADDQH_W(uint64 instruction)
2393{
2394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2395 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2397
2398 std::string rd = GPR(copy(rd_value));
2399 std::string rs = GPR(copy(rs_value));
2400 std::string rt = GPR(copy(rt_value));
2401
2402 return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
2403}
2404
2405
2406/*
2407 * ADDSC rd, rt, rs - Add Signed Word and Set Carry Bit
2408 *
2409 * 3 2 1
2410 * 10987654321098765432109876543210
2411 * 001000 x1110000101
2412 * rt -----
2413 * rs -----
2414 * rd -----
2415 */
2416std::string NMD::ADDSC(uint64 instruction)
2417{
2418 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2419 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2420 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2421
2422 std::string rd = GPR(copy(rd_value));
2423 std::string rs = GPR(copy(rs_value));
2424 std::string rt = GPR(copy(rt_value));
2425
2426 return img::format("ADDSC %s, %s, %s", rd, rs, rt);
2427}
2428
2429
2430/*
2431 * ADDU[16] rd3, rs3, rt3 -
2432 *
2433 * 5432109876543210
2434 * 101100 0
2435 * rt3 ---
2436 * rs3 ---
2437 * rd3 ---
2438 */
2439std::string NMD::ADDU_16_(uint64 instruction)
2440{
2441 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2442 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2443 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2444
2445 std::string rt3 = GPR(encode_gpr3(rt3_value));
2446 std::string rs3 = GPR(encode_gpr3(rs3_value));
2447 std::string rd3 = GPR(encode_gpr3(rd3_value));
2448
2449 return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
2450}
2451
2452
2453/*
2454 *
2455 *
2456 * 3 2 1
2457 * 10987654321098765432109876543210
2458 * 001000 x1110000101
2459 * rt -----
2460 * rs -----
2461 * rd -----
2462 */
2463std::string NMD::ADDU_32_(uint64 instruction)
2464{
2465 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2466 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2467 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2468
2469 std::string rd = GPR(copy(rd_value));
2470 std::string rs = GPR(copy(rs_value));
2471 std::string rt = GPR(copy(rt_value));
2472
2473 return img::format("ADDU %s, %s, %s", rd, rs, rt);
2474}
2475
2476
2477/*
2478 *
2479 *
2480 * 3 2 1
2481 * 10987654321098765432109876543210
2482 * 001000 x1110000101
2483 * rt -----
2484 * rs -----
2485 * rd -----
2486 */
2487std::string NMD::ADDU_4X4_(uint64 instruction)
2488{
2489 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2490 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2491
2492 std::string rs4 = GPR(encode_gpr4(rs4_value));
2493 std::string rt4 = GPR(encode_gpr4(rt4_value));
2494
2495 return img::format("ADDU %s, %s", rs4, rt4);
2496}
2497
2498
2499/*
2500 * ADDU.PH rd, rt, rs - Unsigned Add Integer Halfwords
2501 *
2502 * 3 2 1
2503 * 10987654321098765432109876543210
2504 * 001000 00100001101
2505 * rt -----
2506 * rs -----
2507 * rd -----
2508 */
2509std::string NMD::ADDU_PH(uint64 instruction)
2510{
2511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2512 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2513 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2514
2515 std::string rd = GPR(copy(rd_value));
2516 std::string rs = GPR(copy(rs_value));
2517 std::string rt = GPR(copy(rt_value));
2518
2519 return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
2520}
2521
2522
2523/*
2524 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2525 *
2526 * 3 2 1
2527 * 10987654321098765432109876543210
2528 * 001000 00011001101
2529 * rt -----
2530 * rs -----
2531 * rd -----
2532 */
2533std::string NMD::ADDU_QB(uint64 instruction)
2534{
2535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2536 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2537 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2538
2539 std::string rd = GPR(copy(rd_value));
2540 std::string rs = GPR(copy(rs_value));
2541 std::string rt = GPR(copy(rt_value));
2542
2543 return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
2544}
2545
2546
2547/*
2548 * ADDU_S.PH rd, rt, rs - Unsigned Add Integer Halfwords
2549 *
2550 * 3 2 1
2551 * 10987654321098765432109876543210
2552 * 001000 10100001101
2553 * rt -----
2554 * rs -----
2555 * rd -----
2556 */
2557std::string NMD::ADDU_S_PH(uint64 instruction)
2558{
2559 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2560 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2561 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2562
2563 std::string rd = GPR(copy(rd_value));
2564 std::string rs = GPR(copy(rs_value));
2565 std::string rt = GPR(copy(rt_value));
2566
2567 return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2568}
2569
2570
2571/*
2572 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2573 *
2574 * 3 2 1
2575 * 10987654321098765432109876543210
2576 * 001000 10011001101
2577 * rt -----
2578 * rs -----
2579 * rd -----
2580 */
2581std::string NMD::ADDU_S_QB(uint64 instruction)
2582{
2583 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2584 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2585 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2586
2587 std::string rd = GPR(copy(rd_value));
2588 std::string rs = GPR(copy(rs_value));
2589 std::string rt = GPR(copy(rt_value));
2590
2591 return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2592}
2593
2594
2595/*
2596 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2597 * to Halve Results
2598 *
2599 * 3 2 1
2600 * 10987654321098765432109876543210
2601 * 001000 00101001101
2602 * rt -----
2603 * rs -----
2604 * rd -----
2605 */
2606std::string NMD::ADDUH_QB(uint64 instruction)
2607{
2608 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2609 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2611
2612 std::string rd = GPR(copy(rd_value));
2613 std::string rs = GPR(copy(rs_value));
2614 std::string rt = GPR(copy(rt_value));
2615
2616 return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2617}
2618
2619
2620/*
2621 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2622 * to Halve Results
2623 *
2624 * 3 2 1
2625 * 10987654321098765432109876543210
2626 * 001000 10101001101
2627 * rt -----
2628 * rs -----
2629 * rd -----
2630 */
2631std::string NMD::ADDUH_R_QB(uint64 instruction)
2632{
2633 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2634 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2635 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2636
2637 std::string rd = GPR(copy(rd_value));
2638 std::string rs = GPR(copy(rs_value));
2639 std::string rt = GPR(copy(rt_value));
2640
2641 return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2642}
2643
2644/*
2645 * ADDWC rd, rt, rs - Add Word with Carry Bit
2646 *
2647 * 3 2 1
2648 * 10987654321098765432109876543210
2649 * 001000 x1111000101
2650 * rt -----
2651 * rs -----
2652 * rd -----
2653 */
2654std::string NMD::ADDWC(uint64 instruction)
2655{
2656 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2657 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2658 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2659
2660 std::string rd = GPR(copy(rd_value));
2661 std::string rs = GPR(copy(rs_value));
2662 std::string rt = GPR(copy(rt_value));
2663
2664 return img::format("ADDWC %s, %s, %s", rd, rs, rt);
2665}
2666
2667
2668/*
2669 *
2670 *
2671 * 3 2 1
2672 * 10987654321098765432109876543210
2673 * 001000 x1110000101
2674 * rt -----
2675 * rs -----
2676 * rd -----
2677 */
2678std::string NMD::ALUIPC(uint64 instruction)
2679{
2680 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2681 int64 s_value = extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(instruction);
2682
2683 std::string rt = GPR(copy(rt_value));
2684 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2685
2686 return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2687}
2688
2689
2690/*
2691 * AND[16] rt3, rs3 -
2692 *
2693 * 5432109876543210
2694 * 101100
2695 * rt3 ---
2696 * rs3 ---
2697 * eu ----
2698 */
2699std::string NMD::AND_16_(uint64 instruction)
2700{
2701 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2702 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2703
2704 std::string rt3 = GPR(encode_gpr3(rt3_value));
2705 std::string rs3 = GPR(encode_gpr3(rs3_value));
2706
2707 return img::format("AND %s, %s", rs3, rt3);
2708}
2709
2710
2711/*
2712 *
2713 *
2714 * 3 2 1
2715 * 10987654321098765432109876543210
2716 * 001000 x1110000101
2717 * rt -----
2718 * rs -----
2719 * rd -----
2720 */
2721std::string NMD::AND_32_(uint64 instruction)
2722{
2723 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2724 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
2725 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2726
2727 std::string rd = GPR(copy(rd_value));
2728 std::string rs = GPR(copy(rs_value));
2729 std::string rt = GPR(copy(rt_value));
2730
2731 return img::format("AND %s, %s, %s", rd, rs, rt);
2732}
2733
2734
2735/*
2736 * ANDI rt, rs, u -
2737 *
2738 * 5432109876543210
2739 * 101100
2740 * rt3 ---
2741 * rs3 ---
2742 * eu ----
2743 */
2744std::string NMD::ANDI_16_(uint64 instruction)
2745{
2746 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2747 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2748 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2749
2750 std::string rt3 = GPR(encode_gpr3(rt3_value));
2751 std::string rs3 = GPR(encode_gpr3(rs3_value));
2752 std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
2753
2754 return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
2755}
2756
2757
2758/*
2759 *
2760 *
2761 * 3 2 1
2762 * 10987654321098765432109876543210
2763 * 001000 x1110000101
2764 * rt -----
2765 * rs -----
2766 * rd -----
2767 */
2768std::string NMD::ANDI_32_(uint64 instruction)
2769{
2770 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2771 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2772 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2773
2774 std::string rt = GPR(copy(rt_value));
2775 std::string rs = GPR(copy(rs_value));
2776 std::string u = IMMEDIATE(copy(u_value));
2777
2778 return img::format("ANDI %s, %s, %s", rt, rs, u);
2779}
2780
2781
2782/*
2783 *
2784 *
2785 * 3 2 1
2786 * 10987654321098765432109876543210
2787 * 001000 x1110000101
2788 * rt -----
2789 * rs -----
2790 * rd -----
2791 */
2792std::string NMD::APPEND(uint64 instruction)
2793{
2794 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2795 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2796 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2797
2798 std::string rt = GPR(copy(rt_value));
2799 std::string rs = GPR(copy(rs_value));
2800 std::string sa = IMMEDIATE(copy(sa_value));
2801
2802 return img::format("APPEND %s, %s, %s", rt, rs, sa);
2803}
2804
2805
2806/*
2807 *
2808 *
2809 * 3 2 1
2810 * 10987654321098765432109876543210
2811 * 001000 x1110000101
2812 * rt -----
2813 * rs -----
2814 * rd -----
2815 */
2816std::string NMD::ASET(uint64 instruction)
2817{
2818 uint64 bit_value = extract_bit_23_22_21(instruction);
2819 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
2820 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2821
2822 std::string bit = IMMEDIATE(copy(bit_value));
2823 std::string s = IMMEDIATE(copy(s_value));
2824 std::string rs = GPR(copy(rs_value));
2825
2826 return img::format("ASET %s, %s(%s)", bit, s, rs);
2827}
2828
2829
2830/*
2831 *
2832 *
2833 * 3 2 1
2834 * 10987654321098765432109876543210
2835 * 001000 x1110000101
2836 * rt -----
2837 * rs -----
2838 * rd -----
2839 */
2840std::string NMD::BALC_16_(uint64 instruction)
2841{
2842 int64 s_value = extr_sil0il10bs1_il1il1bs9Tmsb10(instruction);
2843
2844 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2845
2846 return img::format("BALC %s", s);
2847}
2848
2849
2850/*
2851 *
2852 *
2853 * 3 2 1
2854 * 10987654321098765432109876543210
2855 * 001000 x1110000101
2856 * rt -----
2857 * rs -----
2858 * rd -----
2859 */
2860std::string NMD::BALC_32_(uint64 instruction)
2861{
2862 int64 s_value = extr_sil0il25bs1_il1il1bs24Tmsb25(instruction);
2863
2864 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2865
2866 return img::format("BALC %s", s);
2867}
2868
2869
2870/*
2871 *
2872 *
2873 * 3 2 1
2874 * 10987654321098765432109876543210
2875 * 001000 x1110000101
2876 * rt -----
2877 * rs -----
2878 * rd -----
2879 */
2880std::string NMD::BALRSC(uint64 instruction)
2881{
2882 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2883 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2884
2885 std::string rt = GPR(copy(rt_value));
2886 std::string rs = GPR(copy(rs_value));
2887
2888 return img::format("BALRSC %s, %s", rt, rs);
2889}
2890
2891
2892/*
2893 *
2894 *
2895 * 3 2 1
2896 * 10987654321098765432109876543210
2897 * 001000 x1110000101
2898 * rt -----
2899 * rs -----
2900 * rd -----
2901 */
2902std::string NMD::BBEQZC(uint64 instruction)
2903{
2904 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2905 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2906 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
2907
2908 std::string rt = GPR(copy(rt_value));
2909 std::string bit = IMMEDIATE(copy(bit_value));
2910 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2911
2912 return img::format("BBEQZC %s, %s, %s", rt, bit, s);
2913}
2914
2915
2916/*
2917 *
2918 *
2919 * 3 2 1
2920 * 10987654321098765432109876543210
2921 * 001000 x1110000101
2922 * rt -----
2923 * rs -----
2924 * rd -----
2925 */
2926std::string NMD::BBNEZC(uint64 instruction)
2927{
2928 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2929 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2930 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
2931
2932 std::string rt = GPR(copy(rt_value));
2933 std::string bit = IMMEDIATE(copy(bit_value));
2934 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2935
2936 return img::format("BBNEZC %s, %s, %s", rt, bit, s);
2937}
2938
2939
2940/*
2941 *
2942 *
2943 * 3 2 1
2944 * 10987654321098765432109876543210
2945 * 001000 x1110000101
2946 * rt -----
2947 * rs -----
2948 * rd -----
2949 */
2950std::string NMD::BC_16_(uint64 instruction)
2951{
2952 int64 s_value = extr_sil0il10bs1_il1il1bs9Tmsb10(instruction);
2953
2954 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2955
2956 return img::format("BC %s", s);
2957}
2958
2959
2960/*
2961 *
2962 *
2963 * 3 2 1
2964 * 10987654321098765432109876543210
2965 * 001000 x1110000101
2966 * rt -----
2967 * rs -----
2968 * rd -----
2969 */
2970std::string NMD::BC_32_(uint64 instruction)
2971{
2972 int64 s_value = extr_sil0il25bs1_il1il1bs24Tmsb25(instruction);
2973
2974 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2975
2976 return img::format("BC %s", s);
2977}
2978
2979
2980/*
2981 *
2982 *
2983 * 3 2 1
2984 * 10987654321098765432109876543210
2985 * 001000 x1110000101
2986 * rt -----
2987 * rs -----
2988 * rd -----
2989 */
2990std::string NMD::BC1EQZC(uint64 instruction)
2991{
2992 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
2993 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
2994
2995 std::string ft = FPR(copy(ft_value));
2996 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2997
2998 return img::format("BC1EQZC %s, %s", ft, s);
2999}
3000
3001
3002/*
3003 *
3004 *
3005 * 3 2 1
3006 * 10987654321098765432109876543210
3007 * 001000 x1110000101
3008 * rt -----
3009 * rs -----
3010 * rd -----
3011 */
3012std::string NMD::BC1NEZC(uint64 instruction)
3013{
3014 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3015 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3016
3017 std::string ft = FPR(copy(ft_value));
3018 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3019
3020 return img::format("BC1NEZC %s, %s", ft, s);
3021}
3022
3023
3024/*
3025 *
3026 *
3027 * 3 2 1
3028 * 10987654321098765432109876543210
3029 * 001000 x1110000101
3030 * rt -----
3031 * rs -----
3032 * rd -----
3033 */
3034std::string NMD::BC2EQZC(uint64 instruction)
3035{
3036 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3037 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3038
3039 std::string ct = CPR(copy(ct_value));
3040 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3041
3042 return img::format("BC2EQZC %s, %s", ct, s);
3043}
3044
3045
3046/*
3047 *
3048 *
3049 * 3 2 1
3050 * 10987654321098765432109876543210
3051 * 001000 x1110000101
3052 * rt -----
3053 * rs -----
3054 * rd -----
3055 */
3056std::string NMD::BC2NEZC(uint64 instruction)
3057{
3058 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3059 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3060
3061 std::string ct = CPR(copy(ct_value));
3062 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3063
3064 return img::format("BC2NEZC %s, %s", ct, s);
3065}
3066
3067
3068/*
3069 *
3070 *
3071 * 3 2 1
3072 * 10987654321098765432109876543210
3073 * 001000 x1110000101
3074 * rt -----
3075 * rs -----
3076 * rd -----
3077 */
3078std::string NMD::BEQC_16_(uint64 instruction)
3079{
3080 uint64 u_value = extr_uil0il1bs4Fmsb4(instruction);
3081 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3082 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3083
3084 std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
3085 std::string rt3 = GPR(encode_gpr3(rt3_value));
3086 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3087
3088 return img::format("BEQC %s, %s, %s", rs3, rt3, u);
3089}
3090
3091
3092/*
3093 *
3094 *
3095 * 3 2 1
3096 * 10987654321098765432109876543210
3097 * 001000 x1110000101
3098 * rt -----
3099 * rs -----
3100 * rd -----
3101 */
3102std::string NMD::BEQC_32_(uint64 instruction)
3103{
3104 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3105 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3107
3108 std::string rs = GPR(copy(rs_value));
3109 std::string rt = GPR(copy(rt_value));
3110 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3111
3112 return img::format("BEQC %s, %s, %s", rs, rt, s);
3113}
3114
3115
3116/*
3117 *
3118 *
3119 * 3 2 1
3120 * 10987654321098765432109876543210
3121 * 001000 x1110000101
3122 * rt -----
3123 * rs -----
3124 * rd -----
3125 */
3126std::string NMD::BEQIC(uint64 instruction)
3127{
3128 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3129 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3130 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3131
3132 std::string rt = GPR(copy(rt_value));
3133 std::string u = IMMEDIATE(copy(u_value));
3134 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3135
3136 return img::format("BEQIC %s, %s, %s", rt, u, s);
3137}
3138
3139
3140/*
3141 *
3142 *
3143 * 3 2 1
3144 * 10987654321098765432109876543210
3145 * 001000 x1110000101
3146 * rt -----
3147 * rs -----
3148 * rd -----
3149 */
3150std::string NMD::BEQZC_16_(uint64 instruction)
3151{
3152 int64 s_value = extr_sil0il7bs1_il1il1bs6Tmsb7(instruction);
3153 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3154
3155 std::string rt3 = GPR(encode_gpr3(rt3_value));
3156 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3157
3158 return img::format("BEQZC %s, %s", rt3, s);
3159}
3160
3161
3162/*
3163 *
3164 *
3165 * 3 2 1
3166 * 10987654321098765432109876543210
3167 * 001000 x1110000101
3168 * rt -----
3169 * rs -----
3170 * rd -----
3171 */
3172std::string NMD::BGEC(uint64 instruction)
3173{
3174 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3175 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3176 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3177
3178 std::string rs = GPR(copy(rs_value));
3179 std::string rt = GPR(copy(rt_value));
3180 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3181
3182 return img::format("BGEC %s, %s, %s", rs, rt, s);
3183}
3184
3185
3186/*
3187 *
3188 *
3189 * 3 2 1
3190 * 10987654321098765432109876543210
3191 * 001000 x1110000101
3192 * rt -----
3193 * rs -----
3194 * rd -----
3195 */
3196std::string NMD::BGEIC(uint64 instruction)
3197{
3198 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3199 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3200 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3201
3202 std::string rt = GPR(copy(rt_value));
3203 std::string u = IMMEDIATE(copy(u_value));
3204 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3205
3206 return img::format("BGEIC %s, %s, %s", rt, u, s);
3207}
3208
3209
3210/*
3211 *
3212 *
3213 * 3 2 1
3214 * 10987654321098765432109876543210
3215 * 001000 x1110000101
3216 * rt -----
3217 * rs -----
3218 * rd -----
3219 */
3220std::string NMD::BGEIUC(uint64 instruction)
3221{
3222 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3223 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3224 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3225
3226 std::string rt = GPR(copy(rt_value));
3227 std::string u = IMMEDIATE(copy(u_value));
3228 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3229
3230 return img::format("BGEIUC %s, %s, %s", rt, u, s);
3231}
3232
3233
3234/*
3235 *
3236 *
3237 * 3 2 1
3238 * 10987654321098765432109876543210
3239 * 001000 x1110000101
3240 * rt -----
3241 * rs -----
3242 * rd -----
3243 */
3244std::string NMD::BGEUC(uint64 instruction)
3245{
3246 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3247 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3248 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3249
3250 std::string rs = GPR(copy(rs_value));
3251 std::string rt = GPR(copy(rt_value));
3252 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3253
3254 return img::format("BGEUC %s, %s, %s", rs, rt, s);
3255}
3256
3257
3258/*
3259 *
3260 *
3261 * 3 2 1
3262 * 10987654321098765432109876543210
3263 * 001000 x1110000101
3264 * rt -----
3265 * rs -----
3266 * rd -----
3267 */
3268std::string NMD::BLTC(uint64 instruction)
3269{
3270 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3271 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3272 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3273
3274 std::string rs = GPR(copy(rs_value));
3275 std::string rt = GPR(copy(rt_value));
3276 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3277
3278 return img::format("BLTC %s, %s, %s", rs, rt, s);
3279}
3280
3281
3282/*
3283 *
3284 *
3285 * 3 2 1
3286 * 10987654321098765432109876543210
3287 * 001000 x1110000101
3288 * rt -----
3289 * rs -----
3290 * rd -----
3291 */
3292std::string NMD::BLTIC(uint64 instruction)
3293{
3294 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3295 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3296 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3297
3298 std::string rt = GPR(copy(rt_value));
3299 std::string u = IMMEDIATE(copy(u_value));
3300 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3301
3302 return img::format("BLTIC %s, %s, %s", rt, u, s);
3303}
3304
3305
3306/*
3307 *
3308 *
3309 * 3 2 1
3310 * 10987654321098765432109876543210
3311 * 001000 x1110000101
3312 * rt -----
3313 * rs -----
3314 * rd -----
3315 */
3316std::string NMD::BLTIUC(uint64 instruction)
3317{
3318 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3319 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3320 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3321
3322 std::string rt = GPR(copy(rt_value));
3323 std::string u = IMMEDIATE(copy(u_value));
3324 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3325
3326 return img::format("BLTIUC %s, %s, %s", rt, u, s);
3327}
3328
3329
3330/*
3331 *
3332 *
3333 * 3 2 1
3334 * 10987654321098765432109876543210
3335 * 001000 x1110000101
3336 * rt -----
3337 * rs -----
3338 * rd -----
3339 */
3340std::string NMD::BLTUC(uint64 instruction)
3341{
3342 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3343 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3344 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3345
3346 std::string rs = GPR(copy(rs_value));
3347 std::string rt = GPR(copy(rt_value));
3348 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3349
3350 return img::format("BLTUC %s, %s, %s", rs, rt, s);
3351}
3352
3353
3354/*
3355 *
3356 *
3357 * 3 2 1
3358 * 10987654321098765432109876543210
3359 * 001000 x1110000101
3360 * rt -----
3361 * rs -----
3362 * rd -----
3363 */
3364std::string NMD::BNEC_16_(uint64 instruction)
3365{
3366 uint64 u_value = extr_uil0il1bs4Fmsb4(instruction);
3367 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3368 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3369
3370 std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
3371 std::string rt3 = GPR(encode_gpr3(rt3_value));
3372 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3373
3374 return img::format("BNEC %s, %s, %s", rs3, rt3, u);
3375}
3376
3377
3378/*
3379 *
3380 *
3381 * 3 2 1
3382 * 10987654321098765432109876543210
3383 * 001000 x1110000101
3384 * rt -----
3385 * rs -----
3386 * rd -----
3387 */
3388std::string NMD::BNEC_32_(uint64 instruction)
3389{
3390 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3391 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3392 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3393
3394 std::string rs = GPR(copy(rs_value));
3395 std::string rt = GPR(copy(rt_value));
3396 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3397
3398 return img::format("BNEC %s, %s, %s", rs, rt, s);
3399}
3400
3401
3402/*
3403 *
3404 *
3405 * 3 2 1
3406 * 10987654321098765432109876543210
3407 * 001000 x1110000101
3408 * rt -----
3409 * rs -----
3410 * rd -----
3411 */
3412std::string NMD::BNEIC(uint64 instruction)
3413{
3414 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3415 int64 s_value = extr_sil0il11bs1_il1il1bs10Tmsb11(instruction);
3416 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3417
3418 std::string rt = GPR(copy(rt_value));
3419 std::string u = IMMEDIATE(copy(u_value));
3420 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3421
3422 return img::format("BNEIC %s, %s, %s", rt, u, s);
3423}
3424
3425
3426/*
3427 *
3428 *
3429 * 3 2 1
3430 * 10987654321098765432109876543210
3431 * 001000 x1110000101
3432 * rt -----
3433 * rs -----
3434 * rd -----
3435 */
3436std::string NMD::BNEZC_16_(uint64 instruction)
3437{
3438 int64 s_value = extr_sil0il7bs1_il1il1bs6Tmsb7(instruction);
3439 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3440
3441 std::string rt3 = GPR(encode_gpr3(rt3_value));
3442 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3443
3444 return img::format("BNEZC %s, %s", rt3, s);
3445}
3446
3447
3448/*
3449 *
3450 *
3451 * 3 2 1
3452 * 10987654321098765432109876543210
3453 * 001000 x1110000101
3454 * rt -----
3455 * rs -----
3456 * rd -----
3457 */
3458std::string NMD::BPOSGE32C(uint64 instruction)
3459{
3460 int64 s_value = extr_sil0il14bs1_il1il1bs13Tmsb14(instruction);
3461
3462 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3463
3464 return img::format("BPOSGE32C %s", s);
3465}
3466
3467
3468/*
3469 *
3470 *
3471 * 3 2 1
3472 * 10987654321098765432109876543210
3473 * 001000 x1110000101
3474 * rt -----
3475 * rs -----
3476 * rd -----
3477 */
3478std::string NMD::BREAK_16_(uint64 instruction)
3479{
3480 uint64 code_value = extract_code_2_1_0(instruction);
3481
3482 std::string code = IMMEDIATE(copy(code_value));
3483
3484 return img::format("BREAK %s", code);
3485}
3486
3487
3488/*
3489 * BREAK code - Break. Cause a Breakpoint exception
3490 *
3491 * 3 2 1
3492 * 10987654321098765432109876543210
3493 * 001000 x1110000101
3494 * rt -----
3495 * rs -----
3496 * rd -----
3497 */
3498std::string NMD::BREAK_32_(uint64 instruction)
3499{
3500 uint64 code_value = extract_code_18_to_0(instruction);
3501
3502 std::string code = IMMEDIATE(copy(code_value));
3503
3504 return img::format("BREAK %s", code);
3505}
3506
3507
3508/*
3509 *
3510 *
3511 * 3 2 1
3512 * 10987654321098765432109876543210
3513 * 001000 x1110000101
3514 * rt -----
3515 * rs -----
3516 * rd -----
3517 */
3518std::string NMD::BRSC(uint64 instruction)
3519{
3520 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3521
3522 std::string rs = GPR(copy(rs_value));
3523
3524 return img::format("BRSC %s", rs);
3525}
3526
3527
3528/*
3529 *
3530 *
3531 * 3 2 1
3532 * 10987654321098765432109876543210
3533 * 001000 x1110000101
3534 * rt -----
3535 * rs -----
3536 * rd -----
3537 */
3538std::string NMD::CACHE(uint64 instruction)
3539{
3540 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
3541 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3542 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3543
3544 std::string op = IMMEDIATE(copy(op_value));
3545 std::string s = IMMEDIATE(copy(s_value));
3546 std::string rs = GPR(copy(rs_value));
3547
3548 return img::format("CACHE %s, %s(%s)", op, s, rs);
3549}
3550
3551
3552/*
3553 *
3554 *
3555 * 3 2 1
3556 * 10987654321098765432109876543210
3557 * 001000 x1110000101
3558 * rt -----
3559 * rs -----
3560 * rd -----
3561 */
3562std::string NMD::CACHEE(uint64 instruction)
3563{
3564 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
3565 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3566 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3567
3568 std::string op = IMMEDIATE(copy(op_value));
3569 std::string s = IMMEDIATE(copy(s_value));
3570 std::string rs = GPR(copy(rs_value));
3571
3572 return img::format("CACHEE %s, %s(%s)", op, s, rs);
3573}
3574
3575
3576/*
3577 *
3578 *
3579 * 3 2 1
3580 * 10987654321098765432109876543210
3581 * 001000 x1110000101
3582 * rt -----
3583 * rs -----
3584 * rd -----
3585 */
3586std::string NMD::CEIL_L_D(uint64 instruction)
3587{
3588 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3589 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3590
3591 std::string ft = FPR(copy(ft_value));
3592 std::string fs = FPR(copy(fs_value));
3593
3594 return img::format("CEIL.L.D %s, %s", ft, fs);
3595}
3596
3597
3598/*
3599 *
3600 *
3601 * 3 2 1
3602 * 10987654321098765432109876543210
3603 * 001000 x1110000101
3604 * rt -----
3605 * rs -----
3606 * rd -----
3607 */
3608std::string NMD::CEIL_L_S(uint64 instruction)
3609{
3610 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3611 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3612
3613 std::string ft = FPR(copy(ft_value));
3614 std::string fs = FPR(copy(fs_value));
3615
3616 return img::format("CEIL.L.S %s, %s", ft, fs);
3617}
3618
3619
3620/*
3621 *
3622 *
3623 * 3 2 1
3624 * 10987654321098765432109876543210
3625 * 001000 x1110000101
3626 * rt -----
3627 * rs -----
3628 * rd -----
3629 */
3630std::string NMD::CEIL_W_D(uint64 instruction)
3631{
3632 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3633 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3634
3635 std::string ft = FPR(copy(ft_value));
3636 std::string fs = FPR(copy(fs_value));
3637
3638 return img::format("CEIL.W.D %s, %s", ft, fs);
3639}
3640
3641
3642/*
3643 *
3644 *
3645 * 3 2 1
3646 * 10987654321098765432109876543210
3647 * 001000 x1110000101
3648 * rt -----
3649 * rs -----
3650 * rd -----
3651 */
3652std::string NMD::CEIL_W_S(uint64 instruction)
3653{
3654 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3655 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3656
3657 std::string ft = FPR(copy(ft_value));
3658 std::string fs = FPR(copy(fs_value));
3659
3660 return img::format("CEIL.W.S %s, %s", ft, fs);
3661}
3662
3663
3664/*
3665 *
3666 *
3667 * 3 2 1
3668 * 10987654321098765432109876543210
3669 * 001000 x1110000101
3670 * rt -----
3671 * rs -----
3672 * rd -----
3673 */
3674std::string NMD::CFC1(uint64 instruction)
3675{
3676 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3677 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3678
3679 std::string rt = GPR(copy(rt_value));
3680 std::string cs = CPR(copy(cs_value));
3681
3682 return img::format("CFC1 %s, %s", rt, cs);
3683}
3684
3685
3686/*
3687 *
3688 *
3689 * 3 2 1
3690 * 10987654321098765432109876543210
3691 * 001000 x1110000101
3692 * rt -----
3693 * rs -----
3694 * rd -----
3695 */
3696std::string NMD::CFC2(uint64 instruction)
3697{
3698 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3699 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3700
3701 std::string rt = GPR(copy(rt_value));
3702 std::string cs = CPR(copy(cs_value));
3703
3704 return img::format("CFC2 %s, %s", rt, cs);
3705}
3706
3707
3708/*
3709 *
3710 *
3711 * 3 2 1
3712 * 10987654321098765432109876543210
3713 * 001000 x1110000101
3714 * rt -----
3715 * rs -----
3716 * rd -----
3717 */
3718std::string NMD::CLASS_D(uint64 instruction)
3719{
3720 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3721 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3722
3723 std::string ft = FPR(copy(ft_value));
3724 std::string fs = FPR(copy(fs_value));
3725
3726 return img::format("CLASS.D %s, %s", ft, fs);
3727}
3728
3729
3730/*
3731 *
3732 *
3733 * 3 2 1
3734 * 10987654321098765432109876543210
3735 * 001000 x1110000101
3736 * rt -----
3737 * rs -----
3738 * rd -----
3739 */
3740std::string NMD::CLASS_S(uint64 instruction)
3741{
3742 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3743 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3744
3745 std::string ft = FPR(copy(ft_value));
3746 std::string fs = FPR(copy(fs_value));
3747
3748 return img::format("CLASS.S %s, %s", ft, fs);
3749}
3750
3751
3752/*
3753 *
3754 *
3755 * 3 2 1
3756 * 10987654321098765432109876543210
3757 * 001000 x1110000101
3758 * rt -----
3759 * rs -----
3760 * rd -----
3761 */
3762std::string NMD::CLO(uint64 instruction)
3763{
3764 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3765 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3766
3767 std::string rt = GPR(copy(rt_value));
3768 std::string rs = GPR(copy(rs_value));
3769
3770 return img::format("CLO %s, %s", rt, rs);
3771}
3772
3773
3774/*
3775 *
3776 *
3777 * 3 2 1
3778 * 10987654321098765432109876543210
3779 * 001000 x1110000101
3780 * rt -----
3781 * rs -----
3782 * rd -----
3783 */
3784std::string NMD::CLZ(uint64 instruction)
3785{
3786 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3787 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3788
3789 std::string rt = GPR(copy(rt_value));
3790 std::string rs = GPR(copy(rs_value));
3791
3792 return img::format("CLZ %s, %s", rt, rs);
3793}
3794
3795
3796/*
3797 *
3798 *
3799 * 3 2 1
3800 * 10987654321098765432109876543210
3801 * 001000 x1110000101
3802 * rt -----
3803 * rs -----
3804 * rd -----
3805 */
3806std::string NMD::CMP_AF_D(uint64 instruction)
3807{
3808 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3809 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3810 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3811
3812 std::string fd = FPR(copy(fd_value));
3813 std::string fs = FPR(copy(fs_value));
3814 std::string ft = FPR(copy(ft_value));
3815
3816 return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3817}
3818
3819
3820/*
3821 *
3822 *
3823 * 3 2 1
3824 * 10987654321098765432109876543210
3825 * 001000 x1110000101
3826 * rt -----
3827 * rs -----
3828 * rd -----
3829 */
3830std::string NMD::CMP_AF_S(uint64 instruction)
3831{
3832 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3833 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3834 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3835
3836 std::string fd = FPR(copy(fd_value));
3837 std::string fs = FPR(copy(fs_value));
3838 std::string ft = FPR(copy(ft_value));
3839
3840 return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3841}
3842
3843
3844/*
3845 *
3846 *
3847 * 3 2 1
3848 * 10987654321098765432109876543210
3849 * 001000 x1110000101
3850 * rt -----
3851 * rs -----
3852 * rd -----
3853 */
3854std::string NMD::CMP_EQ_D(uint64 instruction)
3855{
3856 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3857 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3858 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3859
3860 std::string fd = FPR(copy(fd_value));
3861 std::string fs = FPR(copy(fs_value));
3862 std::string ft = FPR(copy(ft_value));
3863
3864 return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3865}
3866
3867
3868/*
3869 *
3870 *
3871 * 3 2 1
3872 * 10987654321098765432109876543210
3873 * 001000 x1110000101
3874 * rt -----
3875 * rs -----
3876 * rd -----
3877 */
3878std::string NMD::CMP_EQ_PH(uint64 instruction)
3879{
3880 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3881 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3882
3883 std::string rs = GPR(copy(rs_value));
3884 std::string rt = GPR(copy(rt_value));
3885
3886 return img::format("CMP.EQ.PH %s, %s", rs, rt);
3887}
3888
3889
3890/*
3891 *
3892 *
3893 * 3 2 1
3894 * 10987654321098765432109876543210
3895 * 001000 x1110000101
3896 * rt -----
3897 * rs -----
3898 * rd -----
3899 */
3900std::string NMD::CMP_EQ_S(uint64 instruction)
3901{
3902 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3903 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3904 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3905
3906 std::string fd = FPR(copy(fd_value));
3907 std::string fs = FPR(copy(fs_value));
3908 std::string ft = FPR(copy(ft_value));
3909
3910 return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3911}
3912
3913
3914/*
3915 *
3916 *
3917 * 3 2 1
3918 * 10987654321098765432109876543210
3919 * 001000 x1110000101
3920 * rt -----
3921 * rs -----
3922 * rd -----
3923 */
3924std::string NMD::CMP_LE_D(uint64 instruction)
3925{
3926 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3927 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3928 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3929
3930 std::string fd = FPR(copy(fd_value));
3931 std::string fs = FPR(copy(fs_value));
3932 std::string ft = FPR(copy(ft_value));
3933
3934 return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3935}
3936
3937
3938/*
3939 *
3940 *
3941 * 3 2 1
3942 * 10987654321098765432109876543210
3943 * 001000 x1110000101
3944 * rt -----
3945 * rs -----
3946 * rd -----
3947 */
3948std::string NMD::CMP_LE_PH(uint64 instruction)
3949{
3950 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3951 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3952
3953 std::string rs = GPR(copy(rs_value));
3954 std::string rt = GPR(copy(rt_value));
3955
3956 return img::format("CMP.LE.PH %s, %s", rs, rt);
3957}
3958
3959
3960/*
3961 *
3962 *
3963 * 3 2 1
3964 * 10987654321098765432109876543210
3965 * 001000 x1110000101
3966 * rt -----
3967 * rs -----
3968 * rd -----
3969 */
3970std::string NMD::CMP_LE_S(uint64 instruction)
3971{
3972 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3973 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3974 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3975
3976 std::string fd = FPR(copy(fd_value));
3977 std::string fs = FPR(copy(fs_value));
3978 std::string ft = FPR(copy(ft_value));
3979
3980 return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3981}
3982
3983
3984/*
3985 *
3986 *
3987 * 3 2 1
3988 * 10987654321098765432109876543210
3989 * 001000 x1110000101
3990 * rt -----
3991 * rs -----
3992 * rd -----
3993 */
3994std::string NMD::CMP_LT_D(uint64 instruction)
3995{
3996 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
3997 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
3998 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
3999
4000 std::string fd = FPR(copy(fd_value));
4001 std::string fs = FPR(copy(fs_value));
4002 std::string ft = FPR(copy(ft_value));
4003
4004 return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
4005}
4006
4007
4008/*
4009 *
4010 *
4011 * 3 2 1
4012 * 10987654321098765432109876543210
4013 * 001000 x1110000101
4014 * rt -----
4015 * rs -----
4016 * rd -----
4017 */
4018std::string NMD::CMP_LT_PH(uint64 instruction)
4019{
4020 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4021 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4022
4023 std::string rs = GPR(copy(rs_value));
4024 std::string rt = GPR(copy(rt_value));
4025
4026 return img::format("CMP.LT.PH %s, %s", rs, rt);
4027}
4028
4029
4030/*
4031 *
4032 *
4033 * 3 2 1
4034 * 10987654321098765432109876543210
4035 * 001000 x1110000101
4036 * rt -----
4037 * rs -----
4038 * rd -----
4039 */
4040std::string NMD::CMP_LT_S(uint64 instruction)
4041{
4042 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4043 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4044 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4045
4046 std::string fd = FPR(copy(fd_value));
4047 std::string fs = FPR(copy(fs_value));
4048 std::string ft = FPR(copy(ft_value));
4049
4050 return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
4051}
4052
4053
4054/*
4055 *
4056 *
4057 * 3 2 1
4058 * 10987654321098765432109876543210
4059 * 001000 x1110000101
4060 * rt -----
4061 * rs -----
4062 * rd -----
4063 */
4064std::string NMD::CMP_NE_D(uint64 instruction)
4065{
4066 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4067 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4068 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4069
4070 std::string fd = FPR(copy(fd_value));
4071 std::string fs = FPR(copy(fs_value));
4072 std::string ft = FPR(copy(ft_value));
4073
4074 return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
4075}
4076
4077
4078/*
4079 *
4080 *
4081 * 3 2 1
4082 * 10987654321098765432109876543210
4083 * 001000 x1110000101
4084 * rt -----
4085 * rs -----
4086 * rd -----
4087 */
4088std::string NMD::CMP_NE_S(uint64 instruction)
4089{
4090 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4091 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4092 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4093
4094 std::string fd = FPR(copy(fd_value));
4095 std::string fs = FPR(copy(fs_value));
4096 std::string ft = FPR(copy(ft_value));
4097
4098 return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
4099}
4100
4101
4102/*
4103 *
4104 *
4105 * 3 2 1
4106 * 10987654321098765432109876543210
4107 * 001000 x1110000101
4108 * rt -----
4109 * rs -----
4110 * rd -----
4111 */
4112std::string NMD::CMP_OR_D(uint64 instruction)
4113{
4114 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4115 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4116 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4117
4118 std::string fd = FPR(copy(fd_value));
4119 std::string fs = FPR(copy(fs_value));
4120 std::string ft = FPR(copy(ft_value));
4121
4122 return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
4123}
4124
4125
4126/*
4127 *
4128 *
4129 * 3 2 1
4130 * 10987654321098765432109876543210
4131 * 001000 x1110000101
4132 * rt -----
4133 * rs -----
4134 * rd -----
4135 */
4136std::string NMD::CMP_OR_S(uint64 instruction)
4137{
4138 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4139 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4140 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4141
4142 std::string fd = FPR(copy(fd_value));
4143 std::string fs = FPR(copy(fs_value));
4144 std::string ft = FPR(copy(ft_value));
4145
4146 return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
4147}
4148
4149
4150/*
4151 *
4152 *
4153 * 3 2 1
4154 * 10987654321098765432109876543210
4155 * 001000 x1110000101
4156 * rt -----
4157 * rs -----
4158 * rd -----
4159 */
4160std::string NMD::CMP_SAF_D(uint64 instruction)
4161{
4162 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4163 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4164 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4165
4166 std::string fd = FPR(copy(fd_value));
4167 std::string fs = FPR(copy(fs_value));
4168 std::string ft = FPR(copy(ft_value));
4169
4170 return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
4171}
4172
4173
4174/*
4175 *
4176 *
4177 * 3 2 1
4178 * 10987654321098765432109876543210
4179 * 001000 x1110000101
4180 * rt -----
4181 * rs -----
4182 * rd -----
4183 */
4184std::string NMD::CMP_SAF_S(uint64 instruction)
4185{
4186 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4187 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4188 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4189
4190 std::string fd = FPR(copy(fd_value));
4191 std::string fs = FPR(copy(fs_value));
4192 std::string ft = FPR(copy(ft_value));
4193
4194 return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
4195}
4196
4197
4198/*
4199 *
4200 *
4201 * 3 2 1
4202 * 10987654321098765432109876543210
4203 * 001000 x1110000101
4204 * rt -----
4205 * rs -----
4206 * rd -----
4207 */
4208std::string NMD::CMP_SEQ_D(uint64 instruction)
4209{
4210 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4211 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4212 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4213
4214 std::string fd = FPR(copy(fd_value));
4215 std::string fs = FPR(copy(fs_value));
4216 std::string ft = FPR(copy(ft_value));
4217
4218 return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
4219}
4220
4221
4222/*
4223 *
4224 *
4225 * 3 2 1
4226 * 10987654321098765432109876543210
4227 * 001000 x1110000101
4228 * rt -----
4229 * rs -----
4230 * rd -----
4231 */
4232std::string NMD::CMP_SEQ_S(uint64 instruction)
4233{
4234 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4235 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4236 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4237
4238 std::string fd = FPR(copy(fd_value));
4239 std::string fs = FPR(copy(fs_value));
4240 std::string ft = FPR(copy(ft_value));
4241
4242 return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
4243}
4244
4245
4246/*
4247 *
4248 *
4249 * 3 2 1
4250 * 10987654321098765432109876543210
4251 * 001000 x1110000101
4252 * rt -----
4253 * rs -----
4254 * rd -----
4255 */
4256std::string NMD::CMP_SLE_D(uint64 instruction)
4257{
4258 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4259 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4260 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4261
4262 std::string fd = FPR(copy(fd_value));
4263 std::string fs = FPR(copy(fs_value));
4264 std::string ft = FPR(copy(ft_value));
4265
4266 return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
4267}
4268
4269
4270/*
4271 *
4272 *
4273 * 3 2 1
4274 * 10987654321098765432109876543210
4275 * 001000 x1110000101
4276 * rt -----
4277 * rs -----
4278 * rd -----
4279 */
4280std::string NMD::CMP_SLE_S(uint64 instruction)
4281{
4282 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4283 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4284 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4285
4286 std::string fd = FPR(copy(fd_value));
4287 std::string fs = FPR(copy(fs_value));
4288 std::string ft = FPR(copy(ft_value));
4289
4290 return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
4291}
4292
4293
4294/*
4295 *
4296 *
4297 * 3 2 1
4298 * 10987654321098765432109876543210
4299 * 001000 x1110000101
4300 * rt -----
4301 * rs -----
4302 * rd -----
4303 */
4304std::string NMD::CMP_SLT_D(uint64 instruction)
4305{
4306 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4307 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4308 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4309
4310 std::string fd = FPR(copy(fd_value));
4311 std::string fs = FPR(copy(fs_value));
4312 std::string ft = FPR(copy(ft_value));
4313
4314 return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4315}
4316
4317
4318/*
4319 *
4320 *
4321 * 3 2 1
4322 * 10987654321098765432109876543210
4323 * 001000 x1110000101
4324 * rt -----
4325 * rs -----
4326 * rd -----
4327 */
4328std::string NMD::CMP_SLT_S(uint64 instruction)
4329{
4330 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4331 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4332 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4333
4334 std::string fd = FPR(copy(fd_value));
4335 std::string fs = FPR(copy(fs_value));
4336 std::string ft = FPR(copy(ft_value));
4337
4338 return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4339}
4340
4341
4342/*
4343 *
4344 *
4345 * 3 2 1
4346 * 10987654321098765432109876543210
4347 * 001000 x1110000101
4348 * rt -----
4349 * rs -----
4350 * rd -----
4351 */
4352std::string NMD::CMP_SNE_D(uint64 instruction)
4353{
4354 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4355 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4356 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4357
4358 std::string fd = FPR(copy(fd_value));
4359 std::string fs = FPR(copy(fs_value));
4360 std::string ft = FPR(copy(ft_value));
4361
4362 return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4363}
4364
4365
4366/*
4367 *
4368 *
4369 * 3 2 1
4370 * 10987654321098765432109876543210
4371 * 001000 x1110000101
4372 * rt -----
4373 * rs -----
4374 * rd -----
4375 */
4376std::string NMD::CMP_SNE_S(uint64 instruction)
4377{
4378 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4379 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4380 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4381
4382 std::string fd = FPR(copy(fd_value));
4383 std::string fs = FPR(copy(fs_value));
4384 std::string ft = FPR(copy(ft_value));
4385
4386 return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4387}
4388
4389
4390/*
4391 *
4392 *
4393 * 3 2 1
4394 * 10987654321098765432109876543210
4395 * 001000 x1110000101
4396 * rt -----
4397 * rs -----
4398 * rd -----
4399 */
4400std::string NMD::CMP_SOR_D(uint64 instruction)
4401{
4402 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4403 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4404 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4405
4406 std::string fd = FPR(copy(fd_value));
4407 std::string fs = FPR(copy(fs_value));
4408 std::string ft = FPR(copy(ft_value));
4409
4410 return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4411}
4412
4413
4414/*
4415 *
4416 *
4417 * 3 2 1
4418 * 10987654321098765432109876543210
4419 * 001000 x1110000101
4420 * rt -----
4421 * rs -----
4422 * rd -----
4423 */
4424std::string NMD::CMP_SOR_S(uint64 instruction)
4425{
4426 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4427 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4428 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4429
4430 std::string fd = FPR(copy(fd_value));
4431 std::string fs = FPR(copy(fs_value));
4432 std::string ft = FPR(copy(ft_value));
4433
4434 return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4435}
4436
4437
4438/*
4439 *
4440 *
4441 * 3 2 1
4442 * 10987654321098765432109876543210
4443 * 001000 x1110000101
4444 * rt -----
4445 * rs -----
4446 * rd -----
4447 */
4448std::string NMD::CMP_SUEQ_D(uint64 instruction)
4449{
4450 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4451 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4452 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4453
4454 std::string fd = FPR(copy(fd_value));
4455 std::string fs = FPR(copy(fs_value));
4456 std::string ft = FPR(copy(ft_value));
4457
4458 return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4459}
4460
4461
4462/*
4463 *
4464 *
4465 * 3 2 1
4466 * 10987654321098765432109876543210
4467 * 001000 x1110000101
4468 * rt -----
4469 * rs -----
4470 * rd -----
4471 */
4472std::string NMD::CMP_SUEQ_S(uint64 instruction)
4473{
4474 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4475 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4476 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4477
4478 std::string fd = FPR(copy(fd_value));
4479 std::string fs = FPR(copy(fs_value));
4480 std::string ft = FPR(copy(ft_value));
4481
4482 return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4483}
4484
4485
4486/*
4487 *
4488 *
4489 * 3 2 1
4490 * 10987654321098765432109876543210
4491 * 001000 x1110000101
4492 * rt -----
4493 * rs -----
4494 * rd -----
4495 */
4496std::string NMD::CMP_SULE_D(uint64 instruction)
4497{
4498 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4499 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4500 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4501
4502 std::string fd = FPR(copy(fd_value));
4503 std::string fs = FPR(copy(fs_value));
4504 std::string ft = FPR(copy(ft_value));
4505
4506 return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4507}
4508
4509
4510/*
4511 *
4512 *
4513 * 3 2 1
4514 * 10987654321098765432109876543210
4515 * 001000 x1110000101
4516 * rt -----
4517 * rs -----
4518 * rd -----
4519 */
4520std::string NMD::CMP_SULE_S(uint64 instruction)
4521{
4522 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4523 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4524 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4525
4526 std::string fd = FPR(copy(fd_value));
4527 std::string fs = FPR(copy(fs_value));
4528 std::string ft = FPR(copy(ft_value));
4529
4530 return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4531}
4532
4533
4534/*
4535 *
4536 *
4537 * 3 2 1
4538 * 10987654321098765432109876543210
4539 * 001000 x1110000101
4540 * rt -----
4541 * rs -----
4542 * rd -----
4543 */
4544std::string NMD::CMP_SULT_D(uint64 instruction)
4545{
4546 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4547 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4548 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4549
4550 std::string fd = FPR(copy(fd_value));
4551 std::string fs = FPR(copy(fs_value));
4552 std::string ft = FPR(copy(ft_value));
4553
4554 return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4555}
4556
4557
4558/*
4559 *
4560 *
4561 * 3 2 1
4562 * 10987654321098765432109876543210
4563 * 001000 x1110000101
4564 * rt -----
4565 * rs -----
4566 * rd -----
4567 */
4568std::string NMD::CMP_SULT_S(uint64 instruction)
4569{
4570 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4571 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4572 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4573
4574 std::string fd = FPR(copy(fd_value));
4575 std::string fs = FPR(copy(fs_value));
4576 std::string ft = FPR(copy(ft_value));
4577
4578 return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4579}
4580
4581
4582/*
4583 *
4584 *
4585 * 3 2 1
4586 * 10987654321098765432109876543210
4587 * 001000 x1110000101
4588 * rt -----
4589 * rs -----
4590 * rd -----
4591 */
4592std::string NMD::CMP_SUN_D(uint64 instruction)
4593{
4594 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4595 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4596 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4597
4598 std::string fd = FPR(copy(fd_value));
4599 std::string fs = FPR(copy(fs_value));
4600 std::string ft = FPR(copy(ft_value));
4601
4602 return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4603}
4604
4605
4606/*
4607 *
4608 *
4609 * 3 2 1
4610 * 10987654321098765432109876543210
4611 * 001000 x1110000101
4612 * rt -----
4613 * rs -----
4614 * rd -----
4615 */
4616std::string NMD::CMP_SUNE_D(uint64 instruction)
4617{
4618 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4619 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4620 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4621
4622 std::string fd = FPR(copy(fd_value));
4623 std::string fs = FPR(copy(fs_value));
4624 std::string ft = FPR(copy(ft_value));
4625
4626 return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4627}
4628
4629
4630/*
4631 *
4632 *
4633 * 3 2 1
4634 * 10987654321098765432109876543210
4635 * 001000 x1110000101
4636 * rt -----
4637 * rs -----
4638 * rd -----
4639 */
4640std::string NMD::CMP_SUNE_S(uint64 instruction)
4641{
4642 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4643 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4644 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4645
4646 std::string fd = FPR(copy(fd_value));
4647 std::string fs = FPR(copy(fs_value));
4648 std::string ft = FPR(copy(ft_value));
4649
4650 return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4651}
4652
4653
4654/*
4655 *
4656 *
4657 * 3 2 1
4658 * 10987654321098765432109876543210
4659 * 001000 x1110000101
4660 * rt -----
4661 * rs -----
4662 * rd -----
4663 */
4664std::string NMD::CMP_SUN_S(uint64 instruction)
4665{
4666 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4667 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4668 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4669
4670 std::string fd = FPR(copy(fd_value));
4671 std::string fs = FPR(copy(fs_value));
4672 std::string ft = FPR(copy(ft_value));
4673
4674 return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4675}
4676
4677
4678/*
4679 *
4680 *
4681 * 3 2 1
4682 * 10987654321098765432109876543210
4683 * 001000 x1110000101
4684 * rt -----
4685 * rs -----
4686 * rd -----
4687 */
4688std::string NMD::CMP_UEQ_D(uint64 instruction)
4689{
4690 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4691 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4692 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4693
4694 std::string fd = FPR(copy(fd_value));
4695 std::string fs = FPR(copy(fs_value));
4696 std::string ft = FPR(copy(ft_value));
4697
4698 return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4699}
4700
4701
4702/*
4703 *
4704 *
4705 * 3 2 1
4706 * 10987654321098765432109876543210
4707 * 001000 x1110000101
4708 * rt -----
4709 * rs -----
4710 * rd -----
4711 */
4712std::string NMD::CMP_UEQ_S(uint64 instruction)
4713{
4714 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4715 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4716 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4717
4718 std::string fd = FPR(copy(fd_value));
4719 std::string fs = FPR(copy(fs_value));
4720 std::string ft = FPR(copy(ft_value));
4721
4722 return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4723}
4724
4725
4726/*
4727 *
4728 *
4729 * 3 2 1
4730 * 10987654321098765432109876543210
4731 * 001000 x1110000101
4732 * rt -----
4733 * rs -----
4734 * rd -----
4735 */
4736std::string NMD::CMP_ULE_D(uint64 instruction)
4737{
4738 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4739 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4740 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4741
4742 std::string fd = FPR(copy(fd_value));
4743 std::string fs = FPR(copy(fs_value));
4744 std::string ft = FPR(copy(ft_value));
4745
4746 return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4747}
4748
4749
4750/*
4751 *
4752 *
4753 * 3 2 1
4754 * 10987654321098765432109876543210
4755 * 001000 x1110000101
4756 * rt -----
4757 * rs -----
4758 * rd -----
4759 */
4760std::string NMD::CMP_ULE_S(uint64 instruction)
4761{
4762 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4763 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4764 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4765
4766 std::string fd = FPR(copy(fd_value));
4767 std::string fs = FPR(copy(fs_value));
4768 std::string ft = FPR(copy(ft_value));
4769
4770 return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4771}
4772
4773
4774/*
4775 *
4776 *
4777 * 3 2 1
4778 * 10987654321098765432109876543210
4779 * 001000 x1110000101
4780 * rt -----
4781 * rs -----
4782 * rd -----
4783 */
4784std::string NMD::CMP_ULT_D(uint64 instruction)
4785{
4786 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4787 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4788 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4789
4790 std::string fd = FPR(copy(fd_value));
4791 std::string fs = FPR(copy(fs_value));
4792 std::string ft = FPR(copy(ft_value));
4793
4794 return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4795}
4796
4797
4798/*
4799 *
4800 *
4801 * 3 2 1
4802 * 10987654321098765432109876543210
4803 * 001000 x1110000101
4804 * rt -----
4805 * rs -----
4806 * rd -----
4807 */
4808std::string NMD::CMP_ULT_S(uint64 instruction)
4809{
4810 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4811 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4812 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4813
4814 std::string fd = FPR(copy(fd_value));
4815 std::string fs = FPR(copy(fs_value));
4816 std::string ft = FPR(copy(ft_value));
4817
4818 return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4819}
4820
4821
4822/*
4823 *
4824 *
4825 * 3 2 1
4826 * 10987654321098765432109876543210
4827 * 001000 x1110000101
4828 * rt -----
4829 * rs -----
4830 * rd -----
4831 */
4832std::string NMD::CMP_UN_D(uint64 instruction)
4833{
4834 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4835 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4836 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4837
4838 std::string fd = FPR(copy(fd_value));
4839 std::string fs = FPR(copy(fs_value));
4840 std::string ft = FPR(copy(ft_value));
4841
4842 return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4843}
4844
4845
4846/*
4847 *
4848 *
4849 * 3 2 1
4850 * 10987654321098765432109876543210
4851 * 001000 x1110000101
4852 * rt -----
4853 * rs -----
4854 * rd -----
4855 */
4856std::string NMD::CMP_UNE_D(uint64 instruction)
4857{
4858 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4859 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4860 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4861
4862 std::string fd = FPR(copy(fd_value));
4863 std::string fs = FPR(copy(fs_value));
4864 std::string ft = FPR(copy(ft_value));
4865
4866 return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4867}
4868
4869
4870/*
4871 *
4872 *
4873 * 3 2 1
4874 * 10987654321098765432109876543210
4875 * 001000 x1110000101
4876 * rt -----
4877 * rs -----
4878 * rd -----
4879 */
4880std::string NMD::CMP_UNE_S(uint64 instruction)
4881{
4882 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4883 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4884 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4885
4886 std::string fd = FPR(copy(fd_value));
4887 std::string fs = FPR(copy(fs_value));
4888 std::string ft = FPR(copy(ft_value));
4889
4890 return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4891}
4892
4893
4894/*
4895 *
4896 *
4897 * 3 2 1
4898 * 10987654321098765432109876543210
4899 * 001000 x1110000101
4900 * rt -----
4901 * rs -----
4902 * rd -----
4903 */
4904std::string NMD::CMP_UN_S(uint64 instruction)
4905{
4906 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
4907 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
4908 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
4909
4910 std::string fd = FPR(copy(fd_value));
4911 std::string fs = FPR(copy(fs_value));
4912 std::string ft = FPR(copy(ft_value));
4913
4914 return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4915}
4916
4917
4918/*
4919 *
4920 *
4921 * 3 2 1
4922 * 10987654321098765432109876543210
4923 * 001000 x1110000101
4924 * rt -----
4925 * rs -----
4926 * rd -----
4927 */
4928std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
4929{
4930 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4931 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4932 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4933
4934 std::string rd = GPR(copy(rd_value));
4935 std::string rs = GPR(copy(rs_value));
4936 std::string rt = GPR(copy(rt_value));
4937
4938 return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4939}
4940
4941
4942/*
4943 *
4944 *
4945 * 3 2 1
4946 * 10987654321098765432109876543210
4947 * 001000 x1110000101
4948 * rt -----
4949 * rs -----
4950 * rd -----
4951 */
4952std::string NMD::CMPGDU_LE_QB(uint64 instruction)
4953{
4954 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4955 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4956 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4957
4958 std::string rd = GPR(copy(rd_value));
4959 std::string rs = GPR(copy(rs_value));
4960 std::string rt = GPR(copy(rt_value));
4961
4962 return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4963}
4964
4965
4966/*
4967 *
4968 *
4969 * 3 2 1
4970 * 10987654321098765432109876543210
4971 * 001000 x1110000101
4972 * rt -----
4973 * rs -----
4974 * rd -----
4975 */
4976std::string NMD::CMPGDU_LT_QB(uint64 instruction)
4977{
4978 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4979 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
4980 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4981
4982 std::string rd = GPR(copy(rd_value));
4983 std::string rs = GPR(copy(rs_value));
4984 std::string rt = GPR(copy(rt_value));
4985
4986 return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4987}
4988
4989
4990/*
4991 *
4992 *
4993 * 3 2 1
4994 * 10987654321098765432109876543210
4995 * 001000 x1110000101
4996 * rt -----
4997 * rs -----
4998 * rd -----
4999 */
5000std::string NMD::CMPGU_EQ_QB(uint64 instruction)
5001{
5002 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5003 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5004 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5005
5006 std::string rd = GPR(copy(rd_value));
5007 std::string rs = GPR(copy(rs_value));
5008 std::string rt = GPR(copy(rt_value));
5009
5010 return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
5011}
5012
5013
5014/*
5015 *
5016 *
5017 * 3 2 1
5018 * 10987654321098765432109876543210
5019 * 001000 x1110000101
5020 * rt -----
5021 * rs -----
5022 * rd -----
5023 */
5024std::string NMD::CMPGU_LE_QB(uint64 instruction)
5025{
5026 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5027 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5028 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5029
5030 std::string rd = GPR(copy(rd_value));
5031 std::string rs = GPR(copy(rs_value));
5032 std::string rt = GPR(copy(rt_value));
5033
5034 return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
5035}
5036
5037
5038/*
5039 *
5040 *
5041 * 3 2 1
5042 * 10987654321098765432109876543210
5043 * 001000 x1110000101
5044 * rt -----
5045 * rs -----
5046 * rd -----
5047 */
5048std::string NMD::CMPGU_LT_QB(uint64 instruction)
5049{
5050 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5051 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5052 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5053
5054 std::string rd = GPR(copy(rd_value));
5055 std::string rs = GPR(copy(rs_value));
5056 std::string rt = GPR(copy(rt_value));
5057
5058 return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
5059}
5060
5061
5062/*
5063 *
5064 *
5065 * 3 2 1
5066 * 10987654321098765432109876543210
5067 * 001000 x1110000101
5068 * rt -----
5069 * rs -----
5070 * rd -----
5071 */
5072std::string NMD::CMPU_EQ_QB(uint64 instruction)
5073{
5074 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5075 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5076
5077 std::string rs = GPR(copy(rs_value));
5078 std::string rt = GPR(copy(rt_value));
5079
5080 return img::format("CMPU.EQ.QB %s, %s", rs, rt);
5081}
5082
5083
5084/*
5085 *
5086 *
5087 * 3 2 1
5088 * 10987654321098765432109876543210
5089 * 001000 x1110000101
5090 * rt -----
5091 * rs -----
5092 * rd -----
5093 */
5094std::string NMD::CMPU_LE_QB(uint64 instruction)
5095{
5096 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5097 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5098
5099 std::string rs = GPR(copy(rs_value));
5100 std::string rt = GPR(copy(rt_value));
5101
5102 return img::format("CMPU.LE.QB %s, %s", rs, rt);
5103}
5104
5105
5106/*
5107 *
5108 *
5109 * 3 2 1
5110 * 10987654321098765432109876543210
5111 * 001000 x1110000101
5112 * rt -----
5113 * rs -----
5114 * rd -----
5115 */
5116std::string NMD::CMPU_LT_QB(uint64 instruction)
5117{
5118 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5119 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5120
5121 std::string rs = GPR(copy(rs_value));
5122 std::string rt = GPR(copy(rt_value));
5123
5124 return img::format("CMPU.LT.QB %s, %s", rs, rt);
5125}
5126
5127
5128/*
5129 *
5130 *
5131 * 3 2 1
5132 * 10987654321098765432109876543210
5133 * 001000 x1110000101
5134 * rt -----
5135 * rs -----
5136 * rd -----
5137 */
5138std::string NMD::COP2_1(uint64 instruction)
5139{
5140 uint64 cofun_value = extract_cofun_25_24_23(instruction);
5141
5142 std::string cofun = IMMEDIATE(copy(cofun_value));
5143
5144 return img::format("COP2_1 %s", cofun);
5145}
5146
5147
5148/*
5149 *
5150 *
5151 * 3 2 1
5152 * 10987654321098765432109876543210
5153 * 001000 x1110000101
5154 * rt -----
5155 * rs -----
5156 * rd -----
5157 */
5158std::string NMD::CTC1(uint64 instruction)
5159{
5160 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5162
5163 std::string rt = GPR(copy(rt_value));
5164 std::string cs = CPR(copy(cs_value));
5165
5166 return img::format("CTC1 %s, %s", rt, cs);
5167}
5168
5169
5170/*
5171 *
5172 *
5173 * 3 2 1
5174 * 10987654321098765432109876543210
5175 * 001000 x1110000101
5176 * rt -----
5177 * rs -----
5178 * rd -----
5179 */
5180std::string NMD::CTC2(uint64 instruction)
5181{
5182 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5183 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5184
5185 std::string rt = GPR(copy(rt_value));
5186 std::string cs = CPR(copy(cs_value));
5187
5188 return img::format("CTC2 %s, %s", rt, cs);
5189}
5190
5191
5192/*
5193 *
5194 *
5195 * 3 2 1
5196 * 10987654321098765432109876543210
5197 * 001000 x1110000101
5198 * rt -----
5199 * rs -----
5200 * rd -----
5201 */
5202std::string NMD::CVT_D_L(uint64 instruction)
5203{
5204 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5205 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5206
5207 std::string ft = FPR(copy(ft_value));
5208 std::string fs = FPR(copy(fs_value));
5209
5210 return img::format("CVT.D.L %s, %s", ft, fs);
5211}
5212
5213
5214/*
5215 *
5216 *
5217 * 3 2 1
5218 * 10987654321098765432109876543210
5219 * 001000 x1110000101
5220 * rt -----
5221 * rs -----
5222 * rd -----
5223 */
5224std::string NMD::CVT_D_S(uint64 instruction)
5225{
5226 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5227 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5228
5229 std::string ft = FPR(copy(ft_value));
5230 std::string fs = FPR(copy(fs_value));
5231
5232 return img::format("CVT.D.S %s, %s", ft, fs);
5233}
5234
5235
5236/*
5237 *
5238 *
5239 * 3 2 1
5240 * 10987654321098765432109876543210
5241 * 001000 x1110000101
5242 * rt -----
5243 * rs -----
5244 * rd -----
5245 */
5246std::string NMD::CVT_D_W(uint64 instruction)
5247{
5248 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5249 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5250
5251 std::string ft = FPR(copy(ft_value));
5252 std::string fs = FPR(copy(fs_value));
5253
5254 return img::format("CVT.D.W %s, %s", ft, fs);
5255}
5256
5257
5258/*
5259 *
5260 *
5261 * 3 2 1
5262 * 10987654321098765432109876543210
5263 * 001000 x1110000101
5264 * rt -----
5265 * rs -----
5266 * rd -----
5267 */
5268std::string NMD::CVT_L_D(uint64 instruction)
5269{
5270 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5271 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5272
5273 std::string ft = FPR(copy(ft_value));
5274 std::string fs = FPR(copy(fs_value));
5275
5276 return img::format("CVT.L.D %s, %s", ft, fs);
5277}
5278
5279
5280/*
5281 *
5282 *
5283 * 3 2 1
5284 * 10987654321098765432109876543210
5285 * 001000 x1110000101
5286 * rt -----
5287 * rs -----
5288 * rd -----
5289 */
5290std::string NMD::CVT_L_S(uint64 instruction)
5291{
5292 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5293 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5294
5295 std::string ft = FPR(copy(ft_value));
5296 std::string fs = FPR(copy(fs_value));
5297
5298 return img::format("CVT.L.S %s, %s", ft, fs);
5299}
5300
5301
5302/*
5303 *
5304 *
5305 * 3 2 1
5306 * 10987654321098765432109876543210
5307 * 001000 x1110000101
5308 * rt -----
5309 * rs -----
5310 * rd -----
5311 */
5312std::string NMD::CVT_S_D(uint64 instruction)
5313{
5314 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5315 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5316
5317 std::string ft = FPR(copy(ft_value));
5318 std::string fs = FPR(copy(fs_value));
5319
5320 return img::format("CVT.S.D %s, %s", ft, fs);
5321}
5322
5323
5324/*
5325 *
5326 *
5327 * 3 2 1
5328 * 10987654321098765432109876543210
5329 * 001000 x1110000101
5330 * rt -----
5331 * rs -----
5332 * rd -----
5333 */
5334std::string NMD::CVT_S_L(uint64 instruction)
5335{
5336 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5337 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5338
5339 std::string ft = FPR(copy(ft_value));
5340 std::string fs = FPR(copy(fs_value));
5341
5342 return img::format("CVT.S.L %s, %s", ft, fs);
5343}
5344
5345
5346/*
5347 *
5348 *
5349 * 3 2 1
5350 * 10987654321098765432109876543210
5351 * 001000 x1110000101
5352 * rt -----
5353 * rs -----
5354 * rd -----
5355 */
5356std::string NMD::CVT_S_PL(uint64 instruction)
5357{
5358 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5359 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5360
5361 std::string ft = FPR(copy(ft_value));
5362 std::string fs = FPR(copy(fs_value));
5363
5364 return img::format("CVT.S.PL %s, %s", ft, fs);
5365}
5366
5367
5368/*
5369 *
5370 *
5371 * 3 2 1
5372 * 10987654321098765432109876543210
5373 * 001000 x1110000101
5374 * rt -----
5375 * rs -----
5376 * rd -----
5377 */
5378std::string NMD::CVT_S_PU(uint64 instruction)
5379{
5380 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5381 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5382
5383 std::string ft = FPR(copy(ft_value));
5384 std::string fs = FPR(copy(fs_value));
5385
5386 return img::format("CVT.S.PU %s, %s", ft, fs);
5387}
5388
5389
5390/*
5391 *
5392 *
5393 * 3 2 1
5394 * 10987654321098765432109876543210
5395 * 001000 x1110000101
5396 * rt -----
5397 * rs -----
5398 * rd -----
5399 */
5400std::string NMD::CVT_S_W(uint64 instruction)
5401{
5402 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5403 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5404
5405 std::string ft = FPR(copy(ft_value));
5406 std::string fs = FPR(copy(fs_value));
5407
5408 return img::format("CVT.S.W %s, %s", ft, fs);
5409}
5410
5411
5412/*
5413 *
5414 *
5415 * 3 2 1
5416 * 10987654321098765432109876543210
5417 * 001000 x1110000101
5418 * rt -----
5419 * rs -----
5420 * rd -----
5421 */
5422std::string NMD::CVT_W_D(uint64 instruction)
5423{
5424 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5425 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5426
5427 std::string ft = FPR(copy(ft_value));
5428 std::string fs = FPR(copy(fs_value));
5429
5430 return img::format("CVT.W.D %s, %s", ft, fs);
5431}
5432
5433
5434/*
5435 *
5436 *
5437 * 3 2 1
5438 * 10987654321098765432109876543210
5439 * 001000 x1110000101
5440 * rt -----
5441 * rs -----
5442 * rd -----
5443 */
5444std::string NMD::CVT_W_S(uint64 instruction)
5445{
5446 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5447 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5448
5449 std::string ft = FPR(copy(ft_value));
5450 std::string fs = FPR(copy(fs_value));
5451
5452 return img::format("CVT.W.S %s, %s", ft, fs);
5453}
5454
5455
5456/*
5457 *
5458 *
5459 * 3 2 1
5460 * 10987654321098765432109876543210
5461 * 001000 x1110000101
5462 * rt -----
5463 * rs -----
5464 * rd -----
5465 */
5466std::string NMD::DADDIU_48_(uint64 instruction)
5467{
5468 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5469 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
5470
5471 std::string rt = GPR(copy(rt_value));
5472 std::string s = IMMEDIATE(copy(s_value));
5473
5474 return img::format("DADDIU %s, %s", rt, s);
5475}
5476
5477
5478/*
5479 *
5480 *
5481 * 3 2 1
5482 * 10987654321098765432109876543210
5483 * 001000 x1110000101
5484 * rt -----
5485 * rs -----
5486 * rd -----
5487 */
5488std::string NMD::DADDIU_NEG_(uint64 instruction)
5489{
5490 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5491 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5492 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5493
5494 std::string rt = GPR(copy(rt_value));
5495 std::string rs = GPR(copy(rs_value));
5496 std::string u = IMMEDIATE(neg_copy(u_value));
5497
5498 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5499}
5500
5501
5502/*
5503 *
5504 *
5505 * 3 2 1
5506 * 10987654321098765432109876543210
5507 * 001000 x1110000101
5508 * rt -----
5509 * rs -----
5510 * rd -----
5511 */
5512std::string NMD::DADDIU_U12_(uint64 instruction)
5513{
5514 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5515 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5516 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5517
5518 std::string rt = GPR(copy(rt_value));
5519 std::string rs = GPR(copy(rs_value));
5520 std::string u = IMMEDIATE(copy(u_value));
5521
5522 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5523}
5524
5525
5526/*
5527 *
5528 *
5529 * 3 2 1
5530 * 10987654321098765432109876543210
5531 * 001000 x1110000101
5532 * rt -----
5533 * rs -----
5534 * rd -----
5535 */
5536std::string NMD::DADD(uint64 instruction)
5537{
5538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5539 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5540 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5541
5542 std::string rd = GPR(copy(rd_value));
5543 std::string rs = GPR(copy(rs_value));
5544 std::string rt = GPR(copy(rt_value));
5545
5546 return img::format("DADD %s, %s, %s", rd, rs, rt);
5547}
5548
5549
5550/*
5551 *
5552 *
5553 * 3 2 1
5554 * 10987654321098765432109876543210
5555 * 001000 x1110000101
5556 * rt -----
5557 * rs -----
5558 * rd -----
5559 */
5560std::string NMD::DADDU(uint64 instruction)
5561{
5562 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5563 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5564 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5565
5566 std::string rd = GPR(copy(rd_value));
5567 std::string rs = GPR(copy(rs_value));
5568 std::string rt = GPR(copy(rt_value));
5569
5570 return img::format("DADDU %s, %s, %s", rd, rs, rt);
5571}
5572
5573
5574/*
5575 *
5576 *
5577 * 3 2 1
5578 * 10987654321098765432109876543210
5579 * 001000 x1110000101
5580 * rt -----
5581 * rs -----
5582 * rd -----
5583 */
5584std::string NMD::DCLO(uint64 instruction)
5585{
5586 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5587 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5588
5589 std::string rt = GPR(copy(rt_value));
5590 std::string rs = GPR(copy(rs_value));
5591
5592 return img::format("DCLO %s, %s", rt, rs);
5593}
5594
5595
5596/*
5597 *
5598 *
5599 * 3 2 1
5600 * 10987654321098765432109876543210
5601 * 001000 x1110000101
5602 * rt -----
5603 * rs -----
5604 * rd -----
5605 */
5606std::string NMD::DCLZ(uint64 instruction)
5607{
5608 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5609 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5610
5611 std::string rt = GPR(copy(rt_value));
5612 std::string rs = GPR(copy(rs_value));
5613
5614 return img::format("DCLZ %s, %s", rt, rs);
5615}
5616
5617
5618/*
5619 *
5620 *
5621 * 3 2 1
5622 * 10987654321098765432109876543210
5623 * 001000 x1110000101
5624 * rt -----
5625 * rs -----
5626 * rd -----
5627 */
5628std::string NMD::DDIV(uint64 instruction)
5629{
5630 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5631 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5632 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5633
5634 std::string rd = GPR(copy(rd_value));
5635 std::string rs = GPR(copy(rs_value));
5636 std::string rt = GPR(copy(rt_value));
5637
5638 return img::format("DDIV %s, %s, %s", rd, rs, rt);
5639}
5640
5641
5642/*
5643 *
5644 *
5645 * 3 2 1
5646 * 10987654321098765432109876543210
5647 * 001000 x1110000101
5648 * rt -----
5649 * rs -----
5650 * rd -----
5651 */
5652std::string NMD::DDIVU(uint64 instruction)
5653{
5654 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5655 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5656 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5657
5658 std::string rd = GPR(copy(rd_value));
5659 std::string rs = GPR(copy(rs_value));
5660 std::string rt = GPR(copy(rt_value));
5661
5662 return img::format("DDIVU %s, %s, %s", rd, rs, rt);
5663}
5664
5665
5666/*
5667 *
5668 *
5669 * 3 2 1
5670 * 10987654321098765432109876543210
5671 * 001000 x1110000101
5672 * rt -----
5673 * rs -----
5674 * rd -----
5675 */
5676std::string NMD::DERET(uint64 instruction)
5677{
5678 (void)instruction;
5679
5680 return "DERET ";
5681}
5682
5683
5684/*
5685 *
5686 *
5687 * 3 2 1
5688 * 10987654321098765432109876543210
5689 * 001000 x1110000101
5690 * rt -----
5691 * rs -----
5692 * rd -----
5693 */
5694std::string NMD::DEXTM(uint64 instruction)
5695{
5696 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5697 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5698 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5699 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5700
5701 std::string rt = GPR(copy(rt_value));
5702 std::string rs = GPR(copy(rs_value));
5703 std::string lsb = IMMEDIATE(copy(lsb_value));
5704 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5705
5706 return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
5707}
5708
5709
5710/*
5711 *
5712 *
5713 * 3 2 1
5714 * 10987654321098765432109876543210
5715 * 001000 x1110000101
5716 * rt -----
5717 * rs -----
5718 * rd -----
5719 */
5720std::string NMD::DEXT(uint64 instruction)
5721{
5722 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5723 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5724 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5725 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5726
5727 std::string rt = GPR(copy(rt_value));
5728 std::string rs = GPR(copy(rs_value));
5729 std::string lsb = IMMEDIATE(copy(lsb_value));
5730 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5731
5732 return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
5733}
5734
5735
5736/*
5737 *
5738 *
5739 * 3 2 1
5740 * 10987654321098765432109876543210
5741 * 001000 x1110000101
5742 * rt -----
5743 * rs -----
5744 * rd -----
5745 */
5746std::string NMD::DEXTU(uint64 instruction)
5747{
5748 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5749 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5750 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5751 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5752
5753 std::string rt = GPR(copy(rt_value));
5754 std::string rs = GPR(copy(rs_value));
5755 std::string lsb = IMMEDIATE(copy(lsb_value));
5756 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5757
5758 return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
5759}
5760
5761
5762/*
5763 *
5764 *
5765 * 3 2 1
5766 * 10987654321098765432109876543210
5767 * 001000 x1110000101
5768 * rt -----
5769 * rs -----
5770 * rd -----
5771 */
5772std::string NMD::DINSM(uint64 instruction)
5773{
5774 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5775 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5776 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5777 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5778
5779 std::string rt = GPR(copy(rt_value));
5780 std::string rs = GPR(copy(rs_value));
5781 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5782 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5783 /* !!!!!!!!!! - no conversion function */
5784
5785 return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
5786 /* hand edited */
5787}
5788
5789
5790/*
5791 *
5792 *
5793 * 3 2 1
5794 * 10987654321098765432109876543210
5795 * 001000 x1110000101
5796 * rt -----
5797 * rs -----
5798 * rd -----
5799 */
5800std::string NMD::DINS(uint64 instruction)
5801{
5802 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5803 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5804 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5805 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5806
5807 std::string rt = GPR(copy(rt_value));
5808 std::string rs = GPR(copy(rs_value));
5809 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5810 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5811 /* !!!!!!!!!! - no conversion function */
5812
5813 return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
5814 /* hand edited */
5815}
5816
5817
5818/*
5819 *
5820 *
5821 * 3 2 1
5822 * 10987654321098765432109876543210
5823 * 001000 x1110000101
5824 * rt -----
5825 * rs -----
5826 * rd -----
5827 */
5828std::string NMD::DINSU(uint64 instruction)
5829{
5830 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5831 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5832 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5834
5835 std::string rt = GPR(copy(rt_value));
5836 std::string rs = GPR(copy(rs_value));
5837 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5838 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5839 /* !!!!!!!!!! - no conversion function */
5840
5841 return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
5842 /* hand edited */
5843}
5844
5845
5846/*
5847 *
5848 *
5849 * 3 2 1
5850 * 10987654321098765432109876543210
5851 * 001000 x1110000101
5852 * rt -----
5853 * rs -----
5854 * rd -----
5855 */
5856std::string NMD::DI(uint64 instruction)
5857{
5858 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5859
5860 std::string rt = GPR(copy(rt_value));
5861
5862 return img::format("DI %s", rt);
5863}
5864
5865
5866/*
5867 *
5868 *
5869 * 3 2 1
5870 * 10987654321098765432109876543210
5871 * 001000 x1110000101
5872 * rt -----
5873 * rs -----
5874 * rd -----
5875 */
5876std::string NMD::DIV(uint64 instruction)
5877{
5878 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5879 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5880 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5881
5882 std::string rd = GPR(copy(rd_value));
5883 std::string rs = GPR(copy(rs_value));
5884 std::string rt = GPR(copy(rt_value));
5885
5886 return img::format("DIV %s, %s, %s", rd, rs, rt);
5887}
5888
5889
5890/*
5891 *
5892 *
5893 * 3 2 1
5894 * 10987654321098765432109876543210
5895 * 001000 x1110000101
5896 * rt -----
5897 * rs -----
5898 * rd -----
5899 */
5900std::string NMD::DIV_D(uint64 instruction)
5901{
5902 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5903 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5904 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
5905
5906 std::string fd = FPR(copy(fd_value));
5907 std::string fs = FPR(copy(fs_value));
5908 std::string ft = FPR(copy(ft_value));
5909
5910 return img::format("DIV.D %s, %s, %s", fd, fs, ft);
5911}
5912
5913
5914/*
5915 *
5916 *
5917 * 3 2 1
5918 * 10987654321098765432109876543210
5919 * 001000 x1110000101
5920 * rt -----
5921 * rs -----
5922 * rd -----
5923 */
5924std::string NMD::DIV_S(uint64 instruction)
5925{
5926 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
5927 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
5928 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
5929
5930 std::string fd = FPR(copy(fd_value));
5931 std::string fs = FPR(copy(fs_value));
5932 std::string ft = FPR(copy(ft_value));
5933
5934 return img::format("DIV.S %s, %s, %s", fd, fs, ft);
5935}
5936
5937
5938/*
5939 *
5940 *
5941 * 3 2 1
5942 * 10987654321098765432109876543210
5943 * 001000 x1110000101
5944 * rt -----
5945 * rs -----
5946 * rd -----
5947 */
5948std::string NMD::DIVU(uint64 instruction)
5949{
5950 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5951 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5953
5954 std::string rd = GPR(copy(rd_value));
5955 std::string rs = GPR(copy(rs_value));
5956 std::string rt = GPR(copy(rt_value));
5957
5958 return img::format("DIVU %s, %s, %s", rd, rs, rt);
5959}
5960
5961
5962/*
5963 *
5964 *
5965 * 3 2 1
5966 * 10987654321098765432109876543210
5967 * 001000 x1110000101
5968 * rt -----
5969 * rs -----
5970 * rd -----
5971 */
5972std::string NMD::DLSA(uint64 instruction)
5973{
5974 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5975 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
5976 uint64 u2_value = extract_u2_10_9(instruction);
5977 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5978
5979 std::string rd = GPR(copy(rd_value));
5980 std::string rs = GPR(copy(rs_value));
5981 std::string rt = GPR(copy(rt_value));
5982 std::string u2 = IMMEDIATE(copy(u2_value));
5983
5984 return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
5985}
5986
5987
5988/*
5989 *
5990 *
5991 * 3 2 1
5992 * 10987654321098765432109876543210
5993 * 001000 x1110000101
5994 * rt -----
5995 * rs -----
5996 * rd -----
5997 */
5998std::string NMD::DLUI_48_(uint64 instruction)
5999{
6000 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
6001 uint64 u_value = extr_uil0il32bs32Fmsb63(instruction);
6002
6003 std::string rt = GPR(copy(rt_value));
6004 std::string u = IMMEDIATE(copy(u_value));
6005
6006 return img::format("DLUI %s, %s", rt, u);
6007}
6008
6009
6010/*
6011 *
6012 *
6013 * 3 2 1
6014 * 10987654321098765432109876543210
6015 * 001000 x1110000101
6016 * rt -----
6017 * rs -----
6018 * rd -----
6019 */
6020std::string NMD::DMFC0(uint64 instruction)
6021{
6022 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6023 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6024 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6025
6026 std::string rt = GPR(copy(rt_value));
6027 std::string c0s = CPR(copy(c0s_value));
6028 std::string sel = IMMEDIATE(copy(sel_value));
6029
6030 return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
6031}
6032
6033
6034/*
6035 *
6036 *
6037 * 3 2 1
6038 * 10987654321098765432109876543210
6039 * 001000 x1110000101
6040 * rt -----
6041 * rs -----
6042 * rd -----
6043 */
6044std::string NMD::DMFC1(uint64 instruction)
6045{
6046 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6047 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
6048
6049 std::string rt = GPR(copy(rt_value));
6050 std::string fs = FPR(copy(fs_value));
6051
6052 return img::format("DMFC1 %s, %s", rt, fs);
6053}
6054
6055
6056/*
6057 *
6058 *
6059 * 3 2 1
6060 * 10987654321098765432109876543210
6061 * 001000 x1110000101
6062 * rt -----
6063 * rs -----
6064 * rd -----
6065 */
6066std::string NMD::DMFC2(uint64 instruction)
6067{
6068 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6069 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6070
6071 std::string rt = GPR(copy(rt_value));
6072 std::string cs = CPR(copy(cs_value));
6073
6074 return img::format("DMFC2 %s, %s", rt, cs);
6075}
6076
6077
6078/*
6079 *
6080 *
6081 * 3 2 1
6082 * 10987654321098765432109876543210
6083 * 001000 x1110000101
6084 * rt -----
6085 * rs -----
6086 * rd -----
6087 */
6088std::string NMD::DMFGC0(uint64 instruction)
6089{
6090 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6091 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6092 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6093
6094 std::string rt = GPR(copy(rt_value));
6095 std::string c0s = CPR(copy(c0s_value));
6096 std::string sel = IMMEDIATE(copy(sel_value));
6097
6098 return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
6099}
6100
6101
6102/*
6103 *
6104 *
6105 * 3 2 1
6106 * 10987654321098765432109876543210
6107 * 001000 x1110000101
6108 * rt -----
6109 * rs -----
6110 * rd -----
6111 */
6112std::string NMD::DMOD(uint64 instruction)
6113{
6114 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6115 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6116 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6117
6118 std::string rd = GPR(copy(rd_value));
6119 std::string rs = GPR(copy(rs_value));
6120 std::string rt = GPR(copy(rt_value));
6121
6122 return img::format("DMOD %s, %s, %s", rd, rs, rt);
6123}
6124
6125
6126/*
6127 *
6128 *
6129 * 3 2 1
6130 * 10987654321098765432109876543210
6131 * 001000 x1110000101
6132 * rt -----
6133 * rs -----
6134 * rd -----
6135 */
6136std::string NMD::DMODU(uint64 instruction)
6137{
6138 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6139 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6140 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6141
6142 std::string rd = GPR(copy(rd_value));
6143 std::string rs = GPR(copy(rs_value));
6144 std::string rt = GPR(copy(rt_value));
6145
6146 return img::format("DMODU %s, %s, %s", rd, rs, rt);
6147}
6148
6149
6150/*
6151 *
6152 *
6153 * 3 2 1
6154 * 10987654321098765432109876543210
6155 * 001000 x1110000101
6156 * rt -----
6157 * rs -----
6158 * rd -----
6159 */
6160std::string NMD::DMTC0(uint64 instruction)
6161{
6162 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6163 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6164 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6165
6166 std::string rt = GPR(copy(rt_value));
6167 std::string c0s = CPR(copy(c0s_value));
6168 std::string sel = IMMEDIATE(copy(sel_value));
6169
6170 return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
6171}
6172
6173
6174/*
6175 *
6176 *
6177 * 3 2 1
6178 * 10987654321098765432109876543210
6179 * 001000 x1110000101
6180 * rt -----
6181 * rs -----
6182 * rd -----
6183 */
6184std::string NMD::DMTC1(uint64 instruction)
6185{
6186 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6187 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
6188
6189 std::string rt = GPR(copy(rt_value));
6190 std::string fs = FPR(copy(fs_value));
6191
6192 return img::format("DMTC1 %s, %s", rt, fs);
6193}
6194
6195
6196/*
6197 *
6198 *
6199 * 3 2 1
6200 * 10987654321098765432109876543210
6201 * 001000 x1110000101
6202 * rt -----
6203 * rs -----
6204 * rd -----
6205 */
6206std::string NMD::DMTC2(uint64 instruction)
6207{
6208 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6209 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6210
6211 std::string rt = GPR(copy(rt_value));
6212 std::string cs = CPR(copy(cs_value));
6213
6214 return img::format("DMTC2 %s, %s", rt, cs);
6215}
6216
6217
6218/*
6219 *
6220 *
6221 * 3 2 1
6222 * 10987654321098765432109876543210
6223 * 001000 x1110000101
6224 * rt -----
6225 * rs -----
6226 * rd -----
6227 */
6228std::string NMD::DMTGC0(uint64 instruction)
6229{
6230 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6231 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6232 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6233
6234 std::string rt = GPR(copy(rt_value));
6235 std::string c0s = CPR(copy(c0s_value));
6236 std::string sel = IMMEDIATE(copy(sel_value));
6237
6238 return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
6239}
6240
6241
6242/*
6243 *
6244 *
6245 * 3 2 1
6246 * 10987654321098765432109876543210
6247 * 001000 x1110000101
6248 * rt -----
6249 * rs -----
6250 * rd -----
6251 */
6252std::string NMD::DMT(uint64 instruction)
6253{
6254 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6255
6256 std::string rt = GPR(copy(rt_value));
6257
6258 return img::format("DMT %s", rt);
6259}
6260
6261
6262/*
6263 *
6264 *
6265 * 3 2 1
6266 * 10987654321098765432109876543210
6267 * 001000 x1110000101
6268 * rt -----
6269 * rs -----
6270 * rd -----
6271 */
6272std::string NMD::DMUH(uint64 instruction)
6273{
6274 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6275 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6276 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6277
6278 std::string rd = GPR(copy(rd_value));
6279 std::string rs = GPR(copy(rs_value));
6280 std::string rt = GPR(copy(rt_value));
6281
6282 return img::format("DMUH %s, %s, %s", rd, rs, rt);
6283}
6284
6285
6286/*
6287 *
6288 *
6289 * 3 2 1
6290 * 10987654321098765432109876543210
6291 * 001000 x1110000101
6292 * rt -----
6293 * rs -----
6294 * rd -----
6295 */
6296std::string NMD::DMUHU(uint64 instruction)
6297{
6298 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6299 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6300 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6301
6302 std::string rd = GPR(copy(rd_value));
6303 std::string rs = GPR(copy(rs_value));
6304 std::string rt = GPR(copy(rt_value));
6305
6306 return img::format("DMUHU %s, %s, %s", rd, rs, rt);
6307}
6308
6309
6310/*
6311 *
6312 *
6313 * 3 2 1
6314 * 10987654321098765432109876543210
6315 * 001000 x1110000101
6316 * rt -----
6317 * rs -----
6318 * rd -----
6319 */
6320std::string NMD::DMUL(uint64 instruction)
6321{
6322 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6323 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6324 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6325
6326 std::string rd = GPR(copy(rd_value));
6327 std::string rs = GPR(copy(rs_value));
6328 std::string rt = GPR(copy(rt_value));
6329
6330 return img::format("DMUL %s, %s, %s", rd, rs, rt);
6331}
6332
6333
6334/*
6335 *
6336 *
6337 * 3 2 1
6338 * 10987654321098765432109876543210
6339 * 001000 x1110000101
6340 * rt -----
6341 * rs -----
6342 * rd -----
6343 */
6344std::string NMD::DMULU(uint64 instruction)
6345{
6346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6347 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6348 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6349
6350 std::string rd = GPR(copy(rd_value));
6351 std::string rs = GPR(copy(rs_value));
6352 std::string rt = GPR(copy(rt_value));
6353
6354 return img::format("DMULU %s, %s, %s", rd, rs, rt);
6355}
6356
6357
6358/*
6359 *
6360 *
6361 * 3 2 1
6362 * 10987654321098765432109876543210
6363 * 001000 x1110000101
6364 * rt -----
6365 * rs -----
6366 * rd -----
6367 */
6368std::string NMD::DPA_W_PH(uint64 instruction)
6369{
6370 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6371 uint64 ac_value = extract_ac_13_12(instruction);
6372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6373
6374 std::string ac = AC(copy(ac_value));
6375 std::string rs = GPR(copy(rs_value));
6376 std::string rt = GPR(copy(rt_value));
6377
6378 return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6379}
6380
6381
6382/*
6383 *
6384 *
6385 * 3 2 1
6386 * 10987654321098765432109876543210
6387 * 001000 x1110000101
6388 * rt -----
6389 * rs -----
6390 * rd -----
6391 */
6392std::string NMD::DPAQ_SA_L_W(uint64 instruction)
6393{
6394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6395 uint64 ac_value = extract_ac_13_12(instruction);
6396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6397
6398 std::string ac = AC(copy(ac_value));
6399 std::string rs = GPR(copy(rs_value));
6400 std::string rt = GPR(copy(rt_value));
6401
6402 return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6403}
6404
6405
6406/*
6407 *
6408 *
6409 * 3 2 1
6410 * 10987654321098765432109876543210
6411 * 001000 x1110000101
6412 * rt -----
6413 * rs -----
6414 * rd -----
6415 */
6416std::string NMD::DPAQ_S_W_PH(uint64 instruction)
6417{
6418 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6419 uint64 ac_value = extract_ac_13_12(instruction);
6420 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6421
6422 std::string ac = AC(copy(ac_value));
6423 std::string rs = GPR(copy(rs_value));
6424 std::string rt = GPR(copy(rt_value));
6425
6426 return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6427}
6428
6429
6430/*
6431 *
6432 *
6433 * 3 2 1
6434 * 10987654321098765432109876543210
6435 * 001000 x1110000101
6436 * rt -----
6437 * rs -----
6438 * rd -----
6439 */
6440std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
6441{
6442 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6443 uint64 ac_value = extract_ac_13_12(instruction);
6444 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6445
6446 std::string ac = AC(copy(ac_value));
6447 std::string rs = GPR(copy(rs_value));
6448 std::string rt = GPR(copy(rt_value));
6449
6450 return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6451}
6452
6453
6454/*
6455 *
6456 *
6457 * 3 2 1
6458 * 10987654321098765432109876543210
6459 * 001000 x1110000101
6460 * rt -----
6461 * rs -----
6462 * rd -----
6463 */
6464std::string NMD::DPAQX_S_W_PH(uint64 instruction)
6465{
6466 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6467 uint64 ac_value = extract_ac_13_12(instruction);
6468 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6469
6470 std::string ac = AC(copy(ac_value));
6471 std::string rs = GPR(copy(rs_value));
6472 std::string rt = GPR(copy(rt_value));
6473
6474 return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6475}
6476
6477
6478/*
6479 *
6480 *
6481 * 3 2 1
6482 * 10987654321098765432109876543210
6483 * 001000 x1110000101
6484 * rt -----
6485 * rs -----
6486 * rd -----
6487 */
6488std::string NMD::DPAU_H_QBL(uint64 instruction)
6489{
6490 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6491 uint64 ac_value = extract_ac_13_12(instruction);
6492 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6493
6494 std::string ac = AC(copy(ac_value));
6495 std::string rs = GPR(copy(rs_value));
6496 std::string rt = GPR(copy(rt_value));
6497
6498 return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6499}
6500
6501
6502/*
6503 *
6504 *
6505 * 3 2 1
6506 * 10987654321098765432109876543210
6507 * 001000 x1110000101
6508 * rt -----
6509 * rs -----
6510 * rd -----
6511 */
6512std::string NMD::DPAU_H_QBR(uint64 instruction)
6513{
6514 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6515 uint64 ac_value = extract_ac_13_12(instruction);
6516 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6517
6518 std::string ac = AC(copy(ac_value));
6519 std::string rs = GPR(copy(rs_value));
6520 std::string rt = GPR(copy(rt_value));
6521
6522 return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6523}
6524
6525
6526/*
6527 *
6528 *
6529 * 3 2 1
6530 * 10987654321098765432109876543210
6531 * 001000 x1110000101
6532 * rt -----
6533 * rs -----
6534 * rd -----
6535 */
6536std::string NMD::DPAX_W_PH(uint64 instruction)
6537{
6538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6539 uint64 ac_value = extract_ac_13_12(instruction);
6540 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6541
6542 std::string ac = AC(copy(ac_value));
6543 std::string rs = GPR(copy(rs_value));
6544 std::string rt = GPR(copy(rt_value));
6545
6546 return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6547}
6548
6549
6550/*
6551 *
6552 *
6553 * 3 2 1
6554 * 10987654321098765432109876543210
6555 * 001000 x1110000101
6556 * rt -----
6557 * rs -----
6558 * rd -----
6559 */
6560std::string NMD::DPS_W_PH(uint64 instruction)
6561{
6562 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6563 uint64 ac_value = extract_ac_13_12(instruction);
6564 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6565
6566 std::string ac = AC(copy(ac_value));
6567 std::string rs = GPR(copy(rs_value));
6568 std::string rt = GPR(copy(rt_value));
6569
6570 return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6571}
6572
6573
6574/*
6575 *
6576 *
6577 * 3 2 1
6578 * 10987654321098765432109876543210
6579 * 001000 x1110000101
6580 * rt -----
6581 * rs -----
6582 * rd -----
6583 */
6584std::string NMD::DPSQ_SA_L_W(uint64 instruction)
6585{
6586 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6587 uint64 ac_value = extract_ac_13_12(instruction);
6588 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6589
6590 std::string ac = AC(copy(ac_value));
6591 std::string rs = GPR(copy(rs_value));
6592 std::string rt = GPR(copy(rt_value));
6593
6594 return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6595}
6596
6597
6598/*
6599 *
6600 *
6601 * 3 2 1
6602 * 10987654321098765432109876543210
6603 * 001000 x1110000101
6604 * rt -----
6605 * rs -----
6606 * rd -----
6607 */
6608std::string NMD::DPSQ_S_W_PH(uint64 instruction)
6609{
6610 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6611 uint64 ac_value = extract_ac_13_12(instruction);
6612 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6613
6614 std::string ac = AC(copy(ac_value));
6615 std::string rs = GPR(copy(rs_value));
6616 std::string rt = GPR(copy(rt_value));
6617
6618 return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6619}
6620
6621
6622/*
6623 *
6624 *
6625 * 3 2 1
6626 * 10987654321098765432109876543210
6627 * 001000 x1110000101
6628 * rt -----
6629 * rs -----
6630 * rd -----
6631 */
6632std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
6633{
6634 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6635 uint64 ac_value = extract_ac_13_12(instruction);
6636 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6637
6638 std::string ac = AC(copy(ac_value));
6639 std::string rs = GPR(copy(rs_value));
6640 std::string rt = GPR(copy(rt_value));
6641
6642 return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6643}
6644
6645
6646/*
6647 *
6648 *
6649 * 3 2 1
6650 * 10987654321098765432109876543210
6651 * 001000 x1110000101
6652 * rt -----
6653 * rs -----
6654 * rd -----
6655 */
6656std::string NMD::DPSQX_S_W_PH(uint64 instruction)
6657{
6658 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6659 uint64 ac_value = extract_ac_13_12(instruction);
6660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6661
6662 std::string ac = AC(copy(ac_value));
6663 std::string rs = GPR(copy(rs_value));
6664 std::string rt = GPR(copy(rt_value));
6665
6666 return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6667}
6668
6669
6670/*
6671 *
6672 *
6673 * 3 2 1
6674 * 10987654321098765432109876543210
6675 * 001000 x1110000101
6676 * rt -----
6677 * rs -----
6678 * rd -----
6679 */
6680std::string NMD::DPSU_H_QBL(uint64 instruction)
6681{
6682 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6683 uint64 ac_value = extract_ac_13_12(instruction);
6684 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6685
6686 std::string ac = AC(copy(ac_value));
6687 std::string rs = GPR(copy(rs_value));
6688 std::string rt = GPR(copy(rt_value));
6689
6690 return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6691}
6692
6693
6694/*
6695 *
6696 *
6697 * 3 2 1
6698 * 10987654321098765432109876543210
6699 * 001000 x1110000101
6700 * rt -----
6701 * rs -----
6702 * rd -----
6703 */
6704std::string NMD::DPSU_H_QBR(uint64 instruction)
6705{
6706 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6707 uint64 ac_value = extract_ac_13_12(instruction);
6708 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6709
6710 std::string ac = AC(copy(ac_value));
6711 std::string rs = GPR(copy(rs_value));
6712 std::string rt = GPR(copy(rt_value));
6713
6714 return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6715}
6716
6717
6718/*
6719 *
6720 *
6721 * 3 2 1
6722 * 10987654321098765432109876543210
6723 * 001000 x1110000101
6724 * rt -----
6725 * rs -----
6726 * rd -----
6727 */
6728std::string NMD::DPSX_W_PH(uint64 instruction)
6729{
6730 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6731 uint64 ac_value = extract_ac_13_12(instruction);
6732 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6733
6734 std::string ac = AC(copy(ac_value));
6735 std::string rs = GPR(copy(rs_value));
6736 std::string rt = GPR(copy(rt_value));
6737
6738 return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6739}
6740
6741
6742/*
6743 * DROTR -
6744 *
6745 * 3 2 1
6746 * 10987654321098765432109876543210
6747 * 001000 x1110000101
6748 * rt -----
6749 * rs -----
6750 * rd -----
6751 */
6752std::string NMD::DROTR(uint64 instruction)
6753{
6754 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6755 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6756 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6757
6758 std::string rt = GPR(copy(rt_value));
6759 std::string rs = GPR(copy(rs_value));
6760 std::string shift = IMMEDIATE(copy(shift_value));
6761
6762 return img::format("DROTR %s, %s, %s", rt, rs, shift);
6763}
6764
6765
6766/*
6767 * DROTR[32] -
6768 *
6769 * 3 2 1
6770 * 10987654321098765432109876543210
6771 * 10o000 1100xxx0110
6772 * rt -----
6773 * rs -----
6774 * shift -----
6775 */
6776std::string NMD::DROTR32(uint64 instruction)
6777{
6778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6779 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6780 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6781
6782 std::string rt = GPR(copy(rt_value));
6783 std::string rs = GPR(copy(rs_value));
6784 std::string shift = IMMEDIATE(copy(shift_value));
6785
6786 return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
6787}
6788
6789
6790/*
6791 *
6792 *
6793 * 3 2 1
6794 * 10987654321098765432109876543210
6795 * 001000 x1110000101
6796 * rt -----
6797 * rs -----
6798 * rd -----
6799 */
6800std::string NMD::DROTRV(uint64 instruction)
6801{
6802 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6803 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6804 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6805
6806 std::string rd = GPR(copy(rd_value));
6807 std::string rs = GPR(copy(rs_value));
6808 std::string rt = GPR(copy(rt_value));
6809
6810 return img::format("DROTRV %s, %s, %s", rd, rs, rt);
6811}
6812
6813
6814/*
6815 *
6816 *
6817 * 3 2 1
6818 * 10987654321098765432109876543210
6819 * 001000 x1110000101
6820 * rt -----
6821 * rs -----
6822 * rd -----
6823 */
6824std::string NMD::DROTX(uint64 instruction)
6825{
6826 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6827 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6828 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6829 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6830
6831 std::string rt = GPR(copy(rt_value));
6832 std::string rs = GPR(copy(rs_value));
6833 std::string shift = IMMEDIATE(copy(shift_value));
6834 std::string shiftx = IMMEDIATE(copy(shiftx_value));
6835
6836 return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
6837}
6838
6839
6840/*
6841 * DSLL -
6842 *
6843 * 3 2 1
6844 * 10987654321098765432109876543210
6845 * 10o000 1100xxx0000
6846 * rt -----
6847 * rs -----
6848 * shift -----
6849 */
6850std::string NMD::DSLL(uint64 instruction)
6851{
6852 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6853 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6854 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6855
6856 std::string rt = GPR(copy(rt_value));
6857 std::string rs = GPR(copy(rs_value));
6858 std::string shift = IMMEDIATE(copy(shift_value));
6859
6860 return img::format("DSLL %s, %s, %s", rt, rs, shift);
6861}
6862
6863
6864/*
6865 * DSLL[32] -
6866 *
6867 * 3 2 1
6868 * 10987654321098765432109876543210
6869 * 10o000 1100xxx0000
6870 * rt -----
6871 * rs -----
6872 * shift -----
6873 */
6874std::string NMD::DSLL32(uint64 instruction)
6875{
6876 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6877 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6878 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6879
6880 std::string rt = GPR(copy(rt_value));
6881 std::string rs = GPR(copy(rs_value));
6882 std::string shift = IMMEDIATE(copy(shift_value));
6883
6884 return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
6885}
6886
6887
6888/*
6889 *
6890 *
6891 * 3 2 1
6892 * 10987654321098765432109876543210
6893 * 001000 x1110000101
6894 * rt -----
6895 * rs -----
6896 * rd -----
6897 */
6898std::string NMD::DSLLV(uint64 instruction)
6899{
6900 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6901 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6902 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6903
6904 std::string rd = GPR(copy(rd_value));
6905 std::string rs = GPR(copy(rs_value));
6906 std::string rt = GPR(copy(rt_value));
6907
6908 return img::format("DSLLV %s, %s, %s", rd, rs, rt);
6909}
6910
6911
6912/*
6913 * DSRA -
6914 *
6915 * 3 2 1
6916 * 10987654321098765432109876543210
6917 * 10o000 1100xxx0100
6918 * rt -----
6919 * rs -----
6920 * shift -----
6921 */
6922std::string NMD::DSRA(uint64 instruction)
6923{
6924 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6925 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6926 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6927
6928 std::string rt = GPR(copy(rt_value));
6929 std::string rs = GPR(copy(rs_value));
6930 std::string shift = IMMEDIATE(copy(shift_value));
6931
6932 return img::format("DSRA %s, %s, %s", rt, rs, shift);
6933}
6934
6935
6936/*
6937 * DSRA[32] -
6938 *
6939 * 3 2 1
6940 * 10987654321098765432109876543210
6941 * 10o000 1100xxx0100
6942 * rt -----
6943 * rs -----
6944 * shift -----
6945 */
6946std::string NMD::DSRA32(uint64 instruction)
6947{
6948 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6949 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6950 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6951
6952 std::string rt = GPR(copy(rt_value));
6953 std::string rs = GPR(copy(rs_value));
6954 std::string shift = IMMEDIATE(copy(shift_value));
6955
6956 return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
6957}
6958
6959
6960/*
6961 *
6962 *
6963 * 3 2 1
6964 * 10987654321098765432109876543210
6965 * 001000 x1110000101
6966 * rt -----
6967 * rs -----
6968 * rd -----
6969 */
6970std::string NMD::DSRAV(uint64 instruction)
6971{
6972 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6973 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
6974 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6975
6976 std::string rd = GPR(copy(rd_value));
6977 std::string rs = GPR(copy(rs_value));
6978 std::string rt = GPR(copy(rt_value));
6979
6980 return img::format("DSRAV %s, %s, %s", rd, rs, rt);
6981}
6982
6983
6984/*
6985 * DSRL -
6986 *
6987 * 3 2 1
6988 * 10987654321098765432109876543210
6989 * 10o000 1100xxx0100
6990 * rt -----
6991 * rs -----
6992 * shift -----
6993 */
6994std::string NMD::DSRL(uint64 instruction)
6995{
6996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6997 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6998 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6999
7000 std::string rt = GPR(copy(rt_value));
7001 std::string rs = GPR(copy(rs_value));
7002 std::string shift = IMMEDIATE(copy(shift_value));
7003
7004 return img::format("DSRL %s, %s, %s", rt, rs, shift);
7005}
7006
7007
7008/*
7009 * DSRL[32] -
7010 *
7011 * 3 2 1
7012 * 10987654321098765432109876543210
7013 * 10o000 1100xxx0010
7014 * rt -----
7015 * rs -----
7016 * shift -----
7017 */
7018std::string NMD::DSRL32(uint64 instruction)
7019{
7020 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7021 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
7022 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7023
7024 std::string rt = GPR(copy(rt_value));
7025 std::string rs = GPR(copy(rs_value));
7026 std::string shift = IMMEDIATE(copy(shift_value));
7027
7028 return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
7029}
7030
7031
7032/*
7033 *
7034 *
7035 * 3 2 1
7036 * 10987654321098765432109876543210
7037 * 001000 x1110000101
7038 * rt -----
7039 * rs -----
7040 * rd -----
7041 */
7042std::string NMD::DSRLV(uint64 instruction)
7043{
7044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7045 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7046 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7047
7048 std::string rd = GPR(copy(rd_value));
7049 std::string rs = GPR(copy(rs_value));
7050 std::string rt = GPR(copy(rt_value));
7051
7052 return img::format("DSRLV %s, %s, %s", rd, rs, rt);
7053}
7054
7055
7056/*
7057 *
7058 *
7059 * 3 2 1
7060 * 10987654321098765432109876543210
7061 * 001000 x1110000101
7062 * rt -----
7063 * rs -----
7064 * rd -----
7065 */
7066std::string NMD::DSUB(uint64 instruction)
7067{
7068 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7069 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7070 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7071
7072 std::string rd = GPR(copy(rd_value));
7073 std::string rs = GPR(copy(rs_value));
7074 std::string rt = GPR(copy(rt_value));
7075
7076 return img::format("DSUB %s, %s, %s", rd, rs, rt);
7077}
7078
7079
7080/*
7081 *
7082 *
7083 * 3 2 1
7084 * 10987654321098765432109876543210
7085 * 001000 x1110000101
7086 * rt -----
7087 * rs -----
7088 * rd -----
7089 */
7090std::string NMD::DSUBU(uint64 instruction)
7091{
7092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7093 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7094 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7095
7096 std::string rd = GPR(copy(rd_value));
7097 std::string rs = GPR(copy(rs_value));
7098 std::string rt = GPR(copy(rt_value));
7099
7100 return img::format("DSUBU %s, %s, %s", rd, rs, rt);
7101}
7102
7103
7104/*
7105 *
7106 *
7107 * 3 2 1
7108 * 10987654321098765432109876543210
7109 * 001000 x1110000101
7110 * rt -----
7111 * rs -----
7112 * rd -----
7113 */
7114std::string NMD::DVPE(uint64 instruction)
7115{
7116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7117
7118 std::string rt = GPR(copy(rt_value));
7119
7120 return img::format("DVPE %s", rt);
7121}
7122
7123
7124/*
7125 *
7126 *
7127 * 3 2 1
7128 * 10987654321098765432109876543210
7129 * 001000 x1110000101
7130 * rt -----
7131 * rs -----
7132 * rd -----
7133 */
7134std::string NMD::DVP(uint64 instruction)
7135{
7136 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7137
7138 std::string rt = GPR(copy(rt_value));
7139
7140 return img::format("DVP %s", rt);
7141}
7142
7143
7144/*
7145 *
7146 *
7147 * 3 2 1
7148 * 10987654321098765432109876543210
7149 * 001000 x1110000101
7150 * rt -----
7151 * rs -----
7152 * rd -----
7153 */
7154std::string NMD::EHB(uint64 instruction)
7155{
7156 (void)instruction;
7157
7158 return "EHB ";
7159}
7160
7161
7162/*
7163 *
7164 *
7165 * 3 2 1
7166 * 10987654321098765432109876543210
7167 * 001000 x1110000101
7168 * rt -----
7169 * rs -----
7170 * rd -----
7171 */
7172std::string NMD::EI(uint64 instruction)
7173{
7174 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7175
7176 std::string rt = GPR(copy(rt_value));
7177
7178 return img::format("EI %s", rt);
7179}
7180
7181
7182/*
7183 *
7184 *
7185 * 3 2 1
7186 * 10987654321098765432109876543210
7187 * 001000 x1110000101
7188 * rt -----
7189 * rs -----
7190 * rd -----
7191 */
7192std::string NMD::EMT(uint64 instruction)
7193{
7194 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7195
7196 std::string rt = GPR(copy(rt_value));
7197
7198 return img::format("EMT %s", rt);
7199}
7200
7201
7202/*
7203 *
7204 *
7205 * 3 2 1
7206 * 10987654321098765432109876543210
7207 * 001000 x1110000101
7208 * rt -----
7209 * rs -----
7210 * rd -----
7211 */
7212std::string NMD::ERET(uint64 instruction)
7213{
7214 (void)instruction;
7215
7216 return "ERET ";
7217}
7218
7219
7220/*
7221 *
7222 *
7223 * 3 2 1
7224 * 10987654321098765432109876543210
7225 * 001000 x1110000101
7226 * rt -----
7227 * rs -----
7228 * rd -----
7229 */
7230std::string NMD::ERETNC(uint64 instruction)
7231{
7232 (void)instruction;
7233
7234 return "ERETNC ";
7235}
7236
7237
7238/*
7239 *
7240 *
7241 * 3 2 1
7242 * 10987654321098765432109876543210
7243 * 001000 x1110000101
7244 * rt -----
7245 * rs -----
7246 * rd -----
7247 */
7248std::string NMD::EVP(uint64 instruction)
7249{
7250 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7251
7252 std::string rt = GPR(copy(rt_value));
7253
7254 return img::format("EVP %s", rt);
7255}
7256
7257
7258/*
7259 *
7260 *
7261 * 3 2 1
7262 * 10987654321098765432109876543210
7263 * 001000 x1110000101
7264 * rt -----
7265 * rs -----
7266 * rd -----
7267 */
7268std::string NMD::EVPE(uint64 instruction)
7269{
7270 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7271
7272 std::string rt = GPR(copy(rt_value));
7273
7274 return img::format("EVPE %s", rt);
7275}
7276
7277
7278/*
7279 *
7280 *
7281 * 3 2 1
7282 * 10987654321098765432109876543210
7283 * 001000 x1110000101
7284 * rt -----
7285 * rs -----
7286 * rd -----
7287 */
7288std::string NMD::EXT(uint64 instruction)
7289{
7290 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7291 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7292 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7293 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7294
7295 std::string rt = GPR(copy(rt_value));
7296 std::string rs = GPR(copy(rs_value));
7297 std::string lsb = IMMEDIATE(copy(lsb_value));
7298 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
7299
7300 return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
7301}
7302
7303
7304/*
7305 *
7306 *
7307 * 3 2 1
7308 * 10987654321098765432109876543210
7309 * 001000 x1110000101
7310 * rt -----
7311 * rs -----
7312 * rd -----
7313 */
7314std::string NMD::EXTD(uint64 instruction)
7315{
7316 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7317 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7318 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7319 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7320
7321 std::string rd = GPR(copy(rd_value));
7322 std::string rs = GPR(copy(rs_value));
7323 std::string rt = GPR(copy(rt_value));
7324 std::string shift = IMMEDIATE(copy(shift_value));
7325
7326 return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
7327}
7328
7329
7330/*
7331 *
7332 *
7333 * 3 2 1
7334 * 10987654321098765432109876543210
7335 * 001000 x1110000101
7336 * rt -----
7337 * rs -----
7338 * rd -----
7339 */
7340std::string NMD::EXTD32(uint64 instruction)
7341{
7342 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7343 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7344 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7345 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7346
7347 std::string rd = GPR(copy(rd_value));
7348 std::string rs = GPR(copy(rs_value));
7349 std::string rt = GPR(copy(rt_value));
7350 std::string shift = IMMEDIATE(copy(shift_value));
7351
7352 return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
7353}
7354
7355
7356/*
7357 *
7358 *
7359 * 3 2 1
7360 * 10987654321098765432109876543210
7361 * 001000 x1110000101
7362 * rt -----
7363 * rs -----
7364 * rd -----
7365 */
7366std::string NMD::EXTPDP(uint64 instruction)
7367{
7368 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7369 uint64 ac_value = extract_ac_13_12(instruction);
7370 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7371
7372 std::string rt = GPR(copy(rt_value));
7373 std::string ac = AC(copy(ac_value));
7374 std::string size = IMMEDIATE(copy(size_value));
7375
7376 return img::format("EXTPDP %s, %s, %s", rt, ac, size);
7377}
7378
7379
7380/*
7381 *
7382 *
7383 * 3 2 1
7384 * 10987654321098765432109876543210
7385 * 001000 x1110000101
7386 * rt -----
7387 * rs -----
7388 * rd -----
7389 */
7390std::string NMD::EXTPDPV(uint64 instruction)
7391{
7392 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7393 uint64 ac_value = extract_ac_13_12(instruction);
7394 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7395
7396 std::string rt = GPR(copy(rt_value));
7397 std::string ac = AC(copy(ac_value));
7398 std::string rs = GPR(copy(rs_value));
7399
7400 return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
7401}
7402
7403
7404/*
7405 *
7406 *
7407 * 3 2 1
7408 * 10987654321098765432109876543210
7409 * 001000 x1110000101
7410 * rt -----
7411 * rs -----
7412 * rd -----
7413 */
7414std::string NMD::EXTP(uint64 instruction)
7415{
7416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7417 uint64 ac_value = extract_ac_13_12(instruction);
7418 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7419
7420 std::string rt = GPR(copy(rt_value));
7421 std::string ac = AC(copy(ac_value));
7422 std::string size = IMMEDIATE(copy(size_value));
7423
7424 return img::format("EXTP %s, %s, %s", rt, ac, size);
7425}
7426
7427
7428/*
7429 *
7430 *
7431 * 3 2 1
7432 * 10987654321098765432109876543210
7433 * 001000 x1110000101
7434 * rt -----
7435 * rs -----
7436 * rd -----
7437 */
7438std::string NMD::EXTPV(uint64 instruction)
7439{
7440 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7441 uint64 ac_value = extract_ac_13_12(instruction);
7442 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7443
7444 std::string rt = GPR(copy(rt_value));
7445 std::string ac = AC(copy(ac_value));
7446 std::string rs = GPR(copy(rs_value));
7447
7448 return img::format("EXTPV %s, %s, %s", rt, ac, rs);
7449}
7450
7451
7452/*
7453 *
7454 *
7455 * 3 2 1
7456 * 10987654321098765432109876543210
7457 * 001000 x1110000101
7458 * rt -----
7459 * rs -----
7460 * rd -----
7461 */
7462std::string NMD::EXTR_RS_W(uint64 instruction)
7463{
7464 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7465 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7466 uint64 ac_value = extract_ac_13_12(instruction);
7467
7468 std::string rt = GPR(copy(rt_value));
7469 std::string ac = AC(copy(ac_value));
7470 std::string shift = IMMEDIATE(copy(shift_value));
7471
7472 return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
7473}
7474
7475
7476/*
7477 *
7478 *
7479 * 3 2 1
7480 * 10987654321098765432109876543210
7481 * 001000 x1110000101
7482 * rt -----
7483 * rs -----
7484 * rd -----
7485 */
7486std::string NMD::EXTR_R_W(uint64 instruction)
7487{
7488 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7489 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7490 uint64 ac_value = extract_ac_13_12(instruction);
7491
7492 std::string rt = GPR(copy(rt_value));
7493 std::string ac = AC(copy(ac_value));
7494 std::string shift = IMMEDIATE(copy(shift_value));
7495
7496 return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
7497}
7498
7499
7500/*
7501 *
7502 *
7503 * 3 2 1
7504 * 10987654321098765432109876543210
7505 * 001000 x1110000101
7506 * rt -----
7507 * rs -----
7508 * rd -----
7509 */
7510std::string NMD::EXTR_S_H(uint64 instruction)
7511{
7512 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7513 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7514 uint64 ac_value = extract_ac_13_12(instruction);
7515
7516 std::string rt = GPR(copy(rt_value));
7517 std::string ac = AC(copy(ac_value));
7518 std::string shift = IMMEDIATE(copy(shift_value));
7519
7520 return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
7521}
7522
7523
7524/*
7525 *
7526 *
7527 * 3 2 1
7528 * 10987654321098765432109876543210
7529 * 001000 x1110000101
7530 * rt -----
7531 * rs -----
7532 * rd -----
7533 */
7534std::string NMD::EXTR_W(uint64 instruction)
7535{
7536 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7537 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7538 uint64 ac_value = extract_ac_13_12(instruction);
7539
7540 std::string rt = GPR(copy(rt_value));
7541 std::string ac = AC(copy(ac_value));
7542 std::string shift = IMMEDIATE(copy(shift_value));
7543
7544 return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
7545}
7546
7547
7548/*
7549 *
7550 *
7551 * 3 2 1
7552 * 10987654321098765432109876543210
7553 * 001000 x1110000101
7554 * rt -----
7555 * rs -----
7556 * rd -----
7557 */
7558std::string NMD::EXTRV_RS_W(uint64 instruction)
7559{
7560 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7561 uint64 ac_value = extract_ac_13_12(instruction);
7562 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7563
7564 std::string rt = GPR(copy(rt_value));
7565 std::string ac = AC(copy(ac_value));
7566 std::string rs = GPR(copy(rs_value));
7567
7568 return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7569}
7570
7571
7572/*
7573 *
7574 *
7575 * 3 2 1
7576 * 10987654321098765432109876543210
7577 * 001000 x1110000101
7578 * rt -----
7579 * rs -----
7580 * rd -----
7581 */
7582std::string NMD::EXTRV_R_W(uint64 instruction)
7583{
7584 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7585 uint64 ac_value = extract_ac_13_12(instruction);
7586 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7587
7588 std::string rt = GPR(copy(rt_value));
7589 std::string ac = AC(copy(ac_value));
7590 std::string rs = GPR(copy(rs_value));
7591
7592 return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7593}
7594
7595
7596/*
7597 *
7598 *
7599 * 3 2 1
7600 * 10987654321098765432109876543210
7601 * 001000 x1110000101
7602 * rt -----
7603 * rs -----
7604 * rd -----
7605 */
7606std::string NMD::EXTRV_S_H(uint64 instruction)
7607{
7608 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7609 uint64 ac_value = extract_ac_13_12(instruction);
7610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7611
7612 std::string rt = GPR(copy(rt_value));
7613 std::string ac = AC(copy(ac_value));
7614 std::string rs = GPR(copy(rs_value));
7615
7616 return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7617}
7618
7619
7620/*
7621 *
7622 *
7623 * 3 2 1
7624 * 10987654321098765432109876543210
7625 * 001000 x1110000101
7626 * rt -----
7627 * rs -----
7628 * rd -----
7629 */
7630std::string NMD::EXTRV_W(uint64 instruction)
7631{
7632 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7633 uint64 ac_value = extract_ac_13_12(instruction);
7634 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7635
7636 std::string rt = GPR(copy(rt_value));
7637 std::string ac = AC(copy(ac_value));
7638 std::string rs = GPR(copy(rs_value));
7639
7640 return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
7641}
7642
7643
7644/*
7645 * EXTW - Extract Word
7646 *
7647 * 3 2 1
7648 * 10987654321098765432109876543210
7649 * 001000 011111
7650 * rt -----
7651 * rs -----
7652 * rd -----
7653 * shift -----
7654 */
7655std::string NMD::EXTW(uint64 instruction)
7656{
7657 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7658 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7659 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7661
7662 std::string rd = GPR(copy(rd_value));
7663 std::string rs = GPR(copy(rs_value));
7664 std::string rt = GPR(copy(rt_value));
7665 std::string shift = IMMEDIATE(copy(shift_value));
7666
7667 return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
7668}
7669
7670
7671/*
7672 *
7673 *
7674 * 3 2 1
7675 * 10987654321098765432109876543210
7676 * 001000 x1110000101
7677 * rt -----
7678 * rs -----
7679 * rd -----
7680 */
7681std::string NMD::FLOOR_L_D(uint64 instruction)
7682{
7683 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7684 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7685
7686 std::string ft = FPR(copy(ft_value));
7687 std::string fs = FPR(copy(fs_value));
7688
7689 return img::format("FLOOR.L.D %s, %s", ft, fs);
7690}
7691
7692
7693/*
7694 *
7695 *
7696 * 3 2 1
7697 * 10987654321098765432109876543210
7698 * 001000 x1110000101
7699 * rt -----
7700 * rs -----
7701 * rd -----
7702 */
7703std::string NMD::FLOOR_L_S(uint64 instruction)
7704{
7705 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7706 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7707
7708 std::string ft = FPR(copy(ft_value));
7709 std::string fs = FPR(copy(fs_value));
7710
7711 return img::format("FLOOR.L.S %s, %s", ft, fs);
7712}
7713
7714
7715/*
7716 *
7717 *
7718 * 3 2 1
7719 * 10987654321098765432109876543210
7720 * 001000 x1110000101
7721 * rt -----
7722 * rs -----
7723 * rd -----
7724 */
7725std::string NMD::FLOOR_W_D(uint64 instruction)
7726{
7727 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7728 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7729
7730 std::string ft = FPR(copy(ft_value));
7731 std::string fs = FPR(copy(fs_value));
7732
7733 return img::format("FLOOR.W.D %s, %s", ft, fs);
7734}
7735
7736
7737/*
7738 *
7739 *
7740 * 3 2 1
7741 * 10987654321098765432109876543210
7742 * 001000 x1110000101
7743 * rt -----
7744 * rs -----
7745 * rd -----
7746 */
7747std::string NMD::FLOOR_W_S(uint64 instruction)
7748{
7749 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
7750 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
7751
7752 std::string ft = FPR(copy(ft_value));
7753 std::string fs = FPR(copy(fs_value));
7754
7755 return img::format("FLOOR.W.S %s, %s", ft, fs);
7756}
7757
7758
7759/*
7760 *
7761 *
7762 * 3 2 1
7763 * 10987654321098765432109876543210
7764 * 001000 x1110000101
7765 * rt -----
7766 * rs -----
7767 * rd -----
7768 */
7769std::string NMD::FORK(uint64 instruction)
7770{
7771 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7772 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
7773 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7774
7775 std::string rd = GPR(copy(rd_value));
7776 std::string rs = GPR(copy(rs_value));
7777 std::string rt = GPR(copy(rt_value));
7778
7779 return img::format("FORK %s, %s, %s", rd, rs, rt);
7780}
7781
7782
7783/*
7784 *
7785 *
7786 * 3 2 1
7787 * 10987654321098765432109876543210
7788 * 001000 x1110000101
7789 * rt -----
7790 * rs -----
7791 * rd -----
7792 */
7793std::string NMD::HYPCALL(uint64 instruction)
7794{
7795 uint64 code_value = extract_code_17_to_0(instruction);
7796
7797 std::string code = IMMEDIATE(copy(code_value));
7798
7799 return img::format("HYPCALL %s", code);
7800}
7801
7802
7803/*
7804 *
7805 *
7806 * 3 2 1
7807 * 10987654321098765432109876543210
7808 * 001000 x1110000101
7809 * rt -----
7810 * rs -----
7811 * rd -----
7812 */
7813std::string NMD::HYPCALL_16_(uint64 instruction)
7814{
7815 uint64 code_value = extract_code_1_0(instruction);
7816
7817 std::string code = IMMEDIATE(copy(code_value));
7818
7819 return img::format("HYPCALL %s", code);
7820}
7821
7822
7823/*
7824 *
7825 *
7826 * 3 2 1
7827 * 10987654321098765432109876543210
7828 * 001000 x1110000101
7829 * rt -----
7830 * rs -----
7831 * rd -----
7832 */
7833std::string NMD::INS(uint64 instruction)
7834{
7835 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7836 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7837 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7838 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7839
7840 std::string rt = GPR(copy(rt_value));
7841 std::string rs = GPR(copy(rs_value));
7842 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
7843 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
7844 /* !!!!!!!!!! - no conversion function */
7845
7846 return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
7847 /* hand edited */
7848}
7849
7850
7851/*
7852 *
7853 *
7854 * 3 2 1
7855 * 10987654321098765432109876543210
7856 * 001000 x1110000101
7857 * rt -----
7858 * rs -----
7859 * rd -----
7860 */
7861std::string NMD::INSV(uint64 instruction)
7862{
7863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7864 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7865
7866 std::string rt = GPR(copy(rt_value));
7867 std::string rs = GPR(copy(rs_value));
7868
7869 return img::format("INSV %s, %s", rt, rs);
7870}
7871
7872
7873/*
7874 *
7875 *
7876 * 3 2 1
7877 * 10987654321098765432109876543210
7878 * 001000 x1110000101
7879 * rt -----
7880 * rs -----
7881 * rd -----
7882 */
7883std::string NMD::IRET(uint64 instruction)
7884{
7885 (void)instruction;
7886
7887 return "IRET ";
7888}
7889
7890
7891/*
7892 *
7893 *
7894 * 3 2 1
7895 * 10987654321098765432109876543210
7896 * 001000 x1110000101
7897 * rt -----
7898 * rs -----
7899 * rd -----
7900 */
7901std::string NMD::JALRC_16_(uint64 instruction)
7902{
7903 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7904
7905 std::string rt = GPR(copy(rt_value));
7906
7907 return img::format("JALRC $%d, %s", 31, rt);
7908}
7909
7910
7911/*
7912 *
7913 *
7914 * 3 2 1
7915 * 10987654321098765432109876543210
7916 * 001000 x1110000101
7917 * rt -----
7918 * rs -----
7919 * rd -----
7920 */
7921std::string NMD::JALRC_32_(uint64 instruction)
7922{
7923 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7924 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7925
7926 std::string rt = GPR(copy(rt_value));
7927 std::string rs = GPR(copy(rs_value));
7928
7929 return img::format("JALRC %s, %s", rt, rs);
7930}
7931
7932
7933/*
7934 *
7935 *
7936 * 3 2 1
7937 * 10987654321098765432109876543210
7938 * 001000 x1110000101
7939 * rt -----
7940 * rs -----
7941 * rd -----
7942 */
7943std::string NMD::JALRC_HB(uint64 instruction)
7944{
7945 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7946 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7947
7948 std::string rt = GPR(copy(rt_value));
7949 std::string rs = GPR(copy(rs_value));
7950
7951 return img::format("JALRC.HB %s, %s", rt, rs);
7952}
7953
7954
7955/*
7956 *
7957 *
7958 * 3 2 1
7959 * 10987654321098765432109876543210
7960 * 001000 x1110000101
7961 * rt -----
7962 * rs -----
7963 * rd -----
7964 */
7965std::string NMD::JRC(uint64 instruction)
7966{
7967 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7968
7969 std::string rt = GPR(copy(rt_value));
7970
7971 return img::format("JRC %s", rt);
7972}
7973
7974
7975/*
7976 *
7977 *
7978 * 3 2 1
7979 * 10987654321098765432109876543210
7980 * 001000 x1110000101
7981 * rt -----
7982 * rs -----
7983 * rd -----
7984 */
7985std::string NMD::LB_16_(uint64 instruction)
7986{
7987 uint64 u_value = extract_u_1_0(instruction);
7988 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7989 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7990
7991 std::string rt3 = GPR(encode_gpr3(rt3_value));
7992 std::string u = IMMEDIATE(copy(u_value));
7993 std::string rs3 = GPR(encode_gpr3(rs3_value));
7994
7995 return img::format("LB %s, %s(%s)", rt3, u, rs3);
7996}
7997
7998
7999/*
8000 *
8001 *
8002 * 3 2 1
8003 * 10987654321098765432109876543210
8004 * 001000 x1110000101
8005 * rt -----
8006 * rs -----
8007 * rd -----
8008 */
8009std::string NMD::LB_GP_(uint64 instruction)
8010{
8011 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8012 uint64 u_value = extract_u_17_to_0(instruction);
8013
8014 std::string rt = GPR(copy(rt_value));
8015 std::string u = IMMEDIATE(copy(u_value));
8016
8017 return img::format("LB %s, %s($%d)", rt, u, 28);
8018}
8019
8020
8021/*
8022 *
8023 *
8024 * 3 2 1
8025 * 10987654321098765432109876543210
8026 * 001000 x1110000101
8027 * rt -----
8028 * rs -----
8029 * rd -----
8030 */
8031std::string NMD::LB_S9_(uint64 instruction)
8032{
8033 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8034 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8035 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8036
8037 std::string rt = GPR(copy(rt_value));
8038 std::string s = IMMEDIATE(copy(s_value));
8039 std::string rs = GPR(copy(rs_value));
8040
8041 return img::format("LB %s, %s(%s)", rt, s, rs);
8042}
8043
8044
8045/*
8046 *
8047 *
8048 * 3 2 1
8049 * 10987654321098765432109876543210
8050 * 001000 x1110000101
8051 * rt -----
8052 * rs -----
8053 * rd -----
8054 */
8055std::string NMD::LB_U12_(uint64 instruction)
8056{
8057 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8058 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8059 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8060
8061 std::string rt = GPR(copy(rt_value));
8062 std::string u = IMMEDIATE(copy(u_value));
8063 std::string rs = GPR(copy(rs_value));
8064
8065 return img::format("LB %s, %s(%s)", rt, u, rs);
8066}
8067
8068
8069/*
8070 *
8071 *
8072 * 3 2 1
8073 * 10987654321098765432109876543210
8074 * 001000 x1110000101
8075 * rt -----
8076 * rs -----
8077 * rd -----
8078 */
8079std::string NMD::LBE(uint64 instruction)
8080{
8081 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8082 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8083 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8084
8085 std::string rt = GPR(copy(rt_value));
8086 std::string s = IMMEDIATE(copy(s_value));
8087 std::string rs = GPR(copy(rs_value));
8088
8089 return img::format("LBE %s, %s(%s)", rt, s, rs);
8090}
8091
8092
8093/*
8094 *
8095 *
8096 * 3 2 1
8097 * 10987654321098765432109876543210
8098 * 001000 x1110000101
8099 * rt -----
8100 * rs -----
8101 * rd -----
8102 */
8103std::string NMD::LBU_16_(uint64 instruction)
8104{
8105 uint64 u_value = extract_u_1_0(instruction);
8106 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8107 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8108
8109 std::string rt3 = GPR(encode_gpr3(rt3_value));
8110 std::string u = IMMEDIATE(copy(u_value));
8111 std::string rs3 = GPR(encode_gpr3(rs3_value));
8112
8113 return img::format("LBU %s, %s(%s)", rt3, u, rs3);
8114}
8115
8116
8117/*
8118 *
8119 *
8120 * 3 2 1
8121 * 10987654321098765432109876543210
8122 * 001000 x1110000101
8123 * rt -----
8124 * rs -----
8125 * rd -----
8126 */
8127std::string NMD::LBU_GP_(uint64 instruction)
8128{
8129 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8130 uint64 u_value = extract_u_17_to_0(instruction);
8131
8132 std::string rt = GPR(copy(rt_value));
8133 std::string u = IMMEDIATE(copy(u_value));
8134
8135 return img::format("LBU %s, %s($%d)", rt, u, 28);
8136}
8137
8138
8139/*
8140 *
8141 *
8142 * 3 2 1
8143 * 10987654321098765432109876543210
8144 * 001000 x1110000101
8145 * rt -----
8146 * rs -----
8147 * rd -----
8148 */
8149std::string NMD::LBU_S9_(uint64 instruction)
8150{
8151 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8152 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8153 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8154
8155 std::string rt = GPR(copy(rt_value));
8156 std::string s = IMMEDIATE(copy(s_value));
8157 std::string rs = GPR(copy(rs_value));
8158
8159 return img::format("LBU %s, %s(%s)", rt, s, rs);
8160}
8161
8162
8163/*
8164 *
8165 *
8166 * 3 2 1
8167 * 10987654321098765432109876543210
8168 * 001000 x1110000101
8169 * rt -----
8170 * rs -----
8171 * rd -----
8172 */
8173std::string NMD::LBU_U12_(uint64 instruction)
8174{
8175 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8176 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8177 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8178
8179 std::string rt = GPR(copy(rt_value));
8180 std::string u = IMMEDIATE(copy(u_value));
8181 std::string rs = GPR(copy(rs_value));
8182
8183 return img::format("LBU %s, %s(%s)", rt, u, rs);
8184}
8185
8186
8187/*
8188 *
8189 *
8190 * 3 2 1
8191 * 10987654321098765432109876543210
8192 * 001000 x1110000101
8193 * rt -----
8194 * rs -----
8195 * rd -----
8196 */
8197std::string NMD::LBUE(uint64 instruction)
8198{
8199 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8200 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8201 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8202
8203 std::string rt = GPR(copy(rt_value));
8204 std::string s = IMMEDIATE(copy(s_value));
8205 std::string rs = GPR(copy(rs_value));
8206
8207 return img::format("LBUE %s, %s(%s)", rt, s, rs);
8208}
8209
8210
8211/*
8212 *
8213 *
8214 * 3 2 1
8215 * 10987654321098765432109876543210
8216 * 001000 x1110000101
8217 * rt -----
8218 * rs -----
8219 * rd -----
8220 */
8221std::string NMD::LBUX(uint64 instruction)
8222{
8223 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8224 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8225 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8226
8227 std::string rd = GPR(copy(rd_value));
8228 std::string rs = GPR(copy(rs_value));
8229 std::string rt = GPR(copy(rt_value));
8230
8231 return img::format("LBUX %s, %s(%s)", rd, rs, rt);
8232}
8233
8234
8235/*
8236 *
8237 *
8238 * 3 2 1
8239 * 10987654321098765432109876543210
8240 * 001000 x1110000101
8241 * rt -----
8242 * rs -----
8243 * rd -----
8244 */
8245std::string NMD::LBX(uint64 instruction)
8246{
8247 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8248 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8249 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8250
8251 std::string rd = GPR(copy(rd_value));
8252 std::string rs = GPR(copy(rs_value));
8253 std::string rt = GPR(copy(rt_value));
8254
8255 return img::format("LBX %s, %s(%s)", rd, rs, rt);
8256}
8257
8258
8259/*
8260 *
8261 *
8262 * 3 2 1
8263 * 10987654321098765432109876543210
8264 * 001000 x1110000101
8265 * rt -----
8266 * rs -----
8267 * rd -----
8268 */
8269std::string NMD::LD_GP_(uint64 instruction)
8270{
8271 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8272 uint64 u_value = extr_uil3il3bs18Fmsb20(instruction);
8273
8274 std::string rt = GPR(copy(rt_value));
8275 std::string u = IMMEDIATE(copy(u_value));
8276
8277 return img::format("LD %s, %s($%d)", rt, u, 28);
8278}
8279
8280
8281/*
8282 *
8283 *
8284 * 3 2 1
8285 * 10987654321098765432109876543210
8286 * 001000 x1110000101
8287 * rt -----
8288 * rs -----
8289 * rd -----
8290 */
8291std::string NMD::LD_S9_(uint64 instruction)
8292{
8293 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8294 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8295 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8296
8297 std::string rt = GPR(copy(rt_value));
8298 std::string s = IMMEDIATE(copy(s_value));
8299 std::string rs = GPR(copy(rs_value));
8300
8301 return img::format("LD %s, %s(%s)", rt, s, rs);
8302}
8303
8304
8305/*
8306 *
8307 *
8308 * 3 2 1
8309 * 10987654321098765432109876543210
8310 * 001000 x1110000101
8311 * rt -----
8312 * rs -----
8313 * rd -----
8314 */
8315std::string NMD::LD_U12_(uint64 instruction)
8316{
8317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8318 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8319 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8320
8321 std::string rt = GPR(copy(rt_value));
8322 std::string u = IMMEDIATE(copy(u_value));
8323 std::string rs = GPR(copy(rs_value));
8324
8325 return img::format("LD %s, %s(%s)", rt, u, rs);
8326}
8327
8328
8329/*
8330 *
8331 *
8332 * 3 2 1
8333 * 10987654321098765432109876543210
8334 * 001000 x1110000101
8335 * rt -----
8336 * rs -----
8337 * rd -----
8338 */
8339std::string NMD::LDC1_GP_(uint64 instruction)
8340{
8341 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8342 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
8343
8344 std::string ft = FPR(copy(ft_value));
8345 std::string u = IMMEDIATE(copy(u_value));
8346
8347 return img::format("LDC1 %s, %s($%d)", ft, u, 28);
8348}
8349
8350
8351/*
8352 *
8353 *
8354 * 3 2 1
8355 * 10987654321098765432109876543210
8356 * 001000 x1110000101
8357 * rt -----
8358 * rs -----
8359 * rd -----
8360 */
8361std::string NMD::LDC1_S9_(uint64 instruction)
8362{
8363 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8364 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8365 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8366
8367 std::string ft = FPR(copy(ft_value));
8368 std::string s = IMMEDIATE(copy(s_value));
8369 std::string rs = GPR(copy(rs_value));
8370
8371 return img::format("LDC1 %s, %s(%s)", ft, s, rs);
8372}
8373
8374
8375/*
8376 *
8377 *
8378 * 3 2 1
8379 * 10987654321098765432109876543210
8380 * 001000 x1110000101
8381 * rt -----
8382 * rs -----
8383 * rd -----
8384 */
8385std::string NMD::LDC1_U12_(uint64 instruction)
8386{
8387 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
8388 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8389 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8390
8391 std::string ft = FPR(copy(ft_value));
8392 std::string u = IMMEDIATE(copy(u_value));
8393 std::string rs = GPR(copy(rs_value));
8394
8395 return img::format("LDC1 %s, %s(%s)", ft, u, rs);
8396}
8397
8398
8399/*
8400 *
8401 *
8402 * 3 2 1
8403 * 10987654321098765432109876543210
8404 * 001000 x1110000101
8405 * rt -----
8406 * rs -----
8407 * rd -----
8408 */
8409std::string NMD::LDC1XS(uint64 instruction)
8410{
8411 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8412 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8413 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8414
8415 std::string ft = FPR(copy(ft_value));
8416 std::string rs = GPR(copy(rs_value));
8417 std::string rt = GPR(copy(rt_value));
8418
8419 return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
8420}
8421
8422
8423/*
8424 *
8425 *
8426 * 3 2 1
8427 * 10987654321098765432109876543210
8428 * 001000 x1110000101
8429 * rt -----
8430 * rs -----
8431 * rd -----
8432 */
8433std::string NMD::LDC1X(uint64 instruction)
8434{
8435 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8436 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8437 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8438
8439 std::string ft = FPR(copy(ft_value));
8440 std::string rs = GPR(copy(rs_value));
8441 std::string rt = GPR(copy(rt_value));
8442
8443 return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
8444}
8445
8446
8447/*
8448 *
8449 *
8450 * 3 2 1
8451 * 10987654321098765432109876543210
8452 * 001000 x1110000101
8453 * rt -----
8454 * rs -----
8455 * rd -----
8456 */
8457std::string NMD::LDC2(uint64 instruction)
8458{
8459 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8460 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8462
8463 std::string ct = CPR(copy(ct_value));
8464 std::string s = IMMEDIATE(copy(s_value));
8465 std::string rs = GPR(copy(rs_value));
8466
8467 return img::format("LDC2 %s, %s(%s)", ct, s, rs);
8468}
8469
8470
8471/*
8472 *
8473 *
8474 * 3 2 1
8475 * 10987654321098765432109876543210
8476 * 001000 x1110000101
8477 * rt -----
8478 * rs -----
8479 * rd -----
8480 */
8481std::string NMD::LDM(uint64 instruction)
8482{
8483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8484 uint64 count3_value = extract_count3_14_13_12(instruction);
8485 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8486 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8487
8488 std::string rt = GPR(copy(rt_value));
8489 std::string s = IMMEDIATE(copy(s_value));
8490 std::string rs = GPR(copy(rs_value));
8491 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
8492
8493 return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
8494}
8495
8496
8497/*
8498 *
8499 *
8500 * 3 2 1
8501 * 10987654321098765432109876543210
8502 * 001000 x1110000101
8503 * rt -----
8504 * rs -----
8505 * rd -----
8506 */
8507std::string NMD::LDPC_48_(uint64 instruction)
8508{
8509 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8510 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
8511
8512 std::string rt = GPR(copy(rt_value));
8513 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
8514
8515 return img::format("LDPC %s, %s", rt, s);
8516}
8517
8518
8519/*
8520 *
8521 *
8522 * 3 2 1
8523 * 10987654321098765432109876543210
8524 * 001000 x1110000101
8525 * rt -----
8526 * rs -----
8527 * rd -----
8528 */
8529std::string NMD::LDX(uint64 instruction)
8530{
8531 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8532 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8533 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8534
8535 std::string rd = GPR(copy(rd_value));
8536 std::string rs = GPR(copy(rs_value));
8537 std::string rt = GPR(copy(rt_value));
8538
8539 return img::format("LDX %s, %s(%s)", rd, rs, rt);
8540}
8541
8542
8543/*
8544 *
8545 *
8546 * 3 2 1
8547 * 10987654321098765432109876543210
8548 * 001000 x1110000101
8549 * rt -----
8550 * rs -----
8551 * rd -----
8552 */
8553std::string NMD::LDXS(uint64 instruction)
8554{
8555 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8556 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8557 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8558
8559 std::string rd = GPR(copy(rd_value));
8560 std::string rs = GPR(copy(rs_value));
8561 std::string rt = GPR(copy(rt_value));
8562
8563 return img::format("LDXS %s, %s(%s)", rd, rs, rt);
8564}
8565
8566
8567/*
8568 *
8569 *
8570 * 3 2 1
8571 * 10987654321098765432109876543210
8572 * 001000 x1110000101
8573 * rt -----
8574 * rs -----
8575 * rd -----
8576 */
8577std::string NMD::LH_16_(uint64 instruction)
8578{
8579 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
8580 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8581 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8582
8583 std::string rt3 = GPR(encode_gpr3(rt3_value));
8584 std::string u = IMMEDIATE(copy(u_value));
8585 std::string rs3 = GPR(encode_gpr3(rs3_value));
8586
8587 return img::format("LH %s, %s(%s)", rt3, u, rs3);
8588}
8589
8590
8591/*
8592 *
8593 *
8594 * 3 2 1
8595 * 10987654321098765432109876543210
8596 * 001000 x1110000101
8597 * rt -----
8598 * rs -----
8599 * rd -----
8600 */
8601std::string NMD::LH_GP_(uint64 instruction)
8602{
8603 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8604 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
8605
8606 std::string rt = GPR(copy(rt_value));
8607 std::string u = IMMEDIATE(copy(u_value));
8608
8609 return img::format("LH %s, %s($%d)", rt, u, 28);
8610}
8611
8612
8613/*
8614 *
8615 *
8616 * 3 2 1
8617 * 10987654321098765432109876543210
8618 * 001000 x1110000101
8619 * rt -----
8620 * rs -----
8621 * rd -----
8622 */
8623std::string NMD::LH_S9_(uint64 instruction)
8624{
8625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8626 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8627 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8628
8629 std::string rt = GPR(copy(rt_value));
8630 std::string s = IMMEDIATE(copy(s_value));
8631 std::string rs = GPR(copy(rs_value));
8632
8633 return img::format("LH %s, %s(%s)", rt, s, rs);
8634}
8635
8636
8637/*
8638 *
8639 *
8640 * 3 2 1
8641 * 10987654321098765432109876543210
8642 * 001000 x1110000101
8643 * rt -----
8644 * rs -----
8645 * rd -----
8646 */
8647std::string NMD::LH_U12_(uint64 instruction)
8648{
8649 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8650 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8651 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8652
8653 std::string rt = GPR(copy(rt_value));
8654 std::string u = IMMEDIATE(copy(u_value));
8655 std::string rs = GPR(copy(rs_value));
8656
8657 return img::format("LH %s, %s(%s)", rt, u, rs);
8658}
8659
8660
8661/*
8662 *
8663 *
8664 * 3 2 1
8665 * 10987654321098765432109876543210
8666 * 001000 x1110000101
8667 * rt -----
8668 * rs -----
8669 * rd -----
8670 */
8671std::string NMD::LHE(uint64 instruction)
8672{
8673 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8674 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8675 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8676
8677 std::string rt = GPR(copy(rt_value));
8678 std::string s = IMMEDIATE(copy(s_value));
8679 std::string rs = GPR(copy(rs_value));
8680
8681 return img::format("LHE %s, %s(%s)", rt, s, rs);
8682}
8683
8684
8685/*
8686 *
8687 *
8688 * 3 2 1
8689 * 10987654321098765432109876543210
8690 * 001000 x1110000101
8691 * rt -----
8692 * rs -----
8693 * rd -----
8694 */
8695std::string NMD::LHU_16_(uint64 instruction)
8696{
8697 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
8698 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8699 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8700
8701 std::string rt3 = GPR(encode_gpr3(rt3_value));
8702 std::string u = IMMEDIATE(copy(u_value));
8703 std::string rs3 = GPR(encode_gpr3(rs3_value));
8704
8705 return img::format("LHU %s, %s(%s)", rt3, u, rs3);
8706}
8707
8708
8709/*
8710 *
8711 *
8712 * 3 2 1
8713 * 10987654321098765432109876543210
8714 * 001000 x1110000101
8715 * rt -----
8716 * rs -----
8717 * rd -----
8718 */
8719std::string NMD::LHU_GP_(uint64 instruction)
8720{
8721 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8722 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
8723
8724 std::string rt = GPR(copy(rt_value));
8725 std::string u = IMMEDIATE(copy(u_value));
8726
8727 return img::format("LHU %s, %s($%d)", rt, u, 28);
8728}
8729
8730
8731/*
8732 *
8733 *
8734 * 3 2 1
8735 * 10987654321098765432109876543210
8736 * 001000 x1110000101
8737 * rt -----
8738 * rs -----
8739 * rd -----
8740 */
8741std::string NMD::LHU_S9_(uint64 instruction)
8742{
8743 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8744 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8745 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8746
8747 std::string rt = GPR(copy(rt_value));
8748 std::string s = IMMEDIATE(copy(s_value));
8749 std::string rs = GPR(copy(rs_value));
8750
8751 return img::format("LHU %s, %s(%s)", rt, s, rs);
8752}
8753
8754
8755/*
8756 *
8757 *
8758 * 3 2 1
8759 * 10987654321098765432109876543210
8760 * 001000 x1110000101
8761 * rt -----
8762 * rs -----
8763 * rd -----
8764 */
8765std::string NMD::LHU_U12_(uint64 instruction)
8766{
8767 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8768 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8769 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8770
8771 std::string rt = GPR(copy(rt_value));
8772 std::string u = IMMEDIATE(copy(u_value));
8773 std::string rs = GPR(copy(rs_value));
8774
8775 return img::format("LHU %s, %s(%s)", rt, u, rs);
8776}
8777
8778
8779/*
8780 *
8781 *
8782 * 3 2 1
8783 * 10987654321098765432109876543210
8784 * 001000 x1110000101
8785 * rt -----
8786 * rs -----
8787 * rd -----
8788 */
8789std::string NMD::LHUE(uint64 instruction)
8790{
8791 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8792 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
8793 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8794
8795 std::string rt = GPR(copy(rt_value));
8796 std::string s = IMMEDIATE(copy(s_value));
8797 std::string rs = GPR(copy(rs_value));
8798
8799 return img::format("LHUE %s, %s(%s)", rt, s, rs);
8800}
8801
8802
8803/*
8804 *
8805 *
8806 * 3 2 1
8807 * 10987654321098765432109876543210
8808 * 001000 x1110000101
8809 * rt -----
8810 * rs -----
8811 * rd -----
8812 */
8813std::string NMD::LHUX(uint64 instruction)
8814{
8815 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8816 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8817 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8818
8819 std::string rd = GPR(copy(rd_value));
8820 std::string rs = GPR(copy(rs_value));
8821 std::string rt = GPR(copy(rt_value));
8822
8823 return img::format("LHUX %s, %s(%s)", rd, rs, rt);
8824}
8825
8826
8827/*
8828 *
8829 *
8830 * 3 2 1
8831 * 10987654321098765432109876543210
8832 * 001000 x1110000101
8833 * rt -----
8834 * rs -----
8835 * rd -----
8836 */
8837std::string NMD::LHUXS(uint64 instruction)
8838{
8839 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8840 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8841 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8842
8843 std::string rd = GPR(copy(rd_value));
8844 std::string rs = GPR(copy(rs_value));
8845 std::string rt = GPR(copy(rt_value));
8846
8847 return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
8848}
8849
8850
8851/*
8852 *
8853 *
8854 * 3 2 1
8855 * 10987654321098765432109876543210
8856 * 001000 x1110000101
8857 * rt -----
8858 * rs -----
8859 * rd -----
8860 */
8861std::string NMD::LHXS(uint64 instruction)
8862{
8863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8864 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8865 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8866
8867 std::string rd = GPR(copy(rd_value));
8868 std::string rs = GPR(copy(rs_value));
8869 std::string rt = GPR(copy(rt_value));
8870
8871 return img::format("LHXS %s, %s(%s)", rd, rs, rt);
8872}
8873
8874
8875/*
8876 *
8877 *
8878 * 3 2 1
8879 * 10987654321098765432109876543210
8880 * 001000 x1110000101
8881 * rt -----
8882 * rs -----
8883 * rd -----
8884 */
8885std::string NMD::LHX(uint64 instruction)
8886{
8887 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8888 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
8889 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8890
8891 std::string rd = GPR(copy(rd_value));
8892 std::string rs = GPR(copy(rs_value));
8893 std::string rt = GPR(copy(rt_value));
8894
8895 return img::format("LHX %s, %s(%s)", rd, rs, rt);
8896}
8897
8898
8899/*
8900 *
8901 *
8902 * 3 2 1
8903 * 10987654321098765432109876543210
8904 * 001000 x1110000101
8905 * rt -----
8906 * rs -----
8907 * rd -----
8908 */
8909std::string NMD::LI_16_(uint64 instruction)
8910{
8911 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8912 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8913
8914 std::string rt3 = GPR(encode_gpr3(rt3_value));
8915 std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
8916
8917 return img::format("LI %s, %s", rt3, eu);
8918}
8919
8920
8921/*
8922 *
8923 *
8924 * 3 2 1
8925 * 10987654321098765432109876543210
8926 * 001000 x1110000101
8927 * rt -----
8928 * rs -----
8929 * rd -----
8930 */
8931std::string NMD::LI_48_(uint64 instruction)
8932{
8933 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8934 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
8935
8936 std::string rt = GPR(copy(rt_value));
8937 std::string s = IMMEDIATE(copy(s_value));
8938
8939 return img::format("LI %s, %s", rt, s);
8940}
8941
8942
8943/*
8944 *
8945 *
8946 * 3 2 1
8947 * 10987654321098765432109876543210
8948 * 001000 x1110000101
8949 * rt -----
8950 * rs -----
8951 * rd -----
8952 */
8953std::string NMD::LL(uint64 instruction)
8954{
8955 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8956 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
8957 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8958
8959 std::string rt = GPR(copy(rt_value));
8960 std::string s = IMMEDIATE(copy(s_value));
8961 std::string rs = GPR(copy(rs_value));
8962
8963 return img::format("LL %s, %s(%s)", rt, s, rs);
8964}
8965
8966
8967/*
8968 *
8969 *
8970 * 3 2 1
8971 * 10987654321098765432109876543210
8972 * 001000 x1110000101
8973 * rt -----
8974 * rs -----
8975 * rd -----
8976 */
8977std::string NMD::LLD(uint64 instruction)
8978{
8979 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8980 int64 s_value = extr_sil3il3bs5_il15il8bs1Tmsb8(instruction);
8981 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8982
8983 std::string rt = GPR(copy(rt_value));
8984 std::string s = IMMEDIATE(copy(s_value));
8985 std::string rs = GPR(copy(rs_value));
8986
8987 return img::format("LLD %s, %s(%s)", rt, s, rs);
8988}
8989
8990
8991/*
8992 *
8993 *
8994 * 3 2 1
8995 * 10987654321098765432109876543210
8996 * 001000 x1110000101
8997 * rt -----
8998 * rs -----
8999 * rd -----
9000 */
9001std::string NMD::LLDP(uint64 instruction)
9002{
9003 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9004 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9005 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9006
9007 std::string rt = GPR(copy(rt_value));
9008 std::string ru = GPR(copy(ru_value));
9009 std::string rs = GPR(copy(rs_value));
9010
9011 return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
9012}
9013
9014
9015/*
9016 *
9017 *
9018 * 3 2 1
9019 * 10987654321098765432109876543210
9020 * 001000 x1110000101
9021 * rt -----
9022 * rs -----
9023 * rd -----
9024 */
9025std::string NMD::LLE(uint64 instruction)
9026{
9027 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9028 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
9029 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9030
9031 std::string rt = GPR(copy(rt_value));
9032 std::string s = IMMEDIATE(copy(s_value));
9033 std::string rs = GPR(copy(rs_value));
9034
9035 return img::format("LLE %s, %s(%s)", rt, s, rs);
9036}
9037
9038
9039/*
9040 *
9041 *
9042 * 3 2 1
9043 * 10987654321098765432109876543210
9044 * 001000 x1110000101
9045 * rt -----
9046 * rs -----
9047 * rd -----
9048 */
9049std::string NMD::LLWP(uint64 instruction)
9050{
9051 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9052 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9053 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9054
9055 std::string rt = GPR(copy(rt_value));
9056 std::string ru = GPR(copy(ru_value));
9057 std::string rs = GPR(copy(rs_value));
9058
9059 return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
9060}
9061
9062
9063/*
9064 *
9065 *
9066 * 3 2 1
9067 * 10987654321098765432109876543210
9068 * 001000 x1110000101
9069 * rt -----
9070 * rs -----
9071 * rd -----
9072 */
9073std::string NMD::LLWPE(uint64 instruction)
9074{
9075 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9076 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9077 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9078
9079 std::string rt = GPR(copy(rt_value));
9080 std::string ru = GPR(copy(ru_value));
9081 std::string rs = GPR(copy(rs_value));
9082
9083 return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
9084}
9085
9086
9087/*
9088 *
9089 *
9090 * 3 2 1
9091 * 10987654321098765432109876543210
9092 * 001000 x1110000101
9093 * rt -----
9094 * rs -----
9095 * rd -----
9096 */
9097std::string NMD::LSA(uint64 instruction)
9098{
9099 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9100 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9101 uint64 u2_value = extract_u2_10_9(instruction);
9102 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9103
9104 std::string rd = GPR(copy(rd_value));
9105 std::string rs = GPR(copy(rs_value));
9106 std::string rt = GPR(copy(rt_value));
9107 std::string u2 = IMMEDIATE(copy(u2_value));
9108
9109 return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
9110}
9111
9112
9113/*
9114 *
9115 *
9116 * 3 2 1
9117 * 10987654321098765432109876543210
9118 * 001000 x1110000101
9119 * rt -----
9120 * rs -----
9121 * rd -----
9122 */
9123std::string NMD::LUI(uint64 instruction)
9124{
9125 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9126 int64 s_value = extr_sil0il31bs1_il2il21bs10_il12il12bs9Tmsb31(instruction);
9127
9128 std::string rt = GPR(copy(rt_value));
9129 std::string s = IMMEDIATE(copy(s_value));
9130
9131 return img::format("LUI %s, %%hi(%s)", rt, s);
9132}
9133
9134
9135/*
9136 *
9137 *
9138 * 3 2 1
9139 * 10987654321098765432109876543210
9140 * 001000 x1110000101
9141 * rt -----
9142 * rs -----
9143 * rd -----
9144 */
9145std::string NMD::LW_16_(uint64 instruction)
9146{
9147 uint64 u_value = extr_uil0il2bs4Fmsb5(instruction);
9148 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9149 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9150
9151 std::string rt3 = GPR(encode_gpr3(rt3_value));
9152 std::string u = IMMEDIATE(copy(u_value));
9153 std::string rs3 = GPR(encode_gpr3(rs3_value));
9154
9155 return img::format("LW %s, %s(%s)", rt3, u, rs3);
9156}
9157
9158
9159/*
9160 *
9161 *
9162 * 3 2 1
9163 * 10987654321098765432109876543210
9164 * 001000 x1110000101
9165 * rt -----
9166 * rs -----
9167 * rd -----
9168 */
9169std::string NMD::LW_4X4_(uint64 instruction)
9170{
9171 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
9172 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
9173 uint64 u_value = extr_uil3il3bs1_il8il2bs1Fmsb3(instruction);
9174
9175 std::string rt4 = GPR(encode_gpr4(rt4_value));
9176 std::string u = IMMEDIATE(copy(u_value));
9177 std::string rs4 = GPR(encode_gpr4(rs4_value));
9178
9179 return img::format("LW %s, %s(%s)", rt4, u, rs4);
9180}
9181
9182
9183/*
9184 *
9185 *
9186 * 3 2 1
9187 * 10987654321098765432109876543210
9188 * 001000 x1110000101
9189 * rt -----
9190 * rs -----
9191 * rd -----
9192 */
9193std::string NMD::LW_GP_(uint64 instruction)
9194{
9195 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9196 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
9197
9198 std::string rt = GPR(copy(rt_value));
9199 std::string u = IMMEDIATE(copy(u_value));
9200
9201 return img::format("LW %s, %s($%d)", rt, u, 28);
9202}
9203
9204
9205/*
9206 *
9207 *
9208 * 3 2 1
9209 * 10987654321098765432109876543210
9210 * 001000 x1110000101
9211 * rt -----
9212 * rs -----
9213 * rd -----
9214 */
9215std::string NMD::LW_GP16_(uint64 instruction)
9216{
9217 uint64 u_value = extr_uil0il2bs7Fmsb8(instruction);
9218 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9219
9220 std::string rt3 = GPR(encode_gpr3(rt3_value));
9221 std::string u = IMMEDIATE(copy(u_value));
9222
9223 return img::format("LW %s, %s($%d)", rt3, u, 28);
9224}
9225
9226
9227/*
9228 *
9229 *
9230 * 3 2 1
9231 * 10987654321098765432109876543210
9232 * 001000 x1110000101
9233 * rt -----
9234 * rs -----
9235 * rd -----
9236 */
9237std::string NMD::LW_S9_(uint64 instruction)
9238{
9239 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9240 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9242
9243 std::string rt = GPR(copy(rt_value));
9244 std::string s = IMMEDIATE(copy(s_value));
9245 std::string rs = GPR(copy(rs_value));
9246
9247 return img::format("LW %s, %s(%s)", rt, s, rs);
9248}
9249
9250
9251/*
9252 *
9253 *
9254 * 3 2 1
9255 * 10987654321098765432109876543210
9256 * 001000 x1110000101
9257 * rt -----
9258 * rs -----
9259 * rd -----
9260 */
9261std::string NMD::LW_SP_(uint64 instruction)
9262{
9263 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
9264 uint64 u_value = extr_uil0il2bs5Fmsb6(instruction);
9265
9266 std::string rt = GPR(copy(rt_value));
9267 std::string u = IMMEDIATE(copy(u_value));
9268
9269 return img::format("LW %s, %s($%d)", rt, u, 29);
9270}
9271
9272
9273/*
9274 *
9275 *
9276 * 3 2 1
9277 * 10987654321098765432109876543210
9278 * 001000 x1110000101
9279 * rt -----
9280 * rs -----
9281 * rd -----
9282 */
9283std::string NMD::LW_U12_(uint64 instruction)
9284{
9285 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9286 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9287 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9288
9289 std::string rt = GPR(copy(rt_value));
9290 std::string u = IMMEDIATE(copy(u_value));
9291 std::string rs = GPR(copy(rs_value));
9292
9293 return img::format("LW %s, %s(%s)", rt, u, rs);
9294}
9295
9296
9297/*
9298 *
9299 *
9300 * 3 2 1
9301 * 10987654321098765432109876543210
9302 * 001000 x1110000101
9303 * rt -----
9304 * rs -----
9305 * rd -----
9306 */
9307std::string NMD::LWC1_GP_(uint64 instruction)
9308{
9309 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9310 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
9311
9312 std::string ft = FPR(copy(ft_value));
9313 std::string u = IMMEDIATE(copy(u_value));
9314
9315 return img::format("LWC1 %s, %s($%d)", ft, u, 28);
9316}
9317
9318
9319/*
9320 *
9321 *
9322 * 3 2 1
9323 * 10987654321098765432109876543210
9324 * 001000 x1110000101
9325 * rt -----
9326 * rs -----
9327 * rd -----
9328 */
9329std::string NMD::LWC1_S9_(uint64 instruction)
9330{
9331 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9332 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9333 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9334
9335 std::string ft = FPR(copy(ft_value));
9336 std::string s = IMMEDIATE(copy(s_value));
9337 std::string rs = GPR(copy(rs_value));
9338
9339 return img::format("LWC1 %s, %s(%s)", ft, s, rs);
9340}
9341
9342
9343/*
9344 *
9345 *
9346 * 3 2 1
9347 * 10987654321098765432109876543210
9348 * 001000 x1110000101
9349 * rt -----
9350 * rs -----
9351 * rd -----
9352 */
9353std::string NMD::LWC1_U12_(uint64 instruction)
9354{
9355 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9356 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9357 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9358
9359 std::string ft = FPR(copy(ft_value));
9360 std::string u = IMMEDIATE(copy(u_value));
9361 std::string rs = GPR(copy(rs_value));
9362
9363 return img::format("LWC1 %s, %s(%s)", ft, u, rs);
9364}
9365
9366
9367/*
9368 *
9369 *
9370 * 3 2 1
9371 * 10987654321098765432109876543210
9372 * 001000 x1110000101
9373 * rt -----
9374 * rs -----
9375 * rd -----
9376 */
9377std::string NMD::LWC1X(uint64 instruction)
9378{
9379 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9380 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9381 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9382
9383 std::string ft = FPR(copy(ft_value));
9384 std::string rs = GPR(copy(rs_value));
9385 std::string rt = GPR(copy(rt_value));
9386
9387 return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
9388}
9389
9390
9391/*
9392 *
9393 *
9394 * 3 2 1
9395 * 10987654321098765432109876543210
9396 * 001000 x1110000101
9397 * rt -----
9398 * rs -----
9399 * rd -----
9400 */
9401std::string NMD::LWC1XS(uint64 instruction)
9402{
9403 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9404 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9405 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9406
9407 std::string ft = FPR(copy(ft_value));
9408 std::string rs = GPR(copy(rs_value));
9409 std::string rt = GPR(copy(rt_value));
9410
9411 return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
9412}
9413
9414
9415/*
9416 *
9417 *
9418 * 3 2 1
9419 * 10987654321098765432109876543210
9420 * 001000 x1110000101
9421 * rt -----
9422 * rs -----
9423 * rd -----
9424 */
9425std::string NMD::LWC2(uint64 instruction)
9426{
9427 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9428 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9429 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9430
9431 std::string ct = CPR(copy(ct_value));
9432 std::string s = IMMEDIATE(copy(s_value));
9433 std::string rs = GPR(copy(rs_value));
9434
9435 return img::format("LWC2 %s, %s(%s)", ct, s, rs);
9436}
9437
9438
9439/*
9440 *
9441 *
9442 * 3 2 1
9443 * 10987654321098765432109876543210
9444 * 001000 x1110000101
9445 * rt -----
9446 * rs -----
9447 * rd -----
9448 */
9449std::string NMD::LWE(uint64 instruction)
9450{
9451 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9452 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9453 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9454
9455 std::string rt = GPR(copy(rt_value));
9456 std::string s = IMMEDIATE(copy(s_value));
9457 std::string rs = GPR(copy(rs_value));
9458
9459 return img::format("LWE %s, %s(%s)", rt, s, rs);
9460}
9461
9462
9463/*
9464 *
9465 *
9466 * 3 2 1
9467 * 10987654321098765432109876543210
9468 * 001000 x1110000101
9469 * rt -----
9470 * rs -----
9471 * rd -----
9472 */
9473std::string NMD::LWM(uint64 instruction)
9474{
9475 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9476 uint64 count3_value = extract_count3_14_13_12(instruction);
9477 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9478 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9479
9480 std::string rt = GPR(copy(rt_value));
9481 std::string s = IMMEDIATE(copy(s_value));
9482 std::string rs = GPR(copy(rs_value));
9483 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
9484
9485 return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
9486}
9487
9488
9489/*
9490 *
9491 *
9492 * 3 2 1
9493 * 10987654321098765432109876543210
9494 * 001000 x1110000101
9495 * rt -----
9496 * rs -----
9497 * rd -----
9498 */
9499std::string NMD::LWPC_48_(uint64 instruction)
9500{
9501 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9502 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
9503
9504 std::string rt = GPR(copy(rt_value));
9505 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
9506
9507 return img::format("LWPC %s, %s", rt, s);
9508}
9509
9510
9511/*
9512 *
9513 *
9514 * 3 2 1
9515 * 10987654321098765432109876543210
9516 * 001000 x1110000101
9517 * rt -----
9518 * rs -----
9519 * rd -----
9520 */
9521std::string NMD::LWU_GP_(uint64 instruction)
9522{
9523 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9524 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
9525
9526 std::string rt = GPR(copy(rt_value));
9527 std::string u = IMMEDIATE(copy(u_value));
9528
9529 return img::format("LWU %s, %s($%d)", rt, u, 28);
9530}
9531
9532
9533/*
9534 *
9535 *
9536 * 3 2 1
9537 * 10987654321098765432109876543210
9538 * 001000 x1110000101
9539 * rt -----
9540 * rs -----
9541 * rd -----
9542 */
9543std::string NMD::LWU_S9_(uint64 instruction)
9544{
9545 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9546 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
9547 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9548
9549 std::string rt = GPR(copy(rt_value));
9550 std::string s = IMMEDIATE(copy(s_value));
9551 std::string rs = GPR(copy(rs_value));
9552
9553 return img::format("LWU %s, %s(%s)", rt, s, rs);
9554}
9555
9556
9557/*
9558 *
9559 *
9560 * 3 2 1
9561 * 10987654321098765432109876543210
9562 * 001000 x1110000101
9563 * rt -----
9564 * rs -----
9565 * rd -----
9566 */
9567std::string NMD::LWU_U12_(uint64 instruction)
9568{
9569 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9570 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9571 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9572
9573 std::string rt = GPR(copy(rt_value));
9574 std::string u = IMMEDIATE(copy(u_value));
9575 std::string rs = GPR(copy(rs_value));
9576
9577 return img::format("LWU %s, %s(%s)", rt, u, rs);
9578}
9579
9580
9581/*
9582 *
9583 *
9584 * 3 2 1
9585 * 10987654321098765432109876543210
9586 * 001000 x1110000101
9587 * rt -----
9588 * rs -----
9589 * rd -----
9590 */
9591std::string NMD::LWUX(uint64 instruction)
9592{
9593 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9594 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9595 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9596
9597 std::string rd = GPR(copy(rd_value));
9598 std::string rs = GPR(copy(rs_value));
9599 std::string rt = GPR(copy(rt_value));
9600
9601 return img::format("LWUX %s, %s(%s)", rd, rs, rt);
9602}
9603
9604
9605/*
9606 *
9607 *
9608 * 3 2 1
9609 * 10987654321098765432109876543210
9610 * 001000 x1110000101
9611 * rt -----
9612 * rs -----
9613 * rd -----
9614 */
9615std::string NMD::LWUXS(uint64 instruction)
9616{
9617 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9618 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9619 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9620
9621 std::string rd = GPR(copy(rd_value));
9622 std::string rs = GPR(copy(rs_value));
9623 std::string rt = GPR(copy(rt_value));
9624
9625 return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
9626}
9627
9628
9629/*
9630 *
9631 *
9632 * 3 2 1
9633 * 10987654321098765432109876543210
9634 * 001000 x1110000101
9635 * rt -----
9636 * rs -----
9637 * rd -----
9638 */
9639std::string NMD::LWX(uint64 instruction)
9640{
9641 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9642 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9643 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9644
9645 std::string rd = GPR(copy(rd_value));
9646 std::string rs = GPR(copy(rs_value));
9647 std::string rt = GPR(copy(rt_value));
9648
9649 return img::format("LWX %s, %s(%s)", rd, rs, rt);
9650}
9651
9652
9653/*
9654 *
9655 *
9656 * 3 2 1
9657 * 10987654321098765432109876543210
9658 * 001000 x1110000101
9659 * rt -----
9660 * rs -----
9661 * rd -----
9662 */
9663std::string NMD::LWXS_16_(uint64 instruction)
9664{
9665 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9666 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9667 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9668
9669 std::string rd3 = GPR(encode_gpr3(rd3_value));
9670 std::string rs3 = GPR(encode_gpr3(rs3_value));
9671 std::string rt3 = IMMEDIATE(encode_gpr3(rt3_value));
9672
9673 return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
9674}
9675
9676
9677/*
9678 *
9679 *
9680 * 3 2 1
9681 * 10987654321098765432109876543210
9682 * 001000 x1110000101
9683 * rt -----
9684 * rs -----
9685 * rd -----
9686 */
9687std::string NMD::LWXS_32_(uint64 instruction)
9688{
9689 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9690 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
9691 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9692
9693 std::string rd = GPR(copy(rd_value));
9694 std::string rs = GPR(copy(rs_value));
9695 std::string rt = GPR(copy(rt_value));
9696
9697 return img::format("LWXS %s, %s(%s)", rd, rs, rt);
9698}
9699
9700
9701/*
9702 *
9703 *
9704 * 3 2 1
9705 * 10987654321098765432109876543210
9706 * 001000 x1110000101
9707 * rt -----
9708 * rs -----
9709 * rd -----
9710 */
9711std::string NMD::MADD_DSP_(uint64 instruction)
9712{
9713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9714 uint64 ac_value = extract_ac_13_12(instruction);
9715 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9716
9717 std::string ac = AC(copy(ac_value));
9718 std::string rs = GPR(copy(rs_value));
9719 std::string rt = GPR(copy(rt_value));
9720
9721 return img::format("MADD %s, %s, %s", ac, rs, rt);
9722}
9723
9724
9725/*
9726 *
9727 *
9728 * 3 2 1
9729 * 10987654321098765432109876543210
9730 * 001000 x1110000101
9731 * rt -----
9732 * rs -----
9733 * rd -----
9734 */
9735std::string NMD::MADDF_D(uint64 instruction)
9736{
9737 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9738 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9739 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9740
9741 std::string fd = FPR(copy(fd_value));
9742 std::string fs = FPR(copy(fs_value));
9743 std::string ft = FPR(copy(ft_value));
9744
9745 return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
9746}
9747
9748
9749/*
9750 *
9751 *
9752 * 3 2 1
9753 * 10987654321098765432109876543210
9754 * 001000 x1110000101
9755 * rt -----
9756 * rs -----
9757 * rd -----
9758 */
9759std::string NMD::MADDF_S(uint64 instruction)
9760{
9761 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9762 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9763 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9764
9765 std::string fd = FPR(copy(fd_value));
9766 std::string fs = FPR(copy(fs_value));
9767 std::string ft = FPR(copy(ft_value));
9768
9769 return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
9770}
9771
9772
9773/*
9774 *
9775 *
9776 * 3 2 1
9777 * 10987654321098765432109876543210
9778 * 001000 x1110000101
9779 * rt -----
9780 * rs -----
9781 * rd -----
9782 */
9783std::string NMD::MADDU_DSP_(uint64 instruction)
9784{
9785 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9786 uint64 ac_value = extract_ac_13_12(instruction);
9787 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9788
9789 std::string ac = AC(copy(ac_value));
9790 std::string rs = GPR(copy(rs_value));
9791 std::string rt = GPR(copy(rt_value));
9792
9793 return img::format("MADDU %s, %s, %s", ac, rs, rt);
9794}
9795
9796
9797/*
9798 *
9799 *
9800 * 3 2 1
9801 * 10987654321098765432109876543210
9802 * 001000 x1110000101
9803 * rt -----
9804 * rs -----
9805 * rd -----
9806 */
9807std::string NMD::MAQ_S_W_PHL(uint64 instruction)
9808{
9809 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9810 uint64 ac_value = extract_ac_13_12(instruction);
9811 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9812
9813 std::string ac = AC(copy(ac_value));
9814 std::string rs = GPR(copy(rs_value));
9815 std::string rt = GPR(copy(rt_value));
9816
9817 return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9818}
9819
9820
9821/*
9822 *
9823 *
9824 * 3 2 1
9825 * 10987654321098765432109876543210
9826 * 001000 x1110000101
9827 * rt -----
9828 * rs -----
9829 * rd -----
9830 */
9831std::string NMD::MAQ_S_W_PHR(uint64 instruction)
9832{
9833 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9834 uint64 ac_value = extract_ac_13_12(instruction);
9835 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9836
9837 std::string ac = AC(copy(ac_value));
9838 std::string rs = GPR(copy(rs_value));
9839 std::string rt = GPR(copy(rt_value));
9840
9841 return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9842}
9843
9844
9845/*
9846 *
9847 *
9848 * 3 2 1
9849 * 10987654321098765432109876543210
9850 * 001000 x1110000101
9851 * rt -----
9852 * rs -----
9853 * rd -----
9854 */
9855std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
9856{
9857 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9858 uint64 ac_value = extract_ac_13_12(instruction);
9859 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9860
9861 std::string ac = AC(copy(ac_value));
9862 std::string rs = GPR(copy(rs_value));
9863 std::string rt = GPR(copy(rt_value));
9864
9865 return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9866}
9867
9868
9869/*
9870 *
9871 *
9872 * 3 2 1
9873 * 10987654321098765432109876543210
9874 * 001000 x1110000101
9875 * rt -----
9876 * rs -----
9877 * rd -----
9878 */
9879std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
9880{
9881 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9882 uint64 ac_value = extract_ac_13_12(instruction);
9883 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9884
9885 std::string ac = AC(copy(ac_value));
9886 std::string rs = GPR(copy(rs_value));
9887 std::string rt = GPR(copy(rt_value));
9888
9889 return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9890}
9891
9892
9893/*
9894 *
9895 *
9896 * 3 2 1
9897 * 10987654321098765432109876543210
9898 * 001000 x1110000101
9899 * rt -----
9900 * rs -----
9901 * rd -----
9902 */
9903std::string NMD::MAX_D(uint64 instruction)
9904{
9905 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9906 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9907 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9908
9909 std::string fd = FPR(copy(fd_value));
9910 std::string fs = FPR(copy(fs_value));
9911 std::string ft = FPR(copy(ft_value));
9912
9913 return img::format("MAX.D %s, %s, %s", fd, fs, ft);
9914}
9915
9916
9917/*
9918 *
9919 *
9920 * 3 2 1
9921 * 10987654321098765432109876543210
9922 * 001000 x1110000101
9923 * rt -----
9924 * rs -----
9925 * rd -----
9926 */
9927std::string NMD::MAX_S(uint64 instruction)
9928{
9929 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9930 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9931 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9932
9933 std::string fd = FPR(copy(fd_value));
9934 std::string fs = FPR(copy(fs_value));
9935 std::string ft = FPR(copy(ft_value));
9936
9937 return img::format("MAX.S %s, %s, %s", fd, fs, ft);
9938}
9939
9940
9941/*
9942 *
9943 *
9944 * 3 2 1
9945 * 10987654321098765432109876543210
9946 * 001000 x1110000101
9947 * rt -----
9948 * rs -----
9949 * rd -----
9950 */
9951std::string NMD::MAXA_D(uint64 instruction)
9952{
9953 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9954 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9955 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9956
9957 std::string fd = FPR(copy(fd_value));
9958 std::string fs = FPR(copy(fs_value));
9959 std::string ft = FPR(copy(ft_value));
9960
9961 return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
9962}
9963
9964
9965/*
9966 *
9967 *
9968 * 3 2 1
9969 * 10987654321098765432109876543210
9970 * 001000 x1110000101
9971 * rt -----
9972 * rs -----
9973 * rd -----
9974 */
9975std::string NMD::MAXA_S(uint64 instruction)
9976{
9977 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
9978 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
9979 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
9980
9981 std::string fd = FPR(copy(fd_value));
9982 std::string fs = FPR(copy(fs_value));
9983 std::string ft = FPR(copy(ft_value));
9984
9985 return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
9986}
9987
9988
9989/*
9990 *
9991 *
9992 * 3 2 1
9993 * 10987654321098765432109876543210
9994 * 001000 x1110000101
9995 * rt -----
9996 * rs -----
9997 * rd -----
9998 */
9999std::string NMD::MFC0(uint64 instruction)
10000{
10001 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10002 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10003 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10004
10005 std::string rt = GPR(copy(rt_value));
10006 std::string c0s = CPR(copy(c0s_value));
10007 std::string sel = IMMEDIATE(copy(sel_value));
10008
10009 return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
10010}
10011
10012
10013/*
10014 *
10015 *
10016 * 3 2 1
10017 * 10987654321098765432109876543210
10018 * 001000 x1110000101
10019 * rt -----
10020 * rs -----
10021 * rd -----
10022 */
10023std::string NMD::MFC1(uint64 instruction)
10024{
10025 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10026 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10027
10028 std::string rt = GPR(copy(rt_value));
10029 std::string fs = FPR(copy(fs_value));
10030
10031 return img::format("MFC1 %s, %s", rt, fs);
10032}
10033
10034
10035/*
10036 *
10037 *
10038 * 3 2 1
10039 * 10987654321098765432109876543210
10040 * 001000 x1110000101
10041 * rt -----
10042 * rs -----
10043 * rd -----
10044 */
10045std::string NMD::MFC2(uint64 instruction)
10046{
10047 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10048 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10049
10050 std::string rt = GPR(copy(rt_value));
10051 std::string cs = CPR(copy(cs_value));
10052
10053 return img::format("MFC2 %s, %s", rt, cs);
10054}
10055
10056
10057/*
10058 *
10059 *
10060 * 3 2 1
10061 * 10987654321098765432109876543210
10062 * 001000 x1110000101
10063 * rt -----
10064 * rs -----
10065 * rd -----
10066 */
10067std::string NMD::MFGC0(uint64 instruction)
10068{
10069 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10070 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10071 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10072
10073 std::string rt = GPR(copy(rt_value));
10074 std::string c0s = CPR(copy(c0s_value));
10075 std::string sel = IMMEDIATE(copy(sel_value));
10076
10077 return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
10078}
10079
10080
10081/*
10082 *
10083 *
10084 * 3 2 1
10085 * 10987654321098765432109876543210
10086 * 001000 x1110000101
10087 * rt -----
10088 * rs -----
10089 * rd -----
10090 */
10091std::string NMD::MFHC0(uint64 instruction)
10092{
10093 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10094 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10095 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10096
10097 std::string rt = GPR(copy(rt_value));
10098 std::string c0s = CPR(copy(c0s_value));
10099 std::string sel = IMMEDIATE(copy(sel_value));
10100
10101 return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
10102}
10103
10104
10105/*
10106 *
10107 *
10108 * 3 2 1
10109 * 10987654321098765432109876543210
10110 * 001000 x1110000101
10111 * rt -----
10112 * rs -----
10113 * rd -----
10114 */
10115std::string NMD::MFHC1(uint64 instruction)
10116{
10117 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10118 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10119
10120 std::string rt = GPR(copy(rt_value));
10121 std::string fs = FPR(copy(fs_value));
10122
10123 return img::format("MFHC1 %s, %s", rt, fs);
10124}
10125
10126
10127/*
10128 *
10129 *
10130 * 3 2 1
10131 * 10987654321098765432109876543210
10132 * 001000 x1110000101
10133 * rt -----
10134 * rs -----
10135 * rd -----
10136 */
10137std::string NMD::MFHC2(uint64 instruction)
10138{
10139 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10141
10142 std::string rt = GPR(copy(rt_value));
10143 std::string cs = CPR(copy(cs_value));
10144
10145 return img::format("MFHC2 %s, %s", rt, cs);
10146}
10147
10148
10149/*
10150 *
10151 *
10152 * 3 2 1
10153 * 10987654321098765432109876543210
10154 * 001000 x1110000101
10155 * rt -----
10156 * rs -----
10157 * rd -----
10158 */
10159std::string NMD::MFHGC0(uint64 instruction)
10160{
10161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10162 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10163 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10164
10165 std::string rt = GPR(copy(rt_value));
10166 std::string c0s = CPR(copy(c0s_value));
10167 std::string sel = IMMEDIATE(copy(sel_value));
10168
10169 return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
10170}
10171
10172
10173/*
10174 *
10175 *
10176 * 3 2 1
10177 * 10987654321098765432109876543210
10178 * 001000 x1110000101
10179 * rt -----
10180 * rs -----
10181 * rd -----
10182 */
10183std::string NMD::MFHI_DSP_(uint64 instruction)
10184{
10185 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10186 uint64 ac_value = extract_ac_13_12(instruction);
10187
10188 std::string rt = GPR(copy(rt_value));
10189 std::string ac = AC(copy(ac_value));
10190
10191 return img::format("MFHI %s, %s", rt, ac);
10192}
10193
10194
10195/*
10196 *
10197 *
10198 * 3 2 1
10199 * 10987654321098765432109876543210
10200 * 001000 x1110000101
10201 * rt -----
10202 * rs -----
10203 * rd -----
10204 */
10205std::string NMD::MFHTR(uint64 instruction)
10206{
10207 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10208 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10209 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10210 uint64 u_value = extract_u_10(instruction);
10211
10212 std::string rt = GPR(copy(rt_value));
10213 std::string c0s = IMMEDIATE(copy(c0s_value));
10214 std::string u = IMMEDIATE(copy(u_value));
10215 std::string sel = IMMEDIATE(copy(sel_value));
10216
10217 return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
10218}
10219
10220
10221/*
10222 *
10223 *
10224 * 3 2 1
10225 * 10987654321098765432109876543210
10226 * 001000 x1110000101
10227 * rt -----
10228 * rs -----
10229 * rd -----
10230 */
10231std::string NMD::MFLO_DSP_(uint64 instruction)
10232{
10233 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10234 uint64 ac_value = extract_ac_13_12(instruction);
10235
10236 std::string rt = GPR(copy(rt_value));
10237 std::string ac = AC(copy(ac_value));
10238
10239 return img::format("MFLO %s, %s", rt, ac);
10240}
10241
10242
10243/*
10244 *
10245 *
10246 * 3 2 1
10247 * 10987654321098765432109876543210
10248 * 001000 x1110000101
10249 * rt -----
10250 * rs -----
10251 * rd -----
10252 */
10253std::string NMD::MFTR(uint64 instruction)
10254{
10255 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10256 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10257 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10258 uint64 u_value = extract_u_10(instruction);
10259
10260 std::string rt = GPR(copy(rt_value));
10261 std::string c0s = IMMEDIATE(copy(c0s_value));
10262 std::string u = IMMEDIATE(copy(u_value));
10263 std::string sel = IMMEDIATE(copy(sel_value));
10264
10265 return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
10266}
10267
10268
10269/*
10270 *
10271 *
10272 * 3 2 1
10273 * 10987654321098765432109876543210
10274 * 001000 x1110000101
10275 * rt -----
10276 * rs -----
10277 * rd -----
10278 */
10279std::string NMD::MIN_D(uint64 instruction)
10280{
10281 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10282 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10283 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10284
10285 std::string fd = FPR(copy(fd_value));
10286 std::string fs = FPR(copy(fs_value));
10287 std::string ft = FPR(copy(ft_value));
10288
10289 return img::format("MIN.D %s, %s, %s", fd, fs, ft);
10290}
10291
10292
10293/*
10294 *
10295 *
10296 * 3 2 1
10297 * 10987654321098765432109876543210
10298 * 001000 x1110000101
10299 * rt -----
10300 * rs -----
10301 * rd -----
10302 */
10303std::string NMD::MIN_S(uint64 instruction)
10304{
10305 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10306 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10307 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10308
10309 std::string fd = FPR(copy(fd_value));
10310 std::string fs = FPR(copy(fs_value));
10311 std::string ft = FPR(copy(ft_value));
10312
10313 return img::format("MIN.S %s, %s, %s", fd, fs, ft);
10314}
10315
10316
10317/*
10318 *
10319 *
10320 * 3 2 1
10321 * 10987654321098765432109876543210
10322 * 001000 x1110000101
10323 * rt -----
10324 * rs -----
10325 * rd -----
10326 */
10327std::string NMD::MINA_D(uint64 instruction)
10328{
10329 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10330 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10331 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10332
10333 std::string fd = FPR(copy(fd_value));
10334 std::string fs = FPR(copy(fs_value));
10335 std::string ft = FPR(copy(ft_value));
10336
10337 return img::format("MINA.D %s, %s, %s", fd, fs, ft);
10338}
10339
10340
10341/*
10342 *
10343 *
10344 * 3 2 1
10345 * 10987654321098765432109876543210
10346 * 001000 x1110000101
10347 * rt -----
10348 * rs -----
10349 * rd -----
10350 */
10351std::string NMD::MINA_S(uint64 instruction)
10352{
10353 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10354 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10355 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10356
10357 std::string fd = FPR(copy(fd_value));
10358 std::string fs = FPR(copy(fs_value));
10359 std::string ft = FPR(copy(ft_value));
10360
10361 return img::format("MINA.S %s, %s, %s", fd, fs, ft);
10362}
10363
10364
10365/*
10366 *
10367 *
10368 * 3 2 1
10369 * 10987654321098765432109876543210
10370 * 001000 x1110000101
10371 * rt -----
10372 * rs -----
10373 * rd -----
10374 */
10375std::string NMD::MOD(uint64 instruction)
10376{
10377 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10378 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10379 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10380
10381 std::string rd = GPR(copy(rd_value));
10382 std::string rs = GPR(copy(rs_value));
10383 std::string rt = GPR(copy(rt_value));
10384
10385 return img::format("MOD %s, %s, %s", rd, rs, rt);
10386}
10387
10388
10389/*
10390 *
10391 *
10392 * 3 2 1
10393 * 10987654321098765432109876543210
10394 * 001000 x1110000101
10395 * rt -----
10396 * rs -----
10397 * rd -----
10398 */
10399std::string NMD::MODSUB(uint64 instruction)
10400{
10401 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10402 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10403 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10404
10405 std::string rd = GPR(copy(rd_value));
10406 std::string rs = GPR(copy(rs_value));
10407 std::string rt = GPR(copy(rt_value));
10408
10409 return img::format("MODSUB %s, %s, %s", rd, rs, rt);
10410}
10411
10412
10413/*
10414 *
10415 *
10416 * 3 2 1
10417 * 10987654321098765432109876543210
10418 * 001000 x1110000101
10419 * rt -----
10420 * rs -----
10421 * rd -----
10422 */
10423std::string NMD::MODU(uint64 instruction)
10424{
10425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10426 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10427 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10428
10429 std::string rd = GPR(copy(rd_value));
10430 std::string rs = GPR(copy(rs_value));
10431 std::string rt = GPR(copy(rt_value));
10432
10433 return img::format("MODU %s, %s, %s", rd, rs, rt);
10434}
10435
10436
10437/*
10438 *
10439 *
10440 * 3 2 1
10441 * 10987654321098765432109876543210
10442 * 001000 x1110000101
10443 * rt -----
10444 * rs -----
10445 * rd -----
10446 */
10447std::string NMD::MOV_D(uint64 instruction)
10448{
10449 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10450 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10451
10452 std::string ft = FPR(copy(ft_value));
10453 std::string fs = FPR(copy(fs_value));
10454
10455 return img::format("MOV.D %s, %s", ft, fs);
10456}
10457
10458
10459/*
10460 *
10461 *
10462 * 3 2 1
10463 * 10987654321098765432109876543210
10464 * 001000 x1110000101
10465 * rt -----
10466 * rs -----
10467 * rd -----
10468 */
10469std::string NMD::MOV_S(uint64 instruction)
10470{
10471 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10472 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10473
10474 std::string ft = FPR(copy(ft_value));
10475 std::string fs = FPR(copy(fs_value));
10476
10477 return img::format("MOV.S %s, %s", ft, fs);
10478}
10479
10480
10481/*
10482 *
10483 *
10484 * 3 2 1
10485 * 10987654321098765432109876543210
10486 * 001000 x1110000101
10487 * rt -----
10488 * rs -----
10489 * rd -----
10490 */
10491std::string NMD::MOVE_BALC(uint64 instruction)
10492{
10493 uint64 rd1_value = extract_rdl_25_24(instruction);
10494 int64 s_value = extr_sil0il21bs1_il1il1bs20Tmsb21(instruction);
10495 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10496
10497 std::string rd1 = GPR(encode_rd1_from_rd(rd1_value));
10498 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10499 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
10500
10501 return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10502}
10503
10504
10505/*
10506 *
10507 *
10508 * 3 2 1
10509 * 10987654321098765432109876543210
10510 * 001000 x1110000101
10511 * rt -----
10512 * rs -----
10513 * rd -----
10514 */
10515std::string NMD::MOVEP(uint64 instruction)
10516{
10517 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10518 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10519 uint64 rd2_value = extract_rd2_3_8(instruction);
10520
10521 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10522 std::string re2 = GPR(encode_rd2_reg2(rd2_value));
10523 /* !!!!!!!!!! - no conversion function */
10524 std::string rsz4 = GPR(encode_gpr4_zero(rsz4_value));
10525 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10526
10527 return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10528 /* hand edited */
10529}
10530
10531
10532/*
10533 *
10534 *
10535 * 3 2 1
10536 * 10987654321098765432109876543210
10537 * 001000 x1110000101
10538 * rt -----
10539 * rs -----
10540 * rd -----
10541 */
10542std::string NMD::MOVEP_REV_(uint64 instruction)
10543{
10544 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10545 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10546 uint64 rd2_value = extract_rd2_3_8(instruction);
10547
10548 std::string rs4 = GPR(encode_gpr4(rs4_value));
10549 std::string rt4 = GPR(encode_gpr4(rt4_value));
10550 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10551 std::string rs2 = GPR(encode_rd2_reg2(rd2_value));
10552 /* !!!!!!!!!! - no conversion function */
10553
10554 return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10555 /* hand edited */
10556}
10557
10558
10559/*
10560 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10561 *
10562 * 3 2 1
10563 * 10987654321098765432109876543210
10564 * 001000 00010001101
10565 * rt -----
10566 * rs -----
10567 * rd -----
10568 */
10569std::string NMD::MOVE(uint64 instruction)
10570{
10571 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10572 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10573
10574 std::string rt = GPR(copy(rt_value));
10575 std::string rs = GPR(copy(rs_value));
10576
10577 return img::format("MOVE %s, %s", rt, rs);
10578}
10579
10580
10581/*
10582 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10583 *
10584 * 3 2 1
10585 * 10987654321098765432109876543210
10586 * 001000 00010001101
10587 * rt -----
10588 * rs -----
10589 * rd -----
10590 */
10591std::string NMD::MOVN(uint64 instruction)
10592{
10593 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10594 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10595 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10596
10597 std::string rd = GPR(copy(rd_value));
10598 std::string rs = GPR(copy(rs_value));
10599 std::string rt = GPR(copy(rt_value));
10600
10601 return img::format("MOVN %s, %s, %s", rd, rs, rt);
10602}
10603
10604
10605/*
10606 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10607 *
10608 * 3 2 1
10609 * 10987654321098765432109876543210
10610 * 001000 00010001101
10611 * rt -----
10612 * rs -----
10613 * rd -----
10614 */
10615std::string NMD::MOVZ(uint64 instruction)
10616{
10617 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10618 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
10619 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10620
10621 std::string rd = GPR(copy(rd_value));
10622 std::string rs = GPR(copy(rs_value));
10623 std::string rt = GPR(copy(rt_value));
10624
10625 return img::format("MOVZ %s, %s, %s", rd, rs, rt);
10626}
10627
10628
10629/*
10630 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10631 *
10632 * 3 2 1
10633 * 10987654321098765432109876543210
10634 * 001000 00010001101
10635 * rt -----
10636 * rs -----
10637 * rd -----
10638 */
10639std::string NMD::MSUB_DSP_(uint64 instruction)
10640{
10641 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10642 uint64 ac_value = extract_ac_13_12(instruction);
10643 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10644
10645 std::string ac = AC(copy(ac_value));
10646 std::string rs = GPR(copy(rs_value));
10647 std::string rt = GPR(copy(rt_value));
10648
10649 return img::format("MSUB %s, %s, %s", ac, rs, rt);
10650}
10651
10652
10653/*
10654 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10655 *
10656 * 3 2 1
10657 * 10987654321098765432109876543210
10658 * 001000 00010001101
10659 * rt -----
10660 * rs -----
10661 * rd -----
10662 */
10663std::string NMD::MSUBF_D(uint64 instruction)
10664{
10665 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10666 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10667 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10668
10669 std::string fd = FPR(copy(fd_value));
10670 std::string fs = FPR(copy(fs_value));
10671 std::string ft = FPR(copy(ft_value));
10672
10673 return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
10674}
10675
10676
10677/*
10678 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10679 *
10680 * 3 2 1
10681 * 10987654321098765432109876543210
10682 * 001000 00010001101
10683 * rt -----
10684 * rs -----
10685 * rd -----
10686 */
10687std::string NMD::MSUBF_S(uint64 instruction)
10688{
10689 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10690 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
10691 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
10692
10693 std::string fd = FPR(copy(fd_value));
10694 std::string fs = FPR(copy(fs_value));
10695 std::string ft = FPR(copy(ft_value));
10696
10697 return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
10698}
10699
10700
10701/*
10702 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10703 *
10704 * 3 2 1
10705 * 10987654321098765432109876543210
10706 * 001000 00010001101
10707 * rt -----
10708 * rs -----
10709 * rd -----
10710 */
10711std::string NMD::MSUBU_DSP_(uint64 instruction)
10712{
10713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10714 uint64 ac_value = extract_ac_13_12(instruction);
10715 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10716
10717 std::string ac = AC(copy(ac_value));
10718 std::string rs = GPR(copy(rs_value));
10719 std::string rt = GPR(copy(rt_value));
10720
10721 return img::format("MSUBU %s, %s, %s", ac, rs, rt);
10722}
10723
10724
10725/*
10726 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10727 *
10728 * 3 2 1
10729 * 10987654321098765432109876543210
10730 * 001000 00010001101
10731 * rt -----
10732 * rs -----
10733 * rd -----
10734 */
10735std::string NMD::MTC0(uint64 instruction)
10736{
10737 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10738 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10739 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10740
10741 std::string rt = GPR(copy(rt_value));
10742 std::string c0s = CPR(copy(c0s_value));
10743 std::string sel = IMMEDIATE(copy(sel_value));
10744
10745 return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
10746}
10747
10748
10749/*
10750 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10751 *
10752 * 3 2 1
10753 * 10987654321098765432109876543210
10754 * 001000 00010001101
10755 * rt -----
10756 * rs -----
10757 * rd -----
10758 */
10759std::string NMD::MTC1(uint64 instruction)
10760{
10761 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10762 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10763
10764 std::string rt = GPR(copy(rt_value));
10765 std::string fs = FPR(copy(fs_value));
10766
10767 return img::format("MTC1 %s, %s", rt, fs);
10768}
10769
10770
10771/*
10772 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10773 *
10774 * 3 2 1
10775 * 10987654321098765432109876543210
10776 * 001000 00010001101
10777 * rt -----
10778 * rs -----
10779 * rd -----
10780 */
10781std::string NMD::MTC2(uint64 instruction)
10782{
10783 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10784 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10785
10786 std::string rt = GPR(copy(rt_value));
10787 std::string cs = CPR(copy(cs_value));
10788
10789 return img::format("MTC2 %s, %s", rt, cs);
10790}
10791
10792
10793/*
10794 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10795 *
10796 * 3 2 1
10797 * 10987654321098765432109876543210
10798 * 001000 00010001101
10799 * rt -----
10800 * rs -----
10801 * rd -----
10802 */
10803std::string NMD::MTGC0(uint64 instruction)
10804{
10805 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10806 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10807 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10808
10809 std::string rt = GPR(copy(rt_value));
10810 std::string c0s = CPR(copy(c0s_value));
10811 std::string sel = IMMEDIATE(copy(sel_value));
10812
10813 return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
10814}
10815
10816
10817/*
10818 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10819 *
10820 * 3 2 1
10821 * 10987654321098765432109876543210
10822 * 001000 00010001101
10823 * rt -----
10824 * rs -----
10825 * rd -----
10826 */
10827std::string NMD::MTHC0(uint64 instruction)
10828{
10829 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10830 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10831 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10832
10833 std::string rt = GPR(copy(rt_value));
10834 std::string c0s = CPR(copy(c0s_value));
10835 std::string sel = IMMEDIATE(copy(sel_value));
10836
10837 return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
10838}
10839
10840
10841/*
10842 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10843 *
10844 * 3 2 1
10845 * 10987654321098765432109876543210
10846 * 001000 00010001101
10847 * rt -----
10848 * rs -----
10849 * rd -----
10850 */
10851std::string NMD::MTHC1(uint64 instruction)
10852{
10853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10854 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
10855
10856 std::string rt = GPR(copy(rt_value));
10857 std::string fs = FPR(copy(fs_value));
10858
10859 return img::format("MTHC1 %s, %s", rt, fs);
10860}
10861
10862
10863/*
10864 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10865 *
10866 * 3 2 1
10867 * 10987654321098765432109876543210
10868 * 001000 00010001101
10869 * rt -----
10870 * rs -----
10871 * rd -----
10872 */
10873std::string NMD::MTHC2(uint64 instruction)
10874{
10875 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10876 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10877
10878 std::string rt = GPR(copy(rt_value));
10879 std::string cs = CPR(copy(cs_value));
10880
10881 return img::format("MTHC2 %s, %s", rt, cs);
10882}
10883
10884
10885/*
10886 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10887 *
10888 * 3 2 1
10889 * 10987654321098765432109876543210
10890 * 001000 00010001101
10891 * rt -----
10892 * rs -----
10893 * rd -----
10894 */
10895std::string NMD::MTHGC0(uint64 instruction)
10896{
10897 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10898 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10899 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10900
10901 std::string rt = GPR(copy(rt_value));
10902 std::string c0s = CPR(copy(c0s_value));
10903 std::string sel = IMMEDIATE(copy(sel_value));
10904
10905 return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
10906}
10907
10908
10909/*
10910 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10911 *
10912 * 3 2 1
10913 * 10987654321098765432109876543210
10914 * 001000 00010001101
10915 * rt -----
10916 * rs -----
10917 * rd -----
10918 */
10919std::string NMD::MTHI_DSP_(uint64 instruction)
10920{
10921 uint64 ac_value = extract_ac_13_12(instruction);
10922 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10923
10924 std::string rs = GPR(copy(rs_value));
10925 std::string ac = AC(copy(ac_value));
10926
10927 return img::format("MTHI %s, %s", rs, ac);
10928}
10929
10930
10931/*
10932 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10933 *
10934 * 3 2 1
10935 * 10987654321098765432109876543210
10936 * 001000 00010001101
10937 * rt -----
10938 * rs -----
10939 * rd -----
10940 */
10941std::string NMD::MTHLIP(uint64 instruction)
10942{
10943 uint64 ac_value = extract_ac_13_12(instruction);
10944 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10945
10946 std::string rs = GPR(copy(rs_value));
10947 std::string ac = AC(copy(ac_value));
10948
10949 return img::format("MTHLIP %s, %s", rs, ac);
10950}
10951
10952
10953/*
10954 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10955 *
10956 * 3 2 1
10957 * 10987654321098765432109876543210
10958 * 001000 00010001101
10959 * rt -----
10960 * rs -----
10961 * rd -----
10962 */
10963std::string NMD::MTHTR(uint64 instruction)
10964{
10965 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10966 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10967 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10968 uint64 u_value = extract_u_10(instruction);
10969
10970 std::string rt = GPR(copy(rt_value));
10971 std::string c0s = IMMEDIATE(copy(c0s_value));
10972 std::string u = IMMEDIATE(copy(u_value));
10973 std::string sel = IMMEDIATE(copy(sel_value));
10974
10975 return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
10976}
10977
10978
10979/*
10980 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10981 *
10982 * 3 2 1
10983 * 10987654321098765432109876543210
10984 * 001000 00010001101
10985 * rt -----
10986 * rs -----
10987 * rd -----
10988 */
10989std::string NMD::MTLO_DSP_(uint64 instruction)
10990{
10991 uint64 ac_value = extract_ac_13_12(instruction);
10992 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10993
10994 std::string rs = GPR(copy(rs_value));
10995 std::string ac = AC(copy(ac_value));
10996
10997 return img::format("MTLO %s, %s", rs, ac);
10998}
10999
11000
11001/*
11002 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11003 *
11004 * 3 2 1
11005 * 10987654321098765432109876543210
11006 * 001000 00010001101
11007 * rt -----
11008 * rs -----
11009 * rd -----
11010 */
11011std::string NMD::MTTR(uint64 instruction)
11012{
11013 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11014 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
11015 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
11016 uint64 u_value = extract_u_10(instruction);
11017
11018 std::string rt = GPR(copy(rt_value));
11019 std::string c0s = IMMEDIATE(copy(c0s_value));
11020 std::string u = IMMEDIATE(copy(u_value));
11021 std::string sel = IMMEDIATE(copy(sel_value));
11022
11023 return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
11024}
11025
11026
11027/*
11028 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11029 *
11030 * 3 2 1
11031 * 10987654321098765432109876543210
11032 * 001000 00010001101
11033 * rt -----
11034 * rs -----
11035 * rd -----
11036 */
11037std::string NMD::MUH(uint64 instruction)
11038{
11039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11040 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11041 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11042
11043 std::string rd = GPR(copy(rd_value));
11044 std::string rs = GPR(copy(rs_value));
11045 std::string rt = GPR(copy(rt_value));
11046
11047 return img::format("MUH %s, %s, %s", rd, rs, rt);
11048}
11049
11050
11051/*
11052 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11053 *
11054 * 3 2 1
11055 * 10987654321098765432109876543210
11056 * 001000 00010001101
11057 * rt -----
11058 * rs -----
11059 * rd -----
11060 */
11061std::string NMD::MUHU(uint64 instruction)
11062{
11063 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11064 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11065 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11066
11067 std::string rd = GPR(copy(rd_value));
11068 std::string rs = GPR(copy(rs_value));
11069 std::string rt = GPR(copy(rt_value));
11070
11071 return img::format("MUHU %s, %s, %s", rd, rs, rt);
11072}
11073
11074
11075/*
11076 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11077 *
11078 * 3 2 1
11079 * 10987654321098765432109876543210
11080 * 001000 00010001101
11081 * rt -----
11082 * rs -----
11083 * rd -----
11084 */
11085std::string NMD::MUL_32_(uint64 instruction)
11086{
11087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11088 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11089 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11090
11091 std::string rd = GPR(copy(rd_value));
11092 std::string rs = GPR(copy(rs_value));
11093 std::string rt = GPR(copy(rt_value));
11094
11095 return img::format("MUL %s, %s, %s", rd, rs, rt);
11096}
11097
11098
11099/*
11100 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11101 *
11102 * 3 2 1
11103 * 10987654321098765432109876543210
11104 * 001000 00010001101
11105 * rt -----
11106 * rs -----
11107 * rd -----
11108 */
11109std::string NMD::MUL_4X4_(uint64 instruction)
11110{
11111 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11112 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
11113
11114 std::string rs4 = GPR(encode_gpr4(rs4_value));
11115 std::string rt4 = GPR(encode_gpr4(rt4_value));
11116
11117 return img::format("MUL %s, %s", rs4, rt4);
11118}
11119
11120
11121/*
11122 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11123 *
11124 * 3 2 1
11125 * 10987654321098765432109876543210
11126 * 001000 00010001101
11127 * rt -----
11128 * rs -----
11129 * rd -----
11130 */
11131std::string NMD::MUL_D(uint64 instruction)
11132{
11133 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11134 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11135 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
11136
11137 std::string fd = FPR(copy(fd_value));
11138 std::string fs = FPR(copy(fs_value));
11139 std::string ft = FPR(copy(ft_value));
11140
11141 return img::format("MUL.D %s, %s, %s", fd, fs, ft);
11142}
11143
11144
11145/*
11146 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11147 *
11148 * 3 2 1
11149 * 10987654321098765432109876543210
11150 * 001000 00010001101
11151 * rt -----
11152 * rs -----
11153 * rd -----
11154 */
11155std::string NMD::MUL_PH(uint64 instruction)
11156{
11157 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11158 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11159 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11160
11161 std::string rd = GPR(copy(rd_value));
11162 std::string rs = GPR(copy(rs_value));
11163 std::string rt = GPR(copy(rt_value));
11164
11165 return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
11166}
11167
11168
11169/*
11170 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11171 *
11172 * 3 2 1
11173 * 10987654321098765432109876543210
11174 * 001000 00010001101
11175 * rt -----
11176 * rs -----
11177 * rd -----
11178 */
11179std::string NMD::MUL_S_PH(uint64 instruction)
11180{
11181 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11182 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11183 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11184
11185 std::string rd = GPR(copy(rd_value));
11186 std::string rs = GPR(copy(rs_value));
11187 std::string rt = GPR(copy(rt_value));
11188
11189 return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
11190}
11191
11192
11193/*
11194 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11195 *
11196 * 3 2 1
11197 * 10987654321098765432109876543210
11198 * 001000 00010001101
11199 * rt -----
11200 * rs -----
11201 * rd -----
11202 */
11203std::string NMD::MUL_S(uint64 instruction)
11204{
11205 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11206 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11207 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
11208
11209 std::string fd = FPR(copy(fd_value));
11210 std::string fs = FPR(copy(fs_value));
11211 std::string ft = FPR(copy(ft_value));
11212
11213 return img::format("MUL.S %s, %s, %s", fd, fs, ft);
11214}
11215
11216
11217/*
11218 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11219 *
11220 * 3 2 1
11221 * 10987654321098765432109876543210
11222 * 001000 00010001101
11223 * rt -----
11224 * rs -----
11225 * rd -----
11226 */
11227std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
11228{
11229 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11230 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11231 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11232
11233 std::string rd = GPR(copy(rd_value));
11234 std::string rs = GPR(copy(rs_value));
11235 std::string rt = GPR(copy(rt_value));
11236
11237 return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
11238}
11239
11240
11241/*
11242 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11243 *
11244 * 3 2 1
11245 * 10987654321098765432109876543210
11246 * 001000 00010001101
11247 * rt -----
11248 * rs -----
11249 * rd -----
11250 */
11251std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
11252{
11253 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11254 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11255 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11256
11257 std::string rd = GPR(copy(rd_value));
11258 std::string rs = GPR(copy(rs_value));
11259 std::string rt = GPR(copy(rt_value));
11260
11261 return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
11262}
11263
11264
11265/*
11266 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11267 *
11268 * 3 2 1
11269 * 10987654321098765432109876543210
11270 * 001000 00010001101
11271 * rt -----
11272 * rs -----
11273 * rd -----
11274 */
11275std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
11276{
11277 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11278 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11279 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11280
11281 std::string rd = GPR(copy(rd_value));
11282 std::string rs = GPR(copy(rs_value));
11283 std::string rt = GPR(copy(rt_value));
11284
11285 return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
11286}
11287
11288
11289/*
11290 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11291 *
11292 * 3 2 1
11293 * 10987654321098765432109876543210
11294 * 001000 00010001101
11295 * rt -----
11296 * rs -----
11297 * rd -----
11298 */
11299std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
11300{
11301 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11302 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11303 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11304
11305 std::string rd = GPR(copy(rd_value));
11306 std::string rs = GPR(copy(rs_value));
11307 std::string rt = GPR(copy(rt_value));
11308
11309 return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
11310}
11311
11312
11313/*
11314 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11315 *
11316 * 3 2 1
11317 * 10987654321098765432109876543210
11318 * 001000 00010001101
11319 * rt -----
11320 * rs -----
11321 * rd -----
11322 */
11323std::string NMD::MULQ_RS_PH(uint64 instruction)
11324{
11325 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11326 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11327 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11328
11329 std::string rd = GPR(copy(rd_value));
11330 std::string rs = GPR(copy(rs_value));
11331 std::string rt = GPR(copy(rt_value));
11332
11333 return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
11334}
11335
11336
11337/*
11338 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11339 *
11340 * 3 2 1
11341 * 10987654321098765432109876543210
11342 * 001000 00010001101
11343 * rt -----
11344 * rs -----
11345 * rd -----
11346 */
11347std::string NMD::MULQ_RS_W(uint64 instruction)
11348{
11349 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11350 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11351 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11352
11353 std::string rd = GPR(copy(rd_value));
11354 std::string rs = GPR(copy(rs_value));
11355 std::string rt = GPR(copy(rt_value));
11356
11357 return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
11358}
11359
11360
11361/*
11362 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11363 *
11364 * 3 2 1
11365 * 10987654321098765432109876543210
11366 * 001000 00010001101
11367 * rt -----
11368 * rs -----
11369 * rd -----
11370 */
11371std::string NMD::MULQ_S_PH(uint64 instruction)
11372{
11373 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11374 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11375 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11376
11377 std::string rd = GPR(copy(rd_value));
11378 std::string rs = GPR(copy(rs_value));
11379 std::string rt = GPR(copy(rt_value));
11380
11381 return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
11382}
11383
11384
11385/*
11386 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11387 *
11388 * 3 2 1
11389 * 10987654321098765432109876543210
11390 * 001000 00010001101
11391 * rt -----
11392 * rs -----
11393 * rd -----
11394 */
11395std::string NMD::MULQ_S_W(uint64 instruction)
11396{
11397 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11398 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11399 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11400
11401 std::string rd = GPR(copy(rd_value));
11402 std::string rs = GPR(copy(rs_value));
11403 std::string rt = GPR(copy(rt_value));
11404
11405 return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11406}
11407
11408
11409/*
11410 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11411 *
11412 * 3 2 1
11413 * 10987654321098765432109876543210
11414 * 001000 00010001101
11415 * rt -----
11416 * rs -----
11417 * rd -----
11418 */
11419std::string NMD::MULSA_W_PH(uint64 instruction)
11420{
11421 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11422 uint64 ac_value = extract_ac_13_12(instruction);
11423 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11424
11425 std::string ac = AC(copy(ac_value));
11426 std::string rs = GPR(copy(rs_value));
11427 std::string rt = GPR(copy(rt_value));
11428
11429 return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11430}
11431
11432
11433/*
11434 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11435 *
11436 * 3 2 1
11437 * 10987654321098765432109876543210
11438 * 001000 00010001101
11439 * rt -----
11440 * rs -----
11441 * rd -----
11442 */
11443std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
11444{
11445 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11446 uint64 ac_value = extract_ac_13_12(instruction);
11447 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11448
11449 std::string ac = AC(copy(ac_value));
11450 std::string rs = GPR(copy(rs_value));
11451 std::string rt = GPR(copy(rt_value));
11452
11453 return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11454}
11455
11456
11457/*
11458 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11459 *
11460 * 3 2 1
11461 * 10987654321098765432109876543210
11462 * 001000 00010001101
11463 * rt -----
11464 * rs -----
11465 * rd -----
11466 */
11467std::string NMD::MULT_DSP_(uint64 instruction)
11468{
11469 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11470 uint64 ac_value = extract_ac_13_12(instruction);
11471 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11472
11473 std::string ac = AC(copy(ac_value));
11474 std::string rs = GPR(copy(rs_value));
11475 std::string rt = GPR(copy(rt_value));
11476
11477 return img::format("MULT %s, %s, %s", ac, rs, rt);
11478}
11479
11480
11481/*
11482 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11483 *
11484 * 3 2 1
11485 * 10987654321098765432109876543210
11486 * 001000 00010001101
11487 * rt -----
11488 * rs -----
11489 * rd -----
11490 */
11491std::string NMD::MULTU_DSP_(uint64 instruction)
11492{
11493 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11494 uint64 ac_value = extract_ac_13_12(instruction);
11495 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11496
11497 std::string ac = AC(copy(ac_value));
11498 std::string rs = GPR(copy(rs_value));
11499 std::string rt = GPR(copy(rt_value));
11500
11501 return img::format("MULTU %s, %s, %s", ac, rs, rt);
11502}
11503
11504
11505/*
11506 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11507 *
11508 * 3 2 1
11509 * 10987654321098765432109876543210
11510 * 001000 00010001101
11511 * rt -----
11512 * rs -----
11513 * rd -----
11514 */
11515std::string NMD::MULU(uint64 instruction)
11516{
11517 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11518 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11519 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11520
11521 std::string rd = GPR(copy(rd_value));
11522 std::string rs = GPR(copy(rs_value));
11523 std::string rt = GPR(copy(rt_value));
11524
11525 return img::format("MULU %s, %s, %s", rd, rs, rt);
11526}
11527
11528
11529/*
11530 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11531 *
11532 * 3 2 1
11533 * 10987654321098765432109876543210
11534 * 001000 00010001101
11535 * rt -----
11536 * rs -----
11537 * rd -----
11538 */
11539std::string NMD::NEG_D(uint64 instruction)
11540{
11541 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11542 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11543
11544 std::string ft = FPR(copy(ft_value));
11545 std::string fs = FPR(copy(fs_value));
11546
11547 return img::format("NEG.D %s, %s", ft, fs);
11548}
11549
11550
11551/*
11552 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11553 *
11554 * 3 2 1
11555 * 10987654321098765432109876543210
11556 * 001000 00010001101
11557 * rt -----
11558 * rs -----
11559 * rd -----
11560 */
11561std::string NMD::NEG_S(uint64 instruction)
11562{
11563 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
11564 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
11565
11566 std::string ft = FPR(copy(ft_value));
11567 std::string fs = FPR(copy(fs_value));
11568
11569 return img::format("NEG.S %s, %s", ft, fs);
11570}
11571
11572
11573/*
11574 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11575 *
11576 * 3 2 1
11577 * 10987654321098765432109876543210
11578 * 001000 00010001101
11579 * rt -----
11580 * rs -----
11581 * rd -----
11582 */
11583std::string NMD::NOP_16_(uint64 instruction)
11584{
11585 (void)instruction;
11586
11587 return "NOP ";
11588}
11589
11590
11591/*
11592 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11593 *
11594 * 3 2 1
11595 * 10987654321098765432109876543210
11596 * 001000 00010001101
11597 * rt -----
11598 * rs -----
11599 * rd -----
11600 */
11601std::string NMD::NOP_32_(uint64 instruction)
11602{
11603 (void)instruction;
11604
11605 return "NOP ";
11606}
11607
11608
11609/*
11610 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11611 *
11612 * 3 2 1
11613 * 10987654321098765432109876543210
11614 * 001000 00010001101
11615 * rt -----
11616 * rs -----
11617 * rd -----
11618 */
11619std::string NMD::NOR(uint64 instruction)
11620{
11621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11622 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11624
11625 std::string rd = GPR(copy(rd_value));
11626 std::string rs = GPR(copy(rs_value));
11627 std::string rt = GPR(copy(rt_value));
11628
11629 return img::format("NOR %s, %s, %s", rd, rs, rt);
11630}
11631
11632
11633/*
11634 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11635 *
11636 * 3 2 1
11637 * 10987654321098765432109876543210
11638 * 001000 00010001101
11639 * rt -----
11640 * rs -----
11641 * rd -----
11642 */
11643std::string NMD::NOT_16_(uint64 instruction)
11644{
11645 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11646 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11647
11648 std::string rt3 = GPR(encode_gpr3(rt3_value));
11649 std::string rs3 = GPR(encode_gpr3(rs3_value));
11650
11651 return img::format("NOT %s, %s", rt3, rs3);
11652}
11653
11654
11655/*
11656 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11657 *
11658 * 3 2 1
11659 * 10987654321098765432109876543210
11660 * 001000 00010001101
11661 * rt -----
11662 * rs -----
11663 * rd -----
11664 */
11665std::string NMD::OR_16_(uint64 instruction)
11666{
11667 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11668 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11669
11670 std::string rs3 = GPR(encode_gpr3(rs3_value));
11671 std::string rt3 = GPR(encode_gpr3(rt3_value));
11672
11673 return img::format("OR %s, %s", rs3, rt3);
11674}
11675
11676
11677/*
11678 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11679 *
11680 * 3 2 1
11681 * 10987654321098765432109876543210
11682 * 001000 00010001101
11683 * rt -----
11684 * rs -----
11685 * rd -----
11686 */
11687std::string NMD::OR_32_(uint64 instruction)
11688{
11689 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11690 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11691 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11692
11693 std::string rd = GPR(copy(rd_value));
11694 std::string rs = GPR(copy(rs_value));
11695 std::string rt = GPR(copy(rt_value));
11696
11697 return img::format("OR %s, %s, %s", rd, rs, rt);
11698}
11699
11700
11701/*
11702 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11703 *
11704 * 3 2 1
11705 * 10987654321098765432109876543210
11706 * 001000 00010001101
11707 * rt -----
11708 * rs -----
11709 * rd -----
11710 */
11711std::string NMD::ORI(uint64 instruction)
11712{
11713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11714 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11715 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11716
11717 std::string rt = GPR(copy(rt_value));
11718 std::string rs = GPR(copy(rs_value));
11719 std::string u = IMMEDIATE(copy(u_value));
11720
11721 return img::format("ORI %s, %s, %s", rt, rs, u);
11722}
11723
11724
11725/*
11726 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11727 *
11728 * 3 2 1
11729 * 10987654321098765432109876543210
11730 * 001000 00010001101
11731 * rt -----
11732 * rs -----
11733 * rd -----
11734 */
11735std::string NMD::PACKRL_PH(uint64 instruction)
11736{
11737 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11738 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11739 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11740
11741 std::string rd = GPR(copy(rd_value));
11742 std::string rs = GPR(copy(rs_value));
11743 std::string rt = GPR(copy(rt_value));
11744
11745 return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11746}
11747
11748
11749/*
11750 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11751 *
11752 * 3 2 1
11753 * 10987654321098765432109876543210
11754 * 001000 00010001101
11755 * rt -----
11756 * rs -----
11757 * rd -----
11758 */
11759std::string NMD::PAUSE(uint64 instruction)
11760{
11761 (void)instruction;
11762
11763 return "PAUSE ";
11764}
11765
11766
11767/*
11768 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11769 *
11770 * 3 2 1
11771 * 10987654321098765432109876543210
11772 * 001000 00010001101
11773 * rt -----
11774 * rs -----
11775 * rd -----
11776 */
11777std::string NMD::PICK_PH(uint64 instruction)
11778{
11779 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11780 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11781 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11782
11783 std::string rd = GPR(copy(rd_value));
11784 std::string rs = GPR(copy(rs_value));
11785 std::string rt = GPR(copy(rt_value));
11786
11787 return img::format("PICK.PH %s, %s, %s", rd, rs, rt);
11788}
11789
11790
11791/*
11792 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11793 *
11794 * 3 2 1
11795 * 10987654321098765432109876543210
11796 * 001000 00010001101
11797 * rt -----
11798 * rs -----
11799 * rd -----
11800 */
11801std::string NMD::PICK_QB(uint64 instruction)
11802{
11803 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11804 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
11805 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11806
11807 std::string rd = GPR(copy(rd_value));
11808 std::string rs = GPR(copy(rs_value));
11809 std::string rt = GPR(copy(rt_value));
11810
11811 return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
11812}
11813
11814
11815/*
11816 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11817 *
11818 * 3 2 1
11819 * 10987654321098765432109876543210
11820 * 001000 00010001101
11821 * rt -----
11822 * rs -----
11823 * rd -----
11824 */
11825std::string NMD::PRECEQ_W_PHL(uint64 instruction)
11826{
11827 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11828 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11829
11830 std::string rt = GPR(copy(rt_value));
11831 std::string rs = GPR(copy(rs_value));
11832
11833 return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
11834}
11835
11836
11837/*
11838 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11839 *
11840 * 3 2 1
11841 * 10987654321098765432109876543210
11842 * 001000 00010001101
11843 * rt -----
11844 * rs -----
11845 * rd -----
11846 */
11847std::string NMD::PRECEQ_W_PHR(uint64 instruction)
11848{
11849 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11850 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11851
11852 std::string rt = GPR(copy(rt_value));
11853 std::string rs = GPR(copy(rs_value));
11854
11855 return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
11856}
11857
11858
11859/*
11860 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11861 *
11862 * 3 2 1
11863 * 10987654321098765432109876543210
11864 * 001000 00010001101
11865 * rt -----
11866 * rs -----
11867 * rd -----
11868 */
11869std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
11870{
11871 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11872 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11873
11874 std::string rt = GPR(copy(rt_value));
11875 std::string rs = GPR(copy(rs_value));
11876
11877 return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11878}
11879
11880
11881/*
11882 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11883 *
11884 * 3 2 1
11885 * 10987654321098765432109876543210
11886 * 001000 00010001101
11887 * rt -----
11888 * rs -----
11889 * rd -----
11890 */
11891std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
11892{
11893 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11894 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11895
11896 std::string rt = GPR(copy(rt_value));
11897 std::string rs = GPR(copy(rs_value));
11898
11899 return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
11900}
11901
11902
11903/*
11904 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11905 *
11906 * 3 2 1
11907 * 10987654321098765432109876543210
11908 * 001000 00010001101
11909 * rt -----
11910 * rs -----
11911 * rd -----
11912 */
11913std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
11914{
11915 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11916 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11917
11918 std::string rt = GPR(copy(rt_value));
11919 std::string rs = GPR(copy(rs_value));
11920
11921 return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11922}
11923
11924
11925/*
11926 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11927 *
11928 * 3 2 1
11929 * 10987654321098765432109876543210
11930 * 001000 00010001101
11931 * rt -----
11932 * rs -----
11933 * rd -----
11934 */
11935std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
11936{
11937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11939
11940 std::string rt = GPR(copy(rt_value));
11941 std::string rs = GPR(copy(rs_value));
11942
11943 return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
11944}
11945
11946
11947/*
11948 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11949 *
11950 * 3 2 1
11951 * 10987654321098765432109876543210
11952 * 001000 00010001101
11953 * rt -----
11954 * rs -----
11955 * rd -----
11956 */
11957std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
11958{
11959 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11960 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11961
11962 std::string rt = GPR(copy(rt_value));
11963 std::string rs = GPR(copy(rs_value));
11964
11965 return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
11966}
11967
11968
11969/*
11970 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11971 *
11972 * 3 2 1
11973 * 10987654321098765432109876543210
11974 * 001000 00010001101
11975 * rt -----
11976 * rs -----
11977 * rd -----
11978 */
11979std::string NMD::PRECEU_PH_QBL(uint64 instruction)
11980{
11981 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11982 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11983
11984 std::string rt = GPR(copy(rt_value));
11985 std::string rs = GPR(copy(rs_value));
11986
11987 return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
11988}
11989
11990
11991/*
11992 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11993 *
11994 * 3 2 1
11995 * 10987654321098765432109876543210
11996 * 001000 00010001101
11997 * rt -----
11998 * rs -----
11999 * rd -----
12000 */
12001std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
12002{
12003 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12004 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12005
12006 std::string rt = GPR(copy(rt_value));
12007 std::string rs = GPR(copy(rs_value));
12008
12009 return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
12010}
12011
12012
12013/*
12014 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12015 *
12016 * 3 2 1
12017 * 10987654321098765432109876543210
12018 * 001000 00010001101
12019 * rt -----
12020 * rs -----
12021 * rd -----
12022 */
12023std::string NMD::PRECEU_PH_QBR(uint64 instruction)
12024{
12025 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12026 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12027
12028 std::string rt = GPR(copy(rt_value));
12029 std::string rs = GPR(copy(rs_value));
12030
12031 return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
12032}
12033
12034
12035/*
12036 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12037 *
12038 * 3 2 1
12039 * 10987654321098765432109876543210
12040 * 001000 00010001101
12041 * rt -----
12042 * rs -----
12043 * rd -----
12044 */
12045std::string NMD::PRECR_QB_PH(uint64 instruction)
12046{
12047 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12048 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12049 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12050
12051 std::string rd = GPR(copy(rd_value));
12052 std::string rs = GPR(copy(rs_value));
12053 std::string rt = GPR(copy(rt_value));
12054
12055 return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
12056}
12057
12058
12059/*
12060 *
12061 *
12062 * 3 2 1
12063 * 10987654321098765432109876543210
12064 * 001000 x1110000101
12065 * rt -----
12066 * rs -----
12067 * rd -----
12068 */
12069std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
12070{
12071 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12072 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12073 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12074
12075 std::string rt = GPR(copy(rt_value));
12076 std::string rs = GPR(copy(rs_value));
12077 std::string sa = IMMEDIATE(copy(sa_value));
12078
12079 return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
12080}
12081
12082
12083/*
12084 *
12085 *
12086 * 3 2 1
12087 * 10987654321098765432109876543210
12088 * 001000 x1110000101
12089 * rt -----
12090 * rs -----
12091 * rd -----
12092 */
12093std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
12094{
12095 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12096 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12097 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12098
12099 std::string rt = GPR(copy(rt_value));
12100 std::string rs = GPR(copy(rs_value));
12101 std::string sa = IMMEDIATE(copy(sa_value));
12102
12103 return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
12104}
12105
12106
12107/*
12108 *
12109 *
12110 * 3 2 1
12111 * 10987654321098765432109876543210
12112 * 001000 x1110000101
12113 * rt -----
12114 * rs -----
12115 * rd -----
12116 */
12117std::string NMD::PRECRQ_PH_W(uint64 instruction)
12118{
12119 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12120 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12121 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12122
12123 std::string rd = GPR(copy(rd_value));
12124 std::string rs = GPR(copy(rs_value));
12125 std::string rt = GPR(copy(rt_value));
12126
12127 return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
12128}
12129
12130
12131/*
12132 *
12133 *
12134 * 3 2 1
12135 * 10987654321098765432109876543210
12136 * 001000 x1110000101
12137 * rt -----
12138 * rs -----
12139 * rd -----
12140 */
12141std::string NMD::PRECRQ_QB_PH(uint64 instruction)
12142{
12143 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12144 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12145 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12146
12147 std::string rd = GPR(copy(rd_value));
12148 std::string rs = GPR(copy(rs_value));
12149 std::string rt = GPR(copy(rt_value));
12150
12151 return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
12152}
12153
12154
12155/*
12156 *
12157 *
12158 * 3 2 1
12159 * 10987654321098765432109876543210
12160 * 001000 x1110000101
12161 * rt -----
12162 * rs -----
12163 * rd -----
12164 */
12165std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
12166{
12167 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12168 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12169 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12170
12171 std::string rd = GPR(copy(rd_value));
12172 std::string rs = GPR(copy(rs_value));
12173 std::string rt = GPR(copy(rt_value));
12174
12175 return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
12176}
12177
12178
12179/*
12180 *
12181 *
12182 * 3 2 1
12183 * 10987654321098765432109876543210
12184 * 001000 x1110000101
12185 * rt -----
12186 * rs -----
12187 * rd -----
12188 */
12189std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
12190{
12191 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12192 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12193 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12194
12195 std::string rd = GPR(copy(rd_value));
12196 std::string rs = GPR(copy(rs_value));
12197 std::string rt = GPR(copy(rt_value));
12198
12199 return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
12200}
12201
12202
12203/*
12204 *
12205 *
12206 * 3 2 1
12207 * 10987654321098765432109876543210
12208 * 001000 x1110000101
12209 * rt -----
12210 * rs -----
12211 * rd -----
12212 */
12213std::string NMD::PREF_S9_(uint64 instruction)
12214{
12215 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12216 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12217 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12218
12219 std::string hint = IMMEDIATE(copy(hint_value));
12220 std::string s = IMMEDIATE(copy(s_value));
12221 std::string rs = GPR(copy(rs_value));
12222
12223 return img::format("PREF %s, %s(%s)", hint, s, rs);
12224}
12225
12226
12227/*
12228 *
12229 *
12230 * 3 2 1
12231 * 10987654321098765432109876543210
12232 * 001000 x1110000101
12233 * rt -----
12234 * rs -----
12235 * rd -----
12236 */
12237std::string NMD::PREF_U12_(uint64 instruction)
12238{
12239 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12240 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12242
12243 std::string hint = IMMEDIATE(copy(hint_value));
12244 std::string u = IMMEDIATE(copy(u_value));
12245 std::string rs = GPR(copy(rs_value));
12246
12247 return img::format("PREF %s, %s(%s)", hint, u, rs);
12248}
12249
12250
12251/*
12252 *
12253 *
12254 * 3 2 1
12255 * 10987654321098765432109876543210
12256 * 001000 x1110000101
12257 * rt -----
12258 * rs -----
12259 * rd -----
12260 */
12261std::string NMD::PREFE(uint64 instruction)
12262{
12263 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12264 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12265 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12266
12267 std::string hint = IMMEDIATE(copy(hint_value));
12268 std::string s = IMMEDIATE(copy(s_value));
12269 std::string rs = GPR(copy(rs_value));
12270
12271 return img::format("PREFE %s, %s(%s)", hint, s, rs);
12272}
12273
12274
12275/*
12276 *
12277 *
12278 * 3 2 1
12279 * 10987654321098765432109876543210
12280 * 001000 x1110000101
12281 * rt -----
12282 * rs -----
12283 * rd -----
12284 */
12285std::string NMD::PREPEND(uint64 instruction)
12286{
12287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12288 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12289 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12290
12291 std::string rt = GPR(copy(rt_value));
12292 std::string rs = GPR(copy(rs_value));
12293 std::string sa = IMMEDIATE(copy(sa_value));
12294
12295 return img::format("PREPEND %s, %s, %s", rt, rs, sa);
12296}
12297
12298
12299/*
12300 *
12301 *
12302 * 3 2 1
12303 * 10987654321098765432109876543210
12304 * 001000 x1110000101
12305 * rt -----
12306 * rs -----
12307 * rd -----
12308 */
12309std::string NMD::RADDU_W_QB(uint64 instruction)
12310{
12311 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12312 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12313
12314 std::string rt = GPR(copy(rt_value));
12315 std::string rs = GPR(copy(rs_value));
12316
12317 return img::format("RADDU.W.QB %s, %s", rt, rs);
12318}
12319
12320
12321/*
12322 *
12323 *
12324 * 3 2 1
12325 * 10987654321098765432109876543210
12326 * 001000 x1110000101
12327 * rt -----
12328 * rs -----
12329 * rd -----
12330 */
12331std::string NMD::RDDSP(uint64 instruction)
12332{
12333 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12334 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
12335
12336 std::string rt = GPR(copy(rt_value));
12337 std::string mask = IMMEDIATE(copy(mask_value));
12338
12339 return img::format("RDDSP %s, %s", rt, mask);
12340}
12341
12342
12343/*
12344 *
12345 *
12346 * 3 2 1
12347 * 10987654321098765432109876543210
12348 * 001000 x1110000101
12349 * rt -----
12350 * rs -----
12351 * rd -----
12352 */
12353std::string NMD::RDHWR(uint64 instruction)
12354{
12355 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12356 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
12357 uint64 sel_value = extract_sel_13_12_11(instruction);
12358
12359 std::string rt = GPR(copy(rt_value));
12360 std::string hs = CPR(copy(hs_value));
12361 std::string sel = IMMEDIATE(copy(sel_value));
12362
12363 return img::format("RDHWR %s, %s, %s", rt, hs, sel);
12364}
12365
12366
12367/*
12368 *
12369 *
12370 * 3 2 1
12371 * 10987654321098765432109876543210
12372 * 001000 x1110000101
12373 * rt -----
12374 * rs -----
12375 * rd -----
12376 */
12377std::string NMD::RDPGPR(uint64 instruction)
12378{
12379 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12380 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12381
12382 std::string rt = GPR(copy(rt_value));
12383 std::string rs = GPR(copy(rs_value));
12384
12385 return img::format("RDPGPR %s, %s", rt, rs);
12386}
12387
12388
12389/*
12390 *
12391 *
12392 * 3 2 1
12393 * 10987654321098765432109876543210
12394 * 001000 x1110000101
12395 * rt -----
12396 * rs -----
12397 * rd -----
12398 */
12399std::string NMD::RECIP_D(uint64 instruction)
12400{
12401 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12402 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12403
12404 std::string ft = FPR(copy(ft_value));
12405 std::string fs = FPR(copy(fs_value));
12406
12407 return img::format("RECIP.D %s, %s", ft, fs);
12408}
12409
12410
12411/*
12412 *
12413 *
12414 * 3 2 1
12415 * 10987654321098765432109876543210
12416 * 001000 x1110000101
12417 * rt -----
12418 * rs -----
12419 * rd -----
12420 */
12421std::string NMD::RECIP_S(uint64 instruction)
12422{
12423 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12424 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12425
12426 std::string ft = FPR(copy(ft_value));
12427 std::string fs = FPR(copy(fs_value));
12428
12429 return img::format("RECIP.S %s, %s", ft, fs);
12430}
12431
12432
12433/*
12434 *
12435 *
12436 * 3 2 1
12437 * 10987654321098765432109876543210
12438 * 001000 x1110000101
12439 * rt -----
12440 * rs -----
12441 * rd -----
12442 */
12443std::string NMD::REPL_PH(uint64 instruction)
12444{
12445 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12446 int64 s_value = extr_sil11il0bs10Tmsb9(instruction);
12447
12448 std::string rt = GPR(copy(rt_value));
12449 std::string s = IMMEDIATE(copy(s_value));
12450
12451 return img::format("REPL.PH %s, %s", rt, s);
12452}
12453
12454
12455/*
12456 *
12457 *
12458 * 3 2 1
12459 * 10987654321098765432109876543210
12460 * 001000 x1110000101
12461 * rt -----
12462 * rs -----
12463 * rd -----
12464 */
12465std::string NMD::REPL_QB(uint64 instruction)
12466{
12467 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12468 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12469
12470 std::string rt = GPR(copy(rt_value));
12471 std::string u = IMMEDIATE(copy(u_value));
12472
12473 return img::format("REPL.QB %s, %s", rt, u);
12474}
12475
12476
12477/*
12478 *
12479 *
12480 * 3 2 1
12481 * 10987654321098765432109876543210
12482 * 001000 x1110000101
12483 * rt -----
12484 * rs -----
12485 * rd -----
12486 */
12487std::string NMD::REPLV_PH(uint64 instruction)
12488{
12489 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12490 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12491
12492 std::string rt = GPR(copy(rt_value));
12493 std::string rs = GPR(copy(rs_value));
12494
12495 return img::format("REPLV.PH %s, %s", rt, rs);
12496}
12497
12498
12499/*
12500 *
12501 *
12502 * 3 2 1
12503 * 10987654321098765432109876543210
12504 * 001000 x1110000101
12505 * rt -----
12506 * rs -----
12507 * rd -----
12508 */
12509std::string NMD::REPLV_QB(uint64 instruction)
12510{
12511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12513
12514 std::string rt = GPR(copy(rt_value));
12515 std::string rs = GPR(copy(rs_value));
12516
12517 return img::format("REPLV.QB %s, %s", rt, rs);
12518}
12519
12520
12521/*
12522 *
12523 *
12524 * 3 2 1
12525 * 10987654321098765432109876543210
12526 * 001000 x1110000101
12527 * rt -----
12528 * rs -----
12529 * rd -----
12530 */
12531std::string NMD::RESTORE_32_(uint64 instruction)
12532{
12533 uint64 count_value = extract_count_19_18_17_16(instruction);
12534 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12535 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12536 uint64 gp_value = extract_gp_2(instruction);
12537
12538 std::string u = IMMEDIATE(copy(u_value));
12539 return img::format("RESTORE %s%s", u,
12540 save_restore_list(rt_value, count_value, gp_value));
12541}
12542
12543
12544/*
12545 *
12546 *
12547 * 3 2 1
12548 * 10987654321098765432109876543210
12549 * 001000 x1110000101
12550 * rt -----
12551 * rs -----
12552 * rd -----
12553 */
12554std::string NMD::RESTORE_JRC_16_(uint64 instruction)
12555{
12556 uint64 count_value = extract_count_3_2_1_0(instruction);
12557 uint64 rt1_value = extract_rtl_11(instruction);
12558 uint64 u_value = extr_uil4il4bs4Fmsb7(instruction);
12559
12560 std::string u = IMMEDIATE(copy(u_value));
12561 return img::format("RESTORE.JRC %s%s", u,
12562 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12563}
12564
12565
12566/*
12567 *
12568 *
12569 * 3 2 1
12570 * 10987654321098765432109876543210
12571 * 001000 x1110000101
12572 * rt -----
12573 * rs -----
12574 * rd -----
12575 */
12576std::string NMD::RESTORE_JRC_32_(uint64 instruction)
12577{
12578 uint64 count_value = extract_count_19_18_17_16(instruction);
12579 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12580 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12581 uint64 gp_value = extract_gp_2(instruction);
12582
12583 std::string u = IMMEDIATE(copy(u_value));
12584 return img::format("RESTORE.JRC %s%s", u,
12585 save_restore_list(rt_value, count_value, gp_value));
12586}
12587
12588
12589/*
12590 *
12591 *
12592 * 3 2 1
12593 * 10987654321098765432109876543210
12594 * 001000 x1110000101
12595 * rt -----
12596 * rs -----
12597 * rd -----
12598 */
12599std::string NMD::RESTOREF(uint64 instruction)
12600{
12601 uint64 count_value = extract_count_19_18_17_16(instruction);
12602 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12603
12604 std::string u = IMMEDIATE(copy(u_value));
12605 std::string count = IMMEDIATE(copy(count_value));
12606
12607 return img::format("RESTOREF %s, %s", u, count);
12608}
12609
12610
12611/*
12612 *
12613 *
12614 * 3 2 1
12615 * 10987654321098765432109876543210
12616 * 001000 x1110000101
12617 * rt -----
12618 * rs -----
12619 * rd -----
12620 */
12621std::string NMD::RINT_D(uint64 instruction)
12622{
12623 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12624 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12625
12626 std::string ft = FPR(copy(ft_value));
12627 std::string fs = FPR(copy(fs_value));
12628
12629 return img::format("RINT.D %s, %s", ft, fs);
12630}
12631
12632
12633/*
12634 *
12635 *
12636 * 3 2 1
12637 * 10987654321098765432109876543210
12638 * 001000 x1110000101
12639 * rt -----
12640 * rs -----
12641 * rd -----
12642 */
12643std::string NMD::RINT_S(uint64 instruction)
12644{
12645 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12646 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12647
12648 std::string ft = FPR(copy(ft_value));
12649 std::string fs = FPR(copy(fs_value));
12650
12651 return img::format("RINT.S %s, %s", ft, fs);
12652}
12653
12654
12655/*
12656 *
12657 *
12658 * 3 2 1
12659 * 10987654321098765432109876543210
12660 * 001000 x1110000101
12661 * rt -----
12662 * rs -----
12663 * rd -----
12664 */
12665std::string NMD::ROTR(uint64 instruction)
12666{
12667 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12668 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12669 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12670
12671 std::string rt = GPR(copy(rt_value));
12672 std::string rs = GPR(copy(rs_value));
12673 std::string shift = IMMEDIATE(copy(shift_value));
12674
12675 return img::format("ROTR %s, %s, %s", rt, rs, shift);
12676}
12677
12678
12679/*
12680 *
12681 *
12682 * 3 2 1
12683 * 10987654321098765432109876543210
12684 * 001000 x1110000101
12685 * rt -----
12686 * rs -----
12687 * rd -----
12688 */
12689std::string NMD::ROTRV(uint64 instruction)
12690{
12691 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12692 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
12693 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12694
12695 std::string rd = GPR(copy(rd_value));
12696 std::string rs = GPR(copy(rs_value));
12697 std::string rt = GPR(copy(rt_value));
12698
12699 return img::format("ROTRV %s, %s, %s", rd, rs, rt);
12700}
12701
12702
12703/*
12704 *
12705 *
12706 * 3 2 1
12707 * 10987654321098765432109876543210
12708 * 001000 x1110000101
12709 * rt -----
12710 * rs -----
12711 * rd -----
12712 */
12713std::string NMD::ROTX(uint64 instruction)
12714{
12715 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12716 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12717 uint64 shiftx_value = extr_shiftxil7il1bs4Fmsb4(instruction);
12718 uint64 stripe_value = extract_stripe_6(instruction);
12719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12720
12721 std::string rt = GPR(copy(rt_value));
12722 std::string rs = GPR(copy(rs_value));
12723 std::string shift = IMMEDIATE(copy(shift_value));
12724 std::string shiftx = IMMEDIATE(copy(shiftx_value));
12725 std::string stripe = IMMEDIATE(copy(stripe_value));
12726
12727 return img::format("ROTX %s, %s, %s, %s, %s",
12728 rt, rs, shift, shiftx, stripe);
12729}
12730
12731
12732/*
12733 *
12734 *
12735 * 3 2 1
12736 * 10987654321098765432109876543210
12737 * 001000 x1110000101
12738 * rt -----
12739 * rs -----
12740 * rd -----
12741 */
12742std::string NMD::ROUND_L_D(uint64 instruction)
12743{
12744 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12745 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12746
12747 std::string ft = FPR(copy(ft_value));
12748 std::string fs = FPR(copy(fs_value));
12749
12750 return img::format("ROUND.L.D %s, %s", ft, fs);
12751}
12752
12753
12754/*
12755 *
12756 *
12757 * 3 2 1
12758 * 10987654321098765432109876543210
12759 * 001000 x1110000101
12760 * rt -----
12761 * rs -----
12762 * rd -----
12763 */
12764std::string NMD::ROUND_L_S(uint64 instruction)
12765{
12766 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12767 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12768
12769 std::string ft = FPR(copy(ft_value));
12770 std::string fs = FPR(copy(fs_value));
12771
12772 return img::format("ROUND.L.S %s, %s", ft, fs);
12773}
12774
12775
12776/*
12777 *
12778 *
12779 * 3 2 1
12780 * 10987654321098765432109876543210
12781 * 001000 x1110000101
12782 * rt -----
12783 * rs -----
12784 * rd -----
12785 */
12786std::string NMD::ROUND_W_D(uint64 instruction)
12787{
12788 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12789 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12790
12791 std::string ft = FPR(copy(ft_value));
12792 std::string fs = FPR(copy(fs_value));
12793
12794 return img::format("ROUND.W.D %s, %s", ft, fs);
12795}
12796
12797
12798/*
12799 *
12800 *
12801 * 3 2 1
12802 * 10987654321098765432109876543210
12803 * 001000 x1110000101
12804 * rt -----
12805 * rs -----
12806 * rd -----
12807 */
12808std::string NMD::ROUND_W_S(uint64 instruction)
12809{
12810 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12811 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12812
12813 std::string ft = FPR(copy(ft_value));
12814 std::string fs = FPR(copy(fs_value));
12815
12816 return img::format("ROUND.W.S %s, %s", ft, fs);
12817}
12818
12819
12820/*
12821 *
12822 *
12823 * 3 2 1
12824 * 10987654321098765432109876543210
12825 * 001000 x1110000101
12826 * rt -----
12827 * rs -----
12828 * rd -----
12829 */
12830std::string NMD::RSQRT_D(uint64 instruction)
12831{
12832 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12833 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12834
12835 std::string ft = FPR(copy(ft_value));
12836 std::string fs = FPR(copy(fs_value));
12837
12838 return img::format("RSQRT.D %s, %s", ft, fs);
12839}
12840
12841
12842/*
12843 *
12844 *
12845 * 3 2 1
12846 * 10987654321098765432109876543210
12847 * 001000 x1110000101
12848 * rt -----
12849 * rs -----
12850 * rd -----
12851 */
12852std::string NMD::RSQRT_S(uint64 instruction)
12853{
12854 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
12855 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
12856
12857 std::string ft = FPR(copy(ft_value));
12858 std::string fs = FPR(copy(fs_value));
12859
12860 return img::format("RSQRT.S %s, %s", ft, fs);
12861}
12862
12863
12864/*
12865 *
12866 *
12867 * 3 2 1
12868 * 10987654321098765432109876543210
12869 * 001000 01001001101
12870 * rt -----
12871 * rs -----
12872 * rd -----
12873 */
12874std::string NMD::SAVE_16_(uint64 instruction)
12875{
12876 uint64 count_value = extract_count_3_2_1_0(instruction);
12877 uint64 rt1_value = extract_rtl_11(instruction);
12878 uint64 u_value = extr_uil4il4bs4Fmsb7(instruction);
12879
12880 std::string u = IMMEDIATE(copy(u_value));
12881 return img::format("SAVE %s%s", u,
12882 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12883}
12884
12885
12886/*
12887 *
12888 *
12889 * 3 2 1
12890 * 10987654321098765432109876543210
12891 * 001000 01001001101
12892 * rt -----
12893 * rs -----
12894 * rd -----
12895 */
12896std::string NMD::SAVE_32_(uint64 instruction)
12897{
12898 uint64 count_value = extract_count_19_18_17_16(instruction);
12899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12900 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12901 uint64 gp_value = extract_gp_2(instruction);
12902
12903 std::string u = IMMEDIATE(copy(u_value));
12904 return img::format("SAVE %s%s", u,
12905 save_restore_list(rt_value, count_value, gp_value));
12906}
12907
12908
12909/*
12910 *
12911 *
12912 * 3 2 1
12913 * 10987654321098765432109876543210
12914 * 001000 01001001101
12915 * rt -----
12916 * rs -----
12917 * rd -----
12918 */
12919std::string NMD::SAVEF(uint64 instruction)
12920{
12921 uint64 count_value = extract_count_19_18_17_16(instruction);
12922 uint64 u_value = extr_uil3il3bs9Fmsb11(instruction);
12923
12924 std::string u = IMMEDIATE(copy(u_value));
12925 std::string count = IMMEDIATE(copy(count_value));
12926
12927 return img::format("SAVEF %s, %s", u, count);
12928}
12929
12930
12931/*
12932 *
12933 *
12934 * 3 2 1
12935 * 10987654321098765432109876543210
12936 * 001000 01001001101
12937 * rt -----
12938 * rs -----
12939 * rd -----
12940 */
12941std::string NMD::SB_16_(uint64 instruction)
12942{
12943 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12944 uint64 u_value = extract_u_1_0(instruction);
12945 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12946
12947 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
12948 std::string u = IMMEDIATE(copy(u_value));
12949 std::string rs3 = GPR(encode_gpr3(rs3_value));
12950
12951 return img::format("SB %s, %s(%s)", rtz3, u, rs3);
12952}
12953
12954
12955/*
12956 *
12957 *
12958 * 3 2 1
12959 * 10987654321098765432109876543210
12960 * 001000 01001001101
12961 * rt -----
12962 * rs -----
12963 * rd -----
12964 */
12965std::string NMD::SB_GP_(uint64 instruction)
12966{
12967 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12968 uint64 u_value = extract_u_17_to_0(instruction);
12969
12970 std::string rt = GPR(copy(rt_value));
12971 std::string u = IMMEDIATE(copy(u_value));
12972
12973 return img::format("SB %s, %s($%d)", rt, u, 28);
12974}
12975
12976
12977/*
12978 *
12979 *
12980 * 3 2 1
12981 * 10987654321098765432109876543210
12982 * 001000 01001001101
12983 * rt -----
12984 * rs -----
12985 * rd -----
12986 */
12987std::string NMD::SB_S9_(uint64 instruction)
12988{
12989 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12990 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
12991 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12992
12993 std::string rt = GPR(copy(rt_value));
12994 std::string s = IMMEDIATE(copy(s_value));
12995 std::string rs = GPR(copy(rs_value));
12996
12997 return img::format("SB %s, %s(%s)", rt, s, rs);
12998}
12999
13000
13001/*
13002 *
13003 *
13004 * 3 2 1
13005 * 10987654321098765432109876543210
13006 * 001000 01001001101
13007 * rt -----
13008 * rs -----
13009 * rd -----
13010 */
13011std::string NMD::SB_U12_(uint64 instruction)
13012{
13013 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13014 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13015 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13016
13017 std::string rt = GPR(copy(rt_value));
13018 std::string u = IMMEDIATE(copy(u_value));
13019 std::string rs = GPR(copy(rs_value));
13020
13021 return img::format("SB %s, %s(%s)", rt, u, rs);
13022}
13023
13024
13025/*
13026 *
13027 *
13028 * 3 2 1
13029 * 10987654321098765432109876543210
13030 * 001000 01001001101
13031 * rt -----
13032 * rs -----
13033 * rd -----
13034 */
13035std::string NMD::SBE(uint64 instruction)
13036{
13037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13038 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13039 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13040
13041 std::string rt = GPR(copy(rt_value));
13042 std::string s = IMMEDIATE(copy(s_value));
13043 std::string rs = GPR(copy(rs_value));
13044
13045 return img::format("SBE %s, %s(%s)", rt, s, rs);
13046}
13047
13048
13049/*
13050 *
13051 *
13052 * 3 2 1
13053 * 10987654321098765432109876543210
13054 * 001000 01001001101
13055 * rt -----
13056 * rs -----
13057 * rd -----
13058 */
13059std::string NMD::SBX(uint64 instruction)
13060{
13061 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13062 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13063 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13064
13065 std::string rd = GPR(copy(rd_value));
13066 std::string rs = GPR(copy(rs_value));
13067 std::string rt = GPR(copy(rt_value));
13068
13069 return img::format("SBX %s, %s(%s)", rd, rs, rt);
13070}
13071
13072
13073/*
13074 *
13075 *
13076 * 3 2 1
13077 * 10987654321098765432109876543210
13078 * 001000 01001001101
13079 * rt -----
13080 * rs -----
13081 * rd -----
13082 */
13083std::string NMD::SC(uint64 instruction)
13084{
13085 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13086 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
13087 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13088
13089 std::string rt = GPR(copy(rt_value));
13090 std::string s = IMMEDIATE(copy(s_value));
13091 std::string rs = GPR(copy(rs_value));
13092
13093 return img::format("SC %s, %s(%s)", rt, s, rs);
13094}
13095
13096
13097/*
13098 *
13099 *
13100 * 3 2 1
13101 * 10987654321098765432109876543210
13102 * 001000 01001001101
13103 * rt -----
13104 * rs -----
13105 * rd -----
13106 */
13107std::string NMD::SCD(uint64 instruction)
13108{
13109 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13110 int64 s_value = extr_sil3il3bs5_il15il8bs1Tmsb8(instruction);
13111 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13112
13113 std::string rt = GPR(copy(rt_value));
13114 std::string s = IMMEDIATE(copy(s_value));
13115 std::string rs = GPR(copy(rs_value));
13116
13117 return img::format("SCD %s, %s(%s)", rt, s, rs);
13118}
13119
13120
13121/*
13122 *
13123 *
13124 * 3 2 1
13125 * 10987654321098765432109876543210
13126 * 001000 01001001101
13127 * rt -----
13128 * rs -----
13129 * rd -----
13130 */
13131std::string NMD::SCDP(uint64 instruction)
13132{
13133 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13134 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13135 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13136
13137 std::string rt = GPR(copy(rt_value));
13138 std::string ru = GPR(copy(ru_value));
13139 std::string rs = GPR(copy(rs_value));
13140
13141 return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
13142}
13143
13144
13145/*
13146 *
13147 *
13148 * 3 2 1
13149 * 10987654321098765432109876543210
13150 * 001000 01001001101
13151 * rt -----
13152 * rs -----
13153 * rd -----
13154 */
13155std::string NMD::SCE(uint64 instruction)
13156{
13157 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13158 int64 s_value = extr_sil2il2bs6_il15il8bs1Tmsb8(instruction);
13159 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13160
13161 std::string rt = GPR(copy(rt_value));
13162 std::string s = IMMEDIATE(copy(s_value));
13163 std::string rs = GPR(copy(rs_value));
13164
13165 return img::format("SCE %s, %s(%s)", rt, s, rs);
13166}
13167
13168
13169/*
13170 *
13171 *
13172 * 3 2 1
13173 * 10987654321098765432109876543210
13174 * 001000 01001001101
13175 * rt -----
13176 * rs -----
13177 * rd -----
13178 */
13179std::string NMD::SCWP(uint64 instruction)
13180{
13181 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13182 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13183 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13184
13185 std::string rt = GPR(copy(rt_value));
13186 std::string ru = GPR(copy(ru_value));
13187 std::string rs = GPR(copy(rs_value));
13188
13189 return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
13190}
13191
13192
13193/*
13194 *
13195 *
13196 * 3 2 1
13197 * 10987654321098765432109876543210
13198 * 001000 01001001101
13199 * rt -----
13200 * rs -----
13201 * rd -----
13202 */
13203std::string NMD::SCWPE(uint64 instruction)
13204{
13205 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13206 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13207 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13208
13209 std::string rt = GPR(copy(rt_value));
13210 std::string ru = GPR(copy(ru_value));
13211 std::string rs = GPR(copy(rs_value));
13212
13213 return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
13214}
13215
13216
13217/*
13218 *
13219 *
13220 * 3 2 1
13221 * 10987654321098765432109876543210
13222 * 001000 01001001101
13223 * rt -----
13224 * rs -----
13225 * rd -----
13226 */
13227std::string NMD::SD_GP_(uint64 instruction)
13228{
13229 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13230 uint64 u_value = extr_uil3il3bs18Fmsb20(instruction);
13231
13232 std::string rt = GPR(copy(rt_value));
13233 std::string u = IMMEDIATE(copy(u_value));
13234
13235 return img::format("SD %s, %s($%d)", rt, u, 28);
13236}
13237
13238
13239/*
13240 *
13241 *
13242 * 3 2 1
13243 * 10987654321098765432109876543210
13244 * 001000 01001001101
13245 * rt -----
13246 * rs -----
13247 * rd -----
13248 */
13249std::string NMD::SD_S9_(uint64 instruction)
13250{
13251 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13252 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13253 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13254
13255 std::string rt = GPR(copy(rt_value));
13256 std::string s = IMMEDIATE(copy(s_value));
13257 std::string rs = GPR(copy(rs_value));
13258
13259 return img::format("SD %s, %s(%s)", rt, s, rs);
13260}
13261
13262
13263/*
13264 *
13265 *
13266 * 3 2 1
13267 * 10987654321098765432109876543210
13268 * 001000 01001001101
13269 * rt -----
13270 * rs -----
13271 * rd -----
13272 */
13273std::string NMD::SD_U12_(uint64 instruction)
13274{
13275 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13276 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13277 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13278
13279 std::string rt = GPR(copy(rt_value));
13280 std::string u = IMMEDIATE(copy(u_value));
13281 std::string rs = GPR(copy(rs_value));
13282
13283 return img::format("SD %s, %s(%s)", rt, u, rs);
13284}
13285
13286
13287/*
13288 *
13289 *
13290 * 3 2 1
13291 * 10987654321098765432109876543210
13292 * 001000 01001001101
13293 * rt -----
13294 * rs -----
13295 * rd -----
13296 */
13297std::string NMD::SDBBP_16_(uint64 instruction)
13298{
13299 uint64 code_value = extract_code_2_1_0(instruction);
13300
13301 std::string code = IMMEDIATE(copy(code_value));
13302
13303 return img::format("SDBBP %s", code);
13304}
13305
13306
13307/*
13308 *
13309 *
13310 * 3 2 1
13311 * 10987654321098765432109876543210
13312 * 001000 01001001101
13313 * rt -----
13314 * rs -----
13315 * rd -----
13316 */
13317std::string NMD::SDBBP_32_(uint64 instruction)
13318{
13319 uint64 code_value = extract_code_18_to_0(instruction);
13320
13321 std::string code = IMMEDIATE(copy(code_value));
13322
13323 return img::format("SDBBP %s", code);
13324}
13325
13326
13327/*
13328 *
13329 *
13330 * 3 2 1
13331 * 10987654321098765432109876543210
13332 * 001000 01001001101
13333 * rt -----
13334 * rs -----
13335 * rd -----
13336 */
13337std::string NMD::SDC1_GP_(uint64 instruction)
13338{
13339 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13340 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
13341
13342 std::string ft = FPR(copy(ft_value));
13343 std::string u = IMMEDIATE(copy(u_value));
13344
13345 return img::format("SDC1 %s, %s($%d)", ft, u, 28);
13346}
13347
13348
13349/*
13350 *
13351 *
13352 * 3 2 1
13353 * 10987654321098765432109876543210
13354 * 001000 01001001101
13355 * rt -----
13356 * rs -----
13357 * rd -----
13358 */
13359std::string NMD::SDC1_S9_(uint64 instruction)
13360{
13361 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13362 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13363 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13364
13365 std::string ft = FPR(copy(ft_value));
13366 std::string s = IMMEDIATE(copy(s_value));
13367 std::string rs = GPR(copy(rs_value));
13368
13369 return img::format("SDC1 %s, %s(%s)", ft, s, rs);
13370}
13371
13372
13373/*
13374 *
13375 *
13376 * 3 2 1
13377 * 10987654321098765432109876543210
13378 * 001000 01001001101
13379 * rt -----
13380 * rs -----
13381 * rd -----
13382 */
13383std::string NMD::SDC1_U12_(uint64 instruction)
13384{
13385 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13386 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13387 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13388
13389 std::string ft = FPR(copy(ft_value));
13390 std::string u = IMMEDIATE(copy(u_value));
13391 std::string rs = GPR(copy(rs_value));
13392
13393 return img::format("SDC1 %s, %s(%s)", ft, u, rs);
13394}
13395
13396
13397/*
13398 *
13399 *
13400 * 3 2 1
13401 * 10987654321098765432109876543210
13402 * 001000 01001001101
13403 * rt -----
13404 * rs -----
13405 * rd -----
13406 */
13407std::string NMD::SDC1X(uint64 instruction)
13408{
13409 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13410 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13411 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13412
13413 std::string ft = FPR(copy(ft_value));
13414 std::string rs = GPR(copy(rs_value));
13415 std::string rt = GPR(copy(rt_value));
13416
13417 return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
13418}
13419
13420
13421/*
13422 *
13423 *
13424 * 3 2 1
13425 * 10987654321098765432109876543210
13426 * 001000 01001001101
13427 * rt -----
13428 * rs -----
13429 * rd -----
13430 */
13431std::string NMD::SDC1XS(uint64 instruction)
13432{
13433 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13434 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13435 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13436
13437 std::string ft = FPR(copy(ft_value));
13438 std::string rs = GPR(copy(rs_value));
13439 std::string rt = GPR(copy(rt_value));
13440
13441 return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
13442}
13443
13444
13445/*
13446 *
13447 *
13448 * 3 2 1
13449 * 10987654321098765432109876543210
13450 * 001000 01001001101
13451 * rt -----
13452 * rs -----
13453 * rd -----
13454 */
13455std::string NMD::SDC2(uint64 instruction)
13456{
13457 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
13458 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13459 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13460
13461 std::string cs = CPR(copy(cs_value));
13462 std::string s = IMMEDIATE(copy(s_value));
13463 std::string rs = GPR(copy(rs_value));
13464
13465 return img::format("SDC2 %s, %s(%s)", cs, s, rs);
13466}
13467
13468
13469/*
13470 *
13471 *
13472 * 3 2 1
13473 * 10987654321098765432109876543210
13474 * 001000 01001001101
13475 * rt -----
13476 * rs -----
13477 * rd -----
13478 */
13479std::string NMD::SDM(uint64 instruction)
13480{
13481 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13482 uint64 count3_value = extract_count3_14_13_12(instruction);
13483 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13485
13486 std::string rt = GPR(copy(rt_value));
13487 std::string s = IMMEDIATE(copy(s_value));
13488 std::string rs = GPR(copy(rs_value));
13489 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
13490
13491 return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
13492}
13493
13494
13495/*
13496 *
13497 *
13498 * 3 2 1
13499 * 10987654321098765432109876543210
13500 * 001000 01001001101
13501 * rt -----
13502 * rs -----
13503 * rd -----
13504 */
13505std::string NMD::SDPC_48_(uint64 instruction)
13506{
13507 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13508 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
13509
13510 std::string rt = GPR(copy(rt_value));
13511 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
13512
13513 return img::format("SDPC %s, %s", rt, s);
13514}
13515
13516
13517/*
13518 *
13519 *
13520 * 3 2 1
13521 * 10987654321098765432109876543210
13522 * 001000 01001001101
13523 * rt -----
13524 * rs -----
13525 * rd -----
13526 */
13527std::string NMD::SDXS(uint64 instruction)
13528{
13529 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13530 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13531 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13532
13533 std::string rd = GPR(copy(rd_value));
13534 std::string rs = GPR(copy(rs_value));
13535 std::string rt = GPR(copy(rt_value));
13536
13537 return img::format("SDXS %s, %s(%s)", rd, rs, rt);
13538}
13539
13540
13541/*
13542 *
13543 *
13544 * 3 2 1
13545 * 10987654321098765432109876543210
13546 * 001000 01001001101
13547 * rt -----
13548 * rs -----
13549 * rd -----
13550 */
13551std::string NMD::SDX(uint64 instruction)
13552{
13553 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13554 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
13555 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13556
13557 std::string rd = GPR(copy(rd_value));
13558 std::string rs = GPR(copy(rs_value));
13559 std::string rt = GPR(copy(rt_value));
13560
13561 return img::format("SDX %s, %s(%s)", rd, rs, rt);
13562}
13563
13564
13565/*
13566 *
13567 *
13568 * 3 2 1
13569 * 10987654321098765432109876543210
13570 * 001000 01001001101
13571 * rt -----
13572 * rs -----
13573 * rd -----
13574 */
13575std::string NMD::SEB(uint64 instruction)
13576{
13577 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13578 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13579
13580 std::string rt = GPR(copy(rt_value));
13581 std::string rs = GPR(copy(rs_value));
13582
13583 return img::format("SEB %s, %s", rt, rs);
13584}
13585
13586
13587/*
13588 *
13589 *
13590 * 3 2 1
13591 * 10987654321098765432109876543210
13592 * 001000 01001001101
13593 * rt -----
13594 * rs -----
13595 * rd -----
13596 */
13597std::string NMD::SEH(uint64 instruction)
13598{
13599 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13600 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13601
13602 std::string rt = GPR(copy(rt_value));
13603 std::string rs = GPR(copy(rs_value));
13604
13605 return img::format("SEH %s, %s", rt, rs);
13606}
13607
13608
13609/*
13610 *
13611 *
13612 * 3 2 1
13613 * 10987654321098765432109876543210
13614 * 001000 01001001101
13615 * rt -----
13616 * rs -----
13617 * rd -----
13618 */
13619std::string NMD::SEL_D(uint64 instruction)
13620{
13621 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13622 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13623 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13624
13625 std::string fd = FPR(copy(fd_value));
13626 std::string fs = FPR(copy(fs_value));
13627 std::string ft = FPR(copy(ft_value));
13628
13629 return img::format("SEL.D %s, %s, %s", fd, fs, ft);
13630}
13631
13632
13633/*
13634 *
13635 *
13636 * 3 2 1
13637 * 10987654321098765432109876543210
13638 * 001000 01001001101
13639 * rt -----
13640 * rs -----
13641 * rd -----
13642 */
13643std::string NMD::SEL_S(uint64 instruction)
13644{
13645 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13646 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13647 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13648
13649 std::string fd = FPR(copy(fd_value));
13650 std::string fs = FPR(copy(fs_value));
13651 std::string ft = FPR(copy(ft_value));
13652
13653 return img::format("SEL.S %s, %s, %s", fd, fs, ft);
13654}
13655
13656
13657/*
13658 *
13659 *
13660 * 3 2 1
13661 * 10987654321098765432109876543210
13662 * 001000 01001001101
13663 * rt -----
13664 * rs -----
13665 * rd -----
13666 */
13667std::string NMD::SELEQZ_D(uint64 instruction)
13668{
13669 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13670 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13671 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13672
13673 std::string fd = FPR(copy(fd_value));
13674 std::string fs = FPR(copy(fs_value));
13675 std::string ft = FPR(copy(ft_value));
13676
13677 return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13678}
13679
13680
13681/*
13682 *
13683 *
13684 * 3 2 1
13685 * 10987654321098765432109876543210
13686 * 001000 01001001101
13687 * rt -----
13688 * rs -----
13689 * rd -----
13690 */
13691std::string NMD::SELEQZ_S(uint64 instruction)
13692{
13693 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13694 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13695 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13696
13697 std::string fd = FPR(copy(fd_value));
13698 std::string fs = FPR(copy(fs_value));
13699 std::string ft = FPR(copy(ft_value));
13700
13701 return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13702}
13703
13704
13705/*
13706 *
13707 *
13708 * 3 2 1
13709 * 10987654321098765432109876543210
13710 * 001000 01001001101
13711 * rt -----
13712 * rs -----
13713 * rd -----
13714 */
13715std::string NMD::SELNEZ_D(uint64 instruction)
13716{
13717 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13718 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13719 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13720
13721 std::string fd = FPR(copy(fd_value));
13722 std::string fs = FPR(copy(fs_value));
13723 std::string ft = FPR(copy(ft_value));
13724
13725 return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13726}
13727
13728
13729/*
13730 *
13731 *
13732 * 3 2 1
13733 * 10987654321098765432109876543210
13734 * 001000 01001001101
13735 * rt -----
13736 * rs -----
13737 * rd -----
13738 */
13739std::string NMD::SELNEZ_S(uint64 instruction)
13740{
13741 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
13742 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
13743 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
13744
13745 std::string fd = FPR(copy(fd_value));
13746 std::string fs = FPR(copy(fs_value));
13747 std::string ft = FPR(copy(ft_value));
13748
13749 return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13750}
13751
13752
13753/*
13754 *
13755 *
13756 * 3 2 1
13757 * 10987654321098765432109876543210
13758 * 001000 01001001101
13759 * rt -----
13760 * rs -----
13761 * rd -----
13762 */
13763std::string NMD::SEQI(uint64 instruction)
13764{
13765 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13766 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13767 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13768
13769 std::string rt = GPR(copy(rt_value));
13770 std::string rs = GPR(copy(rs_value));
13771 std::string u = IMMEDIATE(copy(u_value));
13772
13773 return img::format("SEQI %s, %s, %s", rt, rs, u);
13774}
13775
13776
13777/*
13778 *
13779 *
13780 * 3 2 1
13781 * 10987654321098765432109876543210
13782 * 001000 01001001101
13783 * rt -----
13784 * rs -----
13785 * rd -----
13786 */
13787std::string NMD::SH_16_(uint64 instruction)
13788{
13789 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13790 uint64 u_value = extr_uil1il1bs2Fmsb2(instruction);
13791 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13792
13793 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
13794 std::string u = IMMEDIATE(copy(u_value));
13795 std::string rs3 = GPR(encode_gpr3(rs3_value));
13796
13797 return img::format("SH %s, %s(%s)", rtz3, u, rs3);
13798}
13799
13800
13801/*
13802 *
13803 *
13804 * 3 2 1
13805 * 10987654321098765432109876543210
13806 * 001000 01001001101
13807 * rt -----
13808 * rs -----
13809 * rd -----
13810 */
13811std::string NMD::SH_GP_(uint64 instruction)
13812{
13813 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13814 uint64 u_value = extr_uil1il1bs17Fmsb17(instruction);
13815
13816 std::string rt = GPR(copy(rt_value));
13817 std::string u = IMMEDIATE(copy(u_value));
13818
13819 return img::format("SH %s, %s($%d)", rt, u, 28);
13820}
13821
13822
13823/*
13824 *
13825 *
13826 * 3 2 1
13827 * 10987654321098765432109876543210
13828 * 001000 01001001101
13829 * rt -----
13830 * rs -----
13831 * rd -----
13832 */
13833std::string NMD::SH_S9_(uint64 instruction)
13834{
13835 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13836 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13837 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13838
13839 std::string rt = GPR(copy(rt_value));
13840 std::string s = IMMEDIATE(copy(s_value));
13841 std::string rs = GPR(copy(rs_value));
13842
13843 return img::format("SH %s, %s(%s)", rt, s, rs);
13844}
13845
13846
13847/*
13848 *
13849 *
13850 * 3 2 1
13851 * 10987654321098765432109876543210
13852 * 001000 01001001101
13853 * rt -----
13854 * rs -----
13855 * rd -----
13856 */
13857std::string NMD::SH_U12_(uint64 instruction)
13858{
13859 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13860 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13861 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13862
13863 std::string rt = GPR(copy(rt_value));
13864 std::string u = IMMEDIATE(copy(u_value));
13865 std::string rs = GPR(copy(rs_value));
13866
13867 return img::format("SH %s, %s(%s)", rt, u, rs);
13868}
13869
13870
13871/*
13872 *
13873 *
13874 * 3 2 1
13875 * 10987654321098765432109876543210
13876 * 001000 01001001101
13877 * rt -----
13878 * rs -----
13879 * rd -----
13880 */
13881std::string NMD::SHE(uint64 instruction)
13882{
13883 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13884 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
13885 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13886
13887 std::string rt = GPR(copy(rt_value));
13888 std::string s = IMMEDIATE(copy(s_value));
13889 std::string rs = GPR(copy(rs_value));
13890
13891 return img::format("SHE %s, %s(%s)", rt, s, rs);
13892}
13893
13894
13895/*
13896 * SHILO ac, shift - Shift an Accumulator Value Leaving the Result in the Same
13897 * Accumulator
13898 *
13899 * 3 2 1
13900 * 10987654321098765432109876543210
13901 * 001000xxxx xxxx0000011101
13902 * shift ------
13903 * ac --
13904 */
13905std::string NMD::SHILO(uint64 instruction)
13906{
13907 int64 shift_value = extract_shift_21_20_19_18_17_16(instruction);
13908 uint64 ac_value = extract_ac_13_12(instruction);
13909
13910 std::string shift = IMMEDIATE(copy(shift_value));
13911 std::string ac = AC(copy(ac_value));
13912
13913 return img::format("SHILO %s, %s", ac, shift);
13914}
13915
13916
13917/*
13918 * SHILOV ac, rs - Variable Shift of Accumulator Value Leaving the Result in
13919 * the Same Accumulator
13920 *
13921 * 3 2 1
13922 * 10987654321098765432109876543210
13923 * 001000xxxxx 01001001111111
13924 * rs -----
13925 * ac --
13926 */
13927std::string NMD::SHILOV(uint64 instruction)
13928{
13929 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13930 uint64 ac_value = extract_ac_13_12(instruction);
13931
13932 std::string rs = GPR(copy(rs_value));
13933 std::string ac = AC(copy(ac_value));
13934
13935 return img::format("SHILOV %s, %s", ac, rs);
13936}
13937
13938
13939/*
13940 * SHLL.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords
13941 *
13942 * 3 2 1
13943 * 10987654321098765432109876543210
13944 * 001000 001110110101
13945 * rt -----
13946 * rs -----
13947 * sa ----
13948 */
13949std::string NMD::SHLL_PH(uint64 instruction)
13950{
13951 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13953 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13954
13955 std::string rt = GPR(copy(rt_value));
13956 std::string rs = GPR(copy(rs_value));
13957 std::string sa = IMMEDIATE(copy(sa_value));
13958
13959 return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
13960}
13961
13962
13963/*
13964 * SHLL.QB rt, rs, sa - Shift Left Logical Vector Quad Bytes
13965 *
13966 * 3 2 1
13967 * 10987654321098765432109876543210
13968 * 001000 0100001111111
13969 * rt -----
13970 * rs -----
13971 * sa ---
13972 */
13973std::string NMD::SHLL_QB(uint64 instruction)
13974{
13975 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13976 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13977 uint64 sa_value = extract_sa_15_14_13(instruction);
13978
13979 std::string rt = GPR(copy(rt_value));
13980 std::string rs = GPR(copy(rs_value));
13981 std::string sa = IMMEDIATE(copy(sa_value));
13982
13983 return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
13984}
13985
13986
13987/*
13988 * SHLL_S.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords (saturated)
13989 *
13990 * 3 2 1
13991 * 10987654321098765432109876543210
13992 * 001000 001110110101
13993 * rt -----
13994 * rs -----
13995 * sa ----
13996 */
13997std::string NMD::SHLL_S_PH(uint64 instruction)
13998{
13999 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14000 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14001 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14002
14003 std::string rt = GPR(copy(rt_value));
14004 std::string rs = GPR(copy(rs_value));
14005 std::string sa = IMMEDIATE(copy(sa_value));
14006
14007 return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
14008}
14009
14010
14011/*
14012 *
14013 *
14014 * 3 2 1
14015 * 10987654321098765432109876543210
14016 * 001000 01001001101
14017 * rt -----
14018 * rs -----
14019 * rd -----
14020 */
14021std::string NMD::SHLL_S_W(uint64 instruction)
14022{
14023 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14024 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14025 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14026
14027 std::string rt = GPR(copy(rt_value));
14028 std::string rs = GPR(copy(rs_value));
14029 std::string sa = IMMEDIATE(copy(sa_value));
14030
14031 return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
14032}
14033
14034
14035/*
14036 *
14037 *
14038 * 3 2 1
14039 * 10987654321098765432109876543210
14040 * 001000 01001001101
14041 * rt -----
14042 * rs -----
14043 * rd -----
14044 */
14045std::string NMD::SHLLV_PH(uint64 instruction)
14046{
14047 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14048 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14049 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14050
14051 std::string rd = GPR(copy(rd_value));
14052 std::string rt = GPR(copy(rt_value));
14053 std::string rs = GPR(copy(rs_value));
14054
14055 return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
14056}
14057
14058
14059/*
14060 *
14061 *
14062 * 3 2 1
14063 * 10987654321098765432109876543210
14064 * 001000 01001001101
14065 * rt -----
14066 * rs -----
14067 * rd -----
14068 */
14069std::string NMD::SHLLV_QB(uint64 instruction)
14070{
14071 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14072 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14073 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14074
14075 std::string rd = GPR(copy(rd_value));
14076 std::string rt = GPR(copy(rt_value));
14077 std::string rs = GPR(copy(rs_value));
14078
14079 return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
14080}
14081
14082
14083/*
14084 *
14085 *
14086 * 3 2 1
14087 * 10987654321098765432109876543210
14088 * 001000 01001001101
14089 * rt -----
14090 * rs -----
14091 * rd -----
14092 */
14093std::string NMD::SHLLV_S_PH(uint64 instruction)
14094{
14095 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14096 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14097 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14098
14099 std::string rd = GPR(copy(rd_value));
14100 std::string rt = GPR(copy(rt_value));
14101 std::string rs = GPR(copy(rs_value));
14102
14103 return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
14104}
14105
14106
14107/*
14108 *
14109 *
14110 * 3 2 1
14111 * 10987654321098765432109876543210
14112 * 001000 01001001101
14113 * rt -----
14114 * rs -----
14115 * rd -----
14116 */
14117std::string NMD::SHLLV_S_W(uint64 instruction)
14118{
14119 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14120 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14121 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14122
14123 std::string rd = GPR(copy(rd_value));
14124 std::string rt = GPR(copy(rt_value));
14125 std::string rs = GPR(copy(rs_value));
14126
14127 return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
14128}
14129
14130
14131/*
14132 *
14133 *
14134 * 3 2 1
14135 * 10987654321098765432109876543210
14136 * 001000 01001001101
14137 * rt -----
14138 * rs -----
14139 * rd -----
14140 */
14141std::string NMD::SHRA_PH(uint64 instruction)
14142{
14143 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14144 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14145 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14146
14147 std::string rt = GPR(copy(rt_value));
14148 std::string rs = GPR(copy(rs_value));
14149 std::string sa = IMMEDIATE(copy(sa_value));
14150
14151 return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
14152}
14153
14154
14155/*
14156 *
14157 *
14158 * 3 2 1
14159 * 10987654321098765432109876543210
14160 * 001000 01001001101
14161 * rt -----
14162 * rs -----
14163 * rd -----
14164 */
14165std::string NMD::SHRA_QB(uint64 instruction)
14166{
14167 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14168 uint64 sa_value = extract_sa_15_14_13(instruction);
14169 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14170
14171 std::string rt = GPR(copy(rt_value));
14172 std::string rs = GPR(copy(rs_value));
14173 std::string sa = IMMEDIATE(copy(sa_value));
14174
14175 return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
14176}
14177
14178
14179/*
14180 *
14181 *
14182 * 3 2 1
14183 * 10987654321098765432109876543210
14184 * 001000 01001001101
14185 * rt -----
14186 * rs -----
14187 * rd -----
14188 */
14189std::string NMD::SHRA_R_PH(uint64 instruction)
14190{
14191 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14192 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14193 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14194
14195 std::string rt = GPR(copy(rt_value));
14196 std::string rs = GPR(copy(rs_value));
14197 std::string sa = IMMEDIATE(copy(sa_value));
14198
14199 return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
14200}
14201
14202
14203/*
14204 *
14205 *
14206 * 3 2 1
14207 * 10987654321098765432109876543210
14208 * 001000 01001001101
14209 * rt -----
14210 * rs -----
14211 * rd -----
14212 */
14213std::string NMD::SHRA_R_QB(uint64 instruction)
14214{
14215 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14216 uint64 sa_value = extract_sa_15_14_13(instruction);
14217 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14218
14219 std::string rt = GPR(copy(rt_value));
14220 std::string rs = GPR(copy(rs_value));
14221 std::string sa = IMMEDIATE(copy(sa_value));
14222
14223 return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
14224}
14225
14226
14227/*
14228 *
14229 *
14230 * 3 2 1
14231 * 10987654321098765432109876543210
14232 * 001000 01001001101
14233 * rt -----
14234 * rs -----
14235 * rd -----
14236 */
14237std::string NMD::SHRA_R_W(uint64 instruction)
14238{
14239 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14240 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14242
14243 std::string rt = GPR(copy(rt_value));
14244 std::string rs = GPR(copy(rs_value));
14245 std::string sa = IMMEDIATE(copy(sa_value));
14246
14247 return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
14248}
14249
14250
14251/*
14252 *
14253 *
14254 * 3 2 1
14255 * 10987654321098765432109876543210
14256 * 001000 01001001101
14257 * rt -----
14258 * rs -----
14259 * rd -----
14260 */
14261std::string NMD::SHRAV_PH(uint64 instruction)
14262{
14263 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14264 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14265 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14266
14267 std::string rd = GPR(copy(rd_value));
14268 std::string rt = GPR(copy(rt_value));
14269 std::string rs = GPR(copy(rs_value));
14270
14271 return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
14272}
14273
14274
14275/*
14276 *
14277 *
14278 * 3 2 1
14279 * 10987654321098765432109876543210
14280 * 001000 01001001101
14281 * rt -----
14282 * rs -----
14283 * rd -----
14284 */
14285std::string NMD::SHRAV_QB(uint64 instruction)
14286{
14287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14288 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14289 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14290
14291 std::string rd = GPR(copy(rd_value));
14292 std::string rt = GPR(copy(rt_value));
14293 std::string rs = GPR(copy(rs_value));
14294
14295 return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
14296}
14297
14298
14299/*
14300 *
14301 *
14302 * 3 2 1
14303 * 10987654321098765432109876543210
14304 * 001000 01001001101
14305 * rt -----
14306 * rs -----
14307 * rd -----
14308 */
14309std::string NMD::SHRAV_R_PH(uint64 instruction)
14310{
14311 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14312 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14313 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14314
14315 std::string rd = GPR(copy(rd_value));
14316 std::string rt = GPR(copy(rt_value));
14317 std::string rs = GPR(copy(rs_value));
14318
14319 return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
14320}
14321
14322
14323/*
14324 *
14325 *
14326 * 3 2 1
14327 * 10987654321098765432109876543210
14328 * 001000 01001001101
14329 * rt -----
14330 * rs -----
14331 * rd -----
14332 */
14333std::string NMD::SHRAV_R_QB(uint64 instruction)
14334{
14335 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14336 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14337 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14338
14339 std::string rd = GPR(copy(rd_value));
14340 std::string rt = GPR(copy(rt_value));
14341 std::string rs = GPR(copy(rs_value));
14342
14343 return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
14344}
14345
14346
14347/*
14348 *
14349 *
14350 * 3 2 1
14351 * 10987654321098765432109876543210
14352 * 001000 01001001101
14353 * rt -----
14354 * rs -----
14355 * rd -----
14356 */
14357std::string NMD::SHRAV_R_W(uint64 instruction)
14358{
14359 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14360 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14361 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14362
14363 std::string rd = GPR(copy(rd_value));
14364 std::string rt = GPR(copy(rt_value));
14365 std::string rs = GPR(copy(rs_value));
14366
14367 return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
14368}
14369
14370
14371/*
14372 *
14373 *
14374 * 3 2 1
14375 * 10987654321098765432109876543210
14376 * 001000 01001001101
14377 * rt -----
14378 * rs -----
14379 * rd -----
14380 */
14381std::string NMD::SHRL_PH(uint64 instruction)
14382{
14383 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14384 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14385 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14386
14387 std::string rt = GPR(copy(rt_value));
14388 std::string rs = GPR(copy(rs_value));
14389 std::string sa = IMMEDIATE(copy(sa_value));
14390
14391 return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
14392}
14393
14394
14395/*
14396 *
14397 *
14398 * 3 2 1
14399 * 10987654321098765432109876543210
14400 * 001000 01001001101
14401 * rt -----
14402 * rs -----
14403 * rd -----
14404 */
14405std::string NMD::SHRL_QB(uint64 instruction)
14406{
14407 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14408 uint64 sa_value = extract_sa_15_14_13(instruction);
14409 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14410
14411 std::string rt = GPR(copy(rt_value));
14412 std::string rs = GPR(copy(rs_value));
14413 std::string sa = IMMEDIATE(copy(sa_value));
14414
14415 return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
14416}
14417
14418
14419/*
14420 *
14421 *
14422 * 3 2 1
14423 * 10987654321098765432109876543210
14424 * 001000 01001001101
14425 * rt -----
14426 * rs -----
14427 * rd -----
14428 */
14429std::string NMD::SHRLV_PH(uint64 instruction)
14430{
14431 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14432 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14433 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14434
14435 std::string rd = GPR(copy(rd_value));
14436 std::string rt = GPR(copy(rt_value));
14437 std::string rs = GPR(copy(rs_value));
14438
14439 return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14440}
14441
14442
14443/*
14444 *
14445 *
14446 * 3 2 1
14447 * 10987654321098765432109876543210
14448 * 001000 01001001101
14449 * rt -----
14450 * rs -----
14451 * rd -----
14452 */
14453std::string NMD::SHRLV_QB(uint64 instruction)
14454{
14455 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14456 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14457 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14458
14459 std::string rd = GPR(copy(rd_value));
14460 std::string rt = GPR(copy(rt_value));
14461 std::string rs = GPR(copy(rs_value));
14462
14463 return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14464}
14465
14466
14467/*
14468 *
14469 *
14470 * 3 2 1
14471 * 10987654321098765432109876543210
14472 * 001000 01001001101
14473 * rt -----
14474 * rs -----
14475 * rd -----
14476 */
14477std::string NMD::SHX(uint64 instruction)
14478{
14479 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14480 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14481 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14482
14483 std::string rd = GPR(copy(rd_value));
14484 std::string rs = GPR(copy(rs_value));
14485 std::string rt = GPR(copy(rt_value));
14486
14487 return img::format("SHX %s, %s(%s)", rd, rs, rt);
14488}
14489
14490
14491/*
14492 *
14493 *
14494 * 3 2 1
14495 * 10987654321098765432109876543210
14496 * 001000 01001001101
14497 * rt -----
14498 * rs -----
14499 * rd -----
14500 */
14501std::string NMD::SHXS(uint64 instruction)
14502{
14503 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14504 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14505 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14506
14507 std::string rd = GPR(copy(rd_value));
14508 std::string rs = GPR(copy(rs_value));
14509 std::string rt = GPR(copy(rt_value));
14510
14511 return img::format("SHXS %s, %s(%s)", rd, rs, rt);
14512}
14513
14514
14515/*
14516 *
14517 *
14518 * 3 2 1
14519 * 10987654321098765432109876543210
14520 * 001000 01001001101
14521 * rt -----
14522 * rs -----
14523 * rd -----
14524 */
14525std::string NMD::SIGRIE(uint64 instruction)
14526{
14527 uint64 code_value = extract_code_18_to_0(instruction);
14528
14529 std::string code = IMMEDIATE(copy(code_value));
14530
14531 return img::format("SIGRIE %s", code);
14532}
14533
14534
14535/*
14536 *
14537 *
14538 * 3 2 1
14539 * 10987654321098765432109876543210
14540 * 001000 01001001101
14541 * rt -----
14542 * rs -----
14543 * rd -----
14544 */
14545std::string NMD::SLL_16_(uint64 instruction)
14546{
14547 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14548 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14549 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14550
14551 std::string rt3 = GPR(encode_gpr3(rt3_value));
14552 std::string rs3 = GPR(encode_gpr3(rs3_value));
14553 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14554
14555 return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
14556}
14557
14558
14559/*
14560 *
14561 *
14562 * 3 2 1
14563 * 10987654321098765432109876543210
14564 * 001000 01001001101
14565 * rt -----
14566 * rs -----
14567 * rd -----
14568 */
14569std::string NMD::SLL_32_(uint64 instruction)
14570{
14571 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14572 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14573 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14574
14575 std::string rt = GPR(copy(rt_value));
14576 std::string rs = GPR(copy(rs_value));
14577 std::string shift = IMMEDIATE(copy(shift_value));
14578
14579 return img::format("SLL %s, %s, %s", rt, rs, shift);
14580}
14581
14582
14583/*
14584 *
14585 *
14586 * 3 2 1
14587 * 10987654321098765432109876543210
14588 * 001000 01001001101
14589 * rt -----
14590 * rs -----
14591 * rd -----
14592 */
14593std::string NMD::SLLV(uint64 instruction)
14594{
14595 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14596 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14597 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14598
14599 std::string rd = GPR(copy(rd_value));
14600 std::string rs = GPR(copy(rs_value));
14601 std::string rt = GPR(copy(rt_value));
14602
14603 return img::format("SLLV %s, %s, %s", rd, rs, rt);
14604}
14605
14606
14607/*
14608 *
14609 *
14610 * 3 2 1
14611 * 10987654321098765432109876543210
14612 * 001000 01001001101
14613 * rt -----
14614 * rs -----
14615 * rd -----
14616 */
14617std::string NMD::SLT(uint64 instruction)
14618{
14619 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14620 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14621 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14622
14623 std::string rd = GPR(copy(rd_value));
14624 std::string rs = GPR(copy(rs_value));
14625 std::string rt = GPR(copy(rt_value));
14626
14627 return img::format("SLT %s, %s, %s", rd, rs, rt);
14628}
14629
14630
14631/*
14632 *
14633 *
14634 * 3 2 1
14635 * 10987654321098765432109876543210
14636 * 001000 01001001101
14637 * rt -----
14638 * rs -----
14639 * rd -----
14640 */
14641std::string NMD::SLTI(uint64 instruction)
14642{
14643 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14644 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14645 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14646
14647 std::string rt = GPR(copy(rt_value));
14648 std::string rs = GPR(copy(rs_value));
14649 std::string u = IMMEDIATE(copy(u_value));
14650
14651 return img::format("SLTI %s, %s, %s", rt, rs, u);
14652}
14653
14654
14655/*
14656 *
14657 *
14658 * 3 2 1
14659 * 10987654321098765432109876543210
14660 * 001000 01001001101
14661 * rt -----
14662 * rs -----
14663 * rd -----
14664 */
14665std::string NMD::SLTIU(uint64 instruction)
14666{
14667 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14668 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14669 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14670
14671 std::string rt = GPR(copy(rt_value));
14672 std::string rs = GPR(copy(rs_value));
14673 std::string u = IMMEDIATE(copy(u_value));
14674
14675 return img::format("SLTIU %s, %s, %s", rt, rs, u);
14676}
14677
14678
14679/*
14680 *
14681 *
14682 * 3 2 1
14683 * 10987654321098765432109876543210
14684 * 001000 01001001101
14685 * rt -----
14686 * rs -----
14687 * rd -----
14688 */
14689std::string NMD::SLTU(uint64 instruction)
14690{
14691 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14692 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14693 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14694
14695 std::string rd = GPR(copy(rd_value));
14696 std::string rs = GPR(copy(rs_value));
14697 std::string rt = GPR(copy(rt_value));
14698
14699 return img::format("SLTU %s, %s, %s", rd, rs, rt);
14700}
14701
14702
14703/*
14704 *
14705 *
14706 * 3 2 1
14707 * 10987654321098765432109876543210
14708 * 001000 01001001101
14709 * rt -----
14710 * rs -----
14711 * rd -----
14712 */
14713std::string NMD::SOV(uint64 instruction)
14714{
14715 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14716 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14717 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14718
14719 std::string rd = GPR(copy(rd_value));
14720 std::string rs = GPR(copy(rs_value));
14721 std::string rt = GPR(copy(rt_value));
14722
14723 return img::format("SOV %s, %s, %s", rd, rs, rt);
14724}
14725
14726
14727/*
14728 *
14729 *
14730 * 3 2 1
14731 * 10987654321098765432109876543210
14732 * 001000 01001001101
14733 * rt -----
14734 * rs -----
14735 * rd -----
14736 */
14737std::string NMD::SPECIAL2(uint64 instruction)
14738{
14739 uint64 op_value = extract_op_25_to_3(instruction);
14740
14741 std::string op = IMMEDIATE(copy(op_value));
14742
14743 return img::format("SPECIAL2 %s", op);
14744}
14745
14746
14747/*
14748 *
14749 *
14750 * 3 2 1
14751 * 10987654321098765432109876543210
14752 * 001000 01001001101
14753 * rt -----
14754 * rs -----
14755 * rd -----
14756 */
14757std::string NMD::SQRT_D(uint64 instruction)
14758{
14759 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14760 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14761
14762 std::string ft = FPR(copy(ft_value));
14763 std::string fs = FPR(copy(fs_value));
14764
14765 return img::format("SQRT.D %s, %s", ft, fs);
14766}
14767
14768
14769/*
14770 *
14771 *
14772 * 3 2 1
14773 * 10987654321098765432109876543210
14774 * 001000 01001001101
14775 * rt -----
14776 * rs -----
14777 * rd -----
14778 */
14779std::string NMD::SQRT_S(uint64 instruction)
14780{
14781 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14782 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14783
14784 std::string ft = FPR(copy(ft_value));
14785 std::string fs = FPR(copy(fs_value));
14786
14787 return img::format("SQRT.S %s, %s", ft, fs);
14788}
14789
14790
14791/*
14792 * SRA rd, rt, sa - Shift Word Right Arithmetic
14793 *
14794 * 3 2 1
14795 * 10987654321098765432109876543210
14796 * 00000000000 000011
14797 * rt -----
14798 * rd -----
14799 * sa -----
14800 */
14801std::string NMD::SRA(uint64 instruction)
14802{
14803 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14804 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14805 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14806
14807 std::string rt = GPR(copy(rt_value));
14808 std::string rs = GPR(copy(rs_value));
14809 std::string shift = IMMEDIATE(copy(shift_value));
14810
14811 return img::format("SRA %s, %s, %s", rt, rs, shift);
14812}
14813
14814
14815/*
14816 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14817 *
14818 * 3 2 1
14819 * 10987654321098765432109876543210
14820 * 001000 00000000111
14821 * rs -----
14822 * rt -----
14823 * rd -----
14824 */
14825std::string NMD::SRAV(uint64 instruction)
14826{
14827 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14828 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14829 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14830
14831 std::string rd = GPR(copy(rd_value));
14832 std::string rs = GPR(copy(rs_value));
14833 std::string rt = GPR(copy(rt_value));
14834
14835 return img::format("SRAV %s, %s, %s", rd, rs, rt);
14836}
14837
14838
14839/*
14840 *
14841 *
14842 * 3 2 1
14843 * 10987654321098765432109876543210
14844 * 001000 00000000111
14845 * rs -----
14846 * rt -----
14847 * rd -----
14848 */
14849std::string NMD::SRL_16_(uint64 instruction)
14850{
14851 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14852 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14853 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14854
14855 std::string rt3 = GPR(encode_gpr3(rt3_value));
14856 std::string rs3 = GPR(encode_gpr3(rs3_value));
14857 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14858
14859 return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
14860}
14861
14862
14863/*
14864 *
14865 *
14866 * 3 2 1
14867 * 10987654321098765432109876543210
14868 * 001000 01001001101
14869 * rt -----
14870 * rs -----
14871 * rd -----
14872 */
14873std::string NMD::SRL_32_(uint64 instruction)
14874{
14875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14876 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14877 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14878
14879 std::string rt = GPR(copy(rt_value));
14880 std::string rs = GPR(copy(rs_value));
14881 std::string shift = IMMEDIATE(copy(shift_value));
14882
14883 return img::format("SRL %s, %s, %s", rt, rs, shift);
14884}
14885
14886
14887/*
14888 *
14889 *
14890 * 3 2 1
14891 * 10987654321098765432109876543210
14892 * 001000 01001001101
14893 * rt -----
14894 * rs -----
14895 * rd -----
14896 */
14897std::string NMD::SRLV(uint64 instruction)
14898{
14899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14900 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14901 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14902
14903 std::string rd = GPR(copy(rd_value));
14904 std::string rs = GPR(copy(rs_value));
14905 std::string rt = GPR(copy(rt_value));
14906
14907 return img::format("SRLV %s, %s, %s", rd, rs, rt);
14908}
14909
14910
14911/*
14912 *
14913 *
14914 * 3 2 1
14915 * 10987654321098765432109876543210
14916 * 001000 01001001101
14917 * rt -----
14918 * rs -----
14919 * rd -----
14920 */
14921std::string NMD::SUB(uint64 instruction)
14922{
14923 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14924 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14925 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14926
14927 std::string rd = GPR(copy(rd_value));
14928 std::string rs = GPR(copy(rs_value));
14929 std::string rt = GPR(copy(rt_value));
14930
14931 return img::format("SUB %s, %s, %s", rd, rs, rt);
14932}
14933
14934
14935/*
14936 *
14937 *
14938 * 3 2 1
14939 * 10987654321098765432109876543210
14940 * 001000 01001001101
14941 * rt -----
14942 * rs -----
14943 * rd -----
14944 */
14945std::string NMD::SUB_D(uint64 instruction)
14946{
14947 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14948 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14949 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
14950
14951 std::string fd = FPR(copy(fd_value));
14952 std::string fs = FPR(copy(fs_value));
14953 std::string ft = FPR(copy(ft_value));
14954
14955 return img::format("SUB.D %s, %s, %s", fd, fs, ft);
14956}
14957
14958
14959/*
14960 *
14961 *
14962 * 3 2 1
14963 * 10987654321098765432109876543210
14964 * 001000 01001001101
14965 * rt -----
14966 * rs -----
14967 * rd -----
14968 */
14969std::string NMD::SUB_S(uint64 instruction)
14970{
14971 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
14972 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
14973 uint64 fd_value = extract_fd_10_9_8_7_6(instruction);
14974
14975 std::string fd = FPR(copy(fd_value));
14976 std::string fs = FPR(copy(fs_value));
14977 std::string ft = FPR(copy(ft_value));
14978
14979 return img::format("SUB.S %s, %s, %s", fd, fs, ft);
14980}
14981
14982
14983/*
14984 *
14985 *
14986 * 3 2 1
14987 * 10987654321098765432109876543210
14988 * 001000 01001001101
14989 * rt -----
14990 * rs -----
14991 * rd -----
14992 */
14993std::string NMD::SUBQ_PH(uint64 instruction)
14994{
14995 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14996 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
14997 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14998
14999 std::string rd = GPR(copy(rd_value));
15000 std::string rs = GPR(copy(rs_value));
15001 std::string rt = GPR(copy(rt_value));
15002
15003 return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
15004}
15005
15006
15007/*
15008 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15009 * to Halve Results
15010 *
15011 * 3 2 1
15012 * 10987654321098765432109876543210
15013 * 001000 01001001101
15014 * rt -----
15015 * rs -----
15016 * rd -----
15017 */
15018std::string NMD::SUBQ_S_PH(uint64 instruction)
15019{
15020 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15021 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15022 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15023
15024 std::string rd = GPR(copy(rd_value));
15025 std::string rs = GPR(copy(rs_value));
15026 std::string rt = GPR(copy(rt_value));
15027
15028 return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
15029}
15030
15031
15032/*
15033 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15034 * to Halve Results
15035 *
15036 * 3 2 1
15037 * 10987654321098765432109876543210
15038 * 001000 01001001101
15039 * rt -----
15040 * rs -----
15041 * rd -----
15042 */
15043std::string NMD::SUBQ_S_W(uint64 instruction)
15044{
15045 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15046 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15047 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15048
15049 std::string rd = GPR(copy(rd_value));
15050 std::string rs = GPR(copy(rs_value));
15051 std::string rt = GPR(copy(rt_value));
15052
15053 return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
15054}
15055
15056
15057/*
15058 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15059 * to Halve Results
15060 *
15061 * 3 2 1
15062 * 10987654321098765432109876543210
15063 * 001000 01001001101
15064 * rt -----
15065 * rs -----
15066 * rd -----
15067 */
15068std::string NMD::SUBQH_PH(uint64 instruction)
15069{
15070 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15071 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15072 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15073
15074 std::string rd = GPR(copy(rd_value));
15075 std::string rs = GPR(copy(rs_value));
15076 std::string rt = GPR(copy(rt_value));
15077
15078 return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
15079}
15080
15081
15082/*
15083 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15084 * to Halve Results
15085 *
15086 * 3 2 1
15087 * 10987654321098765432109876543210
15088 * 001000 01001001101
15089 * rt -----
15090 * rs -----
15091 * rd -----
15092 */
15093std::string NMD::SUBQH_R_PH(uint64 instruction)
15094{
15095 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15096 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15097 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15098
15099 std::string rd = GPR(copy(rd_value));
15100 std::string rs = GPR(copy(rs_value));
15101 std::string rt = GPR(copy(rt_value));
15102
15103 return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
15104}
15105
15106
15107/*
15108 * SUBQH_R.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15109 * to Halve Results (rounding)
15110 *
15111 * 3 2 1
15112 * 10987654321098765432109876543210
15113 * 001000 11001001101
15114 * rt -----
15115 * rs -----
15116 * rd -----
15117 */
15118std::string NMD::SUBQH_R_W(uint64 instruction)
15119{
15120 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15121 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15122 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15123
15124 std::string rd = GPR(copy(rd_value));
15125 std::string rs = GPR(copy(rs_value));
15126 std::string rt = GPR(copy(rt_value));
15127
15128 return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
15129}
15130
15131
15132/*
15133 * SUBQH.W rd, rs, rt - Subtract Fractional Words And Shift Right to Halve
15134 * Results
15135 *
15136 * 3 2 1
15137 * 10987654321098765432109876543210
15138 * 001000 01010001101
15139 * rt -----
15140 * rs -----
15141 * rd -----
15142 */
15143std::string NMD::SUBQH_W(uint64 instruction)
15144{
15145 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15146 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15147 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15148
15149 std::string rd = GPR(copy(rd_value));
15150 std::string rs = GPR(copy(rs_value));
15151 std::string rt = GPR(copy(rt_value));
15152
15153 return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
15154}
15155
15156
15157/*
15158 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15159 *
15160 * 3 2 1
15161 * 10987654321098765432109876543210
15162 * 001000 00010001101
15163 * rt -----
15164 * rs -----
15165 * rd -----
15166 */
15167std::string NMD::SUBU_16_(uint64 instruction)
15168{
15169 uint64 rd3_value = extract_rd3_3_2_1(instruction);
15170 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15171 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15172
15173 std::string rd3 = GPR(encode_gpr3(rd3_value));
15174 std::string rs3 = GPR(encode_gpr3(rs3_value));
15175 std::string rt3 = GPR(encode_gpr3(rt3_value));
15176
15177 return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
15178}
15179
15180
15181/*
15182 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15183 *
15184 * 3 2 1
15185 * 10987654321098765432109876543210
15186 * 001000 00010001101
15187 * rt -----
15188 * rs -----
15189 * rd -----
15190 */
15191std::string NMD::SUBU_32_(uint64 instruction)
15192{
15193 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15194 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15195 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15196
15197 std::string rd = GPR(copy(rd_value));
15198 std::string rs = GPR(copy(rs_value));
15199 std::string rt = GPR(copy(rt_value));
15200
15201 return img::format("SUBU %s, %s, %s", rd, rs, rt);
15202}
15203
15204
15205/*
15206 * SUBU.PH rd, rs, rt - Subtract Unsigned Integer Halfwords
15207 *
15208 * 3 2 1
15209 * 10987654321098765432109876543210
15210 * 001000 01100001101
15211 * rt -----
15212 * rs -----
15213 * rd -----
15214 */
15215std::string NMD::SUBU_PH(uint64 instruction)
15216{
15217 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15218 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15219 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15220
15221 std::string rd = GPR(copy(rd_value));
15222 std::string rs = GPR(copy(rs_value));
15223 std::string rt = GPR(copy(rt_value));
15224
15225 return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
15226}
15227
15228
15229/*
15230 * SUBU.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector
15231 *
15232 * 3 2 1
15233 * 10987654321098765432109876543210
15234 * 001000 01011001101
15235 * rt -----
15236 * rs -----
15237 * rd -----
15238 */
15239std::string NMD::SUBU_QB(uint64 instruction)
15240{
15241 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15242 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15243 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15244
15245 std::string rd = GPR(copy(rd_value));
15246 std::string rs = GPR(copy(rs_value));
15247 std::string rt = GPR(copy(rt_value));
15248
15249 return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
15250}
15251
15252
15253/*
15254 * SUBU_S.PH rd, rs, rt - Subtract Unsigned Integer Halfwords (saturating)
15255 *
15256 * 3 2 1
15257 * 10987654321098765432109876543210
15258 * 001000 11100001101
15259 * rt -----
15260 * rs -----
15261 * rd -----
15262 */
15263std::string NMD::SUBU_S_PH(uint64 instruction)
15264{
15265 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15266 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15267 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15268
15269 std::string rd = GPR(copy(rd_value));
15270 std::string rs = GPR(copy(rs_value));
15271 std::string rt = GPR(copy(rt_value));
15272
15273 return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
15274}
15275
15276
15277/*
15278 * SUBU_S.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector (saturating)
15279 *
15280 * 3 2 1
15281 * 10987654321098765432109876543210
15282 * 001000 11011001101
15283 * rt -----
15284 * rs -----
15285 * rd -----
15286 */
15287std::string NMD::SUBU_S_QB(uint64 instruction)
15288{
15289 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15290 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15291 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15292
15293 std::string rd = GPR(copy(rd_value));
15294 std::string rs = GPR(copy(rs_value));
15295 std::string rt = GPR(copy(rt_value));
15296
15297 return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
15298}
15299
15300
15301/*
15302 * SUBUH.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15303 * Results
15304 *
15305 * 3 2 1
15306 * 10987654321098765432109876543210
15307 * 001000 01101001101
15308 * rt -----
15309 * rs -----
15310 * rd -----
15311 */
15312std::string NMD::SUBUH_QB(uint64 instruction)
15313{
15314 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15315 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15316 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15317
15318 std::string rd = GPR(copy(rd_value));
15319 std::string rs = GPR(copy(rs_value));
15320 std::string rt = GPR(copy(rt_value));
15321
15322 return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
15323}
15324
15325
15326/*
15327 * SUBUH_R.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15328 * Results (rounding)
15329 *
15330 * 3 2 1
15331 * 10987654321098765432109876543210
15332 * 001000 11101001101
15333 * rt -----
15334 * rs -----
15335 * rd -----
15336 */
15337std::string NMD::SUBUH_R_QB(uint64 instruction)
15338{
15339 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15340 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15341 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15342
15343 std::string rd = GPR(copy(rd_value));
15344 std::string rs = GPR(copy(rs_value));
15345 std::string rt = GPR(copy(rt_value));
15346
15347 return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
15348}
15349
15350
15351/*
15352 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15353 *
15354 * 3 2 1
15355 * 10987654321098765432109876543210
15356 * 001000 00010001101
15357 * rt -----
15358 * rs -----
15359 * rd -----
15360 */
15361std::string NMD::SW_16_(uint64 instruction)
15362{
15363 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15364 uint64 u_value = extr_uil0il2bs4Fmsb5(instruction);
15365 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15366
15367 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
15368 std::string u = IMMEDIATE(copy(u_value));
15369 std::string rs3 = GPR(encode_gpr3(rs3_value));
15370
15371 return img::format("SW %s, %s(%s)", rtz3, u, rs3);
15372}
15373
15374
15375/*
15376 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15377 *
15378 * 3 2 1
15379 * 10987654321098765432109876543210
15380 * 001000 00010001101
15381 * rt -----
15382 * rs -----
15383 * rd -----
15384 */
15385std::string NMD::SW_4X4_(uint64 instruction)
15386{
15387 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
15388 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
15389 uint64 u_value = extr_uil3il3bs1_il8il2bs1Fmsb3(instruction);
15390
15391 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
15392 std::string u = IMMEDIATE(copy(u_value));
15393 std::string rs4 = GPR(encode_gpr4(rs4_value));
15394
15395 return img::format("SW %s, %s(%s)", rtz4, u, rs4);
15396}
15397
15398
15399/*
15400 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15401 *
15402 * 3 2 1
15403 * 10987654321098765432109876543210
15404 * 001000 00010001101
15405 * rt -----
15406 * rs -----
15407 * rd -----
15408 */
15409std::string NMD::SW_GP16_(uint64 instruction)
15410{
15411 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15412 uint64 u_value = extr_uil0il2bs7Fmsb8(instruction);
15413
15414 std::string rtz3 = GPR(encode_gpr3_store(rtz3_value));
15415 std::string u = IMMEDIATE(copy(u_value));
15416
15417 return img::format("SW %s, %s($%d)", rtz3, u, 28);
15418}
15419
15420
15421/*
15422 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15423 *
15424 * 3 2 1
15425 * 10987654321098765432109876543210
15426 * 001000 00010001101
15427 * rt -----
15428 * rs -----
15429 * rd -----
15430 */
15431std::string NMD::SW_GP_(uint64 instruction)
15432{
15433 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15434 uint64 u_value = extr_uil2il2bs19Fmsb20(instruction);
15435
15436 std::string rt = GPR(copy(rt_value));
15437 std::string u = IMMEDIATE(copy(u_value));
15438
15439 return img::format("SW %s, %s($%d)", rt, u, 28);
15440}
15441
15442
15443/*
15444 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15445 *
15446 * 3 2 1
15447 * 10987654321098765432109876543210
15448 * 001000 00010001101
15449 * rt -----
15450 * rs -----
15451 * rd -----
15452 */
15453std::string NMD::SW_S9_(uint64 instruction)
15454{
15455 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15456 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15457 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15458
15459 std::string rt = GPR(copy(rt_value));
15460 std::string s = IMMEDIATE(copy(s_value));
15461 std::string rs = GPR(copy(rs_value));
15462
15463 return img::format("SW %s, %s(%s)", rt, s, rs);
15464}
15465
15466
15467/*
15468 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15469 *
15470 * 3 2 1
15471 * 10987654321098765432109876543210
15472 * 001000 00010001101
15473 * rt -----
15474 * rs -----
15475 * rd -----
15476 */
15477std::string NMD::SW_SP_(uint64 instruction)
15478{
15479 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
15480 uint64 u_value = extr_uil0il2bs5Fmsb6(instruction);
15481
15482 std::string rt = GPR(copy(rt_value));
15483 std::string u = IMMEDIATE(copy(u_value));
15484
15485 return img::format("SW %s, %s($%d)", rt, u, 29);
15486}
15487
15488
15489/*
15490 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15491 *
15492 * 3 2 1
15493 * 10987654321098765432109876543210
15494 * 001000 00010001101
15495 * rt -----
15496 * rs -----
15497 * rd -----
15498 */
15499std::string NMD::SW_U12_(uint64 instruction)
15500{
15501 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15502 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15503 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15504
15505 std::string rt = GPR(copy(rt_value));
15506 std::string u = IMMEDIATE(copy(u_value));
15507 std::string rs = GPR(copy(rs_value));
15508
15509 return img::format("SW %s, %s(%s)", rt, u, rs);
15510}
15511
15512
15513/*
15514 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15515 *
15516 * 3 2 1
15517 * 10987654321098765432109876543210
15518 * 001000 00010001101
15519 * rt -----
15520 * rs -----
15521 * rd -----
15522 */
15523std::string NMD::SWC1_GP_(uint64 instruction)
15524{
15525 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15526 uint64 u_value = extr_uil2il2bs16Fmsb17(instruction);
15527
15528 std::string ft = FPR(copy(ft_value));
15529 std::string u = IMMEDIATE(copy(u_value));
15530
15531 return img::format("SWC1 %s, %s($%d)", ft, u, 28);
15532}
15533
15534
15535/*
15536 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15537 *
15538 * 3 2 1
15539 * 10987654321098765432109876543210
15540 * 001000 00010001101
15541 * rt -----
15542 * rs -----
15543 * rd -----
15544 */
15545std::string NMD::SWC1_S9_(uint64 instruction)
15546{
15547 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15548 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15549 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15550
15551 std::string ft = FPR(copy(ft_value));
15552 std::string s = IMMEDIATE(copy(s_value));
15553 std::string rs = GPR(copy(rs_value));
15554
15555 return img::format("SWC1 %s, %s(%s)", ft, s, rs);
15556}
15557
15558
15559/*
15560 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15561 *
15562 * 3 2 1
15563 * 10987654321098765432109876543210
15564 * 001000 00010001101
15565 * rt -----
15566 * rs -----
15567 * rd -----
15568 */
15569std::string NMD::SWC1_U12_(uint64 instruction)
15570{
15571 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
15572 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15573 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15574
15575 std::string ft = FPR(copy(ft_value));
15576 std::string u = IMMEDIATE(copy(u_value));
15577 std::string rs = GPR(copy(rs_value));
15578
15579 return img::format("SWC1 %s, %s(%s)", ft, u, rs);
15580}
15581
15582
15583/*
15584 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15585 *
15586 * 3 2 1
15587 * 10987654321098765432109876543210
15588 * 001000 00010001101
15589 * rt -----
15590 * rs -----
15591 * rd -----
15592 */
15593std::string NMD::SWC1X(uint64 instruction)
15594{
15595 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15596 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15597 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15598
15599 std::string ft = FPR(copy(ft_value));
15600 std::string rs = GPR(copy(rs_value));
15601 std::string rt = GPR(copy(rt_value));
15602
15603 return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
15604}
15605
15606
15607/*
15608 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15609 *
15610 * 3 2 1
15611 * 10987654321098765432109876543210
15612 * 001000 00010001101
15613 * rt -----
15614 * rs -----
15615 * rd -----
15616 */
15617std::string NMD::SWC1XS(uint64 instruction)
15618{
15619 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15620 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15621 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15622
15623 std::string ft = FPR(copy(ft_value));
15624 std::string rs = GPR(copy(rs_value));
15625 std::string rt = GPR(copy(rt_value));
15626
15627 return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
15628}
15629
15630
15631/*
15632 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15633 *
15634 * 3 2 1
15635 * 10987654321098765432109876543210
15636 * 001000 00010001101
15637 * rt -----
15638 * rs -----
15639 * rd -----
15640 */
15641std::string NMD::SWC2(uint64 instruction)
15642{
15643 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15644 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15645 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15646
15647 std::string cs = CPR(copy(cs_value));
15648 std::string s = IMMEDIATE(copy(s_value));
15649 std::string rs = GPR(copy(rs_value));
15650
15651 return img::format("SWC2 %s, %s(%s)", cs, s, rs);
15652}
15653
15654
15655/*
15656 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15657 *
15658 * 3 2 1
15659 * 10987654321098765432109876543210
15660 * 001000 00010001101
15661 * rt -----
15662 * rs -----
15663 * rd -----
15664 */
15665std::string NMD::SWE(uint64 instruction)
15666{
15667 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15668 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15669 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15670
15671 std::string rt = GPR(copy(rt_value));
15672 std::string s = IMMEDIATE(copy(s_value));
15673 std::string rs = GPR(copy(rs_value));
15674
15675 return img::format("SWE %s, %s(%s)", rt, s, rs);
15676}
15677
15678
15679/*
15680 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15681 *
15682 * 3 2 1
15683 * 10987654321098765432109876543210
15684 * 001000 00010001101
15685 * rt -----
15686 * rs -----
15687 * rd -----
15688 */
15689std::string NMD::SWM(uint64 instruction)
15690{
15691 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15692 uint64 count3_value = extract_count3_14_13_12(instruction);
15693 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15694 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15695
15696 std::string rt = GPR(copy(rt_value));
15697 std::string s = IMMEDIATE(copy(s_value));
15698 std::string rs = GPR(copy(rs_value));
15699 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
15700
15701 return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
15702}
15703
15704
15705/*
15706 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15707 *
15708 * 3 2 1
15709 * 10987654321098765432109876543210
15710 * 001000 00010001101
15711 * rt -----
15712 * rs -----
15713 * rd -----
15714 */
15715std::string NMD::SWPC_48_(uint64 instruction)
15716{
15717 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15718 int64 s_value = extr_sil0il16bs16_il16il0bs16Tmsb31(instruction);
15719
15720 std::string rt = GPR(copy(rt_value));
15721 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
15722
15723 return img::format("SWPC %s, %s", rt, s);
15724}
15725
15726
15727/*
15728 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15729 *
15730 * 3 2 1
15731 * 10987654321098765432109876543210
15732 * 001000 00010001101
15733 * rt -----
15734 * rs -----
15735 * rd -----
15736 */
15737std::string NMD::SWX(uint64 instruction)
15738{
15739 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15740 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15741 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15742
15743 std::string rd = GPR(copy(rd_value));
15744 std::string rs = GPR(copy(rs_value));
15745 std::string rt = GPR(copy(rt_value));
15746
15747 return img::format("SWX %s, %s(%s)", rd, rs, rt);
15748}
15749
15750
15751/*
15752 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15753 *
15754 * 3 2 1
15755 * 10987654321098765432109876543210
15756 * 001000 00010001101
15757 * rt -----
15758 * rs -----
15759 * rd -----
15760 */
15761std::string NMD::SWXS(uint64 instruction)
15762{
15763 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15764 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
15765 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15766
15767 std::string rd = GPR(copy(rd_value));
15768 std::string rs = GPR(copy(rs_value));
15769 std::string rt = GPR(copy(rt_value));
15770
15771 return img::format("SWXS %s, %s(%s)", rd, rs, rt);
15772}
15773
15774
15775/*
15776 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15777 *
15778 * 3 2 1
15779 * 10987654321098765432109876543210
15780 * 001000 00010001101
15781 * rt -----
15782 * rs -----
15783 * rd -----
15784 */
15785std::string NMD::SYNC(uint64 instruction)
15786{
15787 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15788
15789 std::string stype = IMMEDIATE(copy(stype_value));
15790
15791 return img::format("SYNC %s", stype);
15792}
15793
15794
15795/*
15796 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15797 *
15798 * 3 2 1
15799 * 10987654321098765432109876543210
15800 * 001000 00010001101
15801 * rt -----
15802 * rs -----
15803 * rd -----
15804 */
15805std::string NMD::SYNCI(uint64 instruction)
15806{
15807 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15808 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15809
15810 std::string s = IMMEDIATE(copy(s_value));
15811 std::string rs = GPR(copy(rs_value));
15812
15813 return img::format("SYNCI %s(%s)", s, rs);
15814}
15815
15816
15817/*
15818 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15819 *
15820 * 3 2 1
15821 * 10987654321098765432109876543210
15822 * 001000 00010001101
15823 * rt -----
15824 * rs -----
15825 * rd -----
15826 */
15827std::string NMD::SYNCIE(uint64 instruction)
15828{
15829 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
15830 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15831
15832 std::string s = IMMEDIATE(copy(s_value));
15833 std::string rs = GPR(copy(rs_value));
15834
15835 return img::format("SYNCIE %s(%s)", s, rs);
15836}
15837
15838
15839/*
15840 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15841 *
15842 * 3 2 1
15843 * 10987654321098765432109876543210
15844 * 001000 00010001101
15845 * rt -----
15846 * rs -----
15847 * rd -----
15848 */
15849std::string NMD::SYSCALL_16_(uint64 instruction)
15850{
15851 uint64 code_value = extract_code_1_0(instruction);
15852
15853 std::string code = IMMEDIATE(copy(code_value));
15854
15855 return img::format("SYSCALL %s", code);
15856}
15857
15858
15859/*
15860 * SYSCALL code - System Call. Cause a System Call Exception
15861 *
15862 * 3 2 1
15863 * 10987654321098765432109876543210
15864 * 00000000000010
15865 * code ------------------
15866 */
15867std::string NMD::SYSCALL_32_(uint64 instruction)
15868{
15869 uint64 code_value = extract_code_17_to_0(instruction);
15870
15871 std::string code = IMMEDIATE(copy(code_value));
15872
15873 return img::format("SYSCALL %s", code);
15874}
15875
15876
15877/*
15878 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15879 *
15880 * 3 2 1
15881 * 10987654321098765432109876543210
15882 * 001000 00010001101
15883 * rt -----
15884 * rs -----
15885 * rd -----
15886 */
15887std::string NMD::TEQ(uint64 instruction)
15888{
15889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15890 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15891
15892 std::string rs = GPR(copy(rs_value));
15893 std::string rt = GPR(copy(rt_value));
15894
15895 return img::format("TEQ %s, %s", rs, rt);
15896}
15897
15898
15899/*
15900 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15901 *
15902 * 3 2 1
15903 * 10987654321098765432109876543210
15904 * 001000 00010001101
15905 * rt -----
15906 * rs -----
15907 * rd -----
15908 */
15909std::string NMD::TLBGINV(uint64 instruction)
15910{
15911 (void)instruction;
15912
15913 return "TLBGINV ";
15914}
15915
15916
15917/*
15918 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15919 *
15920 * 3 2 1
15921 * 10987654321098765432109876543210
15922 * 001000 00010001101
15923 * rt -----
15924 * rs -----
15925 * rd -----
15926 */
15927std::string NMD::TLBGINVF(uint64 instruction)
15928{
15929 (void)instruction;
15930
15931 return "TLBGINVF ";
15932}
15933
15934
15935/*
15936 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15937 *
15938 * 3 2 1
15939 * 10987654321098765432109876543210
15940 * 001000 00010001101
15941 * rt -----
15942 * rs -----
15943 * rd -----
15944 */
15945std::string NMD::TLBGP(uint64 instruction)
15946{
15947 (void)instruction;
15948
15949 return "TLBGP ";
15950}
15951
15952
15953/*
15954 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15955 *
15956 * 3 2 1
15957 * 10987654321098765432109876543210
15958 * 001000 00010001101
15959 * rt -----
15960 * rs -----
15961 * rd -----
15962 */
15963std::string NMD::TLBGR(uint64 instruction)
15964{
15965 (void)instruction;
15966
15967 return "TLBGR ";
15968}
15969
15970
15971/*
15972 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15973 *
15974 * 3 2 1
15975 * 10987654321098765432109876543210
15976 * 001000 00010001101
15977 * rt -----
15978 * rs -----
15979 * rd -----
15980 */
15981std::string NMD::TLBGWI(uint64 instruction)
15982{
15983 (void)instruction;
15984
15985 return "TLBGWI ";
15986}
15987
15988
15989/*
15990 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15991 *
15992 * 3 2 1
15993 * 10987654321098765432109876543210
15994 * 001000 00010001101
15995 * rt -----
15996 * rs -----
15997 * rd -----
15998 */
15999std::string NMD::TLBGWR(uint64 instruction)
16000{
16001 (void)instruction;
16002
16003 return "TLBGWR ";
16004}
16005
16006
16007/*
16008 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16009 *
16010 * 3 2 1
16011 * 10987654321098765432109876543210
16012 * 001000 00010001101
16013 * rt -----
16014 * rs -----
16015 * rd -----
16016 */
16017std::string NMD::TLBINV(uint64 instruction)
16018{
16019 (void)instruction;
16020
16021 return "TLBINV ";
16022}
16023
16024
16025/*
16026 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16027 *
16028 * 3 2 1
16029 * 10987654321098765432109876543210
16030 * 001000 00010001101
16031 * rt -----
16032 * rs -----
16033 * rd -----
16034 */
16035std::string NMD::TLBINVF(uint64 instruction)
16036{
16037 (void)instruction;
16038
16039 return "TLBINVF ";
16040}
16041
16042
16043/*
16044 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16045 *
16046 * 3 2 1
16047 * 10987654321098765432109876543210
16048 * 001000 00010001101
16049 * rt -----
16050 * rs -----
16051 * rd -----
16052 */
16053std::string NMD::TLBP(uint64 instruction)
16054{
16055 (void)instruction;
16056
16057 return "TLBP ";
16058}
16059
16060
16061/*
16062 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16063 *
16064 * 3 2 1
16065 * 10987654321098765432109876543210
16066 * 001000 00010001101
16067 * rt -----
16068 * rs -----
16069 * rd -----
16070 */
16071std::string NMD::TLBR(uint64 instruction)
16072{
16073 (void)instruction;
16074
16075 return "TLBR ";
16076}
16077
16078
16079/*
16080 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16081 *
16082 * 3 2 1
16083 * 10987654321098765432109876543210
16084 * 001000 00010001101
16085 * rt -----
16086 * rs -----
16087 * rd -----
16088 */
16089std::string NMD::TLBWI(uint64 instruction)
16090{
16091 (void)instruction;
16092
16093 return "TLBWI ";
16094}
16095
16096
16097/*
16098 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16099 *
16100 * 3 2 1
16101 * 10987654321098765432109876543210
16102 * 001000 00010001101
16103 * rt -----
16104 * rs -----
16105 * rd -----
16106 */
16107std::string NMD::TLBWR(uint64 instruction)
16108{
16109 (void)instruction;
16110
16111 return "TLBWR ";
16112}
16113
16114
16115/*
16116 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16117 *
16118 * 3 2 1
16119 * 10987654321098765432109876543210
16120 * 001000 00010001101
16121 * rt -----
16122 * rs -----
16123 * rd -----
16124 */
16125std::string NMD::TNE(uint64 instruction)
16126{
16127 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16128 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16129
16130 std::string rs = GPR(copy(rs_value));
16131 std::string rt = GPR(copy(rt_value));
16132
16133 return img::format("TNE %s, %s", rs, rt);
16134}
16135
16136
16137/*
16138 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16139 *
16140 * 3 2 1
16141 * 10987654321098765432109876543210
16142 * 001000 00010001101
16143 * rt -----
16144 * rs -----
16145 * rd -----
16146 */
16147std::string NMD::TRUNC_L_D(uint64 instruction)
16148{
16149 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16150 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16151
16152 std::string ft = FPR(copy(ft_value));
16153 std::string fs = FPR(copy(fs_value));
16154
16155 return img::format("TRUNC.L.D %s, %s", ft, fs);
16156}
16157
16158
16159/*
16160 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16161 *
16162 * 3 2 1
16163 * 10987654321098765432109876543210
16164 * 001000 00010001101
16165 * rt -----
16166 * rs -----
16167 * rd -----
16168 */
16169std::string NMD::TRUNC_L_S(uint64 instruction)
16170{
16171 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16172 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16173
16174 std::string ft = FPR(copy(ft_value));
16175 std::string fs = FPR(copy(fs_value));
16176
16177 return img::format("TRUNC.L.S %s, %s", ft, fs);
16178}
16179
16180
16181/*
16182 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16183 *
16184 * 3 2 1
16185 * 10987654321098765432109876543210
16186 * 001000 00010001101
16187 * rt -----
16188 * rs -----
16189 * rd -----
16190 */
16191std::string NMD::TRUNC_W_D(uint64 instruction)
16192{
16193 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16194 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16195
16196 std::string ft = FPR(copy(ft_value));
16197 std::string fs = FPR(copy(fs_value));
16198
16199 return img::format("TRUNC.W.D %s, %s", ft, fs);
16200}
16201
16202
16203/*
16204 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16205 *
16206 * 3 2 1
16207 * 10987654321098765432109876543210
16208 * 001000 00010001101
16209 * rt -----
16210 * rs -----
16211 * rd -----
16212 */
16213std::string NMD::TRUNC_W_S(uint64 instruction)
16214{
16215 uint64 fs_value = extract_fs_15_14_13_12_11(instruction);
16216 uint64 ft_value = extract_ft_20_19_18_17_16(instruction);
16217
16218 std::string ft = FPR(copy(ft_value));
16219 std::string fs = FPR(copy(fs_value));
16220
16221 return img::format("TRUNC.W.S %s, %s", ft, fs);
16222}
16223
16224
16225/*
16226 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16227 *
16228 * 3 2 1
16229 * 10987654321098765432109876543210
16230 * 001000 00010001101
16231 * rt -----
16232 * rs -----
16233 * rd -----
16234 */
16235std::string NMD::UALDM(uint64 instruction)
16236{
16237 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16238 uint64 count3_value = extract_count3_14_13_12(instruction);
16239 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16240 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16241
16242 std::string rt = GPR(copy(rt_value));
16243 std::string s = IMMEDIATE(copy(s_value));
16244 std::string rs = GPR(copy(rs_value));
16245 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16246
16247 return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
16248}
16249
16250
16251/*
16252 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16253 *
16254 * 3 2 1
16255 * 10987654321098765432109876543210
16256 * 001000 00010001101
16257 * rt -----
16258 * rs -----
16259 * rd -----
16260 */
16261std::string NMD::UALH(uint64 instruction)
16262{
16263 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16264 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16265 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16266
16267 std::string rt = GPR(copy(rt_value));
16268 std::string s = IMMEDIATE(copy(s_value));
16269 std::string rs = GPR(copy(rs_value));
16270
16271 return img::format("UALH %s, %s(%s)", rt, s, rs);
16272}
16273
16274
16275/*
16276 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16277 *
16278 * 3 2 1
16279 * 10987654321098765432109876543210
16280 * 001000 00010001101
16281 * rt -----
16282 * rs -----
16283 * rd -----
16284 */
16285std::string NMD::UALWM(uint64 instruction)
16286{
16287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16288 uint64 count3_value = extract_count3_14_13_12(instruction);
16289 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16290 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16291
16292 std::string rt = GPR(copy(rt_value));
16293 std::string s = IMMEDIATE(copy(s_value));
16294 std::string rs = GPR(copy(rs_value));
16295 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16296
16297 return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
16298}
16299
16300
16301/*
16302 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16303 *
16304 * 3 2 1
16305 * 10987654321098765432109876543210
16306 * 001000 00010001101
16307 * rt -----
16308 * rs -----
16309 * rd -----
16310 */
16311std::string NMD::UASDM(uint64 instruction)
16312{
16313 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16314 uint64 count3_value = extract_count3_14_13_12(instruction);
16315 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16316 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16317
16318 std::string rt = GPR(copy(rt_value));
16319 std::string s = IMMEDIATE(copy(s_value));
16320 std::string rs = GPR(copy(rs_value));
16321 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16322
16323 return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
16324}
16325
16326
16327/*
16328 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16329 *
16330 * 3 2 1
16331 * 10987654321098765432109876543210
16332 * 001000 00010001101
16333 * rt -----
16334 * rs -----
16335 * rd -----
16336 */
16337std::string NMD::UASH(uint64 instruction)
16338{
16339 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16340 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16341 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16342
16343 std::string rt = GPR(copy(rt_value));
16344 std::string s = IMMEDIATE(copy(s_value));
16345 std::string rs = GPR(copy(rs_value));
16346
16347 return img::format("UASH %s, %s(%s)", rt, s, rs);
16348}
16349
16350
16351/*
16352 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16353 *
16354 * 3 2 1
16355 * 10987654321098765432109876543210
16356 * 001000 00010001101
16357 * rt -----
16358 * rs -----
16359 * rd -----
16360 */
16361std::string NMD::UASWM(uint64 instruction)
16362{
16363 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16364 uint64 count3_value = extract_count3_14_13_12(instruction);
16365 int64 s_value = extr_sil0il0bs8_il15il8bs1Tmsb8(instruction);
16366 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16367
16368 std::string rt = GPR(copy(rt_value));
16369 std::string s = IMMEDIATE(copy(s_value));
16370 std::string rs = GPR(copy(rs_value));
16371 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16372
16373 return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
16374}
16375
16376
16377/*
16378 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16379 *
16380 * 3 2 1
16381 * 10987654321098765432109876543210
16382 * 001000 00010001101
16383 * rt -----
16384 * rs -----
16385 * rd -----
16386 */
16387std::string NMD::UDI(uint64 instruction)
16388{
16389 uint64 op_value = extract_op_25_to_3(instruction);
16390
16391 std::string op = IMMEDIATE(copy(op_value));
16392
16393 return img::format("UDI %s", op);
16394}
16395
16396
16397/*
16398 * WAIT code - Enter Wait State
16399 *
16400 * 3 2 1
16401 * 10987654321098765432109876543210
16402 * 001000 1100001101111111
16403 * code ----------
16404 */
16405std::string NMD::WAIT(uint64 instruction)
16406{
16407 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
16408
16409 std::string code = IMMEDIATE(copy(code_value));
16410
16411 return img::format("WAIT %s", code);
16412}
16413
16414
16415/*
16416 * WRDSP rt, mask - Write Fields to DSPControl Register from a GPR
16417 *
16418 * 3 2 1
16419 * 10987654321098765432109876543210
16420 * 001000 01011001111111
16421 * rt -----
16422 * mask -------
16423 */
16424std::string NMD::WRDSP(uint64 instruction)
16425{
16426 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16427 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
16428
16429 std::string rt = GPR(copy(rt_value));
16430 std::string mask = IMMEDIATE(copy(mask_value));
16431
16432 return img::format("WRDSP %s, %s", rt, mask);
16433}
16434
16435
16436/*
16437 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16438 *
16439 * 3 2 1
16440 * 10987654321098765432109876543210
16441 * 001000 00010001101
16442 * rt -----
16443 * rs -----
16444 * rd -----
16445 */
16446std::string NMD::WRPGPR(uint64 instruction)
16447{
16448 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16449 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16450
16451 std::string rt = GPR(copy(rt_value));
16452 std::string rs = GPR(copy(rs_value));
16453
16454 return img::format("WRPGPR %s, %s", rt, rs);
16455}
16456
16457
16458/*
16459 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16460 *
16461 * 3 2 1
16462 * 10987654321098765432109876543210
16463 * 001000 00010001101
16464 * rt -----
16465 * rs -----
16466 * rd -----
16467 */
16468std::string NMD::XOR_16_(uint64 instruction)
16469{
16470 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16471 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16472
16473 std::string rs3 = GPR(encode_gpr3(rs3_value));
16474 std::string rt3 = GPR(encode_gpr3(rt3_value));
16475
16476 return img::format("XOR %s, %s", rs3, rt3);
16477}
16478
16479
16480/*
16481 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16482 *
16483 * 3 2 1
16484 * 10987654321098765432109876543210
16485 * 001000 00010001101
16486 * rt -----
16487 * rs -----
16488 * rd -----
16489 */
16490std::string NMD::XOR_32_(uint64 instruction)
16491{
16492 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16493 uint64 rd_value = extract_rd_20_19_18_17_16(instruction);
16494 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16495
16496 std::string rd = GPR(copy(rd_value));
16497 std::string rs = GPR(copy(rs_value));
16498 std::string rt = GPR(copy(rt_value));
16499
16500 return img::format("XOR %s, %s, %s", rd, rs, rt);
16501}
16502
16503
16504/*
16505 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16506 *
16507 * 3 2 1
16508 * 10987654321098765432109876543210
16509 * 001000 00010001101
16510 * rt -----
16511 * rs -----
16512 * rd -----
16513 */
16514std::string NMD::XORI(uint64 instruction)
16515{
16516 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16517 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
16518 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16519
16520 std::string rt = GPR(copy(rt_value));
16521 std::string rs = GPR(copy(rs_value));
16522 std::string u = IMMEDIATE(copy(u_value));
16523
16524 return img::format("XORI %s, %s, %s", rt, rs, u);
16525}
16526
16527
16528/*
16529 * YIELD rt, rs -
16530 *
16531 * 3 2 1
16532 * 10987654321098765432109876543210
16533 * 001000 00010001101
16534 * rt -----
16535 * rs -----
16536 */
16537std::string NMD::YIELD(uint64 instruction)
16538{
16539 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16540 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16541
16542 std::string rt = GPR(copy(rt_value));
16543 std::string rs = GPR(copy(rs_value));
16544
16545 return img::format("YIELD %s, %s", rt, rs);
16546}
16547
16548
16549
16550NMD::Pool NMD::P_SYSCALL[2] = {
16551 { instruction , 0 , 0 , 32,
16552 0xfffc0000, 0x00080000, &NMD::SYSCALL_32_ , 0,
16553 0x0 }, /* SYSCALL[32] */
16554 { instruction , 0 , 0 , 32,
16555 0xfffc0000, 0x000c0000, &NMD::HYPCALL , 0,
16556 CP0_ | VZ_ }, /* HYPCALL */
16557};
16558
16559
16560NMD::Pool NMD::P_RI[4] = {
16561 { instruction , 0 , 0 , 32,
16562 0xfff80000, 0x00000000, &NMD::SIGRIE , 0,
16563 0x0 }, /* SIGRIE */
16564 { pool , P_SYSCALL , 2 , 32,
16565 0xfff80000, 0x00080000, 0 , 0,
16566 0x0 }, /* P.SYSCALL */
16567 { instruction , 0 , 0 , 32,
16568 0xfff80000, 0x00100000, &NMD::BREAK_32_ , 0,
16569 0x0 }, /* BREAK[32] */
16570 { instruction , 0 , 0 , 32,
16571 0xfff80000, 0x00180000, &NMD::SDBBP_32_ , 0,
16572 EJTAG_ }, /* SDBBP[32] */
16573};
16574
16575
16576NMD::Pool NMD::P_ADDIU[2] = {
16577 { pool , P_RI , 4 , 32,
16578 0xffe00000, 0x00000000, 0 , 0,
16579 0x0 }, /* P.RI */
16580 { instruction , 0 , 0 , 32,
16581 0xfc000000, 0x00000000, &NMD::ADDIU_32_ , &NMD::ADDIU_32__cond ,
16582 0x0 }, /* ADDIU[32] */
16583};
16584
16585
16586NMD::Pool NMD::P_TRAP[2] = {
16587 { instruction , 0 , 0 , 32,
16588 0xfc0007ff, 0x20000000, &NMD::TEQ , 0,
16589 XMMS_ }, /* TEQ */
16590 { instruction , 0 , 0 , 32,
16591 0xfc0007ff, 0x20000400, &NMD::TNE , 0,
16592 XMMS_ }, /* TNE */
16593};
16594
16595
16596NMD::Pool NMD::P_CMOVE[2] = {
16597 { instruction , 0 , 0 , 32,
16598 0xfc0007ff, 0x20000210, &NMD::MOVZ , 0,
16599 0x0 }, /* MOVZ */
16600 { instruction , 0 , 0 , 32,
16601 0xfc0007ff, 0x20000610, &NMD::MOVN , 0,
16602 0x0 }, /* MOVN */
16603};
16604
16605
16606NMD::Pool NMD::P_D_MT_VPE[2] = {
16607 { instruction , 0 , 0 , 32,
16608 0xfc1f3fff, 0x20010ab0, &NMD::DMT , 0,
16609 MT_ }, /* DMT */
16610 { instruction , 0 , 0 , 32,
16611 0xfc1f3fff, 0x20000ab0, &NMD::DVPE , 0,
16612 MT_ }, /* DVPE */
16613};
16614
16615
16616NMD::Pool NMD::P_E_MT_VPE[2] = {
16617 { instruction , 0 , 0 , 32,
16618 0xfc1f3fff, 0x20010eb0, &NMD::EMT , 0,
16619 MT_ }, /* EMT */
16620 { instruction , 0 , 0 , 32,
16621 0xfc1f3fff, 0x20000eb0, &NMD::EVPE , 0,
16622 MT_ }, /* EVPE */
16623};
16624
16625
16626NMD::Pool NMD::_P_MT_VPE[2] = {
16627 { pool , P_D_MT_VPE , 2 , 32,
16628 0xfc003fff, 0x20000ab0, 0 , 0,
16629 0x0 }, /* P.D_MT_VPE */
16630 { pool , P_E_MT_VPE , 2 , 32,
16631 0xfc003fff, 0x20000eb0, 0 , 0,
16632 0x0 }, /* P.E_MT_VPE */
16633};
16634
16635
16636NMD::Pool NMD::P_MT_VPE[8] = {
16637 { reserved_block , 0 , 0 , 32,
16638 0xfc003bff, 0x200002b0, 0 , 0,
16639 0x0 }, /* P.MT_VPE~*(0) */
16640 { pool , _P_MT_VPE , 2 , 32,
16641 0xfc003bff, 0x20000ab0, 0 , 0,
16642 0x0 }, /* _P.MT_VPE */
16643 { reserved_block , 0 , 0 , 32,
16644 0xfc003bff, 0x200012b0, 0 , 0,
16645 0x0 }, /* P.MT_VPE~*(2) */
16646 { reserved_block , 0 , 0 , 32,
16647 0xfc003bff, 0x20001ab0, 0 , 0,
16648 0x0 }, /* P.MT_VPE~*(3) */
16649 { reserved_block , 0 , 0 , 32,
16650 0xfc003bff, 0x200022b0, 0 , 0,
16651 0x0 }, /* P.MT_VPE~*(4) */
16652 { reserved_block , 0 , 0 , 32,
16653 0xfc003bff, 0x20002ab0, 0 , 0,
16654 0x0 }, /* P.MT_VPE~*(5) */
16655 { reserved_block , 0 , 0 , 32,
16656 0xfc003bff, 0x200032b0, 0 , 0,
16657 0x0 }, /* P.MT_VPE~*(6) */
16658 { reserved_block , 0 , 0 , 32,
16659 0xfc003bff, 0x20003ab0, 0 , 0,
16660 0x0 }, /* P.MT_VPE~*(7) */
16661};
16662
16663
16664NMD::Pool NMD::P_DVP[2] = {
16665 { instruction , 0 , 0 , 32,
16666 0xfc00ffff, 0x20000390, &NMD::DVP , 0,
16667 0x0 }, /* DVP */
16668 { instruction , 0 , 0 , 32,
16669 0xfc00ffff, 0x20000790, &NMD::EVP , 0,
16670 0x0 }, /* EVP */
16671};
16672
16673
16674NMD::Pool NMD::P_SLTU[2] = {
16675 { pool , P_DVP , 2 , 32,
16676 0xfc00fbff, 0x20000390, 0 , 0,
16677 0x0 }, /* P.DVP */
16678 { instruction , 0 , 0 , 32,
16679 0xfc0003ff, 0x20000390, &NMD::SLTU , &NMD::SLTU_cond ,
16680 0x0 }, /* SLTU */
16681};
16682
16683
16684NMD::Pool NMD::_POOL32A0[128] = {
16685 { pool , P_TRAP , 2 , 32,
16686 0xfc0003ff, 0x20000000, 0 , 0,
16687 0x0 }, /* P.TRAP */
16688 { instruction , 0 , 0 , 32,
16689 0xfc0003ff, 0x20000008, &NMD::SEB , 0,
16690 XMMS_ }, /* SEB */
16691 { instruction , 0 , 0 , 32,
16692 0xfc0003ff, 0x20000010, &NMD::SLLV , 0,
16693 0x0 }, /* SLLV */
16694 { instruction , 0 , 0 , 32,
16695 0xfc0003ff, 0x20000018, &NMD::MUL_32_ , 0,
16696 0x0 }, /* MUL[32] */
16697 { reserved_block , 0 , 0 , 32,
16698 0xfc0003ff, 0x20000020, 0 , 0,
16699 0x0 }, /* _POOL32A0~*(4) */
16700 { reserved_block , 0 , 0 , 32,
16701 0xfc0003ff, 0x20000028, 0 , 0,
16702 0x0 }, /* _POOL32A0~*(5) */
16703 { instruction , 0 , 0 , 32,
16704 0xfc0003ff, 0x20000030, &NMD::MFC0 , 0,
16705 0x0 }, /* MFC0 */
16706 { instruction , 0 , 0 , 32,
16707 0xfc0003ff, 0x20000038, &NMD::MFHC0 , 0,
16708 CP0_ | MVH_ }, /* MFHC0 */
16709 { reserved_block , 0 , 0 , 32,
16710 0xfc0003ff, 0x20000040, 0 , 0,
16711 0x0 }, /* _POOL32A0~*(8) */
16712 { instruction , 0 , 0 , 32,
16713 0xfc0003ff, 0x20000048, &NMD::SEH , 0,
16714 0x0 }, /* SEH */
16715 { instruction , 0 , 0 , 32,
16716 0xfc0003ff, 0x20000050, &NMD::SRLV , 0,
16717 0x0 }, /* SRLV */
16718 { instruction , 0 , 0 , 32,
16719 0xfc0003ff, 0x20000058, &NMD::MUH , 0,
16720 0x0 }, /* MUH */
16721 { reserved_block , 0 , 0 , 32,
16722 0xfc0003ff, 0x20000060, 0 , 0,
16723 0x0 }, /* _POOL32A0~*(12) */
16724 { reserved_block , 0 , 0 , 32,
16725 0xfc0003ff, 0x20000068, 0 , 0,
16726 0x0 }, /* _POOL32A0~*(13) */
16727 { instruction , 0 , 0 , 32,
16728 0xfc0003ff, 0x20000070, &NMD::MTC0 , 0,
16729 CP0_ }, /* MTC0 */
16730 { instruction , 0 , 0 , 32,
16731 0xfc0003ff, 0x20000078, &NMD::MTHC0 , 0,
16732 CP0_ | MVH_ }, /* MTHC0 */
16733 { reserved_block , 0 , 0 , 32,
16734 0xfc0003ff, 0x20000080, 0 , 0,
16735 0x0 }, /* _POOL32A0~*(16) */
16736 { reserved_block , 0 , 0 , 32,
16737 0xfc0003ff, 0x20000088, 0 , 0,
16738 0x0 }, /* _POOL32A0~*(17) */
16739 { instruction , 0 , 0 , 32,
16740 0xfc0003ff, 0x20000090, &NMD::SRAV , 0,
16741 0x0 }, /* SRAV */
16742 { instruction , 0 , 0 , 32,
16743 0xfc0003ff, 0x20000098, &NMD::MULU , 0,
16744 0x0 }, /* MULU */
16745 { reserved_block , 0 , 0 , 32,
16746 0xfc0003ff, 0x200000a0, 0 , 0,
16747 0x0 }, /* _POOL32A0~*(20) */
16748 { reserved_block , 0 , 0 , 32,
16749 0xfc0003ff, 0x200000a8, 0 , 0,
16750 0x0 }, /* _POOL32A0~*(21) */
16751 { instruction , 0 , 0 , 32,
16752 0xfc0003ff, 0x200000b0, &NMD::MFGC0 , 0,
16753 CP0_ | VZ_ }, /* MFGC0 */
16754 { instruction , 0 , 0 , 32,
16755 0xfc0003ff, 0x200000b8, &NMD::MFHGC0 , 0,
16756 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16757 { reserved_block , 0 , 0 , 32,
16758 0xfc0003ff, 0x200000c0, 0 , 0,
16759 0x0 }, /* _POOL32A0~*(24) */
16760 { reserved_block , 0 , 0 , 32,
16761 0xfc0003ff, 0x200000c8, 0 , 0,
16762 0x0 }, /* _POOL32A0~*(25) */
16763 { instruction , 0 , 0 , 32,
16764 0xfc0003ff, 0x200000d0, &NMD::ROTRV , 0,
16765 0x0 }, /* ROTRV */
16766 { instruction , 0 , 0 , 32,
16767 0xfc0003ff, 0x200000d8, &NMD::MUHU , 0,
16768 0x0 }, /* MUHU */
16769 { reserved_block , 0 , 0 , 32,
16770 0xfc0003ff, 0x200000e0, 0 , 0,
16771 0x0 }, /* _POOL32A0~*(28) */
16772 { reserved_block , 0 , 0 , 32,
16773 0xfc0003ff, 0x200000e8, 0 , 0,
16774 0x0 }, /* _POOL32A0~*(29) */
16775 { instruction , 0 , 0 , 32,
16776 0xfc0003ff, 0x200000f0, &NMD::MTGC0 , 0,
16777 CP0_ | VZ_ }, /* MTGC0 */
16778 { instruction , 0 , 0 , 32,
16779 0xfc0003ff, 0x200000f8, &NMD::MTHGC0 , 0,
16780 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16781 { reserved_block , 0 , 0 , 32,
16782 0xfc0003ff, 0x20000100, 0 , 0,
16783 0x0 }, /* _POOL32A0~*(32) */
16784 { reserved_block , 0 , 0 , 32,
16785 0xfc0003ff, 0x20000108, 0 , 0,
16786 0x0 }, /* _POOL32A0~*(33) */
16787 { instruction , 0 , 0 , 32,
16788 0xfc0003ff, 0x20000110, &NMD::ADD , 0,
16789 XMMS_ }, /* ADD */
16790 { instruction , 0 , 0 , 32,
16791 0xfc0003ff, 0x20000118, &NMD::DIV , 0,
16792 0x0 }, /* DIV */
16793 { reserved_block , 0 , 0 , 32,
16794 0xfc0003ff, 0x20000120, 0 , 0,
16795 0x0 }, /* _POOL32A0~*(36) */
16796 { reserved_block , 0 , 0 , 32,
16797 0xfc0003ff, 0x20000128, 0 , 0,
16798 0x0 }, /* _POOL32A0~*(37) */
16799 { instruction , 0 , 0 , 32,
16800 0xfc0003ff, 0x20000130, &NMD::DMFC0 , 0,
16801 CP0_ | MIPS64_ }, /* DMFC0 */
16802 { reserved_block , 0 , 0 , 32,
16803 0xfc0003ff, 0x20000138, 0 , 0,
16804 0x0 }, /* _POOL32A0~*(39) */
16805 { reserved_block , 0 , 0 , 32,
16806 0xfc0003ff, 0x20000140, 0 , 0,
16807 0x0 }, /* _POOL32A0~*(40) */
16808 { reserved_block , 0 , 0 , 32,
16809 0xfc0003ff, 0x20000148, 0 , 0,
16810 0x0 }, /* _POOL32A0~*(41) */
16811 { instruction , 0 , 0 , 32,
16812 0xfc0003ff, 0x20000150, &NMD::ADDU_32_ , 0,
16813 0x0 }, /* ADDU[32] */
16814 { instruction , 0 , 0 , 32,
16815 0xfc0003ff, 0x20000158, &NMD::MOD , 0,
16816 0x0 }, /* MOD */
16817 { reserved_block , 0 , 0 , 32,
16818 0xfc0003ff, 0x20000160, 0 , 0,
16819 0x0 }, /* _POOL32A0~*(44) */
16820 { reserved_block , 0 , 0 , 32,
16821 0xfc0003ff, 0x20000168, 0 , 0,
16822 0x0 }, /* _POOL32A0~*(45) */
16823 { instruction , 0 , 0 , 32,
16824 0xfc0003ff, 0x20000170, &NMD::DMTC0 , 0,
16825 CP0_ | MIPS64_ }, /* DMTC0 */
16826 { reserved_block , 0 , 0 , 32,
16827 0xfc0003ff, 0x20000178, 0 , 0,
16828 0x0 }, /* _POOL32A0~*(47) */
16829 { reserved_block , 0 , 0 , 32,
16830 0xfc0003ff, 0x20000180, 0 , 0,
16831 0x0 }, /* _POOL32A0~*(48) */
16832 { reserved_block , 0 , 0 , 32,
16833 0xfc0003ff, 0x20000188, 0 , 0,
16834 0x0 }, /* _POOL32A0~*(49) */
16835 { instruction , 0 , 0 , 32,
16836 0xfc0003ff, 0x20000190, &NMD::SUB , 0,
16837 XMMS_ }, /* SUB */
16838 { instruction , 0 , 0 , 32,
16839 0xfc0003ff, 0x20000198, &NMD::DIVU , 0,
16840 0x0 }, /* DIVU */
16841 { reserved_block , 0 , 0 , 32,
16842 0xfc0003ff, 0x200001a0, 0 , 0,
16843 0x0 }, /* _POOL32A0~*(52) */
16844 { reserved_block , 0 , 0 , 32,
16845 0xfc0003ff, 0x200001a8, 0 , 0,
16846 0x0 }, /* _POOL32A0~*(53) */
16847 { instruction , 0 , 0 , 32,
16848 0xfc0003ff, 0x200001b0, &NMD::DMFGC0 , 0,
16849 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16850 { reserved_block , 0 , 0 , 32,
16851 0xfc0003ff, 0x200001b8, 0 , 0,
16852 0x0 }, /* _POOL32A0~*(55) */
16853 { instruction , 0 , 0 , 32,
16854 0xfc0003ff, 0x200001c0, &NMD::RDHWR , 0,
16855 XMMS_ }, /* RDHWR */
16856 { reserved_block , 0 , 0 , 32,
16857 0xfc0003ff, 0x200001c8, 0 , 0,
16858 0x0 }, /* _POOL32A0~*(57) */
16859 { instruction , 0 , 0 , 32,
16860 0xfc0003ff, 0x200001d0, &NMD::SUBU_32_ , 0,
16861 0x0 }, /* SUBU[32] */
16862 { instruction , 0 , 0 , 32,
16863 0xfc0003ff, 0x200001d8, &NMD::MODU , 0,
16864 0x0 }, /* MODU */
16865 { reserved_block , 0 , 0 , 32,
16866 0xfc0003ff, 0x200001e0, 0 , 0,
16867 0x0 }, /* _POOL32A0~*(60) */
16868 { reserved_block , 0 , 0 , 32,
16869 0xfc0003ff, 0x200001e8, 0 , 0,
16870 0x0 }, /* _POOL32A0~*(61) */
16871 { instruction , 0 , 0 , 32,
16872 0xfc0003ff, 0x200001f0, &NMD::DMTGC0 , 0,
16873 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16874 { reserved_block , 0 , 0 , 32,
16875 0xfc0003ff, 0x200001f8, 0 , 0,
16876 0x0 }, /* _POOL32A0~*(63) */
16877 { reserved_block , 0 , 0 , 32,
16878 0xfc0003ff, 0x20000200, 0 , 0,
16879 0x0 }, /* _POOL32A0~*(64) */
16880 { reserved_block , 0 , 0 , 32,
16881 0xfc0003ff, 0x20000208, 0 , 0,
16882 0x0 }, /* _POOL32A0~*(65) */
16883 { pool , P_CMOVE , 2 , 32,
16884 0xfc0003ff, 0x20000210, 0 , 0,
16885 0x0 }, /* P.CMOVE */
16886 { reserved_block , 0 , 0 , 32,
16887 0xfc0003ff, 0x20000218, 0 , 0,
16888 0x0 }, /* _POOL32A0~*(67) */
16889 { reserved_block , 0 , 0 , 32,
16890 0xfc0003ff, 0x20000220, 0 , 0,
16891 0x0 }, /* _POOL32A0~*(68) */
16892 { instruction , 0 , 0 , 32,
16893 0xfc0003ff, 0x20000228, &NMD::FORK , 0,
16894 MT_ }, /* FORK */
16895 { instruction , 0 , 0 , 32,
16896 0xfc0003ff, 0x20000230, &NMD::MFTR , 0,
16897 MT_ }, /* MFTR */
16898 { instruction , 0 , 0 , 32,
16899 0xfc0003ff, 0x20000238, &NMD::MFHTR , 0,
16900 MT_ }, /* MFHTR */
16901 { reserved_block , 0 , 0 , 32,
16902 0xfc0003ff, 0x20000240, 0 , 0,
16903 0x0 }, /* _POOL32A0~*(72) */
16904 { reserved_block , 0 , 0 , 32,
16905 0xfc0003ff, 0x20000248, 0 , 0,
16906 0x0 }, /* _POOL32A0~*(73) */
16907 { instruction , 0 , 0 , 32,
16908 0xfc0003ff, 0x20000250, &NMD::AND_32_ , 0,
16909 0x0 }, /* AND[32] */
16910 { reserved_block , 0 , 0 , 32,
16911 0xfc0003ff, 0x20000258, 0 , 0,
16912 0x0 }, /* _POOL32A0~*(75) */
16913 { reserved_block , 0 , 0 , 32,
16914 0xfc0003ff, 0x20000260, 0 , 0,
16915 0x0 }, /* _POOL32A0~*(76) */
16916 { instruction , 0 , 0 , 32,
16917 0xfc0003ff, 0x20000268, &NMD::YIELD , 0,
16918 MT_ }, /* YIELD */
16919 { instruction , 0 , 0 , 32,
16920 0xfc0003ff, 0x20000270, &NMD::MTTR , 0,
16921 MT_ }, /* MTTR */
16922 { instruction , 0 , 0 , 32,
16923 0xfc0003ff, 0x20000278, &NMD::MTHTR , 0,
16924 MT_ }, /* MTHTR */
16925 { reserved_block , 0 , 0 , 32,
16926 0xfc0003ff, 0x20000280, 0 , 0,
16927 0x0 }, /* _POOL32A0~*(80) */
16928 { reserved_block , 0 , 0 , 32,
16929 0xfc0003ff, 0x20000288, 0 , 0,
16930 0x0 }, /* _POOL32A0~*(81) */
16931 { instruction , 0 , 0 , 32,
16932 0xfc0003ff, 0x20000290, &NMD::OR_32_ , 0,
16933 0x0 }, /* OR[32] */
16934 { reserved_block , 0 , 0 , 32,
16935 0xfc0003ff, 0x20000298, 0 , 0,
16936 0x0 }, /* _POOL32A0~*(83) */
16937 { reserved_block , 0 , 0 , 32,
16938 0xfc0003ff, 0x200002a0, 0 , 0,
16939 0x0 }, /* _POOL32A0~*(84) */
16940 { reserved_block , 0 , 0 , 32,
16941 0xfc0003ff, 0x200002a8, 0 , 0,
16942 0x0 }, /* _POOL32A0~*(85) */
16943 { pool , P_MT_VPE , 8 , 32,
16944 0xfc0003ff, 0x200002b0, 0 , 0,
16945 0x0 }, /* P.MT_VPE */
16946 { reserved_block , 0 , 0 , 32,
16947 0xfc0003ff, 0x200002b8, 0 , 0,
16948 0x0 }, /* _POOL32A0~*(87) */
16949 { reserved_block , 0 , 0 , 32,
16950 0xfc0003ff, 0x200002c0, 0 , 0,
16951 0x0 }, /* _POOL32A0~*(88) */
16952 { reserved_block , 0 , 0 , 32,
16953 0xfc0003ff, 0x200002c8, 0 , 0,
16954 0x0 }, /* _POOL32A0~*(89) */
16955 { instruction , 0 , 0 , 32,
16956 0xfc0003ff, 0x200002d0, &NMD::NOR , 0,
16957 0x0 }, /* NOR */
16958 { reserved_block , 0 , 0 , 32,
16959 0xfc0003ff, 0x200002d8, 0 , 0,
16960 0x0 }, /* _POOL32A0~*(91) */
16961 { reserved_block , 0 , 0 , 32,
16962 0xfc0003ff, 0x200002e0, 0 , 0,
16963 0x0 }, /* _POOL32A0~*(92) */
16964 { reserved_block , 0 , 0 , 32,
16965 0xfc0003ff, 0x200002e8, 0 , 0,
16966 0x0 }, /* _POOL32A0~*(93) */
16967 { reserved_block , 0 , 0 , 32,
16968 0xfc0003ff, 0x200002f0, 0 , 0,
16969 0x0 }, /* _POOL32A0~*(94) */
16970 { reserved_block , 0 , 0 , 32,
16971 0xfc0003ff, 0x200002f8, 0 , 0,
16972 0x0 }, /* _POOL32A0~*(95) */
16973 { reserved_block , 0 , 0 , 32,
16974 0xfc0003ff, 0x20000300, 0 , 0,
16975 0x0 }, /* _POOL32A0~*(96) */
16976 { reserved_block , 0 , 0 , 32,
16977 0xfc0003ff, 0x20000308, 0 , 0,
16978 0x0 }, /* _POOL32A0~*(97) */
16979 { instruction , 0 , 0 , 32,
16980 0xfc0003ff, 0x20000310, &NMD::XOR_32_ , 0,
16981 0x0 }, /* XOR[32] */
16982 { reserved_block , 0 , 0 , 32,
16983 0xfc0003ff, 0x20000318, 0 , 0,
16984 0x0 }, /* _POOL32A0~*(99) */
16985 { reserved_block , 0 , 0 , 32,
16986 0xfc0003ff, 0x20000320, 0 , 0,
16987 0x0 }, /* _POOL32A0~*(100) */
16988 { reserved_block , 0 , 0 , 32,
16989 0xfc0003ff, 0x20000328, 0 , 0,
16990 0x0 }, /* _POOL32A0~*(101) */
16991 { reserved_block , 0 , 0 , 32,
16992 0xfc0003ff, 0x20000330, 0 , 0,
16993 0x0 }, /* _POOL32A0~*(102) */
16994 { reserved_block , 0 , 0 , 32,
16995 0xfc0003ff, 0x20000338, 0 , 0,
16996 0x0 }, /* _POOL32A0~*(103) */
16997 { reserved_block , 0 , 0 , 32,
16998 0xfc0003ff, 0x20000340, 0 , 0,
16999 0x0 }, /* _POOL32A0~*(104) */
17000 { reserved_block , 0 , 0 , 32,
17001 0xfc0003ff, 0x20000348, 0 , 0,
17002 0x0 }, /* _POOL32A0~*(105) */
17003 { instruction , 0 , 0 , 32,
17004 0xfc0003ff, 0x20000350, &NMD::SLT , 0,
17005 0x0 }, /* SLT */
17006 { reserved_block , 0 , 0 , 32,
17007 0xfc0003ff, 0x20000358, 0 , 0,
17008 0x0 }, /* _POOL32A0~*(107) */
17009 { reserved_block , 0 , 0 , 32,
17010 0xfc0003ff, 0x20000360, 0 , 0,
17011 0x0 }, /* _POOL32A0~*(108) */
17012 { reserved_block , 0 , 0 , 32,
17013 0xfc0003ff, 0x20000368, 0 , 0,
17014 0x0 }, /* _POOL32A0~*(109) */
17015 { reserved_block , 0 , 0 , 32,
17016 0xfc0003ff, 0x20000370, 0 , 0,
17017 0x0 }, /* _POOL32A0~*(110) */
17018 { reserved_block , 0 , 0 , 32,
17019 0xfc0003ff, 0x20000378, 0 , 0,
17020 0x0 }, /* _POOL32A0~*(111) */
17021 { reserved_block , 0 , 0 , 32,
17022 0xfc0003ff, 0x20000380, 0 , 0,
17023 0x0 }, /* _POOL32A0~*(112) */
17024 { reserved_block , 0 , 0 , 32,
17025 0xfc0003ff, 0x20000388, 0 , 0,
17026 0x0 }, /* _POOL32A0~*(113) */
17027 { pool , P_SLTU , 2 , 32,
17028 0xfc0003ff, 0x20000390, 0 , 0,
17029 0x0 }, /* P.SLTU */
17030 { reserved_block , 0 , 0 , 32,
17031 0xfc0003ff, 0x20000398, 0 , 0,
17032 0x0 }, /* _POOL32A0~*(115) */
17033 { reserved_block , 0 , 0 , 32,
17034 0xfc0003ff, 0x200003a0, 0 , 0,
17035 0x0 }, /* _POOL32A0~*(116) */
17036 { reserved_block , 0 , 0 , 32,
17037 0xfc0003ff, 0x200003a8, 0 , 0,
17038 0x0 }, /* _POOL32A0~*(117) */
17039 { reserved_block , 0 , 0 , 32,
17040 0xfc0003ff, 0x200003b0, 0 , 0,
17041 0x0 }, /* _POOL32A0~*(118) */
17042 { reserved_block , 0 , 0 , 32,
17043 0xfc0003ff, 0x200003b8, 0 , 0,
17044 0x0 }, /* _POOL32A0~*(119) */
17045 { reserved_block , 0 , 0 , 32,
17046 0xfc0003ff, 0x200003c0, 0 , 0,
17047 0x0 }, /* _POOL32A0~*(120) */
17048 { reserved_block , 0 , 0 , 32,
17049 0xfc0003ff, 0x200003c8, 0 , 0,
17050 0x0 }, /* _POOL32A0~*(121) */
17051 { instruction , 0 , 0 , 32,
17052 0xfc0003ff, 0x200003d0, &NMD::SOV , 0,
17053 0x0 }, /* SOV */
17054 { reserved_block , 0 , 0 , 32,
17055 0xfc0003ff, 0x200003d8, 0 , 0,
17056 0x0 }, /* _POOL32A0~*(123) */
17057 { reserved_block , 0 , 0 , 32,
17058 0xfc0003ff, 0x200003e0, 0 , 0,
17059 0x0 }, /* _POOL32A0~*(124) */
17060 { reserved_block , 0 , 0 , 32,
17061 0xfc0003ff, 0x200003e8, 0 , 0,
17062 0x0 }, /* _POOL32A0~*(125) */
17063 { reserved_block , 0 , 0 , 32,
17064 0xfc0003ff, 0x200003f0, 0 , 0,
17065 0x0 }, /* _POOL32A0~*(126) */
17066 { reserved_block , 0 , 0 , 32,
17067 0xfc0003ff, 0x200003f8, 0 , 0,
17068 0x0 }, /* _POOL32A0~*(127) */
17069};
17070
17071
17072NMD::Pool NMD::ADDQ__S__PH[2] = {
17073 { instruction , 0 , 0 , 32,
17074 0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH , 0,
17075 DSP_ }, /* ADDQ.PH */
17076 { instruction , 0 , 0 , 32,
17077 0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH , 0,
17078 DSP_ }, /* ADDQ_S.PH */
17079};
17080
17081
17082NMD::Pool NMD::MUL__S__PH[2] = {
17083 { instruction , 0 , 0 , 32,
17084 0xfc0007ff, 0x2000002d, &NMD::MUL_PH , 0,
17085 DSP_ }, /* MUL.PH */
17086 { instruction , 0 , 0 , 32,
17087 0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH , 0,
17088 DSP_ }, /* MUL_S.PH */
17089};
17090
17091
17092NMD::Pool NMD::ADDQH__R__PH[2] = {
17093 { instruction , 0 , 0 , 32,
17094 0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH , 0,
17095 DSP_ }, /* ADDQH.PH */
17096 { instruction , 0 , 0 , 32,
17097 0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH , 0,
17098 DSP_ }, /* ADDQH_R.PH */
17099};
17100
17101
17102NMD::Pool NMD::ADDQH__R__W[2] = {
17103 { instruction , 0 , 0 , 32,
17104 0xfc0007ff, 0x2000008d, &NMD::ADDQH_W , 0,
17105 DSP_ }, /* ADDQH.W */
17106 { instruction , 0 , 0 , 32,
17107 0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W , 0,
17108 DSP_ }, /* ADDQH_R.W */
17109};
17110
17111
17112NMD::Pool NMD::ADDU__S__QB[2] = {
17113 { instruction , 0 , 0 , 32,
17114 0xfc0007ff, 0x200000cd, &NMD::ADDU_QB , 0,
17115 DSP_ }, /* ADDU.QB */
17116 { instruction , 0 , 0 , 32,
17117 0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB , 0,
17118 DSP_ }, /* ADDU_S.QB */
17119};
17120
17121
17122NMD::Pool NMD::ADDU__S__PH[2] = {
17123 { instruction , 0 , 0 , 32,
17124 0xfc0007ff, 0x2000010d, &NMD::ADDU_PH , 0,
17125 DSP_ }, /* ADDU.PH */
17126 { instruction , 0 , 0 , 32,
17127 0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH , 0,
17128 DSP_ }, /* ADDU_S.PH */
17129};
17130
17131
17132NMD::Pool NMD::ADDUH__R__QB[2] = {
17133 { instruction , 0 , 0 , 32,
17134 0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB , 0,
17135 DSP_ }, /* ADDUH.QB */
17136 { instruction , 0 , 0 , 32,
17137 0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB , 0,
17138 DSP_ }, /* ADDUH_R.QB */
17139};
17140
17141
17142NMD::Pool NMD::SHRAV__R__PH[2] = {
17143 { instruction , 0 , 0 , 32,
17144 0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH , 0,
17145 DSP_ }, /* SHRAV.PH */
17146 { instruction , 0 , 0 , 32,
17147 0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH , 0,
17148 DSP_ }, /* SHRAV_R.PH */
17149};
17150
17151
17152NMD::Pool NMD::SHRAV__R__QB[2] = {
17153 { instruction , 0 , 0 , 32,
17154 0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB , 0,
17155 DSP_ }, /* SHRAV.QB */
17156 { instruction , 0 , 0 , 32,
17157 0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB , 0,
17158 DSP_ }, /* SHRAV_R.QB */
17159};
17160
17161
17162NMD::Pool NMD::SUBQ__S__PH[2] = {
17163 { instruction , 0 , 0 , 32,
17164 0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH , 0,
17165 DSP_ }, /* SUBQ.PH */
17166 { instruction , 0 , 0 , 32,
17167 0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH , 0,
17168 DSP_ }, /* SUBQ_S.PH */
17169};
17170
17171
17172NMD::Pool NMD::SUBQH__R__PH[2] = {
17173 { instruction , 0 , 0 , 32,
17174 0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH , 0,
17175 DSP_ }, /* SUBQH.PH */
17176 { instruction , 0 , 0 , 32,
17177 0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH , 0,
17178 DSP_ }, /* SUBQH_R.PH */
17179};
17180
17181
17182NMD::Pool NMD::SUBQH__R__W[2] = {
17183 { instruction , 0 , 0 , 32,
17184 0xfc0007ff, 0x2000028d, &NMD::SUBQH_W , 0,
17185 DSP_ }, /* SUBQH.W */
17186 { instruction , 0 , 0 , 32,
17187 0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W , 0,
17188 DSP_ }, /* SUBQH_R.W */
17189};
17190
17191
17192NMD::Pool NMD::SUBU__S__QB[2] = {
17193 { instruction , 0 , 0 , 32,
17194 0xfc0007ff, 0x200002cd, &NMD::SUBU_QB , 0,
17195 DSP_ }, /* SUBU.QB */
17196 { instruction , 0 , 0 , 32,
17197 0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB , 0,
17198 DSP_ }, /* SUBU_S.QB */
17199};
17200
17201
17202NMD::Pool NMD::SUBU__S__PH[2] = {
17203 { instruction , 0 , 0 , 32,
17204 0xfc0007ff, 0x2000030d, &NMD::SUBU_PH , 0,
17205 DSP_ }, /* SUBU.PH */
17206 { instruction , 0 , 0 , 32,
17207 0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH , 0,
17208 DSP_ }, /* SUBU_S.PH */
17209};
17210
17211
17212NMD::Pool NMD::SHRA__R__PH[2] = {
17213 { instruction , 0 , 0 , 32,
17214 0xfc0007ff, 0x20000335, &NMD::SHRA_PH , 0,
17215 DSP_ }, /* SHRA.PH */
17216 { instruction , 0 , 0 , 32,
17217 0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH , 0,
17218 DSP_ }, /* SHRA_R.PH */
17219};
17220
17221
17222NMD::Pool NMD::SUBUH__R__QB[2] = {
17223 { instruction , 0 , 0 , 32,
17224 0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB , 0,
17225 DSP_ }, /* SUBUH.QB */
17226 { instruction , 0 , 0 , 32,
17227 0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB , 0,
17228 DSP_ }, /* SUBUH_R.QB */
17229};
17230
17231
17232NMD::Pool NMD::SHLLV__S__PH[2] = {
17233 { instruction , 0 , 0 , 32,
17234 0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH , 0,
17235 DSP_ }, /* SHLLV.PH */
17236 { instruction , 0 , 0 , 32,
17237 0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH , 0,
17238 DSP_ }, /* SHLLV_S.PH */
17239};
17240
17241
17242NMD::Pool NMD::SHLL__S__PH[4] = {
17243 { instruction , 0 , 0 , 32,
17244 0xfc000fff, 0x200003b5, &NMD::SHLL_PH , 0,
17245 DSP_ }, /* SHLL.PH */
17246 { reserved_block , 0 , 0 , 32,
17247 0xfc000fff, 0x200007b5, 0 , 0,
17248 0x0 }, /* SHLL[_S].PH~*(1) */
17249 { instruction , 0 , 0 , 32,
17250 0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH , 0,
17251 DSP_ }, /* SHLL_S.PH */
17252 { reserved_block , 0 , 0 , 32,
17253 0xfc000fff, 0x20000fb5, 0 , 0,
17254 0x0 }, /* SHLL[_S].PH~*(3) */
17255};
17256
17257
17258NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
17259 { instruction , 0 , 0 , 32,
17260 0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W , 0,
17261 DSP_ }, /* PRECR_SRA.PH.W */
17262 { instruction , 0 , 0 , 32,
17263 0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
17264 DSP_ }, /* PRECR_SRA_R.PH.W */
17265};
17266
17267
17268NMD::Pool NMD::_POOL32A5[128] = {
17269 { instruction , 0 , 0 , 32,
17270 0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH , 0,
17271 DSP_ }, /* CMP.EQ.PH */
17272 { pool , ADDQ__S__PH , 2 , 32,
17273 0xfc0003ff, 0x2000000d, 0 , 0,
17274 0x0 }, /* ADDQ[_S].PH */
17275 { reserved_block , 0 , 0 , 32,
17276 0xfc0003ff, 0x20000015, 0 , 0,
17277 0x0 }, /* _POOL32A5~*(2) */
17278 { instruction , 0 , 0 , 32,
17279 0xfc0003ff, 0x2000001d, &NMD::SHILO , 0,
17280 DSP_ }, /* SHILO */
17281 { instruction , 0 , 0 , 32,
17282 0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL , 0,
17283 DSP_ }, /* MULEQ_S.W.PHL */
17284 { pool , MUL__S__PH , 2 , 32,
17285 0xfc0003ff, 0x2000002d, 0 , 0,
17286 0x0 }, /* MUL[_S].PH */
17287 { reserved_block , 0 , 0 , 32,
17288 0xfc0003ff, 0x20000035, 0 , 0,
17289 0x0 }, /* _POOL32A5~*(6) */
17290 { instruction , 0 , 0 , 32,
17291 0xfc0003ff, 0x2000003d, &NMD::REPL_PH , 0,
17292 DSP_ }, /* REPL.PH */
17293 { instruction , 0 , 0 , 32,
17294 0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH , 0,
17295 DSP_ }, /* CMP.LT.PH */
17296 { pool , ADDQH__R__PH , 2 , 32,
17297 0xfc0003ff, 0x2000004d, 0 , 0,
17298 0x0 }, /* ADDQH[_R].PH */
17299 { reserved_block , 0 , 0 , 32,
17300 0xfc0003ff, 0x20000055, 0 , 0,
17301 0x0 }, /* _POOL32A5~*(10) */
17302 { reserved_block , 0 , 0 , 32,
17303 0xfc0003ff, 0x2000005d, 0 , 0,
17304 0x0 }, /* _POOL32A5~*(11) */
17305 { instruction , 0 , 0 , 32,
17306 0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR , 0,
17307 DSP_ }, /* MULEQ_S.W.PHR */
17308 { instruction , 0 , 0 , 32,
17309 0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH , 0,
17310 DSP_ }, /* PRECR.QB.PH */
17311 { reserved_block , 0 , 0 , 32,
17312 0xfc0003ff, 0x20000075, 0 , 0,
17313 0x0 }, /* _POOL32A5~*(14) */
17314 { reserved_block , 0 , 0 , 32,
17315 0xfc0003ff, 0x2000007d, 0 , 0,
17316 0x0 }, /* _POOL32A5~*(15) */
17317 { instruction , 0 , 0 , 32,
17318 0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH , 0,
17319 DSP_ }, /* CMP.LE.PH */
17320 { pool , ADDQH__R__W , 2 , 32,
17321 0xfc0003ff, 0x2000008d, 0 , 0,
17322 0x0 }, /* ADDQH[_R].W */
17323 { instruction , 0 , 0 , 32,
17324 0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL , 0,
17325 DSP_ }, /* MULEU_S.PH.QBL */
17326 { reserved_block , 0 , 0 , 32,
17327 0xfc0003ff, 0x2000009d, 0 , 0,
17328 0x0 }, /* _POOL32A5~*(19) */
17329 { reserved_block , 0 , 0 , 32,
17330 0xfc0003ff, 0x200000a5, 0 , 0,
17331 0x0 }, /* _POOL32A5~*(20) */
17332 { instruction , 0 , 0 , 32,
17333 0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH , 0,
17334 DSP_ }, /* PRECRQ.QB.PH */
17335 { reserved_block , 0 , 0 , 32,
17336 0xfc0003ff, 0x200000b5, 0 , 0,
17337 0x0 }, /* _POOL32A5~*(22) */
17338 { reserved_block , 0 , 0 , 32,
17339 0xfc0003ff, 0x200000bd, 0 , 0,
17340 0x0 }, /* _POOL32A5~*(23) */
17341 { instruction , 0 , 0 , 32,
17342 0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB , 0,
17343 DSP_ }, /* CMPGU.EQ.QB */
17344 { pool , ADDU__S__QB , 2 , 32,
17345 0xfc0003ff, 0x200000cd, 0 , 0,
17346 0x0 }, /* ADDU[_S].QB */
17347 { instruction , 0 , 0 , 32,
17348 0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR , 0,
17349 DSP_ }, /* MULEU_S.PH.QBR */
17350 { reserved_block , 0 , 0 , 32,
17351 0xfc0003ff, 0x200000dd, 0 , 0,
17352 0x0 }, /* _POOL32A5~*(27) */
17353 { reserved_block , 0 , 0 , 32,
17354 0xfc0003ff, 0x200000e5, 0 , 0,
17355 0x0 }, /* _POOL32A5~*(28) */
17356 { instruction , 0 , 0 , 32,
17357 0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W , 0,
17358 DSP_ }, /* PRECRQ.PH.W */
17359 { reserved_block , 0 , 0 , 32,
17360 0xfc0003ff, 0x200000f5, 0 , 0,
17361 0x0 }, /* _POOL32A5~*(30) */
17362 { reserved_block , 0 , 0 , 32,
17363 0xfc0003ff, 0x200000fd, 0 , 0,
17364 0x0 }, /* _POOL32A5~*(31) */
17365 { instruction , 0 , 0 , 32,
17366 0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB , 0,
17367 DSP_ }, /* CMPGU.LT.QB */
17368 { pool , ADDU__S__PH , 2 , 32,
17369 0xfc0003ff, 0x2000010d, 0 , 0,
17370 0x0 }, /* ADDU[_S].PH */
17371 { instruction , 0 , 0 , 32,
17372 0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH , 0,
17373 DSP_ }, /* MULQ_RS.PH */
17374 { reserved_block , 0 , 0 , 32,
17375 0xfc0003ff, 0x2000011d, 0 , 0,
17376 0x0 }, /* _POOL32A5~*(35) */
17377 { reserved_block , 0 , 0 , 32,
17378 0xfc0003ff, 0x20000125, 0 , 0,
17379 0x0 }, /* _POOL32A5~*(36) */
17380 { instruction , 0 , 0 , 32,
17381 0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W , 0,
17382 DSP_ }, /* PRECRQ_RS.PH.W */
17383 { reserved_block , 0 , 0 , 32,
17384 0xfc0003ff, 0x20000135, 0 , 0,
17385 0x0 }, /* _POOL32A5~*(38) */
17386 { reserved_block , 0 , 0 , 32,
17387 0xfc0003ff, 0x2000013d, 0 , 0,
17388 0x0 }, /* _POOL32A5~*(39) */
17389 { instruction , 0 , 0 , 32,
17390 0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB , 0,
17391 DSP_ }, /* CMPGU.LE.QB */
17392 { pool , ADDUH__R__QB , 2 , 32,
17393 0xfc0003ff, 0x2000014d, 0 , 0,
17394 0x0 }, /* ADDUH[_R].QB */
17395 { instruction , 0 , 0 , 32,
17396 0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH , 0,
17397 DSP_ }, /* MULQ_S.PH */
17398 { reserved_block , 0 , 0 , 32,
17399 0xfc0003ff, 0x2000015d, 0 , 0,
17400 0x0 }, /* _POOL32A5~*(43) */
17401 { reserved_block , 0 , 0 , 32,
17402 0xfc0003ff, 0x20000165, 0 , 0,
17403 0x0 }, /* _POOL32A5~*(44) */
17404 { instruction , 0 , 0 , 32,
17405 0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH , 0,
17406 DSP_ }, /* PRECRQU_S.QB.PH */
17407 { reserved_block , 0 , 0 , 32,
17408 0xfc0003ff, 0x20000175, 0 , 0,
17409 0x0 }, /* _POOL32A5~*(46) */
17410 { reserved_block , 0 , 0 , 32,
17411 0xfc0003ff, 0x2000017d, 0 , 0,
17412 0x0 }, /* _POOL32A5~*(47) */
17413 { instruction , 0 , 0 , 32,
17414 0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB , 0,
17415 DSP_ }, /* CMPGDU.EQ.QB */
17416 { pool , SHRAV__R__PH , 2 , 32,
17417 0xfc0003ff, 0x2000018d, 0 , 0,
17418 0x0 }, /* SHRAV[_R].PH */
17419 { instruction , 0 , 0 , 32,
17420 0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W , 0,
17421 DSP_ }, /* MULQ_RS.W */
17422 { reserved_block , 0 , 0 , 32,
17423 0xfc0003ff, 0x2000019d, 0 , 0,
17424 0x0 }, /* _POOL32A5~*(51) */
17425 { reserved_block , 0 , 0 , 32,
17426 0xfc0003ff, 0x200001a5, 0 , 0,
17427 0x0 }, /* _POOL32A5~*(52) */
17428 { instruction , 0 , 0 , 32,
17429 0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH , 0,
17430 DSP_ }, /* PACKRL.PH */
17431 { reserved_block , 0 , 0 , 32,
17432 0xfc0003ff, 0x200001b5, 0 , 0,
17433 0x0 }, /* _POOL32A5~*(54) */
17434 { reserved_block , 0 , 0 , 32,
17435 0xfc0003ff, 0x200001bd, 0 , 0,
17436 0x0 }, /* _POOL32A5~*(55) */
17437 { instruction , 0 , 0 , 32,
17438 0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB , 0,
17439 DSP_ }, /* CMPGDU.LT.QB */
17440 { pool , SHRAV__R__QB , 2 , 32,
17441 0xfc0003ff, 0x200001cd, 0 , 0,
17442 0x0 }, /* SHRAV[_R].QB */
17443 { instruction , 0 , 0 , 32,
17444 0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W , 0,
17445 DSP_ }, /* MULQ_S.W */
17446 { reserved_block , 0 , 0 , 32,
17447 0xfc0003ff, 0x200001dd, 0 , 0,
17448 0x0 }, /* _POOL32A5~*(59) */
17449 { reserved_block , 0 , 0 , 32,
17450 0xfc0003ff, 0x200001e5, 0 , 0,
17451 0x0 }, /* _POOL32A5~*(60) */
17452 { instruction , 0 , 0 , 32,
17453 0xfc0003ff, 0x200001ed, &NMD::PICK_QB , 0,
17454 DSP_ }, /* PICK.QB */
17455 { reserved_block , 0 , 0 , 32,
17456 0xfc0003ff, 0x200001f5, 0 , 0,
17457 0x0 }, /* _POOL32A5~*(62) */
17458 { reserved_block , 0 , 0 , 32,
17459 0xfc0003ff, 0x200001fd, 0 , 0,
17460 0x0 }, /* _POOL32A5~*(63) */
17461 { instruction , 0 , 0 , 32,
17462 0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB , 0,
17463 DSP_ }, /* CMPGDU.LE.QB */
17464 { pool , SUBQ__S__PH , 2 , 32,
17465 0xfc0003ff, 0x2000020d, 0 , 0,
17466 0x0 }, /* SUBQ[_S].PH */
17467 { instruction , 0 , 0 , 32,
17468 0xfc0003ff, 0x20000215, &NMD::APPEND , 0,
17469 DSP_ }, /* APPEND */
17470 { reserved_block , 0 , 0 , 32,
17471 0xfc0003ff, 0x2000021d, 0 , 0,
17472 0x0 }, /* _POOL32A5~*(67) */
17473 { reserved_block , 0 , 0 , 32,
17474 0xfc0003ff, 0x20000225, 0 , 0,
17475 0x0 }, /* _POOL32A5~*(68) */
17476 { instruction , 0 , 0 , 32,
17477 0xfc0003ff, 0x2000022d, &NMD::PICK_PH , 0,
17478 DSP_ }, /* PICK.PH */
17479 { reserved_block , 0 , 0 , 32,
17480 0xfc0003ff, 0x20000235, 0 , 0,
17481 0x0 }, /* _POOL32A5~*(70) */
17482 { reserved_block , 0 , 0 , 32,
17483 0xfc0003ff, 0x2000023d, 0 , 0,
17484 0x0 }, /* _POOL32A5~*(71) */
17485 { instruction , 0 , 0 , 32,
17486 0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB , 0,
17487 DSP_ }, /* CMPU.EQ.QB */
17488 { pool , SUBQH__R__PH , 2 , 32,
17489 0xfc0003ff, 0x2000024d, 0 , 0,
17490 0x0 }, /* SUBQH[_R].PH */
17491 { instruction , 0 , 0 , 32,
17492 0xfc0003ff, 0x20000255, &NMD::PREPEND , 0,
17493 DSP_ }, /* PREPEND */
17494 { reserved_block , 0 , 0 , 32,
17495 0xfc0003ff, 0x2000025d, 0 , 0,
17496 0x0 }, /* _POOL32A5~*(75) */
17497 { reserved_block , 0 , 0 , 32,
17498 0xfc0003ff, 0x20000265, 0 , 0,
17499 0x0 }, /* _POOL32A5~*(76) */
17500 { reserved_block , 0 , 0 , 32,
17501 0xfc0003ff, 0x2000026d, 0 , 0,
17502 0x0 }, /* _POOL32A5~*(77) */
17503 { reserved_block , 0 , 0 , 32,
17504 0xfc0003ff, 0x20000275, 0 , 0,
17505 0x0 }, /* _POOL32A5~*(78) */
17506 { reserved_block , 0 , 0 , 32,
17507 0xfc0003ff, 0x2000027d, 0 , 0,
17508 0x0 }, /* _POOL32A5~*(79) */
17509 { instruction , 0 , 0 , 32,
17510 0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB , 0,
17511 DSP_ }, /* CMPU.LT.QB */
17512 { pool , SUBQH__R__W , 2 , 32,
17513 0xfc0003ff, 0x2000028d, 0 , 0,
17514 0x0 }, /* SUBQH[_R].W */
17515 { instruction , 0 , 0 , 32,
17516 0xfc0003ff, 0x20000295, &NMD::MODSUB , 0,
17517 DSP_ }, /* MODSUB */
17518 { reserved_block , 0 , 0 , 32,
17519 0xfc0003ff, 0x2000029d, 0 , 0,
17520 0x0 }, /* _POOL32A5~*(83) */
17521 { reserved_block , 0 , 0 , 32,
17522 0xfc0003ff, 0x200002a5, 0 , 0,
17523 0x0 }, /* _POOL32A5~*(84) */
17524 { reserved_block , 0 , 0 , 32,
17525 0xfc0003ff, 0x200002ad, 0 , 0,
17526 0x0 }, /* _POOL32A5~*(85) */
17527 { reserved_block , 0 , 0 , 32,
17528 0xfc0003ff, 0x200002b5, 0 , 0,
17529 0x0 }, /* _POOL32A5~*(86) */
17530 { reserved_block , 0 , 0 , 32,
17531 0xfc0003ff, 0x200002bd, 0 , 0,
17532 0x0 }, /* _POOL32A5~*(87) */
17533 { instruction , 0 , 0 , 32,
17534 0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB , 0,
17535 DSP_ }, /* CMPU.LE.QB */
17536 { pool , SUBU__S__QB , 2 , 32,
17537 0xfc0003ff, 0x200002cd, 0 , 0,
17538 0x0 }, /* SUBU[_S].QB */
17539 { instruction , 0 , 0 , 32,
17540 0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W , 0,
17541 DSP_ }, /* SHRAV_R.W */
17542 { reserved_block , 0 , 0 , 32,
17543 0xfc0003ff, 0x200002dd, 0 , 0,
17544 0x0 }, /* _POOL32A5~*(91) */
17545 { reserved_block , 0 , 0 , 32,
17546 0xfc0003ff, 0x200002e5, 0 , 0,
17547 0x0 }, /* _POOL32A5~*(92) */
17548 { reserved_block , 0 , 0 , 32,
17549 0xfc0003ff, 0x200002ed, 0 , 0,
17550 0x0 }, /* _POOL32A5~*(93) */
17551 { instruction , 0 , 0 , 32,
17552 0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W , 0,
17553 DSP_ }, /* SHRA_R.W */
17554 { reserved_block , 0 , 0 , 32,
17555 0xfc0003ff, 0x200002fd, 0 , 0,
17556 0x0 }, /* _POOL32A5~*(95) */
17557 { instruction , 0 , 0 , 32,
17558 0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W , 0,
17559 DSP_ }, /* ADDQ_S.W */
17560 { pool , SUBU__S__PH , 2 , 32,
17561 0xfc0003ff, 0x2000030d, 0 , 0,
17562 0x0 }, /* SUBU[_S].PH */
17563 { instruction , 0 , 0 , 32,
17564 0xfc0003ff, 0x20000315, &NMD::SHRLV_PH , 0,
17565 DSP_ }, /* SHRLV.PH */
17566 { reserved_block , 0 , 0 , 32,
17567 0xfc0003ff, 0x2000031d, 0 , 0,
17568 0x0 }, /* _POOL32A5~*(99) */
17569 { reserved_block , 0 , 0 , 32,
17570 0xfc0003ff, 0x20000325, 0 , 0,
17571 0x0 }, /* _POOL32A5~*(100) */
17572 { reserved_block , 0 , 0 , 32,
17573 0xfc0003ff, 0x2000032d, 0 , 0,
17574 0x0 }, /* _POOL32A5~*(101) */
17575 { pool , SHRA__R__PH , 2 , 32,
17576 0xfc0003ff, 0x20000335, 0 , 0,
17577 0x0 }, /* SHRA[_R].PH */
17578 { reserved_block , 0 , 0 , 32,
17579 0xfc0003ff, 0x2000033d, 0 , 0,
17580 0x0 }, /* _POOL32A5~*(103) */
17581 { instruction , 0 , 0 , 32,
17582 0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W , 0,
17583 DSP_ }, /* SUBQ_S.W */
17584 { pool , SUBUH__R__QB , 2 , 32,
17585 0xfc0003ff, 0x2000034d, 0 , 0,
17586 0x0 }, /* SUBUH[_R].QB */
17587 { instruction , 0 , 0 , 32,
17588 0xfc0003ff, 0x20000355, &NMD::SHRLV_QB , 0,
17589 DSP_ }, /* SHRLV.QB */
17590 { reserved_block , 0 , 0 , 32,
17591 0xfc0003ff, 0x2000035d, 0 , 0,
17592 0x0 }, /* _POOL32A5~*(107) */
17593 { reserved_block , 0 , 0 , 32,
17594 0xfc0003ff, 0x20000365, 0 , 0,
17595 0x0 }, /* _POOL32A5~*(108) */
17596 { reserved_block , 0 , 0 , 32,
17597 0xfc0003ff, 0x2000036d, 0 , 0,
17598 0x0 }, /* _POOL32A5~*(109) */
17599 { reserved_block , 0 , 0 , 32,
17600 0xfc0003ff, 0x20000375, 0 , 0,
17601 0x0 }, /* _POOL32A5~*(110) */
17602 { reserved_block , 0 , 0 , 32,
17603 0xfc0003ff, 0x2000037d, 0 , 0,
17604 0x0 }, /* _POOL32A5~*(111) */
17605 { instruction , 0 , 0 , 32,
17606 0xfc0003ff, 0x20000385, &NMD::ADDSC , 0,
17607 DSP_ }, /* ADDSC */
17608 { pool , SHLLV__S__PH , 2 , 32,
17609 0xfc0003ff, 0x2000038d, 0 , 0,
17610 0x0 }, /* SHLLV[_S].PH */
17611 { instruction , 0 , 0 , 32,
17612 0xfc0003ff, 0x20000395, &NMD::SHLLV_QB , 0,
17613 DSP_ }, /* SHLLV.QB */
17614 { reserved_block , 0 , 0 , 32,
17615 0xfc0003ff, 0x2000039d, 0 , 0,
17616 0x0 }, /* _POOL32A5~*(115) */
17617 { reserved_block , 0 , 0 , 32,
17618 0xfc0003ff, 0x200003a5, 0 , 0,
17619 0x0 }, /* _POOL32A5~*(116) */
17620 { reserved_block , 0 , 0 , 32,
17621 0xfc0003ff, 0x200003ad, 0 , 0,
17622 0x0 }, /* _POOL32A5~*(117) */
17623 { pool , SHLL__S__PH , 4 , 32,
17624 0xfc0003ff, 0x200003b5, 0 , 0,
17625 0x0 }, /* SHLL[_S].PH */
17626 { reserved_block , 0 , 0 , 32,
17627 0xfc0003ff, 0x200003bd, 0 , 0,
17628 0x0 }, /* _POOL32A5~*(119) */
17629 { instruction , 0 , 0 , 32,
17630 0xfc0003ff, 0x200003c5, &NMD::ADDWC , 0,
17631 DSP_ }, /* ADDWC */
17632 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17633 0xfc0003ff, 0x200003cd, 0 , 0,
17634 0x0 }, /* PRECR_SRA[_R].PH.W */
17635 { instruction , 0 , 0 , 32,
17636 0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W , 0,
17637 DSP_ }, /* SHLLV_S.W */
17638 { reserved_block , 0 , 0 , 32,
17639 0xfc0003ff, 0x200003dd, 0 , 0,
17640 0x0 }, /* _POOL32A5~*(123) */
17641 { reserved_block , 0 , 0 , 32,
17642 0xfc0003ff, 0x200003e5, 0 , 0,
17643 0x0 }, /* _POOL32A5~*(124) */
17644 { reserved_block , 0 , 0 , 32,
17645 0xfc0003ff, 0x200003ed, 0 , 0,
17646 0x0 }, /* _POOL32A5~*(125) */
17647 { instruction , 0 , 0 , 32,
17648 0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W , 0,
17649 DSP_ }, /* SHLL_S.W */
17650 { reserved_block , 0 , 0 , 32,
17651 0xfc0003ff, 0x200003fd, 0 , 0,
17652 0x0 }, /* _POOL32A5~*(127) */
17653};
17654
17655
17656NMD::Pool NMD::PP_LSX[16] = {
17657 { instruction , 0 , 0 , 32,
17658 0xfc0007ff, 0x20000007, &NMD::LBX , 0,
17659 0x0 }, /* LBX */
17660 { instruction , 0 , 0 , 32,
17661 0xfc0007ff, 0x20000087, &NMD::SBX , 0,
17662 XMMS_ }, /* SBX */
17663 { instruction , 0 , 0 , 32,
17664 0xfc0007ff, 0x20000107, &NMD::LBUX , 0,
17665 0x0 }, /* LBUX */
17666 { reserved_block , 0 , 0 , 32,
17667 0xfc0007ff, 0x20000187, 0 , 0,
17668 0x0 }, /* PP.LSX~*(3) */
17669 { instruction , 0 , 0 , 32,
17670 0xfc0007ff, 0x20000207, &NMD::LHX , 0,
17671 0x0 }, /* LHX */
17672 { instruction , 0 , 0 , 32,
17673 0xfc0007ff, 0x20000287, &NMD::SHX , 0,
17674 XMMS_ }, /* SHX */
17675 { instruction , 0 , 0 , 32,
17676 0xfc0007ff, 0x20000307, &NMD::LHUX , 0,
17677 0x0 }, /* LHUX */
17678 { instruction , 0 , 0 , 32,
17679 0xfc0007ff, 0x20000387, &NMD::LWUX , 0,
17680 MIPS64_ }, /* LWUX */
17681 { instruction , 0 , 0 , 32,
17682 0xfc0007ff, 0x20000407, &NMD::LWX , 0,
17683 0x0 }, /* LWX */
17684 { instruction , 0 , 0 , 32,
17685 0xfc0007ff, 0x20000487, &NMD::SWX , 0,
17686 XMMS_ }, /* SWX */
17687 { instruction , 0 , 0 , 32,
17688 0xfc0007ff, 0x20000507, &NMD::LWC1X , 0,
17689 CP1_ }, /* LWC1X */
17690 { instruction , 0 , 0 , 32,
17691 0xfc0007ff, 0x20000587, &NMD::SWC1X , 0,
17692 CP1_ }, /* SWC1X */
17693 { instruction , 0 , 0 , 32,
17694 0xfc0007ff, 0x20000607, &NMD::LDX , 0,
17695 MIPS64_ }, /* LDX */
17696 { instruction , 0 , 0 , 32,
17697 0xfc0007ff, 0x20000687, &NMD::SDX , 0,
17698 MIPS64_ }, /* SDX */
17699 { instruction , 0 , 0 , 32,
17700 0xfc0007ff, 0x20000707, &NMD::LDC1X , 0,
17701 CP1_ }, /* LDC1X */
17702 { instruction , 0 , 0 , 32,
17703 0xfc0007ff, 0x20000787, &NMD::SDC1X , 0,
17704 CP1_ }, /* SDC1X */
17705};
17706
17707
17708NMD::Pool NMD::PP_LSXS[16] = {
17709 { reserved_block , 0 , 0 , 32,
17710 0xfc0007ff, 0x20000047, 0 , 0,
17711 0x0 }, /* PP.LSXS~*(0) */
17712 { reserved_block , 0 , 0 , 32,
17713 0xfc0007ff, 0x200000c7, 0 , 0,
17714 0x0 }, /* PP.LSXS~*(1) */
17715 { reserved_block , 0 , 0 , 32,
17716 0xfc0007ff, 0x20000147, 0 , 0,
17717 0x0 }, /* PP.LSXS~*(2) */
17718 { reserved_block , 0 , 0 , 32,
17719 0xfc0007ff, 0x200001c7, 0 , 0,
17720 0x0 }, /* PP.LSXS~*(3) */
17721 { instruction , 0 , 0 , 32,
17722 0xfc0007ff, 0x20000247, &NMD::LHXS , 0,
17723 0x0 }, /* LHXS */
17724 { instruction , 0 , 0 , 32,
17725 0xfc0007ff, 0x200002c7, &NMD::SHXS , 0,
17726 XMMS_ }, /* SHXS */
17727 { instruction , 0 , 0 , 32,
17728 0xfc0007ff, 0x20000347, &NMD::LHUXS , 0,
17729 0x0 }, /* LHUXS */
17730 { instruction , 0 , 0 , 32,
17731 0xfc0007ff, 0x200003c7, &NMD::LWUXS , 0,
17732 MIPS64_ }, /* LWUXS */
17733 { instruction , 0 , 0 , 32,
17734 0xfc0007ff, 0x20000447, &NMD::LWXS_32_ , 0,
17735 0x0 }, /* LWXS[32] */
17736 { instruction , 0 , 0 , 32,
17737 0xfc0007ff, 0x200004c7, &NMD::SWXS , 0,
17738 XMMS_ }, /* SWXS */
17739 { instruction , 0 , 0 , 32,
17740 0xfc0007ff, 0x20000547, &NMD::LWC1XS , 0,
17741 CP1_ }, /* LWC1XS */
17742 { instruction , 0 , 0 , 32,
17743 0xfc0007ff, 0x200005c7, &NMD::SWC1XS , 0,
17744 CP1_ }, /* SWC1XS */
17745 { instruction , 0 , 0 , 32,
17746 0xfc0007ff, 0x20000647, &NMD::LDXS , 0,
17747 MIPS64_ }, /* LDXS */
17748 { instruction , 0 , 0 , 32,
17749 0xfc0007ff, 0x200006c7, &NMD::SDXS , 0,
17750 MIPS64_ }, /* SDXS */
17751 { instruction , 0 , 0 , 32,
17752 0xfc0007ff, 0x20000747, &NMD::LDC1XS , 0,
17753 CP1_ }, /* LDC1XS */
17754 { instruction , 0 , 0 , 32,
17755 0xfc0007ff, 0x200007c7, &NMD::SDC1XS , 0,
17756 CP1_ }, /* SDC1XS */
17757};
17758
17759
17760NMD::Pool NMD::P_LSX[2] = {
17761 { pool , PP_LSX , 16 , 32,
17762 0xfc00007f, 0x20000007, 0 , 0,
17763 0x0 }, /* PP.LSX */
17764 { pool , PP_LSXS , 16 , 32,
17765 0xfc00007f, 0x20000047, 0 , 0,
17766 0x0 }, /* PP.LSXS */
17767};
17768
17769
17770NMD::Pool NMD::POOL32Axf_1_0[4] = {
17771 { instruction , 0 , 0 , 32,
17772 0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_ , 0,
17773 DSP_ }, /* MFHI[DSP] */
17774 { instruction , 0 , 0 , 32,
17775 0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_ , 0,
17776 DSP_ }, /* MFLO[DSP] */
17777 { instruction , 0 , 0 , 32,
17778 0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_ , 0,
17779 DSP_ }, /* MTHI[DSP] */
17780 { instruction , 0 , 0 , 32,
17781 0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_ , 0,
17782 DSP_ }, /* MTLO[DSP] */
17783};
17784
17785
17786NMD::Pool NMD::POOL32Axf_1_1[4] = {
17787 { instruction , 0 , 0 , 32,
17788 0xfc003fff, 0x2000027f, &NMD::MTHLIP , 0,
17789 DSP_ }, /* MTHLIP */
17790 { instruction , 0 , 0 , 32,
17791 0xfc003fff, 0x2000127f, &NMD::SHILOV , 0,
17792 DSP_ }, /* SHILOV */
17793 { reserved_block , 0 , 0 , 32,
17794 0xfc003fff, 0x2000227f, 0 , 0,
17795 0x0 }, /* POOL32Axf_1_1~*(2) */
17796 { reserved_block , 0 , 0 , 32,
17797 0xfc003fff, 0x2000327f, 0 , 0,
17798 0x0 }, /* POOL32Axf_1_1~*(3) */
17799};
17800
17801
17802NMD::Pool NMD::POOL32Axf_1_3[4] = {
17803 { instruction , 0 , 0 , 32,
17804 0xfc003fff, 0x2000067f, &NMD::RDDSP , 0,
17805 DSP_ }, /* RDDSP */
17806 { instruction , 0 , 0 , 32,
17807 0xfc003fff, 0x2000167f, &NMD::WRDSP , 0,
17808 DSP_ }, /* WRDSP */
17809 { instruction , 0 , 0 , 32,
17810 0xfc003fff, 0x2000267f, &NMD::EXTP , 0,
17811 DSP_ }, /* EXTP */
17812 { instruction , 0 , 0 , 32,
17813 0xfc003fff, 0x2000367f, &NMD::EXTPDP , 0,
17814 DSP_ }, /* EXTPDP */
17815};
17816
17817
17818NMD::Pool NMD::POOL32Axf_1_4[2] = {
17819 { instruction , 0 , 0 , 32,
17820 0xfc001fff, 0x2000087f, &NMD::SHLL_QB , 0,
17821 DSP_ }, /* SHLL.QB */
17822 { instruction , 0 , 0 , 32,
17823 0xfc001fff, 0x2000187f, &NMD::SHRL_QB , 0,
17824 DSP_ }, /* SHRL.QB */
17825};
17826
17827
17828NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
17829 { instruction , 0 , 0 , 32,
17830 0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR , 0,
17831 DSP_ }, /* MAQ_S.W.PHR */
17832 { instruction , 0 , 0 , 32,
17833 0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR , 0,
17834 DSP_ }, /* MAQ_SA.W.PHR */
17835};
17836
17837
17838NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
17839 { instruction , 0 , 0 , 32,
17840 0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL , 0,
17841 DSP_ }, /* MAQ_S.W.PHL */
17842 { instruction , 0 , 0 , 32,
17843 0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL , 0,
17844 DSP_ }, /* MAQ_SA.W.PHL */
17845};
17846
17847
17848NMD::Pool NMD::POOL32Axf_1_5[2] = {
17849 { pool , MAQ_S_A__W_PHR , 2 , 32,
17850 0xfc001fff, 0x20000a7f, 0 , 0,
17851 0x0 }, /* MAQ_S[A].W.PHR */
17852 { pool , MAQ_S_A__W_PHL , 2 , 32,
17853 0xfc001fff, 0x20001a7f, 0 , 0,
17854 0x0 }, /* MAQ_S[A].W.PHL */
17855};
17856
17857
17858NMD::Pool NMD::POOL32Axf_1_7[4] = {
17859 { instruction , 0 , 0 , 32,
17860 0xfc003fff, 0x20000e7f, &NMD::EXTR_W , 0,
17861 DSP_ }, /* EXTR.W */
17862 { instruction , 0 , 0 , 32,
17863 0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W , 0,
17864 DSP_ }, /* EXTR_R.W */
17865 { instruction , 0 , 0 , 32,
17866 0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W , 0,
17867 DSP_ }, /* EXTR_RS.W */
17868 { instruction , 0 , 0 , 32,
17869 0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H , 0,
17870 DSP_ }, /* EXTR_S.H */
17871};
17872
17873
17874NMD::Pool NMD::POOL32Axf_1[8] = {
17875 { pool , POOL32Axf_1_0 , 4 , 32,
17876 0xfc000fff, 0x2000007f, 0 , 0,
17877 0x0 }, /* POOL32Axf_1_0 */
17878 { pool , POOL32Axf_1_1 , 4 , 32,
17879 0xfc000fff, 0x2000027f, 0 , 0,
17880 0x0 }, /* POOL32Axf_1_1 */
17881 { reserved_block , 0 , 0 , 32,
17882 0xfc000fff, 0x2000047f, 0 , 0,
17883 0x0 }, /* POOL32Axf_1~*(2) */
17884 { pool , POOL32Axf_1_3 , 4 , 32,
17885 0xfc000fff, 0x2000067f, 0 , 0,
17886 0x0 }, /* POOL32Axf_1_3 */
17887 { pool , POOL32Axf_1_4 , 2 , 32,
17888 0xfc000fff, 0x2000087f, 0 , 0,
17889 0x0 }, /* POOL32Axf_1_4 */
17890 { pool , POOL32Axf_1_5 , 2 , 32,
17891 0xfc000fff, 0x20000a7f, 0 , 0,
17892 0x0 }, /* POOL32Axf_1_5 */
17893 { reserved_block , 0 , 0 , 32,
17894 0xfc000fff, 0x20000c7f, 0 , 0,
17895 0x0 }, /* POOL32Axf_1~*(6) */
17896 { pool , POOL32Axf_1_7 , 4 , 32,
17897 0xfc000fff, 0x20000e7f, 0 , 0,
17898 0x0 }, /* POOL32Axf_1_7 */
17899};
17900
17901
17902NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
17903 { instruction , 0 , 0 , 32,
17904 0xfc003fff, 0x200000bf, &NMD::DPA_W_PH , 0,
17905 DSP_ }, /* DPA.W.PH */
17906 { instruction , 0 , 0 , 32,
17907 0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH , 0,
17908 DSP_ }, /* DPAQ_S.W.PH */
17909 { instruction , 0 , 0 , 32,
17910 0xfc003fff, 0x200004bf, &NMD::DPS_W_PH , 0,
17911 DSP_ }, /* DPS.W.PH */
17912 { instruction , 0 , 0 , 32,
17913 0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH , 0,
17914 DSP_ }, /* DPSQ_S.W.PH */
17915 { reserved_block , 0 , 0 , 32,
17916 0xfc003fff, 0x200008bf, 0 , 0,
17917 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17918 { instruction , 0 , 0 , 32,
17919 0xfc003fff, 0x20000abf, &NMD::MADD_DSP_ , 0,
17920 DSP_ }, /* MADD[DSP] */
17921 { instruction , 0 , 0 , 32,
17922 0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_ , 0,
17923 DSP_ }, /* MULT[DSP] */
17924 { instruction , 0 , 0 , 32,
17925 0xfc003fff, 0x20000ebf, &NMD::EXTRV_W , 0,
17926 DSP_ }, /* EXTRV.W */
17927};
17928
17929
17930NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
17931 { instruction , 0 , 0 , 32,
17932 0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH , 0,
17933 DSP_ }, /* DPAX.W.PH */
17934 { instruction , 0 , 0 , 32,
17935 0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W , 0,
17936 DSP_ }, /* DPAQ_SA.L.W */
17937 { instruction , 0 , 0 , 32,
17938 0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH , 0,
17939 DSP_ }, /* DPSX.W.PH */
17940 { instruction , 0 , 0 , 32,
17941 0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W , 0,
17942 DSP_ }, /* DPSQ_SA.L.W */
17943 { reserved_block , 0 , 0 , 32,
17944 0xfc003fff, 0x200018bf, 0 , 0,
17945 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17946 { instruction , 0 , 0 , 32,
17947 0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_ , 0,
17948 DSP_ }, /* MADDU[DSP] */
17949 { instruction , 0 , 0 , 32,
17950 0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_ , 0,
17951 DSP_ }, /* MULTU[DSP] */
17952 { instruction , 0 , 0 , 32,
17953 0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W , 0,
17954 DSP_ }, /* EXTRV_R.W */
17955};
17956
17957
17958NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
17959 { instruction , 0 , 0 , 32,
17960 0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL , 0,
17961 DSP_ }, /* DPAU.H.QBL */
17962 { instruction , 0 , 0 , 32,
17963 0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH , 0,
17964 DSP_ }, /* DPAQX_S.W.PH */
17965 { instruction , 0 , 0 , 32,
17966 0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL , 0,
17967 DSP_ }, /* DPSU.H.QBL */
17968 { instruction , 0 , 0 , 32,
17969 0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH , 0,
17970 DSP_ }, /* DPSQX_S.W.PH */
17971 { instruction , 0 , 0 , 32,
17972 0xfc003fff, 0x200028bf, &NMD::EXTPV , 0,
17973 DSP_ }, /* EXTPV */
17974 { instruction , 0 , 0 , 32,
17975 0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_ , 0,
17976 DSP_ }, /* MSUB[DSP] */
17977 { instruction , 0 , 0 , 32,
17978 0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH , 0,
17979 DSP_ }, /* MULSA.W.PH */
17980 { instruction , 0 , 0 , 32,
17981 0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W , 0,
17982 DSP_ }, /* EXTRV_RS.W */
17983};
17984
17985
17986NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
17987 { instruction , 0 , 0 , 32,
17988 0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR , 0,
17989 DSP_ }, /* DPAU.H.QBR */
17990 { instruction , 0 , 0 , 32,
17991 0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH , 0,
17992 DSP_ }, /* DPAQX_SA.W.PH */
17993 { instruction , 0 , 0 , 32,
17994 0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR , 0,
17995 DSP_ }, /* DPSU.H.QBR */
17996 { instruction , 0 , 0 , 32,
17997 0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH , 0,
17998 DSP_ }, /* DPSQX_SA.W.PH */
17999 { instruction , 0 , 0 , 32,
18000 0xfc003fff, 0x200038bf, &NMD::EXTPDPV , 0,
18001 DSP_ }, /* EXTPDPV */
18002 { instruction , 0 , 0 , 32,
18003 0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_ , 0,
18004 DSP_ }, /* MSUBU[DSP] */
18005 { instruction , 0 , 0 , 32,
18006 0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH , 0,
18007 DSP_ }, /* MULSAQ_S.W.PH */
18008 { instruction , 0 , 0 , 32,
18009 0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H , 0,
18010 DSP_ }, /* EXTRV_S.H */
18011};
18012
18013
18014NMD::Pool NMD::POOL32Axf_2[4] = {
18015 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
18016 0xfc0031ff, 0x200000bf, 0 , 0,
18017 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
18018 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
18019 0xfc0031ff, 0x200010bf, 0 , 0,
18020 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
18021 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
18022 0xfc0031ff, 0x200020bf, 0 , 0,
18023 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
18024 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
18025 0xfc0031ff, 0x200030bf, 0 , 0,
18026 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
18027};
18028
18029
18030NMD::Pool NMD::POOL32Axf_4[128] = {
18031 { instruction , 0 , 0 , 32,
18032 0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB , 0,
18033 DSP_ }, /* ABSQ_S.QB */
18034 { instruction , 0 , 0 , 32,
18035 0xfc00ffff, 0x2000033f, &NMD::REPLV_PH , 0,
18036 DSP_ }, /* REPLV.PH */
18037 { reserved_block , 0 , 0 , 32,
18038 0xfc00ffff, 0x2000053f, 0 , 0,
18039 0x0 }, /* POOL32Axf_4~*(2) */
18040 { reserved_block , 0 , 0 , 32,
18041 0xfc00ffff, 0x2000073f, 0 , 0,
18042 0x0 }, /* POOL32Axf_4~*(3) */
18043 { reserved_block , 0 , 0 , 32,
18044 0xfc00ffff, 0x2000093f, 0 , 0,
18045 0x0 }, /* POOL32Axf_4~*(4) */
18046 { reserved_block , 0 , 0 , 32,
18047 0xfc00ffff, 0x20000b3f, 0 , 0,
18048 0x0 }, /* POOL32Axf_4~*(5) */
18049 { reserved_block , 0 , 0 , 32,
18050 0xfc00ffff, 0x20000d3f, 0 , 0,
18051 0x0 }, /* POOL32Axf_4~*(6) */
18052 { reserved_block , 0 , 0 , 32,
18053 0xfc00ffff, 0x20000f3f, 0 , 0,
18054 0x0 }, /* POOL32Axf_4~*(7) */
18055 { instruction , 0 , 0 , 32,
18056 0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH , 0,
18057 DSP_ }, /* ABSQ_S.PH */
18058 { instruction , 0 , 0 , 32,
18059 0xfc00ffff, 0x2000133f, &NMD::REPLV_QB , 0,
18060 DSP_ }, /* REPLV.QB */
18061 { reserved_block , 0 , 0 , 32,
18062 0xfc00ffff, 0x2000153f, 0 , 0,
18063 0x0 }, /* POOL32Axf_4~*(10) */
18064 { reserved_block , 0 , 0 , 32,
18065 0xfc00ffff, 0x2000173f, 0 , 0,
18066 0x0 }, /* POOL32Axf_4~*(11) */
18067 { reserved_block , 0 , 0 , 32,
18068 0xfc00ffff, 0x2000193f, 0 , 0,
18069 0x0 }, /* POOL32Axf_4~*(12) */
18070 { reserved_block , 0 , 0 , 32,
18071 0xfc00ffff, 0x20001b3f, 0 , 0,
18072 0x0 }, /* POOL32Axf_4~*(13) */
18073 { reserved_block , 0 , 0 , 32,
18074 0xfc00ffff, 0x20001d3f, 0 , 0,
18075 0x0 }, /* POOL32Axf_4~*(14) */
18076 { reserved_block , 0 , 0 , 32,
18077 0xfc00ffff, 0x20001f3f, 0 , 0,
18078 0x0 }, /* POOL32Axf_4~*(15) */
18079 { instruction , 0 , 0 , 32,
18080 0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W , 0,
18081 DSP_ }, /* ABSQ_S.W */
18082 { reserved_block , 0 , 0 , 32,
18083 0xfc00ffff, 0x2000233f, 0 , 0,
18084 0x0 }, /* POOL32Axf_4~*(17) */
18085 { reserved_block , 0 , 0 , 32,
18086 0xfc00ffff, 0x2000253f, 0 , 0,
18087 0x0 }, /* POOL32Axf_4~*(18) */
18088 { reserved_block , 0 , 0 , 32,
18089 0xfc00ffff, 0x2000273f, 0 , 0,
18090 0x0 }, /* POOL32Axf_4~*(19) */
18091 { reserved_block , 0 , 0 , 32,
18092 0xfc00ffff, 0x2000293f, 0 , 0,
18093 0x0 }, /* POOL32Axf_4~*(20) */
18094 { reserved_block , 0 , 0 , 32,
18095 0xfc00ffff, 0x20002b3f, 0 , 0,
18096 0x0 }, /* POOL32Axf_4~*(21) */
18097 { reserved_block , 0 , 0 , 32,
18098 0xfc00ffff, 0x20002d3f, 0 , 0,
18099 0x0 }, /* POOL32Axf_4~*(22) */
18100 { reserved_block , 0 , 0 , 32,
18101 0xfc00ffff, 0x20002f3f, 0 , 0,
18102 0x0 }, /* POOL32Axf_4~*(23) */
18103 { reserved_block , 0 , 0 , 32,
18104 0xfc00ffff, 0x2000313f, 0 , 0,
18105 0x0 }, /* POOL32Axf_4~*(24) */
18106 { reserved_block , 0 , 0 , 32,
18107 0xfc00ffff, 0x2000333f, 0 , 0,
18108 0x0 }, /* POOL32Axf_4~*(25) */
18109 { reserved_block , 0 , 0 , 32,
18110 0xfc00ffff, 0x2000353f, 0 , 0,
18111 0x0 }, /* POOL32Axf_4~*(26) */
18112 { reserved_block , 0 , 0 , 32,
18113 0xfc00ffff, 0x2000373f, 0 , 0,
18114 0x0 }, /* POOL32Axf_4~*(27) */
18115 { reserved_block , 0 , 0 , 32,
18116 0xfc00ffff, 0x2000393f, 0 , 0,
18117 0x0 }, /* POOL32Axf_4~*(28) */
18118 { reserved_block , 0 , 0 , 32,
18119 0xfc00ffff, 0x20003b3f, 0 , 0,
18120 0x0 }, /* POOL32Axf_4~*(29) */
18121 { reserved_block , 0 , 0 , 32,
18122 0xfc00ffff, 0x20003d3f, 0 , 0,
18123 0x0 }, /* POOL32Axf_4~*(30) */
18124 { reserved_block , 0 , 0 , 32,
18125 0xfc00ffff, 0x20003f3f, 0 , 0,
18126 0x0 }, /* POOL32Axf_4~*(31) */
18127 { instruction , 0 , 0 , 32,
18128 0xfc00ffff, 0x2000413f, &NMD::INSV , 0,
18129 DSP_ }, /* INSV */
18130 { reserved_block , 0 , 0 , 32,
18131 0xfc00ffff, 0x2000433f, 0 , 0,
18132 0x0 }, /* POOL32Axf_4~*(33) */
18133 { reserved_block , 0 , 0 , 32,
18134 0xfc00ffff, 0x2000453f, 0 , 0,
18135 0x0 }, /* POOL32Axf_4~*(34) */
18136 { reserved_block , 0 , 0 , 32,
18137 0xfc00ffff, 0x2000473f, 0 , 0,
18138 0x0 }, /* POOL32Axf_4~*(35) */
18139 { reserved_block , 0 , 0 , 32,
18140 0xfc00ffff, 0x2000493f, 0 , 0,
18141 0x0 }, /* POOL32Axf_4~*(36) */
18142 { instruction , 0 , 0 , 32,
18143 0xfc00ffff, 0x20004b3f, &NMD::CLO , 0,
18144 XMMS_ }, /* CLO */
18145 { instruction , 0 , 0 , 32,
18146 0xfc00ffff, 0x20004d3f, &NMD::MFC2 , 0,
18147 CP2_ }, /* MFC2 */
18148 { reserved_block , 0 , 0 , 32,
18149 0xfc00ffff, 0x20004f3f, 0 , 0,
18150 0x0 }, /* POOL32Axf_4~*(39) */
18151 { instruction , 0 , 0 , 32,
18152 0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL , 0,
18153 DSP_ }, /* PRECEQ.W.PHL */
18154 { reserved_block , 0 , 0 , 32,
18155 0xfc00ffff, 0x2000533f, 0 , 0,
18156 0x0 }, /* POOL32Axf_4~*(41) */
18157 { reserved_block , 0 , 0 , 32,
18158 0xfc00ffff, 0x2000553f, 0 , 0,
18159 0x0 }, /* POOL32Axf_4~*(42) */
18160 { reserved_block , 0 , 0 , 32,
18161 0xfc00ffff, 0x2000573f, 0 , 0,
18162 0x0 }, /* POOL32Axf_4~*(43) */
18163 { reserved_block , 0 , 0 , 32,
18164 0xfc00ffff, 0x2000593f, 0 , 0,
18165 0x0 }, /* POOL32Axf_4~*(44) */
18166 { instruction , 0 , 0 , 32,
18167 0xfc00ffff, 0x20005b3f, &NMD::CLZ , 0,
18168 XMMS_ }, /* CLZ */
18169 { instruction , 0 , 0 , 32,
18170 0xfc00ffff, 0x20005d3f, &NMD::MTC2 , 0,
18171 CP2_ }, /* MTC2 */
18172 { reserved_block , 0 , 0 , 32,
18173 0xfc00ffff, 0x20005f3f, 0 , 0,
18174 0x0 }, /* POOL32Axf_4~*(47) */
18175 { instruction , 0 , 0 , 32,
18176 0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR , 0,
18177 DSP_ }, /* PRECEQ.W.PHR */
18178 { reserved_block , 0 , 0 , 32,
18179 0xfc00ffff, 0x2000633f, 0 , 0,
18180 0x0 }, /* POOL32Axf_4~*(49) */
18181 { reserved_block , 0 , 0 , 32,
18182 0xfc00ffff, 0x2000653f, 0 , 0,
18183 0x0 }, /* POOL32Axf_4~*(50) */
18184 { reserved_block , 0 , 0 , 32,
18185 0xfc00ffff, 0x2000673f, 0 , 0,
18186 0x0 }, /* POOL32Axf_4~*(51) */
18187 { reserved_block , 0 , 0 , 32,
18188 0xfc00ffff, 0x2000693f, 0 , 0,
18189 0x0 }, /* POOL32Axf_4~*(52) */
18190 { reserved_block , 0 , 0 , 32,
18191 0xfc00ffff, 0x20006b3f, 0 , 0,
18192 0x0 }, /* POOL32Axf_4~*(53) */
18193 { instruction , 0 , 0 , 32,
18194 0xfc00ffff, 0x20006d3f, &NMD::DMFC2 , 0,
18195 CP2_ }, /* DMFC2 */
18196 { reserved_block , 0 , 0 , 32,
18197 0xfc00ffff, 0x20006f3f, 0 , 0,
18198 0x0 }, /* POOL32Axf_4~*(55) */
18199 { instruction , 0 , 0 , 32,
18200 0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL , 0,
18201 DSP_ }, /* PRECEQU.PH.QBL */
18202 { instruction , 0 , 0 , 32,
18203 0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA , 0,
18204 DSP_ }, /* PRECEQU.PH.QBLA */
18205 { reserved_block , 0 , 0 , 32,
18206 0xfc00ffff, 0x2000753f, 0 , 0,
18207 0x0 }, /* POOL32Axf_4~*(58) */
18208 { reserved_block , 0 , 0 , 32,
18209 0xfc00ffff, 0x2000773f, 0 , 0,
18210 0x0 }, /* POOL32Axf_4~*(59) */
18211 { reserved_block , 0 , 0 , 32,
18212 0xfc00ffff, 0x2000793f, 0 , 0,
18213 0x0 }, /* POOL32Axf_4~*(60) */
18214 { reserved_block , 0 , 0 , 32,
18215 0xfc00ffff, 0x20007b3f, 0 , 0,
18216 0x0 }, /* POOL32Axf_4~*(61) */
18217 { instruction , 0 , 0 , 32,
18218 0xfc00ffff, 0x20007d3f, &NMD::DMTC2 , 0,
18219 CP2_ }, /* DMTC2 */
18220 { reserved_block , 0 , 0 , 32,
18221 0xfc00ffff, 0x20007f3f, 0 , 0,
18222 0x0 }, /* POOL32Axf_4~*(63) */
18223 { reserved_block , 0 , 0 , 32,
18224 0xfc00ffff, 0x2000813f, 0 , 0,
18225 0x0 }, /* POOL32Axf_4~*(64) */
18226 { reserved_block , 0 , 0 , 32,
18227 0xfc00ffff, 0x2000833f, 0 , 0,
18228 0x0 }, /* POOL32Axf_4~*(65) */
18229 { reserved_block , 0 , 0 , 32,
18230 0xfc00ffff, 0x2000853f, 0 , 0,
18231 0x0 }, /* POOL32Axf_4~*(66) */
18232 { reserved_block , 0 , 0 , 32,
18233 0xfc00ffff, 0x2000873f, 0 , 0,
18234 0x0 }, /* POOL32Axf_4~*(67) */
18235 { reserved_block , 0 , 0 , 32,
18236 0xfc00ffff, 0x2000893f, 0 , 0,
18237 0x0 }, /* POOL32Axf_4~*(68) */
18238 { reserved_block , 0 , 0 , 32,
18239 0xfc00ffff, 0x20008b3f, 0 , 0,
18240 0x0 }, /* POOL32Axf_4~*(69) */
18241 { instruction , 0 , 0 , 32,
18242 0xfc00ffff, 0x20008d3f, &NMD::MFHC2 , 0,
18243 CP2_ }, /* MFHC2 */
18244 { reserved_block , 0 , 0 , 32,
18245 0xfc00ffff, 0x20008f3f, 0 , 0,
18246 0x0 }, /* POOL32Axf_4~*(71) */
18247 { instruction , 0 , 0 , 32,
18248 0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR , 0,
18249 DSP_ }, /* PRECEQU.PH.QBR */
18250 { instruction , 0 , 0 , 32,
18251 0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA , 0,
18252 DSP_ }, /* PRECEQU.PH.QBRA */
18253 { reserved_block , 0 , 0 , 32,
18254 0xfc00ffff, 0x2000953f, 0 , 0,
18255 0x0 }, /* POOL32Axf_4~*(74) */
18256 { reserved_block , 0 , 0 , 32,
18257 0xfc00ffff, 0x2000973f, 0 , 0,
18258 0x0 }, /* POOL32Axf_4~*(75) */
18259 { reserved_block , 0 , 0 , 32,
18260 0xfc00ffff, 0x2000993f, 0 , 0,
18261 0x0 }, /* POOL32Axf_4~*(76) */
18262 { reserved_block , 0 , 0 , 32,
18263 0xfc00ffff, 0x20009b3f, 0 , 0,
18264 0x0 }, /* POOL32Axf_4~*(77) */
18265 { instruction , 0 , 0 , 32,
18266 0xfc00ffff, 0x20009d3f, &NMD::MTHC2 , 0,
18267 CP2_ }, /* MTHC2 */
18268 { reserved_block , 0 , 0 , 32,
18269 0xfc00ffff, 0x20009f3f, 0 , 0,
18270 0x0 }, /* POOL32Axf_4~*(79) */
18271 { reserved_block , 0 , 0 , 32,
18272 0xfc00ffff, 0x2000a13f, 0 , 0,
18273 0x0 }, /* POOL32Axf_4~*(80) */
18274 { reserved_block , 0 , 0 , 32,
18275 0xfc00ffff, 0x2000a33f, 0 , 0,
18276 0x0 }, /* POOL32Axf_4~*(81) */
18277 { reserved_block , 0 , 0 , 32,
18278 0xfc00ffff, 0x2000a53f, 0 , 0,
18279 0x0 }, /* POOL32Axf_4~*(82) */
18280 { reserved_block , 0 , 0 , 32,
18281 0xfc00ffff, 0x2000a73f, 0 , 0,
18282 0x0 }, /* POOL32Axf_4~*(83) */
18283 { reserved_block , 0 , 0 , 32,
18284 0xfc00ffff, 0x2000a93f, 0 , 0,
18285 0x0 }, /* POOL32Axf_4~*(84) */
18286 { reserved_block , 0 , 0 , 32,
18287 0xfc00ffff, 0x2000ab3f, 0 , 0,
18288 0x0 }, /* POOL32Axf_4~*(85) */
18289 { reserved_block , 0 , 0 , 32,
18290 0xfc00ffff, 0x2000ad3f, 0 , 0,
18291 0x0 }, /* POOL32Axf_4~*(86) */
18292 { reserved_block , 0 , 0 , 32,
18293 0xfc00ffff, 0x2000af3f, 0 , 0,
18294 0x0 }, /* POOL32Axf_4~*(87) */
18295 { instruction , 0 , 0 , 32,
18296 0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL , 0,
18297 DSP_ }, /* PRECEU.PH.QBL */
18298 { instruction , 0 , 0 , 32,
18299 0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA , 0,
18300 DSP_ }, /* PRECEU.PH.QBLA */
18301 { reserved_block , 0 , 0 , 32,
18302 0xfc00ffff, 0x2000b53f, 0 , 0,
18303 0x0 }, /* POOL32Axf_4~*(90) */
18304 { reserved_block , 0 , 0 , 32,
18305 0xfc00ffff, 0x2000b73f, 0 , 0,
18306 0x0 }, /* POOL32Axf_4~*(91) */
18307 { reserved_block , 0 , 0 , 32,
18308 0xfc00ffff, 0x2000b93f, 0 , 0,
18309 0x0 }, /* POOL32Axf_4~*(92) */
18310 { reserved_block , 0 , 0 , 32,
18311 0xfc00ffff, 0x2000bb3f, 0 , 0,
18312 0x0 }, /* POOL32Axf_4~*(93) */
18313 { reserved_block , 0 , 0 , 32,
18314 0xfc00ffff, 0x2000bd3f, 0 , 0,
18315 0x0 }, /* POOL32Axf_4~*(94) */
18316 { reserved_block , 0 , 0 , 32,
18317 0xfc00ffff, 0x2000bf3f, 0 , 0,
18318 0x0 }, /* POOL32Axf_4~*(95) */
18319 { reserved_block , 0 , 0 , 32,
18320 0xfc00ffff, 0x2000c13f, 0 , 0,
18321 0x0 }, /* POOL32Axf_4~*(96) */
18322 { reserved_block , 0 , 0 , 32,
18323 0xfc00ffff, 0x2000c33f, 0 , 0,
18324 0x0 }, /* POOL32Axf_4~*(97) */
18325 { reserved_block , 0 , 0 , 32,
18326 0xfc00ffff, 0x2000c53f, 0 , 0,
18327 0x0 }, /* POOL32Axf_4~*(98) */
18328 { reserved_block , 0 , 0 , 32,
18329 0xfc00ffff, 0x2000c73f, 0 , 0,
18330 0x0 }, /* POOL32Axf_4~*(99) */
18331 { reserved_block , 0 , 0 , 32,
18332 0xfc00ffff, 0x2000c93f, 0 , 0,
18333 0x0 }, /* POOL32Axf_4~*(100) */
18334 { reserved_block , 0 , 0 , 32,
18335 0xfc00ffff, 0x2000cb3f, 0 , 0,
18336 0x0 }, /* POOL32Axf_4~*(101) */
18337 { instruction , 0 , 0 , 32,
18338 0xfc00ffff, 0x2000cd3f, &NMD::CFC2 , 0,
18339 CP2_ }, /* CFC2 */
18340 { reserved_block , 0 , 0 , 32,
18341 0xfc00ffff, 0x2000cf3f, 0 , 0,
18342 0x0 }, /* POOL32Axf_4~*(103) */
18343 { instruction , 0 , 0 , 32,
18344 0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR , 0,
18345 DSP_ }, /* PRECEU.PH.QBR */
18346 { instruction , 0 , 0 , 32,
18347 0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA , 0,
18348 DSP_ }, /* PRECEU.PH.QBRA */
18349 { reserved_block , 0 , 0 , 32,
18350 0xfc00ffff, 0x2000d53f, 0 , 0,
18351 0x0 }, /* POOL32Axf_4~*(106) */
18352 { reserved_block , 0 , 0 , 32,
18353 0xfc00ffff, 0x2000d73f, 0 , 0,
18354 0x0 }, /* POOL32Axf_4~*(107) */
18355 { reserved_block , 0 , 0 , 32,
18356 0xfc00ffff, 0x2000d93f, 0 , 0,
18357 0x0 }, /* POOL32Axf_4~*(108) */
18358 { reserved_block , 0 , 0 , 32,
18359 0xfc00ffff, 0x2000db3f, 0 , 0,
18360 0x0 }, /* POOL32Axf_4~*(109) */
18361 { instruction , 0 , 0 , 32,
18362 0xfc00ffff, 0x2000dd3f, &NMD::CTC2 , 0,
18363 CP2_ }, /* CTC2 */
18364 { reserved_block , 0 , 0 , 32,
18365 0xfc00ffff, 0x2000df3f, 0 , 0,
18366 0x0 }, /* POOL32Axf_4~*(111) */
18367 { reserved_block , 0 , 0 , 32,
18368 0xfc00ffff, 0x2000e13f, 0 , 0,
18369 0x0 }, /* POOL32Axf_4~*(112) */
18370 { reserved_block , 0 , 0 , 32,
18371 0xfc00ffff, 0x2000e33f, 0 , 0,
18372 0x0 }, /* POOL32Axf_4~*(113) */
18373 { reserved_block , 0 , 0 , 32,
18374 0xfc00ffff, 0x2000e53f, 0 , 0,
18375 0x0 }, /* POOL32Axf_4~*(114) */
18376 { reserved_block , 0 , 0 , 32,
18377 0xfc00ffff, 0x2000e73f, 0 , 0,
18378 0x0 }, /* POOL32Axf_4~*(115) */
18379 { reserved_block , 0 , 0 , 32,
18380 0xfc00ffff, 0x2000e93f, 0 , 0,
18381 0x0 }, /* POOL32Axf_4~*(116) */
18382 { reserved_block , 0 , 0 , 32,
18383 0xfc00ffff, 0x2000eb3f, 0 , 0,
18384 0x0 }, /* POOL32Axf_4~*(117) */
18385 { reserved_block , 0 , 0 , 32,
18386 0xfc00ffff, 0x2000ed3f, 0 , 0,
18387 0x0 }, /* POOL32Axf_4~*(118) */
18388 { reserved_block , 0 , 0 , 32,
18389 0xfc00ffff, 0x2000ef3f, 0 , 0,
18390 0x0 }, /* POOL32Axf_4~*(119) */
18391 { instruction , 0 , 0 , 32,
18392 0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB , 0,
18393 DSP_ }, /* RADDU.W.QB */
18394 { reserved_block , 0 , 0 , 32,
18395 0xfc00ffff, 0x2000f33f, 0 , 0,
18396 0x0 }, /* POOL32Axf_4~*(121) */
18397 { reserved_block , 0 , 0 , 32,
18398 0xfc00ffff, 0x2000f53f, 0 , 0,
18399 0x0 }, /* POOL32Axf_4~*(122) */
18400 { reserved_block , 0 , 0 , 32,
18401 0xfc00ffff, 0x2000f73f, 0 , 0,
18402 0x0 }, /* POOL32Axf_4~*(123) */
18403 { reserved_block , 0 , 0 , 32,
18404 0xfc00ffff, 0x2000f93f, 0 , 0,
18405 0x0 }, /* POOL32Axf_4~*(124) */
18406 { reserved_block , 0 , 0 , 32,
18407 0xfc00ffff, 0x2000fb3f, 0 , 0,
18408 0x0 }, /* POOL32Axf_4~*(125) */
18409 { reserved_block , 0 , 0 , 32,
18410 0xfc00ffff, 0x2000fd3f, 0 , 0,
18411 0x0 }, /* POOL32Axf_4~*(126) */
18412 { reserved_block , 0 , 0 , 32,
18413 0xfc00ffff, 0x2000ff3f, 0 , 0,
18414 0x0 }, /* POOL32Axf_4~*(127) */
18415};
18416
18417
18418NMD::Pool NMD::POOL32Axf_5_group0[32] = {
18419 { instruction , 0 , 0 , 32,
18420 0xfc00ffff, 0x2000017f, &NMD::TLBGP , 0,
18421 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18422 { instruction , 0 , 0 , 32,
18423 0xfc00ffff, 0x2000037f, &NMD::TLBP , 0,
18424 CP0_ | TLB_ }, /* TLBP */
18425 { instruction , 0 , 0 , 32,
18426 0xfc00ffff, 0x2000057f, &NMD::TLBGINV , 0,
18427 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18428 { instruction , 0 , 0 , 32,
18429 0xfc00ffff, 0x2000077f, &NMD::TLBINV , 0,
18430 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18431 { reserved_block , 0 , 0 , 32,
18432 0xfc00ffff, 0x2000097f, 0 , 0,
18433 0x0 }, /* POOL32Axf_5_group0~*(4) */
18434 { reserved_block , 0 , 0 , 32,
18435 0xfc00ffff, 0x20000b7f, 0 , 0,
18436 0x0 }, /* POOL32Axf_5_group0~*(5) */
18437 { reserved_block , 0 , 0 , 32,
18438 0xfc00ffff, 0x20000d7f, 0 , 0,
18439 0x0 }, /* POOL32Axf_5_group0~*(6) */
18440 { reserved_block , 0 , 0 , 32,
18441 0xfc00ffff, 0x20000f7f, 0 , 0,
18442 0x0 }, /* POOL32Axf_5_group0~*(7) */
18443 { instruction , 0 , 0 , 32,
18444 0xfc00ffff, 0x2000117f, &NMD::TLBGR , 0,
18445 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18446 { instruction , 0 , 0 , 32,
18447 0xfc00ffff, 0x2000137f, &NMD::TLBR , 0,
18448 CP0_ | TLB_ }, /* TLBR */
18449 { instruction , 0 , 0 , 32,
18450 0xfc00ffff, 0x2000157f, &NMD::TLBGINVF , 0,
18451 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18452 { instruction , 0 , 0 , 32,
18453 0xfc00ffff, 0x2000177f, &NMD::TLBINVF , 0,
18454 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18455 { reserved_block , 0 , 0 , 32,
18456 0xfc00ffff, 0x2000197f, 0 , 0,
18457 0x0 }, /* POOL32Axf_5_group0~*(12) */
18458 { reserved_block , 0 , 0 , 32,
18459 0xfc00ffff, 0x20001b7f, 0 , 0,
18460 0x0 }, /* POOL32Axf_5_group0~*(13) */
18461 { reserved_block , 0 , 0 , 32,
18462 0xfc00ffff, 0x20001d7f, 0 , 0,
18463 0x0 }, /* POOL32Axf_5_group0~*(14) */
18464 { reserved_block , 0 , 0 , 32,
18465 0xfc00ffff, 0x20001f7f, 0 , 0,
18466 0x0 }, /* POOL32Axf_5_group0~*(15) */
18467 { instruction , 0 , 0 , 32,
18468 0xfc00ffff, 0x2000217f, &NMD::TLBGWI , 0,
18469 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18470 { instruction , 0 , 0 , 32,
18471 0xfc00ffff, 0x2000237f, &NMD::TLBWI , 0,
18472 CP0_ | TLB_ }, /* TLBWI */
18473 { reserved_block , 0 , 0 , 32,
18474 0xfc00ffff, 0x2000257f, 0 , 0,
18475 0x0 }, /* POOL32Axf_5_group0~*(18) */
18476 { reserved_block , 0 , 0 , 32,
18477 0xfc00ffff, 0x2000277f, 0 , 0,
18478 0x0 }, /* POOL32Axf_5_group0~*(19) */
18479 { reserved_block , 0 , 0 , 32,
18480 0xfc00ffff, 0x2000297f, 0 , 0,
18481 0x0 }, /* POOL32Axf_5_group0~*(20) */
18482 { reserved_block , 0 , 0 , 32,
18483 0xfc00ffff, 0x20002b7f, 0 , 0,
18484 0x0 }, /* POOL32Axf_5_group0~*(21) */
18485 { reserved_block , 0 , 0 , 32,
18486 0xfc00ffff, 0x20002d7f, 0 , 0,
18487 0x0 }, /* POOL32Axf_5_group0~*(22) */
18488 { reserved_block , 0 , 0 , 32,
18489 0xfc00ffff, 0x20002f7f, 0 , 0,
18490 0x0 }, /* POOL32Axf_5_group0~*(23) */
18491 { instruction , 0 , 0 , 32,
18492 0xfc00ffff, 0x2000317f, &NMD::TLBGWR , 0,
18493 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18494 { instruction , 0 , 0 , 32,
18495 0xfc00ffff, 0x2000337f, &NMD::TLBWR , 0,
18496 CP0_ | TLB_ }, /* TLBWR */
18497 { reserved_block , 0 , 0 , 32,
18498 0xfc00ffff, 0x2000357f, 0 , 0,
18499 0x0 }, /* POOL32Axf_5_group0~*(26) */
18500 { reserved_block , 0 , 0 , 32,
18501 0xfc00ffff, 0x2000377f, 0 , 0,
18502 0x0 }, /* POOL32Axf_5_group0~*(27) */
18503 { reserved_block , 0 , 0 , 32,
18504 0xfc00ffff, 0x2000397f, 0 , 0,
18505 0x0 }, /* POOL32Axf_5_group0~*(28) */
18506 { reserved_block , 0 , 0 , 32,
18507 0xfc00ffff, 0x20003b7f, 0 , 0,
18508 0x0 }, /* POOL32Axf_5_group0~*(29) */
18509 { reserved_block , 0 , 0 , 32,
18510 0xfc00ffff, 0x20003d7f, 0 , 0,
18511 0x0 }, /* POOL32Axf_5_group0~*(30) */
18512 { reserved_block , 0 , 0 , 32,
18513 0xfc00ffff, 0x20003f7f, 0 , 0,
18514 0x0 }, /* POOL32Axf_5_group0~*(31) */
18515};
18516
18517
18518NMD::Pool NMD::POOL32Axf_5_group1[32] = {
18519 { reserved_block , 0 , 0 , 32,
18520 0xfc00ffff, 0x2000417f, 0 , 0,
18521 0x0 }, /* POOL32Axf_5_group1~*(0) */
18522 { reserved_block , 0 , 0 , 32,
18523 0xfc00ffff, 0x2000437f, 0 , 0,
18524 0x0 }, /* POOL32Axf_5_group1~*(1) */
18525 { reserved_block , 0 , 0 , 32,
18526 0xfc00ffff, 0x2000457f, 0 , 0,
18527 0x0 }, /* POOL32Axf_5_group1~*(2) */
18528 { instruction , 0 , 0 , 32,
18529 0xfc00ffff, 0x2000477f, &NMD::DI , 0,
18530 0x0 }, /* DI */
18531 { reserved_block , 0 , 0 , 32,
18532 0xfc00ffff, 0x2000497f, 0 , 0,
18533 0x0 }, /* POOL32Axf_5_group1~*(4) */
18534 { reserved_block , 0 , 0 , 32,
18535 0xfc00ffff, 0x20004b7f, 0 , 0,
18536 0x0 }, /* POOL32Axf_5_group1~*(5) */
18537 { reserved_block , 0 , 0 , 32,
18538 0xfc00ffff, 0x20004d7f, 0 , 0,
18539 0x0 }, /* POOL32Axf_5_group1~*(6) */
18540 { reserved_block , 0 , 0 , 32,
18541 0xfc00ffff, 0x20004f7f, 0 , 0,
18542 0x0 }, /* POOL32Axf_5_group1~*(7) */
18543 { reserved_block , 0 , 0 , 32,
18544 0xfc00ffff, 0x2000517f, 0 , 0,
18545 0x0 }, /* POOL32Axf_5_group1~*(8) */
18546 { reserved_block , 0 , 0 , 32,
18547 0xfc00ffff, 0x2000537f, 0 , 0,
18548 0x0 }, /* POOL32Axf_5_group1~*(9) */
18549 { reserved_block , 0 , 0 , 32,
18550 0xfc00ffff, 0x2000557f, 0 , 0,
18551 0x0 }, /* POOL32Axf_5_group1~*(10) */
18552 { instruction , 0 , 0 , 32,
18553 0xfc00ffff, 0x2000577f, &NMD::EI , 0,
18554 0x0 }, /* EI */
18555 { reserved_block , 0 , 0 , 32,
18556 0xfc00ffff, 0x2000597f, 0 , 0,
18557 0x0 }, /* POOL32Axf_5_group1~*(12) */
18558 { reserved_block , 0 , 0 , 32,
18559 0xfc00ffff, 0x20005b7f, 0 , 0,
18560 0x0 }, /* POOL32Axf_5_group1~*(13) */
18561 { reserved_block , 0 , 0 , 32,
18562 0xfc00ffff, 0x20005d7f, 0 , 0,
18563 0x0 }, /* POOL32Axf_5_group1~*(14) */
18564 { reserved_block , 0 , 0 , 32,
18565 0xfc00ffff, 0x20005f7f, 0 , 0,
18566 0x0 }, /* POOL32Axf_5_group1~*(15) */
18567 { reserved_block , 0 , 0 , 32,
18568 0xfc00ffff, 0x2000617f, 0 , 0,
18569 0x0 }, /* POOL32Axf_5_group1~*(16) */
18570 { reserved_block , 0 , 0 , 32,
18571 0xfc00ffff, 0x2000637f, 0 , 0,
18572 0x0 }, /* POOL32Axf_5_group1~*(17) */
18573 { reserved_block , 0 , 0 , 32,
18574 0xfc00ffff, 0x2000657f, 0 , 0,
18575 0x0 }, /* POOL32Axf_5_group1~*(18) */
18576 { reserved_block , 0 , 0 , 32,
18577 0xfc00ffff, 0x2000677f, 0 , 0,
18578 0x0 }, /* POOL32Axf_5_group1~*(19) */
18579 { reserved_block , 0 , 0 , 32,
18580 0xfc00ffff, 0x2000697f, 0 , 0,
18581 0x0 }, /* POOL32Axf_5_group1~*(20) */
18582 { reserved_block , 0 , 0 , 32,
18583 0xfc00ffff, 0x20006b7f, 0 , 0,
18584 0x0 }, /* POOL32Axf_5_group1~*(21) */
18585 { reserved_block , 0 , 0 , 32,
18586 0xfc00ffff, 0x20006d7f, 0 , 0,
18587 0x0 }, /* POOL32Axf_5_group1~*(22) */
18588 { reserved_block , 0 , 0 , 32,
18589 0xfc00ffff, 0x20006f7f, 0 , 0,
18590 0x0 }, /* POOL32Axf_5_group1~*(23) */
18591 { reserved_block , 0 , 0 , 32,
18592 0xfc00ffff, 0x2000717f, 0 , 0,
18593 0x0 }, /* POOL32Axf_5_group1~*(24) */
18594 { reserved_block , 0 , 0 , 32,
18595 0xfc00ffff, 0x2000737f, 0 , 0,
18596 0x0 }, /* POOL32Axf_5_group1~*(25) */
18597 { reserved_block , 0 , 0 , 32,
18598 0xfc00ffff, 0x2000757f, 0 , 0,
18599 0x0 }, /* POOL32Axf_5_group1~*(26) */
18600 { reserved_block , 0 , 0 , 32,
18601 0xfc00ffff, 0x2000777f, 0 , 0,
18602 0x0 }, /* POOL32Axf_5_group1~*(27) */
18603 { reserved_block , 0 , 0 , 32,
18604 0xfc00ffff, 0x2000797f, 0 , 0,
18605 0x0 }, /* POOL32Axf_5_group1~*(28) */
18606 { reserved_block , 0 , 0 , 32,
18607 0xfc00ffff, 0x20007b7f, 0 , 0,
18608 0x0 }, /* POOL32Axf_5_group1~*(29) */
18609 { reserved_block , 0 , 0 , 32,
18610 0xfc00ffff, 0x20007d7f, 0 , 0,
18611 0x0 }, /* POOL32Axf_5_group1~*(30) */
18612 { reserved_block , 0 , 0 , 32,
18613 0xfc00ffff, 0x20007f7f, 0 , 0,
18614 0x0 }, /* POOL32Axf_5_group1~*(31) */
18615};
18616
18617
18618NMD::Pool NMD::ERETx[2] = {
18619 { instruction , 0 , 0 , 32,
18620 0xfc01ffff, 0x2000f37f, &NMD::ERET , 0,
18621 0x0 }, /* ERET */
18622 { instruction , 0 , 0 , 32,
18623 0xfc01ffff, 0x2001f37f, &NMD::ERETNC , 0,
18624 0x0 }, /* ERETNC */
18625};
18626
18627
18628NMD::Pool NMD::POOL32Axf_5_group3[32] = {
18629 { reserved_block , 0 , 0 , 32,
18630 0xfc00ffff, 0x2000c17f, 0 , 0,
18631 0x0 }, /* POOL32Axf_5_group3~*(0) */
18632 { instruction , 0 , 0 , 32,
18633 0xfc00ffff, 0x2000c37f, &NMD::WAIT , 0,
18634 0x0 }, /* WAIT */
18635 { reserved_block , 0 , 0 , 32,
18636 0xfc00ffff, 0x2000c57f, 0 , 0,
18637 0x0 }, /* POOL32Axf_5_group3~*(2) */
18638 { reserved_block , 0 , 0 , 32,
18639 0xfc00ffff, 0x2000c77f, 0 , 0,
18640 0x0 }, /* POOL32Axf_5_group3~*(3) */
18641 { reserved_block , 0 , 0 , 32,
18642 0xfc00ffff, 0x2000c97f, 0 , 0,
18643 0x0 }, /* POOL32Axf_5_group3~*(4) */
18644 { reserved_block , 0 , 0 , 32,
18645 0xfc00ffff, 0x2000cb7f, 0 , 0,
18646 0x0 }, /* POOL32Axf_5_group3~*(5) */
18647 { reserved_block , 0 , 0 , 32,
18648 0xfc00ffff, 0x2000cd7f, 0 , 0,
18649 0x0 }, /* POOL32Axf_5_group3~*(6) */
18650 { reserved_block , 0 , 0 , 32,
18651 0xfc00ffff, 0x2000cf7f, 0 , 0,
18652 0x0 }, /* POOL32Axf_5_group3~*(7) */
18653 { reserved_block , 0 , 0 , 32,
18654 0xfc00ffff, 0x2000d17f, 0 , 0,
18655 0x0 }, /* POOL32Axf_5_group3~*(8) */
18656 { instruction , 0 , 0 , 32,
18657 0xfc00ffff, 0x2000d37f, &NMD::IRET , 0,
18658 MCU_ }, /* IRET */
18659 { reserved_block , 0 , 0 , 32,
18660 0xfc00ffff, 0x2000d57f, 0 , 0,
18661 0x0 }, /* POOL32Axf_5_group3~*(10) */
18662 { reserved_block , 0 , 0 , 32,
18663 0xfc00ffff, 0x2000d77f, 0 , 0,
18664 0x0 }, /* POOL32Axf_5_group3~*(11) */
18665 { reserved_block , 0 , 0 , 32,
18666 0xfc00ffff, 0x2000d97f, 0 , 0,
18667 0x0 }, /* POOL32Axf_5_group3~*(12) */
18668 { reserved_block , 0 , 0 , 32,
18669 0xfc00ffff, 0x2000db7f, 0 , 0,
18670 0x0 }, /* POOL32Axf_5_group3~*(13) */
18671 { reserved_block , 0 , 0 , 32,
18672 0xfc00ffff, 0x2000dd7f, 0 , 0,
18673 0x0 }, /* POOL32Axf_5_group3~*(14) */
18674 { reserved_block , 0 , 0 , 32,
18675 0xfc00ffff, 0x2000df7f, 0 , 0,
18676 0x0 }, /* POOL32Axf_5_group3~*(15) */
18677 { instruction , 0 , 0 , 32,
18678 0xfc00ffff, 0x2000e17f, &NMD::RDPGPR , 0,
18679 CP0_ }, /* RDPGPR */
18680 { instruction , 0 , 0 , 32,
18681 0xfc00ffff, 0x2000e37f, &NMD::DERET , 0,
18682 EJTAG_ }, /* DERET */
18683 { reserved_block , 0 , 0 , 32,
18684 0xfc00ffff, 0x2000e57f, 0 , 0,
18685 0x0 }, /* POOL32Axf_5_group3~*(18) */
18686 { reserved_block , 0 , 0 , 32,
18687 0xfc00ffff, 0x2000e77f, 0 , 0,
18688 0x0 }, /* POOL32Axf_5_group3~*(19) */
18689 { reserved_block , 0 , 0 , 32,
18690 0xfc00ffff, 0x2000e97f, 0 , 0,
18691 0x0 }, /* POOL32Axf_5_group3~*(20) */
18692 { reserved_block , 0 , 0 , 32,
18693 0xfc00ffff, 0x2000eb7f, 0 , 0,
18694 0x0 }, /* POOL32Axf_5_group3~*(21) */
18695 { reserved_block , 0 , 0 , 32,
18696 0xfc00ffff, 0x2000ed7f, 0 , 0,
18697 0x0 }, /* POOL32Axf_5_group3~*(22) */
18698 { reserved_block , 0 , 0 , 32,
18699 0xfc00ffff, 0x2000ef7f, 0 , 0,
18700 0x0 }, /* POOL32Axf_5_group3~*(23) */
18701 { instruction , 0 , 0 , 32,
18702 0xfc00ffff, 0x2000f17f, &NMD::WRPGPR , 0,
18703 CP0_ }, /* WRPGPR */
18704 { pool , ERETx , 2 , 32,
18705 0xfc00ffff, 0x2000f37f, 0 , 0,
18706 0x0 }, /* ERETx */
18707 { reserved_block , 0 , 0 , 32,
18708 0xfc00ffff, 0x2000f57f, 0 , 0,
18709 0x0 }, /* POOL32Axf_5_group3~*(26) */
18710 { reserved_block , 0 , 0 , 32,
18711 0xfc00ffff, 0x2000f77f, 0 , 0,
18712 0x0 }, /* POOL32Axf_5_group3~*(27) */
18713 { reserved_block , 0 , 0 , 32,
18714 0xfc00ffff, 0x2000f97f, 0 , 0,
18715 0x0 }, /* POOL32Axf_5_group3~*(28) */
18716 { reserved_block , 0 , 0 , 32,
18717 0xfc00ffff, 0x2000fb7f, 0 , 0,
18718 0x0 }, /* POOL32Axf_5_group3~*(29) */
18719 { reserved_block , 0 , 0 , 32,
18720 0xfc00ffff, 0x2000fd7f, 0 , 0,
18721 0x0 }, /* POOL32Axf_5_group3~*(30) */
18722 { reserved_block , 0 , 0 , 32,
18723 0xfc00ffff, 0x2000ff7f, 0 , 0,
18724 0x0 }, /* POOL32Axf_5_group3~*(31) */
18725};
18726
18727
18728NMD::Pool NMD::POOL32Axf_5[4] = {
18729 { pool , POOL32Axf_5_group0 , 32 , 32,
18730 0xfc00c1ff, 0x2000017f, 0 , 0,
18731 0x0 }, /* POOL32Axf_5_group0 */
18732 { pool , POOL32Axf_5_group1 , 32 , 32,
18733 0xfc00c1ff, 0x2000417f, 0 , 0,
18734 0x0 }, /* POOL32Axf_5_group1 */
18735 { reserved_block , 0 , 0 , 32,
18736 0xfc00c1ff, 0x2000817f, 0 , 0,
18737 0x0 }, /* POOL32Axf_5~*(2) */
18738 { pool , POOL32Axf_5_group3 , 32 , 32,
18739 0xfc00c1ff, 0x2000c17f, 0 , 0,
18740 0x0 }, /* POOL32Axf_5_group3 */
18741};
18742
18743
18744NMD::Pool NMD::SHRA__R__QB[2] = {
18745 { instruction , 0 , 0 , 32,
18746 0xfc001fff, 0x200001ff, &NMD::SHRA_QB , 0,
18747 DSP_ }, /* SHRA.QB */
18748 { instruction , 0 , 0 , 32,
18749 0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB , 0,
18750 DSP_ }, /* SHRA_R.QB */
18751};
18752
18753
18754NMD::Pool NMD::POOL32Axf_7[8] = {
18755 { pool , SHRA__R__QB , 2 , 32,
18756 0xfc000fff, 0x200001ff, 0 , 0,
18757 0x0 }, /* SHRA[_R].QB */
18758 { instruction , 0 , 0 , 32,
18759 0xfc000fff, 0x200003ff, &NMD::SHRL_PH , 0,
18760 DSP_ }, /* SHRL.PH */
18761 { instruction , 0 , 0 , 32,
18762 0xfc000fff, 0x200005ff, &NMD::REPL_QB , 0,
18763 DSP_ }, /* REPL.QB */
18764 { reserved_block , 0 , 0 , 32,
18765 0xfc000fff, 0x200007ff, 0 , 0,
18766 0x0 }, /* POOL32Axf_7~*(3) */
18767 { reserved_block , 0 , 0 , 32,
18768 0xfc000fff, 0x200009ff, 0 , 0,
18769 0x0 }, /* POOL32Axf_7~*(4) */
18770 { reserved_block , 0 , 0 , 32,
18771 0xfc000fff, 0x20000bff, 0 , 0,
18772 0x0 }, /* POOL32Axf_7~*(5) */
18773 { reserved_block , 0 , 0 , 32,
18774 0xfc000fff, 0x20000dff, 0 , 0,
18775 0x0 }, /* POOL32Axf_7~*(6) */
18776 { reserved_block , 0 , 0 , 32,
18777 0xfc000fff, 0x20000fff, 0 , 0,
18778 0x0 }, /* POOL32Axf_7~*(7) */
18779};
18780
18781
18782NMD::Pool NMD::POOL32Axf[8] = {
18783 { reserved_block , 0 , 0 , 32,
18784 0xfc0001ff, 0x2000003f, 0 , 0,
18785 0x0 }, /* POOL32Axf~*(0) */
18786 { pool , POOL32Axf_1 , 8 , 32,
18787 0xfc0001ff, 0x2000007f, 0 , 0,
18788 0x0 }, /* POOL32Axf_1 */
18789 { pool , POOL32Axf_2 , 4 , 32,
18790 0xfc0001ff, 0x200000bf, 0 , 0,
18791 0x0 }, /* POOL32Axf_2 */
18792 { reserved_block , 0 , 0 , 32,
18793 0xfc0001ff, 0x200000ff, 0 , 0,
18794 0x0 }, /* POOL32Axf~*(3) */
18795 { pool , POOL32Axf_4 , 128 , 32,
18796 0xfc0001ff, 0x2000013f, 0 , 0,
18797 0x0 }, /* POOL32Axf_4 */
18798 { pool , POOL32Axf_5 , 4 , 32,
18799 0xfc0001ff, 0x2000017f, 0 , 0,
18800 0x0 }, /* POOL32Axf_5 */
18801 { reserved_block , 0 , 0 , 32,
18802 0xfc0001ff, 0x200001bf, 0 , 0,
18803 0x0 }, /* POOL32Axf~*(6) */
18804 { pool , POOL32Axf_7 , 8 , 32,
18805 0xfc0001ff, 0x200001ff, 0 , 0,
18806 0x0 }, /* POOL32Axf_7 */
18807};
18808
18809
18810NMD::Pool NMD::_POOL32A7[8] = {
18811 { pool , P_LSX , 2 , 32,
18812 0xfc00003f, 0x20000007, 0 , 0,
18813 0x0 }, /* P.LSX */
18814 { instruction , 0 , 0 , 32,
18815 0xfc00003f, 0x2000000f, &NMD::LSA , 0,
18816 0x0 }, /* LSA */
18817 { reserved_block , 0 , 0 , 32,
18818 0xfc00003f, 0x20000017, 0 , 0,
18819 0x0 }, /* _POOL32A7~*(2) */
18820 { instruction , 0 , 0 , 32,
18821 0xfc00003f, 0x2000001f, &NMD::EXTW , 0,
18822 0x0 }, /* EXTW */
18823 { reserved_block , 0 , 0 , 32,
18824 0xfc00003f, 0x20000027, 0 , 0,
18825 0x0 }, /* _POOL32A7~*(4) */
18826 { reserved_block , 0 , 0 , 32,
18827 0xfc00003f, 0x2000002f, 0 , 0,
18828 0x0 }, /* _POOL32A7~*(5) */
18829 { reserved_block , 0 , 0 , 32,
18830 0xfc00003f, 0x20000037, 0 , 0,
18831 0x0 }, /* _POOL32A7~*(6) */
18832 { pool , POOL32Axf , 8 , 32,
18833 0xfc00003f, 0x2000003f, 0 , 0,
18834 0x0 }, /* POOL32Axf */
18835};
18836
18837
18838NMD::Pool NMD::P32A[8] = {
18839 { pool , _POOL32A0 , 128 , 32,
18840 0xfc000007, 0x20000000, 0 , 0,
18841 0x0 }, /* _POOL32A0 */
18842 { instruction , 0 , 0 , 32,
18843 0xfc000007, 0x20000001, &NMD::SPECIAL2 , 0,
18844 UDI_ }, /* SPECIAL2 */
18845 { instruction , 0 , 0 , 32,
18846 0xfc000007, 0x20000002, &NMD::COP2_1 , 0,
18847 CP2_ }, /* COP2_1 */
18848 { instruction , 0 , 0 , 32,
18849 0xfc000007, 0x20000003, &NMD::UDI , 0,
18850 UDI_ }, /* UDI */
18851 { reserved_block , 0 , 0 , 32,
18852 0xfc000007, 0x20000004, 0 , 0,
18853 0x0 }, /* P32A~*(4) */
18854 { pool , _POOL32A5 , 128 , 32,
18855 0xfc000007, 0x20000005, 0 , 0,
18856 0x0 }, /* _POOL32A5 */
18857 { reserved_block , 0 , 0 , 32,
18858 0xfc000007, 0x20000006, 0 , 0,
18859 0x0 }, /* P32A~*(6) */
18860 { pool , _POOL32A7 , 8 , 32,
18861 0xfc000007, 0x20000007, 0 , 0,
18862 0x0 }, /* _POOL32A7 */
18863};
18864
18865
18866NMD::Pool NMD::P_GP_D[2] = {
18867 { instruction , 0 , 0 , 32,
18868 0xfc000007, 0x40000001, &NMD::LD_GP_ , 0,
18869 MIPS64_ }, /* LD[GP] */
18870 { instruction , 0 , 0 , 32,
18871 0xfc000007, 0x40000005, &NMD::SD_GP_ , 0,
18872 MIPS64_ }, /* SD[GP] */
18873};
18874
18875
18876NMD::Pool NMD::P_GP_W[4] = {
18877 { instruction , 0 , 0 , 32,
18878 0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_ , 0,
18879 0x0 }, /* ADDIU[GP.W] */
18880 { pool , P_GP_D , 2 , 32,
18881 0xfc000003, 0x40000001, 0 , 0,
18882 0x0 }, /* P.GP.D */
18883 { instruction , 0 , 0 , 32,
18884 0xfc000003, 0x40000002, &NMD::LW_GP_ , 0,
18885 0x0 }, /* LW[GP] */
18886 { instruction , 0 , 0 , 32,
18887 0xfc000003, 0x40000003, &NMD::SW_GP_ , 0,
18888 0x0 }, /* SW[GP] */
18889};
18890
18891
18892NMD::Pool NMD::POOL48I[32] = {
18893 { instruction , 0 , 0 , 48,
18894 0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_ , 0,
18895 XMMS_ }, /* LI[48] */
18896 { instruction , 0 , 0 , 48,
18897 0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_ , 0,
18898 XMMS_ }, /* ADDIU[48] */
18899 { instruction , 0 , 0 , 48,
18900 0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_ , 0,
18901 XMMS_ }, /* ADDIU[GP48] */
18902 { instruction , 0 , 0 , 48,
18903 0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_ , 0,
18904 XMMS_ }, /* ADDIUPC[48] */
18905 { reserved_block , 0 , 0 , 48,
18906 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18907 0x0 }, /* POOL48I~*(4) */
18908 { reserved_block , 0 , 0 , 48,
18909 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18910 0x0 }, /* POOL48I~*(5) */
18911 { reserved_block , 0 , 0 , 48,
18912 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18913 0x0 }, /* POOL48I~*(6) */
18914 { reserved_block , 0 , 0 , 48,
18915 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18916 0x0 }, /* POOL48I~*(7) */
18917 { reserved_block , 0 , 0 , 48,
18918 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18919 0x0 }, /* POOL48I~*(8) */
18920 { reserved_block , 0 , 0 , 48,
18921 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18922 0x0 }, /* POOL48I~*(9) */
18923 { reserved_block , 0 , 0 , 48,
18924 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18925 0x0 }, /* POOL48I~*(10) */
18926 { instruction , 0 , 0 , 48,
18927 0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_ , 0,
18928 XMMS_ }, /* LWPC[48] */
18929 { reserved_block , 0 , 0 , 48,
18930 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18931 0x0 }, /* POOL48I~*(12) */
18932 { reserved_block , 0 , 0 , 48,
18933 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18934 0x0 }, /* POOL48I~*(13) */
18935 { reserved_block , 0 , 0 , 48,
18936 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18937 0x0 }, /* POOL48I~*(14) */
18938 { instruction , 0 , 0 , 48,
18939 0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_ , 0,
18940 XMMS_ }, /* SWPC[48] */
18941 { reserved_block , 0 , 0 , 48,
18942 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18943 0x0 }, /* POOL48I~*(16) */
18944 { instruction , 0 , 0 , 48,
18945 0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_ , 0,
18946 MIPS64_ }, /* DADDIU[48] */
18947 { reserved_block , 0 , 0 , 48,
18948 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18949 0x0 }, /* POOL48I~*(18) */
18950 { reserved_block , 0 , 0 , 48,
18951 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18952 0x0 }, /* POOL48I~*(19) */
18953 { instruction , 0 , 0 , 48,
18954 0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_ , 0,
18955 MIPS64_ }, /* DLUI[48] */
18956 { reserved_block , 0 , 0 , 48,
18957 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18958 0x0 }, /* POOL48I~*(21) */
18959 { reserved_block , 0 , 0 , 48,
18960 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18961 0x0 }, /* POOL48I~*(22) */
18962 { reserved_block , 0 , 0 , 48,
18963 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18964 0x0 }, /* POOL48I~*(23) */
18965 { reserved_block , 0 , 0 , 48,
18966 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18967 0x0 }, /* POOL48I~*(24) */
18968 { reserved_block , 0 , 0 , 48,
18969 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18970 0x0 }, /* POOL48I~*(25) */
18971 { reserved_block , 0 , 0 , 48,
18972 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18973 0x0 }, /* POOL48I~*(26) */
18974 { instruction , 0 , 0 , 48,
18975 0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_ , 0,
18976 MIPS64_ }, /* LDPC[48] */
18977 { reserved_block , 0 , 0 , 48,
18978 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18979 0x0 }, /* POOL48I~*(28) */
18980 { reserved_block , 0 , 0 , 48,
18981 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18982 0x0 }, /* POOL48I~*(29) */
18983 { reserved_block , 0 , 0 , 48,
18984 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18985 0x0 }, /* POOL48I~*(30) */
18986 { instruction , 0 , 0 , 48,
18987 0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_ , 0,
18988 MIPS64_ }, /* SDPC[48] */
18989};
18990
18991
18992NMD::Pool NMD::PP_SR[4] = {
18993 { instruction , 0 , 0 , 32,
18994 0xfc10f003, 0x80003000, &NMD::SAVE_32_ , 0,
18995 0x0 }, /* SAVE[32] */
18996 { reserved_block , 0 , 0 , 32,
18997 0xfc10f003, 0x80003001, 0 , 0,
18998 0x0 }, /* PP.SR~*(1) */
18999 { instruction , 0 , 0 , 32,
19000 0xfc10f003, 0x80003002, &NMD::RESTORE_32_ , 0,
19001 0x0 }, /* RESTORE[32] */
19002 { return_instruction , 0 , 0 , 32,
19003 0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_ , 0,
19004 0x0 }, /* RESTORE.JRC[32] */
19005};
19006
19007
19008NMD::Pool NMD::P_SR_F[8] = {
19009 { instruction , 0 , 0 , 32,
19010 0xfc10f007, 0x80103000, &NMD::SAVEF , 0,
19011 CP1_ }, /* SAVEF */
19012 { instruction , 0 , 0 , 32,
19013 0xfc10f007, 0x80103001, &NMD::RESTOREF , 0,
19014 CP1_ }, /* RESTOREF */
19015 { reserved_block , 0 , 0 , 32,
19016 0xfc10f007, 0x80103002, 0 , 0,
19017 0x0 }, /* P.SR.F~*(2) */
19018 { reserved_block , 0 , 0 , 32,
19019 0xfc10f007, 0x80103003, 0 , 0,
19020 0x0 }, /* P.SR.F~*(3) */
19021 { reserved_block , 0 , 0 , 32,
19022 0xfc10f007, 0x80103004, 0 , 0,
19023 0x0 }, /* P.SR.F~*(4) */
19024 { reserved_block , 0 , 0 , 32,
19025 0xfc10f007, 0x80103005, 0 , 0,
19026 0x0 }, /* P.SR.F~*(5) */
19027 { reserved_block , 0 , 0 , 32,
19028 0xfc10f007, 0x80103006, 0 , 0,
19029 0x0 }, /* P.SR.F~*(6) */
19030 { reserved_block , 0 , 0 , 32,
19031 0xfc10f007, 0x80103007, 0 , 0,
19032 0x0 }, /* P.SR.F~*(7) */
19033};
19034
19035
19036NMD::Pool NMD::P_SR[2] = {
19037 { pool , PP_SR , 4 , 32,
19038 0xfc10f000, 0x80003000, 0 , 0,
19039 0x0 }, /* PP.SR */
19040 { pool , P_SR_F , 8 , 32,
19041 0xfc10f000, 0x80103000, 0 , 0,
19042 0x0 }, /* P.SR.F */
19043};
19044
19045
19046NMD::Pool NMD::P_SLL[5] = {
19047 { instruction , 0 , 0 , 32,
19048 0xffe0f1ff, 0x8000c000, &NMD::NOP_32_ , 0,
19049 0x0 }, /* NOP[32] */
19050 { instruction , 0 , 0 , 32,
19051 0xffe0f1ff, 0x8000c003, &NMD::EHB , 0,
19052 0x0 }, /* EHB */
19053 { instruction , 0 , 0 , 32,
19054 0xffe0f1ff, 0x8000c005, &NMD::PAUSE , 0,
19055 0x0 }, /* PAUSE */
19056 { instruction , 0 , 0 , 32,
19057 0xffe0f1ff, 0x8000c006, &NMD::SYNC , 0,
19058 0x0 }, /* SYNC */
19059 { instruction , 0 , 0 , 32,
19060 0xfc00f1e0, 0x8000c000, &NMD::SLL_32_ , 0,
19061 0x0 }, /* SLL[32] */
19062};
19063
19064
19065NMD::Pool NMD::P_SHIFT[16] = {
19066 { pool , P_SLL , 5 , 32,
19067 0xfc00f1e0, 0x8000c000, 0 , 0,
19068 0x0 }, /* P.SLL */
19069 { reserved_block , 0 , 0 , 32,
19070 0xfc00f1e0, 0x8000c020, 0 , 0,
19071 0x0 }, /* P.SHIFT~*(1) */
19072 { instruction , 0 , 0 , 32,
19073 0xfc00f1e0, 0x8000c040, &NMD::SRL_32_ , 0,
19074 0x0 }, /* SRL[32] */
19075 { reserved_block , 0 , 0 , 32,
19076 0xfc00f1e0, 0x8000c060, 0 , 0,
19077 0x0 }, /* P.SHIFT~*(3) */
19078 { instruction , 0 , 0 , 32,
19079 0xfc00f1e0, 0x8000c080, &NMD::SRA , 0,
19080 0x0 }, /* SRA */
19081 { reserved_block , 0 , 0 , 32,
19082 0xfc00f1e0, 0x8000c0a0, 0 , 0,
19083 0x0 }, /* P.SHIFT~*(5) */
19084 { instruction , 0 , 0 , 32,
19085 0xfc00f1e0, 0x8000c0c0, &NMD::ROTR , 0,
19086 0x0 }, /* ROTR */
19087 { reserved_block , 0 , 0 , 32,
19088 0xfc00f1e0, 0x8000c0e0, 0 , 0,
19089 0x0 }, /* P.SHIFT~*(7) */
19090 { instruction , 0 , 0 , 32,
19091 0xfc00f1e0, 0x8000c100, &NMD::DSLL , 0,
19092 MIPS64_ }, /* DSLL */
19093 { instruction , 0 , 0 , 32,
19094 0xfc00f1e0, 0x8000c120, &NMD::DSLL32 , 0,
19095 MIPS64_ }, /* DSLL32 */
19096 { instruction , 0 , 0 , 32,
19097 0xfc00f1e0, 0x8000c140, &NMD::DSRL , 0,
19098 MIPS64_ }, /* DSRL */
19099 { instruction , 0 , 0 , 32,
19100 0xfc00f1e0, 0x8000c160, &NMD::DSRL32 , 0,
19101 MIPS64_ }, /* DSRL32 */
19102 { instruction , 0 , 0 , 32,
19103 0xfc00f1e0, 0x8000c180, &NMD::DSRA , 0,
19104 MIPS64_ }, /* DSRA */
19105 { instruction , 0 , 0 , 32,
19106 0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32 , 0,
19107 MIPS64_ }, /* DSRA32 */
19108 { instruction , 0 , 0 , 32,
19109 0xfc00f1e0, 0x8000c1c0, &NMD::DROTR , 0,
19110 MIPS64_ }, /* DROTR */
19111 { instruction , 0 , 0 , 32,
19112 0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32 , 0,
19113 MIPS64_ }, /* DROTR32 */
19114};
19115
19116
19117NMD::Pool NMD::P_ROTX[4] = {
19118 { instruction , 0 , 0 , 32,
19119 0xfc00f820, 0x8000d000, &NMD::ROTX , 0,
19120 XMMS_ }, /* ROTX */
19121 { reserved_block , 0 , 0 , 32,
19122 0xfc00f820, 0x8000d020, 0 , 0,
19123 0x0 }, /* P.ROTX~*(1) */
19124 { reserved_block , 0 , 0 , 32,
19125 0xfc00f820, 0x8000d800, 0 , 0,
19126 0x0 }, /* P.ROTX~*(2) */
19127 { reserved_block , 0 , 0 , 32,
19128 0xfc00f820, 0x8000d820, 0 , 0,
19129 0x0 }, /* P.ROTX~*(3) */
19130};
19131
19132
19133NMD::Pool NMD::P_INS[4] = {
19134 { instruction , 0 , 0 , 32,
19135 0xfc00f820, 0x8000e000, &NMD::INS , 0,
19136 XMMS_ }, /* INS */
19137 { instruction , 0 , 0 , 32,
19138 0xfc00f820, 0x8000e020, &NMD::DINSU , 0,
19139 MIPS64_ }, /* DINSU */
19140 { instruction , 0 , 0 , 32,
19141 0xfc00f820, 0x8000e800, &NMD::DINSM , 0,
19142 MIPS64_ }, /* DINSM */
19143 { instruction , 0 , 0 , 32,
19144 0xfc00f820, 0x8000e820, &NMD::DINS , 0,
19145 MIPS64_ }, /* DINS */
19146};
19147
19148
19149NMD::Pool NMD::P_EXT[4] = {
19150 { instruction , 0 , 0 , 32,
19151 0xfc00f820, 0x8000f000, &NMD::EXT , 0,
19152 XMMS_ }, /* EXT */
19153 { instruction , 0 , 0 , 32,
19154 0xfc00f820, 0x8000f020, &NMD::DEXTU , 0,
19155 MIPS64_ }, /* DEXTU */
19156 { instruction , 0 , 0 , 32,
19157 0xfc00f820, 0x8000f800, &NMD::DEXTM , 0,
19158 MIPS64_ }, /* DEXTM */
19159 { instruction , 0 , 0 , 32,
19160 0xfc00f820, 0x8000f820, &NMD::DEXT , 0,
19161 MIPS64_ }, /* DEXT */
19162};
19163
19164
19165NMD::Pool NMD::P_U12[16] = {
19166 { instruction , 0 , 0 , 32,
19167 0xfc00f000, 0x80000000, &NMD::ORI , 0,
19168 0x0 }, /* ORI */
19169 { instruction , 0 , 0 , 32,
19170 0xfc00f000, 0x80001000, &NMD::XORI , 0,
19171 0x0 }, /* XORI */
19172 { instruction , 0 , 0 , 32,
19173 0xfc00f000, 0x80002000, &NMD::ANDI_32_ , 0,
19174 0x0 }, /* ANDI[32] */
19175 { pool , P_SR , 2 , 32,
19176 0xfc00f000, 0x80003000, 0 , 0,
19177 0x0 }, /* P.SR */
19178 { instruction , 0 , 0 , 32,
19179 0xfc00f000, 0x80004000, &NMD::SLTI , 0,
19180 0x0 }, /* SLTI */
19181 { instruction , 0 , 0 , 32,
19182 0xfc00f000, 0x80005000, &NMD::SLTIU , 0,
19183 0x0 }, /* SLTIU */
19184 { instruction , 0 , 0 , 32,
19185 0xfc00f000, 0x80006000, &NMD::SEQI , 0,
19186 0x0 }, /* SEQI */
19187 { reserved_block , 0 , 0 , 32,
19188 0xfc00f000, 0x80007000, 0 , 0,
19189 0x0 }, /* P.U12~*(7) */
19190 { instruction , 0 , 0 , 32,
19191 0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_ , 0,
19192 0x0 }, /* ADDIU[NEG] */
19193 { instruction , 0 , 0 , 32,
19194 0xfc00f000, 0x80009000, &NMD::DADDIU_U12_ , 0,
19195 MIPS64_ }, /* DADDIU[U12] */
19196 { instruction , 0 , 0 , 32,
19197 0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_ , 0,
19198 MIPS64_ }, /* DADDIU[NEG] */
19199 { instruction , 0 , 0 , 32,
19200 0xfc00f000, 0x8000b000, &NMD::DROTX , 0,
19201 MIPS64_ }, /* DROTX */
19202 { pool , P_SHIFT , 16 , 32,
19203 0xfc00f000, 0x8000c000, 0 , 0,
19204 0x0 }, /* P.SHIFT */
19205 { pool , P_ROTX , 4 , 32,
19206 0xfc00f000, 0x8000d000, 0 , 0,
19207 0x0 }, /* P.ROTX */
19208 { pool , P_INS , 4 , 32,
19209 0xfc00f000, 0x8000e000, 0 , 0,
19210 0x0 }, /* P.INS */
19211 { pool , P_EXT , 4 , 32,
19212 0xfc00f000, 0x8000f000, 0 , 0,
19213 0x0 }, /* P.EXT */
19214};
19215
19216
19217NMD::Pool NMD::RINT_fmt[2] = {
19218 { instruction , 0 , 0 , 32,
19219 0xfc0003ff, 0xa0000020, &NMD::RINT_S , 0,
19220 CP1_ }, /* RINT.S */
19221 { instruction , 0 , 0 , 32,
19222 0xfc0003ff, 0xa0000220, &NMD::RINT_D , 0,
19223 CP1_ }, /* RINT.D */
19224};
19225
19226
19227NMD::Pool NMD::ADD_fmt0[2] = {
19228 { instruction , 0 , 0 , 32,
19229 0xfc0003ff, 0xa0000030, &NMD::ADD_S , 0,
19230 CP1_ }, /* ADD.S */
19231 { reserved_block , 0 , 0 , 32,
19232 0xfc0003ff, 0xa0000230, 0 , 0,
19233 CP1_ }, /* ADD.fmt0~*(1) */
19234};
19235
19236
19237NMD::Pool NMD::SELEQZ_fmt[2] = {
19238 { instruction , 0 , 0 , 32,
19239 0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S , 0,
19240 CP1_ }, /* SELEQZ.S */
19241 { instruction , 0 , 0 , 32,
19242 0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D , 0,
19243 CP1_ }, /* SELEQZ.D */
19244};
19245
19246
19247NMD::Pool NMD::CLASS_fmt[2] = {
19248 { instruction , 0 , 0 , 32,
19249 0xfc0003ff, 0xa0000060, &NMD::CLASS_S , 0,
19250 CP1_ }, /* CLASS.S */
19251 { instruction , 0 , 0 , 32,
19252 0xfc0003ff, 0xa0000260, &NMD::CLASS_D , 0,
19253 CP1_ }, /* CLASS.D */
19254};
19255
19256
19257NMD::Pool NMD::SUB_fmt0[2] = {
19258 { instruction , 0 , 0 , 32,
19259 0xfc0003ff, 0xa0000070, &NMD::SUB_S , 0,
19260 CP1_ }, /* SUB.S */
19261 { reserved_block , 0 , 0 , 32,
19262 0xfc0003ff, 0xa0000270, 0 , 0,
19263 CP1_ }, /* SUB.fmt0~*(1) */
19264};
19265
19266
19267NMD::Pool NMD::SELNEZ_fmt[2] = {
19268 { instruction , 0 , 0 , 32,
19269 0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S , 0,
19270 CP1_ }, /* SELNEZ.S */
19271 { instruction , 0 , 0 , 32,
19272 0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D , 0,
19273 CP1_ }, /* SELNEZ.D */
19274};
19275
19276
19277NMD::Pool NMD::MUL_fmt0[2] = {
19278 { instruction , 0 , 0 , 32,
19279 0xfc0003ff, 0xa00000b0, &NMD::MUL_S , 0,
19280 CP1_ }, /* MUL.S */
19281 { reserved_block , 0 , 0 , 32,
19282 0xfc0003ff, 0xa00002b0, 0 , 0,
19283 CP1_ }, /* MUL.fmt0~*(1) */
19284};
19285
19286
19287NMD::Pool NMD::SEL_fmt[2] = {
19288 { instruction , 0 , 0 , 32,
19289 0xfc0003ff, 0xa00000b8, &NMD::SEL_S , 0,
19290 CP1_ }, /* SEL.S */
19291 { instruction , 0 , 0 , 32,
19292 0xfc0003ff, 0xa00002b8, &NMD::SEL_D , 0,
19293 CP1_ }, /* SEL.D */
19294};
19295
19296
19297NMD::Pool NMD::DIV_fmt0[2] = {
19298 { instruction , 0 , 0 , 32,
19299 0xfc0003ff, 0xa00000f0, &NMD::DIV_S , 0,
19300 CP1_ }, /* DIV.S */
19301 { reserved_block , 0 , 0 , 32,
19302 0xfc0003ff, 0xa00002f0, 0 , 0,
19303 CP1_ }, /* DIV.fmt0~*(1) */
19304};
19305
19306
19307NMD::Pool NMD::ADD_fmt1[2] = {
19308 { instruction , 0 , 0 , 32,
19309 0xfc0003ff, 0xa0000130, &NMD::ADD_D , 0,
19310 CP1_ }, /* ADD.D */
19311 { reserved_block , 0 , 0 , 32,
19312 0xfc0003ff, 0xa0000330, 0 , 0,
19313 CP1_ }, /* ADD.fmt1~*(1) */
19314};
19315
19316
19317NMD::Pool NMD::SUB_fmt1[2] = {
19318 { instruction , 0 , 0 , 32,
19319 0xfc0003ff, 0xa0000170, &NMD::SUB_D , 0,
19320 CP1_ }, /* SUB.D */
19321 { reserved_block , 0 , 0 , 32,
19322 0xfc0003ff, 0xa0000370, 0 , 0,
19323 CP1_ }, /* SUB.fmt1~*(1) */
19324};
19325
19326
19327NMD::Pool NMD::MUL_fmt1[2] = {
19328 { instruction , 0 , 0 , 32,
19329 0xfc0003ff, 0xa00001b0, &NMD::MUL_D , 0,
19330 CP1_ }, /* MUL.D */
19331 { reserved_block , 0 , 0 , 32,
19332 0xfc0003ff, 0xa00003b0, 0 , 0,
19333 CP1_ }, /* MUL.fmt1~*(1) */
19334};
19335
19336
19337NMD::Pool NMD::MADDF_fmt[2] = {
19338 { instruction , 0 , 0 , 32,
19339 0xfc0003ff, 0xa00001b8, &NMD::MADDF_S , 0,
19340 CP1_ }, /* MADDF.S */
19341 { instruction , 0 , 0 , 32,
19342 0xfc0003ff, 0xa00003b8, &NMD::MADDF_D , 0,
19343 CP1_ }, /* MADDF.D */
19344};
19345
19346
19347NMD::Pool NMD::DIV_fmt1[2] = {
19348 { instruction , 0 , 0 , 32,
19349 0xfc0003ff, 0xa00001f0, &NMD::DIV_D , 0,
19350 CP1_ }, /* DIV.D */
19351 { reserved_block , 0 , 0 , 32,
19352 0xfc0003ff, 0xa00003f0, 0 , 0,
19353 CP1_ }, /* DIV.fmt1~*(1) */
19354};
19355
19356
19357NMD::Pool NMD::MSUBF_fmt[2] = {
19358 { instruction , 0 , 0 , 32,
19359 0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S , 0,
19360 CP1_ }, /* MSUBF.S */
19361 { instruction , 0 , 0 , 32,
19362 0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D , 0,
19363 CP1_ }, /* MSUBF.D */
19364};
19365
19366
19367NMD::Pool NMD::POOL32F_0[64] = {
19368 { reserved_block , 0 , 0 , 32,
19369 0xfc0001ff, 0xa0000000, 0 , 0,
19370 CP1_ }, /* POOL32F_0~*(0) */
19371 { reserved_block , 0 , 0 , 32,
19372 0xfc0001ff, 0xa0000008, 0 , 0,
19373 CP1_ }, /* POOL32F_0~*(1) */
19374 { reserved_block , 0 , 0 , 32,
19375 0xfc0001ff, 0xa0000010, 0 , 0,
19376 CP1_ }, /* POOL32F_0~*(2) */
19377 { reserved_block , 0 , 0 , 32,
19378 0xfc0001ff, 0xa0000018, 0 , 0,
19379 CP1_ }, /* POOL32F_0~*(3) */
19380 { pool , RINT_fmt , 2 , 32,
19381 0xfc0001ff, 0xa0000020, 0 , 0,
19382 CP1_ }, /* RINT.fmt */
19383 { reserved_block , 0 , 0 , 32,
19384 0xfc0001ff, 0xa0000028, 0 , 0,
19385 CP1_ }, /* POOL32F_0~*(5) */
19386 { pool , ADD_fmt0 , 2 , 32,
19387 0xfc0001ff, 0xa0000030, 0 , 0,
19388 CP1_ }, /* ADD.fmt0 */
19389 { pool , SELEQZ_fmt , 2 , 32,
19390 0xfc0001ff, 0xa0000038, 0 , 0,
19391 CP1_ }, /* SELEQZ.fmt */
19392 { reserved_block , 0 , 0 , 32,
19393 0xfc0001ff, 0xa0000040, 0 , 0,
19394 CP1_ }, /* POOL32F_0~*(8) */
19395 { reserved_block , 0 , 0 , 32,
19396 0xfc0001ff, 0xa0000048, 0 , 0,
19397 CP1_ }, /* POOL32F_0~*(9) */
19398 { reserved_block , 0 , 0 , 32,
19399 0xfc0001ff, 0xa0000050, 0 , 0,
19400 CP1_ }, /* POOL32F_0~*(10) */
19401 { reserved_block , 0 , 0 , 32,
19402 0xfc0001ff, 0xa0000058, 0 , 0,
19403 CP1_ }, /* POOL32F_0~*(11) */
19404 { pool , CLASS_fmt , 2 , 32,
19405 0xfc0001ff, 0xa0000060, 0 , 0,
19406 CP1_ }, /* CLASS.fmt */
19407 { reserved_block , 0 , 0 , 32,
19408 0xfc0001ff, 0xa0000068, 0 , 0,
19409 CP1_ }, /* POOL32F_0~*(13) */
19410 { pool , SUB_fmt0 , 2 , 32,
19411 0xfc0001ff, 0xa0000070, 0 , 0,
19412 CP1_ }, /* SUB.fmt0 */
19413 { pool , SELNEZ_fmt , 2 , 32,
19414 0xfc0001ff, 0xa0000078, 0 , 0,
19415 CP1_ }, /* SELNEZ.fmt */
19416 { reserved_block , 0 , 0 , 32,
19417 0xfc0001ff, 0xa0000080, 0 , 0,
19418 CP1_ }, /* POOL32F_0~*(16) */
19419 { reserved_block , 0 , 0 , 32,
19420 0xfc0001ff, 0xa0000088, 0 , 0,
19421 CP1_ }, /* POOL32F_0~*(17) */
19422 { reserved_block , 0 , 0 , 32,
19423 0xfc0001ff, 0xa0000090, 0 , 0,
19424 CP1_ }, /* POOL32F_0~*(18) */
19425 { reserved_block , 0 , 0 , 32,
19426 0xfc0001ff, 0xa0000098, 0 , 0,
19427 CP1_ }, /* POOL32F_0~*(19) */
19428 { reserved_block , 0 , 0 , 32,
19429 0xfc0001ff, 0xa00000a0, 0 , 0,
19430 CP1_ }, /* POOL32F_0~*(20) */
19431 { reserved_block , 0 , 0 , 32,
19432 0xfc0001ff, 0xa00000a8, 0 , 0,
19433 CP1_ }, /* POOL32F_0~*(21) */
19434 { pool , MUL_fmt0 , 2 , 32,
19435 0xfc0001ff, 0xa00000b0, 0 , 0,
19436 CP1_ }, /* MUL.fmt0 */
19437 { pool , SEL_fmt , 2 , 32,
19438 0xfc0001ff, 0xa00000b8, 0 , 0,
19439 CP1_ }, /* SEL.fmt */
19440 { reserved_block , 0 , 0 , 32,
19441 0xfc0001ff, 0xa00000c0, 0 , 0,
19442 CP1_ }, /* POOL32F_0~*(24) */
19443 { reserved_block , 0 , 0 , 32,
19444 0xfc0001ff, 0xa00000c8, 0 , 0,
19445 CP1_ }, /* POOL32F_0~*(25) */
19446 { reserved_block , 0 , 0 , 32,
19447 0xfc0001ff, 0xa00000d0, 0 , 0,
19448 CP1_ }, /* POOL32F_0~*(26) */
19449 { reserved_block , 0 , 0 , 32,
19450 0xfc0001ff, 0xa00000d8, 0 , 0,
19451 CP1_ }, /* POOL32F_0~*(27) */
19452 { reserved_block , 0 , 0 , 32,
19453 0xfc0001ff, 0xa00000e0, 0 , 0,
19454 CP1_ }, /* POOL32F_0~*(28) */
19455 { reserved_block , 0 , 0 , 32,
19456 0xfc0001ff, 0xa00000e8, 0 , 0,
19457 CP1_ }, /* POOL32F_0~*(29) */
19458 { pool , DIV_fmt0 , 2 , 32,
19459 0xfc0001ff, 0xa00000f0, 0 , 0,
19460 CP1_ }, /* DIV.fmt0 */
19461 { reserved_block , 0 , 0 , 32,
19462 0xfc0001ff, 0xa00000f8, 0 , 0,
19463 CP1_ }, /* POOL32F_0~*(31) */
19464 { reserved_block , 0 , 0 , 32,
19465 0xfc0001ff, 0xa0000100, 0 , 0,
19466 CP1_ }, /* POOL32F_0~*(32) */
19467 { reserved_block , 0 , 0 , 32,
19468 0xfc0001ff, 0xa0000108, 0 , 0,
19469 CP1_ }, /* POOL32F_0~*(33) */
19470 { reserved_block , 0 , 0 , 32,
19471 0xfc0001ff, 0xa0000110, 0 , 0,
19472 CP1_ }, /* POOL32F_0~*(34) */
19473 { reserved_block , 0 , 0 , 32,
19474 0xfc0001ff, 0xa0000118, 0 , 0,
19475 CP1_ }, /* POOL32F_0~*(35) */
19476 { reserved_block , 0 , 0 , 32,
19477 0xfc0001ff, 0xa0000120, 0 , 0,
19478 CP1_ }, /* POOL32F_0~*(36) */
19479 { reserved_block , 0 , 0 , 32,
19480 0xfc0001ff, 0xa0000128, 0 , 0,
19481 CP1_ }, /* POOL32F_0~*(37) */
19482 { pool , ADD_fmt1 , 2 , 32,
19483 0xfc0001ff, 0xa0000130, 0 , 0,
19484 CP1_ }, /* ADD.fmt1 */
19485 { reserved_block , 0 , 0 , 32,
19486 0xfc0001ff, 0xa0000138, 0 , 0,
19487 CP1_ }, /* POOL32F_0~*(39) */
19488 { reserved_block , 0 , 0 , 32,
19489 0xfc0001ff, 0xa0000140, 0 , 0,
19490 CP1_ }, /* POOL32F_0~*(40) */
19491 { reserved_block , 0 , 0 , 32,
19492 0xfc0001ff, 0xa0000148, 0 , 0,
19493 CP1_ }, /* POOL32F_0~*(41) */
19494 { reserved_block , 0 , 0 , 32,
19495 0xfc0001ff, 0xa0000150, 0 , 0,
19496 CP1_ }, /* POOL32F_0~*(42) */
19497 { reserved_block , 0 , 0 , 32,
19498 0xfc0001ff, 0xa0000158, 0 , 0,
19499 CP1_ }, /* POOL32F_0~*(43) */
19500 { reserved_block , 0 , 0 , 32,
19501 0xfc0001ff, 0xa0000160, 0 , 0,
19502 CP1_ }, /* POOL32F_0~*(44) */
19503 { reserved_block , 0 , 0 , 32,
19504 0xfc0001ff, 0xa0000168, 0 , 0,
19505 CP1_ }, /* POOL32F_0~*(45) */
19506 { pool , SUB_fmt1 , 2 , 32,
19507 0xfc0001ff, 0xa0000170, 0 , 0,
19508 CP1_ }, /* SUB.fmt1 */
19509 { reserved_block , 0 , 0 , 32,
19510 0xfc0001ff, 0xa0000178, 0 , 0,
19511 CP1_ }, /* POOL32F_0~*(47) */
19512 { reserved_block , 0 , 0 , 32,
19513 0xfc0001ff, 0xa0000180, 0 , 0,
19514 CP1_ }, /* POOL32F_0~*(48) */
19515 { reserved_block , 0 , 0 , 32,
19516 0xfc0001ff, 0xa0000188, 0 , 0,
19517 CP1_ }, /* POOL32F_0~*(49) */
19518 { reserved_block , 0 , 0 , 32,
19519 0xfc0001ff, 0xa0000190, 0 , 0,
19520 CP1_ }, /* POOL32F_0~*(50) */
19521 { reserved_block , 0 , 0 , 32,
19522 0xfc0001ff, 0xa0000198, 0 , 0,
19523 CP1_ }, /* POOL32F_0~*(51) */
19524 { reserved_block , 0 , 0 , 32,
19525 0xfc0001ff, 0xa00001a0, 0 , 0,
19526 CP1_ }, /* POOL32F_0~*(52) */
19527 { reserved_block , 0 , 0 , 32,
19528 0xfc0001ff, 0xa00001a8, 0 , 0,
19529 CP1_ }, /* POOL32F_0~*(53) */
19530 { pool , MUL_fmt1 , 2 , 32,
19531 0xfc0001ff, 0xa00001b0, 0 , 0,
19532 CP1_ }, /* MUL.fmt1 */
19533 { pool , MADDF_fmt , 2 , 32,
19534 0xfc0001ff, 0xa00001b8, 0 , 0,
19535 CP1_ }, /* MADDF.fmt */
19536 { reserved_block , 0 , 0 , 32,
19537 0xfc0001ff, 0xa00001c0, 0 , 0,
19538 CP1_ }, /* POOL32F_0~*(56) */
19539 { reserved_block , 0 , 0 , 32,
19540 0xfc0001ff, 0xa00001c8, 0 , 0,
19541 CP1_ }, /* POOL32F_0~*(57) */
19542 { reserved_block , 0 , 0 , 32,
19543 0xfc0001ff, 0xa00001d0, 0 , 0,
19544 CP1_ }, /* POOL32F_0~*(58) */
19545 { reserved_block , 0 , 0 , 32,
19546 0xfc0001ff, 0xa00001d8, 0 , 0,
19547 CP1_ }, /* POOL32F_0~*(59) */
19548 { reserved_block , 0 , 0 , 32,
19549 0xfc0001ff, 0xa00001e0, 0 , 0,
19550 CP1_ }, /* POOL32F_0~*(60) */
19551 { reserved_block , 0 , 0 , 32,
19552 0xfc0001ff, 0xa00001e8, 0 , 0,
19553 CP1_ }, /* POOL32F_0~*(61) */
19554 { pool , DIV_fmt1 , 2 , 32,
19555 0xfc0001ff, 0xa00001f0, 0 , 0,
19556 CP1_ }, /* DIV.fmt1 */
19557 { pool , MSUBF_fmt , 2 , 32,
19558 0xfc0001ff, 0xa00001f8, 0 , 0,
19559 CP1_ }, /* MSUBF.fmt */
19560};
19561
19562
19563NMD::Pool NMD::MIN_fmt[2] = {
19564 { instruction , 0 , 0 , 32,
19565 0xfc00023f, 0xa0000003, &NMD::MIN_S , 0,
19566 CP1_ }, /* MIN.S */
19567 { instruction , 0 , 0 , 32,
19568 0xfc00023f, 0xa0000203, &NMD::MIN_D , 0,
19569 CP1_ }, /* MIN.D */
19570};
19571
19572
19573NMD::Pool NMD::MAX_fmt[2] = {
19574 { instruction , 0 , 0 , 32,
19575 0xfc00023f, 0xa000000b, &NMD::MAX_S , 0,
19576 CP1_ }, /* MAX.S */
19577 { instruction , 0 , 0 , 32,
19578 0xfc00023f, 0xa000020b, &NMD::MAX_D , 0,
19579 CP1_ }, /* MAX.D */
19580};
19581
19582
19583NMD::Pool NMD::MINA_fmt[2] = {
19584 { instruction , 0 , 0 , 32,
19585 0xfc00023f, 0xa0000023, &NMD::MINA_S , 0,
19586 CP1_ }, /* MINA.S */
19587 { instruction , 0 , 0 , 32,
19588 0xfc00023f, 0xa0000223, &NMD::MINA_D , 0,
19589 CP1_ }, /* MINA.D */
19590};
19591
19592
19593NMD::Pool NMD::MAXA_fmt[2] = {
19594 { instruction , 0 , 0 , 32,
19595 0xfc00023f, 0xa000002b, &NMD::MAXA_S , 0,
19596 CP1_ }, /* MAXA.S */
19597 { instruction , 0 , 0 , 32,
19598 0xfc00023f, 0xa000022b, &NMD::MAXA_D , 0,
19599 CP1_ }, /* MAXA.D */
19600};
19601
19602
19603NMD::Pool NMD::CVT_L_fmt[2] = {
19604 { instruction , 0 , 0 , 32,
19605 0xfc007fff, 0xa000013b, &NMD::CVT_L_S , 0,
19606 CP1_ }, /* CVT.L.S */
19607 { instruction , 0 , 0 , 32,
19608 0xfc007fff, 0xa000413b, &NMD::CVT_L_D , 0,
19609 CP1_ }, /* CVT.L.D */
19610};
19611
19612
19613NMD::Pool NMD::RSQRT_fmt[2] = {
19614 { instruction , 0 , 0 , 32,
19615 0xfc007fff, 0xa000023b, &NMD::RSQRT_S , 0,
19616 CP1_ }, /* RSQRT.S */
19617 { instruction , 0 , 0 , 32,
19618 0xfc007fff, 0xa000423b, &NMD::RSQRT_D , 0,
19619 CP1_ }, /* RSQRT.D */
19620};
19621
19622
19623NMD::Pool NMD::FLOOR_L_fmt[2] = {
19624 { instruction , 0 , 0 , 32,
19625 0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S , 0,
19626 CP1_ }, /* FLOOR.L.S */
19627 { instruction , 0 , 0 , 32,
19628 0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D , 0,
19629 CP1_ }, /* FLOOR.L.D */
19630};
19631
19632
19633NMD::Pool NMD::CVT_W_fmt[2] = {
19634 { instruction , 0 , 0 , 32,
19635 0xfc007fff, 0xa000093b, &NMD::CVT_W_S , 0,
19636 CP1_ }, /* CVT.W.S */
19637 { instruction , 0 , 0 , 32,
19638 0xfc007fff, 0xa000493b, &NMD::CVT_W_D , 0,
19639 CP1_ }, /* CVT.W.D */
19640};
19641
19642
19643NMD::Pool NMD::SQRT_fmt[2] = {
19644 { instruction , 0 , 0 , 32,
19645 0xfc007fff, 0xa0000a3b, &NMD::SQRT_S , 0,
19646 CP1_ }, /* SQRT.S */
19647 { instruction , 0 , 0 , 32,
19648 0xfc007fff, 0xa0004a3b, &NMD::SQRT_D , 0,
19649 CP1_ }, /* SQRT.D */
19650};
19651
19652
19653NMD::Pool NMD::FLOOR_W_fmt[2] = {
19654 { instruction , 0 , 0 , 32,
19655 0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S , 0,
19656 CP1_ }, /* FLOOR.W.S */
19657 { instruction , 0 , 0 , 32,
19658 0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D , 0,
19659 CP1_ }, /* FLOOR.W.D */
19660};
19661
19662
19663NMD::Pool NMD::RECIP_fmt[2] = {
19664 { instruction , 0 , 0 , 32,
19665 0xfc007fff, 0xa000123b, &NMD::RECIP_S , 0,
19666 CP1_ }, /* RECIP.S */
19667 { instruction , 0 , 0 , 32,
19668 0xfc007fff, 0xa000523b, &NMD::RECIP_D , 0,
19669 CP1_ }, /* RECIP.D */
19670};
19671
19672
19673NMD::Pool NMD::CEIL_L_fmt[2] = {
19674 { instruction , 0 , 0 , 32,
19675 0xfc007fff, 0xa000133b, &NMD::CEIL_L_S , 0,
19676 CP1_ }, /* CEIL.L.S */
19677 { instruction , 0 , 0 , 32,
19678 0xfc007fff, 0xa000533b, &NMD::CEIL_L_D , 0,
19679 CP1_ }, /* CEIL.L.D */
19680};
19681
19682
19683NMD::Pool NMD::CEIL_W_fmt[2] = {
19684 { instruction , 0 , 0 , 32,
19685 0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S , 0,
19686 CP1_ }, /* CEIL.W.S */
19687 { instruction , 0 , 0 , 32,
19688 0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D , 0,
19689 CP1_ }, /* CEIL.W.D */
19690};
19691
19692
19693NMD::Pool NMD::TRUNC_L_fmt[2] = {
19694 { instruction , 0 , 0 , 32,
19695 0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S , 0,
19696 CP1_ }, /* TRUNC.L.S */
19697 { instruction , 0 , 0 , 32,
19698 0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D , 0,
19699 CP1_ }, /* TRUNC.L.D */
19700};
19701
19702
19703NMD::Pool NMD::TRUNC_W_fmt[2] = {
19704 { instruction , 0 , 0 , 32,
19705 0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S , 0,
19706 CP1_ }, /* TRUNC.W.S */
19707 { instruction , 0 , 0 , 32,
19708 0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D , 0,
19709 CP1_ }, /* TRUNC.W.D */
19710};
19711
19712
19713NMD::Pool NMD::ROUND_L_fmt[2] = {
19714 { instruction , 0 , 0 , 32,
19715 0xfc007fff, 0xa000333b, &NMD::ROUND_L_S , 0,
19716 CP1_ }, /* ROUND.L.S */
19717 { instruction , 0 , 0 , 32,
19718 0xfc007fff, 0xa000733b, &NMD::ROUND_L_D , 0,
19719 CP1_ }, /* ROUND.L.D */
19720};
19721
19722
19723NMD::Pool NMD::ROUND_W_fmt[2] = {
19724 { instruction , 0 , 0 , 32,
19725 0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S , 0,
19726 CP1_ }, /* ROUND.W.S */
19727 { instruction , 0 , 0 , 32,
19728 0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D , 0,
19729 CP1_ }, /* ROUND.W.D */
19730};
19731
19732
19733NMD::Pool NMD::POOL32Fxf_0[64] = {
19734 { reserved_block , 0 , 0 , 32,
19735 0xfc003fff, 0xa000003b, 0 , 0,
19736 CP1_ }, /* POOL32Fxf_0~*(0) */
19737 { pool , CVT_L_fmt , 2 , 32,
19738 0xfc003fff, 0xa000013b, 0 , 0,
19739 CP1_ }, /* CVT.L.fmt */
19740 { pool , RSQRT_fmt , 2 , 32,
19741 0xfc003fff, 0xa000023b, 0 , 0,
19742 CP1_ }, /* RSQRT.fmt */
19743 { pool , FLOOR_L_fmt , 2 , 32,
19744 0xfc003fff, 0xa000033b, 0 , 0,
19745 CP1_ }, /* FLOOR.L.fmt */
19746 { reserved_block , 0 , 0 , 32,
19747 0xfc003fff, 0xa000043b, 0 , 0,
19748 CP1_ }, /* POOL32Fxf_0~*(4) */
19749 { reserved_block , 0 , 0 , 32,
19750 0xfc003fff, 0xa000053b, 0 , 0,
19751 CP1_ }, /* POOL32Fxf_0~*(5) */
19752 { reserved_block , 0 , 0 , 32,
19753 0xfc003fff, 0xa000063b, 0 , 0,
19754 CP1_ }, /* POOL32Fxf_0~*(6) */
19755 { reserved_block , 0 , 0 , 32,
19756 0xfc003fff, 0xa000073b, 0 , 0,
19757 CP1_ }, /* POOL32Fxf_0~*(7) */
19758 { reserved_block , 0 , 0 , 32,
19759 0xfc003fff, 0xa000083b, 0 , 0,
19760 CP1_ }, /* POOL32Fxf_0~*(8) */
19761 { pool , CVT_W_fmt , 2 , 32,
19762 0xfc003fff, 0xa000093b, 0 , 0,
19763 CP1_ }, /* CVT.W.fmt */
19764 { pool , SQRT_fmt , 2 , 32,
19765 0xfc003fff, 0xa0000a3b, 0 , 0,
19766 CP1_ }, /* SQRT.fmt */
19767 { pool , FLOOR_W_fmt , 2 , 32,
19768 0xfc003fff, 0xa0000b3b, 0 , 0,
19769 CP1_ }, /* FLOOR.W.fmt */
19770 { reserved_block , 0 , 0 , 32,
19771 0xfc003fff, 0xa0000c3b, 0 , 0,
19772 CP1_ }, /* POOL32Fxf_0~*(12) */
19773 { reserved_block , 0 , 0 , 32,
19774 0xfc003fff, 0xa0000d3b, 0 , 0,
19775 CP1_ }, /* POOL32Fxf_0~*(13) */
19776 { reserved_block , 0 , 0 , 32,
19777 0xfc003fff, 0xa0000e3b, 0 , 0,
19778 CP1_ }, /* POOL32Fxf_0~*(14) */
19779 { reserved_block , 0 , 0 , 32,
19780 0xfc003fff, 0xa0000f3b, 0 , 0,
19781 CP1_ }, /* POOL32Fxf_0~*(15) */
19782 { instruction , 0 , 0 , 32,
19783 0xfc003fff, 0xa000103b, &NMD::CFC1 , 0,
19784 CP1_ }, /* CFC1 */
19785 { reserved_block , 0 , 0 , 32,
19786 0xfc003fff, 0xa000113b, 0 , 0,
19787 CP1_ }, /* POOL32Fxf_0~*(17) */
19788 { pool , RECIP_fmt , 2 , 32,
19789 0xfc003fff, 0xa000123b, 0 , 0,
19790 CP1_ }, /* RECIP.fmt */
19791 { pool , CEIL_L_fmt , 2 , 32,
19792 0xfc003fff, 0xa000133b, 0 , 0,
19793 CP1_ }, /* CEIL.L.fmt */
19794 { reserved_block , 0 , 0 , 32,
19795 0xfc003fff, 0xa000143b, 0 , 0,
19796 CP1_ }, /* POOL32Fxf_0~*(20) */
19797 { reserved_block , 0 , 0 , 32,
19798 0xfc003fff, 0xa000153b, 0 , 0,
19799 CP1_ }, /* POOL32Fxf_0~*(21) */
19800 { reserved_block , 0 , 0 , 32,
19801 0xfc003fff, 0xa000163b, 0 , 0,
19802 CP1_ }, /* POOL32Fxf_0~*(22) */
19803 { reserved_block , 0 , 0 , 32,
19804 0xfc003fff, 0xa000173b, 0 , 0,
19805 CP1_ }, /* POOL32Fxf_0~*(23) */
19806 { instruction , 0 , 0 , 32,
19807 0xfc003fff, 0xa000183b, &NMD::CTC1 , 0,
19808 CP1_ }, /* CTC1 */
19809 { reserved_block , 0 , 0 , 32,
19810 0xfc003fff, 0xa000193b, 0 , 0,
19811 CP1_ }, /* POOL32Fxf_0~*(25) */
19812 { reserved_block , 0 , 0 , 32,
19813 0xfc003fff, 0xa0001a3b, 0 , 0,
19814 CP1_ }, /* POOL32Fxf_0~*(26) */
19815 { pool , CEIL_W_fmt , 2 , 32,
19816 0xfc003fff, 0xa0001b3b, 0 , 0,
19817 CP1_ }, /* CEIL.W.fmt */
19818 { reserved_block , 0 , 0 , 32,
19819 0xfc003fff, 0xa0001c3b, 0 , 0,
19820 CP1_ }, /* POOL32Fxf_0~*(28) */
19821 { reserved_block , 0 , 0 , 32,
19822 0xfc003fff, 0xa0001d3b, 0 , 0,
19823 CP1_ }, /* POOL32Fxf_0~*(29) */
19824 { reserved_block , 0 , 0 , 32,
19825 0xfc003fff, 0xa0001e3b, 0 , 0,
19826 CP1_ }, /* POOL32Fxf_0~*(30) */
19827 { reserved_block , 0 , 0 , 32,
19828 0xfc003fff, 0xa0001f3b, 0 , 0,
19829 CP1_ }, /* POOL32Fxf_0~*(31) */
19830 { instruction , 0 , 0 , 32,
19831 0xfc003fff, 0xa000203b, &NMD::MFC1 , 0,
19832 CP1_ }, /* MFC1 */
19833 { instruction , 0 , 0 , 32,
19834 0xfc003fff, 0xa000213b, &NMD::CVT_S_PL , 0,
19835 CP1_ }, /* CVT.S.PL */
19836 { reserved_block , 0 , 0 , 32,
19837 0xfc003fff, 0xa000223b, 0 , 0,
19838 CP1_ }, /* POOL32Fxf_0~*(34) */
19839 { pool , TRUNC_L_fmt , 2 , 32,
19840 0xfc003fff, 0xa000233b, 0 , 0,
19841 CP1_ }, /* TRUNC.L.fmt */
19842 { instruction , 0 , 0 , 32,
19843 0xfc003fff, 0xa000243b, &NMD::DMFC1 , 0,
19844 CP1_ | MIPS64_ }, /* DMFC1 */
19845 { reserved_block , 0 , 0 , 32,
19846 0xfc003fff, 0xa000253b, 0 , 0,
19847 CP1_ }, /* POOL32Fxf_0~*(37) */
19848 { reserved_block , 0 , 0 , 32,
19849 0xfc003fff, 0xa000263b, 0 , 0,
19850 CP1_ }, /* POOL32Fxf_0~*(38) */
19851 { reserved_block , 0 , 0 , 32,
19852 0xfc003fff, 0xa000273b, 0 , 0,
19853 CP1_ }, /* POOL32Fxf_0~*(39) */
19854 { instruction , 0 , 0 , 32,
19855 0xfc003fff, 0xa000283b, &NMD::MTC1 , 0,
19856 CP1_ }, /* MTC1 */
19857 { instruction , 0 , 0 , 32,
19858 0xfc003fff, 0xa000293b, &NMD::CVT_S_PU , 0,
19859 CP1_ }, /* CVT.S.PU */
19860 { reserved_block , 0 , 0 , 32,
19861 0xfc003fff, 0xa0002a3b, 0 , 0,
19862 CP1_ }, /* POOL32Fxf_0~*(42) */
19863 { pool , TRUNC_W_fmt , 2 , 32,
19864 0xfc003fff, 0xa0002b3b, 0 , 0,
19865 CP1_ }, /* TRUNC.W.fmt */
19866 { instruction , 0 , 0 , 32,
19867 0xfc003fff, 0xa0002c3b, &NMD::DMTC1 , 0,
19868 CP1_ | MIPS64_ }, /* DMTC1 */
19869 { reserved_block , 0 , 0 , 32,
19870 0xfc003fff, 0xa0002d3b, 0 , 0,
19871 CP1_ }, /* POOL32Fxf_0~*(45) */
19872 { reserved_block , 0 , 0 , 32,
19873 0xfc003fff, 0xa0002e3b, 0 , 0,
19874 CP1_ }, /* POOL32Fxf_0~*(46) */
19875 { reserved_block , 0 , 0 , 32,
19876 0xfc003fff, 0xa0002f3b, 0 , 0,
19877 CP1_ }, /* POOL32Fxf_0~*(47) */
19878 { instruction , 0 , 0 , 32,
19879 0xfc003fff, 0xa000303b, &NMD::MFHC1 , 0,
19880 CP1_ }, /* MFHC1 */
19881 { reserved_block , 0 , 0 , 32,
19882 0xfc003fff, 0xa000313b, 0 , 0,
19883 CP1_ }, /* POOL32Fxf_0~*(49) */
19884 { reserved_block , 0 , 0 , 32,
19885 0xfc003fff, 0xa000323b, 0 , 0,
19886 CP1_ }, /* POOL32Fxf_0~*(50) */
19887 { pool , ROUND_L_fmt , 2 , 32,
19888 0xfc003fff, 0xa000333b, 0 , 0,
19889 CP1_ }, /* ROUND.L.fmt */
19890 { reserved_block , 0 , 0 , 32,
19891 0xfc003fff, 0xa000343b, 0 , 0,
19892 CP1_ }, /* POOL32Fxf_0~*(52) */
19893 { reserved_block , 0 , 0 , 32,
19894 0xfc003fff, 0xa000353b, 0 , 0,
19895 CP1_ }, /* POOL32Fxf_0~*(53) */
19896 { reserved_block , 0 , 0 , 32,
19897 0xfc003fff, 0xa000363b, 0 , 0,
19898 CP1_ }, /* POOL32Fxf_0~*(54) */
19899 { reserved_block , 0 , 0 , 32,
19900 0xfc003fff, 0xa000373b, 0 , 0,
19901 CP1_ }, /* POOL32Fxf_0~*(55) */
19902 { instruction , 0 , 0 , 32,
19903 0xfc003fff, 0xa000383b, &NMD::MTHC1 , 0,
19904 CP1_ }, /* MTHC1 */
19905 { reserved_block , 0 , 0 , 32,
19906 0xfc003fff, 0xa000393b, 0 , 0,
19907 CP1_ }, /* POOL32Fxf_0~*(57) */
19908 { reserved_block , 0 , 0 , 32,
19909 0xfc003fff, 0xa0003a3b, 0 , 0,
19910 CP1_ }, /* POOL32Fxf_0~*(58) */
19911 { pool , ROUND_W_fmt , 2 , 32,
19912 0xfc003fff, 0xa0003b3b, 0 , 0,
19913 CP1_ }, /* ROUND.W.fmt */
19914 { reserved_block , 0 , 0 , 32,
19915 0xfc003fff, 0xa0003c3b, 0 , 0,
19916 CP1_ }, /* POOL32Fxf_0~*(60) */
19917 { reserved_block , 0 , 0 , 32,
19918 0xfc003fff, 0xa0003d3b, 0 , 0,
19919 CP1_ }, /* POOL32Fxf_0~*(61) */
19920 { reserved_block , 0 , 0 , 32,
19921 0xfc003fff, 0xa0003e3b, 0 , 0,
19922 CP1_ }, /* POOL32Fxf_0~*(62) */
19923 { reserved_block , 0 , 0 , 32,
19924 0xfc003fff, 0xa0003f3b, 0 , 0,
19925 CP1_ }, /* POOL32Fxf_0~*(63) */
19926};
19927
19928
19929NMD::Pool NMD::MOV_fmt[4] = {
19930 { instruction , 0 , 0 , 32,
19931 0xfc007fff, 0xa000007b, &NMD::MOV_S , 0,
19932 CP1_ }, /* MOV.S */
19933 { instruction , 0 , 0 , 32,
19934 0xfc007fff, 0xa000207b, &NMD::MOV_D , 0,
19935 CP1_ }, /* MOV.D */
19936 { reserved_block , 0 , 0 , 32,
19937 0xfc007fff, 0xa000407b, 0 , 0,
19938 CP1_ }, /* MOV.fmt~*(2) */
19939 { reserved_block , 0 , 0 , 32,
19940 0xfc007fff, 0xa000607b, 0 , 0,
19941 CP1_ }, /* MOV.fmt~*(3) */
19942};
19943
19944
19945NMD::Pool NMD::ABS_fmt[4] = {
19946 { instruction , 0 , 0 , 32,
19947 0xfc007fff, 0xa000037b, &NMD::ABS_S , 0,
19948 CP1_ }, /* ABS.S */
19949 { instruction , 0 , 0 , 32,
19950 0xfc007fff, 0xa000237b, &NMD::ABS_D , 0,
19951 CP1_ }, /* ABS.D */
19952 { reserved_block , 0 , 0 , 32,
19953 0xfc007fff, 0xa000437b, 0 , 0,
19954 CP1_ }, /* ABS.fmt~*(2) */
19955 { reserved_block , 0 , 0 , 32,
19956 0xfc007fff, 0xa000637b, 0 , 0,
19957 CP1_ }, /* ABS.fmt~*(3) */
19958};
19959
19960
19961NMD::Pool NMD::NEG_fmt[4] = {
19962 { instruction , 0 , 0 , 32,
19963 0xfc007fff, 0xa0000b7b, &NMD::NEG_S , 0,
19964 CP1_ }, /* NEG.S */
19965 { instruction , 0 , 0 , 32,
19966 0xfc007fff, 0xa0002b7b, &NMD::NEG_D , 0,
19967 CP1_ }, /* NEG.D */
19968 { reserved_block , 0 , 0 , 32,
19969 0xfc007fff, 0xa0004b7b, 0 , 0,
19970 CP1_ }, /* NEG.fmt~*(2) */
19971 { reserved_block , 0 , 0 , 32,
19972 0xfc007fff, 0xa0006b7b, 0 , 0,
19973 CP1_ }, /* NEG.fmt~*(3) */
19974};
19975
19976
19977NMD::Pool NMD::CVT_D_fmt[4] = {
19978 { instruction , 0 , 0 , 32,
19979 0xfc007fff, 0xa000137b, &NMD::CVT_D_S , 0,
19980 CP1_ }, /* CVT.D.S */
19981 { instruction , 0 , 0 , 32,
19982 0xfc007fff, 0xa000337b, &NMD::CVT_D_W , 0,
19983 CP1_ }, /* CVT.D.W */
19984 { instruction , 0 , 0 , 32,
19985 0xfc007fff, 0xa000537b, &NMD::CVT_D_L , 0,
19986 CP1_ }, /* CVT.D.L */
19987 { reserved_block , 0 , 0 , 32,
19988 0xfc007fff, 0xa000737b, 0 , 0,
19989 CP1_ }, /* CVT.D.fmt~*(3) */
19990};
19991
19992
19993NMD::Pool NMD::CVT_S_fmt[4] = {
19994 { instruction , 0 , 0 , 32,
19995 0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D , 0,
19996 CP1_ }, /* CVT.S.D */
19997 { instruction , 0 , 0 , 32,
19998 0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W , 0,
19999 CP1_ }, /* CVT.S.W */
20000 { instruction , 0 , 0 , 32,
20001 0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L , 0,
20002 CP1_ }, /* CVT.S.L */
20003 { reserved_block , 0 , 0 , 32,
20004 0xfc007fff, 0xa0007b7b, 0 , 0,
20005 CP1_ }, /* CVT.S.fmt~*(3) */
20006};
20007
20008
20009NMD::Pool NMD::POOL32Fxf_1[32] = {
20010 { pool , MOV_fmt , 4 , 32,
20011 0xfc001fff, 0xa000007b, 0 , 0,
20012 CP1_ }, /* MOV.fmt */
20013 { reserved_block , 0 , 0 , 32,
20014 0xfc001fff, 0xa000017b, 0 , 0,
20015 CP1_ }, /* POOL32Fxf_1~*(1) */
20016 { reserved_block , 0 , 0 , 32,
20017 0xfc001fff, 0xa000027b, 0 , 0,
20018 CP1_ }, /* POOL32Fxf_1~*(2) */
20019 { pool , ABS_fmt , 4 , 32,
20020 0xfc001fff, 0xa000037b, 0 , 0,
20021 CP1_ }, /* ABS.fmt */
20022 { reserved_block , 0 , 0 , 32,
20023 0xfc001fff, 0xa000047b, 0 , 0,
20024 CP1_ }, /* POOL32Fxf_1~*(4) */
20025 { reserved_block , 0 , 0 , 32,
20026 0xfc001fff, 0xa000057b, 0 , 0,
20027 CP1_ }, /* POOL32Fxf_1~*(5) */
20028 { reserved_block , 0 , 0 , 32,
20029 0xfc001fff, 0xa000067b, 0 , 0,
20030 CP1_ }, /* POOL32Fxf_1~*(6) */
20031 { reserved_block , 0 , 0 , 32,
20032 0xfc001fff, 0xa000077b, 0 , 0,
20033 CP1_ }, /* POOL32Fxf_1~*(7) */
20034 { reserved_block , 0 , 0 , 32,
20035 0xfc001fff, 0xa000087b, 0 , 0,
20036 CP1_ }, /* POOL32Fxf_1~*(8) */
20037 { reserved_block , 0 , 0 , 32,
20038 0xfc001fff, 0xa000097b, 0 , 0,
20039 CP1_ }, /* POOL32Fxf_1~*(9) */
20040 { reserved_block , 0 , 0 , 32,
20041 0xfc001fff, 0xa0000a7b, 0 , 0,
20042 CP1_ }, /* POOL32Fxf_1~*(10) */
20043 { pool , NEG_fmt , 4 , 32,
20044 0xfc001fff, 0xa0000b7b, 0 , 0,
20045 CP1_ }, /* NEG.fmt */
20046 { reserved_block , 0 , 0 , 32,
20047 0xfc001fff, 0xa0000c7b, 0 , 0,
20048 CP1_ }, /* POOL32Fxf_1~*(12) */
20049 { reserved_block , 0 , 0 , 32,
20050 0xfc001fff, 0xa0000d7b, 0 , 0,
20051 CP1_ }, /* POOL32Fxf_1~*(13) */
20052 { reserved_block , 0 , 0 , 32,
20053 0xfc001fff, 0xa0000e7b, 0 , 0,
20054 CP1_ }, /* POOL32Fxf_1~*(14) */
20055 { reserved_block , 0 , 0 , 32,
20056 0xfc001fff, 0xa0000f7b, 0 , 0,
20057 CP1_ }, /* POOL32Fxf_1~*(15) */
20058 { reserved_block , 0 , 0 , 32,
20059 0xfc001fff, 0xa000107b, 0 , 0,
20060 CP1_ }, /* POOL32Fxf_1~*(16) */
20061 { reserved_block , 0 , 0 , 32,
20062 0xfc001fff, 0xa000117b, 0 , 0,
20063 CP1_ }, /* POOL32Fxf_1~*(17) */
20064 { reserved_block , 0 , 0 , 32,
20065 0xfc001fff, 0xa000127b, 0 , 0,
20066 CP1_ }, /* POOL32Fxf_1~*(18) */
20067 { pool , CVT_D_fmt , 4 , 32,
20068 0xfc001fff, 0xa000137b, 0 , 0,
20069 CP1_ }, /* CVT.D.fmt */
20070 { reserved_block , 0 , 0 , 32,
20071 0xfc001fff, 0xa000147b, 0 , 0,
20072 CP1_ }, /* POOL32Fxf_1~*(20) */
20073 { reserved_block , 0 , 0 , 32,
20074 0xfc001fff, 0xa000157b, 0 , 0,
20075 CP1_ }, /* POOL32Fxf_1~*(21) */
20076 { reserved_block , 0 , 0 , 32,
20077 0xfc001fff, 0xa000167b, 0 , 0,
20078 CP1_ }, /* POOL32Fxf_1~*(22) */
20079 { reserved_block , 0 , 0 , 32,
20080 0xfc001fff, 0xa000177b, 0 , 0,
20081 CP1_ }, /* POOL32Fxf_1~*(23) */
20082 { reserved_block , 0 , 0 , 32,
20083 0xfc001fff, 0xa000187b, 0 , 0,
20084 CP1_ }, /* POOL32Fxf_1~*(24) */
20085 { reserved_block , 0 , 0 , 32,
20086 0xfc001fff, 0xa000197b, 0 , 0,
20087 CP1_ }, /* POOL32Fxf_1~*(25) */
20088 { reserved_block , 0 , 0 , 32,
20089 0xfc001fff, 0xa0001a7b, 0 , 0,
20090 CP1_ }, /* POOL32Fxf_1~*(26) */
20091 { pool , CVT_S_fmt , 4 , 32,
20092 0xfc001fff, 0xa0001b7b, 0 , 0,
20093 CP1_ }, /* CVT.S.fmt */
20094 { reserved_block , 0 , 0 , 32,
20095 0xfc001fff, 0xa0001c7b, 0 , 0,
20096 CP1_ }, /* POOL32Fxf_1~*(28) */
20097 { reserved_block , 0 , 0 , 32,
20098 0xfc001fff, 0xa0001d7b, 0 , 0,
20099 CP1_ }, /* POOL32Fxf_1~*(29) */
20100 { reserved_block , 0 , 0 , 32,
20101 0xfc001fff, 0xa0001e7b, 0 , 0,
20102 CP1_ }, /* POOL32Fxf_1~*(30) */
20103 { reserved_block , 0 , 0 , 32,
20104 0xfc001fff, 0xa0001f7b, 0 , 0,
20105 CP1_ }, /* POOL32Fxf_1~*(31) */
20106};
20107
20108
20109NMD::Pool NMD::POOL32Fxf[4] = {
20110 { pool , POOL32Fxf_0 , 64 , 32,
20111 0xfc0000ff, 0xa000003b, 0 , 0,
20112 CP1_ }, /* POOL32Fxf_0 */
20113 { pool , POOL32Fxf_1 , 32 , 32,
20114 0xfc0000ff, 0xa000007b, 0 , 0,
20115 CP1_ }, /* POOL32Fxf_1 */
20116 { reserved_block , 0 , 0 , 32,
20117 0xfc0000ff, 0xa00000bb, 0 , 0,
20118 CP1_ }, /* POOL32Fxf~*(2) */
20119 { reserved_block , 0 , 0 , 32,
20120 0xfc0000ff, 0xa00000fb, 0 , 0,
20121 CP1_ }, /* POOL32Fxf~*(3) */
20122};
20123
20124
20125NMD::Pool NMD::POOL32F_3[8] = {
20126 { pool , MIN_fmt , 2 , 32,
20127 0xfc00003f, 0xa0000003, 0 , 0,
20128 CP1_ }, /* MIN.fmt */
20129 { pool , MAX_fmt , 2 , 32,
20130 0xfc00003f, 0xa000000b, 0 , 0,
20131 CP1_ }, /* MAX.fmt */
20132 { reserved_block , 0 , 0 , 32,
20133 0xfc00003f, 0xa0000013, 0 , 0,
20134 CP1_ }, /* POOL32F_3~*(2) */
20135 { reserved_block , 0 , 0 , 32,
20136 0xfc00003f, 0xa000001b, 0 , 0,
20137 CP1_ }, /* POOL32F_3~*(3) */
20138 { pool , MINA_fmt , 2 , 32,
20139 0xfc00003f, 0xa0000023, 0 , 0,
20140 CP1_ }, /* MINA.fmt */
20141 { pool , MAXA_fmt , 2 , 32,
20142 0xfc00003f, 0xa000002b, 0 , 0,
20143 CP1_ }, /* MAXA.fmt */
20144 { reserved_block , 0 , 0 , 32,
20145 0xfc00003f, 0xa0000033, 0 , 0,
20146 CP1_ }, /* POOL32F_3~*(6) */
20147 { pool , POOL32Fxf , 4 , 32,
20148 0xfc00003f, 0xa000003b, 0 , 0,
20149 CP1_ }, /* POOL32Fxf */
20150};
20151
20152
20153NMD::Pool NMD::CMP_condn_S[32] = {
20154 { instruction , 0 , 0 , 32,
20155 0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S , 0,
20156 CP1_ }, /* CMP.AF.S */
20157 { instruction , 0 , 0 , 32,
20158 0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S , 0,
20159 CP1_ }, /* CMP.UN.S */
20160 { instruction , 0 , 0 , 32,
20161 0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S , 0,
20162 CP1_ }, /* CMP.EQ.S */
20163 { instruction , 0 , 0 , 32,
20164 0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S , 0,
20165 CP1_ }, /* CMP.UEQ.S */
20166 { instruction , 0 , 0 , 32,
20167 0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S , 0,
20168 CP1_ }, /* CMP.LT.S */
20169 { instruction , 0 , 0 , 32,
20170 0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S , 0,
20171 CP1_ }, /* CMP.ULT.S */
20172 { instruction , 0 , 0 , 32,
20173 0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S , 0,
20174 CP1_ }, /* CMP.LE.S */
20175 { instruction , 0 , 0 , 32,
20176 0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S , 0,
20177 CP1_ }, /* CMP.ULE.S */
20178 { instruction , 0 , 0 , 32,
20179 0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S , 0,
20180 CP1_ }, /* CMP.SAF.S */
20181 { instruction , 0 , 0 , 32,
20182 0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S , 0,
20183 CP1_ }, /* CMP.SUN.S */
20184 { instruction , 0 , 0 , 32,
20185 0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S , 0,
20186 CP1_ }, /* CMP.SEQ.S */
20187 { instruction , 0 , 0 , 32,
20188 0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S , 0,
20189 CP1_ }, /* CMP.SUEQ.S */
20190 { instruction , 0 , 0 , 32,
20191 0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S , 0,
20192 CP1_ }, /* CMP.SLT.S */
20193 { instruction , 0 , 0 , 32,
20194 0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S , 0,
20195 CP1_ }, /* CMP.SULT.S */
20196 { instruction , 0 , 0 , 32,
20197 0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S , 0,
20198 CP1_ }, /* CMP.SLE.S */
20199 { instruction , 0 , 0 , 32,
20200 0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S , 0,
20201 CP1_ }, /* CMP.SULE.S */
20202 { reserved_block , 0 , 0 , 32,
20203 0xfc0007ff, 0xa0000405, 0 , 0,
20204 CP1_ }, /* CMP.condn.S~*(16) */
20205 { instruction , 0 , 0 , 32,
20206 0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S , 0,
20207 CP1_ }, /* CMP.OR.S */
20208 { instruction , 0 , 0 , 32,
20209 0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S , 0,
20210 CP1_ }, /* CMP.UNE.S */
20211 { instruction , 0 , 0 , 32,
20212 0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S , 0,
20213 CP1_ }, /* CMP.NE.S */
20214 { reserved_block , 0 , 0 , 32,
20215 0xfc0007ff, 0xa0000505, 0 , 0,
20216 CP1_ }, /* CMP.condn.S~*(20) */
20217 { reserved_block , 0 , 0 , 32,
20218 0xfc0007ff, 0xa0000545, 0 , 0,
20219 CP1_ }, /* CMP.condn.S~*(21) */
20220 { reserved_block , 0 , 0 , 32,
20221 0xfc0007ff, 0xa0000585, 0 , 0,
20222 CP1_ }, /* CMP.condn.S~*(22) */
20223 { reserved_block , 0 , 0 , 32,
20224 0xfc0007ff, 0xa00005c5, 0 , 0,
20225 CP1_ }, /* CMP.condn.S~*(23) */
20226 { reserved_block , 0 , 0 , 32,
20227 0xfc0007ff, 0xa0000605, 0 , 0,
20228 CP1_ }, /* CMP.condn.S~*(24) */
20229 { instruction , 0 , 0 , 32,
20230 0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S , 0,
20231 CP1_ }, /* CMP.SOR.S */
20232 { instruction , 0 , 0 , 32,
20233 0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S , 0,
20234 CP1_ }, /* CMP.SUNE.S */
20235 { instruction , 0 , 0 , 32,
20236 0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S , 0,
20237 CP1_ }, /* CMP.SNE.S */
20238 { reserved_block , 0 , 0 , 32,
20239 0xfc0007ff, 0xa0000705, 0 , 0,
20240 CP1_ }, /* CMP.condn.S~*(28) */
20241 { reserved_block , 0 , 0 , 32,
20242 0xfc0007ff, 0xa0000745, 0 , 0,
20243 CP1_ }, /* CMP.condn.S~*(29) */
20244 { reserved_block , 0 , 0 , 32,
20245 0xfc0007ff, 0xa0000785, 0 , 0,
20246 CP1_ }, /* CMP.condn.S~*(30) */
20247 { reserved_block , 0 , 0 , 32,
20248 0xfc0007ff, 0xa00007c5, 0 , 0,
20249 CP1_ }, /* CMP.condn.S~*(31) */
20250};
20251
20252
20253NMD::Pool NMD::CMP_condn_D[32] = {
20254 { instruction , 0 , 0 , 32,
20255 0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D , 0,
20256 CP1_ }, /* CMP.AF.D */
20257 { instruction , 0 , 0 , 32,
20258 0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D , 0,
20259 CP1_ }, /* CMP.UN.D */
20260 { instruction , 0 , 0 , 32,
20261 0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D , 0,
20262 CP1_ }, /* CMP.EQ.D */
20263 { instruction , 0 , 0 , 32,
20264 0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D , 0,
20265 CP1_ }, /* CMP.UEQ.D */
20266 { instruction , 0 , 0 , 32,
20267 0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D , 0,
20268 CP1_ }, /* CMP.LT.D */
20269 { instruction , 0 , 0 , 32,
20270 0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D , 0,
20271 CP1_ }, /* CMP.ULT.D */
20272 { instruction , 0 , 0 , 32,
20273 0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D , 0,
20274 CP1_ }, /* CMP.LE.D */
20275 { instruction , 0 , 0 , 32,
20276 0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D , 0,
20277 CP1_ }, /* CMP.ULE.D */
20278 { instruction , 0 , 0 , 32,
20279 0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D , 0,
20280 CP1_ }, /* CMP.SAF.D */
20281 { instruction , 0 , 0 , 32,
20282 0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D , 0,
20283 CP1_ }, /* CMP.SUN.D */
20284 { instruction , 0 , 0 , 32,
20285 0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D , 0,
20286 CP1_ }, /* CMP.SEQ.D */
20287 { instruction , 0 , 0 , 32,
20288 0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D , 0,
20289 CP1_ }, /* CMP.SUEQ.D */
20290 { instruction , 0 , 0 , 32,
20291 0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D , 0,
20292 CP1_ }, /* CMP.SLT.D */
20293 { instruction , 0 , 0 , 32,
20294 0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D , 0,
20295 CP1_ }, /* CMP.SULT.D */
20296 { instruction , 0 , 0 , 32,
20297 0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D , 0,
20298 CP1_ }, /* CMP.SLE.D */
20299 { instruction , 0 , 0 , 32,
20300 0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D , 0,
20301 CP1_ }, /* CMP.SULE.D */
20302 { reserved_block , 0 , 0 , 32,
20303 0xfc0007ff, 0xa0000415, 0 , 0,
20304 CP1_ }, /* CMP.condn.D~*(16) */
20305 { instruction , 0 , 0 , 32,
20306 0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D , 0,
20307 CP1_ }, /* CMP.OR.D */
20308 { instruction , 0 , 0 , 32,
20309 0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D , 0,
20310 CP1_ }, /* CMP.UNE.D */
20311 { instruction , 0 , 0 , 32,
20312 0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D , 0,
20313 CP1_ }, /* CMP.NE.D */
20314 { reserved_block , 0 , 0 , 32,
20315 0xfc0007ff, 0xa0000515, 0 , 0,
20316 CP1_ }, /* CMP.condn.D~*(20) */
20317 { reserved_block , 0 , 0 , 32,
20318 0xfc0007ff, 0xa0000555, 0 , 0,
20319 CP1_ }, /* CMP.condn.D~*(21) */
20320 { reserved_block , 0 , 0 , 32,
20321 0xfc0007ff, 0xa0000595, 0 , 0,
20322 CP1_ }, /* CMP.condn.D~*(22) */
20323 { reserved_block , 0 , 0 , 32,
20324 0xfc0007ff, 0xa00005d5, 0 , 0,
20325 CP1_ }, /* CMP.condn.D~*(23) */
20326 { reserved_block , 0 , 0 , 32,
20327 0xfc0007ff, 0xa0000615, 0 , 0,
20328 CP1_ }, /* CMP.condn.D~*(24) */
20329 { instruction , 0 , 0 , 32,
20330 0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D , 0,
20331 CP1_ }, /* CMP.SOR.D */
20332 { instruction , 0 , 0 , 32,
20333 0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D , 0,
20334 CP1_ }, /* CMP.SUNE.D */
20335 { instruction , 0 , 0 , 32,
20336 0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D , 0,
20337 CP1_ }, /* CMP.SNE.D */
20338 { reserved_block , 0 , 0 , 32,
20339 0xfc0007ff, 0xa0000715, 0 , 0,
20340 CP1_ }, /* CMP.condn.D~*(28) */
20341 { reserved_block , 0 , 0 , 32,
20342 0xfc0007ff, 0xa0000755, 0 , 0,
20343 CP1_ }, /* CMP.condn.D~*(29) */
20344 { reserved_block , 0 , 0 , 32,
20345 0xfc0007ff, 0xa0000795, 0 , 0,
20346 CP1_ }, /* CMP.condn.D~*(30) */
20347 { reserved_block , 0 , 0 , 32,
20348 0xfc0007ff, 0xa00007d5, 0 , 0,
20349 CP1_ }, /* CMP.condn.D~*(31) */
20350};
20351
20352
20353NMD::Pool NMD::POOL32F_5[8] = {
20354 { pool , CMP_condn_S , 32 , 32,
20355 0xfc00003f, 0xa0000005, 0 , 0,
20356 CP1_ }, /* CMP.condn.S */
20357 { reserved_block , 0 , 0 , 32,
20358 0xfc00003f, 0xa000000d, 0 , 0,
20359 CP1_ }, /* POOL32F_5~*(1) */
20360 { pool , CMP_condn_D , 32 , 32,
20361 0xfc00003f, 0xa0000015, 0 , 0,
20362 CP1_ }, /* CMP.condn.D */
20363 { reserved_block , 0 , 0 , 32,
20364 0xfc00003f, 0xa000001d, 0 , 0,
20365 CP1_ }, /* POOL32F_5~*(3) */
20366 { reserved_block , 0 , 0 , 32,
20367 0xfc00003f, 0xa0000025, 0 , 0,
20368 CP1_ }, /* POOL32F_5~*(4) */
20369 { reserved_block , 0 , 0 , 32,
20370 0xfc00003f, 0xa000002d, 0 , 0,
20371 CP1_ }, /* POOL32F_5~*(5) */
20372 { reserved_block , 0 , 0 , 32,
20373 0xfc00003f, 0xa0000035, 0 , 0,
20374 CP1_ }, /* POOL32F_5~*(6) */
20375 { reserved_block , 0 , 0 , 32,
20376 0xfc00003f, 0xa000003d, 0 , 0,
20377 CP1_ }, /* POOL32F_5~*(7) */
20378};
20379
20380
20381NMD::Pool NMD::POOL32F[8] = {
20382 { pool , POOL32F_0 , 64 , 32,
20383 0xfc000007, 0xa0000000, 0 , 0,
20384 CP1_ }, /* POOL32F_0 */
20385 { reserved_block , 0 , 0 , 32,
20386 0xfc000007, 0xa0000001, 0 , 0,
20387 CP1_ }, /* POOL32F~*(1) */
20388 { reserved_block , 0 , 0 , 32,
20389 0xfc000007, 0xa0000002, 0 , 0,
20390 CP1_ }, /* POOL32F~*(2) */
20391 { pool , POOL32F_3 , 8 , 32,
20392 0xfc000007, 0xa0000003, 0 , 0,
20393 CP1_ }, /* POOL32F_3 */
20394 { reserved_block , 0 , 0 , 32,
20395 0xfc000007, 0xa0000004, 0 , 0,
20396 CP1_ }, /* POOL32F~*(4) */
20397 { pool , POOL32F_5 , 8 , 32,
20398 0xfc000007, 0xa0000005, 0 , 0,
20399 CP1_ }, /* POOL32F_5 */
20400 { reserved_block , 0 , 0 , 32,
20401 0xfc000007, 0xa0000006, 0 , 0,
20402 CP1_ }, /* POOL32F~*(6) */
20403 { reserved_block , 0 , 0 , 32,
20404 0xfc000007, 0xa0000007, 0 , 0,
20405 CP1_ }, /* POOL32F~*(7) */
20406};
20407
20408
20409NMD::Pool NMD::POOL32S_0[64] = {
20410 { reserved_block , 0 , 0 , 32,
20411 0xfc0001ff, 0xc0000000, 0 , 0,
20412 0x0 }, /* POOL32S_0~*(0) */
20413 { instruction , 0 , 0 , 32,
20414 0xfc0001ff, 0xc0000008, &NMD::DLSA , 0,
20415 MIPS64_ }, /* DLSA */
20416 { instruction , 0 , 0 , 32,
20417 0xfc0001ff, 0xc0000010, &NMD::DSLLV , 0,
20418 MIPS64_ }, /* DSLLV */
20419 { instruction , 0 , 0 , 32,
20420 0xfc0001ff, 0xc0000018, &NMD::DMUL , 0,
20421 MIPS64_ }, /* DMUL */
20422 { reserved_block , 0 , 0 , 32,
20423 0xfc0001ff, 0xc0000020, 0 , 0,
20424 0x0 }, /* POOL32S_0~*(4) */
20425 { reserved_block , 0 , 0 , 32,
20426 0xfc0001ff, 0xc0000028, 0 , 0,
20427 0x0 }, /* POOL32S_0~*(5) */
20428 { reserved_block , 0 , 0 , 32,
20429 0xfc0001ff, 0xc0000030, 0 , 0,
20430 0x0 }, /* POOL32S_0~*(6) */
20431 { reserved_block , 0 , 0 , 32,
20432 0xfc0001ff, 0xc0000038, 0 , 0,
20433 0x0 }, /* POOL32S_0~*(7) */
20434 { reserved_block , 0 , 0 , 32,
20435 0xfc0001ff, 0xc0000040, 0 , 0,
20436 0x0 }, /* POOL32S_0~*(8) */
20437 { reserved_block , 0 , 0 , 32,
20438 0xfc0001ff, 0xc0000048, 0 , 0,
20439 0x0 }, /* POOL32S_0~*(9) */
20440 { instruction , 0 , 0 , 32,
20441 0xfc0001ff, 0xc0000050, &NMD::DSRLV , 0,
20442 MIPS64_ }, /* DSRLV */
20443 { instruction , 0 , 0 , 32,
20444 0xfc0001ff, 0xc0000058, &NMD::DMUH , 0,
20445 MIPS64_ }, /* DMUH */
20446 { reserved_block , 0 , 0 , 32,
20447 0xfc0001ff, 0xc0000060, 0 , 0,
20448 0x0 }, /* POOL32S_0~*(12) */
20449 { reserved_block , 0 , 0 , 32,
20450 0xfc0001ff, 0xc0000068, 0 , 0,
20451 0x0 }, /* POOL32S_0~*(13) */
20452 { reserved_block , 0 , 0 , 32,
20453 0xfc0001ff, 0xc0000070, 0 , 0,
20454 0x0 }, /* POOL32S_0~*(14) */
20455 { reserved_block , 0 , 0 , 32,
20456 0xfc0001ff, 0xc0000078, 0 , 0,
20457 0x0 }, /* POOL32S_0~*(15) */
20458 { reserved_block , 0 , 0 , 32,
20459 0xfc0001ff, 0xc0000080, 0 , 0,
20460 0x0 }, /* POOL32S_0~*(16) */
20461 { reserved_block , 0 , 0 , 32,
20462 0xfc0001ff, 0xc0000088, 0 , 0,
20463 0x0 }, /* POOL32S_0~*(17) */
20464 { instruction , 0 , 0 , 32,
20465 0xfc0001ff, 0xc0000090, &NMD::DSRAV , 0,
20466 MIPS64_ }, /* DSRAV */
20467 { instruction , 0 , 0 , 32,
20468 0xfc0001ff, 0xc0000098, &NMD::DMULU , 0,
20469 MIPS64_ }, /* DMULU */
20470 { reserved_block , 0 , 0 , 32,
20471 0xfc0001ff, 0xc00000a0, 0 , 0,
20472 0x0 }, /* POOL32S_0~*(20) */
20473 { reserved_block , 0 , 0 , 32,
20474 0xfc0001ff, 0xc00000a8, 0 , 0,
20475 0x0 }, /* POOL32S_0~*(21) */
20476 { reserved_block , 0 , 0 , 32,
20477 0xfc0001ff, 0xc00000b0, 0 , 0,
20478 0x0 }, /* POOL32S_0~*(22) */
20479 { reserved_block , 0 , 0 , 32,
20480 0xfc0001ff, 0xc00000b8, 0 , 0,
20481 0x0 }, /* POOL32S_0~*(23) */
20482 { reserved_block , 0 , 0 , 32,
20483 0xfc0001ff, 0xc00000c0, 0 , 0,
20484 0x0 }, /* POOL32S_0~*(24) */
20485 { reserved_block , 0 , 0 , 32,
20486 0xfc0001ff, 0xc00000c8, 0 , 0,
20487 0x0 }, /* POOL32S_0~*(25) */
20488 { instruction , 0 , 0 , 32,
20489 0xfc0001ff, 0xc00000d0, &NMD::DROTRV , 0,
20490 MIPS64_ }, /* DROTRV */
20491 { instruction , 0 , 0 , 32,
20492 0xfc0001ff, 0xc00000d8, &NMD::DMUHU , 0,
20493 MIPS64_ }, /* DMUHU */
20494 { reserved_block , 0 , 0 , 32,
20495 0xfc0001ff, 0xc00000e0, 0 , 0,
20496 0x0 }, /* POOL32S_0~*(28) */
20497 { reserved_block , 0 , 0 , 32,
20498 0xfc0001ff, 0xc00000e8, 0 , 0,
20499 0x0 }, /* POOL32S_0~*(29) */
20500 { reserved_block , 0 , 0 , 32,
20501 0xfc0001ff, 0xc00000f0, 0 , 0,
20502 0x0 }, /* POOL32S_0~*(30) */
20503 { reserved_block , 0 , 0 , 32,
20504 0xfc0001ff, 0xc00000f8, 0 , 0,
20505 0x0 }, /* POOL32S_0~*(31) */
20506 { reserved_block , 0 , 0 , 32,
20507 0xfc0001ff, 0xc0000100, 0 , 0,
20508 0x0 }, /* POOL32S_0~*(32) */
20509 { reserved_block , 0 , 0 , 32,
20510 0xfc0001ff, 0xc0000108, 0 , 0,
20511 0x0 }, /* POOL32S_0~*(33) */
20512 { instruction , 0 , 0 , 32,
20513 0xfc0001ff, 0xc0000110, &NMD::DADD , 0,
20514 MIPS64_ }, /* DADD */
20515 { instruction , 0 , 0 , 32,
20516 0xfc0001ff, 0xc0000118, &NMD::DDIV , 0,
20517 MIPS64_ }, /* DDIV */
20518 { reserved_block , 0 , 0 , 32,
20519 0xfc0001ff, 0xc0000120, 0 , 0,
20520 0x0 }, /* POOL32S_0~*(36) */
20521 { reserved_block , 0 , 0 , 32,
20522 0xfc0001ff, 0xc0000128, 0 , 0,
20523 0x0 }, /* POOL32S_0~*(37) */
20524 { reserved_block , 0 , 0 , 32,
20525 0xfc0001ff, 0xc0000130, 0 , 0,
20526 0x0 }, /* POOL32S_0~*(38) */
20527 { reserved_block , 0 , 0 , 32,
20528 0xfc0001ff, 0xc0000138, 0 , 0,
20529 0x0 }, /* POOL32S_0~*(39) */
20530 { reserved_block , 0 , 0 , 32,
20531 0xfc0001ff, 0xc0000140, 0 , 0,
20532 0x0 }, /* POOL32S_0~*(40) */
20533 { reserved_block , 0 , 0 , 32,
20534 0xfc0001ff, 0xc0000148, 0 , 0,
20535 0x0 }, /* POOL32S_0~*(41) */
20536 { instruction , 0 , 0 , 32,
20537 0xfc0001ff, 0xc0000150, &NMD::DADDU , 0,
20538 MIPS64_ }, /* DADDU */
20539 { instruction , 0 , 0 , 32,
20540 0xfc0001ff, 0xc0000158, &NMD::DMOD , 0,
20541 MIPS64_ }, /* DMOD */
20542 { reserved_block , 0 , 0 , 32,
20543 0xfc0001ff, 0xc0000160, 0 , 0,
20544 0x0 }, /* POOL32S_0~*(44) */
20545 { reserved_block , 0 , 0 , 32,
20546 0xfc0001ff, 0xc0000168, 0 , 0,
20547 0x0 }, /* POOL32S_0~*(45) */
20548 { reserved_block , 0 , 0 , 32,
20549 0xfc0001ff, 0xc0000170, 0 , 0,
20550 0x0 }, /* POOL32S_0~*(46) */
20551 { reserved_block , 0 , 0 , 32,
20552 0xfc0001ff, 0xc0000178, 0 , 0,
20553 0x0 }, /* POOL32S_0~*(47) */
20554 { reserved_block , 0 , 0 , 32,
20555 0xfc0001ff, 0xc0000180, 0 , 0,
20556 0x0 }, /* POOL32S_0~*(48) */
20557 { reserved_block , 0 , 0 , 32,
20558 0xfc0001ff, 0xc0000188, 0 , 0,
20559 0x0 }, /* POOL32S_0~*(49) */
20560 { instruction , 0 , 0 , 32,
20561 0xfc0001ff, 0xc0000190, &NMD::DSUB , 0,
20562 MIPS64_ }, /* DSUB */
20563 { instruction , 0 , 0 , 32,
20564 0xfc0001ff, 0xc0000198, &NMD::DDIVU , 0,
20565 MIPS64_ }, /* DDIVU */
20566 { reserved_block , 0 , 0 , 32,
20567 0xfc0001ff, 0xc00001a0, 0 , 0,
20568 0x0 }, /* POOL32S_0~*(52) */
20569 { reserved_block , 0 , 0 , 32,
20570 0xfc0001ff, 0xc00001a8, 0 , 0,
20571 0x0 }, /* POOL32S_0~*(53) */
20572 { reserved_block , 0 , 0 , 32,
20573 0xfc0001ff, 0xc00001b0, 0 , 0,
20574 0x0 }, /* POOL32S_0~*(54) */
20575 { reserved_block , 0 , 0 , 32,
20576 0xfc0001ff, 0xc00001b8, 0 , 0,
20577 0x0 }, /* POOL32S_0~*(55) */
20578 { reserved_block , 0 , 0 , 32,
20579 0xfc0001ff, 0xc00001c0, 0 , 0,
20580 0x0 }, /* POOL32S_0~*(56) */
20581 { reserved_block , 0 , 0 , 32,
20582 0xfc0001ff, 0xc00001c8, 0 , 0,
20583 0x0 }, /* POOL32S_0~*(57) */
20584 { instruction , 0 , 0 , 32,
20585 0xfc0001ff, 0xc00001d0, &NMD::DSUBU , 0,
20586 MIPS64_ }, /* DSUBU */
20587 { instruction , 0 , 0 , 32,
20588 0xfc0001ff, 0xc00001d8, &NMD::DMODU , 0,
20589 MIPS64_ }, /* DMODU */
20590 { reserved_block , 0 , 0 , 32,
20591 0xfc0001ff, 0xc00001e0, 0 , 0,
20592 0x0 }, /* POOL32S_0~*(60) */
20593 { reserved_block , 0 , 0 , 32,
20594 0xfc0001ff, 0xc00001e8, 0 , 0,
20595 0x0 }, /* POOL32S_0~*(61) */
20596 { reserved_block , 0 , 0 , 32,
20597 0xfc0001ff, 0xc00001f0, 0 , 0,
20598 0x0 }, /* POOL32S_0~*(62) */
20599 { reserved_block , 0 , 0 , 32,
20600 0xfc0001ff, 0xc00001f8, 0 , 0,
20601 0x0 }, /* POOL32S_0~*(63) */
20602};
20603
20604
20605NMD::Pool NMD::POOL32Sxf_4[128] = {
20606 { reserved_block , 0 , 0 , 32,
20607 0xfc00ffff, 0xc000013c, 0 , 0,
20608 0x0 }, /* POOL32Sxf_4~*(0) */
20609 { reserved_block , 0 , 0 , 32,
20610 0xfc00ffff, 0xc000033c, 0 , 0,
20611 0x0 }, /* POOL32Sxf_4~*(1) */
20612 { reserved_block , 0 , 0 , 32,
20613 0xfc00ffff, 0xc000053c, 0 , 0,
20614 0x0 }, /* POOL32Sxf_4~*(2) */
20615 { reserved_block , 0 , 0 , 32,
20616 0xfc00ffff, 0xc000073c, 0 , 0,
20617 0x0 }, /* POOL32Sxf_4~*(3) */
20618 { reserved_block , 0 , 0 , 32,
20619 0xfc00ffff, 0xc000093c, 0 , 0,
20620 0x0 }, /* POOL32Sxf_4~*(4) */
20621 { reserved_block , 0 , 0 , 32,
20622 0xfc00ffff, 0xc0000b3c, 0 , 0,
20623 0x0 }, /* POOL32Sxf_4~*(5) */
20624 { reserved_block , 0 , 0 , 32,
20625 0xfc00ffff, 0xc0000d3c, 0 , 0,
20626 0x0 }, /* POOL32Sxf_4~*(6) */
20627 { reserved_block , 0 , 0 , 32,
20628 0xfc00ffff, 0xc0000f3c, 0 , 0,
20629 0x0 }, /* POOL32Sxf_4~*(7) */
20630 { reserved_block , 0 , 0 , 32,
20631 0xfc00ffff, 0xc000113c, 0 , 0,
20632 0x0 }, /* POOL32Sxf_4~*(8) */
20633 { reserved_block , 0 , 0 , 32,
20634 0xfc00ffff, 0xc000133c, 0 , 0,
20635 0x0 }, /* POOL32Sxf_4~*(9) */
20636 { reserved_block , 0 , 0 , 32,
20637 0xfc00ffff, 0xc000153c, 0 , 0,
20638 0x0 }, /* POOL32Sxf_4~*(10) */
20639 { reserved_block , 0 , 0 , 32,
20640 0xfc00ffff, 0xc000173c, 0 , 0,
20641 0x0 }, /* POOL32Sxf_4~*(11) */
20642 { reserved_block , 0 , 0 , 32,
20643 0xfc00ffff, 0xc000193c, 0 , 0,
20644 0x0 }, /* POOL32Sxf_4~*(12) */
20645 { reserved_block , 0 , 0 , 32,
20646 0xfc00ffff, 0xc0001b3c, 0 , 0,
20647 0x0 }, /* POOL32Sxf_4~*(13) */
20648 { reserved_block , 0 , 0 , 32,
20649 0xfc00ffff, 0xc0001d3c, 0 , 0,
20650 0x0 }, /* POOL32Sxf_4~*(14) */
20651 { reserved_block , 0 , 0 , 32,
20652 0xfc00ffff, 0xc0001f3c, 0 , 0,
20653 0x0 }, /* POOL32Sxf_4~*(15) */
20654 { reserved_block , 0 , 0 , 32,
20655 0xfc00ffff, 0xc000213c, 0 , 0,
20656 0x0 }, /* POOL32Sxf_4~*(16) */
20657 { reserved_block , 0 , 0 , 32,
20658 0xfc00ffff, 0xc000233c, 0 , 0,
20659 0x0 }, /* POOL32Sxf_4~*(17) */
20660 { reserved_block , 0 , 0 , 32,
20661 0xfc00ffff, 0xc000253c, 0 , 0,
20662 0x0 }, /* POOL32Sxf_4~*(18) */
20663 { reserved_block , 0 , 0 , 32,
20664 0xfc00ffff, 0xc000273c, 0 , 0,
20665 0x0 }, /* POOL32Sxf_4~*(19) */
20666 { reserved_block , 0 , 0 , 32,
20667 0xfc00ffff, 0xc000293c, 0 , 0,
20668 0x0 }, /* POOL32Sxf_4~*(20) */
20669 { reserved_block , 0 , 0 , 32,
20670 0xfc00ffff, 0xc0002b3c, 0 , 0,
20671 0x0 }, /* POOL32Sxf_4~*(21) */
20672 { reserved_block , 0 , 0 , 32,
20673 0xfc00ffff, 0xc0002d3c, 0 , 0,
20674 0x0 }, /* POOL32Sxf_4~*(22) */
20675 { reserved_block , 0 , 0 , 32,
20676 0xfc00ffff, 0xc0002f3c, 0 , 0,
20677 0x0 }, /* POOL32Sxf_4~*(23) */
20678 { reserved_block , 0 , 0 , 32,
20679 0xfc00ffff, 0xc000313c, 0 , 0,
20680 0x0 }, /* POOL32Sxf_4~*(24) */
20681 { reserved_block , 0 , 0 , 32,
20682 0xfc00ffff, 0xc000333c, 0 , 0,
20683 0x0 }, /* POOL32Sxf_4~*(25) */
20684 { reserved_block , 0 , 0 , 32,
20685 0xfc00ffff, 0xc000353c, 0 , 0,
20686 0x0 }, /* POOL32Sxf_4~*(26) */
20687 { reserved_block , 0 , 0 , 32,
20688 0xfc00ffff, 0xc000373c, 0 , 0,
20689 0x0 }, /* POOL32Sxf_4~*(27) */
20690 { reserved_block , 0 , 0 , 32,
20691 0xfc00ffff, 0xc000393c, 0 , 0,
20692 0x0 }, /* POOL32Sxf_4~*(28) */
20693 { reserved_block , 0 , 0 , 32,
20694 0xfc00ffff, 0xc0003b3c, 0 , 0,
20695 0x0 }, /* POOL32Sxf_4~*(29) */
20696 { reserved_block , 0 , 0 , 32,
20697 0xfc00ffff, 0xc0003d3c, 0 , 0,
20698 0x0 }, /* POOL32Sxf_4~*(30) */
20699 { reserved_block , 0 , 0 , 32,
20700 0xfc00ffff, 0xc0003f3c, 0 , 0,
20701 0x0 }, /* POOL32Sxf_4~*(31) */
20702 { reserved_block , 0 , 0 , 32,
20703 0xfc00ffff, 0xc000413c, 0 , 0,
20704 0x0 }, /* POOL32Sxf_4~*(32) */
20705 { reserved_block , 0 , 0 , 32,
20706 0xfc00ffff, 0xc000433c, 0 , 0,
20707 0x0 }, /* POOL32Sxf_4~*(33) */
20708 { reserved_block , 0 , 0 , 32,
20709 0xfc00ffff, 0xc000453c, 0 , 0,
20710 0x0 }, /* POOL32Sxf_4~*(34) */
20711 { reserved_block , 0 , 0 , 32,
20712 0xfc00ffff, 0xc000473c, 0 , 0,
20713 0x0 }, /* POOL32Sxf_4~*(35) */
20714 { reserved_block , 0 , 0 , 32,
20715 0xfc00ffff, 0xc000493c, 0 , 0,
20716 0x0 }, /* POOL32Sxf_4~*(36) */
20717 { instruction , 0 , 0 , 32,
20718 0xfc00ffff, 0xc0004b3c, &NMD::DCLO , 0,
20719 MIPS64_ }, /* DCLO */
20720 { reserved_block , 0 , 0 , 32,
20721 0xfc00ffff, 0xc0004d3c, 0 , 0,
20722 0x0 }, /* POOL32Sxf_4~*(38) */
20723 { reserved_block , 0 , 0 , 32,
20724 0xfc00ffff, 0xc0004f3c, 0 , 0,
20725 0x0 }, /* POOL32Sxf_4~*(39) */
20726 { reserved_block , 0 , 0 , 32,
20727 0xfc00ffff, 0xc000513c, 0 , 0,
20728 0x0 }, /* POOL32Sxf_4~*(40) */
20729 { reserved_block , 0 , 0 , 32,
20730 0xfc00ffff, 0xc000533c, 0 , 0,
20731 0x0 }, /* POOL32Sxf_4~*(41) */
20732 { reserved_block , 0 , 0 , 32,
20733 0xfc00ffff, 0xc000553c, 0 , 0,
20734 0x0 }, /* POOL32Sxf_4~*(42) */
20735 { reserved_block , 0 , 0 , 32,
20736 0xfc00ffff, 0xc000573c, 0 , 0,
20737 0x0 }, /* POOL32Sxf_4~*(43) */
20738 { reserved_block , 0 , 0 , 32,
20739 0xfc00ffff, 0xc000593c, 0 , 0,
20740 0x0 }, /* POOL32Sxf_4~*(44) */
20741 { instruction , 0 , 0 , 32,
20742 0xfc00ffff, 0xc0005b3c, &NMD::DCLZ , 0,
20743 MIPS64_ }, /* DCLZ */
20744 { reserved_block , 0 , 0 , 32,
20745 0xfc00ffff, 0xc0005d3c, 0 , 0,
20746 0x0 }, /* POOL32Sxf_4~*(46) */
20747 { reserved_block , 0 , 0 , 32,
20748 0xfc00ffff, 0xc0005f3c, 0 , 0,
20749 0x0 }, /* POOL32Sxf_4~*(47) */
20750 { reserved_block , 0 , 0 , 32,
20751 0xfc00ffff, 0xc000613c, 0 , 0,
20752 0x0 }, /* POOL32Sxf_4~*(48) */
20753 { reserved_block , 0 , 0 , 32,
20754 0xfc00ffff, 0xc000633c, 0 , 0,
20755 0x0 }, /* POOL32Sxf_4~*(49) */
20756 { reserved_block , 0 , 0 , 32,
20757 0xfc00ffff, 0xc000653c, 0 , 0,
20758 0x0 }, /* POOL32Sxf_4~*(50) */
20759 { reserved_block , 0 , 0 , 32,
20760 0xfc00ffff, 0xc000673c, 0 , 0,
20761 0x0 }, /* POOL32Sxf_4~*(51) */
20762 { reserved_block , 0 , 0 , 32,
20763 0xfc00ffff, 0xc000693c, 0 , 0,
20764 0x0 }, /* POOL32Sxf_4~*(52) */
20765 { reserved_block , 0 , 0 , 32,
20766 0xfc00ffff, 0xc0006b3c, 0 , 0,
20767 0x0 }, /* POOL32Sxf_4~*(53) */
20768 { reserved_block , 0 , 0 , 32,
20769 0xfc00ffff, 0xc0006d3c, 0 , 0,
20770 0x0 }, /* POOL32Sxf_4~*(54) */
20771 { reserved_block , 0 , 0 , 32,
20772 0xfc00ffff, 0xc0006f3c, 0 , 0,
20773 0x0 }, /* POOL32Sxf_4~*(55) */
20774 { reserved_block , 0 , 0 , 32,
20775 0xfc00ffff, 0xc000713c, 0 , 0,
20776 0x0 }, /* POOL32Sxf_4~*(56) */
20777 { reserved_block , 0 , 0 , 32,
20778 0xfc00ffff, 0xc000733c, 0 , 0,
20779 0x0 }, /* POOL32Sxf_4~*(57) */
20780 { reserved_block , 0 , 0 , 32,
20781 0xfc00ffff, 0xc000753c, 0 , 0,
20782 0x0 }, /* POOL32Sxf_4~*(58) */
20783 { reserved_block , 0 , 0 , 32,
20784 0xfc00ffff, 0xc000773c, 0 , 0,
20785 0x0 }, /* POOL32Sxf_4~*(59) */
20786 { reserved_block , 0 , 0 , 32,
20787 0xfc00ffff, 0xc000793c, 0 , 0,
20788 0x0 }, /* POOL32Sxf_4~*(60) */
20789 { reserved_block , 0 , 0 , 32,
20790 0xfc00ffff, 0xc0007b3c, 0 , 0,
20791 0x0 }, /* POOL32Sxf_4~*(61) */
20792 { reserved_block , 0 , 0 , 32,
20793 0xfc00ffff, 0xc0007d3c, 0 , 0,
20794 0x0 }, /* POOL32Sxf_4~*(62) */
20795 { reserved_block , 0 , 0 , 32,
20796 0xfc00ffff, 0xc0007f3c, 0 , 0,
20797 0x0 }, /* POOL32Sxf_4~*(63) */
20798 { reserved_block , 0 , 0 , 32,
20799 0xfc00ffff, 0xc000813c, 0 , 0,
20800 0x0 }, /* POOL32Sxf_4~*(64) */
20801 { reserved_block , 0 , 0 , 32,
20802 0xfc00ffff, 0xc000833c, 0 , 0,
20803 0x0 }, /* POOL32Sxf_4~*(65) */
20804 { reserved_block , 0 , 0 , 32,
20805 0xfc00ffff, 0xc000853c, 0 , 0,
20806 0x0 }, /* POOL32Sxf_4~*(66) */
20807 { reserved_block , 0 , 0 , 32,
20808 0xfc00ffff, 0xc000873c, 0 , 0,
20809 0x0 }, /* POOL32Sxf_4~*(67) */
20810 { reserved_block , 0 , 0 , 32,
20811 0xfc00ffff, 0xc000893c, 0 , 0,
20812 0x0 }, /* POOL32Sxf_4~*(68) */
20813 { reserved_block , 0 , 0 , 32,
20814 0xfc00ffff, 0xc0008b3c, 0 , 0,
20815 0x0 }, /* POOL32Sxf_4~*(69) */
20816 { reserved_block , 0 , 0 , 32,
20817 0xfc00ffff, 0xc0008d3c, 0 , 0,
20818 0x0 }, /* POOL32Sxf_4~*(70) */
20819 { reserved_block , 0 , 0 , 32,
20820 0xfc00ffff, 0xc0008f3c, 0 , 0,
20821 0x0 }, /* POOL32Sxf_4~*(71) */
20822 { reserved_block , 0 , 0 , 32,
20823 0xfc00ffff, 0xc000913c, 0 , 0,
20824 0x0 }, /* POOL32Sxf_4~*(72) */
20825 { reserved_block , 0 , 0 , 32,
20826 0xfc00ffff, 0xc000933c, 0 , 0,
20827 0x0 }, /* POOL32Sxf_4~*(73) */
20828 { reserved_block , 0 , 0 , 32,
20829 0xfc00ffff, 0xc000953c, 0 , 0,
20830 0x0 }, /* POOL32Sxf_4~*(74) */
20831 { reserved_block , 0 , 0 , 32,
20832 0xfc00ffff, 0xc000973c, 0 , 0,
20833 0x0 }, /* POOL32Sxf_4~*(75) */
20834 { reserved_block , 0 , 0 , 32,
20835 0xfc00ffff, 0xc000993c, 0 , 0,
20836 0x0 }, /* POOL32Sxf_4~*(76) */
20837 { reserved_block , 0 , 0 , 32,
20838 0xfc00ffff, 0xc0009b3c, 0 , 0,
20839 0x0 }, /* POOL32Sxf_4~*(77) */
20840 { reserved_block , 0 , 0 , 32,
20841 0xfc00ffff, 0xc0009d3c, 0 , 0,
20842 0x0 }, /* POOL32Sxf_4~*(78) */
20843 { reserved_block , 0 , 0 , 32,
20844 0xfc00ffff, 0xc0009f3c, 0 , 0,
20845 0x0 }, /* POOL32Sxf_4~*(79) */
20846 { reserved_block , 0 , 0 , 32,
20847 0xfc00ffff, 0xc000a13c, 0 , 0,
20848 0x0 }, /* POOL32Sxf_4~*(80) */
20849 { reserved_block , 0 , 0 , 32,
20850 0xfc00ffff, 0xc000a33c, 0 , 0,
20851 0x0 }, /* POOL32Sxf_4~*(81) */
20852 { reserved_block , 0 , 0 , 32,
20853 0xfc00ffff, 0xc000a53c, 0 , 0,
20854 0x0 }, /* POOL32Sxf_4~*(82) */
20855 { reserved_block , 0 , 0 , 32,
20856 0xfc00ffff, 0xc000a73c, 0 , 0,
20857 0x0 }, /* POOL32Sxf_4~*(83) */
20858 { reserved_block , 0 , 0 , 32,
20859 0xfc00ffff, 0xc000a93c, 0 , 0,
20860 0x0 }, /* POOL32Sxf_4~*(84) */
20861 { reserved_block , 0 , 0 , 32,
20862 0xfc00ffff, 0xc000ab3c, 0 , 0,
20863 0x0 }, /* POOL32Sxf_4~*(85) */
20864 { reserved_block , 0 , 0 , 32,
20865 0xfc00ffff, 0xc000ad3c, 0 , 0,
20866 0x0 }, /* POOL32Sxf_4~*(86) */
20867 { reserved_block , 0 , 0 , 32,
20868 0xfc00ffff, 0xc000af3c, 0 , 0,
20869 0x0 }, /* POOL32Sxf_4~*(87) */
20870 { reserved_block , 0 , 0 , 32,
20871 0xfc00ffff, 0xc000b13c, 0 , 0,
20872 0x0 }, /* POOL32Sxf_4~*(88) */
20873 { reserved_block , 0 , 0 , 32,
20874 0xfc00ffff, 0xc000b33c, 0 , 0,
20875 0x0 }, /* POOL32Sxf_4~*(89) */
20876 { reserved_block , 0 , 0 , 32,
20877 0xfc00ffff, 0xc000b53c, 0 , 0,
20878 0x0 }, /* POOL32Sxf_4~*(90) */
20879 { reserved_block , 0 , 0 , 32,
20880 0xfc00ffff, 0xc000b73c, 0 , 0,
20881 0x0 }, /* POOL32Sxf_4~*(91) */
20882 { reserved_block , 0 , 0 , 32,
20883 0xfc00ffff, 0xc000b93c, 0 , 0,
20884 0x0 }, /* POOL32Sxf_4~*(92) */
20885 { reserved_block , 0 , 0 , 32,
20886 0xfc00ffff, 0xc000bb3c, 0 , 0,
20887 0x0 }, /* POOL32Sxf_4~*(93) */
20888 { reserved_block , 0 , 0 , 32,
20889 0xfc00ffff, 0xc000bd3c, 0 , 0,
20890 0x0 }, /* POOL32Sxf_4~*(94) */
20891 { reserved_block , 0 , 0 , 32,
20892 0xfc00ffff, 0xc000bf3c, 0 , 0,
20893 0x0 }, /* POOL32Sxf_4~*(95) */
20894 { reserved_block , 0 , 0 , 32,
20895 0xfc00ffff, 0xc000c13c, 0 , 0,
20896 0x0 }, /* POOL32Sxf_4~*(96) */
20897 { reserved_block , 0 , 0 , 32,
20898 0xfc00ffff, 0xc000c33c, 0 , 0,
20899 0x0 }, /* POOL32Sxf_4~*(97) */
20900 { reserved_block , 0 , 0 , 32,
20901 0xfc00ffff, 0xc000c53c, 0 , 0,
20902 0x0 }, /* POOL32Sxf_4~*(98) */
20903 { reserved_block , 0 , 0 , 32,
20904 0xfc00ffff, 0xc000c73c, 0 , 0,
20905 0x0 }, /* POOL32Sxf_4~*(99) */
20906 { reserved_block , 0 , 0 , 32,
20907 0xfc00ffff, 0xc000c93c, 0 , 0,
20908 0x0 }, /* POOL32Sxf_4~*(100) */
20909 { reserved_block , 0 , 0 , 32,
20910 0xfc00ffff, 0xc000cb3c, 0 , 0,
20911 0x0 }, /* POOL32Sxf_4~*(101) */
20912 { reserved_block , 0 , 0 , 32,
20913 0xfc00ffff, 0xc000cd3c, 0 , 0,
20914 0x0 }, /* POOL32Sxf_4~*(102) */
20915 { reserved_block , 0 , 0 , 32,
20916 0xfc00ffff, 0xc000cf3c, 0 , 0,
20917 0x0 }, /* POOL32Sxf_4~*(103) */
20918 { reserved_block , 0 , 0 , 32,
20919 0xfc00ffff, 0xc000d13c, 0 , 0,
20920 0x0 }, /* POOL32Sxf_4~*(104) */
20921 { reserved_block , 0 , 0 , 32,
20922 0xfc00ffff, 0xc000d33c, 0 , 0,
20923 0x0 }, /* POOL32Sxf_4~*(105) */
20924 { reserved_block , 0 , 0 , 32,
20925 0xfc00ffff, 0xc000d53c, 0 , 0,
20926 0x0 }, /* POOL32Sxf_4~*(106) */
20927 { reserved_block , 0 , 0 , 32,
20928 0xfc00ffff, 0xc000d73c, 0 , 0,
20929 0x0 }, /* POOL32Sxf_4~*(107) */
20930 { reserved_block , 0 , 0 , 32,
20931 0xfc00ffff, 0xc000d93c, 0 , 0,
20932 0x0 }, /* POOL32Sxf_4~*(108) */
20933 { reserved_block , 0 , 0 , 32,
20934 0xfc00ffff, 0xc000db3c, 0 , 0,
20935 0x0 }, /* POOL32Sxf_4~*(109) */
20936 { reserved_block , 0 , 0 , 32,
20937 0xfc00ffff, 0xc000dd3c, 0 , 0,
20938 0x0 }, /* POOL32Sxf_4~*(110) */
20939 { reserved_block , 0 , 0 , 32,
20940 0xfc00ffff, 0xc000df3c, 0 , 0,
20941 0x0 }, /* POOL32Sxf_4~*(111) */
20942 { reserved_block , 0 , 0 , 32,
20943 0xfc00ffff, 0xc000e13c, 0 , 0,
20944 0x0 }, /* POOL32Sxf_4~*(112) */
20945 { reserved_block , 0 , 0 , 32,
20946 0xfc00ffff, 0xc000e33c, 0 , 0,
20947 0x0 }, /* POOL32Sxf_4~*(113) */
20948 { reserved_block , 0 , 0 , 32,
20949 0xfc00ffff, 0xc000e53c, 0 , 0,
20950 0x0 }, /* POOL32Sxf_4~*(114) */
20951 { reserved_block , 0 , 0 , 32,
20952 0xfc00ffff, 0xc000e73c, 0 , 0,
20953 0x0 }, /* POOL32Sxf_4~*(115) */
20954 { reserved_block , 0 , 0 , 32,
20955 0xfc00ffff, 0xc000e93c, 0 , 0,
20956 0x0 }, /* POOL32Sxf_4~*(116) */
20957 { reserved_block , 0 , 0 , 32,
20958 0xfc00ffff, 0xc000eb3c, 0 , 0,
20959 0x0 }, /* POOL32Sxf_4~*(117) */
20960 { reserved_block , 0 , 0 , 32,
20961 0xfc00ffff, 0xc000ed3c, 0 , 0,
20962 0x0 }, /* POOL32Sxf_4~*(118) */
20963 { reserved_block , 0 , 0 , 32,
20964 0xfc00ffff, 0xc000ef3c, 0 , 0,
20965 0x0 }, /* POOL32Sxf_4~*(119) */
20966 { reserved_block , 0 , 0 , 32,
20967 0xfc00ffff, 0xc000f13c, 0 , 0,
20968 0x0 }, /* POOL32Sxf_4~*(120) */
20969 { reserved_block , 0 , 0 , 32,
20970 0xfc00ffff, 0xc000f33c, 0 , 0,
20971 0x0 }, /* POOL32Sxf_4~*(121) */
20972 { reserved_block , 0 , 0 , 32,
20973 0xfc00ffff, 0xc000f53c, 0 , 0,
20974 0x0 }, /* POOL32Sxf_4~*(122) */
20975 { reserved_block , 0 , 0 , 32,
20976 0xfc00ffff, 0xc000f73c, 0 , 0,
20977 0x0 }, /* POOL32Sxf_4~*(123) */
20978 { reserved_block , 0 , 0 , 32,
20979 0xfc00ffff, 0xc000f93c, 0 , 0,
20980 0x0 }, /* POOL32Sxf_4~*(124) */
20981 { reserved_block , 0 , 0 , 32,
20982 0xfc00ffff, 0xc000fb3c, 0 , 0,
20983 0x0 }, /* POOL32Sxf_4~*(125) */
20984 { reserved_block , 0 , 0 , 32,
20985 0xfc00ffff, 0xc000fd3c, 0 , 0,
20986 0x0 }, /* POOL32Sxf_4~*(126) */
20987 { reserved_block , 0 , 0 , 32,
20988 0xfc00ffff, 0xc000ff3c, 0 , 0,
20989 0x0 }, /* POOL32Sxf_4~*(127) */
20990};
20991
20992
20993NMD::Pool NMD::POOL32Sxf[8] = {
20994 { reserved_block , 0 , 0 , 32,
20995 0xfc0001ff, 0xc000003c, 0 , 0,
20996 0x0 }, /* POOL32Sxf~*(0) */
20997 { reserved_block , 0 , 0 , 32,
20998 0xfc0001ff, 0xc000007c, 0 , 0,
20999 0x0 }, /* POOL32Sxf~*(1) */
21000 { reserved_block , 0 , 0 , 32,
21001 0xfc0001ff, 0xc00000bc, 0 , 0,
21002 0x0 }, /* POOL32Sxf~*(2) */
21003 { reserved_block , 0 , 0 , 32,
21004 0xfc0001ff, 0xc00000fc, 0 , 0,
21005 0x0 }, /* POOL32Sxf~*(3) */
21006 { pool , POOL32Sxf_4 , 128 , 32,
21007 0xfc0001ff, 0xc000013c, 0 , 0,
21008 0x0 }, /* POOL32Sxf_4 */
21009 { reserved_block , 0 , 0 , 32,
21010 0xfc0001ff, 0xc000017c, 0 , 0,
21011 0x0 }, /* POOL32Sxf~*(5) */
21012 { reserved_block , 0 , 0 , 32,
21013 0xfc0001ff, 0xc00001bc, 0 , 0,
21014 0x0 }, /* POOL32Sxf~*(6) */
21015 { reserved_block , 0 , 0 , 32,
21016 0xfc0001ff, 0xc00001fc, 0 , 0,
21017 0x0 }, /* POOL32Sxf~*(7) */
21018};
21019
21020
21021NMD::Pool NMD::POOL32S_4[8] = {
21022 { instruction , 0 , 0 , 32,
21023 0xfc00003f, 0xc0000004, &NMD::EXTD , 0,
21024 MIPS64_ }, /* EXTD */
21025 { instruction , 0 , 0 , 32,
21026 0xfc00003f, 0xc000000c, &NMD::EXTD32 , 0,
21027 MIPS64_ }, /* EXTD32 */
21028 { reserved_block , 0 , 0 , 32,
21029 0xfc00003f, 0xc0000014, 0 , 0,
21030 0x0 }, /* POOL32S_4~*(2) */
21031 { reserved_block , 0 , 0 , 32,
21032 0xfc00003f, 0xc000001c, 0 , 0,
21033 0x0 }, /* POOL32S_4~*(3) */
21034 { reserved_block , 0 , 0 , 32,
21035 0xfc00003f, 0xc0000024, 0 , 0,
21036 0x0 }, /* POOL32S_4~*(4) */
21037 { reserved_block , 0 , 0 , 32,
21038 0xfc00003f, 0xc000002c, 0 , 0,
21039 0x0 }, /* POOL32S_4~*(5) */
21040 { reserved_block , 0 , 0 , 32,
21041 0xfc00003f, 0xc0000034, 0 , 0,
21042 0x0 }, /* POOL32S_4~*(6) */
21043 { pool , POOL32Sxf , 8 , 32,
21044 0xfc00003f, 0xc000003c, 0 , 0,
21045 0x0 }, /* POOL32Sxf */
21046};
21047
21048
21049NMD::Pool NMD::POOL32S[8] = {
21050 { pool , POOL32S_0 , 64 , 32,
21051 0xfc000007, 0xc0000000, 0 , 0,
21052 0x0 }, /* POOL32S_0 */
21053 { reserved_block , 0 , 0 , 32,
21054 0xfc000007, 0xc0000001, 0 , 0,
21055 0x0 }, /* POOL32S~*(1) */
21056 { reserved_block , 0 , 0 , 32,
21057 0xfc000007, 0xc0000002, 0 , 0,
21058 0x0 }, /* POOL32S~*(2) */
21059 { reserved_block , 0 , 0 , 32,
21060 0xfc000007, 0xc0000003, 0 , 0,
21061 0x0 }, /* POOL32S~*(3) */
21062 { pool , POOL32S_4 , 8 , 32,
21063 0xfc000007, 0xc0000004, 0 , 0,
21064 0x0 }, /* POOL32S_4 */
21065 { reserved_block , 0 , 0 , 32,
21066 0xfc000007, 0xc0000005, 0 , 0,
21067 0x0 }, /* POOL32S~*(5) */
21068 { reserved_block , 0 , 0 , 32,
21069 0xfc000007, 0xc0000006, 0 , 0,
21070 0x0 }, /* POOL32S~*(6) */
21071 { reserved_block , 0 , 0 , 32,
21072 0xfc000007, 0xc0000007, 0 , 0,
21073 0x0 }, /* POOL32S~*(7) */
21074};
21075
21076
21077NMD::Pool NMD::P_LUI[2] = {
21078 { instruction , 0 , 0 , 32,
21079 0xfc000002, 0xe0000000, &NMD::LUI , 0,
21080 0x0 }, /* LUI */
21081 { instruction , 0 , 0 , 32,
21082 0xfc000002, 0xe0000002, &NMD::ALUIPC , 0,
21083 0x0 }, /* ALUIPC */
21084};
21085
21086
21087NMD::Pool NMD::P_GP_LH[2] = {
21088 { instruction , 0 , 0 , 32,
21089 0xfc1c0001, 0x44100000, &NMD::LH_GP_ , 0,
21090 0x0 }, /* LH[GP] */
21091 { instruction , 0 , 0 , 32,
21092 0xfc1c0001, 0x44100001, &NMD::LHU_GP_ , 0,
21093 0x0 }, /* LHU[GP] */
21094};
21095
21096
21097NMD::Pool NMD::P_GP_SH[2] = {
21098 { instruction , 0 , 0 , 32,
21099 0xfc1c0001, 0x44140000, &NMD::SH_GP_ , 0,
21100 0x0 }, /* SH[GP] */
21101 { reserved_block , 0 , 0 , 32,
21102 0xfc1c0001, 0x44140001, 0 , 0,
21103 0x0 }, /* P.GP.SH~*(1) */
21104};
21105
21106
21107NMD::Pool NMD::P_GP_CP1[4] = {
21108 { instruction , 0 , 0 , 32,
21109 0xfc1c0003, 0x44180000, &NMD::LWC1_GP_ , 0,
21110 CP1_ }, /* LWC1[GP] */
21111 { instruction , 0 , 0 , 32,
21112 0xfc1c0003, 0x44180001, &NMD::SWC1_GP_ , 0,
21113 CP1_ }, /* SWC1[GP] */
21114 { instruction , 0 , 0 , 32,
21115 0xfc1c0003, 0x44180002, &NMD::LDC1_GP_ , 0,
21116 CP1_ }, /* LDC1[GP] */
21117 { instruction , 0 , 0 , 32,
21118 0xfc1c0003, 0x44180003, &NMD::SDC1_GP_ , 0,
21119 CP1_ }, /* SDC1[GP] */
21120};
21121
21122
21123NMD::Pool NMD::P_GP_M64[4] = {
21124 { instruction , 0 , 0 , 32,
21125 0xfc1c0003, 0x441c0000, &NMD::LWU_GP_ , 0,
21126 MIPS64_ }, /* LWU[GP] */
21127 { reserved_block , 0 , 0 , 32,
21128 0xfc1c0003, 0x441c0001, 0 , 0,
21129 0x0 }, /* P.GP.M64~*(1) */
21130 { reserved_block , 0 , 0 , 32,
21131 0xfc1c0003, 0x441c0002, 0 , 0,
21132 0x0 }, /* P.GP.M64~*(2) */
21133 { reserved_block , 0 , 0 , 32,
21134 0xfc1c0003, 0x441c0003, 0 , 0,
21135 0x0 }, /* P.GP.M64~*(3) */
21136};
21137
21138
21139NMD::Pool NMD::P_GP_BH[8] = {
21140 { instruction , 0 , 0 , 32,
21141 0xfc1c0000, 0x44000000, &NMD::LB_GP_ , 0,
21142 0x0 }, /* LB[GP] */
21143 { instruction , 0 , 0 , 32,
21144 0xfc1c0000, 0x44040000, &NMD::SB_GP_ , 0,
21145 0x0 }, /* SB[GP] */
21146 { instruction , 0 , 0 , 32,
21147 0xfc1c0000, 0x44080000, &NMD::LBU_GP_ , 0,
21148 0x0 }, /* LBU[GP] */
21149 { instruction , 0 , 0 , 32,
21150 0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_ , 0,
21151 0x0 }, /* ADDIU[GP.B] */
21152 { pool , P_GP_LH , 2 , 32,
21153 0xfc1c0000, 0x44100000, 0 , 0,
21154 0x0 }, /* P.GP.LH */
21155 { pool , P_GP_SH , 2 , 32,
21156 0xfc1c0000, 0x44140000, 0 , 0,
21157 0x0 }, /* P.GP.SH */
21158 { pool , P_GP_CP1 , 4 , 32,
21159 0xfc1c0000, 0x44180000, 0 , 0,
21160 0x0 }, /* P.GP.CP1 */
21161 { pool , P_GP_M64 , 4 , 32,
21162 0xfc1c0000, 0x441c0000, 0 , 0,
21163 0x0 }, /* P.GP.M64 */
21164};
21165
21166
21167NMD::Pool NMD::P_LS_U12[16] = {
21168 { instruction , 0 , 0 , 32,
21169 0xfc00f000, 0x84000000, &NMD::LB_U12_ , 0,
21170 0x0 }, /* LB[U12] */
21171 { instruction , 0 , 0 , 32,
21172 0xfc00f000, 0x84001000, &NMD::SB_U12_ , 0,
21173 0x0 }, /* SB[U12] */
21174 { instruction , 0 , 0 , 32,
21175 0xfc00f000, 0x84002000, &NMD::LBU_U12_ , 0,
21176 0x0 }, /* LBU[U12] */
21177 { instruction , 0 , 0 , 32,
21178 0xfc00f000, 0x84003000, &NMD::PREF_U12_ , 0,
21179 0x0 }, /* PREF[U12] */
21180 { instruction , 0 , 0 , 32,
21181 0xfc00f000, 0x84004000, &NMD::LH_U12_ , 0,
21182 0x0 }, /* LH[U12] */
21183 { instruction , 0 , 0 , 32,
21184 0xfc00f000, 0x84005000, &NMD::SH_U12_ , 0,
21185 0x0 }, /* SH[U12] */
21186 { instruction , 0 , 0 , 32,
21187 0xfc00f000, 0x84006000, &NMD::LHU_U12_ , 0,
21188 0x0 }, /* LHU[U12] */
21189 { instruction , 0 , 0 , 32,
21190 0xfc00f000, 0x84007000, &NMD::LWU_U12_ , 0,
21191 MIPS64_ }, /* LWU[U12] */
21192 { instruction , 0 , 0 , 32,
21193 0xfc00f000, 0x84008000, &NMD::LW_U12_ , 0,
21194 0x0 }, /* LW[U12] */
21195 { instruction , 0 , 0 , 32,
21196 0xfc00f000, 0x84009000, &NMD::SW_U12_ , 0,
21197 0x0 }, /* SW[U12] */
21198 { instruction , 0 , 0 , 32,
21199 0xfc00f000, 0x8400a000, &NMD::LWC1_U12_ , 0,
21200 CP1_ }, /* LWC1[U12] */
21201 { instruction , 0 , 0 , 32,
21202 0xfc00f000, 0x8400b000, &NMD::SWC1_U12_ , 0,
21203 CP1_ }, /* SWC1[U12] */
21204 { instruction , 0 , 0 , 32,
21205 0xfc00f000, 0x8400c000, &NMD::LD_U12_ , 0,
21206 MIPS64_ }, /* LD[U12] */
21207 { instruction , 0 , 0 , 32,
21208 0xfc00f000, 0x8400d000, &NMD::SD_U12_ , 0,
21209 MIPS64_ }, /* SD[U12] */
21210 { instruction , 0 , 0 , 32,
21211 0xfc00f000, 0x8400e000, &NMD::LDC1_U12_ , 0,
21212 CP1_ }, /* LDC1[U12] */
21213 { instruction , 0 , 0 , 32,
21214 0xfc00f000, 0x8400f000, &NMD::SDC1_U12_ , 0,
21215 CP1_ }, /* SDC1[U12] */
21216};
21217
21218
21219NMD::Pool NMD::P_PREF_S9_[2] = {
21220 { instruction , 0 , 0 , 32,
21221 0xffe07f00, 0xa7e01800, &NMD::SYNCI , 0,
21222 0x0 }, /* SYNCI */
21223 { instruction , 0 , 0 , 32,
21224 0xfc007f00, 0xa4001800, &NMD::PREF_S9_ , &NMD::PREF_S9__cond ,
21225 0x0 }, /* PREF[S9] */
21226};
21227
21228
21229NMD::Pool NMD::P_LS_S0[16] = {
21230 { instruction , 0 , 0 , 32,
21231 0xfc007f00, 0xa4000000, &NMD::LB_S9_ , 0,
21232 0x0 }, /* LB[S9] */
21233 { instruction , 0 , 0 , 32,
21234 0xfc007f00, 0xa4000800, &NMD::SB_S9_ , 0,
21235 0x0 }, /* SB[S9] */
21236 { instruction , 0 , 0 , 32,
21237 0xfc007f00, 0xa4001000, &NMD::LBU_S9_ , 0,
21238 0x0 }, /* LBU[S9] */
21239 { pool , P_PREF_S9_ , 2 , 32,
21240 0xfc007f00, 0xa4001800, 0 , 0,
21241 0x0 }, /* P.PREF[S9] */
21242 { instruction , 0 , 0 , 32,
21243 0xfc007f00, 0xa4002000, &NMD::LH_S9_ , 0,
21244 0x0 }, /* LH[S9] */
21245 { instruction , 0 , 0 , 32,
21246 0xfc007f00, 0xa4002800, &NMD::SH_S9_ , 0,
21247 0x0 }, /* SH[S9] */
21248 { instruction , 0 , 0 , 32,
21249 0xfc007f00, 0xa4003000, &NMD::LHU_S9_ , 0,
21250 0x0 }, /* LHU[S9] */
21251 { instruction , 0 , 0 , 32,
21252 0xfc007f00, 0xa4003800, &NMD::LWU_S9_ , 0,
21253 MIPS64_ }, /* LWU[S9] */
21254 { instruction , 0 , 0 , 32,
21255 0xfc007f00, 0xa4004000, &NMD::LW_S9_ , 0,
21256 0x0 }, /* LW[S9] */
21257 { instruction , 0 , 0 , 32,
21258 0xfc007f00, 0xa4004800, &NMD::SW_S9_ , 0,
21259 0x0 }, /* SW[S9] */
21260 { instruction , 0 , 0 , 32,
21261 0xfc007f00, 0xa4005000, &NMD::LWC1_S9_ , 0,
21262 CP1_ }, /* LWC1[S9] */
21263 { instruction , 0 , 0 , 32,
21264 0xfc007f00, 0xa4005800, &NMD::SWC1_S9_ , 0,
21265 CP1_ }, /* SWC1[S9] */
21266 { instruction , 0 , 0 , 32,
21267 0xfc007f00, 0xa4006000, &NMD::LD_S9_ , 0,
21268 MIPS64_ }, /* LD[S9] */
21269 { instruction , 0 , 0 , 32,
21270 0xfc007f00, 0xa4006800, &NMD::SD_S9_ , 0,
21271 MIPS64_ }, /* SD[S9] */
21272 { instruction , 0 , 0 , 32,
21273 0xfc007f00, 0xa4007000, &NMD::LDC1_S9_ , 0,
21274 CP1_ }, /* LDC1[S9] */
21275 { instruction , 0 , 0 , 32,
21276 0xfc007f00, 0xa4007800, &NMD::SDC1_S9_ , 0,
21277 CP1_ }, /* SDC1[S9] */
21278};
21279
21280
21281NMD::Pool NMD::ASET_ACLR[2] = {
21282 { instruction , 0 , 0 , 32,
21283 0xfe007f00, 0xa4001100, &NMD::ASET , 0,
21284 MCU_ }, /* ASET */
21285 { instruction , 0 , 0 , 32,
21286 0xfe007f00, 0xa6001100, &NMD::ACLR , 0,
21287 MCU_ }, /* ACLR */
21288};
21289
21290
21291NMD::Pool NMD::P_LL[4] = {
21292 { instruction , 0 , 0 , 32,
21293 0xfc007f03, 0xa4005100, &NMD::LL , 0,
21294 0x0 }, /* LL */
21295 { instruction , 0 , 0 , 32,
21296 0xfc007f03, 0xa4005101, &NMD::LLWP , 0,
21297 XNP_ }, /* LLWP */
21298 { reserved_block , 0 , 0 , 32,
21299 0xfc007f03, 0xa4005102, 0 , 0,
21300 0x0 }, /* P.LL~*(2) */
21301 { reserved_block , 0 , 0 , 32,
21302 0xfc007f03, 0xa4005103, 0 , 0,
21303 0x0 }, /* P.LL~*(3) */
21304};
21305
21306
21307NMD::Pool NMD::P_SC[4] = {
21308 { instruction , 0 , 0 , 32,
21309 0xfc007f03, 0xa4005900, &NMD::SC , 0,
21310 0x0 }, /* SC */
21311 { instruction , 0 , 0 , 32,
21312 0xfc007f03, 0xa4005901, &NMD::SCWP , 0,
21313 XNP_ }, /* SCWP */
21314 { reserved_block , 0 , 0 , 32,
21315 0xfc007f03, 0xa4005902, 0 , 0,
21316 0x0 }, /* P.SC~*(2) */
21317 { reserved_block , 0 , 0 , 32,
21318 0xfc007f03, 0xa4005903, 0 , 0,
21319 0x0 }, /* P.SC~*(3) */
21320};
21321
21322
21323NMD::Pool NMD::P_LLD[8] = {
21324 { instruction , 0 , 0 , 32,
21325 0xfc007f07, 0xa4007100, &NMD::LLD , 0,
21326 MIPS64_ }, /* LLD */
21327 { instruction , 0 , 0 , 32,
21328 0xfc007f07, 0xa4007101, &NMD::LLDP , 0,
21329 MIPS64_ }, /* LLDP */
21330 { reserved_block , 0 , 0 , 32,
21331 0xfc007f07, 0xa4007102, 0 , 0,
21332 0x0 }, /* P.LLD~*(2) */
21333 { reserved_block , 0 , 0 , 32,
21334 0xfc007f07, 0xa4007103, 0 , 0,
21335 0x0 }, /* P.LLD~*(3) */
21336 { reserved_block , 0 , 0 , 32,
21337 0xfc007f07, 0xa4007104, 0 , 0,
21338 0x0 }, /* P.LLD~*(4) */
21339 { reserved_block , 0 , 0 , 32,
21340 0xfc007f07, 0xa4007105, 0 , 0,
21341 0x0 }, /* P.LLD~*(5) */
21342 { reserved_block , 0 , 0 , 32,
21343 0xfc007f07, 0xa4007106, 0 , 0,
21344 0x0 }, /* P.LLD~*(6) */
21345 { reserved_block , 0 , 0 , 32,
21346 0xfc007f07, 0xa4007107, 0 , 0,
21347 0x0 }, /* P.LLD~*(7) */
21348};
21349
21350
21351NMD::Pool NMD::P_SCD[8] = {
21352 { instruction , 0 , 0 , 32,
21353 0xfc007f07, 0xa4007900, &NMD::SCD , 0,
21354 MIPS64_ }, /* SCD */
21355 { instruction , 0 , 0 , 32,
21356 0xfc007f07, 0xa4007901, &NMD::SCDP , 0,
21357 MIPS64_ }, /* SCDP */
21358 { reserved_block , 0 , 0 , 32,
21359 0xfc007f07, 0xa4007902, 0 , 0,
21360 0x0 }, /* P.SCD~*(2) */
21361 { reserved_block , 0 , 0 , 32,
21362 0xfc007f07, 0xa4007903, 0 , 0,
21363 0x0 }, /* P.SCD~*(3) */
21364 { reserved_block , 0 , 0 , 32,
21365 0xfc007f07, 0xa4007904, 0 , 0,
21366 0x0 }, /* P.SCD~*(4) */
21367 { reserved_block , 0 , 0 , 32,
21368 0xfc007f07, 0xa4007905, 0 , 0,
21369 0x0 }, /* P.SCD~*(5) */
21370 { reserved_block , 0 , 0 , 32,
21371 0xfc007f07, 0xa4007906, 0 , 0,
21372 0x0 }, /* P.SCD~*(6) */
21373 { reserved_block , 0 , 0 , 32,
21374 0xfc007f07, 0xa4007907, 0 , 0,
21375 0x0 }, /* P.SCD~*(7) */
21376};
21377
21378
21379NMD::Pool NMD::P_LS_S1[16] = {
21380 { reserved_block , 0 , 0 , 32,
21381 0xfc007f00, 0xa4000100, 0 , 0,
21382 0x0 }, /* P.LS.S1~*(0) */
21383 { reserved_block , 0 , 0 , 32,
21384 0xfc007f00, 0xa4000900, 0 , 0,
21385 0x0 }, /* P.LS.S1~*(1) */
21386 { pool , ASET_ACLR , 2 , 32,
21387 0xfc007f00, 0xa4001100, 0 , 0,
21388 0x0 }, /* ASET_ACLR */
21389 { reserved_block , 0 , 0 , 32,
21390 0xfc007f00, 0xa4001900, 0 , 0,
21391 0x0 }, /* P.LS.S1~*(3) */
21392 { instruction , 0 , 0 , 32,
21393 0xfc007f00, 0xa4002100, &NMD::UALH , 0,
21394 XMMS_ }, /* UALH */
21395 { instruction , 0 , 0 , 32,
21396 0xfc007f00, 0xa4002900, &NMD::UASH , 0,
21397 XMMS_ }, /* UASH */
21398 { reserved_block , 0 , 0 , 32,
21399 0xfc007f00, 0xa4003100, 0 , 0,
21400 0x0 }, /* P.LS.S1~*(6) */
21401 { instruction , 0 , 0 , 32,
21402 0xfc007f00, 0xa4003900, &NMD::CACHE , 0,
21403 CP0_ }, /* CACHE */
21404 { instruction , 0 , 0 , 32,
21405 0xfc007f00, 0xa4004100, &NMD::LWC2 , 0,
21406 CP2_ }, /* LWC2 */
21407 { instruction , 0 , 0 , 32,
21408 0xfc007f00, 0xa4004900, &NMD::SWC2 , 0,
21409 CP2_ }, /* SWC2 */
21410 { pool , P_LL , 4 , 32,
21411 0xfc007f00, 0xa4005100, 0 , 0,
21412 0x0 }, /* P.LL */
21413 { pool , P_SC , 4 , 32,
21414 0xfc007f00, 0xa4005900, 0 , 0,
21415 0x0 }, /* P.SC */
21416 { instruction , 0 , 0 , 32,
21417 0xfc007f00, 0xa4006100, &NMD::LDC2 , 0,
21418 CP2_ }, /* LDC2 */
21419 { instruction , 0 , 0 , 32,
21420 0xfc007f00, 0xa4006900, &NMD::SDC2 , 0,
21421 CP2_ }, /* SDC2 */
21422 { pool , P_LLD , 8 , 32,
21423 0xfc007f00, 0xa4007100, 0 , 0,
21424 0x0 }, /* P.LLD */
21425 { pool , P_SCD , 8 , 32,
21426 0xfc007f00, 0xa4007900, 0 , 0,
21427 0x0 }, /* P.SCD */
21428};
21429
21430
21431NMD::Pool NMD::P_PREFE[2] = {
21432 { instruction , 0 , 0 , 32,
21433 0xffe07f00, 0xa7e01a00, &NMD::SYNCIE , 0,
21434 CP0_ | EVA_ }, /* SYNCIE */
21435 { instruction , 0 , 0 , 32,
21436 0xfc007f00, 0xa4001a00, &NMD::PREFE , &NMD::PREFE_cond ,
21437 CP0_ | EVA_ }, /* PREFE */
21438};
21439
21440
21441NMD::Pool NMD::P_LLE[4] = {
21442 { instruction , 0 , 0 , 32,
21443 0xfc007f03, 0xa4005200, &NMD::LLE , 0,
21444 CP0_ | EVA_ }, /* LLE */
21445 { instruction , 0 , 0 , 32,
21446 0xfc007f03, 0xa4005201, &NMD::LLWPE , 0,
21447 CP0_ | EVA_ }, /* LLWPE */
21448 { reserved_block , 0 , 0 , 32,
21449 0xfc007f03, 0xa4005202, 0 , 0,
21450 0x0 }, /* P.LLE~*(2) */
21451 { reserved_block , 0 , 0 , 32,
21452 0xfc007f03, 0xa4005203, 0 , 0,
21453 0x0 }, /* P.LLE~*(3) */
21454};
21455
21456
21457NMD::Pool NMD::P_SCE[4] = {
21458 { instruction , 0 , 0 , 32,
21459 0xfc007f03, 0xa4005a00, &NMD::SCE , 0,
21460 CP0_ | EVA_ }, /* SCE */
21461 { instruction , 0 , 0 , 32,
21462 0xfc007f03, 0xa4005a01, &NMD::SCWPE , 0,
21463 CP0_ | EVA_ }, /* SCWPE */
21464 { reserved_block , 0 , 0 , 32,
21465 0xfc007f03, 0xa4005a02, 0 , 0,
21466 0x0 }, /* P.SCE~*(2) */
21467 { reserved_block , 0 , 0 , 32,
21468 0xfc007f03, 0xa4005a03, 0 , 0,
21469 0x0 }, /* P.SCE~*(3) */
21470};
21471
21472
21473NMD::Pool NMD::P_LS_E0[16] = {
21474 { instruction , 0 , 0 , 32,
21475 0xfc007f00, 0xa4000200, &NMD::LBE , 0,
21476 CP0_ | EVA_ }, /* LBE */
21477 { instruction , 0 , 0 , 32,
21478 0xfc007f00, 0xa4000a00, &NMD::SBE , 0,
21479 CP0_ | EVA_ }, /* SBE */
21480 { instruction , 0 , 0 , 32,
21481 0xfc007f00, 0xa4001200, &NMD::LBUE , 0,
21482 CP0_ | EVA_ }, /* LBUE */
21483 { pool , P_PREFE , 2 , 32,
21484 0xfc007f00, 0xa4001a00, 0 , 0,
21485 0x0 }, /* P.PREFE */
21486 { instruction , 0 , 0 , 32,
21487 0xfc007f00, 0xa4002200, &NMD::LHE , 0,
21488 CP0_ | EVA_ }, /* LHE */
21489 { instruction , 0 , 0 , 32,
21490 0xfc007f00, 0xa4002a00, &NMD::SHE , 0,
21491 CP0_ | EVA_ }, /* SHE */
21492 { instruction , 0 , 0 , 32,
21493 0xfc007f00, 0xa4003200, &NMD::LHUE , 0,
21494 CP0_ | EVA_ }, /* LHUE */
21495 { instruction , 0 , 0 , 32,
21496 0xfc007f00, 0xa4003a00, &NMD::CACHEE , 0,
21497 CP0_ | EVA_ }, /* CACHEE */
21498 { instruction , 0 , 0 , 32,
21499 0xfc007f00, 0xa4004200, &NMD::LWE , 0,
21500 CP0_ | EVA_ }, /* LWE */
21501 { instruction , 0 , 0 , 32,
21502 0xfc007f00, 0xa4004a00, &NMD::SWE , 0,
21503 CP0_ | EVA_ }, /* SWE */
21504 { pool , P_LLE , 4 , 32,
21505 0xfc007f00, 0xa4005200, 0 , 0,
21506 0x0 }, /* P.LLE */
21507 { pool , P_SCE , 4 , 32,
21508 0xfc007f00, 0xa4005a00, 0 , 0,
21509 0x0 }, /* P.SCE */
21510 { reserved_block , 0 , 0 , 32,
21511 0xfc007f00, 0xa4006200, 0 , 0,
21512 0x0 }, /* P.LS.E0~*(12) */
21513 { reserved_block , 0 , 0 , 32,
21514 0xfc007f00, 0xa4006a00, 0 , 0,
21515 0x0 }, /* P.LS.E0~*(13) */
21516 { reserved_block , 0 , 0 , 32,
21517 0xfc007f00, 0xa4007200, 0 , 0,
21518 0x0 }, /* P.LS.E0~*(14) */
21519 { reserved_block , 0 , 0 , 32,
21520 0xfc007f00, 0xa4007a00, 0 , 0,
21521 0x0 }, /* P.LS.E0~*(15) */
21522};
21523
21524
21525NMD::Pool NMD::P_LS_WM[2] = {
21526 { instruction , 0 , 0 , 32,
21527 0xfc000f00, 0xa4000400, &NMD::LWM , 0,
21528 XMMS_ }, /* LWM */
21529 { instruction , 0 , 0 , 32,
21530 0xfc000f00, 0xa4000c00, &NMD::SWM , 0,
21531 XMMS_ }, /* SWM */
21532};
21533
21534
21535NMD::Pool NMD::P_LS_UAWM[2] = {
21536 { instruction , 0 , 0 , 32,
21537 0xfc000f00, 0xa4000500, &NMD::UALWM , 0,
21538 XMMS_ }, /* UALWM */
21539 { instruction , 0 , 0 , 32,
21540 0xfc000f00, 0xa4000d00, &NMD::UASWM , 0,
21541 XMMS_ }, /* UASWM */
21542};
21543
21544
21545NMD::Pool NMD::P_LS_DM[2] = {
21546 { instruction , 0 , 0 , 32,
21547 0xfc000f00, 0xa4000600, &NMD::LDM , 0,
21548 MIPS64_ }, /* LDM */
21549 { instruction , 0 , 0 , 32,
21550 0xfc000f00, 0xa4000e00, &NMD::SDM , 0,
21551 MIPS64_ }, /* SDM */
21552};
21553
21554
21555NMD::Pool NMD::P_LS_UADM[2] = {
21556 { instruction , 0 , 0 , 32,
21557 0xfc000f00, 0xa4000700, &NMD::UALDM , 0,
21558 MIPS64_ }, /* UALDM */
21559 { instruction , 0 , 0 , 32,
21560 0xfc000f00, 0xa4000f00, &NMD::UASDM , 0,
21561 MIPS64_ }, /* UASDM */
21562};
21563
21564
21565NMD::Pool NMD::P_LS_S9[8] = {
21566 { pool , P_LS_S0 , 16 , 32,
21567 0xfc000700, 0xa4000000, 0 , 0,
21568 0x0 }, /* P.LS.S0 */
21569 { pool , P_LS_S1 , 16 , 32,
21570 0xfc000700, 0xa4000100, 0 , 0,
21571 0x0 }, /* P.LS.S1 */
21572 { pool , P_LS_E0 , 16 , 32,
21573 0xfc000700, 0xa4000200, 0 , 0,
21574 0x0 }, /* P.LS.E0 */
21575 { reserved_block , 0 , 0 , 32,
21576 0xfc000700, 0xa4000300, 0 , 0,
21577 0x0 }, /* P.LS.S9~*(3) */
21578 { pool , P_LS_WM , 2 , 32,
21579 0xfc000700, 0xa4000400, 0 , 0,
21580 0x0 }, /* P.LS.WM */
21581 { pool , P_LS_UAWM , 2 , 32,
21582 0xfc000700, 0xa4000500, 0 , 0,
21583 0x0 }, /* P.LS.UAWM */
21584 { pool , P_LS_DM , 2 , 32,
21585 0xfc000700, 0xa4000600, 0 , 0,
21586 0x0 }, /* P.LS.DM */
21587 { pool , P_LS_UADM , 2 , 32,
21588 0xfc000700, 0xa4000700, 0 , 0,
21589 0x0 }, /* P.LS.UADM */
21590};
21591
21592
21593NMD::Pool NMD::P_BAL[2] = {
21594 { branch_instruction , 0 , 0 , 32,
21595 0xfe000000, 0x28000000, &NMD::BC_32_ , 0,
21596 0x0 }, /* BC[32] */
21597 { call_instruction , 0 , 0 , 32,
21598 0xfe000000, 0x2a000000, &NMD::BALC_32_ , 0,
21599 0x0 }, /* BALC[32] */
21600};
21601
21602
21603NMD::Pool NMD::P_BALRSC[2] = {
21604 { branch_instruction , 0 , 0 , 32,
21605 0xffe0f000, 0x48008000, &NMD::BRSC , 0,
21606 0x0 }, /* BRSC */
21607 { call_instruction , 0 , 0 , 32,
21608 0xfc00f000, 0x48008000, &NMD::BALRSC , &NMD::BALRSC_cond ,
21609 0x0 }, /* BALRSC */
21610};
21611
21612
21613NMD::Pool NMD::P_J[16] = {
21614 { call_instruction , 0 , 0 , 32,
21615 0xfc00f000, 0x48000000, &NMD::JALRC_32_ , 0,
21616 0x0 }, /* JALRC[32] */
21617 { call_instruction , 0 , 0 , 32,
21618 0xfc00f000, 0x48001000, &NMD::JALRC_HB , 0,
21619 0x0 }, /* JALRC.HB */
21620 { reserved_block , 0 , 0 , 32,
21621 0xfc00f000, 0x48002000, 0 , 0,
21622 0x0 }, /* P.J~*(2) */
21623 { reserved_block , 0 , 0 , 32,
21624 0xfc00f000, 0x48003000, 0 , 0,
21625 0x0 }, /* P.J~*(3) */
21626 { reserved_block , 0 , 0 , 32,
21627 0xfc00f000, 0x48004000, 0 , 0,
21628 0x0 }, /* P.J~*(4) */
21629 { reserved_block , 0 , 0 , 32,
21630 0xfc00f000, 0x48005000, 0 , 0,
21631 0x0 }, /* P.J~*(5) */
21632 { reserved_block , 0 , 0 , 32,
21633 0xfc00f000, 0x48006000, 0 , 0,
21634 0x0 }, /* P.J~*(6) */
21635 { reserved_block , 0 , 0 , 32,
21636 0xfc00f000, 0x48007000, 0 , 0,
21637 0x0 }, /* P.J~*(7) */
21638 { pool , P_BALRSC , 2 , 32,
21639 0xfc00f000, 0x48008000, 0 , 0,
21640 0x0 }, /* P.BALRSC */
21641 { reserved_block , 0 , 0 , 32,
21642 0xfc00f000, 0x48009000, 0 , 0,
21643 0x0 }, /* P.J~*(9) */
21644 { reserved_block , 0 , 0 , 32,
21645 0xfc00f000, 0x4800a000, 0 , 0,
21646 0x0 }, /* P.J~*(10) */
21647 { reserved_block , 0 , 0 , 32,
21648 0xfc00f000, 0x4800b000, 0 , 0,
21649 0x0 }, /* P.J~*(11) */
21650 { reserved_block , 0 , 0 , 32,
21651 0xfc00f000, 0x4800c000, 0 , 0,
21652 0x0 }, /* P.J~*(12) */
21653 { reserved_block , 0 , 0 , 32,
21654 0xfc00f000, 0x4800d000, 0 , 0,
21655 0x0 }, /* P.J~*(13) */
21656 { reserved_block , 0 , 0 , 32,
21657 0xfc00f000, 0x4800e000, 0 , 0,
21658 0x0 }, /* P.J~*(14) */
21659 { reserved_block , 0 , 0 , 32,
21660 0xfc00f000, 0x4800f000, 0 , 0,
21661 0x0 }, /* P.J~*(15) */
21662};
21663
21664
21665NMD::Pool NMD::P_BR3A[32] = {
21666 { branch_instruction , 0 , 0 , 32,
21667 0xfc1fc000, 0x88004000, &NMD::BC1EQZC , 0,
21668 CP1_ }, /* BC1EQZC */
21669 { branch_instruction , 0 , 0 , 32,
21670 0xfc1fc000, 0x88014000, &NMD::BC1NEZC , 0,
21671 CP1_ }, /* BC1NEZC */
21672 { branch_instruction , 0 , 0 , 32,
21673 0xfc1fc000, 0x88024000, &NMD::BC2EQZC , 0,
21674 CP2_ }, /* BC2EQZC */
21675 { branch_instruction , 0 , 0 , 32,
21676 0xfc1fc000, 0x88034000, &NMD::BC2NEZC , 0,
21677 CP2_ }, /* BC2NEZC */
21678 { branch_instruction , 0 , 0 , 32,
21679 0xfc1fc000, 0x88044000, &NMD::BPOSGE32C , 0,
21680 DSP_ }, /* BPOSGE32C */
21681 { reserved_block , 0 , 0 , 32,
21682 0xfc1fc000, 0x88054000, 0 , 0,
21683 0x0 }, /* P.BR3A~*(5) */
21684 { reserved_block , 0 , 0 , 32,
21685 0xfc1fc000, 0x88064000, 0 , 0,
21686 0x0 }, /* P.BR3A~*(6) */
21687 { reserved_block , 0 , 0 , 32,
21688 0xfc1fc000, 0x88074000, 0 , 0,
21689 0x0 }, /* P.BR3A~*(7) */
21690 { reserved_block , 0 , 0 , 32,
21691 0xfc1fc000, 0x88084000, 0 , 0,
21692 0x0 }, /* P.BR3A~*(8) */
21693 { reserved_block , 0 , 0 , 32,
21694 0xfc1fc000, 0x88094000, 0 , 0,
21695 0x0 }, /* P.BR3A~*(9) */
21696 { reserved_block , 0 , 0 , 32,
21697 0xfc1fc000, 0x880a4000, 0 , 0,
21698 0x0 }, /* P.BR3A~*(10) */
21699 { reserved_block , 0 , 0 , 32,
21700 0xfc1fc000, 0x880b4000, 0 , 0,
21701 0x0 }, /* P.BR3A~*(11) */
21702 { reserved_block , 0 , 0 , 32,
21703 0xfc1fc000, 0x880c4000, 0 , 0,
21704 0x0 }, /* P.BR3A~*(12) */
21705 { reserved_block , 0 , 0 , 32,
21706 0xfc1fc000, 0x880d4000, 0 , 0,
21707 0x0 }, /* P.BR3A~*(13) */
21708 { reserved_block , 0 , 0 , 32,
21709 0xfc1fc000, 0x880e4000, 0 , 0,
21710 0x0 }, /* P.BR3A~*(14) */
21711 { reserved_block , 0 , 0 , 32,
21712 0xfc1fc000, 0x880f4000, 0 , 0,
21713 0x0 }, /* P.BR3A~*(15) */
21714 { reserved_block , 0 , 0 , 32,
21715 0xfc1fc000, 0x88104000, 0 , 0,
21716 0x0 }, /* P.BR3A~*(16) */
21717 { reserved_block , 0 , 0 , 32,
21718 0xfc1fc000, 0x88114000, 0 , 0,
21719 0x0 }, /* P.BR3A~*(17) */
21720 { reserved_block , 0 , 0 , 32,
21721 0xfc1fc000, 0x88124000, 0 , 0,
21722 0x0 }, /* P.BR3A~*(18) */
21723 { reserved_block , 0 , 0 , 32,
21724 0xfc1fc000, 0x88134000, 0 , 0,
21725 0x0 }, /* P.BR3A~*(19) */
21726 { reserved_block , 0 , 0 , 32,
21727 0xfc1fc000, 0x88144000, 0 , 0,
21728 0x0 }, /* P.BR3A~*(20) */
21729 { reserved_block , 0 , 0 , 32,
21730 0xfc1fc000, 0x88154000, 0 , 0,
21731 0x0 }, /* P.BR3A~*(21) */
21732 { reserved_block , 0 , 0 , 32,
21733 0xfc1fc000, 0x88164000, 0 , 0,
21734 0x0 }, /* P.BR3A~*(22) */
21735 { reserved_block , 0 , 0 , 32,
21736 0xfc1fc000, 0x88174000, 0 , 0,
21737 0x0 }, /* P.BR3A~*(23) */
21738 { reserved_block , 0 , 0 , 32,
21739 0xfc1fc000, 0x88184000, 0 , 0,
21740 0x0 }, /* P.BR3A~*(24) */
21741 { reserved_block , 0 , 0 , 32,
21742 0xfc1fc000, 0x88194000, 0 , 0,
21743 0x0 }, /* P.BR3A~*(25) */
21744 { reserved_block , 0 , 0 , 32,
21745 0xfc1fc000, 0x881a4000, 0 , 0,
21746 0x0 }, /* P.BR3A~*(26) */
21747 { reserved_block , 0 , 0 , 32,
21748 0xfc1fc000, 0x881b4000, 0 , 0,
21749 0x0 }, /* P.BR3A~*(27) */
21750 { reserved_block , 0 , 0 , 32,
21751 0xfc1fc000, 0x881c4000, 0 , 0,
21752 0x0 }, /* P.BR3A~*(28) */
21753 { reserved_block , 0 , 0 , 32,
21754 0xfc1fc000, 0x881d4000, 0 , 0,
21755 0x0 }, /* P.BR3A~*(29) */
21756 { reserved_block , 0 , 0 , 32,
21757 0xfc1fc000, 0x881e4000, 0 , 0,
21758 0x0 }, /* P.BR3A~*(30) */
21759 { reserved_block , 0 , 0 , 32,
21760 0xfc1fc000, 0x881f4000, 0 , 0,
21761 0x0 }, /* P.BR3A~*(31) */
21762};
21763
21764
21765NMD::Pool NMD::P_BR1[4] = {
21766 { branch_instruction , 0 , 0 , 32,
21767 0xfc00c000, 0x88000000, &NMD::BEQC_32_ , 0,
21768 0x0 }, /* BEQC[32] */
21769 { pool , P_BR3A , 32 , 32,
21770 0xfc00c000, 0x88004000, 0 , 0,
21771 0x0 }, /* P.BR3A */
21772 { branch_instruction , 0 , 0 , 32,
21773 0xfc00c000, 0x88008000, &NMD::BGEC , 0,
21774 0x0 }, /* BGEC */
21775 { branch_instruction , 0 , 0 , 32,
21776 0xfc00c000, 0x8800c000, &NMD::BGEUC , 0,
21777 0x0 }, /* BGEUC */
21778};
21779
21780
21781NMD::Pool NMD::P_BR2[4] = {
21782 { branch_instruction , 0 , 0 , 32,
21783 0xfc00c000, 0xa8000000, &NMD::BNEC_32_ , 0,
21784 0x0 }, /* BNEC[32] */
21785 { reserved_block , 0 , 0 , 32,
21786 0xfc00c000, 0xa8004000, 0 , 0,
21787 0x0 }, /* P.BR2~*(1) */
21788 { branch_instruction , 0 , 0 , 32,
21789 0xfc00c000, 0xa8008000, &NMD::BLTC , 0,
21790 0x0 }, /* BLTC */
21791 { branch_instruction , 0 , 0 , 32,
21792 0xfc00c000, 0xa800c000, &NMD::BLTUC , 0,
21793 0x0 }, /* BLTUC */
21794};
21795
21796
21797NMD::Pool NMD::P_BRI[8] = {
21798 { branch_instruction , 0 , 0 , 32,
21799 0xfc1c0000, 0xc8000000, &NMD::BEQIC , 0,
21800 0x0 }, /* BEQIC */
21801 { branch_instruction , 0 , 0 , 32,
21802 0xfc1c0000, 0xc8040000, &NMD::BBEQZC , 0,
21803 XMMS_ }, /* BBEQZC */
21804 { branch_instruction , 0 , 0 , 32,
21805 0xfc1c0000, 0xc8080000, &NMD::BGEIC , 0,
21806 0x0 }, /* BGEIC */
21807 { branch_instruction , 0 , 0 , 32,
21808 0xfc1c0000, 0xc80c0000, &NMD::BGEIUC , 0,
21809 0x0 }, /* BGEIUC */
21810 { branch_instruction , 0 , 0 , 32,
21811 0xfc1c0000, 0xc8100000, &NMD::BNEIC , 0,
21812 0x0 }, /* BNEIC */
21813 { branch_instruction , 0 , 0 , 32,
21814 0xfc1c0000, 0xc8140000, &NMD::BBNEZC , 0,
21815 XMMS_ }, /* BBNEZC */
21816 { branch_instruction , 0 , 0 , 32,
21817 0xfc1c0000, 0xc8180000, &NMD::BLTIC , 0,
21818 0x0 }, /* BLTIC */
21819 { branch_instruction , 0 , 0 , 32,
21820 0xfc1c0000, 0xc81c0000, &NMD::BLTIUC , 0,
21821 0x0 }, /* BLTIUC */
21822};
21823
21824
21825NMD::Pool NMD::P32[32] = {
21826 { pool , P_ADDIU , 2 , 32,
21827 0xfc000000, 0x00000000, 0 , 0,
21828 0x0 }, /* P.ADDIU */
21829 { pool , P32A , 8 , 32,
21830 0xfc000000, 0x20000000, 0 , 0,
21831 0x0 }, /* P32A */
21832 { pool , P_GP_W , 4 , 32,
21833 0xfc000000, 0x40000000, 0 , 0,
21834 0x0 }, /* P.GP.W */
21835 { pool , POOL48I , 32 , 48,
21836 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21837 0x0 }, /* POOL48I */
21838 { pool , P_U12 , 16 , 32,
21839 0xfc000000, 0x80000000, 0 , 0,
21840 0x0 }, /* P.U12 */
21841 { pool , POOL32F , 8 , 32,
21842 0xfc000000, 0xa0000000, 0 , 0,
21843 CP1_ }, /* POOL32F */
21844 { pool , POOL32S , 8 , 32,
21845 0xfc000000, 0xc0000000, 0 , 0,
21846 0x0 }, /* POOL32S */
21847 { pool , P_LUI , 2 , 32,
21848 0xfc000000, 0xe0000000, 0 , 0,
21849 0x0 }, /* P.LUI */
21850 { instruction , 0 , 0 , 32,
21851 0xfc000000, 0x04000000, &NMD::ADDIUPC_32_ , 0,
21852 0x0 }, /* ADDIUPC[32] */
21853 { reserved_block , 0 , 0 , 32,
21854 0xfc000000, 0x24000000, 0 , 0,
21855 0x0 }, /* P32~*(5) */
21856 { pool , P_GP_BH , 8 , 32,
21857 0xfc000000, 0x44000000, 0 , 0,
21858 0x0 }, /* P.GP.BH */
21859 { reserved_block , 0 , 0 , 32,
21860 0xfc000000, 0x64000000, 0 , 0,
21861 0x0 }, /* P32~*(13) */
21862 { pool , P_LS_U12 , 16 , 32,
21863 0xfc000000, 0x84000000, 0 , 0,
21864 0x0 }, /* P.LS.U12 */
21865 { pool , P_LS_S9 , 8 , 32,
21866 0xfc000000, 0xa4000000, 0 , 0,
21867 0x0 }, /* P.LS.S9 */
21868 { reserved_block , 0 , 0 , 32,
21869 0xfc000000, 0xc4000000, 0 , 0,
21870 0x0 }, /* P32~*(25) */
21871 { reserved_block , 0 , 0 , 32,
21872 0xfc000000, 0xe4000000, 0 , 0,
21873 0x0 }, /* P32~*(29) */
21874 { call_instruction , 0 , 0 , 32,
21875 0xfc000000, 0x08000000, &NMD::MOVE_BALC , 0,
21876 XMMS_ }, /* MOVE.BALC */
21877 { pool , P_BAL , 2 , 32,
21878 0xfc000000, 0x28000000, 0 , 0,
21879 0x0 }, /* P.BAL */
21880 { pool , P_J , 16 , 32,
21881 0xfc000000, 0x48000000, 0 , 0,
21882 0x0 }, /* P.J */
21883 { reserved_block , 0 , 0 , 32,
21884 0xfc000000, 0x68000000, 0 , 0,
21885 0x0 }, /* P32~*(14) */
21886 { pool , P_BR1 , 4 , 32,
21887 0xfc000000, 0x88000000, 0 , 0,
21888 0x0 }, /* P.BR1 */
21889 { pool , P_BR2 , 4 , 32,
21890 0xfc000000, 0xa8000000, 0 , 0,
21891 0x0 }, /* P.BR2 */
21892 { pool , P_BRI , 8 , 32,
21893 0xfc000000, 0xc8000000, 0 , 0,
21894 0x0 }, /* P.BRI */
21895 { reserved_block , 0 , 0 , 32,
21896 0xfc000000, 0xe8000000, 0 , 0,
21897 0x0 }, /* P32~*(30) */
21898 { reserved_block , 0 , 0 , 32,
21899 0xfc000000, 0x0c000000, 0 , 0,
21900 0x0 }, /* P32~*(3) */
21901 { reserved_block , 0 , 0 , 32,
21902 0xfc000000, 0x2c000000, 0 , 0,
21903 0x0 }, /* P32~*(7) */
21904 { reserved_block , 0 , 0 , 32,
21905 0xfc000000, 0x4c000000, 0 , 0,
21906 0x0 }, /* P32~*(11) */
21907 { reserved_block , 0 , 0 , 32,
21908 0xfc000000, 0x6c000000, 0 , 0,
21909 0x0 }, /* P32~*(15) */
21910 { reserved_block , 0 , 0 , 32,
21911 0xfc000000, 0x8c000000, 0 , 0,
21912 0x0 }, /* P32~*(19) */
21913 { reserved_block , 0 , 0 , 32,
21914 0xfc000000, 0xac000000, 0 , 0,
21915 0x0 }, /* P32~*(23) */
21916 { reserved_block , 0 , 0 , 32,
21917 0xfc000000, 0xcc000000, 0 , 0,
21918 0x0 }, /* P32~*(27) */
21919 { reserved_block , 0 , 0 , 32,
21920 0xfc000000, 0xec000000, 0 , 0,
21921 0x0 }, /* P32~*(31) */
21922};
21923
21924
21925NMD::Pool NMD::P16_SYSCALL[2] = {
21926 { instruction , 0 , 0 , 16,
21927 0xfffc , 0x1008 , &NMD::SYSCALL_16_ , 0,
21928 0x0 }, /* SYSCALL[16] */
21929 { instruction , 0 , 0 , 16,
21930 0xfffc , 0x100c , &NMD::HYPCALL_16_ , 0,
21931 CP0_ | VZ_ }, /* HYPCALL[16] */
21932};
21933
21934
21935NMD::Pool NMD::P16_RI[4] = {
21936 { reserved_block , 0 , 0 , 16,
21937 0xfff8 , 0x1000 , 0 , 0,
21938 0x0 }, /* P16.RI~*(0) */
21939 { pool , P16_SYSCALL , 2 , 16,
21940 0xfff8 , 0x1008 , 0 , 0,
21941 0x0 }, /* P16.SYSCALL */
21942 { instruction , 0 , 0 , 16,
21943 0xfff8 , 0x1010 , &NMD::BREAK_16_ , 0,
21944 0x0 }, /* BREAK[16] */
21945 { instruction , 0 , 0 , 16,
21946 0xfff8 , 0x1018 , &NMD::SDBBP_16_ , 0,
21947 EJTAG_ }, /* SDBBP[16] */
21948};
21949
21950
21951NMD::Pool NMD::P16_MV[2] = {
21952 { pool , P16_RI , 4 , 16,
21953 0xffe0 , 0x1000 , 0 , 0,
21954 0x0 }, /* P16.RI */
21955 { instruction , 0 , 0 , 16,
21956 0xfc00 , 0x1000 , &NMD::MOVE , &NMD::MOVE_cond ,
21957 0x0 }, /* MOVE */
21958};
21959
21960
21961NMD::Pool NMD::P16_SHIFT[2] = {
21962 { instruction , 0 , 0 , 16,
21963 0xfc08 , 0x3000 , &NMD::SLL_16_ , 0,
21964 0x0 }, /* SLL[16] */
21965 { instruction , 0 , 0 , 16,
21966 0xfc08 , 0x3008 , &NMD::SRL_16_ , 0,
21967 0x0 }, /* SRL[16] */
21968};
21969
21970
21971NMD::Pool NMD::POOL16C_00[4] = {
21972 { instruction , 0 , 0 , 16,
21973 0xfc0f , 0x5000 , &NMD::NOT_16_ , 0,
21974 0x0 }, /* NOT[16] */
21975 { instruction , 0 , 0 , 16,
21976 0xfc0f , 0x5004 , &NMD::XOR_16_ , 0,
21977 0x0 }, /* XOR[16] */
21978 { instruction , 0 , 0 , 16,
21979 0xfc0f , 0x5008 , &NMD::AND_16_ , 0,
21980 0x0 }, /* AND[16] */
21981 { instruction , 0 , 0 , 16,
21982 0xfc0f , 0x500c , &NMD::OR_16_ , 0,
21983 0x0 }, /* OR[16] */
21984};
21985
21986
21987NMD::Pool NMD::POOL16C_0[2] = {
21988 { pool , POOL16C_00 , 4 , 16,
21989 0xfc03 , 0x5000 , 0 , 0,
21990 0x0 }, /* POOL16C_00 */
21991 { reserved_block , 0 , 0 , 16,
21992 0xfc03 , 0x5002 , 0 , 0,
21993 0x0 }, /* POOL16C_0~*(1) */
21994};
21995
21996
21997NMD::Pool NMD::P16C[2] = {
21998 { pool , POOL16C_0 , 2 , 16,
21999 0xfc01 , 0x5000 , 0 , 0,
22000 0x0 }, /* POOL16C_0 */
22001 { instruction , 0 , 0 , 16,
22002 0xfc01 , 0x5001 , &NMD::LWXS_16_ , 0,
22003 0x0 }, /* LWXS[16] */
22004};
22005
22006
22007NMD::Pool NMD::P16_A1[2] = {
22008 { reserved_block , 0 , 0 , 16,
22009 0xfc40 , 0x7000 , 0 , 0,
22010 0x0 }, /* P16.A1~*(0) */
22011 { instruction , 0 , 0 , 16,
22012 0xfc40 , 0x7040 , &NMD::ADDIU_R1_SP_ , 0,
22013 0x0 }, /* ADDIU[R1.SP] */
22014};
22015
22016
22017NMD::Pool NMD::P_ADDIU_RS5_[2] = {
22018 { instruction , 0 , 0 , 16,
22019 0xffe8 , 0x9008 , &NMD::NOP_16_ , 0,
22020 0x0 }, /* NOP[16] */
22021 { instruction , 0 , 0 , 16,
22022 0xfc08 , 0x9008 , &NMD::ADDIU_RS5_ , &NMD::ADDIU_RS5__cond ,
22023 0x0 }, /* ADDIU[RS5] */
22024};
22025
22026
22027NMD::Pool NMD::P16_A2[2] = {
22028 { instruction , 0 , 0 , 16,
22029 0xfc08 , 0x9000 , &NMD::ADDIU_R2_ , 0,
22030 0x0 }, /* ADDIU[R2] */
22031 { pool , P_ADDIU_RS5_ , 2 , 16,
22032 0xfc08 , 0x9008 , 0 , 0,
22033 0x0 }, /* P.ADDIU[RS5] */
22034};
22035
22036
22037NMD::Pool NMD::P16_ADDU[2] = {
22038 { instruction , 0 , 0 , 16,
22039 0xfc01 , 0xb000 , &NMD::ADDU_16_ , 0,
22040 0x0 }, /* ADDU[16] */
22041 { instruction , 0 , 0 , 16,
22042 0xfc01 , 0xb001 , &NMD::SUBU_16_ , 0,
22043 0x0 }, /* SUBU[16] */
22044};
22045
22046
22047NMD::Pool NMD::P16_JRC[2] = {
22048 { branch_instruction , 0 , 0 , 16,
22049 0xfc1f , 0xd800 , &NMD::JRC , 0,
22050 0x0 }, /* JRC */
22051 { call_instruction , 0 , 0 , 16,
22052 0xfc1f , 0xd810 , &NMD::JALRC_16_ , 0,
22053 0x0 }, /* JALRC[16] */
22054};
22055
22056
22057NMD::Pool NMD::P16_BR1[2] = {
22058 { branch_instruction , 0 , 0 , 16,
22059 0xfc00 , 0xd800 , &NMD::BEQC_16_ , &NMD::BEQC_16__cond ,
22060 XMMS_ }, /* BEQC[16] */
22061 { branch_instruction , 0 , 0 , 16,
22062 0xfc00 , 0xd800 , &NMD::BNEC_16_ , &NMD::BNEC_16__cond ,
22063 XMMS_ }, /* BNEC[16] */
22064};
22065
22066
22067NMD::Pool NMD::P16_BR[2] = {
22068 { pool , P16_JRC , 2 , 16,
22069 0xfc0f , 0xd800 , 0 , 0,
22070 0x0 }, /* P16.JRC */
22071 { pool , P16_BR1 , 2 , 16,
22072 0xfc00 , 0xd800 , 0 , &NMD::P16_BR1_cond ,
22073 0x0 }, /* P16.BR1 */
22074};
22075
22076
22077NMD::Pool NMD::P16_SR[2] = {
22078 { instruction , 0 , 0 , 16,
22079 0xfd00 , 0x1c00 , &NMD::SAVE_16_ , 0,
22080 0x0 }, /* SAVE[16] */
22081 { return_instruction , 0 , 0 , 16,
22082 0xfd00 , 0x1d00 , &NMD::RESTORE_JRC_16_ , 0,
22083 0x0 }, /* RESTORE.JRC[16] */
22084};
22085
22086
22087NMD::Pool NMD::P16_4X4[4] = {
22088 { instruction , 0 , 0 , 16,
22089 0xfd08 , 0x3c00 , &NMD::ADDU_4X4_ , 0,
22090 XMMS_ }, /* ADDU[4X4] */
22091 { instruction , 0 , 0 , 16,
22092 0xfd08 , 0x3c08 , &NMD::MUL_4X4_ , 0,
22093 XMMS_ }, /* MUL[4X4] */
22094 { reserved_block , 0 , 0 , 16,
22095 0xfd08 , 0x3d00 , 0 , 0,
22096 0x0 }, /* P16.4X4~*(2) */
22097 { reserved_block , 0 , 0 , 16,
22098 0xfd08 , 0x3d08 , 0 , 0,
22099 0x0 }, /* P16.4X4~*(3) */
22100};
22101
22102
22103NMD::Pool NMD::P16_LB[4] = {
22104 { instruction , 0 , 0 , 16,
22105 0xfc0c , 0x5c00 , &NMD::LB_16_ , 0,
22106 0x0 }, /* LB[16] */
22107 { instruction , 0 , 0 , 16,
22108 0xfc0c , 0x5c04 , &NMD::SB_16_ , 0,
22109 0x0 }, /* SB[16] */
22110 { instruction , 0 , 0 , 16,
22111 0xfc0c , 0x5c08 , &NMD::LBU_16_ , 0,
22112 0x0 }, /* LBU[16] */
22113 { reserved_block , 0 , 0 , 16,
22114 0xfc0c , 0x5c0c , 0 , 0,
22115 0x0 }, /* P16.LB~*(3) */
22116};
22117
22118
22119NMD::Pool NMD::P16_LH[4] = {
22120 { instruction , 0 , 0 , 16,
22121 0xfc09 , 0x7c00 , &NMD::LH_16_ , 0,
22122 0x0 }, /* LH[16] */
22123 { instruction , 0 , 0 , 16,
22124 0xfc09 , 0x7c01 , &NMD::SH_16_ , 0,
22125 0x0 }, /* SH[16] */
22126 { instruction , 0 , 0 , 16,
22127 0xfc09 , 0x7c08 , &NMD::LHU_16_ , 0,
22128 0x0 }, /* LHU[16] */
22129 { reserved_block , 0 , 0 , 16,
22130 0xfc09 , 0x7c09 , 0 , 0,
22131 0x0 }, /* P16.LH~*(3) */
22132};
22133
22134
22135NMD::Pool NMD::P16[32] = {
22136 { pool , P16_MV , 2 , 16,
22137 0xfc00 , 0x1000 , 0 , 0,
22138 0x0 }, /* P16.MV */
22139 { pool , P16_SHIFT , 2 , 16,
22140 0xfc00 , 0x3000 , 0 , 0,
22141 0x0 }, /* P16.SHIFT */
22142 { pool , P16C , 2 , 16,
22143 0xfc00 , 0x5000 , 0 , 0,
22144 0x0 }, /* P16C */
22145 { pool , P16_A1 , 2 , 16,
22146 0xfc00 , 0x7000 , 0 , 0,
22147 0x0 }, /* P16.A1 */
22148 { pool , P16_A2 , 2 , 16,
22149 0xfc00 , 0x9000 , 0 , 0,
22150 0x0 }, /* P16.A2 */
22151 { pool , P16_ADDU , 2 , 16,
22152 0xfc00 , 0xb000 , 0 , 0,
22153 0x0 }, /* P16.ADDU */
22154 { instruction , 0 , 0 , 16,
22155 0xfc00 , 0xd000 , &NMD::LI_16_ , 0,
22156 0x0 }, /* LI[16] */
22157 { instruction , 0 , 0 , 16,
22158 0xfc00 , 0xf000 , &NMD::ANDI_16_ , 0,
22159 0x0 }, /* ANDI[16] */
22160 { instruction , 0 , 0 , 16,
22161 0xfc00 , 0x1400 , &NMD::LW_16_ , 0,
22162 0x0 }, /* LW[16] */
22163 { instruction , 0 , 0 , 16,
22164 0xfc00 , 0x3400 , &NMD::LW_SP_ , 0,
22165 0x0 }, /* LW[SP] */
22166 { instruction , 0 , 0 , 16,
22167 0xfc00 , 0x5400 , &NMD::LW_GP16_ , 0,
22168 0x0 }, /* LW[GP16] */
22169 { instruction , 0 , 0 , 16,
22170 0xfc00 , 0x7400 , &NMD::LW_4X4_ , 0,
22171 XMMS_ }, /* LW[4X4] */
22172 { instruction , 0 , 0 , 16,
22173 0xfc00 , 0x9400 , &NMD::SW_16_ , 0,
22174 0x0 }, /* SW[16] */
22175 { instruction , 0 , 0 , 16,
22176 0xfc00 , 0xb400 , &NMD::SW_SP_ , 0,
22177 0x0 }, /* SW[SP] */
22178 { instruction , 0 , 0 , 16,
22179 0xfc00 , 0xd400 , &NMD::SW_GP16_ , 0,
22180 0x0 }, /* SW[GP16] */
22181 { instruction , 0 , 0 , 16,
22182 0xfc00 , 0xf400 , &NMD::SW_4X4_ , 0,
22183 XMMS_ }, /* SW[4X4] */
22184 { branch_instruction , 0 , 0 , 16,
22185 0xfc00 , 0x1800 , &NMD::BC_16_ , 0,
22186 0x0 }, /* BC[16] */
22187 { call_instruction , 0 , 0 , 16,
22188 0xfc00 , 0x3800 , &NMD::BALC_16_ , 0,
22189 0x0 }, /* BALC[16] */
22190 { reserved_block , 0 , 0 , 16,
22191 0xfc00 , 0x5800 , 0 , 0,
22192 0x0 }, /* P16~*(10) */
22193 { reserved_block , 0 , 0 , 16,
22194 0xfc00 , 0x7800 , 0 , 0,
22195 0x0 }, /* P16~*(14) */
22196 { branch_instruction , 0 , 0 , 16,
22197 0xfc00 , 0x9800 , &NMD::BEQZC_16_ , 0,
22198 0x0 }, /* BEQZC[16] */
22199 { branch_instruction , 0 , 0 , 16,
22200 0xfc00 , 0xb800 , &NMD::BNEZC_16_ , 0,
22201 0x0 }, /* BNEZC[16] */
22202 { pool , P16_BR , 2 , 16,
22203 0xfc00 , 0xd800 , 0 , 0,
22204 0x0 }, /* P16.BR */
22205 { reserved_block , 0 , 0 , 16,
22206 0xfc00 , 0xf800 , 0 , 0,
22207 0x0 }, /* P16~*(30) */
22208 { pool , P16_SR , 2 , 16,
22209 0xfc00 , 0x1c00 , 0 , 0,
22210 0x0 }, /* P16.SR */
22211 { pool , P16_4X4 , 4 , 16,
22212 0xfc00 , 0x3c00 , 0 , 0,
22213 0x0 }, /* P16.4X4 */
22214 { pool , P16_LB , 4 , 16,
22215 0xfc00 , 0x5c00 , 0 , 0,
22216 0x0 }, /* P16.LB */
22217 { pool , P16_LH , 4 , 16,
22218 0xfc00 , 0x7c00 , 0 , 0,
22219 0x0 }, /* P16.LH */
22220 { reserved_block , 0 , 0 , 16,
22221 0xfc00 , 0x9c00 , 0 , 0,
22222 0x0 }, /* P16~*(19) */
22223 { instruction , 0 , 0 , 16,
22224 0xfc00 , 0xbc00 , &NMD::MOVEP , 0,
22225 XMMS_ }, /* MOVEP */
22226 { reserved_block , 0 , 0 , 16,
22227 0xfc00 , 0xdc00 , 0 , 0,
22228 0x0 }, /* P16~*(27) */
22229 { instruction , 0 , 0 , 16,
22230 0xfc00 , 0xfc00 , &NMD::MOVEP_REV_ , 0,
22231 XMMS_ }, /* MOVEP[REV] */
22232};
22233
22234
22235NMD::Pool NMD::MAJOR[2] = {
22236 { pool , P32 , 32 , 32,
22237 0x10000000, 0x00000000, 0 , 0,
22238 0x0 }, /* P32 */
22239 { pool , P16 , 32 , 16,
22240 0x1000 , 0x1000 , 0 , 0,
22241 0x0 }, /* P16 */
22242};
Empty description
This page took 2.178894 seconds and 4 git commands to generate.