]> Git Repo - qemu.git/blame - disas/nanomips.cpp
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
disas: nanoMIPS: Rename the decoder of 'gpr3.src.store' gpr encoding type
[qemu.git] / disas / nanomips.cpp
CommitLineData
89a955e8
AM		 1/*
2 * Source file for nanoMIPS disassembler component of QEMU
3 *
8bae1509 4 * Copyright (C) 2018 Wave Computing, Inc.
89a955e8 5 * Copyright (C) 2018 Matthew Fortune <[email protected]>
8bae1509 6 * Copyright (C) 2018 Aleksandar Markovic <[email protected]>
89a955e8
AM		 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
8bae1509 10 * the Free Software Foundation, either version 2 of the License, or
89a955e8
AM		 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/>.
8bae1509 20 *
89a955e8
AM		 21 */
22
23extern "C" {
24#include "qemu/osdep.h"
25#include "disas/bfd.h"
26}
27
28#include <cstring>
29#include <stdexcept>
30#include <sstream>
31#include <stdio.h>
32#include <stdarg.h>
33
34#include "nanomips.h"
35
36#define IMGASSERTONCE(test)
37
38
39int nanomips_dis(char *buf,
40 unsigned address,
41 unsigned short one,
42 unsigned short two,
43 unsigned short three)
44{
45 std::string disasm;
46 uint16 bits[3] = {one, two, three};
47
48 NMD::TABLE_ENTRY_TYPE type;
49 NMD d(address, NMD::ALL_ATTRIBUTES);
50 int size = d.Disassemble(bits, disasm, type);
51
52 strcpy(buf, disasm.c_str());
53 return size;
54}
55
56int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
57{
58 int status;
59 bfd_byte buffer[2];
60 uint16_t insn1 = 0, insn2 = 0, insn3 = 0;
61 char buf[200];
62
63 info->bytes_per_chunk = 2;
64 info->display_endian = info->endian;
65 info->insn_info_valid = 1;
66 info->branch_delay_insns = 0;
67 info->data_size = 0;
68 info->insn_type = dis_nonbranch;
69 info->target = 0;
70 info->target2 = 0;
71
72 status = (*info->read_memory_func)(memaddr, buffer, 2, info);
73 if (status != 0) {
74 (*info->memory_error_func)(status, memaddr, info);
75 return -1;
76 }
77
78 if (info->endian == BFD_ENDIAN_BIG) {
79 insn1 = bfd_getb16(buffer);
80 } else {
81 insn1 = bfd_getl16(buffer);
82 }
83 (*info->fprintf_func)(info->stream, "%04x ", insn1);
84
85 /* Handle 32-bit opcodes. */
86 if ((insn1 & 0x1000) == 0) {
87 status = (*info->read_memory_func)(memaddr + 2, buffer, 2, info);
88 if (status != 0) {
89 (*info->memory_error_func)(status, memaddr + 2, info);
90 return -1;
91 }
92
93 if (info->endian == BFD_ENDIAN_BIG) {
94 insn2 = bfd_getb16(buffer);
95 } else {
96 insn2 = bfd_getl16(buffer);
97 }
98 (*info->fprintf_func)(info->stream, "%04x ", insn2);
99 } else {
100 (*info->fprintf_func)(info->stream, " ");
101 }
102 /* Handle 48-bit opcodes. */
103 if ((insn1 >> 10) == 0x18) {
104 status = (*info->read_memory_func)(memaddr + 4, buffer, 2, info);
105 if (status != 0) {
106 (*info->memory_error_func)(status, memaddr + 4, info);
107 return -1;
108 }
109
110 if (info->endian == BFD_ENDIAN_BIG) {
111 insn3 = bfd_getb16(buffer);
112 } else {
113 insn3 = bfd_getl16(buffer);
114 }
115 (*info->fprintf_func)(info->stream, "%04x ", insn3);
116 } else {
117 (*info->fprintf_func)(info->stream, " ");
118 }
119
120 int length = nanomips_dis(buf, memaddr, insn1, insn2, insn3);
121
122 /* FIXME: Should probably use a hash table on the major opcode here. */
123
124 (*info->fprintf_func) (info->stream, "%s", buf);
125 if (length > 0) {
126 return length / 8;
127 }
128
129 info->insn_type = dis_noninsn;
130
131 return insn3 ? 6 : insn2 ? 4 : 2;
132}
133
134
135namespace img
136{
137 address addr32(address a)
138 {
139 return a;
140 }
141
142 std::string format(const char *format, ...)
143 {
144 char buffer[256];
145 va_list args;
146 va_start(args, format);
147 int err = vsprintf(buffer, format, args);
148 if (err < 0) {
149 perror(buffer);
150 }
151 va_end(args);
152 return buffer;
153 }
154
155 std::string format(const char *format,
156 std::string s)
157 {
158 char buffer[256];
159
160 sprintf(buffer, format, s.c_str());
161
162 return buffer;
163 }
164
165 std::string format(const char *format,
166 std::string s1,
167 std::string s2)
168 {
169 char buffer[256];
170
171 sprintf(buffer, format, s1.c_str(), s2.c_str());
172
173 return buffer;
174 }
175
176 std::string format(const char *format,
177 std::string s1,
178 std::string s2,
179 std::string s3)
180 {
181 char buffer[256];
182
183 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str());
184
185 return buffer;
186 }
187
188 std::string format(const char *format,
189 std::string s1,
190 std::string s2,
191 std::string s3,
192 std::string s4)
193 {
194 char buffer[256];
195
196 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
197 s4.c_str());
198
199 return buffer;
200 }
201
202 std::string format(const char *format,
203 std::string s1,
204 std::string s2,
205 std::string s3,
206 std::string s4,
207 std::string s5)
208 {
209 char buffer[256];
210
211 sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
212 s4.c_str(), s5.c_str());
213
214 return buffer;
215 }
216
217 std::string format(const char *format,
218 uint64 d,
219 std::string s2)
220 {
221 char buffer[256];
222
223 sprintf(buffer, format, d, s2.c_str());
224
225 return buffer;
226 }
227
228 std::string format(const char *format,
229 std::string s1,
230 uint64 d,
231 std::string s2)
232 {
233 char buffer[256];
234
235 sprintf(buffer, format, s1.c_str(), d, s2.c_str());
236
237 return buffer;
238 }
239
240 std::string format(const char *format,
241 std::string s1,
242 std::string s2,
243 uint64 d)
244 {
245 char buffer[256];
246
247 sprintf(buffer, format, s1.c_str(), s2.c_str(), d);
248
249 return buffer;
250 }
251
252 char as_char(int c)
253 {
254 return static_cast<char>(c);
255 }
256};
257
258
259std::string to_string(img::address a)
260{
261 char buffer[256];
8c33ea59 262 sprintf(buffer, "0x%" PRIx64, a);
89a955e8
AM		 263 return buffer;
264}
265
266
267uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
268{
269 return (data << (64 - (bit_size + bit_offset))) >> (64 - bit_size);
270}
271
272
273int64 sign_extend(int64 data, int msb)
274{
275 uint64 shift = 63 - msb;
276 return (data << shift) >> shift;
277}
278
279
280uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
281 size_t register_list_size)
282{
283 if (index < register_list_size) {
284 return register_list[index];
285 }
286
287 throw std::runtime_error(img::format(
8c33ea59
SW		 288 "Invalid register mapping index %" PRIu64
289 ", size of list = %zu",
89a955e8
AM		 290 index, register_list_size));
291}
292
293
294/*
01fc2557
AM		 295 * NMD::decode_gpr_gpr3() - decoder for 'gpr3' gpr encoding type
296 *
297 * Map a 3-bit code to the 5-bit register space according to this pattern:
298 *
299 * 7 6 5 4 3 2 1 0
300 * | | | | | | | |
301 * | | | | | | | |
302 * | | | └-----------------------┐
303 * | | └-----------------------┐ |
304 * | └-----------------------┐ | |
305 * └-----------------------┐ | | |
306 * | | | | | | | |
307 * ┌-------┘ | | | | | | |
308 * | ┌-------┘ | | | | | |
309 * | | ┌-------┘ | | | | |
310 * | | | ┌-------┘ | | | |
311 * | | | | | | | |
312 * 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
313 * 3 2 1 0
314 *
315 * Used in handling following instructions:
316 *
317 * - ADDIU[R1.SP]
318 * - ADDIU[R2]
319 * - ADDU[16]
320 * - AND[16]
321 * - ANDI[16]
322 * - BEQC[16]
323 * - BEQZC[16]
324 * - BNEC[16]
325 * - BNEZC[16]
326 * - LB[16]
327 * - LBU[16]
328 * - LH[16]
329 * - LHU[16]
330 * - LI[16]
331 * - LW[16]
332 * - LW[GP16]
333 * - LWXS[16]
334 * - NOT[16]
335 * - OR[16]
336 * - SB[16]
337 * - SH[16]
338 * - SLL[16]
339 * - SRL[16]
340 * - SUBU[16]
341 * - SW[16]
342 * - XOR[16]
89a955e8 343 */
988d6c89 344uint64 NMD::decode_gpr_gpr3(uint64 d)
89a955e8
AM		 345{
346 static uint64 register_list[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
347 return renumber_registers(d, register_list,
348 sizeof(register_list) / sizeof(register_list[0]));
349}
350
351
8191856b 352uint64 NMD::decode_gpr_gpr3_src_store(uint64 d)
89a955e8
AM		 353{
354 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
355 return renumber_registers(d, register_list,
356 sizeof(register_list) / sizeof(register_list[0]));
357}
358
359
360uint64 NMD::encode_rd1_from_rd(uint64 d)
361{
362 static uint64 register_list[] = { 4, 5 };
363 return renumber_registers(d, register_list,
364 sizeof(register_list) / sizeof(register_list[0]));
365}
366
367
368uint64 NMD::encode_gpr4_zero(uint64 d)
369{
370 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
371 16, 17, 18, 19, 20, 21, 22, 23 };
372 return renumber_registers(d, register_list,
373 sizeof(register_list) / sizeof(register_list[0]));
374}
375
376
377uint64 NMD::encode_gpr4(uint64 d)
378{
379 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
380 16, 17, 18, 19, 20, 21, 22, 23 };
381 return renumber_registers(d, register_list,
382 sizeof(register_list) / sizeof(register_list[0]));
383}
384
385
386uint64 NMD::encode_rd2_reg1(uint64 d)
387{
388 static uint64 register_list[] = { 4, 5, 6, 7 };
389 return renumber_registers(d, register_list,
390 sizeof(register_list) / sizeof(register_list[0]));
391}
392
393
394uint64 NMD::encode_rd2_reg2(uint64 d)
395{
396 static uint64 register_list[] = { 5, 6, 7, 8 };
397 return renumber_registers(d, register_list,
398 sizeof(register_list) / sizeof(register_list[0]));
399}
400
401
402uint64 NMD::copy(uint64 d)
403{
404 return d;
405}
406
407
408int64 NMD::copy(int64 d)
409{
410 return d;
411}
412
413
414int64 NMD::neg_copy(uint64 d)
415{
416 return 0ll - d;
417}
418
419
420int64 NMD::neg_copy(int64 d)
421{
422 return -d;
423}
424
425
426/* strange wrapper around gpr3 */
427uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
428{
988d6c89 429return decode_gpr_gpr3(d);
89a955e8
AM		 430}
431
432
433/* strange wrapper around gpr3 */
434uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
435{
988d6c89 436 return decode_gpr_gpr3(d);
89a955e8
AM		 437}
438
439
440/* nop - done by extraction function */
441uint64 NMD::encode_s_from_address(uint64 d)
442{
443 return d;
444}
445
446
447/* nop - done by extraction function */
448uint64 NMD::encode_u_from_address(uint64 d)
449{
450 return d;
451}
452
453
454/* nop - done by extraction function */
455uint64 NMD::encode_s_from_s_hi(uint64 d)
456{
457 return d;
458}
459
460
461uint64 NMD::encode_count3_from_count(uint64 d)
462{
463 IMGASSERTONCE(d < 8);
464 return d == 0ull ? 8ull : d;
465}
466
467
468uint64 NMD::encode_shift3_from_shift(uint64 d)
469{
470 IMGASSERTONCE(d < 8);
471 return d == 0ull ? 8ull : d;
472}
473
474
475/* special value for load literal */
476int64 NMD::encode_eu_from_s_li16(uint64 d)
477{
478 IMGASSERTONCE(d < 128);
479 return d == 127 ? -1 : (int64)d;
480}
481
482
483uint64 NMD::encode_msbd_from_size(uint64 d)
484{
485 IMGASSERTONCE(d < 32);
486 return d + 1;
487}
488
489
490uint64 NMD::encode_eu_from_u_andi16(uint64 d)
491{
492 IMGASSERTONCE(d < 16);
493 if (d == 12) {
494 return 0x00ffull;
495 }
496 if (d == 13) {
497 return 0xffffull;
498 }
499 return d;
500}
501
502
503uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
504{
505 IMGASSERTONCE(0);
506 return d;
507}
508
509
510/* save16 / restore16 ???? */
511uint64 NMD::encode_rt1_from_rt(uint64 d)
512{
513 return d ? 31 : 30;
514}
515
516
517/* ? */
518uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
519{
520 return d;
521}
522
523
524std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
525{
526 std::string str;
527
528 for (uint64 counter = 0; counter != count; counter++) {
529 bool use_gp = gp && (counter == count - 1);
530 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
531 str += img::format(",%s", GPR(this_rt));
532 }
533
534 return str;
535}
536
537
538std::string NMD::GPR(uint64 reg)
539{
540 static const char *gpr_reg[32] = {
541 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
542 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
543 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
544 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
545 };
546
547 if (reg < 32) {
548 return gpr_reg[reg];
549 }
550
8c33ea59
SW		 551 throw std::runtime_error(img::format("Invalid GPR register index %" PRIu64,
552 reg));
89a955e8
AM		 553}
554
555
556std::string NMD::FPR(uint64 reg)
557{
558 static const char *fpr_reg[32] = {
559 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
560 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
561 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
562 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
563 };
564
565 if (reg < 32) {
566 return fpr_reg[reg];
567 }
568
8c33ea59
SW		 569 throw std::runtime_error(img::format("Invalid FPR register index %" PRIu64,
570 reg));
89a955e8
AM		 571}
572
573
574std::string NMD::AC(uint64 reg)
575{
576 static const char *ac_reg[4] = {
577 "ac0", "ac1", "ac2", "ac3"
578 };
579
580 if (reg < 4) {
581 return ac_reg[reg];
582 }
583
8c33ea59
SW		 584 throw std::runtime_error(img::format("Invalid AC register index %" PRIu64,
585 reg));
89a955e8
AM		 586}
587
588
589std::string NMD::IMMEDIATE(uint64 value)
590{
8c33ea59 591 return img::format("0x%" PRIx64, value);
89a955e8
AM		 592}
593
594
595std::string NMD::IMMEDIATE(int64 value)
596{
8c33ea59 597 return img::format("%" PRId64, value);
89a955e8
AM		 598}
599
600
601std::string NMD::CPR(uint64 reg)
602{
603 /* needs more work */
8c33ea59 604 return img::format("CP%" PRIu64, reg);
89a955e8
AM		 605}
606
607
608std::string NMD::ADDRESS(uint64 value, int instruction_size)
609{
610 /* token for string replace */
611 /* const char TOKEN_REPLACE = (char)0xa2; */
612 img::address address = m_pc + value + instruction_size;
613 /* symbol replacement */
614 /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
615 return to_string(address);
616}
617
618
619uint64 NMD::extract_op_code_value(const uint16 * data, int size)
620{
621 switch (size) {
622 case 16:
623 return data[0];
624 case 32:
625 return ((uint64)data[0] << 16) | data[1];
626 case 48:
627 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
628 default:
629 return data[0];
630 }
631}
632
633
634int NMD::Disassemble(const uint16 * data, std::string & dis,
635 NMD::TABLE_ENTRY_TYPE & type)
636{
637 return Disassemble(data, dis, type, MAJOR, 2);
638}
639
640
641/*
642 * Recurse through tables until the instruction is found then return
643 * the string and size
644 *
645 * inputs:
646 * pointer to a word stream,
647 * disassember table and size
648 * returns:
649 * instruction size - negative is error
650 * disassembly string - on error will constain error string
651 */
652int NMD::Disassemble(const uint16 * data, std::string & dis,
653 NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
654 int table_size)
655{
656 try
657 {
658 for (int i = 0; i < table_size; i++) {
659 uint64 op_code = extract_op_code_value(data,
660 table[i].instructions_size);
661 if ((op_code & table[i].mask) == table[i].value) {
662 /* possible match */
663 conditional_function cond = table[i].condition;
664 if ((cond == 0) || (this->*cond)(op_code)) {
665 try
666 {
667 if (table[i].type == pool) {
668 return Disassemble(data, dis, type,
669 table[i].next_table,
670 table[i].next_table_size);
671 } else if ((table[i].type == instruction) ||
672 (table[i].type == call_instruction) ||
673 (table[i].type == branch_instruction) ||
674 (table[i].type == return_instruction)) {
675 if ((table[i].attributes != 0) &&
676 (m_requested_instruction_categories &
677 table[i].attributes) == 0) {
678 /*
679 * failed due to instruction having
680 * an ASE attribute and the requested version
681 * not having that attribute
682 */
683 dis = "ASE attribute missmatch";
684 return -5;
685 }
686 disassembly_function dis_fn = table[i].disassembly;
687 if (dis_fn == 0) {
688 dis = "disassembler failure - bad table entry";
689 return -6;
690 }
691 type = table[i].type;
692 dis = (this->*dis_fn)(op_code);
693 return table[i].instructions_size;
694 } else {
695 dis = "reserved instruction";
696 return -2;
697 }
698 }
699 catch (std::runtime_error & e)
700 {
701 dis = e.what();
702 return -3; /* runtime error */
703 }
704 }
705 }
706 }
707 }
708 catch (std::exception & e)
709 {
710 dis = e.what();
711 return -4; /* runtime error */
712 }
713
714 dis = "failed to disassemble";
715 return -1; /* failed to disassemble */
716}
717
718
719uint64 NMD::extract_code_18_to_0(uint64 instruction)
720{
721 uint64 value = 0;
722 value |= extract_bits(instruction, 0, 19);
723 return value;
724}
725
726
727uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
728{
729 uint64 value = 0;
730 value |= extract_bits(instruction, 0, 3);
731 return value;
732}
733
734
11b9732a 735uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
89a955e8
AM		 736{
737 uint64 value = 0;
738 value |= extract_bits(instruction, 3, 9) << 3;
739 return value;
740}
741
742
743uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
744{
745 uint64 value = 0;
746 value |= extract_bits(instruction, 0, 4);
747 return value;
748}
749
750
751uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
752{
753 uint64 value = 0;
754 value |= extract_bits(instruction, 7, 3);
755 return value;
756}
757
758
11b9732a 759uint64 NMD::extract_u_17_to_1__s1(uint64 instruction)
89a955e8
AM		 760{
761 uint64 value = 0;
762 value |= extract_bits(instruction, 1, 17) << 1;
763 return value;
764}
765
766
d3605cc0 767int64 NMD::extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
89a955e8
AM		 768{
769 int64 value = 0;
770 value |= extract_bits(instruction, 11, 10);
771 value = sign_extend(value, 9);
772 return value;
773}
774
775
d3605cc0 776int64 NMD::extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
89a955e8
AM		 777{
778 int64 value = 0;
779 value |= extract_bits(instruction, 0, 1) << 11;
780 value |= extract_bits(instruction, 1, 10) << 1;
781 value = sign_extend(value, 11);
782 return value;
783}
784
785
786uint64 NMD::extract_u_10(uint64 instruction)
787{
788 uint64 value = 0;
789 value |= extract_bits(instruction, 10, 1);
790 return value;
791}
792
793
794uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
795{
796 uint64 value = 0;
797 value |= extract_bits(instruction, 21, 3);
798 value |= extract_bits(instruction, 25, 1) << 3;
799 return value;
800}
801
802
803uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
804{
805 uint64 value = 0;
806 value |= extract_bits(instruction, 11, 5);
807 return value;
808}
809
810
811uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
812{
813 uint64 value = 0;
814 value |= extract_bits(instruction, 0, 5);
815 return value;
816}
817
818
11b9732a 819uint64 NMD::extract_shiftx_10_9_8_7__s1(uint64 instruction)
89a955e8
AM		 820{
821 uint64 value = 0;
822 value |= extract_bits(instruction, 7, 4) << 1;
823 return value;
824}
825
826
827uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
828{
829 uint64 value = 0;
830 value |= extract_bits(instruction, 21, 5);
831 return value;
832}
833
834
835uint64 NMD::extract_count3_14_13_12(uint64 instruction)
836{
837 uint64 value = 0;
838 value |= extract_bits(instruction, 12, 3);
839 return value;
840}
841
842
d3605cc0 843int64 NMD::extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
89a955e8
AM		 844{
845 int64 value = 0;
846 value |= extract_bits(instruction, 0, 1) << 31;
847 value |= extract_bits(instruction, 2, 10) << 21;
848 value |= extract_bits(instruction, 12, 9) << 12;
849 value = sign_extend(value, 31);
850 return value;
851}
852
853
d3605cc0 854int64 NMD::extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
89a955e8
AM		 855{
856 int64 value = 0;
857 value |= extract_bits(instruction, 0, 1) << 7;
858 value |= extract_bits(instruction, 1, 6) << 1;
859 value = sign_extend(value, 7);
860 return value;
861}
862
863
864uint64 NMD::extract_u2_10_9(uint64 instruction)
865{
866 uint64 value = 0;
867 value |= extract_bits(instruction, 9, 2);
868 return value;
869}
870
871
872uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
873{
874 uint64 value = 0;
875 value |= extract_bits(instruction, 16, 10);
876 return value;
877}
878
879
880uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
881{
882 uint64 value = 0;
883 value |= extract_bits(instruction, 16, 5);
884 return value;
885}
886
887
11b9732a 888uint64 NMD::extract_u_2_1__s1(uint64 instruction)
89a955e8
AM		 889{
890 uint64 value = 0;
891 value |= extract_bits(instruction, 1, 2) << 1;
892 return value;
893}
894
895
896uint64 NMD::extract_stripe_6(uint64 instruction)
897{
898 uint64 value = 0;
899 value |= extract_bits(instruction, 6, 1);
900 return value;
901}
902
903
89a955e8
AM		 904uint64 NMD::extract_ac_13_12(uint64 instruction)
905{
906 uint64 value = 0;
907 value |= extract_bits(instruction, 14, 2);
908 return value;
909}
910
911
912uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
913{
914 uint64 value = 0;
915 value |= extract_bits(instruction, 16, 5);
916 return value;
917}
918
919
920uint64 NMD::extract_rdl_25_24(uint64 instruction)
921{
922 uint64 value = 0;
923 value |= extract_bits(instruction, 24, 1);
924 return value;
925}
926
927
d3605cc0 928int64 NMD::extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
89a955e8
AM		 929{
930 int64 value = 0;
931 value |= extract_bits(instruction, 0, 1) << 10;
932 value |= extract_bits(instruction, 1, 9) << 1;
933 value = sign_extend(value, 10);
934 return value;
935}
936
937
938uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
939{
940 uint64 value = 0;
941 value |= extract_bits(instruction, 0, 7);
942 return value;
943}
944
945
946uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
947{
948 uint64 value = 0;
949 value |= extract_bits(instruction, 0, 6);
950 return value;
951}
952
953
89a955e8
AM		 954uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
955{
956 uint64 value = 0;
957 value |= extract_bits(instruction, 16, 4);
958 return value;
959}
960
961
962uint64 NMD::extract_code_2_1_0(uint64 instruction)
963{
964 uint64 value = 0;
965 value |= extract_bits(instruction, 0, 3);
966 return value;
967}
968
969
89a955e8
AM		 970uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
971{
972 uint64 value = 0;
973 value |= extract_bits(instruction, 0, 12);
974 return value;
975}
976
977
978uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
979{
980 uint64 value = 0;
981 value |= extract_bits(instruction, 0, 5);
982 return value;
983}
984
985
11b9732a 986uint64 NMD::extract_u_20_to_3__s3(uint64 instruction)
89a955e8
AM		 987{
988 uint64 value = 0;
989 value |= extract_bits(instruction, 3, 18) << 3;
990 return value;
991}
992
993
11b9732a 994uint64 NMD::extract_u_3_2_1_0__s2(uint64 instruction)
89a955e8
AM		 995{
996 uint64 value = 0;
997 value |= extract_bits(instruction, 0, 4) << 2;
998 return value;
999}
1000
1001
1002uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
1003{
1004 uint64 value = 0;
1005 value |= extract_bits(instruction, 3, 23);
1006 return value;
1007}
1008
1009
11b9732a 1010uint64 NMD::extract_u_2_1_0__s2(uint64 instruction)
89a955e8
AM		 1011{
1012 uint64 value = 0;
1013 value |= extract_bits(instruction, 0, 3) << 2;
1014 return value;
1015}
1016
1017
89a955e8
AM		 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
89a955e8
AM		 1050uint64 NMD::extract_u_17_to_0(uint64 instruction)
1051{
1052 uint64 value = 0;
1053 value |= extract_bits(instruction, 0, 18);
1054 return value;
1055}
1056
1057
89a955e8
AM		 1058uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
1059{
1060 uint64 value = 0;
1061 value |= extract_bits(instruction, 0, 3);
1062 value |= extract_bits(instruction, 4, 1) << 3;
1063 return value;
1064}
1065
1066
d3605cc0 1067int64 NMD::extract_s__se21_0_20_to_1_s1(uint64 instruction)
89a955e8
AM		 1068{
1069 int64 value = 0;
1070 value |= extract_bits(instruction, 0, 1) << 21;
1071 value |= extract_bits(instruction, 1, 20) << 1;
1072 value = sign_extend(value, 21);
1073 return value;
1074}
1075
1076
1077uint64 NMD::extract_op_25_to_3(uint64 instruction)
1078{
1079 uint64 value = 0;
1080 value |= extract_bits(instruction, 3, 23);
1081 return value;
1082}
1083
1084
1085uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
1086{
1087 uint64 value = 0;
1088 value |= extract_bits(instruction, 0, 3);
1089 value |= extract_bits(instruction, 4, 1) << 3;
1090 return value;
1091}
1092
1093
1094uint64 NMD::extract_bit_23_22_21(uint64 instruction)
1095{
1096 uint64 value = 0;
1097 value |= extract_bits(instruction, 21, 3);
1098 return value;
1099}
1100
1101
1102uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
1103{
1104 uint64 value = 0;
1105 value |= extract_bits(instruction, 37, 5);
1106 return value;
1107}
1108
1109
d3605cc0 1110int64 NMD::extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
89a955e8
AM		 1111{
1112 int64 value = 0;
1113 value |= extract_bits(instruction, 16, 6);
1114 value = sign_extend(value, 5);
1115 return value;
1116}
1117
1118
89a955e8
AM		 1119uint64 NMD::extract_rd2_3_8(uint64 instruction)
1120{
1121 uint64 value = 0;
1122 value |= extract_bits(instruction, 3, 1) << 1;
1123 value |= extract_bits(instruction, 8, 1);
1124 return value;
1125}
1126
1127
89a955e8
AM		 1128uint64 NMD::extract_code_17_to_0(uint64 instruction)
1129{
1130 uint64 value = 0;
1131 value |= extract_bits(instruction, 0, 18);
1132 return value;
1133}
1134
1135
89a955e8
AM		 1136uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
1137{
1138 uint64 value = 0;
1139 value |= extract_bits(instruction, 16, 5);
1140 return value;
1141}
1142
1143
d3605cc0 1144int64 NMD::extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
89a955e8
AM		 1145{
1146 int64 value = 0;
1147 value |= extract_bits(instruction, 2, 6) << 2;
1148 value |= extract_bits(instruction, 15, 1) << 8;
1149 value = sign_extend(value, 8);
1150 return value;
1151}
1152
1153
1154uint64 NMD::extract_u_15_to_0(uint64 instruction)
1155{
1156 uint64 value = 0;
1157 value |= extract_bits(instruction, 0, 16);
1158 return value;
1159}
1160
1161
52a96d22 1162uint64 NMD::extract_fs_20_19_18_17_16(uint64 instruction)
89a955e8
AM		 1163{
1164 uint64 value = 0;
1165 value |= extract_bits(instruction, 16, 5);
1166 return value;
1167}
1168
1169
d3605cc0 1170int64 NMD::extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
89a955e8
AM		 1171{
1172 int64 value = 0;
1173 value |= extract_bits(instruction, 0, 8);
1174 value |= extract_bits(instruction, 15, 1) << 8;
1175 value = sign_extend(value, 8);
1176 return value;
1177}
1178
1179
1180uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
1181{
1182 uint64 value = 0;
1183 value |= extract_bits(instruction, 16, 5);
1184 return value;
1185}
1186
1187
1188uint64 NMD::extract_rtl_11(uint64 instruction)
1189{
1190 uint64 value = 0;
1191 value |= extract_bits(instruction, 9, 1);
1192 return value;
1193}
1194
1195
1196uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
1197{
1198 uint64 value = 0;
1199 value |= extract_bits(instruction, 16, 5);
1200 return value;
1201}
1202
1203
89a955e8
AM		 1204uint64 NMD::extract_sel_13_12_11(uint64 instruction)
1205{
1206 uint64 value = 0;
1207 value |= extract_bits(instruction, 11, 3);
1208 return value;
1209}
1210
1211
1212uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
1213{
1214 uint64 value = 0;
1215 value |= extract_bits(instruction, 0, 5);
1216 return value;
1217}
1218
1219
89a955e8
AM		 1220uint64 NMD::extract_gp_2(uint64 instruction)
1221{
1222 uint64 value = 0;
1223 value |= extract_bits(instruction, 2, 1);
1224 return value;
1225}
1226
1227
1228uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
1229{
1230 uint64 value = 0;
1231 value |= extract_bits(instruction, 7, 3);
1232 return value;
1233}
1234
1235
17ce2f00 1236uint64 NMD::extract_ft_25_24_23_22_21(uint64 instruction)
89a955e8
AM		 1237{
1238 uint64 value = 0;
1239 value |= extract_bits(instruction, 21, 5);
1240 return value;
1241}
1242
1243
1244uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
1245{
1246 uint64 value = 0;
1247 value |= extract_bits(instruction, 11, 7);
1248 return value;
1249}
1250
1251
1252uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
1253{
1254 uint64 value = 0;
1255 value |= extract_bits(instruction, 16, 5);
1256 return value;
1257}
1258
1259
89a955e8
AM		 1260uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
1261{
1262 uint64 value = 0;
1263 value |= extract_bits(instruction, 5, 3);
1264 value |= extract_bits(instruction, 9, 1) << 3;
1265 return value;
1266}
1267
1268
1269uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
1270{
1271 uint64 value = 0;
1272 value |= extract_bits(instruction, 6, 5);
1273 return value;
1274}
1275
1276
11b9732a 1277uint64 NMD::extract_u_5_4_3_2_1_0__s2(uint64 instruction)
89a955e8
AM		 1278{
1279 uint64 value = 0;
1280 value |= extract_bits(instruction, 0, 6) << 2;
1281 return value;
1282}
1283
1284
89a955e8
AM		 1285uint64 NMD::extract_sa_15_14_13(uint64 instruction)
1286{
1287 uint64 value = 0;
1288 value |= extract_bits(instruction, 13, 3);
1289 return value;
1290}
1291
1292
d3605cc0 1293int64 NMD::extract_s__se14_0_13_to_1_s1(uint64 instruction)
89a955e8
AM		 1294{
1295 int64 value = 0;
1296 value |= extract_bits(instruction, 0, 1) << 14;
1297 value |= extract_bits(instruction, 1, 13) << 1;
1298 value = sign_extend(value, 14);
1299 return value;
1300}
1301
1302
1303uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
1304{
1305 uint64 value = 0;
1306 value |= extract_bits(instruction, 4, 3);
1307 return value;
1308}
1309
1310
11b9732a 1311uint64 NMD::extract_u_31_to_0__s32(uint64 instruction)
89a955e8
AM		 1312{
1313 uint64 value = 0;
1314 value |= extract_bits(instruction, 0, 32) << 32;
1315 return value;
1316}
1317
1318
1319uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
1320{
1321 uint64 value = 0;
1322 value |= extract_bits(instruction, 6, 5);
1323 return value;
1324}
1325
1326
1327uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
1328{
1329 uint64 value = 0;
1330 value |= extract_bits(instruction, 21, 5);
1331 return value;
1332}
1333
1334
1335uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1336{
1337 uint64 value = 0;
1338 value |= extract_bits(instruction, 6, 6);
1339 return value;
1340}
1341
1342
1343uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
1344{
1345 uint64 value = 0;
1346 value |= extract_bits(instruction, 5, 5);
1347 return value;
1348}
1349
1350
1351uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
1352{
1353 uint64 value = 0;
1354 value |= extract_bits(instruction, 21, 5);
1355 return value;
1356}
1357
1358
11b9732a 1359uint64 NMD::extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
89a955e8
AM		 1360{
1361 uint64 value = 0;
1362 value |= extract_bits(instruction, 0, 7) << 2;
1363 return value;
1364}
1365
1366
1367uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
1368{
1369 uint64 value = 0;
1370 value |= extract_bits(instruction, 11, 6);
1371 return value;
1372}
1373
1374
89a955e8
AM		 1375uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1376{
1377 uint64 value = 0;
1378 value |= extract_bits(instruction, 14, 7);
1379 return value;
1380}
1381
1382
1383uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
1384{
1385 uint64 value = 0;
1386 value |= extract_bits(instruction, 0, 4);
1387 return value;
1388}
1389
1390
11b9732a 1391uint64 NMD::extract_u_7_6_5_4__s4(uint64 instruction)
89a955e8
AM		 1392{
1393 uint64 value = 0;
1394 value |= extract_bits(instruction, 4, 4) << 4;
1395 return value;
1396}
1397
1398
d3605cc0 1399int64 NMD::extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
89a955e8
AM		 1400{
1401 int64 value = 0;
1402 value |= extract_bits(instruction, 3, 5) << 3;
1403 value |= extract_bits(instruction, 15, 1) << 8;
1404 value = sign_extend(value, 8);
1405 return value;
1406}
1407
1408
1409uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
1410{
1411 uint64 value = 0;
1412 value |= extract_bits(instruction, 11, 5);
1413 return value;
1414}
1415
1416
d3605cc0 1417int64 NMD::extract_s__se31_15_to_0_31_to_16(uint64 instruction)
89a955e8
AM		 1418{
1419 int64 value = 0;
1420 value |= extract_bits(instruction, 0, 16) << 16;
1421 value |= extract_bits(instruction, 16, 16);
1422 value = sign_extend(value, 31);
1423 return value;
1424}
1425
1426
1427uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1428{
1429 uint64 value = 0;
1430 value |= extract_bits(instruction, 13, 8);
1431 return value;
1432}
1433
1434
11b9732a 1435uint64 NMD::extract_u_17_to_2__s2(uint64 instruction)
89a955e8
AM		 1436{
1437 uint64 value = 0;
1438 value |= extract_bits(instruction, 2, 16) << 2;
1439 return value;
1440}
1441
1442
b4c5d21c 1443uint64 NMD::extract_rd_15_14_13_12_11(uint64 instruction)
89a955e8
AM		 1444{
1445 uint64 value = 0;
1446 value |= extract_bits(instruction, 11, 5);
1447 return value;
1448}
1449
1450
1451uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
1452{
1453 uint64 value = 0;
1454 value |= extract_bits(instruction, 16, 5);
1455 return value;
1456}
1457
1458
1459uint64 NMD::extract_code_1_0(uint64 instruction)
1460{
1461 uint64 value = 0;
1462 value |= extract_bits(instruction, 0, 2);
1463 return value;
1464}
1465
1466
d3605cc0 1467int64 NMD::extract_s__se25_0_24_to_1_s1(uint64 instruction)
89a955e8
AM		 1468{
1469 int64 value = 0;
1470 value |= extract_bits(instruction, 0, 1) << 25;
1471 value |= extract_bits(instruction, 1, 24) << 1;
1472 value = sign_extend(value, 25);
1473 return value;
1474}
1475
1476
89a955e8
AM		 1477uint64 NMD::extract_u_1_0(uint64 instruction)
1478{
1479 uint64 value = 0;
1480 value |= extract_bits(instruction, 0, 2);
1481 return value;
1482}
1483
1484
11b9732a 1485uint64 NMD::extract_u_3_8__s2(uint64 instruction)
89a955e8
AM		 1486{
1487 uint64 value = 0;
1488 value |= extract_bits(instruction, 3, 1) << 3;
1489 value |= extract_bits(instruction, 8, 1) << 2;
1490 return value;
1491}
1492
1493
d0c60abd 1494uint64 NMD::extract_fd_15_14_13_12_11(uint64 instruction)
89a955e8
AM		 1495{
1496 uint64 value = 0;
1497 value |= extract_bits(instruction, 11, 5);
1498 return value;
1499}
1500
1501
11b9732a 1502uint64 NMD::extract_u_4_3_2_1_0__s2(uint64 instruction)
89a955e8
AM		 1503{
1504 uint64 value = 0;
1505 value |= extract_bits(instruction, 0, 5) << 2;
1506 return value;
1507}
1508
1509
1510uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
1511{
1512 uint64 value = 0;
1513 value |= extract_bits(instruction, 5, 3);
1514 value |= extract_bits(instruction, 9, 1) << 3;
1515 return value;
1516}
1517
1518
1519uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
1520{
1521 uint64 value = 0;
1522 value |= extract_bits(instruction, 11, 5);
1523 return value;
1524}
1525
1526
1527uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
1528{
1529 uint64 value = 0;
1530 value |= extract_bits(instruction, 21, 5);
1531 return value;
1532}
1533
1534
11b9732a 1535uint64 NMD::extract_u_20_to_2__s2(uint64 instruction)
89a955e8
AM		 1536{
1537 uint64 value = 0;
1538 value |= extract_bits(instruction, 2, 19) << 2;
1539 return value;
1540}
1541
1542
d3605cc0 1543int64 NMD::extract_s__se3_4_2_1_0(uint64 instruction)
89a955e8
AM		 1544{
1545 int64 value = 0;
1546 value |= extract_bits(instruction, 0, 3);
1547 value |= extract_bits(instruction, 4, 1) << 3;
1548 value = sign_extend(value, 3);
1549 return value;
1550}
1551
1552
11b9732a 1553uint64 NMD::extract_u_3_2_1_0__s1(uint64 instruction)
89a955e8
AM		 1554{
1555 uint64 value = 0;
1556 value |= extract_bits(instruction, 0, 4) << 1;
1557 return value;
1558}
1559
1560
89a955e8
AM		 1561
1562bool NMD::ADDIU_32__cond(uint64 instruction)
1563{
1564 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1565 return rt != 0;
1566}
1567
1568
1569bool NMD::ADDIU_RS5__cond(uint64 instruction)
1570{
1571 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1572 return rt != 0;
1573}
1574
1575
1576bool NMD::BALRSC_cond(uint64 instruction)
1577{
1578 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1579 return rt != 0;
1580}
1581
1582
1583bool NMD::BEQC_16__cond(uint64 instruction)
1584{
1585 uint64 rs3 = extract_rs3_6_5_4(instruction);
1586 uint64 rt3 = extract_rt3_9_8_7(instruction);
11b9732a 1587 uint64 u = extract_u_3_2_1_0__s1(instruction);
89a955e8
AM		 1588 return rs3 < rt3 && u != 0;
1589}
1590
1591
1592bool NMD::BNEC_16__cond(uint64 instruction)
1593{
1594 uint64 rs3 = extract_rs3_6_5_4(instruction);
1595 uint64 rt3 = extract_rt3_9_8_7(instruction);
11b9732a 1596 uint64 u = extract_u_3_2_1_0__s1(instruction);
89a955e8
AM		 1597 return rs3 >= rt3 && u != 0;
1598}
1599
1600
1601bool NMD::MOVE_cond(uint64 instruction)
1602{
1603 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1604 return rt != 0;
1605}
1606
1607
1608bool NMD::P16_BR1_cond(uint64 instruction)
1609{
11b9732a 1610 uint64 u = extract_u_3_2_1_0__s1(instruction);
89a955e8
AM		 1611 return u != 0;
1612}
1613
1614
1615bool NMD::PREF_S9__cond(uint64 instruction)
1616{
1617 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1618 return hint != 31;
1619}
1620
1621
1622bool NMD::PREFE_cond(uint64 instruction)
1623{
1624 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1625 return hint != 31;
1626}
1627
1628
1629bool NMD::SLTU_cond(uint64 instruction)
1630{
b4c5d21c 1631 uint64 rd = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 1632 return rd != 0;
1633}
1634
1635
1636
1637/*
1638 * ABS.D fd, fs - Floating Point Absolute Value
1639 *
1640 * 3 2 1
1641 * 10987654321098765432109876543210
1642 * 010001 00000 000101
1643 * fmt -----
1644 * fs -----
1645 * fd -----
1646 */
1647std::string NMD::ABS_D(uint64 instruction)
1648{
17ce2f00 1649 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 1650 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 1651
1652 std::string fs = FPR(copy(fs_value));
1653 std::string fd = FPR(copy(fd_value));
1654
1655 return img::format("ABS.D %s, %s", fd, fs);
1656}
1657
1658
1659/*
1660 * ABS.S fd, fs - Floating Point Absolute Value
1661 *
1662 * 3 2 1
1663 * 10987654321098765432109876543210
1664 * 010001 00000 000101
1665 * fmt -----
1666 * fd -----
1667 * fs -----
1668 */
1669std::string NMD::ABS_S(uint64 instruction)
1670{
17ce2f00 1671 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 1672 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 1673
1674 std::string fs = FPR(copy(fs_value));
1675 std::string fd = FPR(copy(fd_value));
1676
1677 return img::format("ABS.S %s, %s", fd, fs);
1678}
1679
1680
1681/*
1682 * ABSQ_S.PH rt, rs - Find Absolute Value of Two Fractional Halfwords
1683 *
1684 * 3 2 1
1685 * 10987654321098765432109876543210
1686 * 001000 0001000100111111
1687 * rt -----
1688 * rs -----
1689 */
1690std::string NMD::ABSQ_S_PH(uint64 instruction)
1691{
1692 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1693 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1694
1695 std::string rt = GPR(copy(rt_value));
1696 std::string rs = GPR(copy(rs_value));
1697
1698 return img::format("ABSQ_S.PH %s, %s", rt, rs);
1699}
1700
1701
1702/*
1703 * ABSQ_S.QB rt, rs - Find Absolute Value of Four Fractional Byte Values
1704 *
1705 * 3 2 1
1706 * 10987654321098765432109876543210
1707 * 001000 0000000100111111
1708 * rt -----
1709 * rs -----
1710 */
1711std::string NMD::ABSQ_S_QB(uint64 instruction)
1712{
1713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1714 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1715
1716 std::string rt = GPR(copy(rt_value));
1717 std::string rs = GPR(copy(rs_value));
1718
1719 return img::format("ABSQ_S.QB %s, %s", rt, rs);
1720}
1721
1722
1723/*
1724 *
1725 *
1726 * 3 2 1
1727 * 10987654321098765432109876543210
1728 * 001000 0010000100111111
1729 * rt -----
1730 * rs -----
1731 */
1732std::string NMD::ABSQ_S_W(uint64 instruction)
1733{
1734 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1735 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1736
1737 std::string rt = GPR(copy(rt_value));
1738 std::string rs = GPR(copy(rs_value));
1739
1740 return img::format("ABSQ_S.W %s, %s", rt, rs);
1741}
1742
1743
1744/*
1745 *
1746 *
1747 * 3 2 1
1748 * 10987654321098765432109876543210
1749 * 001000 0010000100111111
1750 * rt -----
1751 * rs -----
1752 */
1753std::string NMD::ACLR(uint64 instruction)
1754{
1755 uint64 bit_value = extract_bit_23_22_21(instruction);
89a955e8 1756 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 1757 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 1758
1759 std::string bit = IMMEDIATE(copy(bit_value));
1760 std::string s = IMMEDIATE(copy(s_value));
1761 std::string rs = GPR(copy(rs_value));
1762
1763 return img::format("ACLR %s, %s(%s)", bit, s, rs);
1764}
1765
1766
1767/*
1768 *
1769 *
1770 * 3 2 1
1771 * 10987654321098765432109876543210
1772 * 001000 0010000100111111
1773 * rt -----
1774 * rs -----
1775 */
1776std::string NMD::ADD(uint64 instruction)
1777{
1778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 1779 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 1780 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 1781
1782 std::string rd = GPR(copy(rd_value));
1783 std::string rs = GPR(copy(rs_value));
1784 std::string rt = GPR(copy(rt_value));
1785
1786 return img::format("ADD %s, %s, %s", rd, rs, rt);
1787}
1788
1789
1790/*
1791 * ADD.D fd, fs, ft - Floating Point Add
1792 *
1793 * 3 2 1
1794 * 10987654321098765432109876543210
1795 * 010001 000101
1796 * fmt -----
1797 * ft -----
1798 * fs -----
1799 * fd -----
1800 */
1801std::string NMD::ADD_D(uint64 instruction)
1802{
17ce2f00 1803 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 1804 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 1805 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 1806
1807 std::string ft = FPR(copy(ft_value));
1808 std::string fs = FPR(copy(fs_value));
1809 std::string fd = FPR(copy(fd_value));
1810
1811 return img::format("ADD.D %s, %s, %s", fd, fs, ft);
1812}
1813
1814
1815/*
1816 * ADD.S fd, fs, ft - Floating Point Add
1817 *
1818 * 3 2 1
1819 * 10987654321098765432109876543210
1820 * 010001 000101
1821 * fmt -----
1822 * ft -----
1823 * fs -----
1824 * fd -----
1825 */
1826std::string NMD::ADD_S(uint64 instruction)
1827{
17ce2f00 1828 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 1829 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 1830 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 1831
1832 std::string ft = FPR(copy(ft_value));
1833 std::string fs = FPR(copy(fs_value));
1834 std::string fd = FPR(copy(fd_value));
1835
1836 return img::format("ADD.S %s, %s, %s", fd, fs, ft);
1837}
1838
1839
1840/*
1841 *
1842 *
1843 * 3 2 1
1844 * 10987654321098765432109876543210
1845 * 001000 0010000100111111
1846 * rt -----
1847 * rs -----
1848 */
1849std::string NMD::ADDIU_32_(uint64 instruction)
1850{
1851 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 1852 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 1853 uint64 u_value = extract_u_15_to_0(instruction);
89a955e8
AM		 1854
1855 std::string rt = GPR(copy(rt_value));
1856 std::string rs = GPR(copy(rs_value));
1857 std::string u = IMMEDIATE(copy(u_value));
1858
1859 return img::format("ADDIU %s, %s, %s", rt, rs, u);
1860}
1861
1862
1863/*
1864 *
1865 *
1866 * 3 2 1
1867 * 10987654321098765432109876543210
1868 * 001000 0010000100111111
1869 * rt -----
1870 * rs -----
1871 */
1872std::string NMD::ADDIU_48_(uint64 instruction)
1873{
1874 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 1875 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 1876
1877 std::string rt = GPR(copy(rt_value));
1878 std::string s = IMMEDIATE(copy(s_value));
1879
1880 return img::format("ADDIU %s, %s", rt, s);
1881}
1882
1883
1884/*
1885 *
1886 *
1887 * 3 2 1
1888 * 10987654321098765432109876543210
1889 * 001000 0010000100111111
1890 * rt -----
1891 * rs -----
1892 */
1893std::string NMD::ADDIU_GP48_(uint64 instruction)
1894{
1895 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 1896 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 1897
1898 std::string rt = GPR(copy(rt_value));
1899 std::string s = IMMEDIATE(copy(s_value));
1900
1901 return img::format("ADDIU %s, $%d, %s", rt, 28, s);
1902}
1903
1904
1905/*
1906 *
1907 *
1908 * 3 2 1
1909 * 10987654321098765432109876543210
1910 * 001000 0010000100111111
1911 * rt -----
1912 * rs -----
1913 */
1914std::string NMD::ADDIU_GP_B_(uint64 instruction)
1915{
1916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1917 uint64 u_value = extract_u_17_to_0(instruction);
1918
1919 std::string rt = GPR(copy(rt_value));
1920 std::string u = IMMEDIATE(copy(u_value));
1921
1922 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
1923}
1924
1925
1926/*
1927 *
1928 *
1929 * 3 2 1
1930 * 10987654321098765432109876543210
1931 * 001000 0010000100111111
1932 * rt -----
1933 * rs -----
1934 */
1935std::string NMD::ADDIU_GP_W_(uint64 instruction)
1936{
1937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 1938 uint64 u_value = extract_u_20_to_2__s2(instruction);
89a955e8
AM		 1939
1940 std::string rt = GPR(copy(rt_value));
1941 std::string u = IMMEDIATE(copy(u_value));
1942
1943 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
1944}
1945
1946
1947/*
1948 *
1949 *
1950 * 3 2 1
1951 * 10987654321098765432109876543210
1952 * 001000 0010000100111111
1953 * rt -----
1954 * rs -----
1955 */
1956std::string NMD::ADDIU_NEG_(uint64 instruction)
1957{
1958 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 1959 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 1960 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 1961
1962 std::string rt = GPR(copy(rt_value));
1963 std::string rs = GPR(copy(rs_value));
1964 std::string u = IMMEDIATE(neg_copy(u_value));
1965
1966 return img::format("ADDIU %s, %s, %s", rt, rs, u);
1967}
1968
1969
1970/*
1971 *
1972 *
1973 * 3 2 1
1974 * 10987654321098765432109876543210
1975 * 001000 0010000100111111
1976 * rt -----
1977 * rs -----
1978 */
1979std::string NMD::ADDIU_R1_SP_(uint64 instruction)
1980{
11b9732a 1981 uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
89a955e8
AM		 1982 uint64 rt3_value = extract_rt3_9_8_7(instruction);
1983
988d6c89 1984 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 1985 std::string u = IMMEDIATE(copy(u_value));
1986
1987 return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
1988}
1989
1990
1991/*
1992 *
1993 *
1994 * 3 2 1
1995 * 10987654321098765432109876543210
1996 * 001000 0010000100111111
1997 * rt -----
1998 * rs -----
1999 */
2000std::string NMD::ADDIU_R2_(uint64 instruction)
2001{
89a955e8
AM		 2002 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2003 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 2004 uint64 u_value = extract_u_2_1_0__s2(instruction);
89a955e8 2005
988d6c89
AM		 2006 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2007 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 2008 std::string u = IMMEDIATE(copy(u_value));
2009
2010 return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
2011}
2012
2013
2014/*
2015 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
2016 *
2017 * 5432109876543210
2018 * 100100 1
2019 * rt -----
2020 * s - ---
2021 */
2022std::string NMD::ADDIU_RS5_(uint64 instruction)
2023{
2024 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
d3605cc0 2025 int64 s_value = extract_s__se3_4_2_1_0(instruction);
89a955e8
AM		 2026
2027 std::string rt = GPR(copy(rt_value));
2028 std::string s = IMMEDIATE(copy(s_value));
2029
2030 return img::format("ADDIU %s, %s", rt, s);
2031}
2032
2033
2034/*
2035 *
2036 *
2037 * 3 2 1
2038 * 10987654321098765432109876543210
2039 * 001000 x1110000101
2040 * rt -----
2041 * rs -----
2042 * rd -----
2043 */
2044std::string NMD::ADDIUPC_32_(uint64 instruction)
2045{
2046 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
d3605cc0 2047 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
89a955e8
AM		 2048
2049 std::string rt = GPR(copy(rt_value));
2050 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2051
2052 return img::format("ADDIUPC %s, %s", rt, s);
2053}
2054
2055
2056/*
2057 *
2058 *
2059 * 3 2 1
2060 * 10987654321098765432109876543210
2061 * 001000 x1110000101
2062 * rt -----
2063 * rs -----
2064 * rd -----
2065 */
2066std::string NMD::ADDIUPC_48_(uint64 instruction)
2067{
2068 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 2069 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 2070
2071 std::string rt = GPR(copy(rt_value));
2072 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
2073
2074 return img::format("ADDIUPC %s, %s", rt, s);
2075}
2076
2077
2078/*
2079 * ADDQ.PH rd, rt, rs - Add Fractional Halfword Vectors
2080 *
2081 * 3 2 1
2082 * 10987654321098765432109876543210
2083 * 001000 00000001101
2084 * rt -----
2085 * rs -----
2086 * rd -----
2087 */
2088std::string NMD::ADDQ_PH(uint64 instruction)
2089{
2090 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2091 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2092 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2093
2094 std::string rd = GPR(copy(rd_value));
2095 std::string rs = GPR(copy(rs_value));
2096 std::string rt = GPR(copy(rt_value));
2097
2098 return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
2099}
2100
2101
2102/*
2103 * ADDQ_S.PH rd, rt, rs - Add Fractional Halfword Vectors
2104 *
2105 * 3 2 1
2106 * 10987654321098765432109876543210
2107 * 001000 10000001101
2108 * rt -----
2109 * rs -----
2110 * rd -----
2111 */
2112std::string NMD::ADDQ_S_PH(uint64 instruction)
2113{
2114 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2115 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2116 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2117
2118 std::string rd = GPR(copy(rd_value));
2119 std::string rs = GPR(copy(rs_value));
2120 std::string rt = GPR(copy(rt_value));
2121
2122 return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
2123}
2124
2125
2126/*
2127 * ADDQ_S.W rd, rt, rs - Add Fractional Words
2128 *
2129 * 3 2 1
2130 * 10987654321098765432109876543210
2131 * 001000 x1100000101
2132 * rt -----
2133 * rs -----
2134 * rd -----
2135 */
2136std::string NMD::ADDQ_S_W(uint64 instruction)
2137{
2138 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2139 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2140 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2141
2142 std::string rd = GPR(copy(rd_value));
2143 std::string rs = GPR(copy(rs_value));
2144 std::string rt = GPR(copy(rt_value));
2145
2146 return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2147}
2148
2149
2150/*
2151 * ADDQH.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2152 * to Halve Results
2153 *
2154 * 3 2 1
2155 * 10987654321098765432109876543210
2156 * 001000 00001001101
2157 * rt -----
2158 * rs -----
2159 * rd -----
2160 */
2161std::string NMD::ADDQH_PH(uint64 instruction)
2162{
2163 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2164 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2165 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2166
2167 std::string rd = GPR(copy(rd_value));
2168 std::string rs = GPR(copy(rs_value));
2169 std::string rt = GPR(copy(rt_value));
2170
2171 return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2172}
2173
2174
2175/*
2176 * ADDQH_R.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2177 * to Halve Results
2178 *
2179 * 3 2 1
2180 * 10987654321098765432109876543210
2181 * 001000 10001001101
2182 * rt -----
2183 * rs -----
2184 * rd -----
2185 */
2186std::string NMD::ADDQH_R_PH(uint64 instruction)
2187{
2188 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2190 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2191
2192 std::string rd = GPR(copy(rd_value));
2193 std::string rs = GPR(copy(rs_value));
2194 std::string rt = GPR(copy(rt_value));
2195
2196 return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2197}
2198
2199
2200/*
2201 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2202 *
2203 * 3 2 1
2204 * 10987654321098765432109876543210
2205 * 001000 00010001101
2206 * rt -----
2207 * rs -----
2208 * rd -----
2209 */
2210std::string NMD::ADDQH_R_W(uint64 instruction)
2211{
2212 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2214 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2215
2216 std::string rd = GPR(copy(rd_value));
2217 std::string rs = GPR(copy(rs_value));
2218 std::string rt = GPR(copy(rt_value));
2219
2220 return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2221}
2222
2223
2224/*
2225 * ADDQH.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2226 *
2227 * 3 2 1
2228 * 10987654321098765432109876543210
2229 * 001000 10010001101
2230 * rt -----
2231 * rs -----
2232 * rd -----
2233 */
2234std::string NMD::ADDQH_W(uint64 instruction)
2235{
2236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2238 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2239
2240 std::string rd = GPR(copy(rd_value));
2241 std::string rs = GPR(copy(rs_value));
2242 std::string rt = GPR(copy(rt_value));
2243
2244 return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
2245}
2246
2247
2248/*
2249 * ADDSC rd, rt, rs - Add Signed Word and Set Carry Bit
2250 *
2251 * 3 2 1
2252 * 10987654321098765432109876543210
2253 * 001000 x1110000101
2254 * rt -----
2255 * rs -----
2256 * rd -----
2257 */
2258std::string NMD::ADDSC(uint64 instruction)
2259{
2260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2261 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2262 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2263
2264 std::string rd = GPR(copy(rd_value));
2265 std::string rs = GPR(copy(rs_value));
2266 std::string rt = GPR(copy(rt_value));
2267
2268 return img::format("ADDSC %s, %s, %s", rd, rs, rt);
2269}
2270
2271
2272/*
2273 * ADDU[16] rd3, rs3, rt3 -
2274 *
2275 * 5432109876543210
2276 * 101100 0
2277 * rt3 ---
2278 * rs3 ---
2279 * rd3 ---
2280 */
2281std::string NMD::ADDU_16_(uint64 instruction)
2282{
2283 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2284 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2285 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2286
988d6c89
AM		 2287 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2288 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2289 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
89a955e8
AM		 2290
2291 return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
2292}
2293
2294
2295/*
2296 *
2297 *
2298 * 3 2 1
2299 * 10987654321098765432109876543210
2300 * 001000 x1110000101
2301 * rt -----
2302 * rs -----
2303 * rd -----
2304 */
2305std::string NMD::ADDU_32_(uint64 instruction)
2306{
2307 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2308 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2309 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2310
2311 std::string rd = GPR(copy(rd_value));
2312 std::string rs = GPR(copy(rs_value));
2313 std::string rt = GPR(copy(rt_value));
2314
2315 return img::format("ADDU %s, %s, %s", rd, rs, rt);
2316}
2317
2318
2319/*
2320 *
2321 *
2322 * 3 2 1
2323 * 10987654321098765432109876543210
2324 * 001000 x1110000101
2325 * rt -----
2326 * rs -----
2327 * rd -----
2328 */
2329std::string NMD::ADDU_4X4_(uint64 instruction)
2330{
89a955e8 2331 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
86b5f803 2332 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
89a955e8
AM		 2333
2334 std::string rs4 = GPR(encode_gpr4(rs4_value));
2335 std::string rt4 = GPR(encode_gpr4(rt4_value));
2336
2337 return img::format("ADDU %s, %s", rs4, rt4);
2338}
2339
2340
2341/*
2342 * ADDU.PH rd, rt, rs - Unsigned Add Integer Halfwords
2343 *
2344 * 3 2 1
2345 * 10987654321098765432109876543210
2346 * 001000 00100001101
2347 * rt -----
2348 * rs -----
2349 * rd -----
2350 */
2351std::string NMD::ADDU_PH(uint64 instruction)
2352{
2353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2355 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2356
2357 std::string rd = GPR(copy(rd_value));
2358 std::string rs = GPR(copy(rs_value));
2359 std::string rt = GPR(copy(rt_value));
2360
2361 return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
2362}
2363
2364
2365/*
2366 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2367 *
2368 * 3 2 1
2369 * 10987654321098765432109876543210
2370 * 001000 00011001101
2371 * rt -----
2372 * rs -----
2373 * rd -----
2374 */
2375std::string NMD::ADDU_QB(uint64 instruction)
2376{
2377 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2378 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2379 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2380
2381 std::string rd = GPR(copy(rd_value));
2382 std::string rs = GPR(copy(rs_value));
2383 std::string rt = GPR(copy(rt_value));
2384
2385 return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
2386}
2387
2388
2389/*
2390 * ADDU_S.PH rd, rt, rs - Unsigned Add Integer Halfwords
2391 *
2392 * 3 2 1
2393 * 10987654321098765432109876543210
2394 * 001000 10100001101
2395 * rt -----
2396 * rs -----
2397 * rd -----
2398 */
2399std::string NMD::ADDU_S_PH(uint64 instruction)
2400{
2401 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2402 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2403 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2404
2405 std::string rd = GPR(copy(rd_value));
2406 std::string rs = GPR(copy(rs_value));
2407 std::string rt = GPR(copy(rt_value));
2408
2409 return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2410}
2411
2412
2413/*
2414 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2415 *
2416 * 3 2 1
2417 * 10987654321098765432109876543210
2418 * 001000 10011001101
2419 * rt -----
2420 * rs -----
2421 * rd -----
2422 */
2423std::string NMD::ADDU_S_QB(uint64 instruction)
2424{
2425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2426 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2427 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2428
2429 std::string rd = GPR(copy(rd_value));
2430 std::string rs = GPR(copy(rs_value));
2431 std::string rt = GPR(copy(rt_value));
2432
2433 return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2434}
2435
2436
2437/*
2438 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2439 * to Halve Results
2440 *
2441 * 3 2 1
2442 * 10987654321098765432109876543210
2443 * 001000 00101001101
2444 * rt -----
2445 * rs -----
2446 * rd -----
2447 */
2448std::string NMD::ADDUH_QB(uint64 instruction)
2449{
2450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2452 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2453
2454 std::string rd = GPR(copy(rd_value));
2455 std::string rs = GPR(copy(rs_value));
2456 std::string rt = GPR(copy(rt_value));
2457
2458 return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2459}
2460
2461
2462/*
2463 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2464 * to Halve Results
2465 *
2466 * 3 2 1
2467 * 10987654321098765432109876543210
2468 * 001000 10101001101
2469 * rt -----
2470 * rs -----
2471 * rd -----
2472 */
2473std::string NMD::ADDUH_R_QB(uint64 instruction)
2474{
2475 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2476 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2477 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2478
2479 std::string rd = GPR(copy(rd_value));
2480 std::string rs = GPR(copy(rs_value));
2481 std::string rt = GPR(copy(rt_value));
2482
2483 return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2484}
2485
2486/*
2487 * ADDWC rd, rt, rs - Add Word with Carry Bit
2488 *
2489 * 3 2 1
2490 * 10987654321098765432109876543210
2491 * 001000 x1111000101
2492 * rt -----
2493 * rs -----
2494 * rd -----
2495 */
2496std::string NMD::ADDWC(uint64 instruction)
2497{
2498 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2499 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2500 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2501
2502 std::string rd = GPR(copy(rd_value));
2503 std::string rs = GPR(copy(rs_value));
2504 std::string rt = GPR(copy(rt_value));
2505
2506 return img::format("ADDWC %s, %s, %s", rd, rs, rt);
2507}
2508
2509
2510/*
2511 *
2512 *
2513 * 3 2 1
2514 * 10987654321098765432109876543210
2515 * 001000 x1110000101
2516 * rt -----
2517 * rs -----
2518 * rd -----
2519 */
2520std::string NMD::ALUIPC(uint64 instruction)
2521{
2522 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
d3605cc0 2523 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
89a955e8
AM		 2524
2525 std::string rt = GPR(copy(rt_value));
2526 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2527
2528 return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2529}
2530
2531
2532/*
2533 * AND[16] rt3, rs3 -
2534 *
2535 * 5432109876543210
2536 * 101100
2537 * rt3 ---
2538 * rs3 ---
2539 * eu ----
2540 */
2541std::string NMD::AND_16_(uint64 instruction)
2542{
2543 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2544 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2545
988d6c89
AM		 2546 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2547 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 2548
2549 return img::format("AND %s, %s", rs3, rt3);
2550}
2551
2552
2553/*
2554 *
2555 *
2556 * 3 2 1
2557 * 10987654321098765432109876543210
2558 * 001000 x1110000101
2559 * rt -----
2560 * rs -----
2561 * rd -----
2562 */
2563std::string NMD::AND_32_(uint64 instruction)
2564{
2565 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2566 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2567 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 2568
2569 std::string rd = GPR(copy(rd_value));
2570 std::string rs = GPR(copy(rs_value));
2571 std::string rt = GPR(copy(rt_value));
2572
2573 return img::format("AND %s, %s, %s", rd, rs, rt);
2574}
2575
2576
2577/*
2578 * ANDI rt, rs, u -
2579 *
2580 * 5432109876543210
2581 * 101100
2582 * rt3 ---
2583 * rs3 ---
2584 * eu ----
2585 */
2586std::string NMD::ANDI_16_(uint64 instruction)
2587{
2588 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2589 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2590 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2591
988d6c89
AM		 2592 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2593 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 2594 std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
2595
2596 return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
2597}
2598
2599
2600/*
2601 *
2602 *
2603 * 3 2 1
2604 * 10987654321098765432109876543210
2605 * 001000 x1110000101
2606 * rt -----
2607 * rs -----
2608 * rd -----
2609 */
2610std::string NMD::ANDI_32_(uint64 instruction)
2611{
2612 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2613 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2614 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 2615
2616 std::string rt = GPR(copy(rt_value));
2617 std::string rs = GPR(copy(rs_value));
2618 std::string u = IMMEDIATE(copy(u_value));
2619
2620 return img::format("ANDI %s, %s, %s", rt, rs, u);
2621}
2622
2623
2624/*
2625 *
2626 *
2627 * 3 2 1
2628 * 10987654321098765432109876543210
2629 * 001000 x1110000101
2630 * rt -----
2631 * rs -----
2632 * rd -----
2633 */
2634std::string NMD::APPEND(uint64 instruction)
2635{
2636 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2637 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 2638 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 2639
2640 std::string rt = GPR(copy(rt_value));
2641 std::string rs = GPR(copy(rs_value));
2642 std::string sa = IMMEDIATE(copy(sa_value));
2643
2644 return img::format("APPEND %s, %s, %s", rt, rs, sa);
2645}
2646
2647
2648/*
2649 *
2650 *
2651 * 3 2 1
2652 * 10987654321098765432109876543210
2653 * 001000 x1110000101
2654 * rt -----
2655 * rs -----
2656 * rd -----
2657 */
2658std::string NMD::ASET(uint64 instruction)
2659{
2660 uint64 bit_value = extract_bit_23_22_21(instruction);
89a955e8 2661 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 2662 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 2663
2664 std::string bit = IMMEDIATE(copy(bit_value));
2665 std::string s = IMMEDIATE(copy(s_value));
2666 std::string rs = GPR(copy(rs_value));
2667
2668 return img::format("ASET %s, %s(%s)", bit, s, rs);
2669}
2670
2671
2672/*
2673 *
2674 *
2675 * 3 2 1
2676 * 10987654321098765432109876543210
2677 * 001000 x1110000101
2678 * rt -----
2679 * rs -----
2680 * rd -----
2681 */
2682std::string NMD::BALC_16_(uint64 instruction)
2683{
d3605cc0 2684 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
89a955e8
AM		 2685
2686 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2687
2688 return img::format("BALC %s", s);
2689}
2690
2691
2692/*
2693 *
2694 *
2695 * 3 2 1
2696 * 10987654321098765432109876543210
2697 * 001000 x1110000101
2698 * rt -----
2699 * rs -----
2700 * rd -----
2701 */
2702std::string NMD::BALC_32_(uint64 instruction)
2703{
d3605cc0 2704 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
89a955e8
AM		 2705
2706 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2707
2708 return img::format("BALC %s", s);
2709}
2710
2711
2712/*
2713 *
2714 *
2715 * 3 2 1
2716 * 10987654321098765432109876543210
2717 * 001000 x1110000101
2718 * rt -----
2719 * rs -----
2720 * rd -----
2721 */
2722std::string NMD::BALRSC(uint64 instruction)
2723{
2724 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2725 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2726
2727 std::string rt = GPR(copy(rt_value));
2728 std::string rs = GPR(copy(rs_value));
2729
2730 return img::format("BALRSC %s, %s", rt, rs);
2731}
2732
2733
2734/*
2735 *
2736 *
2737 * 3 2 1
2738 * 10987654321098765432109876543210
2739 * 001000 x1110000101
2740 * rt -----
2741 * rs -----
2742 * rd -----
2743 */
2744std::string NMD::BBEQZC(uint64 instruction)
2745{
2746 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2747 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
d3605cc0 2748 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 2749
2750 std::string rt = GPR(copy(rt_value));
2751 std::string bit = IMMEDIATE(copy(bit_value));
2752 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2753
2754 return img::format("BBEQZC %s, %s, %s", rt, bit, s);
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::BBNEZC(uint64 instruction)
2769{
2770 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2771 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
d3605cc0 2772 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 2773
2774 std::string rt = GPR(copy(rt_value));
2775 std::string bit = IMMEDIATE(copy(bit_value));
2776 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2777
2778 return img::format("BBNEZC %s, %s, %s", rt, bit, s);
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::BC_16_(uint64 instruction)
2793{
d3605cc0 2794 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
89a955e8
AM		 2795
2796 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2797
2798 return img::format("BC %s", s);
2799}
2800
2801
2802/*
2803 *
2804 *
2805 * 3 2 1
2806 * 10987654321098765432109876543210
2807 * 001000 x1110000101
2808 * rt -----
2809 * rs -----
2810 * rd -----
2811 */
2812std::string NMD::BC_32_(uint64 instruction)
2813{
d3605cc0 2814 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
89a955e8
AM		 2815
2816 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2817
2818 return img::format("BC %s", s);
2819}
2820
2821
2822/*
2823 *
2824 *
2825 * 3 2 1
2826 * 10987654321098765432109876543210
2827 * 001000 x1110000101
2828 * rt -----
2829 * rs -----
2830 * rd -----
2831 */
2832std::string NMD::BC1EQZC(uint64 instruction)
2833{
17ce2f00 2834 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
75199b40 2835 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 2836
2837 std::string ft = FPR(copy(ft_value));
2838 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2839
2840 return img::format("BC1EQZC %s, %s", ft, s);
2841}
2842
2843
2844/*
2845 *
2846 *
2847 * 3 2 1
2848 * 10987654321098765432109876543210
2849 * 001000 x1110000101
2850 * rt -----
2851 * rs -----
2852 * rd -----
2853 */
2854std::string NMD::BC1NEZC(uint64 instruction)
2855{
17ce2f00 2856 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
75199b40 2857 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 2858
2859 std::string ft = FPR(copy(ft_value));
2860 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2861
2862 return img::format("BC1NEZC %s, %s", ft, s);
2863}
2864
2865
2866/*
2867 *
2868 *
2869 * 3 2 1
2870 * 10987654321098765432109876543210
2871 * 001000 x1110000101
2872 * rt -----
2873 * rs -----
2874 * rd -----
2875 */
2876std::string NMD::BC2EQZC(uint64 instruction)
2877{
89a955e8 2878 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
75199b40 2879 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 2880
2881 std::string ct = CPR(copy(ct_value));
2882 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2883
2884 return img::format("BC2EQZC %s, %s", ct, s);
2885}
2886
2887
2888/*
2889 *
2890 *
2891 * 3 2 1
2892 * 10987654321098765432109876543210
2893 * 001000 x1110000101
2894 * rt -----
2895 * rs -----
2896 * rd -----
2897 */
2898std::string NMD::BC2NEZC(uint64 instruction)
2899{
89a955e8 2900 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
75199b40 2901 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 2902
2903 std::string ct = CPR(copy(ct_value));
2904 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2905
2906 return img::format("BC2NEZC %s, %s", ct, s);
2907}
2908
2909
2910/*
2911 *
2912 *
2913 * 3 2 1
2914 * 10987654321098765432109876543210
2915 * 001000 x1110000101
2916 * rt -----
2917 * rs -----
2918 * rd -----
2919 */
2920std::string NMD::BEQC_16_(uint64 instruction)
2921{
89a955e8
AM		 2922 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2923 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 2924 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
89a955e8
AM		 2925
2926 std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
988d6c89 2927 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 2928 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
2929
2930 return img::format("BEQC %s, %s, %s", rs3, rt3, u);
2931}
2932
2933
2934/*
2935 *
2936 *
2937 * 3 2 1
2938 * 10987654321098765432109876543210
2939 * 001000 x1110000101
2940 * rt -----
2941 * rs -----
2942 * rd -----
2943 */
2944std::string NMD::BEQC_32_(uint64 instruction)
2945{
2946 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2947 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 2948 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 2949
2950 std::string rs = GPR(copy(rs_value));
2951 std::string rt = GPR(copy(rt_value));
2952 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2953
2954 return img::format("BEQC %s, %s, %s", rs, rt, s);
2955}
2956
2957
2958/*
2959 *
2960 *
2961 * 3 2 1
2962 * 10987654321098765432109876543210
2963 * 001000 x1110000101
2964 * rt -----
2965 * rs -----
2966 * rd -----
2967 */
2968std::string NMD::BEQIC(uint64 instruction)
2969{
2970 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 2971 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 2972 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 2973
2974 std::string rt = GPR(copy(rt_value));
2975 std::string u = IMMEDIATE(copy(u_value));
2976 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2977
2978 return img::format("BEQIC %s, %s, %s", rt, u, s);
2979}
2980
2981
2982/*
2983 *
2984 *
2985 * 3 2 1
2986 * 10987654321098765432109876543210
2987 * 001000 x1110000101
2988 * rt -----
2989 * rs -----
2990 * rd -----
2991 */
2992std::string NMD::BEQZC_16_(uint64 instruction)
2993{
89a955e8 2994 uint64 rt3_value = extract_rt3_9_8_7(instruction);
75199b40 2995 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
89a955e8 2996
988d6c89 2997 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 2998 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2999
3000 return img::format("BEQZC %s, %s", rt3, s);
3001}
3002
3003
3004/*
3005 *
3006 *
3007 * 3 2 1
3008 * 10987654321098765432109876543210
3009 * 001000 x1110000101
3010 * rt -----
3011 * rs -----
3012 * rd -----
3013 */
3014std::string NMD::BGEC(uint64 instruction)
3015{
3016 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3017 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3018 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3019
3020 std::string rs = GPR(copy(rs_value));
3021 std::string rt = GPR(copy(rt_value));
3022 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3023
3024 return img::format("BGEC %s, %s, %s", rs, rt, s);
3025}
3026
3027
3028/*
3029 *
3030 *
3031 * 3 2 1
3032 * 10987654321098765432109876543210
3033 * 001000 x1110000101
3034 * rt -----
3035 * rs -----
3036 * rd -----
3037 */
3038std::string NMD::BGEIC(uint64 instruction)
3039{
3040 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3041 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 3042 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 3043
3044 std::string rt = GPR(copy(rt_value));
3045 std::string u = IMMEDIATE(copy(u_value));
3046 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3047
3048 return img::format("BGEIC %s, %s, %s", rt, u, s);
3049}
3050
3051
3052/*
3053 *
3054 *
3055 * 3 2 1
3056 * 10987654321098765432109876543210
3057 * 001000 x1110000101
3058 * rt -----
3059 * rs -----
3060 * rd -----
3061 */
3062std::string NMD::BGEIUC(uint64 instruction)
3063{
3064 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3065 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 3066 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 3067
3068 std::string rt = GPR(copy(rt_value));
3069 std::string u = IMMEDIATE(copy(u_value));
3070 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3071
3072 return img::format("BGEIUC %s, %s, %s", rt, u, s);
3073}
3074
3075
3076/*
3077 *
3078 *
3079 * 3 2 1
3080 * 10987654321098765432109876543210
3081 * 001000 x1110000101
3082 * rt -----
3083 * rs -----
3084 * rd -----
3085 */
3086std::string NMD::BGEUC(uint64 instruction)
3087{
3088 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3089 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3090 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3091
3092 std::string rs = GPR(copy(rs_value));
3093 std::string rt = GPR(copy(rt_value));
3094 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3095
3096 return img::format("BGEUC %s, %s, %s", rs, rt, s);
3097}
3098
3099
3100/*
3101 *
3102 *
3103 * 3 2 1
3104 * 10987654321098765432109876543210
3105 * 001000 x1110000101
3106 * rt -----
3107 * rs -----
3108 * rd -----
3109 */
3110std::string NMD::BLTC(uint64 instruction)
3111{
3112 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3113 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3114 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3115
3116 std::string rs = GPR(copy(rs_value));
3117 std::string rt = GPR(copy(rt_value));
3118 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3119
3120 return img::format("BLTC %s, %s, %s", rs, rt, s);
3121}
3122
3123
3124/*
3125 *
3126 *
3127 * 3 2 1
3128 * 10987654321098765432109876543210
3129 * 001000 x1110000101
3130 * rt -----
3131 * rs -----
3132 * rd -----
3133 */
3134std::string NMD::BLTIC(uint64 instruction)
3135{
3136 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3137 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 3138 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 3139
3140 std::string rt = GPR(copy(rt_value));
3141 std::string u = IMMEDIATE(copy(u_value));
3142 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3143
3144 return img::format("BLTIC %s, %s, %s", rt, u, s);
3145}
3146
3147
3148/*
3149 *
3150 *
3151 * 3 2 1
3152 * 10987654321098765432109876543210
3153 * 001000 x1110000101
3154 * rt -----
3155 * rs -----
3156 * rd -----
3157 */
3158std::string NMD::BLTIUC(uint64 instruction)
3159{
3160 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3161 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 3162 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 3163
3164 std::string rt = GPR(copy(rt_value));
3165 std::string u = IMMEDIATE(copy(u_value));
3166 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3167
3168 return img::format("BLTIUC %s, %s, %s", rt, u, s);
3169}
3170
3171
3172/*
3173 *
3174 *
3175 * 3 2 1
3176 * 10987654321098765432109876543210
3177 * 001000 x1110000101
3178 * rt -----
3179 * rs -----
3180 * rd -----
3181 */
3182std::string NMD::BLTUC(uint64 instruction)
3183{
3184 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3185 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3186 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3187
3188 std::string rs = GPR(copy(rs_value));
3189 std::string rt = GPR(copy(rt_value));
3190 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3191
3192 return img::format("BLTUC %s, %s, %s", rs, rt, s);
3193}
3194
3195
3196/*
3197 *
3198 *
3199 * 3 2 1
3200 * 10987654321098765432109876543210
3201 * 001000 x1110000101
3202 * rt -----
3203 * rs -----
3204 * rd -----
3205 */
3206std::string NMD::BNEC_16_(uint64 instruction)
3207{
89a955e8
AM		 3208 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3209 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 3210 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
89a955e8
AM		 3211
3212 std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
988d6c89 3213 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 3214 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3215
3216 return img::format("BNEC %s, %s, %s", rs3, rt3, u);
3217}
3218
3219
3220/*
3221 *
3222 *
3223 * 3 2 1
3224 * 10987654321098765432109876543210
3225 * 001000 x1110000101
3226 * rt -----
3227 * rs -----
3228 * rd -----
3229 */
3230std::string NMD::BNEC_32_(uint64 instruction)
3231{
3232 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3233 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3234 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3235
3236 std::string rs = GPR(copy(rs_value));
3237 std::string rt = GPR(copy(rt_value));
3238 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3239
3240 return img::format("BNEC %s, %s, %s", rs, rt, s);
3241}
3242
3243
3244/*
3245 *
3246 *
3247 * 3 2 1
3248 * 10987654321098765432109876543210
3249 * 001000 x1110000101
3250 * rt -----
3251 * rs -----
3252 * rd -----
3253 */
3254std::string NMD::BNEIC(uint64 instruction)
3255{
3256 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 3257 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
75199b40 3258 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
89a955e8
AM		 3259
3260 std::string rt = GPR(copy(rt_value));
3261 std::string u = IMMEDIATE(copy(u_value));
3262 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3263
3264 return img::format("BNEIC %s, %s, %s", rt, u, s);
3265}
3266
3267
3268/*
3269 *
3270 *
3271 * 3 2 1
3272 * 10987654321098765432109876543210
3273 * 001000 x1110000101
3274 * rt -----
3275 * rs -----
3276 * rd -----
3277 */
3278std::string NMD::BNEZC_16_(uint64 instruction)
3279{
89a955e8 3280 uint64 rt3_value = extract_rt3_9_8_7(instruction);
75199b40 3281 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
89a955e8 3282
988d6c89 3283 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 3284 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3285
3286 return img::format("BNEZC %s, %s", rt3, s);
3287}
3288
3289
3290/*
3291 *
3292 *
3293 * 3 2 1
3294 * 10987654321098765432109876543210
3295 * 001000 x1110000101
3296 * rt -----
3297 * rs -----
3298 * rd -----
3299 */
3300std::string NMD::BPOSGE32C(uint64 instruction)
3301{
d3605cc0 3302 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
89a955e8
AM		 3303
3304 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3305
3306 return img::format("BPOSGE32C %s", s);
3307}
3308
3309
3310/*
3311 *
3312 *
3313 * 3 2 1
3314 * 10987654321098765432109876543210
3315 * 001000 x1110000101
3316 * rt -----
3317 * rs -----
3318 * rd -----
3319 */
3320std::string NMD::BREAK_16_(uint64 instruction)
3321{
3322 uint64 code_value = extract_code_2_1_0(instruction);
3323
3324 std::string code = IMMEDIATE(copy(code_value));
3325
3326 return img::format("BREAK %s", code);
3327}
3328
3329
3330/*
3331 * BREAK code - Break. Cause a Breakpoint exception
3332 *
3333 * 3 2 1
3334 * 10987654321098765432109876543210
3335 * 001000 x1110000101
3336 * rt -----
3337 * rs -----
3338 * rd -----
3339 */
3340std::string NMD::BREAK_32_(uint64 instruction)
3341{
3342 uint64 code_value = extract_code_18_to_0(instruction);
3343
3344 std::string code = IMMEDIATE(copy(code_value));
3345
3346 return img::format("BREAK %s", code);
3347}
3348
3349
3350/*
3351 *
3352 *
3353 * 3 2 1
3354 * 10987654321098765432109876543210
3355 * 001000 x1110000101
3356 * rt -----
3357 * rs -----
3358 * rd -----
3359 */
3360std::string NMD::BRSC(uint64 instruction)
3361{
3362 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3363
3364 std::string rs = GPR(copy(rs_value));
3365
3366 return img::format("BRSC %s", rs);
3367}
3368
3369
3370/*
3371 *
3372 *
3373 * 3 2 1
3374 * 10987654321098765432109876543210
3375 * 001000 x1110000101
3376 * rt -----
3377 * rs -----
3378 * rd -----
3379 */
3380std::string NMD::CACHE(uint64 instruction)
3381{
89a955e8
AM		 3382 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3383 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3384 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 3385
3386 std::string op = IMMEDIATE(copy(op_value));
3387 std::string s = IMMEDIATE(copy(s_value));
3388 std::string rs = GPR(copy(rs_value));
3389
3390 return img::format("CACHE %s, %s(%s)", op, s, rs);
3391}
3392
3393
3394/*
3395 *
3396 *
3397 * 3 2 1
3398 * 10987654321098765432109876543210
3399 * 001000 x1110000101
3400 * rt -----
3401 * rs -----
3402 * rd -----
3403 */
3404std::string NMD::CACHEE(uint64 instruction)
3405{
89a955e8
AM		 3406 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3407 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 3408 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 3409
3410 std::string op = IMMEDIATE(copy(op_value));
3411 std::string s = IMMEDIATE(copy(s_value));
3412 std::string rs = GPR(copy(rs_value));
3413
3414 return img::format("CACHEE %s, %s(%s)", op, s, rs);
3415}
3416
3417
3418/*
3419 *
3420 *
3421 * 3 2 1
3422 * 10987654321098765432109876543210
3423 * 001000 x1110000101
3424 * rt -----
3425 * rs -----
3426 * rd -----
3427 */
3428std::string NMD::CEIL_L_D(uint64 instruction)
3429{
17ce2f00 3430 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3431 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3432
3433 std::string ft = FPR(copy(ft_value));
3434 std::string fs = FPR(copy(fs_value));
3435
3436 return img::format("CEIL.L.D %s, %s", ft, fs);
3437}
3438
3439
3440/*
3441 *
3442 *
3443 * 3 2 1
3444 * 10987654321098765432109876543210
3445 * 001000 x1110000101
3446 * rt -----
3447 * rs -----
3448 * rd -----
3449 */
3450std::string NMD::CEIL_L_S(uint64 instruction)
3451{
17ce2f00 3452 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3453 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3454
3455 std::string ft = FPR(copy(ft_value));
3456 std::string fs = FPR(copy(fs_value));
3457
3458 return img::format("CEIL.L.S %s, %s", ft, fs);
3459}
3460
3461
3462/*
3463 *
3464 *
3465 * 3 2 1
3466 * 10987654321098765432109876543210
3467 * 001000 x1110000101
3468 * rt -----
3469 * rs -----
3470 * rd -----
3471 */
3472std::string NMD::CEIL_W_D(uint64 instruction)
3473{
17ce2f00 3474 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3475 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3476
3477 std::string ft = FPR(copy(ft_value));
3478 std::string fs = FPR(copy(fs_value));
3479
3480 return img::format("CEIL.W.D %s, %s", ft, fs);
3481}
3482
3483
3484/*
3485 *
3486 *
3487 * 3 2 1
3488 * 10987654321098765432109876543210
3489 * 001000 x1110000101
3490 * rt -----
3491 * rs -----
3492 * rd -----
3493 */
3494std::string NMD::CEIL_W_S(uint64 instruction)
3495{
17ce2f00 3496 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3497 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3498
3499 std::string ft = FPR(copy(ft_value));
3500 std::string fs = FPR(copy(fs_value));
3501
3502 return img::format("CEIL.W.S %s, %s", ft, fs);
3503}
3504
3505
3506/*
3507 *
3508 *
3509 * 3 2 1
3510 * 10987654321098765432109876543210
3511 * 001000 x1110000101
3512 * rt -----
3513 * rs -----
3514 * rd -----
3515 */
3516std::string NMD::CFC1(uint64 instruction)
3517{
89a955e8 3518 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 3519 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 3520
3521 std::string rt = GPR(copy(rt_value));
3522 std::string cs = CPR(copy(cs_value));
3523
3524 return img::format("CFC1 %s, %s", rt, cs);
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::CFC2(uint64 instruction)
3539{
89a955e8 3540 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 3541 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 3542
3543 std::string rt = GPR(copy(rt_value));
3544 std::string cs = CPR(copy(cs_value));
3545
3546 return img::format("CFC2 %s, %s", rt, cs);
3547}
3548
3549
3550/*
3551 *
3552 *
3553 * 3 2 1
3554 * 10987654321098765432109876543210
3555 * 001000 x1110000101
3556 * rt -----
3557 * rs -----
3558 * rd -----
3559 */
3560std::string NMD::CLASS_D(uint64 instruction)
3561{
17ce2f00 3562 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3563 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3564
3565 std::string ft = FPR(copy(ft_value));
3566 std::string fs = FPR(copy(fs_value));
3567
3568 return img::format("CLASS.D %s, %s", ft, fs);
3569}
3570
3571
3572/*
3573 *
3574 *
3575 * 3 2 1
3576 * 10987654321098765432109876543210
3577 * 001000 x1110000101
3578 * rt -----
3579 * rs -----
3580 * rd -----
3581 */
3582std::string NMD::CLASS_S(uint64 instruction)
3583{
17ce2f00 3584 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3585 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 3586
3587 std::string ft = FPR(copy(ft_value));
3588 std::string fs = FPR(copy(fs_value));
3589
3590 return img::format("CLASS.S %s, %s", ft, fs);
3591}
3592
3593
3594/*
3595 *
3596 *
3597 * 3 2 1
3598 * 10987654321098765432109876543210
3599 * 001000 x1110000101
3600 * rt -----
3601 * rs -----
3602 * rd -----
3603 */
3604std::string NMD::CLO(uint64 instruction)
3605{
3606 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3607 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3608
3609 std::string rt = GPR(copy(rt_value));
3610 std::string rs = GPR(copy(rs_value));
3611
3612 return img::format("CLO %s, %s", rt, rs);
3613}
3614
3615
3616/*
3617 *
3618 *
3619 * 3 2 1
3620 * 10987654321098765432109876543210
3621 * 001000 x1110000101
3622 * rt -----
3623 * rs -----
3624 * rd -----
3625 */
3626std::string NMD::CLZ(uint64 instruction)
3627{
3628 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3629 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3630
3631 std::string rt = GPR(copy(rt_value));
3632 std::string rs = GPR(copy(rs_value));
3633
3634 return img::format("CLZ %s, %s", rt, rs);
3635}
3636
3637
3638/*
3639 *
3640 *
3641 * 3 2 1
3642 * 10987654321098765432109876543210
3643 * 001000 x1110000101
3644 * rt -----
3645 * rs -----
3646 * rd -----
3647 */
3648std::string NMD::CMP_AF_D(uint64 instruction)
3649{
17ce2f00 3650 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3651 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3652 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3653
3654 std::string fd = FPR(copy(fd_value));
3655 std::string fs = FPR(copy(fs_value));
3656 std::string ft = FPR(copy(ft_value));
3657
3658 return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3659}
3660
3661
3662/*
3663 *
3664 *
3665 * 3 2 1
3666 * 10987654321098765432109876543210
3667 * 001000 x1110000101
3668 * rt -----
3669 * rs -----
3670 * rd -----
3671 */
3672std::string NMD::CMP_AF_S(uint64 instruction)
3673{
17ce2f00 3674 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3675 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3676 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3677
3678 std::string fd = FPR(copy(fd_value));
3679 std::string fs = FPR(copy(fs_value));
3680 std::string ft = FPR(copy(ft_value));
3681
3682 return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
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::CMP_EQ_D(uint64 instruction)
3697{
17ce2f00 3698 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3699 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3700 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3701
3702 std::string fd = FPR(copy(fd_value));
3703 std::string fs = FPR(copy(fs_value));
3704 std::string ft = FPR(copy(ft_value));
3705
3706 return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3707}
3708
3709
3710/*
3711 *
3712 *
3713 * 3 2 1
3714 * 10987654321098765432109876543210
3715 * 001000 x1110000101
3716 * rt -----
3717 * rs -----
3718 * rd -----
3719 */
3720std::string NMD::CMP_EQ_PH(uint64 instruction)
3721{
3722 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3723 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3724
3725 std::string rs = GPR(copy(rs_value));
3726 std::string rt = GPR(copy(rt_value));
3727
3728 return img::format("CMP.EQ.PH %s, %s", rs, rt);
3729}
3730
3731
3732/*
3733 *
3734 *
3735 * 3 2 1
3736 * 10987654321098765432109876543210
3737 * 001000 x1110000101
3738 * rt -----
3739 * rs -----
3740 * rd -----
3741 */
3742std::string NMD::CMP_EQ_S(uint64 instruction)
3743{
17ce2f00 3744 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3745 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3746 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3747
3748 std::string fd = FPR(copy(fd_value));
3749 std::string fs = FPR(copy(fs_value));
3750 std::string ft = FPR(copy(ft_value));
3751
3752 return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3753}
3754
3755
3756/*
3757 *
3758 *
3759 * 3 2 1
3760 * 10987654321098765432109876543210
3761 * 001000 x1110000101
3762 * rt -----
3763 * rs -----
3764 * rd -----
3765 */
3766std::string NMD::CMP_LE_D(uint64 instruction)
3767{
17ce2f00 3768 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3769 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3770 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3771
3772 std::string fd = FPR(copy(fd_value));
3773 std::string fs = FPR(copy(fs_value));
3774 std::string ft = FPR(copy(ft_value));
3775
3776 return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3777}
3778
3779
3780/*
3781 *
3782 *
3783 * 3 2 1
3784 * 10987654321098765432109876543210
3785 * 001000 x1110000101
3786 * rt -----
3787 * rs -----
3788 * rd -----
3789 */
3790std::string NMD::CMP_LE_PH(uint64 instruction)
3791{
3792 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3793 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3794
3795 std::string rs = GPR(copy(rs_value));
3796 std::string rt = GPR(copy(rt_value));
3797
3798 return img::format("CMP.LE.PH %s, %s", rs, rt);
3799}
3800
3801
3802/*
3803 *
3804 *
3805 * 3 2 1
3806 * 10987654321098765432109876543210
3807 * 001000 x1110000101
3808 * rt -----
3809 * rs -----
3810 * rd -----
3811 */
3812std::string NMD::CMP_LE_S(uint64 instruction)
3813{
17ce2f00 3814 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3815 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3816 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3817
3818 std::string fd = FPR(copy(fd_value));
3819 std::string fs = FPR(copy(fs_value));
3820 std::string ft = FPR(copy(ft_value));
3821
3822 return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3823}
3824
3825
3826/*
3827 *
3828 *
3829 * 3 2 1
3830 * 10987654321098765432109876543210
3831 * 001000 x1110000101
3832 * rt -----
3833 * rs -----
3834 * rd -----
3835 */
3836std::string NMD::CMP_LT_D(uint64 instruction)
3837{
17ce2f00 3838 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3839 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3840 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3841
3842 std::string fd = FPR(copy(fd_value));
3843 std::string fs = FPR(copy(fs_value));
3844 std::string ft = FPR(copy(ft_value));
3845
3846 return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
3847}
3848
3849
3850/*
3851 *
3852 *
3853 * 3 2 1
3854 * 10987654321098765432109876543210
3855 * 001000 x1110000101
3856 * rt -----
3857 * rs -----
3858 * rd -----
3859 */
3860std::string NMD::CMP_LT_PH(uint64 instruction)
3861{
3862 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3863 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3864
3865 std::string rs = GPR(copy(rs_value));
3866 std::string rt = GPR(copy(rt_value));
3867
3868 return img::format("CMP.LT.PH %s, %s", rs, rt);
3869}
3870
3871
3872/*
3873 *
3874 *
3875 * 3 2 1
3876 * 10987654321098765432109876543210
3877 * 001000 x1110000101
3878 * rt -----
3879 * rs -----
3880 * rd -----
3881 */
3882std::string NMD::CMP_LT_S(uint64 instruction)
3883{
17ce2f00 3884 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3885 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3886 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3887
3888 std::string fd = FPR(copy(fd_value));
3889 std::string fs = FPR(copy(fs_value));
3890 std::string ft = FPR(copy(ft_value));
3891
3892 return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
3893}
3894
3895
3896/*
3897 *
3898 *
3899 * 3 2 1
3900 * 10987654321098765432109876543210
3901 * 001000 x1110000101
3902 * rt -----
3903 * rs -----
3904 * rd -----
3905 */
3906std::string NMD::CMP_NE_D(uint64 instruction)
3907{
17ce2f00 3908 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3909 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3910 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3911
3912 std::string fd = FPR(copy(fd_value));
3913 std::string fs = FPR(copy(fs_value));
3914 std::string ft = FPR(copy(ft_value));
3915
3916 return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
3917}
3918
3919
3920/*
3921 *
3922 *
3923 * 3 2 1
3924 * 10987654321098765432109876543210
3925 * 001000 x1110000101
3926 * rt -----
3927 * rs -----
3928 * rd -----
3929 */
3930std::string NMD::CMP_NE_S(uint64 instruction)
3931{
17ce2f00 3932 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3933 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3934 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3935
3936 std::string fd = FPR(copy(fd_value));
3937 std::string fs = FPR(copy(fs_value));
3938 std::string ft = FPR(copy(ft_value));
3939
3940 return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
3941}
3942
3943
3944/*
3945 *
3946 *
3947 * 3 2 1
3948 * 10987654321098765432109876543210
3949 * 001000 x1110000101
3950 * rt -----
3951 * rs -----
3952 * rd -----
3953 */
3954std::string NMD::CMP_OR_D(uint64 instruction)
3955{
17ce2f00 3956 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3957 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3958 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3959
3960 std::string fd = FPR(copy(fd_value));
3961 std::string fs = FPR(copy(fs_value));
3962 std::string ft = FPR(copy(ft_value));
3963
3964 return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
3965}
3966
3967
3968/*
3969 *
3970 *
3971 * 3 2 1
3972 * 10987654321098765432109876543210
3973 * 001000 x1110000101
3974 * rt -----
3975 * rs -----
3976 * rd -----
3977 */
3978std::string NMD::CMP_OR_S(uint64 instruction)
3979{
17ce2f00 3980 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 3981 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 3982 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 3983
3984 std::string fd = FPR(copy(fd_value));
3985 std::string fs = FPR(copy(fs_value));
3986 std::string ft = FPR(copy(ft_value));
3987
3988 return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
3989}
3990
3991
3992/*
3993 *
3994 *
3995 * 3 2 1
3996 * 10987654321098765432109876543210
3997 * 001000 x1110000101
3998 * rt -----
3999 * rs -----
4000 * rd -----
4001 */
4002std::string NMD::CMP_SAF_D(uint64 instruction)
4003{
17ce2f00 4004 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4005 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4006 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4007
4008 std::string fd = FPR(copy(fd_value));
4009 std::string fs = FPR(copy(fs_value));
4010 std::string ft = FPR(copy(ft_value));
4011
4012 return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
4013}
4014
4015
4016/*
4017 *
4018 *
4019 * 3 2 1
4020 * 10987654321098765432109876543210
4021 * 001000 x1110000101
4022 * rt -----
4023 * rs -----
4024 * rd -----
4025 */
4026std::string NMD::CMP_SAF_S(uint64 instruction)
4027{
17ce2f00 4028 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4029 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4030 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4031
4032 std::string fd = FPR(copy(fd_value));
4033 std::string fs = FPR(copy(fs_value));
4034 std::string ft = FPR(copy(ft_value));
4035
4036 return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
4037}
4038
4039
4040/*
4041 *
4042 *
4043 * 3 2 1
4044 * 10987654321098765432109876543210
4045 * 001000 x1110000101
4046 * rt -----
4047 * rs -----
4048 * rd -----
4049 */
4050std::string NMD::CMP_SEQ_D(uint64 instruction)
4051{
17ce2f00 4052 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4053 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4054 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4055
4056 std::string fd = FPR(copy(fd_value));
4057 std::string fs = FPR(copy(fs_value));
4058 std::string ft = FPR(copy(ft_value));
4059
4060 return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
4061}
4062
4063
4064/*
4065 *
4066 *
4067 * 3 2 1
4068 * 10987654321098765432109876543210
4069 * 001000 x1110000101
4070 * rt -----
4071 * rs -----
4072 * rd -----
4073 */
4074std::string NMD::CMP_SEQ_S(uint64 instruction)
4075{
17ce2f00 4076 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4077 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4078 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4079
4080 std::string fd = FPR(copy(fd_value));
4081 std::string fs = FPR(copy(fs_value));
4082 std::string ft = FPR(copy(ft_value));
4083
4084 return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
4085}
4086
4087
4088/*
4089 *
4090 *
4091 * 3 2 1
4092 * 10987654321098765432109876543210
4093 * 001000 x1110000101
4094 * rt -----
4095 * rs -----
4096 * rd -----
4097 */
4098std::string NMD::CMP_SLE_D(uint64 instruction)
4099{
17ce2f00 4100 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4101 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4102 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4103
4104 std::string fd = FPR(copy(fd_value));
4105 std::string fs = FPR(copy(fs_value));
4106 std::string ft = FPR(copy(ft_value));
4107
4108 return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
4109}
4110
4111
4112/*
4113 *
4114 *
4115 * 3 2 1
4116 * 10987654321098765432109876543210
4117 * 001000 x1110000101
4118 * rt -----
4119 * rs -----
4120 * rd -----
4121 */
4122std::string NMD::CMP_SLE_S(uint64 instruction)
4123{
17ce2f00 4124 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4125 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4126 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4127
4128 std::string fd = FPR(copy(fd_value));
4129 std::string fs = FPR(copy(fs_value));
4130 std::string ft = FPR(copy(ft_value));
4131
4132 return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
4133}
4134
4135
4136/*
4137 *
4138 *
4139 * 3 2 1
4140 * 10987654321098765432109876543210
4141 * 001000 x1110000101
4142 * rt -----
4143 * rs -----
4144 * rd -----
4145 */
4146std::string NMD::CMP_SLT_D(uint64 instruction)
4147{
17ce2f00 4148 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4149 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4150 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4151
4152 std::string fd = FPR(copy(fd_value));
4153 std::string fs = FPR(copy(fs_value));
4154 std::string ft = FPR(copy(ft_value));
4155
4156 return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4157}
4158
4159
4160/*
4161 *
4162 *
4163 * 3 2 1
4164 * 10987654321098765432109876543210
4165 * 001000 x1110000101
4166 * rt -----
4167 * rs -----
4168 * rd -----
4169 */
4170std::string NMD::CMP_SLT_S(uint64 instruction)
4171{
17ce2f00 4172 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4173 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4174 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4175
4176 std::string fd = FPR(copy(fd_value));
4177 std::string fs = FPR(copy(fs_value));
4178 std::string ft = FPR(copy(ft_value));
4179
4180 return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4181}
4182
4183
4184/*
4185 *
4186 *
4187 * 3 2 1
4188 * 10987654321098765432109876543210
4189 * 001000 x1110000101
4190 * rt -----
4191 * rs -----
4192 * rd -----
4193 */
4194std::string NMD::CMP_SNE_D(uint64 instruction)
4195{
17ce2f00 4196 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4197 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4198 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4199
4200 std::string fd = FPR(copy(fd_value));
4201 std::string fs = FPR(copy(fs_value));
4202 std::string ft = FPR(copy(ft_value));
4203
4204 return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4205}
4206
4207
4208/*
4209 *
4210 *
4211 * 3 2 1
4212 * 10987654321098765432109876543210
4213 * 001000 x1110000101
4214 * rt -----
4215 * rs -----
4216 * rd -----
4217 */
4218std::string NMD::CMP_SNE_S(uint64 instruction)
4219{
17ce2f00 4220 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4221 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4222 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4223
4224 std::string fd = FPR(copy(fd_value));
4225 std::string fs = FPR(copy(fs_value));
4226 std::string ft = FPR(copy(ft_value));
4227
4228 return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4229}
4230
4231
4232/*
4233 *
4234 *
4235 * 3 2 1
4236 * 10987654321098765432109876543210
4237 * 001000 x1110000101
4238 * rt -----
4239 * rs -----
4240 * rd -----
4241 */
4242std::string NMD::CMP_SOR_D(uint64 instruction)
4243{
17ce2f00 4244 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4245 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4246 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4247
4248 std::string fd = FPR(copy(fd_value));
4249 std::string fs = FPR(copy(fs_value));
4250 std::string ft = FPR(copy(ft_value));
4251
4252 return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4253}
4254
4255
4256/*
4257 *
4258 *
4259 * 3 2 1
4260 * 10987654321098765432109876543210
4261 * 001000 x1110000101
4262 * rt -----
4263 * rs -----
4264 * rd -----
4265 */
4266std::string NMD::CMP_SOR_S(uint64 instruction)
4267{
17ce2f00 4268 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4269 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4270 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4271
4272 std::string fd = FPR(copy(fd_value));
4273 std::string fs = FPR(copy(fs_value));
4274 std::string ft = FPR(copy(ft_value));
4275
4276 return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4277}
4278
4279
4280/*
4281 *
4282 *
4283 * 3 2 1
4284 * 10987654321098765432109876543210
4285 * 001000 x1110000101
4286 * rt -----
4287 * rs -----
4288 * rd -----
4289 */
4290std::string NMD::CMP_SUEQ_D(uint64 instruction)
4291{
17ce2f00 4292 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4293 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4294 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4295
4296 std::string fd = FPR(copy(fd_value));
4297 std::string fs = FPR(copy(fs_value));
4298 std::string ft = FPR(copy(ft_value));
4299
4300 return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4301}
4302
4303
4304/*
4305 *
4306 *
4307 * 3 2 1
4308 * 10987654321098765432109876543210
4309 * 001000 x1110000101
4310 * rt -----
4311 * rs -----
4312 * rd -----
4313 */
4314std::string NMD::CMP_SUEQ_S(uint64 instruction)
4315{
17ce2f00 4316 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4317 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4318 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4319
4320 std::string fd = FPR(copy(fd_value));
4321 std::string fs = FPR(copy(fs_value));
4322 std::string ft = FPR(copy(ft_value));
4323
4324 return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4325}
4326
4327
4328/*
4329 *
4330 *
4331 * 3 2 1
4332 * 10987654321098765432109876543210
4333 * 001000 x1110000101
4334 * rt -----
4335 * rs -----
4336 * rd -----
4337 */
4338std::string NMD::CMP_SULE_D(uint64 instruction)
4339{
17ce2f00 4340 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4341 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4342 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4343
4344 std::string fd = FPR(copy(fd_value));
4345 std::string fs = FPR(copy(fs_value));
4346 std::string ft = FPR(copy(ft_value));
4347
4348 return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4349}
4350
4351
4352/*
4353 *
4354 *
4355 * 3 2 1
4356 * 10987654321098765432109876543210
4357 * 001000 x1110000101
4358 * rt -----
4359 * rs -----
4360 * rd -----
4361 */
4362std::string NMD::CMP_SULE_S(uint64 instruction)
4363{
17ce2f00 4364 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4365 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4366 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4367
4368 std::string fd = FPR(copy(fd_value));
4369 std::string fs = FPR(copy(fs_value));
4370 std::string ft = FPR(copy(ft_value));
4371
4372 return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4373}
4374
4375
4376/*
4377 *
4378 *
4379 * 3 2 1
4380 * 10987654321098765432109876543210
4381 * 001000 x1110000101
4382 * rt -----
4383 * rs -----
4384 * rd -----
4385 */
4386std::string NMD::CMP_SULT_D(uint64 instruction)
4387{
17ce2f00 4388 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4389 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4390 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4391
4392 std::string fd = FPR(copy(fd_value));
4393 std::string fs = FPR(copy(fs_value));
4394 std::string ft = FPR(copy(ft_value));
4395
4396 return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4397}
4398
4399
4400/*
4401 *
4402 *
4403 * 3 2 1
4404 * 10987654321098765432109876543210
4405 * 001000 x1110000101
4406 * rt -----
4407 * rs -----
4408 * rd -----
4409 */
4410std::string NMD::CMP_SULT_S(uint64 instruction)
4411{
17ce2f00 4412 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4413 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4414 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4415
4416 std::string fd = FPR(copy(fd_value));
4417 std::string fs = FPR(copy(fs_value));
4418 std::string ft = FPR(copy(ft_value));
4419
4420 return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4421}
4422
4423
4424/*
4425 *
4426 *
4427 * 3 2 1
4428 * 10987654321098765432109876543210
4429 * 001000 x1110000101
4430 * rt -----
4431 * rs -----
4432 * rd -----
4433 */
4434std::string NMD::CMP_SUN_D(uint64 instruction)
4435{
17ce2f00 4436 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4437 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4438 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4439
4440 std::string fd = FPR(copy(fd_value));
4441 std::string fs = FPR(copy(fs_value));
4442 std::string ft = FPR(copy(ft_value));
4443
4444 return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4445}
4446
4447
4448/*
4449 *
4450 *
4451 * 3 2 1
4452 * 10987654321098765432109876543210
4453 * 001000 x1110000101
4454 * rt -----
4455 * rs -----
4456 * rd -----
4457 */
4458std::string NMD::CMP_SUNE_D(uint64 instruction)
4459{
17ce2f00 4460 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4461 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4462 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4463
4464 std::string fd = FPR(copy(fd_value));
4465 std::string fs = FPR(copy(fs_value));
4466 std::string ft = FPR(copy(ft_value));
4467
4468 return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4469}
4470
4471
4472/*
4473 *
4474 *
4475 * 3 2 1
4476 * 10987654321098765432109876543210
4477 * 001000 x1110000101
4478 * rt -----
4479 * rs -----
4480 * rd -----
4481 */
4482std::string NMD::CMP_SUNE_S(uint64 instruction)
4483{
17ce2f00 4484 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4485 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4486 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4487
4488 std::string fd = FPR(copy(fd_value));
4489 std::string fs = FPR(copy(fs_value));
4490 std::string ft = FPR(copy(ft_value));
4491
4492 return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4493}
4494
4495
4496/*
4497 *
4498 *
4499 * 3 2 1
4500 * 10987654321098765432109876543210
4501 * 001000 x1110000101
4502 * rt -----
4503 * rs -----
4504 * rd -----
4505 */
4506std::string NMD::CMP_SUN_S(uint64 instruction)
4507{
17ce2f00 4508 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4509 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4510 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4511
4512 std::string fd = FPR(copy(fd_value));
4513 std::string fs = FPR(copy(fs_value));
4514 std::string ft = FPR(copy(ft_value));
4515
4516 return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4517}
4518
4519
4520/*
4521 *
4522 *
4523 * 3 2 1
4524 * 10987654321098765432109876543210
4525 * 001000 x1110000101
4526 * rt -----
4527 * rs -----
4528 * rd -----
4529 */
4530std::string NMD::CMP_UEQ_D(uint64 instruction)
4531{
17ce2f00 4532 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4533 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4534 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4535
4536 std::string fd = FPR(copy(fd_value));
4537 std::string fs = FPR(copy(fs_value));
4538 std::string ft = FPR(copy(ft_value));
4539
4540 return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4541}
4542
4543
4544/*
4545 *
4546 *
4547 * 3 2 1
4548 * 10987654321098765432109876543210
4549 * 001000 x1110000101
4550 * rt -----
4551 * rs -----
4552 * rd -----
4553 */
4554std::string NMD::CMP_UEQ_S(uint64 instruction)
4555{
17ce2f00 4556 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4557 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4558 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4559
4560 std::string fd = FPR(copy(fd_value));
4561 std::string fs = FPR(copy(fs_value));
4562 std::string ft = FPR(copy(ft_value));
4563
4564 return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4565}
4566
4567
4568/*
4569 *
4570 *
4571 * 3 2 1
4572 * 10987654321098765432109876543210
4573 * 001000 x1110000101
4574 * rt -----
4575 * rs -----
4576 * rd -----
4577 */
4578std::string NMD::CMP_ULE_D(uint64 instruction)
4579{
17ce2f00 4580 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4581 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4582 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4583
4584 std::string fd = FPR(copy(fd_value));
4585 std::string fs = FPR(copy(fs_value));
4586 std::string ft = FPR(copy(ft_value));
4587
4588 return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4589}
4590
4591
4592/*
4593 *
4594 *
4595 * 3 2 1
4596 * 10987654321098765432109876543210
4597 * 001000 x1110000101
4598 * rt -----
4599 * rs -----
4600 * rd -----
4601 */
4602std::string NMD::CMP_ULE_S(uint64 instruction)
4603{
17ce2f00 4604 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4605 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4606 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4607
4608 std::string fd = FPR(copy(fd_value));
4609 std::string fs = FPR(copy(fs_value));
4610 std::string ft = FPR(copy(ft_value));
4611
4612 return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4613}
4614
4615
4616/*
4617 *
4618 *
4619 * 3 2 1
4620 * 10987654321098765432109876543210
4621 * 001000 x1110000101
4622 * rt -----
4623 * rs -----
4624 * rd -----
4625 */
4626std::string NMD::CMP_ULT_D(uint64 instruction)
4627{
17ce2f00 4628 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4629 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4630 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4631
4632 std::string fd = FPR(copy(fd_value));
4633 std::string fs = FPR(copy(fs_value));
4634 std::string ft = FPR(copy(ft_value));
4635
4636 return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4637}
4638
4639
4640/*
4641 *
4642 *
4643 * 3 2 1
4644 * 10987654321098765432109876543210
4645 * 001000 x1110000101
4646 * rt -----
4647 * rs -----
4648 * rd -----
4649 */
4650std::string NMD::CMP_ULT_S(uint64 instruction)
4651{
17ce2f00 4652 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4653 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4654 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4655
4656 std::string fd = FPR(copy(fd_value));
4657 std::string fs = FPR(copy(fs_value));
4658 std::string ft = FPR(copy(ft_value));
4659
4660 return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4661}
4662
4663
4664/*
4665 *
4666 *
4667 * 3 2 1
4668 * 10987654321098765432109876543210
4669 * 001000 x1110000101
4670 * rt -----
4671 * rs -----
4672 * rd -----
4673 */
4674std::string NMD::CMP_UN_D(uint64 instruction)
4675{
17ce2f00 4676 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4677 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4678 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4679
4680 std::string fd = FPR(copy(fd_value));
4681 std::string fs = FPR(copy(fs_value));
4682 std::string ft = FPR(copy(ft_value));
4683
4684 return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4685}
4686
4687
4688/*
4689 *
4690 *
4691 * 3 2 1
4692 * 10987654321098765432109876543210
4693 * 001000 x1110000101
4694 * rt -----
4695 * rs -----
4696 * rd -----
4697 */
4698std::string NMD::CMP_UNE_D(uint64 instruction)
4699{
17ce2f00 4700 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4701 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4702 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4703
4704 std::string fd = FPR(copy(fd_value));
4705 std::string fs = FPR(copy(fs_value));
4706 std::string ft = FPR(copy(ft_value));
4707
4708 return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4709}
4710
4711
4712/*
4713 *
4714 *
4715 * 3 2 1
4716 * 10987654321098765432109876543210
4717 * 001000 x1110000101
4718 * rt -----
4719 * rs -----
4720 * rd -----
4721 */
4722std::string NMD::CMP_UNE_S(uint64 instruction)
4723{
17ce2f00 4724 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4725 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4726 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4727
4728 std::string fd = FPR(copy(fd_value));
4729 std::string fs = FPR(copy(fs_value));
4730 std::string ft = FPR(copy(ft_value));
4731
4732 return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4733}
4734
4735
4736/*
4737 *
4738 *
4739 * 3 2 1
4740 * 10987654321098765432109876543210
4741 * 001000 x1110000101
4742 * rt -----
4743 * rs -----
4744 * rd -----
4745 */
4746std::string NMD::CMP_UN_S(uint64 instruction)
4747{
17ce2f00 4748 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 4749 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 4750 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 4751
4752 std::string fd = FPR(copy(fd_value));
4753 std::string fs = FPR(copy(fs_value));
4754 std::string ft = FPR(copy(ft_value));
4755
4756 return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4757}
4758
4759
4760/*
4761 *
4762 *
4763 * 3 2 1
4764 * 10987654321098765432109876543210
4765 * 001000 x1110000101
4766 * rt -----
4767 * rs -----
4768 * rd -----
4769 */
4770std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
4771{
4772 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4773 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4774 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4775
4776 std::string rd = GPR(copy(rd_value));
4777 std::string rs = GPR(copy(rs_value));
4778 std::string rt = GPR(copy(rt_value));
4779
4780 return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4781}
4782
4783
4784/*
4785 *
4786 *
4787 * 3 2 1
4788 * 10987654321098765432109876543210
4789 * 001000 x1110000101
4790 * rt -----
4791 * rs -----
4792 * rd -----
4793 */
4794std::string NMD::CMPGDU_LE_QB(uint64 instruction)
4795{
4796 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4797 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4798 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4799
4800 std::string rd = GPR(copy(rd_value));
4801 std::string rs = GPR(copy(rs_value));
4802 std::string rt = GPR(copy(rt_value));
4803
4804 return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4805}
4806
4807
4808/*
4809 *
4810 *
4811 * 3 2 1
4812 * 10987654321098765432109876543210
4813 * 001000 x1110000101
4814 * rt -----
4815 * rs -----
4816 * rd -----
4817 */
4818std::string NMD::CMPGDU_LT_QB(uint64 instruction)
4819{
4820 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4821 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4822 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4823
4824 std::string rd = GPR(copy(rd_value));
4825 std::string rs = GPR(copy(rs_value));
4826 std::string rt = GPR(copy(rt_value));
4827
4828 return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4829}
4830
4831
4832/*
4833 *
4834 *
4835 * 3 2 1
4836 * 10987654321098765432109876543210
4837 * 001000 x1110000101
4838 * rt -----
4839 * rs -----
4840 * rd -----
4841 */
4842std::string NMD::CMPGU_EQ_QB(uint64 instruction)
4843{
4844 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4845 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4846 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4847
4848 std::string rd = GPR(copy(rd_value));
4849 std::string rs = GPR(copy(rs_value));
4850 std::string rt = GPR(copy(rt_value));
4851
4852 return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
4853}
4854
4855
4856/*
4857 *
4858 *
4859 * 3 2 1
4860 * 10987654321098765432109876543210
4861 * 001000 x1110000101
4862 * rt -----
4863 * rs -----
4864 * rd -----
4865 */
4866std::string NMD::CMPGU_LE_QB(uint64 instruction)
4867{
4868 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4869 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4870 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4871
4872 std::string rd = GPR(copy(rd_value));
4873 std::string rs = GPR(copy(rs_value));
4874 std::string rt = GPR(copy(rt_value));
4875
4876 return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
4877}
4878
4879
4880/*
4881 *
4882 *
4883 * 3 2 1
4884 * 10987654321098765432109876543210
4885 * 001000 x1110000101
4886 * rt -----
4887 * rs -----
4888 * rd -----
4889 */
4890std::string NMD::CMPGU_LT_QB(uint64 instruction)
4891{
4892 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 4893 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 4894 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 4895
4896 std::string rd = GPR(copy(rd_value));
4897 std::string rs = GPR(copy(rs_value));
4898 std::string rt = GPR(copy(rt_value));
4899
4900 return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
4901}
4902
4903
4904/*
4905 *
4906 *
4907 * 3 2 1
4908 * 10987654321098765432109876543210
4909 * 001000 x1110000101
4910 * rt -----
4911 * rs -----
4912 * rd -----
4913 */
4914std::string NMD::CMPU_EQ_QB(uint64 instruction)
4915{
4916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4917 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4918
4919 std::string rs = GPR(copy(rs_value));
4920 std::string rt = GPR(copy(rt_value));
4921
4922 return img::format("CMPU.EQ.QB %s, %s", rs, rt);
4923}
4924
4925
4926/*
4927 *
4928 *
4929 * 3 2 1
4930 * 10987654321098765432109876543210
4931 * 001000 x1110000101
4932 * rt -----
4933 * rs -----
4934 * rd -----
4935 */
4936std::string NMD::CMPU_LE_QB(uint64 instruction)
4937{
4938 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4939 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4940
4941 std::string rs = GPR(copy(rs_value));
4942 std::string rt = GPR(copy(rt_value));
4943
4944 return img::format("CMPU.LE.QB %s, %s", rs, rt);
4945}
4946
4947
4948/*
4949 *
4950 *
4951 * 3 2 1
4952 * 10987654321098765432109876543210
4953 * 001000 x1110000101
4954 * rt -----
4955 * rs -----
4956 * rd -----
4957 */
4958std::string NMD::CMPU_LT_QB(uint64 instruction)
4959{
4960 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4961 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4962
4963 std::string rs = GPR(copy(rs_value));
4964 std::string rt = GPR(copy(rt_value));
4965
4966 return img::format("CMPU.LT.QB %s, %s", rs, rt);
4967}
4968
4969
4970/*
4971 *
4972 *
4973 * 3 2 1
4974 * 10987654321098765432109876543210
4975 * 001000 x1110000101
4976 * rt -----
4977 * rs -----
4978 * rd -----
4979 */
4980std::string NMD::COP2_1(uint64 instruction)
4981{
4982 uint64 cofun_value = extract_cofun_25_24_23(instruction);
4983
4984 std::string cofun = IMMEDIATE(copy(cofun_value));
4985
4986 return img::format("COP2_1 %s", cofun);
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::CTC1(uint64 instruction)
5001{
89a955e8 5002 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5003 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 5004
5005 std::string rt = GPR(copy(rt_value));
5006 std::string cs = CPR(copy(cs_value));
5007
5008 return img::format("CTC1 %s, %s", rt, cs);
5009}
5010
5011
5012/*
5013 *
5014 *
5015 * 3 2 1
5016 * 10987654321098765432109876543210
5017 * 001000 x1110000101
5018 * rt -----
5019 * rs -----
5020 * rd -----
5021 */
5022std::string NMD::CTC2(uint64 instruction)
5023{
89a955e8 5024 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5025 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 5026
5027 std::string rt = GPR(copy(rt_value));
5028 std::string cs = CPR(copy(cs_value));
5029
5030 return img::format("CTC2 %s, %s", rt, cs);
5031}
5032
5033
5034/*
5035 *
5036 *
5037 * 3 2 1
5038 * 10987654321098765432109876543210
5039 * 001000 x1110000101
5040 * rt -----
5041 * rs -----
5042 * rd -----
5043 */
5044std::string NMD::CVT_D_L(uint64 instruction)
5045{
17ce2f00 5046 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5047 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5048
5049 std::string ft = FPR(copy(ft_value));
5050 std::string fs = FPR(copy(fs_value));
5051
5052 return img::format("CVT.D.L %s, %s", ft, fs);
5053}
5054
5055
5056/*
5057 *
5058 *
5059 * 3 2 1
5060 * 10987654321098765432109876543210
5061 * 001000 x1110000101
5062 * rt -----
5063 * rs -----
5064 * rd -----
5065 */
5066std::string NMD::CVT_D_S(uint64 instruction)
5067{
17ce2f00 5068 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5069 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5070
5071 std::string ft = FPR(copy(ft_value));
5072 std::string fs = FPR(copy(fs_value));
5073
5074 return img::format("CVT.D.S %s, %s", ft, fs);
5075}
5076
5077
5078/*
5079 *
5080 *
5081 * 3 2 1
5082 * 10987654321098765432109876543210
5083 * 001000 x1110000101
5084 * rt -----
5085 * rs -----
5086 * rd -----
5087 */
5088std::string NMD::CVT_D_W(uint64 instruction)
5089{
17ce2f00 5090 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5091 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5092
5093 std::string ft = FPR(copy(ft_value));
5094 std::string fs = FPR(copy(fs_value));
5095
5096 return img::format("CVT.D.W %s, %s", ft, fs);
5097}
5098
5099
5100/*
5101 *
5102 *
5103 * 3 2 1
5104 * 10987654321098765432109876543210
5105 * 001000 x1110000101
5106 * rt -----
5107 * rs -----
5108 * rd -----
5109 */
5110std::string NMD::CVT_L_D(uint64 instruction)
5111{
17ce2f00 5112 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5113 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5114
5115 std::string ft = FPR(copy(ft_value));
5116 std::string fs = FPR(copy(fs_value));
5117
5118 return img::format("CVT.L.D %s, %s", ft, fs);
5119}
5120
5121
5122/*
5123 *
5124 *
5125 * 3 2 1
5126 * 10987654321098765432109876543210
5127 * 001000 x1110000101
5128 * rt -----
5129 * rs -----
5130 * rd -----
5131 */
5132std::string NMD::CVT_L_S(uint64 instruction)
5133{
17ce2f00 5134 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5135 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5136
5137 std::string ft = FPR(copy(ft_value));
5138 std::string fs = FPR(copy(fs_value));
5139
5140 return img::format("CVT.L.S %s, %s", ft, fs);
5141}
5142
5143
5144/*
5145 *
5146 *
5147 * 3 2 1
5148 * 10987654321098765432109876543210
5149 * 001000 x1110000101
5150 * rt -----
5151 * rs -----
5152 * rd -----
5153 */
5154std::string NMD::CVT_S_D(uint64 instruction)
5155{
17ce2f00 5156 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5157 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5158
5159 std::string ft = FPR(copy(ft_value));
5160 std::string fs = FPR(copy(fs_value));
5161
5162 return img::format("CVT.S.D %s, %s", ft, fs);
5163}
5164
5165
5166/*
5167 *
5168 *
5169 * 3 2 1
5170 * 10987654321098765432109876543210
5171 * 001000 x1110000101
5172 * rt -----
5173 * rs -----
5174 * rd -----
5175 */
5176std::string NMD::CVT_S_L(uint64 instruction)
5177{
17ce2f00 5178 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5179 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5180
5181 std::string ft = FPR(copy(ft_value));
5182 std::string fs = FPR(copy(fs_value));
5183
5184 return img::format("CVT.S.L %s, %s", ft, fs);
5185}
5186
5187
5188/*
5189 *
5190 *
5191 * 3 2 1
5192 * 10987654321098765432109876543210
5193 * 001000 x1110000101
5194 * rt -----
5195 * rs -----
5196 * rd -----
5197 */
5198std::string NMD::CVT_S_PL(uint64 instruction)
5199{
17ce2f00 5200 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5201 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5202
5203 std::string ft = FPR(copy(ft_value));
5204 std::string fs = FPR(copy(fs_value));
5205
5206 return img::format("CVT.S.PL %s, %s", ft, fs);
5207}
5208
5209
5210/*
5211 *
5212 *
5213 * 3 2 1
5214 * 10987654321098765432109876543210
5215 * 001000 x1110000101
5216 * rt -----
5217 * rs -----
5218 * rd -----
5219 */
5220std::string NMD::CVT_S_PU(uint64 instruction)
5221{
17ce2f00 5222 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5223 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5224
5225 std::string ft = FPR(copy(ft_value));
5226 std::string fs = FPR(copy(fs_value));
5227
5228 return img::format("CVT.S.PU %s, %s", ft, fs);
5229}
5230
5231
5232/*
5233 *
5234 *
5235 * 3 2 1
5236 * 10987654321098765432109876543210
5237 * 001000 x1110000101
5238 * rt -----
5239 * rs -----
5240 * rd -----
5241 */
5242std::string NMD::CVT_S_W(uint64 instruction)
5243{
17ce2f00 5244 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5245 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5246
5247 std::string ft = FPR(copy(ft_value));
5248 std::string fs = FPR(copy(fs_value));
5249
5250 return img::format("CVT.S.W %s, %s", ft, fs);
5251}
5252
5253
5254/*
5255 *
5256 *
5257 * 3 2 1
5258 * 10987654321098765432109876543210
5259 * 001000 x1110000101
5260 * rt -----
5261 * rs -----
5262 * rd -----
5263 */
5264std::string NMD::CVT_W_D(uint64 instruction)
5265{
17ce2f00 5266 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5267 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5268
5269 std::string ft = FPR(copy(ft_value));
5270 std::string fs = FPR(copy(fs_value));
5271
5272 return img::format("CVT.W.D %s, %s", ft, fs);
5273}
5274
5275
5276/*
5277 *
5278 *
5279 * 3 2 1
5280 * 10987654321098765432109876543210
5281 * 001000 x1110000101
5282 * rt -----
5283 * rs -----
5284 * rd -----
5285 */
5286std::string NMD::CVT_W_S(uint64 instruction)
5287{
17ce2f00 5288 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5289 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5290
5291 std::string ft = FPR(copy(ft_value));
5292 std::string fs = FPR(copy(fs_value));
5293
5294 return img::format("CVT.W.S %s, %s", ft, fs);
5295}
5296
5297
5298/*
5299 *
5300 *
5301 * 3 2 1
5302 * 10987654321098765432109876543210
5303 * 001000 x1110000101
5304 * rt -----
5305 * rs -----
5306 * rd -----
5307 */
5308std::string NMD::DADDIU_48_(uint64 instruction)
5309{
5310 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 5311 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 5312
5313 std::string rt = GPR(copy(rt_value));
5314 std::string s = IMMEDIATE(copy(s_value));
5315
5316 return img::format("DADDIU %s, %s", rt, s);
5317}
5318
5319
5320/*
5321 *
5322 *
5323 * 3 2 1
5324 * 10987654321098765432109876543210
5325 * 001000 x1110000101
5326 * rt -----
5327 * rs -----
5328 * rd -----
5329 */
5330std::string NMD::DADDIU_NEG_(uint64 instruction)
5331{
5332 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5333 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5334 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 5335
5336 std::string rt = GPR(copy(rt_value));
5337 std::string rs = GPR(copy(rs_value));
5338 std::string u = IMMEDIATE(neg_copy(u_value));
5339
5340 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5341}
5342
5343
5344/*
5345 *
5346 *
5347 * 3 2 1
5348 * 10987654321098765432109876543210
5349 * 001000 x1110000101
5350 * rt -----
5351 * rs -----
5352 * rd -----
5353 */
5354std::string NMD::DADDIU_U12_(uint64 instruction)
5355{
5356 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5357 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5358 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 5359
5360 std::string rt = GPR(copy(rt_value));
5361 std::string rs = GPR(copy(rs_value));
5362 std::string u = IMMEDIATE(copy(u_value));
5363
5364 return img::format("DADDIU %s, %s, %s", rt, rs, u);
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::DADD(uint64 instruction)
5379{
5380 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5381 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5382 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5383
5384 std::string rd = GPR(copy(rd_value));
5385 std::string rs = GPR(copy(rs_value));
5386 std::string rt = GPR(copy(rt_value));
5387
5388 return img::format("DADD %s, %s, %s", rd, rs, rt);
5389}
5390
5391
5392/*
5393 *
5394 *
5395 * 3 2 1
5396 * 10987654321098765432109876543210
5397 * 001000 x1110000101
5398 * rt -----
5399 * rs -----
5400 * rd -----
5401 */
5402std::string NMD::DADDU(uint64 instruction)
5403{
5404 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5405 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5406 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5407
5408 std::string rd = GPR(copy(rd_value));
5409 std::string rs = GPR(copy(rs_value));
5410 std::string rt = GPR(copy(rt_value));
5411
5412 return img::format("DADDU %s, %s, %s", rd, rs, rt);
5413}
5414
5415
5416/*
5417 *
5418 *
5419 * 3 2 1
5420 * 10987654321098765432109876543210
5421 * 001000 x1110000101
5422 * rt -----
5423 * rs -----
5424 * rd -----
5425 */
5426std::string NMD::DCLO(uint64 instruction)
5427{
5428 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5429 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5430
5431 std::string rt = GPR(copy(rt_value));
5432 std::string rs = GPR(copy(rs_value));
5433
5434 return img::format("DCLO %s, %s", rt, rs);
5435}
5436
5437
5438/*
5439 *
5440 *
5441 * 3 2 1
5442 * 10987654321098765432109876543210
5443 * 001000 x1110000101
5444 * rt -----
5445 * rs -----
5446 * rd -----
5447 */
5448std::string NMD::DCLZ(uint64 instruction)
5449{
5450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5452
5453 std::string rt = GPR(copy(rt_value));
5454 std::string rs = GPR(copy(rs_value));
5455
5456 return img::format("DCLZ %s, %s", rt, rs);
5457}
5458
5459
5460/*
5461 *
5462 *
5463 * 3 2 1
5464 * 10987654321098765432109876543210
5465 * 001000 x1110000101
5466 * rt -----
5467 * rs -----
5468 * rd -----
5469 */
5470std::string NMD::DDIV(uint64 instruction)
5471{
5472 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5473 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5474 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5475
5476 std::string rd = GPR(copy(rd_value));
5477 std::string rs = GPR(copy(rs_value));
5478 std::string rt = GPR(copy(rt_value));
5479
5480 return img::format("DDIV %s, %s, %s", rd, rs, rt);
5481}
5482
5483
5484/*
5485 *
5486 *
5487 * 3 2 1
5488 * 10987654321098765432109876543210
5489 * 001000 x1110000101
5490 * rt -----
5491 * rs -----
5492 * rd -----
5493 */
5494std::string NMD::DDIVU(uint64 instruction)
5495{
5496 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5497 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5498 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5499
5500 std::string rd = GPR(copy(rd_value));
5501 std::string rs = GPR(copy(rs_value));
5502 std::string rt = GPR(copy(rt_value));
5503
5504 return img::format("DDIVU %s, %s, %s", rd, rs, rt);
5505}
5506
5507
5508/*
5509 *
5510 *
5511 * 3 2 1
5512 * 10987654321098765432109876543210
5513 * 001000 x1110000101
5514 * rt -----
5515 * rs -----
5516 * rd -----
5517 */
5518std::string NMD::DERET(uint64 instruction)
5519{
5520 (void)instruction;
5521
5522 return "DERET ";
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::DEXTM(uint64 instruction)
5537{
5538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5539 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5540 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5541 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5542
5543 std::string rt = GPR(copy(rt_value));
5544 std::string rs = GPR(copy(rs_value));
5545 std::string lsb = IMMEDIATE(copy(lsb_value));
5546 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5547
5548 return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
5549}
5550
5551
5552/*
5553 *
5554 *
5555 * 3 2 1
5556 * 10987654321098765432109876543210
5557 * 001000 x1110000101
5558 * rt -----
5559 * rs -----
5560 * rd -----
5561 */
5562std::string NMD::DEXT(uint64 instruction)
5563{
5564 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5565 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5566 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5567 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5568
5569 std::string rt = GPR(copy(rt_value));
5570 std::string rs = GPR(copy(rs_value));
5571 std::string lsb = IMMEDIATE(copy(lsb_value));
5572 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5573
5574 return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
5575}
5576
5577
5578/*
5579 *
5580 *
5581 * 3 2 1
5582 * 10987654321098765432109876543210
5583 * 001000 x1110000101
5584 * rt -----
5585 * rs -----
5586 * rd -----
5587 */
5588std::string NMD::DEXTU(uint64 instruction)
5589{
5590 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5591 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5592 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5593 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5594
5595 std::string rt = GPR(copy(rt_value));
5596 std::string rs = GPR(copy(rs_value));
5597 std::string lsb = IMMEDIATE(copy(lsb_value));
5598 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5599
5600 return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
5601}
5602
5603
5604/*
5605 *
5606 *
5607 * 3 2 1
5608 * 10987654321098765432109876543210
5609 * 001000 x1110000101
5610 * rt -----
5611 * rs -----
5612 * rd -----
5613 */
5614std::string NMD::DINSM(uint64 instruction)
5615{
5616 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5617 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5618 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5619 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5620
5621 std::string rt = GPR(copy(rt_value));
5622 std::string rs = GPR(copy(rs_value));
5623 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5624 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5625 /* !!!!!!!!!! - no conversion function */
5626
5627 return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
5628 /* hand edited */
5629}
5630
5631
5632/*
5633 *
5634 *
5635 * 3 2 1
5636 * 10987654321098765432109876543210
5637 * 001000 x1110000101
5638 * rt -----
5639 * rs -----
5640 * rd -----
5641 */
5642std::string NMD::DINS(uint64 instruction)
5643{
5644 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5645 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5646 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5647 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5648
5649 std::string rt = GPR(copy(rt_value));
5650 std::string rs = GPR(copy(rs_value));
5651 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5652 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5653 /* !!!!!!!!!! - no conversion function */
5654
5655 return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
5656 /* hand edited */
5657}
5658
5659
5660/*
5661 *
5662 *
5663 * 3 2 1
5664 * 10987654321098765432109876543210
5665 * 001000 x1110000101
5666 * rt -----
5667 * rs -----
5668 * rd -----
5669 */
5670std::string NMD::DINSU(uint64 instruction)
5671{
5672 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 5674 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5675 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 5676
5677 std::string rt = GPR(copy(rt_value));
5678 std::string rs = GPR(copy(rs_value));
5679 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5680 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5681 /* !!!!!!!!!! - no conversion function */
5682
5683 return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
5684 /* hand edited */
5685}
5686
5687
5688/*
5689 *
5690 *
5691 * 3 2 1
5692 * 10987654321098765432109876543210
5693 * 001000 x1110000101
5694 * rt -----
5695 * rs -----
5696 * rd -----
5697 */
5698std::string NMD::DI(uint64 instruction)
5699{
5700 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5701
5702 std::string rt = GPR(copy(rt_value));
5703
5704 return img::format("DI %s", rt);
5705}
5706
5707
5708/*
5709 *
5710 *
5711 * 3 2 1
5712 * 10987654321098765432109876543210
5713 * 001000 x1110000101
5714 * rt -----
5715 * rs -----
5716 * rd -----
5717 */
5718std::string NMD::DIV(uint64 instruction)
5719{
5720 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5721 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5722 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5723
5724 std::string rd = GPR(copy(rd_value));
5725 std::string rs = GPR(copy(rs_value));
5726 std::string rt = GPR(copy(rt_value));
5727
5728 return img::format("DIV %s, %s, %s", rd, rs, rt);
5729}
5730
5731
5732/*
5733 *
5734 *
5735 * 3 2 1
5736 * 10987654321098765432109876543210
5737 * 001000 x1110000101
5738 * rt -----
5739 * rs -----
5740 * rd -----
5741 */
5742std::string NMD::DIV_D(uint64 instruction)
5743{
17ce2f00 5744 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5745 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 5746 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 5747
5748 std::string fd = FPR(copy(fd_value));
5749 std::string fs = FPR(copy(fs_value));
5750 std::string ft = FPR(copy(ft_value));
5751
5752 return img::format("DIV.D %s, %s, %s", fd, fs, ft);
5753}
5754
5755
5756/*
5757 *
5758 *
5759 * 3 2 1
5760 * 10987654321098765432109876543210
5761 * 001000 x1110000101
5762 * rt -----
5763 * rs -----
5764 * rd -----
5765 */
5766std::string NMD::DIV_S(uint64 instruction)
5767{
17ce2f00 5768 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 5769 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 5770 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 5771
5772 std::string fd = FPR(copy(fd_value));
5773 std::string fs = FPR(copy(fs_value));
5774 std::string ft = FPR(copy(ft_value));
5775
5776 return img::format("DIV.S %s, %s, %s", fd, fs, ft);
5777}
5778
5779
5780/*
5781 *
5782 *
5783 * 3 2 1
5784 * 10987654321098765432109876543210
5785 * 001000 x1110000101
5786 * rt -----
5787 * rs -----
5788 * rd -----
5789 */
5790std::string NMD::DIVU(uint64 instruction)
5791{
5792 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5793 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5794 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5795
5796 std::string rd = GPR(copy(rd_value));
5797 std::string rs = GPR(copy(rs_value));
5798 std::string rt = GPR(copy(rt_value));
5799
5800 return img::format("DIVU %s, %s, %s", rd, rs, rt);
5801}
5802
5803
5804/*
5805 *
5806 *
5807 * 3 2 1
5808 * 10987654321098765432109876543210
5809 * 001000 x1110000101
5810 * rt -----
5811 * rs -----
5812 * rd -----
5813 */
5814std::string NMD::DLSA(uint64 instruction)
5815{
5816 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5817 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
b4c5d21c 5818 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8 5819 uint64 u2_value = extract_u2_10_9(instruction);
89a955e8
AM		 5820
5821 std::string rd = GPR(copy(rd_value));
5822 std::string rs = GPR(copy(rs_value));
5823 std::string rt = GPR(copy(rt_value));
5824 std::string u2 = IMMEDIATE(copy(u2_value));
5825
5826 return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
5827}
5828
5829
5830/*
5831 *
5832 *
5833 * 3 2 1
5834 * 10987654321098765432109876543210
5835 * 001000 x1110000101
5836 * rt -----
5837 * rs -----
5838 * rd -----
5839 */
5840std::string NMD::DLUI_48_(uint64 instruction)
5841{
5842 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
11b9732a 5843 uint64 u_value = extract_u_31_to_0__s32(instruction);
89a955e8
AM		 5844
5845 std::string rt = GPR(copy(rt_value));
5846 std::string u = IMMEDIATE(copy(u_value));
5847
5848 return img::format("DLUI %s, %s", rt, u);
5849}
5850
5851
5852/*
5853 *
5854 *
5855 * 3 2 1
5856 * 10987654321098765432109876543210
5857 * 001000 x1110000101
5858 * rt -----
5859 * rs -----
5860 * rd -----
5861 */
5862std::string NMD::DMFC0(uint64 instruction)
5863{
5864 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5865 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5866 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5867
5868 std::string rt = GPR(copy(rt_value));
5869 std::string c0s = CPR(copy(c0s_value));
5870 std::string sel = IMMEDIATE(copy(sel_value));
5871
5872 return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
5873}
5874
5875
5876/*
5877 *
5878 *
5879 * 3 2 1
5880 * 10987654321098765432109876543210
5881 * 001000 x1110000101
5882 * rt -----
5883 * rs -----
5884 * rd -----
5885 */
5886std::string NMD::DMFC1(uint64 instruction)
5887{
5888 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 5889 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 5890
5891 std::string rt = GPR(copy(rt_value));
5892 std::string fs = FPR(copy(fs_value));
5893
5894 return img::format("DMFC1 %s, %s", rt, fs);
5895}
5896
5897
5898/*
5899 *
5900 *
5901 * 3 2 1
5902 * 10987654321098765432109876543210
5903 * 001000 x1110000101
5904 * rt -----
5905 * rs -----
5906 * rd -----
5907 */
5908std::string NMD::DMFC2(uint64 instruction)
5909{
89a955e8 5910 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 5911 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 5912
5913 std::string rt = GPR(copy(rt_value));
5914 std::string cs = CPR(copy(cs_value));
5915
5916 return img::format("DMFC2 %s, %s", rt, cs);
5917}
5918
5919
5920/*
5921 *
5922 *
5923 * 3 2 1
5924 * 10987654321098765432109876543210
5925 * 001000 x1110000101
5926 * rt -----
5927 * rs -----
5928 * rd -----
5929 */
5930std::string NMD::DMFGC0(uint64 instruction)
5931{
5932 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5933 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5934 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5935
5936 std::string rt = GPR(copy(rt_value));
5937 std::string c0s = CPR(copy(c0s_value));
5938 std::string sel = IMMEDIATE(copy(sel_value));
5939
5940 return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
5941}
5942
5943
5944/*
5945 *
5946 *
5947 * 3 2 1
5948 * 10987654321098765432109876543210
5949 * 001000 x1110000101
5950 * rt -----
5951 * rs -----
5952 * rd -----
5953 */
5954std::string NMD::DMOD(uint64 instruction)
5955{
5956 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5957 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5958 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5959
5960 std::string rd = GPR(copy(rd_value));
5961 std::string rs = GPR(copy(rs_value));
5962 std::string rt = GPR(copy(rt_value));
5963
5964 return img::format("DMOD %s, %s, %s", rd, rs, rt);
5965}
5966
5967
5968/*
5969 *
5970 *
5971 * 3 2 1
5972 * 10987654321098765432109876543210
5973 * 001000 x1110000101
5974 * rt -----
5975 * rs -----
5976 * rd -----
5977 */
5978std::string NMD::DMODU(uint64 instruction)
5979{
5980 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 5981 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 5982 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 5983
5984 std::string rd = GPR(copy(rd_value));
5985 std::string rs = GPR(copy(rs_value));
5986 std::string rt = GPR(copy(rt_value));
5987
5988 return img::format("DMODU %s, %s, %s", rd, rs, rt);
5989}
5990
5991
5992/*
5993 *
5994 *
5995 * 3 2 1
5996 * 10987654321098765432109876543210
5997 * 001000 x1110000101
5998 * rt -----
5999 * rs -----
6000 * rd -----
6001 */
6002std::string NMD::DMTC0(uint64 instruction)
6003{
6004 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6005 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6006 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6007
6008 std::string rt = GPR(copy(rt_value));
6009 std::string c0s = CPR(copy(c0s_value));
6010 std::string sel = IMMEDIATE(copy(sel_value));
6011
6012 return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
6013}
6014
6015
6016/*
6017 *
6018 *
6019 * 3 2 1
6020 * 10987654321098765432109876543210
6021 * 001000 x1110000101
6022 * rt -----
6023 * rs -----
6024 * rd -----
6025 */
6026std::string NMD::DMTC1(uint64 instruction)
6027{
6028 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 6029 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 6030
6031 std::string rt = GPR(copy(rt_value));
6032 std::string fs = FPR(copy(fs_value));
6033
6034 return img::format("DMTC1 %s, %s", rt, fs);
6035}
6036
6037
6038/*
6039 *
6040 *
6041 * 3 2 1
6042 * 10987654321098765432109876543210
6043 * 001000 x1110000101
6044 * rt -----
6045 * rs -----
6046 * rd -----
6047 */
6048std::string NMD::DMTC2(uint64 instruction)
6049{
89a955e8 6050 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 6051 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 6052
6053 std::string rt = GPR(copy(rt_value));
6054 std::string cs = CPR(copy(cs_value));
6055
6056 return img::format("DMTC2 %s, %s", rt, cs);
6057}
6058
6059
6060/*
6061 *
6062 *
6063 * 3 2 1
6064 * 10987654321098765432109876543210
6065 * 001000 x1110000101
6066 * rt -----
6067 * rs -----
6068 * rd -----
6069 */
6070std::string NMD::DMTGC0(uint64 instruction)
6071{
6072 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6073 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6074 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6075
6076 std::string rt = GPR(copy(rt_value));
6077 std::string c0s = CPR(copy(c0s_value));
6078 std::string sel = IMMEDIATE(copy(sel_value));
6079
6080 return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
6081}
6082
6083
6084/*
6085 *
6086 *
6087 * 3 2 1
6088 * 10987654321098765432109876543210
6089 * 001000 x1110000101
6090 * rt -----
6091 * rs -----
6092 * rd -----
6093 */
6094std::string NMD::DMT(uint64 instruction)
6095{
6096 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6097
6098 std::string rt = GPR(copy(rt_value));
6099
6100 return img::format("DMT %s", rt);
6101}
6102
6103
6104/*
6105 *
6106 *
6107 * 3 2 1
6108 * 10987654321098765432109876543210
6109 * 001000 x1110000101
6110 * rt -----
6111 * rs -----
6112 * rd -----
6113 */
6114std::string NMD::DMUH(uint64 instruction)
6115{
6116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6117 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6118 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6119
6120 std::string rd = GPR(copy(rd_value));
6121 std::string rs = GPR(copy(rs_value));
6122 std::string rt = GPR(copy(rt_value));
6123
6124 return img::format("DMUH %s, %s, %s", rd, rs, rt);
6125}
6126
6127
6128/*
6129 *
6130 *
6131 * 3 2 1
6132 * 10987654321098765432109876543210
6133 * 001000 x1110000101
6134 * rt -----
6135 * rs -----
6136 * rd -----
6137 */
6138std::string NMD::DMUHU(uint64 instruction)
6139{
6140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6141 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6142 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6143
6144 std::string rd = GPR(copy(rd_value));
6145 std::string rs = GPR(copy(rs_value));
6146 std::string rt = GPR(copy(rt_value));
6147
6148 return img::format("DMUHU %s, %s, %s", rd, rs, rt);
6149}
6150
6151
6152/*
6153 *
6154 *
6155 * 3 2 1
6156 * 10987654321098765432109876543210
6157 * 001000 x1110000101
6158 * rt -----
6159 * rs -----
6160 * rd -----
6161 */
6162std::string NMD::DMUL(uint64 instruction)
6163{
6164 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6165 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6166 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6167
6168 std::string rd = GPR(copy(rd_value));
6169 std::string rs = GPR(copy(rs_value));
6170 std::string rt = GPR(copy(rt_value));
6171
6172 return img::format("DMUL %s, %s, %s", rd, rs, rt);
6173}
6174
6175
6176/*
6177 *
6178 *
6179 * 3 2 1
6180 * 10987654321098765432109876543210
6181 * 001000 x1110000101
6182 * rt -----
6183 * rs -----
6184 * rd -----
6185 */
6186std::string NMD::DMULU(uint64 instruction)
6187{
6188 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6190 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6191
6192 std::string rd = GPR(copy(rd_value));
6193 std::string rs = GPR(copy(rs_value));
6194 std::string rt = GPR(copy(rt_value));
6195
6196 return img::format("DMULU %s, %s, %s", rd, rs, rt);
6197}
6198
6199
6200/*
6201 *
6202 *
6203 * 3 2 1
6204 * 10987654321098765432109876543210
6205 * 001000 x1110000101
6206 * rt -----
6207 * rs -----
6208 * rd -----
6209 */
6210std::string NMD::DPA_W_PH(uint64 instruction)
6211{
6212 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6214 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6215
6216 std::string ac = AC(copy(ac_value));
6217 std::string rs = GPR(copy(rs_value));
6218 std::string rt = GPR(copy(rt_value));
6219
6220 return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6221}
6222
6223
6224/*
6225 *
6226 *
6227 * 3 2 1
6228 * 10987654321098765432109876543210
6229 * 001000 x1110000101
6230 * rt -----
6231 * rs -----
6232 * rd -----
6233 */
6234std::string NMD::DPAQ_SA_L_W(uint64 instruction)
6235{
6236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6238 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6239
6240 std::string ac = AC(copy(ac_value));
6241 std::string rs = GPR(copy(rs_value));
6242 std::string rt = GPR(copy(rt_value));
6243
6244 return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6245}
6246
6247
6248/*
6249 *
6250 *
6251 * 3 2 1
6252 * 10987654321098765432109876543210
6253 * 001000 x1110000101
6254 * rt -----
6255 * rs -----
6256 * rd -----
6257 */
6258std::string NMD::DPAQ_S_W_PH(uint64 instruction)
6259{
6260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6261 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6262 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6263
6264 std::string ac = AC(copy(ac_value));
6265 std::string rs = GPR(copy(rs_value));
6266 std::string rt = GPR(copy(rt_value));
6267
6268 return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6269}
6270
6271
6272/*
6273 *
6274 *
6275 * 3 2 1
6276 * 10987654321098765432109876543210
6277 * 001000 x1110000101
6278 * rt -----
6279 * rs -----
6280 * rd -----
6281 */
6282std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
6283{
6284 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6285 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6286 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6287
6288 std::string ac = AC(copy(ac_value));
6289 std::string rs = GPR(copy(rs_value));
6290 std::string rt = GPR(copy(rt_value));
6291
6292 return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6293}
6294
6295
6296/*
6297 *
6298 *
6299 * 3 2 1
6300 * 10987654321098765432109876543210
6301 * 001000 x1110000101
6302 * rt -----
6303 * rs -----
6304 * rd -----
6305 */
6306std::string NMD::DPAQX_S_W_PH(uint64 instruction)
6307{
6308 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6309 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6310 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6311
6312 std::string ac = AC(copy(ac_value));
6313 std::string rs = GPR(copy(rs_value));
6314 std::string rt = GPR(copy(rt_value));
6315
6316 return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6317}
6318
6319
6320/*
6321 *
6322 *
6323 * 3 2 1
6324 * 10987654321098765432109876543210
6325 * 001000 x1110000101
6326 * rt -----
6327 * rs -----
6328 * rd -----
6329 */
6330std::string NMD::DPAU_H_QBL(uint64 instruction)
6331{
6332 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6333 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6334 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6335
6336 std::string ac = AC(copy(ac_value));
6337 std::string rs = GPR(copy(rs_value));
6338 std::string rt = GPR(copy(rt_value));
6339
6340 return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6341}
6342
6343
6344/*
6345 *
6346 *
6347 * 3 2 1
6348 * 10987654321098765432109876543210
6349 * 001000 x1110000101
6350 * rt -----
6351 * rs -----
6352 * rd -----
6353 */
6354std::string NMD::DPAU_H_QBR(uint64 instruction)
6355{
6356 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6357 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6358 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6359
6360 std::string ac = AC(copy(ac_value));
6361 std::string rs = GPR(copy(rs_value));
6362 std::string rt = GPR(copy(rt_value));
6363
6364 return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6365}
6366
6367
6368/*
6369 *
6370 *
6371 * 3 2 1
6372 * 10987654321098765432109876543210
6373 * 001000 x1110000101
6374 * rt -----
6375 * rs -----
6376 * rd -----
6377 */
6378std::string NMD::DPAX_W_PH(uint64 instruction)
6379{
6380 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6381 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6382 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6383
6384 std::string ac = AC(copy(ac_value));
6385 std::string rs = GPR(copy(rs_value));
6386 std::string rt = GPR(copy(rt_value));
6387
6388 return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6389}
6390
6391
6392/*
6393 *
6394 *
6395 * 3 2 1
6396 * 10987654321098765432109876543210
6397 * 001000 x1110000101
6398 * rt -----
6399 * rs -----
6400 * rd -----
6401 */
6402std::string NMD::DPS_W_PH(uint64 instruction)
6403{
6404 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6405 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6406 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6407
6408 std::string ac = AC(copy(ac_value));
6409 std::string rs = GPR(copy(rs_value));
6410 std::string rt = GPR(copy(rt_value));
6411
6412 return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6413}
6414
6415
6416/*
6417 *
6418 *
6419 * 3 2 1
6420 * 10987654321098765432109876543210
6421 * 001000 x1110000101
6422 * rt -----
6423 * rs -----
6424 * rd -----
6425 */
6426std::string NMD::DPSQ_SA_L_W(uint64 instruction)
6427{
6428 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6429 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6430 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6431
6432 std::string ac = AC(copy(ac_value));
6433 std::string rs = GPR(copy(rs_value));
6434 std::string rt = GPR(copy(rt_value));
6435
6436 return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6437}
6438
6439
6440/*
6441 *
6442 *
6443 * 3 2 1
6444 * 10987654321098765432109876543210
6445 * 001000 x1110000101
6446 * rt -----
6447 * rs -----
6448 * rd -----
6449 */
6450std::string NMD::DPSQ_S_W_PH(uint64 instruction)
6451{
6452 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6453 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6454 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6455
6456 std::string ac = AC(copy(ac_value));
6457 std::string rs = GPR(copy(rs_value));
6458 std::string rt = GPR(copy(rt_value));
6459
6460 return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6461}
6462
6463
6464/*
6465 *
6466 *
6467 * 3 2 1
6468 * 10987654321098765432109876543210
6469 * 001000 x1110000101
6470 * rt -----
6471 * rs -----
6472 * rd -----
6473 */
6474std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
6475{
6476 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6477 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6478 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6479
6480 std::string ac = AC(copy(ac_value));
6481 std::string rs = GPR(copy(rs_value));
6482 std::string rt = GPR(copy(rt_value));
6483
6484 return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6485}
6486
6487
6488/*
6489 *
6490 *
6491 * 3 2 1
6492 * 10987654321098765432109876543210
6493 * 001000 x1110000101
6494 * rt -----
6495 * rs -----
6496 * rd -----
6497 */
6498std::string NMD::DPSQX_S_W_PH(uint64 instruction)
6499{
6500 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6501 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6502 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6503
6504 std::string ac = AC(copy(ac_value));
6505 std::string rs = GPR(copy(rs_value));
6506 std::string rt = GPR(copy(rt_value));
6507
6508 return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6509}
6510
6511
6512/*
6513 *
6514 *
6515 * 3 2 1
6516 * 10987654321098765432109876543210
6517 * 001000 x1110000101
6518 * rt -----
6519 * rs -----
6520 * rd -----
6521 */
6522std::string NMD::DPSU_H_QBL(uint64 instruction)
6523{
6524 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6525 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6526 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6527
6528 std::string ac = AC(copy(ac_value));
6529 std::string rs = GPR(copy(rs_value));
6530 std::string rt = GPR(copy(rt_value));
6531
6532 return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6533}
6534
6535
6536/*
6537 *
6538 *
6539 * 3 2 1
6540 * 10987654321098765432109876543210
6541 * 001000 x1110000101
6542 * rt -----
6543 * rs -----
6544 * rd -----
6545 */
6546std::string NMD::DPSU_H_QBR(uint64 instruction)
6547{
6548 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6549 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6550 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6551
6552 std::string ac = AC(copy(ac_value));
6553 std::string rs = GPR(copy(rs_value));
6554 std::string rt = GPR(copy(rt_value));
6555
6556 return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6557}
6558
6559
6560/*
6561 *
6562 *
6563 * 3 2 1
6564 * 10987654321098765432109876543210
6565 * 001000 x1110000101
6566 * rt -----
6567 * rs -----
6568 * rd -----
6569 */
6570std::string NMD::DPSX_W_PH(uint64 instruction)
6571{
6572 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6573 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6574 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 6575
6576 std::string ac = AC(copy(ac_value));
6577 std::string rs = GPR(copy(rs_value));
6578 std::string rt = GPR(copy(rt_value));
6579
6580 return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6581}
6582
6583
6584/*
6585 * DROTR -
6586 *
6587 * 3 2 1
6588 * 10987654321098765432109876543210
6589 * 001000 x1110000101
6590 * rt -----
6591 * rs -----
6592 * rd -----
6593 */
6594std::string NMD::DROTR(uint64 instruction)
6595{
6596 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6597 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6598 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6599
6600 std::string rt = GPR(copy(rt_value));
6601 std::string rs = GPR(copy(rs_value));
6602 std::string shift = IMMEDIATE(copy(shift_value));
6603
6604 return img::format("DROTR %s, %s, %s", rt, rs, shift);
6605}
6606
6607
6608/*
6609 * DROTR[32] -
6610 *
6611 * 3 2 1
6612 * 10987654321098765432109876543210
6613 * 10o000 1100xxx0110
6614 * rt -----
6615 * rs -----
6616 * shift -----
6617 */
6618std::string NMD::DROTR32(uint64 instruction)
6619{
6620 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6621 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6622 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6623
6624 std::string rt = GPR(copy(rt_value));
6625 std::string rs = GPR(copy(rs_value));
6626 std::string shift = IMMEDIATE(copy(shift_value));
6627
6628 return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
6629}
6630
6631
6632/*
6633 *
6634 *
6635 * 3 2 1
6636 * 10987654321098765432109876543210
6637 * 001000 x1110000101
6638 * rt -----
6639 * rs -----
6640 * rd -----
6641 */
6642std::string NMD::DROTRV(uint64 instruction)
6643{
6644 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6645 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6646 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6647
6648 std::string rd = GPR(copy(rd_value));
6649 std::string rs = GPR(copy(rs_value));
6650 std::string rt = GPR(copy(rt_value));
6651
6652 return img::format("DROTRV %s, %s, %s", rd, rs, rt);
6653}
6654
6655
6656/*
6657 *
6658 *
6659 * 3 2 1
6660 * 10987654321098765432109876543210
6661 * 001000 x1110000101
6662 * rt -----
6663 * rs -----
6664 * rd -----
6665 */
6666std::string NMD::DROTX(uint64 instruction)
6667{
6668 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6669 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803
AM		 6670 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6671 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
89a955e8
AM		 6672
6673 std::string rt = GPR(copy(rt_value));
6674 std::string rs = GPR(copy(rs_value));
6675 std::string shift = IMMEDIATE(copy(shift_value));
6676 std::string shiftx = IMMEDIATE(copy(shiftx_value));
6677
6678 return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
6679}
6680
6681
6682/*
6683 * DSLL -
6684 *
6685 * 3 2 1
6686 * 10987654321098765432109876543210
6687 * 10o000 1100xxx0000
6688 * rt -----
6689 * rs -----
6690 * shift -----
6691 */
6692std::string NMD::DSLL(uint64 instruction)
6693{
6694 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6695 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6696 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6697
6698 std::string rt = GPR(copy(rt_value));
6699 std::string rs = GPR(copy(rs_value));
6700 std::string shift = IMMEDIATE(copy(shift_value));
6701
6702 return img::format("DSLL %s, %s, %s", rt, rs, shift);
6703}
6704
6705
6706/*
6707 * DSLL[32] -
6708 *
6709 * 3 2 1
6710 * 10987654321098765432109876543210
6711 * 10o000 1100xxx0000
6712 * rt -----
6713 * rs -----
6714 * shift -----
6715 */
6716std::string NMD::DSLL32(uint64 instruction)
6717{
6718 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6720 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6721
6722 std::string rt = GPR(copy(rt_value));
6723 std::string rs = GPR(copy(rs_value));
6724 std::string shift = IMMEDIATE(copy(shift_value));
6725
6726 return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
6727}
6728
6729
6730/*
6731 *
6732 *
6733 * 3 2 1
6734 * 10987654321098765432109876543210
6735 * 001000 x1110000101
6736 * rt -----
6737 * rs -----
6738 * rd -----
6739 */
6740std::string NMD::DSLLV(uint64 instruction)
6741{
6742 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6743 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6744 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6745
6746 std::string rd = GPR(copy(rd_value));
6747 std::string rs = GPR(copy(rs_value));
6748 std::string rt = GPR(copy(rt_value));
6749
6750 return img::format("DSLLV %s, %s, %s", rd, rs, rt);
6751}
6752
6753
6754/*
6755 * DSRA -
6756 *
6757 * 3 2 1
6758 * 10987654321098765432109876543210
6759 * 10o000 1100xxx0100
6760 * rt -----
6761 * rs -----
6762 * shift -----
6763 */
6764std::string NMD::DSRA(uint64 instruction)
6765{
6766 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6767 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6768 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6769
6770 std::string rt = GPR(copy(rt_value));
6771 std::string rs = GPR(copy(rs_value));
6772 std::string shift = IMMEDIATE(copy(shift_value));
6773
6774 return img::format("DSRA %s, %s, %s", rt, rs, shift);
6775}
6776
6777
6778/*
6779 * DSRA[32] -
6780 *
6781 * 3 2 1
6782 * 10987654321098765432109876543210
6783 * 10o000 1100xxx0100
6784 * rt -----
6785 * rs -----
6786 * shift -----
6787 */
6788std::string NMD::DSRA32(uint64 instruction)
6789{
6790 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6791 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6792 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6793
6794 std::string rt = GPR(copy(rt_value));
6795 std::string rs = GPR(copy(rs_value));
6796 std::string shift = IMMEDIATE(copy(shift_value));
6797
6798 return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
6799}
6800
6801
6802/*
6803 *
6804 *
6805 * 3 2 1
6806 * 10987654321098765432109876543210
6807 * 001000 x1110000101
6808 * rt -----
6809 * rs -----
6810 * rd -----
6811 */
6812std::string NMD::DSRAV(uint64 instruction)
6813{
6814 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6815 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6816 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6817
6818 std::string rd = GPR(copy(rd_value));
6819 std::string rs = GPR(copy(rs_value));
6820 std::string rt = GPR(copy(rt_value));
6821
6822 return img::format("DSRAV %s, %s, %s", rd, rs, rt);
6823}
6824
6825
6826/*
6827 * DSRL -
6828 *
6829 * 3 2 1
6830 * 10987654321098765432109876543210
6831 * 10o000 1100xxx0100
6832 * rt -----
6833 * rs -----
6834 * shift -----
6835 */
6836std::string NMD::DSRL(uint64 instruction)
6837{
6838 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6839 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6840 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6841
6842 std::string rt = GPR(copy(rt_value));
6843 std::string rs = GPR(copy(rs_value));
6844 std::string shift = IMMEDIATE(copy(shift_value));
6845
6846 return img::format("DSRL %s, %s, %s", rt, rs, shift);
6847}
6848
6849
6850/*
6851 * DSRL[32] -
6852 *
6853 * 3 2 1
6854 * 10987654321098765432109876543210
6855 * 10o000 1100xxx0010
6856 * rt -----
6857 * rs -----
6858 * shift -----
6859 */
6860std::string NMD::DSRL32(uint64 instruction)
6861{
6862 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6863 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6864 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 6865
6866 std::string rt = GPR(copy(rt_value));
6867 std::string rs = GPR(copy(rs_value));
6868 std::string shift = IMMEDIATE(copy(shift_value));
6869
6870 return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
6871}
6872
6873
6874/*
6875 *
6876 *
6877 * 3 2 1
6878 * 10987654321098765432109876543210
6879 * 001000 x1110000101
6880 * rt -----
6881 * rs -----
6882 * rd -----
6883 */
6884std::string NMD::DSRLV(uint64 instruction)
6885{
6886 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6887 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6888 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6889
6890 std::string rd = GPR(copy(rd_value));
6891 std::string rs = GPR(copy(rs_value));
6892 std::string rt = GPR(copy(rt_value));
6893
6894 return img::format("DSRLV %s, %s, %s", rd, rs, rt);
6895}
6896
6897
6898/*
6899 *
6900 *
6901 * 3 2 1
6902 * 10987654321098765432109876543210
6903 * 001000 x1110000101
6904 * rt -----
6905 * rs -----
6906 * rd -----
6907 */
6908std::string NMD::DSUB(uint64 instruction)
6909{
6910 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6911 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6912 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6913
6914 std::string rd = GPR(copy(rd_value));
6915 std::string rs = GPR(copy(rs_value));
6916 std::string rt = GPR(copy(rt_value));
6917
6918 return img::format("DSUB %s, %s, %s", rd, rs, rt);
6919}
6920
6921
6922/*
6923 *
6924 *
6925 * 3 2 1
6926 * 10987654321098765432109876543210
6927 * 001000 x1110000101
6928 * rt -----
6929 * rs -----
6930 * rd -----
6931 */
6932std::string NMD::DSUBU(uint64 instruction)
6933{
6934 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 6935 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 6936 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 6937
6938 std::string rd = GPR(copy(rd_value));
6939 std::string rs = GPR(copy(rs_value));
6940 std::string rt = GPR(copy(rt_value));
6941
6942 return img::format("DSUBU %s, %s, %s", rd, rs, rt);
6943}
6944
6945
6946/*
6947 *
6948 *
6949 * 3 2 1
6950 * 10987654321098765432109876543210
6951 * 001000 x1110000101
6952 * rt -----
6953 * rs -----
6954 * rd -----
6955 */
6956std::string NMD::DVPE(uint64 instruction)
6957{
6958 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6959
6960 std::string rt = GPR(copy(rt_value));
6961
6962 return img::format("DVPE %s", rt);
6963}
6964
6965
6966/*
6967 *
6968 *
6969 * 3 2 1
6970 * 10987654321098765432109876543210
6971 * 001000 x1110000101
6972 * rt -----
6973 * rs -----
6974 * rd -----
6975 */
6976std::string NMD::DVP(uint64 instruction)
6977{
6978 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6979
6980 std::string rt = GPR(copy(rt_value));
6981
6982 return img::format("DVP %s", rt);
6983}
6984
6985
6986/*
6987 *
6988 *
6989 * 3 2 1
6990 * 10987654321098765432109876543210
6991 * 001000 x1110000101
6992 * rt -----
6993 * rs -----
6994 * rd -----
6995 */
6996std::string NMD::EHB(uint64 instruction)
6997{
6998 (void)instruction;
6999
7000 return "EHB ";
7001}
7002
7003
7004/*
7005 *
7006 *
7007 * 3 2 1
7008 * 10987654321098765432109876543210
7009 * 001000 x1110000101
7010 * rt -----
7011 * rs -----
7012 * rd -----
7013 */
7014std::string NMD::EI(uint64 instruction)
7015{
7016 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7017
7018 std::string rt = GPR(copy(rt_value));
7019
7020 return img::format("EI %s", rt);
7021}
7022
7023
7024/*
7025 *
7026 *
7027 * 3 2 1
7028 * 10987654321098765432109876543210
7029 * 001000 x1110000101
7030 * rt -----
7031 * rs -----
7032 * rd -----
7033 */
7034std::string NMD::EMT(uint64 instruction)
7035{
7036 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7037
7038 std::string rt = GPR(copy(rt_value));
7039
7040 return img::format("EMT %s", rt);
7041}
7042
7043
7044/*
7045 *
7046 *
7047 * 3 2 1
7048 * 10987654321098765432109876543210
7049 * 001000 x1110000101
7050 * rt -----
7051 * rs -----
7052 * rd -----
7053 */
7054std::string NMD::ERET(uint64 instruction)
7055{
7056 (void)instruction;
7057
7058 return "ERET ";
7059}
7060
7061
7062/*
7063 *
7064 *
7065 * 3 2 1
7066 * 10987654321098765432109876543210
7067 * 001000 x1110000101
7068 * rt -----
7069 * rs -----
7070 * rd -----
7071 */
7072std::string NMD::ERETNC(uint64 instruction)
7073{
7074 (void)instruction;
7075
7076 return "ERETNC ";
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::EVP(uint64 instruction)
7091{
7092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7093
7094 std::string rt = GPR(copy(rt_value));
7095
7096 return img::format("EVP %s", rt);
7097}
7098
7099
7100/*
7101 *
7102 *
7103 * 3 2 1
7104 * 10987654321098765432109876543210
7105 * 001000 x1110000101
7106 * rt -----
7107 * rs -----
7108 * rd -----
7109 */
7110std::string NMD::EVPE(uint64 instruction)
7111{
7112 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7113
7114 std::string rt = GPR(copy(rt_value));
7115
7116 return img::format("EVPE %s", rt);
7117}
7118
7119
7120/*
7121 *
7122 *
7123 * 3 2 1
7124 * 10987654321098765432109876543210
7125 * 001000 x1110000101
7126 * rt -----
7127 * rs -----
7128 * rd -----
7129 */
7130std::string NMD::EXT(uint64 instruction)
7131{
7132 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
75199b40 7133 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 7134 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7135 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 7136
7137 std::string rt = GPR(copy(rt_value));
7138 std::string rs = GPR(copy(rs_value));
7139 std::string lsb = IMMEDIATE(copy(lsb_value));
7140 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
7141
7142 return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
7143}
7144
7145
7146/*
7147 *
7148 *
7149 * 3 2 1
7150 * 10987654321098765432109876543210
7151 * 001000 x1110000101
7152 * rt -----
7153 * rs -----
7154 * rd -----
7155 */
7156std::string NMD::EXTD(uint64 instruction)
7157{
7158 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7159 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7160 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
75199b40 7161 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
89a955e8
AM		 7162
7163 std::string rd = GPR(copy(rd_value));
7164 std::string rs = GPR(copy(rs_value));
7165 std::string rt = GPR(copy(rt_value));
7166 std::string shift = IMMEDIATE(copy(shift_value));
7167
7168 return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
7169}
7170
7171
7172/*
7173 *
7174 *
7175 * 3 2 1
7176 * 10987654321098765432109876543210
7177 * 001000 x1110000101
7178 * rt -----
7179 * rs -----
7180 * rd -----
7181 */
7182std::string NMD::EXTD32(uint64 instruction)
7183{
7184 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7185 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7186 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
75199b40 7187 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
89a955e8
AM		 7188
7189 std::string rd = GPR(copy(rd_value));
7190 std::string rs = GPR(copy(rs_value));
7191 std::string rt = GPR(copy(rt_value));
7192 std::string shift = IMMEDIATE(copy(shift_value));
7193
7194 return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
7195}
7196
7197
7198/*
7199 *
7200 *
7201 * 3 2 1
7202 * 10987654321098765432109876543210
7203 * 001000 x1110000101
7204 * rt -----
7205 * rs -----
7206 * rd -----
7207 */
7208std::string NMD::EXTPDP(uint64 instruction)
7209{
7210 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7211 uint64 size_value = extract_size_20_19_18_17_16(instruction);
75199b40 7212 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7213
7214 std::string rt = GPR(copy(rt_value));
7215 std::string ac = AC(copy(ac_value));
7216 std::string size = IMMEDIATE(copy(size_value));
7217
7218 return img::format("EXTPDP %s, %s, %s", rt, ac, size);
7219}
7220
7221
7222/*
7223 *
7224 *
7225 * 3 2 1
7226 * 10987654321098765432109876543210
7227 * 001000 x1110000101
7228 * rt -----
7229 * rs -----
7230 * rd -----
7231 */
7232std::string NMD::EXTPDPV(uint64 instruction)
7233{
7234 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7235 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7236 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7237
7238 std::string rt = GPR(copy(rt_value));
7239 std::string ac = AC(copy(ac_value));
7240 std::string rs = GPR(copy(rs_value));
7241
7242 return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
7243}
7244
7245
7246/*
7247 *
7248 *
7249 * 3 2 1
7250 * 10987654321098765432109876543210
7251 * 001000 x1110000101
7252 * rt -----
7253 * rs -----
7254 * rd -----
7255 */
7256std::string NMD::EXTP(uint64 instruction)
7257{
7258 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7259 uint64 size_value = extract_size_20_19_18_17_16(instruction);
75199b40 7260 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7261
7262 std::string rt = GPR(copy(rt_value));
7263 std::string ac = AC(copy(ac_value));
7264 std::string size = IMMEDIATE(copy(size_value));
7265
7266 return img::format("EXTP %s, %s, %s", rt, ac, size);
7267}
7268
7269
7270/*
7271 *
7272 *
7273 * 3 2 1
7274 * 10987654321098765432109876543210
7275 * 001000 x1110000101
7276 * rt -----
7277 * rs -----
7278 * rd -----
7279 */
7280std::string NMD::EXTPV(uint64 instruction)
7281{
7282 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7283 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7284 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7285
7286 std::string rt = GPR(copy(rt_value));
7287 std::string ac = AC(copy(ac_value));
7288 std::string rs = GPR(copy(rs_value));
7289
7290 return img::format("EXTPV %s, %s, %s", rt, ac, rs);
7291}
7292
7293
7294/*
7295 *
7296 *
7297 * 3 2 1
7298 * 10987654321098765432109876543210
7299 * 001000 x1110000101
7300 * rt -----
7301 * rs -----
7302 * rd -----
7303 */
7304std::string NMD::EXTR_RS_W(uint64 instruction)
7305{
7306 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7307 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7308 uint64 ac_value = extract_ac_13_12(instruction);
7309
7310 std::string rt = GPR(copy(rt_value));
7311 std::string ac = AC(copy(ac_value));
7312 std::string shift = IMMEDIATE(copy(shift_value));
7313
7314 return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
7315}
7316
7317
7318/*
7319 *
7320 *
7321 * 3 2 1
7322 * 10987654321098765432109876543210
7323 * 001000 x1110000101
7324 * rt -----
7325 * rs -----
7326 * rd -----
7327 */
7328std::string NMD::EXTR_R_W(uint64 instruction)
7329{
7330 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7331 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7332 uint64 ac_value = extract_ac_13_12(instruction);
7333
7334 std::string rt = GPR(copy(rt_value));
7335 std::string ac = AC(copy(ac_value));
7336 std::string shift = IMMEDIATE(copy(shift_value));
7337
7338 return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
7339}
7340
7341
7342/*
7343 *
7344 *
7345 * 3 2 1
7346 * 10987654321098765432109876543210
7347 * 001000 x1110000101
7348 * rt -----
7349 * rs -----
7350 * rd -----
7351 */
7352std::string NMD::EXTR_S_H(uint64 instruction)
7353{
7354 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7355 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7356 uint64 ac_value = extract_ac_13_12(instruction);
7357
7358 std::string rt = GPR(copy(rt_value));
7359 std::string ac = AC(copy(ac_value));
7360 std::string shift = IMMEDIATE(copy(shift_value));
7361
7362 return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
7363}
7364
7365
7366/*
7367 *
7368 *
7369 * 3 2 1
7370 * 10987654321098765432109876543210
7371 * 001000 x1110000101
7372 * rt -----
7373 * rs -----
7374 * rd -----
7375 */
7376std::string NMD::EXTR_W(uint64 instruction)
7377{
7378 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7379 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7380 uint64 ac_value = extract_ac_13_12(instruction);
7381
7382 std::string rt = GPR(copy(rt_value));
7383 std::string ac = AC(copy(ac_value));
7384 std::string shift = IMMEDIATE(copy(shift_value));
7385
7386 return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
7387}
7388
7389
7390/*
7391 *
7392 *
7393 * 3 2 1
7394 * 10987654321098765432109876543210
7395 * 001000 x1110000101
7396 * rt -----
7397 * rs -----
7398 * rd -----
7399 */
7400std::string NMD::EXTRV_RS_W(uint64 instruction)
7401{
7402 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7403 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7404 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7405
7406 std::string rt = GPR(copy(rt_value));
7407 std::string ac = AC(copy(ac_value));
7408 std::string rs = GPR(copy(rs_value));
7409
7410 return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7411}
7412
7413
7414/*
7415 *
7416 *
7417 * 3 2 1
7418 * 10987654321098765432109876543210
7419 * 001000 x1110000101
7420 * rt -----
7421 * rs -----
7422 * rd -----
7423 */
7424std::string NMD::EXTRV_R_W(uint64 instruction)
7425{
7426 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7427 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7428 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7429
7430 std::string rt = GPR(copy(rt_value));
7431 std::string ac = AC(copy(ac_value));
7432 std::string rs = GPR(copy(rs_value));
7433
7434 return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7435}
7436
7437
7438/*
7439 *
7440 *
7441 * 3 2 1
7442 * 10987654321098765432109876543210
7443 * 001000 x1110000101
7444 * rt -----
7445 * rs -----
7446 * rd -----
7447 */
7448std::string NMD::EXTRV_S_H(uint64 instruction)
7449{
7450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7452 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7453
7454 std::string rt = GPR(copy(rt_value));
7455 std::string ac = AC(copy(ac_value));
7456 std::string rs = GPR(copy(rs_value));
7457
7458 return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7459}
7460
7461
7462/*
7463 *
7464 *
7465 * 3 2 1
7466 * 10987654321098765432109876543210
7467 * 001000 x1110000101
7468 * rt -----
7469 * rs -----
7470 * rd -----
7471 */
7472std::string NMD::EXTRV_W(uint64 instruction)
7473{
7474 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7475 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7476 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 7477
7478 std::string rt = GPR(copy(rt_value));
7479 std::string ac = AC(copy(ac_value));
7480 std::string rs = GPR(copy(rs_value));
7481
7482 return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
7483}
7484
7485
7486/*
7487 * EXTW - Extract Word
7488 *
7489 * 3 2 1
7490 * 10987654321098765432109876543210
7491 * 001000 011111
7492 * rt -----
7493 * rs -----
7494 * rd -----
7495 * shift -----
7496 */
7497std::string NMD::EXTW(uint64 instruction)
7498{
7499 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7500 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7501 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
75199b40 7502 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
89a955e8
AM		 7503
7504 std::string rd = GPR(copy(rd_value));
7505 std::string rs = GPR(copy(rs_value));
7506 std::string rt = GPR(copy(rt_value));
7507 std::string shift = IMMEDIATE(copy(shift_value));
7508
7509 return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
7510}
7511
7512
7513/*
7514 *
7515 *
7516 * 3 2 1
7517 * 10987654321098765432109876543210
7518 * 001000 x1110000101
7519 * rt -----
7520 * rs -----
7521 * rd -----
7522 */
7523std::string NMD::FLOOR_L_D(uint64 instruction)
7524{
17ce2f00 7525 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 7526 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 7527
7528 std::string ft = FPR(copy(ft_value));
7529 std::string fs = FPR(copy(fs_value));
7530
7531 return img::format("FLOOR.L.D %s, %s", ft, fs);
7532}
7533
7534
7535/*
7536 *
7537 *
7538 * 3 2 1
7539 * 10987654321098765432109876543210
7540 * 001000 x1110000101
7541 * rt -----
7542 * rs -----
7543 * rd -----
7544 */
7545std::string NMD::FLOOR_L_S(uint64 instruction)
7546{
17ce2f00 7547 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 7548 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 7549
7550 std::string ft = FPR(copy(ft_value));
7551 std::string fs = FPR(copy(fs_value));
7552
7553 return img::format("FLOOR.L.S %s, %s", ft, fs);
7554}
7555
7556
7557/*
7558 *
7559 *
7560 * 3 2 1
7561 * 10987654321098765432109876543210
7562 * 001000 x1110000101
7563 * rt -----
7564 * rs -----
7565 * rd -----
7566 */
7567std::string NMD::FLOOR_W_D(uint64 instruction)
7568{
17ce2f00 7569 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 7570 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 7571
7572 std::string ft = FPR(copy(ft_value));
7573 std::string fs = FPR(copy(fs_value));
7574
7575 return img::format("FLOOR.W.D %s, %s", ft, fs);
7576}
7577
7578
7579/*
7580 *
7581 *
7582 * 3 2 1
7583 * 10987654321098765432109876543210
7584 * 001000 x1110000101
7585 * rt -----
7586 * rs -----
7587 * rd -----
7588 */
7589std::string NMD::FLOOR_W_S(uint64 instruction)
7590{
17ce2f00 7591 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 7592 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 7593
7594 std::string ft = FPR(copy(ft_value));
7595 std::string fs = FPR(copy(fs_value));
7596
7597 return img::format("FLOOR.W.S %s, %s", ft, fs);
7598}
7599
7600
7601/*
7602 *
7603 *
7604 * 3 2 1
7605 * 10987654321098765432109876543210
7606 * 001000 x1110000101
7607 * rt -----
7608 * rs -----
7609 * rd -----
7610 */
7611std::string NMD::FORK(uint64 instruction)
7612{
7613 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7614 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7615 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 7616
7617 std::string rd = GPR(copy(rd_value));
7618 std::string rs = GPR(copy(rs_value));
7619 std::string rt = GPR(copy(rt_value));
7620
7621 return img::format("FORK %s, %s, %s", rd, rs, rt);
7622}
7623
7624
7625/*
7626 *
7627 *
7628 * 3 2 1
7629 * 10987654321098765432109876543210
7630 * 001000 x1110000101
7631 * rt -----
7632 * rs -----
7633 * rd -----
7634 */
7635std::string NMD::HYPCALL(uint64 instruction)
7636{
7637 uint64 code_value = extract_code_17_to_0(instruction);
7638
7639 std::string code = IMMEDIATE(copy(code_value));
7640
7641 return img::format("HYPCALL %s", code);
7642}
7643
7644
7645/*
7646 *
7647 *
7648 * 3 2 1
7649 * 10987654321098765432109876543210
7650 * 001000 x1110000101
7651 * rt -----
7652 * rs -----
7653 * rd -----
7654 */
7655std::string NMD::HYPCALL_16_(uint64 instruction)
7656{
7657 uint64 code_value = extract_code_1_0(instruction);
7658
7659 std::string code = IMMEDIATE(copy(code_value));
7660
7661 return img::format("HYPCALL %s", code);
7662}
7663
7664
7665/*
7666 *
7667 *
7668 * 3 2 1
7669 * 10987654321098765432109876543210
7670 * 001000 x1110000101
7671 * rt -----
7672 * rs -----
7673 * rd -----
7674 */
7675std::string NMD::INS(uint64 instruction)
7676{
7677 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
75199b40 7678 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
89a955e8
AM		 7679 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7680 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
89a955e8
AM		 7681
7682 std::string rt = GPR(copy(rt_value));
7683 std::string rs = GPR(copy(rs_value));
7684 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
7685 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
7686 /* !!!!!!!!!! - no conversion function */
7687
7688 return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
7689 /* hand edited */
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::INSV(uint64 instruction)
7704{
7705 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7706 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7707
7708 std::string rt = GPR(copy(rt_value));
7709 std::string rs = GPR(copy(rs_value));
7710
7711 return img::format("INSV %s, %s", rt, rs);
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::IRET(uint64 instruction)
7726{
7727 (void)instruction;
7728
7729 return "IRET ";
7730}
7731
7732
7733/*
7734 *
7735 *
7736 * 3 2 1
7737 * 10987654321098765432109876543210
7738 * 001000 x1110000101
7739 * rt -----
7740 * rs -----
7741 * rd -----
7742 */
7743std::string NMD::JALRC_16_(uint64 instruction)
7744{
7745 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7746
7747 std::string rt = GPR(copy(rt_value));
7748
7749 return img::format("JALRC $%d, %s", 31, rt);
7750}
7751
7752
7753/*
7754 *
7755 *
7756 * 3 2 1
7757 * 10987654321098765432109876543210
7758 * 001000 x1110000101
7759 * rt -----
7760 * rs -----
7761 * rd -----
7762 */
7763std::string NMD::JALRC_32_(uint64 instruction)
7764{
7765 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7766 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7767
7768 std::string rt = GPR(copy(rt_value));
7769 std::string rs = GPR(copy(rs_value));
7770
7771 return img::format("JALRC %s, %s", rt, rs);
7772}
7773
7774
7775/*
7776 *
7777 *
7778 * 3 2 1
7779 * 10987654321098765432109876543210
7780 * 001000 x1110000101
7781 * rt -----
7782 * rs -----
7783 * rd -----
7784 */
7785std::string NMD::JALRC_HB(uint64 instruction)
7786{
7787 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7788 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7789
7790 std::string rt = GPR(copy(rt_value));
7791 std::string rs = GPR(copy(rs_value));
7792
7793 return img::format("JALRC.HB %s, %s", rt, rs);
7794}
7795
7796
7797/*
7798 *
7799 *
7800 * 3 2 1
7801 * 10987654321098765432109876543210
7802 * 001000 x1110000101
7803 * rt -----
7804 * rs -----
7805 * rd -----
7806 */
7807std::string NMD::JRC(uint64 instruction)
7808{
7809 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7810
7811 std::string rt = GPR(copy(rt_value));
7812
7813 return img::format("JRC %s", rt);
7814}
7815
7816
7817/*
7818 *
7819 *
7820 * 3 2 1
7821 * 10987654321098765432109876543210
7822 * 001000 x1110000101
7823 * rt -----
7824 * rs -----
7825 * rd -----
7826 */
7827std::string NMD::LB_16_(uint64 instruction)
7828{
89a955e8
AM		 7829 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7830 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 7831 uint64 u_value = extract_u_1_0(instruction);
89a955e8 7832
988d6c89 7833 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8 7834 std::string u = IMMEDIATE(copy(u_value));
988d6c89 7835 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 7836
7837 return img::format("LB %s, %s(%s)", rt3, u, rs3);
7838}
7839
7840
7841/*
7842 *
7843 *
7844 * 3 2 1
7845 * 10987654321098765432109876543210
7846 * 001000 x1110000101
7847 * rt -----
7848 * rs -----
7849 * rd -----
7850 */
7851std::string NMD::LB_GP_(uint64 instruction)
7852{
7853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7854 uint64 u_value = extract_u_17_to_0(instruction);
7855
7856 std::string rt = GPR(copy(rt_value));
7857 std::string u = IMMEDIATE(copy(u_value));
7858
7859 return img::format("LB %s, %s($%d)", rt, u, 28);
7860}
7861
7862
7863/*
7864 *
7865 *
7866 * 3 2 1
7867 * 10987654321098765432109876543210
7868 * 001000 x1110000101
7869 * rt -----
7870 * rs -----
7871 * rd -----
7872 */
7873std::string NMD::LB_S9_(uint64 instruction)
7874{
7875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7876 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 7877 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 7878
7879 std::string rt = GPR(copy(rt_value));
7880 std::string s = IMMEDIATE(copy(s_value));
7881 std::string rs = GPR(copy(rs_value));
7882
7883 return img::format("LB %s, %s(%s)", rt, s, rs);
7884}
7885
7886
7887/*
7888 *
7889 *
7890 * 3 2 1
7891 * 10987654321098765432109876543210
7892 * 001000 x1110000101
7893 * rt -----
7894 * rs -----
7895 * rd -----
7896 */
7897std::string NMD::LB_U12_(uint64 instruction)
7898{
7899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7900 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 7901 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 7902
7903 std::string rt = GPR(copy(rt_value));
7904 std::string u = IMMEDIATE(copy(u_value));
7905 std::string rs = GPR(copy(rs_value));
7906
7907 return img::format("LB %s, %s(%s)", rt, u, rs);
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::LBE(uint64 instruction)
7922{
7923 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7924 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 7925 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 7926
7927 std::string rt = GPR(copy(rt_value));
7928 std::string s = IMMEDIATE(copy(s_value));
7929 std::string rs = GPR(copy(rs_value));
7930
7931 return img::format("LBE %s, %s(%s)", rt, s, rs);
7932}
7933
7934
7935/*
7936 *
7937 *
7938 * 3 2 1
7939 * 10987654321098765432109876543210
7940 * 001000 x1110000101
7941 * rt -----
7942 * rs -----
7943 * rd -----
7944 */
7945std::string NMD::LBU_16_(uint64 instruction)
7946{
89a955e8
AM		 7947 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7948 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 7949 uint64 u_value = extract_u_1_0(instruction);
89a955e8 7950
988d6c89 7951 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8 7952 std::string u = IMMEDIATE(copy(u_value));
988d6c89 7953 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 7954
7955 return img::format("LBU %s, %s(%s)", rt3, u, rs3);
7956}
7957
7958
7959/*
7960 *
7961 *
7962 * 3 2 1
7963 * 10987654321098765432109876543210
7964 * 001000 x1110000101
7965 * rt -----
7966 * rs -----
7967 * rd -----
7968 */
7969std::string NMD::LBU_GP_(uint64 instruction)
7970{
7971 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7972 uint64 u_value = extract_u_17_to_0(instruction);
7973
7974 std::string rt = GPR(copy(rt_value));
7975 std::string u = IMMEDIATE(copy(u_value));
7976
7977 return img::format("LBU %s, %s($%d)", rt, u, 28);
7978}
7979
7980
7981/*
7982 *
7983 *
7984 * 3 2 1
7985 * 10987654321098765432109876543210
7986 * 001000 x1110000101
7987 * rt -----
7988 * rs -----
7989 * rd -----
7990 */
7991std::string NMD::LBU_S9_(uint64 instruction)
7992{
7993 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 7994 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 7995 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 7996
7997 std::string rt = GPR(copy(rt_value));
7998 std::string s = IMMEDIATE(copy(s_value));
7999 std::string rs = GPR(copy(rs_value));
8000
8001 return img::format("LBU %s, %s(%s)", rt, s, rs);
8002}
8003
8004
8005/*
8006 *
8007 *
8008 * 3 2 1
8009 * 10987654321098765432109876543210
8010 * 001000 x1110000101
8011 * rt -----
8012 * rs -----
8013 * rd -----
8014 */
8015std::string NMD::LBU_U12_(uint64 instruction)
8016{
8017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8018 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8019 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8020
8021 std::string rt = GPR(copy(rt_value));
8022 std::string u = IMMEDIATE(copy(u_value));
8023 std::string rs = GPR(copy(rs_value));
8024
8025 return img::format("LBU %s, %s(%s)", rt, u, rs);
8026}
8027
8028
8029/*
8030 *
8031 *
8032 * 3 2 1
8033 * 10987654321098765432109876543210
8034 * 001000 x1110000101
8035 * rt -----
8036 * rs -----
8037 * rd -----
8038 */
8039std::string NMD::LBUE(uint64 instruction)
8040{
8041 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8042 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8043 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8044
8045 std::string rt = GPR(copy(rt_value));
8046 std::string s = IMMEDIATE(copy(s_value));
8047 std::string rs = GPR(copy(rs_value));
8048
8049 return img::format("LBUE %s, %s(%s)", rt, s, rs);
8050}
8051
8052
8053/*
8054 *
8055 *
8056 * 3 2 1
8057 * 10987654321098765432109876543210
8058 * 001000 x1110000101
8059 * rt -----
8060 * rs -----
8061 * rd -----
8062 */
8063std::string NMD::LBUX(uint64 instruction)
8064{
8065 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8066 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8067 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8068
8069 std::string rd = GPR(copy(rd_value));
8070 std::string rs = GPR(copy(rs_value));
8071 std::string rt = GPR(copy(rt_value));
8072
8073 return img::format("LBUX %s, %s(%s)", rd, rs, rt);
8074}
8075
8076
8077/*
8078 *
8079 *
8080 * 3 2 1
8081 * 10987654321098765432109876543210
8082 * 001000 x1110000101
8083 * rt -----
8084 * rs -----
8085 * rd -----
8086 */
8087std::string NMD::LBX(uint64 instruction)
8088{
8089 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8090 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8091 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8092
8093 std::string rd = GPR(copy(rd_value));
8094 std::string rs = GPR(copy(rs_value));
8095 std::string rt = GPR(copy(rt_value));
8096
8097 return img::format("LBX %s, %s(%s)", rd, rs, rt);
8098}
8099
8100
8101/*
8102 *
8103 *
8104 * 3 2 1
8105 * 10987654321098765432109876543210
8106 * 001000 x1110000101
8107 * rt -----
8108 * rs -----
8109 * rd -----
8110 */
8111std::string NMD::LD_GP_(uint64 instruction)
8112{
8113 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 8114 uint64 u_value = extract_u_20_to_3__s3(instruction);
89a955e8
AM		 8115
8116 std::string rt = GPR(copy(rt_value));
8117 std::string u = IMMEDIATE(copy(u_value));
8118
8119 return img::format("LD %s, %s($%d)", rt, u, 28);
8120}
8121
8122
8123/*
8124 *
8125 *
8126 * 3 2 1
8127 * 10987654321098765432109876543210
8128 * 001000 x1110000101
8129 * rt -----
8130 * rs -----
8131 * rd -----
8132 */
8133std::string NMD::LD_S9_(uint64 instruction)
8134{
8135 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8136 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8137 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8138
8139 std::string rt = GPR(copy(rt_value));
8140 std::string s = IMMEDIATE(copy(s_value));
8141 std::string rs = GPR(copy(rs_value));
8142
8143 return img::format("LD %s, %s(%s)", rt, s, rs);
8144}
8145
8146
8147/*
8148 *
8149 *
8150 * 3 2 1
8151 * 10987654321098765432109876543210
8152 * 001000 x1110000101
8153 * rt -----
8154 * rs -----
8155 * rd -----
8156 */
8157std::string NMD::LD_U12_(uint64 instruction)
8158{
8159 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8160 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8161 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8162
8163 std::string rt = GPR(copy(rt_value));
8164 std::string u = IMMEDIATE(copy(u_value));
8165 std::string rs = GPR(copy(rs_value));
8166
8167 return img::format("LD %s, %s(%s)", rt, u, rs);
8168}
8169
8170
8171/*
8172 *
8173 *
8174 * 3 2 1
8175 * 10987654321098765432109876543210
8176 * 001000 x1110000101
8177 * rt -----
8178 * rs -----
8179 * rd -----
8180 */
8181std::string NMD::LDC1_GP_(uint64 instruction)
8182{
17ce2f00 8183 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11b9732a 8184 uint64 u_value = extract_u_17_to_2__s2(instruction);
89a955e8
AM		 8185
8186 std::string ft = FPR(copy(ft_value));
8187 std::string u = IMMEDIATE(copy(u_value));
8188
8189 return img::format("LDC1 %s, %s($%d)", ft, u, 28);
8190}
8191
8192
8193/*
8194 *
8195 *
8196 * 3 2 1
8197 * 10987654321098765432109876543210
8198 * 001000 x1110000101
8199 * rt -----
8200 * rs -----
8201 * rd -----
8202 */
8203std::string NMD::LDC1_S9_(uint64 instruction)
8204{
17ce2f00 8205 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 8206 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8207 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8208
8209 std::string ft = FPR(copy(ft_value));
8210 std::string s = IMMEDIATE(copy(s_value));
8211 std::string rs = GPR(copy(rs_value));
8212
8213 return img::format("LDC1 %s, %s(%s)", ft, s, rs);
8214}
8215
8216
8217/*
8218 *
8219 *
8220 * 3 2 1
8221 * 10987654321098765432109876543210
8222 * 001000 x1110000101
8223 * rt -----
8224 * rs -----
8225 * rd -----
8226 */
8227std::string NMD::LDC1_U12_(uint64 instruction)
8228{
17ce2f00 8229 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 8230 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8231 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8232
8233 std::string ft = FPR(copy(ft_value));
8234 std::string u = IMMEDIATE(copy(u_value));
8235 std::string rs = GPR(copy(rs_value));
8236
8237 return img::format("LDC1 %s, %s(%s)", ft, u, rs);
8238}
8239
8240
8241/*
8242 *
8243 *
8244 * 3 2 1
8245 * 10987654321098765432109876543210
8246 * 001000 x1110000101
8247 * rt -----
8248 * rs -----
8249 * rd -----
8250 */
8251std::string NMD::LDC1XS(uint64 instruction)
8252{
8253 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8254 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8255 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 8256
8257 std::string ft = FPR(copy(ft_value));
8258 std::string rs = GPR(copy(rs_value));
8259 std::string rt = GPR(copy(rt_value));
8260
8261 return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
8262}
8263
8264
8265/*
8266 *
8267 *
8268 * 3 2 1
8269 * 10987654321098765432109876543210
8270 * 001000 x1110000101
8271 * rt -----
8272 * rs -----
8273 * rd -----
8274 */
8275std::string NMD::LDC1X(uint64 instruction)
8276{
8277 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8278 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8279 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 8280
8281 std::string ft = FPR(copy(ft_value));
8282 std::string rs = GPR(copy(rs_value));
8283 std::string rt = GPR(copy(rt_value));
8284
8285 return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
8286}
8287
8288
8289/*
8290 *
8291 *
8292 * 3 2 1
8293 * 10987654321098765432109876543210
8294 * 001000 x1110000101
8295 * rt -----
8296 * rs -----
8297 * rd -----
8298 */
8299std::string NMD::LDC2(uint64 instruction)
8300{
89a955e8
AM		 8301 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8302 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8303 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8304
8305 std::string ct = CPR(copy(ct_value));
8306 std::string s = IMMEDIATE(copy(s_value));
8307 std::string rs = GPR(copy(rs_value));
8308
8309 return img::format("LDC2 %s, %s(%s)", ct, s, rs);
8310}
8311
8312
8313/*
8314 *
8315 *
8316 * 3 2 1
8317 * 10987654321098765432109876543210
8318 * 001000 x1110000101
8319 * rt -----
8320 * rs -----
8321 * rd -----
8322 */
8323std::string NMD::LDM(uint64 instruction)
8324{
8325 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8326 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 8327 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8328 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 8329
8330 std::string rt = GPR(copy(rt_value));
8331 std::string s = IMMEDIATE(copy(s_value));
8332 std::string rs = GPR(copy(rs_value));
8333 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
8334
8335 return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
8336}
8337
8338
8339/*
8340 *
8341 *
8342 * 3 2 1
8343 * 10987654321098765432109876543210
8344 * 001000 x1110000101
8345 * rt -----
8346 * rs -----
8347 * rd -----
8348 */
8349std::string NMD::LDPC_48_(uint64 instruction)
8350{
8351 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 8352 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 8353
8354 std::string rt = GPR(copy(rt_value));
8355 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
8356
8357 return img::format("LDPC %s, %s", rt, s);
8358}
8359
8360
8361/*
8362 *
8363 *
8364 * 3 2 1
8365 * 10987654321098765432109876543210
8366 * 001000 x1110000101
8367 * rt -----
8368 * rs -----
8369 * rd -----
8370 */
8371std::string NMD::LDX(uint64 instruction)
8372{
8373 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8374 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8375 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8376
8377 std::string rd = GPR(copy(rd_value));
8378 std::string rs = GPR(copy(rs_value));
8379 std::string rt = GPR(copy(rt_value));
8380
8381 return img::format("LDX %s, %s(%s)", rd, rs, rt);
8382}
8383
8384
8385/*
8386 *
8387 *
8388 * 3 2 1
8389 * 10987654321098765432109876543210
8390 * 001000 x1110000101
8391 * rt -----
8392 * rs -----
8393 * rd -----
8394 */
8395std::string NMD::LDXS(uint64 instruction)
8396{
8397 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8398 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8399 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8400
8401 std::string rd = GPR(copy(rd_value));
8402 std::string rs = GPR(copy(rs_value));
8403 std::string rt = GPR(copy(rt_value));
8404
8405 return img::format("LDXS %s, %s(%s)", rd, rs, rt);
8406}
8407
8408
8409/*
8410 *
8411 *
8412 * 3 2 1
8413 * 10987654321098765432109876543210
8414 * 001000 x1110000101
8415 * rt -----
8416 * rs -----
8417 * rd -----
8418 */
8419std::string NMD::LH_16_(uint64 instruction)
8420{
89a955e8
AM		 8421 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8422 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 8423 uint64 u_value = extract_u_2_1__s1(instruction);
89a955e8 8424
988d6c89 8425 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8 8426 std::string u = IMMEDIATE(copy(u_value));
988d6c89 8427 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 8428
8429 return img::format("LH %s, %s(%s)", rt3, u, rs3);
8430}
8431
8432
8433/*
8434 *
8435 *
8436 * 3 2 1
8437 * 10987654321098765432109876543210
8438 * 001000 x1110000101
8439 * rt -----
8440 * rs -----
8441 * rd -----
8442 */
8443std::string NMD::LH_GP_(uint64 instruction)
8444{
8445 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 8446 uint64 u_value = extract_u_17_to_1__s1(instruction);
89a955e8
AM		 8447
8448 std::string rt = GPR(copy(rt_value));
8449 std::string u = IMMEDIATE(copy(u_value));
8450
8451 return img::format("LH %s, %s($%d)", rt, u, 28);
8452}
8453
8454
8455/*
8456 *
8457 *
8458 * 3 2 1
8459 * 10987654321098765432109876543210
8460 * 001000 x1110000101
8461 * rt -----
8462 * rs -----
8463 * rd -----
8464 */
8465std::string NMD::LH_S9_(uint64 instruction)
8466{
8467 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8468 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8469 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8470
8471 std::string rt = GPR(copy(rt_value));
8472 std::string s = IMMEDIATE(copy(s_value));
8473 std::string rs = GPR(copy(rs_value));
8474
8475 return img::format("LH %s, %s(%s)", rt, s, rs);
8476}
8477
8478
8479/*
8480 *
8481 *
8482 * 3 2 1
8483 * 10987654321098765432109876543210
8484 * 001000 x1110000101
8485 * rt -----
8486 * rs -----
8487 * rd -----
8488 */
8489std::string NMD::LH_U12_(uint64 instruction)
8490{
8491 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8492 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8493 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8494
8495 std::string rt = GPR(copy(rt_value));
8496 std::string u = IMMEDIATE(copy(u_value));
8497 std::string rs = GPR(copy(rs_value));
8498
8499 return img::format("LH %s, %s(%s)", rt, u, rs);
8500}
8501
8502
8503/*
8504 *
8505 *
8506 * 3 2 1
8507 * 10987654321098765432109876543210
8508 * 001000 x1110000101
8509 * rt -----
8510 * rs -----
8511 * rd -----
8512 */
8513std::string NMD::LHE(uint64 instruction)
8514{
8515 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8516 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8517 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8518
8519 std::string rt = GPR(copy(rt_value));
8520 std::string s = IMMEDIATE(copy(s_value));
8521 std::string rs = GPR(copy(rs_value));
8522
8523 return img::format("LHE %s, %s(%s)", rt, s, rs);
8524}
8525
8526
8527/*
8528 *
8529 *
8530 * 3 2 1
8531 * 10987654321098765432109876543210
8532 * 001000 x1110000101
8533 * rt -----
8534 * rs -----
8535 * rd -----
8536 */
8537std::string NMD::LHU_16_(uint64 instruction)
8538{
89a955e8
AM		 8539 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8540 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 8541 uint64 u_value = extract_u_2_1__s1(instruction);
89a955e8 8542
988d6c89 8543 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8 8544 std::string u = IMMEDIATE(copy(u_value));
988d6c89 8545 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 8546
8547 return img::format("LHU %s, %s(%s)", rt3, u, rs3);
8548}
8549
8550
8551/*
8552 *
8553 *
8554 * 3 2 1
8555 * 10987654321098765432109876543210
8556 * 001000 x1110000101
8557 * rt -----
8558 * rs -----
8559 * rd -----
8560 */
8561std::string NMD::LHU_GP_(uint64 instruction)
8562{
8563 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 8564 uint64 u_value = extract_u_17_to_1__s1(instruction);
89a955e8
AM		 8565
8566 std::string rt = GPR(copy(rt_value));
8567 std::string u = IMMEDIATE(copy(u_value));
8568
8569 return img::format("LHU %s, %s($%d)", rt, u, 28);
8570}
8571
8572
8573/*
8574 *
8575 *
8576 * 3 2 1
8577 * 10987654321098765432109876543210
8578 * 001000 x1110000101
8579 * rt -----
8580 * rs -----
8581 * rd -----
8582 */
8583std::string NMD::LHU_S9_(uint64 instruction)
8584{
8585 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8586 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8587 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8588
8589 std::string rt = GPR(copy(rt_value));
8590 std::string s = IMMEDIATE(copy(s_value));
8591 std::string rs = GPR(copy(rs_value));
8592
8593 return img::format("LHU %s, %s(%s)", rt, s, rs);
8594}
8595
8596
8597/*
8598 *
8599 *
8600 * 3 2 1
8601 * 10987654321098765432109876543210
8602 * 001000 x1110000101
8603 * rt -----
8604 * rs -----
8605 * rd -----
8606 */
8607std::string NMD::LHU_U12_(uint64 instruction)
8608{
8609 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8611 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8612
8613 std::string rt = GPR(copy(rt_value));
8614 std::string u = IMMEDIATE(copy(u_value));
8615 std::string rs = GPR(copy(rs_value));
8616
8617 return img::format("LHU %s, %s(%s)", rt, u, rs);
8618}
8619
8620
8621/*
8622 *
8623 *
8624 * 3 2 1
8625 * 10987654321098765432109876543210
8626 * 001000 x1110000101
8627 * rt -----
8628 * rs -----
8629 * rd -----
8630 */
8631std::string NMD::LHUE(uint64 instruction)
8632{
8633 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8634 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8635 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 8636
8637 std::string rt = GPR(copy(rt_value));
8638 std::string s = IMMEDIATE(copy(s_value));
8639 std::string rs = GPR(copy(rs_value));
8640
8641 return img::format("LHUE %s, %s(%s)", rt, s, rs);
8642}
8643
8644
8645/*
8646 *
8647 *
8648 * 3 2 1
8649 * 10987654321098765432109876543210
8650 * 001000 x1110000101
8651 * rt -----
8652 * rs -----
8653 * rd -----
8654 */
8655std::string NMD::LHUX(uint64 instruction)
8656{
8657 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8658 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8659 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8660
8661 std::string rd = GPR(copy(rd_value));
8662 std::string rs = GPR(copy(rs_value));
8663 std::string rt = GPR(copy(rt_value));
8664
8665 return img::format("LHUX %s, %s(%s)", rd, rs, rt);
8666}
8667
8668
8669/*
8670 *
8671 *
8672 * 3 2 1
8673 * 10987654321098765432109876543210
8674 * 001000 x1110000101
8675 * rt -----
8676 * rs -----
8677 * rd -----
8678 */
8679std::string NMD::LHUXS(uint64 instruction)
8680{
8681 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8682 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8683 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8684
8685 std::string rd = GPR(copy(rd_value));
8686 std::string rs = GPR(copy(rs_value));
8687 std::string rt = GPR(copy(rt_value));
8688
8689 return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
8690}
8691
8692
8693/*
8694 *
8695 *
8696 * 3 2 1
8697 * 10987654321098765432109876543210
8698 * 001000 x1110000101
8699 * rt -----
8700 * rs -----
8701 * rd -----
8702 */
8703std::string NMD::LHXS(uint64 instruction)
8704{
8705 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8706 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8707 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8708
8709 std::string rd = GPR(copy(rd_value));
8710 std::string rs = GPR(copy(rs_value));
8711 std::string rt = GPR(copy(rt_value));
8712
8713 return img::format("LHXS %s, %s(%s)", rd, rs, rt);
8714}
8715
8716
8717/*
8718 *
8719 *
8720 * 3 2 1
8721 * 10987654321098765432109876543210
8722 * 001000 x1110000101
8723 * rt -----
8724 * rs -----
8725 * rd -----
8726 */
8727std::string NMD::LHX(uint64 instruction)
8728{
8729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8730 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8731 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 8732
8733 std::string rd = GPR(copy(rd_value));
8734 std::string rs = GPR(copy(rs_value));
8735 std::string rt = GPR(copy(rt_value));
8736
8737 return img::format("LHX %s, %s(%s)", rd, rs, rt);
8738}
8739
8740
8741/*
8742 *
8743 *
8744 * 3 2 1
8745 * 10987654321098765432109876543210
8746 * 001000 x1110000101
8747 * rt -----
8748 * rs -----
8749 * rd -----
8750 */
8751std::string NMD::LI_16_(uint64 instruction)
8752{
89a955e8 8753 uint64 rt3_value = extract_rt3_9_8_7(instruction);
75199b40 8754 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
89a955e8 8755
988d6c89 8756 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 8757 std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
8758
8759 return img::format("LI %s, %s", rt3, eu);
8760}
8761
8762
8763/*
8764 *
8765 *
8766 * 3 2 1
8767 * 10987654321098765432109876543210
8768 * 001000 x1110000101
8769 * rt -----
8770 * rs -----
8771 * rd -----
8772 */
8773std::string NMD::LI_48_(uint64 instruction)
8774{
8775 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 8776 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 8777
8778 std::string rt = GPR(copy(rt_value));
8779 std::string s = IMMEDIATE(copy(s_value));
8780
8781 return img::format("LI %s, %s", rt, s);
8782}
8783
8784
8785/*
8786 *
8787 *
8788 * 3 2 1
8789 * 10987654321098765432109876543210
8790 * 001000 x1110000101
8791 * rt -----
8792 * rs -----
8793 * rd -----
8794 */
8795std::string NMD::LL(uint64 instruction)
8796{
8797 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8798 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8799 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
89a955e8
AM		 8800
8801 std::string rt = GPR(copy(rt_value));
8802 std::string s = IMMEDIATE(copy(s_value));
8803 std::string rs = GPR(copy(rs_value));
8804
8805 return img::format("LL %s, %s(%s)", rt, s, rs);
8806}
8807
8808
8809/*
8810 *
8811 *
8812 * 3 2 1
8813 * 10987654321098765432109876543210
8814 * 001000 x1110000101
8815 * rt -----
8816 * rs -----
8817 * rd -----
8818 */
8819std::string NMD::LLD(uint64 instruction)
8820{
8821 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8822 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8823 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
89a955e8
AM		 8824
8825 std::string rt = GPR(copy(rt_value));
8826 std::string s = IMMEDIATE(copy(s_value));
8827 std::string rs = GPR(copy(rs_value));
8828
8829 return img::format("LLD %s, %s(%s)", rt, s, rs);
8830}
8831
8832
8833/*
8834 *
8835 *
8836 * 3 2 1
8837 * 10987654321098765432109876543210
8838 * 001000 x1110000101
8839 * rt -----
8840 * rs -----
8841 * rd -----
8842 */
8843std::string NMD::LLDP(uint64 instruction)
8844{
8845 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8846 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8847 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 8848
8849 std::string rt = GPR(copy(rt_value));
8850 std::string ru = GPR(copy(ru_value));
8851 std::string rs = GPR(copy(rs_value));
8852
8853 return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
8854}
8855
8856
8857/*
8858 *
8859 *
8860 * 3 2 1
8861 * 10987654321098765432109876543210
8862 * 001000 x1110000101
8863 * rt -----
8864 * rs -----
8865 * rd -----
8866 */
8867std::string NMD::LLE(uint64 instruction)
8868{
8869 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8870 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 8871 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
89a955e8
AM		 8872
8873 std::string rt = GPR(copy(rt_value));
8874 std::string s = IMMEDIATE(copy(s_value));
8875 std::string rs = GPR(copy(rs_value));
8876
8877 return img::format("LLE %s, %s(%s)", rt, s, rs);
8878}
8879
8880
8881/*
8882 *
8883 *
8884 * 3 2 1
8885 * 10987654321098765432109876543210
8886 * 001000 x1110000101
8887 * rt -----
8888 * rs -----
8889 * rd -----
8890 */
8891std::string NMD::LLWP(uint64 instruction)
8892{
8893 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8894 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8895 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 8896
8897 std::string rt = GPR(copy(rt_value));
8898 std::string ru = GPR(copy(ru_value));
8899 std::string rs = GPR(copy(rs_value));
8900
8901 return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
8902}
8903
8904
8905/*
8906 *
8907 *
8908 * 3 2 1
8909 * 10987654321098765432109876543210
8910 * 001000 x1110000101
8911 * rt -----
8912 * rs -----
8913 * rd -----
8914 */
8915std::string NMD::LLWPE(uint64 instruction)
8916{
8917 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 8918 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 8919 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 8920
8921 std::string rt = GPR(copy(rt_value));
8922 std::string ru = GPR(copy(ru_value));
8923 std::string rs = GPR(copy(rs_value));
8924
8925 return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
8926}
8927
8928
8929/*
8930 *
8931 *
8932 * 3 2 1
8933 * 10987654321098765432109876543210
8934 * 001000 x1110000101
8935 * rt -----
8936 * rs -----
8937 * rd -----
8938 */
8939std::string NMD::LSA(uint64 instruction)
8940{
8941 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
75199b40 8942 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
b4c5d21c 8943 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8 8944 uint64 u2_value = extract_u2_10_9(instruction);
89a955e8
AM		 8945
8946 std::string rd = GPR(copy(rd_value));
8947 std::string rs = GPR(copy(rs_value));
8948 std::string rt = GPR(copy(rt_value));
8949 std::string u2 = IMMEDIATE(copy(u2_value));
8950
8951 return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
8952}
8953
8954
8955/*
8956 *
8957 *
8958 * 3 2 1
8959 * 10987654321098765432109876543210
8960 * 001000 x1110000101
8961 * rt -----
8962 * rs -----
8963 * rd -----
8964 */
8965std::string NMD::LUI(uint64 instruction)
8966{
8967 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
d3605cc0 8968 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
89a955e8
AM		 8969
8970 std::string rt = GPR(copy(rt_value));
8971 std::string s = IMMEDIATE(copy(s_value));
8972
8973 return img::format("LUI %s, %%hi(%s)", rt, s);
8974}
8975
8976
8977/*
8978 *
8979 *
8980 * 3 2 1
8981 * 10987654321098765432109876543210
8982 * 001000 x1110000101
8983 * rt -----
8984 * rs -----
8985 * rd -----
8986 */
8987std::string NMD::LW_16_(uint64 instruction)
8988{
89a955e8
AM		 8989 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8990 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 8991 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
89a955e8 8992
988d6c89 8993 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8 8994 std::string u = IMMEDIATE(copy(u_value));
988d6c89 8995 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 8996
8997 return img::format("LW %s, %s(%s)", rt3, u, rs3);
8998}
8999
9000
9001/*
9002 *
9003 *
9004 * 3 2 1
9005 * 10987654321098765432109876543210
9006 * 001000 x1110000101
9007 * rt -----
9008 * rs -----
9009 * rd -----
9010 */
9011std::string NMD::LW_4X4_(uint64 instruction)
9012{
89a955e8 9013 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
75199b40 9014 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11b9732a 9015 uint64 u_value = extract_u_3_8__s2(instruction);
89a955e8
AM		 9016
9017 std::string rt4 = GPR(encode_gpr4(rt4_value));
9018 std::string u = IMMEDIATE(copy(u_value));
9019 std::string rs4 = GPR(encode_gpr4(rs4_value));
9020
9021 return img::format("LW %s, %s(%s)", rt4, u, rs4);
9022}
9023
9024
9025/*
9026 *
9027 *
9028 * 3 2 1
9029 * 10987654321098765432109876543210
9030 * 001000 x1110000101
9031 * rt -----
9032 * rs -----
9033 * rd -----
9034 */
9035std::string NMD::LW_GP_(uint64 instruction)
9036{
9037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 9038 uint64 u_value = extract_u_20_to_2__s2(instruction);
89a955e8
AM		 9039
9040 std::string rt = GPR(copy(rt_value));
9041 std::string u = IMMEDIATE(copy(u_value));
9042
9043 return img::format("LW %s, %s($%d)", rt, u, 28);
9044}
9045
9046
9047/*
9048 *
9049 *
9050 * 3 2 1
9051 * 10987654321098765432109876543210
9052 * 001000 x1110000101
9053 * rt -----
9054 * rs -----
9055 * rd -----
9056 */
9057std::string NMD::LW_GP16_(uint64 instruction)
9058{
89a955e8 9059 uint64 rt3_value = extract_rt3_9_8_7(instruction);
75199b40 9060 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
89a955e8 9061
988d6c89 9062 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 9063 std::string u = IMMEDIATE(copy(u_value));
9064
9065 return img::format("LW %s, %s($%d)", rt3, u, 28);
9066}
9067
9068
9069/*
9070 *
9071 *
9072 * 3 2 1
9073 * 10987654321098765432109876543210
9074 * 001000 x1110000101
9075 * rt -----
9076 * rs -----
9077 * rd -----
9078 */
9079std::string NMD::LW_S9_(uint64 instruction)
9080{
9081 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9082 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9083 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9084
9085 std::string rt = GPR(copy(rt_value));
9086 std::string s = IMMEDIATE(copy(s_value));
9087 std::string rs = GPR(copy(rs_value));
9088
9089 return img::format("LW %s, %s(%s)", rt, s, rs);
9090}
9091
9092
9093/*
9094 *
9095 *
9096 * 3 2 1
9097 * 10987654321098765432109876543210
9098 * 001000 x1110000101
9099 * rt -----
9100 * rs -----
9101 * rd -----
9102 */
9103std::string NMD::LW_SP_(uint64 instruction)
9104{
9105 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
11b9732a 9106 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
89a955e8
AM		 9107
9108 std::string rt = GPR(copy(rt_value));
9109 std::string u = IMMEDIATE(copy(u_value));
9110
9111 return img::format("LW %s, %s($%d)", rt, u, 29);
9112}
9113
9114
9115/*
9116 *
9117 *
9118 * 3 2 1
9119 * 10987654321098765432109876543210
9120 * 001000 x1110000101
9121 * rt -----
9122 * rs -----
9123 * rd -----
9124 */
9125std::string NMD::LW_U12_(uint64 instruction)
9126{
9127 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9128 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9129 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9130
9131 std::string rt = GPR(copy(rt_value));
9132 std::string u = IMMEDIATE(copy(u_value));
9133 std::string rs = GPR(copy(rs_value));
9134
9135 return img::format("LW %s, %s(%s)", rt, u, rs);
9136}
9137
9138
9139/*
9140 *
9141 *
9142 * 3 2 1
9143 * 10987654321098765432109876543210
9144 * 001000 x1110000101
9145 * rt -----
9146 * rs -----
9147 * rd -----
9148 */
9149std::string NMD::LWC1_GP_(uint64 instruction)
9150{
17ce2f00 9151 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11b9732a 9152 uint64 u_value = extract_u_17_to_2__s2(instruction);
89a955e8
AM		 9153
9154 std::string ft = FPR(copy(ft_value));
9155 std::string u = IMMEDIATE(copy(u_value));
9156
9157 return img::format("LWC1 %s, %s($%d)", ft, u, 28);
9158}
9159
9160
9161/*
9162 *
9163 *
9164 * 3 2 1
9165 * 10987654321098765432109876543210
9166 * 001000 x1110000101
9167 * rt -----
9168 * rs -----
9169 * rd -----
9170 */
9171std::string NMD::LWC1_S9_(uint64 instruction)
9172{
17ce2f00 9173 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 9174 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9175 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9176
9177 std::string ft = FPR(copy(ft_value));
9178 std::string s = IMMEDIATE(copy(s_value));
9179 std::string rs = GPR(copy(rs_value));
9180
9181 return img::format("LWC1 %s, %s(%s)", ft, s, rs);
9182}
9183
9184
9185/*
9186 *
9187 *
9188 * 3 2 1
9189 * 10987654321098765432109876543210
9190 * 001000 x1110000101
9191 * rt -----
9192 * rs -----
9193 * rd -----
9194 */
9195std::string NMD::LWC1_U12_(uint64 instruction)
9196{
17ce2f00 9197 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 9198 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9199 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9200
9201 std::string ft = FPR(copy(ft_value));
9202 std::string u = IMMEDIATE(copy(u_value));
9203 std::string rs = GPR(copy(rs_value));
9204
9205 return img::format("LWC1 %s, %s(%s)", ft, u, rs);
9206}
9207
9208
9209/*
9210 *
9211 *
9212 * 3 2 1
9213 * 10987654321098765432109876543210
9214 * 001000 x1110000101
9215 * rt -----
9216 * rs -----
9217 * rd -----
9218 */
9219std::string NMD::LWC1X(uint64 instruction)
9220{
9221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9222 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9223 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 9224
9225 std::string ft = FPR(copy(ft_value));
9226 std::string rs = GPR(copy(rs_value));
9227 std::string rt = GPR(copy(rt_value));
9228
9229 return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
9230}
9231
9232
9233/*
9234 *
9235 *
9236 * 3 2 1
9237 * 10987654321098765432109876543210
9238 * 001000 x1110000101
9239 * rt -----
9240 * rs -----
9241 * rd -----
9242 */
9243std::string NMD::LWC1XS(uint64 instruction)
9244{
9245 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9246 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9247 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 9248
9249 std::string ft = FPR(copy(ft_value));
9250 std::string rs = GPR(copy(rs_value));
9251 std::string rt = GPR(copy(rt_value));
9252
9253 return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
9254}
9255
9256
9257/*
9258 *
9259 *
9260 * 3 2 1
9261 * 10987654321098765432109876543210
9262 * 001000 x1110000101
9263 * rt -----
9264 * rs -----
9265 * rd -----
9266 */
9267std::string NMD::LWC2(uint64 instruction)
9268{
89a955e8
AM		 9269 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9270 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9271 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9272
9273 std::string ct = CPR(copy(ct_value));
9274 std::string s = IMMEDIATE(copy(s_value));
9275 std::string rs = GPR(copy(rs_value));
9276
9277 return img::format("LWC2 %s, %s(%s)", ct, s, rs);
9278}
9279
9280
9281/*
9282 *
9283 *
9284 * 3 2 1
9285 * 10987654321098765432109876543210
9286 * 001000 x1110000101
9287 * rt -----
9288 * rs -----
9289 * rd -----
9290 */
9291std::string NMD::LWE(uint64 instruction)
9292{
9293 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9294 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9295 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9296
9297 std::string rt = GPR(copy(rt_value));
9298 std::string s = IMMEDIATE(copy(s_value));
9299 std::string rs = GPR(copy(rs_value));
9300
9301 return img::format("LWE %s, %s(%s)", rt, s, rs);
9302}
9303
9304
9305/*
9306 *
9307 *
9308 * 3 2 1
9309 * 10987654321098765432109876543210
9310 * 001000 x1110000101
9311 * rt -----
9312 * rs -----
9313 * rd -----
9314 */
9315std::string NMD::LWM(uint64 instruction)
9316{
9317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9318 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 9319 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9320 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 9321
9322 std::string rt = GPR(copy(rt_value));
9323 std::string s = IMMEDIATE(copy(s_value));
9324 std::string rs = GPR(copy(rs_value));
9325 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
9326
9327 return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
9328}
9329
9330
9331/*
9332 *
9333 *
9334 * 3 2 1
9335 * 10987654321098765432109876543210
9336 * 001000 x1110000101
9337 * rt -----
9338 * rs -----
9339 * rd -----
9340 */
9341std::string NMD::LWPC_48_(uint64 instruction)
9342{
9343 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 9344 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 9345
9346 std::string rt = GPR(copy(rt_value));
9347 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
9348
9349 return img::format("LWPC %s, %s", rt, s);
9350}
9351
9352
9353/*
9354 *
9355 *
9356 * 3 2 1
9357 * 10987654321098765432109876543210
9358 * 001000 x1110000101
9359 * rt -----
9360 * rs -----
9361 * rd -----
9362 */
9363std::string NMD::LWU_GP_(uint64 instruction)
9364{
9365 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 9366 uint64 u_value = extract_u_17_to_2__s2(instruction);
89a955e8
AM		 9367
9368 std::string rt = GPR(copy(rt_value));
9369 std::string u = IMMEDIATE(copy(u_value));
9370
9371 return img::format("LWU %s, %s($%d)", rt, u, 28);
9372}
9373
9374
9375/*
9376 *
9377 *
9378 * 3 2 1
9379 * 10987654321098765432109876543210
9380 * 001000 x1110000101
9381 * rt -----
9382 * rs -----
9383 * rd -----
9384 */
9385std::string NMD::LWU_S9_(uint64 instruction)
9386{
9387 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9388 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 9389 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9390
9391 std::string rt = GPR(copy(rt_value));
9392 std::string s = IMMEDIATE(copy(s_value));
9393 std::string rs = GPR(copy(rs_value));
9394
9395 return img::format("LWU %s, %s(%s)", rt, s, rs);
9396}
9397
9398
9399/*
9400 *
9401 *
9402 * 3 2 1
9403 * 10987654321098765432109876543210
9404 * 001000 x1110000101
9405 * rt -----
9406 * rs -----
9407 * rd -----
9408 */
9409std::string NMD::LWU_U12_(uint64 instruction)
9410{
9411 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9412 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9413 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 9414
9415 std::string rt = GPR(copy(rt_value));
9416 std::string u = IMMEDIATE(copy(u_value));
9417 std::string rs = GPR(copy(rs_value));
9418
9419 return img::format("LWU %s, %s(%s)", rt, u, rs);
9420}
9421
9422
9423/*
9424 *
9425 *
9426 * 3 2 1
9427 * 10987654321098765432109876543210
9428 * 001000 x1110000101
9429 * rt -----
9430 * rs -----
9431 * rd -----
9432 */
9433std::string NMD::LWUX(uint64 instruction)
9434{
9435 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9436 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9437 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 9438
9439 std::string rd = GPR(copy(rd_value));
9440 std::string rs = GPR(copy(rs_value));
9441 std::string rt = GPR(copy(rt_value));
9442
9443 return img::format("LWUX %s, %s(%s)", rd, rs, rt);
9444}
9445
9446
9447/*
9448 *
9449 *
9450 * 3 2 1
9451 * 10987654321098765432109876543210
9452 * 001000 x1110000101
9453 * rt -----
9454 * rs -----
9455 * rd -----
9456 */
9457std::string NMD::LWUXS(uint64 instruction)
9458{
9459 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9460 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9461 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 9462
9463 std::string rd = GPR(copy(rd_value));
9464 std::string rs = GPR(copy(rs_value));
9465 std::string rt = GPR(copy(rt_value));
9466
9467 return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
9468}
9469
9470
9471/*
9472 *
9473 *
9474 * 3 2 1
9475 * 10987654321098765432109876543210
9476 * 001000 x1110000101
9477 * rt -----
9478 * rs -----
9479 * rd -----
9480 */
9481std::string NMD::LWX(uint64 instruction)
9482{
9483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9485 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 9486
9487 std::string rd = GPR(copy(rd_value));
9488 std::string rs = GPR(copy(rs_value));
9489 std::string rt = GPR(copy(rt_value));
9490
9491 return img::format("LWX %s, %s(%s)", rd, rs, rt);
9492}
9493
9494
9495/*
9496 *
9497 *
9498 * 3 2 1
9499 * 10987654321098765432109876543210
9500 * 001000 x1110000101
9501 * rt -----
9502 * rs -----
9503 * rd -----
9504 */
9505std::string NMD::LWXS_16_(uint64 instruction)
9506{
89a955e8
AM		 9507 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9508 uint64 rs3_value = extract_rs3_6_5_4(instruction);
86b5f803 9509 uint64 rd3_value = extract_rd3_3_2_1(instruction);
89a955e8 9510
988d6c89
AM		 9511 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
9512 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
9513 std::string rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 9514
9515 return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
9516}
9517
9518
9519/*
9520 *
9521 *
9522 * 3 2 1
9523 * 10987654321098765432109876543210
9524 * 001000 x1110000101
9525 * rt -----
9526 * rs -----
9527 * rd -----
9528 */
9529std::string NMD::LWXS_32_(uint64 instruction)
9530{
9531 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9532 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9533 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 9534
9535 std::string rd = GPR(copy(rd_value));
9536 std::string rs = GPR(copy(rs_value));
9537 std::string rt = GPR(copy(rt_value));
9538
9539 return img::format("LWXS %s, %s(%s)", rd, rs, rt);
9540}
9541
9542
9543/*
9544 *
9545 *
9546 * 3 2 1
9547 * 10987654321098765432109876543210
9548 * 001000 x1110000101
9549 * rt -----
9550 * rs -----
9551 * rd -----
9552 */
9553std::string NMD::MADD_DSP_(uint64 instruction)
9554{
9555 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9556 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9557 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9558
9559 std::string ac = AC(copy(ac_value));
9560 std::string rs = GPR(copy(rs_value));
9561 std::string rt = GPR(copy(rt_value));
9562
9563 return img::format("MADD %s, %s, %s", ac, rs, rt);
9564}
9565
9566
9567/*
9568 *
9569 *
9570 * 3 2 1
9571 * 10987654321098765432109876543210
9572 * 001000 x1110000101
9573 * rt -----
9574 * rs -----
9575 * rd -----
9576 */
9577std::string NMD::MADDF_D(uint64 instruction)
9578{
17ce2f00 9579 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9580 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9581 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9582
9583 std::string fd = FPR(copy(fd_value));
9584 std::string fs = FPR(copy(fs_value));
9585 std::string ft = FPR(copy(ft_value));
9586
9587 return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
9588}
9589
9590
9591/*
9592 *
9593 *
9594 * 3 2 1
9595 * 10987654321098765432109876543210
9596 * 001000 x1110000101
9597 * rt -----
9598 * rs -----
9599 * rd -----
9600 */
9601std::string NMD::MADDF_S(uint64 instruction)
9602{
17ce2f00 9603 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9604 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9605 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9606
9607 std::string fd = FPR(copy(fd_value));
9608 std::string fs = FPR(copy(fs_value));
9609 std::string ft = FPR(copy(ft_value));
9610
9611 return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
9612}
9613
9614
9615/*
9616 *
9617 *
9618 * 3 2 1
9619 * 10987654321098765432109876543210
9620 * 001000 x1110000101
9621 * rt -----
9622 * rs -----
9623 * rd -----
9624 */
9625std::string NMD::MADDU_DSP_(uint64 instruction)
9626{
9627 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9628 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9629 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9630
9631 std::string ac = AC(copy(ac_value));
9632 std::string rs = GPR(copy(rs_value));
9633 std::string rt = GPR(copy(rt_value));
9634
9635 return img::format("MADDU %s, %s, %s", ac, rs, rt);
9636}
9637
9638
9639/*
9640 *
9641 *
9642 * 3 2 1
9643 * 10987654321098765432109876543210
9644 * 001000 x1110000101
9645 * rt -----
9646 * rs -----
9647 * rd -----
9648 */
9649std::string NMD::MAQ_S_W_PHL(uint64 instruction)
9650{
9651 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9652 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9653 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9654
9655 std::string ac = AC(copy(ac_value));
9656 std::string rs = GPR(copy(rs_value));
9657 std::string rt = GPR(copy(rt_value));
9658
9659 return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9660}
9661
9662
9663/*
9664 *
9665 *
9666 * 3 2 1
9667 * 10987654321098765432109876543210
9668 * 001000 x1110000101
9669 * rt -----
9670 * rs -----
9671 * rd -----
9672 */
9673std::string NMD::MAQ_S_W_PHR(uint64 instruction)
9674{
9675 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9676 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9677 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9678
9679 std::string ac = AC(copy(ac_value));
9680 std::string rs = GPR(copy(rs_value));
9681 std::string rt = GPR(copy(rt_value));
9682
9683 return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9684}
9685
9686
9687/*
9688 *
9689 *
9690 * 3 2 1
9691 * 10987654321098765432109876543210
9692 * 001000 x1110000101
9693 * rt -----
9694 * rs -----
9695 * rd -----
9696 */
9697std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
9698{
9699 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9700 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9701 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9702
9703 std::string ac = AC(copy(ac_value));
9704 std::string rs = GPR(copy(rs_value));
9705 std::string rt = GPR(copy(rt_value));
9706
9707 return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9708}
9709
9710
9711/*
9712 *
9713 *
9714 * 3 2 1
9715 * 10987654321098765432109876543210
9716 * 001000 x1110000101
9717 * rt -----
9718 * rs -----
9719 * rd -----
9720 */
9721std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
9722{
9723 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 9724 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 9725 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 9726
9727 std::string ac = AC(copy(ac_value));
9728 std::string rs = GPR(copy(rs_value));
9729 std::string rt = GPR(copy(rt_value));
9730
9731 return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9732}
9733
9734
9735/*
9736 *
9737 *
9738 * 3 2 1
9739 * 10987654321098765432109876543210
9740 * 001000 x1110000101
9741 * rt -----
9742 * rs -----
9743 * rd -----
9744 */
9745std::string NMD::MAX_D(uint64 instruction)
9746{
17ce2f00 9747 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9748 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9749 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9750
9751 std::string fd = FPR(copy(fd_value));
9752 std::string fs = FPR(copy(fs_value));
9753 std::string ft = FPR(copy(ft_value));
9754
9755 return img::format("MAX.D %s, %s, %s", fd, fs, ft);
9756}
9757
9758
9759/*
9760 *
9761 *
9762 * 3 2 1
9763 * 10987654321098765432109876543210
9764 * 001000 x1110000101
9765 * rt -----
9766 * rs -----
9767 * rd -----
9768 */
9769std::string NMD::MAX_S(uint64 instruction)
9770{
17ce2f00 9771 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9772 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9773 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9774
9775 std::string fd = FPR(copy(fd_value));
9776 std::string fs = FPR(copy(fs_value));
9777 std::string ft = FPR(copy(ft_value));
9778
9779 return img::format("MAX.S %s, %s, %s", fd, fs, ft);
9780}
9781
9782
9783/*
9784 *
9785 *
9786 * 3 2 1
9787 * 10987654321098765432109876543210
9788 * 001000 x1110000101
9789 * rt -----
9790 * rs -----
9791 * rd -----
9792 */
9793std::string NMD::MAXA_D(uint64 instruction)
9794{
17ce2f00 9795 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9796 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9797 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9798
9799 std::string fd = FPR(copy(fd_value));
9800 std::string fs = FPR(copy(fs_value));
9801 std::string ft = FPR(copy(ft_value));
9802
9803 return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
9804}
9805
9806
9807/*
9808 *
9809 *
9810 * 3 2 1
9811 * 10987654321098765432109876543210
9812 * 001000 x1110000101
9813 * rt -----
9814 * rs -----
9815 * rd -----
9816 */
9817std::string NMD::MAXA_S(uint64 instruction)
9818{
17ce2f00 9819 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 9820 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 9821 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 9822
9823 std::string fd = FPR(copy(fd_value));
9824 std::string fs = FPR(copy(fs_value));
9825 std::string ft = FPR(copy(ft_value));
9826
9827 return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
9828}
9829
9830
9831/*
9832 *
9833 *
9834 * 3 2 1
9835 * 10987654321098765432109876543210
9836 * 001000 x1110000101
9837 * rt -----
9838 * rs -----
9839 * rd -----
9840 */
9841std::string NMD::MFC0(uint64 instruction)
9842{
9843 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9844 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9845 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9846
9847 std::string rt = GPR(copy(rt_value));
9848 std::string c0s = CPR(copy(c0s_value));
9849 std::string sel = IMMEDIATE(copy(sel_value));
9850
9851 return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
9852}
9853
9854
9855/*
9856 *
9857 *
9858 * 3 2 1
9859 * 10987654321098765432109876543210
9860 * 001000 x1110000101
9861 * rt -----
9862 * rs -----
9863 * rd -----
9864 */
9865std::string NMD::MFC1(uint64 instruction)
9866{
9867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 9868 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 9869
9870 std::string rt = GPR(copy(rt_value));
9871 std::string fs = FPR(copy(fs_value));
9872
9873 return img::format("MFC1 %s, %s", rt, fs);
9874}
9875
9876
9877/*
9878 *
9879 *
9880 * 3 2 1
9881 * 10987654321098765432109876543210
9882 * 001000 x1110000101
9883 * rt -----
9884 * rs -----
9885 * rd -----
9886 */
9887std::string NMD::MFC2(uint64 instruction)
9888{
89a955e8 9889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 9890 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 9891
9892 std::string rt = GPR(copy(rt_value));
9893 std::string cs = CPR(copy(cs_value));
9894
9895 return img::format("MFC2 %s, %s", rt, cs);
9896}
9897
9898
9899/*
9900 *
9901 *
9902 * 3 2 1
9903 * 10987654321098765432109876543210
9904 * 001000 x1110000101
9905 * rt -----
9906 * rs -----
9907 * rd -----
9908 */
9909std::string NMD::MFGC0(uint64 instruction)
9910{
9911 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9912 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9913 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9914
9915 std::string rt = GPR(copy(rt_value));
9916 std::string c0s = CPR(copy(c0s_value));
9917 std::string sel = IMMEDIATE(copy(sel_value));
9918
9919 return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
9920}
9921
9922
9923/*
9924 *
9925 *
9926 * 3 2 1
9927 * 10987654321098765432109876543210
9928 * 001000 x1110000101
9929 * rt -----
9930 * rs -----
9931 * rd -----
9932 */
9933std::string NMD::MFHC0(uint64 instruction)
9934{
9935 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9936 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9937 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9938
9939 std::string rt = GPR(copy(rt_value));
9940 std::string c0s = CPR(copy(c0s_value));
9941 std::string sel = IMMEDIATE(copy(sel_value));
9942
9943 return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
9944}
9945
9946
9947/*
9948 *
9949 *
9950 * 3 2 1
9951 * 10987654321098765432109876543210
9952 * 001000 x1110000101
9953 * rt -----
9954 * rs -----
9955 * rd -----
9956 */
9957std::string NMD::MFHC1(uint64 instruction)
9958{
9959 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 9960 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 9961
9962 std::string rt = GPR(copy(rt_value));
9963 std::string fs = FPR(copy(fs_value));
9964
9965 return img::format("MFHC1 %s, %s", rt, fs);
9966}
9967
9968
9969/*
9970 *
9971 *
9972 * 3 2 1
9973 * 10987654321098765432109876543210
9974 * 001000 x1110000101
9975 * rt -----
9976 * rs -----
9977 * rd -----
9978 */
9979std::string NMD::MFHC2(uint64 instruction)
9980{
89a955e8 9981 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 9982 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 9983
9984 std::string rt = GPR(copy(rt_value));
9985 std::string cs = CPR(copy(cs_value));
9986
9987 return img::format("MFHC2 %s, %s", rt, cs);
9988}
9989
9990
9991/*
9992 *
9993 *
9994 * 3 2 1
9995 * 10987654321098765432109876543210
9996 * 001000 x1110000101
9997 * rt -----
9998 * rs -----
9999 * rd -----
10000 */
10001std::string NMD::MFHGC0(uint64 instruction)
10002{
10003 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10004 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10005 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10006
10007 std::string rt = GPR(copy(rt_value));
10008 std::string c0s = CPR(copy(c0s_value));
10009 std::string sel = IMMEDIATE(copy(sel_value));
10010
10011 return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
10012}
10013
10014
10015/*
10016 *
10017 *
10018 * 3 2 1
10019 * 10987654321098765432109876543210
10020 * 001000 x1110000101
10021 * rt -----
10022 * rs -----
10023 * rd -----
10024 */
10025std::string NMD::MFHI_DSP_(uint64 instruction)
10026{
10027 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10028 uint64 ac_value = extract_ac_13_12(instruction);
10029
10030 std::string rt = GPR(copy(rt_value));
10031 std::string ac = AC(copy(ac_value));
10032
10033 return img::format("MFHI %s, %s", rt, ac);
10034}
10035
10036
10037/*
10038 *
10039 *
10040 * 3 2 1
10041 * 10987654321098765432109876543210
10042 * 001000 x1110000101
10043 * rt -----
10044 * rs -----
10045 * rd -----
10046 */
10047std::string NMD::MFHTR(uint64 instruction)
10048{
10049 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10050 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10051 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10052 uint64 u_value = extract_u_10(instruction);
10053
10054 std::string rt = GPR(copy(rt_value));
10055 std::string c0s = IMMEDIATE(copy(c0s_value));
10056 std::string u = IMMEDIATE(copy(u_value));
10057 std::string sel = IMMEDIATE(copy(sel_value));
10058
10059 return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
10060}
10061
10062
10063/*
10064 *
10065 *
10066 * 3 2 1
10067 * 10987654321098765432109876543210
10068 * 001000 x1110000101
10069 * rt -----
10070 * rs -----
10071 * rd -----
10072 */
10073std::string NMD::MFLO_DSP_(uint64 instruction)
10074{
10075 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10076 uint64 ac_value = extract_ac_13_12(instruction);
10077
10078 std::string rt = GPR(copy(rt_value));
10079 std::string ac = AC(copy(ac_value));
10080
10081 return img::format("MFLO %s, %s", rt, ac);
10082}
10083
10084
10085/*
10086 *
10087 *
10088 * 3 2 1
10089 * 10987654321098765432109876543210
10090 * 001000 x1110000101
10091 * rt -----
10092 * rs -----
10093 * rd -----
10094 */
10095std::string NMD::MFTR(uint64 instruction)
10096{
10097 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10098 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10099 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10100 uint64 u_value = extract_u_10(instruction);
10101
10102 std::string rt = GPR(copy(rt_value));
10103 std::string c0s = IMMEDIATE(copy(c0s_value));
10104 std::string u = IMMEDIATE(copy(u_value));
10105 std::string sel = IMMEDIATE(copy(sel_value));
10106
10107 return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
10108}
10109
10110
10111/*
10112 *
10113 *
10114 * 3 2 1
10115 * 10987654321098765432109876543210
10116 * 001000 x1110000101
10117 * rt -----
10118 * rs -----
10119 * rd -----
10120 */
10121std::string NMD::MIN_D(uint64 instruction)
10122{
17ce2f00 10123 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10124 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10125 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10126
10127 std::string fd = FPR(copy(fd_value));
10128 std::string fs = FPR(copy(fs_value));
10129 std::string ft = FPR(copy(ft_value));
10130
10131 return img::format("MIN.D %s, %s, %s", fd, fs, ft);
10132}
10133
10134
10135/*
10136 *
10137 *
10138 * 3 2 1
10139 * 10987654321098765432109876543210
10140 * 001000 x1110000101
10141 * rt -----
10142 * rs -----
10143 * rd -----
10144 */
10145std::string NMD::MIN_S(uint64 instruction)
10146{
17ce2f00 10147 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10148 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10149 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10150
10151 std::string fd = FPR(copy(fd_value));
10152 std::string fs = FPR(copy(fs_value));
10153 std::string ft = FPR(copy(ft_value));
10154
10155 return img::format("MIN.S %s, %s, %s", fd, fs, ft);
10156}
10157
10158
10159/*
10160 *
10161 *
10162 * 3 2 1
10163 * 10987654321098765432109876543210
10164 * 001000 x1110000101
10165 * rt -----
10166 * rs -----
10167 * rd -----
10168 */
10169std::string NMD::MINA_D(uint64 instruction)
10170{
17ce2f00 10171 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10172 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10173 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10174
10175 std::string fd = FPR(copy(fd_value));
10176 std::string fs = FPR(copy(fs_value));
10177 std::string ft = FPR(copy(ft_value));
10178
10179 return img::format("MINA.D %s, %s, %s", fd, fs, ft);
10180}
10181
10182
10183/*
10184 *
10185 *
10186 * 3 2 1
10187 * 10987654321098765432109876543210
10188 * 001000 x1110000101
10189 * rt -----
10190 * rs -----
10191 * rd -----
10192 */
10193std::string NMD::MINA_S(uint64 instruction)
10194{
17ce2f00 10195 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10196 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10197 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10198
10199 std::string fd = FPR(copy(fd_value));
10200 std::string fs = FPR(copy(fs_value));
10201 std::string ft = FPR(copy(ft_value));
10202
10203 return img::format("MINA.S %s, %s, %s", fd, fs, ft);
10204}
10205
10206
10207/*
10208 *
10209 *
10210 * 3 2 1
10211 * 10987654321098765432109876543210
10212 * 001000 x1110000101
10213 * rt -----
10214 * rs -----
10215 * rd -----
10216 */
10217std::string NMD::MOD(uint64 instruction)
10218{
10219 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10220 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10221 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10222
10223 std::string rd = GPR(copy(rd_value));
10224 std::string rs = GPR(copy(rs_value));
10225 std::string rt = GPR(copy(rt_value));
10226
10227 return img::format("MOD %s, %s, %s", rd, rs, rt);
10228}
10229
10230
10231/*
10232 *
10233 *
10234 * 3 2 1
10235 * 10987654321098765432109876543210
10236 * 001000 x1110000101
10237 * rt -----
10238 * rs -----
10239 * rd -----
10240 */
10241std::string NMD::MODSUB(uint64 instruction)
10242{
10243 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10244 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10245 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10246
10247 std::string rd = GPR(copy(rd_value));
10248 std::string rs = GPR(copy(rs_value));
10249 std::string rt = GPR(copy(rt_value));
10250
10251 return img::format("MODSUB %s, %s, %s", rd, rs, rt);
10252}
10253
10254
10255/*
10256 *
10257 *
10258 * 3 2 1
10259 * 10987654321098765432109876543210
10260 * 001000 x1110000101
10261 * rt -----
10262 * rs -----
10263 * rd -----
10264 */
10265std::string NMD::MODU(uint64 instruction)
10266{
10267 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10268 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10269 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10270
10271 std::string rd = GPR(copy(rd_value));
10272 std::string rs = GPR(copy(rs_value));
10273 std::string rt = GPR(copy(rt_value));
10274
10275 return img::format("MODU %s, %s, %s", rd, rs, rt);
10276}
10277
10278
10279/*
10280 *
10281 *
10282 * 3 2 1
10283 * 10987654321098765432109876543210
10284 * 001000 x1110000101
10285 * rt -----
10286 * rs -----
10287 * rd -----
10288 */
10289std::string NMD::MOV_D(uint64 instruction)
10290{
17ce2f00 10291 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10292 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 10293
10294 std::string ft = FPR(copy(ft_value));
10295 std::string fs = FPR(copy(fs_value));
10296
10297 return img::format("MOV.D %s, %s", ft, fs);
10298}
10299
10300
10301/*
10302 *
10303 *
10304 * 3 2 1
10305 * 10987654321098765432109876543210
10306 * 001000 x1110000101
10307 * rt -----
10308 * rs -----
10309 * rd -----
10310 */
10311std::string NMD::MOV_S(uint64 instruction)
10312{
17ce2f00 10313 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10314 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 10315
10316 std::string ft = FPR(copy(ft_value));
10317 std::string fs = FPR(copy(fs_value));
10318
10319 return img::format("MOV.S %s, %s", ft, fs);
10320}
10321
10322
10323/*
10324 *
10325 *
10326 * 3 2 1
10327 * 10987654321098765432109876543210
10328 * 001000 x1110000101
10329 * rt -----
10330 * rs -----
10331 * rd -----
10332 */
10333std::string NMD::MOVE_BALC(uint64 instruction)
10334{
86b5f803 10335 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
89a955e8 10336 uint64 rd1_value = extract_rdl_25_24(instruction);
d3605cc0 10337 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
89a955e8
AM		 10338
10339 std::string rd1 = GPR(encode_rd1_from_rd(rd1_value));
10340 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10341 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
10342
10343 return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10344}
10345
10346
10347/*
10348 *
10349 *
10350 * 3 2 1
10351 * 10987654321098765432109876543210
10352 * 001000 x1110000101
10353 * rt -----
10354 * rs -----
10355 * rd -----
10356 */
10357std::string NMD::MOVEP(uint64 instruction)
10358{
89a955e8
AM		 10359 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10360 uint64 rd2_value = extract_rd2_3_8(instruction);
75199b40 10361 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
89a955e8
AM		 10362
10363 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10364 std::string re2 = GPR(encode_rd2_reg2(rd2_value));
10365 /* !!!!!!!!!! - no conversion function */
10366 std::string rsz4 = GPR(encode_gpr4_zero(rsz4_value));
10367 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
10368
10369 return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10370 /* hand edited */
10371}
10372
10373
10374/*
10375 *
10376 *
10377 * 3 2 1
10378 * 10987654321098765432109876543210
10379 * 001000 x1110000101
10380 * rt -----
10381 * rs -----
10382 * rd -----
10383 */
10384std::string NMD::MOVEP_REV_(uint64 instruction)
10385{
89a955e8
AM		 10386 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10387 uint64 rd2_value = extract_rd2_3_8(instruction);
75199b40 10388 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
89a955e8
AM		 10389
10390 std::string rs4 = GPR(encode_gpr4(rs4_value));
10391 std::string rt4 = GPR(encode_gpr4(rt4_value));
10392 std::string rd2 = GPR(encode_rd2_reg1(rd2_value));
10393 std::string rs2 = GPR(encode_rd2_reg2(rd2_value));
10394 /* !!!!!!!!!! - no conversion function */
10395
10396 return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10397 /* hand edited */
10398}
10399
10400
10401/*
10402 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10403 *
10404 * 3 2 1
10405 * 10987654321098765432109876543210
10406 * 001000 00010001101
10407 * rt -----
10408 * rs -----
10409 * rd -----
10410 */
10411std::string NMD::MOVE(uint64 instruction)
10412{
10413 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10414 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10415
10416 std::string rt = GPR(copy(rt_value));
10417 std::string rs = GPR(copy(rs_value));
10418
10419 return img::format("MOVE %s, %s", rt, rs);
10420}
10421
10422
10423/*
10424 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10425 *
10426 * 3 2 1
10427 * 10987654321098765432109876543210
10428 * 001000 00010001101
10429 * rt -----
10430 * rs -----
10431 * rd -----
10432 */
10433std::string NMD::MOVN(uint64 instruction)
10434{
10435 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10436 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10437 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10438
10439 std::string rd = GPR(copy(rd_value));
10440 std::string rs = GPR(copy(rs_value));
10441 std::string rt = GPR(copy(rt_value));
10442
10443 return img::format("MOVN %s, %s, %s", rd, rs, rt);
10444}
10445
10446
10447/*
10448 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10449 *
10450 * 3 2 1
10451 * 10987654321098765432109876543210
10452 * 001000 00010001101
10453 * rt -----
10454 * rs -----
10455 * rd -----
10456 */
10457std::string NMD::MOVZ(uint64 instruction)
10458{
10459 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10460 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10461 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10462
10463 std::string rd = GPR(copy(rd_value));
10464 std::string rs = GPR(copy(rs_value));
10465 std::string rt = GPR(copy(rt_value));
10466
10467 return img::format("MOVZ %s, %s, %s", rd, rs, rt);
10468}
10469
10470
10471/*
10472 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10473 *
10474 * 3 2 1
10475 * 10987654321098765432109876543210
10476 * 001000 00010001101
10477 * rt -----
10478 * rs -----
10479 * rd -----
10480 */
10481std::string NMD::MSUB_DSP_(uint64 instruction)
10482{
10483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10485 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 10486
10487 std::string ac = AC(copy(ac_value));
10488 std::string rs = GPR(copy(rs_value));
10489 std::string rt = GPR(copy(rt_value));
10490
10491 return img::format("MSUB %s, %s, %s", ac, rs, rt);
10492}
10493
10494
10495/*
10496 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10497 *
10498 * 3 2 1
10499 * 10987654321098765432109876543210
10500 * 001000 00010001101
10501 * rt -----
10502 * rs -----
10503 * rd -----
10504 */
10505std::string NMD::MSUBF_D(uint64 instruction)
10506{
17ce2f00 10507 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10508 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10509 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10510
10511 std::string fd = FPR(copy(fd_value));
10512 std::string fs = FPR(copy(fs_value));
10513 std::string ft = FPR(copy(ft_value));
10514
10515 return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
10516}
10517
10518
10519/*
10520 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10521 *
10522 * 3 2 1
10523 * 10987654321098765432109876543210
10524 * 001000 00010001101
10525 * rt -----
10526 * rs -----
10527 * rd -----
10528 */
10529std::string NMD::MSUBF_S(uint64 instruction)
10530{
17ce2f00 10531 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10532 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10533 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10534
10535 std::string fd = FPR(copy(fd_value));
10536 std::string fs = FPR(copy(fs_value));
10537 std::string ft = FPR(copy(ft_value));
10538
10539 return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
10540}
10541
10542
10543/*
10544 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10545 *
10546 * 3 2 1
10547 * 10987654321098765432109876543210
10548 * 001000 00010001101
10549 * rt -----
10550 * rs -----
10551 * rd -----
10552 */
10553std::string NMD::MSUBU_DSP_(uint64 instruction)
10554{
10555 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10556 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10557 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 10558
10559 std::string ac = AC(copy(ac_value));
10560 std::string rs = GPR(copy(rs_value));
10561 std::string rt = GPR(copy(rt_value));
10562
10563 return img::format("MSUBU %s, %s, %s", ac, rs, rt);
10564}
10565
10566
10567/*
10568 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10569 *
10570 * 3 2 1
10571 * 10987654321098765432109876543210
10572 * 001000 00010001101
10573 * rt -----
10574 * rs -----
10575 * rd -----
10576 */
10577std::string NMD::MTC0(uint64 instruction)
10578{
10579 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10580 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10581 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10582
10583 std::string rt = GPR(copy(rt_value));
10584 std::string c0s = CPR(copy(c0s_value));
10585 std::string sel = IMMEDIATE(copy(sel_value));
10586
10587 return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
10588}
10589
10590
10591/*
10592 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10593 *
10594 * 3 2 1
10595 * 10987654321098765432109876543210
10596 * 001000 00010001101
10597 * rt -----
10598 * rs -----
10599 * rd -----
10600 */
10601std::string NMD::MTC1(uint64 instruction)
10602{
10603 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 10604 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 10605
10606 std::string rt = GPR(copy(rt_value));
10607 std::string fs = FPR(copy(fs_value));
10608
10609 return img::format("MTC1 %s, %s", rt, fs);
10610}
10611
10612
10613/*
10614 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10615 *
10616 * 3 2 1
10617 * 10987654321098765432109876543210
10618 * 001000 00010001101
10619 * rt -----
10620 * rs -----
10621 * rd -----
10622 */
10623std::string NMD::MTC2(uint64 instruction)
10624{
89a955e8 10625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 10626 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 10627
10628 std::string rt = GPR(copy(rt_value));
10629 std::string cs = CPR(copy(cs_value));
10630
10631 return img::format("MTC2 %s, %s", rt, cs);
10632}
10633
10634
10635/*
10636 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10637 *
10638 * 3 2 1
10639 * 10987654321098765432109876543210
10640 * 001000 00010001101
10641 * rt -----
10642 * rs -----
10643 * rd -----
10644 */
10645std::string NMD::MTGC0(uint64 instruction)
10646{
10647 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10648 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10649 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10650
10651 std::string rt = GPR(copy(rt_value));
10652 std::string c0s = CPR(copy(c0s_value));
10653 std::string sel = IMMEDIATE(copy(sel_value));
10654
10655 return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
10656}
10657
10658
10659/*
10660 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10661 *
10662 * 3 2 1
10663 * 10987654321098765432109876543210
10664 * 001000 00010001101
10665 * rt -----
10666 * rs -----
10667 * rd -----
10668 */
10669std::string NMD::MTHC0(uint64 instruction)
10670{
10671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10672 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10673 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10674
10675 std::string rt = GPR(copy(rt_value));
10676 std::string c0s = CPR(copy(c0s_value));
10677 std::string sel = IMMEDIATE(copy(sel_value));
10678
10679 return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
10680}
10681
10682
10683/*
10684 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10685 *
10686 * 3 2 1
10687 * 10987654321098765432109876543210
10688 * 001000 00010001101
10689 * rt -----
10690 * rs -----
10691 * rd -----
10692 */
10693std::string NMD::MTHC1(uint64 instruction)
10694{
10695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
52a96d22 10696 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 10697
10698 std::string rt = GPR(copy(rt_value));
10699 std::string fs = FPR(copy(fs_value));
10700
10701 return img::format("MTHC1 %s, %s", rt, fs);
10702}
10703
10704
10705/*
10706 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10707 *
10708 * 3 2 1
10709 * 10987654321098765432109876543210
10710 * 001000 00010001101
10711 * rt -----
10712 * rs -----
10713 * rd -----
10714 */
10715std::string NMD::MTHC2(uint64 instruction)
10716{
89a955e8 10717 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 10718 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
89a955e8
AM		 10719
10720 std::string rt = GPR(copy(rt_value));
10721 std::string cs = CPR(copy(cs_value));
10722
10723 return img::format("MTHC2 %s, %s", rt, cs);
10724}
10725
10726
10727/*
10728 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10729 *
10730 * 3 2 1
10731 * 10987654321098765432109876543210
10732 * 001000 00010001101
10733 * rt -----
10734 * rs -----
10735 * rd -----
10736 */
10737std::string NMD::MTHGC0(uint64 instruction)
10738{
10739 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10740 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10741 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10742
10743 std::string rt = GPR(copy(rt_value));
10744 std::string c0s = CPR(copy(c0s_value));
10745 std::string sel = IMMEDIATE(copy(sel_value));
10746
10747 return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
10748}
10749
10750
10751/*
10752 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10753 *
10754 * 3 2 1
10755 * 10987654321098765432109876543210
10756 * 001000 00010001101
10757 * rt -----
10758 * rs -----
10759 * rd -----
10760 */
10761std::string NMD::MTHI_DSP_(uint64 instruction)
10762{
89a955e8 10763 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10764 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 10765
10766 std::string rs = GPR(copy(rs_value));
10767 std::string ac = AC(copy(ac_value));
10768
10769 return img::format("MTHI %s, %s", rs, ac);
10770}
10771
10772
10773/*
10774 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10775 *
10776 * 3 2 1
10777 * 10987654321098765432109876543210
10778 * 001000 00010001101
10779 * rt -----
10780 * rs -----
10781 * rd -----
10782 */
10783std::string NMD::MTHLIP(uint64 instruction)
10784{
89a955e8 10785 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10786 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 10787
10788 std::string rs = GPR(copy(rs_value));
10789 std::string ac = AC(copy(ac_value));
10790
10791 return img::format("MTHLIP %s, %s", rs, ac);
10792}
10793
10794
10795/*
10796 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10797 *
10798 * 3 2 1
10799 * 10987654321098765432109876543210
10800 * 001000 00010001101
10801 * rt -----
10802 * rs -----
10803 * rd -----
10804 */
10805std::string NMD::MTHTR(uint64 instruction)
10806{
10807 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10808 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10809 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10810 uint64 u_value = extract_u_10(instruction);
10811
10812 std::string rt = GPR(copy(rt_value));
10813 std::string c0s = IMMEDIATE(copy(c0s_value));
10814 std::string u = IMMEDIATE(copy(u_value));
10815 std::string sel = IMMEDIATE(copy(sel_value));
10816
10817 return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
10818}
10819
10820
10821/*
10822 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10823 *
10824 * 3 2 1
10825 * 10987654321098765432109876543210
10826 * 001000 00010001101
10827 * rt -----
10828 * rs -----
10829 * rd -----
10830 */
10831std::string NMD::MTLO_DSP_(uint64 instruction)
10832{
89a955e8 10833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10834 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 10835
10836 std::string rs = GPR(copy(rs_value));
10837 std::string ac = AC(copy(ac_value));
10838
10839 return img::format("MTLO %s, %s", rs, ac);
10840}
10841
10842
10843/*
10844 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10845 *
10846 * 3 2 1
10847 * 10987654321098765432109876543210
10848 * 001000 00010001101
10849 * rt -----
10850 * rs -----
10851 * rd -----
10852 */
10853std::string NMD::MTTR(uint64 instruction)
10854{
10855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10856 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10857 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10858 uint64 u_value = extract_u_10(instruction);
10859
10860 std::string rt = GPR(copy(rt_value));
10861 std::string c0s = IMMEDIATE(copy(c0s_value));
10862 std::string u = IMMEDIATE(copy(u_value));
10863 std::string sel = IMMEDIATE(copy(sel_value));
10864
10865 return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
10866}
10867
10868
10869/*
10870 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10871 *
10872 * 3 2 1
10873 * 10987654321098765432109876543210
10874 * 001000 00010001101
10875 * rt -----
10876 * rs -----
10877 * rd -----
10878 */
10879std::string NMD::MUH(uint64 instruction)
10880{
10881 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10882 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10883 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10884
10885 std::string rd = GPR(copy(rd_value));
10886 std::string rs = GPR(copy(rs_value));
10887 std::string rt = GPR(copy(rt_value));
10888
10889 return img::format("MUH %s, %s, %s", rd, rs, rt);
10890}
10891
10892
10893/*
10894 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10895 *
10896 * 3 2 1
10897 * 10987654321098765432109876543210
10898 * 001000 00010001101
10899 * rt -----
10900 * rs -----
10901 * rd -----
10902 */
10903std::string NMD::MUHU(uint64 instruction)
10904{
10905 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10906 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10907 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10908
10909 std::string rd = GPR(copy(rd_value));
10910 std::string rs = GPR(copy(rs_value));
10911 std::string rt = GPR(copy(rt_value));
10912
10913 return img::format("MUHU %s, %s, %s", rd, rs, rt);
10914}
10915
10916
10917/*
10918 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10919 *
10920 * 3 2 1
10921 * 10987654321098765432109876543210
10922 * 001000 00010001101
10923 * rt -----
10924 * rs -----
10925 * rd -----
10926 */
10927std::string NMD::MUL_32_(uint64 instruction)
10928{
10929 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 10930 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 10931 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 10932
10933 std::string rd = GPR(copy(rd_value));
10934 std::string rs = GPR(copy(rs_value));
10935 std::string rt = GPR(copy(rt_value));
10936
10937 return img::format("MUL %s, %s, %s", rd, rs, rt);
10938}
10939
10940
10941/*
10942 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10943 *
10944 * 3 2 1
10945 * 10987654321098765432109876543210
10946 * 001000 00010001101
10947 * rt -----
10948 * rs -----
10949 * rd -----
10950 */
10951std::string NMD::MUL_4X4_(uint64 instruction)
10952{
89a955e8 10953 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
75199b40 10954 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
89a955e8
AM		 10955
10956 std::string rs4 = GPR(encode_gpr4(rs4_value));
10957 std::string rt4 = GPR(encode_gpr4(rt4_value));
10958
10959 return img::format("MUL %s, %s", rs4, rt4);
10960}
10961
10962
10963/*
10964 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10965 *
10966 * 3 2 1
10967 * 10987654321098765432109876543210
10968 * 001000 00010001101
10969 * rt -----
10970 * rs -----
10971 * rd -----
10972 */
10973std::string NMD::MUL_D(uint64 instruction)
10974{
17ce2f00 10975 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 10976 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 10977 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 10978
10979 std::string fd = FPR(copy(fd_value));
10980 std::string fs = FPR(copy(fs_value));
10981 std::string ft = FPR(copy(ft_value));
10982
10983 return img::format("MUL.D %s, %s, %s", fd, fs, ft);
10984}
10985
10986
10987/*
10988 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10989 *
10990 * 3 2 1
10991 * 10987654321098765432109876543210
10992 * 001000 00010001101
10993 * rt -----
10994 * rs -----
10995 * rd -----
10996 */
10997std::string NMD::MUL_PH(uint64 instruction)
10998{
10999 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11000 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11001 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11002
11003 std::string rd = GPR(copy(rd_value));
11004 std::string rs = GPR(copy(rs_value));
11005 std::string rt = GPR(copy(rt_value));
11006
11007 return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
11008}
11009
11010
11011/*
11012 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11013 *
11014 * 3 2 1
11015 * 10987654321098765432109876543210
11016 * 001000 00010001101
11017 * rt -----
11018 * rs -----
11019 * rd -----
11020 */
11021std::string NMD::MUL_S_PH(uint64 instruction)
11022{
11023 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11024 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11025 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11026
11027 std::string rd = GPR(copy(rd_value));
11028 std::string rs = GPR(copy(rs_value));
11029 std::string rt = GPR(copy(rt_value));
11030
11031 return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
11032}
11033
11034
11035/*
11036 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11037 *
11038 * 3 2 1
11039 * 10987654321098765432109876543210
11040 * 001000 00010001101
11041 * rt -----
11042 * rs -----
11043 * rd -----
11044 */
11045std::string NMD::MUL_S(uint64 instruction)
11046{
17ce2f00 11047 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 11048 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 11049 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 11050
11051 std::string fd = FPR(copy(fd_value));
11052 std::string fs = FPR(copy(fs_value));
11053 std::string ft = FPR(copy(ft_value));
11054
11055 return img::format("MUL.S %s, %s, %s", fd, fs, ft);
11056}
11057
11058
11059/*
11060 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11061 *
11062 * 3 2 1
11063 * 10987654321098765432109876543210
11064 * 001000 00010001101
11065 * rt -----
11066 * rs -----
11067 * rd -----
11068 */
11069std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
11070{
11071 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11072 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11073 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11074
11075 std::string rd = GPR(copy(rd_value));
11076 std::string rs = GPR(copy(rs_value));
11077 std::string rt = GPR(copy(rt_value));
11078
11079 return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
11080}
11081
11082
11083/*
11084 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11085 *
11086 * 3 2 1
11087 * 10987654321098765432109876543210
11088 * 001000 00010001101
11089 * rt -----
11090 * rs -----
11091 * rd -----
11092 */
11093std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
11094{
11095 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11096 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11097 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11098
11099 std::string rd = GPR(copy(rd_value));
11100 std::string rs = GPR(copy(rs_value));
11101 std::string rt = GPR(copy(rt_value));
11102
11103 return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
11104}
11105
11106
11107/*
11108 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11109 *
11110 * 3 2 1
11111 * 10987654321098765432109876543210
11112 * 001000 00010001101
11113 * rt -----
11114 * rs -----
11115 * rd -----
11116 */
11117std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
11118{
11119 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11120 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11121 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11122
11123 std::string rd = GPR(copy(rd_value));
11124 std::string rs = GPR(copy(rs_value));
11125 std::string rt = GPR(copy(rt_value));
11126
11127 return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
11128}
11129
11130
11131/*
11132 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11133 *
11134 * 3 2 1
11135 * 10987654321098765432109876543210
11136 * 001000 00010001101
11137 * rt -----
11138 * rs -----
11139 * rd -----
11140 */
11141std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
11142{
11143 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11144 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11145 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11146
11147 std::string rd = GPR(copy(rd_value));
11148 std::string rs = GPR(copy(rs_value));
11149 std::string rt = GPR(copy(rt_value));
11150
11151 return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
11152}
11153
11154
11155/*
11156 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11157 *
11158 * 3 2 1
11159 * 10987654321098765432109876543210
11160 * 001000 00010001101
11161 * rt -----
11162 * rs -----
11163 * rd -----
11164 */
11165std::string NMD::MULQ_RS_PH(uint64 instruction)
11166{
11167 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11168 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11169 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11170
11171 std::string rd = GPR(copy(rd_value));
11172 std::string rs = GPR(copy(rs_value));
11173 std::string rt = GPR(copy(rt_value));
11174
11175 return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
11176}
11177
11178
11179/*
11180 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11181 *
11182 * 3 2 1
11183 * 10987654321098765432109876543210
11184 * 001000 00010001101
11185 * rt -----
11186 * rs -----
11187 * rd -----
11188 */
11189std::string NMD::MULQ_RS_W(uint64 instruction)
11190{
11191 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11192 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11193 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11194
11195 std::string rd = GPR(copy(rd_value));
11196 std::string rs = GPR(copy(rs_value));
11197 std::string rt = GPR(copy(rt_value));
11198
11199 return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
11200}
11201
11202
11203/*
11204 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11205 *
11206 * 3 2 1
11207 * 10987654321098765432109876543210
11208 * 001000 00010001101
11209 * rt -----
11210 * rs -----
11211 * rd -----
11212 */
11213std::string NMD::MULQ_S_PH(uint64 instruction)
11214{
11215 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11216 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11217 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11218
11219 std::string rd = GPR(copy(rd_value));
11220 std::string rs = GPR(copy(rs_value));
11221 std::string rt = GPR(copy(rt_value));
11222
11223 return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
11224}
11225
11226
11227/*
11228 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11229 *
11230 * 3 2 1
11231 * 10987654321098765432109876543210
11232 * 001000 00010001101
11233 * rt -----
11234 * rs -----
11235 * rd -----
11236 */
11237std::string NMD::MULQ_S_W(uint64 instruction)
11238{
11239 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11240 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11241 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11242
11243 std::string rd = GPR(copy(rd_value));
11244 std::string rs = GPR(copy(rs_value));
11245 std::string rt = GPR(copy(rt_value));
11246
11247 return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11248}
11249
11250
11251/*
11252 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11253 *
11254 * 3 2 1
11255 * 10987654321098765432109876543210
11256 * 001000 00010001101
11257 * rt -----
11258 * rs -----
11259 * rd -----
11260 */
11261std::string NMD::MULSA_W_PH(uint64 instruction)
11262{
11263 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11264 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11265 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 11266
11267 std::string ac = AC(copy(ac_value));
11268 std::string rs = GPR(copy(rs_value));
11269 std::string rt = GPR(copy(rt_value));
11270
11271 return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11272}
11273
11274
11275/*
11276 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11277 *
11278 * 3 2 1
11279 * 10987654321098765432109876543210
11280 * 001000 00010001101
11281 * rt -----
11282 * rs -----
11283 * rd -----
11284 */
11285std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
11286{
11287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11288 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11289 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 11290
11291 std::string ac = AC(copy(ac_value));
11292 std::string rs = GPR(copy(rs_value));
11293 std::string rt = GPR(copy(rt_value));
11294
11295 return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11296}
11297
11298
11299/*
11300 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11301 *
11302 * 3 2 1
11303 * 10987654321098765432109876543210
11304 * 001000 00010001101
11305 * rt -----
11306 * rs -----
11307 * rd -----
11308 */
11309std::string NMD::MULT_DSP_(uint64 instruction)
11310{
11311 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11312 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11313 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 11314
11315 std::string ac = AC(copy(ac_value));
11316 std::string rs = GPR(copy(rs_value));
11317 std::string rt = GPR(copy(rt_value));
11318
11319 return img::format("MULT %s, %s, %s", ac, rs, rt);
11320}
11321
11322
11323/*
11324 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11325 *
11326 * 3 2 1
11327 * 10987654321098765432109876543210
11328 * 001000 00010001101
11329 * rt -----
11330 * rs -----
11331 * rd -----
11332 */
11333std::string NMD::MULTU_DSP_(uint64 instruction)
11334{
11335 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11336 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11337 uint64 ac_value = extract_ac_13_12(instruction);
89a955e8
AM		 11338
11339 std::string ac = AC(copy(ac_value));
11340 std::string rs = GPR(copy(rs_value));
11341 std::string rt = GPR(copy(rt_value));
11342
11343 return img::format("MULTU %s, %s, %s", ac, rs, rt);
11344}
11345
11346
11347/*
11348 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11349 *
11350 * 3 2 1
11351 * 10987654321098765432109876543210
11352 * 001000 00010001101
11353 * rt -----
11354 * rs -----
11355 * rd -----
11356 */
11357std::string NMD::MULU(uint64 instruction)
11358{
11359 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11360 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11361 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11362
11363 std::string rd = GPR(copy(rd_value));
11364 std::string rs = GPR(copy(rs_value));
11365 std::string rt = GPR(copy(rt_value));
11366
11367 return img::format("MULU %s, %s, %s", rd, rs, rt);
11368}
11369
11370
11371/*
11372 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11373 *
11374 * 3 2 1
11375 * 10987654321098765432109876543210
11376 * 001000 00010001101
11377 * rt -----
11378 * rs -----
11379 * rd -----
11380 */
11381std::string NMD::NEG_D(uint64 instruction)
11382{
17ce2f00 11383 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 11384 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 11385
11386 std::string ft = FPR(copy(ft_value));
11387 std::string fs = FPR(copy(fs_value));
11388
11389 return img::format("NEG.D %s, %s", ft, fs);
11390}
11391
11392
11393/*
11394 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11395 *
11396 * 3 2 1
11397 * 10987654321098765432109876543210
11398 * 001000 00010001101
11399 * rt -----
11400 * rs -----
11401 * rd -----
11402 */
11403std::string NMD::NEG_S(uint64 instruction)
11404{
17ce2f00 11405 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 11406 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 11407
11408 std::string ft = FPR(copy(ft_value));
11409 std::string fs = FPR(copy(fs_value));
11410
11411 return img::format("NEG.S %s, %s", ft, fs);
11412}
11413
11414
11415/*
11416 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11417 *
11418 * 3 2 1
11419 * 10987654321098765432109876543210
11420 * 001000 00010001101
11421 * rt -----
11422 * rs -----
11423 * rd -----
11424 */
11425std::string NMD::NOP_16_(uint64 instruction)
11426{
11427 (void)instruction;
11428
11429 return "NOP ";
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::NOP_32_(uint64 instruction)
11444{
11445 (void)instruction;
11446
11447 return "NOP ";
11448}
11449
11450
11451/*
11452 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11453 *
11454 * 3 2 1
11455 * 10987654321098765432109876543210
11456 * 001000 00010001101
11457 * rt -----
11458 * rs -----
11459 * rd -----
11460 */
11461std::string NMD::NOR(uint64 instruction)
11462{
11463 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11464 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11465 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11466
11467 std::string rd = GPR(copy(rd_value));
11468 std::string rs = GPR(copy(rs_value));
11469 std::string rt = GPR(copy(rt_value));
11470
11471 return img::format("NOR %s, %s, %s", rd, rs, rt);
11472}
11473
11474
11475/*
11476 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11477 *
11478 * 3 2 1
11479 * 10987654321098765432109876543210
11480 * 001000 00010001101
11481 * rt -----
11482 * rs -----
11483 * rd -----
11484 */
11485std::string NMD::NOT_16_(uint64 instruction)
11486{
11487 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11488 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11489
988d6c89
AM		 11490 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
11491 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 11492
11493 return img::format("NOT %s, %s", rt3, rs3);
11494}
11495
11496
11497/*
11498 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11499 *
11500 * 3 2 1
11501 * 10987654321098765432109876543210
11502 * 001000 00010001101
11503 * rt -----
11504 * rs -----
11505 * rd -----
11506 */
11507std::string NMD::OR_16_(uint64 instruction)
11508{
11509 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11510 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11511
988d6c89
AM		 11512 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
11513 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 11514
11515 return img::format("OR %s, %s", rs3, rt3);
11516}
11517
11518
11519/*
11520 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11521 *
11522 * 3 2 1
11523 * 10987654321098765432109876543210
11524 * 001000 00010001101
11525 * rt -----
11526 * rs -----
11527 * rd -----
11528 */
11529std::string NMD::OR_32_(uint64 instruction)
11530{
11531 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11532 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11533 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11534
11535 std::string rd = GPR(copy(rd_value));
11536 std::string rs = GPR(copy(rs_value));
11537 std::string rt = GPR(copy(rt_value));
11538
11539 return img::format("OR %s, %s, %s", rd, rs, rt);
11540}
11541
11542
11543/*
11544 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11545 *
11546 * 3 2 1
11547 * 10987654321098765432109876543210
11548 * 001000 00010001101
11549 * rt -----
11550 * rs -----
11551 * rd -----
11552 */
11553std::string NMD::ORI(uint64 instruction)
11554{
11555 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11556 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11557 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 11558
11559 std::string rt = GPR(copy(rt_value));
11560 std::string rs = GPR(copy(rs_value));
11561 std::string u = IMMEDIATE(copy(u_value));
11562
11563 return img::format("ORI %s, %s, %s", rt, rs, u);
11564}
11565
11566
11567/*
11568 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11569 *
11570 * 3 2 1
11571 * 10987654321098765432109876543210
11572 * 001000 00010001101
11573 * rt -----
11574 * rs -----
11575 * rd -----
11576 */
11577std::string NMD::PACKRL_PH(uint64 instruction)
11578{
11579 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11580 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11581 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11582
11583 std::string rd = GPR(copy(rd_value));
11584 std::string rs = GPR(copy(rs_value));
11585 std::string rt = GPR(copy(rt_value));
11586
11587 return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
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::PAUSE(uint64 instruction)
11602{
11603 (void)instruction;
11604
11605 return "PAUSE ";
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::PICK_PH(uint64 instruction)
11620{
11621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11622 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11623 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 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("PICK.PH %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::PICK_QB(uint64 instruction)
11644{
11645 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11646 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11647 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11648
11649 std::string rd = GPR(copy(rd_value));
11650 std::string rs = GPR(copy(rs_value));
11651 std::string rt = GPR(copy(rt_value));
11652
11653 return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
11654}
11655
11656
11657/*
11658 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11659 *
11660 * 3 2 1
11661 * 10987654321098765432109876543210
11662 * 001000 00010001101
11663 * rt -----
11664 * rs -----
11665 * rd -----
11666 */
11667std::string NMD::PRECEQ_W_PHL(uint64 instruction)
11668{
11669 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11670 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11671
11672 std::string rt = GPR(copy(rt_value));
11673 std::string rs = GPR(copy(rs_value));
11674
11675 return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
11676}
11677
11678
11679/*
11680 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11681 *
11682 * 3 2 1
11683 * 10987654321098765432109876543210
11684 * 001000 00010001101
11685 * rt -----
11686 * rs -----
11687 * rd -----
11688 */
11689std::string NMD::PRECEQ_W_PHR(uint64 instruction)
11690{
11691 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11692 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11693
11694 std::string rt = GPR(copy(rt_value));
11695 std::string rs = GPR(copy(rs_value));
11696
11697 return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
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::PRECEQU_PH_QBLA(uint64 instruction)
11712{
11713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11714 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11715
11716 std::string rt = GPR(copy(rt_value));
11717 std::string rs = GPR(copy(rs_value));
11718
11719 return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11720}
11721
11722
11723/*
11724 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11725 *
11726 * 3 2 1
11727 * 10987654321098765432109876543210
11728 * 001000 00010001101
11729 * rt -----
11730 * rs -----
11731 * rd -----
11732 */
11733std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
11734{
11735 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11737
11738 std::string rt = GPR(copy(rt_value));
11739 std::string rs = GPR(copy(rs_value));
11740
11741 return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
11742}
11743
11744
11745/*
11746 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11747 *
11748 * 3 2 1
11749 * 10987654321098765432109876543210
11750 * 001000 00010001101
11751 * rt -----
11752 * rs -----
11753 * rd -----
11754 */
11755std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
11756{
11757 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11758 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11759
11760 std::string rt = GPR(copy(rt_value));
11761 std::string rs = GPR(copy(rs_value));
11762
11763 return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
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::PRECEQU_PH_QBR(uint64 instruction)
11778{
11779 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11780 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11781
11782 std::string rt = GPR(copy(rt_value));
11783 std::string rs = GPR(copy(rs_value));
11784
11785 return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
11786}
11787
11788
11789/*
11790 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11791 *
11792 * 3 2 1
11793 * 10987654321098765432109876543210
11794 * 001000 00010001101
11795 * rt -----
11796 * rs -----
11797 * rd -----
11798 */
11799std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
11800{
11801 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11802 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11803
11804 std::string rt = GPR(copy(rt_value));
11805 std::string rs = GPR(copy(rs_value));
11806
11807 return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
11808}
11809
11810
11811/*
11812 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11813 *
11814 * 3 2 1
11815 * 10987654321098765432109876543210
11816 * 001000 00010001101
11817 * rt -----
11818 * rs -----
11819 * rd -----
11820 */
11821std::string NMD::PRECEU_PH_QBL(uint64 instruction)
11822{
11823 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11824 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11825
11826 std::string rt = GPR(copy(rt_value));
11827 std::string rs = GPR(copy(rs_value));
11828
11829 return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
11830}
11831
11832
11833/*
11834 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11835 *
11836 * 3 2 1
11837 * 10987654321098765432109876543210
11838 * 001000 00010001101
11839 * rt -----
11840 * rs -----
11841 * rd -----
11842 */
11843std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
11844{
11845 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11846 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11847
11848 std::string rt = GPR(copy(rt_value));
11849 std::string rs = GPR(copy(rs_value));
11850
11851 return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
11852}
11853
11854
11855/*
11856 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11857 *
11858 * 3 2 1
11859 * 10987654321098765432109876543210
11860 * 001000 00010001101
11861 * rt -----
11862 * rs -----
11863 * rd -----
11864 */
11865std::string NMD::PRECEU_PH_QBR(uint64 instruction)
11866{
11867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11868 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11869
11870 std::string rt = GPR(copy(rt_value));
11871 std::string rs = GPR(copy(rs_value));
11872
11873 return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
11874}
11875
11876
11877/*
11878 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11879 *
11880 * 3 2 1
11881 * 10987654321098765432109876543210
11882 * 001000 00010001101
11883 * rt -----
11884 * rs -----
11885 * rd -----
11886 */
11887std::string NMD::PRECR_QB_PH(uint64 instruction)
11888{
11889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11890 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11891 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11892
11893 std::string rd = GPR(copy(rd_value));
11894 std::string rs = GPR(copy(rs_value));
11895 std::string rt = GPR(copy(rt_value));
11896
11897 return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
11898}
11899
11900
11901/*
11902 *
11903 *
11904 * 3 2 1
11905 * 10987654321098765432109876543210
11906 * 001000 x1110000101
11907 * rt -----
11908 * rs -----
11909 * rd -----
11910 */
11911std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
11912{
11913 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11914 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 11915 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 11916
11917 std::string rt = GPR(copy(rt_value));
11918 std::string rs = GPR(copy(rs_value));
11919 std::string sa = IMMEDIATE(copy(sa_value));
11920
11921 return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
11922}
11923
11924
11925/*
11926 *
11927 *
11928 * 3 2 1
11929 * 10987654321098765432109876543210
11930 * 001000 x1110000101
11931 * rt -----
11932 * rs -----
11933 * rd -----
11934 */
11935std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
11936{
11937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 11939 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 11940
11941 std::string rt = GPR(copy(rt_value));
11942 std::string rs = GPR(copy(rs_value));
11943 std::string sa = IMMEDIATE(copy(sa_value));
11944
11945 return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
11946}
11947
11948
11949/*
11950 *
11951 *
11952 * 3 2 1
11953 * 10987654321098765432109876543210
11954 * 001000 x1110000101
11955 * rt -----
11956 * rs -----
11957 * rd -----
11958 */
11959std::string NMD::PRECRQ_PH_W(uint64 instruction)
11960{
11961 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11962 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11963 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11964
11965 std::string rd = GPR(copy(rd_value));
11966 std::string rs = GPR(copy(rs_value));
11967 std::string rt = GPR(copy(rt_value));
11968
11969 return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
11970}
11971
11972
11973/*
11974 *
11975 *
11976 * 3 2 1
11977 * 10987654321098765432109876543210
11978 * 001000 x1110000101
11979 * rt -----
11980 * rs -----
11981 * rd -----
11982 */
11983std::string NMD::PRECRQ_QB_PH(uint64 instruction)
11984{
11985 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 11986 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 11987 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 11988
11989 std::string rd = GPR(copy(rd_value));
11990 std::string rs = GPR(copy(rs_value));
11991 std::string rt = GPR(copy(rt_value));
11992
11993 return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
11994}
11995
11996
11997/*
11998 *
11999 *
12000 * 3 2 1
12001 * 10987654321098765432109876543210
12002 * 001000 x1110000101
12003 * rt -----
12004 * rs -----
12005 * rd -----
12006 */
12007std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
12008{
12009 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12010 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12011 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 12012
12013 std::string rd = GPR(copy(rd_value));
12014 std::string rs = GPR(copy(rs_value));
12015 std::string rt = GPR(copy(rt_value));
12016
12017 return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
12018}
12019
12020
12021/*
12022 *
12023 *
12024 * 3 2 1
12025 * 10987654321098765432109876543210
12026 * 001000 x1110000101
12027 * rt -----
12028 * rs -----
12029 * rd -----
12030 */
12031std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
12032{
12033 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12034 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12035 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 12036
12037 std::string rd = GPR(copy(rd_value));
12038 std::string rs = GPR(copy(rs_value));
12039 std::string rt = GPR(copy(rt_value));
12040
12041 return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
12042}
12043
12044
12045/*
12046 *
12047 *
12048 * 3 2 1
12049 * 10987654321098765432109876543210
12050 * 001000 x1110000101
12051 * rt -----
12052 * rs -----
12053 * rd -----
12054 */
12055std::string NMD::PREF_S9_(uint64 instruction)
12056{
89a955e8
AM		 12057 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12058 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
d3605cc0 12059 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12060
12061 std::string hint = IMMEDIATE(copy(hint_value));
12062 std::string s = IMMEDIATE(copy(s_value));
12063 std::string rs = GPR(copy(rs_value));
12064
12065 return img::format("PREF %s, %s(%s)", hint, s, rs);
12066}
12067
12068
12069/*
12070 *
12071 *
12072 * 3 2 1
12073 * 10987654321098765432109876543210
12074 * 001000 x1110000101
12075 * rt -----
12076 * rs -----
12077 * rd -----
12078 */
12079std::string NMD::PREF_U12_(uint64 instruction)
12080{
12081 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
89a955e8 12082 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12083 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12084
12085 std::string hint = IMMEDIATE(copy(hint_value));
12086 std::string u = IMMEDIATE(copy(u_value));
12087 std::string rs = GPR(copy(rs_value));
12088
12089 return img::format("PREF %s, %s(%s)", hint, u, rs);
12090}
12091
12092
12093/*
12094 *
12095 *
12096 * 3 2 1
12097 * 10987654321098765432109876543210
12098 * 001000 x1110000101
12099 * rt -----
12100 * rs -----
12101 * rd -----
12102 */
12103std::string NMD::PREFE(uint64 instruction)
12104{
89a955e8
AM		 12105 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12107 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12108
12109 std::string hint = IMMEDIATE(copy(hint_value));
12110 std::string s = IMMEDIATE(copy(s_value));
12111 std::string rs = GPR(copy(rs_value));
12112
12113 return img::format("PREFE %s, %s(%s)", hint, s, rs);
12114}
12115
12116
12117/*
12118 *
12119 *
12120 * 3 2 1
12121 * 10987654321098765432109876543210
12122 * 001000 x1110000101
12123 * rt -----
12124 * rs -----
12125 * rd -----
12126 */
12127std::string NMD::PREPEND(uint64 instruction)
12128{
12129 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12130 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12131 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 12132
12133 std::string rt = GPR(copy(rt_value));
12134 std::string rs = GPR(copy(rs_value));
12135 std::string sa = IMMEDIATE(copy(sa_value));
12136
12137 return img::format("PREPEND %s, %s, %s", rt, rs, sa);
12138}
12139
12140
12141/*
12142 *
12143 *
12144 * 3 2 1
12145 * 10987654321098765432109876543210
12146 * 001000 x1110000101
12147 * rt -----
12148 * rs -----
12149 * rd -----
12150 */
12151std::string NMD::RADDU_W_QB(uint64 instruction)
12152{
12153 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12154 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12155
12156 std::string rt = GPR(copy(rt_value));
12157 std::string rs = GPR(copy(rs_value));
12158
12159 return img::format("RADDU.W.QB %s, %s", rt, rs);
12160}
12161
12162
12163/*
12164 *
12165 *
12166 * 3 2 1
12167 * 10987654321098765432109876543210
12168 * 001000 x1110000101
12169 * rt -----
12170 * rs -----
12171 * rd -----
12172 */
12173std::string NMD::RDDSP(uint64 instruction)
12174{
12175 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12176 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
12177
12178 std::string rt = GPR(copy(rt_value));
12179 std::string mask = IMMEDIATE(copy(mask_value));
12180
12181 return img::format("RDDSP %s, %s", rt, mask);
12182}
12183
12184
12185/*
12186 *
12187 *
12188 * 3 2 1
12189 * 10987654321098765432109876543210
12190 * 001000 x1110000101
12191 * rt -----
12192 * rs -----
12193 * rd -----
12194 */
12195std::string NMD::RDHWR(uint64 instruction)
12196{
12197 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12198 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
12199 uint64 sel_value = extract_sel_13_12_11(instruction);
12200
12201 std::string rt = GPR(copy(rt_value));
12202 std::string hs = CPR(copy(hs_value));
12203 std::string sel = IMMEDIATE(copy(sel_value));
12204
12205 return img::format("RDHWR %s, %s, %s", rt, hs, sel);
12206}
12207
12208
12209/*
12210 *
12211 *
12212 * 3 2 1
12213 * 10987654321098765432109876543210
12214 * 001000 x1110000101
12215 * rt -----
12216 * rs -----
12217 * rd -----
12218 */
12219std::string NMD::RDPGPR(uint64 instruction)
12220{
12221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12222 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12223
12224 std::string rt = GPR(copy(rt_value));
12225 std::string rs = GPR(copy(rs_value));
12226
12227 return img::format("RDPGPR %s, %s", rt, rs);
12228}
12229
12230
12231/*
12232 *
12233 *
12234 * 3 2 1
12235 * 10987654321098765432109876543210
12236 * 001000 x1110000101
12237 * rt -----
12238 * rs -----
12239 * rd -----
12240 */
12241std::string NMD::RECIP_D(uint64 instruction)
12242{
17ce2f00 12243 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12244 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12245
12246 std::string ft = FPR(copy(ft_value));
12247 std::string fs = FPR(copy(fs_value));
12248
12249 return img::format("RECIP.D %s, %s", ft, fs);
12250}
12251
12252
12253/*
12254 *
12255 *
12256 * 3 2 1
12257 * 10987654321098765432109876543210
12258 * 001000 x1110000101
12259 * rt -----
12260 * rs -----
12261 * rd -----
12262 */
12263std::string NMD::RECIP_S(uint64 instruction)
12264{
17ce2f00 12265 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12266 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12267
12268 std::string ft = FPR(copy(ft_value));
12269 std::string fs = FPR(copy(fs_value));
12270
12271 return img::format("RECIP.S %s, %s", ft, fs);
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::REPL_PH(uint64 instruction)
12286{
12287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
d3605cc0 12288 int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
89a955e8
AM		 12289
12290 std::string rt = GPR(copy(rt_value));
12291 std::string s = IMMEDIATE(copy(s_value));
12292
12293 return img::format("REPL.PH %s, %s", rt, s);
12294}
12295
12296
12297/*
12298 *
12299 *
12300 * 3 2 1
12301 * 10987654321098765432109876543210
12302 * 001000 x1110000101
12303 * rt -----
12304 * rs -----
12305 * rd -----
12306 */
12307std::string NMD::REPL_QB(uint64 instruction)
12308{
12309 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12310 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12311
12312 std::string rt = GPR(copy(rt_value));
12313 std::string u = IMMEDIATE(copy(u_value));
12314
12315 return img::format("REPL.QB %s, %s", rt, u);
12316}
12317
12318
12319/*
12320 *
12321 *
12322 * 3 2 1
12323 * 10987654321098765432109876543210
12324 * 001000 x1110000101
12325 * rt -----
12326 * rs -----
12327 * rd -----
12328 */
12329std::string NMD::REPLV_PH(uint64 instruction)
12330{
12331 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12332 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12333
12334 std::string rt = GPR(copy(rt_value));
12335 std::string rs = GPR(copy(rs_value));
12336
12337 return img::format("REPLV.PH %s, %s", rt, rs);
12338}
12339
12340
12341/*
12342 *
12343 *
12344 * 3 2 1
12345 * 10987654321098765432109876543210
12346 * 001000 x1110000101
12347 * rt -----
12348 * rs -----
12349 * rd -----
12350 */
12351std::string NMD::REPLV_QB(uint64 instruction)
12352{
12353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12355
12356 std::string rt = GPR(copy(rt_value));
12357 std::string rs = GPR(copy(rs_value));
12358
12359 return img::format("REPLV.QB %s, %s", rt, rs);
12360}
12361
12362
12363/*
12364 *
12365 *
12366 * 3 2 1
12367 * 10987654321098765432109876543210
12368 * 001000 x1110000101
12369 * rt -----
12370 * rs -----
12371 * rd -----
12372 */
12373std::string NMD::RESTORE_32_(uint64 instruction)
12374{
89a955e8 12375 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
75199b40 12376 uint64 count_value = extract_count_19_18_17_16(instruction);
11b9732a 12377 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
89a955e8
AM		 12378 uint64 gp_value = extract_gp_2(instruction);
12379
12380 std::string u = IMMEDIATE(copy(u_value));
12381 return img::format("RESTORE %s%s", u,
12382 save_restore_list(rt_value, count_value, gp_value));
12383}
12384
12385
12386/*
12387 *
12388 *
12389 * 3 2 1
12390 * 10987654321098765432109876543210
12391 * 001000 x1110000101
12392 * rt -----
12393 * rs -----
12394 * rd -----
12395 */
12396std::string NMD::RESTORE_JRC_16_(uint64 instruction)
12397{
89a955e8 12398 uint64 rt1_value = extract_rtl_11(instruction);
11b9732a 12399 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
75199b40 12400 uint64 count_value = extract_count_3_2_1_0(instruction);
89a955e8
AM		 12401
12402 std::string u = IMMEDIATE(copy(u_value));
12403 return img::format("RESTORE.JRC %s%s", u,
12404 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12405}
12406
12407
12408/*
12409 *
12410 *
12411 * 3 2 1
12412 * 10987654321098765432109876543210
12413 * 001000 x1110000101
12414 * rt -----
12415 * rs -----
12416 * rd -----
12417 */
12418std::string NMD::RESTORE_JRC_32_(uint64 instruction)
12419{
89a955e8 12420 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 12421 uint64 count_value = extract_count_19_18_17_16(instruction);
11b9732a 12422 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
89a955e8
AM		 12423 uint64 gp_value = extract_gp_2(instruction);
12424
12425 std::string u = IMMEDIATE(copy(u_value));
12426 return img::format("RESTORE.JRC %s%s", u,
12427 save_restore_list(rt_value, count_value, gp_value));
12428}
12429
12430
12431/*
12432 *
12433 *
12434 * 3 2 1
12435 * 10987654321098765432109876543210
12436 * 001000 x1110000101
12437 * rt -----
12438 * rs -----
12439 * rd -----
12440 */
12441std::string NMD::RESTOREF(uint64 instruction)
12442{
12443 uint64 count_value = extract_count_19_18_17_16(instruction);
11b9732a 12444 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
89a955e8
AM		 12445
12446 std::string u = IMMEDIATE(copy(u_value));
12447 std::string count = IMMEDIATE(copy(count_value));
12448
12449 return img::format("RESTOREF %s, %s", u, count);
12450}
12451
12452
12453/*
12454 *
12455 *
12456 * 3 2 1
12457 * 10987654321098765432109876543210
12458 * 001000 x1110000101
12459 * rt -----
12460 * rs -----
12461 * rd -----
12462 */
12463std::string NMD::RINT_D(uint64 instruction)
12464{
17ce2f00 12465 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12466 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12467
12468 std::string ft = FPR(copy(ft_value));
12469 std::string fs = FPR(copy(fs_value));
12470
12471 return img::format("RINT.D %s, %s", ft, fs);
12472}
12473
12474
12475/*
12476 *
12477 *
12478 * 3 2 1
12479 * 10987654321098765432109876543210
12480 * 001000 x1110000101
12481 * rt -----
12482 * rs -----
12483 * rd -----
12484 */
12485std::string NMD::RINT_S(uint64 instruction)
12486{
17ce2f00 12487 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12488 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12489
12490 std::string ft = FPR(copy(ft_value));
12491 std::string fs = FPR(copy(fs_value));
12492
12493 return img::format("RINT.S %s, %s", ft, fs);
12494}
12495
12496
12497/*
12498 *
12499 *
12500 * 3 2 1
12501 * 10987654321098765432109876543210
12502 * 001000 x1110000101
12503 * rt -----
12504 * rs -----
12505 * rd -----
12506 */
12507std::string NMD::ROTR(uint64 instruction)
12508{
12509 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12510 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12511 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 12512
12513 std::string rt = GPR(copy(rt_value));
12514 std::string rs = GPR(copy(rs_value));
12515 std::string shift = IMMEDIATE(copy(shift_value));
12516
12517 return img::format("ROTR %s, %s, %s", rt, rs, shift);
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::ROTRV(uint64 instruction)
12532{
12533 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12534 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12535 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 12536
12537 std::string rd = GPR(copy(rd_value));
12538 std::string rs = GPR(copy(rs_value));
12539 std::string rt = GPR(copy(rt_value));
12540
12541 return img::format("ROTRV %s, %s, %s", rd, rs, rt);
12542}
12543
12544
12545/*
12546 *
12547 *
12548 * 3 2 1
12549 * 10987654321098765432109876543210
12550 * 001000 x1110000101
12551 * rt -----
12552 * rs -----
12553 * rd -----
12554 */
12555std::string NMD::ROTX(uint64 instruction)
12556{
12557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
86b5f803 12558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11b9732a 12559 uint64 shiftx_value = extract_shiftx_10_9_8_7__s1(instruction);
89a955e8 12560 uint64 stripe_value = extract_stripe_6(instruction);
86b5f803 12561 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 12562
12563 std::string rt = GPR(copy(rt_value));
12564 std::string rs = GPR(copy(rs_value));
12565 std::string shift = IMMEDIATE(copy(shift_value));
12566 std::string shiftx = IMMEDIATE(copy(shiftx_value));
12567 std::string stripe = IMMEDIATE(copy(stripe_value));
12568
12569 return img::format("ROTX %s, %s, %s, %s, %s",
12570 rt, rs, shift, shiftx, stripe);
12571}
12572
12573
12574/*
12575 *
12576 *
12577 * 3 2 1
12578 * 10987654321098765432109876543210
12579 * 001000 x1110000101
12580 * rt -----
12581 * rs -----
12582 * rd -----
12583 */
12584std::string NMD::ROUND_L_D(uint64 instruction)
12585{
17ce2f00 12586 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12587 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12588
12589 std::string ft = FPR(copy(ft_value));
12590 std::string fs = FPR(copy(fs_value));
12591
12592 return img::format("ROUND.L.D %s, %s", ft, fs);
12593}
12594
12595
12596/*
12597 *
12598 *
12599 * 3 2 1
12600 * 10987654321098765432109876543210
12601 * 001000 x1110000101
12602 * rt -----
12603 * rs -----
12604 * rd -----
12605 */
12606std::string NMD::ROUND_L_S(uint64 instruction)
12607{
17ce2f00 12608 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12609 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12610
12611 std::string ft = FPR(copy(ft_value));
12612 std::string fs = FPR(copy(fs_value));
12613
12614 return img::format("ROUND.L.S %s, %s", ft, fs);
12615}
12616
12617
12618/*
12619 *
12620 *
12621 * 3 2 1
12622 * 10987654321098765432109876543210
12623 * 001000 x1110000101
12624 * rt -----
12625 * rs -----
12626 * rd -----
12627 */
12628std::string NMD::ROUND_W_D(uint64 instruction)
12629{
17ce2f00 12630 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12631 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12632
12633 std::string ft = FPR(copy(ft_value));
12634 std::string fs = FPR(copy(fs_value));
12635
12636 return img::format("ROUND.W.D %s, %s", ft, fs);
12637}
12638
12639
12640/*
12641 *
12642 *
12643 * 3 2 1
12644 * 10987654321098765432109876543210
12645 * 001000 x1110000101
12646 * rt -----
12647 * rs -----
12648 * rd -----
12649 */
12650std::string NMD::ROUND_W_S(uint64 instruction)
12651{
17ce2f00 12652 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12653 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12654
12655 std::string ft = FPR(copy(ft_value));
12656 std::string fs = FPR(copy(fs_value));
12657
12658 return img::format("ROUND.W.S %s, %s", ft, fs);
12659}
12660
12661
12662/*
12663 *
12664 *
12665 * 3 2 1
12666 * 10987654321098765432109876543210
12667 * 001000 x1110000101
12668 * rt -----
12669 * rs -----
12670 * rd -----
12671 */
12672std::string NMD::RSQRT_D(uint64 instruction)
12673{
17ce2f00 12674 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12675 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12676
12677 std::string ft = FPR(copy(ft_value));
12678 std::string fs = FPR(copy(fs_value));
12679
12680 return img::format("RSQRT.D %s, %s", ft, fs);
12681}
12682
12683
12684/*
12685 *
12686 *
12687 * 3 2 1
12688 * 10987654321098765432109876543210
12689 * 001000 x1110000101
12690 * rt -----
12691 * rs -----
12692 * rd -----
12693 */
12694std::string NMD::RSQRT_S(uint64 instruction)
12695{
17ce2f00 12696 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 12697 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 12698
12699 std::string ft = FPR(copy(ft_value));
12700 std::string fs = FPR(copy(fs_value));
12701
12702 return img::format("RSQRT.S %s, %s", ft, fs);
12703}
12704
12705
12706/*
12707 *
12708 *
12709 * 3 2 1
12710 * 10987654321098765432109876543210
12711 * 001000 01001001101
12712 * rt -----
12713 * rs -----
12714 * rd -----
12715 */
12716std::string NMD::SAVE_16_(uint64 instruction)
12717{
89a955e8 12718 uint64 rt1_value = extract_rtl_11(instruction);
11b9732a 12719 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
75199b40 12720 uint64 count_value = extract_count_3_2_1_0(instruction);
89a955e8
AM		 12721
12722 std::string u = IMMEDIATE(copy(u_value));
12723 return img::format("SAVE %s%s", u,
12724 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12725}
12726
12727
12728/*
12729 *
12730 *
12731 * 3 2 1
12732 * 10987654321098765432109876543210
12733 * 001000 01001001101
12734 * rt -----
12735 * rs -----
12736 * rd -----
12737 */
12738std::string NMD::SAVE_32_(uint64 instruction)
12739{
12740 uint64 count_value = extract_count_19_18_17_16(instruction);
12741 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 12742 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
89a955e8
AM		 12743 uint64 gp_value = extract_gp_2(instruction);
12744
12745 std::string u = IMMEDIATE(copy(u_value));
12746 return img::format("SAVE %s%s", u,
12747 save_restore_list(rt_value, count_value, gp_value));
12748}
12749
12750
12751/*
12752 *
12753 *
12754 * 3 2 1
12755 * 10987654321098765432109876543210
12756 * 001000 01001001101
12757 * rt -----
12758 * rs -----
12759 * rd -----
12760 */
12761std::string NMD::SAVEF(uint64 instruction)
12762{
12763 uint64 count_value = extract_count_19_18_17_16(instruction);
11b9732a 12764 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
89a955e8
AM		 12765
12766 std::string u = IMMEDIATE(copy(u_value));
12767 std::string count = IMMEDIATE(copy(count_value));
12768
12769 return img::format("SAVEF %s, %s", u, count);
12770}
12771
12772
12773/*
12774 *
12775 *
12776 * 3 2 1
12777 * 10987654321098765432109876543210
12778 * 001000 01001001101
12779 * rt -----
12780 * rs -----
12781 * rd -----
12782 */
12783std::string NMD::SB_16_(uint64 instruction)
12784{
12785 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
89a955e8 12786 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 12787 uint64 u_value = extract_u_1_0(instruction);
89a955e8 12788
8191856b 12789 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
89a955e8 12790 std::string u = IMMEDIATE(copy(u_value));
988d6c89 12791 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 12792
12793 return img::format("SB %s, %s(%s)", rtz3, u, rs3);
12794}
12795
12796
12797/*
12798 *
12799 *
12800 * 3 2 1
12801 * 10987654321098765432109876543210
12802 * 001000 01001001101
12803 * rt -----
12804 * rs -----
12805 * rd -----
12806 */
12807std::string NMD::SB_GP_(uint64 instruction)
12808{
12809 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12810 uint64 u_value = extract_u_17_to_0(instruction);
12811
12812 std::string rt = GPR(copy(rt_value));
12813 std::string u = IMMEDIATE(copy(u_value));
12814
12815 return img::format("SB %s, %s($%d)", rt, u, 28);
12816}
12817
12818
12819/*
12820 *
12821 *
12822 * 3 2 1
12823 * 10987654321098765432109876543210
12824 * 001000 01001001101
12825 * rt -----
12826 * rs -----
12827 * rd -----
12828 */
12829std::string NMD::SB_S9_(uint64 instruction)
12830{
12831 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12832 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12833 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12834
12835 std::string rt = GPR(copy(rt_value));
12836 std::string s = IMMEDIATE(copy(s_value));
12837 std::string rs = GPR(copy(rs_value));
12838
12839 return img::format("SB %s, %s(%s)", rt, s, rs);
12840}
12841
12842
12843/*
12844 *
12845 *
12846 * 3 2 1
12847 * 10987654321098765432109876543210
12848 * 001000 01001001101
12849 * rt -----
12850 * rs -----
12851 * rd -----
12852 */
12853std::string NMD::SB_U12_(uint64 instruction)
12854{
12855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12856 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12857 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12858
12859 std::string rt = GPR(copy(rt_value));
12860 std::string u = IMMEDIATE(copy(u_value));
12861 std::string rs = GPR(copy(rs_value));
12862
12863 return img::format("SB %s, %s(%s)", rt, u, rs);
12864}
12865
12866
12867/*
12868 *
12869 *
12870 * 3 2 1
12871 * 10987654321098765432109876543210
12872 * 001000 01001001101
12873 * rt -----
12874 * rs -----
12875 * rd -----
12876 */
12877std::string NMD::SBE(uint64 instruction)
12878{
12879 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12880 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12881 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 12882
12883 std::string rt = GPR(copy(rt_value));
12884 std::string s = IMMEDIATE(copy(s_value));
12885 std::string rs = GPR(copy(rs_value));
12886
12887 return img::format("SBE %s, %s(%s)", rt, s, rs);
12888}
12889
12890
12891/*
12892 *
12893 *
12894 * 3 2 1
12895 * 10987654321098765432109876543210
12896 * 001000 01001001101
12897 * rt -----
12898 * rs -----
12899 * rd -----
12900 */
12901std::string NMD::SBX(uint64 instruction)
12902{
12903 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12904 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12905 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 12906
12907 std::string rd = GPR(copy(rd_value));
12908 std::string rs = GPR(copy(rs_value));
12909 std::string rt = GPR(copy(rt_value));
12910
12911 return img::format("SBX %s, %s(%s)", rd, rs, rt);
12912}
12913
12914
12915/*
12916 *
12917 *
12918 * 3 2 1
12919 * 10987654321098765432109876543210
12920 * 001000 01001001101
12921 * rt -----
12922 * rs -----
12923 * rd -----
12924 */
12925std::string NMD::SC(uint64 instruction)
12926{
12927 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12928 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12929 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
89a955e8
AM		 12930
12931 std::string rt = GPR(copy(rt_value));
12932 std::string s = IMMEDIATE(copy(s_value));
12933 std::string rs = GPR(copy(rs_value));
12934
12935 return img::format("SC %s, %s(%s)", rt, s, rs);
12936}
12937
12938
12939/*
12940 *
12941 *
12942 * 3 2 1
12943 * 10987654321098765432109876543210
12944 * 001000 01001001101
12945 * rt -----
12946 * rs -----
12947 * rd -----
12948 */
12949std::string NMD::SCD(uint64 instruction)
12950{
12951 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 12953 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
89a955e8
AM		 12954
12955 std::string rt = GPR(copy(rt_value));
12956 std::string s = IMMEDIATE(copy(s_value));
12957 std::string rs = GPR(copy(rs_value));
12958
12959 return img::format("SCD %s, %s(%s)", rt, s, rs);
12960}
12961
12962
12963/*
12964 *
12965 *
12966 * 3 2 1
12967 * 10987654321098765432109876543210
12968 * 001000 01001001101
12969 * rt -----
12970 * rs -----
12971 * rd -----
12972 */
12973std::string NMD::SCDP(uint64 instruction)
12974{
12975 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 12976 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 12977 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 12978
12979 std::string rt = GPR(copy(rt_value));
12980 std::string ru = GPR(copy(ru_value));
12981 std::string rs = GPR(copy(rs_value));
12982
12983 return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
12984}
12985
12986
12987/*
12988 *
12989 *
12990 * 3 2 1
12991 * 10987654321098765432109876543210
12992 * 001000 01001001101
12993 * rt -----
12994 * rs -----
12995 * rd -----
12996 */
12997std::string NMD::SCE(uint64 instruction)
12998{
12999 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13000 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13001 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
89a955e8
AM		 13002
13003 std::string rt = GPR(copy(rt_value));
13004 std::string s = IMMEDIATE(copy(s_value));
13005 std::string rs = GPR(copy(rs_value));
13006
13007 return img::format("SCE %s, %s(%s)", rt, s, rs);
13008}
13009
13010
13011/*
13012 *
13013 *
13014 * 3 2 1
13015 * 10987654321098765432109876543210
13016 * 001000 01001001101
13017 * rt -----
13018 * rs -----
13019 * rd -----
13020 */
13021std::string NMD::SCWP(uint64 instruction)
13022{
13023 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13024 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13025 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 13026
13027 std::string rt = GPR(copy(rt_value));
13028 std::string ru = GPR(copy(ru_value));
13029 std::string rs = GPR(copy(rs_value));
13030
13031 return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
13032}
13033
13034
13035/*
13036 *
13037 *
13038 * 3 2 1
13039 * 10987654321098765432109876543210
13040 * 001000 01001001101
13041 * rt -----
13042 * rs -----
13043 * rd -----
13044 */
13045std::string NMD::SCWPE(uint64 instruction)
13046{
13047 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13048 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13049 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
89a955e8
AM		 13050
13051 std::string rt = GPR(copy(rt_value));
13052 std::string ru = GPR(copy(ru_value));
13053 std::string rs = GPR(copy(rs_value));
13054
13055 return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
13056}
13057
13058
13059/*
13060 *
13061 *
13062 * 3 2 1
13063 * 10987654321098765432109876543210
13064 * 001000 01001001101
13065 * rt -----
13066 * rs -----
13067 * rd -----
13068 */
13069std::string NMD::SD_GP_(uint64 instruction)
13070{
13071 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 13072 uint64 u_value = extract_u_20_to_3__s3(instruction);
89a955e8
AM		 13073
13074 std::string rt = GPR(copy(rt_value));
13075 std::string u = IMMEDIATE(copy(u_value));
13076
13077 return img::format("SD %s, %s($%d)", rt, u, 28);
13078}
13079
13080
13081/*
13082 *
13083 *
13084 * 3 2 1
13085 * 10987654321098765432109876543210
13086 * 001000 01001001101
13087 * rt -----
13088 * rs -----
13089 * rd -----
13090 */
13091std::string NMD::SD_S9_(uint64 instruction)
13092{
13093 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13094 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13095 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13096
13097 std::string rt = GPR(copy(rt_value));
13098 std::string s = IMMEDIATE(copy(s_value));
13099 std::string rs = GPR(copy(rs_value));
13100
13101 return img::format("SD %s, %s(%s)", rt, s, rs);
13102}
13103
13104
13105/*
13106 *
13107 *
13108 * 3 2 1
13109 * 10987654321098765432109876543210
13110 * 001000 01001001101
13111 * rt -----
13112 * rs -----
13113 * rd -----
13114 */
13115std::string NMD::SD_U12_(uint64 instruction)
13116{
13117 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13118 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13119 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13120
13121 std::string rt = GPR(copy(rt_value));
13122 std::string u = IMMEDIATE(copy(u_value));
13123 std::string rs = GPR(copy(rs_value));
13124
13125 return img::format("SD %s, %s(%s)", rt, u, rs);
13126}
13127
13128
13129/*
13130 *
13131 *
13132 * 3 2 1
13133 * 10987654321098765432109876543210
13134 * 001000 01001001101
13135 * rt -----
13136 * rs -----
13137 * rd -----
13138 */
13139std::string NMD::SDBBP_16_(uint64 instruction)
13140{
13141 uint64 code_value = extract_code_2_1_0(instruction);
13142
13143 std::string code = IMMEDIATE(copy(code_value));
13144
13145 return img::format("SDBBP %s", code);
13146}
13147
13148
13149/*
13150 *
13151 *
13152 * 3 2 1
13153 * 10987654321098765432109876543210
13154 * 001000 01001001101
13155 * rt -----
13156 * rs -----
13157 * rd -----
13158 */
13159std::string NMD::SDBBP_32_(uint64 instruction)
13160{
13161 uint64 code_value = extract_code_18_to_0(instruction);
13162
13163 std::string code = IMMEDIATE(copy(code_value));
13164
13165 return img::format("SDBBP %s", code);
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::SDC1_GP_(uint64 instruction)
13180{
17ce2f00 13181 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11b9732a 13182 uint64 u_value = extract_u_17_to_2__s2(instruction);
89a955e8
AM		 13183
13184 std::string ft = FPR(copy(ft_value));
13185 std::string u = IMMEDIATE(copy(u_value));
13186
13187 return img::format("SDC1 %s, %s($%d)", ft, u, 28);
13188}
13189
13190
13191/*
13192 *
13193 *
13194 * 3 2 1
13195 * 10987654321098765432109876543210
13196 * 001000 01001001101
13197 * rt -----
13198 * rs -----
13199 * rd -----
13200 */
13201std::string NMD::SDC1_S9_(uint64 instruction)
13202{
17ce2f00 13203 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 13204 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13205 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13206
13207 std::string ft = FPR(copy(ft_value));
13208 std::string s = IMMEDIATE(copy(s_value));
13209 std::string rs = GPR(copy(rs_value));
13210
13211 return img::format("SDC1 %s, %s(%s)", ft, s, rs);
13212}
13213
13214
13215/*
13216 *
13217 *
13218 * 3 2 1
13219 * 10987654321098765432109876543210
13220 * 001000 01001001101
13221 * rt -----
13222 * rs -----
13223 * rd -----
13224 */
13225std::string NMD::SDC1_U12_(uint64 instruction)
13226{
17ce2f00 13227 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 13228 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13229 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13230
13231 std::string ft = FPR(copy(ft_value));
13232 std::string u = IMMEDIATE(copy(u_value));
13233 std::string rs = GPR(copy(rs_value));
13234
13235 return img::format("SDC1 %s, %s(%s)", ft, u, rs);
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::SDC1X(uint64 instruction)
13250{
13251 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13252 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13253 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 13254
13255 std::string ft = FPR(copy(ft_value));
13256 std::string rs = GPR(copy(rs_value));
13257 std::string rt = GPR(copy(rt_value));
13258
13259 return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
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::SDC1XS(uint64 instruction)
13274{
13275 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13276 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13277 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 13278
13279 std::string ft = FPR(copy(ft_value));
13280 std::string rs = GPR(copy(rs_value));
13281 std::string rt = GPR(copy(rt_value));
13282
13283 return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
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::SDC2(uint64 instruction)
13298{
13299 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
89a955e8 13300 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13301 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13302
13303 std::string cs = CPR(copy(cs_value));
13304 std::string s = IMMEDIATE(copy(s_value));
13305 std::string rs = GPR(copy(rs_value));
13306
13307 return img::format("SDC2 %s, %s(%s)", cs, s, rs);
13308}
13309
13310
13311/*
13312 *
13313 *
13314 * 3 2 1
13315 * 10987654321098765432109876543210
13316 * 001000 01001001101
13317 * rt -----
13318 * rs -----
13319 * rd -----
13320 */
13321std::string NMD::SDM(uint64 instruction)
13322{
13323 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13324 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 13325 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13326 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 13327
13328 std::string rt = GPR(copy(rt_value));
13329 std::string s = IMMEDIATE(copy(s_value));
13330 std::string rs = GPR(copy(rs_value));
13331 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
13332
13333 return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
13334}
13335
13336
13337/*
13338 *
13339 *
13340 * 3 2 1
13341 * 10987654321098765432109876543210
13342 * 001000 01001001101
13343 * rt -----
13344 * rs -----
13345 * rd -----
13346 */
13347std::string NMD::SDPC_48_(uint64 instruction)
13348{
13349 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 13350 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 13351
13352 std::string rt = GPR(copy(rt_value));
13353 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
13354
13355 return img::format("SDPC %s, %s", rt, s);
13356}
13357
13358
13359/*
13360 *
13361 *
13362 * 3 2 1
13363 * 10987654321098765432109876543210
13364 * 001000 01001001101
13365 * rt -----
13366 * rs -----
13367 * rd -----
13368 */
13369std::string NMD::SDXS(uint64 instruction)
13370{
13371 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13373 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13374
13375 std::string rd = GPR(copy(rd_value));
13376 std::string rs = GPR(copy(rs_value));
13377 std::string rt = GPR(copy(rt_value));
13378
13379 return img::format("SDXS %s, %s(%s)", rd, rs, rt);
13380}
13381
13382
13383/*
13384 *
13385 *
13386 * 3 2 1
13387 * 10987654321098765432109876543210
13388 * 001000 01001001101
13389 * rt -----
13390 * rs -----
13391 * rd -----
13392 */
13393std::string NMD::SDX(uint64 instruction)
13394{
13395 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13397 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13398
13399 std::string rd = GPR(copy(rd_value));
13400 std::string rs = GPR(copy(rs_value));
13401 std::string rt = GPR(copy(rt_value));
13402
13403 return img::format("SDX %s, %s(%s)", rd, rs, rt);
13404}
13405
13406
13407/*
13408 *
13409 *
13410 * 3 2 1
13411 * 10987654321098765432109876543210
13412 * 001000 01001001101
13413 * rt -----
13414 * rs -----
13415 * rd -----
13416 */
13417std::string NMD::SEB(uint64 instruction)
13418{
13419 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13420 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13421
13422 std::string rt = GPR(copy(rt_value));
13423 std::string rs = GPR(copy(rs_value));
13424
13425 return img::format("SEB %s, %s", rt, rs);
13426}
13427
13428
13429/*
13430 *
13431 *
13432 * 3 2 1
13433 * 10987654321098765432109876543210
13434 * 001000 01001001101
13435 * rt -----
13436 * rs -----
13437 * rd -----
13438 */
13439std::string NMD::SEH(uint64 instruction)
13440{
13441 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13442 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13443
13444 std::string rt = GPR(copy(rt_value));
13445 std::string rs = GPR(copy(rs_value));
13446
13447 return img::format("SEH %s, %s", rt, rs);
13448}
13449
13450
13451/*
13452 *
13453 *
13454 * 3 2 1
13455 * 10987654321098765432109876543210
13456 * 001000 01001001101
13457 * rt -----
13458 * rs -----
13459 * rd -----
13460 */
13461std::string NMD::SEL_D(uint64 instruction)
13462{
17ce2f00 13463 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13464 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13465 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13466
13467 std::string fd = FPR(copy(fd_value));
13468 std::string fs = FPR(copy(fs_value));
13469 std::string ft = FPR(copy(ft_value));
13470
13471 return img::format("SEL.D %s, %s, %s", fd, fs, ft);
13472}
13473
13474
13475/*
13476 *
13477 *
13478 * 3 2 1
13479 * 10987654321098765432109876543210
13480 * 001000 01001001101
13481 * rt -----
13482 * rs -----
13483 * rd -----
13484 */
13485std::string NMD::SEL_S(uint64 instruction)
13486{
17ce2f00 13487 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13488 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13489 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13490
13491 std::string fd = FPR(copy(fd_value));
13492 std::string fs = FPR(copy(fs_value));
13493 std::string ft = FPR(copy(ft_value));
13494
13495 return img::format("SEL.S %s, %s, %s", fd, fs, ft);
13496}
13497
13498
13499/*
13500 *
13501 *
13502 * 3 2 1
13503 * 10987654321098765432109876543210
13504 * 001000 01001001101
13505 * rt -----
13506 * rs -----
13507 * rd -----
13508 */
13509std::string NMD::SELEQZ_D(uint64 instruction)
13510{
17ce2f00 13511 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13512 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13513 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13514
13515 std::string fd = FPR(copy(fd_value));
13516 std::string fs = FPR(copy(fs_value));
13517 std::string ft = FPR(copy(ft_value));
13518
13519 return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13520}
13521
13522
13523/*
13524 *
13525 *
13526 * 3 2 1
13527 * 10987654321098765432109876543210
13528 * 001000 01001001101
13529 * rt -----
13530 * rs -----
13531 * rd -----
13532 */
13533std::string NMD::SELEQZ_S(uint64 instruction)
13534{
17ce2f00 13535 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13536 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13537 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13538
13539 std::string fd = FPR(copy(fd_value));
13540 std::string fs = FPR(copy(fs_value));
13541 std::string ft = FPR(copy(ft_value));
13542
13543 return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13544}
13545
13546
13547/*
13548 *
13549 *
13550 * 3 2 1
13551 * 10987654321098765432109876543210
13552 * 001000 01001001101
13553 * rt -----
13554 * rs -----
13555 * rd -----
13556 */
13557std::string NMD::SELNEZ_D(uint64 instruction)
13558{
17ce2f00 13559 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13560 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13561 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13562
13563 std::string fd = FPR(copy(fd_value));
13564 std::string fs = FPR(copy(fs_value));
13565 std::string ft = FPR(copy(ft_value));
13566
13567 return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13568}
13569
13570
13571/*
13572 *
13573 *
13574 * 3 2 1
13575 * 10987654321098765432109876543210
13576 * 001000 01001001101
13577 * rt -----
13578 * rs -----
13579 * rd -----
13580 */
13581std::string NMD::SELNEZ_S(uint64 instruction)
13582{
17ce2f00 13583 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 13584 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 13585 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 13586
13587 std::string fd = FPR(copy(fd_value));
13588 std::string fs = FPR(copy(fs_value));
13589 std::string ft = FPR(copy(ft_value));
13590
13591 return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13592}
13593
13594
13595/*
13596 *
13597 *
13598 * 3 2 1
13599 * 10987654321098765432109876543210
13600 * 001000 01001001101
13601 * rt -----
13602 * rs -----
13603 * rd -----
13604 */
13605std::string NMD::SEQI(uint64 instruction)
13606{
13607 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13608 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13609 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13610
13611 std::string rt = GPR(copy(rt_value));
13612 std::string rs = GPR(copy(rs_value));
13613 std::string u = IMMEDIATE(copy(u_value));
13614
13615 return img::format("SEQI %s, %s, %s", rt, rs, u);
13616}
13617
13618
13619/*
13620 *
13621 *
13622 * 3 2 1
13623 * 10987654321098765432109876543210
13624 * 001000 01001001101
13625 * rt -----
13626 * rs -----
13627 * rd -----
13628 */
13629std::string NMD::SH_16_(uint64 instruction)
13630{
13631 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
89a955e8 13632 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 13633 uint64 u_value = extract_u_2_1__s1(instruction);
89a955e8 13634
8191856b 13635 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
89a955e8 13636 std::string u = IMMEDIATE(copy(u_value));
988d6c89 13637 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 13638
13639 return img::format("SH %s, %s(%s)", rtz3, u, rs3);
13640}
13641
13642
13643/*
13644 *
13645 *
13646 * 3 2 1
13647 * 10987654321098765432109876543210
13648 * 001000 01001001101
13649 * rt -----
13650 * rs -----
13651 * rd -----
13652 */
13653std::string NMD::SH_GP_(uint64 instruction)
13654{
13655 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 13656 uint64 u_value = extract_u_17_to_1__s1(instruction);
89a955e8
AM		 13657
13658 std::string rt = GPR(copy(rt_value));
13659 std::string u = IMMEDIATE(copy(u_value));
13660
13661 return img::format("SH %s, %s($%d)", rt, u, 28);
13662}
13663
13664
13665/*
13666 *
13667 *
13668 * 3 2 1
13669 * 10987654321098765432109876543210
13670 * 001000 01001001101
13671 * rt -----
13672 * rs -----
13673 * rd -----
13674 */
13675std::string NMD::SH_S9_(uint64 instruction)
13676{
13677 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13678 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13679 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13680
13681 std::string rt = GPR(copy(rt_value));
13682 std::string s = IMMEDIATE(copy(s_value));
13683 std::string rs = GPR(copy(rs_value));
13684
13685 return img::format("SH %s, %s(%s)", rt, s, rs);
13686}
13687
13688
13689/*
13690 *
13691 *
13692 * 3 2 1
13693 * 10987654321098765432109876543210
13694 * 001000 01001001101
13695 * rt -----
13696 * rs -----
13697 * rd -----
13698 */
13699std::string NMD::SH_U12_(uint64 instruction)
13700{
13701 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13702 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13703 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13704
13705 std::string rt = GPR(copy(rt_value));
13706 std::string u = IMMEDIATE(copy(u_value));
13707 std::string rs = GPR(copy(rs_value));
13708
13709 return img::format("SH %s, %s(%s)", rt, u, rs);
13710}
13711
13712
13713/*
13714 *
13715 *
13716 * 3 2 1
13717 * 10987654321098765432109876543210
13718 * 001000 01001001101
13719 * rt -----
13720 * rs -----
13721 * rd -----
13722 */
13723std::string NMD::SHE(uint64 instruction)
13724{
13725 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13726 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13727 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 13728
13729 std::string rt = GPR(copy(rt_value));
13730 std::string s = IMMEDIATE(copy(s_value));
13731 std::string rs = GPR(copy(rs_value));
13732
13733 return img::format("SHE %s, %s(%s)", rt, s, rs);
13734}
13735
13736
13737/*
13738 * SHILO ac, shift - Shift an Accumulator Value Leaving the Result in the Same
13739 * Accumulator
13740 *
13741 * 3 2 1
13742 * 10987654321098765432109876543210
13743 * 001000xxxx xxxx0000011101
13744 * shift ------
13745 * ac --
13746 */
13747std::string NMD::SHILO(uint64 instruction)
13748{
d3605cc0 13749 int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
89a955e8
AM		 13750 uint64 ac_value = extract_ac_13_12(instruction);
13751
13752 std::string shift = IMMEDIATE(copy(shift_value));
13753 std::string ac = AC(copy(ac_value));
13754
13755 return img::format("SHILO %s, %s", ac, shift);
13756}
13757
13758
13759/*
13760 * SHILOV ac, rs - Variable Shift of Accumulator Value Leaving the Result in
13761 * the Same Accumulator
13762 *
13763 * 3 2 1
13764 * 10987654321098765432109876543210
13765 * 001000xxxxx 01001001111111
13766 * rs -----
13767 * ac --
13768 */
13769std::string NMD::SHILOV(uint64 instruction)
13770{
13771 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13772 uint64 ac_value = extract_ac_13_12(instruction);
13773
13774 std::string rs = GPR(copy(rs_value));
13775 std::string ac = AC(copy(ac_value));
13776
13777 return img::format("SHILOV %s, %s", ac, rs);
13778}
13779
13780
13781/*
13782 * SHLL.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords
13783 *
13784 * 3 2 1
13785 * 10987654321098765432109876543210
13786 * 001000 001110110101
13787 * rt -----
13788 * rs -----
13789 * sa ----
13790 */
13791std::string NMD::SHLL_PH(uint64 instruction)
13792{
13793 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13794 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13795 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13796
13797 std::string rt = GPR(copy(rt_value));
13798 std::string rs = GPR(copy(rs_value));
13799 std::string sa = IMMEDIATE(copy(sa_value));
13800
13801 return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
13802}
13803
13804
13805/*
13806 * SHLL.QB rt, rs, sa - Shift Left Logical Vector Quad Bytes
13807 *
13808 * 3 2 1
13809 * 10987654321098765432109876543210
13810 * 001000 0100001111111
13811 * rt -----
13812 * rs -----
13813 * sa ---
13814 */
13815std::string NMD::SHLL_QB(uint64 instruction)
13816{
13817 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13818 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13819 uint64 sa_value = extract_sa_15_14_13(instruction);
13820
13821 std::string rt = GPR(copy(rt_value));
13822 std::string rs = GPR(copy(rs_value));
13823 std::string sa = IMMEDIATE(copy(sa_value));
13824
13825 return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
13826}
13827
13828
13829/*
13830 * SHLL_S.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords (saturated)
13831 *
13832 * 3 2 1
13833 * 10987654321098765432109876543210
13834 * 001000 001110110101
13835 * rt -----
13836 * rs -----
13837 * sa ----
13838 */
13839std::string NMD::SHLL_S_PH(uint64 instruction)
13840{
13841 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13842 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13843 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13844
13845 std::string rt = GPR(copy(rt_value));
13846 std::string rs = GPR(copy(rs_value));
13847 std::string sa = IMMEDIATE(copy(sa_value));
13848
13849 return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
13850}
13851
13852
13853/*
13854 *
13855 *
13856 * 3 2 1
13857 * 10987654321098765432109876543210
13858 * 001000 01001001101
13859 * rt -----
13860 * rs -----
13861 * rd -----
13862 */
13863std::string NMD::SHLL_S_W(uint64 instruction)
13864{
13865 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13866 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13867 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 13868
13869 std::string rt = GPR(copy(rt_value));
13870 std::string rs = GPR(copy(rs_value));
13871 std::string sa = IMMEDIATE(copy(sa_value));
13872
13873 return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
13874}
13875
13876
13877/*
13878 *
13879 *
13880 * 3 2 1
13881 * 10987654321098765432109876543210
13882 * 001000 01001001101
13883 * rt -----
13884 * rs -----
13885 * rd -----
13886 */
13887std::string NMD::SHLLV_PH(uint64 instruction)
13888{
13889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13890 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13891 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13892
13893 std::string rd = GPR(copy(rd_value));
13894 std::string rt = GPR(copy(rt_value));
13895 std::string rs = GPR(copy(rs_value));
13896
13897 return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
13898}
13899
13900
13901/*
13902 *
13903 *
13904 * 3 2 1
13905 * 10987654321098765432109876543210
13906 * 001000 01001001101
13907 * rt -----
13908 * rs -----
13909 * rd -----
13910 */
13911std::string NMD::SHLLV_QB(uint64 instruction)
13912{
13913 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13914 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13915 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13916
13917 std::string rd = GPR(copy(rd_value));
13918 std::string rt = GPR(copy(rt_value));
13919 std::string rs = GPR(copy(rs_value));
13920
13921 return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
13922}
13923
13924
13925/*
13926 *
13927 *
13928 * 3 2 1
13929 * 10987654321098765432109876543210
13930 * 001000 01001001101
13931 * rt -----
13932 * rs -----
13933 * rd -----
13934 */
13935std::string NMD::SHLLV_S_PH(uint64 instruction)
13936{
13937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13939 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13940
13941 std::string rd = GPR(copy(rd_value));
13942 std::string rt = GPR(copy(rt_value));
13943 std::string rs = GPR(copy(rs_value));
13944
13945 return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
13946}
13947
13948
13949/*
13950 *
13951 *
13952 * 3 2 1
13953 * 10987654321098765432109876543210
13954 * 001000 01001001101
13955 * rt -----
13956 * rs -----
13957 * rd -----
13958 */
13959std::string NMD::SHLLV_S_W(uint64 instruction)
13960{
13961 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13962 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 13963 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 13964
13965 std::string rd = GPR(copy(rd_value));
13966 std::string rt = GPR(copy(rt_value));
13967 std::string rs = GPR(copy(rs_value));
13968
13969 return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
13970}
13971
13972
13973/*
13974 *
13975 *
13976 * 3 2 1
13977 * 10987654321098765432109876543210
13978 * 001000 01001001101
13979 * rt -----
13980 * rs -----
13981 * rd -----
13982 */
13983std::string NMD::SHRA_PH(uint64 instruction)
13984{
13985 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 13986 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 13987 uint64 sa_value = extract_sa_15_14_13_12(instruction);
89a955e8
AM		 13988
13989 std::string rt = GPR(copy(rt_value));
13990 std::string rs = GPR(copy(rs_value));
13991 std::string sa = IMMEDIATE(copy(sa_value));
13992
13993 return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
13994}
13995
13996
13997/*
13998 *
13999 *
14000 * 3 2 1
14001 * 10987654321098765432109876543210
14002 * 001000 01001001101
14003 * rt -----
14004 * rs -----
14005 * rd -----
14006 */
14007std::string NMD::SHRA_QB(uint64 instruction)
14008{
14009 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14010 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14011 uint64 sa_value = extract_sa_15_14_13(instruction);
89a955e8
AM		 14012
14013 std::string rt = GPR(copy(rt_value));
14014 std::string rs = GPR(copy(rs_value));
14015 std::string sa = IMMEDIATE(copy(sa_value));
14016
14017 return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
14018}
14019
14020
14021/*
14022 *
14023 *
14024 * 3 2 1
14025 * 10987654321098765432109876543210
14026 * 001000 01001001101
14027 * rt -----
14028 * rs -----
14029 * rd -----
14030 */
14031std::string NMD::SHRA_R_PH(uint64 instruction)
14032{
14033 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14034 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14035 uint64 sa_value = extract_sa_15_14_13_12(instruction);
89a955e8
AM		 14036
14037 std::string rt = GPR(copy(rt_value));
14038 std::string rs = GPR(copy(rs_value));
14039 std::string sa = IMMEDIATE(copy(sa_value));
14040
14041 return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
14042}
14043
14044
14045/*
14046 *
14047 *
14048 * 3 2 1
14049 * 10987654321098765432109876543210
14050 * 001000 01001001101
14051 * rt -----
14052 * rs -----
14053 * rd -----
14054 */
14055std::string NMD::SHRA_R_QB(uint64 instruction)
14056{
14057 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14058 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14059 uint64 sa_value = extract_sa_15_14_13(instruction);
89a955e8
AM		 14060
14061 std::string rt = GPR(copy(rt_value));
14062 std::string rs = GPR(copy(rs_value));
14063 std::string sa = IMMEDIATE(copy(sa_value));
14064
14065 return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
14066}
14067
14068
14069/*
14070 *
14071 *
14072 * 3 2 1
14073 * 10987654321098765432109876543210
14074 * 001000 01001001101
14075 * rt -----
14076 * rs -----
14077 * rd -----
14078 */
14079std::string NMD::SHRA_R_W(uint64 instruction)
14080{
14081 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14082 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14083 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
89a955e8
AM		 14084
14085 std::string rt = GPR(copy(rt_value));
14086 std::string rs = GPR(copy(rs_value));
14087 std::string sa = IMMEDIATE(copy(sa_value));
14088
14089 return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
14090}
14091
14092
14093/*
14094 *
14095 *
14096 * 3 2 1
14097 * 10987654321098765432109876543210
14098 * 001000 01001001101
14099 * rt -----
14100 * rs -----
14101 * rd -----
14102 */
14103std::string NMD::SHRAV_PH(uint64 instruction)
14104{
14105 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14107 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14108
14109 std::string rd = GPR(copy(rd_value));
14110 std::string rt = GPR(copy(rt_value));
14111 std::string rs = GPR(copy(rs_value));
14112
14113 return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
14114}
14115
14116
14117/*
14118 *
14119 *
14120 * 3 2 1
14121 * 10987654321098765432109876543210
14122 * 001000 01001001101
14123 * rt -----
14124 * rs -----
14125 * rd -----
14126 */
14127std::string NMD::SHRAV_QB(uint64 instruction)
14128{
14129 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14130 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14131 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14132
14133 std::string rd = GPR(copy(rd_value));
14134 std::string rt = GPR(copy(rt_value));
14135 std::string rs = GPR(copy(rs_value));
14136
14137 return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
14138}
14139
14140
14141/*
14142 *
14143 *
14144 * 3 2 1
14145 * 10987654321098765432109876543210
14146 * 001000 01001001101
14147 * rt -----
14148 * rs -----
14149 * rd -----
14150 */
14151std::string NMD::SHRAV_R_PH(uint64 instruction)
14152{
14153 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14154 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14155 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14156
14157 std::string rd = GPR(copy(rd_value));
14158 std::string rt = GPR(copy(rt_value));
14159 std::string rs = GPR(copy(rs_value));
14160
14161 return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
14162}
14163
14164
14165/*
14166 *
14167 *
14168 * 3 2 1
14169 * 10987654321098765432109876543210
14170 * 001000 01001001101
14171 * rt -----
14172 * rs -----
14173 * rd -----
14174 */
14175std::string NMD::SHRAV_R_QB(uint64 instruction)
14176{
14177 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14178 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14179 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14180
14181 std::string rd = GPR(copy(rd_value));
14182 std::string rt = GPR(copy(rt_value));
14183 std::string rs = GPR(copy(rs_value));
14184
14185 return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
14186}
14187
14188
14189/*
14190 *
14191 *
14192 * 3 2 1
14193 * 10987654321098765432109876543210
14194 * 001000 01001001101
14195 * rt -----
14196 * rs -----
14197 * rd -----
14198 */
14199std::string NMD::SHRAV_R_W(uint64 instruction)
14200{
14201 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14202 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14203 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14204
14205 std::string rd = GPR(copy(rd_value));
14206 std::string rt = GPR(copy(rt_value));
14207 std::string rs = GPR(copy(rs_value));
14208
14209 return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
14210}
14211
14212
14213/*
14214 *
14215 *
14216 * 3 2 1
14217 * 10987654321098765432109876543210
14218 * 001000 01001001101
14219 * rt -----
14220 * rs -----
14221 * rd -----
14222 */
14223std::string NMD::SHRL_PH(uint64 instruction)
14224{
14225 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14226 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14227 uint64 sa_value = extract_sa_15_14_13_12(instruction);
89a955e8
AM		 14228
14229 std::string rt = GPR(copy(rt_value));
14230 std::string rs = GPR(copy(rs_value));
14231 std::string sa = IMMEDIATE(copy(sa_value));
14232
14233 return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
14234}
14235
14236
14237/*
14238 *
14239 *
14240 * 3 2 1
14241 * 10987654321098765432109876543210
14242 * 001000 01001001101
14243 * rt -----
14244 * rs -----
14245 * rd -----
14246 */
14247std::string NMD::SHRL_QB(uint64 instruction)
14248{
14249 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14250 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 14251 uint64 sa_value = extract_sa_15_14_13(instruction);
89a955e8
AM		 14252
14253 std::string rt = GPR(copy(rt_value));
14254 std::string rs = GPR(copy(rs_value));
14255 std::string sa = IMMEDIATE(copy(sa_value));
14256
14257 return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
14258}
14259
14260
14261/*
14262 *
14263 *
14264 * 3 2 1
14265 * 10987654321098765432109876543210
14266 * 001000 01001001101
14267 * rt -----
14268 * rs -----
14269 * rd -----
14270 */
14271std::string NMD::SHRLV_PH(uint64 instruction)
14272{
14273 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14274 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14275 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14276
14277 std::string rd = GPR(copy(rd_value));
14278 std::string rt = GPR(copy(rt_value));
14279 std::string rs = GPR(copy(rs_value));
14280
14281 return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14282}
14283
14284
14285/*
14286 *
14287 *
14288 * 3 2 1
14289 * 10987654321098765432109876543210
14290 * 001000 01001001101
14291 * rt -----
14292 * rs -----
14293 * rd -----
14294 */
14295std::string NMD::SHRLV_QB(uint64 instruction)
14296{
14297 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14298 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14299 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14300
14301 std::string rd = GPR(copy(rd_value));
14302 std::string rt = GPR(copy(rt_value));
14303 std::string rs = GPR(copy(rs_value));
14304
14305 return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14306}
14307
14308
14309/*
14310 *
14311 *
14312 * 3 2 1
14313 * 10987654321098765432109876543210
14314 * 001000 01001001101
14315 * rt -----
14316 * rs -----
14317 * rd -----
14318 */
14319std::string NMD::SHX(uint64 instruction)
14320{
14321 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14322 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14323 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14324
14325 std::string rd = GPR(copy(rd_value));
14326 std::string rs = GPR(copy(rs_value));
14327 std::string rt = GPR(copy(rt_value));
14328
14329 return img::format("SHX %s, %s(%s)", rd, rs, rt);
14330}
14331
14332
14333/*
14334 *
14335 *
14336 * 3 2 1
14337 * 10987654321098765432109876543210
14338 * 001000 01001001101
14339 * rt -----
14340 * rs -----
14341 * rd -----
14342 */
14343std::string NMD::SHXS(uint64 instruction)
14344{
14345 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14346 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14347 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14348
14349 std::string rd = GPR(copy(rd_value));
14350 std::string rs = GPR(copy(rs_value));
14351 std::string rt = GPR(copy(rt_value));
14352
14353 return img::format("SHXS %s, %s(%s)", rd, rs, rt);
14354}
14355
14356
14357/*
14358 *
14359 *
14360 * 3 2 1
14361 * 10987654321098765432109876543210
14362 * 001000 01001001101
14363 * rt -----
14364 * rs -----
14365 * rd -----
14366 */
14367std::string NMD::SIGRIE(uint64 instruction)
14368{
14369 uint64 code_value = extract_code_18_to_0(instruction);
14370
14371 std::string code = IMMEDIATE(copy(code_value));
14372
14373 return img::format("SIGRIE %s", code);
14374}
14375
14376
14377/*
14378 *
14379 *
14380 * 3 2 1
14381 * 10987654321098765432109876543210
14382 * 001000 01001001101
14383 * rt -----
14384 * rs -----
14385 * rd -----
14386 */
14387std::string NMD::SLL_16_(uint64 instruction)
14388{
89a955e8
AM		 14389 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14390 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 14391 uint64 shift3_value = extract_shift3_2_1_0(instruction);
89a955e8 14392
988d6c89
AM		 14393 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14394 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 14395 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14396
14397 return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
14398}
14399
14400
14401/*
14402 *
14403 *
14404 * 3 2 1
14405 * 10987654321098765432109876543210
14406 * 001000 01001001101
14407 * rt -----
14408 * rs -----
14409 * rd -----
14410 */
14411std::string NMD::SLL_32_(uint64 instruction)
14412{
14413 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14414 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14415 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 14416
14417 std::string rt = GPR(copy(rt_value));
14418 std::string rs = GPR(copy(rs_value));
14419 std::string shift = IMMEDIATE(copy(shift_value));
14420
14421 return img::format("SLL %s, %s, %s", rt, rs, shift);
14422}
14423
14424
14425/*
14426 *
14427 *
14428 * 3 2 1
14429 * 10987654321098765432109876543210
14430 * 001000 01001001101
14431 * rt -----
14432 * rs -----
14433 * rd -----
14434 */
14435std::string NMD::SLLV(uint64 instruction)
14436{
14437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14438 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14439 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14440
14441 std::string rd = GPR(copy(rd_value));
14442 std::string rs = GPR(copy(rs_value));
14443 std::string rt = GPR(copy(rt_value));
14444
14445 return img::format("SLLV %s, %s, %s", rd, rs, rt);
14446}
14447
14448
14449/*
14450 *
14451 *
14452 * 3 2 1
14453 * 10987654321098765432109876543210
14454 * 001000 01001001101
14455 * rt -----
14456 * rs -----
14457 * rd -----
14458 */
14459std::string NMD::SLT(uint64 instruction)
14460{
14461 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14462 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14463 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14464
14465 std::string rd = GPR(copy(rd_value));
14466 std::string rs = GPR(copy(rs_value));
14467 std::string rt = GPR(copy(rt_value));
14468
14469 return img::format("SLT %s, %s, %s", rd, rs, rt);
14470}
14471
14472
14473/*
14474 *
14475 *
14476 * 3 2 1
14477 * 10987654321098765432109876543210
14478 * 001000 01001001101
14479 * rt -----
14480 * rs -----
14481 * rd -----
14482 */
14483std::string NMD::SLTI(uint64 instruction)
14484{
14485 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14486 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14487 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 14488
14489 std::string rt = GPR(copy(rt_value));
14490 std::string rs = GPR(copy(rs_value));
14491 std::string u = IMMEDIATE(copy(u_value));
14492
14493 return img::format("SLTI %s, %s, %s", rt, rs, u);
14494}
14495
14496
14497/*
14498 *
14499 *
14500 * 3 2 1
14501 * 10987654321098765432109876543210
14502 * 001000 01001001101
14503 * rt -----
14504 * rs -----
14505 * rd -----
14506 */
14507std::string NMD::SLTIU(uint64 instruction)
14508{
14509 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14510 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14511 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 14512
14513 std::string rt = GPR(copy(rt_value));
14514 std::string rs = GPR(copy(rs_value));
14515 std::string u = IMMEDIATE(copy(u_value));
14516
14517 return img::format("SLTIU %s, %s, %s", rt, rs, u);
14518}
14519
14520
14521/*
14522 *
14523 *
14524 * 3 2 1
14525 * 10987654321098765432109876543210
14526 * 001000 01001001101
14527 * rt -----
14528 * rs -----
14529 * rd -----
14530 */
14531std::string NMD::SLTU(uint64 instruction)
14532{
14533 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14534 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14535 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14536
14537 std::string rd = GPR(copy(rd_value));
14538 std::string rs = GPR(copy(rs_value));
14539 std::string rt = GPR(copy(rt_value));
14540
14541 return img::format("SLTU %s, %s, %s", rd, rs, rt);
14542}
14543
14544
14545/*
14546 *
14547 *
14548 * 3 2 1
14549 * 10987654321098765432109876543210
14550 * 001000 01001001101
14551 * rt -----
14552 * rs -----
14553 * rd -----
14554 */
14555std::string NMD::SOV(uint64 instruction)
14556{
14557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14559 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14560
14561 std::string rd = GPR(copy(rd_value));
14562 std::string rs = GPR(copy(rs_value));
14563 std::string rt = GPR(copy(rt_value));
14564
14565 return img::format("SOV %s, %s, %s", rd, rs, rt);
14566}
14567
14568
14569/*
14570 *
14571 *
14572 * 3 2 1
14573 * 10987654321098765432109876543210
14574 * 001000 01001001101
14575 * rt -----
14576 * rs -----
14577 * rd -----
14578 */
14579std::string NMD::SPECIAL2(uint64 instruction)
14580{
14581 uint64 op_value = extract_op_25_to_3(instruction);
14582
14583 std::string op = IMMEDIATE(copy(op_value));
14584
14585 return img::format("SPECIAL2 %s", op);
14586}
14587
14588
14589/*
14590 *
14591 *
14592 * 3 2 1
14593 * 10987654321098765432109876543210
14594 * 001000 01001001101
14595 * rt -----
14596 * rs -----
14597 * rd -----
14598 */
14599std::string NMD::SQRT_D(uint64 instruction)
14600{
17ce2f00 14601 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 14602 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 14603
14604 std::string ft = FPR(copy(ft_value));
14605 std::string fs = FPR(copy(fs_value));
14606
14607 return img::format("SQRT.D %s, %s", ft, fs);
14608}
14609
14610
14611/*
14612 *
14613 *
14614 * 3 2 1
14615 * 10987654321098765432109876543210
14616 * 001000 01001001101
14617 * rt -----
14618 * rs -----
14619 * rd -----
14620 */
14621std::string NMD::SQRT_S(uint64 instruction)
14622{
17ce2f00 14623 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 14624 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 14625
14626 std::string ft = FPR(copy(ft_value));
14627 std::string fs = FPR(copy(fs_value));
14628
14629 return img::format("SQRT.S %s, %s", ft, fs);
14630}
14631
14632
14633/*
14634 * SRA rd, rt, sa - Shift Word Right Arithmetic
14635 *
14636 * 3 2 1
14637 * 10987654321098765432109876543210
14638 * 00000000000 000011
14639 * rt -----
14640 * rd -----
14641 * sa -----
14642 */
14643std::string NMD::SRA(uint64 instruction)
14644{
14645 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14646 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14647 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14648
14649 std::string rt = GPR(copy(rt_value));
14650 std::string rs = GPR(copy(rs_value));
14651 std::string shift = IMMEDIATE(copy(shift_value));
14652
14653 return img::format("SRA %s, %s, %s", rt, rs, shift);
14654}
14655
14656
14657/*
14658 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14659 *
14660 * 3 2 1
14661 * 10987654321098765432109876543210
14662 * 001000 00000000111
14663 * rs -----
14664 * rt -----
14665 * rd -----
14666 */
14667std::string NMD::SRAV(uint64 instruction)
14668{
14669 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14670 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14671 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14672
14673 std::string rd = GPR(copy(rd_value));
14674 std::string rs = GPR(copy(rs_value));
14675 std::string rt = GPR(copy(rt_value));
14676
14677 return img::format("SRAV %s, %s, %s", rd, rs, rt);
14678}
14679
14680
14681/*
14682 *
14683 *
14684 * 3 2 1
14685 * 10987654321098765432109876543210
14686 * 001000 00000000111
14687 * rs -----
14688 * rt -----
14689 * rd -----
14690 */
14691std::string NMD::SRL_16_(uint64 instruction)
14692{
89a955e8
AM		 14693 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14694 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 14695 uint64 shift3_value = extract_shift3_2_1_0(instruction);
89a955e8 14696
988d6c89
AM		 14697 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14698 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 14699 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14700
14701 return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
14702}
14703
14704
14705/*
14706 *
14707 *
14708 * 3 2 1
14709 * 10987654321098765432109876543210
14710 * 001000 01001001101
14711 * rt -----
14712 * rs -----
14713 * rd -----
14714 */
14715std::string NMD::SRL_32_(uint64 instruction)
14716{
14717 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14718 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14719 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
89a955e8
AM		 14720
14721 std::string rt = GPR(copy(rt_value));
14722 std::string rs = GPR(copy(rs_value));
14723 std::string shift = IMMEDIATE(copy(shift_value));
14724
14725 return img::format("SRL %s, %s, %s", rt, rs, shift);
14726}
14727
14728
14729/*
14730 *
14731 *
14732 * 3 2 1
14733 * 10987654321098765432109876543210
14734 * 001000 01001001101
14735 * rt -----
14736 * rs -----
14737 * rd -----
14738 */
14739std::string NMD::SRLV(uint64 instruction)
14740{
14741 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14742 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14743 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14744
14745 std::string rd = GPR(copy(rd_value));
14746 std::string rs = GPR(copy(rs_value));
14747 std::string rt = GPR(copy(rt_value));
14748
14749 return img::format("SRLV %s, %s, %s", rd, rs, rt);
14750}
14751
14752
14753/*
14754 *
14755 *
14756 * 3 2 1
14757 * 10987654321098765432109876543210
14758 * 001000 01001001101
14759 * rt -----
14760 * rs -----
14761 * rd -----
14762 */
14763std::string NMD::SUB(uint64 instruction)
14764{
14765 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14766 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14767 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14768
14769 std::string rd = GPR(copy(rd_value));
14770 std::string rs = GPR(copy(rs_value));
14771 std::string rt = GPR(copy(rt_value));
14772
14773 return img::format("SUB %s, %s, %s", rd, rs, rt);
14774}
14775
14776
14777/*
14778 *
14779 *
14780 * 3 2 1
14781 * 10987654321098765432109876543210
14782 * 001000 01001001101
14783 * rt -----
14784 * rs -----
14785 * rd -----
14786 */
14787std::string NMD::SUB_D(uint64 instruction)
14788{
17ce2f00 14789 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 14790 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 14791 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 14792
14793 std::string fd = FPR(copy(fd_value));
14794 std::string fs = FPR(copy(fs_value));
14795 std::string ft = FPR(copy(ft_value));
14796
14797 return img::format("SUB.D %s, %s, %s", fd, fs, ft);
14798}
14799
14800
14801/*
14802 *
14803 *
14804 * 3 2 1
14805 * 10987654321098765432109876543210
14806 * 001000 01001001101
14807 * rt -----
14808 * rs -----
14809 * rd -----
14810 */
14811std::string NMD::SUB_S(uint64 instruction)
14812{
17ce2f00 14813 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 14814 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
d0c60abd 14815 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
89a955e8
AM		 14816
14817 std::string fd = FPR(copy(fd_value));
14818 std::string fs = FPR(copy(fs_value));
14819 std::string ft = FPR(copy(ft_value));
14820
14821 return img::format("SUB.S %s, %s, %s", fd, fs, ft);
14822}
14823
14824
14825/*
14826 *
14827 *
14828 * 3 2 1
14829 * 10987654321098765432109876543210
14830 * 001000 01001001101
14831 * rt -----
14832 * rs -----
14833 * rd -----
14834 */
14835std::string NMD::SUBQ_PH(uint64 instruction)
14836{
14837 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14838 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14839 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14840
14841 std::string rd = GPR(copy(rd_value));
14842 std::string rs = GPR(copy(rs_value));
14843 std::string rt = GPR(copy(rt_value));
14844
14845 return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
14846}
14847
14848
14849/*
14850 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14851 * to Halve Results
14852 *
14853 * 3 2 1
14854 * 10987654321098765432109876543210
14855 * 001000 01001001101
14856 * rt -----
14857 * rs -----
14858 * rd -----
14859 */
14860std::string NMD::SUBQ_S_PH(uint64 instruction)
14861{
14862 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14863 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14864 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14865
14866 std::string rd = GPR(copy(rd_value));
14867 std::string rs = GPR(copy(rs_value));
14868 std::string rt = GPR(copy(rt_value));
14869
14870 return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
14871}
14872
14873
14874/*
14875 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14876 * to Halve Results
14877 *
14878 * 3 2 1
14879 * 10987654321098765432109876543210
14880 * 001000 01001001101
14881 * rt -----
14882 * rs -----
14883 * rd -----
14884 */
14885std::string NMD::SUBQ_S_W(uint64 instruction)
14886{
14887 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14888 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14889 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14890
14891 std::string rd = GPR(copy(rd_value));
14892 std::string rs = GPR(copy(rs_value));
14893 std::string rt = GPR(copy(rt_value));
14894
14895 return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
14896}
14897
14898
14899/*
14900 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14901 * to Halve Results
14902 *
14903 * 3 2 1
14904 * 10987654321098765432109876543210
14905 * 001000 01001001101
14906 * rt -----
14907 * rs -----
14908 * rd -----
14909 */
14910std::string NMD::SUBQH_PH(uint64 instruction)
14911{
14912 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14913 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14914 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14915
14916 std::string rd = GPR(copy(rd_value));
14917 std::string rs = GPR(copy(rs_value));
14918 std::string rt = GPR(copy(rt_value));
14919
14920 return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
14921}
14922
14923
14924/*
14925 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14926 * to Halve Results
14927 *
14928 * 3 2 1
14929 * 10987654321098765432109876543210
14930 * 001000 01001001101
14931 * rt -----
14932 * rs -----
14933 * rd -----
14934 */
14935std::string NMD::SUBQH_R_PH(uint64 instruction)
14936{
14937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14939 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14940
14941 std::string rd = GPR(copy(rd_value));
14942 std::string rs = GPR(copy(rs_value));
14943 std::string rt = GPR(copy(rt_value));
14944
14945 return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
14946}
14947
14948
14949/*
14950 * SUBQH_R.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14951 * to Halve Results (rounding)
14952 *
14953 * 3 2 1
14954 * 10987654321098765432109876543210
14955 * 001000 11001001101
14956 * rt -----
14957 * rs -----
14958 * rd -----
14959 */
14960std::string NMD::SUBQH_R_W(uint64 instruction)
14961{
14962 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14963 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14964 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14965
14966 std::string rd = GPR(copy(rd_value));
14967 std::string rs = GPR(copy(rs_value));
14968 std::string rt = GPR(copy(rt_value));
14969
14970 return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
14971}
14972
14973
14974/*
14975 * SUBQH.W rd, rs, rt - Subtract Fractional Words And Shift Right to Halve
14976 * Results
14977 *
14978 * 3 2 1
14979 * 10987654321098765432109876543210
14980 * 001000 01010001101
14981 * rt -----
14982 * rs -----
14983 * rd -----
14984 */
14985std::string NMD::SUBQH_W(uint64 instruction)
14986{
14987 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 14988 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 14989 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 14990
14991 std::string rd = GPR(copy(rd_value));
14992 std::string rs = GPR(copy(rs_value));
14993 std::string rt = GPR(copy(rt_value));
14994
14995 return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
14996}
14997
14998
14999/*
15000 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15001 *
15002 * 3 2 1
15003 * 10987654321098765432109876543210
15004 * 001000 00010001101
15005 * rt -----
15006 * rs -----
15007 * rd -----
15008 */
15009std::string NMD::SUBU_16_(uint64 instruction)
15010{
89a955e8
AM		 15011 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15012 uint64 rs3_value = extract_rs3_6_5_4(instruction);
86b5f803 15013 uint64 rd3_value = extract_rd3_3_2_1(instruction);
89a955e8 15014
988d6c89
AM		 15015 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
15016 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
15017 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 15018
15019 return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
15020}
15021
15022
15023/*
15024 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15025 *
15026 * 3 2 1
15027 * 10987654321098765432109876543210
15028 * 001000 00010001101
15029 * rt -----
15030 * rs -----
15031 * rd -----
15032 */
15033std::string NMD::SUBU_32_(uint64 instruction)
15034{
15035 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15036 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15037 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15038
15039 std::string rd = GPR(copy(rd_value));
15040 std::string rs = GPR(copy(rs_value));
15041 std::string rt = GPR(copy(rt_value));
15042
15043 return img::format("SUBU %s, %s, %s", rd, rs, rt);
15044}
15045
15046
15047/*
15048 * SUBU.PH rd, rs, rt - Subtract Unsigned Integer Halfwords
15049 *
15050 * 3 2 1
15051 * 10987654321098765432109876543210
15052 * 001000 01100001101
15053 * rt -----
15054 * rs -----
15055 * rd -----
15056 */
15057std::string NMD::SUBU_PH(uint64 instruction)
15058{
15059 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15060 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15061 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15062
15063 std::string rd = GPR(copy(rd_value));
15064 std::string rs = GPR(copy(rs_value));
15065 std::string rt = GPR(copy(rt_value));
15066
15067 return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
15068}
15069
15070
15071/*
15072 * SUBU.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector
15073 *
15074 * 3 2 1
15075 * 10987654321098765432109876543210
15076 * 001000 01011001101
15077 * rt -----
15078 * rs -----
15079 * rd -----
15080 */
15081std::string NMD::SUBU_QB(uint64 instruction)
15082{
15083 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15084 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15085 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15086
15087 std::string rd = GPR(copy(rd_value));
15088 std::string rs = GPR(copy(rs_value));
15089 std::string rt = GPR(copy(rt_value));
15090
15091 return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
15092}
15093
15094
15095/*
15096 * SUBU_S.PH rd, rs, rt - Subtract Unsigned Integer Halfwords (saturating)
15097 *
15098 * 3 2 1
15099 * 10987654321098765432109876543210
15100 * 001000 11100001101
15101 * rt -----
15102 * rs -----
15103 * rd -----
15104 */
15105std::string NMD::SUBU_S_PH(uint64 instruction)
15106{
15107 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15108 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15109 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15110
15111 std::string rd = GPR(copy(rd_value));
15112 std::string rs = GPR(copy(rs_value));
15113 std::string rt = GPR(copy(rt_value));
15114
15115 return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
15116}
15117
15118
15119/*
15120 * SUBU_S.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector (saturating)
15121 *
15122 * 3 2 1
15123 * 10987654321098765432109876543210
15124 * 001000 11011001101
15125 * rt -----
15126 * rs -----
15127 * rd -----
15128 */
15129std::string NMD::SUBU_S_QB(uint64 instruction)
15130{
15131 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15132 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15133 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15134
15135 std::string rd = GPR(copy(rd_value));
15136 std::string rs = GPR(copy(rs_value));
15137 std::string rt = GPR(copy(rt_value));
15138
15139 return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
15140}
15141
15142
15143/*
15144 * SUBUH.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15145 * Results
15146 *
15147 * 3 2 1
15148 * 10987654321098765432109876543210
15149 * 001000 01101001101
15150 * rt -----
15151 * rs -----
15152 * rd -----
15153 */
15154std::string NMD::SUBUH_QB(uint64 instruction)
15155{
15156 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15157 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15158 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15159
15160 std::string rd = GPR(copy(rd_value));
15161 std::string rs = GPR(copy(rs_value));
15162 std::string rt = GPR(copy(rt_value));
15163
15164 return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
15165}
15166
15167
15168/*
15169 * SUBUH_R.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15170 * Results (rounding)
15171 *
15172 * 3 2 1
15173 * 10987654321098765432109876543210
15174 * 001000 11101001101
15175 * rt -----
15176 * rs -----
15177 * rd -----
15178 */
15179std::string NMD::SUBUH_R_QB(uint64 instruction)
15180{
15181 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15182 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15183 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15184
15185 std::string rd = GPR(copy(rd_value));
15186 std::string rs = GPR(copy(rs_value));
15187 std::string rt = GPR(copy(rt_value));
15188
15189 return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
15190}
15191
15192
15193/*
15194 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15195 *
15196 * 3 2 1
15197 * 10987654321098765432109876543210
15198 * 001000 00010001101
15199 * rt -----
15200 * rs -----
15201 * rd -----
15202 */
15203std::string NMD::SW_16_(uint64 instruction)
15204{
15205 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
89a955e8 15206 uint64 rs3_value = extract_rs3_6_5_4(instruction);
75199b40 15207 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
89a955e8 15208
8191856b 15209 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
89a955e8 15210 std::string u = IMMEDIATE(copy(u_value));
988d6c89 15211 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
89a955e8
AM		 15212
15213 return img::format("SW %s, %s(%s)", rtz3, u, rs3);
15214}
15215
15216
15217/*
15218 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15219 *
15220 * 3 2 1
15221 * 10987654321098765432109876543210
15222 * 001000 00010001101
15223 * rt -----
15224 * rs -----
15225 * rd -----
15226 */
15227std::string NMD::SW_4X4_(uint64 instruction)
15228{
89a955e8 15229 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
75199b40 15230 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11b9732a 15231 uint64 u_value = extract_u_3_8__s2(instruction);
89a955e8
AM		 15232
15233 std::string rtz4 = GPR(encode_gpr4_zero(rtz4_value));
15234 std::string u = IMMEDIATE(copy(u_value));
15235 std::string rs4 = GPR(encode_gpr4(rs4_value));
15236
15237 return img::format("SW %s, %s(%s)", rtz4, u, rs4);
15238}
15239
15240
15241/*
15242 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15243 *
15244 * 3 2 1
15245 * 10987654321098765432109876543210
15246 * 001000 00010001101
15247 * rt -----
15248 * rs -----
15249 * rd -----
15250 */
15251std::string NMD::SW_GP16_(uint64 instruction)
15252{
11b9732a 15253 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
75199b40 15254 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
89a955e8 15255
8191856b 15256 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
89a955e8
AM		 15257 std::string u = IMMEDIATE(copy(u_value));
15258
15259 return img::format("SW %s, %s($%d)", rtz3, u, 28);
15260}
15261
15262
15263/*
15264 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15265 *
15266 * 3 2 1
15267 * 10987654321098765432109876543210
15268 * 001000 00010001101
15269 * rt -----
15270 * rs -----
15271 * rd -----
15272 */
15273std::string NMD::SW_GP_(uint64 instruction)
15274{
15275 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11b9732a 15276 uint64 u_value = extract_u_20_to_2__s2(instruction);
89a955e8
AM		 15277
15278 std::string rt = GPR(copy(rt_value));
15279 std::string u = IMMEDIATE(copy(u_value));
15280
15281 return img::format("SW %s, %s($%d)", rt, u, 28);
15282}
15283
15284
15285/*
15286 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15287 *
15288 * 3 2 1
15289 * 10987654321098765432109876543210
15290 * 001000 00010001101
15291 * rt -----
15292 * rs -----
15293 * rd -----
15294 */
15295std::string NMD::SW_S9_(uint64 instruction)
15296{
15297 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
d3605cc0 15298 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15299 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15300
15301 std::string rt = GPR(copy(rt_value));
15302 std::string s = IMMEDIATE(copy(s_value));
15303 std::string rs = GPR(copy(rs_value));
15304
15305 return img::format("SW %s, %s(%s)", rt, s, rs);
15306}
15307
15308
15309/*
15310 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15311 *
15312 * 3 2 1
15313 * 10987654321098765432109876543210
15314 * 001000 00010001101
15315 * rt -----
15316 * rs -----
15317 * rd -----
15318 */
15319std::string NMD::SW_SP_(uint64 instruction)
15320{
15321 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
11b9732a 15322 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
89a955e8
AM		 15323
15324 std::string rt = GPR(copy(rt_value));
15325 std::string u = IMMEDIATE(copy(u_value));
15326
15327 return img::format("SW %s, %s($%d)", rt, u, 29);
15328}
15329
15330
15331/*
15332 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15333 *
15334 * 3 2 1
15335 * 10987654321098765432109876543210
15336 * 001000 00010001101
15337 * rt -----
15338 * rs -----
15339 * rd -----
15340 */
15341std::string NMD::SW_U12_(uint64 instruction)
15342{
15343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15344 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15345 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15346
15347 std::string rt = GPR(copy(rt_value));
15348 std::string u = IMMEDIATE(copy(u_value));
15349 std::string rs = GPR(copy(rs_value));
15350
15351 return img::format("SW %s, %s(%s)", rt, u, rs);
15352}
15353
15354
15355/*
15356 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15357 *
15358 * 3 2 1
15359 * 10987654321098765432109876543210
15360 * 001000 00010001101
15361 * rt -----
15362 * rs -----
15363 * rd -----
15364 */
15365std::string NMD::SWC1_GP_(uint64 instruction)
15366{
17ce2f00 15367 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11b9732a 15368 uint64 u_value = extract_u_17_to_2__s2(instruction);
89a955e8
AM		 15369
15370 std::string ft = FPR(copy(ft_value));
15371 std::string u = IMMEDIATE(copy(u_value));
15372
15373 return img::format("SWC1 %s, %s($%d)", ft, u, 28);
15374}
15375
15376
15377/*
15378 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15379 *
15380 * 3 2 1
15381 * 10987654321098765432109876543210
15382 * 001000 00010001101
15383 * rt -----
15384 * rs -----
15385 * rd -----
15386 */
15387std::string NMD::SWC1_S9_(uint64 instruction)
15388{
17ce2f00 15389 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 15390 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15391 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15392
15393 std::string ft = FPR(copy(ft_value));
15394 std::string s = IMMEDIATE(copy(s_value));
15395 std::string rs = GPR(copy(rs_value));
15396
15397 return img::format("SWC1 %s, %s(%s)", ft, s, rs);
15398}
15399
15400
15401/*
15402 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15403 *
15404 * 3 2 1
15405 * 10987654321098765432109876543210
15406 * 001000 00010001101
15407 * rt -----
15408 * rs -----
15409 * rd -----
15410 */
15411std::string NMD::SWC1_U12_(uint64 instruction)
15412{
17ce2f00 15413 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
89a955e8 15414 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15415 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15416
15417 std::string ft = FPR(copy(ft_value));
15418 std::string u = IMMEDIATE(copy(u_value));
15419 std::string rs = GPR(copy(rs_value));
15420
15421 return img::format("SWC1 %s, %s(%s)", ft, u, rs);
15422}
15423
15424
15425/*
15426 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15427 *
15428 * 3 2 1
15429 * 10987654321098765432109876543210
15430 * 001000 00010001101
15431 * rt -----
15432 * rs -----
15433 * rd -----
15434 */
15435std::string NMD::SWC1X(uint64 instruction)
15436{
15437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15438 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15439 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 15440
15441 std::string ft = FPR(copy(ft_value));
15442 std::string rs = GPR(copy(rs_value));
15443 std::string rt = GPR(copy(rt_value));
15444
15445 return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
15446}
15447
15448
15449/*
15450 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15451 *
15452 * 3 2 1
15453 * 10987654321098765432109876543210
15454 * 001000 00010001101
15455 * rt -----
15456 * rs -----
15457 * rd -----
15458 */
15459std::string NMD::SWC1XS(uint64 instruction)
15460{
15461 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15462 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15463 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
89a955e8
AM		 15464
15465 std::string ft = FPR(copy(ft_value));
15466 std::string rs = GPR(copy(rs_value));
15467 std::string rt = GPR(copy(rt_value));
15468
15469 return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
15470}
15471
15472
15473/*
15474 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15475 *
15476 * 3 2 1
15477 * 10987654321098765432109876543210
15478 * 001000 00010001101
15479 * rt -----
15480 * rs -----
15481 * rd -----
15482 */
15483std::string NMD::SWC2(uint64 instruction)
15484{
15485 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
89a955e8 15486 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15487 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15488
15489 std::string cs = CPR(copy(cs_value));
15490 std::string s = IMMEDIATE(copy(s_value));
15491 std::string rs = GPR(copy(rs_value));
15492
15493 return img::format("SWC2 %s, %s(%s)", cs, s, rs);
15494}
15495
15496
15497/*
15498 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15499 *
15500 * 3 2 1
15501 * 10987654321098765432109876543210
15502 * 001000 00010001101
15503 * rt -----
15504 * rs -----
15505 * rd -----
15506 */
15507std::string NMD::SWE(uint64 instruction)
15508{
15509 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15510 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15511 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15512
15513 std::string rt = GPR(copy(rt_value));
15514 std::string s = IMMEDIATE(copy(s_value));
15515 std::string rs = GPR(copy(rs_value));
15516
15517 return img::format("SWE %s, %s(%s)", rt, s, rs);
15518}
15519
15520
15521/*
15522 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15523 *
15524 * 3 2 1
15525 * 10987654321098765432109876543210
15526 * 001000 00010001101
15527 * rt -----
15528 * rs -----
15529 * rd -----
15530 */
15531std::string NMD::SWM(uint64 instruction)
15532{
15533 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15534 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 15535 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15536 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 15537
15538 std::string rt = GPR(copy(rt_value));
15539 std::string s = IMMEDIATE(copy(s_value));
15540 std::string rs = GPR(copy(rs_value));
15541 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
15542
15543 return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
15544}
15545
15546
15547/*
15548 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15549 *
15550 * 3 2 1
15551 * 10987654321098765432109876543210
15552 * 001000 00010001101
15553 * rt -----
15554 * rs -----
15555 * rd -----
15556 */
15557std::string NMD::SWPC_48_(uint64 instruction)
15558{
15559 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
d3605cc0 15560 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
89a955e8
AM		 15561
15562 std::string rt = GPR(copy(rt_value));
15563 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
15564
15565 return img::format("SWPC %s, %s", rt, s);
15566}
15567
15568
15569/*
15570 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15571 *
15572 * 3 2 1
15573 * 10987654321098765432109876543210
15574 * 001000 00010001101
15575 * rt -----
15576 * rs -----
15577 * rd -----
15578 */
15579std::string NMD::SWX(uint64 instruction)
15580{
15581 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15582 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15583 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15584
15585 std::string rd = GPR(copy(rd_value));
15586 std::string rs = GPR(copy(rs_value));
15587 std::string rt = GPR(copy(rt_value));
15588
15589 return img::format("SWX %s, %s(%s)", rd, rs, rt);
15590}
15591
15592
15593/*
15594 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15595 *
15596 * 3 2 1
15597 * 10987654321098765432109876543210
15598 * 001000 00010001101
15599 * rt -----
15600 * rs -----
15601 * rd -----
15602 */
15603std::string NMD::SWXS(uint64 instruction)
15604{
15605 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 15606 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 15607 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 15608
15609 std::string rd = GPR(copy(rd_value));
15610 std::string rs = GPR(copy(rs_value));
15611 std::string rt = GPR(copy(rt_value));
15612
15613 return img::format("SWXS %s, %s(%s)", rd, rs, rt);
15614}
15615
15616
15617/*
15618 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15619 *
15620 * 3 2 1
15621 * 10987654321098765432109876543210
15622 * 001000 00010001101
15623 * rt -----
15624 * rs -----
15625 * rd -----
15626 */
15627std::string NMD::SYNC(uint64 instruction)
15628{
15629 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15630
15631 std::string stype = IMMEDIATE(copy(stype_value));
15632
15633 return img::format("SYNC %s", stype);
15634}
15635
15636
15637/*
15638 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15639 *
15640 * 3 2 1
15641 * 10987654321098765432109876543210
15642 * 001000 00010001101
15643 * rt -----
15644 * rs -----
15645 * rd -----
15646 */
15647std::string NMD::SYNCI(uint64 instruction)
15648{
89a955e8 15649 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15650 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15651
15652 std::string s = IMMEDIATE(copy(s_value));
15653 std::string rs = GPR(copy(rs_value));
15654
15655 return img::format("SYNCI %s(%s)", s, rs);
15656}
15657
15658
15659/*
15660 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15661 *
15662 * 3 2 1
15663 * 10987654321098765432109876543210
15664 * 001000 00010001101
15665 * rt -----
15666 * rs -----
15667 * rd -----
15668 */
15669std::string NMD::SYNCIE(uint64 instruction)
15670{
89a955e8 15671 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 15672 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 15673
15674 std::string s = IMMEDIATE(copy(s_value));
15675 std::string rs = GPR(copy(rs_value));
15676
15677 return img::format("SYNCIE %s(%s)", s, rs);
15678}
15679
15680
15681/*
15682 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15683 *
15684 * 3 2 1
15685 * 10987654321098765432109876543210
15686 * 001000 00010001101
15687 * rt -----
15688 * rs -----
15689 * rd -----
15690 */
15691std::string NMD::SYSCALL_16_(uint64 instruction)
15692{
15693 uint64 code_value = extract_code_1_0(instruction);
15694
15695 std::string code = IMMEDIATE(copy(code_value));
15696
15697 return img::format("SYSCALL %s", code);
15698}
15699
15700
15701/*
15702 * SYSCALL code - System Call. Cause a System Call Exception
15703 *
15704 * 3 2 1
15705 * 10987654321098765432109876543210
15706 * 00000000000010
15707 * code ------------------
15708 */
15709std::string NMD::SYSCALL_32_(uint64 instruction)
15710{
15711 uint64 code_value = extract_code_17_to_0(instruction);
15712
15713 std::string code = IMMEDIATE(copy(code_value));
15714
15715 return img::format("SYSCALL %s", code);
15716}
15717
15718
15719/*
15720 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15721 *
15722 * 3 2 1
15723 * 10987654321098765432109876543210
15724 * 001000 00010001101
15725 * rt -----
15726 * rs -----
15727 * rd -----
15728 */
15729std::string NMD::TEQ(uint64 instruction)
15730{
15731 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15732 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15733
15734 std::string rs = GPR(copy(rs_value));
15735 std::string rt = GPR(copy(rt_value));
15736
15737 return img::format("TEQ %s, %s", rs, rt);
15738}
15739
15740
15741/*
15742 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15743 *
15744 * 3 2 1
15745 * 10987654321098765432109876543210
15746 * 001000 00010001101
15747 * rt -----
15748 * rs -----
15749 * rd -----
15750 */
15751std::string NMD::TLBGINV(uint64 instruction)
15752{
15753 (void)instruction;
15754
15755 return "TLBGINV ";
15756}
15757
15758
15759/*
15760 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15761 *
15762 * 3 2 1
15763 * 10987654321098765432109876543210
15764 * 001000 00010001101
15765 * rt -----
15766 * rs -----
15767 * rd -----
15768 */
15769std::string NMD::TLBGINVF(uint64 instruction)
15770{
15771 (void)instruction;
15772
15773 return "TLBGINVF ";
15774}
15775
15776
15777/*
15778 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15779 *
15780 * 3 2 1
15781 * 10987654321098765432109876543210
15782 * 001000 00010001101
15783 * rt -----
15784 * rs -----
15785 * rd -----
15786 */
15787std::string NMD::TLBGP(uint64 instruction)
15788{
15789 (void)instruction;
15790
15791 return "TLBGP ";
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::TLBGR(uint64 instruction)
15806{
15807 (void)instruction;
15808
15809 return "TLBGR ";
15810}
15811
15812
15813/*
15814 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15815 *
15816 * 3 2 1
15817 * 10987654321098765432109876543210
15818 * 001000 00010001101
15819 * rt -----
15820 * rs -----
15821 * rd -----
15822 */
15823std::string NMD::TLBGWI(uint64 instruction)
15824{
15825 (void)instruction;
15826
15827 return "TLBGWI ";
15828}
15829
15830
15831/*
15832 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15833 *
15834 * 3 2 1
15835 * 10987654321098765432109876543210
15836 * 001000 00010001101
15837 * rt -----
15838 * rs -----
15839 * rd -----
15840 */
15841std::string NMD::TLBGWR(uint64 instruction)
15842{
15843 (void)instruction;
15844
15845 return "TLBGWR ";
15846}
15847
15848
15849/*
15850 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15851 *
15852 * 3 2 1
15853 * 10987654321098765432109876543210
15854 * 001000 00010001101
15855 * rt -----
15856 * rs -----
15857 * rd -----
15858 */
15859std::string NMD::TLBINV(uint64 instruction)
15860{
15861 (void)instruction;
15862
15863 return "TLBINV ";
15864}
15865
15866
15867/*
15868 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15869 *
15870 * 3 2 1
15871 * 10987654321098765432109876543210
15872 * 001000 00010001101
15873 * rt -----
15874 * rs -----
15875 * rd -----
15876 */
15877std::string NMD::TLBINVF(uint64 instruction)
15878{
15879 (void)instruction;
15880
15881 return "TLBINVF ";
15882}
15883
15884
15885/*
15886 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15887 *
15888 * 3 2 1
15889 * 10987654321098765432109876543210
15890 * 001000 00010001101
15891 * rt -----
15892 * rs -----
15893 * rd -----
15894 */
15895std::string NMD::TLBP(uint64 instruction)
15896{
15897 (void)instruction;
15898
15899 return "TLBP ";
15900}
15901
15902
15903/*
15904 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15905 *
15906 * 3 2 1
15907 * 10987654321098765432109876543210
15908 * 001000 00010001101
15909 * rt -----
15910 * rs -----
15911 * rd -----
15912 */
15913std::string NMD::TLBR(uint64 instruction)
15914{
15915 (void)instruction;
15916
15917 return "TLBR ";
15918}
15919
15920
15921/*
15922 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15923 *
15924 * 3 2 1
15925 * 10987654321098765432109876543210
15926 * 001000 00010001101
15927 * rt -----
15928 * rs -----
15929 * rd -----
15930 */
15931std::string NMD::TLBWI(uint64 instruction)
15932{
15933 (void)instruction;
15934
15935 return "TLBWI ";
15936}
15937
15938
15939/*
15940 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15941 *
15942 * 3 2 1
15943 * 10987654321098765432109876543210
15944 * 001000 00010001101
15945 * rt -----
15946 * rs -----
15947 * rd -----
15948 */
15949std::string NMD::TLBWR(uint64 instruction)
15950{
15951 (void)instruction;
15952
15953 return "TLBWR ";
15954}
15955
15956
15957/*
15958 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15959 *
15960 * 3 2 1
15961 * 10987654321098765432109876543210
15962 * 001000 00010001101
15963 * rt -----
15964 * rs -----
15965 * rd -----
15966 */
15967std::string NMD::TNE(uint64 instruction)
15968{
15969 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15970 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15971
15972 std::string rs = GPR(copy(rs_value));
15973 std::string rt = GPR(copy(rt_value));
15974
15975 return img::format("TNE %s, %s", rs, rt);
15976}
15977
15978
15979/*
15980 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15981 *
15982 * 3 2 1
15983 * 10987654321098765432109876543210
15984 * 001000 00010001101
15985 * rt -----
15986 * rs -----
15987 * rd -----
15988 */
15989std::string NMD::TRUNC_L_D(uint64 instruction)
15990{
17ce2f00 15991 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 15992 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 15993
15994 std::string ft = FPR(copy(ft_value));
15995 std::string fs = FPR(copy(fs_value));
15996
15997 return img::format("TRUNC.L.D %s, %s", ft, fs);
15998}
15999
16000
16001/*
16002 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16003 *
16004 * 3 2 1
16005 * 10987654321098765432109876543210
16006 * 001000 00010001101
16007 * rt -----
16008 * rs -----
16009 * rd -----
16010 */
16011std::string NMD::TRUNC_L_S(uint64 instruction)
16012{
17ce2f00 16013 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 16014 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 16015
16016 std::string ft = FPR(copy(ft_value));
16017 std::string fs = FPR(copy(fs_value));
16018
16019 return img::format("TRUNC.L.S %s, %s", ft, fs);
16020}
16021
16022
16023/*
16024 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16025 *
16026 * 3 2 1
16027 * 10987654321098765432109876543210
16028 * 001000 00010001101
16029 * rt -----
16030 * rs -----
16031 * rd -----
16032 */
16033std::string NMD::TRUNC_W_D(uint64 instruction)
16034{
17ce2f00 16035 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 16036 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 16037
16038 std::string ft = FPR(copy(ft_value));
16039 std::string fs = FPR(copy(fs_value));
16040
16041 return img::format("TRUNC.W.D %s, %s", ft, fs);
16042}
16043
16044
16045/*
16046 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16047 *
16048 * 3 2 1
16049 * 10987654321098765432109876543210
16050 * 001000 00010001101
16051 * rt -----
16052 * rs -----
16053 * rd -----
16054 */
16055std::string NMD::TRUNC_W_S(uint64 instruction)
16056{
17ce2f00 16057 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
52a96d22 16058 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
89a955e8
AM		 16059
16060 std::string ft = FPR(copy(ft_value));
16061 std::string fs = FPR(copy(fs_value));
16062
16063 return img::format("TRUNC.W.S %s, %s", ft, fs);
16064}
16065
16066
16067/*
16068 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16069 *
16070 * 3 2 1
16071 * 10987654321098765432109876543210
16072 * 001000 00010001101
16073 * rt -----
16074 * rs -----
16075 * rd -----
16076 */
16077std::string NMD::UALDM(uint64 instruction)
16078{
16079 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16080 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 16081 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16082 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 16083
16084 std::string rt = GPR(copy(rt_value));
16085 std::string s = IMMEDIATE(copy(s_value));
16086 std::string rs = GPR(copy(rs_value));
16087 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16088
16089 return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
16090}
16091
16092
16093/*
16094 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16095 *
16096 * 3 2 1
16097 * 10987654321098765432109876543210
16098 * 001000 00010001101
16099 * rt -----
16100 * rs -----
16101 * rd -----
16102 */
16103std::string NMD::UALH(uint64 instruction)
16104{
16105 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 16107 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 16108
16109 std::string rt = GPR(copy(rt_value));
16110 std::string s = IMMEDIATE(copy(s_value));
16111 std::string rs = GPR(copy(rs_value));
16112
16113 return img::format("UALH %s, %s(%s)", rt, s, rs);
16114}
16115
16116
16117/*
16118 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16119 *
16120 * 3 2 1
16121 * 10987654321098765432109876543210
16122 * 001000 00010001101
16123 * rt -----
16124 * rs -----
16125 * rd -----
16126 */
16127std::string NMD::UALWM(uint64 instruction)
16128{
16129 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16130 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 16131 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16132 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 16133
16134 std::string rt = GPR(copy(rt_value));
16135 std::string s = IMMEDIATE(copy(s_value));
16136 std::string rs = GPR(copy(rs_value));
16137 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16138
16139 return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
16140}
16141
16142
16143/*
16144 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16145 *
16146 * 3 2 1
16147 * 10987654321098765432109876543210
16148 * 001000 00010001101
16149 * rt -----
16150 * rs -----
16151 * rd -----
16152 */
16153std::string NMD::UASDM(uint64 instruction)
16154{
16155 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16156 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 16157 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16158 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 16159
16160 std::string rt = GPR(copy(rt_value));
16161 std::string s = IMMEDIATE(copy(s_value));
16162 std::string rs = GPR(copy(rs_value));
16163 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16164
16165 return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
16166}
16167
16168
16169/*
16170 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16171 *
16172 * 3 2 1
16173 * 10987654321098765432109876543210
16174 * 001000 00010001101
16175 * rt -----
16176 * rs -----
16177 * rd -----
16178 */
16179std::string NMD::UASH(uint64 instruction)
16180{
16181 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16182 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40 16183 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 16184
16185 std::string rt = GPR(copy(rt_value));
16186 std::string s = IMMEDIATE(copy(s_value));
16187 std::string rs = GPR(copy(rs_value));
16188
16189 return img::format("UASH %s, %s(%s)", rt, s, rs);
16190}
16191
16192
16193/*
16194 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16195 *
16196 * 3 2 1
16197 * 10987654321098765432109876543210
16198 * 001000 00010001101
16199 * rt -----
16200 * rs -----
16201 * rd -----
16202 */
16203std::string NMD::UASWM(uint64 instruction)
16204{
16205 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16206 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
75199b40
AM		 16207 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16208 uint64 count3_value = extract_count3_14_13_12(instruction);
89a955e8
AM		 16209
16210 std::string rt = GPR(copy(rt_value));
16211 std::string s = IMMEDIATE(copy(s_value));
16212 std::string rs = GPR(copy(rs_value));
16213 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16214
16215 return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
16216}
16217
16218
16219/*
16220 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16221 *
16222 * 3 2 1
16223 * 10987654321098765432109876543210
16224 * 001000 00010001101
16225 * rt -----
16226 * rs -----
16227 * rd -----
16228 */
16229std::string NMD::UDI(uint64 instruction)
16230{
16231 uint64 op_value = extract_op_25_to_3(instruction);
16232
16233 std::string op = IMMEDIATE(copy(op_value));
16234
16235 return img::format("UDI %s", op);
16236}
16237
16238
16239/*
16240 * WAIT code - Enter Wait State
16241 *
16242 * 3 2 1
16243 * 10987654321098765432109876543210
16244 * 001000 1100001101111111
16245 * code ----------
16246 */
16247std::string NMD::WAIT(uint64 instruction)
16248{
16249 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
16250
16251 std::string code = IMMEDIATE(copy(code_value));
16252
16253 return img::format("WAIT %s", code);
16254}
16255
16256
16257/*
16258 * WRDSP rt, mask - Write Fields to DSPControl Register from a GPR
16259 *
16260 * 3 2 1
16261 * 10987654321098765432109876543210
16262 * 001000 01011001111111
16263 * rt -----
16264 * mask -------
16265 */
16266std::string NMD::WRDSP(uint64 instruction)
16267{
16268 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16269 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
16270
16271 std::string rt = GPR(copy(rt_value));
16272 std::string mask = IMMEDIATE(copy(mask_value));
16273
16274 return img::format("WRDSP %s, %s", rt, mask);
16275}
16276
16277
16278/*
16279 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16280 *
16281 * 3 2 1
16282 * 10987654321098765432109876543210
16283 * 001000 00010001101
16284 * rt -----
16285 * rs -----
16286 * rd -----
16287 */
16288std::string NMD::WRPGPR(uint64 instruction)
16289{
16290 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16291 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16292
16293 std::string rt = GPR(copy(rt_value));
16294 std::string rs = GPR(copy(rs_value));
16295
16296 return img::format("WRPGPR %s, %s", rt, rs);
16297}
16298
16299
16300/*
16301 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16302 *
16303 * 3 2 1
16304 * 10987654321098765432109876543210
16305 * 001000 00010001101
16306 * rt -----
16307 * rs -----
16308 * rd -----
16309 */
16310std::string NMD::XOR_16_(uint64 instruction)
16311{
16312 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16313 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16314
988d6c89
AM		 16315 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
16316 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
89a955e8
AM		 16317
16318 return img::format("XOR %s, %s", rs3, rt3);
16319}
16320
16321
16322/*
16323 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16324 *
16325 * 3 2 1
16326 * 10987654321098765432109876543210
16327 * 001000 00010001101
16328 * rt -----
16329 * rs -----
16330 * rd -----
16331 */
16332std::string NMD::XOR_32_(uint64 instruction)
16333{
16334 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16335 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 16336 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
89a955e8
AM		 16337
16338 std::string rd = GPR(copy(rd_value));
16339 std::string rs = GPR(copy(rs_value));
16340 std::string rt = GPR(copy(rt_value));
16341
16342 return img::format("XOR %s, %s, %s", rd, rs, rt);
16343}
16344
16345
16346/*
16347 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16348 *
16349 * 3 2 1
16350 * 10987654321098765432109876543210
16351 * 001000 00010001101
16352 * rt -----
16353 * rs -----
16354 * rd -----
16355 */
16356std::string NMD::XORI(uint64 instruction)
16357{
16358 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
89a955e8 16359 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
86b5f803 16360 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
89a955e8
AM		 16361
16362 std::string rt = GPR(copy(rt_value));
16363 std::string rs = GPR(copy(rs_value));
16364 std::string u = IMMEDIATE(copy(u_value));
16365
16366 return img::format("XORI %s, %s, %s", rt, rs, u);
16367}
16368
16369
16370/*
16371 * YIELD rt, rs -
16372 *
16373 * 3 2 1
16374 * 10987654321098765432109876543210
16375 * 001000 00010001101
16376 * rt -----
16377 * rs -----
16378 */
16379std::string NMD::YIELD(uint64 instruction)
16380{
16381 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16382 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16383
16384 std::string rt = GPR(copy(rt_value));
16385 std::string rs = GPR(copy(rs_value));
16386
16387 return img::format("YIELD %s, %s", rt, rs);
16388}
16389
16390
16391
16392NMD::Pool NMD::P_SYSCALL[2] = {
16393 { instruction , 0 , 0 , 32,
16394 0xfffc0000, 0x00080000, &NMD::SYSCALL_32_ , 0,
16395 0x0 }, /* SYSCALL[32] */
16396 { instruction , 0 , 0 , 32,
16397 0xfffc0000, 0x000c0000, &NMD::HYPCALL , 0,
16398 CP0_ | VZ_ }, /* HYPCALL */
16399};
16400
16401
16402NMD::Pool NMD::P_RI[4] = {
16403 { instruction , 0 , 0 , 32,
16404 0xfff80000, 0x00000000, &NMD::SIGRIE , 0,
16405 0x0 }, /* SIGRIE */
16406 { pool , P_SYSCALL , 2 , 32,
16407 0xfff80000, 0x00080000, 0 , 0,
16408 0x0 }, /* P.SYSCALL */
16409 { instruction , 0 , 0 , 32,
16410 0xfff80000, 0x00100000, &NMD::BREAK_32_ , 0,
16411 0x0 }, /* BREAK[32] */
16412 { instruction , 0 , 0 , 32,
16413 0xfff80000, 0x00180000, &NMD::SDBBP_32_ , 0,
16414 EJTAG_ }, /* SDBBP[32] */
16415};
16416
16417
16418NMD::Pool NMD::P_ADDIU[2] = {
16419 { pool , P_RI , 4 , 32,
16420 0xffe00000, 0x00000000, 0 , 0,
16421 0x0 }, /* P.RI */
16422 { instruction , 0 , 0 , 32,
16423 0xfc000000, 0x00000000, &NMD::ADDIU_32_ , &NMD::ADDIU_32__cond ,
16424 0x0 }, /* ADDIU[32] */
16425};
16426
16427
16428NMD::Pool NMD::P_TRAP[2] = {
16429 { instruction , 0 , 0 , 32,
16430 0xfc0007ff, 0x20000000, &NMD::TEQ , 0,
16431 XMMS_ }, /* TEQ */
16432 { instruction , 0 , 0 , 32,
16433 0xfc0007ff, 0x20000400, &NMD::TNE , 0,
16434 XMMS_ }, /* TNE */
16435};
16436
16437
16438NMD::Pool NMD::P_CMOVE[2] = {
16439 { instruction , 0 , 0 , 32,
16440 0xfc0007ff, 0x20000210, &NMD::MOVZ , 0,
16441 0x0 }, /* MOVZ */
16442 { instruction , 0 , 0 , 32,
16443 0xfc0007ff, 0x20000610, &NMD::MOVN , 0,
16444 0x0 }, /* MOVN */
16445};
16446
16447
16448NMD::Pool NMD::P_D_MT_VPE[2] = {
16449 { instruction , 0 , 0 , 32,
16450 0xfc1f3fff, 0x20010ab0, &NMD::DMT , 0,
16451 MT_ }, /* DMT */
16452 { instruction , 0 , 0 , 32,
16453 0xfc1f3fff, 0x20000ab0, &NMD::DVPE , 0,
16454 MT_ }, /* DVPE */
16455};
16456
16457
16458NMD::Pool NMD::P_E_MT_VPE[2] = {
16459 { instruction , 0 , 0 , 32,
16460 0xfc1f3fff, 0x20010eb0, &NMD::EMT , 0,
16461 MT_ }, /* EMT */
16462 { instruction , 0 , 0 , 32,
16463 0xfc1f3fff, 0x20000eb0, &NMD::EVPE , 0,
16464 MT_ }, /* EVPE */
16465};
16466
16467
16468NMD::Pool NMD::_P_MT_VPE[2] = {
16469 { pool , P_D_MT_VPE , 2 , 32,
16470 0xfc003fff, 0x20000ab0, 0 , 0,
16471 0x0 }, /* P.D_MT_VPE */
16472 { pool , P_E_MT_VPE , 2 , 32,
16473 0xfc003fff, 0x20000eb0, 0 , 0,
16474 0x0 }, /* P.E_MT_VPE */
16475};
16476
16477
16478NMD::Pool NMD::P_MT_VPE[8] = {
16479 { reserved_block , 0 , 0 , 32,
16480 0xfc003bff, 0x200002b0, 0 , 0,
16481 0x0 }, /* P.MT_VPE~*(0) */
16482 { pool , _P_MT_VPE , 2 , 32,
16483 0xfc003bff, 0x20000ab0, 0 , 0,
16484 0x0 }, /* _P.MT_VPE */
16485 { reserved_block , 0 , 0 , 32,
16486 0xfc003bff, 0x200012b0, 0 , 0,
16487 0x0 }, /* P.MT_VPE~*(2) */
16488 { reserved_block , 0 , 0 , 32,
16489 0xfc003bff, 0x20001ab0, 0 , 0,
16490 0x0 }, /* P.MT_VPE~*(3) */
16491 { reserved_block , 0 , 0 , 32,
16492 0xfc003bff, 0x200022b0, 0 , 0,
16493 0x0 }, /* P.MT_VPE~*(4) */
16494 { reserved_block , 0 , 0 , 32,
16495 0xfc003bff, 0x20002ab0, 0 , 0,
16496 0x0 }, /* P.MT_VPE~*(5) */
16497 { reserved_block , 0 , 0 , 32,
16498 0xfc003bff, 0x200032b0, 0 , 0,
16499 0x0 }, /* P.MT_VPE~*(6) */
16500 { reserved_block , 0 , 0 , 32,
16501 0xfc003bff, 0x20003ab0, 0 , 0,
16502 0x0 }, /* P.MT_VPE~*(7) */
16503};
16504
16505
16506NMD::Pool NMD::P_DVP[2] = {
16507 { instruction , 0 , 0 , 32,
16508 0xfc00ffff, 0x20000390, &NMD::DVP , 0,
16509 0x0 }, /* DVP */
16510 { instruction , 0 , 0 , 32,
16511 0xfc00ffff, 0x20000790, &NMD::EVP , 0,
16512 0x0 }, /* EVP */
16513};
16514
16515
16516NMD::Pool NMD::P_SLTU[2] = {
16517 { pool , P_DVP , 2 , 32,
16518 0xfc00fbff, 0x20000390, 0 , 0,
16519 0x0 }, /* P.DVP */
16520 { instruction , 0 , 0 , 32,
16521 0xfc0003ff, 0x20000390, &NMD::SLTU , &NMD::SLTU_cond ,
16522 0x0 }, /* SLTU */
16523};
16524
16525
16526NMD::Pool NMD::_POOL32A0[128] = {
16527 { pool , P_TRAP , 2 , 32,
16528 0xfc0003ff, 0x20000000, 0 , 0,
16529 0x0 }, /* P.TRAP */
16530 { instruction , 0 , 0 , 32,
16531 0xfc0003ff, 0x20000008, &NMD::SEB , 0,
16532 XMMS_ }, /* SEB */
16533 { instruction , 0 , 0 , 32,
16534 0xfc0003ff, 0x20000010, &NMD::SLLV , 0,
16535 0x0 }, /* SLLV */
16536 { instruction , 0 , 0 , 32,
16537 0xfc0003ff, 0x20000018, &NMD::MUL_32_ , 0,
16538 0x0 }, /* MUL[32] */
16539 { reserved_block , 0 , 0 , 32,
16540 0xfc0003ff, 0x20000020, 0 , 0,
16541 0x0 }, /* _POOL32A0~*(4) */
16542 { reserved_block , 0 , 0 , 32,
16543 0xfc0003ff, 0x20000028, 0 , 0,
16544 0x0 }, /* _POOL32A0~*(5) */
16545 { instruction , 0 , 0 , 32,
16546 0xfc0003ff, 0x20000030, &NMD::MFC0 , 0,
16547 0x0 }, /* MFC0 */
16548 { instruction , 0 , 0 , 32,
16549 0xfc0003ff, 0x20000038, &NMD::MFHC0 , 0,
16550 CP0_ | MVH_ }, /* MFHC0 */
16551 { reserved_block , 0 , 0 , 32,
16552 0xfc0003ff, 0x20000040, 0 , 0,
16553 0x0 }, /* _POOL32A0~*(8) */
16554 { instruction , 0 , 0 , 32,
16555 0xfc0003ff, 0x20000048, &NMD::SEH , 0,
16556 0x0 }, /* SEH */
16557 { instruction , 0 , 0 , 32,
16558 0xfc0003ff, 0x20000050, &NMD::SRLV , 0,
16559 0x0 }, /* SRLV */
16560 { instruction , 0 , 0 , 32,
16561 0xfc0003ff, 0x20000058, &NMD::MUH , 0,
16562 0x0 }, /* MUH */
16563 { reserved_block , 0 , 0 , 32,
16564 0xfc0003ff, 0x20000060, 0 , 0,
16565 0x0 }, /* _POOL32A0~*(12) */
16566 { reserved_block , 0 , 0 , 32,
16567 0xfc0003ff, 0x20000068, 0 , 0,
16568 0x0 }, /* _POOL32A0~*(13) */
16569 { instruction , 0 , 0 , 32,
16570 0xfc0003ff, 0x20000070, &NMD::MTC0 , 0,
16571 CP0_ }, /* MTC0 */
16572 { instruction , 0 , 0 , 32,
16573 0xfc0003ff, 0x20000078, &NMD::MTHC0 , 0,
16574 CP0_ | MVH_ }, /* MTHC0 */
16575 { reserved_block , 0 , 0 , 32,
16576 0xfc0003ff, 0x20000080, 0 , 0,
16577 0x0 }, /* _POOL32A0~*(16) */
16578 { reserved_block , 0 , 0 , 32,
16579 0xfc0003ff, 0x20000088, 0 , 0,
16580 0x0 }, /* _POOL32A0~*(17) */
16581 { instruction , 0 , 0 , 32,
16582 0xfc0003ff, 0x20000090, &NMD::SRAV , 0,
16583 0x0 }, /* SRAV */
16584 { instruction , 0 , 0 , 32,
16585 0xfc0003ff, 0x20000098, &NMD::MULU , 0,
16586 0x0 }, /* MULU */
16587 { reserved_block , 0 , 0 , 32,
16588 0xfc0003ff, 0x200000a0, 0 , 0,
16589 0x0 }, /* _POOL32A0~*(20) */
16590 { reserved_block , 0 , 0 , 32,
16591 0xfc0003ff, 0x200000a8, 0 , 0,
16592 0x0 }, /* _POOL32A0~*(21) */
16593 { instruction , 0 , 0 , 32,
16594 0xfc0003ff, 0x200000b0, &NMD::MFGC0 , 0,
16595 CP0_ | VZ_ }, /* MFGC0 */
16596 { instruction , 0 , 0 , 32,
16597 0xfc0003ff, 0x200000b8, &NMD::MFHGC0 , 0,
16598 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16599 { reserved_block , 0 , 0 , 32,
16600 0xfc0003ff, 0x200000c0, 0 , 0,
16601 0x0 }, /* _POOL32A0~*(24) */
16602 { reserved_block , 0 , 0 , 32,
16603 0xfc0003ff, 0x200000c8, 0 , 0,
16604 0x0 }, /* _POOL32A0~*(25) */
16605 { instruction , 0 , 0 , 32,
16606 0xfc0003ff, 0x200000d0, &NMD::ROTRV , 0,
16607 0x0 }, /* ROTRV */
16608 { instruction , 0 , 0 , 32,
16609 0xfc0003ff, 0x200000d8, &NMD::MUHU , 0,
16610 0x0 }, /* MUHU */
16611 { reserved_block , 0 , 0 , 32,
16612 0xfc0003ff, 0x200000e0, 0 , 0,
16613 0x0 }, /* _POOL32A0~*(28) */
16614 { reserved_block , 0 , 0 , 32,
16615 0xfc0003ff, 0x200000e8, 0 , 0,
16616 0x0 }, /* _POOL32A0~*(29) */
16617 { instruction , 0 , 0 , 32,
16618 0xfc0003ff, 0x200000f0, &NMD::MTGC0 , 0,
16619 CP0_ | VZ_ }, /* MTGC0 */
16620 { instruction , 0 , 0 , 32,
16621 0xfc0003ff, 0x200000f8, &NMD::MTHGC0 , 0,
16622 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16623 { reserved_block , 0 , 0 , 32,
16624 0xfc0003ff, 0x20000100, 0 , 0,
16625 0x0 }, /* _POOL32A0~*(32) */
16626 { reserved_block , 0 , 0 , 32,
16627 0xfc0003ff, 0x20000108, 0 , 0,
16628 0x0 }, /* _POOL32A0~*(33) */
16629 { instruction , 0 , 0 , 32,
16630 0xfc0003ff, 0x20000110, &NMD::ADD , 0,
16631 XMMS_ }, /* ADD */
16632 { instruction , 0 , 0 , 32,
16633 0xfc0003ff, 0x20000118, &NMD::DIV , 0,
16634 0x0 }, /* DIV */
16635 { reserved_block , 0 , 0 , 32,
16636 0xfc0003ff, 0x20000120, 0 , 0,
16637 0x0 }, /* _POOL32A0~*(36) */
16638 { reserved_block , 0 , 0 , 32,
16639 0xfc0003ff, 0x20000128, 0 , 0,
16640 0x0 }, /* _POOL32A0~*(37) */
16641 { instruction , 0 , 0 , 32,
16642 0xfc0003ff, 0x20000130, &NMD::DMFC0 , 0,
16643 CP0_ | MIPS64_ }, /* DMFC0 */
16644 { reserved_block , 0 , 0 , 32,
16645 0xfc0003ff, 0x20000138, 0 , 0,
16646 0x0 }, /* _POOL32A0~*(39) */
16647 { reserved_block , 0 , 0 , 32,
16648 0xfc0003ff, 0x20000140, 0 , 0,
16649 0x0 }, /* _POOL32A0~*(40) */
16650 { reserved_block , 0 , 0 , 32,
16651 0xfc0003ff, 0x20000148, 0 , 0,
16652 0x0 }, /* _POOL32A0~*(41) */
16653 { instruction , 0 , 0 , 32,
16654 0xfc0003ff, 0x20000150, &NMD::ADDU_32_ , 0,
16655 0x0 }, /* ADDU[32] */
16656 { instruction , 0 , 0 , 32,
16657 0xfc0003ff, 0x20000158, &NMD::MOD , 0,
16658 0x0 }, /* MOD */
16659 { reserved_block , 0 , 0 , 32,
16660 0xfc0003ff, 0x20000160, 0 , 0,
16661 0x0 }, /* _POOL32A0~*(44) */
16662 { reserved_block , 0 , 0 , 32,
16663 0xfc0003ff, 0x20000168, 0 , 0,
16664 0x0 }, /* _POOL32A0~*(45) */
16665 { instruction , 0 , 0 , 32,
16666 0xfc0003ff, 0x20000170, &NMD::DMTC0 , 0,
16667 CP0_ | MIPS64_ }, /* DMTC0 */
16668 { reserved_block , 0 , 0 , 32,
16669 0xfc0003ff, 0x20000178, 0 , 0,
16670 0x0 }, /* _POOL32A0~*(47) */
16671 { reserved_block , 0 , 0 , 32,
16672 0xfc0003ff, 0x20000180, 0 , 0,
16673 0x0 }, /* _POOL32A0~*(48) */
16674 { reserved_block , 0 , 0 , 32,
16675 0xfc0003ff, 0x20000188, 0 , 0,
16676 0x0 }, /* _POOL32A0~*(49) */
16677 { instruction , 0 , 0 , 32,
16678 0xfc0003ff, 0x20000190, &NMD::SUB , 0,
16679 XMMS_ }, /* SUB */
16680 { instruction , 0 , 0 , 32,
16681 0xfc0003ff, 0x20000198, &NMD::DIVU , 0,
16682 0x0 }, /* DIVU */
16683 { reserved_block , 0 , 0 , 32,
16684 0xfc0003ff, 0x200001a0, 0 , 0,
16685 0x0 }, /* _POOL32A0~*(52) */
16686 { reserved_block , 0 , 0 , 32,
16687 0xfc0003ff, 0x200001a8, 0 , 0,
16688 0x0 }, /* _POOL32A0~*(53) */
16689 { instruction , 0 , 0 , 32,
16690 0xfc0003ff, 0x200001b0, &NMD::DMFGC0 , 0,
16691 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16692 { reserved_block , 0 , 0 , 32,
16693 0xfc0003ff, 0x200001b8, 0 , 0,
16694 0x0 }, /* _POOL32A0~*(55) */
16695 { instruction , 0 , 0 , 32,
16696 0xfc0003ff, 0x200001c0, &NMD::RDHWR , 0,
16697 XMMS_ }, /* RDHWR */
16698 { reserved_block , 0 , 0 , 32,
16699 0xfc0003ff, 0x200001c8, 0 , 0,
16700 0x0 }, /* _POOL32A0~*(57) */
16701 { instruction , 0 , 0 , 32,
16702 0xfc0003ff, 0x200001d0, &NMD::SUBU_32_ , 0,
16703 0x0 }, /* SUBU[32] */
16704 { instruction , 0 , 0 , 32,
16705 0xfc0003ff, 0x200001d8, &NMD::MODU , 0,
16706 0x0 }, /* MODU */
16707 { reserved_block , 0 , 0 , 32,
16708 0xfc0003ff, 0x200001e0, 0 , 0,
16709 0x0 }, /* _POOL32A0~*(60) */
16710 { reserved_block , 0 , 0 , 32,
16711 0xfc0003ff, 0x200001e8, 0 , 0,
16712 0x0 }, /* _POOL32A0~*(61) */
16713 { instruction , 0 , 0 , 32,
16714 0xfc0003ff, 0x200001f0, &NMD::DMTGC0 , 0,
16715 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16716 { reserved_block , 0 , 0 , 32,
16717 0xfc0003ff, 0x200001f8, 0 , 0,
16718 0x0 }, /* _POOL32A0~*(63) */
16719 { reserved_block , 0 , 0 , 32,
16720 0xfc0003ff, 0x20000200, 0 , 0,
16721 0x0 }, /* _POOL32A0~*(64) */
16722 { reserved_block , 0 , 0 , 32,
16723 0xfc0003ff, 0x20000208, 0 , 0,
16724 0x0 }, /* _POOL32A0~*(65) */
16725 { pool , P_CMOVE , 2 , 32,
16726 0xfc0003ff, 0x20000210, 0 , 0,
16727 0x0 }, /* P.CMOVE */
16728 { reserved_block , 0 , 0 , 32,
16729 0xfc0003ff, 0x20000218, 0 , 0,
16730 0x0 }, /* _POOL32A0~*(67) */
16731 { reserved_block , 0 , 0 , 32,
16732 0xfc0003ff, 0x20000220, 0 , 0,
16733 0x0 }, /* _POOL32A0~*(68) */
16734 { instruction , 0 , 0 , 32,
16735 0xfc0003ff, 0x20000228, &NMD::FORK , 0,
16736 MT_ }, /* FORK */
16737 { instruction , 0 , 0 , 32,
16738 0xfc0003ff, 0x20000230, &NMD::MFTR , 0,
16739 MT_ }, /* MFTR */
16740 { instruction , 0 , 0 , 32,
16741 0xfc0003ff, 0x20000238, &NMD::MFHTR , 0,
16742 MT_ }, /* MFHTR */
16743 { reserved_block , 0 , 0 , 32,
16744 0xfc0003ff, 0x20000240, 0 , 0,
16745 0x0 }, /* _POOL32A0~*(72) */
16746 { reserved_block , 0 , 0 , 32,
16747 0xfc0003ff, 0x20000248, 0 , 0,
16748 0x0 }, /* _POOL32A0~*(73) */
16749 { instruction , 0 , 0 , 32,
16750 0xfc0003ff, 0x20000250, &NMD::AND_32_ , 0,
16751 0x0 }, /* AND[32] */
16752 { reserved_block , 0 , 0 , 32,
16753 0xfc0003ff, 0x20000258, 0 , 0,
16754 0x0 }, /* _POOL32A0~*(75) */
16755 { reserved_block , 0 , 0 , 32,
16756 0xfc0003ff, 0x20000260, 0 , 0,
16757 0x0 }, /* _POOL32A0~*(76) */
16758 { instruction , 0 , 0 , 32,
16759 0xfc0003ff, 0x20000268, &NMD::YIELD , 0,
16760 MT_ }, /* YIELD */
16761 { instruction , 0 , 0 , 32,
16762 0xfc0003ff, 0x20000270, &NMD::MTTR , 0,
16763 MT_ }, /* MTTR */
16764 { instruction , 0 , 0 , 32,
16765 0xfc0003ff, 0x20000278, &NMD::MTHTR , 0,
16766 MT_ }, /* MTHTR */
16767 { reserved_block , 0 , 0 , 32,
16768 0xfc0003ff, 0x20000280, 0 , 0,
16769 0x0 }, /* _POOL32A0~*(80) */
16770 { reserved_block , 0 , 0 , 32,
16771 0xfc0003ff, 0x20000288, 0 , 0,
16772 0x0 }, /* _POOL32A0~*(81) */
16773 { instruction , 0 , 0 , 32,
16774 0xfc0003ff, 0x20000290, &NMD::OR_32_ , 0,
16775 0x0 }, /* OR[32] */
16776 { reserved_block , 0 , 0 , 32,
16777 0xfc0003ff, 0x20000298, 0 , 0,
16778 0x0 }, /* _POOL32A0~*(83) */
16779 { reserved_block , 0 , 0 , 32,
16780 0xfc0003ff, 0x200002a0, 0 , 0,
16781 0x0 }, /* _POOL32A0~*(84) */
16782 { reserved_block , 0 , 0 , 32,
16783 0xfc0003ff, 0x200002a8, 0 , 0,
16784 0x0 }, /* _POOL32A0~*(85) */
16785 { pool , P_MT_VPE , 8 , 32,
16786 0xfc0003ff, 0x200002b0, 0 , 0,
16787 0x0 }, /* P.MT_VPE */
16788 { reserved_block , 0 , 0 , 32,
16789 0xfc0003ff, 0x200002b8, 0 , 0,
16790 0x0 }, /* _POOL32A0~*(87) */
16791 { reserved_block , 0 , 0 , 32,
16792 0xfc0003ff, 0x200002c0, 0 , 0,
16793 0x0 }, /* _POOL32A0~*(88) */
16794 { reserved_block , 0 , 0 , 32,
16795 0xfc0003ff, 0x200002c8, 0 , 0,
16796 0x0 }, /* _POOL32A0~*(89) */
16797 { instruction , 0 , 0 , 32,
16798 0xfc0003ff, 0x200002d0, &NMD::NOR , 0,
16799 0x0 }, /* NOR */
16800 { reserved_block , 0 , 0 , 32,
16801 0xfc0003ff, 0x200002d8, 0 , 0,
16802 0x0 }, /* _POOL32A0~*(91) */
16803 { reserved_block , 0 , 0 , 32,
16804 0xfc0003ff, 0x200002e0, 0 , 0,
16805 0x0 }, /* _POOL32A0~*(92) */
16806 { reserved_block , 0 , 0 , 32,
16807 0xfc0003ff, 0x200002e8, 0 , 0,
16808 0x0 }, /* _POOL32A0~*(93) */
16809 { reserved_block , 0 , 0 , 32,
16810 0xfc0003ff, 0x200002f0, 0 , 0,
16811 0x0 }, /* _POOL32A0~*(94) */
16812 { reserved_block , 0 , 0 , 32,
16813 0xfc0003ff, 0x200002f8, 0 , 0,
16814 0x0 }, /* _POOL32A0~*(95) */
16815 { reserved_block , 0 , 0 , 32,
16816 0xfc0003ff, 0x20000300, 0 , 0,
16817 0x0 }, /* _POOL32A0~*(96) */
16818 { reserved_block , 0 , 0 , 32,
16819 0xfc0003ff, 0x20000308, 0 , 0,
16820 0x0 }, /* _POOL32A0~*(97) */
16821 { instruction , 0 , 0 , 32,
16822 0xfc0003ff, 0x20000310, &NMD::XOR_32_ , 0,
16823 0x0 }, /* XOR[32] */
16824 { reserved_block , 0 , 0 , 32,
16825 0xfc0003ff, 0x20000318, 0 , 0,
16826 0x0 }, /* _POOL32A0~*(99) */
16827 { reserved_block , 0 , 0 , 32,
16828 0xfc0003ff, 0x20000320, 0 , 0,
16829 0x0 }, /* _POOL32A0~*(100) */
16830 { reserved_block , 0 , 0 , 32,
16831 0xfc0003ff, 0x20000328, 0 , 0,
16832 0x0 }, /* _POOL32A0~*(101) */
16833 { reserved_block , 0 , 0 , 32,
16834 0xfc0003ff, 0x20000330, 0 , 0,
16835 0x0 }, /* _POOL32A0~*(102) */
16836 { reserved_block , 0 , 0 , 32,
16837 0xfc0003ff, 0x20000338, 0 , 0,
16838 0x0 }, /* _POOL32A0~*(103) */
16839 { reserved_block , 0 , 0 , 32,
16840 0xfc0003ff, 0x20000340, 0 , 0,
16841 0x0 }, /* _POOL32A0~*(104) */
16842 { reserved_block , 0 , 0 , 32,
16843 0xfc0003ff, 0x20000348, 0 , 0,
16844 0x0 }, /* _POOL32A0~*(105) */
16845 { instruction , 0 , 0 , 32,
16846 0xfc0003ff, 0x20000350, &NMD::SLT , 0,
16847 0x0 }, /* SLT */
16848 { reserved_block , 0 , 0 , 32,
16849 0xfc0003ff, 0x20000358, 0 , 0,
16850 0x0 }, /* _POOL32A0~*(107) */
16851 { reserved_block , 0 , 0 , 32,
16852 0xfc0003ff, 0x20000360, 0 , 0,
16853 0x0 }, /* _POOL32A0~*(108) */
16854 { reserved_block , 0 , 0 , 32,
16855 0xfc0003ff, 0x20000368, 0 , 0,
16856 0x0 }, /* _POOL32A0~*(109) */
16857 { reserved_block , 0 , 0 , 32,
16858 0xfc0003ff, 0x20000370, 0 , 0,
16859 0x0 }, /* _POOL32A0~*(110) */
16860 { reserved_block , 0 , 0 , 32,
16861 0xfc0003ff, 0x20000378, 0 , 0,
16862 0x0 }, /* _POOL32A0~*(111) */
16863 { reserved_block , 0 , 0 , 32,
16864 0xfc0003ff, 0x20000380, 0 , 0,
16865 0x0 }, /* _POOL32A0~*(112) */
16866 { reserved_block , 0 , 0 , 32,
16867 0xfc0003ff, 0x20000388, 0 , 0,
16868 0x0 }, /* _POOL32A0~*(113) */
16869 { pool , P_SLTU , 2 , 32,
16870 0xfc0003ff, 0x20000390, 0 , 0,
16871 0x0 }, /* P.SLTU */
16872 { reserved_block , 0 , 0 , 32,
16873 0xfc0003ff, 0x20000398, 0 , 0,
16874 0x0 }, /* _POOL32A0~*(115) */
16875 { reserved_block , 0 , 0 , 32,
16876 0xfc0003ff, 0x200003a0, 0 , 0,
16877 0x0 }, /* _POOL32A0~*(116) */
16878 { reserved_block , 0 , 0 , 32,
16879 0xfc0003ff, 0x200003a8, 0 , 0,
16880 0x0 }, /* _POOL32A0~*(117) */
16881 { reserved_block , 0 , 0 , 32,
16882 0xfc0003ff, 0x200003b0, 0 , 0,
16883 0x0 }, /* _POOL32A0~*(118) */
16884 { reserved_block , 0 , 0 , 32,
16885 0xfc0003ff, 0x200003b8, 0 , 0,
16886 0x0 }, /* _POOL32A0~*(119) */
16887 { reserved_block , 0 , 0 , 32,
16888 0xfc0003ff, 0x200003c0, 0 , 0,
16889 0x0 }, /* _POOL32A0~*(120) */
16890 { reserved_block , 0 , 0 , 32,
16891 0xfc0003ff, 0x200003c8, 0 , 0,
16892 0x0 }, /* _POOL32A0~*(121) */
16893 { instruction , 0 , 0 , 32,
16894 0xfc0003ff, 0x200003d0, &NMD::SOV , 0,
16895 0x0 }, /* SOV */
16896 { reserved_block , 0 , 0 , 32,
16897 0xfc0003ff, 0x200003d8, 0 , 0,
16898 0x0 }, /* _POOL32A0~*(123) */
16899 { reserved_block , 0 , 0 , 32,
16900 0xfc0003ff, 0x200003e0, 0 , 0,
16901 0x0 }, /* _POOL32A0~*(124) */
16902 { reserved_block , 0 , 0 , 32,
16903 0xfc0003ff, 0x200003e8, 0 , 0,
16904 0x0 }, /* _POOL32A0~*(125) */
16905 { reserved_block , 0 , 0 , 32,
16906 0xfc0003ff, 0x200003f0, 0 , 0,
16907 0x0 }, /* _POOL32A0~*(126) */
16908 { reserved_block , 0 , 0 , 32,
16909 0xfc0003ff, 0x200003f8, 0 , 0,
16910 0x0 }, /* _POOL32A0~*(127) */
16911};
16912
16913
16914NMD::Pool NMD::ADDQ__S__PH[2] = {
16915 { instruction , 0 , 0 , 32,
16916 0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH , 0,
16917 DSP_ }, /* ADDQ.PH */
16918 { instruction , 0 , 0 , 32,
16919 0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH , 0,
16920 DSP_ }, /* ADDQ_S.PH */
16921};
16922
16923
16924NMD::Pool NMD::MUL__S__PH[2] = {
16925 { instruction , 0 , 0 , 32,
16926 0xfc0007ff, 0x2000002d, &NMD::MUL_PH , 0,
16927 DSP_ }, /* MUL.PH */
16928 { instruction , 0 , 0 , 32,
16929 0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH , 0,
16930 DSP_ }, /* MUL_S.PH */
16931};
16932
16933
16934NMD::Pool NMD::ADDQH__R__PH[2] = {
16935 { instruction , 0 , 0 , 32,
16936 0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH , 0,
16937 DSP_ }, /* ADDQH.PH */
16938 { instruction , 0 , 0 , 32,
16939 0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH , 0,
16940 DSP_ }, /* ADDQH_R.PH */
16941};
16942
16943
16944NMD::Pool NMD::ADDQH__R__W[2] = {
16945 { instruction , 0 , 0 , 32,
16946 0xfc0007ff, 0x2000008d, &NMD::ADDQH_W , 0,
16947 DSP_ }, /* ADDQH.W */
16948 { instruction , 0 , 0 , 32,
16949 0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W , 0,
16950 DSP_ }, /* ADDQH_R.W */
16951};
16952
16953
16954NMD::Pool NMD::ADDU__S__QB[2] = {
16955 { instruction , 0 , 0 , 32,
16956 0xfc0007ff, 0x200000cd, &NMD::ADDU_QB , 0,
16957 DSP_ }, /* ADDU.QB */
16958 { instruction , 0 , 0 , 32,
16959 0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB , 0,
16960 DSP_ }, /* ADDU_S.QB */
16961};
16962
16963
16964NMD::Pool NMD::ADDU__S__PH[2] = {
16965 { instruction , 0 , 0 , 32,
16966 0xfc0007ff, 0x2000010d, &NMD::ADDU_PH , 0,
16967 DSP_ }, /* ADDU.PH */
16968 { instruction , 0 , 0 , 32,
16969 0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH , 0,
16970 DSP_ }, /* ADDU_S.PH */
16971};
16972
16973
16974NMD::Pool NMD::ADDUH__R__QB[2] = {
16975 { instruction , 0 , 0 , 32,
16976 0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB , 0,
16977 DSP_ }, /* ADDUH.QB */
16978 { instruction , 0 , 0 , 32,
16979 0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB , 0,
16980 DSP_ }, /* ADDUH_R.QB */
16981};
16982
16983
16984NMD::Pool NMD::SHRAV__R__PH[2] = {
16985 { instruction , 0 , 0 , 32,
16986 0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH , 0,
16987 DSP_ }, /* SHRAV.PH */
16988 { instruction , 0 , 0 , 32,
16989 0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH , 0,
16990 DSP_ }, /* SHRAV_R.PH */
16991};
16992
16993
16994NMD::Pool NMD::SHRAV__R__QB[2] = {
16995 { instruction , 0 , 0 , 32,
16996 0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB , 0,
16997 DSP_ }, /* SHRAV.QB */
16998 { instruction , 0 , 0 , 32,
16999 0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB , 0,
17000 DSP_ }, /* SHRAV_R.QB */
17001};
17002
17003
17004NMD::Pool NMD::SUBQ__S__PH[2] = {
17005 { instruction , 0 , 0 , 32,
17006 0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH , 0,
17007 DSP_ }, /* SUBQ.PH */
17008 { instruction , 0 , 0 , 32,
17009 0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH , 0,
17010 DSP_ }, /* SUBQ_S.PH */
17011};
17012
17013
17014NMD::Pool NMD::SUBQH__R__PH[2] = {
17015 { instruction , 0 , 0 , 32,
17016 0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH , 0,
17017 DSP_ }, /* SUBQH.PH */
17018 { instruction , 0 , 0 , 32,
17019 0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH , 0,
17020 DSP_ }, /* SUBQH_R.PH */
17021};
17022
17023
17024NMD::Pool NMD::SUBQH__R__W[2] = {
17025 { instruction , 0 , 0 , 32,
17026 0xfc0007ff, 0x2000028d, &NMD::SUBQH_W , 0,
17027 DSP_ }, /* SUBQH.W */
17028 { instruction , 0 , 0 , 32,
17029 0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W , 0,
17030 DSP_ }, /* SUBQH_R.W */
17031};
17032
17033
17034NMD::Pool NMD::SUBU__S__QB[2] = {
17035 { instruction , 0 , 0 , 32,
17036 0xfc0007ff, 0x200002cd, &NMD::SUBU_QB , 0,
17037 DSP_ }, /* SUBU.QB */
17038 { instruction , 0 , 0 , 32,
17039 0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB , 0,
17040 DSP_ }, /* SUBU_S.QB */
17041};
17042
17043
17044NMD::Pool NMD::SUBU__S__PH[2] = {
17045 { instruction , 0 , 0 , 32,
17046 0xfc0007ff, 0x2000030d, &NMD::SUBU_PH , 0,
17047 DSP_ }, /* SUBU.PH */
17048 { instruction , 0 , 0 , 32,
17049 0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH , 0,
17050 DSP_ }, /* SUBU_S.PH */
17051};
17052
17053
17054NMD::Pool NMD::SHRA__R__PH[2] = {
17055 { instruction , 0 , 0 , 32,
17056 0xfc0007ff, 0x20000335, &NMD::SHRA_PH , 0,
17057 DSP_ }, /* SHRA.PH */
17058 { instruction , 0 , 0 , 32,
17059 0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH , 0,
17060 DSP_ }, /* SHRA_R.PH */
17061};
17062
17063
17064NMD::Pool NMD::SUBUH__R__QB[2] = {
17065 { instruction , 0 , 0 , 32,
17066 0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB , 0,
17067 DSP_ }, /* SUBUH.QB */
17068 { instruction , 0 , 0 , 32,
17069 0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB , 0,
17070 DSP_ }, /* SUBUH_R.QB */
17071};
17072
17073
17074NMD::Pool NMD::SHLLV__S__PH[2] = {
17075 { instruction , 0 , 0 , 32,
17076 0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH , 0,
17077 DSP_ }, /* SHLLV.PH */
17078 { instruction , 0 , 0 , 32,
17079 0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH , 0,
17080 DSP_ }, /* SHLLV_S.PH */
17081};
17082
17083
17084NMD::Pool NMD::SHLL__S__PH[4] = {
17085 { instruction , 0 , 0 , 32,
17086 0xfc000fff, 0x200003b5, &NMD::SHLL_PH , 0,
17087 DSP_ }, /* SHLL.PH */
17088 { reserved_block , 0 , 0 , 32,
17089 0xfc000fff, 0x200007b5, 0 , 0,
17090 0x0 }, /* SHLL[_S].PH~*(1) */
17091 { instruction , 0 , 0 , 32,
17092 0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH , 0,
17093 DSP_ }, /* SHLL_S.PH */
17094 { reserved_block , 0 , 0 , 32,
17095 0xfc000fff, 0x20000fb5, 0 , 0,
17096 0x0 }, /* SHLL[_S].PH~*(3) */
17097};
17098
17099
17100NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
17101 { instruction , 0 , 0 , 32,
17102 0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W , 0,
17103 DSP_ }, /* PRECR_SRA.PH.W */
17104 { instruction , 0 , 0 , 32,
17105 0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
17106 DSP_ }, /* PRECR_SRA_R.PH.W */
17107};
17108
17109
17110NMD::Pool NMD::_POOL32A5[128] = {
17111 { instruction , 0 , 0 , 32,
17112 0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH , 0,
17113 DSP_ }, /* CMP.EQ.PH */
17114 { pool , ADDQ__S__PH , 2 , 32,
17115 0xfc0003ff, 0x2000000d, 0 , 0,
17116 0x0 }, /* ADDQ[_S].PH */
17117 { reserved_block , 0 , 0 , 32,
17118 0xfc0003ff, 0x20000015, 0 , 0,
17119 0x0 }, /* _POOL32A5~*(2) */
17120 { instruction , 0 , 0 , 32,
17121 0xfc0003ff, 0x2000001d, &NMD::SHILO , 0,
17122 DSP_ }, /* SHILO */
17123 { instruction , 0 , 0 , 32,
17124 0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL , 0,
17125 DSP_ }, /* MULEQ_S.W.PHL */
17126 { pool , MUL__S__PH , 2 , 32,
17127 0xfc0003ff, 0x2000002d, 0 , 0,
17128 0x0 }, /* MUL[_S].PH */
17129 { reserved_block , 0 , 0 , 32,
17130 0xfc0003ff, 0x20000035, 0 , 0,
17131 0x0 }, /* _POOL32A5~*(6) */
17132 { instruction , 0 , 0 , 32,
17133 0xfc0003ff, 0x2000003d, &NMD::REPL_PH , 0,
17134 DSP_ }, /* REPL.PH */
17135 { instruction , 0 , 0 , 32,
17136 0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH , 0,
17137 DSP_ }, /* CMP.LT.PH */
17138 { pool , ADDQH__R__PH , 2 , 32,
17139 0xfc0003ff, 0x2000004d, 0 , 0,
17140 0x0 }, /* ADDQH[_R].PH */
17141 { reserved_block , 0 , 0 , 32,
17142 0xfc0003ff, 0x20000055, 0 , 0,
17143 0x0 }, /* _POOL32A5~*(10) */
17144 { reserved_block , 0 , 0 , 32,
17145 0xfc0003ff, 0x2000005d, 0 , 0,
17146 0x0 }, /* _POOL32A5~*(11) */
17147 { instruction , 0 , 0 , 32,
17148 0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR , 0,
17149 DSP_ }, /* MULEQ_S.W.PHR */
17150 { instruction , 0 , 0 , 32,
17151 0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH , 0,
17152 DSP_ }, /* PRECR.QB.PH */
17153 { reserved_block , 0 , 0 , 32,
17154 0xfc0003ff, 0x20000075, 0 , 0,
17155 0x0 }, /* _POOL32A5~*(14) */
17156 { reserved_block , 0 , 0 , 32,
17157 0xfc0003ff, 0x2000007d, 0 , 0,
17158 0x0 }, /* _POOL32A5~*(15) */
17159 { instruction , 0 , 0 , 32,
17160 0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH , 0,
17161 DSP_ }, /* CMP.LE.PH */
17162 { pool , ADDQH__R__W , 2 , 32,
17163 0xfc0003ff, 0x2000008d, 0 , 0,
17164 0x0 }, /* ADDQH[_R].W */
17165 { instruction , 0 , 0 , 32,
17166 0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL , 0,
17167 DSP_ }, /* MULEU_S.PH.QBL */
17168 { reserved_block , 0 , 0 , 32,
17169 0xfc0003ff, 0x2000009d, 0 , 0,
17170 0x0 }, /* _POOL32A5~*(19) */
17171 { reserved_block , 0 , 0 , 32,
17172 0xfc0003ff, 0x200000a5, 0 , 0,
17173 0x0 }, /* _POOL32A5~*(20) */
17174 { instruction , 0 , 0 , 32,
17175 0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH , 0,
17176 DSP_ }, /* PRECRQ.QB.PH */
17177 { reserved_block , 0 , 0 , 32,
17178 0xfc0003ff, 0x200000b5, 0 , 0,
17179 0x0 }, /* _POOL32A5~*(22) */
17180 { reserved_block , 0 , 0 , 32,
17181 0xfc0003ff, 0x200000bd, 0 , 0,
17182 0x0 }, /* _POOL32A5~*(23) */
17183 { instruction , 0 , 0 , 32,
17184 0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB , 0,
17185 DSP_ }, /* CMPGU.EQ.QB */
17186 { pool , ADDU__S__QB , 2 , 32,
17187 0xfc0003ff, 0x200000cd, 0 , 0,
17188 0x0 }, /* ADDU[_S].QB */
17189 { instruction , 0 , 0 , 32,
17190 0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR , 0,
17191 DSP_ }, /* MULEU_S.PH.QBR */
17192 { reserved_block , 0 , 0 , 32,
17193 0xfc0003ff, 0x200000dd, 0 , 0,
17194 0x0 }, /* _POOL32A5~*(27) */
17195 { reserved_block , 0 , 0 , 32,
17196 0xfc0003ff, 0x200000e5, 0 , 0,
17197 0x0 }, /* _POOL32A5~*(28) */
17198 { instruction , 0 , 0 , 32,
17199 0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W , 0,
17200 DSP_ }, /* PRECRQ.PH.W */
17201 { reserved_block , 0 , 0 , 32,
17202 0xfc0003ff, 0x200000f5, 0 , 0,
17203 0x0 }, /* _POOL32A5~*(30) */
17204 { reserved_block , 0 , 0 , 32,
17205 0xfc0003ff, 0x200000fd, 0 , 0,
17206 0x0 }, /* _POOL32A5~*(31) */
17207 { instruction , 0 , 0 , 32,
17208 0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB , 0,
17209 DSP_ }, /* CMPGU.LT.QB */
17210 { pool , ADDU__S__PH , 2 , 32,
17211 0xfc0003ff, 0x2000010d, 0 , 0,
17212 0x0 }, /* ADDU[_S].PH */
17213 { instruction , 0 , 0 , 32,
17214 0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH , 0,
17215 DSP_ }, /* MULQ_RS.PH */
17216 { reserved_block , 0 , 0 , 32,
17217 0xfc0003ff, 0x2000011d, 0 , 0,
17218 0x0 }, /* _POOL32A5~*(35) */
17219 { reserved_block , 0 , 0 , 32,
17220 0xfc0003ff, 0x20000125, 0 , 0,
17221 0x0 }, /* _POOL32A5~*(36) */
17222 { instruction , 0 , 0 , 32,
17223 0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W , 0,
17224 DSP_ }, /* PRECRQ_RS.PH.W */
17225 { reserved_block , 0 , 0 , 32,
17226 0xfc0003ff, 0x20000135, 0 , 0,
17227 0x0 }, /* _POOL32A5~*(38) */
17228 { reserved_block , 0 , 0 , 32,
17229 0xfc0003ff, 0x2000013d, 0 , 0,
17230 0x0 }, /* _POOL32A5~*(39) */
17231 { instruction , 0 , 0 , 32,
17232 0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB , 0,
17233 DSP_ }, /* CMPGU.LE.QB */
17234 { pool , ADDUH__R__QB , 2 , 32,
17235 0xfc0003ff, 0x2000014d, 0 , 0,
17236 0x0 }, /* ADDUH[_R].QB */
17237 { instruction , 0 , 0 , 32,
17238 0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH , 0,
17239 DSP_ }, /* MULQ_S.PH */
17240 { reserved_block , 0 , 0 , 32,
17241 0xfc0003ff, 0x2000015d, 0 , 0,
17242 0x0 }, /* _POOL32A5~*(43) */
17243 { reserved_block , 0 , 0 , 32,
17244 0xfc0003ff, 0x20000165, 0 , 0,
17245 0x0 }, /* _POOL32A5~*(44) */
17246 { instruction , 0 , 0 , 32,
17247 0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH , 0,
17248 DSP_ }, /* PRECRQU_S.QB.PH */
17249 { reserved_block , 0 , 0 , 32,
17250 0xfc0003ff, 0x20000175, 0 , 0,
17251 0x0 }, /* _POOL32A5~*(46) */
17252 { reserved_block , 0 , 0 , 32,
17253 0xfc0003ff, 0x2000017d, 0 , 0,
17254 0x0 }, /* _POOL32A5~*(47) */
17255 { instruction , 0 , 0 , 32,
17256 0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB , 0,
17257 DSP_ }, /* CMPGDU.EQ.QB */
17258 { pool , SHRAV__R__PH , 2 , 32,
17259 0xfc0003ff, 0x2000018d, 0 , 0,
17260 0x0 }, /* SHRAV[_R].PH */
17261 { instruction , 0 , 0 , 32,
17262 0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W , 0,
17263 DSP_ }, /* MULQ_RS.W */
17264 { reserved_block , 0 , 0 , 32,
17265 0xfc0003ff, 0x2000019d, 0 , 0,
17266 0x0 }, /* _POOL32A5~*(51) */
17267 { reserved_block , 0 , 0 , 32,
17268 0xfc0003ff, 0x200001a5, 0 , 0,
17269 0x0 }, /* _POOL32A5~*(52) */
17270 { instruction , 0 , 0 , 32,
17271 0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH , 0,
17272 DSP_ }, /* PACKRL.PH */
17273 { reserved_block , 0 , 0 , 32,
17274 0xfc0003ff, 0x200001b5, 0 , 0,
17275 0x0 }, /* _POOL32A5~*(54) */
17276 { reserved_block , 0 , 0 , 32,
17277 0xfc0003ff, 0x200001bd, 0 , 0,
17278 0x0 }, /* _POOL32A5~*(55) */
17279 { instruction , 0 , 0 , 32,
17280 0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB , 0,
17281 DSP_ }, /* CMPGDU.LT.QB */
17282 { pool , SHRAV__R__QB , 2 , 32,
17283 0xfc0003ff, 0x200001cd, 0 , 0,
17284 0x0 }, /* SHRAV[_R].QB */
17285 { instruction , 0 , 0 , 32,
17286 0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W , 0,
17287 DSP_ }, /* MULQ_S.W */
17288 { reserved_block , 0 , 0 , 32,
17289 0xfc0003ff, 0x200001dd, 0 , 0,
17290 0x0 }, /* _POOL32A5~*(59) */
17291 { reserved_block , 0 , 0 , 32,
17292 0xfc0003ff, 0x200001e5, 0 , 0,
17293 0x0 }, /* _POOL32A5~*(60) */
17294 { instruction , 0 , 0 , 32,
17295 0xfc0003ff, 0x200001ed, &NMD::PICK_QB , 0,
17296 DSP_ }, /* PICK.QB */
17297 { reserved_block , 0 , 0 , 32,
17298 0xfc0003ff, 0x200001f5, 0 , 0,
17299 0x0 }, /* _POOL32A5~*(62) */
17300 { reserved_block , 0 , 0 , 32,
17301 0xfc0003ff, 0x200001fd, 0 , 0,
17302 0x0 }, /* _POOL32A5~*(63) */
17303 { instruction , 0 , 0 , 32,
17304 0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB , 0,
17305 DSP_ }, /* CMPGDU.LE.QB */
17306 { pool , SUBQ__S__PH , 2 , 32,
17307 0xfc0003ff, 0x2000020d, 0 , 0,
17308 0x0 }, /* SUBQ[_S].PH */
17309 { instruction , 0 , 0 , 32,
17310 0xfc0003ff, 0x20000215, &NMD::APPEND , 0,
17311 DSP_ }, /* APPEND */
17312 { reserved_block , 0 , 0 , 32,
17313 0xfc0003ff, 0x2000021d, 0 , 0,
17314 0x0 }, /* _POOL32A5~*(67) */
17315 { reserved_block , 0 , 0 , 32,
17316 0xfc0003ff, 0x20000225, 0 , 0,
17317 0x0 }, /* _POOL32A5~*(68) */
17318 { instruction , 0 , 0 , 32,
17319 0xfc0003ff, 0x2000022d, &NMD::PICK_PH , 0,
17320 DSP_ }, /* PICK.PH */
17321 { reserved_block , 0 , 0 , 32,
17322 0xfc0003ff, 0x20000235, 0 , 0,
17323 0x0 }, /* _POOL32A5~*(70) */
17324 { reserved_block , 0 , 0 , 32,
17325 0xfc0003ff, 0x2000023d, 0 , 0,
17326 0x0 }, /* _POOL32A5~*(71) */
17327 { instruction , 0 , 0 , 32,
17328 0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB , 0,
17329 DSP_ }, /* CMPU.EQ.QB */
17330 { pool , SUBQH__R__PH , 2 , 32,
17331 0xfc0003ff, 0x2000024d, 0 , 0,
17332 0x0 }, /* SUBQH[_R].PH */
17333 { instruction , 0 , 0 , 32,
17334 0xfc0003ff, 0x20000255, &NMD::PREPEND , 0,
17335 DSP_ }, /* PREPEND */
17336 { reserved_block , 0 , 0 , 32,
17337 0xfc0003ff, 0x2000025d, 0 , 0,
17338 0x0 }, /* _POOL32A5~*(75) */
17339 { reserved_block , 0 , 0 , 32,
17340 0xfc0003ff, 0x20000265, 0 , 0,
17341 0x0 }, /* _POOL32A5~*(76) */
17342 { reserved_block , 0 , 0 , 32,
17343 0xfc0003ff, 0x2000026d, 0 , 0,
17344 0x0 }, /* _POOL32A5~*(77) */
17345 { reserved_block , 0 , 0 , 32,
17346 0xfc0003ff, 0x20000275, 0 , 0,
17347 0x0 }, /* _POOL32A5~*(78) */
17348 { reserved_block , 0 , 0 , 32,
17349 0xfc0003ff, 0x2000027d, 0 , 0,
17350 0x0 }, /* _POOL32A5~*(79) */
17351 { instruction , 0 , 0 , 32,
17352 0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB , 0,
17353 DSP_ }, /* CMPU.LT.QB */
17354 { pool , SUBQH__R__W , 2 , 32,
17355 0xfc0003ff, 0x2000028d, 0 , 0,
17356 0x0 }, /* SUBQH[_R].W */
17357 { instruction , 0 , 0 , 32,
17358 0xfc0003ff, 0x20000295, &NMD::MODSUB , 0,
17359 DSP_ }, /* MODSUB */
17360 { reserved_block , 0 , 0 , 32,
17361 0xfc0003ff, 0x2000029d, 0 , 0,
17362 0x0 }, /* _POOL32A5~*(83) */
17363 { reserved_block , 0 , 0 , 32,
17364 0xfc0003ff, 0x200002a5, 0 , 0,
17365 0x0 }, /* _POOL32A5~*(84) */
17366 { reserved_block , 0 , 0 , 32,
17367 0xfc0003ff, 0x200002ad, 0 , 0,
17368 0x0 }, /* _POOL32A5~*(85) */
17369 { reserved_block , 0 , 0 , 32,
17370 0xfc0003ff, 0x200002b5, 0 , 0,
17371 0x0 }, /* _POOL32A5~*(86) */
17372 { reserved_block , 0 , 0 , 32,
17373 0xfc0003ff, 0x200002bd, 0 , 0,
17374 0x0 }, /* _POOL32A5~*(87) */
17375 { instruction , 0 , 0 , 32,
17376 0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB , 0,
17377 DSP_ }, /* CMPU.LE.QB */
17378 { pool , SUBU__S__QB , 2 , 32,
17379 0xfc0003ff, 0x200002cd, 0 , 0,
17380 0x0 }, /* SUBU[_S].QB */
17381 { instruction , 0 , 0 , 32,
17382 0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W , 0,
17383 DSP_ }, /* SHRAV_R.W */
17384 { reserved_block , 0 , 0 , 32,
17385 0xfc0003ff, 0x200002dd, 0 , 0,
17386 0x0 }, /* _POOL32A5~*(91) */
17387 { reserved_block , 0 , 0 , 32,
17388 0xfc0003ff, 0x200002e5, 0 , 0,
17389 0x0 }, /* _POOL32A5~*(92) */
17390 { reserved_block , 0 , 0 , 32,
17391 0xfc0003ff, 0x200002ed, 0 , 0,
17392 0x0 }, /* _POOL32A5~*(93) */
17393 { instruction , 0 , 0 , 32,
17394 0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W , 0,
17395 DSP_ }, /* SHRA_R.W */
17396 { reserved_block , 0 , 0 , 32,
17397 0xfc0003ff, 0x200002fd, 0 , 0,
17398 0x0 }, /* _POOL32A5~*(95) */
17399 { instruction , 0 , 0 , 32,
17400 0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W , 0,
17401 DSP_ }, /* ADDQ_S.W */
17402 { pool , SUBU__S__PH , 2 , 32,
17403 0xfc0003ff, 0x2000030d, 0 , 0,
17404 0x0 }, /* SUBU[_S].PH */
17405 { instruction , 0 , 0 , 32,
17406 0xfc0003ff, 0x20000315, &NMD::SHRLV_PH , 0,
17407 DSP_ }, /* SHRLV.PH */
17408 { reserved_block , 0 , 0 , 32,
17409 0xfc0003ff, 0x2000031d, 0 , 0,
17410 0x0 }, /* _POOL32A5~*(99) */
17411 { reserved_block , 0 , 0 , 32,
17412 0xfc0003ff, 0x20000325, 0 , 0,
17413 0x0 }, /* _POOL32A5~*(100) */
17414 { reserved_block , 0 , 0 , 32,
17415 0xfc0003ff, 0x2000032d, 0 , 0,
17416 0x0 }, /* _POOL32A5~*(101) */
17417 { pool , SHRA__R__PH , 2 , 32,
17418 0xfc0003ff, 0x20000335, 0 , 0,
17419 0x0 }, /* SHRA[_R].PH */
17420 { reserved_block , 0 , 0 , 32,
17421 0xfc0003ff, 0x2000033d, 0 , 0,
17422 0x0 }, /* _POOL32A5~*(103) */
17423 { instruction , 0 , 0 , 32,
17424 0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W , 0,
17425 DSP_ }, /* SUBQ_S.W */
17426 { pool , SUBUH__R__QB , 2 , 32,
17427 0xfc0003ff, 0x2000034d, 0 , 0,
17428 0x0 }, /* SUBUH[_R].QB */
17429 { instruction , 0 , 0 , 32,
17430 0xfc0003ff, 0x20000355, &NMD::SHRLV_QB , 0,
17431 DSP_ }, /* SHRLV.QB */
17432 { reserved_block , 0 , 0 , 32,
17433 0xfc0003ff, 0x2000035d, 0 , 0,
17434 0x0 }, /* _POOL32A5~*(107) */
17435 { reserved_block , 0 , 0 , 32,
17436 0xfc0003ff, 0x20000365, 0 , 0,
17437 0x0 }, /* _POOL32A5~*(108) */
17438 { reserved_block , 0 , 0 , 32,
17439 0xfc0003ff, 0x2000036d, 0 , 0,
17440 0x0 }, /* _POOL32A5~*(109) */
17441 { reserved_block , 0 , 0 , 32,
17442 0xfc0003ff, 0x20000375, 0 , 0,
17443 0x0 }, /* _POOL32A5~*(110) */
17444 { reserved_block , 0 , 0 , 32,
17445 0xfc0003ff, 0x2000037d, 0 , 0,
17446 0x0 }, /* _POOL32A5~*(111) */
17447 { instruction , 0 , 0 , 32,
17448 0xfc0003ff, 0x20000385, &NMD::ADDSC , 0,
17449 DSP_ }, /* ADDSC */
17450 { pool , SHLLV__S__PH , 2 , 32,
17451 0xfc0003ff, 0x2000038d, 0 , 0,
17452 0x0 }, /* SHLLV[_S].PH */
17453 { instruction , 0 , 0 , 32,
17454 0xfc0003ff, 0x20000395, &NMD::SHLLV_QB , 0,
17455 DSP_ }, /* SHLLV.QB */
17456 { reserved_block , 0 , 0 , 32,
17457 0xfc0003ff, 0x2000039d, 0 , 0,
17458 0x0 }, /* _POOL32A5~*(115) */
17459 { reserved_block , 0 , 0 , 32,
17460 0xfc0003ff, 0x200003a5, 0 , 0,
17461 0x0 }, /* _POOL32A5~*(116) */
17462 { reserved_block , 0 , 0 , 32,
17463 0xfc0003ff, 0x200003ad, 0 , 0,
17464 0x0 }, /* _POOL32A5~*(117) */
17465 { pool , SHLL__S__PH , 4 , 32,
17466 0xfc0003ff, 0x200003b5, 0 , 0,
17467 0x0 }, /* SHLL[_S].PH */
17468 { reserved_block , 0 , 0 , 32,
17469 0xfc0003ff, 0x200003bd, 0 , 0,
17470 0x0 }, /* _POOL32A5~*(119) */
17471 { instruction , 0 , 0 , 32,
17472 0xfc0003ff, 0x200003c5, &NMD::ADDWC , 0,
17473 DSP_ }, /* ADDWC */
17474 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17475 0xfc0003ff, 0x200003cd, 0 , 0,
17476 0x0 }, /* PRECR_SRA[_R].PH.W */
17477 { instruction , 0 , 0 , 32,
17478 0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W , 0,
17479 DSP_ }, /* SHLLV_S.W */
17480 { reserved_block , 0 , 0 , 32,
17481 0xfc0003ff, 0x200003dd, 0 , 0,
17482 0x0 }, /* _POOL32A5~*(123) */
17483 { reserved_block , 0 , 0 , 32,
17484 0xfc0003ff, 0x200003e5, 0 , 0,
17485 0x0 }, /* _POOL32A5~*(124) */
17486 { reserved_block , 0 , 0 , 32,
17487 0xfc0003ff, 0x200003ed, 0 , 0,
17488 0x0 }, /* _POOL32A5~*(125) */
17489 { instruction , 0 , 0 , 32,
17490 0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W , 0,
17491 DSP_ }, /* SHLL_S.W */
17492 { reserved_block , 0 , 0 , 32,
17493 0xfc0003ff, 0x200003fd, 0 , 0,
17494 0x0 }, /* _POOL32A5~*(127) */
17495};
17496
17497
17498NMD::Pool NMD::PP_LSX[16] = {
17499 { instruction , 0 , 0 , 32,
17500 0xfc0007ff, 0x20000007, &NMD::LBX , 0,
17501 0x0 }, /* LBX */
17502 { instruction , 0 , 0 , 32,
17503 0xfc0007ff, 0x20000087, &NMD::SBX , 0,
17504 XMMS_ }, /* SBX */
17505 { instruction , 0 , 0 , 32,
17506 0xfc0007ff, 0x20000107, &NMD::LBUX , 0,
17507 0x0 }, /* LBUX */
17508 { reserved_block , 0 , 0 , 32,
17509 0xfc0007ff, 0x20000187, 0 , 0,
17510 0x0 }, /* PP.LSX~*(3) */
17511 { instruction , 0 , 0 , 32,
17512 0xfc0007ff, 0x20000207, &NMD::LHX , 0,
17513 0x0 }, /* LHX */
17514 { instruction , 0 , 0 , 32,
17515 0xfc0007ff, 0x20000287, &NMD::SHX , 0,
17516 XMMS_ }, /* SHX */
17517 { instruction , 0 , 0 , 32,
17518 0xfc0007ff, 0x20000307, &NMD::LHUX , 0,
17519 0x0 }, /* LHUX */
17520 { instruction , 0 , 0 , 32,
17521 0xfc0007ff, 0x20000387, &NMD::LWUX , 0,
17522 MIPS64_ }, /* LWUX */
17523 { instruction , 0 , 0 , 32,
17524 0xfc0007ff, 0x20000407, &NMD::LWX , 0,
17525 0x0 }, /* LWX */
17526 { instruction , 0 , 0 , 32,
17527 0xfc0007ff, 0x20000487, &NMD::SWX , 0,
17528 XMMS_ }, /* SWX */
17529 { instruction , 0 , 0 , 32,
17530 0xfc0007ff, 0x20000507, &NMD::LWC1X , 0,
17531 CP1_ }, /* LWC1X */
17532 { instruction , 0 , 0 , 32,
17533 0xfc0007ff, 0x20000587, &NMD::SWC1X , 0,
17534 CP1_ }, /* SWC1X */
17535 { instruction , 0 , 0 , 32,
17536 0xfc0007ff, 0x20000607, &NMD::LDX , 0,
17537 MIPS64_ }, /* LDX */
17538 { instruction , 0 , 0 , 32,
17539 0xfc0007ff, 0x20000687, &NMD::SDX , 0,
17540 MIPS64_ }, /* SDX */
17541 { instruction , 0 , 0 , 32,
17542 0xfc0007ff, 0x20000707, &NMD::LDC1X , 0,
17543 CP1_ }, /* LDC1X */
17544 { instruction , 0 , 0 , 32,
17545 0xfc0007ff, 0x20000787, &NMD::SDC1X , 0,
17546 CP1_ }, /* SDC1X */
17547};
17548
17549
17550NMD::Pool NMD::PP_LSXS[16] = {
17551 { reserved_block , 0 , 0 , 32,
17552 0xfc0007ff, 0x20000047, 0 , 0,
17553 0x0 }, /* PP.LSXS~*(0) */
17554 { reserved_block , 0 , 0 , 32,
17555 0xfc0007ff, 0x200000c7, 0 , 0,
17556 0x0 }, /* PP.LSXS~*(1) */
17557 { reserved_block , 0 , 0 , 32,
17558 0xfc0007ff, 0x20000147, 0 , 0,
17559 0x0 }, /* PP.LSXS~*(2) */
17560 { reserved_block , 0 , 0 , 32,
17561 0xfc0007ff, 0x200001c7, 0 , 0,
17562 0x0 }, /* PP.LSXS~*(3) */
17563 { instruction , 0 , 0 , 32,
17564 0xfc0007ff, 0x20000247, &NMD::LHXS , 0,
17565 0x0 }, /* LHXS */
17566 { instruction , 0 , 0 , 32,
17567 0xfc0007ff, 0x200002c7, &NMD::SHXS , 0,
17568 XMMS_ }, /* SHXS */
17569 { instruction , 0 , 0 , 32,
17570 0xfc0007ff, 0x20000347, &NMD::LHUXS , 0,
17571 0x0 }, /* LHUXS */
17572 { instruction , 0 , 0 , 32,
17573 0xfc0007ff, 0x200003c7, &NMD::LWUXS , 0,
17574 MIPS64_ }, /* LWUXS */
17575 { instruction , 0 , 0 , 32,
17576 0xfc0007ff, 0x20000447, &NMD::LWXS_32_ , 0,
17577 0x0 }, /* LWXS[32] */
17578 { instruction , 0 , 0 , 32,
17579 0xfc0007ff, 0x200004c7, &NMD::SWXS , 0,
17580 XMMS_ }, /* SWXS */
17581 { instruction , 0 , 0 , 32,
17582 0xfc0007ff, 0x20000547, &NMD::LWC1XS , 0,
17583 CP1_ }, /* LWC1XS */
17584 { instruction , 0 , 0 , 32,
17585 0xfc0007ff, 0x200005c7, &NMD::SWC1XS , 0,
17586 CP1_ }, /* SWC1XS */
17587 { instruction , 0 , 0 , 32,
17588 0xfc0007ff, 0x20000647, &NMD::LDXS , 0,
17589 MIPS64_ }, /* LDXS */
17590 { instruction , 0 , 0 , 32,
17591 0xfc0007ff, 0x200006c7, &NMD::SDXS , 0,
17592 MIPS64_ }, /* SDXS */
17593 { instruction , 0 , 0 , 32,
17594 0xfc0007ff, 0x20000747, &NMD::LDC1XS , 0,
17595 CP1_ }, /* LDC1XS */
17596 { instruction , 0 , 0 , 32,
17597 0xfc0007ff, 0x200007c7, &NMD::SDC1XS , 0,
17598 CP1_ }, /* SDC1XS */
17599};
17600
17601
17602NMD::Pool NMD::P_LSX[2] = {
17603 { pool , PP_LSX , 16 , 32,
17604 0xfc00007f, 0x20000007, 0 , 0,
17605 0x0 }, /* PP.LSX */
17606 { pool , PP_LSXS , 16 , 32,
17607 0xfc00007f, 0x20000047, 0 , 0,
17608 0x0 }, /* PP.LSXS */
17609};
17610
17611
17612NMD::Pool NMD::POOL32Axf_1_0[4] = {
17613 { instruction , 0 , 0 , 32,
17614 0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_ , 0,
17615 DSP_ }, /* MFHI[DSP] */
17616 { instruction , 0 , 0 , 32,
17617 0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_ , 0,
17618 DSP_ }, /* MFLO[DSP] */
17619 { instruction , 0 , 0 , 32,
17620 0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_ , 0,
17621 DSP_ }, /* MTHI[DSP] */
17622 { instruction , 0 , 0 , 32,
17623 0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_ , 0,
17624 DSP_ }, /* MTLO[DSP] */
17625};
17626
17627
17628NMD::Pool NMD::POOL32Axf_1_1[4] = {
17629 { instruction , 0 , 0 , 32,
17630 0xfc003fff, 0x2000027f, &NMD::MTHLIP , 0,
17631 DSP_ }, /* MTHLIP */
17632 { instruction , 0 , 0 , 32,
17633 0xfc003fff, 0x2000127f, &NMD::SHILOV , 0,
17634 DSP_ }, /* SHILOV */
17635 { reserved_block , 0 , 0 , 32,
17636 0xfc003fff, 0x2000227f, 0 , 0,
17637 0x0 }, /* POOL32Axf_1_1~*(2) */
17638 { reserved_block , 0 , 0 , 32,
17639 0xfc003fff, 0x2000327f, 0 , 0,
17640 0x0 }, /* POOL32Axf_1_1~*(3) */
17641};
17642
17643
17644NMD::Pool NMD::POOL32Axf_1_3[4] = {
17645 { instruction , 0 , 0 , 32,
17646 0xfc003fff, 0x2000067f, &NMD::RDDSP , 0,
17647 DSP_ }, /* RDDSP */
17648 { instruction , 0 , 0 , 32,
17649 0xfc003fff, 0x2000167f, &NMD::WRDSP , 0,
17650 DSP_ }, /* WRDSP */
17651 { instruction , 0 , 0 , 32,
17652 0xfc003fff, 0x2000267f, &NMD::EXTP , 0,
17653 DSP_ }, /* EXTP */
17654 { instruction , 0 , 0 , 32,
17655 0xfc003fff, 0x2000367f, &NMD::EXTPDP , 0,
17656 DSP_ }, /* EXTPDP */
17657};
17658
17659
17660NMD::Pool NMD::POOL32Axf_1_4[2] = {
17661 { instruction , 0 , 0 , 32,
17662 0xfc001fff, 0x2000087f, &NMD::SHLL_QB , 0,
17663 DSP_ }, /* SHLL.QB */
17664 { instruction , 0 , 0 , 32,
17665 0xfc001fff, 0x2000187f, &NMD::SHRL_QB , 0,
17666 DSP_ }, /* SHRL.QB */
17667};
17668
17669
17670NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
17671 { instruction , 0 , 0 , 32,
17672 0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR , 0,
17673 DSP_ }, /* MAQ_S.W.PHR */
17674 { instruction , 0 , 0 , 32,
17675 0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR , 0,
17676 DSP_ }, /* MAQ_SA.W.PHR */
17677};
17678
17679
17680NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
17681 { instruction , 0 , 0 , 32,
17682 0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL , 0,
17683 DSP_ }, /* MAQ_S.W.PHL */
17684 { instruction , 0 , 0 , 32,
17685 0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL , 0,
17686 DSP_ }, /* MAQ_SA.W.PHL */
17687};
17688
17689
17690NMD::Pool NMD::POOL32Axf_1_5[2] = {
17691 { pool , MAQ_S_A__W_PHR , 2 , 32,
17692 0xfc001fff, 0x20000a7f, 0 , 0,
17693 0x0 }, /* MAQ_S[A].W.PHR */
17694 { pool , MAQ_S_A__W_PHL , 2 , 32,
17695 0xfc001fff, 0x20001a7f, 0 , 0,
17696 0x0 }, /* MAQ_S[A].W.PHL */
17697};
17698
17699
17700NMD::Pool NMD::POOL32Axf_1_7[4] = {
17701 { instruction , 0 , 0 , 32,
17702 0xfc003fff, 0x20000e7f, &NMD::EXTR_W , 0,
17703 DSP_ }, /* EXTR.W */
17704 { instruction , 0 , 0 , 32,
17705 0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W , 0,
17706 DSP_ }, /* EXTR_R.W */
17707 { instruction , 0 , 0 , 32,
17708 0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W , 0,
17709 DSP_ }, /* EXTR_RS.W */
17710 { instruction , 0 , 0 , 32,
17711 0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H , 0,
17712 DSP_ }, /* EXTR_S.H */
17713};
17714
17715
17716NMD::Pool NMD::POOL32Axf_1[8] = {
17717 { pool , POOL32Axf_1_0 , 4 , 32,
17718 0xfc000fff, 0x2000007f, 0 , 0,
17719 0x0 }, /* POOL32Axf_1_0 */
17720 { pool , POOL32Axf_1_1 , 4 , 32,
17721 0xfc000fff, 0x2000027f, 0 , 0,
17722 0x0 }, /* POOL32Axf_1_1 */
17723 { reserved_block , 0 , 0 , 32,
17724 0xfc000fff, 0x2000047f, 0 , 0,
17725 0x0 }, /* POOL32Axf_1~*(2) */
17726 { pool , POOL32Axf_1_3 , 4 , 32,
17727 0xfc000fff, 0x2000067f, 0 , 0,
17728 0x0 }, /* POOL32Axf_1_3 */
17729 { pool , POOL32Axf_1_4 , 2 , 32,
17730 0xfc000fff, 0x2000087f, 0 , 0,
17731 0x0 }, /* POOL32Axf_1_4 */
17732 { pool , POOL32Axf_1_5 , 2 , 32,
17733 0xfc000fff, 0x20000a7f, 0 , 0,
17734 0x0 }, /* POOL32Axf_1_5 */
17735 { reserved_block , 0 , 0 , 32,
17736 0xfc000fff, 0x20000c7f, 0 , 0,
17737 0x0 }, /* POOL32Axf_1~*(6) */
17738 { pool , POOL32Axf_1_7 , 4 , 32,
17739 0xfc000fff, 0x20000e7f, 0 , 0,
17740 0x0 }, /* POOL32Axf_1_7 */
17741};
17742
17743
17744NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
17745 { instruction , 0 , 0 , 32,
17746 0xfc003fff, 0x200000bf, &NMD::DPA_W_PH , 0,
17747 DSP_ }, /* DPA.W.PH */
17748 { instruction , 0 , 0 , 32,
17749 0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH , 0,
17750 DSP_ }, /* DPAQ_S.W.PH */
17751 { instruction , 0 , 0 , 32,
17752 0xfc003fff, 0x200004bf, &NMD::DPS_W_PH , 0,
17753 DSP_ }, /* DPS.W.PH */
17754 { instruction , 0 , 0 , 32,
17755 0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH , 0,
17756 DSP_ }, /* DPSQ_S.W.PH */
17757 { reserved_block , 0 , 0 , 32,
17758 0xfc003fff, 0x200008bf, 0 , 0,
17759 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17760 { instruction , 0 , 0 , 32,
17761 0xfc003fff, 0x20000abf, &NMD::MADD_DSP_ , 0,
17762 DSP_ }, /* MADD[DSP] */
17763 { instruction , 0 , 0 , 32,
17764 0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_ , 0,
17765 DSP_ }, /* MULT[DSP] */
17766 { instruction , 0 , 0 , 32,
17767 0xfc003fff, 0x20000ebf, &NMD::EXTRV_W , 0,
17768 DSP_ }, /* EXTRV.W */
17769};
17770
17771
17772NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
17773 { instruction , 0 , 0 , 32,
17774 0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH , 0,
17775 DSP_ }, /* DPAX.W.PH */
17776 { instruction , 0 , 0 , 32,
17777 0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W , 0,
17778 DSP_ }, /* DPAQ_SA.L.W */
17779 { instruction , 0 , 0 , 32,
17780 0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH , 0,
17781 DSP_ }, /* DPSX.W.PH */
17782 { instruction , 0 , 0 , 32,
17783 0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W , 0,
17784 DSP_ }, /* DPSQ_SA.L.W */
17785 { reserved_block , 0 , 0 , 32,
17786 0xfc003fff, 0x200018bf, 0 , 0,
17787 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17788 { instruction , 0 , 0 , 32,
17789 0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_ , 0,
17790 DSP_ }, /* MADDU[DSP] */
17791 { instruction , 0 , 0 , 32,
17792 0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_ , 0,
17793 DSP_ }, /* MULTU[DSP] */
17794 { instruction , 0 , 0 , 32,
17795 0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W , 0,
17796 DSP_ }, /* EXTRV_R.W */
17797};
17798
17799
17800NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
17801 { instruction , 0 , 0 , 32,
17802 0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL , 0,
17803 DSP_ }, /* DPAU.H.QBL */
17804 { instruction , 0 , 0 , 32,
17805 0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH , 0,
17806 DSP_ }, /* DPAQX_S.W.PH */
17807 { instruction , 0 , 0 , 32,
17808 0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL , 0,
17809 DSP_ }, /* DPSU.H.QBL */
17810 { instruction , 0 , 0 , 32,
17811 0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH , 0,
17812 DSP_ }, /* DPSQX_S.W.PH */
17813 { instruction , 0 , 0 , 32,
17814 0xfc003fff, 0x200028bf, &NMD::EXTPV , 0,
17815 DSP_ }, /* EXTPV */
17816 { instruction , 0 , 0 , 32,
17817 0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_ , 0,
17818 DSP_ }, /* MSUB[DSP] */
17819 { instruction , 0 , 0 , 32,
17820 0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH , 0,
17821 DSP_ }, /* MULSA.W.PH */
17822 { instruction , 0 , 0 , 32,
17823 0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W , 0,
17824 DSP_ }, /* EXTRV_RS.W */
17825};
17826
17827
17828NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
17829 { instruction , 0 , 0 , 32,
17830 0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR , 0,
17831 DSP_ }, /* DPAU.H.QBR */
17832 { instruction , 0 , 0 , 32,
17833 0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH , 0,
17834 DSP_ }, /* DPAQX_SA.W.PH */
17835 { instruction , 0 , 0 , 32,
17836 0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR , 0,
17837 DSP_ }, /* DPSU.H.QBR */
17838 { instruction , 0 , 0 , 32,
17839 0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH , 0,
17840 DSP_ }, /* DPSQX_SA.W.PH */
17841 { instruction , 0 , 0 , 32,
17842 0xfc003fff, 0x200038bf, &NMD::EXTPDPV , 0,
17843 DSP_ }, /* EXTPDPV */
17844 { instruction , 0 , 0 , 32,
17845 0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_ , 0,
17846 DSP_ }, /* MSUBU[DSP] */
17847 { instruction , 0 , 0 , 32,
17848 0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH , 0,
17849 DSP_ }, /* MULSAQ_S.W.PH */
17850 { instruction , 0 , 0 , 32,
17851 0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H , 0,
17852 DSP_ }, /* EXTRV_S.H */
17853};
17854
17855
17856NMD::Pool NMD::POOL32Axf_2[4] = {
17857 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
17858 0xfc0031ff, 0x200000bf, 0 , 0,
17859 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
17860 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
17861 0xfc0031ff, 0x200010bf, 0 , 0,
17862 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
17863 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
17864 0xfc0031ff, 0x200020bf, 0 , 0,
17865 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
17866 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
17867 0xfc0031ff, 0x200030bf, 0 , 0,
17868 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
17869};
17870
17871
17872NMD::Pool NMD::POOL32Axf_4[128] = {
17873 { instruction , 0 , 0 , 32,
17874 0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB , 0,
17875 DSP_ }, /* ABSQ_S.QB */
17876 { instruction , 0 , 0 , 32,
17877 0xfc00ffff, 0x2000033f, &NMD::REPLV_PH , 0,
17878 DSP_ }, /* REPLV.PH */
17879 { reserved_block , 0 , 0 , 32,
17880 0xfc00ffff, 0x2000053f, 0 , 0,
17881 0x0 }, /* POOL32Axf_4~*(2) */
17882 { reserved_block , 0 , 0 , 32,
17883 0xfc00ffff, 0x2000073f, 0 , 0,
17884 0x0 }, /* POOL32Axf_4~*(3) */
17885 { reserved_block , 0 , 0 , 32,
17886 0xfc00ffff, 0x2000093f, 0 , 0,
17887 0x0 }, /* POOL32Axf_4~*(4) */
17888 { reserved_block , 0 , 0 , 32,
17889 0xfc00ffff, 0x20000b3f, 0 , 0,
17890 0x0 }, /* POOL32Axf_4~*(5) */
17891 { reserved_block , 0 , 0 , 32,
17892 0xfc00ffff, 0x20000d3f, 0 , 0,
17893 0x0 }, /* POOL32Axf_4~*(6) */
17894 { reserved_block , 0 , 0 , 32,
17895 0xfc00ffff, 0x20000f3f, 0 , 0,
17896 0x0 }, /* POOL32Axf_4~*(7) */
17897 { instruction , 0 , 0 , 32,
17898 0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH , 0,
17899 DSP_ }, /* ABSQ_S.PH */
17900 { instruction , 0 , 0 , 32,
17901 0xfc00ffff, 0x2000133f, &NMD::REPLV_QB , 0,
17902 DSP_ }, /* REPLV.QB */
17903 { reserved_block , 0 , 0 , 32,
17904 0xfc00ffff, 0x2000153f, 0 , 0,
17905 0x0 }, /* POOL32Axf_4~*(10) */
17906 { reserved_block , 0 , 0 , 32,
17907 0xfc00ffff, 0x2000173f, 0 , 0,
17908 0x0 }, /* POOL32Axf_4~*(11) */
17909 { reserved_block , 0 , 0 , 32,
17910 0xfc00ffff, 0x2000193f, 0 , 0,
17911 0x0 }, /* POOL32Axf_4~*(12) */
17912 { reserved_block , 0 , 0 , 32,
17913 0xfc00ffff, 0x20001b3f, 0 , 0,
17914 0x0 }, /* POOL32Axf_4~*(13) */
17915 { reserved_block , 0 , 0 , 32,
17916 0xfc00ffff, 0x20001d3f, 0 , 0,
17917 0x0 }, /* POOL32Axf_4~*(14) */
17918 { reserved_block , 0 , 0 , 32,
17919 0xfc00ffff, 0x20001f3f, 0 , 0,
17920 0x0 }, /* POOL32Axf_4~*(15) */
17921 { instruction , 0 , 0 , 32,
17922 0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W , 0,
17923 DSP_ }, /* ABSQ_S.W */
17924 { reserved_block , 0 , 0 , 32,
17925 0xfc00ffff, 0x2000233f, 0 , 0,
17926 0x0 }, /* POOL32Axf_4~*(17) */
17927 { reserved_block , 0 , 0 , 32,
17928 0xfc00ffff, 0x2000253f, 0 , 0,
17929 0x0 }, /* POOL32Axf_4~*(18) */
17930 { reserved_block , 0 , 0 , 32,
17931 0xfc00ffff, 0x2000273f, 0 , 0,
17932 0x0 }, /* POOL32Axf_4~*(19) */
17933 { reserved_block , 0 , 0 , 32,
17934 0xfc00ffff, 0x2000293f, 0 , 0,
17935 0x0 }, /* POOL32Axf_4~*(20) */
17936 { reserved_block , 0 , 0 , 32,
17937 0xfc00ffff, 0x20002b3f, 0 , 0,
17938 0x0 }, /* POOL32Axf_4~*(21) */
17939 { reserved_block , 0 , 0 , 32,
17940 0xfc00ffff, 0x20002d3f, 0 , 0,
17941 0x0 }, /* POOL32Axf_4~*(22) */
17942 { reserved_block , 0 , 0 , 32,
17943 0xfc00ffff, 0x20002f3f, 0 , 0,
17944 0x0 }, /* POOL32Axf_4~*(23) */
17945 { reserved_block , 0 , 0 , 32,
17946 0xfc00ffff, 0x2000313f, 0 , 0,
17947 0x0 }, /* POOL32Axf_4~*(24) */
17948 { reserved_block , 0 , 0 , 32,
17949 0xfc00ffff, 0x2000333f, 0 , 0,
17950 0x0 }, /* POOL32Axf_4~*(25) */
17951 { reserved_block , 0 , 0 , 32,
17952 0xfc00ffff, 0x2000353f, 0 , 0,
17953 0x0 }, /* POOL32Axf_4~*(26) */
17954 { reserved_block , 0 , 0 , 32,
17955 0xfc00ffff, 0x2000373f, 0 , 0,
17956 0x0 }, /* POOL32Axf_4~*(27) */
17957 { reserved_block , 0 , 0 , 32,
17958 0xfc00ffff, 0x2000393f, 0 , 0,
17959 0x0 }, /* POOL32Axf_4~*(28) */
17960 { reserved_block , 0 , 0 , 32,
17961 0xfc00ffff, 0x20003b3f, 0 , 0,
17962 0x0 }, /* POOL32Axf_4~*(29) */
17963 { reserved_block , 0 , 0 , 32,
17964 0xfc00ffff, 0x20003d3f, 0 , 0,
17965 0x0 }, /* POOL32Axf_4~*(30) */
17966 { reserved_block , 0 , 0 , 32,
17967 0xfc00ffff, 0x20003f3f, 0 , 0,
17968 0x0 }, /* POOL32Axf_4~*(31) */
17969 { instruction , 0 , 0 , 32,
17970 0xfc00ffff, 0x2000413f, &NMD::INSV , 0,
17971 DSP_ }, /* INSV */
17972 { reserved_block , 0 , 0 , 32,
17973 0xfc00ffff, 0x2000433f, 0 , 0,
17974 0x0 }, /* POOL32Axf_4~*(33) */
17975 { reserved_block , 0 , 0 , 32,
17976 0xfc00ffff, 0x2000453f, 0 , 0,
17977 0x0 }, /* POOL32Axf_4~*(34) */
17978 { reserved_block , 0 , 0 , 32,
17979 0xfc00ffff, 0x2000473f, 0 , 0,
17980 0x0 }, /* POOL32Axf_4~*(35) */
17981 { reserved_block , 0 , 0 , 32,
17982 0xfc00ffff, 0x2000493f, 0 , 0,
17983 0x0 }, /* POOL32Axf_4~*(36) */
17984 { instruction , 0 , 0 , 32,
17985 0xfc00ffff, 0x20004b3f, &NMD::CLO , 0,
17986 XMMS_ }, /* CLO */
17987 { instruction , 0 , 0 , 32,
17988 0xfc00ffff, 0x20004d3f, &NMD::MFC2 , 0,
17989 CP2_ }, /* MFC2 */
17990 { reserved_block , 0 , 0 , 32,
17991 0xfc00ffff, 0x20004f3f, 0 , 0,
17992 0x0 }, /* POOL32Axf_4~*(39) */
17993 { instruction , 0 , 0 , 32,
17994 0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL , 0,
17995 DSP_ }, /* PRECEQ.W.PHL */
17996 { reserved_block , 0 , 0 , 32,
17997 0xfc00ffff, 0x2000533f, 0 , 0,
17998 0x0 }, /* POOL32Axf_4~*(41) */
17999 { reserved_block , 0 , 0 , 32,
18000 0xfc00ffff, 0x2000553f, 0 , 0,
18001 0x0 }, /* POOL32Axf_4~*(42) */
18002 { reserved_block , 0 , 0 , 32,
18003 0xfc00ffff, 0x2000573f, 0 , 0,
18004 0x0 }, /* POOL32Axf_4~*(43) */
18005 { reserved_block , 0 , 0 , 32,
18006 0xfc00ffff, 0x2000593f, 0 , 0,
18007 0x0 }, /* POOL32Axf_4~*(44) */
18008 { instruction , 0 , 0 , 32,
18009 0xfc00ffff, 0x20005b3f, &NMD::CLZ , 0,
18010 XMMS_ }, /* CLZ */
18011 { instruction , 0 , 0 , 32,
18012 0xfc00ffff, 0x20005d3f, &NMD::MTC2 , 0,
18013 CP2_ }, /* MTC2 */
18014 { reserved_block , 0 , 0 , 32,
18015 0xfc00ffff, 0x20005f3f, 0 , 0,
18016 0x0 }, /* POOL32Axf_4~*(47) */
18017 { instruction , 0 , 0 , 32,
18018 0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR , 0,
18019 DSP_ }, /* PRECEQ.W.PHR */
18020 { reserved_block , 0 , 0 , 32,
18021 0xfc00ffff, 0x2000633f, 0 , 0,
18022 0x0 }, /* POOL32Axf_4~*(49) */
18023 { reserved_block , 0 , 0 , 32,
18024 0xfc00ffff, 0x2000653f, 0 , 0,
18025 0x0 }, /* POOL32Axf_4~*(50) */
18026 { reserved_block , 0 , 0 , 32,
18027 0xfc00ffff, 0x2000673f, 0 , 0,
18028 0x0 }, /* POOL32Axf_4~*(51) */
18029 { reserved_block , 0 , 0 , 32,
18030 0xfc00ffff, 0x2000693f, 0 , 0,
18031 0x0 }, /* POOL32Axf_4~*(52) */
18032 { reserved_block , 0 , 0 , 32,
18033 0xfc00ffff, 0x20006b3f, 0 , 0,
18034 0x0 }, /* POOL32Axf_4~*(53) */
18035 { instruction , 0 , 0 , 32,
18036 0xfc00ffff, 0x20006d3f, &NMD::DMFC2 , 0,
18037 CP2_ }, /* DMFC2 */
18038 { reserved_block , 0 , 0 , 32,
18039 0xfc00ffff, 0x20006f3f, 0 , 0,
18040 0x0 }, /* POOL32Axf_4~*(55) */
18041 { instruction , 0 , 0 , 32,
18042 0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL , 0,
18043 DSP_ }, /* PRECEQU.PH.QBL */
18044 { instruction , 0 , 0 , 32,
18045 0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA , 0,
18046 DSP_ }, /* PRECEQU.PH.QBLA */
18047 { reserved_block , 0 , 0 , 32,
18048 0xfc00ffff, 0x2000753f, 0 , 0,
18049 0x0 }, /* POOL32Axf_4~*(58) */
18050 { reserved_block , 0 , 0 , 32,
18051 0xfc00ffff, 0x2000773f, 0 , 0,
18052 0x0 }, /* POOL32Axf_4~*(59) */
18053 { reserved_block , 0 , 0 , 32,
18054 0xfc00ffff, 0x2000793f, 0 , 0,
18055 0x0 }, /* POOL32Axf_4~*(60) */
18056 { reserved_block , 0 , 0 , 32,
18057 0xfc00ffff, 0x20007b3f, 0 , 0,
18058 0x0 }, /* POOL32Axf_4~*(61) */
18059 { instruction , 0 , 0 , 32,
18060 0xfc00ffff, 0x20007d3f, &NMD::DMTC2 , 0,
18061 CP2_ }, /* DMTC2 */
18062 { reserved_block , 0 , 0 , 32,
18063 0xfc00ffff, 0x20007f3f, 0 , 0,
18064 0x0 }, /* POOL32Axf_4~*(63) */
18065 { reserved_block , 0 , 0 , 32,
18066 0xfc00ffff, 0x2000813f, 0 , 0,
18067 0x0 }, /* POOL32Axf_4~*(64) */
18068 { reserved_block , 0 , 0 , 32,
18069 0xfc00ffff, 0x2000833f, 0 , 0,
18070 0x0 }, /* POOL32Axf_4~*(65) */
18071 { reserved_block , 0 , 0 , 32,
18072 0xfc00ffff, 0x2000853f, 0 , 0,
18073 0x0 }, /* POOL32Axf_4~*(66) */
18074 { reserved_block , 0 , 0 , 32,
18075 0xfc00ffff, 0x2000873f, 0 , 0,
18076 0x0 }, /* POOL32Axf_4~*(67) */
18077 { reserved_block , 0 , 0 , 32,
18078 0xfc00ffff, 0x2000893f, 0 , 0,
18079 0x0 }, /* POOL32Axf_4~*(68) */
18080 { reserved_block , 0 , 0 , 32,
18081 0xfc00ffff, 0x20008b3f, 0 , 0,
18082 0x0 }, /* POOL32Axf_4~*(69) */
18083 { instruction , 0 , 0 , 32,
18084 0xfc00ffff, 0x20008d3f, &NMD::MFHC2 , 0,
18085 CP2_ }, /* MFHC2 */
18086 { reserved_block , 0 , 0 , 32,
18087 0xfc00ffff, 0x20008f3f, 0 , 0,
18088 0x0 }, /* POOL32Axf_4~*(71) */
18089 { instruction , 0 , 0 , 32,
18090 0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR , 0,
18091 DSP_ }, /* PRECEQU.PH.QBR */
18092 { instruction , 0 , 0 , 32,
18093 0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA , 0,
18094 DSP_ }, /* PRECEQU.PH.QBRA */
18095 { reserved_block , 0 , 0 , 32,
18096 0xfc00ffff, 0x2000953f, 0 , 0,
18097 0x0 }, /* POOL32Axf_4~*(74) */
18098 { reserved_block , 0 , 0 , 32,
18099 0xfc00ffff, 0x2000973f, 0 , 0,
18100 0x0 }, /* POOL32Axf_4~*(75) */
18101 { reserved_block , 0 , 0 , 32,
18102 0xfc00ffff, 0x2000993f, 0 , 0,
18103 0x0 }, /* POOL32Axf_4~*(76) */
18104 { reserved_block , 0 , 0 , 32,
18105 0xfc00ffff, 0x20009b3f, 0 , 0,
18106 0x0 }, /* POOL32Axf_4~*(77) */
18107 { instruction , 0 , 0 , 32,
18108 0xfc00ffff, 0x20009d3f, &NMD::MTHC2 , 0,
18109 CP2_ }, /* MTHC2 */
18110 { reserved_block , 0 , 0 , 32,
18111 0xfc00ffff, 0x20009f3f, 0 , 0,
18112 0x0 }, /* POOL32Axf_4~*(79) */
18113 { reserved_block , 0 , 0 , 32,
18114 0xfc00ffff, 0x2000a13f, 0 , 0,
18115 0x0 }, /* POOL32Axf_4~*(80) */
18116 { reserved_block , 0 , 0 , 32,
18117 0xfc00ffff, 0x2000a33f, 0 , 0,
18118 0x0 }, /* POOL32Axf_4~*(81) */
18119 { reserved_block , 0 , 0 , 32,
18120 0xfc00ffff, 0x2000a53f, 0 , 0,
18121 0x0 }, /* POOL32Axf_4~*(82) */
18122 { reserved_block , 0 , 0 , 32,
18123 0xfc00ffff, 0x2000a73f, 0 , 0,
18124 0x0 }, /* POOL32Axf_4~*(83) */
18125 { reserved_block , 0 , 0 , 32,
18126 0xfc00ffff, 0x2000a93f, 0 , 0,
18127 0x0 }, /* POOL32Axf_4~*(84) */
18128 { reserved_block , 0 , 0 , 32,
18129 0xfc00ffff, 0x2000ab3f, 0 , 0,
18130 0x0 }, /* POOL32Axf_4~*(85) */
18131 { reserved_block , 0 , 0 , 32,
18132 0xfc00ffff, 0x2000ad3f, 0 , 0,
18133 0x0 }, /* POOL32Axf_4~*(86) */
18134 { reserved_block , 0 , 0 , 32,
18135 0xfc00ffff, 0x2000af3f, 0 , 0,
18136 0x0 }, /* POOL32Axf_4~*(87) */
18137 { instruction , 0 , 0 , 32,
18138 0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL , 0,
18139 DSP_ }, /* PRECEU.PH.QBL */
18140 { instruction , 0 , 0 , 32,
18141 0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA , 0,
18142 DSP_ }, /* PRECEU.PH.QBLA */
18143 { reserved_block , 0 , 0 , 32,
18144 0xfc00ffff, 0x2000b53f, 0 , 0,
18145 0x0 }, /* POOL32Axf_4~*(90) */
18146 { reserved_block , 0 , 0 , 32,
18147 0xfc00ffff, 0x2000b73f, 0 , 0,
18148 0x0 }, /* POOL32Axf_4~*(91) */
18149 { reserved_block , 0 , 0 , 32,
18150 0xfc00ffff, 0x2000b93f, 0 , 0,
18151 0x0 }, /* POOL32Axf_4~*(92) */
18152 { reserved_block , 0 , 0 , 32,
18153 0xfc00ffff, 0x2000bb3f, 0 , 0,
18154 0x0 }, /* POOL32Axf_4~*(93) */
18155 { reserved_block , 0 , 0 , 32,
18156 0xfc00ffff, 0x2000bd3f, 0 , 0,
18157 0x0 }, /* POOL32Axf_4~*(94) */
18158 { reserved_block , 0 , 0 , 32,
18159 0xfc00ffff, 0x2000bf3f, 0 , 0,
18160 0x0 }, /* POOL32Axf_4~*(95) */
18161 { reserved_block , 0 , 0 , 32,
18162 0xfc00ffff, 0x2000c13f, 0 , 0,
18163 0x0 }, /* POOL32Axf_4~*(96) */
18164 { reserved_block , 0 , 0 , 32,
18165 0xfc00ffff, 0x2000c33f, 0 , 0,
18166 0x0 }, /* POOL32Axf_4~*(97) */
18167 { reserved_block , 0 , 0 , 32,
18168 0xfc00ffff, 0x2000c53f, 0 , 0,
18169 0x0 }, /* POOL32Axf_4~*(98) */
18170 { reserved_block , 0 , 0 , 32,
18171 0xfc00ffff, 0x2000c73f, 0 , 0,
18172 0x0 }, /* POOL32Axf_4~*(99) */
18173 { reserved_block , 0 , 0 , 32,
18174 0xfc00ffff, 0x2000c93f, 0 , 0,
18175 0x0 }, /* POOL32Axf_4~*(100) */
18176 { reserved_block , 0 , 0 , 32,
18177 0xfc00ffff, 0x2000cb3f, 0 , 0,
18178 0x0 }, /* POOL32Axf_4~*(101) */
18179 { instruction , 0 , 0 , 32,
18180 0xfc00ffff, 0x2000cd3f, &NMD::CFC2 , 0,
18181 CP2_ }, /* CFC2 */
18182 { reserved_block , 0 , 0 , 32,
18183 0xfc00ffff, 0x2000cf3f, 0 , 0,
18184 0x0 }, /* POOL32Axf_4~*(103) */
18185 { instruction , 0 , 0 , 32,
18186 0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR , 0,
18187 DSP_ }, /* PRECEU.PH.QBR */
18188 { instruction , 0 , 0 , 32,
18189 0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA , 0,
18190 DSP_ }, /* PRECEU.PH.QBRA */
18191 { reserved_block , 0 , 0 , 32,
18192 0xfc00ffff, 0x2000d53f, 0 , 0,
18193 0x0 }, /* POOL32Axf_4~*(106) */
18194 { reserved_block , 0 , 0 , 32,
18195 0xfc00ffff, 0x2000d73f, 0 , 0,
18196 0x0 }, /* POOL32Axf_4~*(107) */
18197 { reserved_block , 0 , 0 , 32,
18198 0xfc00ffff, 0x2000d93f, 0 , 0,
18199 0x0 }, /* POOL32Axf_4~*(108) */
18200 { reserved_block , 0 , 0 , 32,
18201 0xfc00ffff, 0x2000db3f, 0 , 0,
18202 0x0 }, /* POOL32Axf_4~*(109) */
18203 { instruction , 0 , 0 , 32,
18204 0xfc00ffff, 0x2000dd3f, &NMD::CTC2 , 0,
18205 CP2_ }, /* CTC2 */
18206 { reserved_block , 0 , 0 , 32,
18207 0xfc00ffff, 0x2000df3f, 0 , 0,
18208 0x0 }, /* POOL32Axf_4~*(111) */
18209 { reserved_block , 0 , 0 , 32,
18210 0xfc00ffff, 0x2000e13f, 0 , 0,
18211 0x0 }, /* POOL32Axf_4~*(112) */
18212 { reserved_block , 0 , 0 , 32,
18213 0xfc00ffff, 0x2000e33f, 0 , 0,
18214 0x0 }, /* POOL32Axf_4~*(113) */
18215 { reserved_block , 0 , 0 , 32,
18216 0xfc00ffff, 0x2000e53f, 0 , 0,
18217 0x0 }, /* POOL32Axf_4~*(114) */
18218 { reserved_block , 0 , 0 , 32,
18219 0xfc00ffff, 0x2000e73f, 0 , 0,
18220 0x0 }, /* POOL32Axf_4~*(115) */
18221 { reserved_block , 0 , 0 , 32,
18222 0xfc00ffff, 0x2000e93f, 0 , 0,
18223 0x0 }, /* POOL32Axf_4~*(116) */
18224 { reserved_block , 0 , 0 , 32,
18225 0xfc00ffff, 0x2000eb3f, 0 , 0,
18226 0x0 }, /* POOL32Axf_4~*(117) */
18227 { reserved_block , 0 , 0 , 32,
18228 0xfc00ffff, 0x2000ed3f, 0 , 0,
18229 0x0 }, /* POOL32Axf_4~*(118) */
18230 { reserved_block , 0 , 0 , 32,
18231 0xfc00ffff, 0x2000ef3f, 0 , 0,
18232 0x0 }, /* POOL32Axf_4~*(119) */
18233 { instruction , 0 , 0 , 32,
18234 0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB , 0,
18235 DSP_ }, /* RADDU.W.QB */
18236 { reserved_block , 0 , 0 , 32,
18237 0xfc00ffff, 0x2000f33f, 0 , 0,
18238 0x0 }, /* POOL32Axf_4~*(121) */
18239 { reserved_block , 0 , 0 , 32,
18240 0xfc00ffff, 0x2000f53f, 0 , 0,
18241 0x0 }, /* POOL32Axf_4~*(122) */
18242 { reserved_block , 0 , 0 , 32,
18243 0xfc00ffff, 0x2000f73f, 0 , 0,
18244 0x0 }, /* POOL32Axf_4~*(123) */
18245 { reserved_block , 0 , 0 , 32,
18246 0xfc00ffff, 0x2000f93f, 0 , 0,
18247 0x0 }, /* POOL32Axf_4~*(124) */
18248 { reserved_block , 0 , 0 , 32,
18249 0xfc00ffff, 0x2000fb3f, 0 , 0,
18250 0x0 }, /* POOL32Axf_4~*(125) */
18251 { reserved_block , 0 , 0 , 32,
18252 0xfc00ffff, 0x2000fd3f, 0 , 0,
18253 0x0 }, /* POOL32Axf_4~*(126) */
18254 { reserved_block , 0 , 0 , 32,
18255 0xfc00ffff, 0x2000ff3f, 0 , 0,
18256 0x0 }, /* POOL32Axf_4~*(127) */
18257};
18258
18259
18260NMD::Pool NMD::POOL32Axf_5_group0[32] = {
18261 { instruction , 0 , 0 , 32,
18262 0xfc00ffff, 0x2000017f, &NMD::TLBGP , 0,
18263 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18264 { instruction , 0 , 0 , 32,
18265 0xfc00ffff, 0x2000037f, &NMD::TLBP , 0,
18266 CP0_ | TLB_ }, /* TLBP */
18267 { instruction , 0 , 0 , 32,
18268 0xfc00ffff, 0x2000057f, &NMD::TLBGINV , 0,
18269 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18270 { instruction , 0 , 0 , 32,
18271 0xfc00ffff, 0x2000077f, &NMD::TLBINV , 0,
18272 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18273 { reserved_block , 0 , 0 , 32,
18274 0xfc00ffff, 0x2000097f, 0 , 0,
18275 0x0 }, /* POOL32Axf_5_group0~*(4) */
18276 { reserved_block , 0 , 0 , 32,
18277 0xfc00ffff, 0x20000b7f, 0 , 0,
18278 0x0 }, /* POOL32Axf_5_group0~*(5) */
18279 { reserved_block , 0 , 0 , 32,
18280 0xfc00ffff, 0x20000d7f, 0 , 0,
18281 0x0 }, /* POOL32Axf_5_group0~*(6) */
18282 { reserved_block , 0 , 0 , 32,
18283 0xfc00ffff, 0x20000f7f, 0 , 0,
18284 0x0 }, /* POOL32Axf_5_group0~*(7) */
18285 { instruction , 0 , 0 , 32,
18286 0xfc00ffff, 0x2000117f, &NMD::TLBGR , 0,
18287 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18288 { instruction , 0 , 0 , 32,
18289 0xfc00ffff, 0x2000137f, &NMD::TLBR , 0,
18290 CP0_ | TLB_ }, /* TLBR */
18291 { instruction , 0 , 0 , 32,
18292 0xfc00ffff, 0x2000157f, &NMD::TLBGINVF , 0,
18293 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18294 { instruction , 0 , 0 , 32,
18295 0xfc00ffff, 0x2000177f, &NMD::TLBINVF , 0,
18296 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18297 { reserved_block , 0 , 0 , 32,
18298 0xfc00ffff, 0x2000197f, 0 , 0,
18299 0x0 }, /* POOL32Axf_5_group0~*(12) */
18300 { reserved_block , 0 , 0 , 32,
18301 0xfc00ffff, 0x20001b7f, 0 , 0,
18302 0x0 }, /* POOL32Axf_5_group0~*(13) */
18303 { reserved_block , 0 , 0 , 32,
18304 0xfc00ffff, 0x20001d7f, 0 , 0,
18305 0x0 }, /* POOL32Axf_5_group0~*(14) */
18306 { reserved_block , 0 , 0 , 32,
18307 0xfc00ffff, 0x20001f7f, 0 , 0,
18308 0x0 }, /* POOL32Axf_5_group0~*(15) */
18309 { instruction , 0 , 0 , 32,
18310 0xfc00ffff, 0x2000217f, &NMD::TLBGWI , 0,
18311 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18312 { instruction , 0 , 0 , 32,
18313 0xfc00ffff, 0x2000237f, &NMD::TLBWI , 0,
18314 CP0_ | TLB_ }, /* TLBWI */
18315 { reserved_block , 0 , 0 , 32,
18316 0xfc00ffff, 0x2000257f, 0 , 0,
18317 0x0 }, /* POOL32Axf_5_group0~*(18) */
18318 { reserved_block , 0 , 0 , 32,
18319 0xfc00ffff, 0x2000277f, 0 , 0,
18320 0x0 }, /* POOL32Axf_5_group0~*(19) */
18321 { reserved_block , 0 , 0 , 32,
18322 0xfc00ffff, 0x2000297f, 0 , 0,
18323 0x0 }, /* POOL32Axf_5_group0~*(20) */
18324 { reserved_block , 0 , 0 , 32,
18325 0xfc00ffff, 0x20002b7f, 0 , 0,
18326 0x0 }, /* POOL32Axf_5_group0~*(21) */
18327 { reserved_block , 0 , 0 , 32,
18328 0xfc00ffff, 0x20002d7f, 0 , 0,
18329 0x0 }, /* POOL32Axf_5_group0~*(22) */
18330 { reserved_block , 0 , 0 , 32,
18331 0xfc00ffff, 0x20002f7f, 0 , 0,
18332 0x0 }, /* POOL32Axf_5_group0~*(23) */
18333 { instruction , 0 , 0 , 32,
18334 0xfc00ffff, 0x2000317f, &NMD::TLBGWR , 0,
18335 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18336 { instruction , 0 , 0 , 32,
18337 0xfc00ffff, 0x2000337f, &NMD::TLBWR , 0,
18338 CP0_ | TLB_ }, /* TLBWR */
18339 { reserved_block , 0 , 0 , 32,
18340 0xfc00ffff, 0x2000357f, 0 , 0,
18341 0x0 }, /* POOL32Axf_5_group0~*(26) */
18342 { reserved_block , 0 , 0 , 32,
18343 0xfc00ffff, 0x2000377f, 0 , 0,
18344 0x0 }, /* POOL32Axf_5_group0~*(27) */
18345 { reserved_block , 0 , 0 , 32,
18346 0xfc00ffff, 0x2000397f, 0 , 0,
18347 0x0 }, /* POOL32Axf_5_group0~*(28) */
18348 { reserved_block , 0 , 0 , 32,
18349 0xfc00ffff, 0x20003b7f, 0 , 0,
18350 0x0 }, /* POOL32Axf_5_group0~*(29) */
18351 { reserved_block , 0 , 0 , 32,
18352 0xfc00ffff, 0x20003d7f, 0 , 0,
18353 0x0 }, /* POOL32Axf_5_group0~*(30) */
18354 { reserved_block , 0 , 0 , 32,
18355 0xfc00ffff, 0x20003f7f, 0 , 0,
18356 0x0 }, /* POOL32Axf_5_group0~*(31) */
18357};
18358
18359
18360NMD::Pool NMD::POOL32Axf_5_group1[32] = {
18361 { reserved_block , 0 , 0 , 32,
18362 0xfc00ffff, 0x2000417f, 0 , 0,
18363 0x0 }, /* POOL32Axf_5_group1~*(0) */
18364 { reserved_block , 0 , 0 , 32,
18365 0xfc00ffff, 0x2000437f, 0 , 0,
18366 0x0 }, /* POOL32Axf_5_group1~*(1) */
18367 { reserved_block , 0 , 0 , 32,
18368 0xfc00ffff, 0x2000457f, 0 , 0,
18369 0x0 }, /* POOL32Axf_5_group1~*(2) */
18370 { instruction , 0 , 0 , 32,
18371 0xfc00ffff, 0x2000477f, &NMD::DI , 0,
18372 0x0 }, /* DI */
18373 { reserved_block , 0 , 0 , 32,
18374 0xfc00ffff, 0x2000497f, 0 , 0,
18375 0x0 }, /* POOL32Axf_5_group1~*(4) */
18376 { reserved_block , 0 , 0 , 32,
18377 0xfc00ffff, 0x20004b7f, 0 , 0,
18378 0x0 }, /* POOL32Axf_5_group1~*(5) */
18379 { reserved_block , 0 , 0 , 32,
18380 0xfc00ffff, 0x20004d7f, 0 , 0,
18381 0x0 }, /* POOL32Axf_5_group1~*(6) */
18382 { reserved_block , 0 , 0 , 32,
18383 0xfc00ffff, 0x20004f7f, 0 , 0,
18384 0x0 }, /* POOL32Axf_5_group1~*(7) */
18385 { reserved_block , 0 , 0 , 32,
18386 0xfc00ffff, 0x2000517f, 0 , 0,
18387 0x0 }, /* POOL32Axf_5_group1~*(8) */
18388 { reserved_block , 0 , 0 , 32,
18389 0xfc00ffff, 0x2000537f, 0 , 0,
18390 0x0 }, /* POOL32Axf_5_group1~*(9) */
18391 { reserved_block , 0 , 0 , 32,
18392 0xfc00ffff, 0x2000557f, 0 , 0,
18393 0x0 }, /* POOL32Axf_5_group1~*(10) */
18394 { instruction , 0 , 0 , 32,
18395 0xfc00ffff, 0x2000577f, &NMD::EI , 0,
18396 0x0 }, /* EI */
18397 { reserved_block , 0 , 0 , 32,
18398 0xfc00ffff, 0x2000597f, 0 , 0,
18399 0x0 }, /* POOL32Axf_5_group1~*(12) */
18400 { reserved_block , 0 , 0 , 32,
18401 0xfc00ffff, 0x20005b7f, 0 , 0,
18402 0x0 }, /* POOL32Axf_5_group1~*(13) */
18403 { reserved_block , 0 , 0 , 32,
18404 0xfc00ffff, 0x20005d7f, 0 , 0,
18405 0x0 }, /* POOL32Axf_5_group1~*(14) */
18406 { reserved_block , 0 , 0 , 32,
18407 0xfc00ffff, 0x20005f7f, 0 , 0,
18408 0x0 }, /* POOL32Axf_5_group1~*(15) */
18409 { reserved_block , 0 , 0 , 32,
18410 0xfc00ffff, 0x2000617f, 0 , 0,
18411 0x0 }, /* POOL32Axf_5_group1~*(16) */
18412 { reserved_block , 0 , 0 , 32,
18413 0xfc00ffff, 0x2000637f, 0 , 0,
18414 0x0 }, /* POOL32Axf_5_group1~*(17) */
18415 { reserved_block , 0 , 0 , 32,
18416 0xfc00ffff, 0x2000657f, 0 , 0,
18417 0x0 }, /* POOL32Axf_5_group1~*(18) */
18418 { reserved_block , 0 , 0 , 32,
18419 0xfc00ffff, 0x2000677f, 0 , 0,
18420 0x0 }, /* POOL32Axf_5_group1~*(19) */
18421 { reserved_block , 0 , 0 , 32,
18422 0xfc00ffff, 0x2000697f, 0 , 0,
18423 0x0 }, /* POOL32Axf_5_group1~*(20) */
18424 { reserved_block , 0 , 0 , 32,
18425 0xfc00ffff, 0x20006b7f, 0 , 0,
18426 0x0 }, /* POOL32Axf_5_group1~*(21) */
18427 { reserved_block , 0 , 0 , 32,
18428 0xfc00ffff, 0x20006d7f, 0 , 0,
18429 0x0 }, /* POOL32Axf_5_group1~*(22) */
18430 { reserved_block , 0 , 0 , 32,
18431 0xfc00ffff, 0x20006f7f, 0 , 0,
18432 0x0 }, /* POOL32Axf_5_group1~*(23) */
18433 { reserved_block , 0 , 0 , 32,
18434 0xfc00ffff, 0x2000717f, 0 , 0,
18435 0x0 }, /* POOL32Axf_5_group1~*(24) */
18436 { reserved_block , 0 , 0 , 32,
18437 0xfc00ffff, 0x2000737f, 0 , 0,
18438 0x0 }, /* POOL32Axf_5_group1~*(25) */
18439 { reserved_block , 0 , 0 , 32,
18440 0xfc00ffff, 0x2000757f, 0 , 0,
18441 0x0 }, /* POOL32Axf_5_group1~*(26) */
18442 { reserved_block , 0 , 0 , 32,
18443 0xfc00ffff, 0x2000777f, 0 , 0,
18444 0x0 }, /* POOL32Axf_5_group1~*(27) */
18445 { reserved_block , 0 , 0 , 32,
18446 0xfc00ffff, 0x2000797f, 0 , 0,
18447 0x0 }, /* POOL32Axf_5_group1~*(28) */
18448 { reserved_block , 0 , 0 , 32,
18449 0xfc00ffff, 0x20007b7f, 0 , 0,
18450 0x0 }, /* POOL32Axf_5_group1~*(29) */
18451 { reserved_block , 0 , 0 , 32,
18452 0xfc00ffff, 0x20007d7f, 0 , 0,
18453 0x0 }, /* POOL32Axf_5_group1~*(30) */
18454 { reserved_block , 0 , 0 , 32,
18455 0xfc00ffff, 0x20007f7f, 0 , 0,
18456 0x0 }, /* POOL32Axf_5_group1~*(31) */
18457};
18458
18459
18460NMD::Pool NMD::ERETx[2] = {
18461 { instruction , 0 , 0 , 32,
18462 0xfc01ffff, 0x2000f37f, &NMD::ERET , 0,
18463 0x0 }, /* ERET */
18464 { instruction , 0 , 0 , 32,
18465 0xfc01ffff, 0x2001f37f, &NMD::ERETNC , 0,
18466 0x0 }, /* ERETNC */
18467};
18468
18469
18470NMD::Pool NMD::POOL32Axf_5_group3[32] = {
18471 { reserved_block , 0 , 0 , 32,
18472 0xfc00ffff, 0x2000c17f, 0 , 0,
18473 0x0 }, /* POOL32Axf_5_group3~*(0) */
18474 { instruction , 0 , 0 , 32,
18475 0xfc00ffff, 0x2000c37f, &NMD::WAIT , 0,
18476 0x0 }, /* WAIT */
18477 { reserved_block , 0 , 0 , 32,
18478 0xfc00ffff, 0x2000c57f, 0 , 0,
18479 0x0 }, /* POOL32Axf_5_group3~*(2) */
18480 { reserved_block , 0 , 0 , 32,
18481 0xfc00ffff, 0x2000c77f, 0 , 0,
18482 0x0 }, /* POOL32Axf_5_group3~*(3) */
18483 { reserved_block , 0 , 0 , 32,
18484 0xfc00ffff, 0x2000c97f, 0 , 0,
18485 0x0 }, /* POOL32Axf_5_group3~*(4) */
18486 { reserved_block , 0 , 0 , 32,
18487 0xfc00ffff, 0x2000cb7f, 0 , 0,
18488 0x0 }, /* POOL32Axf_5_group3~*(5) */
18489 { reserved_block , 0 , 0 , 32,
18490 0xfc00ffff, 0x2000cd7f, 0 , 0,
18491 0x0 }, /* POOL32Axf_5_group3~*(6) */
18492 { reserved_block , 0 , 0 , 32,
18493 0xfc00ffff, 0x2000cf7f, 0 , 0,
18494 0x0 }, /* POOL32Axf_5_group3~*(7) */
18495 { reserved_block , 0 , 0 , 32,
18496 0xfc00ffff, 0x2000d17f, 0 , 0,
18497 0x0 }, /* POOL32Axf_5_group3~*(8) */
18498 { instruction , 0 , 0 , 32,
18499 0xfc00ffff, 0x2000d37f, &NMD::IRET , 0,
18500 MCU_ }, /* IRET */
18501 { reserved_block , 0 , 0 , 32,
18502 0xfc00ffff, 0x2000d57f, 0 , 0,
18503 0x0 }, /* POOL32Axf_5_group3~*(10) */
18504 { reserved_block , 0 , 0 , 32,
18505 0xfc00ffff, 0x2000d77f, 0 , 0,
18506 0x0 }, /* POOL32Axf_5_group3~*(11) */
18507 { reserved_block , 0 , 0 , 32,
18508 0xfc00ffff, 0x2000d97f, 0 , 0,
18509 0x0 }, /* POOL32Axf_5_group3~*(12) */
18510 { reserved_block , 0 , 0 , 32,
18511 0xfc00ffff, 0x2000db7f, 0 , 0,
18512 0x0 }, /* POOL32Axf_5_group3~*(13) */
18513 { reserved_block , 0 , 0 , 32,
18514 0xfc00ffff, 0x2000dd7f, 0 , 0,
18515 0x0 }, /* POOL32Axf_5_group3~*(14) */
18516 { reserved_block , 0 , 0 , 32,
18517 0xfc00ffff, 0x2000df7f, 0 , 0,
18518 0x0 }, /* POOL32Axf_5_group3~*(15) */
18519 { instruction , 0 , 0 , 32,
18520 0xfc00ffff, 0x2000e17f, &NMD::RDPGPR , 0,
18521 CP0_ }, /* RDPGPR */
18522 { instruction , 0 , 0 , 32,
18523 0xfc00ffff, 0x2000e37f, &NMD::DERET , 0,
18524 EJTAG_ }, /* DERET */
18525 { reserved_block , 0 , 0 , 32,
18526 0xfc00ffff, 0x2000e57f, 0 , 0,
18527 0x0 }, /* POOL32Axf_5_group3~*(18) */
18528 { reserved_block , 0 , 0 , 32,
18529 0xfc00ffff, 0x2000e77f, 0 , 0,
18530 0x0 }, /* POOL32Axf_5_group3~*(19) */
18531 { reserved_block , 0 , 0 , 32,
18532 0xfc00ffff, 0x2000e97f, 0 , 0,
18533 0x0 }, /* POOL32Axf_5_group3~*(20) */
18534 { reserved_block , 0 , 0 , 32,
18535 0xfc00ffff, 0x2000eb7f, 0 , 0,
18536 0x0 }, /* POOL32Axf_5_group3~*(21) */
18537 { reserved_block , 0 , 0 , 32,
18538 0xfc00ffff, 0x2000ed7f, 0 , 0,
18539 0x0 }, /* POOL32Axf_5_group3~*(22) */
18540 { reserved_block , 0 , 0 , 32,
18541 0xfc00ffff, 0x2000ef7f, 0 , 0,
18542 0x0 }, /* POOL32Axf_5_group3~*(23) */
18543 { instruction , 0 , 0 , 32,
18544 0xfc00ffff, 0x2000f17f, &NMD::WRPGPR , 0,
18545 CP0_ }, /* WRPGPR */
18546 { pool , ERETx , 2 , 32,
18547 0xfc00ffff, 0x2000f37f, 0 , 0,
18548 0x0 }, /* ERETx */
18549 { reserved_block , 0 , 0 , 32,
18550 0xfc00ffff, 0x2000f57f, 0 , 0,
18551 0x0 }, /* POOL32Axf_5_group3~*(26) */
18552 { reserved_block , 0 , 0 , 32,
18553 0xfc00ffff, 0x2000f77f, 0 , 0,
18554 0x0 }, /* POOL32Axf_5_group3~*(27) */
18555 { reserved_block , 0 , 0 , 32,
18556 0xfc00ffff, 0x2000f97f, 0 , 0,
18557 0x0 }, /* POOL32Axf_5_group3~*(28) */
18558 { reserved_block , 0 , 0 , 32,
18559 0xfc00ffff, 0x2000fb7f, 0 , 0,
18560 0x0 }, /* POOL32Axf_5_group3~*(29) */
18561 { reserved_block , 0 , 0 , 32,
18562 0xfc00ffff, 0x2000fd7f, 0 , 0,
18563 0x0 }, /* POOL32Axf_5_group3~*(30) */
18564 { reserved_block , 0 , 0 , 32,
18565 0xfc00ffff, 0x2000ff7f, 0 , 0,
18566 0x0 }, /* POOL32Axf_5_group3~*(31) */
18567};
18568
18569
18570NMD::Pool NMD::POOL32Axf_5[4] = {
18571 { pool , POOL32Axf_5_group0 , 32 , 32,
18572 0xfc00c1ff, 0x2000017f, 0 , 0,
18573 0x0 }, /* POOL32Axf_5_group0 */
18574 { pool , POOL32Axf_5_group1 , 32 , 32,
18575 0xfc00c1ff, 0x2000417f, 0 , 0,
18576 0x0 }, /* POOL32Axf_5_group1 */
18577 { reserved_block , 0 , 0 , 32,
18578 0xfc00c1ff, 0x2000817f, 0 , 0,
18579 0x0 }, /* POOL32Axf_5~*(2) */
18580 { pool , POOL32Axf_5_group3 , 32 , 32,
18581 0xfc00c1ff, 0x2000c17f, 0 , 0,
18582 0x0 }, /* POOL32Axf_5_group3 */
18583};
18584
18585
18586NMD::Pool NMD::SHRA__R__QB[2] = {
18587 { instruction , 0 , 0 , 32,
18588 0xfc001fff, 0x200001ff, &NMD::SHRA_QB , 0,
18589 DSP_ }, /* SHRA.QB */
18590 { instruction , 0 , 0 , 32,
18591 0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB , 0,
18592 DSP_ }, /* SHRA_R.QB */
18593};
18594
18595
18596NMD::Pool NMD::POOL32Axf_7[8] = {
18597 { pool , SHRA__R__QB , 2 , 32,
18598 0xfc000fff, 0x200001ff, 0 , 0,
18599 0x0 }, /* SHRA[_R].QB */
18600 { instruction , 0 , 0 , 32,
18601 0xfc000fff, 0x200003ff, &NMD::SHRL_PH , 0,
18602 DSP_ }, /* SHRL.PH */
18603 { instruction , 0 , 0 , 32,
18604 0xfc000fff, 0x200005ff, &NMD::REPL_QB , 0,
18605 DSP_ }, /* REPL.QB */
18606 { reserved_block , 0 , 0 , 32,
18607 0xfc000fff, 0x200007ff, 0 , 0,
18608 0x0 }, /* POOL32Axf_7~*(3) */
18609 { reserved_block , 0 , 0 , 32,
18610 0xfc000fff, 0x200009ff, 0 , 0,
18611 0x0 }, /* POOL32Axf_7~*(4) */
18612 { reserved_block , 0 , 0 , 32,
18613 0xfc000fff, 0x20000bff, 0 , 0,
18614 0x0 }, /* POOL32Axf_7~*(5) */
18615 { reserved_block , 0 , 0 , 32,
18616 0xfc000fff, 0x20000dff, 0 , 0,
18617 0x0 }, /* POOL32Axf_7~*(6) */
18618 { reserved_block , 0 , 0 , 32,
18619 0xfc000fff, 0x20000fff, 0 , 0,
18620 0x0 }, /* POOL32Axf_7~*(7) */
18621};
18622
18623
18624NMD::Pool NMD::POOL32Axf[8] = {
18625 { reserved_block , 0 , 0 , 32,
18626 0xfc0001ff, 0x2000003f, 0 , 0,
18627 0x0 }, /* POOL32Axf~*(0) */
18628 { pool , POOL32Axf_1 , 8 , 32,
18629 0xfc0001ff, 0x2000007f, 0 , 0,
18630 0x0 }, /* POOL32Axf_1 */
18631 { pool , POOL32Axf_2 , 4 , 32,
18632 0xfc0001ff, 0x200000bf, 0 , 0,
18633 0x0 }, /* POOL32Axf_2 */
18634 { reserved_block , 0 , 0 , 32,
18635 0xfc0001ff, 0x200000ff, 0 , 0,
18636 0x0 }, /* POOL32Axf~*(3) */
18637 { pool , POOL32Axf_4 , 128 , 32,
18638 0xfc0001ff, 0x2000013f, 0 , 0,
18639 0x0 }, /* POOL32Axf_4 */
18640 { pool , POOL32Axf_5 , 4 , 32,
18641 0xfc0001ff, 0x2000017f, 0 , 0,
18642 0x0 }, /* POOL32Axf_5 */
18643 { reserved_block , 0 , 0 , 32,
18644 0xfc0001ff, 0x200001bf, 0 , 0,
18645 0x0 }, /* POOL32Axf~*(6) */
18646 { pool , POOL32Axf_7 , 8 , 32,
18647 0xfc0001ff, 0x200001ff, 0 , 0,
18648 0x0 }, /* POOL32Axf_7 */
18649};
18650
18651
18652NMD::Pool NMD::_POOL32A7[8] = {
18653 { pool , P_LSX , 2 , 32,
18654 0xfc00003f, 0x20000007, 0 , 0,
18655 0x0 }, /* P.LSX */
18656 { instruction , 0 , 0 , 32,
18657 0xfc00003f, 0x2000000f, &NMD::LSA , 0,
18658 0x0 }, /* LSA */
18659 { reserved_block , 0 , 0 , 32,
18660 0xfc00003f, 0x20000017, 0 , 0,
18661 0x0 }, /* _POOL32A7~*(2) */
18662 { instruction , 0 , 0 , 32,
18663 0xfc00003f, 0x2000001f, &NMD::EXTW , 0,
18664 0x0 }, /* EXTW */
18665 { reserved_block , 0 , 0 , 32,
18666 0xfc00003f, 0x20000027, 0 , 0,
18667 0x0 }, /* _POOL32A7~*(4) */
18668 { reserved_block , 0 , 0 , 32,
18669 0xfc00003f, 0x2000002f, 0 , 0,
18670 0x0 }, /* _POOL32A7~*(5) */
18671 { reserved_block , 0 , 0 , 32,
18672 0xfc00003f, 0x20000037, 0 , 0,
18673 0x0 }, /* _POOL32A7~*(6) */
18674 { pool , POOL32Axf , 8 , 32,
18675 0xfc00003f, 0x2000003f, 0 , 0,
18676 0x0 }, /* POOL32Axf */
18677};
18678
18679
18680NMD::Pool NMD::P32A[8] = {
18681 { pool , _POOL32A0 , 128 , 32,
18682 0xfc000007, 0x20000000, 0 , 0,
18683 0x0 }, /* _POOL32A0 */
18684 { instruction , 0 , 0 , 32,
18685 0xfc000007, 0x20000001, &NMD::SPECIAL2 , 0,
18686 UDI_ }, /* SPECIAL2 */
18687 { instruction , 0 , 0 , 32,
18688 0xfc000007, 0x20000002, &NMD::COP2_1 , 0,
18689 CP2_ }, /* COP2_1 */
18690 { instruction , 0 , 0 , 32,
18691 0xfc000007, 0x20000003, &NMD::UDI , 0,
18692 UDI_ }, /* UDI */
18693 { reserved_block , 0 , 0 , 32,
18694 0xfc000007, 0x20000004, 0 , 0,
18695 0x0 }, /* P32A~*(4) */
18696 { pool , _POOL32A5 , 128 , 32,
18697 0xfc000007, 0x20000005, 0 , 0,
18698 0x0 }, /* _POOL32A5 */
18699 { reserved_block , 0 , 0 , 32,
18700 0xfc000007, 0x20000006, 0 , 0,
18701 0x0 }, /* P32A~*(6) */
18702 { pool , _POOL32A7 , 8 , 32,
18703 0xfc000007, 0x20000007, 0 , 0,
18704 0x0 }, /* _POOL32A7 */
18705};
18706
18707
18708NMD::Pool NMD::P_GP_D[2] = {
18709 { instruction , 0 , 0 , 32,
18710 0xfc000007, 0x40000001, &NMD::LD_GP_ , 0,
18711 MIPS64_ }, /* LD[GP] */
18712 { instruction , 0 , 0 , 32,
18713 0xfc000007, 0x40000005, &NMD::SD_GP_ , 0,
18714 MIPS64_ }, /* SD[GP] */
18715};
18716
18717
18718NMD::Pool NMD::P_GP_W[4] = {
18719 { instruction , 0 , 0 , 32,
18720 0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_ , 0,
18721 0x0 }, /* ADDIU[GP.W] */
18722 { pool , P_GP_D , 2 , 32,
18723 0xfc000003, 0x40000001, 0 , 0,
18724 0x0 }, /* P.GP.D */
18725 { instruction , 0 , 0 , 32,
18726 0xfc000003, 0x40000002, &NMD::LW_GP_ , 0,
18727 0x0 }, /* LW[GP] */
18728 { instruction , 0 , 0 , 32,
18729 0xfc000003, 0x40000003, &NMD::SW_GP_ , 0,
18730 0x0 }, /* SW[GP] */
18731};
18732
18733
18734NMD::Pool NMD::POOL48I[32] = {
18735 { instruction , 0 , 0 , 48,
18736 0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_ , 0,
18737 XMMS_ }, /* LI[48] */
18738 { instruction , 0 , 0 , 48,
18739 0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_ , 0,
18740 XMMS_ }, /* ADDIU[48] */
18741 { instruction , 0 , 0 , 48,
18742 0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_ , 0,
18743 XMMS_ }, /* ADDIU[GP48] */
18744 { instruction , 0 , 0 , 48,
18745 0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_ , 0,
18746 XMMS_ }, /* ADDIUPC[48] */
18747 { reserved_block , 0 , 0 , 48,
18748 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18749 0x0 }, /* POOL48I~*(4) */
18750 { reserved_block , 0 , 0 , 48,
18751 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18752 0x0 }, /* POOL48I~*(5) */
18753 { reserved_block , 0 , 0 , 48,
18754 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18755 0x0 }, /* POOL48I~*(6) */
18756 { reserved_block , 0 , 0 , 48,
18757 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18758 0x0 }, /* POOL48I~*(7) */
18759 { reserved_block , 0 , 0 , 48,
18760 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18761 0x0 }, /* POOL48I~*(8) */
18762 { reserved_block , 0 , 0 , 48,
18763 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18764 0x0 }, /* POOL48I~*(9) */
18765 { reserved_block , 0 , 0 , 48,
18766 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18767 0x0 }, /* POOL48I~*(10) */
18768 { instruction , 0 , 0 , 48,
18769 0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_ , 0,
18770 XMMS_ }, /* LWPC[48] */
18771 { reserved_block , 0 , 0 , 48,
18772 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18773 0x0 }, /* POOL48I~*(12) */
18774 { reserved_block , 0 , 0 , 48,
18775 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18776 0x0 }, /* POOL48I~*(13) */
18777 { reserved_block , 0 , 0 , 48,
18778 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18779 0x0 }, /* POOL48I~*(14) */
18780 { instruction , 0 , 0 , 48,
18781 0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_ , 0,
18782 XMMS_ }, /* SWPC[48] */
18783 { reserved_block , 0 , 0 , 48,
18784 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18785 0x0 }, /* POOL48I~*(16) */
18786 { instruction , 0 , 0 , 48,
18787 0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_ , 0,
18788 MIPS64_ }, /* DADDIU[48] */
18789 { reserved_block , 0 , 0 , 48,
18790 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18791 0x0 }, /* POOL48I~*(18) */
18792 { reserved_block , 0 , 0 , 48,
18793 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18794 0x0 }, /* POOL48I~*(19) */
18795 { instruction , 0 , 0 , 48,
18796 0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_ , 0,
18797 MIPS64_ }, /* DLUI[48] */
18798 { reserved_block , 0 , 0 , 48,
18799 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18800 0x0 }, /* POOL48I~*(21) */
18801 { reserved_block , 0 , 0 , 48,
18802 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18803 0x0 }, /* POOL48I~*(22) */
18804 { reserved_block , 0 , 0 , 48,
18805 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18806 0x0 }, /* POOL48I~*(23) */
18807 { reserved_block , 0 , 0 , 48,
18808 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18809 0x0 }, /* POOL48I~*(24) */
18810 { reserved_block , 0 , 0 , 48,
18811 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18812 0x0 }, /* POOL48I~*(25) */
18813 { reserved_block , 0 , 0 , 48,
18814 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18815 0x0 }, /* POOL48I~*(26) */
18816 { instruction , 0 , 0 , 48,
18817 0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_ , 0,
18818 MIPS64_ }, /* LDPC[48] */
18819 { reserved_block , 0 , 0 , 48,
18820 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18821 0x0 }, /* POOL48I~*(28) */
18822 { reserved_block , 0 , 0 , 48,
18823 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18824 0x0 }, /* POOL48I~*(29) */
18825 { reserved_block , 0 , 0 , 48,
18826 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18827 0x0 }, /* POOL48I~*(30) */
18828 { instruction , 0 , 0 , 48,
18829 0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_ , 0,
18830 MIPS64_ }, /* SDPC[48] */
18831};
18832
18833
18834NMD::Pool NMD::PP_SR[4] = {
18835 { instruction , 0 , 0 , 32,
18836 0xfc10f003, 0x80003000, &NMD::SAVE_32_ , 0,
18837 0x0 }, /* SAVE[32] */
18838 { reserved_block , 0 , 0 , 32,
18839 0xfc10f003, 0x80003001, 0 , 0,
18840 0x0 }, /* PP.SR~*(1) */
18841 { instruction , 0 , 0 , 32,
18842 0xfc10f003, 0x80003002, &NMD::RESTORE_32_ , 0,
18843 0x0 }, /* RESTORE[32] */
18844 { return_instruction , 0 , 0 , 32,
18845 0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_ , 0,
18846 0x0 }, /* RESTORE.JRC[32] */
18847};
18848
18849
18850NMD::Pool NMD::P_SR_F[8] = {
18851 { instruction , 0 , 0 , 32,
18852 0xfc10f007, 0x80103000, &NMD::SAVEF , 0,
18853 CP1_ }, /* SAVEF */
18854 { instruction , 0 , 0 , 32,
18855 0xfc10f007, 0x80103001, &NMD::RESTOREF , 0,
18856 CP1_ }, /* RESTOREF */
18857 { reserved_block , 0 , 0 , 32,
18858 0xfc10f007, 0x80103002, 0 , 0,
18859 0x0 }, /* P.SR.F~*(2) */
18860 { reserved_block , 0 , 0 , 32,
18861 0xfc10f007, 0x80103003, 0 , 0,
18862 0x0 }, /* P.SR.F~*(3) */
18863 { reserved_block , 0 , 0 , 32,
18864 0xfc10f007, 0x80103004, 0 , 0,
18865 0x0 }, /* P.SR.F~*(4) */
18866 { reserved_block , 0 , 0 , 32,
18867 0xfc10f007, 0x80103005, 0 , 0,
18868 0x0 }, /* P.SR.F~*(5) */
18869 { reserved_block , 0 , 0 , 32,
18870 0xfc10f007, 0x80103006, 0 , 0,
18871 0x0 }, /* P.SR.F~*(6) */
18872 { reserved_block , 0 , 0 , 32,
18873 0xfc10f007, 0x80103007, 0 , 0,
18874 0x0 }, /* P.SR.F~*(7) */
18875};
18876
18877
18878NMD::Pool NMD::P_SR[2] = {
18879 { pool , PP_SR , 4 , 32,
18880 0xfc10f000, 0x80003000, 0 , 0,
18881 0x0 }, /* PP.SR */
18882 { pool , P_SR_F , 8 , 32,
18883 0xfc10f000, 0x80103000, 0 , 0,
18884 0x0 }, /* P.SR.F */
18885};
18886
18887
18888NMD::Pool NMD::P_SLL[5] = {
18889 { instruction , 0 , 0 , 32,
18890 0xffe0f1ff, 0x8000c000, &NMD::NOP_32_ , 0,
18891 0x0 }, /* NOP[32] */
18892 { instruction , 0 , 0 , 32,
18893 0xffe0f1ff, 0x8000c003, &NMD::EHB , 0,
18894 0x0 }, /* EHB */
18895 { instruction , 0 , 0 , 32,
18896 0xffe0f1ff, 0x8000c005, &NMD::PAUSE , 0,
18897 0x0 }, /* PAUSE */
18898 { instruction , 0 , 0 , 32,
18899 0xffe0f1ff, 0x8000c006, &NMD::SYNC , 0,
18900 0x0 }, /* SYNC */
18901 { instruction , 0 , 0 , 32,
18902 0xfc00f1e0, 0x8000c000, &NMD::SLL_32_ , 0,
18903 0x0 }, /* SLL[32] */
18904};
18905
18906
18907NMD::Pool NMD::P_SHIFT[16] = {
18908 { pool , P_SLL , 5 , 32,
18909 0xfc00f1e0, 0x8000c000, 0 , 0,
18910 0x0 }, /* P.SLL */
18911 { reserved_block , 0 , 0 , 32,
18912 0xfc00f1e0, 0x8000c020, 0 , 0,
18913 0x0 }, /* P.SHIFT~*(1) */
18914 { instruction , 0 , 0 , 32,
18915 0xfc00f1e0, 0x8000c040, &NMD::SRL_32_ , 0,
18916 0x0 }, /* SRL[32] */
18917 { reserved_block , 0 , 0 , 32,
18918 0xfc00f1e0, 0x8000c060, 0 , 0,
18919 0x0 }, /* P.SHIFT~*(3) */
18920 { instruction , 0 , 0 , 32,
18921 0xfc00f1e0, 0x8000c080, &NMD::SRA , 0,
18922 0x0 }, /* SRA */
18923 { reserved_block , 0 , 0 , 32,
18924 0xfc00f1e0, 0x8000c0a0, 0 , 0,
18925 0x0 }, /* P.SHIFT~*(5) */
18926 { instruction , 0 , 0 , 32,
18927 0xfc00f1e0, 0x8000c0c0, &NMD::ROTR , 0,
18928 0x0 }, /* ROTR */
18929 { reserved_block , 0 , 0 , 32,
18930 0xfc00f1e0, 0x8000c0e0, 0 , 0,
18931 0x0 }, /* P.SHIFT~*(7) */
18932 { instruction , 0 , 0 , 32,
18933 0xfc00f1e0, 0x8000c100, &NMD::DSLL , 0,
18934 MIPS64_ }, /* DSLL */
18935 { instruction , 0 , 0 , 32,
18936 0xfc00f1e0, 0x8000c120, &NMD::DSLL32 , 0,
18937 MIPS64_ }, /* DSLL32 */
18938 { instruction , 0 , 0 , 32,
18939 0xfc00f1e0, 0x8000c140, &NMD::DSRL , 0,
18940 MIPS64_ }, /* DSRL */
18941 { instruction , 0 , 0 , 32,
18942 0xfc00f1e0, 0x8000c160, &NMD::DSRL32 , 0,
18943 MIPS64_ }, /* DSRL32 */
18944 { instruction , 0 , 0 , 32,
18945 0xfc00f1e0, 0x8000c180, &NMD::DSRA , 0,
18946 MIPS64_ }, /* DSRA */
18947 { instruction , 0 , 0 , 32,
18948 0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32 , 0,
18949 MIPS64_ }, /* DSRA32 */
18950 { instruction , 0 , 0 , 32,
18951 0xfc00f1e0, 0x8000c1c0, &NMD::DROTR , 0,
18952 MIPS64_ }, /* DROTR */
18953 { instruction , 0 , 0 , 32,
18954 0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32 , 0,
18955 MIPS64_ }, /* DROTR32 */
18956};
18957
18958
18959NMD::Pool NMD::P_ROTX[4] = {
18960 { instruction , 0 , 0 , 32,
18961 0xfc00f820, 0x8000d000, &NMD::ROTX , 0,
18962 XMMS_ }, /* ROTX */
18963 { reserved_block , 0 , 0 , 32,
18964 0xfc00f820, 0x8000d020, 0 , 0,
18965 0x0 }, /* P.ROTX~*(1) */
18966 { reserved_block , 0 , 0 , 32,
18967 0xfc00f820, 0x8000d800, 0 , 0,
18968 0x0 }, /* P.ROTX~*(2) */
18969 { reserved_block , 0 , 0 , 32,
18970 0xfc00f820, 0x8000d820, 0 , 0,
18971 0x0 }, /* P.ROTX~*(3) */
18972};
18973
18974
18975NMD::Pool NMD::P_INS[4] = {
18976 { instruction , 0 , 0 , 32,
18977 0xfc00f820, 0x8000e000, &NMD::INS , 0,
18978 XMMS_ }, /* INS */
18979 { instruction , 0 , 0 , 32,
18980 0xfc00f820, 0x8000e020, &NMD::DINSU , 0,
18981 MIPS64_ }, /* DINSU */
18982 { instruction , 0 , 0 , 32,
18983 0xfc00f820, 0x8000e800, &NMD::DINSM , 0,
18984 MIPS64_ }, /* DINSM */
18985 { instruction , 0 , 0 , 32,
18986 0xfc00f820, 0x8000e820, &NMD::DINS , 0,
18987 MIPS64_ }, /* DINS */
18988};
18989
18990
18991NMD::Pool NMD::P_EXT[4] = {
18992 { instruction , 0 , 0 , 32,
18993 0xfc00f820, 0x8000f000, &NMD::EXT , 0,
18994 XMMS_ }, /* EXT */
18995 { instruction , 0 , 0 , 32,
18996 0xfc00f820, 0x8000f020, &NMD::DEXTU , 0,
18997 MIPS64_ }, /* DEXTU */
18998 { instruction , 0 , 0 , 32,
18999 0xfc00f820, 0x8000f800, &NMD::DEXTM , 0,
19000 MIPS64_ }, /* DEXTM */
19001 { instruction , 0 , 0 , 32,
19002 0xfc00f820, 0x8000f820, &NMD::DEXT , 0,
19003 MIPS64_ }, /* DEXT */
19004};
19005
19006
19007NMD::Pool NMD::P_U12[16] = {
19008 { instruction , 0 , 0 , 32,
19009 0xfc00f000, 0x80000000, &NMD::ORI , 0,
19010 0x0 }, /* ORI */
19011 { instruction , 0 , 0 , 32,
19012 0xfc00f000, 0x80001000, &NMD::XORI , 0,
19013 0x0 }, /* XORI */
19014 { instruction , 0 , 0 , 32,
19015 0xfc00f000, 0x80002000, &NMD::ANDI_32_ , 0,
19016 0x0 }, /* ANDI[32] */
19017 { pool , P_SR , 2 , 32,
19018 0xfc00f000, 0x80003000, 0 , 0,
19019 0x0 }, /* P.SR */
19020 { instruction , 0 , 0 , 32,
19021 0xfc00f000, 0x80004000, &NMD::SLTI , 0,
19022 0x0 }, /* SLTI */
19023 { instruction , 0 , 0 , 32,
19024 0xfc00f000, 0x80005000, &NMD::SLTIU , 0,
19025 0x0 }, /* SLTIU */
19026 { instruction , 0 , 0 , 32,
19027 0xfc00f000, 0x80006000, &NMD::SEQI , 0,
19028 0x0 }, /* SEQI */
19029 { reserved_block , 0 , 0 , 32,
19030 0xfc00f000, 0x80007000, 0 , 0,
19031 0x0 }, /* P.U12~*(7) */
19032 { instruction , 0 , 0 , 32,
19033 0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_ , 0,
19034 0x0 }, /* ADDIU[NEG] */
19035 { instruction , 0 , 0 , 32,
19036 0xfc00f000, 0x80009000, &NMD::DADDIU_U12_ , 0,
19037 MIPS64_ }, /* DADDIU[U12] */
19038 { instruction , 0 , 0 , 32,
19039 0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_ , 0,
19040 MIPS64_ }, /* DADDIU[NEG] */
19041 { instruction , 0 , 0 , 32,
19042 0xfc00f000, 0x8000b000, &NMD::DROTX , 0,
19043 MIPS64_ }, /* DROTX */
19044 { pool , P_SHIFT , 16 , 32,
19045 0xfc00f000, 0x8000c000, 0 , 0,
19046 0x0 }, /* P.SHIFT */
19047 { pool , P_ROTX , 4 , 32,
19048 0xfc00f000, 0x8000d000, 0 , 0,
19049 0x0 }, /* P.ROTX */
19050 { pool , P_INS , 4 , 32,
19051 0xfc00f000, 0x8000e000, 0 , 0,
19052 0x0 }, /* P.INS */
19053 { pool , P_EXT , 4 , 32,
19054 0xfc00f000, 0x8000f000, 0 , 0,
19055 0x0 }, /* P.EXT */
19056};
19057
19058
19059NMD::Pool NMD::RINT_fmt[2] = {
19060 { instruction , 0 , 0 , 32,
19061 0xfc0003ff, 0xa0000020, &NMD::RINT_S , 0,
19062 CP1_ }, /* RINT.S */
19063 { instruction , 0 , 0 , 32,
19064 0xfc0003ff, 0xa0000220, &NMD::RINT_D , 0,
19065 CP1_ }, /* RINT.D */
19066};
19067
19068
19069NMD::Pool NMD::ADD_fmt0[2] = {
19070 { instruction , 0 , 0 , 32,
19071 0xfc0003ff, 0xa0000030, &NMD::ADD_S , 0,
19072 CP1_ }, /* ADD.S */
19073 { reserved_block , 0 , 0 , 32,
19074 0xfc0003ff, 0xa0000230, 0 , 0,
19075 CP1_ }, /* ADD.fmt0~*(1) */
19076};
19077
19078
19079NMD::Pool NMD::SELEQZ_fmt[2] = {
19080 { instruction , 0 , 0 , 32,
19081 0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S , 0,
19082 CP1_ }, /* SELEQZ.S */
19083 { instruction , 0 , 0 , 32,
19084 0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D , 0,
19085 CP1_ }, /* SELEQZ.D */
19086};
19087
19088
19089NMD::Pool NMD::CLASS_fmt[2] = {
19090 { instruction , 0 , 0 , 32,
19091 0xfc0003ff, 0xa0000060, &NMD::CLASS_S , 0,
19092 CP1_ }, /* CLASS.S */
19093 { instruction , 0 , 0 , 32,
19094 0xfc0003ff, 0xa0000260, &NMD::CLASS_D , 0,
19095 CP1_ }, /* CLASS.D */
19096};
19097
19098
19099NMD::Pool NMD::SUB_fmt0[2] = {
19100 { instruction , 0 , 0 , 32,
19101 0xfc0003ff, 0xa0000070, &NMD::SUB_S , 0,
19102 CP1_ }, /* SUB.S */
19103 { reserved_block , 0 , 0 , 32,
19104 0xfc0003ff, 0xa0000270, 0 , 0,
19105 CP1_ }, /* SUB.fmt0~*(1) */
19106};
19107
19108
19109NMD::Pool NMD::SELNEZ_fmt[2] = {
19110 { instruction , 0 , 0 , 32,
19111 0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S , 0,
19112 CP1_ }, /* SELNEZ.S */
19113 { instruction , 0 , 0 , 32,
19114 0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D , 0,
19115 CP1_ }, /* SELNEZ.D */
19116};
19117
19118
19119NMD::Pool NMD::MUL_fmt0[2] = {
19120 { instruction , 0 , 0 , 32,
19121 0xfc0003ff, 0xa00000b0, &NMD::MUL_S , 0,
19122 CP1_ }, /* MUL.S */
19123 { reserved_block , 0 , 0 , 32,
19124 0xfc0003ff, 0xa00002b0, 0 , 0,
19125 CP1_ }, /* MUL.fmt0~*(1) */
19126};
19127
19128
19129NMD::Pool NMD::SEL_fmt[2] = {
19130 { instruction , 0 , 0 , 32,
19131 0xfc0003ff, 0xa00000b8, &NMD::SEL_S , 0,
19132 CP1_ }, /* SEL.S */
19133 { instruction , 0 , 0 , 32,
19134 0xfc0003ff, 0xa00002b8, &NMD::SEL_D , 0,
19135 CP1_ }, /* SEL.D */
19136};
19137
19138
19139NMD::Pool NMD::DIV_fmt0[2] = {
19140 { instruction , 0 , 0 , 32,
19141 0xfc0003ff, 0xa00000f0, &NMD::DIV_S , 0,
19142 CP1_ }, /* DIV.S */
19143 { reserved_block , 0 , 0 , 32,
19144 0xfc0003ff, 0xa00002f0, 0 , 0,
19145 CP1_ }, /* DIV.fmt0~*(1) */
19146};
19147
19148
19149NMD::Pool NMD::ADD_fmt1[2] = {
19150 { instruction , 0 , 0 , 32,
19151 0xfc0003ff, 0xa0000130, &NMD::ADD_D , 0,
19152 CP1_ }, /* ADD.D */
19153 { reserved_block , 0 , 0 , 32,
19154 0xfc0003ff, 0xa0000330, 0 , 0,
19155 CP1_ }, /* ADD.fmt1~*(1) */
19156};
19157
19158
19159NMD::Pool NMD::SUB_fmt1[2] = {
19160 { instruction , 0 , 0 , 32,
19161 0xfc0003ff, 0xa0000170, &NMD::SUB_D , 0,
19162 CP1_ }, /* SUB.D */
19163 { reserved_block , 0 , 0 , 32,
19164 0xfc0003ff, 0xa0000370, 0 , 0,
19165 CP1_ }, /* SUB.fmt1~*(1) */
19166};
19167
19168
19169NMD::Pool NMD::MUL_fmt1[2] = {
19170 { instruction , 0 , 0 , 32,
19171 0xfc0003ff, 0xa00001b0, &NMD::MUL_D , 0,
19172 CP1_ }, /* MUL.D */
19173 { reserved_block , 0 , 0 , 32,
19174 0xfc0003ff, 0xa00003b0, 0 , 0,
19175 CP1_ }, /* MUL.fmt1~*(1) */
19176};
19177
19178
19179NMD::Pool NMD::MADDF_fmt[2] = {
19180 { instruction , 0 , 0 , 32,
19181 0xfc0003ff, 0xa00001b8, &NMD::MADDF_S , 0,
19182 CP1_ }, /* MADDF.S */
19183 { instruction , 0 , 0 , 32,
19184 0xfc0003ff, 0xa00003b8, &NMD::MADDF_D , 0,
19185 CP1_ }, /* MADDF.D */
19186};
19187
19188
19189NMD::Pool NMD::DIV_fmt1[2] = {
19190 { instruction , 0 , 0 , 32,
19191 0xfc0003ff, 0xa00001f0, &NMD::DIV_D , 0,
19192 CP1_ }, /* DIV.D */
19193 { reserved_block , 0 , 0 , 32,
19194 0xfc0003ff, 0xa00003f0, 0 , 0,
19195 CP1_ }, /* DIV.fmt1~*(1) */
19196};
19197
19198
19199NMD::Pool NMD::MSUBF_fmt[2] = {
19200 { instruction , 0 , 0 , 32,
19201 0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S , 0,
19202 CP1_ }, /* MSUBF.S */
19203 { instruction , 0 , 0 , 32,
19204 0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D , 0,
19205 CP1_ }, /* MSUBF.D */
19206};
19207
19208
19209NMD::Pool NMD::POOL32F_0[64] = {
19210 { reserved_block , 0 , 0 , 32,
19211 0xfc0001ff, 0xa0000000, 0 , 0,
19212 CP1_ }, /* POOL32F_0~*(0) */
19213 { reserved_block , 0 , 0 , 32,
19214 0xfc0001ff, 0xa0000008, 0 , 0,
19215 CP1_ }, /* POOL32F_0~*(1) */
19216 { reserved_block , 0 , 0 , 32,
19217 0xfc0001ff, 0xa0000010, 0 , 0,
19218 CP1_ }, /* POOL32F_0~*(2) */
19219 { reserved_block , 0 , 0 , 32,
19220 0xfc0001ff, 0xa0000018, 0 , 0,
19221 CP1_ }, /* POOL32F_0~*(3) */
19222 { pool , RINT_fmt , 2 , 32,
19223 0xfc0001ff, 0xa0000020, 0 , 0,
19224 CP1_ }, /* RINT.fmt */
19225 { reserved_block , 0 , 0 , 32,
19226 0xfc0001ff, 0xa0000028, 0 , 0,
19227 CP1_ }, /* POOL32F_0~*(5) */
19228 { pool , ADD_fmt0 , 2 , 32,
19229 0xfc0001ff, 0xa0000030, 0 , 0,
19230 CP1_ }, /* ADD.fmt0 */
19231 { pool , SELEQZ_fmt , 2 , 32,
19232 0xfc0001ff, 0xa0000038, 0 , 0,
19233 CP1_ }, /* SELEQZ.fmt */
19234 { reserved_block , 0 , 0 , 32,
19235 0xfc0001ff, 0xa0000040, 0 , 0,
19236 CP1_ }, /* POOL32F_0~*(8) */
19237 { reserved_block , 0 , 0 , 32,
19238 0xfc0001ff, 0xa0000048, 0 , 0,
19239 CP1_ }, /* POOL32F_0~*(9) */
19240 { reserved_block , 0 , 0 , 32,
19241 0xfc0001ff, 0xa0000050, 0 , 0,
19242 CP1_ }, /* POOL32F_0~*(10) */
19243 { reserved_block , 0 , 0 , 32,
19244 0xfc0001ff, 0xa0000058, 0 , 0,
19245 CP1_ }, /* POOL32F_0~*(11) */
19246 { pool , CLASS_fmt , 2 , 32,
19247 0xfc0001ff, 0xa0000060, 0 , 0,
19248 CP1_ }, /* CLASS.fmt */
19249 { reserved_block , 0 , 0 , 32,
19250 0xfc0001ff, 0xa0000068, 0 , 0,
19251 CP1_ }, /* POOL32F_0~*(13) */
19252 { pool , SUB_fmt0 , 2 , 32,
19253 0xfc0001ff, 0xa0000070, 0 , 0,
19254 CP1_ }, /* SUB.fmt0 */
19255 { pool , SELNEZ_fmt , 2 , 32,
19256 0xfc0001ff, 0xa0000078, 0 , 0,
19257 CP1_ }, /* SELNEZ.fmt */
19258 { reserved_block , 0 , 0 , 32,
19259 0xfc0001ff, 0xa0000080, 0 , 0,
19260 CP1_ }, /* POOL32F_0~*(16) */
19261 { reserved_block , 0 , 0 , 32,
19262 0xfc0001ff, 0xa0000088, 0 , 0,
19263 CP1_ }, /* POOL32F_0~*(17) */
19264 { reserved_block , 0 , 0 , 32,
19265 0xfc0001ff, 0xa0000090, 0 , 0,
19266 CP1_ }, /* POOL32F_0~*(18) */
19267 { reserved_block , 0 , 0 , 32,
19268 0xfc0001ff, 0xa0000098, 0 , 0,
19269 CP1_ }, /* POOL32F_0~*(19) */
19270 { reserved_block , 0 , 0 , 32,
19271 0xfc0001ff, 0xa00000a0, 0 , 0,
19272 CP1_ }, /* POOL32F_0~*(20) */
19273 { reserved_block , 0 , 0 , 32,
19274 0xfc0001ff, 0xa00000a8, 0 , 0,
19275 CP1_ }, /* POOL32F_0~*(21) */
19276 { pool , MUL_fmt0 , 2 , 32,
19277 0xfc0001ff, 0xa00000b0, 0 , 0,
19278 CP1_ }, /* MUL.fmt0 */
19279 { pool , SEL_fmt , 2 , 32,
19280 0xfc0001ff, 0xa00000b8, 0 , 0,
19281 CP1_ }, /* SEL.fmt */
19282 { reserved_block , 0 , 0 , 32,
19283 0xfc0001ff, 0xa00000c0, 0 , 0,
19284 CP1_ }, /* POOL32F_0~*(24) */
19285 { reserved_block , 0 , 0 , 32,
19286 0xfc0001ff, 0xa00000c8, 0 , 0,
19287 CP1_ }, /* POOL32F_0~*(25) */
19288 { reserved_block , 0 , 0 , 32,
19289 0xfc0001ff, 0xa00000d0, 0 , 0,
19290 CP1_ }, /* POOL32F_0~*(26) */
19291 { reserved_block , 0 , 0 , 32,
19292 0xfc0001ff, 0xa00000d8, 0 , 0,
19293 CP1_ }, /* POOL32F_0~*(27) */
19294 { reserved_block , 0 , 0 , 32,
19295 0xfc0001ff, 0xa00000e0, 0 , 0,
19296 CP1_ }, /* POOL32F_0~*(28) */
19297 { reserved_block , 0 , 0 , 32,
19298 0xfc0001ff, 0xa00000e8, 0 , 0,
19299 CP1_ }, /* POOL32F_0~*(29) */
19300 { pool , DIV_fmt0 , 2 , 32,
19301 0xfc0001ff, 0xa00000f0, 0 , 0,
19302 CP1_ }, /* DIV.fmt0 */
19303 { reserved_block , 0 , 0 , 32,
19304 0xfc0001ff, 0xa00000f8, 0 , 0,
19305 CP1_ }, /* POOL32F_0~*(31) */
19306 { reserved_block , 0 , 0 , 32,
19307 0xfc0001ff, 0xa0000100, 0 , 0,
19308 CP1_ }, /* POOL32F_0~*(32) */
19309 { reserved_block , 0 , 0 , 32,
19310 0xfc0001ff, 0xa0000108, 0 , 0,
19311 CP1_ }, /* POOL32F_0~*(33) */
19312 { reserved_block , 0 , 0 , 32,
19313 0xfc0001ff, 0xa0000110, 0 , 0,
19314 CP1_ }, /* POOL32F_0~*(34) */
19315 { reserved_block , 0 , 0 , 32,
19316 0xfc0001ff, 0xa0000118, 0 , 0,
19317 CP1_ }, /* POOL32F_0~*(35) */
19318 { reserved_block , 0 , 0 , 32,
19319 0xfc0001ff, 0xa0000120, 0 , 0,
19320 CP1_ }, /* POOL32F_0~*(36) */
19321 { reserved_block , 0 , 0 , 32,
19322 0xfc0001ff, 0xa0000128, 0 , 0,
19323 CP1_ }, /* POOL32F_0~*(37) */
19324 { pool , ADD_fmt1 , 2 , 32,
19325 0xfc0001ff, 0xa0000130, 0 , 0,
19326 CP1_ }, /* ADD.fmt1 */
19327 { reserved_block , 0 , 0 , 32,
19328 0xfc0001ff, 0xa0000138, 0 , 0,
19329 CP1_ }, /* POOL32F_0~*(39) */
19330 { reserved_block , 0 , 0 , 32,
19331 0xfc0001ff, 0xa0000140, 0 , 0,
19332 CP1_ }, /* POOL32F_0~*(40) */
19333 { reserved_block , 0 , 0 , 32,
19334 0xfc0001ff, 0xa0000148, 0 , 0,
19335 CP1_ }, /* POOL32F_0~*(41) */
19336 { reserved_block , 0 , 0 , 32,
19337 0xfc0001ff, 0xa0000150, 0 , 0,
19338 CP1_ }, /* POOL32F_0~*(42) */
19339 { reserved_block , 0 , 0 , 32,
19340 0xfc0001ff, 0xa0000158, 0 , 0,
19341 CP1_ }, /* POOL32F_0~*(43) */
19342 { reserved_block , 0 , 0 , 32,
19343 0xfc0001ff, 0xa0000160, 0 , 0,
19344 CP1_ }, /* POOL32F_0~*(44) */
19345 { reserved_block , 0 , 0 , 32,
19346 0xfc0001ff, 0xa0000168, 0 , 0,
19347 CP1_ }, /* POOL32F_0~*(45) */
19348 { pool , SUB_fmt1 , 2 , 32,
19349 0xfc0001ff, 0xa0000170, 0 , 0,
19350 CP1_ }, /* SUB.fmt1 */
19351 { reserved_block , 0 , 0 , 32,
19352 0xfc0001ff, 0xa0000178, 0 , 0,
19353 CP1_ }, /* POOL32F_0~*(47) */
19354 { reserved_block , 0 , 0 , 32,
19355 0xfc0001ff, 0xa0000180, 0 , 0,
19356 CP1_ }, /* POOL32F_0~*(48) */
19357 { reserved_block , 0 , 0 , 32,
19358 0xfc0001ff, 0xa0000188, 0 , 0,
19359 CP1_ }, /* POOL32F_0~*(49) */
19360 { reserved_block , 0 , 0 , 32,
19361 0xfc0001ff, 0xa0000190, 0 , 0,
19362 CP1_ }, /* POOL32F_0~*(50) */
19363 { reserved_block , 0 , 0 , 32,
19364 0xfc0001ff, 0xa0000198, 0 , 0,
19365 CP1_ }, /* POOL32F_0~*(51) */
19366 { reserved_block , 0 , 0 , 32,
19367 0xfc0001ff, 0xa00001a0, 0 , 0,
19368 CP1_ }, /* POOL32F_0~*(52) */
19369 { reserved_block , 0 , 0 , 32,
19370 0xfc0001ff, 0xa00001a8, 0 , 0,
19371 CP1_ }, /* POOL32F_0~*(53) */
19372 { pool , MUL_fmt1 , 2 , 32,
19373 0xfc0001ff, 0xa00001b0, 0 , 0,
19374 CP1_ }, /* MUL.fmt1 */
19375 { pool , MADDF_fmt , 2 , 32,
19376 0xfc0001ff, 0xa00001b8, 0 , 0,
19377 CP1_ }, /* MADDF.fmt */
19378 { reserved_block , 0 , 0 , 32,
19379 0xfc0001ff, 0xa00001c0, 0 , 0,
19380 CP1_ }, /* POOL32F_0~*(56) */
19381 { reserved_block , 0 , 0 , 32,
19382 0xfc0001ff, 0xa00001c8, 0 , 0,
19383 CP1_ }, /* POOL32F_0~*(57) */
19384 { reserved_block , 0 , 0 , 32,
19385 0xfc0001ff, 0xa00001d0, 0 , 0,
19386 CP1_ }, /* POOL32F_0~*(58) */
19387 { reserved_block , 0 , 0 , 32,
19388 0xfc0001ff, 0xa00001d8, 0 , 0,
19389 CP1_ }, /* POOL32F_0~*(59) */
19390 { reserved_block , 0 , 0 , 32,
19391 0xfc0001ff, 0xa00001e0, 0 , 0,
19392 CP1_ }, /* POOL32F_0~*(60) */
19393 { reserved_block , 0 , 0 , 32,
19394 0xfc0001ff, 0xa00001e8, 0 , 0,
19395 CP1_ }, /* POOL32F_0~*(61) */
19396 { pool , DIV_fmt1 , 2 , 32,
19397 0xfc0001ff, 0xa00001f0, 0 , 0,
19398 CP1_ }, /* DIV.fmt1 */
19399 { pool , MSUBF_fmt , 2 , 32,
19400 0xfc0001ff, 0xa00001f8, 0 , 0,
19401 CP1_ }, /* MSUBF.fmt */
19402};
19403
19404
19405NMD::Pool NMD::MIN_fmt[2] = {
19406 { instruction , 0 , 0 , 32,
19407 0xfc00023f, 0xa0000003, &NMD::MIN_S , 0,
19408 CP1_ }, /* MIN.S */
19409 { instruction , 0 , 0 , 32,
19410 0xfc00023f, 0xa0000203, &NMD::MIN_D , 0,
19411 CP1_ }, /* MIN.D */
19412};
19413
19414
19415NMD::Pool NMD::MAX_fmt[2] = {
19416 { instruction , 0 , 0 , 32,
19417 0xfc00023f, 0xa000000b, &NMD::MAX_S , 0,
19418 CP1_ }, /* MAX.S */
19419 { instruction , 0 , 0 , 32,
19420 0xfc00023f, 0xa000020b, &NMD::MAX_D , 0,
19421 CP1_ }, /* MAX.D */
19422};
19423
19424
19425NMD::Pool NMD::MINA_fmt[2] = {
19426 { instruction , 0 , 0 , 32,
19427 0xfc00023f, 0xa0000023, &NMD::MINA_S , 0,
19428 CP1_ }, /* MINA.S */
19429 { instruction , 0 , 0 , 32,
19430 0xfc00023f, 0xa0000223, &NMD::MINA_D , 0,
19431 CP1_ }, /* MINA.D */
19432};
19433
19434
19435NMD::Pool NMD::MAXA_fmt[2] = {
19436 { instruction , 0 , 0 , 32,
19437 0xfc00023f, 0xa000002b, &NMD::MAXA_S , 0,
19438 CP1_ }, /* MAXA.S */
19439 { instruction , 0 , 0 , 32,
19440 0xfc00023f, 0xa000022b, &NMD::MAXA_D , 0,
19441 CP1_ }, /* MAXA.D */
19442};
19443
19444
19445NMD::Pool NMD::CVT_L_fmt[2] = {
19446 { instruction , 0 , 0 , 32,
19447 0xfc007fff, 0xa000013b, &NMD::CVT_L_S , 0,
19448 CP1_ }, /* CVT.L.S */
19449 { instruction , 0 , 0 , 32,
19450 0xfc007fff, 0xa000413b, &NMD::CVT_L_D , 0,
19451 CP1_ }, /* CVT.L.D */
19452};
19453
19454
19455NMD::Pool NMD::RSQRT_fmt[2] = {
19456 { instruction , 0 , 0 , 32,
19457 0xfc007fff, 0xa000023b, &NMD::RSQRT_S , 0,
19458 CP1_ }, /* RSQRT.S */
19459 { instruction , 0 , 0 , 32,
19460 0xfc007fff, 0xa000423b, &NMD::RSQRT_D , 0,
19461 CP1_ }, /* RSQRT.D */
19462};
19463
19464
19465NMD::Pool NMD::FLOOR_L_fmt[2] = {
19466 { instruction , 0 , 0 , 32,
19467 0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S , 0,
19468 CP1_ }, /* FLOOR.L.S */
19469 { instruction , 0 , 0 , 32,
19470 0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D , 0,
19471 CP1_ }, /* FLOOR.L.D */
19472};
19473
19474
19475NMD::Pool NMD::CVT_W_fmt[2] = {
19476 { instruction , 0 , 0 , 32,
19477 0xfc007fff, 0xa000093b, &NMD::CVT_W_S , 0,
19478 CP1_ }, /* CVT.W.S */
19479 { instruction , 0 , 0 , 32,
19480 0xfc007fff, 0xa000493b, &NMD::CVT_W_D , 0,
19481 CP1_ }, /* CVT.W.D */
19482};
19483
19484
19485NMD::Pool NMD::SQRT_fmt[2] = {
19486 { instruction , 0 , 0 , 32,
19487 0xfc007fff, 0xa0000a3b, &NMD::SQRT_S , 0,
19488 CP1_ }, /* SQRT.S */
19489 { instruction , 0 , 0 , 32,
19490 0xfc007fff, 0xa0004a3b, &NMD::SQRT_D , 0,
19491 CP1_ }, /* SQRT.D */
19492};
19493
19494
19495NMD::Pool NMD::FLOOR_W_fmt[2] = {
19496 { instruction , 0 , 0 , 32,
19497 0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S , 0,
19498 CP1_ }, /* FLOOR.W.S */
19499 { instruction , 0 , 0 , 32,
19500 0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D , 0,
19501 CP1_ }, /* FLOOR.W.D */
19502};
19503
19504
19505NMD::Pool NMD::RECIP_fmt[2] = {
19506 { instruction , 0 , 0 , 32,
19507 0xfc007fff, 0xa000123b, &NMD::RECIP_S , 0,
19508 CP1_ }, /* RECIP.S */
19509 { instruction , 0 , 0 , 32,
19510 0xfc007fff, 0xa000523b, &NMD::RECIP_D , 0,
19511 CP1_ }, /* RECIP.D */
19512};
19513
19514
19515NMD::Pool NMD::CEIL_L_fmt[2] = {
19516 { instruction , 0 , 0 , 32,
19517 0xfc007fff, 0xa000133b, &NMD::CEIL_L_S , 0,
19518 CP1_ }, /* CEIL.L.S */
19519 { instruction , 0 , 0 , 32,
19520 0xfc007fff, 0xa000533b, &NMD::CEIL_L_D , 0,
19521 CP1_ }, /* CEIL.L.D */
19522};
19523
19524
19525NMD::Pool NMD::CEIL_W_fmt[2] = {
19526 { instruction , 0 , 0 , 32,
19527 0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S , 0,
19528 CP1_ }, /* CEIL.W.S */
19529 { instruction , 0 , 0 , 32,
19530 0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D , 0,
19531 CP1_ }, /* CEIL.W.D */
19532};
19533
19534
19535NMD::Pool NMD::TRUNC_L_fmt[2] = {
19536 { instruction , 0 , 0 , 32,
19537 0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S , 0,
19538 CP1_ }, /* TRUNC.L.S */
19539 { instruction , 0 , 0 , 32,
19540 0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D , 0,
19541 CP1_ }, /* TRUNC.L.D */
19542};
19543
19544
19545NMD::Pool NMD::TRUNC_W_fmt[2] = {
19546 { instruction , 0 , 0 , 32,
19547 0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S , 0,
19548 CP1_ }, /* TRUNC.W.S */
19549 { instruction , 0 , 0 , 32,
19550 0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D , 0,
19551 CP1_ }, /* TRUNC.W.D */
19552};
19553
19554
19555NMD::Pool NMD::ROUND_L_fmt[2] = {
19556 { instruction , 0 , 0 , 32,
19557 0xfc007fff, 0xa000333b, &NMD::ROUND_L_S , 0,
19558 CP1_ }, /* ROUND.L.S */
19559 { instruction , 0 , 0 , 32,
19560 0xfc007fff, 0xa000733b, &NMD::ROUND_L_D , 0,
19561 CP1_ }, /* ROUND.L.D */
19562};
19563
19564
19565NMD::Pool NMD::ROUND_W_fmt[2] = {
19566 { instruction , 0 , 0 , 32,
19567 0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S , 0,
19568 CP1_ }, /* ROUND.W.S */
19569 { instruction , 0 , 0 , 32,
19570 0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D , 0,
19571 CP1_ }, /* ROUND.W.D */
19572};
19573
19574
19575NMD::Pool NMD::POOL32Fxf_0[64] = {
19576 { reserved_block , 0 , 0 , 32,
19577 0xfc003fff, 0xa000003b, 0 , 0,
19578 CP1_ }, /* POOL32Fxf_0~*(0) */
19579 { pool , CVT_L_fmt , 2 , 32,
19580 0xfc003fff, 0xa000013b, 0 , 0,
19581 CP1_ }, /* CVT.L.fmt */
19582 { pool , RSQRT_fmt , 2 , 32,
19583 0xfc003fff, 0xa000023b, 0 , 0,
19584 CP1_ }, /* RSQRT.fmt */
19585 { pool , FLOOR_L_fmt , 2 , 32,
19586 0xfc003fff, 0xa000033b, 0 , 0,
19587 CP1_ }, /* FLOOR.L.fmt */
19588 { reserved_block , 0 , 0 , 32,
19589 0xfc003fff, 0xa000043b, 0 , 0,
19590 CP1_ }, /* POOL32Fxf_0~*(4) */
19591 { reserved_block , 0 , 0 , 32,
19592 0xfc003fff, 0xa000053b, 0 , 0,
19593 CP1_ }, /* POOL32Fxf_0~*(5) */
19594 { reserved_block , 0 , 0 , 32,
19595 0xfc003fff, 0xa000063b, 0 , 0,
19596 CP1_ }, /* POOL32Fxf_0~*(6) */
19597 { reserved_block , 0 , 0 , 32,
19598 0xfc003fff, 0xa000073b, 0 , 0,
19599 CP1_ }, /* POOL32Fxf_0~*(7) */
19600 { reserved_block , 0 , 0 , 32,
19601 0xfc003fff, 0xa000083b, 0 , 0,
19602 CP1_ }, /* POOL32Fxf_0~*(8) */
19603 { pool , CVT_W_fmt , 2 , 32,
19604 0xfc003fff, 0xa000093b, 0 , 0,
19605 CP1_ }, /* CVT.W.fmt */
19606 { pool , SQRT_fmt , 2 , 32,
19607 0xfc003fff, 0xa0000a3b, 0 , 0,
19608 CP1_ }, /* SQRT.fmt */
19609 { pool , FLOOR_W_fmt , 2 , 32,
19610 0xfc003fff, 0xa0000b3b, 0 , 0,
19611 CP1_ }, /* FLOOR.W.fmt */
19612 { reserved_block , 0 , 0 , 32,
19613 0xfc003fff, 0xa0000c3b, 0 , 0,
19614 CP1_ }, /* POOL32Fxf_0~*(12) */
19615 { reserved_block , 0 , 0 , 32,
19616 0xfc003fff, 0xa0000d3b, 0 , 0,
19617 CP1_ }, /* POOL32Fxf_0~*(13) */
19618 { reserved_block , 0 , 0 , 32,
19619 0xfc003fff, 0xa0000e3b, 0 , 0,
19620 CP1_ }, /* POOL32Fxf_0~*(14) */
19621 { reserved_block , 0 , 0 , 32,
19622 0xfc003fff, 0xa0000f3b, 0 , 0,
19623 CP1_ }, /* POOL32Fxf_0~*(15) */
19624 { instruction , 0 , 0 , 32,
19625 0xfc003fff, 0xa000103b, &NMD::CFC1 , 0,
19626 CP1_ }, /* CFC1 */
19627 { reserved_block , 0 , 0 , 32,
19628 0xfc003fff, 0xa000113b, 0 , 0,
19629 CP1_ }, /* POOL32Fxf_0~*(17) */
19630 { pool , RECIP_fmt , 2 , 32,
19631 0xfc003fff, 0xa000123b, 0 , 0,
19632 CP1_ }, /* RECIP.fmt */
19633 { pool , CEIL_L_fmt , 2 , 32,
19634 0xfc003fff, 0xa000133b, 0 , 0,
19635 CP1_ }, /* CEIL.L.fmt */
19636 { reserved_block , 0 , 0 , 32,
19637 0xfc003fff, 0xa000143b, 0 , 0,
19638 CP1_ }, /* POOL32Fxf_0~*(20) */
19639 { reserved_block , 0 , 0 , 32,
19640 0xfc003fff, 0xa000153b, 0 , 0,
19641 CP1_ }, /* POOL32Fxf_0~*(21) */
19642 { reserved_block , 0 , 0 , 32,
19643 0xfc003fff, 0xa000163b, 0 , 0,
19644 CP1_ }, /* POOL32Fxf_0~*(22) */
19645 { reserved_block , 0 , 0 , 32,
19646 0xfc003fff, 0xa000173b, 0 , 0,
19647 CP1_ }, /* POOL32Fxf_0~*(23) */
19648 { instruction , 0 , 0 , 32,
19649 0xfc003fff, 0xa000183b, &NMD::CTC1 , 0,
19650 CP1_ }, /* CTC1 */
19651 { reserved_block , 0 , 0 , 32,
19652 0xfc003fff, 0xa000193b, 0 , 0,
19653 CP1_ }, /* POOL32Fxf_0~*(25) */
19654 { reserved_block , 0 , 0 , 32,
19655 0xfc003fff, 0xa0001a3b, 0 , 0,
19656 CP1_ }, /* POOL32Fxf_0~*(26) */
19657 { pool , CEIL_W_fmt , 2 , 32,
19658 0xfc003fff, 0xa0001b3b, 0 , 0,
19659 CP1_ }, /* CEIL.W.fmt */
19660 { reserved_block , 0 , 0 , 32,
19661 0xfc003fff, 0xa0001c3b, 0 , 0,
19662 CP1_ }, /* POOL32Fxf_0~*(28) */
19663 { reserved_block , 0 , 0 , 32,
19664 0xfc003fff, 0xa0001d3b, 0 , 0,
19665 CP1_ }, /* POOL32Fxf_0~*(29) */
19666 { reserved_block , 0 , 0 , 32,
19667 0xfc003fff, 0xa0001e3b, 0 , 0,
19668 CP1_ }, /* POOL32Fxf_0~*(30) */
19669 { reserved_block , 0 , 0 , 32,
19670 0xfc003fff, 0xa0001f3b, 0 , 0,
19671 CP1_ }, /* POOL32Fxf_0~*(31) */
19672 { instruction , 0 , 0 , 32,
19673 0xfc003fff, 0xa000203b, &NMD::MFC1 , 0,
19674 CP1_ }, /* MFC1 */
19675 { instruction , 0 , 0 , 32,
19676 0xfc003fff, 0xa000213b, &NMD::CVT_S_PL , 0,
19677 CP1_ }, /* CVT.S.PL */
19678 { reserved_block , 0 , 0 , 32,
19679 0xfc003fff, 0xa000223b, 0 , 0,
19680 CP1_ }, /* POOL32Fxf_0~*(34) */
19681 { pool , TRUNC_L_fmt , 2 , 32,
19682 0xfc003fff, 0xa000233b, 0 , 0,
19683 CP1_ }, /* TRUNC.L.fmt */
19684 { instruction , 0 , 0 , 32,
19685 0xfc003fff, 0xa000243b, &NMD::DMFC1 , 0,
19686 CP1_ | MIPS64_ }, /* DMFC1 */
19687 { reserved_block , 0 , 0 , 32,
19688 0xfc003fff, 0xa000253b, 0 , 0,
19689 CP1_ }, /* POOL32Fxf_0~*(37) */
19690 { reserved_block , 0 , 0 , 32,
19691 0xfc003fff, 0xa000263b, 0 , 0,
19692 CP1_ }, /* POOL32Fxf_0~*(38) */
19693 { reserved_block , 0 , 0 , 32,
19694 0xfc003fff, 0xa000273b, 0 , 0,
19695 CP1_ }, /* POOL32Fxf_0~*(39) */
19696 { instruction , 0 , 0 , 32,
19697 0xfc003fff, 0xa000283b, &NMD::MTC1 , 0,
19698 CP1_ }, /* MTC1 */
19699 { instruction , 0 , 0 , 32,
19700 0xfc003fff, 0xa000293b, &NMD::CVT_S_PU , 0,
19701 CP1_ }, /* CVT.S.PU */
19702 { reserved_block , 0 , 0 , 32,
19703 0xfc003fff, 0xa0002a3b, 0 , 0,
19704 CP1_ }, /* POOL32Fxf_0~*(42) */
19705 { pool , TRUNC_W_fmt , 2 , 32,
19706 0xfc003fff, 0xa0002b3b, 0 , 0,
19707 CP1_ }, /* TRUNC.W.fmt */
19708 { instruction , 0 , 0 , 32,
19709 0xfc003fff, 0xa0002c3b, &NMD::DMTC1 , 0,
19710 CP1_ | MIPS64_ }, /* DMTC1 */
19711 { reserved_block , 0 , 0 , 32,
19712 0xfc003fff, 0xa0002d3b, 0 , 0,
19713 CP1_ }, /* POOL32Fxf_0~*(45) */
19714 { reserved_block , 0 , 0 , 32,
19715 0xfc003fff, 0xa0002e3b, 0 , 0,
19716 CP1_ }, /* POOL32Fxf_0~*(46) */
19717 { reserved_block , 0 , 0 , 32,
19718 0xfc003fff, 0xa0002f3b, 0 , 0,
19719 CP1_ }, /* POOL32Fxf_0~*(47) */
19720 { instruction , 0 , 0 , 32,
19721 0xfc003fff, 0xa000303b, &NMD::MFHC1 , 0,
19722 CP1_ }, /* MFHC1 */
19723 { reserved_block , 0 , 0 , 32,
19724 0xfc003fff, 0xa000313b, 0 , 0,
19725 CP1_ }, /* POOL32Fxf_0~*(49) */
19726 { reserved_block , 0 , 0 , 32,
19727 0xfc003fff, 0xa000323b, 0 , 0,
19728 CP1_ }, /* POOL32Fxf_0~*(50) */
19729 { pool , ROUND_L_fmt , 2 , 32,
19730 0xfc003fff, 0xa000333b, 0 , 0,
19731 CP1_ }, /* ROUND.L.fmt */
19732 { reserved_block , 0 , 0 , 32,
19733 0xfc003fff, 0xa000343b, 0 , 0,
19734 CP1_ }, /* POOL32Fxf_0~*(52) */
19735 { reserved_block , 0 , 0 , 32,
19736 0xfc003fff, 0xa000353b, 0 , 0,
19737 CP1_ }, /* POOL32Fxf_0~*(53) */
19738 { reserved_block , 0 , 0 , 32,
19739 0xfc003fff, 0xa000363b, 0 , 0,
19740 CP1_ }, /* POOL32Fxf_0~*(54) */
19741 { reserved_block , 0 , 0 , 32,
19742 0xfc003fff, 0xa000373b, 0 , 0,
19743 CP1_ }, /* POOL32Fxf_0~*(55) */
19744 { instruction , 0 , 0 , 32,
19745 0xfc003fff, 0xa000383b, &NMD::MTHC1 , 0,
19746 CP1_ }, /* MTHC1 */
19747 { reserved_block , 0 , 0 , 32,
19748 0xfc003fff, 0xa000393b, 0 , 0,
19749 CP1_ }, /* POOL32Fxf_0~*(57) */
19750 { reserved_block , 0 , 0 , 32,
19751 0xfc003fff, 0xa0003a3b, 0 , 0,
19752 CP1_ }, /* POOL32Fxf_0~*(58) */
19753 { pool , ROUND_W_fmt , 2 , 32,
19754 0xfc003fff, 0xa0003b3b, 0 , 0,
19755 CP1_ }, /* ROUND.W.fmt */
19756 { reserved_block , 0 , 0 , 32,
19757 0xfc003fff, 0xa0003c3b, 0 , 0,
19758 CP1_ }, /* POOL32Fxf_0~*(60) */
19759 { reserved_block , 0 , 0 , 32,
19760 0xfc003fff, 0xa0003d3b, 0 , 0,
19761 CP1_ }, /* POOL32Fxf_0~*(61) */
19762 { reserved_block , 0 , 0 , 32,
19763 0xfc003fff, 0xa0003e3b, 0 , 0,
19764 CP1_ }, /* POOL32Fxf_0~*(62) */
19765 { reserved_block , 0 , 0 , 32,
19766 0xfc003fff, 0xa0003f3b, 0 , 0,
19767 CP1_ }, /* POOL32Fxf_0~*(63) */
19768};
19769
19770
19771NMD::Pool NMD::MOV_fmt[4] = {
19772 { instruction , 0 , 0 , 32,
19773 0xfc007fff, 0xa000007b, &NMD::MOV_S , 0,
19774 CP1_ }, /* MOV.S */
19775 { instruction , 0 , 0 , 32,
19776 0xfc007fff, 0xa000207b, &NMD::MOV_D , 0,
19777 CP1_ }, /* MOV.D */
19778 { reserved_block , 0 , 0 , 32,
19779 0xfc007fff, 0xa000407b, 0 , 0,
19780 CP1_ }, /* MOV.fmt~*(2) */
19781 { reserved_block , 0 , 0 , 32,
19782 0xfc007fff, 0xa000607b, 0 , 0,
19783 CP1_ }, /* MOV.fmt~*(3) */
19784};
19785
19786
19787NMD::Pool NMD::ABS_fmt[4] = {
19788 { instruction , 0 , 0 , 32,
19789 0xfc007fff, 0xa000037b, &NMD::ABS_S , 0,
19790 CP1_ }, /* ABS.S */
19791 { instruction , 0 , 0 , 32,
19792 0xfc007fff, 0xa000237b, &NMD::ABS_D , 0,
19793 CP1_ }, /* ABS.D */
19794 { reserved_block , 0 , 0 , 32,
19795 0xfc007fff, 0xa000437b, 0 , 0,
19796 CP1_ }, /* ABS.fmt~*(2) */
19797 { reserved_block , 0 , 0 , 32,
19798 0xfc007fff, 0xa000637b, 0 , 0,
19799 CP1_ }, /* ABS.fmt~*(3) */
19800};
19801
19802
19803NMD::Pool NMD::NEG_fmt[4] = {
19804 { instruction , 0 , 0 , 32,
19805 0xfc007fff, 0xa0000b7b, &NMD::NEG_S , 0,
19806 CP1_ }, /* NEG.S */
19807 { instruction , 0 , 0 , 32,
19808 0xfc007fff, 0xa0002b7b, &NMD::NEG_D , 0,
19809 CP1_ }, /* NEG.D */
19810 { reserved_block , 0 , 0 , 32,
19811 0xfc007fff, 0xa0004b7b, 0 , 0,
19812 CP1_ }, /* NEG.fmt~*(2) */
19813 { reserved_block , 0 , 0 , 32,
19814 0xfc007fff, 0xa0006b7b, 0 , 0,
19815 CP1_ }, /* NEG.fmt~*(3) */
19816};
19817
19818
19819NMD::Pool NMD::CVT_D_fmt[4] = {
19820 { instruction , 0 , 0 , 32,
19821 0xfc007fff, 0xa000137b, &NMD::CVT_D_S , 0,
19822 CP1_ }, /* CVT.D.S */
19823 { instruction , 0 , 0 , 32,
19824 0xfc007fff, 0xa000337b, &NMD::CVT_D_W , 0,
19825 CP1_ }, /* CVT.D.W */
19826 { instruction , 0 , 0 , 32,
19827 0xfc007fff, 0xa000537b, &NMD::CVT_D_L , 0,
19828 CP1_ }, /* CVT.D.L */
19829 { reserved_block , 0 , 0 , 32,
19830 0xfc007fff, 0xa000737b, 0 , 0,
19831 CP1_ }, /* CVT.D.fmt~*(3) */
19832};
19833
19834
19835NMD::Pool NMD::CVT_S_fmt[4] = {
19836 { instruction , 0 , 0 , 32,
19837 0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D , 0,
19838 CP1_ }, /* CVT.S.D */
19839 { instruction , 0 , 0 , 32,
19840 0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W , 0,
19841 CP1_ }, /* CVT.S.W */
19842 { instruction , 0 , 0 , 32,
19843 0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L , 0,
19844 CP1_ }, /* CVT.S.L */
19845 { reserved_block , 0 , 0 , 32,
19846 0xfc007fff, 0xa0007b7b, 0 , 0,
19847 CP1_ }, /* CVT.S.fmt~*(3) */
19848};
19849
19850
19851NMD::Pool NMD::POOL32Fxf_1[32] = {
19852 { pool , MOV_fmt , 4 , 32,
19853 0xfc001fff, 0xa000007b, 0 , 0,
19854 CP1_ }, /* MOV.fmt */
19855 { reserved_block , 0 , 0 , 32,
19856 0xfc001fff, 0xa000017b, 0 , 0,
19857 CP1_ }, /* POOL32Fxf_1~*(1) */
19858 { reserved_block , 0 , 0 , 32,
19859 0xfc001fff, 0xa000027b, 0 , 0,
19860 CP1_ }, /* POOL32Fxf_1~*(2) */
19861 { pool , ABS_fmt , 4 , 32,
19862 0xfc001fff, 0xa000037b, 0 , 0,
19863 CP1_ }, /* ABS.fmt */
19864 { reserved_block , 0 , 0 , 32,
19865 0xfc001fff, 0xa000047b, 0 , 0,
19866 CP1_ }, /* POOL32Fxf_1~*(4) */
19867 { reserved_block , 0 , 0 , 32,
19868 0xfc001fff, 0xa000057b, 0 , 0,
19869 CP1_ }, /* POOL32Fxf_1~*(5) */
19870 { reserved_block , 0 , 0 , 32,
19871 0xfc001fff, 0xa000067b, 0 , 0,
19872 CP1_ }, /* POOL32Fxf_1~*(6) */
19873 { reserved_block , 0 , 0 , 32,
19874 0xfc001fff, 0xa000077b, 0 , 0,
19875 CP1_ }, /* POOL32Fxf_1~*(7) */
19876 { reserved_block , 0 , 0 , 32,
19877 0xfc001fff, 0xa000087b, 0 , 0,
19878 CP1_ }, /* POOL32Fxf_1~*(8) */
19879 { reserved_block , 0 , 0 , 32,
19880 0xfc001fff, 0xa000097b, 0 , 0,
19881 CP1_ }, /* POOL32Fxf_1~*(9) */
19882 { reserved_block , 0 , 0 , 32,
19883 0xfc001fff, 0xa0000a7b, 0 , 0,
19884 CP1_ }, /* POOL32Fxf_1~*(10) */
19885 { pool , NEG_fmt , 4 , 32,
19886 0xfc001fff, 0xa0000b7b, 0 , 0,
19887 CP1_ }, /* NEG.fmt */
19888 { reserved_block , 0 , 0 , 32,
19889 0xfc001fff, 0xa0000c7b, 0 , 0,
19890 CP1_ }, /* POOL32Fxf_1~*(12) */
19891 { reserved_block , 0 , 0 , 32,
19892 0xfc001fff, 0xa0000d7b, 0 , 0,
19893 CP1_ }, /* POOL32Fxf_1~*(13) */
19894 { reserved_block , 0 , 0 , 32,
19895 0xfc001fff, 0xa0000e7b, 0 , 0,
19896 CP1_ }, /* POOL32Fxf_1~*(14) */
19897 { reserved_block , 0 , 0 , 32,
19898 0xfc001fff, 0xa0000f7b, 0 , 0,
19899 CP1_ }, /* POOL32Fxf_1~*(15) */
19900 { reserved_block , 0 , 0 , 32,
19901 0xfc001fff, 0xa000107b, 0 , 0,
19902 CP1_ }, /* POOL32Fxf_1~*(16) */
19903 { reserved_block , 0 , 0 , 32,
19904 0xfc001fff, 0xa000117b, 0 , 0,
19905 CP1_ }, /* POOL32Fxf_1~*(17) */
19906 { reserved_block , 0 , 0 , 32,
19907 0xfc001fff, 0xa000127b, 0 , 0,
19908 CP1_ }, /* POOL32Fxf_1~*(18) */
19909 { pool , CVT_D_fmt , 4 , 32,
19910 0xfc001fff, 0xa000137b, 0 , 0,
19911 CP1_ }, /* CVT.D.fmt */
19912 { reserved_block , 0 , 0 , 32,
19913 0xfc001fff, 0xa000147b, 0 , 0,
19914 CP1_ }, /* POOL32Fxf_1~*(20) */
19915 { reserved_block , 0 , 0 , 32,
19916 0xfc001fff, 0xa000157b, 0 , 0,
19917 CP1_ }, /* POOL32Fxf_1~*(21) */
19918 { reserved_block , 0 , 0 , 32,
19919 0xfc001fff, 0xa000167b, 0 , 0,
19920 CP1_ }, /* POOL32Fxf_1~*(22) */
19921 { reserved_block , 0 , 0 , 32,
19922 0xfc001fff, 0xa000177b, 0 , 0,
19923 CP1_ }, /* POOL32Fxf_1~*(23) */
19924 { reserved_block , 0 , 0 , 32,
19925 0xfc001fff, 0xa000187b, 0 , 0,
19926 CP1_ }, /* POOL32Fxf_1~*(24) */
19927 { reserved_block , 0 , 0 , 32,
19928 0xfc001fff, 0xa000197b, 0 , 0,
19929 CP1_ }, /* POOL32Fxf_1~*(25) */
19930 { reserved_block , 0 , 0 , 32,
19931 0xfc001fff, 0xa0001a7b, 0 , 0,
19932 CP1_ }, /* POOL32Fxf_1~*(26) */
19933 { pool , CVT_S_fmt , 4 , 32,
19934 0xfc001fff, 0xa0001b7b, 0 , 0,
19935 CP1_ }, /* CVT.S.fmt */
19936 { reserved_block , 0 , 0 , 32,
19937 0xfc001fff, 0xa0001c7b, 0 , 0,
19938 CP1_ }, /* POOL32Fxf_1~*(28) */
19939 { reserved_block , 0 , 0 , 32,
19940 0xfc001fff, 0xa0001d7b, 0 , 0,
19941 CP1_ }, /* POOL32Fxf_1~*(29) */
19942 { reserved_block , 0 , 0 , 32,
19943 0xfc001fff, 0xa0001e7b, 0 , 0,
19944 CP1_ }, /* POOL32Fxf_1~*(30) */
19945 { reserved_block , 0 , 0 , 32,
19946 0xfc001fff, 0xa0001f7b, 0 , 0,
19947 CP1_ }, /* POOL32Fxf_1~*(31) */
19948};
19949
19950
19951NMD::Pool NMD::POOL32Fxf[4] = {
19952 { pool , POOL32Fxf_0 , 64 , 32,
19953 0xfc0000ff, 0xa000003b, 0 , 0,
19954 CP1_ }, /* POOL32Fxf_0 */
19955 { pool , POOL32Fxf_1 , 32 , 32,
19956 0xfc0000ff, 0xa000007b, 0 , 0,
19957 CP1_ }, /* POOL32Fxf_1 */
19958 { reserved_block , 0 , 0 , 32,
19959 0xfc0000ff, 0xa00000bb, 0 , 0,
19960 CP1_ }, /* POOL32Fxf~*(2) */
19961 { reserved_block , 0 , 0 , 32,
19962 0xfc0000ff, 0xa00000fb, 0 , 0,
19963 CP1_ }, /* POOL32Fxf~*(3) */
19964};
19965
19966
19967NMD::Pool NMD::POOL32F_3[8] = {
19968 { pool , MIN_fmt , 2 , 32,
19969 0xfc00003f, 0xa0000003, 0 , 0,
19970 CP1_ }, /* MIN.fmt */
19971 { pool , MAX_fmt , 2 , 32,
19972 0xfc00003f, 0xa000000b, 0 , 0,
19973 CP1_ }, /* MAX.fmt */
19974 { reserved_block , 0 , 0 , 32,
19975 0xfc00003f, 0xa0000013, 0 , 0,
19976 CP1_ }, /* POOL32F_3~*(2) */
19977 { reserved_block , 0 , 0 , 32,
19978 0xfc00003f, 0xa000001b, 0 , 0,
19979 CP1_ }, /* POOL32F_3~*(3) */
19980 { pool , MINA_fmt , 2 , 32,
19981 0xfc00003f, 0xa0000023, 0 , 0,
19982 CP1_ }, /* MINA.fmt */
19983 { pool , MAXA_fmt , 2 , 32,
19984 0xfc00003f, 0xa000002b, 0 , 0,
19985 CP1_ }, /* MAXA.fmt */
19986 { reserved_block , 0 , 0 , 32,
19987 0xfc00003f, 0xa0000033, 0 , 0,
19988 CP1_ }, /* POOL32F_3~*(6) */
19989 { pool , POOL32Fxf , 4 , 32,
19990 0xfc00003f, 0xa000003b, 0 , 0,
19991 CP1_ }, /* POOL32Fxf */
19992};
19993
19994
19995NMD::Pool NMD::CMP_condn_S[32] = {
19996 { instruction , 0 , 0 , 32,
19997 0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S , 0,
19998 CP1_ }, /* CMP.AF.S */
19999 { instruction , 0 , 0 , 32,
20000 0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S , 0,
20001 CP1_ }, /* CMP.UN.S */
20002 { instruction , 0 , 0 , 32,
20003 0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S , 0,
20004 CP1_ }, /* CMP.EQ.S */
20005 { instruction , 0 , 0 , 32,
20006 0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S , 0,
20007 CP1_ }, /* CMP.UEQ.S */
20008 { instruction , 0 , 0 , 32,
20009 0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S , 0,
20010 CP1_ }, /* CMP.LT.S */
20011 { instruction , 0 , 0 , 32,
20012 0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S , 0,
20013 CP1_ }, /* CMP.ULT.S */
20014 { instruction , 0 , 0 , 32,
20015 0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S , 0,
20016 CP1_ }, /* CMP.LE.S */
20017 { instruction , 0 , 0 , 32,
20018 0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S , 0,
20019 CP1_ }, /* CMP.ULE.S */
20020 { instruction , 0 , 0 , 32,
20021 0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S , 0,
20022 CP1_ }, /* CMP.SAF.S */
20023 { instruction , 0 , 0 , 32,
20024 0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S , 0,
20025 CP1_ }, /* CMP.SUN.S */
20026 { instruction , 0 , 0 , 32,
20027 0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S , 0,
20028 CP1_ }, /* CMP.SEQ.S */
20029 { instruction , 0 , 0 , 32,
20030 0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S , 0,
20031 CP1_ }, /* CMP.SUEQ.S */
20032 { instruction , 0 , 0 , 32,
20033 0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S , 0,
20034 CP1_ }, /* CMP.SLT.S */
20035 { instruction , 0 , 0 , 32,
20036 0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S , 0,
20037 CP1_ }, /* CMP.SULT.S */
20038 { instruction , 0 , 0 , 32,
20039 0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S , 0,
20040 CP1_ }, /* CMP.SLE.S */
20041 { instruction , 0 , 0 , 32,
20042 0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S , 0,
20043 CP1_ }, /* CMP.SULE.S */
20044 { reserved_block , 0 , 0 , 32,
20045 0xfc0007ff, 0xa0000405, 0 , 0,
20046 CP1_ }, /* CMP.condn.S~*(16) */
20047 { instruction , 0 , 0 , 32,
20048 0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S , 0,
20049 CP1_ }, /* CMP.OR.S */
20050 { instruction , 0 , 0 , 32,
20051 0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S , 0,
20052 CP1_ }, /* CMP.UNE.S */
20053 { instruction , 0 , 0 , 32,
20054 0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S , 0,
20055 CP1_ }, /* CMP.NE.S */
20056 { reserved_block , 0 , 0 , 32,
20057 0xfc0007ff, 0xa0000505, 0 , 0,
20058 CP1_ }, /* CMP.condn.S~*(20) */
20059 { reserved_block , 0 , 0 , 32,
20060 0xfc0007ff, 0xa0000545, 0 , 0,
20061 CP1_ }, /* CMP.condn.S~*(21) */
20062 { reserved_block , 0 , 0 , 32,
20063 0xfc0007ff, 0xa0000585, 0 , 0,
20064 CP1_ }, /* CMP.condn.S~*(22) */
20065 { reserved_block , 0 , 0 , 32,
20066 0xfc0007ff, 0xa00005c5, 0 , 0,
20067 CP1_ }, /* CMP.condn.S~*(23) */
20068 { reserved_block , 0 , 0 , 32,
20069 0xfc0007ff, 0xa0000605, 0 , 0,
20070 CP1_ }, /* CMP.condn.S~*(24) */
20071 { instruction , 0 , 0 , 32,
20072 0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S , 0,
20073 CP1_ }, /* CMP.SOR.S */
20074 { instruction , 0 , 0 , 32,
20075 0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S , 0,
20076 CP1_ }, /* CMP.SUNE.S */
20077 { instruction , 0 , 0 , 32,
20078 0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S , 0,
20079 CP1_ }, /* CMP.SNE.S */
20080 { reserved_block , 0 , 0 , 32,
20081 0xfc0007ff, 0xa0000705, 0 , 0,
20082 CP1_ }, /* CMP.condn.S~*(28) */
20083 { reserved_block , 0 , 0 , 32,
20084 0xfc0007ff, 0xa0000745, 0 , 0,
20085 CP1_ }, /* CMP.condn.S~*(29) */
20086 { reserved_block , 0 , 0 , 32,
20087 0xfc0007ff, 0xa0000785, 0 , 0,
20088 CP1_ }, /* CMP.condn.S~*(30) */
20089 { reserved_block , 0 , 0 , 32,
20090 0xfc0007ff, 0xa00007c5, 0 , 0,
20091 CP1_ }, /* CMP.condn.S~*(31) */
20092};
20093
20094
20095NMD::Pool NMD::CMP_condn_D[32] = {
20096 { instruction , 0 , 0 , 32,
20097 0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D , 0,
20098 CP1_ }, /* CMP.AF.D */
20099 { instruction , 0 , 0 , 32,
20100 0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D , 0,
20101 CP1_ }, /* CMP.UN.D */
20102 { instruction , 0 , 0 , 32,
20103 0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D , 0,
20104 CP1_ }, /* CMP.EQ.D */
20105 { instruction , 0 , 0 , 32,
20106 0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D , 0,
20107 CP1_ }, /* CMP.UEQ.D */
20108 { instruction , 0 , 0 , 32,
20109 0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D , 0,
20110 CP1_ }, /* CMP.LT.D */
20111 { instruction , 0 , 0 , 32,
20112 0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D , 0,
20113 CP1_ }, /* CMP.ULT.D */
20114 { instruction , 0 , 0 , 32,
20115 0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D , 0,
20116 CP1_ }, /* CMP.LE.D */
20117 { instruction , 0 , 0 , 32,
20118 0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D , 0,
20119 CP1_ }, /* CMP.ULE.D */
20120 { instruction , 0 , 0 , 32,
20121 0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D , 0,
20122 CP1_ }, /* CMP.SAF.D */
20123 { instruction , 0 , 0 , 32,
20124 0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D , 0,
20125 CP1_ }, /* CMP.SUN.D */
20126 { instruction , 0 , 0 , 32,
20127 0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D , 0,
20128 CP1_ }, /* CMP.SEQ.D */
20129 { instruction , 0 , 0 , 32,
20130 0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D , 0,
20131 CP1_ }, /* CMP.SUEQ.D */
20132 { instruction , 0 , 0 , 32,
20133 0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D , 0,
20134 CP1_ }, /* CMP.SLT.D */
20135 { instruction , 0 , 0 , 32,
20136 0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D , 0,
20137 CP1_ }, /* CMP.SULT.D */
20138 { instruction , 0 , 0 , 32,
20139 0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D , 0,
20140 CP1_ }, /* CMP.SLE.D */
20141 { instruction , 0 , 0 , 32,
20142 0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D , 0,
20143 CP1_ }, /* CMP.SULE.D */
20144 { reserved_block , 0 , 0 , 32,
20145 0xfc0007ff, 0xa0000415, 0 , 0,
20146 CP1_ }, /* CMP.condn.D~*(16) */
20147 { instruction , 0 , 0 , 32,
20148 0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D , 0,
20149 CP1_ }, /* CMP.OR.D */
20150 { instruction , 0 , 0 , 32,
20151 0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D , 0,
20152 CP1_ }, /* CMP.UNE.D */
20153 { instruction , 0 , 0 , 32,
20154 0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D , 0,
20155 CP1_ }, /* CMP.NE.D */
20156 { reserved_block , 0 , 0 , 32,
20157 0xfc0007ff, 0xa0000515, 0 , 0,
20158 CP1_ }, /* CMP.condn.D~*(20) */
20159 { reserved_block , 0 , 0 , 32,
20160 0xfc0007ff, 0xa0000555, 0 , 0,
20161 CP1_ }, /* CMP.condn.D~*(21) */
20162 { reserved_block , 0 , 0 , 32,
20163 0xfc0007ff, 0xa0000595, 0 , 0,
20164 CP1_ }, /* CMP.condn.D~*(22) */
20165 { reserved_block , 0 , 0 , 32,
20166 0xfc0007ff, 0xa00005d5, 0 , 0,
20167 CP1_ }, /* CMP.condn.D~*(23) */
20168 { reserved_block , 0 , 0 , 32,
20169 0xfc0007ff, 0xa0000615, 0 , 0,
20170 CP1_ }, /* CMP.condn.D~*(24) */
20171 { instruction , 0 , 0 , 32,
20172 0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D , 0,
20173 CP1_ }, /* CMP.SOR.D */
20174 { instruction , 0 , 0 , 32,
20175 0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D , 0,
20176 CP1_ }, /* CMP.SUNE.D */
20177 { instruction , 0 , 0 , 32,
20178 0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D , 0,
20179 CP1_ }, /* CMP.SNE.D */
20180 { reserved_block , 0 , 0 , 32,
20181 0xfc0007ff, 0xa0000715, 0 , 0,
20182 CP1_ }, /* CMP.condn.D~*(28) */
20183 { reserved_block , 0 , 0 , 32,
20184 0xfc0007ff, 0xa0000755, 0 , 0,
20185 CP1_ }, /* CMP.condn.D~*(29) */
20186 { reserved_block , 0 , 0 , 32,
20187 0xfc0007ff, 0xa0000795, 0 , 0,
20188 CP1_ }, /* CMP.condn.D~*(30) */
20189 { reserved_block , 0 , 0 , 32,
20190 0xfc0007ff, 0xa00007d5, 0 , 0,
20191 CP1_ }, /* CMP.condn.D~*(31) */
20192};
20193
20194
20195NMD::Pool NMD::POOL32F_5[8] = {
20196 { pool , CMP_condn_S , 32 , 32,
20197 0xfc00003f, 0xa0000005, 0 , 0,
20198 CP1_ }, /* CMP.condn.S */
20199 { reserved_block , 0 , 0 , 32,
20200 0xfc00003f, 0xa000000d, 0 , 0,
20201 CP1_ }, /* POOL32F_5~*(1) */
20202 { pool , CMP_condn_D , 32 , 32,
20203 0xfc00003f, 0xa0000015, 0 , 0,
20204 CP1_ }, /* CMP.condn.D */
20205 { reserved_block , 0 , 0 , 32,
20206 0xfc00003f, 0xa000001d, 0 , 0,
20207 CP1_ }, /* POOL32F_5~*(3) */
20208 { reserved_block , 0 , 0 , 32,
20209 0xfc00003f, 0xa0000025, 0 , 0,
20210 CP1_ }, /* POOL32F_5~*(4) */
20211 { reserved_block , 0 , 0 , 32,
20212 0xfc00003f, 0xa000002d, 0 , 0,
20213 CP1_ }, /* POOL32F_5~*(5) */
20214 { reserved_block , 0 , 0 , 32,
20215 0xfc00003f, 0xa0000035, 0 , 0,
20216 CP1_ }, /* POOL32F_5~*(6) */
20217 { reserved_block , 0 , 0 , 32,
20218 0xfc00003f, 0xa000003d, 0 , 0,
20219 CP1_ }, /* POOL32F_5~*(7) */
20220};
20221
20222
20223NMD::Pool NMD::POOL32F[8] = {
20224 { pool , POOL32F_0 , 64 , 32,
20225 0xfc000007, 0xa0000000, 0 , 0,
20226 CP1_ }, /* POOL32F_0 */
20227 { reserved_block , 0 , 0 , 32,
20228 0xfc000007, 0xa0000001, 0 , 0,
20229 CP1_ }, /* POOL32F~*(1) */
20230 { reserved_block , 0 , 0 , 32,
20231 0xfc000007, 0xa0000002, 0 , 0,
20232 CP1_ }, /* POOL32F~*(2) */
20233 { pool , POOL32F_3 , 8 , 32,
20234 0xfc000007, 0xa0000003, 0 , 0,
20235 CP1_ }, /* POOL32F_3 */
20236 { reserved_block , 0 , 0 , 32,
20237 0xfc000007, 0xa0000004, 0 , 0,
20238 CP1_ }, /* POOL32F~*(4) */
20239 { pool , POOL32F_5 , 8 , 32,
20240 0xfc000007, 0xa0000005, 0 , 0,
20241 CP1_ }, /* POOL32F_5 */
20242 { reserved_block , 0 , 0 , 32,
20243 0xfc000007, 0xa0000006, 0 , 0,
20244 CP1_ }, /* POOL32F~*(6) */
20245 { reserved_block , 0 , 0 , 32,
20246 0xfc000007, 0xa0000007, 0 , 0,
20247 CP1_ }, /* POOL32F~*(7) */
20248};
20249
20250
20251NMD::Pool NMD::POOL32S_0[64] = {
20252 { reserved_block , 0 , 0 , 32,
20253 0xfc0001ff, 0xc0000000, 0 , 0,
20254 0x0 }, /* POOL32S_0~*(0) */
20255 { instruction , 0 , 0 , 32,
20256 0xfc0001ff, 0xc0000008, &NMD::DLSA , 0,
20257 MIPS64_ }, /* DLSA */
20258 { instruction , 0 , 0 , 32,
20259 0xfc0001ff, 0xc0000010, &NMD::DSLLV , 0,
20260 MIPS64_ }, /* DSLLV */
20261 { instruction , 0 , 0 , 32,
20262 0xfc0001ff, 0xc0000018, &NMD::DMUL , 0,
20263 MIPS64_ }, /* DMUL */
20264 { reserved_block , 0 , 0 , 32,
20265 0xfc0001ff, 0xc0000020, 0 , 0,
20266 0x0 }, /* POOL32S_0~*(4) */
20267 { reserved_block , 0 , 0 , 32,
20268 0xfc0001ff, 0xc0000028, 0 , 0,
20269 0x0 }, /* POOL32S_0~*(5) */
20270 { reserved_block , 0 , 0 , 32,
20271 0xfc0001ff, 0xc0000030, 0 , 0,
20272 0x0 }, /* POOL32S_0~*(6) */
20273 { reserved_block , 0 , 0 , 32,
20274 0xfc0001ff, 0xc0000038, 0 , 0,
20275 0x0 }, /* POOL32S_0~*(7) */
20276 { reserved_block , 0 , 0 , 32,
20277 0xfc0001ff, 0xc0000040, 0 , 0,
20278 0x0 }, /* POOL32S_0~*(8) */
20279 { reserved_block , 0 , 0 , 32,
20280 0xfc0001ff, 0xc0000048, 0 , 0,
20281 0x0 }, /* POOL32S_0~*(9) */
20282 { instruction , 0 , 0 , 32,
20283 0xfc0001ff, 0xc0000050, &NMD::DSRLV , 0,
20284 MIPS64_ }, /* DSRLV */
20285 { instruction , 0 , 0 , 32,
20286 0xfc0001ff, 0xc0000058, &NMD::DMUH , 0,
20287 MIPS64_ }, /* DMUH */
20288 { reserved_block , 0 , 0 , 32,
20289 0xfc0001ff, 0xc0000060, 0 , 0,
20290 0x0 }, /* POOL32S_0~*(12) */
20291 { reserved_block , 0 , 0 , 32,
20292 0xfc0001ff, 0xc0000068, 0 , 0,
20293 0x0 }, /* POOL32S_0~*(13) */
20294 { reserved_block , 0 , 0 , 32,
20295 0xfc0001ff, 0xc0000070, 0 , 0,
20296 0x0 }, /* POOL32S_0~*(14) */
20297 { reserved_block , 0 , 0 , 32,
20298 0xfc0001ff, 0xc0000078, 0 , 0,
20299 0x0 }, /* POOL32S_0~*(15) */
20300 { reserved_block , 0 , 0 , 32,
20301 0xfc0001ff, 0xc0000080, 0 , 0,
20302 0x0 }, /* POOL32S_0~*(16) */
20303 { reserved_block , 0 , 0 , 32,
20304 0xfc0001ff, 0xc0000088, 0 , 0,
20305 0x0 }, /* POOL32S_0~*(17) */
20306 { instruction , 0 , 0 , 32,
20307 0xfc0001ff, 0xc0000090, &NMD::DSRAV , 0,
20308 MIPS64_ }, /* DSRAV */
20309 { instruction , 0 , 0 , 32,
20310 0xfc0001ff, 0xc0000098, &NMD::DMULU , 0,
20311 MIPS64_ }, /* DMULU */
20312 { reserved_block , 0 , 0 , 32,
20313 0xfc0001ff, 0xc00000a0, 0 , 0,
20314 0x0 }, /* POOL32S_0~*(20) */
20315 { reserved_block , 0 , 0 , 32,
20316 0xfc0001ff, 0xc00000a8, 0 , 0,
20317 0x0 }, /* POOL32S_0~*(21) */
20318 { reserved_block , 0 , 0 , 32,
20319 0xfc0001ff, 0xc00000b0, 0 , 0,
20320 0x0 }, /* POOL32S_0~*(22) */
20321 { reserved_block , 0 , 0 , 32,
20322 0xfc0001ff, 0xc00000b8, 0 , 0,
20323 0x0 }, /* POOL32S_0~*(23) */
20324 { reserved_block , 0 , 0 , 32,
20325 0xfc0001ff, 0xc00000c0, 0 , 0,
20326 0x0 }, /* POOL32S_0~*(24) */
20327 { reserved_block , 0 , 0 , 32,
20328 0xfc0001ff, 0xc00000c8, 0 , 0,
20329 0x0 }, /* POOL32S_0~*(25) */
20330 { instruction , 0 , 0 , 32,
20331 0xfc0001ff, 0xc00000d0, &NMD::DROTRV , 0,
20332 MIPS64_ }, /* DROTRV */
20333 { instruction , 0 , 0 , 32,
20334 0xfc0001ff, 0xc00000d8, &NMD::DMUHU , 0,
20335 MIPS64_ }, /* DMUHU */
20336 { reserved_block , 0 , 0 , 32,
20337 0xfc0001ff, 0xc00000e0, 0 , 0,
20338 0x0 }, /* POOL32S_0~*(28) */
20339 { reserved_block , 0 , 0 , 32,
20340 0xfc0001ff, 0xc00000e8, 0 , 0,
20341 0x0 }, /* POOL32S_0~*(29) */
20342 { reserved_block , 0 , 0 , 32,
20343 0xfc0001ff, 0xc00000f0, 0 , 0,
20344 0x0 }, /* POOL32S_0~*(30) */
20345 { reserved_block , 0 , 0 , 32,
20346 0xfc0001ff, 0xc00000f8, 0 , 0,
20347 0x0 }, /* POOL32S_0~*(31) */
20348 { reserved_block , 0 , 0 , 32,
20349 0xfc0001ff, 0xc0000100, 0 , 0,
20350 0x0 }, /* POOL32S_0~*(32) */
20351 { reserved_block , 0 , 0 , 32,
20352 0xfc0001ff, 0xc0000108, 0 , 0,
20353 0x0 }, /* POOL32S_0~*(33) */
20354 { instruction , 0 , 0 , 32,
20355 0xfc0001ff, 0xc0000110, &NMD::DADD , 0,
20356 MIPS64_ }, /* DADD */
20357 { instruction , 0 , 0 , 32,
20358 0xfc0001ff, 0xc0000118, &NMD::DDIV , 0,
20359 MIPS64_ }, /* DDIV */
20360 { reserved_block , 0 , 0 , 32,
20361 0xfc0001ff, 0xc0000120, 0 , 0,
20362 0x0 }, /* POOL32S_0~*(36) */
20363 { reserved_block , 0 , 0 , 32,
20364 0xfc0001ff, 0xc0000128, 0 , 0,
20365 0x0 }, /* POOL32S_0~*(37) */
20366 { reserved_block , 0 , 0 , 32,
20367 0xfc0001ff, 0xc0000130, 0 , 0,
20368 0x0 }, /* POOL32S_0~*(38) */
20369 { reserved_block , 0 , 0 , 32,
20370 0xfc0001ff, 0xc0000138, 0 , 0,
20371 0x0 }, /* POOL32S_0~*(39) */
20372 { reserved_block , 0 , 0 , 32,
20373 0xfc0001ff, 0xc0000140, 0 , 0,
20374 0x0 }, /* POOL32S_0~*(40) */
20375 { reserved_block , 0 , 0 , 32,
20376 0xfc0001ff, 0xc0000148, 0 , 0,
20377 0x0 }, /* POOL32S_0~*(41) */
20378 { instruction , 0 , 0 , 32,
20379 0xfc0001ff, 0xc0000150, &NMD::DADDU , 0,
20380 MIPS64_ }, /* DADDU */
20381 { instruction , 0 , 0 , 32,
20382 0xfc0001ff, 0xc0000158, &NMD::DMOD , 0,
20383 MIPS64_ }, /* DMOD */
20384 { reserved_block , 0 , 0 , 32,
20385 0xfc0001ff, 0xc0000160, 0 , 0,
20386 0x0 }, /* POOL32S_0~*(44) */
20387 { reserved_block , 0 , 0 , 32,
20388 0xfc0001ff, 0xc0000168, 0 , 0,
20389 0x0 }, /* POOL32S_0~*(45) */
20390 { reserved_block , 0 , 0 , 32,
20391 0xfc0001ff, 0xc0000170, 0 , 0,
20392 0x0 }, /* POOL32S_0~*(46) */
20393 { reserved_block , 0 , 0 , 32,
20394 0xfc0001ff, 0xc0000178, 0 , 0,
20395 0x0 }, /* POOL32S_0~*(47) */
20396 { reserved_block , 0 , 0 , 32,
20397 0xfc0001ff, 0xc0000180, 0 , 0,
20398 0x0 }, /* POOL32S_0~*(48) */
20399 { reserved_block , 0 , 0 , 32,
20400 0xfc0001ff, 0xc0000188, 0 , 0,
20401 0x0 }, /* POOL32S_0~*(49) */
20402 { instruction , 0 , 0 , 32,
20403 0xfc0001ff, 0xc0000190, &NMD::DSUB , 0,
20404 MIPS64_ }, /* DSUB */
20405 { instruction , 0 , 0 , 32,
20406 0xfc0001ff, 0xc0000198, &NMD::DDIVU , 0,
20407 MIPS64_ }, /* DDIVU */
20408 { reserved_block , 0 , 0 , 32,
20409 0xfc0001ff, 0xc00001a0, 0 , 0,
20410 0x0 }, /* POOL32S_0~*(52) */
20411 { reserved_block , 0 , 0 , 32,
20412 0xfc0001ff, 0xc00001a8, 0 , 0,
20413 0x0 }, /* POOL32S_0~*(53) */
20414 { reserved_block , 0 , 0 , 32,
20415 0xfc0001ff, 0xc00001b0, 0 , 0,
20416 0x0 }, /* POOL32S_0~*(54) */
20417 { reserved_block , 0 , 0 , 32,
20418 0xfc0001ff, 0xc00001b8, 0 , 0,
20419 0x0 }, /* POOL32S_0~*(55) */
20420 { reserved_block , 0 , 0 , 32,
20421 0xfc0001ff, 0xc00001c0, 0 , 0,
20422 0x0 }, /* POOL32S_0~*(56) */
20423 { reserved_block , 0 , 0 , 32,
20424 0xfc0001ff, 0xc00001c8, 0 , 0,
20425 0x0 }, /* POOL32S_0~*(57) */
20426 { instruction , 0 , 0 , 32,
20427 0xfc0001ff, 0xc00001d0, &NMD::DSUBU , 0,
20428 MIPS64_ }, /* DSUBU */
20429 { instruction , 0 , 0 , 32,
20430 0xfc0001ff, 0xc00001d8, &NMD::DMODU , 0,
20431 MIPS64_ }, /* DMODU */
20432 { reserved_block , 0 , 0 , 32,
20433 0xfc0001ff, 0xc00001e0, 0 , 0,
20434 0x0 }, /* POOL32S_0~*(60) */
20435 { reserved_block , 0 , 0 , 32,
20436 0xfc0001ff, 0xc00001e8, 0 , 0,
20437 0x0 }, /* POOL32S_0~*(61) */
20438 { reserved_block , 0 , 0 , 32,
20439 0xfc0001ff, 0xc00001f0, 0 , 0,
20440 0x0 }, /* POOL32S_0~*(62) */
20441 { reserved_block , 0 , 0 , 32,
20442 0xfc0001ff, 0xc00001f8, 0 , 0,
20443 0x0 }, /* POOL32S_0~*(63) */
20444};
20445
20446
20447NMD::Pool NMD::POOL32Sxf_4[128] = {
20448 { reserved_block , 0 , 0 , 32,
20449 0xfc00ffff, 0xc000013c, 0 , 0,
20450 0x0 }, /* POOL32Sxf_4~*(0) */
20451 { reserved_block , 0 , 0 , 32,
20452 0xfc00ffff, 0xc000033c, 0 , 0,
20453 0x0 }, /* POOL32Sxf_4~*(1) */
20454 { reserved_block , 0 , 0 , 32,
20455 0xfc00ffff, 0xc000053c, 0 , 0,
20456 0x0 }, /* POOL32Sxf_4~*(2) */
20457 { reserved_block , 0 , 0 , 32,
20458 0xfc00ffff, 0xc000073c, 0 , 0,
20459 0x0 }, /* POOL32Sxf_4~*(3) */
20460 { reserved_block , 0 , 0 , 32,
20461 0xfc00ffff, 0xc000093c, 0 , 0,
20462 0x0 }, /* POOL32Sxf_4~*(4) */
20463 { reserved_block , 0 , 0 , 32,
20464 0xfc00ffff, 0xc0000b3c, 0 , 0,
20465 0x0 }, /* POOL32Sxf_4~*(5) */
20466 { reserved_block , 0 , 0 , 32,
20467 0xfc00ffff, 0xc0000d3c, 0 , 0,
20468 0x0 }, /* POOL32Sxf_4~*(6) */
20469 { reserved_block , 0 , 0 , 32,
20470 0xfc00ffff, 0xc0000f3c, 0 , 0,
20471 0x0 }, /* POOL32Sxf_4~*(7) */
20472 { reserved_block , 0 , 0 , 32,
20473 0xfc00ffff, 0xc000113c, 0 , 0,
20474 0x0 }, /* POOL32Sxf_4~*(8) */
20475 { reserved_block , 0 , 0 , 32,
20476 0xfc00ffff, 0xc000133c, 0 , 0,
20477 0x0 }, /* POOL32Sxf_4~*(9) */
20478 { reserved_block , 0 , 0 , 32,
20479 0xfc00ffff, 0xc000153c, 0 , 0,
20480 0x0 }, /* POOL32Sxf_4~*(10) */
20481 { reserved_block , 0 , 0 , 32,
20482 0xfc00ffff, 0xc000173c, 0 , 0,
20483 0x0 }, /* POOL32Sxf_4~*(11) */
20484 { reserved_block , 0 , 0 , 32,
20485 0xfc00ffff, 0xc000193c, 0 , 0,
20486 0x0 }, /* POOL32Sxf_4~*(12) */
20487 { reserved_block , 0 , 0 , 32,
20488 0xfc00ffff, 0xc0001b3c, 0 , 0,
20489 0x0 }, /* POOL32Sxf_4~*(13) */
20490 { reserved_block , 0 , 0 , 32,
20491 0xfc00ffff, 0xc0001d3c, 0 , 0,
20492 0x0 }, /* POOL32Sxf_4~*(14) */
20493 { reserved_block , 0 , 0 , 32,
20494 0xfc00ffff, 0xc0001f3c, 0 , 0,
20495 0x0 }, /* POOL32Sxf_4~*(15) */
20496 { reserved_block , 0 , 0 , 32,
20497 0xfc00ffff, 0xc000213c, 0 , 0,
20498 0x0 }, /* POOL32Sxf_4~*(16) */
20499 { reserved_block , 0 , 0 , 32,
20500 0xfc00ffff, 0xc000233c, 0 , 0,
20501 0x0 }, /* POOL32Sxf_4~*(17) */
20502 { reserved_block , 0 , 0 , 32,
20503 0xfc00ffff, 0xc000253c, 0 , 0,
20504 0x0 }, /* POOL32Sxf_4~*(18) */
20505 { reserved_block , 0 , 0 , 32,
20506 0xfc00ffff, 0xc000273c, 0 , 0,
20507 0x0 }, /* POOL32Sxf_4~*(19) */
20508 { reserved_block , 0 , 0 , 32,
20509 0xfc00ffff, 0xc000293c, 0 , 0,
20510 0x0 }, /* POOL32Sxf_4~*(20) */
20511 { reserved_block , 0 , 0 , 32,
20512 0xfc00ffff, 0xc0002b3c, 0 , 0,
20513 0x0 }, /* POOL32Sxf_4~*(21) */
20514 { reserved_block , 0 , 0 , 32,
20515 0xfc00ffff, 0xc0002d3c, 0 , 0,
20516 0x0 }, /* POOL32Sxf_4~*(22) */
20517 { reserved_block , 0 , 0 , 32,
20518 0xfc00ffff, 0xc0002f3c, 0 , 0,
20519 0x0 }, /* POOL32Sxf_4~*(23) */
20520 { reserved_block , 0 , 0 , 32,
20521 0xfc00ffff, 0xc000313c, 0 , 0,
20522 0x0 }, /* POOL32Sxf_4~*(24) */
20523 { reserved_block , 0 , 0 , 32,
20524 0xfc00ffff, 0xc000333c, 0 , 0,
20525 0x0 }, /* POOL32Sxf_4~*(25) */
20526 { reserved_block , 0 , 0 , 32,
20527 0xfc00ffff, 0xc000353c, 0 , 0,
20528 0x0 }, /* POOL32Sxf_4~*(26) */
20529 { reserved_block , 0 , 0 , 32,
20530 0xfc00ffff, 0xc000373c, 0 , 0,
20531 0x0 }, /* POOL32Sxf_4~*(27) */
20532 { reserved_block , 0 , 0 , 32,
20533 0xfc00ffff, 0xc000393c, 0 , 0,
20534 0x0 }, /* POOL32Sxf_4~*(28) */
20535 { reserved_block , 0 , 0 , 32,
20536 0xfc00ffff, 0xc0003b3c, 0 , 0,
20537 0x0 }, /* POOL32Sxf_4~*(29) */
20538 { reserved_block , 0 , 0 , 32,
20539 0xfc00ffff, 0xc0003d3c, 0 , 0,
20540 0x0 }, /* POOL32Sxf_4~*(30) */
20541 { reserved_block , 0 , 0 , 32,
20542 0xfc00ffff, 0xc0003f3c, 0 , 0,
20543 0x0 }, /* POOL32Sxf_4~*(31) */
20544 { reserved_block , 0 , 0 , 32,
20545 0xfc00ffff, 0xc000413c, 0 , 0,
20546 0x0 }, /* POOL32Sxf_4~*(32) */
20547 { reserved_block , 0 , 0 , 32,
20548 0xfc00ffff, 0xc000433c, 0 , 0,
20549 0x0 }, /* POOL32Sxf_4~*(33) */
20550 { reserved_block , 0 , 0 , 32,
20551 0xfc00ffff, 0xc000453c, 0 , 0,
20552 0x0 }, /* POOL32Sxf_4~*(34) */
20553 { reserved_block , 0 , 0 , 32,
20554 0xfc00ffff, 0xc000473c, 0 , 0,
20555 0x0 }, /* POOL32Sxf_4~*(35) */
20556 { reserved_block , 0 , 0 , 32,
20557 0xfc00ffff, 0xc000493c, 0 , 0,
20558 0x0 }, /* POOL32Sxf_4~*(36) */
20559 { instruction , 0 , 0 , 32,
20560 0xfc00ffff, 0xc0004b3c, &NMD::DCLO , 0,
20561 MIPS64_ }, /* DCLO */
20562 { reserved_block , 0 , 0 , 32,
20563 0xfc00ffff, 0xc0004d3c, 0 , 0,
20564 0x0 }, /* POOL32Sxf_4~*(38) */
20565 { reserved_block , 0 , 0 , 32,
20566 0xfc00ffff, 0xc0004f3c, 0 , 0,
20567 0x0 }, /* POOL32Sxf_4~*(39) */
20568 { reserved_block , 0 , 0 , 32,
20569 0xfc00ffff, 0xc000513c, 0 , 0,
20570 0x0 }, /* POOL32Sxf_4~*(40) */
20571 { reserved_block , 0 , 0 , 32,
20572 0xfc00ffff, 0xc000533c, 0 , 0,
20573 0x0 }, /* POOL32Sxf_4~*(41) */
20574 { reserved_block , 0 , 0 , 32,
20575 0xfc00ffff, 0xc000553c, 0 , 0,
20576 0x0 }, /* POOL32Sxf_4~*(42) */
20577 { reserved_block , 0 , 0 , 32,
20578 0xfc00ffff, 0xc000573c, 0 , 0,
20579 0x0 }, /* POOL32Sxf_4~*(43) */
20580 { reserved_block , 0 , 0 , 32,
20581 0xfc00ffff, 0xc000593c, 0 , 0,
20582 0x0 }, /* POOL32Sxf_4~*(44) */
20583 { instruction , 0 , 0 , 32,
20584 0xfc00ffff, 0xc0005b3c, &NMD::DCLZ , 0,
20585 MIPS64_ }, /* DCLZ */
20586 { reserved_block , 0 , 0 , 32,
20587 0xfc00ffff, 0xc0005d3c, 0 , 0,
20588 0x0 }, /* POOL32Sxf_4~*(46) */
20589 { reserved_block , 0 , 0 , 32,
20590 0xfc00ffff, 0xc0005f3c, 0 , 0,
20591 0x0 }, /* POOL32Sxf_4~*(47) */
20592 { reserved_block , 0 , 0 , 32,
20593 0xfc00ffff, 0xc000613c, 0 , 0,
20594 0x0 }, /* POOL32Sxf_4~*(48) */
20595 { reserved_block , 0 , 0 , 32,
20596 0xfc00ffff, 0xc000633c, 0 , 0,
20597 0x0 }, /* POOL32Sxf_4~*(49) */
20598 { reserved_block , 0 , 0 , 32,
20599 0xfc00ffff, 0xc000653c, 0 , 0,
20600 0x0 }, /* POOL32Sxf_4~*(50) */
20601 { reserved_block , 0 , 0 , 32,
20602 0xfc00ffff, 0xc000673c, 0 , 0,
20603 0x0 }, /* POOL32Sxf_4~*(51) */
20604 { reserved_block , 0 , 0 , 32,
20605 0xfc00ffff, 0xc000693c, 0 , 0,
20606 0x0 }, /* POOL32Sxf_4~*(52) */
20607 { reserved_block , 0 , 0 , 32,
20608 0xfc00ffff, 0xc0006b3c, 0 , 0,
20609 0x0 }, /* POOL32Sxf_4~*(53) */
20610 { reserved_block , 0 , 0 , 32,
20611 0xfc00ffff, 0xc0006d3c, 0 , 0,
20612 0x0 }, /* POOL32Sxf_4~*(54) */
20613 { reserved_block , 0 , 0 , 32,
20614 0xfc00ffff, 0xc0006f3c, 0 , 0,
20615 0x0 }, /* POOL32Sxf_4~*(55) */
20616 { reserved_block , 0 , 0 , 32,
20617 0xfc00ffff, 0xc000713c, 0 , 0,
20618 0x0 }, /* POOL32Sxf_4~*(56) */
20619 { reserved_block , 0 , 0 , 32,
20620 0xfc00ffff, 0xc000733c, 0 , 0,
20621 0x0 }, /* POOL32Sxf_4~*(57) */
20622 { reserved_block , 0 , 0 , 32,
20623 0xfc00ffff, 0xc000753c, 0 , 0,
20624 0x0 }, /* POOL32Sxf_4~*(58) */
20625 { reserved_block , 0 , 0 , 32,
20626 0xfc00ffff, 0xc000773c, 0 , 0,
20627 0x0 }, /* POOL32Sxf_4~*(59) */
20628 { reserved_block , 0 , 0 , 32,
20629 0xfc00ffff, 0xc000793c, 0 , 0,
20630 0x0 }, /* POOL32Sxf_4~*(60) */
20631 { reserved_block , 0 , 0 , 32,
20632 0xfc00ffff, 0xc0007b3c, 0 , 0,
20633 0x0 }, /* POOL32Sxf_4~*(61) */
20634 { reserved_block , 0 , 0 , 32,
20635 0xfc00ffff, 0xc0007d3c, 0 , 0,
20636 0x0 }, /* POOL32Sxf_4~*(62) */
20637 { reserved_block , 0 , 0 , 32,
20638 0xfc00ffff, 0xc0007f3c, 0 , 0,
20639 0x0 }, /* POOL32Sxf_4~*(63) */
20640 { reserved_block , 0 , 0 , 32,
20641 0xfc00ffff, 0xc000813c, 0 , 0,
20642 0x0 }, /* POOL32Sxf_4~*(64) */
20643 { reserved_block , 0 , 0 , 32,
20644 0xfc00ffff, 0xc000833c, 0 , 0,
20645 0x0 }, /* POOL32Sxf_4~*(65) */
20646 { reserved_block , 0 , 0 , 32,
20647 0xfc00ffff, 0xc000853c, 0 , 0,
20648 0x0 }, /* POOL32Sxf_4~*(66) */
20649 { reserved_block , 0 , 0 , 32,
20650 0xfc00ffff, 0xc000873c, 0 , 0,
20651 0x0 }, /* POOL32Sxf_4~*(67) */
20652 { reserved_block , 0 , 0 , 32,
20653 0xfc00ffff, 0xc000893c, 0 , 0,
20654 0x0 }, /* POOL32Sxf_4~*(68) */
20655 { reserved_block , 0 , 0 , 32,
20656 0xfc00ffff, 0xc0008b3c, 0 , 0,
20657 0x0 }, /* POOL32Sxf_4~*(69) */
20658 { reserved_block , 0 , 0 , 32,
20659 0xfc00ffff, 0xc0008d3c, 0 , 0,
20660 0x0 }, /* POOL32Sxf_4~*(70) */
20661 { reserved_block , 0 , 0 , 32,
20662 0xfc00ffff, 0xc0008f3c, 0 , 0,
20663 0x0 }, /* POOL32Sxf_4~*(71) */
20664 { reserved_block , 0 , 0 , 32,
20665 0xfc00ffff, 0xc000913c, 0 , 0,
20666 0x0 }, /* POOL32Sxf_4~*(72) */
20667 { reserved_block , 0 , 0 , 32,
20668 0xfc00ffff, 0xc000933c, 0 , 0,
20669 0x0 }, /* POOL32Sxf_4~*(73) */
20670 { reserved_block , 0 , 0 , 32,
20671 0xfc00ffff, 0xc000953c, 0 , 0,
20672 0x0 }, /* POOL32Sxf_4~*(74) */
20673 { reserved_block , 0 , 0 , 32,
20674 0xfc00ffff, 0xc000973c, 0 , 0,
20675 0x0 }, /* POOL32Sxf_4~*(75) */
20676 { reserved_block , 0 , 0 , 32,
20677 0xfc00ffff, 0xc000993c, 0 , 0,
20678 0x0 }, /* POOL32Sxf_4~*(76) */
20679 { reserved_block , 0 , 0 , 32,
20680 0xfc00ffff, 0xc0009b3c, 0 , 0,
20681 0x0 }, /* POOL32Sxf_4~*(77) */
20682 { reserved_block , 0 , 0 , 32,
20683 0xfc00ffff, 0xc0009d3c, 0 , 0,
20684 0x0 }, /* POOL32Sxf_4~*(78) */
20685 { reserved_block , 0 , 0 , 32,
20686 0xfc00ffff, 0xc0009f3c, 0 , 0,
20687 0x0 }, /* POOL32Sxf_4~*(79) */
20688 { reserved_block , 0 , 0 , 32,
20689 0xfc00ffff, 0xc000a13c, 0 , 0,
20690 0x0 }, /* POOL32Sxf_4~*(80) */
20691 { reserved_block , 0 , 0 , 32,
20692 0xfc00ffff, 0xc000a33c, 0 , 0,
20693 0x0 }, /* POOL32Sxf_4~*(81) */
20694 { reserved_block , 0 , 0 , 32,
20695 0xfc00ffff, 0xc000a53c, 0 , 0,
20696 0x0 }, /* POOL32Sxf_4~*(82) */
20697 { reserved_block , 0 , 0 , 32,
20698 0xfc00ffff, 0xc000a73c, 0 , 0,
20699 0x0 }, /* POOL32Sxf_4~*(83) */
20700 { reserved_block , 0 , 0 , 32,
20701 0xfc00ffff, 0xc000a93c, 0 , 0,
20702 0x0 }, /* POOL32Sxf_4~*(84) */
20703 { reserved_block , 0 , 0 , 32,
20704 0xfc00ffff, 0xc000ab3c, 0 , 0,
20705 0x0 }, /* POOL32Sxf_4~*(85) */
20706 { reserved_block , 0 , 0 , 32,
20707 0xfc00ffff, 0xc000ad3c, 0 , 0,
20708 0x0 }, /* POOL32Sxf_4~*(86) */
20709 { reserved_block , 0 , 0 , 32,
20710 0xfc00ffff, 0xc000af3c, 0 , 0,
20711 0x0 }, /* POOL32Sxf_4~*(87) */
20712 { reserved_block , 0 , 0 , 32,
20713 0xfc00ffff, 0xc000b13c, 0 , 0,
20714 0x0 }, /* POOL32Sxf_4~*(88) */
20715 { reserved_block , 0 , 0 , 32,
20716 0xfc00ffff, 0xc000b33c, 0 , 0,
20717 0x0 }, /* POOL32Sxf_4~*(89) */
20718 { reserved_block , 0 , 0 , 32,
20719 0xfc00ffff, 0xc000b53c, 0 , 0,
20720 0x0 }, /* POOL32Sxf_4~*(90) */
20721 { reserved_block , 0 , 0 , 32,
20722 0xfc00ffff, 0xc000b73c, 0 , 0,
20723 0x0 }, /* POOL32Sxf_4~*(91) */
20724 { reserved_block , 0 , 0 , 32,
20725 0xfc00ffff, 0xc000b93c, 0 , 0,
20726 0x0 }, /* POOL32Sxf_4~*(92) */
20727 { reserved_block , 0 , 0 , 32,
20728 0xfc00ffff, 0xc000bb3c, 0 , 0,
20729 0x0 }, /* POOL32Sxf_4~*(93) */
20730 { reserved_block , 0 , 0 , 32,
20731 0xfc00ffff, 0xc000bd3c, 0 , 0,
20732 0x0 }, /* POOL32Sxf_4~*(94) */
20733 { reserved_block , 0 , 0 , 32,
20734 0xfc00ffff, 0xc000bf3c, 0 , 0,
20735 0x0 }, /* POOL32Sxf_4~*(95) */
20736 { reserved_block , 0 , 0 , 32,
20737 0xfc00ffff, 0xc000c13c, 0 , 0,
20738 0x0 }, /* POOL32Sxf_4~*(96) */
20739 { reserved_block , 0 , 0 , 32,
20740 0xfc00ffff, 0xc000c33c, 0 , 0,
20741 0x0 }, /* POOL32Sxf_4~*(97) */
20742 { reserved_block , 0 , 0 , 32,
20743 0xfc00ffff, 0xc000c53c, 0 , 0,
20744 0x0 }, /* POOL32Sxf_4~*(98) */
20745 { reserved_block , 0 , 0 , 32,
20746 0xfc00ffff, 0xc000c73c, 0 , 0,
20747 0x0 }, /* POOL32Sxf_4~*(99) */
20748 { reserved_block , 0 , 0 , 32,
20749 0xfc00ffff, 0xc000c93c, 0 , 0,
20750 0x0 }, /* POOL32Sxf_4~*(100) */
20751 { reserved_block , 0 , 0 , 32,
20752 0xfc00ffff, 0xc000cb3c, 0 , 0,
20753 0x0 }, /* POOL32Sxf_4~*(101) */
20754 { reserved_block , 0 , 0 , 32,
20755 0xfc00ffff, 0xc000cd3c, 0 , 0,
20756 0x0 }, /* POOL32Sxf_4~*(102) */
20757 { reserved_block , 0 , 0 , 32,
20758 0xfc00ffff, 0xc000cf3c, 0 , 0,
20759 0x0 }, /* POOL32Sxf_4~*(103) */
20760 { reserved_block , 0 , 0 , 32,
20761 0xfc00ffff, 0xc000d13c, 0 , 0,
20762 0x0 }, /* POOL32Sxf_4~*(104) */
20763 { reserved_block , 0 , 0 , 32,
20764 0xfc00ffff, 0xc000d33c, 0 , 0,
20765 0x0 }, /* POOL32Sxf_4~*(105) */
20766 { reserved_block , 0 , 0 , 32,
20767 0xfc00ffff, 0xc000d53c, 0 , 0,
20768 0x0 }, /* POOL32Sxf_4~*(106) */
20769 { reserved_block , 0 , 0 , 32,
20770 0xfc00ffff, 0xc000d73c, 0 , 0,
20771 0x0 }, /* POOL32Sxf_4~*(107) */
20772 { reserved_block , 0 , 0 , 32,
20773 0xfc00ffff, 0xc000d93c, 0 , 0,
20774 0x0 }, /* POOL32Sxf_4~*(108) */
20775 { reserved_block , 0 , 0 , 32,
20776 0xfc00ffff, 0xc000db3c, 0 , 0,
20777 0x0 }, /* POOL32Sxf_4~*(109) */
20778 { reserved_block , 0 , 0 , 32,
20779 0xfc00ffff, 0xc000dd3c, 0 , 0,
20780 0x0 }, /* POOL32Sxf_4~*(110) */
20781 { reserved_block , 0 , 0 , 32,
20782 0xfc00ffff, 0xc000df3c, 0 , 0,
20783 0x0 }, /* POOL32Sxf_4~*(111) */
20784 { reserved_block , 0 , 0 , 32,
20785 0xfc00ffff, 0xc000e13c, 0 , 0,
20786 0x0 }, /* POOL32Sxf_4~*(112) */
20787 { reserved_block , 0 , 0 , 32,
20788 0xfc00ffff, 0xc000e33c, 0 , 0,
20789 0x0 }, /* POOL32Sxf_4~*(113) */
20790 { reserved_block , 0 , 0 , 32,
20791 0xfc00ffff, 0xc000e53c, 0 , 0,
20792 0x0 }, /* POOL32Sxf_4~*(114) */
20793 { reserved_block , 0 , 0 , 32,
20794 0xfc00ffff, 0xc000e73c, 0 , 0,
20795 0x0 }, /* POOL32Sxf_4~*(115) */
20796 { reserved_block , 0 , 0 , 32,
20797 0xfc00ffff, 0xc000e93c, 0 , 0,
20798 0x0 }, /* POOL32Sxf_4~*(116) */
20799 { reserved_block , 0 , 0 , 32,
20800 0xfc00ffff, 0xc000eb3c, 0 , 0,
20801 0x0 }, /* POOL32Sxf_4~*(117) */
20802 { reserved_block , 0 , 0 , 32,
20803 0xfc00ffff, 0xc000ed3c, 0 , 0,
20804 0x0 }, /* POOL32Sxf_4~*(118) */
20805 { reserved_block , 0 , 0 , 32,
20806 0xfc00ffff, 0xc000ef3c, 0 , 0,
20807 0x0 }, /* POOL32Sxf_4~*(119) */
20808 { reserved_block , 0 , 0 , 32,
20809 0xfc00ffff, 0xc000f13c, 0 , 0,
20810 0x0 }, /* POOL32Sxf_4~*(120) */
20811 { reserved_block , 0 , 0 , 32,
20812 0xfc00ffff, 0xc000f33c, 0 , 0,
20813 0x0 }, /* POOL32Sxf_4~*(121) */
20814 { reserved_block , 0 , 0 , 32,
20815 0xfc00ffff, 0xc000f53c, 0 , 0,
20816 0x0 }, /* POOL32Sxf_4~*(122) */
20817 { reserved_block , 0 , 0 , 32,
20818 0xfc00ffff, 0xc000f73c, 0 , 0,
20819 0x0 }, /* POOL32Sxf_4~*(123) */
20820 { reserved_block , 0 , 0 , 32,
20821 0xfc00ffff, 0xc000f93c, 0 , 0,
20822 0x0 }, /* POOL32Sxf_4~*(124) */
20823 { reserved_block , 0 , 0 , 32,
20824 0xfc00ffff, 0xc000fb3c, 0 , 0,
20825 0x0 }, /* POOL32Sxf_4~*(125) */
20826 { reserved_block , 0 , 0 , 32,
20827 0xfc00ffff, 0xc000fd3c, 0 , 0,
20828 0x0 }, /* POOL32Sxf_4~*(126) */
20829 { reserved_block , 0 , 0 , 32,
20830 0xfc00ffff, 0xc000ff3c, 0 , 0,
20831 0x0 }, /* POOL32Sxf_4~*(127) */
20832};
20833
20834
20835NMD::Pool NMD::POOL32Sxf[8] = {
20836 { reserved_block , 0 , 0 , 32,
20837 0xfc0001ff, 0xc000003c, 0 , 0,
20838 0x0 }, /* POOL32Sxf~*(0) */
20839 { reserved_block , 0 , 0 , 32,
20840 0xfc0001ff, 0xc000007c, 0 , 0,
20841 0x0 }, /* POOL32Sxf~*(1) */
20842 { reserved_block , 0 , 0 , 32,
20843 0xfc0001ff, 0xc00000bc, 0 , 0,
20844 0x0 }, /* POOL32Sxf~*(2) */
20845 { reserved_block , 0 , 0 , 32,
20846 0xfc0001ff, 0xc00000fc, 0 , 0,
20847 0x0 }, /* POOL32Sxf~*(3) */
20848 { pool , POOL32Sxf_4 , 128 , 32,
20849 0xfc0001ff, 0xc000013c, 0 , 0,
20850 0x0 }, /* POOL32Sxf_4 */
20851 { reserved_block , 0 , 0 , 32,
20852 0xfc0001ff, 0xc000017c, 0 , 0,
20853 0x0 }, /* POOL32Sxf~*(5) */
20854 { reserved_block , 0 , 0 , 32,
20855 0xfc0001ff, 0xc00001bc, 0 , 0,
20856 0x0 }, /* POOL32Sxf~*(6) */
20857 { reserved_block , 0 , 0 , 32,
20858 0xfc0001ff, 0xc00001fc, 0 , 0,
20859 0x0 }, /* POOL32Sxf~*(7) */
20860};
20861
20862
20863NMD::Pool NMD::POOL32S_4[8] = {
20864 { instruction , 0 , 0 , 32,
20865 0xfc00003f, 0xc0000004, &NMD::EXTD , 0,
20866 MIPS64_ }, /* EXTD */
20867 { instruction , 0 , 0 , 32,
20868 0xfc00003f, 0xc000000c, &NMD::EXTD32 , 0,
20869 MIPS64_ }, /* EXTD32 */
20870 { reserved_block , 0 , 0 , 32,
20871 0xfc00003f, 0xc0000014, 0 , 0,
20872 0x0 }, /* POOL32S_4~*(2) */
20873 { reserved_block , 0 , 0 , 32,
20874 0xfc00003f, 0xc000001c, 0 , 0,
20875 0x0 }, /* POOL32S_4~*(3) */
20876 { reserved_block , 0 , 0 , 32,
20877 0xfc00003f, 0xc0000024, 0 , 0,
20878 0x0 }, /* POOL32S_4~*(4) */
20879 { reserved_block , 0 , 0 , 32,
20880 0xfc00003f, 0xc000002c, 0 , 0,
20881 0x0 }, /* POOL32S_4~*(5) */
20882 { reserved_block , 0 , 0 , 32,
20883 0xfc00003f, 0xc0000034, 0 , 0,
20884 0x0 }, /* POOL32S_4~*(6) */
20885 { pool , POOL32Sxf , 8 , 32,
20886 0xfc00003f, 0xc000003c, 0 , 0,
20887 0x0 }, /* POOL32Sxf */
20888};
20889
20890
20891NMD::Pool NMD::POOL32S[8] = {
20892 { pool , POOL32S_0 , 64 , 32,
20893 0xfc000007, 0xc0000000, 0 , 0,
20894 0x0 }, /* POOL32S_0 */
20895 { reserved_block , 0 , 0 , 32,
20896 0xfc000007, 0xc0000001, 0 , 0,
20897 0x0 }, /* POOL32S~*(1) */
20898 { reserved_block , 0 , 0 , 32,
20899 0xfc000007, 0xc0000002, 0 , 0,
20900 0x0 }, /* POOL32S~*(2) */
20901 { reserved_block , 0 , 0 , 32,
20902 0xfc000007, 0xc0000003, 0 , 0,
20903 0x0 }, /* POOL32S~*(3) */
20904 { pool , POOL32S_4 , 8 , 32,
20905 0xfc000007, 0xc0000004, 0 , 0,
20906 0x0 }, /* POOL32S_4 */
20907 { reserved_block , 0 , 0 , 32,
20908 0xfc000007, 0xc0000005, 0 , 0,
20909 0x0 }, /* POOL32S~*(5) */
20910 { reserved_block , 0 , 0 , 32,
20911 0xfc000007, 0xc0000006, 0 , 0,
20912 0x0 }, /* POOL32S~*(6) */
20913 { reserved_block , 0 , 0 , 32,
20914 0xfc000007, 0xc0000007, 0 , 0,
20915 0x0 }, /* POOL32S~*(7) */
20916};
20917
20918
20919NMD::Pool NMD::P_LUI[2] = {
20920 { instruction , 0 , 0 , 32,
20921 0xfc000002, 0xe0000000, &NMD::LUI , 0,
20922 0x0 }, /* LUI */
20923 { instruction , 0 , 0 , 32,
20924 0xfc000002, 0xe0000002, &NMD::ALUIPC , 0,
20925 0x0 }, /* ALUIPC */
20926};
20927
20928
20929NMD::Pool NMD::P_GP_LH[2] = {
20930 { instruction , 0 , 0 , 32,
20931 0xfc1c0001, 0x44100000, &NMD::LH_GP_ , 0,
20932 0x0 }, /* LH[GP] */
20933 { instruction , 0 , 0 , 32,
20934 0xfc1c0001, 0x44100001, &NMD::LHU_GP_ , 0,
20935 0x0 }, /* LHU[GP] */
20936};
20937
20938
20939NMD::Pool NMD::P_GP_SH[2] = {
20940 { instruction , 0 , 0 , 32,
20941 0xfc1c0001, 0x44140000, &NMD::SH_GP_ , 0,
20942 0x0 }, /* SH[GP] */
20943 { reserved_block , 0 , 0 , 32,
20944 0xfc1c0001, 0x44140001, 0 , 0,
20945 0x0 }, /* P.GP.SH~*(1) */
20946};
20947
20948
20949NMD::Pool NMD::P_GP_CP1[4] = {
20950 { instruction , 0 , 0 , 32,
20951 0xfc1c0003, 0x44180000, &NMD::LWC1_GP_ , 0,
20952 CP1_ }, /* LWC1[GP] */
20953 { instruction , 0 , 0 , 32,
20954 0xfc1c0003, 0x44180001, &NMD::SWC1_GP_ , 0,
20955 CP1_ }, /* SWC1[GP] */
20956 { instruction , 0 , 0 , 32,
20957 0xfc1c0003, 0x44180002, &NMD::LDC1_GP_ , 0,
20958 CP1_ }, /* LDC1[GP] */
20959 { instruction , 0 , 0 , 32,
20960 0xfc1c0003, 0x44180003, &NMD::SDC1_GP_ , 0,
20961 CP1_ }, /* SDC1[GP] */
20962};
20963
20964
20965NMD::Pool NMD::P_GP_M64[4] = {
20966 { instruction , 0 , 0 , 32,
20967 0xfc1c0003, 0x441c0000, &NMD::LWU_GP_ , 0,
20968 MIPS64_ }, /* LWU[GP] */
20969 { reserved_block , 0 , 0 , 32,
20970 0xfc1c0003, 0x441c0001, 0 , 0,
20971 0x0 }, /* P.GP.M64~*(1) */
20972 { reserved_block , 0 , 0 , 32,
20973 0xfc1c0003, 0x441c0002, 0 , 0,
20974 0x0 }, /* P.GP.M64~*(2) */
20975 { reserved_block , 0 , 0 , 32,
20976 0xfc1c0003, 0x441c0003, 0 , 0,
20977 0x0 }, /* P.GP.M64~*(3) */
20978};
20979
20980
20981NMD::Pool NMD::P_GP_BH[8] = {
20982 { instruction , 0 , 0 , 32,
20983 0xfc1c0000, 0x44000000, &NMD::LB_GP_ , 0,
20984 0x0 }, /* LB[GP] */
20985 { instruction , 0 , 0 , 32,
20986 0xfc1c0000, 0x44040000, &NMD::SB_GP_ , 0,
20987 0x0 }, /* SB[GP] */
20988 { instruction , 0 , 0 , 32,
20989 0xfc1c0000, 0x44080000, &NMD::LBU_GP_ , 0,
20990 0x0 }, /* LBU[GP] */
20991 { instruction , 0 , 0 , 32,
20992 0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_ , 0,
20993 0x0 }, /* ADDIU[GP.B] */
20994 { pool , P_GP_LH , 2 , 32,
20995 0xfc1c0000, 0x44100000, 0 , 0,
20996 0x0 }, /* P.GP.LH */
20997 { pool , P_GP_SH , 2 , 32,
20998 0xfc1c0000, 0x44140000, 0 , 0,
20999 0x0 }, /* P.GP.SH */
21000 { pool , P_GP_CP1 , 4 , 32,
21001 0xfc1c0000, 0x44180000, 0 , 0,
21002 0x0 }, /* P.GP.CP1 */
21003 { pool , P_GP_M64 , 4 , 32,
21004 0xfc1c0000, 0x441c0000, 0 , 0,
21005 0x0 }, /* P.GP.M64 */
21006};
21007
21008
21009NMD::Pool NMD::P_LS_U12[16] = {
21010 { instruction , 0 , 0 , 32,
21011 0xfc00f000, 0x84000000, &NMD::LB_U12_ , 0,
21012 0x0 }, /* LB[U12] */
21013 { instruction , 0 , 0 , 32,
21014 0xfc00f000, 0x84001000, &NMD::SB_U12_ , 0,
21015 0x0 }, /* SB[U12] */
21016 { instruction , 0 , 0 , 32,
21017 0xfc00f000, 0x84002000, &NMD::LBU_U12_ , 0,
21018 0x0 }, /* LBU[U12] */
21019 { instruction , 0 , 0 , 32,
21020 0xfc00f000, 0x84003000, &NMD::PREF_U12_ , 0,
21021 0x0 }, /* PREF[U12] */
21022 { instruction , 0 , 0 , 32,
21023 0xfc00f000, 0x84004000, &NMD::LH_U12_ , 0,
21024 0x0 }, /* LH[U12] */
21025 { instruction , 0 , 0 , 32,
21026 0xfc00f000, 0x84005000, &NMD::SH_U12_ , 0,
21027 0x0 }, /* SH[U12] */
21028 { instruction , 0 , 0 , 32,
21029 0xfc00f000, 0x84006000, &NMD::LHU_U12_ , 0,
21030 0x0 }, /* LHU[U12] */
21031 { instruction , 0 , 0 , 32,
21032 0xfc00f000, 0x84007000, &NMD::LWU_U12_ , 0,
21033 MIPS64_ }, /* LWU[U12] */
21034 { instruction , 0 , 0 , 32,
21035 0xfc00f000, 0x84008000, &NMD::LW_U12_ , 0,
21036 0x0 }, /* LW[U12] */
21037 { instruction , 0 , 0 , 32,
21038 0xfc00f000, 0x84009000, &NMD::SW_U12_ , 0,
21039 0x0 }, /* SW[U12] */
21040 { instruction , 0 , 0 , 32,
21041 0xfc00f000, 0x8400a000, &NMD::LWC1_U12_ , 0,
21042 CP1_ }, /* LWC1[U12] */
21043 { instruction , 0 , 0 , 32,
21044 0xfc00f000, 0x8400b000, &NMD::SWC1_U12_ , 0,
21045 CP1_ }, /* SWC1[U12] */
21046 { instruction , 0 , 0 , 32,
21047 0xfc00f000, 0x8400c000, &NMD::LD_U12_ , 0,
21048 MIPS64_ }, /* LD[U12] */
21049 { instruction , 0 , 0 , 32,
21050 0xfc00f000, 0x8400d000, &NMD::SD_U12_ , 0,
21051 MIPS64_ }, /* SD[U12] */
21052 { instruction , 0 , 0 , 32,
21053 0xfc00f000, 0x8400e000, &NMD::LDC1_U12_ , 0,
21054 CP1_ }, /* LDC1[U12] */
21055 { instruction , 0 , 0 , 32,
21056 0xfc00f000, 0x8400f000, &NMD::SDC1_U12_ , 0,
21057 CP1_ }, /* SDC1[U12] */
21058};
21059
21060
21061NMD::Pool NMD::P_PREF_S9_[2] = {
21062 { instruction , 0 , 0 , 32,
21063 0xffe07f00, 0xa7e01800, &NMD::SYNCI , 0,
21064 0x0 }, /* SYNCI */
21065 { instruction , 0 , 0 , 32,
21066 0xfc007f00, 0xa4001800, &NMD::PREF_S9_ , &NMD::PREF_S9__cond ,
21067 0x0 }, /* PREF[S9] */
21068};
21069
21070
21071NMD::Pool NMD::P_LS_S0[16] = {
21072 { instruction , 0 , 0 , 32,
21073 0xfc007f00, 0xa4000000, &NMD::LB_S9_ , 0,
21074 0x0 }, /* LB[S9] */
21075 { instruction , 0 , 0 , 32,
21076 0xfc007f00, 0xa4000800, &NMD::SB_S9_ , 0,
21077 0x0 }, /* SB[S9] */
21078 { instruction , 0 , 0 , 32,
21079 0xfc007f00, 0xa4001000, &NMD::LBU_S9_ , 0,
21080 0x0 }, /* LBU[S9] */
21081 { pool , P_PREF_S9_ , 2 , 32,
21082 0xfc007f00, 0xa4001800, 0 , 0,
21083 0x0 }, /* P.PREF[S9] */
21084 { instruction , 0 , 0 , 32,
21085 0xfc007f00, 0xa4002000, &NMD::LH_S9_ , 0,
21086 0x0 }, /* LH[S9] */
21087 { instruction , 0 , 0 , 32,
21088 0xfc007f00, 0xa4002800, &NMD::SH_S9_ , 0,
21089 0x0 }, /* SH[S9] */
21090 { instruction , 0 , 0 , 32,
21091 0xfc007f00, 0xa4003000, &NMD::LHU_S9_ , 0,
21092 0x0 }, /* LHU[S9] */
21093 { instruction , 0 , 0 , 32,
21094 0xfc007f00, 0xa4003800, &NMD::LWU_S9_ , 0,
21095 MIPS64_ }, /* LWU[S9] */
21096 { instruction , 0 , 0 , 32,
21097 0xfc007f00, 0xa4004000, &NMD::LW_S9_ , 0,
21098 0x0 }, /* LW[S9] */
21099 { instruction , 0 , 0 , 32,
21100 0xfc007f00, 0xa4004800, &NMD::SW_S9_ , 0,
21101 0x0 }, /* SW[S9] */
21102 { instruction , 0 , 0 , 32,
21103 0xfc007f00, 0xa4005000, &NMD::LWC1_S9_ , 0,
21104 CP1_ }, /* LWC1[S9] */
21105 { instruction , 0 , 0 , 32,
21106 0xfc007f00, 0xa4005800, &NMD::SWC1_S9_ , 0,
21107 CP1_ }, /* SWC1[S9] */
21108 { instruction , 0 , 0 , 32,
21109 0xfc007f00, 0xa4006000, &NMD::LD_S9_ , 0,
21110 MIPS64_ }, /* LD[S9] */
21111 { instruction , 0 , 0 , 32,
21112 0xfc007f00, 0xa4006800, &NMD::SD_S9_ , 0,
21113 MIPS64_ }, /* SD[S9] */
21114 { instruction , 0 , 0 , 32,
21115 0xfc007f00, 0xa4007000, &NMD::LDC1_S9_ , 0,
21116 CP1_ }, /* LDC1[S9] */
21117 { instruction , 0 , 0 , 32,
21118 0xfc007f00, 0xa4007800, &NMD::SDC1_S9_ , 0,
21119 CP1_ }, /* SDC1[S9] */
21120};
21121
21122
21123NMD::Pool NMD::ASET_ACLR[2] = {
21124 { instruction , 0 , 0 , 32,
21125 0xfe007f00, 0xa4001100, &NMD::ASET , 0,
21126 MCU_ }, /* ASET */
21127 { instruction , 0 , 0 , 32,
21128 0xfe007f00, 0xa6001100, &NMD::ACLR , 0,
21129 MCU_ }, /* ACLR */
21130};
21131
21132
21133NMD::Pool NMD::P_LL[4] = {
21134 { instruction , 0 , 0 , 32,
21135 0xfc007f03, 0xa4005100, &NMD::LL , 0,
21136 0x0 }, /* LL */
21137 { instruction , 0 , 0 , 32,
21138 0xfc007f03, 0xa4005101, &NMD::LLWP , 0,
21139 XNP_ }, /* LLWP */
21140 { reserved_block , 0 , 0 , 32,
21141 0xfc007f03, 0xa4005102, 0 , 0,
21142 0x0 }, /* P.LL~*(2) */
21143 { reserved_block , 0 , 0 , 32,
21144 0xfc007f03, 0xa4005103, 0 , 0,
21145 0x0 }, /* P.LL~*(3) */
21146};
21147
21148
21149NMD::Pool NMD::P_SC[4] = {
21150 { instruction , 0 , 0 , 32,
21151 0xfc007f03, 0xa4005900, &NMD::SC , 0,
21152 0x0 }, /* SC */
21153 { instruction , 0 , 0 , 32,
21154 0xfc007f03, 0xa4005901, &NMD::SCWP , 0,
21155 XNP_ }, /* SCWP */
21156 { reserved_block , 0 , 0 , 32,
21157 0xfc007f03, 0xa4005902, 0 , 0,
21158 0x0 }, /* P.SC~*(2) */
21159 { reserved_block , 0 , 0 , 32,
21160 0xfc007f03, 0xa4005903, 0 , 0,
21161 0x0 }, /* P.SC~*(3) */
21162};
21163
21164
21165NMD::Pool NMD::P_LLD[8] = {
21166 { instruction , 0 , 0 , 32,
21167 0xfc007f07, 0xa4007100, &NMD::LLD , 0,
21168 MIPS64_ }, /* LLD */
21169 { instruction , 0 , 0 , 32,
21170 0xfc007f07, 0xa4007101, &NMD::LLDP , 0,
21171 MIPS64_ }, /* LLDP */
21172 { reserved_block , 0 , 0 , 32,
21173 0xfc007f07, 0xa4007102, 0 , 0,
21174 0x0 }, /* P.LLD~*(2) */
21175 { reserved_block , 0 , 0 , 32,
21176 0xfc007f07, 0xa4007103, 0 , 0,
21177 0x0 }, /* P.LLD~*(3) */
21178 { reserved_block , 0 , 0 , 32,
21179 0xfc007f07, 0xa4007104, 0 , 0,
21180 0x0 }, /* P.LLD~*(4) */
21181 { reserved_block , 0 , 0 , 32,
21182 0xfc007f07, 0xa4007105, 0 , 0,
21183 0x0 }, /* P.LLD~*(5) */
21184 { reserved_block , 0 , 0 , 32,
21185 0xfc007f07, 0xa4007106, 0 , 0,
21186 0x0 }, /* P.LLD~*(6) */
21187 { reserved_block , 0 , 0 , 32,
21188 0xfc007f07, 0xa4007107, 0 , 0,
21189 0x0 }, /* P.LLD~*(7) */
21190};
21191
21192
21193NMD::Pool NMD::P_SCD[8] = {
21194 { instruction , 0 , 0 , 32,
21195 0xfc007f07, 0xa4007900, &NMD::SCD , 0,
21196 MIPS64_ }, /* SCD */
21197 { instruction , 0 , 0 , 32,
21198 0xfc007f07, 0xa4007901, &NMD::SCDP , 0,
21199 MIPS64_ }, /* SCDP */
21200 { reserved_block , 0 , 0 , 32,
21201 0xfc007f07, 0xa4007902, 0 , 0,
21202 0x0 }, /* P.SCD~*(2) */
21203 { reserved_block , 0 , 0 , 32,
21204 0xfc007f07, 0xa4007903, 0 , 0,
21205 0x0 }, /* P.SCD~*(3) */
21206 { reserved_block , 0 , 0 , 32,
21207 0xfc007f07, 0xa4007904, 0 , 0,
21208 0x0 }, /* P.SCD~*(4) */
21209 { reserved_block , 0 , 0 , 32,
21210 0xfc007f07, 0xa4007905, 0 , 0,
21211 0x0 }, /* P.SCD~*(5) */
21212 { reserved_block , 0 , 0 , 32,
21213 0xfc007f07, 0xa4007906, 0 , 0,
21214 0x0 }, /* P.SCD~*(6) */
21215 { reserved_block , 0 , 0 , 32,
21216 0xfc007f07, 0xa4007907, 0 , 0,
21217 0x0 }, /* P.SCD~*(7) */
21218};
21219
21220
21221NMD::Pool NMD::P_LS_S1[16] = {
21222 { reserved_block , 0 , 0 , 32,
21223 0xfc007f00, 0xa4000100, 0 , 0,
21224 0x0 }, /* P.LS.S1~*(0) */
21225 { reserved_block , 0 , 0 , 32,
21226 0xfc007f00, 0xa4000900, 0 , 0,
21227 0x0 }, /* P.LS.S1~*(1) */
21228 { pool , ASET_ACLR , 2 , 32,
21229 0xfc007f00, 0xa4001100, 0 , 0,
21230 0x0 }, /* ASET_ACLR */
21231 { reserved_block , 0 , 0 , 32,
21232 0xfc007f00, 0xa4001900, 0 , 0,
21233 0x0 }, /* P.LS.S1~*(3) */
21234 { instruction , 0 , 0 , 32,
21235 0xfc007f00, 0xa4002100, &NMD::UALH , 0,
21236 XMMS_ }, /* UALH */
21237 { instruction , 0 , 0 , 32,
21238 0xfc007f00, 0xa4002900, &NMD::UASH , 0,
21239 XMMS_ }, /* UASH */
21240 { reserved_block , 0 , 0 , 32,
21241 0xfc007f00, 0xa4003100, 0 , 0,
21242 0x0 }, /* P.LS.S1~*(6) */
21243 { instruction , 0 , 0 , 32,
21244 0xfc007f00, 0xa4003900, &NMD::CACHE , 0,
21245 CP0_ }, /* CACHE */
21246 { instruction , 0 , 0 , 32,
21247 0xfc007f00, 0xa4004100, &NMD::LWC2 , 0,
21248 CP2_ }, /* LWC2 */
21249 { instruction , 0 , 0 , 32,
21250 0xfc007f00, 0xa4004900, &NMD::SWC2 , 0,
21251 CP2_ }, /* SWC2 */
21252 { pool , P_LL , 4 , 32,
21253 0xfc007f00, 0xa4005100, 0 , 0,
21254 0x0 }, /* P.LL */
21255 { pool , P_SC , 4 , 32,
21256 0xfc007f00, 0xa4005900, 0 , 0,
21257 0x0 }, /* P.SC */
21258 { instruction , 0 , 0 , 32,
21259 0xfc007f00, 0xa4006100, &NMD::LDC2 , 0,
21260 CP2_ }, /* LDC2 */
21261 { instruction , 0 , 0 , 32,
21262 0xfc007f00, 0xa4006900, &NMD::SDC2 , 0,
21263 CP2_ }, /* SDC2 */
21264 { pool , P_LLD , 8 , 32,
21265 0xfc007f00, 0xa4007100, 0 , 0,
21266 0x0 }, /* P.LLD */
21267 { pool , P_SCD , 8 , 32,
21268 0xfc007f00, 0xa4007900, 0 , 0,
21269 0x0 }, /* P.SCD */
21270};
21271
21272
21273NMD::Pool NMD::P_PREFE[2] = {
21274 { instruction , 0 , 0 , 32,
21275 0xffe07f00, 0xa7e01a00, &NMD::SYNCIE , 0,
21276 CP0_ | EVA_ }, /* SYNCIE */
21277 { instruction , 0 , 0 , 32,
21278 0xfc007f00, 0xa4001a00, &NMD::PREFE , &NMD::PREFE_cond ,
21279 CP0_ | EVA_ }, /* PREFE */
21280};
21281
21282
21283NMD::Pool NMD::P_LLE[4] = {
21284 { instruction , 0 , 0 , 32,
21285 0xfc007f03, 0xa4005200, &NMD::LLE , 0,
21286 CP0_ | EVA_ }, /* LLE */
21287 { instruction , 0 , 0 , 32,
21288 0xfc007f03, 0xa4005201, &NMD::LLWPE , 0,
21289 CP0_ | EVA_ }, /* LLWPE */
21290 { reserved_block , 0 , 0 , 32,
21291 0xfc007f03, 0xa4005202, 0 , 0,
21292 0x0 }, /* P.LLE~*(2) */
21293 { reserved_block , 0 , 0 , 32,
21294 0xfc007f03, 0xa4005203, 0 , 0,
21295 0x0 }, /* P.LLE~*(3) */
21296};
21297
21298
21299NMD::Pool NMD::P_SCE[4] = {
21300 { instruction , 0 , 0 , 32,
21301 0xfc007f03, 0xa4005a00, &NMD::SCE , 0,
21302 CP0_ | EVA_ }, /* SCE */
21303 { instruction , 0 , 0 , 32,
21304 0xfc007f03, 0xa4005a01, &NMD::SCWPE , 0,
21305 CP0_ | EVA_ }, /* SCWPE */
21306 { reserved_block , 0 , 0 , 32,
21307 0xfc007f03, 0xa4005a02, 0 , 0,
21308 0x0 }, /* P.SCE~*(2) */
21309 { reserved_block , 0 , 0 , 32,
21310 0xfc007f03, 0xa4005a03, 0 , 0,
21311 0x0 }, /* P.SCE~*(3) */
21312};
21313
21314
21315NMD::Pool NMD::P_LS_E0[16] = {
21316 { instruction , 0 , 0 , 32,
21317 0xfc007f00, 0xa4000200, &NMD::LBE , 0,
21318 CP0_ | EVA_ }, /* LBE */
21319 { instruction , 0 , 0 , 32,
21320 0xfc007f00, 0xa4000a00, &NMD::SBE , 0,
21321 CP0_ | EVA_ }, /* SBE */
21322 { instruction , 0 , 0 , 32,
21323 0xfc007f00, 0xa4001200, &NMD::LBUE , 0,
21324 CP0_ | EVA_ }, /* LBUE */
21325 { pool , P_PREFE , 2 , 32,
21326 0xfc007f00, 0xa4001a00, 0 , 0,
21327 0x0 }, /* P.PREFE */
21328 { instruction , 0 , 0 , 32,
21329 0xfc007f00, 0xa4002200, &NMD::LHE , 0,
21330 CP0_ | EVA_ }, /* LHE */
21331 { instruction , 0 , 0 , 32,
21332 0xfc007f00, 0xa4002a00, &NMD::SHE , 0,
21333 CP0_ | EVA_ }, /* SHE */
21334 { instruction , 0 , 0 , 32,
21335 0xfc007f00, 0xa4003200, &NMD::LHUE , 0,
21336 CP0_ | EVA_ }, /* LHUE */
21337 { instruction , 0 , 0 , 32,
21338 0xfc007f00, 0xa4003a00, &NMD::CACHEE , 0,
21339 CP0_ | EVA_ }, /* CACHEE */
21340 { instruction , 0 , 0 , 32,
21341 0xfc007f00, 0xa4004200, &NMD::LWE , 0,
21342 CP0_ | EVA_ }, /* LWE */
21343 { instruction , 0 , 0 , 32,
21344 0xfc007f00, 0xa4004a00, &NMD::SWE , 0,
21345 CP0_ | EVA_ }, /* SWE */
21346 { pool , P_LLE , 4 , 32,
21347 0xfc007f00, 0xa4005200, 0 , 0,
21348 0x0 }, /* P.LLE */
21349 { pool , P_SCE , 4 , 32,
21350 0xfc007f00, 0xa4005a00, 0 , 0,
21351 0x0 }, /* P.SCE */
21352 { reserved_block , 0 , 0 , 32,
21353 0xfc007f00, 0xa4006200, 0 , 0,
21354 0x0 }, /* P.LS.E0~*(12) */
21355 { reserved_block , 0 , 0 , 32,
21356 0xfc007f00, 0xa4006a00, 0 , 0,
21357 0x0 }, /* P.LS.E0~*(13) */
21358 { reserved_block , 0 , 0 , 32,
21359 0xfc007f00, 0xa4007200, 0 , 0,
21360 0x0 }, /* P.LS.E0~*(14) */
21361 { reserved_block , 0 , 0 , 32,
21362 0xfc007f00, 0xa4007a00, 0 , 0,
21363 0x0 }, /* P.LS.E0~*(15) */
21364};
21365
21366
21367NMD::Pool NMD::P_LS_WM[2] = {
21368 { instruction , 0 , 0 , 32,
21369 0xfc000f00, 0xa4000400, &NMD::LWM , 0,
21370 XMMS_ }, /* LWM */
21371 { instruction , 0 , 0 , 32,
21372 0xfc000f00, 0xa4000c00, &NMD::SWM , 0,
21373 XMMS_ }, /* SWM */
21374};
21375
21376
21377NMD::Pool NMD::P_LS_UAWM[2] = {
21378 { instruction , 0 , 0 , 32,
21379 0xfc000f00, 0xa4000500, &NMD::UALWM , 0,
21380 XMMS_ }, /* UALWM */
21381 { instruction , 0 , 0 , 32,
21382 0xfc000f00, 0xa4000d00, &NMD::UASWM , 0,
21383 XMMS_ }, /* UASWM */
21384};
21385
21386
21387NMD::Pool NMD::P_LS_DM[2] = {
21388 { instruction , 0 , 0 , 32,
21389 0xfc000f00, 0xa4000600, &NMD::LDM , 0,
21390 MIPS64_ }, /* LDM */
21391 { instruction , 0 , 0 , 32,
21392 0xfc000f00, 0xa4000e00, &NMD::SDM , 0,
21393 MIPS64_ }, /* SDM */
21394};
21395
21396
21397NMD::Pool NMD::P_LS_UADM[2] = {
21398 { instruction , 0 , 0 , 32,
21399 0xfc000f00, 0xa4000700, &NMD::UALDM , 0,
21400 MIPS64_ }, /* UALDM */
21401 { instruction , 0 , 0 , 32,
21402 0xfc000f00, 0xa4000f00, &NMD::UASDM , 0,
21403 MIPS64_ }, /* UASDM */
21404};
21405
21406
21407NMD::Pool NMD::P_LS_S9[8] = {
21408 { pool , P_LS_S0 , 16 , 32,
21409 0xfc000700, 0xa4000000, 0 , 0,
21410 0x0 }, /* P.LS.S0 */
21411 { pool , P_LS_S1 , 16 , 32,
21412 0xfc000700, 0xa4000100, 0 , 0,
21413 0x0 }, /* P.LS.S1 */
21414 { pool , P_LS_E0 , 16 , 32,
21415 0xfc000700, 0xa4000200, 0 , 0,
21416 0x0 }, /* P.LS.E0 */
21417 { reserved_block , 0 , 0 , 32,
21418 0xfc000700, 0xa4000300, 0 , 0,
21419 0x0 }, /* P.LS.S9~*(3) */
21420 { pool , P_LS_WM , 2 , 32,
21421 0xfc000700, 0xa4000400, 0 , 0,
21422 0x0 }, /* P.LS.WM */
21423 { pool , P_LS_UAWM , 2 , 32,
21424 0xfc000700, 0xa4000500, 0 , 0,
21425 0x0 }, /* P.LS.UAWM */
21426 { pool , P_LS_DM , 2 , 32,
21427 0xfc000700, 0xa4000600, 0 , 0,
21428 0x0 }, /* P.LS.DM */
21429 { pool , P_LS_UADM , 2 , 32,
21430 0xfc000700, 0xa4000700, 0 , 0,
21431 0x0 }, /* P.LS.UADM */
21432};
21433
21434
21435NMD::Pool NMD::P_BAL[2] = {
21436 { branch_instruction , 0 , 0 , 32,
21437 0xfe000000, 0x28000000, &NMD::BC_32_ , 0,
21438 0x0 }, /* BC[32] */
21439 { call_instruction , 0 , 0 , 32,
21440 0xfe000000, 0x2a000000, &NMD::BALC_32_ , 0,
21441 0x0 }, /* BALC[32] */
21442};
21443
21444
21445NMD::Pool NMD::P_BALRSC[2] = {
21446 { branch_instruction , 0 , 0 , 32,
21447 0xffe0f000, 0x48008000, &NMD::BRSC , 0,
21448 0x0 }, /* BRSC */
21449 { call_instruction , 0 , 0 , 32,
21450 0xfc00f000, 0x48008000, &NMD::BALRSC , &NMD::BALRSC_cond ,
21451 0x0 }, /* BALRSC */
21452};
21453
21454
21455NMD::Pool NMD::P_J[16] = {
21456 { call_instruction , 0 , 0 , 32,
21457 0xfc00f000, 0x48000000, &NMD::JALRC_32_ , 0,
21458 0x0 }, /* JALRC[32] */
21459 { call_instruction , 0 , 0 , 32,
21460 0xfc00f000, 0x48001000, &NMD::JALRC_HB , 0,
21461 0x0 }, /* JALRC.HB */
21462 { reserved_block , 0 , 0 , 32,
21463 0xfc00f000, 0x48002000, 0 , 0,
21464 0x0 }, /* P.J~*(2) */
21465 { reserved_block , 0 , 0 , 32,
21466 0xfc00f000, 0x48003000, 0 , 0,
21467 0x0 }, /* P.J~*(3) */
21468 { reserved_block , 0 , 0 , 32,
21469 0xfc00f000, 0x48004000, 0 , 0,
21470 0x0 }, /* P.J~*(4) */
21471 { reserved_block , 0 , 0 , 32,
21472 0xfc00f000, 0x48005000, 0 , 0,
21473 0x0 }, /* P.J~*(5) */
21474 { reserved_block , 0 , 0 , 32,
21475 0xfc00f000, 0x48006000, 0 , 0,
21476 0x0 }, /* P.J~*(6) */
21477 { reserved_block , 0 , 0 , 32,
21478 0xfc00f000, 0x48007000, 0 , 0,
21479 0x0 }, /* P.J~*(7) */
21480 { pool , P_BALRSC , 2 , 32,
21481 0xfc00f000, 0x48008000, 0 , 0,
21482 0x0 }, /* P.BALRSC */
21483 { reserved_block , 0 , 0 , 32,
21484 0xfc00f000, 0x48009000, 0 , 0,
21485 0x0 }, /* P.J~*(9) */
21486 { reserved_block , 0 , 0 , 32,
21487 0xfc00f000, 0x4800a000, 0 , 0,
21488 0x0 }, /* P.J~*(10) */
21489 { reserved_block , 0 , 0 , 32,
21490 0xfc00f000, 0x4800b000, 0 , 0,
21491 0x0 }, /* P.J~*(11) */
21492 { reserved_block , 0 , 0 , 32,
21493 0xfc00f000, 0x4800c000, 0 , 0,
21494 0x0 }, /* P.J~*(12) */
21495 { reserved_block , 0 , 0 , 32,
21496 0xfc00f000, 0x4800d000, 0 , 0,
21497 0x0 }, /* P.J~*(13) */
21498 { reserved_block , 0 , 0 , 32,
21499 0xfc00f000, 0x4800e000, 0 , 0,
21500 0x0 }, /* P.J~*(14) */
21501 { reserved_block , 0 , 0 , 32,
21502 0xfc00f000, 0x4800f000, 0 , 0,
21503 0x0 }, /* P.J~*(15) */
21504};
21505
21506
21507NMD::Pool NMD::P_BR3A[32] = {
21508 { branch_instruction , 0 , 0 , 32,
21509 0xfc1fc000, 0x88004000, &NMD::BC1EQZC , 0,
21510 CP1_ }, /* BC1EQZC */
21511 { branch_instruction , 0 , 0 , 32,
21512 0xfc1fc000, 0x88014000, &NMD::BC1NEZC , 0,
21513 CP1_ }, /* BC1NEZC */
21514 { branch_instruction , 0 , 0 , 32,
21515 0xfc1fc000, 0x88024000, &NMD::BC2EQZC , 0,
21516 CP2_ }, /* BC2EQZC */
21517 { branch_instruction , 0 , 0 , 32,
21518 0xfc1fc000, 0x88034000, &NMD::BC2NEZC , 0,
21519 CP2_ }, /* BC2NEZC */
21520 { branch_instruction , 0 , 0 , 32,
21521 0xfc1fc000, 0x88044000, &NMD::BPOSGE32C , 0,
21522 DSP_ }, /* BPOSGE32C */
21523 { reserved_block , 0 , 0 , 32,
21524 0xfc1fc000, 0x88054000, 0 , 0,
21525 0x0 }, /* P.BR3A~*(5) */
21526 { reserved_block , 0 , 0 , 32,
21527 0xfc1fc000, 0x88064000, 0 , 0,
21528 0x0 }, /* P.BR3A~*(6) */
21529 { reserved_block , 0 , 0 , 32,
21530 0xfc1fc000, 0x88074000, 0 , 0,
21531 0x0 }, /* P.BR3A~*(7) */
21532 { reserved_block , 0 , 0 , 32,
21533 0xfc1fc000, 0x88084000, 0 , 0,
21534 0x0 }, /* P.BR3A~*(8) */
21535 { reserved_block , 0 , 0 , 32,
21536 0xfc1fc000, 0x88094000, 0 , 0,
21537 0x0 }, /* P.BR3A~*(9) */
21538 { reserved_block , 0 , 0 , 32,
21539 0xfc1fc000, 0x880a4000, 0 , 0,
21540 0x0 }, /* P.BR3A~*(10) */
21541 { reserved_block , 0 , 0 , 32,
21542 0xfc1fc000, 0x880b4000, 0 , 0,
21543 0x0 }, /* P.BR3A~*(11) */
21544 { reserved_block , 0 , 0 , 32,
21545 0xfc1fc000, 0x880c4000, 0 , 0,
21546 0x0 }, /* P.BR3A~*(12) */
21547 { reserved_block , 0 , 0 , 32,
21548 0xfc1fc000, 0x880d4000, 0 , 0,
21549 0x0 }, /* P.BR3A~*(13) */
21550 { reserved_block , 0 , 0 , 32,
21551 0xfc1fc000, 0x880e4000, 0 , 0,
21552 0x0 }, /* P.BR3A~*(14) */
21553 { reserved_block , 0 , 0 , 32,
21554 0xfc1fc000, 0x880f4000, 0 , 0,
21555 0x0 }, /* P.BR3A~*(15) */
21556 { reserved_block , 0 , 0 , 32,
21557 0xfc1fc000, 0x88104000, 0 , 0,
21558 0x0 }, /* P.BR3A~*(16) */
21559 { reserved_block , 0 , 0 , 32,
21560 0xfc1fc000, 0x88114000, 0 , 0,
21561 0x0 }, /* P.BR3A~*(17) */
21562 { reserved_block , 0 , 0 , 32,
21563 0xfc1fc000, 0x88124000, 0 , 0,
21564 0x0 }, /* P.BR3A~*(18) */
21565 { reserved_block , 0 , 0 , 32,
21566 0xfc1fc000, 0x88134000, 0 , 0,
21567 0x0 }, /* P.BR3A~*(19) */
21568 { reserved_block , 0 , 0 , 32,
21569 0xfc1fc000, 0x88144000, 0 , 0,
21570 0x0 }, /* P.BR3A~*(20) */
21571 { reserved_block , 0 , 0 , 32,
21572 0xfc1fc000, 0x88154000, 0 , 0,
21573 0x0 }, /* P.BR3A~*(21) */
21574 { reserved_block , 0 , 0 , 32,
21575 0xfc1fc000, 0x88164000, 0 , 0,
21576 0x0 }, /* P.BR3A~*(22) */
21577 { reserved_block , 0 , 0 , 32,
21578 0xfc1fc000, 0x88174000, 0 , 0,
21579 0x0 }, /* P.BR3A~*(23) */
21580 { reserved_block , 0 , 0 , 32,
21581 0xfc1fc000, 0x88184000, 0 , 0,
21582 0x0 }, /* P.BR3A~*(24) */
21583 { reserved_block , 0 , 0 , 32,
21584 0xfc1fc000, 0x88194000, 0 , 0,
21585 0x0 }, /* P.BR3A~*(25) */
21586 { reserved_block , 0 , 0 , 32,
21587 0xfc1fc000, 0x881a4000, 0 , 0,
21588 0x0 }, /* P.BR3A~*(26) */
21589 { reserved_block , 0 , 0 , 32,
21590 0xfc1fc000, 0x881b4000, 0 , 0,
21591 0x0 }, /* P.BR3A~*(27) */
21592 { reserved_block , 0 , 0 , 32,
21593 0xfc1fc000, 0x881c4000, 0 , 0,
21594 0x0 }, /* P.BR3A~*(28) */
21595 { reserved_block , 0 , 0 , 32,
21596 0xfc1fc000, 0x881d4000, 0 , 0,
21597 0x0 }, /* P.BR3A~*(29) */
21598 { reserved_block , 0 , 0 , 32,
21599 0xfc1fc000, 0x881e4000, 0 , 0,
21600 0x0 }, /* P.BR3A~*(30) */
21601 { reserved_block , 0 , 0 , 32,
21602 0xfc1fc000, 0x881f4000, 0 , 0,
21603 0x0 }, /* P.BR3A~*(31) */
21604};
21605
21606
21607NMD::Pool NMD::P_BR1[4] = {
21608 { branch_instruction , 0 , 0 , 32,
21609 0xfc00c000, 0x88000000, &NMD::BEQC_32_ , 0,
21610 0x0 }, /* BEQC[32] */
21611 { pool , P_BR3A , 32 , 32,
21612 0xfc00c000, 0x88004000, 0 , 0,
21613 0x0 }, /* P.BR3A */
21614 { branch_instruction , 0 , 0 , 32,
21615 0xfc00c000, 0x88008000, &NMD::BGEC , 0,
21616 0x0 }, /* BGEC */
21617 { branch_instruction , 0 , 0 , 32,
21618 0xfc00c000, 0x8800c000, &NMD::BGEUC , 0,
21619 0x0 }, /* BGEUC */
21620};
21621
21622
21623NMD::Pool NMD::P_BR2[4] = {
21624 { branch_instruction , 0 , 0 , 32,
21625 0xfc00c000, 0xa8000000, &NMD::BNEC_32_ , 0,
21626 0x0 }, /* BNEC[32] */
21627 { reserved_block , 0 , 0 , 32,
21628 0xfc00c000, 0xa8004000, 0 , 0,
21629 0x0 }, /* P.BR2~*(1) */
21630 { branch_instruction , 0 , 0 , 32,
21631 0xfc00c000, 0xa8008000, &NMD::BLTC , 0,
21632 0x0 }, /* BLTC */
21633 { branch_instruction , 0 , 0 , 32,
21634 0xfc00c000, 0xa800c000, &NMD::BLTUC , 0,
21635 0x0 }, /* BLTUC */
21636};
21637
21638
21639NMD::Pool NMD::P_BRI[8] = {
21640 { branch_instruction , 0 , 0 , 32,
21641 0xfc1c0000, 0xc8000000, &NMD::BEQIC , 0,
21642 0x0 }, /* BEQIC */
21643 { branch_instruction , 0 , 0 , 32,
21644 0xfc1c0000, 0xc8040000, &NMD::BBEQZC , 0,
21645 XMMS_ }, /* BBEQZC */
21646 { branch_instruction , 0 , 0 , 32,
21647 0xfc1c0000, 0xc8080000, &NMD::BGEIC , 0,
21648 0x0 }, /* BGEIC */
21649 { branch_instruction , 0 , 0 , 32,
21650 0xfc1c0000, 0xc80c0000, &NMD::BGEIUC , 0,
21651 0x0 }, /* BGEIUC */
21652 { branch_instruction , 0 , 0 , 32,
21653 0xfc1c0000, 0xc8100000, &NMD::BNEIC , 0,
21654 0x0 }, /* BNEIC */
21655 { branch_instruction , 0 , 0 , 32,
21656 0xfc1c0000, 0xc8140000, &NMD::BBNEZC , 0,
21657 XMMS_ }, /* BBNEZC */
21658 { branch_instruction , 0 , 0 , 32,
21659 0xfc1c0000, 0xc8180000, &NMD::BLTIC , 0,
21660 0x0 }, /* BLTIC */
21661 { branch_instruction , 0 , 0 , 32,
21662 0xfc1c0000, 0xc81c0000, &NMD::BLTIUC , 0,
21663 0x0 }, /* BLTIUC */
21664};
21665
21666
21667NMD::Pool NMD::P32[32] = {
21668 { pool , P_ADDIU , 2 , 32,
21669 0xfc000000, 0x00000000, 0 , 0,
21670 0x0 }, /* P.ADDIU */
21671 { pool , P32A , 8 , 32,
21672 0xfc000000, 0x20000000, 0 , 0,
21673 0x0 }, /* P32A */
21674 { pool , P_GP_W , 4 , 32,
21675 0xfc000000, 0x40000000, 0 , 0,
21676 0x0 }, /* P.GP.W */
21677 { pool , POOL48I , 32 , 48,
21678 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21679 0x0 }, /* POOL48I */
21680 { pool , P_U12 , 16 , 32,
21681 0xfc000000, 0x80000000, 0 , 0,
21682 0x0 }, /* P.U12 */
21683 { pool , POOL32F , 8 , 32,
21684 0xfc000000, 0xa0000000, 0 , 0,
21685 CP1_ }, /* POOL32F */
21686 { pool , POOL32S , 8 , 32,
21687 0xfc000000, 0xc0000000, 0 , 0,
21688 0x0 }, /* POOL32S */
21689 { pool , P_LUI , 2 , 32,
21690 0xfc000000, 0xe0000000, 0 , 0,
21691 0x0 }, /* P.LUI */
21692 { instruction , 0 , 0 , 32,
21693 0xfc000000, 0x04000000, &NMD::ADDIUPC_32_ , 0,
21694 0x0 }, /* ADDIUPC[32] */
21695 { reserved_block , 0 , 0 , 32,
21696 0xfc000000, 0x24000000, 0 , 0,
21697 0x0 }, /* P32~*(5) */
21698 { pool , P_GP_BH , 8 , 32,
21699 0xfc000000, 0x44000000, 0 , 0,
21700 0x0 }, /* P.GP.BH */
21701 { reserved_block , 0 , 0 , 32,
21702 0xfc000000, 0x64000000, 0 , 0,
21703 0x0 }, /* P32~*(13) */
21704 { pool , P_LS_U12 , 16 , 32,
21705 0xfc000000, 0x84000000, 0 , 0,
21706 0x0 }, /* P.LS.U12 */
21707 { pool , P_LS_S9 , 8 , 32,
21708 0xfc000000, 0xa4000000, 0 , 0,
21709 0x0 }, /* P.LS.S9 */
21710 { reserved_block , 0 , 0 , 32,
21711 0xfc000000, 0xc4000000, 0 , 0,
21712 0x0 }, /* P32~*(25) */
21713 { reserved_block , 0 , 0 , 32,
21714 0xfc000000, 0xe4000000, 0 , 0,
21715 0x0 }, /* P32~*(29) */
21716 { call_instruction , 0 , 0 , 32,
21717 0xfc000000, 0x08000000, &NMD::MOVE_BALC , 0,
21718 XMMS_ }, /* MOVE.BALC */
21719 { pool , P_BAL , 2 , 32,
21720 0xfc000000, 0x28000000, 0 , 0,
21721 0x0 }, /* P.BAL */
21722 { pool , P_J , 16 , 32,
21723 0xfc000000, 0x48000000, 0 , 0,
21724 0x0 }, /* P.J */
21725 { reserved_block , 0 , 0 , 32,
21726 0xfc000000, 0x68000000, 0 , 0,
21727 0x0 }, /* P32~*(14) */
21728 { pool , P_BR1 , 4 , 32,
21729 0xfc000000, 0x88000000, 0 , 0,
21730 0x0 }, /* P.BR1 */
21731 { pool , P_BR2 , 4 , 32,
21732 0xfc000000, 0xa8000000, 0 , 0,
21733 0x0 }, /* P.BR2 */
21734 { pool , P_BRI , 8 , 32,
21735 0xfc000000, 0xc8000000, 0 , 0,
21736 0x0 }, /* P.BRI */
21737 { reserved_block , 0 , 0 , 32,
21738 0xfc000000, 0xe8000000, 0 , 0,
21739 0x0 }, /* P32~*(30) */
21740 { reserved_block , 0 , 0 , 32,
21741 0xfc000000, 0x0c000000, 0 , 0,
21742 0x0 }, /* P32~*(3) */
21743 { reserved_block , 0 , 0 , 32,
21744 0xfc000000, 0x2c000000, 0 , 0,
21745 0x0 }, /* P32~*(7) */
21746 { reserved_block , 0 , 0 , 32,
21747 0xfc000000, 0x4c000000, 0 , 0,
21748 0x0 }, /* P32~*(11) */
21749 { reserved_block , 0 , 0 , 32,
21750 0xfc000000, 0x6c000000, 0 , 0,
21751 0x0 }, /* P32~*(15) */
21752 { reserved_block , 0 , 0 , 32,
21753 0xfc000000, 0x8c000000, 0 , 0,
21754 0x0 }, /* P32~*(19) */
21755 { reserved_block , 0 , 0 , 32,
21756 0xfc000000, 0xac000000, 0 , 0,
21757 0x0 }, /* P32~*(23) */
21758 { reserved_block , 0 , 0 , 32,
21759 0xfc000000, 0xcc000000, 0 , 0,
21760 0x0 }, /* P32~*(27) */
21761 { reserved_block , 0 , 0 , 32,
21762 0xfc000000, 0xec000000, 0 , 0,
21763 0x0 }, /* P32~*(31) */
21764};
21765
21766
21767NMD::Pool NMD::P16_SYSCALL[2] = {
21768 { instruction , 0 , 0 , 16,
21769 0xfffc , 0x1008 , &NMD::SYSCALL_16_ , 0,
21770 0x0 }, /* SYSCALL[16] */
21771 { instruction , 0 , 0 , 16,
21772 0xfffc , 0x100c , &NMD::HYPCALL_16_ , 0,
21773 CP0_ | VZ_ }, /* HYPCALL[16] */
21774};
21775
21776
21777NMD::Pool NMD::P16_RI[4] = {
21778 { reserved_block , 0 , 0 , 16,
21779 0xfff8 , 0x1000 , 0 , 0,
21780 0x0 }, /* P16.RI~*(0) */
21781 { pool , P16_SYSCALL , 2 , 16,
21782 0xfff8 , 0x1008 , 0 , 0,
21783 0x0 }, /* P16.SYSCALL */
21784 { instruction , 0 , 0 , 16,
21785 0xfff8 , 0x1010 , &NMD::BREAK_16_ , 0,
21786 0x0 }, /* BREAK[16] */
21787 { instruction , 0 , 0 , 16,
21788 0xfff8 , 0x1018 , &NMD::SDBBP_16_ , 0,
21789 EJTAG_ }, /* SDBBP[16] */
21790};
21791
21792
21793NMD::Pool NMD::P16_MV[2] = {
21794 { pool , P16_RI , 4 , 16,
21795 0xffe0 , 0x1000 , 0 , 0,
21796 0x0 }, /* P16.RI */
21797 { instruction , 0 , 0 , 16,
21798 0xfc00 , 0x1000 , &NMD::MOVE , &NMD::MOVE_cond ,
21799 0x0 }, /* MOVE */
21800};
21801
21802
21803NMD::Pool NMD::P16_SHIFT[2] = {
21804 { instruction , 0 , 0 , 16,
21805 0xfc08 , 0x3000 , &NMD::SLL_16_ , 0,
21806 0x0 }, /* SLL[16] */
21807 { instruction , 0 , 0 , 16,
21808 0xfc08 , 0x3008 , &NMD::SRL_16_ , 0,
21809 0x0 }, /* SRL[16] */
21810};
21811
21812
21813NMD::Pool NMD::POOL16C_00[4] = {
21814 { instruction , 0 , 0 , 16,
21815 0xfc0f , 0x5000 , &NMD::NOT_16_ , 0,
21816 0x0 }, /* NOT[16] */
21817 { instruction , 0 , 0 , 16,
21818 0xfc0f , 0x5004 , &NMD::XOR_16_ , 0,
21819 0x0 }, /* XOR[16] */
21820 { instruction , 0 , 0 , 16,
21821 0xfc0f , 0x5008 , &NMD::AND_16_ , 0,
21822 0x0 }, /* AND[16] */
21823 { instruction , 0 , 0 , 16,
21824 0xfc0f , 0x500c , &NMD::OR_16_ , 0,
21825 0x0 }, /* OR[16] */
21826};
21827
21828
21829NMD::Pool NMD::POOL16C_0[2] = {
21830 { pool , POOL16C_00 , 4 , 16,
21831 0xfc03 , 0x5000 , 0 , 0,
21832 0x0 }, /* POOL16C_00 */
21833 { reserved_block , 0 , 0 , 16,
21834 0xfc03 , 0x5002 , 0 , 0,
21835 0x0 }, /* POOL16C_0~*(1) */
21836};
21837
21838
21839NMD::Pool NMD::P16C[2] = {
21840 { pool , POOL16C_0 , 2 , 16,
21841 0xfc01 , 0x5000 , 0 , 0,
21842 0x0 }, /* POOL16C_0 */
21843 { instruction , 0 , 0 , 16,
21844 0xfc01 , 0x5001 , &NMD::LWXS_16_ , 0,
21845 0x0 }, /* LWXS[16] */
21846};
21847
21848
21849NMD::Pool NMD::P16_A1[2] = {
21850 { reserved_block , 0 , 0 , 16,
21851 0xfc40 , 0x7000 , 0 , 0,
21852 0x0 }, /* P16.A1~*(0) */
21853 { instruction , 0 , 0 , 16,
21854 0xfc40 , 0x7040 , &NMD::ADDIU_R1_SP_ , 0,
21855 0x0 }, /* ADDIU[R1.SP] */
21856};
21857
21858
21859NMD::Pool NMD::P_ADDIU_RS5_[2] = {
21860 { instruction , 0 , 0 , 16,
21861 0xffe8 , 0x9008 , &NMD::NOP_16_ , 0,
21862 0x0 }, /* NOP[16] */
21863 { instruction , 0 , 0 , 16,
21864 0xfc08 , 0x9008 , &NMD::ADDIU_RS5_ , &NMD::ADDIU_RS5__cond ,
21865 0x0 }, /* ADDIU[RS5] */
21866};
21867
21868
21869NMD::Pool NMD::P16_A2[2] = {
21870 { instruction , 0 , 0 , 16,
21871 0xfc08 , 0x9000 , &NMD::ADDIU_R2_ , 0,
21872 0x0 }, /* ADDIU[R2] */
21873 { pool , P_ADDIU_RS5_ , 2 , 16,
21874 0xfc08 , 0x9008 , 0 , 0,
21875 0x0 }, /* P.ADDIU[RS5] */
21876};
21877
21878
21879NMD::Pool NMD::P16_ADDU[2] = {
21880 { instruction , 0 , 0 , 16,
21881 0xfc01 , 0xb000 , &NMD::ADDU_16_ , 0,
21882 0x0 }, /* ADDU[16] */
21883 { instruction , 0 , 0 , 16,
21884 0xfc01 , 0xb001 , &NMD::SUBU_16_ , 0,
21885 0x0 }, /* SUBU[16] */
21886};
21887
21888
21889NMD::Pool NMD::P16_JRC[2] = {
21890 { branch_instruction , 0 , 0 , 16,
21891 0xfc1f , 0xd800 , &NMD::JRC , 0,
21892 0x0 }, /* JRC */
21893 { call_instruction , 0 , 0 , 16,
21894 0xfc1f , 0xd810 , &NMD::JALRC_16_ , 0,
21895 0x0 }, /* JALRC[16] */
21896};
21897
21898
21899NMD::Pool NMD::P16_BR1[2] = {
21900 { branch_instruction , 0 , 0 , 16,
21901 0xfc00 , 0xd800 , &NMD::BEQC_16_ , &NMD::BEQC_16__cond ,
21902 XMMS_ }, /* BEQC[16] */
21903 { branch_instruction , 0 , 0 , 16,
21904 0xfc00 , 0xd800 , &NMD::BNEC_16_ , &NMD::BNEC_16__cond ,
21905 XMMS_ }, /* BNEC[16] */
21906};
21907
21908
21909NMD::Pool NMD::P16_BR[2] = {
21910 { pool , P16_JRC , 2 , 16,
21911 0xfc0f , 0xd800 , 0 , 0,
21912 0x0 }, /* P16.JRC */
21913 { pool , P16_BR1 , 2 , 16,
21914 0xfc00 , 0xd800 , 0 , &NMD::P16_BR1_cond ,
21915 0x0 }, /* P16.BR1 */
21916};
21917
21918
21919NMD::Pool NMD::P16_SR[2] = {
21920 { instruction , 0 , 0 , 16,
21921 0xfd00 , 0x1c00 , &NMD::SAVE_16_ , 0,
21922 0x0 }, /* SAVE[16] */
21923 { return_instruction , 0 , 0 , 16,
21924 0xfd00 , 0x1d00 , &NMD::RESTORE_JRC_16_ , 0,
21925 0x0 }, /* RESTORE.JRC[16] */
21926};
21927
21928
21929NMD::Pool NMD::P16_4X4[4] = {
21930 { instruction , 0 , 0 , 16,
21931 0xfd08 , 0x3c00 , &NMD::ADDU_4X4_ , 0,
21932 XMMS_ }, /* ADDU[4X4] */
21933 { instruction , 0 , 0 , 16,
21934 0xfd08 , 0x3c08 , &NMD::MUL_4X4_ , 0,
21935 XMMS_ }, /* MUL[4X4] */
21936 { reserved_block , 0 , 0 , 16,
21937 0xfd08 , 0x3d00 , 0 , 0,
21938 0x0 }, /* P16.4X4~*(2) */
21939 { reserved_block , 0 , 0 , 16,
21940 0xfd08 , 0x3d08 , 0 , 0,
21941 0x0 }, /* P16.4X4~*(3) */
21942};
21943
21944
21945NMD::Pool NMD::P16_LB[4] = {
21946 { instruction , 0 , 0 , 16,
21947 0xfc0c , 0x5c00 , &NMD::LB_16_ , 0,
21948 0x0 }, /* LB[16] */
21949 { instruction , 0 , 0 , 16,
21950 0xfc0c , 0x5c04 , &NMD::SB_16_ , 0,
21951 0x0 }, /* SB[16] */
21952 { instruction , 0 , 0 , 16,
21953 0xfc0c , 0x5c08 , &NMD::LBU_16_ , 0,
21954 0x0 }, /* LBU[16] */
21955 { reserved_block , 0 , 0 , 16,
21956 0xfc0c , 0x5c0c , 0 , 0,
21957 0x0 }, /* P16.LB~*(3) */
21958};
21959
21960
21961NMD::Pool NMD::P16_LH[4] = {
21962 { instruction , 0 , 0 , 16,
21963 0xfc09 , 0x7c00 , &NMD::LH_16_ , 0,
21964 0x0 }, /* LH[16] */
21965 { instruction , 0 , 0 , 16,
21966 0xfc09 , 0x7c01 , &NMD::SH_16_ , 0,
21967 0x0 }, /* SH[16] */
21968 { instruction , 0 , 0 , 16,
21969 0xfc09 , 0x7c08 , &NMD::LHU_16_ , 0,
21970 0x0 }, /* LHU[16] */
21971 { reserved_block , 0 , 0 , 16,
21972 0xfc09 , 0x7c09 , 0 , 0,
21973 0x0 }, /* P16.LH~*(3) */
21974};
21975
21976
21977NMD::Pool NMD::P16[32] = {
21978 { pool , P16_MV , 2 , 16,
21979 0xfc00 , 0x1000 , 0 , 0,
21980 0x0 }, /* P16.MV */
21981 { pool , P16_SHIFT , 2 , 16,
21982 0xfc00 , 0x3000 , 0 , 0,
21983 0x0 }, /* P16.SHIFT */
21984 { pool , P16C , 2 , 16,
21985 0xfc00 , 0x5000 , 0 , 0,
21986 0x0 }, /* P16C */
21987 { pool , P16_A1 , 2 , 16,
21988 0xfc00 , 0x7000 , 0 , 0,
21989 0x0 }, /* P16.A1 */
21990 { pool , P16_A2 , 2 , 16,
21991 0xfc00 , 0x9000 , 0 , 0,
21992 0x0 }, /* P16.A2 */
21993 { pool , P16_ADDU , 2 , 16,
21994 0xfc00 , 0xb000 , 0 , 0,
21995 0x0 }, /* P16.ADDU */
21996 { instruction , 0 , 0 , 16,
21997 0xfc00 , 0xd000 , &NMD::LI_16_ , 0,
21998 0x0 }, /* LI[16] */
21999 { instruction , 0 , 0 , 16,
22000 0xfc00 , 0xf000 , &NMD::ANDI_16_ , 0,
22001 0x0 }, /* ANDI[16] */
22002 { instruction , 0 , 0 , 16,
22003 0xfc00 , 0x1400 , &NMD::LW_16_ , 0,
22004 0x0 }, /* LW[16] */
22005 { instruction , 0 , 0 , 16,
22006 0xfc00 , 0x3400 , &NMD::LW_SP_ , 0,
22007 0x0 }, /* LW[SP] */
22008 { instruction , 0 , 0 , 16,
22009 0xfc00 , 0x5400 , &NMD::LW_GP16_ , 0,
22010 0x0 }, /* LW[GP16] */
22011 { instruction , 0 , 0 , 16,
22012 0xfc00 , 0x7400 , &NMD::LW_4X4_ , 0,
22013 XMMS_ }, /* LW[4X4] */
22014 { instruction , 0 , 0 , 16,
22015 0xfc00 , 0x9400 , &NMD::SW_16_ , 0,
22016 0x0 }, /* SW[16] */
22017 { instruction , 0 , 0 , 16,
22018 0xfc00 , 0xb400 , &NMD::SW_SP_ , 0,
22019 0x0 }, /* SW[SP] */
22020 { instruction , 0 , 0 , 16,
22021 0xfc00 , 0xd400 , &NMD::SW_GP16_ , 0,
22022 0x0 }, /* SW[GP16] */
22023 { instruction , 0 , 0 , 16,
22024 0xfc00 , 0xf400 , &NMD::SW_4X4_ , 0,
22025 XMMS_ }, /* SW[4X4] */
22026 { branch_instruction , 0 , 0 , 16,
22027 0xfc00 , 0x1800 , &NMD::BC_16_ , 0,
22028 0x0 }, /* BC[16] */
22029 { call_instruction , 0 , 0 , 16,
22030 0xfc00 , 0x3800 , &NMD::BALC_16_ , 0,
22031 0x0 }, /* BALC[16] */
22032 { reserved_block , 0 , 0 , 16,
22033 0xfc00 , 0x5800 , 0 , 0,
22034 0x0 }, /* P16~*(10) */
22035 { reserved_block , 0 , 0 , 16,
22036 0xfc00 , 0x7800 , 0 , 0,
22037 0x0 }, /* P16~*(14) */
22038 { branch_instruction , 0 , 0 , 16,
22039 0xfc00 , 0x9800 , &NMD::BEQZC_16_ , 0,
22040 0x0 }, /* BEQZC[16] */
22041 { branch_instruction , 0 , 0 , 16,
22042 0xfc00 , 0xb800 , &NMD::BNEZC_16_ , 0,
22043 0x0 }, /* BNEZC[16] */
22044 { pool , P16_BR , 2 , 16,
22045 0xfc00 , 0xd800 , 0 , 0,
22046 0x0 }, /* P16.BR */
22047 { reserved_block , 0 , 0 , 16,
22048 0xfc00 , 0xf800 , 0 , 0,
22049 0x0 }, /* P16~*(30) */
22050 { pool , P16_SR , 2 , 16,
22051 0xfc00 , 0x1c00 , 0 , 0,
22052 0x0 }, /* P16.SR */
22053 { pool , P16_4X4 , 4 , 16,
22054 0xfc00 , 0x3c00 , 0 , 0,
22055 0x0 }, /* P16.4X4 */
22056 { pool , P16_LB , 4 , 16,
22057 0xfc00 , 0x5c00 , 0 , 0,
22058 0x0 }, /* P16.LB */
22059 { pool , P16_LH , 4 , 16,
22060 0xfc00 , 0x7c00 , 0 , 0,
22061 0x0 }, /* P16.LH */
22062 { reserved_block , 0 , 0 , 16,
22063 0xfc00 , 0x9c00 , 0 , 0,
22064 0x0 }, /* P16~*(19) */
22065 { instruction , 0 , 0 , 16,
22066 0xfc00 , 0xbc00 , &NMD::MOVEP , 0,
22067 XMMS_ }, /* MOVEP */
22068 { reserved_block , 0 , 0 , 16,
22069 0xfc00 , 0xdc00 , 0 , 0,
22070 0x0 }, /* P16~*(27) */
22071 { instruction , 0 , 0 , 16,
22072 0xfc00 , 0xfc00 , &NMD::MOVEP_REV_ , 0,
22073 XMMS_ }, /* MOVEP[REV] */
22074};
22075
22076
22077NMD::Pool NMD::MAJOR[2] = {
22078 { pool , P32 , 32 , 32,
22079 0x10000000, 0x00000000, 0 , 0,
22080 0x0 }, /* P32 */
22081 { pool , P16 , 32 , 16,
22082 0x1000 , 0x1000 , 0 , 0,
22083 0x0 }, /* P16 */
22084};
Empty description
This page took 2.333422 seconds and 4 git commands to generate.