?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disas: nanoMIPS: Rename the decoder of 'gpr2.reg2' gpr encoding type
[qemu/kevin.git] / disas / nanomips.cpp
blob06d2400284641980da44e9d3f994c6a3f8ea16a1
1 /*
2 * Source file for nanoMIPS disassembler component of QEMU
3 *
4 * Copyright (C) 2018 Wave Computing, Inc.
5 * Copyright (C) 2018 Matthew Fortune <matthew.fortune@mips.com>
6 * Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 *
21 */
22
23 extern "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
39 int 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
56 int 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
135 namespace 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
259 std::string to_string(img::address a)
260 {
261 char buffer[256];
262 sprintf(buffer, "0x%" PRIx64, a);
263 return buffer;
264 }
265
266
267 uint64 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
273 int64 sign_extend(int64 data, int msb)
274 {
275 uint64 shift = 63 - msb;
276 return (data << shift) >> shift;
277 }
278
279
280 uint64 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(
288 "Invalid register mapping index %" PRIu64
289 ", size of list = %zu",
290 index, register_list_size));
291 }
292
293
294 /*
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]
343 */
344 uint64 NMD::decode_gpr_gpr3(uint64 d)
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
352 /*
353 * NMD::decode_gpr_gpr3_src_store() - decoder for 'gpr3.src.store' gpr encoding
354 * type
355 *
356 * Map a 3-bit code to the 5-bit register space according to this pattern:
357 *
358 * 7 6 5 4 3 2 1 0
359 * | | | | | | | |
360 * | | | | | | | └-----------------------┐
361 * | | | └-----------------------┐ |
362 * | | └-----------------------┐ | |
363 * | └-----------------------┐ | | |
364 * └-----------------------┐ | | | |
365 * | | | | | | | |
366 * ┌-------┘ | | | | | | |
367 * | ┌-------┘ | | | | | |
368 * | | ┌-------┘ | | | | |
369 * | | | | | | | |
370 * | | | | | | | |
371 * 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
372 * 3 2 1 0
373 *
374 * This pattern is the same one used for 'gpr3' gpr encoding type, except for
375 * the input value 0, that is mapped to the output value 0 instead of 16.
376 *
377 * Used in handling following instructions:
378 *
379 * - SB[16]
380 * - SH[16]
381 * - SW[16]
382 * - SW[GP16]
383 */
384 uint64 NMD::decode_gpr_gpr3_src_store(uint64 d)
385 {
386 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
387 return renumber_registers(d, register_list,
388 sizeof(register_list) / sizeof(register_list[0]));
389 }
390
391
392 uint64 NMD::encode_rd1_from_rd(uint64 d)
393 {
394 static uint64 register_list[] = { 4, 5 };
395 return renumber_registers(d, register_list,
396 sizeof(register_list) / sizeof(register_list[0]));
397 }
398
399
400 /*
401 * NMD::decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
402 *
403 * Map a 4-bit code to the 5-bit register space according to this pattern:
404 *
405 * 1 0
406 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
407 * | | | | | | | | | | | | | | | |
408 * | | | | | | | | | | | | └---------------------┐
409 * | | | | | | | | | | | └---------------┐ |
410 * | | | | | | | | | | └---------------┐ | |
411 * | | | | | | | | | └---------------┐ | | |
412 * | | | | | | | | └---------------┐ | | | |
413 * | | | | | | | | | | | | | | | |
414 * | | | | | | | | | | | | | | | |
415 * 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
416 * 3 2 1 0
417 *
418 * This pattern is the same one used for 'gpr4' gpr encoding type, except for
419 * the input value 3, that is mapped to the output value 0 instead of 11.
420 *
421 * Used in handling following instructions:
422 *
423 * - MOVE.BALC
424 * - MOVEP
425 * - SW[4X4]
426 */
427 uint64 NMD::decode_gpr_gpr4_zero(uint64 d)
428 {
429 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
430 16, 17, 18, 19, 20, 21, 22, 23 };
431 return renumber_registers(d, register_list,
432 sizeof(register_list) / sizeof(register_list[0]));
433 }
434
435
436 /*
437 * NMD::decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
438 *
439 * Map a 4-bit code to the 5-bit register space according to this pattern:
440 *
441 * 1 0
442 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
443 * | | | | | | | | | | | | | | | |
444 * | | | | | | | | | | | | | | | |
445 * | | | | | | | | | | | └---------------┐
446 * | | | | | | | | | | └---------------┐ |
447 * | | | | | | | | | └---------------┐ | |
448 * | | | | | | | | └---------------┐ | | |
449 * | | | | | | | | | | | | | | | |
450 * | | | | | | | | | | | | | | | |
451 * 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
452 * 3 2 1 0
453 *
454 * Used in handling following instructions:
455 *
456 * - ADDU[4X4]
457 * - LW[4X4]
458 * - MOVEP[REV]
459 * - MUL[4X4]
460 * - SW[4X4]
461 */
462 uint64 NMD::decode_gpr_gpr4(uint64 d)
463 {
464 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
465 16, 17, 18, 19, 20, 21, 22, 23 };
466 return renumber_registers(d, register_list,
467 sizeof(register_list) / sizeof(register_list[0]));
468 }
469
470
471 /*
472 * NMD::decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
473 *
474 * Map a 2-bit code to the 5-bit register space according to this pattern:
475 *
476 * 3 2 1 0
477 * | | | |
478 * | | | |
479 * | | | └-------------------┐
480 * | | └-------------------┐ |
481 * | └-------------------┐ | |
482 * └-------------------┐ | | |
483 * | | | |
484 * | | | |
485 * 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
486 * 3 2 1 0
487 *
488 * Used in handling following instructions:
489 *
490 * - MOVEP
491 * - MOVEP[REV]
492 */
493 uint64 NMD::decode_gpr_gpr2_reg1(uint64 d)
494 {
495 static uint64 register_list[] = { 4, 5, 6, 7 };
496 return renumber_registers(d, register_list,
497 sizeof(register_list) / sizeof(register_list[0]));
498 }
499
500
501 uint64 NMD::decode_gpr_gpr2_reg2(uint64 d)
502 {
503 static uint64 register_list[] = { 5, 6, 7, 8 };
504 return renumber_registers(d, register_list,
505 sizeof(register_list) / sizeof(register_list[0]));
506 }
507
508
509 uint64 NMD::copy(uint64 d)
510 {
511 return d;
512 }
513
514
515 int64 NMD::copy(int64 d)
516 {
517 return d;
518 }
519
520
521 int64 NMD::neg_copy(uint64 d)
522 {
523 return 0ll - d;
524 }
525
526
527 int64 NMD::neg_copy(int64 d)
528 {
529 return -d;
530 }
531
532
533 /* strange wrapper around gpr3 */
534 uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
535 {
536 return decode_gpr_gpr3(d);
537 }
538
539
540 /* strange wrapper around gpr3 */
541 uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
542 {
543 return decode_gpr_gpr3(d);
544 }
545
546
547 /* nop - done by extraction function */
548 uint64 NMD::encode_s_from_address(uint64 d)
549 {
550 return d;
551 }
552
553
554 /* nop - done by extraction function */
555 uint64 NMD::encode_u_from_address(uint64 d)
556 {
557 return d;
558 }
559
560
561 /* nop - done by extraction function */
562 uint64 NMD::encode_s_from_s_hi(uint64 d)
563 {
564 return d;
565 }
566
567
568 uint64 NMD::encode_count3_from_count(uint64 d)
569 {
570 IMGASSERTONCE(d < 8);
571 return d == 0ull ? 8ull : d;
572 }
573
574
575 uint64 NMD::encode_shift3_from_shift(uint64 d)
576 {
577 IMGASSERTONCE(d < 8);
578 return d == 0ull ? 8ull : d;
579 }
580
581
582 /* special value for load literal */
583 int64 NMD::encode_eu_from_s_li16(uint64 d)
584 {
585 IMGASSERTONCE(d < 128);
586 return d == 127 ? -1 : (int64)d;
587 }
588
589
590 uint64 NMD::encode_msbd_from_size(uint64 d)
591 {
592 IMGASSERTONCE(d < 32);
593 return d + 1;
594 }
595
596
597 uint64 NMD::encode_eu_from_u_andi16(uint64 d)
598 {
599 IMGASSERTONCE(d < 16);
600 if (d == 12) {
601 return 0x00ffull;
602 }
603 if (d == 13) {
604 return 0xffffull;
605 }
606 return d;
607 }
608
609
610 uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
611 {
612 IMGASSERTONCE(0);
613 return d;
614 }
615
616
617 /* save16 / restore16 ???? */
618 uint64 NMD::encode_rt1_from_rt(uint64 d)
619 {
620 return d ? 31 : 30;
621 }
622
623
624 /* ? */
625 uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
626 {
627 return d;
628 }
629
630
631 std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
632 {
633 std::string str;
634
635 for (uint64 counter = 0; counter != count; counter++) {
636 bool use_gp = gp && (counter == count - 1);
637 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
638 str += img::format(",%s", GPR(this_rt));
639 }
640
641 return str;
642 }
643
644
645 std::string NMD::GPR(uint64 reg)
646 {
647 static const char *gpr_reg[32] = {
648 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
649 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
650 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
651 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
652 };
653
654 if (reg < 32) {
655 return gpr_reg[reg];
656 }
657
658 throw std::runtime_error(img::format("Invalid GPR register index %" PRIu64,
659 reg));
660 }
661
662
663 std::string NMD::FPR(uint64 reg)
664 {
665 static const char *fpr_reg[32] = {
666 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
667 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
668 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
669 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
670 };
671
672 if (reg < 32) {
673 return fpr_reg[reg];
674 }
675
676 throw std::runtime_error(img::format("Invalid FPR register index %" PRIu64,
677 reg));
678 }
679
680
681 std::string NMD::AC(uint64 reg)
682 {
683 static const char *ac_reg[4] = {
684 "ac0", "ac1", "ac2", "ac3"
685 };
686
687 if (reg < 4) {
688 return ac_reg[reg];
689 }
690
691 throw std::runtime_error(img::format("Invalid AC register index %" PRIu64,
692 reg));
693 }
694
695
696 std::string NMD::IMMEDIATE(uint64 value)
697 {
698 return img::format("0x%" PRIx64, value);
699 }
700
701
702 std::string NMD::IMMEDIATE(int64 value)
703 {
704 return img::format("%" PRId64, value);
705 }
706
707
708 std::string NMD::CPR(uint64 reg)
709 {
710 /* needs more work */
711 return img::format("CP%" PRIu64, reg);
712 }
713
714
715 std::string NMD::ADDRESS(uint64 value, int instruction_size)
716 {
717 /* token for string replace */
718 /* const char TOKEN_REPLACE = (char)0xa2; */
719 img::address address = m_pc + value + instruction_size;
720 /* symbol replacement */
721 /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
722 return to_string(address);
723 }
724
725
726 uint64 NMD::extract_op_code_value(const uint16 * data, int size)
727 {
728 switch (size) {
729 case 16:
730 return data[0];
731 case 32:
732 return ((uint64)data[0] << 16) | data[1];
733 case 48:
734 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
735 default:
736 return data[0];
737 }
738 }
739
740
741 int NMD::Disassemble(const uint16 * data, std::string & dis,
742 NMD::TABLE_ENTRY_TYPE & type)
743 {
744 return Disassemble(data, dis, type, MAJOR, 2);
745 }
746
747
748 /*
749 * Recurse through tables until the instruction is found then return
750 * the string and size
751 *
752 * inputs:
753 * pointer to a word stream,
754 * disassember table and size
755 * returns:
756 * instruction size - negative is error
757 * disassembly string - on error will constain error string
758 */
759 int NMD::Disassemble(const uint16 * data, std::string & dis,
760 NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
761 int table_size)
762 {
763 try
764 {
765 for (int i = 0; i < table_size; i++) {
766 uint64 op_code = extract_op_code_value(data,
767 table[i].instructions_size);
768 if ((op_code & table[i].mask) == table[i].value) {
769 /* possible match */
770 conditional_function cond = table[i].condition;
771 if ((cond == 0) || (this->*cond)(op_code)) {
772 try
773 {
774 if (table[i].type == pool) {
775 return Disassemble(data, dis, type,
776 table[i].next_table,
777 table[i].next_table_size);
778 } else if ((table[i].type == instruction) ||
779 (table[i].type == call_instruction) ||
780 (table[i].type == branch_instruction) ||
781 (table[i].type == return_instruction)) {
782 if ((table[i].attributes != 0) &&
783 (m_requested_instruction_categories &
784 table[i].attributes) == 0) {
785 /*
786 * failed due to instruction having
787 * an ASE attribute and the requested version
788 * not having that attribute
789 */
790 dis = "ASE attribute missmatch";
791 return -5;
792 }
793 disassembly_function dis_fn = table[i].disassembly;
794 if (dis_fn == 0) {
795 dis = "disassembler failure - bad table entry";
796 return -6;
797 }
798 type = table[i].type;
799 dis = (this->*dis_fn)(op_code);
800 return table[i].instructions_size;
801 } else {
802 dis = "reserved instruction";
803 return -2;
804 }
805 }
806 catch (std::runtime_error & e)
807 {
808 dis = e.what();
809 return -3; /* runtime error */
810 }
811 }
812 }
813 }
814 }
815 catch (std::exception & e)
816 {
817 dis = e.what();
818 return -4; /* runtime error */
819 }
820
821 dis = "failed to disassemble";
822 return -1; /* failed to disassemble */
823 }
824
825
826 uint64 NMD::extract_code_18_to_0(uint64 instruction)
827 {
828 uint64 value = 0;
829 value |= extract_bits(instruction, 0, 19);
830 return value;
831 }
832
833
834 uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
835 {
836 uint64 value = 0;
837 value |= extract_bits(instruction, 0, 3);
838 return value;
839 }
840
841
842 uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
843 {
844 uint64 value = 0;
845 value |= extract_bits(instruction, 3, 9) << 3;
846 return value;
847 }
848
849
850 uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
851 {
852 uint64 value = 0;
853 value |= extract_bits(instruction, 0, 4);
854 return value;
855 }
856
857
858 uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
859 {
860 uint64 value = 0;
861 value |= extract_bits(instruction, 7, 3);
862 return value;
863 }
864
865
866 uint64 NMD::extract_u_17_to_1__s1(uint64 instruction)
867 {
868 uint64 value = 0;
869 value |= extract_bits(instruction, 1, 17) << 1;
870 return value;
871 }
872
873
874 int64 NMD::extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
875 {
876 int64 value = 0;
877 value |= extract_bits(instruction, 11, 10);
878 value = sign_extend(value, 9);
879 return value;
880 }
881
882
883 int64 NMD::extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
884 {
885 int64 value = 0;
886 value |= extract_bits(instruction, 0, 1) << 11;
887 value |= extract_bits(instruction, 1, 10) << 1;
888 value = sign_extend(value, 11);
889 return value;
890 }
891
892
893 uint64 NMD::extract_u_10(uint64 instruction)
894 {
895 uint64 value = 0;
896 value |= extract_bits(instruction, 10, 1);
897 return value;
898 }
899
900
901 uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
902 {
903 uint64 value = 0;
904 value |= extract_bits(instruction, 21, 3);
905 value |= extract_bits(instruction, 25, 1) << 3;
906 return value;
907 }
908
909
910 uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
911 {
912 uint64 value = 0;
913 value |= extract_bits(instruction, 11, 5);
914 return value;
915 }
916
917
918 uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
919 {
920 uint64 value = 0;
921 value |= extract_bits(instruction, 0, 5);
922 return value;
923 }
924
925
926 uint64 NMD::extract_shiftx_10_9_8_7__s1(uint64 instruction)
927 {
928 uint64 value = 0;
929 value |= extract_bits(instruction, 7, 4) << 1;
930 return value;
931 }
932
933
934 uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
935 {
936 uint64 value = 0;
937 value |= extract_bits(instruction, 21, 5);
938 return value;
939 }
940
941
942 uint64 NMD::extract_count3_14_13_12(uint64 instruction)
943 {
944 uint64 value = 0;
945 value |= extract_bits(instruction, 12, 3);
946 return value;
947 }
948
949
950 int64 NMD::extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
951 {
952 int64 value = 0;
953 value |= extract_bits(instruction, 0, 1) << 31;
954 value |= extract_bits(instruction, 2, 10) << 21;
955 value |= extract_bits(instruction, 12, 9) << 12;
956 value = sign_extend(value, 31);
957 return value;
958 }
959
960
961 int64 NMD::extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
962 {
963 int64 value = 0;
964 value |= extract_bits(instruction, 0, 1) << 7;
965 value |= extract_bits(instruction, 1, 6) << 1;
966 value = sign_extend(value, 7);
967 return value;
968 }
969
970
971 uint64 NMD::extract_u2_10_9(uint64 instruction)
972 {
973 uint64 value = 0;
974 value |= extract_bits(instruction, 9, 2);
975 return value;
976 }
977
978
979 uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
980 {
981 uint64 value = 0;
982 value |= extract_bits(instruction, 16, 10);
983 return value;
984 }
985
986
987 uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
988 {
989 uint64 value = 0;
990 value |= extract_bits(instruction, 16, 5);
991 return value;
992 }
993
994
995 uint64 NMD::extract_u_2_1__s1(uint64 instruction)
996 {
997 uint64 value = 0;
998 value |= extract_bits(instruction, 1, 2) << 1;
999 return value;
1000 }
1001
1002
1003 uint64 NMD::extract_stripe_6(uint64 instruction)
1004 {
1005 uint64 value = 0;
1006 value |= extract_bits(instruction, 6, 1);
1007 return value;
1008 }
1009
1010
1011 uint64 NMD::extract_ac_13_12(uint64 instruction)
1012 {
1013 uint64 value = 0;
1014 value |= extract_bits(instruction, 14, 2);
1015 return value;
1016 }
1017
1018
1019 uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
1020 {
1021 uint64 value = 0;
1022 value |= extract_bits(instruction, 16, 5);
1023 return value;
1024 }
1025
1026
1027 uint64 NMD::extract_rdl_25_24(uint64 instruction)
1028 {
1029 uint64 value = 0;
1030 value |= extract_bits(instruction, 24, 1);
1031 return value;
1032 }
1033
1034
1035 int64 NMD::extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
1036 {
1037 int64 value = 0;
1038 value |= extract_bits(instruction, 0, 1) << 10;
1039 value |= extract_bits(instruction, 1, 9) << 1;
1040 value = sign_extend(value, 10);
1041 return value;
1042 }
1043
1044
1045 uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
1046 {
1047 uint64 value = 0;
1048 value |= extract_bits(instruction, 0, 7);
1049 return value;
1050 }
1051
1052
1053 uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
1054 {
1055 uint64 value = 0;
1056 value |= extract_bits(instruction, 0, 6);
1057 return value;
1058 }
1059
1060
1061 uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
1062 {
1063 uint64 value = 0;
1064 value |= extract_bits(instruction, 16, 4);
1065 return value;
1066 }
1067
1068
1069 uint64 NMD::extract_code_2_1_0(uint64 instruction)
1070 {
1071 uint64 value = 0;
1072 value |= extract_bits(instruction, 0, 3);
1073 return value;
1074 }
1075
1076
1077 uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
1078 {
1079 uint64 value = 0;
1080 value |= extract_bits(instruction, 0, 12);
1081 return value;
1082 }
1083
1084
1085 uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
1086 {
1087 uint64 value = 0;
1088 value |= extract_bits(instruction, 0, 5);
1089 return value;
1090 }
1091
1092
1093 uint64 NMD::extract_u_20_to_3__s3(uint64 instruction)
1094 {
1095 uint64 value = 0;
1096 value |= extract_bits(instruction, 3, 18) << 3;
1097 return value;
1098 }
1099
1100
1101 uint64 NMD::extract_u_3_2_1_0__s2(uint64 instruction)
1102 {
1103 uint64 value = 0;
1104 value |= extract_bits(instruction, 0, 4) << 2;
1105 return value;
1106 }
1107
1108
1109 uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
1110 {
1111 uint64 value = 0;
1112 value |= extract_bits(instruction, 3, 23);
1113 return value;
1114 }
1115
1116
1117 uint64 NMD::extract_u_2_1_0__s2(uint64 instruction)
1118 {
1119 uint64 value = 0;
1120 value |= extract_bits(instruction, 0, 3) << 2;
1121 return value;
1122 }
1123
1124
1125 uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
1126 {
1127 uint64 value = 0;
1128 value |= extract_bits(instruction, 1, 3);
1129 return value;
1130 }
1131
1132
1133 uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
1134 {
1135 uint64 value = 0;
1136 value |= extract_bits(instruction, 12, 4);
1137 return value;
1138 }
1139
1140
1141 uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
1142 {
1143 uint64 value = 0;
1144 value |= extract_bits(instruction, 21, 5);
1145 return value;
1146 }
1147
1148
1149 uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
1150 {
1151 uint64 value = 0;
1152 value |= extract_bits(instruction, 3, 5);
1153 return value;
1154 }
1155
1156
1157 uint64 NMD::extract_u_17_to_0(uint64 instruction)
1158 {
1159 uint64 value = 0;
1160 value |= extract_bits(instruction, 0, 18);
1161 return value;
1162 }
1163
1164
1165 uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
1166 {
1167 uint64 value = 0;
1168 value |= extract_bits(instruction, 0, 3);
1169 value |= extract_bits(instruction, 4, 1) << 3;
1170 return value;
1171 }
1172
1173
1174 int64 NMD::extract_s__se21_0_20_to_1_s1(uint64 instruction)
1175 {
1176 int64 value = 0;
1177 value |= extract_bits(instruction, 0, 1) << 21;
1178 value |= extract_bits(instruction, 1, 20) << 1;
1179 value = sign_extend(value, 21);
1180 return value;
1181 }
1182
1183
1184 uint64 NMD::extract_op_25_to_3(uint64 instruction)
1185 {
1186 uint64 value = 0;
1187 value |= extract_bits(instruction, 3, 23);
1188 return value;
1189 }
1190
1191
1192 uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
1193 {
1194 uint64 value = 0;
1195 value |= extract_bits(instruction, 0, 3);
1196 value |= extract_bits(instruction, 4, 1) << 3;
1197 return value;
1198 }
1199
1200
1201 uint64 NMD::extract_bit_23_22_21(uint64 instruction)
1202 {
1203 uint64 value = 0;
1204 value |= extract_bits(instruction, 21, 3);
1205 return value;
1206 }
1207
1208
1209 uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
1210 {
1211 uint64 value = 0;
1212 value |= extract_bits(instruction, 37, 5);
1213 return value;
1214 }
1215
1216
1217 int64 NMD::extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
1218 {
1219 int64 value = 0;
1220 value |= extract_bits(instruction, 16, 6);
1221 value = sign_extend(value, 5);
1222 return value;
1223 }
1224
1225
1226 uint64 NMD::extract_rd2_3_8(uint64 instruction)
1227 {
1228 uint64 value = 0;
1229 value |= extract_bits(instruction, 3, 1) << 1;
1230 value |= extract_bits(instruction, 8, 1);
1231 return value;
1232 }
1233
1234
1235 uint64 NMD::extract_code_17_to_0(uint64 instruction)
1236 {
1237 uint64 value = 0;
1238 value |= extract_bits(instruction, 0, 18);
1239 return value;
1240 }
1241
1242
1243 uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
1244 {
1245 uint64 value = 0;
1246 value |= extract_bits(instruction, 16, 5);
1247 return value;
1248 }
1249
1250
1251 int64 NMD::extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
1252 {
1253 int64 value = 0;
1254 value |= extract_bits(instruction, 2, 6) << 2;
1255 value |= extract_bits(instruction, 15, 1) << 8;
1256 value = sign_extend(value, 8);
1257 return value;
1258 }
1259
1260
1261 uint64 NMD::extract_u_15_to_0(uint64 instruction)
1262 {
1263 uint64 value = 0;
1264 value |= extract_bits(instruction, 0, 16);
1265 return value;
1266 }
1267
1268
1269 uint64 NMD::extract_fs_20_19_18_17_16(uint64 instruction)
1270 {
1271 uint64 value = 0;
1272 value |= extract_bits(instruction, 16, 5);
1273 return value;
1274 }
1275
1276
1277 int64 NMD::extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
1278 {
1279 int64 value = 0;
1280 value |= extract_bits(instruction, 0, 8);
1281 value |= extract_bits(instruction, 15, 1) << 8;
1282 value = sign_extend(value, 8);
1283 return value;
1284 }
1285
1286
1287 uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
1288 {
1289 uint64 value = 0;
1290 value |= extract_bits(instruction, 16, 5);
1291 return value;
1292 }
1293
1294
1295 uint64 NMD::extract_rtl_11(uint64 instruction)
1296 {
1297 uint64 value = 0;
1298 value |= extract_bits(instruction, 9, 1);
1299 return value;
1300 }
1301
1302
1303 uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
1304 {
1305 uint64 value = 0;
1306 value |= extract_bits(instruction, 16, 5);
1307 return value;
1308 }
1309
1310
1311 uint64 NMD::extract_sel_13_12_11(uint64 instruction)
1312 {
1313 uint64 value = 0;
1314 value |= extract_bits(instruction, 11, 3);
1315 return value;
1316 }
1317
1318
1319 uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
1320 {
1321 uint64 value = 0;
1322 value |= extract_bits(instruction, 0, 5);
1323 return value;
1324 }
1325
1326
1327 uint64 NMD::extract_gp_2(uint64 instruction)
1328 {
1329 uint64 value = 0;
1330 value |= extract_bits(instruction, 2, 1);
1331 return value;
1332 }
1333
1334
1335 uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
1336 {
1337 uint64 value = 0;
1338 value |= extract_bits(instruction, 7, 3);
1339 return value;
1340 }
1341
1342
1343 uint64 NMD::extract_ft_25_24_23_22_21(uint64 instruction)
1344 {
1345 uint64 value = 0;
1346 value |= extract_bits(instruction, 21, 5);
1347 return value;
1348 }
1349
1350
1351 uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
1352 {
1353 uint64 value = 0;
1354 value |= extract_bits(instruction, 11, 7);
1355 return value;
1356 }
1357
1358
1359 uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
1360 {
1361 uint64 value = 0;
1362 value |= extract_bits(instruction, 16, 5);
1363 return value;
1364 }
1365
1366
1367 uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
1368 {
1369 uint64 value = 0;
1370 value |= extract_bits(instruction, 5, 3);
1371 value |= extract_bits(instruction, 9, 1) << 3;
1372 return value;
1373 }
1374
1375
1376 uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
1377 {
1378 uint64 value = 0;
1379 value |= extract_bits(instruction, 6, 5);
1380 return value;
1381 }
1382
1383
1384 uint64 NMD::extract_u_5_4_3_2_1_0__s2(uint64 instruction)
1385 {
1386 uint64 value = 0;
1387 value |= extract_bits(instruction, 0, 6) << 2;
1388 return value;
1389 }
1390
1391
1392 uint64 NMD::extract_sa_15_14_13(uint64 instruction)
1393 {
1394 uint64 value = 0;
1395 value |= extract_bits(instruction, 13, 3);
1396 return value;
1397 }
1398
1399
1400 int64 NMD::extract_s__se14_0_13_to_1_s1(uint64 instruction)
1401 {
1402 int64 value = 0;
1403 value |= extract_bits(instruction, 0, 1) << 14;
1404 value |= extract_bits(instruction, 1, 13) << 1;
1405 value = sign_extend(value, 14);
1406 return value;
1407 }
1408
1409
1410 uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
1411 {
1412 uint64 value = 0;
1413 value |= extract_bits(instruction, 4, 3);
1414 return value;
1415 }
1416
1417
1418 uint64 NMD::extract_u_31_to_0__s32(uint64 instruction)
1419 {
1420 uint64 value = 0;
1421 value |= extract_bits(instruction, 0, 32) << 32;
1422 return value;
1423 }
1424
1425
1426 uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
1427 {
1428 uint64 value = 0;
1429 value |= extract_bits(instruction, 6, 5);
1430 return value;
1431 }
1432
1433
1434 uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
1435 {
1436 uint64 value = 0;
1437 value |= extract_bits(instruction, 21, 5);
1438 return value;
1439 }
1440
1441
1442 uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1443 {
1444 uint64 value = 0;
1445 value |= extract_bits(instruction, 6, 6);
1446 return value;
1447 }
1448
1449
1450 uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
1451 {
1452 uint64 value = 0;
1453 value |= extract_bits(instruction, 5, 5);
1454 return value;
1455 }
1456
1457
1458 uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
1459 {
1460 uint64 value = 0;
1461 value |= extract_bits(instruction, 21, 5);
1462 return value;
1463 }
1464
1465
1466 uint64 NMD::extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
1467 {
1468 uint64 value = 0;
1469 value |= extract_bits(instruction, 0, 7) << 2;
1470 return value;
1471 }
1472
1473
1474 uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
1475 {
1476 uint64 value = 0;
1477 value |= extract_bits(instruction, 11, 6);
1478 return value;
1479 }
1480
1481
1482 uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1483 {
1484 uint64 value = 0;
1485 value |= extract_bits(instruction, 14, 7);
1486 return value;
1487 }
1488
1489
1490 uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
1491 {
1492 uint64 value = 0;
1493 value |= extract_bits(instruction, 0, 4);
1494 return value;
1495 }
1496
1497
1498 uint64 NMD::extract_u_7_6_5_4__s4(uint64 instruction)
1499 {
1500 uint64 value = 0;
1501 value |= extract_bits(instruction, 4, 4) << 4;
1502 return value;
1503 }
1504
1505
1506 int64 NMD::extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
1507 {
1508 int64 value = 0;
1509 value |= extract_bits(instruction, 3, 5) << 3;
1510 value |= extract_bits(instruction, 15, 1) << 8;
1511 value = sign_extend(value, 8);
1512 return value;
1513 }
1514
1515
1516 uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
1517 {
1518 uint64 value = 0;
1519 value |= extract_bits(instruction, 11, 5);
1520 return value;
1521 }
1522
1523
1524 int64 NMD::extract_s__se31_15_to_0_31_to_16(uint64 instruction)
1525 {
1526 int64 value = 0;
1527 value |= extract_bits(instruction, 0, 16) << 16;
1528 value |= extract_bits(instruction, 16, 16);
1529 value = sign_extend(value, 31);
1530 return value;
1531 }
1532
1533
1534 uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1535 {
1536 uint64 value = 0;
1537 value |= extract_bits(instruction, 13, 8);
1538 return value;
1539 }
1540
1541
1542 uint64 NMD::extract_u_17_to_2__s2(uint64 instruction)
1543 {
1544 uint64 value = 0;
1545 value |= extract_bits(instruction, 2, 16) << 2;
1546 return value;
1547 }
1548
1549
1550 uint64 NMD::extract_rd_15_14_13_12_11(uint64 instruction)
1551 {
1552 uint64 value = 0;
1553 value |= extract_bits(instruction, 11, 5);
1554 return value;
1555 }
1556
1557
1558 uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
1559 {
1560 uint64 value = 0;
1561 value |= extract_bits(instruction, 16, 5);
1562 return value;
1563 }
1564
1565
1566 uint64 NMD::extract_code_1_0(uint64 instruction)
1567 {
1568 uint64 value = 0;
1569 value |= extract_bits(instruction, 0, 2);
1570 return value;
1571 }
1572
1573
1574 int64 NMD::extract_s__se25_0_24_to_1_s1(uint64 instruction)
1575 {
1576 int64 value = 0;
1577 value |= extract_bits(instruction, 0, 1) << 25;
1578 value |= extract_bits(instruction, 1, 24) << 1;
1579 value = sign_extend(value, 25);
1580 return value;
1581 }
1582
1583
1584 uint64 NMD::extract_u_1_0(uint64 instruction)
1585 {
1586 uint64 value = 0;
1587 value |= extract_bits(instruction, 0, 2);
1588 return value;
1589 }
1590
1591
1592 uint64 NMD::extract_u_3_8__s2(uint64 instruction)
1593 {
1594 uint64 value = 0;
1595 value |= extract_bits(instruction, 3, 1) << 3;
1596 value |= extract_bits(instruction, 8, 1) << 2;
1597 return value;
1598 }
1599
1600
1601 uint64 NMD::extract_fd_15_14_13_12_11(uint64 instruction)
1602 {
1603 uint64 value = 0;
1604 value |= extract_bits(instruction, 11, 5);
1605 return value;
1606 }
1607
1608
1609 uint64 NMD::extract_u_4_3_2_1_0__s2(uint64 instruction)
1610 {
1611 uint64 value = 0;
1612 value |= extract_bits(instruction, 0, 5) << 2;
1613 return value;
1614 }
1615
1616
1617 uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
1618 {
1619 uint64 value = 0;
1620 value |= extract_bits(instruction, 5, 3);
1621 value |= extract_bits(instruction, 9, 1) << 3;
1622 return value;
1623 }
1624
1625
1626 uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
1627 {
1628 uint64 value = 0;
1629 value |= extract_bits(instruction, 11, 5);
1630 return value;
1631 }
1632
1633
1634 uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
1635 {
1636 uint64 value = 0;
1637 value |= extract_bits(instruction, 21, 5);
1638 return value;
1639 }
1640
1641
1642 uint64 NMD::extract_u_20_to_2__s2(uint64 instruction)
1643 {
1644 uint64 value = 0;
1645 value |= extract_bits(instruction, 2, 19) << 2;
1646 return value;
1647 }
1648
1649
1650 int64 NMD::extract_s__se3_4_2_1_0(uint64 instruction)
1651 {
1652 int64 value = 0;
1653 value |= extract_bits(instruction, 0, 3);
1654 value |= extract_bits(instruction, 4, 1) << 3;
1655 value = sign_extend(value, 3);
1656 return value;
1657 }
1658
1659
1660 uint64 NMD::extract_u_3_2_1_0__s1(uint64 instruction)
1661 {
1662 uint64 value = 0;
1663 value |= extract_bits(instruction, 0, 4) << 1;
1664 return value;
1665 }
1666
1667
1668
1669 bool NMD::ADDIU_32__cond(uint64 instruction)
1670 {
1671 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1672 return rt != 0;
1673 }
1674
1675
1676 bool NMD::ADDIU_RS5__cond(uint64 instruction)
1677 {
1678 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1679 return rt != 0;
1680 }
1681
1682
1683 bool NMD::BALRSC_cond(uint64 instruction)
1684 {
1685 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1686 return rt != 0;
1687 }
1688
1689
1690 bool NMD::BEQC_16__cond(uint64 instruction)
1691 {
1692 uint64 rs3 = extract_rs3_6_5_4(instruction);
1693 uint64 rt3 = extract_rt3_9_8_7(instruction);
1694 uint64 u = extract_u_3_2_1_0__s1(instruction);
1695 return rs3 < rt3 && u != 0;
1696 }
1697
1698
1699 bool NMD::BNEC_16__cond(uint64 instruction)
1700 {
1701 uint64 rs3 = extract_rs3_6_5_4(instruction);
1702 uint64 rt3 = extract_rt3_9_8_7(instruction);
1703 uint64 u = extract_u_3_2_1_0__s1(instruction);
1704 return rs3 >= rt3 && u != 0;
1705 }
1706
1707
1708 bool NMD::MOVE_cond(uint64 instruction)
1709 {
1710 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1711 return rt != 0;
1712 }
1713
1714
1715 bool NMD::P16_BR1_cond(uint64 instruction)
1716 {
1717 uint64 u = extract_u_3_2_1_0__s1(instruction);
1718 return u != 0;
1719 }
1720
1721
1722 bool NMD::PREF_S9__cond(uint64 instruction)
1723 {
1724 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1725 return hint != 31;
1726 }
1727
1728
1729 bool NMD::PREFE_cond(uint64 instruction)
1730 {
1731 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1732 return hint != 31;
1733 }
1734
1735
1736 bool NMD::SLTU_cond(uint64 instruction)
1737 {
1738 uint64 rd = extract_rd_15_14_13_12_11(instruction);
1739 return rd != 0;
1740 }
1741
1742
1743
1744 /*
1745 * ABS.D fd, fs - Floating Point Absolute Value
1746 *
1747 * 3 2 1
1748 * 10987654321098765432109876543210
1749 * 010001 00000 000101
1750 * fmt -----
1751 * fs -----
1752 * fd -----
1753 */
1754 std::string NMD::ABS_D(uint64 instruction)
1755 {
1756 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1757 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1758
1759 std::string fs = FPR(copy(fs_value));
1760 std::string fd = FPR(copy(fd_value));
1761
1762 return img::format("ABS.D %s, %s", fd, fs);
1763 }
1764
1765
1766 /*
1767 * ABS.S fd, fs - Floating Point Absolute Value
1768 *
1769 * 3 2 1
1770 * 10987654321098765432109876543210
1771 * 010001 00000 000101
1772 * fmt -----
1773 * fd -----
1774 * fs -----
1775 */
1776 std::string NMD::ABS_S(uint64 instruction)
1777 {
1778 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1779 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1780
1781 std::string fs = FPR(copy(fs_value));
1782 std::string fd = FPR(copy(fd_value));
1783
1784 return img::format("ABS.S %s, %s", fd, fs);
1785 }
1786
1787
1788 /*
1789 * ABSQ_S.PH rt, rs - Find Absolute Value of Two Fractional Halfwords
1790 *
1791 * 3 2 1
1792 * 10987654321098765432109876543210
1793 * 001000 0001000100111111
1794 * rt -----
1795 * rs -----
1796 */
1797 std::string NMD::ABSQ_S_PH(uint64 instruction)
1798 {
1799 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1800 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1801
1802 std::string rt = GPR(copy(rt_value));
1803 std::string rs = GPR(copy(rs_value));
1804
1805 return img::format("ABSQ_S.PH %s, %s", rt, rs);
1806 }
1807
1808
1809 /*
1810 * ABSQ_S.QB rt, rs - Find Absolute Value of Four Fractional Byte Values
1811 *
1812 * 3 2 1
1813 * 10987654321098765432109876543210
1814 * 001000 0000000100111111
1815 * rt -----
1816 * rs -----
1817 */
1818 std::string NMD::ABSQ_S_QB(uint64 instruction)
1819 {
1820 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1821 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1822
1823 std::string rt = GPR(copy(rt_value));
1824 std::string rs = GPR(copy(rs_value));
1825
1826 return img::format("ABSQ_S.QB %s, %s", rt, rs);
1827 }
1828
1829
1830 /*
1831 *
1832 *
1833 * 3 2 1
1834 * 10987654321098765432109876543210
1835 * 001000 0010000100111111
1836 * rt -----
1837 * rs -----
1838 */
1839 std::string NMD::ABSQ_S_W(uint64 instruction)
1840 {
1841 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1842 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1843
1844 std::string rt = GPR(copy(rt_value));
1845 std::string rs = GPR(copy(rs_value));
1846
1847 return img::format("ABSQ_S.W %s, %s", rt, rs);
1848 }
1849
1850
1851 /*
1852 *
1853 *
1854 * 3 2 1
1855 * 10987654321098765432109876543210
1856 * 001000 0010000100111111
1857 * rt -----
1858 * rs -----
1859 */
1860 std::string NMD::ACLR(uint64 instruction)
1861 {
1862 uint64 bit_value = extract_bit_23_22_21(instruction);
1863 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1864 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
1865
1866 std::string bit = IMMEDIATE(copy(bit_value));
1867 std::string s = IMMEDIATE(copy(s_value));
1868 std::string rs = GPR(copy(rs_value));
1869
1870 return img::format("ACLR %s, %s(%s)", bit, s, rs);
1871 }
1872
1873
1874 /*
1875 *
1876 *
1877 * 3 2 1
1878 * 10987654321098765432109876543210
1879 * 001000 0010000100111111
1880 * rt -----
1881 * rs -----
1882 */
1883 std::string NMD::ADD(uint64 instruction)
1884 {
1885 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1886 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1887 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1888
1889 std::string rd = GPR(copy(rd_value));
1890 std::string rs = GPR(copy(rs_value));
1891 std::string rt = GPR(copy(rt_value));
1892
1893 return img::format("ADD %s, %s, %s", rd, rs, rt);
1894 }
1895
1896
1897 /*
1898 * ADD.D fd, fs, ft - Floating Point Add
1899 *
1900 * 3 2 1
1901 * 10987654321098765432109876543210
1902 * 010001 000101
1903 * fmt -----
1904 * ft -----
1905 * fs -----
1906 * fd -----
1907 */
1908 std::string NMD::ADD_D(uint64 instruction)
1909 {
1910 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1911 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1912 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1913
1914 std::string ft = FPR(copy(ft_value));
1915 std::string fs = FPR(copy(fs_value));
1916 std::string fd = FPR(copy(fd_value));
1917
1918 return img::format("ADD.D %s, %s, %s", fd, fs, ft);
1919 }
1920
1921
1922 /*
1923 * ADD.S fd, fs, ft - Floating Point Add
1924 *
1925 * 3 2 1
1926 * 10987654321098765432109876543210
1927 * 010001 000101
1928 * fmt -----
1929 * ft -----
1930 * fs -----
1931 * fd -----
1932 */
1933 std::string NMD::ADD_S(uint64 instruction)
1934 {
1935 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1936 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1937 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1938
1939 std::string ft = FPR(copy(ft_value));
1940 std::string fs = FPR(copy(fs_value));
1941 std::string fd = FPR(copy(fd_value));
1942
1943 return img::format("ADD.S %s, %s, %s", fd, fs, ft);
1944 }
1945
1946
1947 /*
1948 *
1949 *
1950 * 3 2 1
1951 * 10987654321098765432109876543210
1952 * 001000 0010000100111111
1953 * rt -----
1954 * rs -----
1955 */
1956 std::string NMD::ADDIU_32_(uint64 instruction)
1957 {
1958 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1959 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1960 uint64 u_value = extract_u_15_to_0(instruction);
1961
1962 std::string rt = GPR(copy(rt_value));
1963 std::string rs = GPR(copy(rs_value));
1964 std::string u = IMMEDIATE(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 */
1979 std::string NMD::ADDIU_48_(uint64 instruction)
1980 {
1981 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1982 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1983
1984 std::string rt = GPR(copy(rt_value));
1985 std::string s = IMMEDIATE(copy(s_value));
1986
1987 return img::format("ADDIU %s, %s", rt, s);
1988 }
1989
1990
1991 /*
1992 *
1993 *
1994 * 3 2 1
1995 * 10987654321098765432109876543210
1996 * 001000 0010000100111111
1997 * rt -----
1998 * rs -----
1999 */
2000 std::string NMD::ADDIU_GP48_(uint64 instruction)
2001 {
2002 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2003 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
2004
2005 std::string rt = GPR(copy(rt_value));
2006 std::string s = IMMEDIATE(copy(s_value));
2007
2008 return img::format("ADDIU %s, $%d, %s", rt, 28, s);
2009 }
2010
2011
2012 /*
2013 *
2014 *
2015 * 3 2 1
2016 * 10987654321098765432109876543210
2017 * 001000 0010000100111111
2018 * rt -----
2019 * rs -----
2020 */
2021 std::string NMD::ADDIU_GP_B_(uint64 instruction)
2022 {
2023 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2024 uint64 u_value = extract_u_17_to_0(instruction);
2025
2026 std::string rt = GPR(copy(rt_value));
2027 std::string u = IMMEDIATE(copy(u_value));
2028
2029 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2030 }
2031
2032
2033 /*
2034 *
2035 *
2036 * 3 2 1
2037 * 10987654321098765432109876543210
2038 * 001000 0010000100111111
2039 * rt -----
2040 * rs -----
2041 */
2042 std::string NMD::ADDIU_GP_W_(uint64 instruction)
2043 {
2044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2045 uint64 u_value = extract_u_20_to_2__s2(instruction);
2046
2047 std::string rt = GPR(copy(rt_value));
2048 std::string u = IMMEDIATE(copy(u_value));
2049
2050 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2051 }
2052
2053
2054 /*
2055 *
2056 *
2057 * 3 2 1
2058 * 10987654321098765432109876543210
2059 * 001000 0010000100111111
2060 * rt -----
2061 * rs -----
2062 */
2063 std::string NMD::ADDIU_NEG_(uint64 instruction)
2064 {
2065 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2066 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2067 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2068
2069 std::string rt = GPR(copy(rt_value));
2070 std::string rs = GPR(copy(rs_value));
2071 std::string u = IMMEDIATE(neg_copy(u_value));
2072
2073 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2074 }
2075
2076
2077 /*
2078 *
2079 *
2080 * 3 2 1
2081 * 10987654321098765432109876543210
2082 * 001000 0010000100111111
2083 * rt -----
2084 * rs -----
2085 */
2086 std::string NMD::ADDIU_R1_SP_(uint64 instruction)
2087 {
2088 uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
2089 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2090
2091 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2092 std::string u = IMMEDIATE(copy(u_value));
2093
2094 return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
2095 }
2096
2097
2098 /*
2099 *
2100 *
2101 * 3 2 1
2102 * 10987654321098765432109876543210
2103 * 001000 0010000100111111
2104 * rt -----
2105 * rs -----
2106 */
2107 std::string NMD::ADDIU_R2_(uint64 instruction)
2108 {
2109 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2110 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2111 uint64 u_value = extract_u_2_1_0__s2(instruction);
2112
2113 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2114 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2115 std::string u = IMMEDIATE(copy(u_value));
2116
2117 return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
2118 }
2119
2120
2121 /*
2122 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
2123 *
2124 * 5432109876543210
2125 * 100100 1
2126 * rt -----
2127 * s - ---
2128 */
2129 std::string NMD::ADDIU_RS5_(uint64 instruction)
2130 {
2131 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
2132 int64 s_value = extract_s__se3_4_2_1_0(instruction);
2133
2134 std::string rt = GPR(copy(rt_value));
2135 std::string s = IMMEDIATE(copy(s_value));
2136
2137 return img::format("ADDIU %s, %s", rt, s);
2138 }
2139
2140
2141 /*
2142 *
2143 *
2144 * 3 2 1
2145 * 10987654321098765432109876543210
2146 * 001000 x1110000101
2147 * rt -----
2148 * rs -----
2149 * rd -----
2150 */
2151 std::string NMD::ADDIUPC_32_(uint64 instruction)
2152 {
2153 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2154 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
2155
2156 std::string rt = GPR(copy(rt_value));
2157 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2158
2159 return img::format("ADDIUPC %s, %s", rt, s);
2160 }
2161
2162
2163 /*
2164 *
2165 *
2166 * 3 2 1
2167 * 10987654321098765432109876543210
2168 * 001000 x1110000101
2169 * rt -----
2170 * rs -----
2171 * rd -----
2172 */
2173 std::string NMD::ADDIUPC_48_(uint64 instruction)
2174 {
2175 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2176 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
2177
2178 std::string rt = GPR(copy(rt_value));
2179 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
2180
2181 return img::format("ADDIUPC %s, %s", rt, s);
2182 }
2183
2184
2185 /*
2186 * ADDQ.PH rd, rt, rs - Add Fractional Halfword Vectors
2187 *
2188 * 3 2 1
2189 * 10987654321098765432109876543210
2190 * 001000 00000001101
2191 * rt -----
2192 * rs -----
2193 * rd -----
2194 */
2195 std::string NMD::ADDQ_PH(uint64 instruction)
2196 {
2197 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2198 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2199 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2200
2201 std::string rd = GPR(copy(rd_value));
2202 std::string rs = GPR(copy(rs_value));
2203 std::string rt = GPR(copy(rt_value));
2204
2205 return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
2206 }
2207
2208
2209 /*
2210 * ADDQ_S.PH rd, rt, rs - Add Fractional Halfword Vectors
2211 *
2212 * 3 2 1
2213 * 10987654321098765432109876543210
2214 * 001000 10000001101
2215 * rt -----
2216 * rs -----
2217 * rd -----
2218 */
2219 std::string NMD::ADDQ_S_PH(uint64 instruction)
2220 {
2221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2222 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2223 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2224
2225 std::string rd = GPR(copy(rd_value));
2226 std::string rs = GPR(copy(rs_value));
2227 std::string rt = GPR(copy(rt_value));
2228
2229 return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
2230 }
2231
2232
2233 /*
2234 * ADDQ_S.W rd, rt, rs - Add Fractional Words
2235 *
2236 * 3 2 1
2237 * 10987654321098765432109876543210
2238 * 001000 x1100000101
2239 * rt -----
2240 * rs -----
2241 * rd -----
2242 */
2243 std::string NMD::ADDQ_S_W(uint64 instruction)
2244 {
2245 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2246 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2247 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2248
2249 std::string rd = GPR(copy(rd_value));
2250 std::string rs = GPR(copy(rs_value));
2251 std::string rt = GPR(copy(rt_value));
2252
2253 return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2254 }
2255
2256
2257 /*
2258 * ADDQH.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2259 * to Halve Results
2260 *
2261 * 3 2 1
2262 * 10987654321098765432109876543210
2263 * 001000 00001001101
2264 * rt -----
2265 * rs -----
2266 * rd -----
2267 */
2268 std::string NMD::ADDQH_PH(uint64 instruction)
2269 {
2270 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2271 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2272 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2273
2274 std::string rd = GPR(copy(rd_value));
2275 std::string rs = GPR(copy(rs_value));
2276 std::string rt = GPR(copy(rt_value));
2277
2278 return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2279 }
2280
2281
2282 /*
2283 * ADDQH_R.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2284 * to Halve Results
2285 *
2286 * 3 2 1
2287 * 10987654321098765432109876543210
2288 * 001000 10001001101
2289 * rt -----
2290 * rs -----
2291 * rd -----
2292 */
2293 std::string NMD::ADDQH_R_PH(uint64 instruction)
2294 {
2295 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2296 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2297 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2298
2299 std::string rd = GPR(copy(rd_value));
2300 std::string rs = GPR(copy(rs_value));
2301 std::string rt = GPR(copy(rt_value));
2302
2303 return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2304 }
2305
2306
2307 /*
2308 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2309 *
2310 * 3 2 1
2311 * 10987654321098765432109876543210
2312 * 001000 00010001101
2313 * rt -----
2314 * rs -----
2315 * rd -----
2316 */
2317 std::string NMD::ADDQH_R_W(uint64 instruction)
2318 {
2319 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2320 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2321 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2322
2323 std::string rd = GPR(copy(rd_value));
2324 std::string rs = GPR(copy(rs_value));
2325 std::string rt = GPR(copy(rt_value));
2326
2327 return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2328 }
2329
2330
2331 /*
2332 * ADDQH.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2333 *
2334 * 3 2 1
2335 * 10987654321098765432109876543210
2336 * 001000 10010001101
2337 * rt -----
2338 * rs -----
2339 * rd -----
2340 */
2341 std::string NMD::ADDQH_W(uint64 instruction)
2342 {
2343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2344 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2345 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2346
2347 std::string rd = GPR(copy(rd_value));
2348 std::string rs = GPR(copy(rs_value));
2349 std::string rt = GPR(copy(rt_value));
2350
2351 return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
2352 }
2353
2354
2355 /*
2356 * ADDSC rd, rt, rs - Add Signed Word and Set Carry Bit
2357 *
2358 * 3 2 1
2359 * 10987654321098765432109876543210
2360 * 001000 x1110000101
2361 * rt -----
2362 * rs -----
2363 * rd -----
2364 */
2365 std::string NMD::ADDSC(uint64 instruction)
2366 {
2367 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2368 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2369 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2370
2371 std::string rd = GPR(copy(rd_value));
2372 std::string rs = GPR(copy(rs_value));
2373 std::string rt = GPR(copy(rt_value));
2374
2375 return img::format("ADDSC %s, %s, %s", rd, rs, rt);
2376 }
2377
2378
2379 /*
2380 * ADDU[16] rd3, rs3, rt3 -
2381 *
2382 * 5432109876543210
2383 * 101100 0
2384 * rt3 ---
2385 * rs3 ---
2386 * rd3 ---
2387 */
2388 std::string NMD::ADDU_16_(uint64 instruction)
2389 {
2390 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2391 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2392 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2393
2394 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2395 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2396 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
2397
2398 return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
2399 }
2400
2401
2402 /*
2403 *
2404 *
2405 * 3 2 1
2406 * 10987654321098765432109876543210
2407 * 001000 x1110000101
2408 * rt -----
2409 * rs -----
2410 * rd -----
2411 */
2412 std::string NMD::ADDU_32_(uint64 instruction)
2413 {
2414 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2415 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2416 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2417
2418 std::string rd = GPR(copy(rd_value));
2419 std::string rs = GPR(copy(rs_value));
2420 std::string rt = GPR(copy(rt_value));
2421
2422 return img::format("ADDU %s, %s, %s", rd, rs, rt);
2423 }
2424
2425
2426 /*
2427 *
2428 *
2429 * 3 2 1
2430 * 10987654321098765432109876543210
2431 * 001000 x1110000101
2432 * rt -----
2433 * rs -----
2434 * rd -----
2435 */
2436 std::string NMD::ADDU_4X4_(uint64 instruction)
2437 {
2438 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2439 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2440
2441 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
2442 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
2443
2444 return img::format("ADDU %s, %s", rs4, rt4);
2445 }
2446
2447
2448 /*
2449 * ADDU.PH rd, rt, rs - Unsigned Add Integer Halfwords
2450 *
2451 * 3 2 1
2452 * 10987654321098765432109876543210
2453 * 001000 00100001101
2454 * rt -----
2455 * rs -----
2456 * rd -----
2457 */
2458 std::string NMD::ADDU_PH(uint64 instruction)
2459 {
2460 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2462 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2463
2464 std::string rd = GPR(copy(rd_value));
2465 std::string rs = GPR(copy(rs_value));
2466 std::string rt = GPR(copy(rt_value));
2467
2468 return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
2469 }
2470
2471
2472 /*
2473 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2474 *
2475 * 3 2 1
2476 * 10987654321098765432109876543210
2477 * 001000 00011001101
2478 * rt -----
2479 * rs -----
2480 * rd -----
2481 */
2482 std::string NMD::ADDU_QB(uint64 instruction)
2483 {
2484 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2485 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2486 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2487
2488 std::string rd = GPR(copy(rd_value));
2489 std::string rs = GPR(copy(rs_value));
2490 std::string rt = GPR(copy(rt_value));
2491
2492 return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
2493 }
2494
2495
2496 /*
2497 * ADDU_S.PH rd, rt, rs - Unsigned Add Integer Halfwords
2498 *
2499 * 3 2 1
2500 * 10987654321098765432109876543210
2501 * 001000 10100001101
2502 * rt -----
2503 * rs -----
2504 * rd -----
2505 */
2506 std::string NMD::ADDU_S_PH(uint64 instruction)
2507 {
2508 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2509 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2510 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2511
2512 std::string rd = GPR(copy(rd_value));
2513 std::string rs = GPR(copy(rs_value));
2514 std::string rt = GPR(copy(rt_value));
2515
2516 return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2517 }
2518
2519
2520 /*
2521 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2522 *
2523 * 3 2 1
2524 * 10987654321098765432109876543210
2525 * 001000 10011001101
2526 * rt -----
2527 * rs -----
2528 * rd -----
2529 */
2530 std::string NMD::ADDU_S_QB(uint64 instruction)
2531 {
2532 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2533 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2534 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2535
2536 std::string rd = GPR(copy(rd_value));
2537 std::string rs = GPR(copy(rs_value));
2538 std::string rt = GPR(copy(rt_value));
2539
2540 return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2541 }
2542
2543
2544 /*
2545 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2546 * to Halve Results
2547 *
2548 * 3 2 1
2549 * 10987654321098765432109876543210
2550 * 001000 00101001101
2551 * rt -----
2552 * rs -----
2553 * rd -----
2554 */
2555 std::string NMD::ADDUH_QB(uint64 instruction)
2556 {
2557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2559 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2560
2561 std::string rd = GPR(copy(rd_value));
2562 std::string rs = GPR(copy(rs_value));
2563 std::string rt = GPR(copy(rt_value));
2564
2565 return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2566 }
2567
2568
2569 /*
2570 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2571 * to Halve Results
2572 *
2573 * 3 2 1
2574 * 10987654321098765432109876543210
2575 * 001000 10101001101
2576 * rt -----
2577 * rs -----
2578 * rd -----
2579 */
2580 std::string NMD::ADDUH_R_QB(uint64 instruction)
2581 {
2582 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2583 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2584 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2585
2586 std::string rd = GPR(copy(rd_value));
2587 std::string rs = GPR(copy(rs_value));
2588 std::string rt = GPR(copy(rt_value));
2589
2590 return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2591 }
2592
2593 /*
2594 * ADDWC rd, rt, rs - Add Word with Carry Bit
2595 *
2596 * 3 2 1
2597 * 10987654321098765432109876543210
2598 * 001000 x1111000101
2599 * rt -----
2600 * rs -----
2601 * rd -----
2602 */
2603 std::string NMD::ADDWC(uint64 instruction)
2604 {
2605 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2606 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2607 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2608
2609 std::string rd = GPR(copy(rd_value));
2610 std::string rs = GPR(copy(rs_value));
2611 std::string rt = GPR(copy(rt_value));
2612
2613 return img::format("ADDWC %s, %s, %s", rd, rs, rt);
2614 }
2615
2616
2617 /*
2618 *
2619 *
2620 * 3 2 1
2621 * 10987654321098765432109876543210
2622 * 001000 x1110000101
2623 * rt -----
2624 * rs -----
2625 * rd -----
2626 */
2627 std::string NMD::ALUIPC(uint64 instruction)
2628 {
2629 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2630 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
2631
2632 std::string rt = GPR(copy(rt_value));
2633 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2634
2635 return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2636 }
2637
2638
2639 /*
2640 * AND[16] rt3, rs3 -
2641 *
2642 * 5432109876543210
2643 * 101100
2644 * rt3 ---
2645 * rs3 ---
2646 * eu ----
2647 */
2648 std::string NMD::AND_16_(uint64 instruction)
2649 {
2650 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2651 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2652
2653 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2654 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2655
2656 return img::format("AND %s, %s", rs3, rt3);
2657 }
2658
2659
2660 /*
2661 *
2662 *
2663 * 3 2 1
2664 * 10987654321098765432109876543210
2665 * 001000 x1110000101
2666 * rt -----
2667 * rs -----
2668 * rd -----
2669 */
2670 std::string NMD::AND_32_(uint64 instruction)
2671 {
2672 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2674 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2675
2676 std::string rd = GPR(copy(rd_value));
2677 std::string rs = GPR(copy(rs_value));
2678 std::string rt = GPR(copy(rt_value));
2679
2680 return img::format("AND %s, %s, %s", rd, rs, rt);
2681 }
2682
2683
2684 /*
2685 * ANDI rt, rs, u -
2686 *
2687 * 5432109876543210
2688 * 101100
2689 * rt3 ---
2690 * rs3 ---
2691 * eu ----
2692 */
2693 std::string NMD::ANDI_16_(uint64 instruction)
2694 {
2695 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2696 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2697 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2698
2699 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2700 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2701 std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
2702
2703 return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
2704 }
2705
2706
2707 /*
2708 *
2709 *
2710 * 3 2 1
2711 * 10987654321098765432109876543210
2712 * 001000 x1110000101
2713 * rt -----
2714 * rs -----
2715 * rd -----
2716 */
2717 std::string NMD::ANDI_32_(uint64 instruction)
2718 {
2719 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2720 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2721 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2722
2723 std::string rt = GPR(copy(rt_value));
2724 std::string rs = GPR(copy(rs_value));
2725 std::string u = IMMEDIATE(copy(u_value));
2726
2727 return img::format("ANDI %s, %s, %s", rt, rs, u);
2728 }
2729
2730
2731 /*
2732 *
2733 *
2734 * 3 2 1
2735 * 10987654321098765432109876543210
2736 * 001000 x1110000101
2737 * rt -----
2738 * rs -----
2739 * rd -----
2740 */
2741 std::string NMD::APPEND(uint64 instruction)
2742 {
2743 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2744 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2745 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2746
2747 std::string rt = GPR(copy(rt_value));
2748 std::string rs = GPR(copy(rs_value));
2749 std::string sa = IMMEDIATE(copy(sa_value));
2750
2751 return img::format("APPEND %s, %s, %s", rt, rs, sa);
2752 }
2753
2754
2755 /*
2756 *
2757 *
2758 * 3 2 1
2759 * 10987654321098765432109876543210
2760 * 001000 x1110000101
2761 * rt -----
2762 * rs -----
2763 * rd -----
2764 */
2765 std::string NMD::ASET(uint64 instruction)
2766 {
2767 uint64 bit_value = extract_bit_23_22_21(instruction);
2768 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2769 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
2770
2771 std::string bit = IMMEDIATE(copy(bit_value));
2772 std::string s = IMMEDIATE(copy(s_value));
2773 std::string rs = GPR(copy(rs_value));
2774
2775 return img::format("ASET %s, %s(%s)", bit, s, rs);
2776 }
2777
2778
2779 /*
2780 *
2781 *
2782 * 3 2 1
2783 * 10987654321098765432109876543210
2784 * 001000 x1110000101
2785 * rt -----
2786 * rs -----
2787 * rd -----
2788 */
2789 std::string NMD::BALC_16_(uint64 instruction)
2790 {
2791 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2792
2793 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2794
2795 return img::format("BALC %s", s);
2796 }
2797
2798
2799 /*
2800 *
2801 *
2802 * 3 2 1
2803 * 10987654321098765432109876543210
2804 * 001000 x1110000101
2805 * rt -----
2806 * rs -----
2807 * rd -----
2808 */
2809 std::string NMD::BALC_32_(uint64 instruction)
2810 {
2811 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2812
2813 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2814
2815 return img::format("BALC %s", s);
2816 }
2817
2818
2819 /*
2820 *
2821 *
2822 * 3 2 1
2823 * 10987654321098765432109876543210
2824 * 001000 x1110000101
2825 * rt -----
2826 * rs -----
2827 * rd -----
2828 */
2829 std::string NMD::BALRSC(uint64 instruction)
2830 {
2831 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2832 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2833
2834 std::string rt = GPR(copy(rt_value));
2835 std::string rs = GPR(copy(rs_value));
2836
2837 return img::format("BALRSC %s, %s", rt, rs);
2838 }
2839
2840
2841 /*
2842 *
2843 *
2844 * 3 2 1
2845 * 10987654321098765432109876543210
2846 * 001000 x1110000101
2847 * rt -----
2848 * rs -----
2849 * rd -----
2850 */
2851 std::string NMD::BBEQZC(uint64 instruction)
2852 {
2853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2854 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2855 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2856
2857 std::string rt = GPR(copy(rt_value));
2858 std::string bit = IMMEDIATE(copy(bit_value));
2859 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2860
2861 return img::format("BBEQZC %s, %s, %s", rt, bit, s);
2862 }
2863
2864
2865 /*
2866 *
2867 *
2868 * 3 2 1
2869 * 10987654321098765432109876543210
2870 * 001000 x1110000101
2871 * rt -----
2872 * rs -----
2873 * rd -----
2874 */
2875 std::string NMD::BBNEZC(uint64 instruction)
2876 {
2877 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2878 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2879 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2880
2881 std::string rt = GPR(copy(rt_value));
2882 std::string bit = IMMEDIATE(copy(bit_value));
2883 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2884
2885 return img::format("BBNEZC %s, %s, %s", rt, bit, s);
2886 }
2887
2888
2889 /*
2890 *
2891 *
2892 * 3 2 1
2893 * 10987654321098765432109876543210
2894 * 001000 x1110000101
2895 * rt -----
2896 * rs -----
2897 * rd -----
2898 */
2899 std::string NMD::BC_16_(uint64 instruction)
2900 {
2901 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2902
2903 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2904
2905 return img::format("BC %s", s);
2906 }
2907
2908
2909 /*
2910 *
2911 *
2912 * 3 2 1
2913 * 10987654321098765432109876543210
2914 * 001000 x1110000101
2915 * rt -----
2916 * rs -----
2917 * rd -----
2918 */
2919 std::string NMD::BC_32_(uint64 instruction)
2920 {
2921 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2922
2923 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2924
2925 return img::format("BC %s", s);
2926 }
2927
2928
2929 /*
2930 *
2931 *
2932 * 3 2 1
2933 * 10987654321098765432109876543210
2934 * 001000 x1110000101
2935 * rt -----
2936 * rs -----
2937 * rd -----
2938 */
2939 std::string NMD::BC1EQZC(uint64 instruction)
2940 {
2941 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2942 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2943
2944 std::string ft = FPR(copy(ft_value));
2945 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2946
2947 return img::format("BC1EQZC %s, %s", ft, s);
2948 }
2949
2950
2951 /*
2952 *
2953 *
2954 * 3 2 1
2955 * 10987654321098765432109876543210
2956 * 001000 x1110000101
2957 * rt -----
2958 * rs -----
2959 * rd -----
2960 */
2961 std::string NMD::BC1NEZC(uint64 instruction)
2962 {
2963 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2964 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2965
2966 std::string ft = FPR(copy(ft_value));
2967 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2968
2969 return img::format("BC1NEZC %s, %s", ft, s);
2970 }
2971
2972
2973 /*
2974 *
2975 *
2976 * 3 2 1
2977 * 10987654321098765432109876543210
2978 * 001000 x1110000101
2979 * rt -----
2980 * rs -----
2981 * rd -----
2982 */
2983 std::string NMD::BC2EQZC(uint64 instruction)
2984 {
2985 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
2986 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2987
2988 std::string ct = CPR(copy(ct_value));
2989 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2990
2991 return img::format("BC2EQZC %s, %s", ct, s);
2992 }
2993
2994
2995 /*
2996 *
2997 *
2998 * 3 2 1
2999 * 10987654321098765432109876543210
3000 * 001000 x1110000101
3001 * rt -----
3002 * rs -----
3003 * rd -----
3004 */
3005 std::string NMD::BC2NEZC(uint64 instruction)
3006 {
3007 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3008 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3009
3010 std::string ct = CPR(copy(ct_value));
3011 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3012
3013 return img::format("BC2NEZC %s, %s", ct, s);
3014 }
3015
3016
3017 /*
3018 *
3019 *
3020 * 3 2 1
3021 * 10987654321098765432109876543210
3022 * 001000 x1110000101
3023 * rt -----
3024 * rs -----
3025 * rd -----
3026 */
3027 std::string NMD::BEQC_16_(uint64 instruction)
3028 {
3029 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3030 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3031 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
3032
3033 std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
3034 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3035 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3036
3037 return img::format("BEQC %s, %s, %s", rs3, rt3, u);
3038 }
3039
3040
3041 /*
3042 *
3043 *
3044 * 3 2 1
3045 * 10987654321098765432109876543210
3046 * 001000 x1110000101
3047 * rt -----
3048 * rs -----
3049 * rd -----
3050 */
3051 std::string NMD::BEQC_32_(uint64 instruction)
3052 {
3053 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3054 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3055 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3056
3057 std::string rs = GPR(copy(rs_value));
3058 std::string rt = GPR(copy(rt_value));
3059 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3060
3061 return img::format("BEQC %s, %s, %s", rs, rt, s);
3062 }
3063
3064
3065 /*
3066 *
3067 *
3068 * 3 2 1
3069 * 10987654321098765432109876543210
3070 * 001000 x1110000101
3071 * rt -----
3072 * rs -----
3073 * rd -----
3074 */
3075 std::string NMD::BEQIC(uint64 instruction)
3076 {
3077 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3078 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3079 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3080
3081 std::string rt = GPR(copy(rt_value));
3082 std::string u = IMMEDIATE(copy(u_value));
3083 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3084
3085 return img::format("BEQIC %s, %s, %s", rt, u, s);
3086 }
3087
3088
3089 /*
3090 *
3091 *
3092 * 3 2 1
3093 * 10987654321098765432109876543210
3094 * 001000 x1110000101
3095 * rt -----
3096 * rs -----
3097 * rd -----
3098 */
3099 std::string NMD::BEQZC_16_(uint64 instruction)
3100 {
3101 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3102 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3103
3104 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3105 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3106
3107 return img::format("BEQZC %s, %s", rt3, s);
3108 }
3109
3110
3111 /*
3112 *
3113 *
3114 * 3 2 1
3115 * 10987654321098765432109876543210
3116 * 001000 x1110000101
3117 * rt -----
3118 * rs -----
3119 * rd -----
3120 */
3121 std::string NMD::BGEC(uint64 instruction)
3122 {
3123 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3124 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3125 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3126
3127 std::string rs = GPR(copy(rs_value));
3128 std::string rt = GPR(copy(rt_value));
3129 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3130
3131 return img::format("BGEC %s, %s, %s", rs, rt, s);
3132 }
3133
3134
3135 /*
3136 *
3137 *
3138 * 3 2 1
3139 * 10987654321098765432109876543210
3140 * 001000 x1110000101
3141 * rt -----
3142 * rs -----
3143 * rd -----
3144 */
3145 std::string NMD::BGEIC(uint64 instruction)
3146 {
3147 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3148 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3149 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3150
3151 std::string rt = GPR(copy(rt_value));
3152 std::string u = IMMEDIATE(copy(u_value));
3153 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3154
3155 return img::format("BGEIC %s, %s, %s", rt, u, s);
3156 }
3157
3158
3159 /*
3160 *
3161 *
3162 * 3 2 1
3163 * 10987654321098765432109876543210
3164 * 001000 x1110000101
3165 * rt -----
3166 * rs -----
3167 * rd -----
3168 */
3169 std::string NMD::BGEIUC(uint64 instruction)
3170 {
3171 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3172 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3173 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3174
3175 std::string rt = GPR(copy(rt_value));
3176 std::string u = IMMEDIATE(copy(u_value));
3177 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3178
3179 return img::format("BGEIUC %s, %s, %s", rt, u, s);
3180 }
3181
3182
3183 /*
3184 *
3185 *
3186 * 3 2 1
3187 * 10987654321098765432109876543210
3188 * 001000 x1110000101
3189 * rt -----
3190 * rs -----
3191 * rd -----
3192 */
3193 std::string NMD::BGEUC(uint64 instruction)
3194 {
3195 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3196 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3197 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3198
3199 std::string rs = GPR(copy(rs_value));
3200 std::string rt = GPR(copy(rt_value));
3201 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3202
3203 return img::format("BGEUC %s, %s, %s", rs, rt, s);
3204 }
3205
3206
3207 /*
3208 *
3209 *
3210 * 3 2 1
3211 * 10987654321098765432109876543210
3212 * 001000 x1110000101
3213 * rt -----
3214 * rs -----
3215 * rd -----
3216 */
3217 std::string NMD::BLTC(uint64 instruction)
3218 {
3219 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3220 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3221 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3222
3223 std::string rs = GPR(copy(rs_value));
3224 std::string rt = GPR(copy(rt_value));
3225 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3226
3227 return img::format("BLTC %s, %s, %s", rs, rt, s);
3228 }
3229
3230
3231 /*
3232 *
3233 *
3234 * 3 2 1
3235 * 10987654321098765432109876543210
3236 * 001000 x1110000101
3237 * rt -----
3238 * rs -----
3239 * rd -----
3240 */
3241 std::string NMD::BLTIC(uint64 instruction)
3242 {
3243 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3244 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3245 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3246
3247 std::string rt = GPR(copy(rt_value));
3248 std::string u = IMMEDIATE(copy(u_value));
3249 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3250
3251 return img::format("BLTIC %s, %s, %s", rt, u, s);
3252 }
3253
3254
3255 /*
3256 *
3257 *
3258 * 3 2 1
3259 * 10987654321098765432109876543210
3260 * 001000 x1110000101
3261 * rt -----
3262 * rs -----
3263 * rd -----
3264 */
3265 std::string NMD::BLTIUC(uint64 instruction)
3266 {
3267 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3268 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3269 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3270
3271 std::string rt = GPR(copy(rt_value));
3272 std::string u = IMMEDIATE(copy(u_value));
3273 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3274
3275 return img::format("BLTIUC %s, %s, %s", rt, u, s);
3276 }
3277
3278
3279 /*
3280 *
3281 *
3282 * 3 2 1
3283 * 10987654321098765432109876543210
3284 * 001000 x1110000101
3285 * rt -----
3286 * rs -----
3287 * rd -----
3288 */
3289 std::string NMD::BLTUC(uint64 instruction)
3290 {
3291 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3292 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3293 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3294
3295 std::string rs = GPR(copy(rs_value));
3296 std::string rt = GPR(copy(rt_value));
3297 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3298
3299 return img::format("BLTUC %s, %s, %s", rs, rt, s);
3300 }
3301
3302
3303 /*
3304 *
3305 *
3306 * 3 2 1
3307 * 10987654321098765432109876543210
3308 * 001000 x1110000101
3309 * rt -----
3310 * rs -----
3311 * rd -----
3312 */
3313 std::string NMD::BNEC_16_(uint64 instruction)
3314 {
3315 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3316 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3317 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
3318
3319 std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
3320 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3321 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3322
3323 return img::format("BNEC %s, %s, %s", rs3, rt3, u);
3324 }
3325
3326
3327 /*
3328 *
3329 *
3330 * 3 2 1
3331 * 10987654321098765432109876543210
3332 * 001000 x1110000101
3333 * rt -----
3334 * rs -----
3335 * rd -----
3336 */
3337 std::string NMD::BNEC_32_(uint64 instruction)
3338 {
3339 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3340 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3341 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3342
3343 std::string rs = GPR(copy(rs_value));
3344 std::string rt = GPR(copy(rt_value));
3345 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3346
3347 return img::format("BNEC %s, %s, %s", rs, rt, s);
3348 }
3349
3350
3351 /*
3352 *
3353 *
3354 * 3 2 1
3355 * 10987654321098765432109876543210
3356 * 001000 x1110000101
3357 * rt -----
3358 * rs -----
3359 * rd -----
3360 */
3361 std::string NMD::BNEIC(uint64 instruction)
3362 {
3363 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3364 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3365 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3366
3367 std::string rt = GPR(copy(rt_value));
3368 std::string u = IMMEDIATE(copy(u_value));
3369 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3370
3371 return img::format("BNEIC %s, %s, %s", rt, u, s);
3372 }
3373
3374
3375 /*
3376 *
3377 *
3378 * 3 2 1
3379 * 10987654321098765432109876543210
3380 * 001000 x1110000101
3381 * rt -----
3382 * rs -----
3383 * rd -----
3384 */
3385 std::string NMD::BNEZC_16_(uint64 instruction)
3386 {
3387 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3388 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3389
3390 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3391 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3392
3393 return img::format("BNEZC %s, %s", rt3, s);
3394 }
3395
3396
3397 /*
3398 *
3399 *
3400 * 3 2 1
3401 * 10987654321098765432109876543210
3402 * 001000 x1110000101
3403 * rt -----
3404 * rs -----
3405 * rd -----
3406 */
3407 std::string NMD::BPOSGE32C(uint64 instruction)
3408 {
3409 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3410
3411 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3412
3413 return img::format("BPOSGE32C %s", s);
3414 }
3415
3416
3417 /*
3418 *
3419 *
3420 * 3 2 1
3421 * 10987654321098765432109876543210
3422 * 001000 x1110000101
3423 * rt -----
3424 * rs -----
3425 * rd -----
3426 */
3427 std::string NMD::BREAK_16_(uint64 instruction)
3428 {
3429 uint64 code_value = extract_code_2_1_0(instruction);
3430
3431 std::string code = IMMEDIATE(copy(code_value));
3432
3433 return img::format("BREAK %s", code);
3434 }
3435
3436
3437 /*
3438 * BREAK code - Break. Cause a Breakpoint exception
3439 *
3440 * 3 2 1
3441 * 10987654321098765432109876543210
3442 * 001000 x1110000101
3443 * rt -----
3444 * rs -----
3445 * rd -----
3446 */
3447 std::string NMD::BREAK_32_(uint64 instruction)
3448 {
3449 uint64 code_value = extract_code_18_to_0(instruction);
3450
3451 std::string code = IMMEDIATE(copy(code_value));
3452
3453 return img::format("BREAK %s", code);
3454 }
3455
3456
3457 /*
3458 *
3459 *
3460 * 3 2 1
3461 * 10987654321098765432109876543210
3462 * 001000 x1110000101
3463 * rt -----
3464 * rs -----
3465 * rd -----
3466 */
3467 std::string NMD::BRSC(uint64 instruction)
3468 {
3469 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3470
3471 std::string rs = GPR(copy(rs_value));
3472
3473 return img::format("BRSC %s", rs);
3474 }
3475
3476
3477 /*
3478 *
3479 *
3480 * 3 2 1
3481 * 10987654321098765432109876543210
3482 * 001000 x1110000101
3483 * rt -----
3484 * rs -----
3485 * rd -----
3486 */
3487 std::string NMD::CACHE(uint64 instruction)
3488 {
3489 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3490 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3491 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3492
3493 std::string op = IMMEDIATE(copy(op_value));
3494 std::string s = IMMEDIATE(copy(s_value));
3495 std::string rs = GPR(copy(rs_value));
3496
3497 return img::format("CACHE %s, %s(%s)", op, s, rs);
3498 }
3499
3500
3501 /*
3502 *
3503 *
3504 * 3 2 1
3505 * 10987654321098765432109876543210
3506 * 001000 x1110000101
3507 * rt -----
3508 * rs -----
3509 * rd -----
3510 */
3511 std::string NMD::CACHEE(uint64 instruction)
3512 {
3513 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3514 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3515 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3516
3517 std::string op = IMMEDIATE(copy(op_value));
3518 std::string s = IMMEDIATE(copy(s_value));
3519 std::string rs = GPR(copy(rs_value));
3520
3521 return img::format("CACHEE %s, %s(%s)", op, s, rs);
3522 }
3523
3524
3525 /*
3526 *
3527 *
3528 * 3 2 1
3529 * 10987654321098765432109876543210
3530 * 001000 x1110000101
3531 * rt -----
3532 * rs -----
3533 * rd -----
3534 */
3535 std::string NMD::CEIL_L_D(uint64 instruction)
3536 {
3537 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3538 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3539
3540 std::string ft = FPR(copy(ft_value));
3541 std::string fs = FPR(copy(fs_value));
3542
3543 return img::format("CEIL.L.D %s, %s", ft, fs);
3544 }
3545
3546
3547 /*
3548 *
3549 *
3550 * 3 2 1
3551 * 10987654321098765432109876543210
3552 * 001000 x1110000101
3553 * rt -----
3554 * rs -----
3555 * rd -----
3556 */
3557 std::string NMD::CEIL_L_S(uint64 instruction)
3558 {
3559 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3560 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3561
3562 std::string ft = FPR(copy(ft_value));
3563 std::string fs = FPR(copy(fs_value));
3564
3565 return img::format("CEIL.L.S %s, %s", ft, fs);
3566 }
3567
3568
3569 /*
3570 *
3571 *
3572 * 3 2 1
3573 * 10987654321098765432109876543210
3574 * 001000 x1110000101
3575 * rt -----
3576 * rs -----
3577 * rd -----
3578 */
3579 std::string NMD::CEIL_W_D(uint64 instruction)
3580 {
3581 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3582 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3583
3584 std::string ft = FPR(copy(ft_value));
3585 std::string fs = FPR(copy(fs_value));
3586
3587 return img::format("CEIL.W.D %s, %s", ft, fs);
3588 }
3589
3590
3591 /*
3592 *
3593 *
3594 * 3 2 1
3595 * 10987654321098765432109876543210
3596 * 001000 x1110000101
3597 * rt -----
3598 * rs -----
3599 * rd -----
3600 */
3601 std::string NMD::CEIL_W_S(uint64 instruction)
3602 {
3603 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3604 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3605
3606 std::string ft = FPR(copy(ft_value));
3607 std::string fs = FPR(copy(fs_value));
3608
3609 return img::format("CEIL.W.S %s, %s", ft, fs);
3610 }
3611
3612
3613 /*
3614 *
3615 *
3616 * 3 2 1
3617 * 10987654321098765432109876543210
3618 * 001000 x1110000101
3619 * rt -----
3620 * rs -----
3621 * rd -----
3622 */
3623 std::string NMD::CFC1(uint64 instruction)
3624 {
3625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3626 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3627
3628 std::string rt = GPR(copy(rt_value));
3629 std::string cs = CPR(copy(cs_value));
3630
3631 return img::format("CFC1 %s, %s", rt, cs);
3632 }
3633
3634
3635 /*
3636 *
3637 *
3638 * 3 2 1
3639 * 10987654321098765432109876543210
3640 * 001000 x1110000101
3641 * rt -----
3642 * rs -----
3643 * rd -----
3644 */
3645 std::string NMD::CFC2(uint64 instruction)
3646 {
3647 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3648 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3649
3650 std::string rt = GPR(copy(rt_value));
3651 std::string cs = CPR(copy(cs_value));
3652
3653 return img::format("CFC2 %s, %s", rt, cs);
3654 }
3655
3656
3657 /*
3658 *
3659 *
3660 * 3 2 1
3661 * 10987654321098765432109876543210
3662 * 001000 x1110000101
3663 * rt -----
3664 * rs -----
3665 * rd -----
3666 */
3667 std::string NMD::CLASS_D(uint64 instruction)
3668 {
3669 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3670 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3671
3672 std::string ft = FPR(copy(ft_value));
3673 std::string fs = FPR(copy(fs_value));
3674
3675 return img::format("CLASS.D %s, %s", ft, fs);
3676 }
3677
3678
3679 /*
3680 *
3681 *
3682 * 3 2 1
3683 * 10987654321098765432109876543210
3684 * 001000 x1110000101
3685 * rt -----
3686 * rs -----
3687 * rd -----
3688 */
3689 std::string NMD::CLASS_S(uint64 instruction)
3690 {
3691 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3692 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3693
3694 std::string ft = FPR(copy(ft_value));
3695 std::string fs = FPR(copy(fs_value));
3696
3697 return img::format("CLASS.S %s, %s", ft, fs);
3698 }
3699
3700
3701 /*
3702 *
3703 *
3704 * 3 2 1
3705 * 10987654321098765432109876543210
3706 * 001000 x1110000101
3707 * rt -----
3708 * rs -----
3709 * rd -----
3710 */
3711 std::string NMD::CLO(uint64 instruction)
3712 {
3713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3714 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3715
3716 std::string rt = GPR(copy(rt_value));
3717 std::string rs = GPR(copy(rs_value));
3718
3719 return img::format("CLO %s, %s", rt, rs);
3720 }
3721
3722
3723 /*
3724 *
3725 *
3726 * 3 2 1
3727 * 10987654321098765432109876543210
3728 * 001000 x1110000101
3729 * rt -----
3730 * rs -----
3731 * rd -----
3732 */
3733 std::string NMD::CLZ(uint64 instruction)
3734 {
3735 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3737
3738 std::string rt = GPR(copy(rt_value));
3739 std::string rs = GPR(copy(rs_value));
3740
3741 return img::format("CLZ %s, %s", rt, rs);
3742 }
3743
3744
3745 /*
3746 *
3747 *
3748 * 3 2 1
3749 * 10987654321098765432109876543210
3750 * 001000 x1110000101
3751 * rt -----
3752 * rs -----
3753 * rd -----
3754 */
3755 std::string NMD::CMP_AF_D(uint64 instruction)
3756 {
3757 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3758 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3759 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3760
3761 std::string fd = FPR(copy(fd_value));
3762 std::string fs = FPR(copy(fs_value));
3763 std::string ft = FPR(copy(ft_value));
3764
3765 return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3766 }
3767
3768
3769 /*
3770 *
3771 *
3772 * 3 2 1
3773 * 10987654321098765432109876543210
3774 * 001000 x1110000101
3775 * rt -----
3776 * rs -----
3777 * rd -----
3778 */
3779 std::string NMD::CMP_AF_S(uint64 instruction)
3780 {
3781 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3782 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3783 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3784
3785 std::string fd = FPR(copy(fd_value));
3786 std::string fs = FPR(copy(fs_value));
3787 std::string ft = FPR(copy(ft_value));
3788
3789 return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3790 }
3791
3792
3793 /*
3794 *
3795 *
3796 * 3 2 1
3797 * 10987654321098765432109876543210
3798 * 001000 x1110000101
3799 * rt -----
3800 * rs -----
3801 * rd -----
3802 */
3803 std::string NMD::CMP_EQ_D(uint64 instruction)
3804 {
3805 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3806 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3807 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3808
3809 std::string fd = FPR(copy(fd_value));
3810 std::string fs = FPR(copy(fs_value));
3811 std::string ft = FPR(copy(ft_value));
3812
3813 return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3814 }
3815
3816
3817 /*
3818 *
3819 *
3820 * 3 2 1
3821 * 10987654321098765432109876543210
3822 * 001000 x1110000101
3823 * rt -----
3824 * rs -----
3825 * rd -----
3826 */
3827 std::string NMD::CMP_EQ_PH(uint64 instruction)
3828 {
3829 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3830 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3831
3832 std::string rs = GPR(copy(rs_value));
3833 std::string rt = GPR(copy(rt_value));
3834
3835 return img::format("CMP.EQ.PH %s, %s", rs, rt);
3836 }
3837
3838
3839 /*
3840 *
3841 *
3842 * 3 2 1
3843 * 10987654321098765432109876543210
3844 * 001000 x1110000101
3845 * rt -----
3846 * rs -----
3847 * rd -----
3848 */
3849 std::string NMD::CMP_EQ_S(uint64 instruction)
3850 {
3851 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3852 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3853 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3854
3855 std::string fd = FPR(copy(fd_value));
3856 std::string fs = FPR(copy(fs_value));
3857 std::string ft = FPR(copy(ft_value));
3858
3859 return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3860 }
3861
3862
3863 /*
3864 *
3865 *
3866 * 3 2 1
3867 * 10987654321098765432109876543210
3868 * 001000 x1110000101
3869 * rt -----
3870 * rs -----
3871 * rd -----
3872 */
3873 std::string NMD::CMP_LE_D(uint64 instruction)
3874 {
3875 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3876 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3877 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3878
3879 std::string fd = FPR(copy(fd_value));
3880 std::string fs = FPR(copy(fs_value));
3881 std::string ft = FPR(copy(ft_value));
3882
3883 return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3884 }
3885
3886
3887 /*
3888 *
3889 *
3890 * 3 2 1
3891 * 10987654321098765432109876543210
3892 * 001000 x1110000101
3893 * rt -----
3894 * rs -----
3895 * rd -----
3896 */
3897 std::string NMD::CMP_LE_PH(uint64 instruction)
3898 {
3899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3900 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3901
3902 std::string rs = GPR(copy(rs_value));
3903 std::string rt = GPR(copy(rt_value));
3904
3905 return img::format("CMP.LE.PH %s, %s", rs, rt);
3906 }
3907
3908
3909 /*
3910 *
3911 *
3912 * 3 2 1
3913 * 10987654321098765432109876543210
3914 * 001000 x1110000101
3915 * rt -----
3916 * rs -----
3917 * rd -----
3918 */
3919 std::string NMD::CMP_LE_S(uint64 instruction)
3920 {
3921 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3922 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3923 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3924
3925 std::string fd = FPR(copy(fd_value));
3926 std::string fs = FPR(copy(fs_value));
3927 std::string ft = FPR(copy(ft_value));
3928
3929 return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3930 }
3931
3932
3933 /*
3934 *
3935 *
3936 * 3 2 1
3937 * 10987654321098765432109876543210
3938 * 001000 x1110000101
3939 * rt -----
3940 * rs -----
3941 * rd -----
3942 */
3943 std::string NMD::CMP_LT_D(uint64 instruction)
3944 {
3945 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3946 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3947 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3948
3949 std::string fd = FPR(copy(fd_value));
3950 std::string fs = FPR(copy(fs_value));
3951 std::string ft = FPR(copy(ft_value));
3952
3953 return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
3954 }
3955
3956
3957 /*
3958 *
3959 *
3960 * 3 2 1
3961 * 10987654321098765432109876543210
3962 * 001000 x1110000101
3963 * rt -----
3964 * rs -----
3965 * rd -----
3966 */
3967 std::string NMD::CMP_LT_PH(uint64 instruction)
3968 {
3969 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3970 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3971
3972 std::string rs = GPR(copy(rs_value));
3973 std::string rt = GPR(copy(rt_value));
3974
3975 return img::format("CMP.LT.PH %s, %s", rs, rt);
3976 }
3977
3978
3979 /*
3980 *
3981 *
3982 * 3 2 1
3983 * 10987654321098765432109876543210
3984 * 001000 x1110000101
3985 * rt -----
3986 * rs -----
3987 * rd -----
3988 */
3989 std::string NMD::CMP_LT_S(uint64 instruction)
3990 {
3991 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3992 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3993 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3994
3995 std::string fd = FPR(copy(fd_value));
3996 std::string fs = FPR(copy(fs_value));
3997 std::string ft = FPR(copy(ft_value));
3998
3999 return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
4000 }
4001
4002
4003 /*
4004 *
4005 *
4006 * 3 2 1
4007 * 10987654321098765432109876543210
4008 * 001000 x1110000101
4009 * rt -----
4010 * rs -----
4011 * rd -----
4012 */
4013 std::string NMD::CMP_NE_D(uint64 instruction)
4014 {
4015 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4016 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4017 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4018
4019 std::string fd = FPR(copy(fd_value));
4020 std::string fs = FPR(copy(fs_value));
4021 std::string ft = FPR(copy(ft_value));
4022
4023 return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
4024 }
4025
4026
4027 /*
4028 *
4029 *
4030 * 3 2 1
4031 * 10987654321098765432109876543210
4032 * 001000 x1110000101
4033 * rt -----
4034 * rs -----
4035 * rd -----
4036 */
4037 std::string NMD::CMP_NE_S(uint64 instruction)
4038 {
4039 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4040 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4041 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4042
4043 std::string fd = FPR(copy(fd_value));
4044 std::string fs = FPR(copy(fs_value));
4045 std::string ft = FPR(copy(ft_value));
4046
4047 return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
4048 }
4049
4050
4051 /*
4052 *
4053 *
4054 * 3 2 1
4055 * 10987654321098765432109876543210
4056 * 001000 x1110000101
4057 * rt -----
4058 * rs -----
4059 * rd -----
4060 */
4061 std::string NMD::CMP_OR_D(uint64 instruction)
4062 {
4063 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4064 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4065 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4066
4067 std::string fd = FPR(copy(fd_value));
4068 std::string fs = FPR(copy(fs_value));
4069 std::string ft = FPR(copy(ft_value));
4070
4071 return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
4072 }
4073
4074
4075 /*
4076 *
4077 *
4078 * 3 2 1
4079 * 10987654321098765432109876543210
4080 * 001000 x1110000101
4081 * rt -----
4082 * rs -----
4083 * rd -----
4084 */
4085 std::string NMD::CMP_OR_S(uint64 instruction)
4086 {
4087 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4088 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4089 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4090
4091 std::string fd = FPR(copy(fd_value));
4092 std::string fs = FPR(copy(fs_value));
4093 std::string ft = FPR(copy(ft_value));
4094
4095 return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
4096 }
4097
4098
4099 /*
4100 *
4101 *
4102 * 3 2 1
4103 * 10987654321098765432109876543210
4104 * 001000 x1110000101
4105 * rt -----
4106 * rs -----
4107 * rd -----
4108 */
4109 std::string NMD::CMP_SAF_D(uint64 instruction)
4110 {
4111 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4112 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4113 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4114
4115 std::string fd = FPR(copy(fd_value));
4116 std::string fs = FPR(copy(fs_value));
4117 std::string ft = FPR(copy(ft_value));
4118
4119 return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
4120 }
4121
4122
4123 /*
4124 *
4125 *
4126 * 3 2 1
4127 * 10987654321098765432109876543210
4128 * 001000 x1110000101
4129 * rt -----
4130 * rs -----
4131 * rd -----
4132 */
4133 std::string NMD::CMP_SAF_S(uint64 instruction)
4134 {
4135 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4136 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4137 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4138
4139 std::string fd = FPR(copy(fd_value));
4140 std::string fs = FPR(copy(fs_value));
4141 std::string ft = FPR(copy(ft_value));
4142
4143 return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
4144 }
4145
4146
4147 /*
4148 *
4149 *
4150 * 3 2 1
4151 * 10987654321098765432109876543210
4152 * 001000 x1110000101
4153 * rt -----
4154 * rs -----
4155 * rd -----
4156 */
4157 std::string NMD::CMP_SEQ_D(uint64 instruction)
4158 {
4159 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4160 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4161 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4162
4163 std::string fd = FPR(copy(fd_value));
4164 std::string fs = FPR(copy(fs_value));
4165 std::string ft = FPR(copy(ft_value));
4166
4167 return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
4168 }
4169
4170
4171 /*
4172 *
4173 *
4174 * 3 2 1
4175 * 10987654321098765432109876543210
4176 * 001000 x1110000101
4177 * rt -----
4178 * rs -----
4179 * rd -----
4180 */
4181 std::string NMD::CMP_SEQ_S(uint64 instruction)
4182 {
4183 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4184 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4185 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4186
4187 std::string fd = FPR(copy(fd_value));
4188 std::string fs = FPR(copy(fs_value));
4189 std::string ft = FPR(copy(ft_value));
4190
4191 return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
4192 }
4193
4194
4195 /*
4196 *
4197 *
4198 * 3 2 1
4199 * 10987654321098765432109876543210
4200 * 001000 x1110000101
4201 * rt -----
4202 * rs -----
4203 * rd -----
4204 */
4205 std::string NMD::CMP_SLE_D(uint64 instruction)
4206 {
4207 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4208 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4209 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4210
4211 std::string fd = FPR(copy(fd_value));
4212 std::string fs = FPR(copy(fs_value));
4213 std::string ft = FPR(copy(ft_value));
4214
4215 return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
4216 }
4217
4218
4219 /*
4220 *
4221 *
4222 * 3 2 1
4223 * 10987654321098765432109876543210
4224 * 001000 x1110000101
4225 * rt -----
4226 * rs -----
4227 * rd -----
4228 */
4229 std::string NMD::CMP_SLE_S(uint64 instruction)
4230 {
4231 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4232 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4233 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4234
4235 std::string fd = FPR(copy(fd_value));
4236 std::string fs = FPR(copy(fs_value));
4237 std::string ft = FPR(copy(ft_value));
4238
4239 return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
4240 }
4241
4242
4243 /*
4244 *
4245 *
4246 * 3 2 1
4247 * 10987654321098765432109876543210
4248 * 001000 x1110000101
4249 * rt -----
4250 * rs -----
4251 * rd -----
4252 */
4253 std::string NMD::CMP_SLT_D(uint64 instruction)
4254 {
4255 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4256 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4257 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4258
4259 std::string fd = FPR(copy(fd_value));
4260 std::string fs = FPR(copy(fs_value));
4261 std::string ft = FPR(copy(ft_value));
4262
4263 return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4264 }
4265
4266
4267 /*
4268 *
4269 *
4270 * 3 2 1
4271 * 10987654321098765432109876543210
4272 * 001000 x1110000101
4273 * rt -----
4274 * rs -----
4275 * rd -----
4276 */
4277 std::string NMD::CMP_SLT_S(uint64 instruction)
4278 {
4279 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4280 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4281 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4282
4283 std::string fd = FPR(copy(fd_value));
4284 std::string fs = FPR(copy(fs_value));
4285 std::string ft = FPR(copy(ft_value));
4286
4287 return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4288 }
4289
4290
4291 /*
4292 *
4293 *
4294 * 3 2 1
4295 * 10987654321098765432109876543210
4296 * 001000 x1110000101
4297 * rt -----
4298 * rs -----
4299 * rd -----
4300 */
4301 std::string NMD::CMP_SNE_D(uint64 instruction)
4302 {
4303 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4304 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4305 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4306
4307 std::string fd = FPR(copy(fd_value));
4308 std::string fs = FPR(copy(fs_value));
4309 std::string ft = FPR(copy(ft_value));
4310
4311 return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4312 }
4313
4314
4315 /*
4316 *
4317 *
4318 * 3 2 1
4319 * 10987654321098765432109876543210
4320 * 001000 x1110000101
4321 * rt -----
4322 * rs -----
4323 * rd -----
4324 */
4325 std::string NMD::CMP_SNE_S(uint64 instruction)
4326 {
4327 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4328 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4329 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4330
4331 std::string fd = FPR(copy(fd_value));
4332 std::string fs = FPR(copy(fs_value));
4333 std::string ft = FPR(copy(ft_value));
4334
4335 return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4336 }
4337
4338
4339 /*
4340 *
4341 *
4342 * 3 2 1
4343 * 10987654321098765432109876543210
4344 * 001000 x1110000101
4345 * rt -----
4346 * rs -----
4347 * rd -----
4348 */
4349 std::string NMD::CMP_SOR_D(uint64 instruction)
4350 {
4351 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4352 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4353 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4354
4355 std::string fd = FPR(copy(fd_value));
4356 std::string fs = FPR(copy(fs_value));
4357 std::string ft = FPR(copy(ft_value));
4358
4359 return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4360 }
4361
4362
4363 /*
4364 *
4365 *
4366 * 3 2 1
4367 * 10987654321098765432109876543210
4368 * 001000 x1110000101
4369 * rt -----
4370 * rs -----
4371 * rd -----
4372 */
4373 std::string NMD::CMP_SOR_S(uint64 instruction)
4374 {
4375 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4376 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4377 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4378
4379 std::string fd = FPR(copy(fd_value));
4380 std::string fs = FPR(copy(fs_value));
4381 std::string ft = FPR(copy(ft_value));
4382
4383 return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4384 }
4385
4386
4387 /*
4388 *
4389 *
4390 * 3 2 1
4391 * 10987654321098765432109876543210
4392 * 001000 x1110000101
4393 * rt -----
4394 * rs -----
4395 * rd -----
4396 */
4397 std::string NMD::CMP_SUEQ_D(uint64 instruction)
4398 {
4399 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4400 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4401 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4402
4403 std::string fd = FPR(copy(fd_value));
4404 std::string fs = FPR(copy(fs_value));
4405 std::string ft = FPR(copy(ft_value));
4406
4407 return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4408 }
4409
4410
4411 /*
4412 *
4413 *
4414 * 3 2 1
4415 * 10987654321098765432109876543210
4416 * 001000 x1110000101
4417 * rt -----
4418 * rs -----
4419 * rd -----
4420 */
4421 std::string NMD::CMP_SUEQ_S(uint64 instruction)
4422 {
4423 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4424 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4425 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4426
4427 std::string fd = FPR(copy(fd_value));
4428 std::string fs = FPR(copy(fs_value));
4429 std::string ft = FPR(copy(ft_value));
4430
4431 return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4432 }
4433
4434
4435 /*
4436 *
4437 *
4438 * 3 2 1
4439 * 10987654321098765432109876543210
4440 * 001000 x1110000101
4441 * rt -----
4442 * rs -----
4443 * rd -----
4444 */
4445 std::string NMD::CMP_SULE_D(uint64 instruction)
4446 {
4447 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4448 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4449 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4450
4451 std::string fd = FPR(copy(fd_value));
4452 std::string fs = FPR(copy(fs_value));
4453 std::string ft = FPR(copy(ft_value));
4454
4455 return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4456 }
4457
4458
4459 /*
4460 *
4461 *
4462 * 3 2 1
4463 * 10987654321098765432109876543210
4464 * 001000 x1110000101
4465 * rt -----
4466 * rs -----
4467 * rd -----
4468 */
4469 std::string NMD::CMP_SULE_S(uint64 instruction)
4470 {
4471 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4472 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4473 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4474
4475 std::string fd = FPR(copy(fd_value));
4476 std::string fs = FPR(copy(fs_value));
4477 std::string ft = FPR(copy(ft_value));
4478
4479 return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4480 }
4481
4482
4483 /*
4484 *
4485 *
4486 * 3 2 1
4487 * 10987654321098765432109876543210
4488 * 001000 x1110000101
4489 * rt -----
4490 * rs -----
4491 * rd -----
4492 */
4493 std::string NMD::CMP_SULT_D(uint64 instruction)
4494 {
4495 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4496 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4497 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4498
4499 std::string fd = FPR(copy(fd_value));
4500 std::string fs = FPR(copy(fs_value));
4501 std::string ft = FPR(copy(ft_value));
4502
4503 return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4504 }
4505
4506
4507 /*
4508 *
4509 *
4510 * 3 2 1
4511 * 10987654321098765432109876543210
4512 * 001000 x1110000101
4513 * rt -----
4514 * rs -----
4515 * rd -----
4516 */
4517 std::string NMD::CMP_SULT_S(uint64 instruction)
4518 {
4519 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4520 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4521 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4522
4523 std::string fd = FPR(copy(fd_value));
4524 std::string fs = FPR(copy(fs_value));
4525 std::string ft = FPR(copy(ft_value));
4526
4527 return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4528 }
4529
4530
4531 /*
4532 *
4533 *
4534 * 3 2 1
4535 * 10987654321098765432109876543210
4536 * 001000 x1110000101
4537 * rt -----
4538 * rs -----
4539 * rd -----
4540 */
4541 std::string NMD::CMP_SUN_D(uint64 instruction)
4542 {
4543 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4544 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4545 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4546
4547 std::string fd = FPR(copy(fd_value));
4548 std::string fs = FPR(copy(fs_value));
4549 std::string ft = FPR(copy(ft_value));
4550
4551 return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4552 }
4553
4554
4555 /*
4556 *
4557 *
4558 * 3 2 1
4559 * 10987654321098765432109876543210
4560 * 001000 x1110000101
4561 * rt -----
4562 * rs -----
4563 * rd -----
4564 */
4565 std::string NMD::CMP_SUNE_D(uint64 instruction)
4566 {
4567 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4568 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4569 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4570
4571 std::string fd = FPR(copy(fd_value));
4572 std::string fs = FPR(copy(fs_value));
4573 std::string ft = FPR(copy(ft_value));
4574
4575 return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4576 }
4577
4578
4579 /*
4580 *
4581 *
4582 * 3 2 1
4583 * 10987654321098765432109876543210
4584 * 001000 x1110000101
4585 * rt -----
4586 * rs -----
4587 * rd -----
4588 */
4589 std::string NMD::CMP_SUNE_S(uint64 instruction)
4590 {
4591 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4592 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4593 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4594
4595 std::string fd = FPR(copy(fd_value));
4596 std::string fs = FPR(copy(fs_value));
4597 std::string ft = FPR(copy(ft_value));
4598
4599 return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4600 }
4601
4602
4603 /*
4604 *
4605 *
4606 * 3 2 1
4607 * 10987654321098765432109876543210
4608 * 001000 x1110000101
4609 * rt -----
4610 * rs -----
4611 * rd -----
4612 */
4613 std::string NMD::CMP_SUN_S(uint64 instruction)
4614 {
4615 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4616 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4617 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4618
4619 std::string fd = FPR(copy(fd_value));
4620 std::string fs = FPR(copy(fs_value));
4621 std::string ft = FPR(copy(ft_value));
4622
4623 return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4624 }
4625
4626
4627 /*
4628 *
4629 *
4630 * 3 2 1
4631 * 10987654321098765432109876543210
4632 * 001000 x1110000101
4633 * rt -----
4634 * rs -----
4635 * rd -----
4636 */
4637 std::string NMD::CMP_UEQ_D(uint64 instruction)
4638 {
4639 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4640 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4641 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4642
4643 std::string fd = FPR(copy(fd_value));
4644 std::string fs = FPR(copy(fs_value));
4645 std::string ft = FPR(copy(ft_value));
4646
4647 return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4648 }
4649
4650
4651 /*
4652 *
4653 *
4654 * 3 2 1
4655 * 10987654321098765432109876543210
4656 * 001000 x1110000101
4657 * rt -----
4658 * rs -----
4659 * rd -----
4660 */
4661 std::string NMD::CMP_UEQ_S(uint64 instruction)
4662 {
4663 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4664 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4665 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4666
4667 std::string fd = FPR(copy(fd_value));
4668 std::string fs = FPR(copy(fs_value));
4669 std::string ft = FPR(copy(ft_value));
4670
4671 return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4672 }
4673
4674
4675 /*
4676 *
4677 *
4678 * 3 2 1
4679 * 10987654321098765432109876543210
4680 * 001000 x1110000101
4681 * rt -----
4682 * rs -----
4683 * rd -----
4684 */
4685 std::string NMD::CMP_ULE_D(uint64 instruction)
4686 {
4687 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4688 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4689 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4690
4691 std::string fd = FPR(copy(fd_value));
4692 std::string fs = FPR(copy(fs_value));
4693 std::string ft = FPR(copy(ft_value));
4694
4695 return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4696 }
4697
4698
4699 /*
4700 *
4701 *
4702 * 3 2 1
4703 * 10987654321098765432109876543210
4704 * 001000 x1110000101
4705 * rt -----
4706 * rs -----
4707 * rd -----
4708 */
4709 std::string NMD::CMP_ULE_S(uint64 instruction)
4710 {
4711 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4712 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4713 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4714
4715 std::string fd = FPR(copy(fd_value));
4716 std::string fs = FPR(copy(fs_value));
4717 std::string ft = FPR(copy(ft_value));
4718
4719 return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4720 }
4721
4722
4723 /*
4724 *
4725 *
4726 * 3 2 1
4727 * 10987654321098765432109876543210
4728 * 001000 x1110000101
4729 * rt -----
4730 * rs -----
4731 * rd -----
4732 */
4733 std::string NMD::CMP_ULT_D(uint64 instruction)
4734 {
4735 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4736 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4737 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4738
4739 std::string fd = FPR(copy(fd_value));
4740 std::string fs = FPR(copy(fs_value));
4741 std::string ft = FPR(copy(ft_value));
4742
4743 return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4744 }
4745
4746
4747 /*
4748 *
4749 *
4750 * 3 2 1
4751 * 10987654321098765432109876543210
4752 * 001000 x1110000101
4753 * rt -----
4754 * rs -----
4755 * rd -----
4756 */
4757 std::string NMD::CMP_ULT_S(uint64 instruction)
4758 {
4759 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4760 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4761 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4762
4763 std::string fd = FPR(copy(fd_value));
4764 std::string fs = FPR(copy(fs_value));
4765 std::string ft = FPR(copy(ft_value));
4766
4767 return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4768 }
4769
4770
4771 /*
4772 *
4773 *
4774 * 3 2 1
4775 * 10987654321098765432109876543210
4776 * 001000 x1110000101
4777 * rt -----
4778 * rs -----
4779 * rd -----
4780 */
4781 std::string NMD::CMP_UN_D(uint64 instruction)
4782 {
4783 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4784 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4785 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4786
4787 std::string fd = FPR(copy(fd_value));
4788 std::string fs = FPR(copy(fs_value));
4789 std::string ft = FPR(copy(ft_value));
4790
4791 return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4792 }
4793
4794
4795 /*
4796 *
4797 *
4798 * 3 2 1
4799 * 10987654321098765432109876543210
4800 * 001000 x1110000101
4801 * rt -----
4802 * rs -----
4803 * rd -----
4804 */
4805 std::string NMD::CMP_UNE_D(uint64 instruction)
4806 {
4807 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4808 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4809 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4810
4811 std::string fd = FPR(copy(fd_value));
4812 std::string fs = FPR(copy(fs_value));
4813 std::string ft = FPR(copy(ft_value));
4814
4815 return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4816 }
4817
4818
4819 /*
4820 *
4821 *
4822 * 3 2 1
4823 * 10987654321098765432109876543210
4824 * 001000 x1110000101
4825 * rt -----
4826 * rs -----
4827 * rd -----
4828 */
4829 std::string NMD::CMP_UNE_S(uint64 instruction)
4830 {
4831 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4832 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4833 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4834
4835 std::string fd = FPR(copy(fd_value));
4836 std::string fs = FPR(copy(fs_value));
4837 std::string ft = FPR(copy(ft_value));
4838
4839 return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4840 }
4841
4842
4843 /*
4844 *
4845 *
4846 * 3 2 1
4847 * 10987654321098765432109876543210
4848 * 001000 x1110000101
4849 * rt -----
4850 * rs -----
4851 * rd -----
4852 */
4853 std::string NMD::CMP_UN_S(uint64 instruction)
4854 {
4855 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4856 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4857 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4858
4859 std::string fd = FPR(copy(fd_value));
4860 std::string fs = FPR(copy(fs_value));
4861 std::string ft = FPR(copy(ft_value));
4862
4863 return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4864 }
4865
4866
4867 /*
4868 *
4869 *
4870 * 3 2 1
4871 * 10987654321098765432109876543210
4872 * 001000 x1110000101
4873 * rt -----
4874 * rs -----
4875 * rd -----
4876 */
4877 std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
4878 {
4879 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4880 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4881 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4882
4883 std::string rd = GPR(copy(rd_value));
4884 std::string rs = GPR(copy(rs_value));
4885 std::string rt = GPR(copy(rt_value));
4886
4887 return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4888 }
4889
4890
4891 /*
4892 *
4893 *
4894 * 3 2 1
4895 * 10987654321098765432109876543210
4896 * 001000 x1110000101
4897 * rt -----
4898 * rs -----
4899 * rd -----
4900 */
4901 std::string NMD::CMPGDU_LE_QB(uint64 instruction)
4902 {
4903 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4904 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4905 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4906
4907 std::string rd = GPR(copy(rd_value));
4908 std::string rs = GPR(copy(rs_value));
4909 std::string rt = GPR(copy(rt_value));
4910
4911 return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4912 }
4913
4914
4915 /*
4916 *
4917 *
4918 * 3 2 1
4919 * 10987654321098765432109876543210
4920 * 001000 x1110000101
4921 * rt -----
4922 * rs -----
4923 * rd -----
4924 */
4925 std::string NMD::CMPGDU_LT_QB(uint64 instruction)
4926 {
4927 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4928 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4929 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4930
4931 std::string rd = GPR(copy(rd_value));
4932 std::string rs = GPR(copy(rs_value));
4933 std::string rt = GPR(copy(rt_value));
4934
4935 return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4936 }
4937
4938
4939 /*
4940 *
4941 *
4942 * 3 2 1
4943 * 10987654321098765432109876543210
4944 * 001000 x1110000101
4945 * rt -----
4946 * rs -----
4947 * rd -----
4948 */
4949 std::string NMD::CMPGU_EQ_QB(uint64 instruction)
4950 {
4951 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4953 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4954
4955 std::string rd = GPR(copy(rd_value));
4956 std::string rs = GPR(copy(rs_value));
4957 std::string rt = GPR(copy(rt_value));
4958
4959 return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
4960 }
4961
4962
4963 /*
4964 *
4965 *
4966 * 3 2 1
4967 * 10987654321098765432109876543210
4968 * 001000 x1110000101
4969 * rt -----
4970 * rs -----
4971 * rd -----
4972 */
4973 std::string NMD::CMPGU_LE_QB(uint64 instruction)
4974 {
4975 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4976 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4977 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4978
4979 std::string rd = GPR(copy(rd_value));
4980 std::string rs = GPR(copy(rs_value));
4981 std::string rt = GPR(copy(rt_value));
4982
4983 return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
4984 }
4985
4986
4987 /*
4988 *
4989 *
4990 * 3 2 1
4991 * 10987654321098765432109876543210
4992 * 001000 x1110000101
4993 * rt -----
4994 * rs -----
4995 * rd -----
4996 */
4997 std::string NMD::CMPGU_LT_QB(uint64 instruction)
4998 {
4999 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5000 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5001 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5002
5003 std::string rd = GPR(copy(rd_value));
5004 std::string rs = GPR(copy(rs_value));
5005 std::string rt = GPR(copy(rt_value));
5006
5007 return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
5008 }
5009
5010
5011 /*
5012 *
5013 *
5014 * 3 2 1
5015 * 10987654321098765432109876543210
5016 * 001000 x1110000101
5017 * rt -----
5018 * rs -----
5019 * rd -----
5020 */
5021 std::string NMD::CMPU_EQ_QB(uint64 instruction)
5022 {
5023 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5024 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5025
5026 std::string rs = GPR(copy(rs_value));
5027 std::string rt = GPR(copy(rt_value));
5028
5029 return img::format("CMPU.EQ.QB %s, %s", rs, rt);
5030 }
5031
5032
5033 /*
5034 *
5035 *
5036 * 3 2 1
5037 * 10987654321098765432109876543210
5038 * 001000 x1110000101
5039 * rt -----
5040 * rs -----
5041 * rd -----
5042 */
5043 std::string NMD::CMPU_LE_QB(uint64 instruction)
5044 {
5045 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5046 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5047
5048 std::string rs = GPR(copy(rs_value));
5049 std::string rt = GPR(copy(rt_value));
5050
5051 return img::format("CMPU.LE.QB %s, %s", rs, rt);
5052 }
5053
5054
5055 /*
5056 *
5057 *
5058 * 3 2 1
5059 * 10987654321098765432109876543210
5060 * 001000 x1110000101
5061 * rt -----
5062 * rs -----
5063 * rd -----
5064 */
5065 std::string NMD::CMPU_LT_QB(uint64 instruction)
5066 {
5067 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5068 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5069
5070 std::string rs = GPR(copy(rs_value));
5071 std::string rt = GPR(copy(rt_value));
5072
5073 return img::format("CMPU.LT.QB %s, %s", rs, rt);
5074 }
5075
5076
5077 /*
5078 *
5079 *
5080 * 3 2 1
5081 * 10987654321098765432109876543210
5082 * 001000 x1110000101
5083 * rt -----
5084 * rs -----
5085 * rd -----
5086 */
5087 std::string NMD::COP2_1(uint64 instruction)
5088 {
5089 uint64 cofun_value = extract_cofun_25_24_23(instruction);
5090
5091 std::string cofun = IMMEDIATE(copy(cofun_value));
5092
5093 return img::format("COP2_1 %s", cofun);
5094 }
5095
5096
5097 /*
5098 *
5099 *
5100 * 3 2 1
5101 * 10987654321098765432109876543210
5102 * 001000 x1110000101
5103 * rt -----
5104 * rs -----
5105 * rd -----
5106 */
5107 std::string NMD::CTC1(uint64 instruction)
5108 {
5109 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5110 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5111
5112 std::string rt = GPR(copy(rt_value));
5113 std::string cs = CPR(copy(cs_value));
5114
5115 return img::format("CTC1 %s, %s", rt, cs);
5116 }
5117
5118
5119 /*
5120 *
5121 *
5122 * 3 2 1
5123 * 10987654321098765432109876543210
5124 * 001000 x1110000101
5125 * rt -----
5126 * rs -----
5127 * rd -----
5128 */
5129 std::string NMD::CTC2(uint64 instruction)
5130 {
5131 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5132 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5133
5134 std::string rt = GPR(copy(rt_value));
5135 std::string cs = CPR(copy(cs_value));
5136
5137 return img::format("CTC2 %s, %s", rt, cs);
5138 }
5139
5140
5141 /*
5142 *
5143 *
5144 * 3 2 1
5145 * 10987654321098765432109876543210
5146 * 001000 x1110000101
5147 * rt -----
5148 * rs -----
5149 * rd -----
5150 */
5151 std::string NMD::CVT_D_L(uint64 instruction)
5152 {
5153 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5154 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5155
5156 std::string ft = FPR(copy(ft_value));
5157 std::string fs = FPR(copy(fs_value));
5158
5159 return img::format("CVT.D.L %s, %s", ft, fs);
5160 }
5161
5162
5163 /*
5164 *
5165 *
5166 * 3 2 1
5167 * 10987654321098765432109876543210
5168 * 001000 x1110000101
5169 * rt -----
5170 * rs -----
5171 * rd -----
5172 */
5173 std::string NMD::CVT_D_S(uint64 instruction)
5174 {
5175 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5176 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5177
5178 std::string ft = FPR(copy(ft_value));
5179 std::string fs = FPR(copy(fs_value));
5180
5181 return img::format("CVT.D.S %s, %s", ft, fs);
5182 }
5183
5184
5185 /*
5186 *
5187 *
5188 * 3 2 1
5189 * 10987654321098765432109876543210
5190 * 001000 x1110000101
5191 * rt -----
5192 * rs -----
5193 * rd -----
5194 */
5195 std::string NMD::CVT_D_W(uint64 instruction)
5196 {
5197 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5198 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5199
5200 std::string ft = FPR(copy(ft_value));
5201 std::string fs = FPR(copy(fs_value));
5202
5203 return img::format("CVT.D.W %s, %s", ft, fs);
5204 }
5205
5206
5207 /*
5208 *
5209 *
5210 * 3 2 1
5211 * 10987654321098765432109876543210
5212 * 001000 x1110000101
5213 * rt -----
5214 * rs -----
5215 * rd -----
5216 */
5217 std::string NMD::CVT_L_D(uint64 instruction)
5218 {
5219 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5220 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5221
5222 std::string ft = FPR(copy(ft_value));
5223 std::string fs = FPR(copy(fs_value));
5224
5225 return img::format("CVT.L.D %s, %s", ft, fs);
5226 }
5227
5228
5229 /*
5230 *
5231 *
5232 * 3 2 1
5233 * 10987654321098765432109876543210
5234 * 001000 x1110000101
5235 * rt -----
5236 * rs -----
5237 * rd -----
5238 */
5239 std::string NMD::CVT_L_S(uint64 instruction)
5240 {
5241 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5242 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5243
5244 std::string ft = FPR(copy(ft_value));
5245 std::string fs = FPR(copy(fs_value));
5246
5247 return img::format("CVT.L.S %s, %s", ft, fs);
5248 }
5249
5250
5251 /*
5252 *
5253 *
5254 * 3 2 1
5255 * 10987654321098765432109876543210
5256 * 001000 x1110000101
5257 * rt -----
5258 * rs -----
5259 * rd -----
5260 */
5261 std::string NMD::CVT_S_D(uint64 instruction)
5262 {
5263 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5264 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5265
5266 std::string ft = FPR(copy(ft_value));
5267 std::string fs = FPR(copy(fs_value));
5268
5269 return img::format("CVT.S.D %s, %s", ft, fs);
5270 }
5271
5272
5273 /*
5274 *
5275 *
5276 * 3 2 1
5277 * 10987654321098765432109876543210
5278 * 001000 x1110000101
5279 * rt -----
5280 * rs -----
5281 * rd -----
5282 */
5283 std::string NMD::CVT_S_L(uint64 instruction)
5284 {
5285 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5286 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5287
5288 std::string ft = FPR(copy(ft_value));
5289 std::string fs = FPR(copy(fs_value));
5290
5291 return img::format("CVT.S.L %s, %s", ft, fs);
5292 }
5293
5294
5295 /*
5296 *
5297 *
5298 * 3 2 1
5299 * 10987654321098765432109876543210
5300 * 001000 x1110000101
5301 * rt -----
5302 * rs -----
5303 * rd -----
5304 */
5305 std::string NMD::CVT_S_PL(uint64 instruction)
5306 {
5307 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5308 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5309
5310 std::string ft = FPR(copy(ft_value));
5311 std::string fs = FPR(copy(fs_value));
5312
5313 return img::format("CVT.S.PL %s, %s", ft, fs);
5314 }
5315
5316
5317 /*
5318 *
5319 *
5320 * 3 2 1
5321 * 10987654321098765432109876543210
5322 * 001000 x1110000101
5323 * rt -----
5324 * rs -----
5325 * rd -----
5326 */
5327 std::string NMD::CVT_S_PU(uint64 instruction)
5328 {
5329 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5330 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5331
5332 std::string ft = FPR(copy(ft_value));
5333 std::string fs = FPR(copy(fs_value));
5334
5335 return img::format("CVT.S.PU %s, %s", ft, fs);
5336 }
5337
5338
5339 /*
5340 *
5341 *
5342 * 3 2 1
5343 * 10987654321098765432109876543210
5344 * 001000 x1110000101
5345 * rt -----
5346 * rs -----
5347 * rd -----
5348 */
5349 std::string NMD::CVT_S_W(uint64 instruction)
5350 {
5351 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5352 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5353
5354 std::string ft = FPR(copy(ft_value));
5355 std::string fs = FPR(copy(fs_value));
5356
5357 return img::format("CVT.S.W %s, %s", ft, fs);
5358 }
5359
5360
5361 /*
5362 *
5363 *
5364 * 3 2 1
5365 * 10987654321098765432109876543210
5366 * 001000 x1110000101
5367 * rt -----
5368 * rs -----
5369 * rd -----
5370 */
5371 std::string NMD::CVT_W_D(uint64 instruction)
5372 {
5373 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5374 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5375
5376 std::string ft = FPR(copy(ft_value));
5377 std::string fs = FPR(copy(fs_value));
5378
5379 return img::format("CVT.W.D %s, %s", ft, fs);
5380 }
5381
5382
5383 /*
5384 *
5385 *
5386 * 3 2 1
5387 * 10987654321098765432109876543210
5388 * 001000 x1110000101
5389 * rt -----
5390 * rs -----
5391 * rd -----
5392 */
5393 std::string NMD::CVT_W_S(uint64 instruction)
5394 {
5395 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5396 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5397
5398 std::string ft = FPR(copy(ft_value));
5399 std::string fs = FPR(copy(fs_value));
5400
5401 return img::format("CVT.W.S %s, %s", ft, fs);
5402 }
5403
5404
5405 /*
5406 *
5407 *
5408 * 3 2 1
5409 * 10987654321098765432109876543210
5410 * 001000 x1110000101
5411 * rt -----
5412 * rs -----
5413 * rd -----
5414 */
5415 std::string NMD::DADDIU_48_(uint64 instruction)
5416 {
5417 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5418 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
5419
5420 std::string rt = GPR(copy(rt_value));
5421 std::string s = IMMEDIATE(copy(s_value));
5422
5423 return img::format("DADDIU %s, %s", rt, s);
5424 }
5425
5426
5427 /*
5428 *
5429 *
5430 * 3 2 1
5431 * 10987654321098765432109876543210
5432 * 001000 x1110000101
5433 * rt -----
5434 * rs -----
5435 * rd -----
5436 */
5437 std::string NMD::DADDIU_NEG_(uint64 instruction)
5438 {
5439 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5440 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5441 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5442
5443 std::string rt = GPR(copy(rt_value));
5444 std::string rs = GPR(copy(rs_value));
5445 std::string u = IMMEDIATE(neg_copy(u_value));
5446
5447 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5448 }
5449
5450
5451 /*
5452 *
5453 *
5454 * 3 2 1
5455 * 10987654321098765432109876543210
5456 * 001000 x1110000101
5457 * rt -----
5458 * rs -----
5459 * rd -----
5460 */
5461 std::string NMD::DADDIU_U12_(uint64 instruction)
5462 {
5463 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5464 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5465 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5466
5467 std::string rt = GPR(copy(rt_value));
5468 std::string rs = GPR(copy(rs_value));
5469 std::string u = IMMEDIATE(copy(u_value));
5470
5471 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5472 }
5473
5474
5475 /*
5476 *
5477 *
5478 * 3 2 1
5479 * 10987654321098765432109876543210
5480 * 001000 x1110000101
5481 * rt -----
5482 * rs -----
5483 * rd -----
5484 */
5485 std::string NMD::DADD(uint64 instruction)
5486 {
5487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5489 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5490
5491 std::string rd = GPR(copy(rd_value));
5492 std::string rs = GPR(copy(rs_value));
5493 std::string rt = GPR(copy(rt_value));
5494
5495 return img::format("DADD %s, %s, %s", rd, rs, rt);
5496 }
5497
5498
5499 /*
5500 *
5501 *
5502 * 3 2 1
5503 * 10987654321098765432109876543210
5504 * 001000 x1110000101
5505 * rt -----
5506 * rs -----
5507 * rd -----
5508 */
5509 std::string NMD::DADDU(uint64 instruction)
5510 {
5511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5513 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5514
5515 std::string rd = GPR(copy(rd_value));
5516 std::string rs = GPR(copy(rs_value));
5517 std::string rt = GPR(copy(rt_value));
5518
5519 return img::format("DADDU %s, %s, %s", rd, rs, rt);
5520 }
5521
5522
5523 /*
5524 *
5525 *
5526 * 3 2 1
5527 * 10987654321098765432109876543210
5528 * 001000 x1110000101
5529 * rt -----
5530 * rs -----
5531 * rd -----
5532 */
5533 std::string NMD::DCLO(uint64 instruction)
5534 {
5535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5536 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5537
5538 std::string rt = GPR(copy(rt_value));
5539 std::string rs = GPR(copy(rs_value));
5540
5541 return img::format("DCLO %s, %s", rt, rs);
5542 }
5543
5544
5545 /*
5546 *
5547 *
5548 * 3 2 1
5549 * 10987654321098765432109876543210
5550 * 001000 x1110000101
5551 * rt -----
5552 * rs -----
5553 * rd -----
5554 */
5555 std::string NMD::DCLZ(uint64 instruction)
5556 {
5557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5559
5560 std::string rt = GPR(copy(rt_value));
5561 std::string rs = GPR(copy(rs_value));
5562
5563 return img::format("DCLZ %s, %s", rt, rs);
5564 }
5565
5566
5567 /*
5568 *
5569 *
5570 * 3 2 1
5571 * 10987654321098765432109876543210
5572 * 001000 x1110000101
5573 * rt -----
5574 * rs -----
5575 * rd -----
5576 */
5577 std::string NMD::DDIV(uint64 instruction)
5578 {
5579 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5580 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5581 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5582
5583 std::string rd = GPR(copy(rd_value));
5584 std::string rs = GPR(copy(rs_value));
5585 std::string rt = GPR(copy(rt_value));
5586
5587 return img::format("DDIV %s, %s, %s", rd, rs, rt);
5588 }
5589
5590
5591 /*
5592 *
5593 *
5594 * 3 2 1
5595 * 10987654321098765432109876543210
5596 * 001000 x1110000101
5597 * rt -----
5598 * rs -----
5599 * rd -----
5600 */
5601 std::string NMD::DDIVU(uint64 instruction)
5602 {
5603 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5604 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5605 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5606
5607 std::string rd = GPR(copy(rd_value));
5608 std::string rs = GPR(copy(rs_value));
5609 std::string rt = GPR(copy(rt_value));
5610
5611 return img::format("DDIVU %s, %s, %s", rd, rs, rt);
5612 }
5613
5614
5615 /*
5616 *
5617 *
5618 * 3 2 1
5619 * 10987654321098765432109876543210
5620 * 001000 x1110000101
5621 * rt -----
5622 * rs -----
5623 * rd -----
5624 */
5625 std::string NMD::DERET(uint64 instruction)
5626 {
5627 (void)instruction;
5628
5629 return "DERET ";
5630 }
5631
5632
5633 /*
5634 *
5635 *
5636 * 3 2 1
5637 * 10987654321098765432109876543210
5638 * 001000 x1110000101
5639 * rt -----
5640 * rs -----
5641 * rd -----
5642 */
5643 std::string NMD::DEXTM(uint64 instruction)
5644 {
5645 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5646 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5647 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5648 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5649
5650 std::string rt = GPR(copy(rt_value));
5651 std::string rs = GPR(copy(rs_value));
5652 std::string lsb = IMMEDIATE(copy(lsb_value));
5653 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5654
5655 return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
5656 }
5657
5658
5659 /*
5660 *
5661 *
5662 * 3 2 1
5663 * 10987654321098765432109876543210
5664 * 001000 x1110000101
5665 * rt -----
5666 * rs -----
5667 * rd -----
5668 */
5669 std::string NMD::DEXT(uint64 instruction)
5670 {
5671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5672 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5673 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5674 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5675
5676 std::string rt = GPR(copy(rt_value));
5677 std::string rs = GPR(copy(rs_value));
5678 std::string lsb = IMMEDIATE(copy(lsb_value));
5679 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5680
5681 return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
5682 }
5683
5684
5685 /*
5686 *
5687 *
5688 * 3 2 1
5689 * 10987654321098765432109876543210
5690 * 001000 x1110000101
5691 * rt -----
5692 * rs -----
5693 * rd -----
5694 */
5695 std::string NMD::DEXTU(uint64 instruction)
5696 {
5697 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5698 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5699 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5700 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5701
5702 std::string rt = GPR(copy(rt_value));
5703 std::string rs = GPR(copy(rs_value));
5704 std::string lsb = IMMEDIATE(copy(lsb_value));
5705 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5706
5707 return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
5708 }
5709
5710
5711 /*
5712 *
5713 *
5714 * 3 2 1
5715 * 10987654321098765432109876543210
5716 * 001000 x1110000101
5717 * rt -----
5718 * rs -----
5719 * rd -----
5720 */
5721 std::string NMD::DINSM(uint64 instruction)
5722 {
5723 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5724 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5725 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5726 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5727
5728 std::string rt = GPR(copy(rt_value));
5729 std::string rs = GPR(copy(rs_value));
5730 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5731 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5732 /* !!!!!!!!!! - no conversion function */
5733
5734 return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
5735 /* hand edited */
5736 }
5737
5738
5739 /*
5740 *
5741 *
5742 * 3 2 1
5743 * 10987654321098765432109876543210
5744 * 001000 x1110000101
5745 * rt -----
5746 * rs -----
5747 * rd -----
5748 */
5749 std::string NMD::DINS(uint64 instruction)
5750 {
5751 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5752 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5753 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5754 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5755
5756 std::string rt = GPR(copy(rt_value));
5757 std::string rs = GPR(copy(rs_value));
5758 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5759 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5760 /* !!!!!!!!!! - no conversion function */
5761
5762 return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
5763 /* hand edited */
5764 }
5765
5766
5767 /*
5768 *
5769 *
5770 * 3 2 1
5771 * 10987654321098765432109876543210
5772 * 001000 x1110000101
5773 * rt -----
5774 * rs -----
5775 * rd -----
5776 */
5777 std::string NMD::DINSU(uint64 instruction)
5778 {
5779 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5780 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5781 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5782 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5783
5784 std::string rt = GPR(copy(rt_value));
5785 std::string rs = GPR(copy(rs_value));
5786 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5787 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5788 /* !!!!!!!!!! - no conversion function */
5789
5790 return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
5791 /* hand edited */
5792 }
5793
5794
5795 /*
5796 *
5797 *
5798 * 3 2 1
5799 * 10987654321098765432109876543210
5800 * 001000 x1110000101
5801 * rt -----
5802 * rs -----
5803 * rd -----
5804 */
5805 std::string NMD::DI(uint64 instruction)
5806 {
5807 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5808
5809 std::string rt = GPR(copy(rt_value));
5810
5811 return img::format("DI %s", rt);
5812 }
5813
5814
5815 /*
5816 *
5817 *
5818 * 3 2 1
5819 * 10987654321098765432109876543210
5820 * 001000 x1110000101
5821 * rt -----
5822 * rs -----
5823 * rd -----
5824 */
5825 std::string NMD::DIV(uint64 instruction)
5826 {
5827 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5828 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5829 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5830
5831 std::string rd = GPR(copy(rd_value));
5832 std::string rs = GPR(copy(rs_value));
5833 std::string rt = GPR(copy(rt_value));
5834
5835 return img::format("DIV %s, %s, %s", rd, rs, rt);
5836 }
5837
5838
5839 /*
5840 *
5841 *
5842 * 3 2 1
5843 * 10987654321098765432109876543210
5844 * 001000 x1110000101
5845 * rt -----
5846 * rs -----
5847 * rd -----
5848 */
5849 std::string NMD::DIV_D(uint64 instruction)
5850 {
5851 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5852 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5853 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5854
5855 std::string fd = FPR(copy(fd_value));
5856 std::string fs = FPR(copy(fs_value));
5857 std::string ft = FPR(copy(ft_value));
5858
5859 return img::format("DIV.D %s, %s, %s", fd, fs, ft);
5860 }
5861
5862
5863 /*
5864 *
5865 *
5866 * 3 2 1
5867 * 10987654321098765432109876543210
5868 * 001000 x1110000101
5869 * rt -----
5870 * rs -----
5871 * rd -----
5872 */
5873 std::string NMD::DIV_S(uint64 instruction)
5874 {
5875 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5876 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5877 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5878
5879 std::string fd = FPR(copy(fd_value));
5880 std::string fs = FPR(copy(fs_value));
5881 std::string ft = FPR(copy(ft_value));
5882
5883 return img::format("DIV.S %s, %s, %s", fd, fs, ft);
5884 }
5885
5886
5887 /*
5888 *
5889 *
5890 * 3 2 1
5891 * 10987654321098765432109876543210
5892 * 001000 x1110000101
5893 * rt -----
5894 * rs -----
5895 * rd -----
5896 */
5897 std::string NMD::DIVU(uint64 instruction)
5898 {
5899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5900 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5901 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5902
5903 std::string rd = GPR(copy(rd_value));
5904 std::string rs = GPR(copy(rs_value));
5905 std::string rt = GPR(copy(rt_value));
5906
5907 return img::format("DIVU %s, %s, %s", rd, rs, rt);
5908 }
5909
5910
5911 /*
5912 *
5913 *
5914 * 3 2 1
5915 * 10987654321098765432109876543210
5916 * 001000 x1110000101
5917 * rt -----
5918 * rs -----
5919 * rd -----
5920 */
5921 std::string NMD::DLSA(uint64 instruction)
5922 {
5923 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5924 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5925 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5926 uint64 u2_value = extract_u2_10_9(instruction);
5927
5928 std::string rd = GPR(copy(rd_value));
5929 std::string rs = GPR(copy(rs_value));
5930 std::string rt = GPR(copy(rt_value));
5931 std::string u2 = IMMEDIATE(copy(u2_value));
5932
5933 return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
5934 }
5935
5936
5937 /*
5938 *
5939 *
5940 * 3 2 1
5941 * 10987654321098765432109876543210
5942 * 001000 x1110000101
5943 * rt -----
5944 * rs -----
5945 * rd -----
5946 */
5947 std::string NMD::DLUI_48_(uint64 instruction)
5948 {
5949 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5950 uint64 u_value = extract_u_31_to_0__s32(instruction);
5951
5952 std::string rt = GPR(copy(rt_value));
5953 std::string u = IMMEDIATE(copy(u_value));
5954
5955 return img::format("DLUI %s, %s", rt, u);
5956 }
5957
5958
5959 /*
5960 *
5961 *
5962 * 3 2 1
5963 * 10987654321098765432109876543210
5964 * 001000 x1110000101
5965 * rt -----
5966 * rs -----
5967 * rd -----
5968 */
5969 std::string NMD::DMFC0(uint64 instruction)
5970 {
5971 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5972 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5973 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5974
5975 std::string rt = GPR(copy(rt_value));
5976 std::string c0s = CPR(copy(c0s_value));
5977 std::string sel = IMMEDIATE(copy(sel_value));
5978
5979 return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
5980 }
5981
5982
5983 /*
5984 *
5985 *
5986 * 3 2 1
5987 * 10987654321098765432109876543210
5988 * 001000 x1110000101
5989 * rt -----
5990 * rs -----
5991 * rd -----
5992 */
5993 std::string NMD::DMFC1(uint64 instruction)
5994 {
5995 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5996 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5997
5998 std::string rt = GPR(copy(rt_value));
5999 std::string fs = FPR(copy(fs_value));
6000
6001 return img::format("DMFC1 %s, %s", rt, fs);
6002 }
6003
6004
6005 /*
6006 *
6007 *
6008 * 3 2 1
6009 * 10987654321098765432109876543210
6010 * 001000 x1110000101
6011 * rt -----
6012 * rs -----
6013 * rd -----
6014 */
6015 std::string NMD::DMFC2(uint64 instruction)
6016 {
6017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6018 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6019
6020 std::string rt = GPR(copy(rt_value));
6021 std::string cs = CPR(copy(cs_value));
6022
6023 return img::format("DMFC2 %s, %s", rt, cs);
6024 }
6025
6026
6027 /*
6028 *
6029 *
6030 * 3 2 1
6031 * 10987654321098765432109876543210
6032 * 001000 x1110000101
6033 * rt -----
6034 * rs -----
6035 * rd -----
6036 */
6037 std::string NMD::DMFGC0(uint64 instruction)
6038 {
6039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6040 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6041 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6042
6043 std::string rt = GPR(copy(rt_value));
6044 std::string c0s = CPR(copy(c0s_value));
6045 std::string sel = IMMEDIATE(copy(sel_value));
6046
6047 return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
6048 }
6049
6050
6051 /*
6052 *
6053 *
6054 * 3 2 1
6055 * 10987654321098765432109876543210
6056 * 001000 x1110000101
6057 * rt -----
6058 * rs -----
6059 * rd -----
6060 */
6061 std::string NMD::DMOD(uint64 instruction)
6062 {
6063 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6064 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6065 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6066
6067 std::string rd = GPR(copy(rd_value));
6068 std::string rs = GPR(copy(rs_value));
6069 std::string rt = GPR(copy(rt_value));
6070
6071 return img::format("DMOD %s, %s, %s", rd, rs, rt);
6072 }
6073
6074
6075 /*
6076 *
6077 *
6078 * 3 2 1
6079 * 10987654321098765432109876543210
6080 * 001000 x1110000101
6081 * rt -----
6082 * rs -----
6083 * rd -----
6084 */
6085 std::string NMD::DMODU(uint64 instruction)
6086 {
6087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6089 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6090
6091 std::string rd = GPR(copy(rd_value));
6092 std::string rs = GPR(copy(rs_value));
6093 std::string rt = GPR(copy(rt_value));
6094
6095 return img::format("DMODU %s, %s, %s", rd, rs, rt);
6096 }
6097
6098
6099 /*
6100 *
6101 *
6102 * 3 2 1
6103 * 10987654321098765432109876543210
6104 * 001000 x1110000101
6105 * rt -----
6106 * rs -----
6107 * rd -----
6108 */
6109 std::string NMD::DMTC0(uint64 instruction)
6110 {
6111 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6112 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6113 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6114
6115 std::string rt = GPR(copy(rt_value));
6116 std::string c0s = CPR(copy(c0s_value));
6117 std::string sel = IMMEDIATE(copy(sel_value));
6118
6119 return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
6120 }
6121
6122
6123 /*
6124 *
6125 *
6126 * 3 2 1
6127 * 10987654321098765432109876543210
6128 * 001000 x1110000101
6129 * rt -----
6130 * rs -----
6131 * rd -----
6132 */
6133 std::string NMD::DMTC1(uint64 instruction)
6134 {
6135 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6136 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
6137
6138 std::string rt = GPR(copy(rt_value));
6139 std::string fs = FPR(copy(fs_value));
6140
6141 return img::format("DMTC1 %s, %s", rt, fs);
6142 }
6143
6144
6145 /*
6146 *
6147 *
6148 * 3 2 1
6149 * 10987654321098765432109876543210
6150 * 001000 x1110000101
6151 * rt -----
6152 * rs -----
6153 * rd -----
6154 */
6155 std::string NMD::DMTC2(uint64 instruction)
6156 {
6157 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6158 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6159
6160 std::string rt = GPR(copy(rt_value));
6161 std::string cs = CPR(copy(cs_value));
6162
6163 return img::format("DMTC2 %s, %s", rt, cs);
6164 }
6165
6166
6167 /*
6168 *
6169 *
6170 * 3 2 1
6171 * 10987654321098765432109876543210
6172 * 001000 x1110000101
6173 * rt -----
6174 * rs -----
6175 * rd -----
6176 */
6177 std::string NMD::DMTGC0(uint64 instruction)
6178 {
6179 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6180 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6181 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6182
6183 std::string rt = GPR(copy(rt_value));
6184 std::string c0s = CPR(copy(c0s_value));
6185 std::string sel = IMMEDIATE(copy(sel_value));
6186
6187 return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
6188 }
6189
6190
6191 /*
6192 *
6193 *
6194 * 3 2 1
6195 * 10987654321098765432109876543210
6196 * 001000 x1110000101
6197 * rt -----
6198 * rs -----
6199 * rd -----
6200 */
6201 std::string NMD::DMT(uint64 instruction)
6202 {
6203 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6204
6205 std::string rt = GPR(copy(rt_value));
6206
6207 return img::format("DMT %s", rt);
6208 }
6209
6210
6211 /*
6212 *
6213 *
6214 * 3 2 1
6215 * 10987654321098765432109876543210
6216 * 001000 x1110000101
6217 * rt -----
6218 * rs -----
6219 * rd -----
6220 */
6221 std::string NMD::DMUH(uint64 instruction)
6222 {
6223 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6224 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6225 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6226
6227 std::string rd = GPR(copy(rd_value));
6228 std::string rs = GPR(copy(rs_value));
6229 std::string rt = GPR(copy(rt_value));
6230
6231 return img::format("DMUH %s, %s, %s", rd, rs, rt);
6232 }
6233
6234
6235 /*
6236 *
6237 *
6238 * 3 2 1
6239 * 10987654321098765432109876543210
6240 * 001000 x1110000101
6241 * rt -----
6242 * rs -----
6243 * rd -----
6244 */
6245 std::string NMD::DMUHU(uint64 instruction)
6246 {
6247 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6248 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6249 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6250
6251 std::string rd = GPR(copy(rd_value));
6252 std::string rs = GPR(copy(rs_value));
6253 std::string rt = GPR(copy(rt_value));
6254
6255 return img::format("DMUHU %s, %s, %s", rd, rs, rt);
6256 }
6257
6258
6259 /*
6260 *
6261 *
6262 * 3 2 1
6263 * 10987654321098765432109876543210
6264 * 001000 x1110000101
6265 * rt -----
6266 * rs -----
6267 * rd -----
6268 */
6269 std::string NMD::DMUL(uint64 instruction)
6270 {
6271 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6272 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6273 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6274
6275 std::string rd = GPR(copy(rd_value));
6276 std::string rs = GPR(copy(rs_value));
6277 std::string rt = GPR(copy(rt_value));
6278
6279 return img::format("DMUL %s, %s, %s", rd, rs, rt);
6280 }
6281
6282
6283 /*
6284 *
6285 *
6286 * 3 2 1
6287 * 10987654321098765432109876543210
6288 * 001000 x1110000101
6289 * rt -----
6290 * rs -----
6291 * rd -----
6292 */
6293 std::string NMD::DMULU(uint64 instruction)
6294 {
6295 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6296 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6297 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6298
6299 std::string rd = GPR(copy(rd_value));
6300 std::string rs = GPR(copy(rs_value));
6301 std::string rt = GPR(copy(rt_value));
6302
6303 return img::format("DMULU %s, %s, %s", rd, rs, rt);
6304 }
6305
6306
6307 /*
6308 *
6309 *
6310 * 3 2 1
6311 * 10987654321098765432109876543210
6312 * 001000 x1110000101
6313 * rt -----
6314 * rs -----
6315 * rd -----
6316 */
6317 std::string NMD::DPA_W_PH(uint64 instruction)
6318 {
6319 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6320 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6321 uint64 ac_value = extract_ac_13_12(instruction);
6322
6323 std::string ac = AC(copy(ac_value));
6324 std::string rs = GPR(copy(rs_value));
6325 std::string rt = GPR(copy(rt_value));
6326
6327 return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6328 }
6329
6330
6331 /*
6332 *
6333 *
6334 * 3 2 1
6335 * 10987654321098765432109876543210
6336 * 001000 x1110000101
6337 * rt -----
6338 * rs -----
6339 * rd -----
6340 */
6341 std::string NMD::DPAQ_SA_L_W(uint64 instruction)
6342 {
6343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6344 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6345 uint64 ac_value = extract_ac_13_12(instruction);
6346
6347 std::string ac = AC(copy(ac_value));
6348 std::string rs = GPR(copy(rs_value));
6349 std::string rt = GPR(copy(rt_value));
6350
6351 return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6352 }
6353
6354
6355 /*
6356 *
6357 *
6358 * 3 2 1
6359 * 10987654321098765432109876543210
6360 * 001000 x1110000101
6361 * rt -----
6362 * rs -----
6363 * rd -----
6364 */
6365 std::string NMD::DPAQ_S_W_PH(uint64 instruction)
6366 {
6367 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6368 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6369 uint64 ac_value = extract_ac_13_12(instruction);
6370
6371 std::string ac = AC(copy(ac_value));
6372 std::string rs = GPR(copy(rs_value));
6373 std::string rt = GPR(copy(rt_value));
6374
6375 return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6376 }
6377
6378
6379 /*
6380 *
6381 *
6382 * 3 2 1
6383 * 10987654321098765432109876543210
6384 * 001000 x1110000101
6385 * rt -----
6386 * rs -----
6387 * rd -----
6388 */
6389 std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
6390 {
6391 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6392 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6393 uint64 ac_value = extract_ac_13_12(instruction);
6394
6395 std::string ac = AC(copy(ac_value));
6396 std::string rs = GPR(copy(rs_value));
6397 std::string rt = GPR(copy(rt_value));
6398
6399 return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6400 }
6401
6402
6403 /*
6404 *
6405 *
6406 * 3 2 1
6407 * 10987654321098765432109876543210
6408 * 001000 x1110000101
6409 * rt -----
6410 * rs -----
6411 * rd -----
6412 */
6413 std::string NMD::DPAQX_S_W_PH(uint64 instruction)
6414 {
6415 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6416 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6417 uint64 ac_value = extract_ac_13_12(instruction);
6418
6419 std::string ac = AC(copy(ac_value));
6420 std::string rs = GPR(copy(rs_value));
6421 std::string rt = GPR(copy(rt_value));
6422
6423 return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6424 }
6425
6426
6427 /*
6428 *
6429 *
6430 * 3 2 1
6431 * 10987654321098765432109876543210
6432 * 001000 x1110000101
6433 * rt -----
6434 * rs -----
6435 * rd -----
6436 */
6437 std::string NMD::DPAU_H_QBL(uint64 instruction)
6438 {
6439 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6440 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6441 uint64 ac_value = extract_ac_13_12(instruction);
6442
6443 std::string ac = AC(copy(ac_value));
6444 std::string rs = GPR(copy(rs_value));
6445 std::string rt = GPR(copy(rt_value));
6446
6447 return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6448 }
6449
6450
6451 /*
6452 *
6453 *
6454 * 3 2 1
6455 * 10987654321098765432109876543210
6456 * 001000 x1110000101
6457 * rt -----
6458 * rs -----
6459 * rd -----
6460 */
6461 std::string NMD::DPAU_H_QBR(uint64 instruction)
6462 {
6463 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6464 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6465 uint64 ac_value = extract_ac_13_12(instruction);
6466
6467 std::string ac = AC(copy(ac_value));
6468 std::string rs = GPR(copy(rs_value));
6469 std::string rt = GPR(copy(rt_value));
6470
6471 return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6472 }
6473
6474
6475 /*
6476 *
6477 *
6478 * 3 2 1
6479 * 10987654321098765432109876543210
6480 * 001000 x1110000101
6481 * rt -----
6482 * rs -----
6483 * rd -----
6484 */
6485 std::string NMD::DPAX_W_PH(uint64 instruction)
6486 {
6487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6489 uint64 ac_value = extract_ac_13_12(instruction);
6490
6491 std::string ac = AC(copy(ac_value));
6492 std::string rs = GPR(copy(rs_value));
6493 std::string rt = GPR(copy(rt_value));
6494
6495 return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6496 }
6497
6498
6499 /*
6500 *
6501 *
6502 * 3 2 1
6503 * 10987654321098765432109876543210
6504 * 001000 x1110000101
6505 * rt -----
6506 * rs -----
6507 * rd -----
6508 */
6509 std::string NMD::DPS_W_PH(uint64 instruction)
6510 {
6511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6513 uint64 ac_value = extract_ac_13_12(instruction);
6514
6515 std::string ac = AC(copy(ac_value));
6516 std::string rs = GPR(copy(rs_value));
6517 std::string rt = GPR(copy(rt_value));
6518
6519 return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6520 }
6521
6522
6523 /*
6524 *
6525 *
6526 * 3 2 1
6527 * 10987654321098765432109876543210
6528 * 001000 x1110000101
6529 * rt -----
6530 * rs -----
6531 * rd -----
6532 */
6533 std::string NMD::DPSQ_SA_L_W(uint64 instruction)
6534 {
6535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6536 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6537 uint64 ac_value = extract_ac_13_12(instruction);
6538
6539 std::string ac = AC(copy(ac_value));
6540 std::string rs = GPR(copy(rs_value));
6541 std::string rt = GPR(copy(rt_value));
6542
6543 return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6544 }
6545
6546
6547 /*
6548 *
6549 *
6550 * 3 2 1
6551 * 10987654321098765432109876543210
6552 * 001000 x1110000101
6553 * rt -----
6554 * rs -----
6555 * rd -----
6556 */
6557 std::string NMD::DPSQ_S_W_PH(uint64 instruction)
6558 {
6559 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6560 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6561 uint64 ac_value = extract_ac_13_12(instruction);
6562
6563 std::string ac = AC(copy(ac_value));
6564 std::string rs = GPR(copy(rs_value));
6565 std::string rt = GPR(copy(rt_value));
6566
6567 return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6568 }
6569
6570
6571 /*
6572 *
6573 *
6574 * 3 2 1
6575 * 10987654321098765432109876543210
6576 * 001000 x1110000101
6577 * rt -----
6578 * rs -----
6579 * rd -----
6580 */
6581 std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
6582 {
6583 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6584 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6585 uint64 ac_value = extract_ac_13_12(instruction);
6586
6587 std::string ac = AC(copy(ac_value));
6588 std::string rs = GPR(copy(rs_value));
6589 std::string rt = GPR(copy(rt_value));
6590
6591 return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6592 }
6593
6594
6595 /*
6596 *
6597 *
6598 * 3 2 1
6599 * 10987654321098765432109876543210
6600 * 001000 x1110000101
6601 * rt -----
6602 * rs -----
6603 * rd -----
6604 */
6605 std::string NMD::DPSQX_S_W_PH(uint64 instruction)
6606 {
6607 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6608 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6609 uint64 ac_value = extract_ac_13_12(instruction);
6610
6611 std::string ac = AC(copy(ac_value));
6612 std::string rs = GPR(copy(rs_value));
6613 std::string rt = GPR(copy(rt_value));
6614
6615 return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6616 }
6617
6618
6619 /*
6620 *
6621 *
6622 * 3 2 1
6623 * 10987654321098765432109876543210
6624 * 001000 x1110000101
6625 * rt -----
6626 * rs -----
6627 * rd -----
6628 */
6629 std::string NMD::DPSU_H_QBL(uint64 instruction)
6630 {
6631 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6632 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6633 uint64 ac_value = extract_ac_13_12(instruction);
6634
6635 std::string ac = AC(copy(ac_value));
6636 std::string rs = GPR(copy(rs_value));
6637 std::string rt = GPR(copy(rt_value));
6638
6639 return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6640 }
6641
6642
6643 /*
6644 *
6645 *
6646 * 3 2 1
6647 * 10987654321098765432109876543210
6648 * 001000 x1110000101
6649 * rt -----
6650 * rs -----
6651 * rd -----
6652 */
6653 std::string NMD::DPSU_H_QBR(uint64 instruction)
6654 {
6655 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6656 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6657 uint64 ac_value = extract_ac_13_12(instruction);
6658
6659 std::string ac = AC(copy(ac_value));
6660 std::string rs = GPR(copy(rs_value));
6661 std::string rt = GPR(copy(rt_value));
6662
6663 return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6664 }
6665
6666
6667 /*
6668 *
6669 *
6670 * 3 2 1
6671 * 10987654321098765432109876543210
6672 * 001000 x1110000101
6673 * rt -----
6674 * rs -----
6675 * rd -----
6676 */
6677 std::string NMD::DPSX_W_PH(uint64 instruction)
6678 {
6679 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6680 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6681 uint64 ac_value = extract_ac_13_12(instruction);
6682
6683 std::string ac = AC(copy(ac_value));
6684 std::string rs = GPR(copy(rs_value));
6685 std::string rt = GPR(copy(rt_value));
6686
6687 return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6688 }
6689
6690
6691 /*
6692 * DROTR -
6693 *
6694 * 3 2 1
6695 * 10987654321098765432109876543210
6696 * 001000 x1110000101
6697 * rt -----
6698 * rs -----
6699 * rd -----
6700 */
6701 std::string NMD::DROTR(uint64 instruction)
6702 {
6703 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6704 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6705 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6706
6707 std::string rt = GPR(copy(rt_value));
6708 std::string rs = GPR(copy(rs_value));
6709 std::string shift = IMMEDIATE(copy(shift_value));
6710
6711 return img::format("DROTR %s, %s, %s", rt, rs, shift);
6712 }
6713
6714
6715 /*
6716 * DROTR[32] -
6717 *
6718 * 3 2 1
6719 * 10987654321098765432109876543210
6720 * 10o000 1100xxx0110
6721 * rt -----
6722 * rs -----
6723 * shift -----
6724 */
6725 std::string NMD::DROTR32(uint64 instruction)
6726 {
6727 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6728 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6729 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6730
6731 std::string rt = GPR(copy(rt_value));
6732 std::string rs = GPR(copy(rs_value));
6733 std::string shift = IMMEDIATE(copy(shift_value));
6734
6735 return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
6736 }
6737
6738
6739 /*
6740 *
6741 *
6742 * 3 2 1
6743 * 10987654321098765432109876543210
6744 * 001000 x1110000101
6745 * rt -----
6746 * rs -----
6747 * rd -----
6748 */
6749 std::string NMD::DROTRV(uint64 instruction)
6750 {
6751 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6752 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6753 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6754
6755 std::string rd = GPR(copy(rd_value));
6756 std::string rs = GPR(copy(rs_value));
6757 std::string rt = GPR(copy(rt_value));
6758
6759 return img::format("DROTRV %s, %s, %s", rd, rs, rt);
6760 }
6761
6762
6763 /*
6764 *
6765 *
6766 * 3 2 1
6767 * 10987654321098765432109876543210
6768 * 001000 x1110000101
6769 * rt -----
6770 * rs -----
6771 * rd -----
6772 */
6773 std::string NMD::DROTX(uint64 instruction)
6774 {
6775 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6776 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6777 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6778 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6779
6780 std::string rt = GPR(copy(rt_value));
6781 std::string rs = GPR(copy(rs_value));
6782 std::string shift = IMMEDIATE(copy(shift_value));
6783 std::string shiftx = IMMEDIATE(copy(shiftx_value));
6784
6785 return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
6786 }
6787
6788
6789 /*
6790 * DSLL -
6791 *
6792 * 3 2 1
6793 * 10987654321098765432109876543210
6794 * 10o000 1100xxx0000
6795 * rt -----
6796 * rs -----
6797 * shift -----
6798 */
6799 std::string NMD::DSLL(uint64 instruction)
6800 {
6801 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6802 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6803 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6804
6805 std::string rt = GPR(copy(rt_value));
6806 std::string rs = GPR(copy(rs_value));
6807 std::string shift = IMMEDIATE(copy(shift_value));
6808
6809 return img::format("DSLL %s, %s, %s", rt, rs, shift);
6810 }
6811
6812
6813 /*
6814 * DSLL[32] -
6815 *
6816 * 3 2 1
6817 * 10987654321098765432109876543210
6818 * 10o000 1100xxx0000
6819 * rt -----
6820 * rs -----
6821 * shift -----
6822 */
6823 std::string NMD::DSLL32(uint64 instruction)
6824 {
6825 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6826 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6827 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6828
6829 std::string rt = GPR(copy(rt_value));
6830 std::string rs = GPR(copy(rs_value));
6831 std::string shift = IMMEDIATE(copy(shift_value));
6832
6833 return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
6834 }
6835
6836
6837 /*
6838 *
6839 *
6840 * 3 2 1
6841 * 10987654321098765432109876543210
6842 * 001000 x1110000101
6843 * rt -----
6844 * rs -----
6845 * rd -----
6846 */
6847 std::string NMD::DSLLV(uint64 instruction)
6848 {
6849 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6850 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6851 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6852
6853 std::string rd = GPR(copy(rd_value));
6854 std::string rs = GPR(copy(rs_value));
6855 std::string rt = GPR(copy(rt_value));
6856
6857 return img::format("DSLLV %s, %s, %s", rd, rs, rt);
6858 }
6859
6860
6861 /*
6862 * DSRA -
6863 *
6864 * 3 2 1
6865 * 10987654321098765432109876543210
6866 * 10o000 1100xxx0100
6867 * rt -----
6868 * rs -----
6869 * shift -----
6870 */
6871 std::string NMD::DSRA(uint64 instruction)
6872 {
6873 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6874 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6875 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6876
6877 std::string rt = GPR(copy(rt_value));
6878 std::string rs = GPR(copy(rs_value));
6879 std::string shift = IMMEDIATE(copy(shift_value));
6880
6881 return img::format("DSRA %s, %s, %s", rt, rs, shift);
6882 }
6883
6884
6885 /*
6886 * DSRA[32] -
6887 *
6888 * 3 2 1
6889 * 10987654321098765432109876543210
6890 * 10o000 1100xxx0100
6891 * rt -----
6892 * rs -----
6893 * shift -----
6894 */
6895 std::string NMD::DSRA32(uint64 instruction)
6896 {
6897 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6898 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6899 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6900
6901 std::string rt = GPR(copy(rt_value));
6902 std::string rs = GPR(copy(rs_value));
6903 std::string shift = IMMEDIATE(copy(shift_value));
6904
6905 return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
6906 }
6907
6908
6909 /*
6910 *
6911 *
6912 * 3 2 1
6913 * 10987654321098765432109876543210
6914 * 001000 x1110000101
6915 * rt -----
6916 * rs -----
6917 * rd -----
6918 */
6919 std::string NMD::DSRAV(uint64 instruction)
6920 {
6921 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6922 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6923 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6924
6925 std::string rd = GPR(copy(rd_value));
6926 std::string rs = GPR(copy(rs_value));
6927 std::string rt = GPR(copy(rt_value));
6928
6929 return img::format("DSRAV %s, %s, %s", rd, rs, rt);
6930 }
6931
6932
6933 /*
6934 * DSRL -
6935 *
6936 * 3 2 1
6937 * 10987654321098765432109876543210
6938 * 10o000 1100xxx0100
6939 * rt -----
6940 * rs -----
6941 * shift -----
6942 */
6943 std::string NMD::DSRL(uint64 instruction)
6944 {
6945 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6946 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6947 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6948
6949 std::string rt = GPR(copy(rt_value));
6950 std::string rs = GPR(copy(rs_value));
6951 std::string shift = IMMEDIATE(copy(shift_value));
6952
6953 return img::format("DSRL %s, %s, %s", rt, rs, shift);
6954 }
6955
6956
6957 /*
6958 * DSRL[32] -
6959 *
6960 * 3 2 1
6961 * 10987654321098765432109876543210
6962 * 10o000 1100xxx0010
6963 * rt -----
6964 * rs -----
6965 * shift -----
6966 */
6967 std::string NMD::DSRL32(uint64 instruction)
6968 {
6969 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6970 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6971 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6972
6973 std::string rt = GPR(copy(rt_value));
6974 std::string rs = GPR(copy(rs_value));
6975 std::string shift = IMMEDIATE(copy(shift_value));
6976
6977 return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
6978 }
6979
6980
6981 /*
6982 *
6983 *
6984 * 3 2 1
6985 * 10987654321098765432109876543210
6986 * 001000 x1110000101
6987 * rt -----
6988 * rs -----
6989 * rd -----
6990 */
6991 std::string NMD::DSRLV(uint64 instruction)
6992 {
6993 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6994 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6995 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6996
6997 std::string rd = GPR(copy(rd_value));
6998 std::string rs = GPR(copy(rs_value));
6999 std::string rt = GPR(copy(rt_value));
7000
7001 return img::format("DSRLV %s, %s, %s", rd, rs, rt);
7002 }
7003
7004
7005 /*
7006 *
7007 *
7008 * 3 2 1
7009 * 10987654321098765432109876543210
7010 * 001000 x1110000101
7011 * rt -----
7012 * rs -----
7013 * rd -----
7014 */
7015 std::string NMD::DSUB(uint64 instruction)
7016 {
7017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7018 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7019 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7020
7021 std::string rd = GPR(copy(rd_value));
7022 std::string rs = GPR(copy(rs_value));
7023 std::string rt = GPR(copy(rt_value));
7024
7025 return img::format("DSUB %s, %s, %s", rd, rs, rt);
7026 }
7027
7028
7029 /*
7030 *
7031 *
7032 * 3 2 1
7033 * 10987654321098765432109876543210
7034 * 001000 x1110000101
7035 * rt -----
7036 * rs -----
7037 * rd -----
7038 */
7039 std::string NMD::DSUBU(uint64 instruction)
7040 {
7041 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7042 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7043 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7044
7045 std::string rd = GPR(copy(rd_value));
7046 std::string rs = GPR(copy(rs_value));
7047 std::string rt = GPR(copy(rt_value));
7048
7049 return img::format("DSUBU %s, %s, %s", rd, rs, rt);
7050 }
7051
7052
7053 /*
7054 *
7055 *
7056 * 3 2 1
7057 * 10987654321098765432109876543210
7058 * 001000 x1110000101
7059 * rt -----
7060 * rs -----
7061 * rd -----
7062 */
7063 std::string NMD::DVPE(uint64 instruction)
7064 {
7065 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7066
7067 std::string rt = GPR(copy(rt_value));
7068
7069 return img::format("DVPE %s", rt);
7070 }
7071
7072
7073 /*
7074 *
7075 *
7076 * 3 2 1
7077 * 10987654321098765432109876543210
7078 * 001000 x1110000101
7079 * rt -----
7080 * rs -----
7081 * rd -----
7082 */
7083 std::string NMD::DVP(uint64 instruction)
7084 {
7085 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7086
7087 std::string rt = GPR(copy(rt_value));
7088
7089 return img::format("DVP %s", rt);
7090 }
7091
7092
7093 /*
7094 *
7095 *
7096 * 3 2 1
7097 * 10987654321098765432109876543210
7098 * 001000 x1110000101
7099 * rt -----
7100 * rs -----
7101 * rd -----
7102 */
7103 std::string NMD::EHB(uint64 instruction)
7104 {
7105 (void)instruction;
7106
7107 return "EHB ";
7108 }
7109
7110
7111 /*
7112 *
7113 *
7114 * 3 2 1
7115 * 10987654321098765432109876543210
7116 * 001000 x1110000101
7117 * rt -----
7118 * rs -----
7119 * rd -----
7120 */
7121 std::string NMD::EI(uint64 instruction)
7122 {
7123 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7124
7125 std::string rt = GPR(copy(rt_value));
7126
7127 return img::format("EI %s", rt);
7128 }
7129
7130
7131 /*
7132 *
7133 *
7134 * 3 2 1
7135 * 10987654321098765432109876543210
7136 * 001000 x1110000101
7137 * rt -----
7138 * rs -----
7139 * rd -----
7140 */
7141 std::string NMD::EMT(uint64 instruction)
7142 {
7143 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7144
7145 std::string rt = GPR(copy(rt_value));
7146
7147 return img::format("EMT %s", rt);
7148 }
7149
7150
7151 /*
7152 *
7153 *
7154 * 3 2 1
7155 * 10987654321098765432109876543210
7156 * 001000 x1110000101
7157 * rt -----
7158 * rs -----
7159 * rd -----
7160 */
7161 std::string NMD::ERET(uint64 instruction)
7162 {
7163 (void)instruction;
7164
7165 return "ERET ";
7166 }
7167
7168
7169 /*
7170 *
7171 *
7172 * 3 2 1
7173 * 10987654321098765432109876543210
7174 * 001000 x1110000101
7175 * rt -----
7176 * rs -----
7177 * rd -----
7178 */
7179 std::string NMD::ERETNC(uint64 instruction)
7180 {
7181 (void)instruction;
7182
7183 return "ERETNC ";
7184 }
7185
7186
7187 /*
7188 *
7189 *
7190 * 3 2 1
7191 * 10987654321098765432109876543210
7192 * 001000 x1110000101
7193 * rt -----
7194 * rs -----
7195 * rd -----
7196 */
7197 std::string NMD::EVP(uint64 instruction)
7198 {
7199 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7200
7201 std::string rt = GPR(copy(rt_value));
7202
7203 return img::format("EVP %s", rt);
7204 }
7205
7206
7207 /*
7208 *
7209 *
7210 * 3 2 1
7211 * 10987654321098765432109876543210
7212 * 001000 x1110000101
7213 * rt -----
7214 * rs -----
7215 * rd -----
7216 */
7217 std::string NMD::EVPE(uint64 instruction)
7218 {
7219 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7220
7221 std::string rt = GPR(copy(rt_value));
7222
7223 return img::format("EVPE %s", rt);
7224 }
7225
7226
7227 /*
7228 *
7229 *
7230 * 3 2 1
7231 * 10987654321098765432109876543210
7232 * 001000 x1110000101
7233 * rt -----
7234 * rs -----
7235 * rd -----
7236 */
7237 std::string NMD::EXT(uint64 instruction)
7238 {
7239 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7240 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7241 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7242 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7243
7244 std::string rt = GPR(copy(rt_value));
7245 std::string rs = GPR(copy(rs_value));
7246 std::string lsb = IMMEDIATE(copy(lsb_value));
7247 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
7248
7249 return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
7250 }
7251
7252
7253 /*
7254 *
7255 *
7256 * 3 2 1
7257 * 10987654321098765432109876543210
7258 * 001000 x1110000101
7259 * rt -----
7260 * rs -----
7261 * rd -----
7262 */
7263 std::string NMD::EXTD(uint64 instruction)
7264 {
7265 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7266 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7267 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7268 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7269
7270 std::string rd = GPR(copy(rd_value));
7271 std::string rs = GPR(copy(rs_value));
7272 std::string rt = GPR(copy(rt_value));
7273 std::string shift = IMMEDIATE(copy(shift_value));
7274
7275 return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
7276 }
7277
7278
7279 /*
7280 *
7281 *
7282 * 3 2 1
7283 * 10987654321098765432109876543210
7284 * 001000 x1110000101
7285 * rt -----
7286 * rs -----
7287 * rd -----
7288 */
7289 std::string NMD::EXTD32(uint64 instruction)
7290 {
7291 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7292 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7293 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7294 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7295
7296 std::string rd = GPR(copy(rd_value));
7297 std::string rs = GPR(copy(rs_value));
7298 std::string rt = GPR(copy(rt_value));
7299 std::string shift = IMMEDIATE(copy(shift_value));
7300
7301 return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
7302 }
7303
7304
7305 /*
7306 *
7307 *
7308 * 3 2 1
7309 * 10987654321098765432109876543210
7310 * 001000 x1110000101
7311 * rt -----
7312 * rs -----
7313 * rd -----
7314 */
7315 std::string NMD::EXTPDP(uint64 instruction)
7316 {
7317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7318 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7319 uint64 ac_value = extract_ac_13_12(instruction);
7320
7321 std::string rt = GPR(copy(rt_value));
7322 std::string ac = AC(copy(ac_value));
7323 std::string size = IMMEDIATE(copy(size_value));
7324
7325 return img::format("EXTPDP %s, %s, %s", rt, ac, size);
7326 }
7327
7328
7329 /*
7330 *
7331 *
7332 * 3 2 1
7333 * 10987654321098765432109876543210
7334 * 001000 x1110000101
7335 * rt -----
7336 * rs -----
7337 * rd -----
7338 */
7339 std::string NMD::EXTPDPV(uint64 instruction)
7340 {
7341 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7342 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7343 uint64 ac_value = extract_ac_13_12(instruction);
7344
7345 std::string rt = GPR(copy(rt_value));
7346 std::string ac = AC(copy(ac_value));
7347 std::string rs = GPR(copy(rs_value));
7348
7349 return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
7350 }
7351
7352
7353 /*
7354 *
7355 *
7356 * 3 2 1
7357 * 10987654321098765432109876543210
7358 * 001000 x1110000101
7359 * rt -----
7360 * rs -----
7361 * rd -----
7362 */
7363 std::string NMD::EXTP(uint64 instruction)
7364 {
7365 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7366 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7367 uint64 ac_value = extract_ac_13_12(instruction);
7368
7369 std::string rt = GPR(copy(rt_value));
7370 std::string ac = AC(copy(ac_value));
7371 std::string size = IMMEDIATE(copy(size_value));
7372
7373 return img::format("EXTP %s, %s, %s", rt, ac, size);
7374 }
7375
7376
7377 /*
7378 *
7379 *
7380 * 3 2 1
7381 * 10987654321098765432109876543210
7382 * 001000 x1110000101
7383 * rt -----
7384 * rs -----
7385 * rd -----
7386 */
7387 std::string NMD::EXTPV(uint64 instruction)
7388 {
7389 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7390 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7391 uint64 ac_value = extract_ac_13_12(instruction);
7392
7393 std::string rt = GPR(copy(rt_value));
7394 std::string ac = AC(copy(ac_value));
7395 std::string rs = GPR(copy(rs_value));
7396
7397 return img::format("EXTPV %s, %s, %s", rt, ac, rs);
7398 }
7399
7400
7401 /*
7402 *
7403 *
7404 * 3 2 1
7405 * 10987654321098765432109876543210
7406 * 001000 x1110000101
7407 * rt -----
7408 * rs -----
7409 * rd -----
7410 */
7411 std::string NMD::EXTR_RS_W(uint64 instruction)
7412 {
7413 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7414 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7415 uint64 ac_value = extract_ac_13_12(instruction);
7416
7417 std::string rt = GPR(copy(rt_value));
7418 std::string ac = AC(copy(ac_value));
7419 std::string shift = IMMEDIATE(copy(shift_value));
7420
7421 return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
7422 }
7423
7424
7425 /*
7426 *
7427 *
7428 * 3 2 1
7429 * 10987654321098765432109876543210
7430 * 001000 x1110000101
7431 * rt -----
7432 * rs -----
7433 * rd -----
7434 */
7435 std::string NMD::EXTR_R_W(uint64 instruction)
7436 {
7437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7438 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7439 uint64 ac_value = extract_ac_13_12(instruction);
7440
7441 std::string rt = GPR(copy(rt_value));
7442 std::string ac = AC(copy(ac_value));
7443 std::string shift = IMMEDIATE(copy(shift_value));
7444
7445 return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
7446 }
7447
7448
7449 /*
7450 *
7451 *
7452 * 3 2 1
7453 * 10987654321098765432109876543210
7454 * 001000 x1110000101
7455 * rt -----
7456 * rs -----
7457 * rd -----
7458 */
7459 std::string NMD::EXTR_S_H(uint64 instruction)
7460 {
7461 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7462 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7463 uint64 ac_value = extract_ac_13_12(instruction);
7464
7465 std::string rt = GPR(copy(rt_value));
7466 std::string ac = AC(copy(ac_value));
7467 std::string shift = IMMEDIATE(copy(shift_value));
7468
7469 return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
7470 }
7471
7472
7473 /*
7474 *
7475 *
7476 * 3 2 1
7477 * 10987654321098765432109876543210
7478 * 001000 x1110000101
7479 * rt -----
7480 * rs -----
7481 * rd -----
7482 */
7483 std::string NMD::EXTR_W(uint64 instruction)
7484 {
7485 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7486 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7487 uint64 ac_value = extract_ac_13_12(instruction);
7488
7489 std::string rt = GPR(copy(rt_value));
7490 std::string ac = AC(copy(ac_value));
7491 std::string shift = IMMEDIATE(copy(shift_value));
7492
7493 return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
7494 }
7495
7496
7497 /*
7498 *
7499 *
7500 * 3 2 1
7501 * 10987654321098765432109876543210
7502 * 001000 x1110000101
7503 * rt -----
7504 * rs -----
7505 * rd -----
7506 */
7507 std::string NMD::EXTRV_RS_W(uint64 instruction)
7508 {
7509 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7510 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7511 uint64 ac_value = extract_ac_13_12(instruction);
7512
7513 std::string rt = GPR(copy(rt_value));
7514 std::string ac = AC(copy(ac_value));
7515 std::string rs = GPR(copy(rs_value));
7516
7517 return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7518 }
7519
7520
7521 /*
7522 *
7523 *
7524 * 3 2 1
7525 * 10987654321098765432109876543210
7526 * 001000 x1110000101
7527 * rt -----
7528 * rs -----
7529 * rd -----
7530 */
7531 std::string NMD::EXTRV_R_W(uint64 instruction)
7532 {
7533 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7534 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7535 uint64 ac_value = extract_ac_13_12(instruction);
7536
7537 std::string rt = GPR(copy(rt_value));
7538 std::string ac = AC(copy(ac_value));
7539 std::string rs = GPR(copy(rs_value));
7540
7541 return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7542 }
7543
7544
7545 /*
7546 *
7547 *
7548 * 3 2 1
7549 * 10987654321098765432109876543210
7550 * 001000 x1110000101
7551 * rt -----
7552 * rs -----
7553 * rd -----
7554 */
7555 std::string NMD::EXTRV_S_H(uint64 instruction)
7556 {
7557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7559 uint64 ac_value = extract_ac_13_12(instruction);
7560
7561 std::string rt = GPR(copy(rt_value));
7562 std::string ac = AC(copy(ac_value));
7563 std::string rs = GPR(copy(rs_value));
7564
7565 return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7566 }
7567
7568
7569 /*
7570 *
7571 *
7572 * 3 2 1
7573 * 10987654321098765432109876543210
7574 * 001000 x1110000101
7575 * rt -----
7576 * rs -----
7577 * rd -----
7578 */
7579 std::string NMD::EXTRV_W(uint64 instruction)
7580 {
7581 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7582 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7583 uint64 ac_value = extract_ac_13_12(instruction);
7584
7585 std::string rt = GPR(copy(rt_value));
7586 std::string ac = AC(copy(ac_value));
7587 std::string rs = GPR(copy(rs_value));
7588
7589 return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
7590 }
7591
7592
7593 /*
7594 * EXTW - Extract Word
7595 *
7596 * 3 2 1
7597 * 10987654321098765432109876543210
7598 * 001000 011111
7599 * rt -----
7600 * rs -----
7601 * rd -----
7602 * shift -----
7603 */
7604 std::string NMD::EXTW(uint64 instruction)
7605 {
7606 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7607 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7608 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7609 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7610
7611 std::string rd = GPR(copy(rd_value));
7612 std::string rs = GPR(copy(rs_value));
7613 std::string rt = GPR(copy(rt_value));
7614 std::string shift = IMMEDIATE(copy(shift_value));
7615
7616 return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
7617 }
7618
7619
7620 /*
7621 *
7622 *
7623 * 3 2 1
7624 * 10987654321098765432109876543210
7625 * 001000 x1110000101
7626 * rt -----
7627 * rs -----
7628 * rd -----
7629 */
7630 std::string NMD::FLOOR_L_D(uint64 instruction)
7631 {
7632 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7633 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7634
7635 std::string ft = FPR(copy(ft_value));
7636 std::string fs = FPR(copy(fs_value));
7637
7638 return img::format("FLOOR.L.D %s, %s", ft, fs);
7639 }
7640
7641
7642 /*
7643 *
7644 *
7645 * 3 2 1
7646 * 10987654321098765432109876543210
7647 * 001000 x1110000101
7648 * rt -----
7649 * rs -----
7650 * rd -----
7651 */
7652 std::string NMD::FLOOR_L_S(uint64 instruction)
7653 {
7654 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7655 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7656
7657 std::string ft = FPR(copy(ft_value));
7658 std::string fs = FPR(copy(fs_value));
7659
7660 return img::format("FLOOR.L.S %s, %s", ft, fs);
7661 }
7662
7663
7664 /*
7665 *
7666 *
7667 * 3 2 1
7668 * 10987654321098765432109876543210
7669 * 001000 x1110000101
7670 * rt -----
7671 * rs -----
7672 * rd -----
7673 */
7674 std::string NMD::FLOOR_W_D(uint64 instruction)
7675 {
7676 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7677 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7678
7679 std::string ft = FPR(copy(ft_value));
7680 std::string fs = FPR(copy(fs_value));
7681
7682 return img::format("FLOOR.W.D %s, %s", ft, fs);
7683 }
7684
7685
7686 /*
7687 *
7688 *
7689 * 3 2 1
7690 * 10987654321098765432109876543210
7691 * 001000 x1110000101
7692 * rt -----
7693 * rs -----
7694 * rd -----
7695 */
7696 std::string NMD::FLOOR_W_S(uint64 instruction)
7697 {
7698 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7699 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7700
7701 std::string ft = FPR(copy(ft_value));
7702 std::string fs = FPR(copy(fs_value));
7703
7704 return img::format("FLOOR.W.S %s, %s", ft, fs);
7705 }
7706
7707
7708 /*
7709 *
7710 *
7711 * 3 2 1
7712 * 10987654321098765432109876543210
7713 * 001000 x1110000101
7714 * rt -----
7715 * rs -----
7716 * rd -----
7717 */
7718 std::string NMD::FORK(uint64 instruction)
7719 {
7720 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7721 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7722 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7723
7724 std::string rd = GPR(copy(rd_value));
7725 std::string rs = GPR(copy(rs_value));
7726 std::string rt = GPR(copy(rt_value));
7727
7728 return img::format("FORK %s, %s, %s", rd, rs, rt);
7729 }
7730
7731
7732 /*
7733 *
7734 *
7735 * 3 2 1
7736 * 10987654321098765432109876543210
7737 * 001000 x1110000101
7738 * rt -----
7739 * rs -----
7740 * rd -----
7741 */
7742 std::string NMD::HYPCALL(uint64 instruction)
7743 {
7744 uint64 code_value = extract_code_17_to_0(instruction);
7745
7746 std::string code = IMMEDIATE(copy(code_value));
7747
7748 return img::format("HYPCALL %s", code);
7749 }
7750
7751
7752 /*
7753 *
7754 *
7755 * 3 2 1
7756 * 10987654321098765432109876543210
7757 * 001000 x1110000101
7758 * rt -----
7759 * rs -----
7760 * rd -----
7761 */
7762 std::string NMD::HYPCALL_16_(uint64 instruction)
7763 {
7764 uint64 code_value = extract_code_1_0(instruction);
7765
7766 std::string code = IMMEDIATE(copy(code_value));
7767
7768 return img::format("HYPCALL %s", code);
7769 }
7770
7771
7772 /*
7773 *
7774 *
7775 * 3 2 1
7776 * 10987654321098765432109876543210
7777 * 001000 x1110000101
7778 * rt -----
7779 * rs -----
7780 * rd -----
7781 */
7782 std::string NMD::INS(uint64 instruction)
7783 {
7784 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7785 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7786 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7787 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7788
7789 std::string rt = GPR(copy(rt_value));
7790 std::string rs = GPR(copy(rs_value));
7791 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
7792 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
7793 /* !!!!!!!!!! - no conversion function */
7794
7795 return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
7796 /* hand edited */
7797 }
7798
7799
7800 /*
7801 *
7802 *
7803 * 3 2 1
7804 * 10987654321098765432109876543210
7805 * 001000 x1110000101
7806 * rt -----
7807 * rs -----
7808 * rd -----
7809 */
7810 std::string NMD::INSV(uint64 instruction)
7811 {
7812 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7813 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7814
7815 std::string rt = GPR(copy(rt_value));
7816 std::string rs = GPR(copy(rs_value));
7817
7818 return img::format("INSV %s, %s", rt, rs);
7819 }
7820
7821
7822 /*
7823 *
7824 *
7825 * 3 2 1
7826 * 10987654321098765432109876543210
7827 * 001000 x1110000101
7828 * rt -----
7829 * rs -----
7830 * rd -----
7831 */
7832 std::string NMD::IRET(uint64 instruction)
7833 {
7834 (void)instruction;
7835
7836 return "IRET ";
7837 }
7838
7839
7840 /*
7841 *
7842 *
7843 * 3 2 1
7844 * 10987654321098765432109876543210
7845 * 001000 x1110000101
7846 * rt -----
7847 * rs -----
7848 * rd -----
7849 */
7850 std::string NMD::JALRC_16_(uint64 instruction)
7851 {
7852 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7853
7854 std::string rt = GPR(copy(rt_value));
7855
7856 return img::format("JALRC $%d, %s", 31, rt);
7857 }
7858
7859
7860 /*
7861 *
7862 *
7863 * 3 2 1
7864 * 10987654321098765432109876543210
7865 * 001000 x1110000101
7866 * rt -----
7867 * rs -----
7868 * rd -----
7869 */
7870 std::string NMD::JALRC_32_(uint64 instruction)
7871 {
7872 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7873 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7874
7875 std::string rt = GPR(copy(rt_value));
7876 std::string rs = GPR(copy(rs_value));
7877
7878 return img::format("JALRC %s, %s", rt, rs);
7879 }
7880
7881
7882 /*
7883 *
7884 *
7885 * 3 2 1
7886 * 10987654321098765432109876543210
7887 * 001000 x1110000101
7888 * rt -----
7889 * rs -----
7890 * rd -----
7891 */
7892 std::string NMD::JALRC_HB(uint64 instruction)
7893 {
7894 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7895 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7896
7897 std::string rt = GPR(copy(rt_value));
7898 std::string rs = GPR(copy(rs_value));
7899
7900 return img::format("JALRC.HB %s, %s", rt, rs);
7901 }
7902
7903
7904 /*
7905 *
7906 *
7907 * 3 2 1
7908 * 10987654321098765432109876543210
7909 * 001000 x1110000101
7910 * rt -----
7911 * rs -----
7912 * rd -----
7913 */
7914 std::string NMD::JRC(uint64 instruction)
7915 {
7916 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7917
7918 std::string rt = GPR(copy(rt_value));
7919
7920 return img::format("JRC %s", rt);
7921 }
7922
7923
7924 /*
7925 *
7926 *
7927 * 3 2 1
7928 * 10987654321098765432109876543210
7929 * 001000 x1110000101
7930 * rt -----
7931 * rs -----
7932 * rd -----
7933 */
7934 std::string NMD::LB_16_(uint64 instruction)
7935 {
7936 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7937 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7938 uint64 u_value = extract_u_1_0(instruction);
7939
7940 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
7941 std::string u = IMMEDIATE(copy(u_value));
7942 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
7943
7944 return img::format("LB %s, %s(%s)", rt3, u, rs3);
7945 }
7946
7947
7948 /*
7949 *
7950 *
7951 * 3 2 1
7952 * 10987654321098765432109876543210
7953 * 001000 x1110000101
7954 * rt -----
7955 * rs -----
7956 * rd -----
7957 */
7958 std::string NMD::LB_GP_(uint64 instruction)
7959 {
7960 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7961 uint64 u_value = extract_u_17_to_0(instruction);
7962
7963 std::string rt = GPR(copy(rt_value));
7964 std::string u = IMMEDIATE(copy(u_value));
7965
7966 return img::format("LB %s, %s($%d)", rt, u, 28);
7967 }
7968
7969
7970 /*
7971 *
7972 *
7973 * 3 2 1
7974 * 10987654321098765432109876543210
7975 * 001000 x1110000101
7976 * rt -----
7977 * rs -----
7978 * rd -----
7979 */
7980 std::string NMD::LB_S9_(uint64 instruction)
7981 {
7982 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7983 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7984 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7985
7986 std::string rt = GPR(copy(rt_value));
7987 std::string s = IMMEDIATE(copy(s_value));
7988 std::string rs = GPR(copy(rs_value));
7989
7990 return img::format("LB %s, %s(%s)", rt, s, rs);
7991 }
7992
7993
7994 /*
7995 *
7996 *
7997 * 3 2 1
7998 * 10987654321098765432109876543210
7999 * 001000 x1110000101
8000 * rt -----
8001 * rs -----
8002 * rd -----
8003 */
8004 std::string NMD::LB_U12_(uint64 instruction)
8005 {
8006 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8007 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8008 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8009
8010 std::string rt = GPR(copy(rt_value));
8011 std::string u = IMMEDIATE(copy(u_value));
8012 std::string rs = GPR(copy(rs_value));
8013
8014 return img::format("LB %s, %s(%s)", rt, u, rs);
8015 }
8016
8017
8018 /*
8019 *
8020 *
8021 * 3 2 1
8022 * 10987654321098765432109876543210
8023 * 001000 x1110000101
8024 * rt -----
8025 * rs -----
8026 * rd -----
8027 */
8028 std::string NMD::LBE(uint64 instruction)
8029 {
8030 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8031 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8032 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8033
8034 std::string rt = GPR(copy(rt_value));
8035 std::string s = IMMEDIATE(copy(s_value));
8036 std::string rs = GPR(copy(rs_value));
8037
8038 return img::format("LBE %s, %s(%s)", rt, s, rs);
8039 }
8040
8041
8042 /*
8043 *
8044 *
8045 * 3 2 1
8046 * 10987654321098765432109876543210
8047 * 001000 x1110000101
8048 * rt -----
8049 * rs -----
8050 * rd -----
8051 */
8052 std::string NMD::LBU_16_(uint64 instruction)
8053 {
8054 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8055 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8056 uint64 u_value = extract_u_1_0(instruction);
8057
8058 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8059 std::string u = IMMEDIATE(copy(u_value));
8060 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8061
8062 return img::format("LBU %s, %s(%s)", rt3, u, rs3);
8063 }
8064
8065
8066 /*
8067 *
8068 *
8069 * 3 2 1
8070 * 10987654321098765432109876543210
8071 * 001000 x1110000101
8072 * rt -----
8073 * rs -----
8074 * rd -----
8075 */
8076 std::string NMD::LBU_GP_(uint64 instruction)
8077 {
8078 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8079 uint64 u_value = extract_u_17_to_0(instruction);
8080
8081 std::string rt = GPR(copy(rt_value));
8082 std::string u = IMMEDIATE(copy(u_value));
8083
8084 return img::format("LBU %s, %s($%d)", rt, u, 28);
8085 }
8086
8087
8088 /*
8089 *
8090 *
8091 * 3 2 1
8092 * 10987654321098765432109876543210
8093 * 001000 x1110000101
8094 * rt -----
8095 * rs -----
8096 * rd -----
8097 */
8098 std::string NMD::LBU_S9_(uint64 instruction)
8099 {
8100 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8102 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8103
8104 std::string rt = GPR(copy(rt_value));
8105 std::string s = IMMEDIATE(copy(s_value));
8106 std::string rs = GPR(copy(rs_value));
8107
8108 return img::format("LBU %s, %s(%s)", rt, s, rs);
8109 }
8110
8111
8112 /*
8113 *
8114 *
8115 * 3 2 1
8116 * 10987654321098765432109876543210
8117 * 001000 x1110000101
8118 * rt -----
8119 * rs -----
8120 * rd -----
8121 */
8122 std::string NMD::LBU_U12_(uint64 instruction)
8123 {
8124 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8125 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8126 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8127
8128 std::string rt = GPR(copy(rt_value));
8129 std::string u = IMMEDIATE(copy(u_value));
8130 std::string rs = GPR(copy(rs_value));
8131
8132 return img::format("LBU %s, %s(%s)", rt, u, rs);
8133 }
8134
8135
8136 /*
8137 *
8138 *
8139 * 3 2 1
8140 * 10987654321098765432109876543210
8141 * 001000 x1110000101
8142 * rt -----
8143 * rs -----
8144 * rd -----
8145 */
8146 std::string NMD::LBUE(uint64 instruction)
8147 {
8148 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8149 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8150 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8151
8152 std::string rt = GPR(copy(rt_value));
8153 std::string s = IMMEDIATE(copy(s_value));
8154 std::string rs = GPR(copy(rs_value));
8155
8156 return img::format("LBUE %s, %s(%s)", rt, s, rs);
8157 }
8158
8159
8160 /*
8161 *
8162 *
8163 * 3 2 1
8164 * 10987654321098765432109876543210
8165 * 001000 x1110000101
8166 * rt -----
8167 * rs -----
8168 * rd -----
8169 */
8170 std::string NMD::LBUX(uint64 instruction)
8171 {
8172 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8173 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8174 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8175
8176 std::string rd = GPR(copy(rd_value));
8177 std::string rs = GPR(copy(rs_value));
8178 std::string rt = GPR(copy(rt_value));
8179
8180 return img::format("LBUX %s, %s(%s)", rd, rs, rt);
8181 }
8182
8183
8184 /*
8185 *
8186 *
8187 * 3 2 1
8188 * 10987654321098765432109876543210
8189 * 001000 x1110000101
8190 * rt -----
8191 * rs -----
8192 * rd -----
8193 */
8194 std::string NMD::LBX(uint64 instruction)
8195 {
8196 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8197 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8198 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8199
8200 std::string rd = GPR(copy(rd_value));
8201 std::string rs = GPR(copy(rs_value));
8202 std::string rt = GPR(copy(rt_value));
8203
8204 return img::format("LBX %s, %s(%s)", rd, rs, rt);
8205 }
8206
8207
8208 /*
8209 *
8210 *
8211 * 3 2 1
8212 * 10987654321098765432109876543210
8213 * 001000 x1110000101
8214 * rt -----
8215 * rs -----
8216 * rd -----
8217 */
8218 std::string NMD::LD_GP_(uint64 instruction)
8219 {
8220 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8221 uint64 u_value = extract_u_20_to_3__s3(instruction);
8222
8223 std::string rt = GPR(copy(rt_value));
8224 std::string u = IMMEDIATE(copy(u_value));
8225
8226 return img::format("LD %s, %s($%d)", rt, u, 28);
8227 }
8228
8229
8230 /*
8231 *
8232 *
8233 * 3 2 1
8234 * 10987654321098765432109876543210
8235 * 001000 x1110000101
8236 * rt -----
8237 * rs -----
8238 * rd -----
8239 */
8240 std::string NMD::LD_S9_(uint64 instruction)
8241 {
8242 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8243 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8244 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8245
8246 std::string rt = GPR(copy(rt_value));
8247 std::string s = IMMEDIATE(copy(s_value));
8248 std::string rs = GPR(copy(rs_value));
8249
8250 return img::format("LD %s, %s(%s)", rt, s, rs);
8251 }
8252
8253
8254 /*
8255 *
8256 *
8257 * 3 2 1
8258 * 10987654321098765432109876543210
8259 * 001000 x1110000101
8260 * rt -----
8261 * rs -----
8262 * rd -----
8263 */
8264 std::string NMD::LD_U12_(uint64 instruction)
8265 {
8266 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8267 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8268 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8269
8270 std::string rt = GPR(copy(rt_value));
8271 std::string u = IMMEDIATE(copy(u_value));
8272 std::string rs = GPR(copy(rs_value));
8273
8274 return img::format("LD %s, %s(%s)", rt, u, rs);
8275 }
8276
8277
8278 /*
8279 *
8280 *
8281 * 3 2 1
8282 * 10987654321098765432109876543210
8283 * 001000 x1110000101
8284 * rt -----
8285 * rs -----
8286 * rd -----
8287 */
8288 std::string NMD::LDC1_GP_(uint64 instruction)
8289 {
8290 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8291 uint64 u_value = extract_u_17_to_2__s2(instruction);
8292
8293 std::string ft = FPR(copy(ft_value));
8294 std::string u = IMMEDIATE(copy(u_value));
8295
8296 return img::format("LDC1 %s, %s($%d)", ft, u, 28);
8297 }
8298
8299
8300 /*
8301 *
8302 *
8303 * 3 2 1
8304 * 10987654321098765432109876543210
8305 * 001000 x1110000101
8306 * rt -----
8307 * rs -----
8308 * rd -----
8309 */
8310 std::string NMD::LDC1_S9_(uint64 instruction)
8311 {
8312 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8313 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8314 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8315
8316 std::string ft = FPR(copy(ft_value));
8317 std::string s = IMMEDIATE(copy(s_value));
8318 std::string rs = GPR(copy(rs_value));
8319
8320 return img::format("LDC1 %s, %s(%s)", ft, s, rs);
8321 }
8322
8323
8324 /*
8325 *
8326 *
8327 * 3 2 1
8328 * 10987654321098765432109876543210
8329 * 001000 x1110000101
8330 * rt -----
8331 * rs -----
8332 * rd -----
8333 */
8334 std::string NMD::LDC1_U12_(uint64 instruction)
8335 {
8336 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8337 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8338 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8339
8340 std::string ft = FPR(copy(ft_value));
8341 std::string u = IMMEDIATE(copy(u_value));
8342 std::string rs = GPR(copy(rs_value));
8343
8344 return img::format("LDC1 %s, %s(%s)", ft, u, rs);
8345 }
8346
8347
8348 /*
8349 *
8350 *
8351 * 3 2 1
8352 * 10987654321098765432109876543210
8353 * 001000 x1110000101
8354 * rt -----
8355 * rs -----
8356 * rd -----
8357 */
8358 std::string NMD::LDC1XS(uint64 instruction)
8359 {
8360 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8361 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8362 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8363
8364 std::string ft = FPR(copy(ft_value));
8365 std::string rs = GPR(copy(rs_value));
8366 std::string rt = GPR(copy(rt_value));
8367
8368 return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
8369 }
8370
8371
8372 /*
8373 *
8374 *
8375 * 3 2 1
8376 * 10987654321098765432109876543210
8377 * 001000 x1110000101
8378 * rt -----
8379 * rs -----
8380 * rd -----
8381 */
8382 std::string NMD::LDC1X(uint64 instruction)
8383 {
8384 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8385 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8386 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8387
8388 std::string ft = FPR(copy(ft_value));
8389 std::string rs = GPR(copy(rs_value));
8390 std::string rt = GPR(copy(rt_value));
8391
8392 return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
8393 }
8394
8395
8396 /*
8397 *
8398 *
8399 * 3 2 1
8400 * 10987654321098765432109876543210
8401 * 001000 x1110000101
8402 * rt -----
8403 * rs -----
8404 * rd -----
8405 */
8406 std::string NMD::LDC2(uint64 instruction)
8407 {
8408 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8409 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8410 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8411
8412 std::string ct = CPR(copy(ct_value));
8413 std::string s = IMMEDIATE(copy(s_value));
8414 std::string rs = GPR(copy(rs_value));
8415
8416 return img::format("LDC2 %s, %s(%s)", ct, s, rs);
8417 }
8418
8419
8420 /*
8421 *
8422 *
8423 * 3 2 1
8424 * 10987654321098765432109876543210
8425 * 001000 x1110000101
8426 * rt -----
8427 * rs -----
8428 * rd -----
8429 */
8430 std::string NMD::LDM(uint64 instruction)
8431 {
8432 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8433 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8434 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8435 uint64 count3_value = extract_count3_14_13_12(instruction);
8436
8437 std::string rt = GPR(copy(rt_value));
8438 std::string s = IMMEDIATE(copy(s_value));
8439 std::string rs = GPR(copy(rs_value));
8440 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
8441
8442 return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
8443 }
8444
8445
8446 /*
8447 *
8448 *
8449 * 3 2 1
8450 * 10987654321098765432109876543210
8451 * 001000 x1110000101
8452 * rt -----
8453 * rs -----
8454 * rd -----
8455 */
8456 std::string NMD::LDPC_48_(uint64 instruction)
8457 {
8458 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8459 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8460
8461 std::string rt = GPR(copy(rt_value));
8462 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
8463
8464 return img::format("LDPC %s, %s", rt, s);
8465 }
8466
8467
8468 /*
8469 *
8470 *
8471 * 3 2 1
8472 * 10987654321098765432109876543210
8473 * 001000 x1110000101
8474 * rt -----
8475 * rs -----
8476 * rd -----
8477 */
8478 std::string NMD::LDX(uint64 instruction)
8479 {
8480 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8481 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8482 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8483
8484 std::string rd = GPR(copy(rd_value));
8485 std::string rs = GPR(copy(rs_value));
8486 std::string rt = GPR(copy(rt_value));
8487
8488 return img::format("LDX %s, %s(%s)", rd, rs, rt);
8489 }
8490
8491
8492 /*
8493 *
8494 *
8495 * 3 2 1
8496 * 10987654321098765432109876543210
8497 * 001000 x1110000101
8498 * rt -----
8499 * rs -----
8500 * rd -----
8501 */
8502 std::string NMD::LDXS(uint64 instruction)
8503 {
8504 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8505 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8506 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8507
8508 std::string rd = GPR(copy(rd_value));
8509 std::string rs = GPR(copy(rs_value));
8510 std::string rt = GPR(copy(rt_value));
8511
8512 return img::format("LDXS %s, %s(%s)", rd, rs, rt);
8513 }
8514
8515
8516 /*
8517 *
8518 *
8519 * 3 2 1
8520 * 10987654321098765432109876543210
8521 * 001000 x1110000101
8522 * rt -----
8523 * rs -----
8524 * rd -----
8525 */
8526 std::string NMD::LH_16_(uint64 instruction)
8527 {
8528 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8529 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8530 uint64 u_value = extract_u_2_1__s1(instruction);
8531
8532 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8533 std::string u = IMMEDIATE(copy(u_value));
8534 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8535
8536 return img::format("LH %s, %s(%s)", rt3, u, rs3);
8537 }
8538
8539
8540 /*
8541 *
8542 *
8543 * 3 2 1
8544 * 10987654321098765432109876543210
8545 * 001000 x1110000101
8546 * rt -----
8547 * rs -----
8548 * rd -----
8549 */
8550 std::string NMD::LH_GP_(uint64 instruction)
8551 {
8552 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8553 uint64 u_value = extract_u_17_to_1__s1(instruction);
8554
8555 std::string rt = GPR(copy(rt_value));
8556 std::string u = IMMEDIATE(copy(u_value));
8557
8558 return img::format("LH %s, %s($%d)", rt, u, 28);
8559 }
8560
8561
8562 /*
8563 *
8564 *
8565 * 3 2 1
8566 * 10987654321098765432109876543210
8567 * 001000 x1110000101
8568 * rt -----
8569 * rs -----
8570 * rd -----
8571 */
8572 std::string NMD::LH_S9_(uint64 instruction)
8573 {
8574 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8575 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8576 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8577
8578 std::string rt = GPR(copy(rt_value));
8579 std::string s = IMMEDIATE(copy(s_value));
8580 std::string rs = GPR(copy(rs_value));
8581
8582 return img::format("LH %s, %s(%s)", rt, s, rs);
8583 }
8584
8585
8586 /*
8587 *
8588 *
8589 * 3 2 1
8590 * 10987654321098765432109876543210
8591 * 001000 x1110000101
8592 * rt -----
8593 * rs -----
8594 * rd -----
8595 */
8596 std::string NMD::LH_U12_(uint64 instruction)
8597 {
8598 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8600 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8601
8602 std::string rt = GPR(copy(rt_value));
8603 std::string u = IMMEDIATE(copy(u_value));
8604 std::string rs = GPR(copy(rs_value));
8605
8606 return img::format("LH %s, %s(%s)", rt, u, rs);
8607 }
8608
8609
8610 /*
8611 *
8612 *
8613 * 3 2 1
8614 * 10987654321098765432109876543210
8615 * 001000 x1110000101
8616 * rt -----
8617 * rs -----
8618 * rd -----
8619 */
8620 std::string NMD::LHE(uint64 instruction)
8621 {
8622 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8624 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8625
8626 std::string rt = GPR(copy(rt_value));
8627 std::string s = IMMEDIATE(copy(s_value));
8628 std::string rs = GPR(copy(rs_value));
8629
8630 return img::format("LHE %s, %s(%s)", rt, s, rs);
8631 }
8632
8633
8634 /*
8635 *
8636 *
8637 * 3 2 1
8638 * 10987654321098765432109876543210
8639 * 001000 x1110000101
8640 * rt -----
8641 * rs -----
8642 * rd -----
8643 */
8644 std::string NMD::LHU_16_(uint64 instruction)
8645 {
8646 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8647 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8648 uint64 u_value = extract_u_2_1__s1(instruction);
8649
8650 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8651 std::string u = IMMEDIATE(copy(u_value));
8652 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8653
8654 return img::format("LHU %s, %s(%s)", rt3, u, rs3);
8655 }
8656
8657
8658 /*
8659 *
8660 *
8661 * 3 2 1
8662 * 10987654321098765432109876543210
8663 * 001000 x1110000101
8664 * rt -----
8665 * rs -----
8666 * rd -----
8667 */
8668 std::string NMD::LHU_GP_(uint64 instruction)
8669 {
8670 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8671 uint64 u_value = extract_u_17_to_1__s1(instruction);
8672
8673 std::string rt = GPR(copy(rt_value));
8674 std::string u = IMMEDIATE(copy(u_value));
8675
8676 return img::format("LHU %s, %s($%d)", rt, u, 28);
8677 }
8678
8679
8680 /*
8681 *
8682 *
8683 * 3 2 1
8684 * 10987654321098765432109876543210
8685 * 001000 x1110000101
8686 * rt -----
8687 * rs -----
8688 * rd -----
8689 */
8690 std::string NMD::LHU_S9_(uint64 instruction)
8691 {
8692 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8693 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8694 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8695
8696 std::string rt = GPR(copy(rt_value));
8697 std::string s = IMMEDIATE(copy(s_value));
8698 std::string rs = GPR(copy(rs_value));
8699
8700 return img::format("LHU %s, %s(%s)", rt, s, rs);
8701 }
8702
8703
8704 /*
8705 *
8706 *
8707 * 3 2 1
8708 * 10987654321098765432109876543210
8709 * 001000 x1110000101
8710 * rt -----
8711 * rs -----
8712 * rd -----
8713 */
8714 std::string NMD::LHU_U12_(uint64 instruction)
8715 {
8716 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8717 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8718 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8719
8720 std::string rt = GPR(copy(rt_value));
8721 std::string u = IMMEDIATE(copy(u_value));
8722 std::string rs = GPR(copy(rs_value));
8723
8724 return img::format("LHU %s, %s(%s)", rt, u, rs);
8725 }
8726
8727
8728 /*
8729 *
8730 *
8731 * 3 2 1
8732 * 10987654321098765432109876543210
8733 * 001000 x1110000101
8734 * rt -----
8735 * rs -----
8736 * rd -----
8737 */
8738 std::string NMD::LHUE(uint64 instruction)
8739 {
8740 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8741 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8742 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8743
8744 std::string rt = GPR(copy(rt_value));
8745 std::string s = IMMEDIATE(copy(s_value));
8746 std::string rs = GPR(copy(rs_value));
8747
8748 return img::format("LHUE %s, %s(%s)", rt, s, rs);
8749 }
8750
8751
8752 /*
8753 *
8754 *
8755 * 3 2 1
8756 * 10987654321098765432109876543210
8757 * 001000 x1110000101
8758 * rt -----
8759 * rs -----
8760 * rd -----
8761 */
8762 std::string NMD::LHUX(uint64 instruction)
8763 {
8764 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8765 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8766 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8767
8768 std::string rd = GPR(copy(rd_value));
8769 std::string rs = GPR(copy(rs_value));
8770 std::string rt = GPR(copy(rt_value));
8771
8772 return img::format("LHUX %s, %s(%s)", rd, rs, rt);
8773 }
8774
8775
8776 /*
8777 *
8778 *
8779 * 3 2 1
8780 * 10987654321098765432109876543210
8781 * 001000 x1110000101
8782 * rt -----
8783 * rs -----
8784 * rd -----
8785 */
8786 std::string NMD::LHUXS(uint64 instruction)
8787 {
8788 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8789 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8790 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8791
8792 std::string rd = GPR(copy(rd_value));
8793 std::string rs = GPR(copy(rs_value));
8794 std::string rt = GPR(copy(rt_value));
8795
8796 return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
8797 }
8798
8799
8800 /*
8801 *
8802 *
8803 * 3 2 1
8804 * 10987654321098765432109876543210
8805 * 001000 x1110000101
8806 * rt -----
8807 * rs -----
8808 * rd -----
8809 */
8810 std::string NMD::LHXS(uint64 instruction)
8811 {
8812 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8813 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8814 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8815
8816 std::string rd = GPR(copy(rd_value));
8817 std::string rs = GPR(copy(rs_value));
8818 std::string rt = GPR(copy(rt_value));
8819
8820 return img::format("LHXS %s, %s(%s)", rd, rs, rt);
8821 }
8822
8823
8824 /*
8825 *
8826 *
8827 * 3 2 1
8828 * 10987654321098765432109876543210
8829 * 001000 x1110000101
8830 * rt -----
8831 * rs -----
8832 * rd -----
8833 */
8834 std::string NMD::LHX(uint64 instruction)
8835 {
8836 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8837 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8838 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8839
8840 std::string rd = GPR(copy(rd_value));
8841 std::string rs = GPR(copy(rs_value));
8842 std::string rt = GPR(copy(rt_value));
8843
8844 return img::format("LHX %s, %s(%s)", rd, rs, rt);
8845 }
8846
8847
8848 /*
8849 *
8850 *
8851 * 3 2 1
8852 * 10987654321098765432109876543210
8853 * 001000 x1110000101
8854 * rt -----
8855 * rs -----
8856 * rd -----
8857 */
8858 std::string NMD::LI_16_(uint64 instruction)
8859 {
8860 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8861 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8862
8863 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8864 std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
8865
8866 return img::format("LI %s, %s", rt3, eu);
8867 }
8868
8869
8870 /*
8871 *
8872 *
8873 * 3 2 1
8874 * 10987654321098765432109876543210
8875 * 001000 x1110000101
8876 * rt -----
8877 * rs -----
8878 * rd -----
8879 */
8880 std::string NMD::LI_48_(uint64 instruction)
8881 {
8882 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8883 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8884
8885 std::string rt = GPR(copy(rt_value));
8886 std::string s = IMMEDIATE(copy(s_value));
8887
8888 return img::format("LI %s, %s", rt, s);
8889 }
8890
8891
8892 /*
8893 *
8894 *
8895 * 3 2 1
8896 * 10987654321098765432109876543210
8897 * 001000 x1110000101
8898 * rt -----
8899 * rs -----
8900 * rd -----
8901 */
8902 std::string NMD::LL(uint64 instruction)
8903 {
8904 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8905 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8906 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8907
8908 std::string rt = GPR(copy(rt_value));
8909 std::string s = IMMEDIATE(copy(s_value));
8910 std::string rs = GPR(copy(rs_value));
8911
8912 return img::format("LL %s, %s(%s)", rt, s, rs);
8913 }
8914
8915
8916 /*
8917 *
8918 *
8919 * 3 2 1
8920 * 10987654321098765432109876543210
8921 * 001000 x1110000101
8922 * rt -----
8923 * rs -----
8924 * rd -----
8925 */
8926 std::string NMD::LLD(uint64 instruction)
8927 {
8928 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8929 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8930 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
8931
8932 std::string rt = GPR(copy(rt_value));
8933 std::string s = IMMEDIATE(copy(s_value));
8934 std::string rs = GPR(copy(rs_value));
8935
8936 return img::format("LLD %s, %s(%s)", rt, s, rs);
8937 }
8938
8939
8940 /*
8941 *
8942 *
8943 * 3 2 1
8944 * 10987654321098765432109876543210
8945 * 001000 x1110000101
8946 * rt -----
8947 * rs -----
8948 * rd -----
8949 */
8950 std::string NMD::LLDP(uint64 instruction)
8951 {
8952 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8953 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8954 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8955
8956 std::string rt = GPR(copy(rt_value));
8957 std::string ru = GPR(copy(ru_value));
8958 std::string rs = GPR(copy(rs_value));
8959
8960 return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
8961 }
8962
8963
8964 /*
8965 *
8966 *
8967 * 3 2 1
8968 * 10987654321098765432109876543210
8969 * 001000 x1110000101
8970 * rt -----
8971 * rs -----
8972 * rd -----
8973 */
8974 std::string NMD::LLE(uint64 instruction)
8975 {
8976 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8977 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8978 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8979
8980 std::string rt = GPR(copy(rt_value));
8981 std::string s = IMMEDIATE(copy(s_value));
8982 std::string rs = GPR(copy(rs_value));
8983
8984 return img::format("LLE %s, %s(%s)", rt, s, rs);
8985 }
8986
8987
8988 /*
8989 *
8990 *
8991 * 3 2 1
8992 * 10987654321098765432109876543210
8993 * 001000 x1110000101
8994 * rt -----
8995 * rs -----
8996 * rd -----
8997 */
8998 std::string NMD::LLWP(uint64 instruction)
8999 {
9000 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9001 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9002 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9003
9004 std::string rt = GPR(copy(rt_value));
9005 std::string ru = GPR(copy(ru_value));
9006 std::string rs = GPR(copy(rs_value));
9007
9008 return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
9009 }
9010
9011
9012 /*
9013 *
9014 *
9015 * 3 2 1
9016 * 10987654321098765432109876543210
9017 * 001000 x1110000101
9018 * rt -----
9019 * rs -----
9020 * rd -----
9021 */
9022 std::string NMD::LLWPE(uint64 instruction)
9023 {
9024 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9025 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9026 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9027
9028 std::string rt = GPR(copy(rt_value));
9029 std::string ru = GPR(copy(ru_value));
9030 std::string rs = GPR(copy(rs_value));
9031
9032 return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
9033 }
9034
9035
9036 /*
9037 *
9038 *
9039 * 3 2 1
9040 * 10987654321098765432109876543210
9041 * 001000 x1110000101
9042 * rt -----
9043 * rs -----
9044 * rd -----
9045 */
9046 std::string NMD::LSA(uint64 instruction)
9047 {
9048 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9049 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9050 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9051 uint64 u2_value = extract_u2_10_9(instruction);
9052
9053 std::string rd = GPR(copy(rd_value));
9054 std::string rs = GPR(copy(rs_value));
9055 std::string rt = GPR(copy(rt_value));
9056 std::string u2 = IMMEDIATE(copy(u2_value));
9057
9058 return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
9059 }
9060
9061
9062 /*
9063 *
9064 *
9065 * 3 2 1
9066 * 10987654321098765432109876543210
9067 * 001000 x1110000101
9068 * rt -----
9069 * rs -----
9070 * rd -----
9071 */
9072 std::string NMD::LUI(uint64 instruction)
9073 {
9074 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9075 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
9076
9077 std::string rt = GPR(copy(rt_value));
9078 std::string s = IMMEDIATE(copy(s_value));
9079
9080 return img::format("LUI %s, %%hi(%s)", rt, s);
9081 }
9082
9083
9084 /*
9085 *
9086 *
9087 * 3 2 1
9088 * 10987654321098765432109876543210
9089 * 001000 x1110000101
9090 * rt -----
9091 * rs -----
9092 * rd -----
9093 */
9094 std::string NMD::LW_16_(uint64 instruction)
9095 {
9096 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9097 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9098 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
9099
9100 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
9101 std::string u = IMMEDIATE(copy(u_value));
9102 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
9103
9104 return img::format("LW %s, %s(%s)", rt3, u, rs3);
9105 }
9106
9107
9108 /*
9109 *
9110 *
9111 * 3 2 1
9112 * 10987654321098765432109876543210
9113 * 001000 x1110000101
9114 * rt -----
9115 * rs -----
9116 * rd -----
9117 */
9118 std::string NMD::LW_4X4_(uint64 instruction)
9119 {
9120 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
9121 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
9122 uint64 u_value = extract_u_3_8__s2(instruction);
9123
9124 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
9125 std::string u = IMMEDIATE(copy(u_value));
9126 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
9127
9128 return img::format("LW %s, %s(%s)", rt4, u, rs4);
9129 }
9130
9131
9132 /*
9133 *
9134 *
9135 * 3 2 1
9136 * 10987654321098765432109876543210
9137 * 001000 x1110000101
9138 * rt -----
9139 * rs -----
9140 * rd -----
9141 */
9142 std::string NMD::LW_GP_(uint64 instruction)
9143 {
9144 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9145 uint64 u_value = extract_u_20_to_2__s2(instruction);
9146
9147 std::string rt = GPR(copy(rt_value));
9148 std::string u = IMMEDIATE(copy(u_value));
9149
9150 return img::format("LW %s, %s($%d)", rt, u, 28);
9151 }
9152
9153
9154 /*
9155 *
9156 *
9157 * 3 2 1
9158 * 10987654321098765432109876543210
9159 * 001000 x1110000101
9160 * rt -----
9161 * rs -----
9162 * rd -----
9163 */
9164 std::string NMD::LW_GP16_(uint64 instruction)
9165 {
9166 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9167 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
9168
9169 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
9170 std::string u = IMMEDIATE(copy(u_value));
9171
9172 return img::format("LW %s, %s($%d)", rt3, u, 28);
9173 }
9174
9175
9176 /*
9177 *
9178 *
9179 * 3 2 1
9180 * 10987654321098765432109876543210
9181 * 001000 x1110000101
9182 * rt -----
9183 * rs -----
9184 * rd -----
9185 */
9186 std::string NMD::LW_S9_(uint64 instruction)
9187 {
9188 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9190 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9191
9192 std::string rt = GPR(copy(rt_value));
9193 std::string s = IMMEDIATE(copy(s_value));
9194 std::string rs = GPR(copy(rs_value));
9195
9196 return img::format("LW %s, %s(%s)", rt, s, rs);
9197 }
9198
9199
9200 /*
9201 *
9202 *
9203 * 3 2 1
9204 * 10987654321098765432109876543210
9205 * 001000 x1110000101
9206 * rt -----
9207 * rs -----
9208 * rd -----
9209 */
9210 std::string NMD::LW_SP_(uint64 instruction)
9211 {
9212 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
9213 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
9214
9215 std::string rt = GPR(copy(rt_value));
9216 std::string u = IMMEDIATE(copy(u_value));
9217
9218 return img::format("LW %s, %s($%d)", rt, u, 29);
9219 }
9220
9221
9222 /*
9223 *
9224 *
9225 * 3 2 1
9226 * 10987654321098765432109876543210
9227 * 001000 x1110000101
9228 * rt -----
9229 * rs -----
9230 * rd -----
9231 */
9232 std::string NMD::LW_U12_(uint64 instruction)
9233 {
9234 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9235 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9236 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9237
9238 std::string rt = GPR(copy(rt_value));
9239 std::string u = IMMEDIATE(copy(u_value));
9240 std::string rs = GPR(copy(rs_value));
9241
9242 return img::format("LW %s, %s(%s)", rt, u, rs);
9243 }
9244
9245
9246 /*
9247 *
9248 *
9249 * 3 2 1
9250 * 10987654321098765432109876543210
9251 * 001000 x1110000101
9252 * rt -----
9253 * rs -----
9254 * rd -----
9255 */
9256 std::string NMD::LWC1_GP_(uint64 instruction)
9257 {
9258 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9259 uint64 u_value = extract_u_17_to_2__s2(instruction);
9260
9261 std::string ft = FPR(copy(ft_value));
9262 std::string u = IMMEDIATE(copy(u_value));
9263
9264 return img::format("LWC1 %s, %s($%d)", ft, u, 28);
9265 }
9266
9267
9268 /*
9269 *
9270 *
9271 * 3 2 1
9272 * 10987654321098765432109876543210
9273 * 001000 x1110000101
9274 * rt -----
9275 * rs -----
9276 * rd -----
9277 */
9278 std::string NMD::LWC1_S9_(uint64 instruction)
9279 {
9280 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9281 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9282 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9283
9284 std::string ft = FPR(copy(ft_value));
9285 std::string s = IMMEDIATE(copy(s_value));
9286 std::string rs = GPR(copy(rs_value));
9287
9288 return img::format("LWC1 %s, %s(%s)", ft, s, rs);
9289 }
9290
9291
9292 /*
9293 *
9294 *
9295 * 3 2 1
9296 * 10987654321098765432109876543210
9297 * 001000 x1110000101
9298 * rt -----
9299 * rs -----
9300 * rd -----
9301 */
9302 std::string NMD::LWC1_U12_(uint64 instruction)
9303 {
9304 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9305 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9306 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9307
9308 std::string ft = FPR(copy(ft_value));
9309 std::string u = IMMEDIATE(copy(u_value));
9310 std::string rs = GPR(copy(rs_value));
9311
9312 return img::format("LWC1 %s, %s(%s)", ft, u, rs);
9313 }
9314
9315
9316 /*
9317 *
9318 *
9319 * 3 2 1
9320 * 10987654321098765432109876543210
9321 * 001000 x1110000101
9322 * rt -----
9323 * rs -----
9324 * rd -----
9325 */
9326 std::string NMD::LWC1X(uint64 instruction)
9327 {
9328 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9329 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9330 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9331
9332 std::string ft = FPR(copy(ft_value));
9333 std::string rs = GPR(copy(rs_value));
9334 std::string rt = GPR(copy(rt_value));
9335
9336 return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
9337 }
9338
9339
9340 /*
9341 *
9342 *
9343 * 3 2 1
9344 * 10987654321098765432109876543210
9345 * 001000 x1110000101
9346 * rt -----
9347 * rs -----
9348 * rd -----
9349 */
9350 std::string NMD::LWC1XS(uint64 instruction)
9351 {
9352 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9353 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9354 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9355
9356 std::string ft = FPR(copy(ft_value));
9357 std::string rs = GPR(copy(rs_value));
9358 std::string rt = GPR(copy(rt_value));
9359
9360 return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
9361 }
9362
9363
9364 /*
9365 *
9366 *
9367 * 3 2 1
9368 * 10987654321098765432109876543210
9369 * 001000 x1110000101
9370 * rt -----
9371 * rs -----
9372 * rd -----
9373 */
9374 std::string NMD::LWC2(uint64 instruction)
9375 {
9376 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9377 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9378 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9379
9380 std::string ct = CPR(copy(ct_value));
9381 std::string s = IMMEDIATE(copy(s_value));
9382 std::string rs = GPR(copy(rs_value));
9383
9384 return img::format("LWC2 %s, %s(%s)", ct, s, rs);
9385 }
9386
9387
9388 /*
9389 *
9390 *
9391 * 3 2 1
9392 * 10987654321098765432109876543210
9393 * 001000 x1110000101
9394 * rt -----
9395 * rs -----
9396 * rd -----
9397 */
9398 std::string NMD::LWE(uint64 instruction)
9399 {
9400 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9401 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9402 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9403
9404 std::string rt = GPR(copy(rt_value));
9405 std::string s = IMMEDIATE(copy(s_value));
9406 std::string rs = GPR(copy(rs_value));
9407
9408 return img::format("LWE %s, %s(%s)", rt, s, rs);
9409 }
9410
9411
9412 /*
9413 *
9414 *
9415 * 3 2 1
9416 * 10987654321098765432109876543210
9417 * 001000 x1110000101
9418 * rt -----
9419 * rs -----
9420 * rd -----
9421 */
9422 std::string NMD::LWM(uint64 instruction)
9423 {
9424 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9425 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9426 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9427 uint64 count3_value = extract_count3_14_13_12(instruction);
9428
9429 std::string rt = GPR(copy(rt_value));
9430 std::string s = IMMEDIATE(copy(s_value));
9431 std::string rs = GPR(copy(rs_value));
9432 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
9433
9434 return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
9435 }
9436
9437
9438 /*
9439 *
9440 *
9441 * 3 2 1
9442 * 10987654321098765432109876543210
9443 * 001000 x1110000101
9444 * rt -----
9445 * rs -----
9446 * rd -----
9447 */
9448 std::string NMD::LWPC_48_(uint64 instruction)
9449 {
9450 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9451 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
9452
9453 std::string rt = GPR(copy(rt_value));
9454 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
9455
9456 return img::format("LWPC %s, %s", rt, s);
9457 }
9458
9459
9460 /*
9461 *
9462 *
9463 * 3 2 1
9464 * 10987654321098765432109876543210
9465 * 001000 x1110000101
9466 * rt -----
9467 * rs -----
9468 * rd -----
9469 */
9470 std::string NMD::LWU_GP_(uint64 instruction)
9471 {
9472 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9473 uint64 u_value = extract_u_17_to_2__s2(instruction);
9474
9475 std::string rt = GPR(copy(rt_value));
9476 std::string u = IMMEDIATE(copy(u_value));
9477
9478 return img::format("LWU %s, %s($%d)", rt, u, 28);
9479 }
9480
9481
9482 /*
9483 *
9484 *
9485 * 3 2 1
9486 * 10987654321098765432109876543210
9487 * 001000 x1110000101
9488 * rt -----
9489 * rs -----
9490 * rd -----
9491 */
9492 std::string NMD::LWU_S9_(uint64 instruction)
9493 {
9494 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9495 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9496 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9497
9498 std::string rt = GPR(copy(rt_value));
9499 std::string s = IMMEDIATE(copy(s_value));
9500 std::string rs = GPR(copy(rs_value));
9501
9502 return img::format("LWU %s, %s(%s)", rt, s, rs);
9503 }
9504
9505
9506 /*
9507 *
9508 *
9509 * 3 2 1
9510 * 10987654321098765432109876543210
9511 * 001000 x1110000101
9512 * rt -----
9513 * rs -----
9514 * rd -----
9515 */
9516 std::string NMD::LWU_U12_(uint64 instruction)
9517 {
9518 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9519 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9520 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9521
9522 std::string rt = GPR(copy(rt_value));
9523 std::string u = IMMEDIATE(copy(u_value));
9524 std::string rs = GPR(copy(rs_value));
9525
9526 return img::format("LWU %s, %s(%s)", rt, u, rs);
9527 }
9528
9529
9530 /*
9531 *
9532 *
9533 * 3 2 1
9534 * 10987654321098765432109876543210
9535 * 001000 x1110000101
9536 * rt -----
9537 * rs -----
9538 * rd -----
9539 */
9540 std::string NMD::LWUX(uint64 instruction)
9541 {
9542 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9543 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9544 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9545
9546 std::string rd = GPR(copy(rd_value));
9547 std::string rs = GPR(copy(rs_value));
9548 std::string rt = GPR(copy(rt_value));
9549
9550 return img::format("LWUX %s, %s(%s)", rd, rs, rt);
9551 }
9552
9553
9554 /*
9555 *
9556 *
9557 * 3 2 1
9558 * 10987654321098765432109876543210
9559 * 001000 x1110000101
9560 * rt -----
9561 * rs -----
9562 * rd -----
9563 */
9564 std::string NMD::LWUXS(uint64 instruction)
9565 {
9566 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9567 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9568 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9569
9570 std::string rd = GPR(copy(rd_value));
9571 std::string rs = GPR(copy(rs_value));
9572 std::string rt = GPR(copy(rt_value));
9573
9574 return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
9575 }
9576
9577
9578 /*
9579 *
9580 *
9581 * 3 2 1
9582 * 10987654321098765432109876543210
9583 * 001000 x1110000101
9584 * rt -----
9585 * rs -----
9586 * rd -----
9587 */
9588 std::string NMD::LWX(uint64 instruction)
9589 {
9590 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9591 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9592 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9593
9594 std::string rd = GPR(copy(rd_value));
9595 std::string rs = GPR(copy(rs_value));
9596 std::string rt = GPR(copy(rt_value));
9597
9598 return img::format("LWX %s, %s(%s)", rd, rs, rt);
9599 }
9600
9601
9602 /*
9603 *
9604 *
9605 * 3 2 1
9606 * 10987654321098765432109876543210
9607 * 001000 x1110000101
9608 * rt -----
9609 * rs -----
9610 * rd -----
9611 */
9612 std::string NMD::LWXS_16_(uint64 instruction)
9613 {
9614 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9615 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9616 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9617
9618 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
9619 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
9620 std::string rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
9621
9622 return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
9623 }
9624
9625
9626 /*
9627 *
9628 *
9629 * 3 2 1
9630 * 10987654321098765432109876543210
9631 * 001000 x1110000101
9632 * rt -----
9633 * rs -----
9634 * rd -----
9635 */
9636 std::string NMD::LWXS_32_(uint64 instruction)
9637 {
9638 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9639 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9640 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9641
9642 std::string rd = GPR(copy(rd_value));
9643 std::string rs = GPR(copy(rs_value));
9644 std::string rt = GPR(copy(rt_value));
9645
9646 return img::format("LWXS %s, %s(%s)", rd, rs, rt);
9647 }
9648
9649
9650 /*
9651 *
9652 *
9653 * 3 2 1
9654 * 10987654321098765432109876543210
9655 * 001000 x1110000101
9656 * rt -----
9657 * rs -----
9658 * rd -----
9659 */
9660 std::string NMD::MADD_DSP_(uint64 instruction)
9661 {
9662 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9663 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9664 uint64 ac_value = extract_ac_13_12(instruction);
9665
9666 std::string ac = AC(copy(ac_value));
9667 std::string rs = GPR(copy(rs_value));
9668 std::string rt = GPR(copy(rt_value));
9669
9670 return img::format("MADD %s, %s, %s", ac, rs, rt);
9671 }
9672
9673
9674 /*
9675 *
9676 *
9677 * 3 2 1
9678 * 10987654321098765432109876543210
9679 * 001000 x1110000101
9680 * rt -----
9681 * rs -----
9682 * rd -----
9683 */
9684 std::string NMD::MADDF_D(uint64 instruction)
9685 {
9686 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9687 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9688 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9689
9690 std::string fd = FPR(copy(fd_value));
9691 std::string fs = FPR(copy(fs_value));
9692 std::string ft = FPR(copy(ft_value));
9693
9694 return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
9695 }
9696
9697
9698 /*
9699 *
9700 *
9701 * 3 2 1
9702 * 10987654321098765432109876543210
9703 * 001000 x1110000101
9704 * rt -----
9705 * rs -----
9706 * rd -----
9707 */
9708 std::string NMD::MADDF_S(uint64 instruction)
9709 {
9710 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9711 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9712 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9713
9714 std::string fd = FPR(copy(fd_value));
9715 std::string fs = FPR(copy(fs_value));
9716 std::string ft = FPR(copy(ft_value));
9717
9718 return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
9719 }
9720
9721
9722 /*
9723 *
9724 *
9725 * 3 2 1
9726 * 10987654321098765432109876543210
9727 * 001000 x1110000101
9728 * rt -----
9729 * rs -----
9730 * rd -----
9731 */
9732 std::string NMD::MADDU_DSP_(uint64 instruction)
9733 {
9734 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9735 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9736 uint64 ac_value = extract_ac_13_12(instruction);
9737
9738 std::string ac = AC(copy(ac_value));
9739 std::string rs = GPR(copy(rs_value));
9740 std::string rt = GPR(copy(rt_value));
9741
9742 return img::format("MADDU %s, %s, %s", ac, rs, rt);
9743 }
9744
9745
9746 /*
9747 *
9748 *
9749 * 3 2 1
9750 * 10987654321098765432109876543210
9751 * 001000 x1110000101
9752 * rt -----
9753 * rs -----
9754 * rd -----
9755 */
9756 std::string NMD::MAQ_S_W_PHL(uint64 instruction)
9757 {
9758 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9759 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9760 uint64 ac_value = extract_ac_13_12(instruction);
9761
9762 std::string ac = AC(copy(ac_value));
9763 std::string rs = GPR(copy(rs_value));
9764 std::string rt = GPR(copy(rt_value));
9765
9766 return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9767 }
9768
9769
9770 /*
9771 *
9772 *
9773 * 3 2 1
9774 * 10987654321098765432109876543210
9775 * 001000 x1110000101
9776 * rt -----
9777 * rs -----
9778 * rd -----
9779 */
9780 std::string NMD::MAQ_S_W_PHR(uint64 instruction)
9781 {
9782 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9783 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9784 uint64 ac_value = extract_ac_13_12(instruction);
9785
9786 std::string ac = AC(copy(ac_value));
9787 std::string rs = GPR(copy(rs_value));
9788 std::string rt = GPR(copy(rt_value));
9789
9790 return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9791 }
9792
9793
9794 /*
9795 *
9796 *
9797 * 3 2 1
9798 * 10987654321098765432109876543210
9799 * 001000 x1110000101
9800 * rt -----
9801 * rs -----
9802 * rd -----
9803 */
9804 std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
9805 {
9806 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9807 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9808 uint64 ac_value = extract_ac_13_12(instruction);
9809
9810 std::string ac = AC(copy(ac_value));
9811 std::string rs = GPR(copy(rs_value));
9812 std::string rt = GPR(copy(rt_value));
9813
9814 return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9815 }
9816
9817
9818 /*
9819 *
9820 *
9821 * 3 2 1
9822 * 10987654321098765432109876543210
9823 * 001000 x1110000101
9824 * rt -----
9825 * rs -----
9826 * rd -----
9827 */
9828 std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
9829 {
9830 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9831 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9832 uint64 ac_value = extract_ac_13_12(instruction);
9833
9834 std::string ac = AC(copy(ac_value));
9835 std::string rs = GPR(copy(rs_value));
9836 std::string rt = GPR(copy(rt_value));
9837
9838 return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9839 }
9840
9841
9842 /*
9843 *
9844 *
9845 * 3 2 1
9846 * 10987654321098765432109876543210
9847 * 001000 x1110000101
9848 * rt -----
9849 * rs -----
9850 * rd -----
9851 */
9852 std::string NMD::MAX_D(uint64 instruction)
9853 {
9854 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9855 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9856 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9857
9858 std::string fd = FPR(copy(fd_value));
9859 std::string fs = FPR(copy(fs_value));
9860 std::string ft = FPR(copy(ft_value));
9861
9862 return img::format("MAX.D %s, %s, %s", fd, fs, ft);
9863 }
9864
9865
9866 /*
9867 *
9868 *
9869 * 3 2 1
9870 * 10987654321098765432109876543210
9871 * 001000 x1110000101
9872 * rt -----
9873 * rs -----
9874 * rd -----
9875 */
9876 std::string NMD::MAX_S(uint64 instruction)
9877 {
9878 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9879 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9880 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9881
9882 std::string fd = FPR(copy(fd_value));
9883 std::string fs = FPR(copy(fs_value));
9884 std::string ft = FPR(copy(ft_value));
9885
9886 return img::format("MAX.S %s, %s, %s", fd, fs, ft);
9887 }
9888
9889
9890 /*
9891 *
9892 *
9893 * 3 2 1
9894 * 10987654321098765432109876543210
9895 * 001000 x1110000101
9896 * rt -----
9897 * rs -----
9898 * rd -----
9899 */
9900 std::string NMD::MAXA_D(uint64 instruction)
9901 {
9902 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9903 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9904 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9905
9906 std::string fd = FPR(copy(fd_value));
9907 std::string fs = FPR(copy(fs_value));
9908 std::string ft = FPR(copy(ft_value));
9909
9910 return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
9911 }
9912
9913
9914 /*
9915 *
9916 *
9917 * 3 2 1
9918 * 10987654321098765432109876543210
9919 * 001000 x1110000101
9920 * rt -----
9921 * rs -----
9922 * rd -----
9923 */
9924 std::string NMD::MAXA_S(uint64 instruction)
9925 {
9926 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9927 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9928 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9929
9930 std::string fd = FPR(copy(fd_value));
9931 std::string fs = FPR(copy(fs_value));
9932 std::string ft = FPR(copy(ft_value));
9933
9934 return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
9935 }
9936
9937
9938 /*
9939 *
9940 *
9941 * 3 2 1
9942 * 10987654321098765432109876543210
9943 * 001000 x1110000101
9944 * rt -----
9945 * rs -----
9946 * rd -----
9947 */
9948 std::string NMD::MFC0(uint64 instruction)
9949 {
9950 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9951 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9952 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9953
9954 std::string rt = GPR(copy(rt_value));
9955 std::string c0s = CPR(copy(c0s_value));
9956 std::string sel = IMMEDIATE(copy(sel_value));
9957
9958 return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
9959 }
9960
9961
9962 /*
9963 *
9964 *
9965 * 3 2 1
9966 * 10987654321098765432109876543210
9967 * 001000 x1110000101
9968 * rt -----
9969 * rs -----
9970 * rd -----
9971 */
9972 std::string NMD::MFC1(uint64 instruction)
9973 {
9974 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9975 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9976
9977 std::string rt = GPR(copy(rt_value));
9978 std::string fs = FPR(copy(fs_value));
9979
9980 return img::format("MFC1 %s, %s", rt, fs);
9981 }
9982
9983
9984 /*
9985 *
9986 *
9987 * 3 2 1
9988 * 10987654321098765432109876543210
9989 * 001000 x1110000101
9990 * rt -----
9991 * rs -----
9992 * rd -----
9993 */
9994 std::string NMD::MFC2(uint64 instruction)
9995 {
9996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9997 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
9998
9999 std::string rt = GPR(copy(rt_value));
10000 std::string cs = CPR(copy(cs_value));
10001
10002 return img::format("MFC2 %s, %s", rt, cs);
10003 }
10004
10005
10006 /*
10007 *
10008 *
10009 * 3 2 1
10010 * 10987654321098765432109876543210
10011 * 001000 x1110000101
10012 * rt -----
10013 * rs -----
10014 * rd -----
10015 */
10016 std::string NMD::MFGC0(uint64 instruction)
10017 {
10018 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10019 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10020 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10021
10022 std::string rt = GPR(copy(rt_value));
10023 std::string c0s = CPR(copy(c0s_value));
10024 std::string sel = IMMEDIATE(copy(sel_value));
10025
10026 return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
10027 }
10028
10029
10030 /*
10031 *
10032 *
10033 * 3 2 1
10034 * 10987654321098765432109876543210
10035 * 001000 x1110000101
10036 * rt -----
10037 * rs -----
10038 * rd -----
10039 */
10040 std::string NMD::MFHC0(uint64 instruction)
10041 {
10042 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10043 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10044 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10045
10046 std::string rt = GPR(copy(rt_value));
10047 std::string c0s = CPR(copy(c0s_value));
10048 std::string sel = IMMEDIATE(copy(sel_value));
10049
10050 return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
10051 }
10052
10053
10054 /*
10055 *
10056 *
10057 * 3 2 1
10058 * 10987654321098765432109876543210
10059 * 001000 x1110000101
10060 * rt -----
10061 * rs -----
10062 * rd -----
10063 */
10064 std::string NMD::MFHC1(uint64 instruction)
10065 {
10066 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10067 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10068
10069 std::string rt = GPR(copy(rt_value));
10070 std::string fs = FPR(copy(fs_value));
10071
10072 return img::format("MFHC1 %s, %s", rt, fs);
10073 }
10074
10075
10076 /*
10077 *
10078 *
10079 * 3 2 1
10080 * 10987654321098765432109876543210
10081 * 001000 x1110000101
10082 * rt -----
10083 * rs -----
10084 * rd -----
10085 */
10086 std::string NMD::MFHC2(uint64 instruction)
10087 {
10088 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10089 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10090
10091 std::string rt = GPR(copy(rt_value));
10092 std::string cs = CPR(copy(cs_value));
10093
10094 return img::format("MFHC2 %s, %s", rt, cs);
10095 }
10096
10097
10098 /*
10099 *
10100 *
10101 * 3 2 1
10102 * 10987654321098765432109876543210
10103 * 001000 x1110000101
10104 * rt -----
10105 * rs -----
10106 * rd -----
10107 */
10108 std::string NMD::MFHGC0(uint64 instruction)
10109 {
10110 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10111 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10112 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10113
10114 std::string rt = GPR(copy(rt_value));
10115 std::string c0s = CPR(copy(c0s_value));
10116 std::string sel = IMMEDIATE(copy(sel_value));
10117
10118 return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
10119 }
10120
10121
10122 /*
10123 *
10124 *
10125 * 3 2 1
10126 * 10987654321098765432109876543210
10127 * 001000 x1110000101
10128 * rt -----
10129 * rs -----
10130 * rd -----
10131 */
10132 std::string NMD::MFHI_DSP_(uint64 instruction)
10133 {
10134 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10135 uint64 ac_value = extract_ac_13_12(instruction);
10136
10137 std::string rt = GPR(copy(rt_value));
10138 std::string ac = AC(copy(ac_value));
10139
10140 return img::format("MFHI %s, %s", rt, ac);
10141 }
10142
10143
10144 /*
10145 *
10146 *
10147 * 3 2 1
10148 * 10987654321098765432109876543210
10149 * 001000 x1110000101
10150 * rt -----
10151 * rs -----
10152 * rd -----
10153 */
10154 std::string NMD::MFHTR(uint64 instruction)
10155 {
10156 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10157 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10158 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10159 uint64 u_value = extract_u_10(instruction);
10160
10161 std::string rt = GPR(copy(rt_value));
10162 std::string c0s = IMMEDIATE(copy(c0s_value));
10163 std::string u = IMMEDIATE(copy(u_value));
10164 std::string sel = IMMEDIATE(copy(sel_value));
10165
10166 return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
10167 }
10168
10169
10170 /*
10171 *
10172 *
10173 * 3 2 1
10174 * 10987654321098765432109876543210
10175 * 001000 x1110000101
10176 * rt -----
10177 * rs -----
10178 * rd -----
10179 */
10180 std::string NMD::MFLO_DSP_(uint64 instruction)
10181 {
10182 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10183 uint64 ac_value = extract_ac_13_12(instruction);
10184
10185 std::string rt = GPR(copy(rt_value));
10186 std::string ac = AC(copy(ac_value));
10187
10188 return img::format("MFLO %s, %s", rt, ac);
10189 }
10190
10191
10192 /*
10193 *
10194 *
10195 * 3 2 1
10196 * 10987654321098765432109876543210
10197 * 001000 x1110000101
10198 * rt -----
10199 * rs -----
10200 * rd -----
10201 */
10202 std::string NMD::MFTR(uint64 instruction)
10203 {
10204 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10205 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10206 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10207 uint64 u_value = extract_u_10(instruction);
10208
10209 std::string rt = GPR(copy(rt_value));
10210 std::string c0s = IMMEDIATE(copy(c0s_value));
10211 std::string u = IMMEDIATE(copy(u_value));
10212 std::string sel = IMMEDIATE(copy(sel_value));
10213
10214 return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
10215 }
10216
10217
10218 /*
10219 *
10220 *
10221 * 3 2 1
10222 * 10987654321098765432109876543210
10223 * 001000 x1110000101
10224 * rt -----
10225 * rs -----
10226 * rd -----
10227 */
10228 std::string NMD::MIN_D(uint64 instruction)
10229 {
10230 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10231 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10232 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10233
10234 std::string fd = FPR(copy(fd_value));
10235 std::string fs = FPR(copy(fs_value));
10236 std::string ft = FPR(copy(ft_value));
10237
10238 return img::format("MIN.D %s, %s, %s", fd, fs, ft);
10239 }
10240
10241
10242 /*
10243 *
10244 *
10245 * 3 2 1
10246 * 10987654321098765432109876543210
10247 * 001000 x1110000101
10248 * rt -----
10249 * rs -----
10250 * rd -----
10251 */
10252 std::string NMD::MIN_S(uint64 instruction)
10253 {
10254 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10255 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10256 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10257
10258 std::string fd = FPR(copy(fd_value));
10259 std::string fs = FPR(copy(fs_value));
10260 std::string ft = FPR(copy(ft_value));
10261
10262 return img::format("MIN.S %s, %s, %s", fd, fs, ft);
10263 }
10264
10265
10266 /*
10267 *
10268 *
10269 * 3 2 1
10270 * 10987654321098765432109876543210
10271 * 001000 x1110000101
10272 * rt -----
10273 * rs -----
10274 * rd -----
10275 */
10276 std::string NMD::MINA_D(uint64 instruction)
10277 {
10278 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10279 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10280 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10281
10282 std::string fd = FPR(copy(fd_value));
10283 std::string fs = FPR(copy(fs_value));
10284 std::string ft = FPR(copy(ft_value));
10285
10286 return img::format("MINA.D %s, %s, %s", fd, fs, ft);
10287 }
10288
10289
10290 /*
10291 *
10292 *
10293 * 3 2 1
10294 * 10987654321098765432109876543210
10295 * 001000 x1110000101
10296 * rt -----
10297 * rs -----
10298 * rd -----
10299 */
10300 std::string NMD::MINA_S(uint64 instruction)
10301 {
10302 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10303 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10304 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10305
10306 std::string fd = FPR(copy(fd_value));
10307 std::string fs = FPR(copy(fs_value));
10308 std::string ft = FPR(copy(ft_value));
10309
10310 return img::format("MINA.S %s, %s, %s", fd, fs, ft);
10311 }
10312
10313
10314 /*
10315 *
10316 *
10317 * 3 2 1
10318 * 10987654321098765432109876543210
10319 * 001000 x1110000101
10320 * rt -----
10321 * rs -----
10322 * rd -----
10323 */
10324 std::string NMD::MOD(uint64 instruction)
10325 {
10326 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10327 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10328 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10329
10330 std::string rd = GPR(copy(rd_value));
10331 std::string rs = GPR(copy(rs_value));
10332 std::string rt = GPR(copy(rt_value));
10333
10334 return img::format("MOD %s, %s, %s", rd, rs, rt);
10335 }
10336
10337
10338 /*
10339 *
10340 *
10341 * 3 2 1
10342 * 10987654321098765432109876543210
10343 * 001000 x1110000101
10344 * rt -----
10345 * rs -----
10346 * rd -----
10347 */
10348 std::string NMD::MODSUB(uint64 instruction)
10349 {
10350 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10351 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10352 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10353
10354 std::string rd = GPR(copy(rd_value));
10355 std::string rs = GPR(copy(rs_value));
10356 std::string rt = GPR(copy(rt_value));
10357
10358 return img::format("MODSUB %s, %s, %s", rd, rs, rt);
10359 }
10360
10361
10362 /*
10363 *
10364 *
10365 * 3 2 1
10366 * 10987654321098765432109876543210
10367 * 001000 x1110000101
10368 * rt -----
10369 * rs -----
10370 * rd -----
10371 */
10372 std::string NMD::MODU(uint64 instruction)
10373 {
10374 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10375 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10376 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10377
10378 std::string rd = GPR(copy(rd_value));
10379 std::string rs = GPR(copy(rs_value));
10380 std::string rt = GPR(copy(rt_value));
10381
10382 return img::format("MODU %s, %s, %s", rd, rs, rt);
10383 }
10384
10385
10386 /*
10387 *
10388 *
10389 * 3 2 1
10390 * 10987654321098765432109876543210
10391 * 001000 x1110000101
10392 * rt -----
10393 * rs -----
10394 * rd -----
10395 */
10396 std::string NMD::MOV_D(uint64 instruction)
10397 {
10398 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10399 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10400
10401 std::string ft = FPR(copy(ft_value));
10402 std::string fs = FPR(copy(fs_value));
10403
10404 return img::format("MOV.D %s, %s", ft, fs);
10405 }
10406
10407
10408 /*
10409 *
10410 *
10411 * 3 2 1
10412 * 10987654321098765432109876543210
10413 * 001000 x1110000101
10414 * rt -----
10415 * rs -----
10416 * rd -----
10417 */
10418 std::string NMD::MOV_S(uint64 instruction)
10419 {
10420 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10421 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10422
10423 std::string ft = FPR(copy(ft_value));
10424 std::string fs = FPR(copy(fs_value));
10425
10426 return img::format("MOV.S %s, %s", ft, fs);
10427 }
10428
10429
10430 /*
10431 *
10432 *
10433 * 3 2 1
10434 * 10987654321098765432109876543210
10435 * 001000 x1110000101
10436 * rt -----
10437 * rs -----
10438 * rd -----
10439 */
10440 std::string NMD::MOVE_BALC(uint64 instruction)
10441 {
10442 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10443 uint64 rd1_value = extract_rdl_25_24(instruction);
10444 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
10445
10446 std::string rd1 = GPR(encode_rd1_from_rd(rd1_value));
10447 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
10448 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
10449
10450 return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10451 }
10452
10453
10454 /*
10455 *
10456 *
10457 * 3 2 1
10458 * 10987654321098765432109876543210
10459 * 001000 x1110000101
10460 * rt -----
10461 * rs -----
10462 * rd -----
10463 */
10464 std::string NMD::MOVEP(uint64 instruction)
10465 {
10466 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10467 uint64 rd2_value = extract_rd2_3_8(instruction);
10468 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10469
10470 std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
10471 std::string re2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
10472 /* !!!!!!!!!! - no conversion function */
10473 std::string rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
10474 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
10475
10476 return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10477 /* hand edited */
10478 }
10479
10480
10481 /*
10482 *
10483 *
10484 * 3 2 1
10485 * 10987654321098765432109876543210
10486 * 001000 x1110000101
10487 * rt -----
10488 * rs -----
10489 * rd -----
10490 */
10491 std::string NMD::MOVEP_REV_(uint64 instruction)
10492 {
10493 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10494 uint64 rd2_value = extract_rd2_3_8(instruction);
10495 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10496
10497 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
10498 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
10499 std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
10500 std::string rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
10501 /* !!!!!!!!!! - no conversion function */
10502
10503 return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10504 /* hand edited */
10505 }
10506
10507
10508 /*
10509 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10510 *
10511 * 3 2 1
10512 * 10987654321098765432109876543210
10513 * 001000 00010001101
10514 * rt -----
10515 * rs -----
10516 * rd -----
10517 */
10518 std::string NMD::MOVE(uint64 instruction)
10519 {
10520 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10521 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10522
10523 std::string rt = GPR(copy(rt_value));
10524 std::string rs = GPR(copy(rs_value));
10525
10526 return img::format("MOVE %s, %s", rt, rs);
10527 }
10528
10529
10530 /*
10531 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10532 *
10533 * 3 2 1
10534 * 10987654321098765432109876543210
10535 * 001000 00010001101
10536 * rt -----
10537 * rs -----
10538 * rd -----
10539 */
10540 std::string NMD::MOVN(uint64 instruction)
10541 {
10542 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10543 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10544 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10545
10546 std::string rd = GPR(copy(rd_value));
10547 std::string rs = GPR(copy(rs_value));
10548 std::string rt = GPR(copy(rt_value));
10549
10550 return img::format("MOVN %s, %s, %s", rd, rs, rt);
10551 }
10552
10553
10554 /*
10555 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10556 *
10557 * 3 2 1
10558 * 10987654321098765432109876543210
10559 * 001000 00010001101
10560 * rt -----
10561 * rs -----
10562 * rd -----
10563 */
10564 std::string NMD::MOVZ(uint64 instruction)
10565 {
10566 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10567 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10568 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10569
10570 std::string rd = GPR(copy(rd_value));
10571 std::string rs = GPR(copy(rs_value));
10572 std::string rt = GPR(copy(rt_value));
10573
10574 return img::format("MOVZ %s, %s, %s", rd, rs, rt);
10575 }
10576
10577
10578 /*
10579 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10580 *
10581 * 3 2 1
10582 * 10987654321098765432109876543210
10583 * 001000 00010001101
10584 * rt -----
10585 * rs -----
10586 * rd -----
10587 */
10588 std::string NMD::MSUB_DSP_(uint64 instruction)
10589 {
10590 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10591 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10592 uint64 ac_value = extract_ac_13_12(instruction);
10593
10594 std::string ac = AC(copy(ac_value));
10595 std::string rs = GPR(copy(rs_value));
10596 std::string rt = GPR(copy(rt_value));
10597
10598 return img::format("MSUB %s, %s, %s", ac, rs, rt);
10599 }
10600
10601
10602 /*
10603 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10604 *
10605 * 3 2 1
10606 * 10987654321098765432109876543210
10607 * 001000 00010001101
10608 * rt -----
10609 * rs -----
10610 * rd -----
10611 */
10612 std::string NMD::MSUBF_D(uint64 instruction)
10613 {
10614 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10615 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10616 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10617
10618 std::string fd = FPR(copy(fd_value));
10619 std::string fs = FPR(copy(fs_value));
10620 std::string ft = FPR(copy(ft_value));
10621
10622 return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
10623 }
10624
10625
10626 /*
10627 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10628 *
10629 * 3 2 1
10630 * 10987654321098765432109876543210
10631 * 001000 00010001101
10632 * rt -----
10633 * rs -----
10634 * rd -----
10635 */
10636 std::string NMD::MSUBF_S(uint64 instruction)
10637 {
10638 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10639 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10640 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10641
10642 std::string fd = FPR(copy(fd_value));
10643 std::string fs = FPR(copy(fs_value));
10644 std::string ft = FPR(copy(ft_value));
10645
10646 return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
10647 }
10648
10649
10650 /*
10651 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10652 *
10653 * 3 2 1
10654 * 10987654321098765432109876543210
10655 * 001000 00010001101
10656 * rt -----
10657 * rs -----
10658 * rd -----
10659 */
10660 std::string NMD::MSUBU_DSP_(uint64 instruction)
10661 {
10662 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10663 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10664 uint64 ac_value = extract_ac_13_12(instruction);
10665
10666 std::string ac = AC(copy(ac_value));
10667 std::string rs = GPR(copy(rs_value));
10668 std::string rt = GPR(copy(rt_value));
10669
10670 return img::format("MSUBU %s, %s, %s", ac, rs, rt);
10671 }
10672
10673
10674 /*
10675 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10676 *
10677 * 3 2 1
10678 * 10987654321098765432109876543210
10679 * 001000 00010001101
10680 * rt -----
10681 * rs -----
10682 * rd -----
10683 */
10684 std::string NMD::MTC0(uint64 instruction)
10685 {
10686 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10687 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10688 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10689
10690 std::string rt = GPR(copy(rt_value));
10691 std::string c0s = CPR(copy(c0s_value));
10692 std::string sel = IMMEDIATE(copy(sel_value));
10693
10694 return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
10695 }
10696
10697
10698 /*
10699 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10700 *
10701 * 3 2 1
10702 * 10987654321098765432109876543210
10703 * 001000 00010001101
10704 * rt -----
10705 * rs -----
10706 * rd -----
10707 */
10708 std::string NMD::MTC1(uint64 instruction)
10709 {
10710 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10711 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10712
10713 std::string rt = GPR(copy(rt_value));
10714 std::string fs = FPR(copy(fs_value));
10715
10716 return img::format("MTC1 %s, %s", rt, fs);
10717 }
10718
10719
10720 /*
10721 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10722 *
10723 * 3 2 1
10724 * 10987654321098765432109876543210
10725 * 001000 00010001101
10726 * rt -----
10727 * rs -----
10728 * rd -----
10729 */
10730 std::string NMD::MTC2(uint64 instruction)
10731 {
10732 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10733 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10734
10735 std::string rt = GPR(copy(rt_value));
10736 std::string cs = CPR(copy(cs_value));
10737
10738 return img::format("MTC2 %s, %s", rt, cs);
10739 }
10740
10741
10742 /*
10743 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10744 *
10745 * 3 2 1
10746 * 10987654321098765432109876543210
10747 * 001000 00010001101
10748 * rt -----
10749 * rs -----
10750 * rd -----
10751 */
10752 std::string NMD::MTGC0(uint64 instruction)
10753 {
10754 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10755 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10756 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10757
10758 std::string rt = GPR(copy(rt_value));
10759 std::string c0s = CPR(copy(c0s_value));
10760 std::string sel = IMMEDIATE(copy(sel_value));
10761
10762 return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
10763 }
10764
10765
10766 /*
10767 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10768 *
10769 * 3 2 1
10770 * 10987654321098765432109876543210
10771 * 001000 00010001101
10772 * rt -----
10773 * rs -----
10774 * rd -----
10775 */
10776 std::string NMD::MTHC0(uint64 instruction)
10777 {
10778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10779 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10780 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10781
10782 std::string rt = GPR(copy(rt_value));
10783 std::string c0s = CPR(copy(c0s_value));
10784 std::string sel = IMMEDIATE(copy(sel_value));
10785
10786 return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
10787 }
10788
10789
10790 /*
10791 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10792 *
10793 * 3 2 1
10794 * 10987654321098765432109876543210
10795 * 001000 00010001101
10796 * rt -----
10797 * rs -----
10798 * rd -----
10799 */
10800 std::string NMD::MTHC1(uint64 instruction)
10801 {
10802 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10803 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10804
10805 std::string rt = GPR(copy(rt_value));
10806 std::string fs = FPR(copy(fs_value));
10807
10808 return img::format("MTHC1 %s, %s", rt, fs);
10809 }
10810
10811
10812 /*
10813 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10814 *
10815 * 3 2 1
10816 * 10987654321098765432109876543210
10817 * 001000 00010001101
10818 * rt -----
10819 * rs -----
10820 * rd -----
10821 */
10822 std::string NMD::MTHC2(uint64 instruction)
10823 {
10824 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10825 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10826
10827 std::string rt = GPR(copy(rt_value));
10828 std::string cs = CPR(copy(cs_value));
10829
10830 return img::format("MTHC2 %s, %s", rt, cs);
10831 }
10832
10833
10834 /*
10835 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10836 *
10837 * 3 2 1
10838 * 10987654321098765432109876543210
10839 * 001000 00010001101
10840 * rt -----
10841 * rs -----
10842 * rd -----
10843 */
10844 std::string NMD::MTHGC0(uint64 instruction)
10845 {
10846 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10847 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10848 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10849
10850 std::string rt = GPR(copy(rt_value));
10851 std::string c0s = CPR(copy(c0s_value));
10852 std::string sel = IMMEDIATE(copy(sel_value));
10853
10854 return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
10855 }
10856
10857
10858 /*
10859 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10860 *
10861 * 3 2 1
10862 * 10987654321098765432109876543210
10863 * 001000 00010001101
10864 * rt -----
10865 * rs -----
10866 * rd -----
10867 */
10868 std::string NMD::MTHI_DSP_(uint64 instruction)
10869 {
10870 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10871 uint64 ac_value = extract_ac_13_12(instruction);
10872
10873 std::string rs = GPR(copy(rs_value));
10874 std::string ac = AC(copy(ac_value));
10875
10876 return img::format("MTHI %s, %s", rs, ac);
10877 }
10878
10879
10880 /*
10881 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10882 *
10883 * 3 2 1
10884 * 10987654321098765432109876543210
10885 * 001000 00010001101
10886 * rt -----
10887 * rs -----
10888 * rd -----
10889 */
10890 std::string NMD::MTHLIP(uint64 instruction)
10891 {
10892 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10893 uint64 ac_value = extract_ac_13_12(instruction);
10894
10895 std::string rs = GPR(copy(rs_value));
10896 std::string ac = AC(copy(ac_value));
10897
10898 return img::format("MTHLIP %s, %s", rs, ac);
10899 }
10900
10901
10902 /*
10903 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10904 *
10905 * 3 2 1
10906 * 10987654321098765432109876543210
10907 * 001000 00010001101
10908 * rt -----
10909 * rs -----
10910 * rd -----
10911 */
10912 std::string NMD::MTHTR(uint64 instruction)
10913 {
10914 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10915 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10916 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10917 uint64 u_value = extract_u_10(instruction);
10918
10919 std::string rt = GPR(copy(rt_value));
10920 std::string c0s = IMMEDIATE(copy(c0s_value));
10921 std::string u = IMMEDIATE(copy(u_value));
10922 std::string sel = IMMEDIATE(copy(sel_value));
10923
10924 return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
10925 }
10926
10927
10928 /*
10929 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10930 *
10931 * 3 2 1
10932 * 10987654321098765432109876543210
10933 * 001000 00010001101
10934 * rt -----
10935 * rs -----
10936 * rd -----
10937 */
10938 std::string NMD::MTLO_DSP_(uint64 instruction)
10939 {
10940 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10941 uint64 ac_value = extract_ac_13_12(instruction);
10942
10943 std::string rs = GPR(copy(rs_value));
10944 std::string ac = AC(copy(ac_value));
10945
10946 return img::format("MTLO %s, %s", rs, ac);
10947 }
10948
10949
10950 /*
10951 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10952 *
10953 * 3 2 1
10954 * 10987654321098765432109876543210
10955 * 001000 00010001101
10956 * rt -----
10957 * rs -----
10958 * rd -----
10959 */
10960 std::string NMD::MTTR(uint64 instruction)
10961 {
10962 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10963 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10964 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10965 uint64 u_value = extract_u_10(instruction);
10966
10967 std::string rt = GPR(copy(rt_value));
10968 std::string c0s = IMMEDIATE(copy(c0s_value));
10969 std::string u = IMMEDIATE(copy(u_value));
10970 std::string sel = IMMEDIATE(copy(sel_value));
10971
10972 return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
10973 }
10974
10975
10976 /*
10977 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10978 *
10979 * 3 2 1
10980 * 10987654321098765432109876543210
10981 * 001000 00010001101
10982 * rt -----
10983 * rs -----
10984 * rd -----
10985 */
10986 std::string NMD::MUH(uint64 instruction)
10987 {
10988 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10989 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10990 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10991
10992 std::string rd = GPR(copy(rd_value));
10993 std::string rs = GPR(copy(rs_value));
10994 std::string rt = GPR(copy(rt_value));
10995
10996 return img::format("MUH %s, %s, %s", rd, rs, rt);
10997 }
10998
10999
11000 /*
11001 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11002 *
11003 * 3 2 1
11004 * 10987654321098765432109876543210
11005 * 001000 00010001101
11006 * rt -----
11007 * rs -----
11008 * rd -----
11009 */
11010 std::string NMD::MUHU(uint64 instruction)
11011 {
11012 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11013 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11014 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11015
11016 std::string rd = GPR(copy(rd_value));
11017 std::string rs = GPR(copy(rs_value));
11018 std::string rt = GPR(copy(rt_value));
11019
11020 return img::format("MUHU %s, %s, %s", rd, rs, rt);
11021 }
11022
11023
11024 /*
11025 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11026 *
11027 * 3 2 1
11028 * 10987654321098765432109876543210
11029 * 001000 00010001101
11030 * rt -----
11031 * rs -----
11032 * rd -----
11033 */
11034 std::string NMD::MUL_32_(uint64 instruction)
11035 {
11036 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11037 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11038 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11039
11040 std::string rd = GPR(copy(rd_value));
11041 std::string rs = GPR(copy(rs_value));
11042 std::string rt = GPR(copy(rt_value));
11043
11044 return img::format("MUL %s, %s, %s", rd, rs, rt);
11045 }
11046
11047
11048 /*
11049 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11050 *
11051 * 3 2 1
11052 * 10987654321098765432109876543210
11053 * 001000 00010001101
11054 * rt -----
11055 * rs -----
11056 * rd -----
11057 */
11058 std::string NMD::MUL_4X4_(uint64 instruction)
11059 {
11060 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
11061 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11062
11063 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
11064 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
11065
11066 return img::format("MUL %s, %s", rs4, rt4);
11067 }
11068
11069
11070 /*
11071 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11072 *
11073 * 3 2 1
11074 * 10987654321098765432109876543210
11075 * 001000 00010001101
11076 * rt -----
11077 * rs -----
11078 * rd -----
11079 */
11080 std::string NMD::MUL_D(uint64 instruction)
11081 {
11082 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11083 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11084 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
11085
11086 std::string fd = FPR(copy(fd_value));
11087 std::string fs = FPR(copy(fs_value));
11088 std::string ft = FPR(copy(ft_value));
11089
11090 return img::format("MUL.D %s, %s, %s", fd, fs, ft);
11091 }
11092
11093
11094 /*
11095 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11096 *
11097 * 3 2 1
11098 * 10987654321098765432109876543210
11099 * 001000 00010001101
11100 * rt -----
11101 * rs -----
11102 * rd -----
11103 */
11104 std::string NMD::MUL_PH(uint64 instruction)
11105 {
11106 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11107 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11108 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11109
11110 std::string rd = GPR(copy(rd_value));
11111 std::string rs = GPR(copy(rs_value));
11112 std::string rt = GPR(copy(rt_value));
11113
11114 return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
11115 }
11116
11117
11118 /*
11119 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11120 *
11121 * 3 2 1
11122 * 10987654321098765432109876543210
11123 * 001000 00010001101
11124 * rt -----
11125 * rs -----
11126 * rd -----
11127 */
11128 std::string NMD::MUL_S_PH(uint64 instruction)
11129 {
11130 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11131 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11132 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11133
11134 std::string rd = GPR(copy(rd_value));
11135 std::string rs = GPR(copy(rs_value));
11136 std::string rt = GPR(copy(rt_value));
11137
11138 return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
11139 }
11140
11141
11142 /*
11143 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11144 *
11145 * 3 2 1
11146 * 10987654321098765432109876543210
11147 * 001000 00010001101
11148 * rt -----
11149 * rs -----
11150 * rd -----
11151 */
11152 std::string NMD::MUL_S(uint64 instruction)
11153 {
11154 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11155 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11156 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
11157
11158 std::string fd = FPR(copy(fd_value));
11159 std::string fs = FPR(copy(fs_value));
11160 std::string ft = FPR(copy(ft_value));
11161
11162 return img::format("MUL.S %s, %s, %s", fd, fs, ft);
11163 }
11164
11165
11166 /*
11167 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11168 *
11169 * 3 2 1
11170 * 10987654321098765432109876543210
11171 * 001000 00010001101
11172 * rt -----
11173 * rs -----
11174 * rd -----
11175 */
11176 std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
11177 {
11178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11179 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11180 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11181
11182 std::string rd = GPR(copy(rd_value));
11183 std::string rs = GPR(copy(rs_value));
11184 std::string rt = GPR(copy(rt_value));
11185
11186 return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
11187 }
11188
11189
11190 /*
11191 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11192 *
11193 * 3 2 1
11194 * 10987654321098765432109876543210
11195 * 001000 00010001101
11196 * rt -----
11197 * rs -----
11198 * rd -----
11199 */
11200 std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
11201 {
11202 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11203 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11204 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11205
11206 std::string rd = GPR(copy(rd_value));
11207 std::string rs = GPR(copy(rs_value));
11208 std::string rt = GPR(copy(rt_value));
11209
11210 return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
11211 }
11212
11213
11214 /*
11215 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11216 *
11217 * 3 2 1
11218 * 10987654321098765432109876543210
11219 * 001000 00010001101
11220 * rt -----
11221 * rs -----
11222 * rd -----
11223 */
11224 std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
11225 {
11226 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11227 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11228 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11229
11230 std::string rd = GPR(copy(rd_value));
11231 std::string rs = GPR(copy(rs_value));
11232 std::string rt = GPR(copy(rt_value));
11233
11234 return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
11235 }
11236
11237
11238 /*
11239 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11240 *
11241 * 3 2 1
11242 * 10987654321098765432109876543210
11243 * 001000 00010001101
11244 * rt -----
11245 * rs -----
11246 * rd -----
11247 */
11248 std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
11249 {
11250 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11251 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11252 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11253
11254 std::string rd = GPR(copy(rd_value));
11255 std::string rs = GPR(copy(rs_value));
11256 std::string rt = GPR(copy(rt_value));
11257
11258 return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
11259 }
11260
11261
11262 /*
11263 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11264 *
11265 * 3 2 1
11266 * 10987654321098765432109876543210
11267 * 001000 00010001101
11268 * rt -----
11269 * rs -----
11270 * rd -----
11271 */
11272 std::string NMD::MULQ_RS_PH(uint64 instruction)
11273 {
11274 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11275 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11276 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11277
11278 std::string rd = GPR(copy(rd_value));
11279 std::string rs = GPR(copy(rs_value));
11280 std::string rt = GPR(copy(rt_value));
11281
11282 return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
11283 }
11284
11285
11286 /*
11287 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11288 *
11289 * 3 2 1
11290 * 10987654321098765432109876543210
11291 * 001000 00010001101
11292 * rt -----
11293 * rs -----
11294 * rd -----
11295 */
11296 std::string NMD::MULQ_RS_W(uint64 instruction)
11297 {
11298 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11299 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11300 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11301
11302 std::string rd = GPR(copy(rd_value));
11303 std::string rs = GPR(copy(rs_value));
11304 std::string rt = GPR(copy(rt_value));
11305
11306 return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
11307 }
11308
11309
11310 /*
11311 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11312 *
11313 * 3 2 1
11314 * 10987654321098765432109876543210
11315 * 001000 00010001101
11316 * rt -----
11317 * rs -----
11318 * rd -----
11319 */
11320 std::string NMD::MULQ_S_PH(uint64 instruction)
11321 {
11322 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11323 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11324 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11325
11326 std::string rd = GPR(copy(rd_value));
11327 std::string rs = GPR(copy(rs_value));
11328 std::string rt = GPR(copy(rt_value));
11329
11330 return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
11331 }
11332
11333
11334 /*
11335 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11336 *
11337 * 3 2 1
11338 * 10987654321098765432109876543210
11339 * 001000 00010001101
11340 * rt -----
11341 * rs -----
11342 * rd -----
11343 */
11344 std::string NMD::MULQ_S_W(uint64 instruction)
11345 {
11346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11347 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11348 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11349
11350 std::string rd = GPR(copy(rd_value));
11351 std::string rs = GPR(copy(rs_value));
11352 std::string rt = GPR(copy(rt_value));
11353
11354 return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11355 }
11356
11357
11358 /*
11359 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11360 *
11361 * 3 2 1
11362 * 10987654321098765432109876543210
11363 * 001000 00010001101
11364 * rt -----
11365 * rs -----
11366 * rd -----
11367 */
11368 std::string NMD::MULSA_W_PH(uint64 instruction)
11369 {
11370 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11371 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11372 uint64 ac_value = extract_ac_13_12(instruction);
11373
11374 std::string ac = AC(copy(ac_value));
11375 std::string rs = GPR(copy(rs_value));
11376 std::string rt = GPR(copy(rt_value));
11377
11378 return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11379 }
11380
11381
11382 /*
11383 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11384 *
11385 * 3 2 1
11386 * 10987654321098765432109876543210
11387 * 001000 00010001101
11388 * rt -----
11389 * rs -----
11390 * rd -----
11391 */
11392 std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
11393 {
11394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11395 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11396 uint64 ac_value = extract_ac_13_12(instruction);
11397
11398 std::string ac = AC(copy(ac_value));
11399 std::string rs = GPR(copy(rs_value));
11400 std::string rt = GPR(copy(rt_value));
11401
11402 return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11403 }
11404
11405
11406 /*
11407 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11408 *
11409 * 3 2 1
11410 * 10987654321098765432109876543210
11411 * 001000 00010001101
11412 * rt -----
11413 * rs -----
11414 * rd -----
11415 */
11416 std::string NMD::MULT_DSP_(uint64 instruction)
11417 {
11418 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11419 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11420 uint64 ac_value = extract_ac_13_12(instruction);
11421
11422 std::string ac = AC(copy(ac_value));
11423 std::string rs = GPR(copy(rs_value));
11424 std::string rt = GPR(copy(rt_value));
11425
11426 return img::format("MULT %s, %s, %s", ac, rs, rt);
11427 }
11428
11429
11430 /*
11431 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11432 *
11433 * 3 2 1
11434 * 10987654321098765432109876543210
11435 * 001000 00010001101
11436 * rt -----
11437 * rs -----
11438 * rd -----
11439 */
11440 std::string NMD::MULTU_DSP_(uint64 instruction)
11441 {
11442 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11443 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11444 uint64 ac_value = extract_ac_13_12(instruction);
11445
11446 std::string ac = AC(copy(ac_value));
11447 std::string rs = GPR(copy(rs_value));
11448 std::string rt = GPR(copy(rt_value));
11449
11450 return img::format("MULTU %s, %s, %s", ac, rs, rt);
11451 }
11452
11453
11454 /*
11455 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11456 *
11457 * 3 2 1
11458 * 10987654321098765432109876543210
11459 * 001000 00010001101
11460 * rt -----
11461 * rs -----
11462 * rd -----
11463 */
11464 std::string NMD::MULU(uint64 instruction)
11465 {
11466 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11467 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11468 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11469
11470 std::string rd = GPR(copy(rd_value));
11471 std::string rs = GPR(copy(rs_value));
11472 std::string rt = GPR(copy(rt_value));
11473
11474 return img::format("MULU %s, %s, %s", rd, rs, rt);
11475 }
11476
11477
11478 /*
11479 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11480 *
11481 * 3 2 1
11482 * 10987654321098765432109876543210
11483 * 001000 00010001101
11484 * rt -----
11485 * rs -----
11486 * rd -----
11487 */
11488 std::string NMD::NEG_D(uint64 instruction)
11489 {
11490 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11491 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11492
11493 std::string ft = FPR(copy(ft_value));
11494 std::string fs = FPR(copy(fs_value));
11495
11496 return img::format("NEG.D %s, %s", ft, fs);
11497 }
11498
11499
11500 /*
11501 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11502 *
11503 * 3 2 1
11504 * 10987654321098765432109876543210
11505 * 001000 00010001101
11506 * rt -----
11507 * rs -----
11508 * rd -----
11509 */
11510 std::string NMD::NEG_S(uint64 instruction)
11511 {
11512 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11513 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11514
11515 std::string ft = FPR(copy(ft_value));
11516 std::string fs = FPR(copy(fs_value));
11517
11518 return img::format("NEG.S %s, %s", ft, fs);
11519 }
11520
11521
11522 /*
11523 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11524 *
11525 * 3 2 1
11526 * 10987654321098765432109876543210
11527 * 001000 00010001101
11528 * rt -----
11529 * rs -----
11530 * rd -----
11531 */
11532 std::string NMD::NOP_16_(uint64 instruction)
11533 {
11534 (void)instruction;
11535
11536 return "NOP ";
11537 }
11538
11539
11540 /*
11541 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11542 *
11543 * 3 2 1
11544 * 10987654321098765432109876543210
11545 * 001000 00010001101
11546 * rt -----
11547 * rs -----
11548 * rd -----
11549 */
11550 std::string NMD::NOP_32_(uint64 instruction)
11551 {
11552 (void)instruction;
11553
11554 return "NOP ";
11555 }
11556
11557
11558 /*
11559 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11560 *
11561 * 3 2 1
11562 * 10987654321098765432109876543210
11563 * 001000 00010001101
11564 * rt -----
11565 * rs -----
11566 * rd -----
11567 */
11568 std::string NMD::NOR(uint64 instruction)
11569 {
11570 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11571 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11572 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11573
11574 std::string rd = GPR(copy(rd_value));
11575 std::string rs = GPR(copy(rs_value));
11576 std::string rt = GPR(copy(rt_value));
11577
11578 return img::format("NOR %s, %s, %s", rd, rs, rt);
11579 }
11580
11581
11582 /*
11583 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11584 *
11585 * 3 2 1
11586 * 10987654321098765432109876543210
11587 * 001000 00010001101
11588 * rt -----
11589 * rs -----
11590 * rd -----
11591 */
11592 std::string NMD::NOT_16_(uint64 instruction)
11593 {
11594 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11595 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11596
11597 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
11598 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
11599
11600 return img::format("NOT %s, %s", rt3, rs3);
11601 }
11602
11603
11604 /*
11605 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11606 *
11607 * 3 2 1
11608 * 10987654321098765432109876543210
11609 * 001000 00010001101
11610 * rt -----
11611 * rs -----
11612 * rd -----
11613 */
11614 std::string NMD::OR_16_(uint64 instruction)
11615 {
11616 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11617 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11618
11619 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
11620 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
11621
11622 return img::format("OR %s, %s", rs3, rt3);
11623 }
11624
11625
11626 /*
11627 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11628 *
11629 * 3 2 1
11630 * 10987654321098765432109876543210
11631 * 001000 00010001101
11632 * rt -----
11633 * rs -----
11634 * rd -----
11635 */
11636 std::string NMD::OR_32_(uint64 instruction)
11637 {
11638 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11639 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11640 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11641
11642 std::string rd = GPR(copy(rd_value));
11643 std::string rs = GPR(copy(rs_value));
11644 std::string rt = GPR(copy(rt_value));
11645
11646 return img::format("OR %s, %s, %s", rd, rs, rt);
11647 }
11648
11649
11650 /*
11651 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11652 *
11653 * 3 2 1
11654 * 10987654321098765432109876543210
11655 * 001000 00010001101
11656 * rt -----
11657 * rs -----
11658 * rd -----
11659 */
11660 std::string NMD::ORI(uint64 instruction)
11661 {
11662 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11663 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11664 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11665
11666 std::string rt = GPR(copy(rt_value));
11667 std::string rs = GPR(copy(rs_value));
11668 std::string u = IMMEDIATE(copy(u_value));
11669
11670 return img::format("ORI %s, %s, %s", rt, rs, u);
11671 }
11672
11673
11674 /*
11675 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11676 *
11677 * 3 2 1
11678 * 10987654321098765432109876543210
11679 * 001000 00010001101
11680 * rt -----
11681 * rs -----
11682 * rd -----
11683 */
11684 std::string NMD::PACKRL_PH(uint64 instruction)
11685 {
11686 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11687 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11688 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11689
11690 std::string rd = GPR(copy(rd_value));
11691 std::string rs = GPR(copy(rs_value));
11692 std::string rt = GPR(copy(rt_value));
11693
11694 return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11695 }
11696
11697
11698 /*
11699 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11700 *
11701 * 3 2 1
11702 * 10987654321098765432109876543210
11703 * 001000 00010001101
11704 * rt -----
11705 * rs -----
11706 * rd -----
11707 */
11708 std::string NMD::PAUSE(uint64 instruction)
11709 {
11710 (void)instruction;
11711
11712 return "PAUSE ";
11713 }
11714
11715
11716 /*
11717 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11718 *
11719 * 3 2 1
11720 * 10987654321098765432109876543210
11721 * 001000 00010001101
11722 * rt -----
11723 * rs -----
11724 * rd -----
11725 */
11726 std::string NMD::PICK_PH(uint64 instruction)
11727 {
11728 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11729 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11730 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11731
11732 std::string rd = GPR(copy(rd_value));
11733 std::string rs = GPR(copy(rs_value));
11734 std::string rt = GPR(copy(rt_value));
11735
11736 return img::format("PICK.PH %s, %s, %s", rd, rs, rt);
11737 }
11738
11739
11740 /*
11741 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11742 *
11743 * 3 2 1
11744 * 10987654321098765432109876543210
11745 * 001000 00010001101
11746 * rt -----
11747 * rs -----
11748 * rd -----
11749 */
11750 std::string NMD::PICK_QB(uint64 instruction)
11751 {
11752 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11753 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11754 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11755
11756 std::string rd = GPR(copy(rd_value));
11757 std::string rs = GPR(copy(rs_value));
11758 std::string rt = GPR(copy(rt_value));
11759
11760 return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
11761 }
11762
11763
11764 /*
11765 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11766 *
11767 * 3 2 1
11768 * 10987654321098765432109876543210
11769 * 001000 00010001101
11770 * rt -----
11771 * rs -----
11772 * rd -----
11773 */
11774 std::string NMD::PRECEQ_W_PHL(uint64 instruction)
11775 {
11776 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11777 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11778
11779 std::string rt = GPR(copy(rt_value));
11780 std::string rs = GPR(copy(rs_value));
11781
11782 return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
11783 }
11784
11785
11786 /*
11787 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11788 *
11789 * 3 2 1
11790 * 10987654321098765432109876543210
11791 * 001000 00010001101
11792 * rt -----
11793 * rs -----
11794 * rd -----
11795 */
11796 std::string NMD::PRECEQ_W_PHR(uint64 instruction)
11797 {
11798 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11799 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11800
11801 std::string rt = GPR(copy(rt_value));
11802 std::string rs = GPR(copy(rs_value));
11803
11804 return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
11805 }
11806
11807
11808 /*
11809 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11810 *
11811 * 3 2 1
11812 * 10987654321098765432109876543210
11813 * 001000 00010001101
11814 * rt -----
11815 * rs -----
11816 * rd -----
11817 */
11818 std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
11819 {
11820 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11821 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11822
11823 std::string rt = GPR(copy(rt_value));
11824 std::string rs = GPR(copy(rs_value));
11825
11826 return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11827 }
11828
11829
11830 /*
11831 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11832 *
11833 * 3 2 1
11834 * 10987654321098765432109876543210
11835 * 001000 00010001101
11836 * rt -----
11837 * rs -----
11838 * rd -----
11839 */
11840 std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
11841 {
11842 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11843 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11844
11845 std::string rt = GPR(copy(rt_value));
11846 std::string rs = GPR(copy(rs_value));
11847
11848 return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
11849 }
11850
11851
11852 /*
11853 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11854 *
11855 * 3 2 1
11856 * 10987654321098765432109876543210
11857 * 001000 00010001101
11858 * rt -----
11859 * rs -----
11860 * rd -----
11861 */
11862 std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
11863 {
11864 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11865 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11866
11867 std::string rt = GPR(copy(rt_value));
11868 std::string rs = GPR(copy(rs_value));
11869
11870 return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11871 }
11872
11873
11874 /*
11875 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11876 *
11877 * 3 2 1
11878 * 10987654321098765432109876543210
11879 * 001000 00010001101
11880 * rt -----
11881 * rs -----
11882 * rd -----
11883 */
11884 std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
11885 {
11886 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11887 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11888
11889 std::string rt = GPR(copy(rt_value));
11890 std::string rs = GPR(copy(rs_value));
11891
11892 return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
11893 }
11894
11895
11896 /*
11897 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11898 *
11899 * 3 2 1
11900 * 10987654321098765432109876543210
11901 * 001000 00010001101
11902 * rt -----
11903 * rs -----
11904 * rd -----
11905 */
11906 std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
11907 {
11908 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11909 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11910
11911 std::string rt = GPR(copy(rt_value));
11912 std::string rs = GPR(copy(rs_value));
11913
11914 return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
11915 }
11916
11917
11918 /*
11919 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11920 *
11921 * 3 2 1
11922 * 10987654321098765432109876543210
11923 * 001000 00010001101
11924 * rt -----
11925 * rs -----
11926 * rd -----
11927 */
11928 std::string NMD::PRECEU_PH_QBL(uint64 instruction)
11929 {
11930 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11931 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11932
11933 std::string rt = GPR(copy(rt_value));
11934 std::string rs = GPR(copy(rs_value));
11935
11936 return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
11937 }
11938
11939
11940 /*
11941 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11942 *
11943 * 3 2 1
11944 * 10987654321098765432109876543210
11945 * 001000 00010001101
11946 * rt -----
11947 * rs -----
11948 * rd -----
11949 */
11950 std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
11951 {
11952 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11953 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11954
11955 std::string rt = GPR(copy(rt_value));
11956 std::string rs = GPR(copy(rs_value));
11957
11958 return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
11959 }
11960
11961
11962 /*
11963 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11964 *
11965 * 3 2 1
11966 * 10987654321098765432109876543210
11967 * 001000 00010001101
11968 * rt -----
11969 * rs -----
11970 * rd -----
11971 */
11972 std::string NMD::PRECEU_PH_QBR(uint64 instruction)
11973 {
11974 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11975 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11976
11977 std::string rt = GPR(copy(rt_value));
11978 std::string rs = GPR(copy(rs_value));
11979
11980 return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
11981 }
11982
11983
11984 /*
11985 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11986 *
11987 * 3 2 1
11988 * 10987654321098765432109876543210
11989 * 001000 00010001101
11990 * rt -----
11991 * rs -----
11992 * rd -----
11993 */
11994 std::string NMD::PRECR_QB_PH(uint64 instruction)
11995 {
11996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11997 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11998 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11999
12000 std::string rd = GPR(copy(rd_value));
12001 std::string rs = GPR(copy(rs_value));
12002 std::string rt = GPR(copy(rt_value));
12003
12004 return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
12005 }
12006
12007
12008 /*
12009 *
12010 *
12011 * 3 2 1
12012 * 10987654321098765432109876543210
12013 * 001000 x1110000101
12014 * rt -----
12015 * rs -----
12016 * rd -----
12017 */
12018 std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
12019 {
12020 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12021 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12022 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12023
12024 std::string rt = GPR(copy(rt_value));
12025 std::string rs = GPR(copy(rs_value));
12026 std::string sa = IMMEDIATE(copy(sa_value));
12027
12028 return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
12029 }
12030
12031
12032 /*
12033 *
12034 *
12035 * 3 2 1
12036 * 10987654321098765432109876543210
12037 * 001000 x1110000101
12038 * rt -----
12039 * rs -----
12040 * rd -----
12041 */
12042 std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
12043 {
12044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12045 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12046 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12047
12048 std::string rt = GPR(copy(rt_value));
12049 std::string rs = GPR(copy(rs_value));
12050 std::string sa = IMMEDIATE(copy(sa_value));
12051
12052 return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
12053 }
12054
12055
12056 /*
12057 *
12058 *
12059 * 3 2 1
12060 * 10987654321098765432109876543210
12061 * 001000 x1110000101
12062 * rt -----
12063 * rs -----
12064 * rd -----
12065 */
12066 std::string NMD::PRECRQ_PH_W(uint64 instruction)
12067 {
12068 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12069 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12070 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12071
12072 std::string rd = GPR(copy(rd_value));
12073 std::string rs = GPR(copy(rs_value));
12074 std::string rt = GPR(copy(rt_value));
12075
12076 return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
12077 }
12078
12079
12080 /*
12081 *
12082 *
12083 * 3 2 1
12084 * 10987654321098765432109876543210
12085 * 001000 x1110000101
12086 * rt -----
12087 * rs -----
12088 * rd -----
12089 */
12090 std::string NMD::PRECRQ_QB_PH(uint64 instruction)
12091 {
12092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12093 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12094 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12095
12096 std::string rd = GPR(copy(rd_value));
12097 std::string rs = GPR(copy(rs_value));
12098 std::string rt = GPR(copy(rt_value));
12099
12100 return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
12101 }
12102
12103
12104 /*
12105 *
12106 *
12107 * 3 2 1
12108 * 10987654321098765432109876543210
12109 * 001000 x1110000101
12110 * rt -----
12111 * rs -----
12112 * rd -----
12113 */
12114 std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
12115 {
12116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12117 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12118 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12119
12120 std::string rd = GPR(copy(rd_value));
12121 std::string rs = GPR(copy(rs_value));
12122 std::string rt = GPR(copy(rt_value));
12123
12124 return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
12125 }
12126
12127
12128 /*
12129 *
12130 *
12131 * 3 2 1
12132 * 10987654321098765432109876543210
12133 * 001000 x1110000101
12134 * rt -----
12135 * rs -----
12136 * rd -----
12137 */
12138 std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
12139 {
12140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12141 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12142 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12143
12144 std::string rd = GPR(copy(rd_value));
12145 std::string rs = GPR(copy(rs_value));
12146 std::string rt = GPR(copy(rt_value));
12147
12148 return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
12149 }
12150
12151
12152 /*
12153 *
12154 *
12155 * 3 2 1
12156 * 10987654321098765432109876543210
12157 * 001000 x1110000101
12158 * rt -----
12159 * rs -----
12160 * rd -----
12161 */
12162 std::string NMD::PREF_S9_(uint64 instruction)
12163 {
12164 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12165 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12166 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12167
12168 std::string hint = IMMEDIATE(copy(hint_value));
12169 std::string s = IMMEDIATE(copy(s_value));
12170 std::string rs = GPR(copy(rs_value));
12171
12172 return img::format("PREF %s, %s(%s)", hint, s, rs);
12173 }
12174
12175
12176 /*
12177 *
12178 *
12179 * 3 2 1
12180 * 10987654321098765432109876543210
12181 * 001000 x1110000101
12182 * rt -----
12183 * rs -----
12184 * rd -----
12185 */
12186 std::string NMD::PREF_U12_(uint64 instruction)
12187 {
12188 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12190 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12191
12192 std::string hint = IMMEDIATE(copy(hint_value));
12193 std::string u = IMMEDIATE(copy(u_value));
12194 std::string rs = GPR(copy(rs_value));
12195
12196 return img::format("PREF %s, %s(%s)", hint, u, rs);
12197 }
12198
12199
12200 /*
12201 *
12202 *
12203 * 3 2 1
12204 * 10987654321098765432109876543210
12205 * 001000 x1110000101
12206 * rt -----
12207 * rs -----
12208 * rd -----
12209 */
12210 std::string NMD::PREFE(uint64 instruction)
12211 {
12212 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12214 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12215
12216 std::string hint = IMMEDIATE(copy(hint_value));
12217 std::string s = IMMEDIATE(copy(s_value));
12218 std::string rs = GPR(copy(rs_value));
12219
12220 return img::format("PREFE %s, %s(%s)", hint, s, rs);
12221 }
12222
12223
12224 /*
12225 *
12226 *
12227 * 3 2 1
12228 * 10987654321098765432109876543210
12229 * 001000 x1110000101
12230 * rt -----
12231 * rs -----
12232 * rd -----
12233 */
12234 std::string NMD::PREPEND(uint64 instruction)
12235 {
12236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12238 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12239
12240 std::string rt = GPR(copy(rt_value));
12241 std::string rs = GPR(copy(rs_value));
12242 std::string sa = IMMEDIATE(copy(sa_value));
12243
12244 return img::format("PREPEND %s, %s, %s", rt, rs, sa);
12245 }
12246
12247
12248 /*
12249 *
12250 *
12251 * 3 2 1
12252 * 10987654321098765432109876543210
12253 * 001000 x1110000101
12254 * rt -----
12255 * rs -----
12256 * rd -----
12257 */
12258 std::string NMD::RADDU_W_QB(uint64 instruction)
12259 {
12260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12261 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12262
12263 std::string rt = GPR(copy(rt_value));
12264 std::string rs = GPR(copy(rs_value));
12265
12266 return img::format("RADDU.W.QB %s, %s", rt, rs);
12267 }
12268
12269
12270 /*
12271 *
12272 *
12273 * 3 2 1
12274 * 10987654321098765432109876543210
12275 * 001000 x1110000101
12276 * rt -----
12277 * rs -----
12278 * rd -----
12279 */
12280 std::string NMD::RDDSP(uint64 instruction)
12281 {
12282 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12283 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
12284
12285 std::string rt = GPR(copy(rt_value));
12286 std::string mask = IMMEDIATE(copy(mask_value));
12287
12288 return img::format("RDDSP %s, %s", rt, mask);
12289 }
12290
12291
12292 /*
12293 *
12294 *
12295 * 3 2 1
12296 * 10987654321098765432109876543210
12297 * 001000 x1110000101
12298 * rt -----
12299 * rs -----
12300 * rd -----
12301 */
12302 std::string NMD::RDHWR(uint64 instruction)
12303 {
12304 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12305 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
12306 uint64 sel_value = extract_sel_13_12_11(instruction);
12307
12308 std::string rt = GPR(copy(rt_value));
12309 std::string hs = CPR(copy(hs_value));
12310 std::string sel = IMMEDIATE(copy(sel_value));
12311
12312 return img::format("RDHWR %s, %s, %s", rt, hs, sel);
12313 }
12314
12315
12316 /*
12317 *
12318 *
12319 * 3 2 1
12320 * 10987654321098765432109876543210
12321 * 001000 x1110000101
12322 * rt -----
12323 * rs -----
12324 * rd -----
12325 */
12326 std::string NMD::RDPGPR(uint64 instruction)
12327 {
12328 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12329 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12330
12331 std::string rt = GPR(copy(rt_value));
12332 std::string rs = GPR(copy(rs_value));
12333
12334 return img::format("RDPGPR %s, %s", rt, rs);
12335 }
12336
12337
12338 /*
12339 *
12340 *
12341 * 3 2 1
12342 * 10987654321098765432109876543210
12343 * 001000 x1110000101
12344 * rt -----
12345 * rs -----
12346 * rd -----
12347 */
12348 std::string NMD::RECIP_D(uint64 instruction)
12349 {
12350 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12351 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12352
12353 std::string ft = FPR(copy(ft_value));
12354 std::string fs = FPR(copy(fs_value));
12355
12356 return img::format("RECIP.D %s, %s", ft, fs);
12357 }
12358
12359
12360 /*
12361 *
12362 *
12363 * 3 2 1
12364 * 10987654321098765432109876543210
12365 * 001000 x1110000101
12366 * rt -----
12367 * rs -----
12368 * rd -----
12369 */
12370 std::string NMD::RECIP_S(uint64 instruction)
12371 {
12372 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12373 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12374
12375 std::string ft = FPR(copy(ft_value));
12376 std::string fs = FPR(copy(fs_value));
12377
12378 return img::format("RECIP.S %s, %s", ft, fs);
12379 }
12380
12381
12382 /*
12383 *
12384 *
12385 * 3 2 1
12386 * 10987654321098765432109876543210
12387 * 001000 x1110000101
12388 * rt -----
12389 * rs -----
12390 * rd -----
12391 */
12392 std::string NMD::REPL_PH(uint64 instruction)
12393 {
12394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12395 int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
12396
12397 std::string rt = GPR(copy(rt_value));
12398 std::string s = IMMEDIATE(copy(s_value));
12399
12400 return img::format("REPL.PH %s, %s", rt, s);
12401 }
12402
12403
12404 /*
12405 *
12406 *
12407 * 3 2 1
12408 * 10987654321098765432109876543210
12409 * 001000 x1110000101
12410 * rt -----
12411 * rs -----
12412 * rd -----
12413 */
12414 std::string NMD::REPL_QB(uint64 instruction)
12415 {
12416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12417 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12418
12419 std::string rt = GPR(copy(rt_value));
12420 std::string u = IMMEDIATE(copy(u_value));
12421
12422 return img::format("REPL.QB %s, %s", rt, u);
12423 }
12424
12425
12426 /*
12427 *
12428 *
12429 * 3 2 1
12430 * 10987654321098765432109876543210
12431 * 001000 x1110000101
12432 * rt -----
12433 * rs -----
12434 * rd -----
12435 */
12436 std::string NMD::REPLV_PH(uint64 instruction)
12437 {
12438 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12439 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12440
12441 std::string rt = GPR(copy(rt_value));
12442 std::string rs = GPR(copy(rs_value));
12443
12444 return img::format("REPLV.PH %s, %s", rt, rs);
12445 }
12446
12447
12448 /*
12449 *
12450 *
12451 * 3 2 1
12452 * 10987654321098765432109876543210
12453 * 001000 x1110000101
12454 * rt -----
12455 * rs -----
12456 * rd -----
12457 */
12458 std::string NMD::REPLV_QB(uint64 instruction)
12459 {
12460 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12462
12463 std::string rt = GPR(copy(rt_value));
12464 std::string rs = GPR(copy(rs_value));
12465
12466 return img::format("REPLV.QB %s, %s", rt, rs);
12467 }
12468
12469
12470 /*
12471 *
12472 *
12473 * 3 2 1
12474 * 10987654321098765432109876543210
12475 * 001000 x1110000101
12476 * rt -----
12477 * rs -----
12478 * rd -----
12479 */
12480 std::string NMD::RESTORE_32_(uint64 instruction)
12481 {
12482 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12483 uint64 count_value = extract_count_19_18_17_16(instruction);
12484 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12485 uint64 gp_value = extract_gp_2(instruction);
12486
12487 std::string u = IMMEDIATE(copy(u_value));
12488 return img::format("RESTORE %s%s", u,
12489 save_restore_list(rt_value, count_value, gp_value));
12490 }
12491
12492
12493 /*
12494 *
12495 *
12496 * 3 2 1
12497 * 10987654321098765432109876543210
12498 * 001000 x1110000101
12499 * rt -----
12500 * rs -----
12501 * rd -----
12502 */
12503 std::string NMD::RESTORE_JRC_16_(uint64 instruction)
12504 {
12505 uint64 rt1_value = extract_rtl_11(instruction);
12506 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12507 uint64 count_value = extract_count_3_2_1_0(instruction);
12508
12509 std::string u = IMMEDIATE(copy(u_value));
12510 return img::format("RESTORE.JRC %s%s", u,
12511 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12512 }
12513
12514
12515 /*
12516 *
12517 *
12518 * 3 2 1
12519 * 10987654321098765432109876543210
12520 * 001000 x1110000101
12521 * rt -----
12522 * rs -----
12523 * rd -----
12524 */
12525 std::string NMD::RESTORE_JRC_32_(uint64 instruction)
12526 {
12527 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12528 uint64 count_value = extract_count_19_18_17_16(instruction);
12529 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12530 uint64 gp_value = extract_gp_2(instruction);
12531
12532 std::string u = IMMEDIATE(copy(u_value));
12533 return img::format("RESTORE.JRC %s%s", u,
12534 save_restore_list(rt_value, count_value, gp_value));
12535 }
12536
12537
12538 /*
12539 *
12540 *
12541 * 3 2 1
12542 * 10987654321098765432109876543210
12543 * 001000 x1110000101
12544 * rt -----
12545 * rs -----
12546 * rd -----
12547 */
12548 std::string NMD::RESTOREF(uint64 instruction)
12549 {
12550 uint64 count_value = extract_count_19_18_17_16(instruction);
12551 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12552
12553 std::string u = IMMEDIATE(copy(u_value));
12554 std::string count = IMMEDIATE(copy(count_value));
12555
12556 return img::format("RESTOREF %s, %s", u, count);
12557 }
12558
12559
12560 /*
12561 *
12562 *
12563 * 3 2 1
12564 * 10987654321098765432109876543210
12565 * 001000 x1110000101
12566 * rt -----
12567 * rs -----
12568 * rd -----
12569 */
12570 std::string NMD::RINT_D(uint64 instruction)
12571 {
12572 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12573 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12574
12575 std::string ft = FPR(copy(ft_value));
12576 std::string fs = FPR(copy(fs_value));
12577
12578 return img::format("RINT.D %s, %s", ft, fs);
12579 }
12580
12581
12582 /*
12583 *
12584 *
12585 * 3 2 1
12586 * 10987654321098765432109876543210
12587 * 001000 x1110000101
12588 * rt -----
12589 * rs -----
12590 * rd -----
12591 */
12592 std::string NMD::RINT_S(uint64 instruction)
12593 {
12594 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12595 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12596
12597 std::string ft = FPR(copy(ft_value));
12598 std::string fs = FPR(copy(fs_value));
12599
12600 return img::format("RINT.S %s, %s", ft, fs);
12601 }
12602
12603
12604 /*
12605 *
12606 *
12607 * 3 2 1
12608 * 10987654321098765432109876543210
12609 * 001000 x1110000101
12610 * rt -----
12611 * rs -----
12612 * rd -----
12613 */
12614 std::string NMD::ROTR(uint64 instruction)
12615 {
12616 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12617 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12618 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12619
12620 std::string rt = GPR(copy(rt_value));
12621 std::string rs = GPR(copy(rs_value));
12622 std::string shift = IMMEDIATE(copy(shift_value));
12623
12624 return img::format("ROTR %s, %s, %s", rt, rs, shift);
12625 }
12626
12627
12628 /*
12629 *
12630 *
12631 * 3 2 1
12632 * 10987654321098765432109876543210
12633 * 001000 x1110000101
12634 * rt -----
12635 * rs -----
12636 * rd -----
12637 */
12638 std::string NMD::ROTRV(uint64 instruction)
12639 {
12640 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12641 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12642 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12643
12644 std::string rd = GPR(copy(rd_value));
12645 std::string rs = GPR(copy(rs_value));
12646 std::string rt = GPR(copy(rt_value));
12647
12648 return img::format("ROTRV %s, %s, %s", rd, rs, rt);
12649 }
12650
12651
12652 /*
12653 *
12654 *
12655 * 3 2 1
12656 * 10987654321098765432109876543210
12657 * 001000 x1110000101
12658 * rt -----
12659 * rs -----
12660 * rd -----
12661 */
12662 std::string NMD::ROTX(uint64 instruction)
12663 {
12664 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12665 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12666 uint64 shiftx_value = extract_shiftx_10_9_8_7__s1(instruction);
12667 uint64 stripe_value = extract_stripe_6(instruction);
12668 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12669
12670 std::string rt = GPR(copy(rt_value));
12671 std::string rs = GPR(copy(rs_value));
12672 std::string shift = IMMEDIATE(copy(shift_value));
12673 std::string shiftx = IMMEDIATE(copy(shiftx_value));
12674 std::string stripe = IMMEDIATE(copy(stripe_value));
12675
12676 return img::format("ROTX %s, %s, %s, %s, %s",
12677 rt, rs, shift, shiftx, stripe);
12678 }
12679
12680
12681 /*
12682 *
12683 *
12684 * 3 2 1
12685 * 10987654321098765432109876543210
12686 * 001000 x1110000101
12687 * rt -----
12688 * rs -----
12689 * rd -----
12690 */
12691 std::string NMD::ROUND_L_D(uint64 instruction)
12692 {
12693 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12694 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12695
12696 std::string ft = FPR(copy(ft_value));
12697 std::string fs = FPR(copy(fs_value));
12698
12699 return img::format("ROUND.L.D %s, %s", ft, fs);
12700 }
12701
12702
12703 /*
12704 *
12705 *
12706 * 3 2 1
12707 * 10987654321098765432109876543210
12708 * 001000 x1110000101
12709 * rt -----
12710 * rs -----
12711 * rd -----
12712 */
12713 std::string NMD::ROUND_L_S(uint64 instruction)
12714 {
12715 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12716 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12717
12718 std::string ft = FPR(copy(ft_value));
12719 std::string fs = FPR(copy(fs_value));
12720
12721 return img::format("ROUND.L.S %s, %s", ft, fs);
12722 }
12723
12724
12725 /*
12726 *
12727 *
12728 * 3 2 1
12729 * 10987654321098765432109876543210
12730 * 001000 x1110000101
12731 * rt -----
12732 * rs -----
12733 * rd -----
12734 */
12735 std::string NMD::ROUND_W_D(uint64 instruction)
12736 {
12737 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12738 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12739
12740 std::string ft = FPR(copy(ft_value));
12741 std::string fs = FPR(copy(fs_value));
12742
12743 return img::format("ROUND.W.D %s, %s", ft, fs);
12744 }
12745
12746
12747 /*
12748 *
12749 *
12750 * 3 2 1
12751 * 10987654321098765432109876543210
12752 * 001000 x1110000101
12753 * rt -----
12754 * rs -----
12755 * rd -----
12756 */
12757 std::string NMD::ROUND_W_S(uint64 instruction)
12758 {
12759 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12760 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12761
12762 std::string ft = FPR(copy(ft_value));
12763 std::string fs = FPR(copy(fs_value));
12764
12765 return img::format("ROUND.W.S %s, %s", ft, fs);
12766 }
12767
12768
12769 /*
12770 *
12771 *
12772 * 3 2 1
12773 * 10987654321098765432109876543210
12774 * 001000 x1110000101
12775 * rt -----
12776 * rs -----
12777 * rd -----
12778 */
12779 std::string NMD::RSQRT_D(uint64 instruction)
12780 {
12781 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12782 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12783
12784 std::string ft = FPR(copy(ft_value));
12785 std::string fs = FPR(copy(fs_value));
12786
12787 return img::format("RSQRT.D %s, %s", ft, fs);
12788 }
12789
12790
12791 /*
12792 *
12793 *
12794 * 3 2 1
12795 * 10987654321098765432109876543210
12796 * 001000 x1110000101
12797 * rt -----
12798 * rs -----
12799 * rd -----
12800 */
12801 std::string NMD::RSQRT_S(uint64 instruction)
12802 {
12803 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12804 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12805
12806 std::string ft = FPR(copy(ft_value));
12807 std::string fs = FPR(copy(fs_value));
12808
12809 return img::format("RSQRT.S %s, %s", ft, fs);
12810 }
12811
12812
12813 /*
12814 *
12815 *
12816 * 3 2 1
12817 * 10987654321098765432109876543210
12818 * 001000 01001001101
12819 * rt -----
12820 * rs -----
12821 * rd -----
12822 */
12823 std::string NMD::SAVE_16_(uint64 instruction)
12824 {
12825 uint64 rt1_value = extract_rtl_11(instruction);
12826 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12827 uint64 count_value = extract_count_3_2_1_0(instruction);
12828
12829 std::string u = IMMEDIATE(copy(u_value));
12830 return img::format("SAVE %s%s", u,
12831 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12832 }
12833
12834
12835 /*
12836 *
12837 *
12838 * 3 2 1
12839 * 10987654321098765432109876543210
12840 * 001000 01001001101
12841 * rt -----
12842 * rs -----
12843 * rd -----
12844 */
12845 std::string NMD::SAVE_32_(uint64 instruction)
12846 {
12847 uint64 count_value = extract_count_19_18_17_16(instruction);
12848 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12849 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12850 uint64 gp_value = extract_gp_2(instruction);
12851
12852 std::string u = IMMEDIATE(copy(u_value));
12853 return img::format("SAVE %s%s", u,
12854 save_restore_list(rt_value, count_value, gp_value));
12855 }
12856
12857
12858 /*
12859 *
12860 *
12861 * 3 2 1
12862 * 10987654321098765432109876543210
12863 * 001000 01001001101
12864 * rt -----
12865 * rs -----
12866 * rd -----
12867 */
12868 std::string NMD::SAVEF(uint64 instruction)
12869 {
12870 uint64 count_value = extract_count_19_18_17_16(instruction);
12871 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12872
12873 std::string u = IMMEDIATE(copy(u_value));
12874 std::string count = IMMEDIATE(copy(count_value));
12875
12876 return img::format("SAVEF %s, %s", u, count);
12877 }
12878
12879
12880 /*
12881 *
12882 *
12883 * 3 2 1
12884 * 10987654321098765432109876543210
12885 * 001000 01001001101
12886 * rt -----
12887 * rs -----
12888 * rd -----
12889 */
12890 std::string NMD::SB_16_(uint64 instruction)
12891 {
12892 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12893 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12894 uint64 u_value = extract_u_1_0(instruction);
12895
12896 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
12897 std::string u = IMMEDIATE(copy(u_value));
12898 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
12899
12900 return img::format("SB %s, %s(%s)", rtz3, u, rs3);
12901 }
12902
12903
12904 /*
12905 *
12906 *
12907 * 3 2 1
12908 * 10987654321098765432109876543210
12909 * 001000 01001001101
12910 * rt -----
12911 * rs -----
12912 * rd -----
12913 */
12914 std::string NMD::SB_GP_(uint64 instruction)
12915 {
12916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12917 uint64 u_value = extract_u_17_to_0(instruction);
12918
12919 std::string rt = GPR(copy(rt_value));
12920 std::string u = IMMEDIATE(copy(u_value));
12921
12922 return img::format("SB %s, %s($%d)", rt, u, 28);
12923 }
12924
12925
12926 /*
12927 *
12928 *
12929 * 3 2 1
12930 * 10987654321098765432109876543210
12931 * 001000 01001001101
12932 * rt -----
12933 * rs -----
12934 * rd -----
12935 */
12936 std::string NMD::SB_S9_(uint64 instruction)
12937 {
12938 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12939 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12940 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12941
12942 std::string rt = GPR(copy(rt_value));
12943 std::string s = IMMEDIATE(copy(s_value));
12944 std::string rs = GPR(copy(rs_value));
12945
12946 return img::format("SB %s, %s(%s)", rt, s, rs);
12947 }
12948
12949
12950 /*
12951 *
12952 *
12953 * 3 2 1
12954 * 10987654321098765432109876543210
12955 * 001000 01001001101
12956 * rt -----
12957 * rs -----
12958 * rd -----
12959 */
12960 std::string NMD::SB_U12_(uint64 instruction)
12961 {
12962 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12963 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12964 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12965
12966 std::string rt = GPR(copy(rt_value));
12967 std::string u = IMMEDIATE(copy(u_value));
12968 std::string rs = GPR(copy(rs_value));
12969
12970 return img::format("SB %s, %s(%s)", rt, u, rs);
12971 }
12972
12973
12974 /*
12975 *
12976 *
12977 * 3 2 1
12978 * 10987654321098765432109876543210
12979 * 001000 01001001101
12980 * rt -----
12981 * rs -----
12982 * rd -----
12983 */
12984 std::string NMD::SBE(uint64 instruction)
12985 {
12986 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12987 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12988 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12989
12990 std::string rt = GPR(copy(rt_value));
12991 std::string s = IMMEDIATE(copy(s_value));
12992 std::string rs = GPR(copy(rs_value));
12993
12994 return img::format("SBE %s, %s(%s)", rt, s, rs);
12995 }
12996
12997
12998 /*
12999 *
13000 *
13001 * 3 2 1
13002 * 10987654321098765432109876543210
13003 * 001000 01001001101
13004 * rt -----
13005 * rs -----
13006 * rd -----
13007 */
13008 std::string NMD::SBX(uint64 instruction)
13009 {
13010 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13011 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13012 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13013
13014 std::string rd = GPR(copy(rd_value));
13015 std::string rs = GPR(copy(rs_value));
13016 std::string rt = GPR(copy(rt_value));
13017
13018 return img::format("SBX %s, %s(%s)", rd, rs, rt);
13019 }
13020
13021
13022 /*
13023 *
13024 *
13025 * 3 2 1
13026 * 10987654321098765432109876543210
13027 * 001000 01001001101
13028 * rt -----
13029 * rs -----
13030 * rd -----
13031 */
13032 std::string NMD::SC(uint64 instruction)
13033 {
13034 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13035 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13036 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
13037
13038 std::string rt = GPR(copy(rt_value));
13039 std::string s = IMMEDIATE(copy(s_value));
13040 std::string rs = GPR(copy(rs_value));
13041
13042 return img::format("SC %s, %s(%s)", rt, s, rs);
13043 }
13044
13045
13046 /*
13047 *
13048 *
13049 * 3 2 1
13050 * 10987654321098765432109876543210
13051 * 001000 01001001101
13052 * rt -----
13053 * rs -----
13054 * rd -----
13055 */
13056 std::string NMD::SCD(uint64 instruction)
13057 {
13058 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13059 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13060 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
13061
13062 std::string rt = GPR(copy(rt_value));
13063 std::string s = IMMEDIATE(copy(s_value));
13064 std::string rs = GPR(copy(rs_value));
13065
13066 return img::format("SCD %s, %s(%s)", rt, s, rs);
13067 }
13068
13069
13070 /*
13071 *
13072 *
13073 * 3 2 1
13074 * 10987654321098765432109876543210
13075 * 001000 01001001101
13076 * rt -----
13077 * rs -----
13078 * rd -----
13079 */
13080 std::string NMD::SCDP(uint64 instruction)
13081 {
13082 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13083 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13084 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13085
13086 std::string rt = GPR(copy(rt_value));
13087 std::string ru = GPR(copy(ru_value));
13088 std::string rs = GPR(copy(rs_value));
13089
13090 return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
13091 }
13092
13093
13094 /*
13095 *
13096 *
13097 * 3 2 1
13098 * 10987654321098765432109876543210
13099 * 001000 01001001101
13100 * rt -----
13101 * rs -----
13102 * rd -----
13103 */
13104 std::string NMD::SCE(uint64 instruction)
13105 {
13106 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13107 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13108 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
13109
13110 std::string rt = GPR(copy(rt_value));
13111 std::string s = IMMEDIATE(copy(s_value));
13112 std::string rs = GPR(copy(rs_value));
13113
13114 return img::format("SCE %s, %s(%s)", rt, s, rs);
13115 }
13116
13117
13118 /*
13119 *
13120 *
13121 * 3 2 1
13122 * 10987654321098765432109876543210
13123 * 001000 01001001101
13124 * rt -----
13125 * rs -----
13126 * rd -----
13127 */
13128 std::string NMD::SCWP(uint64 instruction)
13129 {
13130 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13131 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13132 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13133
13134 std::string rt = GPR(copy(rt_value));
13135 std::string ru = GPR(copy(ru_value));
13136 std::string rs = GPR(copy(rs_value));
13137
13138 return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
13139 }
13140
13141
13142 /*
13143 *
13144 *
13145 * 3 2 1
13146 * 10987654321098765432109876543210
13147 * 001000 01001001101
13148 * rt -----
13149 * rs -----
13150 * rd -----
13151 */
13152 std::string NMD::SCWPE(uint64 instruction)
13153 {
13154 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13155 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13156 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13157
13158 std::string rt = GPR(copy(rt_value));
13159 std::string ru = GPR(copy(ru_value));
13160 std::string rs = GPR(copy(rs_value));
13161
13162 return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
13163 }
13164
13165
13166 /*
13167 *
13168 *
13169 * 3 2 1
13170 * 10987654321098765432109876543210
13171 * 001000 01001001101
13172 * rt -----
13173 * rs -----
13174 * rd -----
13175 */
13176 std::string NMD::SD_GP_(uint64 instruction)
13177 {
13178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13179 uint64 u_value = extract_u_20_to_3__s3(instruction);
13180
13181 std::string rt = GPR(copy(rt_value));
13182 std::string u = IMMEDIATE(copy(u_value));
13183
13184 return img::format("SD %s, %s($%d)", rt, u, 28);
13185 }
13186
13187
13188 /*
13189 *
13190 *
13191 * 3 2 1
13192 * 10987654321098765432109876543210
13193 * 001000 01001001101
13194 * rt -----
13195 * rs -----
13196 * rd -----
13197 */
13198 std::string NMD::SD_S9_(uint64 instruction)
13199 {
13200 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13201 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13202 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13203
13204 std::string rt = GPR(copy(rt_value));
13205 std::string s = IMMEDIATE(copy(s_value));
13206 std::string rs = GPR(copy(rs_value));
13207
13208 return img::format("SD %s, %s(%s)", rt, s, rs);
13209 }
13210
13211
13212 /*
13213 *
13214 *
13215 * 3 2 1
13216 * 10987654321098765432109876543210
13217 * 001000 01001001101
13218 * rt -----
13219 * rs -----
13220 * rd -----
13221 */
13222 std::string NMD::SD_U12_(uint64 instruction)
13223 {
13224 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13225 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13226 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13227
13228 std::string rt = GPR(copy(rt_value));
13229 std::string u = IMMEDIATE(copy(u_value));
13230 std::string rs = GPR(copy(rs_value));
13231
13232 return img::format("SD %s, %s(%s)", rt, u, rs);
13233 }
13234
13235
13236 /*
13237 *
13238 *
13239 * 3 2 1
13240 * 10987654321098765432109876543210
13241 * 001000 01001001101
13242 * rt -----
13243 * rs -----
13244 * rd -----
13245 */
13246 std::string NMD::SDBBP_16_(uint64 instruction)
13247 {
13248 uint64 code_value = extract_code_2_1_0(instruction);
13249
13250 std::string code = IMMEDIATE(copy(code_value));
13251
13252 return img::format("SDBBP %s", code);
13253 }
13254
13255
13256 /*
13257 *
13258 *
13259 * 3 2 1
13260 * 10987654321098765432109876543210
13261 * 001000 01001001101
13262 * rt -----
13263 * rs -----
13264 * rd -----
13265 */
13266 std::string NMD::SDBBP_32_(uint64 instruction)
13267 {
13268 uint64 code_value = extract_code_18_to_0(instruction);
13269
13270 std::string code = IMMEDIATE(copy(code_value));
13271
13272 return img::format("SDBBP %s", code);
13273 }
13274
13275
13276 /*
13277 *
13278 *
13279 * 3 2 1
13280 * 10987654321098765432109876543210
13281 * 001000 01001001101
13282 * rt -----
13283 * rs -----
13284 * rd -----
13285 */
13286 std::string NMD::SDC1_GP_(uint64 instruction)
13287 {
13288 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13289 uint64 u_value = extract_u_17_to_2__s2(instruction);
13290
13291 std::string ft = FPR(copy(ft_value));
13292 std::string u = IMMEDIATE(copy(u_value));
13293
13294 return img::format("SDC1 %s, %s($%d)", ft, u, 28);
13295 }
13296
13297
13298 /*
13299 *
13300 *
13301 * 3 2 1
13302 * 10987654321098765432109876543210
13303 * 001000 01001001101
13304 * rt -----
13305 * rs -----
13306 * rd -----
13307 */
13308 std::string NMD::SDC1_S9_(uint64 instruction)
13309 {
13310 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13311 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13312 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13313
13314 std::string ft = FPR(copy(ft_value));
13315 std::string s = IMMEDIATE(copy(s_value));
13316 std::string rs = GPR(copy(rs_value));
13317
13318 return img::format("SDC1 %s, %s(%s)", ft, s, rs);
13319 }
13320
13321
13322 /*
13323 *
13324 *
13325 * 3 2 1
13326 * 10987654321098765432109876543210
13327 * 001000 01001001101
13328 * rt -----
13329 * rs -----
13330 * rd -----
13331 */
13332 std::string NMD::SDC1_U12_(uint64 instruction)
13333 {
13334 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13335 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13336 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13337
13338 std::string ft = FPR(copy(ft_value));
13339 std::string u = IMMEDIATE(copy(u_value));
13340 std::string rs = GPR(copy(rs_value));
13341
13342 return img::format("SDC1 %s, %s(%s)", ft, u, rs);
13343 }
13344
13345
13346 /*
13347 *
13348 *
13349 * 3 2 1
13350 * 10987654321098765432109876543210
13351 * 001000 01001001101
13352 * rt -----
13353 * rs -----
13354 * rd -----
13355 */
13356 std::string NMD::SDC1X(uint64 instruction)
13357 {
13358 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13359 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13360 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13361
13362 std::string ft = FPR(copy(ft_value));
13363 std::string rs = GPR(copy(rs_value));
13364 std::string rt = GPR(copy(rt_value));
13365
13366 return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
13367 }
13368
13369
13370 /*
13371 *
13372 *
13373 * 3 2 1
13374 * 10987654321098765432109876543210
13375 * 001000 01001001101
13376 * rt -----
13377 * rs -----
13378 * rd -----
13379 */
13380 std::string NMD::SDC1XS(uint64 instruction)
13381 {
13382 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13383 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13384 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13385
13386 std::string ft = FPR(copy(ft_value));
13387 std::string rs = GPR(copy(rs_value));
13388 std::string rt = GPR(copy(rt_value));
13389
13390 return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
13391 }
13392
13393
13394 /*
13395 *
13396 *
13397 * 3 2 1
13398 * 10987654321098765432109876543210
13399 * 001000 01001001101
13400 * rt -----
13401 * rs -----
13402 * rd -----
13403 */
13404 std::string NMD::SDC2(uint64 instruction)
13405 {
13406 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
13407 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13408 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13409
13410 std::string cs = CPR(copy(cs_value));
13411 std::string s = IMMEDIATE(copy(s_value));
13412 std::string rs = GPR(copy(rs_value));
13413
13414 return img::format("SDC2 %s, %s(%s)", cs, s, rs);
13415 }
13416
13417
13418 /*
13419 *
13420 *
13421 * 3 2 1
13422 * 10987654321098765432109876543210
13423 * 001000 01001001101
13424 * rt -----
13425 * rs -----
13426 * rd -----
13427 */
13428 std::string NMD::SDM(uint64 instruction)
13429 {
13430 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13431 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13432 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13433 uint64 count3_value = extract_count3_14_13_12(instruction);
13434
13435 std::string rt = GPR(copy(rt_value));
13436 std::string s = IMMEDIATE(copy(s_value));
13437 std::string rs = GPR(copy(rs_value));
13438 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
13439
13440 return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
13441 }
13442
13443
13444 /*
13445 *
13446 *
13447 * 3 2 1
13448 * 10987654321098765432109876543210
13449 * 001000 01001001101
13450 * rt -----
13451 * rs -----
13452 * rd -----
13453 */
13454 std::string NMD::SDPC_48_(uint64 instruction)
13455 {
13456 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13457 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
13458
13459 std::string rt = GPR(copy(rt_value));
13460 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
13461
13462 return img::format("SDPC %s, %s", rt, s);
13463 }
13464
13465
13466 /*
13467 *
13468 *
13469 * 3 2 1
13470 * 10987654321098765432109876543210
13471 * 001000 01001001101
13472 * rt -----
13473 * rs -----
13474 * rd -----
13475 */
13476 std::string NMD::SDXS(uint64 instruction)
13477 {
13478 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13479 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13480 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13481
13482 std::string rd = GPR(copy(rd_value));
13483 std::string rs = GPR(copy(rs_value));
13484 std::string rt = GPR(copy(rt_value));
13485
13486 return img::format("SDXS %s, %s(%s)", rd, rs, rt);
13487 }
13488
13489
13490 /*
13491 *
13492 *
13493 * 3 2 1
13494 * 10987654321098765432109876543210
13495 * 001000 01001001101
13496 * rt -----
13497 * rs -----
13498 * rd -----
13499 */
13500 std::string NMD::SDX(uint64 instruction)
13501 {
13502 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13503 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13504 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13505
13506 std::string rd = GPR(copy(rd_value));
13507 std::string rs = GPR(copy(rs_value));
13508 std::string rt = GPR(copy(rt_value));
13509
13510 return img::format("SDX %s, %s(%s)", rd, rs, rt);
13511 }
13512
13513
13514 /*
13515 *
13516 *
13517 * 3 2 1
13518 * 10987654321098765432109876543210
13519 * 001000 01001001101
13520 * rt -----
13521 * rs -----
13522 * rd -----
13523 */
13524 std::string NMD::SEB(uint64 instruction)
13525 {
13526 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13527 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13528
13529 std::string rt = GPR(copy(rt_value));
13530 std::string rs = GPR(copy(rs_value));
13531
13532 return img::format("SEB %s, %s", rt, rs);
13533 }
13534
13535
13536 /*
13537 *
13538 *
13539 * 3 2 1
13540 * 10987654321098765432109876543210
13541 * 001000 01001001101
13542 * rt -----
13543 * rs -----
13544 * rd -----
13545 */
13546 std::string NMD::SEH(uint64 instruction)
13547 {
13548 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13549 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13550
13551 std::string rt = GPR(copy(rt_value));
13552 std::string rs = GPR(copy(rs_value));
13553
13554 return img::format("SEH %s, %s", rt, rs);
13555 }
13556
13557
13558 /*
13559 *
13560 *
13561 * 3 2 1
13562 * 10987654321098765432109876543210
13563 * 001000 01001001101
13564 * rt -----
13565 * rs -----
13566 * rd -----
13567 */
13568 std::string NMD::SEL_D(uint64 instruction)
13569 {
13570 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13571 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13572 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13573
13574 std::string fd = FPR(copy(fd_value));
13575 std::string fs = FPR(copy(fs_value));
13576 std::string ft = FPR(copy(ft_value));
13577
13578 return img::format("SEL.D %s, %s, %s", fd, fs, ft);
13579 }
13580
13581
13582 /*
13583 *
13584 *
13585 * 3 2 1
13586 * 10987654321098765432109876543210
13587 * 001000 01001001101
13588 * rt -----
13589 * rs -----
13590 * rd -----
13591 */
13592 std::string NMD::SEL_S(uint64 instruction)
13593 {
13594 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13595 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13596 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13597
13598 std::string fd = FPR(copy(fd_value));
13599 std::string fs = FPR(copy(fs_value));
13600 std::string ft = FPR(copy(ft_value));
13601
13602 return img::format("SEL.S %s, %s, %s", fd, fs, ft);
13603 }
13604
13605
13606 /*
13607 *
13608 *
13609 * 3 2 1
13610 * 10987654321098765432109876543210
13611 * 001000 01001001101
13612 * rt -----
13613 * rs -----
13614 * rd -----
13615 */
13616 std::string NMD::SELEQZ_D(uint64 instruction)
13617 {
13618 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13619 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13620 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13621
13622 std::string fd = FPR(copy(fd_value));
13623 std::string fs = FPR(copy(fs_value));
13624 std::string ft = FPR(copy(ft_value));
13625
13626 return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13627 }
13628
13629
13630 /*
13631 *
13632 *
13633 * 3 2 1
13634 * 10987654321098765432109876543210
13635 * 001000 01001001101
13636 * rt -----
13637 * rs -----
13638 * rd -----
13639 */
13640 std::string NMD::SELEQZ_S(uint64 instruction)
13641 {
13642 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13643 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13644 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13645
13646 std::string fd = FPR(copy(fd_value));
13647 std::string fs = FPR(copy(fs_value));
13648 std::string ft = FPR(copy(ft_value));
13649
13650 return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13651 }
13652
13653
13654 /*
13655 *
13656 *
13657 * 3 2 1
13658 * 10987654321098765432109876543210
13659 * 001000 01001001101
13660 * rt -----
13661 * rs -----
13662 * rd -----
13663 */
13664 std::string NMD::SELNEZ_D(uint64 instruction)
13665 {
13666 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13667 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13668 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13669
13670 std::string fd = FPR(copy(fd_value));
13671 std::string fs = FPR(copy(fs_value));
13672 std::string ft = FPR(copy(ft_value));
13673
13674 return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13675 }
13676
13677
13678 /*
13679 *
13680 *
13681 * 3 2 1
13682 * 10987654321098765432109876543210
13683 * 001000 01001001101
13684 * rt -----
13685 * rs -----
13686 * rd -----
13687 */
13688 std::string NMD::SELNEZ_S(uint64 instruction)
13689 {
13690 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13691 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13692 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13693
13694 std::string fd = FPR(copy(fd_value));
13695 std::string fs = FPR(copy(fs_value));
13696 std::string ft = FPR(copy(ft_value));
13697
13698 return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13699 }
13700
13701
13702 /*
13703 *
13704 *
13705 * 3 2 1
13706 * 10987654321098765432109876543210
13707 * 001000 01001001101
13708 * rt -----
13709 * rs -----
13710 * rd -----
13711 */
13712 std::string NMD::SEQI(uint64 instruction)
13713 {
13714 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13715 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13716 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13717
13718 std::string rt = GPR(copy(rt_value));
13719 std::string rs = GPR(copy(rs_value));
13720 std::string u = IMMEDIATE(copy(u_value));
13721
13722 return img::format("SEQI %s, %s, %s", rt, rs, u);
13723 }
13724
13725
13726 /*
13727 *
13728 *
13729 * 3 2 1
13730 * 10987654321098765432109876543210
13731 * 001000 01001001101
13732 * rt -----
13733 * rs -----
13734 * rd -----
13735 */
13736 std::string NMD::SH_16_(uint64 instruction)
13737 {
13738 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13739 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13740 uint64 u_value = extract_u_2_1__s1(instruction);
13741
13742 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
13743 std::string u = IMMEDIATE(copy(u_value));
13744 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
13745
13746 return img::format("SH %s, %s(%s)", rtz3, u, rs3);
13747 }
13748
13749
13750 /*
13751 *
13752 *
13753 * 3 2 1
13754 * 10987654321098765432109876543210
13755 * 001000 01001001101
13756 * rt -----
13757 * rs -----
13758 * rd -----
13759 */
13760 std::string NMD::SH_GP_(uint64 instruction)
13761 {
13762 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13763 uint64 u_value = extract_u_17_to_1__s1(instruction);
13764
13765 std::string rt = GPR(copy(rt_value));
13766 std::string u = IMMEDIATE(copy(u_value));
13767
13768 return img::format("SH %s, %s($%d)", rt, u, 28);
13769 }
13770
13771
13772 /*
13773 *
13774 *
13775 * 3 2 1
13776 * 10987654321098765432109876543210
13777 * 001000 01001001101
13778 * rt -----
13779 * rs -----
13780 * rd -----
13781 */
13782 std::string NMD::SH_S9_(uint64 instruction)
13783 {
13784 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13785 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13786 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13787
13788 std::string rt = GPR(copy(rt_value));
13789 std::string s = IMMEDIATE(copy(s_value));
13790 std::string rs = GPR(copy(rs_value));
13791
13792 return img::format("SH %s, %s(%s)", rt, s, rs);
13793 }
13794
13795
13796 /*
13797 *
13798 *
13799 * 3 2 1
13800 * 10987654321098765432109876543210
13801 * 001000 01001001101
13802 * rt -----
13803 * rs -----
13804 * rd -----
13805 */
13806 std::string NMD::SH_U12_(uint64 instruction)
13807 {
13808 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13809 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13810 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13811
13812 std::string rt = GPR(copy(rt_value));
13813 std::string u = IMMEDIATE(copy(u_value));
13814 std::string rs = GPR(copy(rs_value));
13815
13816 return img::format("SH %s, %s(%s)", rt, u, rs);
13817 }
13818
13819
13820 /*
13821 *
13822 *
13823 * 3 2 1
13824 * 10987654321098765432109876543210
13825 * 001000 01001001101
13826 * rt -----
13827 * rs -----
13828 * rd -----
13829 */
13830 std::string NMD::SHE(uint64 instruction)
13831 {
13832 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13834 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13835
13836 std::string rt = GPR(copy(rt_value));
13837 std::string s = IMMEDIATE(copy(s_value));
13838 std::string rs = GPR(copy(rs_value));
13839
13840 return img::format("SHE %s, %s(%s)", rt, s, rs);
13841 }
13842
13843
13844 /*
13845 * SHILO ac, shift - Shift an Accumulator Value Leaving the Result in the Same
13846 * Accumulator
13847 *
13848 * 3 2 1
13849 * 10987654321098765432109876543210
13850 * 001000xxxx xxxx0000011101
13851 * shift ------
13852 * ac --
13853 */
13854 std::string NMD::SHILO(uint64 instruction)
13855 {
13856 int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
13857 uint64 ac_value = extract_ac_13_12(instruction);
13858
13859 std::string shift = IMMEDIATE(copy(shift_value));
13860 std::string ac = AC(copy(ac_value));
13861
13862 return img::format("SHILO %s, %s", ac, shift);
13863 }
13864
13865
13866 /*
13867 * SHILOV ac, rs - Variable Shift of Accumulator Value Leaving the Result in
13868 * the Same Accumulator
13869 *
13870 * 3 2 1
13871 * 10987654321098765432109876543210
13872 * 001000xxxxx 01001001111111
13873 * rs -----
13874 * ac --
13875 */
13876 std::string NMD::SHILOV(uint64 instruction)
13877 {
13878 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13879 uint64 ac_value = extract_ac_13_12(instruction);
13880
13881 std::string rs = GPR(copy(rs_value));
13882 std::string ac = AC(copy(ac_value));
13883
13884 return img::format("SHILOV %s, %s", ac, rs);
13885 }
13886
13887
13888 /*
13889 * SHLL.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords
13890 *
13891 * 3 2 1
13892 * 10987654321098765432109876543210
13893 * 001000 001110110101
13894 * rt -----
13895 * rs -----
13896 * sa ----
13897 */
13898 std::string NMD::SHLL_PH(uint64 instruction)
13899 {
13900 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13901 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13902 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13903
13904 std::string rt = GPR(copy(rt_value));
13905 std::string rs = GPR(copy(rs_value));
13906 std::string sa = IMMEDIATE(copy(sa_value));
13907
13908 return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
13909 }
13910
13911
13912 /*
13913 * SHLL.QB rt, rs, sa - Shift Left Logical Vector Quad Bytes
13914 *
13915 * 3 2 1
13916 * 10987654321098765432109876543210
13917 * 001000 0100001111111
13918 * rt -----
13919 * rs -----
13920 * sa ---
13921 */
13922 std::string NMD::SHLL_QB(uint64 instruction)
13923 {
13924 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13925 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13926 uint64 sa_value = extract_sa_15_14_13(instruction);
13927
13928 std::string rt = GPR(copy(rt_value));
13929 std::string rs = GPR(copy(rs_value));
13930 std::string sa = IMMEDIATE(copy(sa_value));
13931
13932 return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
13933 }
13934
13935
13936 /*
13937 * SHLL_S.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords (saturated)
13938 *
13939 * 3 2 1
13940 * 10987654321098765432109876543210
13941 * 001000 001110110101
13942 * rt -----
13943 * rs -----
13944 * sa ----
13945 */
13946 std::string NMD::SHLL_S_PH(uint64 instruction)
13947 {
13948 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13949 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13950 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13951
13952 std::string rt = GPR(copy(rt_value));
13953 std::string rs = GPR(copy(rs_value));
13954 std::string sa = IMMEDIATE(copy(sa_value));
13955
13956 return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
13957 }
13958
13959
13960 /*
13961 *
13962 *
13963 * 3 2 1
13964 * 10987654321098765432109876543210
13965 * 001000 01001001101
13966 * rt -----
13967 * rs -----
13968 * rd -----
13969 */
13970 std::string NMD::SHLL_S_W(uint64 instruction)
13971 {
13972 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13973 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13974 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
13975
13976 std::string rt = GPR(copy(rt_value));
13977 std::string rs = GPR(copy(rs_value));
13978 std::string sa = IMMEDIATE(copy(sa_value));
13979
13980 return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
13981 }
13982
13983
13984 /*
13985 *
13986 *
13987 * 3 2 1
13988 * 10987654321098765432109876543210
13989 * 001000 01001001101
13990 * rt -----
13991 * rs -----
13992 * rd -----
13993 */
13994 std::string NMD::SHLLV_PH(uint64 instruction)
13995 {
13996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13997 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13998 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13999
14000 std::string rd = GPR(copy(rd_value));
14001 std::string rt = GPR(copy(rt_value));
14002 std::string rs = GPR(copy(rs_value));
14003
14004 return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
14005 }
14006
14007
14008 /*
14009 *
14010 *
14011 * 3 2 1
14012 * 10987654321098765432109876543210
14013 * 001000 01001001101
14014 * rt -----
14015 * rs -----
14016 * rd -----
14017 */
14018 std::string NMD::SHLLV_QB(uint64 instruction)
14019 {
14020 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14021 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14022 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14023
14024 std::string rd = GPR(copy(rd_value));
14025 std::string rt = GPR(copy(rt_value));
14026 std::string rs = GPR(copy(rs_value));
14027
14028 return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
14029 }
14030
14031
14032 /*
14033 *
14034 *
14035 * 3 2 1
14036 * 10987654321098765432109876543210
14037 * 001000 01001001101
14038 * rt -----
14039 * rs -----
14040 * rd -----
14041 */
14042 std::string NMD::SHLLV_S_PH(uint64 instruction)
14043 {
14044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14045 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14046 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14047
14048 std::string rd = GPR(copy(rd_value));
14049 std::string rt = GPR(copy(rt_value));
14050 std::string rs = GPR(copy(rs_value));
14051
14052 return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
14053 }
14054
14055
14056 /*
14057 *
14058 *
14059 * 3 2 1
14060 * 10987654321098765432109876543210
14061 * 001000 01001001101
14062 * rt -----
14063 * rs -----
14064 * rd -----
14065 */
14066 std::string NMD::SHLLV_S_W(uint64 instruction)
14067 {
14068 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14069 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14070 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14071
14072 std::string rd = GPR(copy(rd_value));
14073 std::string rt = GPR(copy(rt_value));
14074 std::string rs = GPR(copy(rs_value));
14075
14076 return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
14077 }
14078
14079
14080 /*
14081 *
14082 *
14083 * 3 2 1
14084 * 10987654321098765432109876543210
14085 * 001000 01001001101
14086 * rt -----
14087 * rs -----
14088 * rd -----
14089 */
14090 std::string NMD::SHRA_PH(uint64 instruction)
14091 {
14092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14093 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14094 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14095
14096 std::string rt = GPR(copy(rt_value));
14097 std::string rs = GPR(copy(rs_value));
14098 std::string sa = IMMEDIATE(copy(sa_value));
14099
14100 return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
14101 }
14102
14103
14104 /*
14105 *
14106 *
14107 * 3 2 1
14108 * 10987654321098765432109876543210
14109 * 001000 01001001101
14110 * rt -----
14111 * rs -----
14112 * rd -----
14113 */
14114 std::string NMD::SHRA_QB(uint64 instruction)
14115 {
14116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14117 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14118 uint64 sa_value = extract_sa_15_14_13(instruction);
14119
14120 std::string rt = GPR(copy(rt_value));
14121 std::string rs = GPR(copy(rs_value));
14122 std::string sa = IMMEDIATE(copy(sa_value));
14123
14124 return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
14125 }
14126
14127
14128 /*
14129 *
14130 *
14131 * 3 2 1
14132 * 10987654321098765432109876543210
14133 * 001000 01001001101
14134 * rt -----
14135 * rs -----
14136 * rd -----
14137 */
14138 std::string NMD::SHRA_R_PH(uint64 instruction)
14139 {
14140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14141 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14142 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14143
14144 std::string rt = GPR(copy(rt_value));
14145 std::string rs = GPR(copy(rs_value));
14146 std::string sa = IMMEDIATE(copy(sa_value));
14147
14148 return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
14149 }
14150
14151
14152 /*
14153 *
14154 *
14155 * 3 2 1
14156 * 10987654321098765432109876543210
14157 * 001000 01001001101
14158 * rt -----
14159 * rs -----
14160 * rd -----
14161 */
14162 std::string NMD::SHRA_R_QB(uint64 instruction)
14163 {
14164 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14165 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14166 uint64 sa_value = extract_sa_15_14_13(instruction);
14167
14168 std::string rt = GPR(copy(rt_value));
14169 std::string rs = GPR(copy(rs_value));
14170 std::string sa = IMMEDIATE(copy(sa_value));
14171
14172 return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
14173 }
14174
14175
14176 /*
14177 *
14178 *
14179 * 3 2 1
14180 * 10987654321098765432109876543210
14181 * 001000 01001001101
14182 * rt -----
14183 * rs -----
14184 * rd -----
14185 */
14186 std::string NMD::SHRA_R_W(uint64 instruction)
14187 {
14188 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14190 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14191
14192 std::string rt = GPR(copy(rt_value));
14193 std::string rs = GPR(copy(rs_value));
14194 std::string sa = IMMEDIATE(copy(sa_value));
14195
14196 return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
14197 }
14198
14199
14200 /*
14201 *
14202 *
14203 * 3 2 1
14204 * 10987654321098765432109876543210
14205 * 001000 01001001101
14206 * rt -----
14207 * rs -----
14208 * rd -----
14209 */
14210 std::string NMD::SHRAV_PH(uint64 instruction)
14211 {
14212 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14214 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14215
14216 std::string rd = GPR(copy(rd_value));
14217 std::string rt = GPR(copy(rt_value));
14218 std::string rs = GPR(copy(rs_value));
14219
14220 return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
14221 }
14222
14223
14224 /*
14225 *
14226 *
14227 * 3 2 1
14228 * 10987654321098765432109876543210
14229 * 001000 01001001101
14230 * rt -----
14231 * rs -----
14232 * rd -----
14233 */
14234 std::string NMD::SHRAV_QB(uint64 instruction)
14235 {
14236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14238 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14239
14240 std::string rd = GPR(copy(rd_value));
14241 std::string rt = GPR(copy(rt_value));
14242 std::string rs = GPR(copy(rs_value));
14243
14244 return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
14245 }
14246
14247
14248 /*
14249 *
14250 *
14251 * 3 2 1
14252 * 10987654321098765432109876543210
14253 * 001000 01001001101
14254 * rt -----
14255 * rs -----
14256 * rd -----
14257 */
14258 std::string NMD::SHRAV_R_PH(uint64 instruction)
14259 {
14260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14261 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14262 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14263
14264 std::string rd = GPR(copy(rd_value));
14265 std::string rt = GPR(copy(rt_value));
14266 std::string rs = GPR(copy(rs_value));
14267
14268 return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
14269 }
14270
14271
14272 /*
14273 *
14274 *
14275 * 3 2 1
14276 * 10987654321098765432109876543210
14277 * 001000 01001001101
14278 * rt -----
14279 * rs -----
14280 * rd -----
14281 */
14282 std::string NMD::SHRAV_R_QB(uint64 instruction)
14283 {
14284 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14285 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14286 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14287
14288 std::string rd = GPR(copy(rd_value));
14289 std::string rt = GPR(copy(rt_value));
14290 std::string rs = GPR(copy(rs_value));
14291
14292 return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
14293 }
14294
14295
14296 /*
14297 *
14298 *
14299 * 3 2 1
14300 * 10987654321098765432109876543210
14301 * 001000 01001001101
14302 * rt -----
14303 * rs -----
14304 * rd -----
14305 */
14306 std::string NMD::SHRAV_R_W(uint64 instruction)
14307 {
14308 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14309 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14310 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14311
14312 std::string rd = GPR(copy(rd_value));
14313 std::string rt = GPR(copy(rt_value));
14314 std::string rs = GPR(copy(rs_value));
14315
14316 return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
14317 }
14318
14319
14320 /*
14321 *
14322 *
14323 * 3 2 1
14324 * 10987654321098765432109876543210
14325 * 001000 01001001101
14326 * rt -----
14327 * rs -----
14328 * rd -----
14329 */
14330 std::string NMD::SHRL_PH(uint64 instruction)
14331 {
14332 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14333 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14334 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14335
14336 std::string rt = GPR(copy(rt_value));
14337 std::string rs = GPR(copy(rs_value));
14338 std::string sa = IMMEDIATE(copy(sa_value));
14339
14340 return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
14341 }
14342
14343
14344 /*
14345 *
14346 *
14347 * 3 2 1
14348 * 10987654321098765432109876543210
14349 * 001000 01001001101
14350 * rt -----
14351 * rs -----
14352 * rd -----
14353 */
14354 std::string NMD::SHRL_QB(uint64 instruction)
14355 {
14356 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14357 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14358 uint64 sa_value = extract_sa_15_14_13(instruction);
14359
14360 std::string rt = GPR(copy(rt_value));
14361 std::string rs = GPR(copy(rs_value));
14362 std::string sa = IMMEDIATE(copy(sa_value));
14363
14364 return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
14365 }
14366
14367
14368 /*
14369 *
14370 *
14371 * 3 2 1
14372 * 10987654321098765432109876543210
14373 * 001000 01001001101
14374 * rt -----
14375 * rs -----
14376 * rd -----
14377 */
14378 std::string NMD::SHRLV_PH(uint64 instruction)
14379 {
14380 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14381 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14382 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14383
14384 std::string rd = GPR(copy(rd_value));
14385 std::string rt = GPR(copy(rt_value));
14386 std::string rs = GPR(copy(rs_value));
14387
14388 return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14389 }
14390
14391
14392 /*
14393 *
14394 *
14395 * 3 2 1
14396 * 10987654321098765432109876543210
14397 * 001000 01001001101
14398 * rt -----
14399 * rs -----
14400 * rd -----
14401 */
14402 std::string NMD::SHRLV_QB(uint64 instruction)
14403 {
14404 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14405 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14406 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14407
14408 std::string rd = GPR(copy(rd_value));
14409 std::string rt = GPR(copy(rt_value));
14410 std::string rs = GPR(copy(rs_value));
14411
14412 return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14413 }
14414
14415
14416 /*
14417 *
14418 *
14419 * 3 2 1
14420 * 10987654321098765432109876543210
14421 * 001000 01001001101
14422 * rt -----
14423 * rs -----
14424 * rd -----
14425 */
14426 std::string NMD::SHX(uint64 instruction)
14427 {
14428 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14429 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14430 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14431
14432 std::string rd = GPR(copy(rd_value));
14433 std::string rs = GPR(copy(rs_value));
14434 std::string rt = GPR(copy(rt_value));
14435
14436 return img::format("SHX %s, %s(%s)", rd, rs, rt);
14437 }
14438
14439
14440 /*
14441 *
14442 *
14443 * 3 2 1
14444 * 10987654321098765432109876543210
14445 * 001000 01001001101
14446 * rt -----
14447 * rs -----
14448 * rd -----
14449 */
14450 std::string NMD::SHXS(uint64 instruction)
14451 {
14452 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14453 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14454 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14455
14456 std::string rd = GPR(copy(rd_value));
14457 std::string rs = GPR(copy(rs_value));
14458 std::string rt = GPR(copy(rt_value));
14459
14460 return img::format("SHXS %s, %s(%s)", rd, rs, rt);
14461 }
14462
14463
14464 /*
14465 *
14466 *
14467 * 3 2 1
14468 * 10987654321098765432109876543210
14469 * 001000 01001001101
14470 * rt -----
14471 * rs -----
14472 * rd -----
14473 */
14474 std::string NMD::SIGRIE(uint64 instruction)
14475 {
14476 uint64 code_value = extract_code_18_to_0(instruction);
14477
14478 std::string code = IMMEDIATE(copy(code_value));
14479
14480 return img::format("SIGRIE %s", code);
14481 }
14482
14483
14484 /*
14485 *
14486 *
14487 * 3 2 1
14488 * 10987654321098765432109876543210
14489 * 001000 01001001101
14490 * rt -----
14491 * rs -----
14492 * rd -----
14493 */
14494 std::string NMD::SLL_16_(uint64 instruction)
14495 {
14496 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14497 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14498 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14499
14500 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14501 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
14502 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14503
14504 return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
14505 }
14506
14507
14508 /*
14509 *
14510 *
14511 * 3 2 1
14512 * 10987654321098765432109876543210
14513 * 001000 01001001101
14514 * rt -----
14515 * rs -----
14516 * rd -----
14517 */
14518 std::string NMD::SLL_32_(uint64 instruction)
14519 {
14520 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14521 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14522 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14523
14524 std::string rt = GPR(copy(rt_value));
14525 std::string rs = GPR(copy(rs_value));
14526 std::string shift = IMMEDIATE(copy(shift_value));
14527
14528 return img::format("SLL %s, %s, %s", rt, rs, shift);
14529 }
14530
14531
14532 /*
14533 *
14534 *
14535 * 3 2 1
14536 * 10987654321098765432109876543210
14537 * 001000 01001001101
14538 * rt -----
14539 * rs -----
14540 * rd -----
14541 */
14542 std::string NMD::SLLV(uint64 instruction)
14543 {
14544 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14545 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14546 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14547
14548 std::string rd = GPR(copy(rd_value));
14549 std::string rs = GPR(copy(rs_value));
14550 std::string rt = GPR(copy(rt_value));
14551
14552 return img::format("SLLV %s, %s, %s", rd, rs, rt);
14553 }
14554
14555
14556 /*
14557 *
14558 *
14559 * 3 2 1
14560 * 10987654321098765432109876543210
14561 * 001000 01001001101
14562 * rt -----
14563 * rs -----
14564 * rd -----
14565 */
14566 std::string NMD::SLT(uint64 instruction)
14567 {
14568 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14569 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14570 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14571
14572 std::string rd = GPR(copy(rd_value));
14573 std::string rs = GPR(copy(rs_value));
14574 std::string rt = GPR(copy(rt_value));
14575
14576 return img::format("SLT %s, %s, %s", rd, rs, rt);
14577 }
14578
14579
14580 /*
14581 *
14582 *
14583 * 3 2 1
14584 * 10987654321098765432109876543210
14585 * 001000 01001001101
14586 * rt -----
14587 * rs -----
14588 * rd -----
14589 */
14590 std::string NMD::SLTI(uint64 instruction)
14591 {
14592 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14593 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14594 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14595
14596 std::string rt = GPR(copy(rt_value));
14597 std::string rs = GPR(copy(rs_value));
14598 std::string u = IMMEDIATE(copy(u_value));
14599
14600 return img::format("SLTI %s, %s, %s", rt, rs, u);
14601 }
14602
14603
14604 /*
14605 *
14606 *
14607 * 3 2 1
14608 * 10987654321098765432109876543210
14609 * 001000 01001001101
14610 * rt -----
14611 * rs -----
14612 * rd -----
14613 */
14614 std::string NMD::SLTIU(uint64 instruction)
14615 {
14616 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14617 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14618 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14619
14620 std::string rt = GPR(copy(rt_value));
14621 std::string rs = GPR(copy(rs_value));
14622 std::string u = IMMEDIATE(copy(u_value));
14623
14624 return img::format("SLTIU %s, %s, %s", rt, rs, u);
14625 }
14626
14627
14628 /*
14629 *
14630 *
14631 * 3 2 1
14632 * 10987654321098765432109876543210
14633 * 001000 01001001101
14634 * rt -----
14635 * rs -----
14636 * rd -----
14637 */
14638 std::string NMD::SLTU(uint64 instruction)
14639 {
14640 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14641 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14642 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14643
14644 std::string rd = GPR(copy(rd_value));
14645 std::string rs = GPR(copy(rs_value));
14646 std::string rt = GPR(copy(rt_value));
14647
14648 return img::format("SLTU %s, %s, %s", rd, rs, rt);
14649 }
14650
14651
14652 /*
14653 *
14654 *
14655 * 3 2 1
14656 * 10987654321098765432109876543210
14657 * 001000 01001001101
14658 * rt -----
14659 * rs -----
14660 * rd -----
14661 */
14662 std::string NMD::SOV(uint64 instruction)
14663 {
14664 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14665 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14666 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14667
14668 std::string rd = GPR(copy(rd_value));
14669 std::string rs = GPR(copy(rs_value));
14670 std::string rt = GPR(copy(rt_value));
14671
14672 return img::format("SOV %s, %s, %s", rd, rs, rt);
14673 }
14674
14675
14676 /*
14677 *
14678 *
14679 * 3 2 1
14680 * 10987654321098765432109876543210
14681 * 001000 01001001101
14682 * rt -----
14683 * rs -----
14684 * rd -----
14685 */
14686 std::string NMD::SPECIAL2(uint64 instruction)
14687 {
14688 uint64 op_value = extract_op_25_to_3(instruction);
14689
14690 std::string op = IMMEDIATE(copy(op_value));
14691
14692 return img::format("SPECIAL2 %s", op);
14693 }
14694
14695
14696 /*
14697 *
14698 *
14699 * 3 2 1
14700 * 10987654321098765432109876543210
14701 * 001000 01001001101
14702 * rt -----
14703 * rs -----
14704 * rd -----
14705 */
14706 std::string NMD::SQRT_D(uint64 instruction)
14707 {
14708 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14709 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14710
14711 std::string ft = FPR(copy(ft_value));
14712 std::string fs = FPR(copy(fs_value));
14713
14714 return img::format("SQRT.D %s, %s", ft, fs);
14715 }
14716
14717
14718 /*
14719 *
14720 *
14721 * 3 2 1
14722 * 10987654321098765432109876543210
14723 * 001000 01001001101
14724 * rt -----
14725 * rs -----
14726 * rd -----
14727 */
14728 std::string NMD::SQRT_S(uint64 instruction)
14729 {
14730 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14731 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14732
14733 std::string ft = FPR(copy(ft_value));
14734 std::string fs = FPR(copy(fs_value));
14735
14736 return img::format("SQRT.S %s, %s", ft, fs);
14737 }
14738
14739
14740 /*
14741 * SRA rd, rt, sa - Shift Word Right Arithmetic
14742 *
14743 * 3 2 1
14744 * 10987654321098765432109876543210
14745 * 00000000000 000011
14746 * rt -----
14747 * rd -----
14748 * sa -----
14749 */
14750 std::string NMD::SRA(uint64 instruction)
14751 {
14752 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14753 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14754 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14755
14756 std::string rt = GPR(copy(rt_value));
14757 std::string rs = GPR(copy(rs_value));
14758 std::string shift = IMMEDIATE(copy(shift_value));
14759
14760 return img::format("SRA %s, %s, %s", rt, rs, shift);
14761 }
14762
14763
14764 /*
14765 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14766 *
14767 * 3 2 1
14768 * 10987654321098765432109876543210
14769 * 001000 00000000111
14770 * rs -----
14771 * rt -----
14772 * rd -----
14773 */
14774 std::string NMD::SRAV(uint64 instruction)
14775 {
14776 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14777 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14778 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14779
14780 std::string rd = GPR(copy(rd_value));
14781 std::string rs = GPR(copy(rs_value));
14782 std::string rt = GPR(copy(rt_value));
14783
14784 return img::format("SRAV %s, %s, %s", rd, rs, rt);
14785 }
14786
14787
14788 /*
14789 *
14790 *
14791 * 3 2 1
14792 * 10987654321098765432109876543210
14793 * 001000 00000000111
14794 * rs -----
14795 * rt -----
14796 * rd -----
14797 */
14798 std::string NMD::SRL_16_(uint64 instruction)
14799 {
14800 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14801 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14802 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14803
14804 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14805 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
14806 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14807
14808 return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
14809 }
14810
14811
14812 /*
14813 *
14814 *
14815 * 3 2 1
14816 * 10987654321098765432109876543210
14817 * 001000 01001001101
14818 * rt -----
14819 * rs -----
14820 * rd -----
14821 */
14822 std::string NMD::SRL_32_(uint64 instruction)
14823 {
14824 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14825 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14826 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14827
14828 std::string rt = GPR(copy(rt_value));
14829 std::string rs = GPR(copy(rs_value));
14830 std::string shift = IMMEDIATE(copy(shift_value));
14831
14832 return img::format("SRL %s, %s, %s", rt, rs, shift);
14833 }
14834
14835
14836 /*
14837 *
14838 *
14839 * 3 2 1
14840 * 10987654321098765432109876543210
14841 * 001000 01001001101
14842 * rt -----
14843 * rs -----
14844 * rd -----
14845 */
14846 std::string NMD::SRLV(uint64 instruction)
14847 {
14848 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14849 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14850 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14851
14852 std::string rd = GPR(copy(rd_value));
14853 std::string rs = GPR(copy(rs_value));
14854 std::string rt = GPR(copy(rt_value));
14855
14856 return img::format("SRLV %s, %s, %s", rd, rs, rt);
14857 }
14858
14859
14860 /*
14861 *
14862 *
14863 * 3 2 1
14864 * 10987654321098765432109876543210
14865 * 001000 01001001101
14866 * rt -----
14867 * rs -----
14868 * rd -----
14869 */
14870 std::string NMD::SUB(uint64 instruction)
14871 {
14872 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14873 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14874 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14875
14876 std::string rd = GPR(copy(rd_value));
14877 std::string rs = GPR(copy(rs_value));
14878 std::string rt = GPR(copy(rt_value));
14879
14880 return img::format("SUB %s, %s, %s", rd, rs, rt);
14881 }
14882
14883
14884 /*
14885 *
14886 *
14887 * 3 2 1
14888 * 10987654321098765432109876543210
14889 * 001000 01001001101
14890 * rt -----
14891 * rs -----
14892 * rd -----
14893 */
14894 std::string NMD::SUB_D(uint64 instruction)
14895 {
14896 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14897 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14898 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14899
14900 std::string fd = FPR(copy(fd_value));
14901 std::string fs = FPR(copy(fs_value));
14902 std::string ft = FPR(copy(ft_value));
14903
14904 return img::format("SUB.D %s, %s, %s", fd, fs, ft);
14905 }
14906
14907
14908 /*
14909 *
14910 *
14911 * 3 2 1
14912 * 10987654321098765432109876543210
14913 * 001000 01001001101
14914 * rt -----
14915 * rs -----
14916 * rd -----
14917 */
14918 std::string NMD::SUB_S(uint64 instruction)
14919 {
14920 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14921 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14922 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14923
14924 std::string fd = FPR(copy(fd_value));
14925 std::string fs = FPR(copy(fs_value));
14926 std::string ft = FPR(copy(ft_value));
14927
14928 return img::format("SUB.S %s, %s, %s", fd, fs, ft);
14929 }
14930
14931
14932 /*
14933 *
14934 *
14935 * 3 2 1
14936 * 10987654321098765432109876543210
14937 * 001000 01001001101
14938 * rt -----
14939 * rs -----
14940 * rd -----
14941 */
14942 std::string NMD::SUBQ_PH(uint64 instruction)
14943 {
14944 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14945 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14946 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14947
14948 std::string rd = GPR(copy(rd_value));
14949 std::string rs = GPR(copy(rs_value));
14950 std::string rt = GPR(copy(rt_value));
14951
14952 return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
14953 }
14954
14955
14956 /*
14957 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14958 * to Halve Results
14959 *
14960 * 3 2 1
14961 * 10987654321098765432109876543210
14962 * 001000 01001001101
14963 * rt -----
14964 * rs -----
14965 * rd -----
14966 */
14967 std::string NMD::SUBQ_S_PH(uint64 instruction)
14968 {
14969 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14970 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14971 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14972
14973 std::string rd = GPR(copy(rd_value));
14974 std::string rs = GPR(copy(rs_value));
14975 std::string rt = GPR(copy(rt_value));
14976
14977 return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
14978 }
14979
14980
14981 /*
14982 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
14983 * to Halve Results
14984 *
14985 * 3 2 1
14986 * 10987654321098765432109876543210
14987 * 001000 01001001101
14988 * rt -----
14989 * rs -----
14990 * rd -----
14991 */
14992 std::string NMD::SUBQ_S_W(uint64 instruction)
14993 {
14994 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14995 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14996 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14997
14998 std::string rd = GPR(copy(rd_value));
14999 std::string rs = GPR(copy(rs_value));
15000 std::string rt = GPR(copy(rt_value));
15001
15002 return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
15003 }
15004
15005
15006 /*
15007 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15008 * to Halve Results
15009 *
15010 * 3 2 1
15011 * 10987654321098765432109876543210
15012 * 001000 01001001101
15013 * rt -----
15014 * rs -----
15015 * rd -----
15016 */
15017 std::string NMD::SUBQH_PH(uint64 instruction)
15018 {
15019 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15020 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15021 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15022
15023 std::string rd = GPR(copy(rd_value));
15024 std::string rs = GPR(copy(rs_value));
15025 std::string rt = GPR(copy(rt_value));
15026
15027 return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
15028 }
15029
15030
15031 /*
15032 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15033 * to Halve Results
15034 *
15035 * 3 2 1
15036 * 10987654321098765432109876543210
15037 * 001000 01001001101
15038 * rt -----
15039 * rs -----
15040 * rd -----
15041 */
15042 std::string NMD::SUBQH_R_PH(uint64 instruction)
15043 {
15044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15045 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15046 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15047
15048 std::string rd = GPR(copy(rd_value));
15049 std::string rs = GPR(copy(rs_value));
15050 std::string rt = GPR(copy(rt_value));
15051
15052 return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
15053 }
15054
15055
15056 /*
15057 * SUBQH_R.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15058 * to Halve Results (rounding)
15059 *
15060 * 3 2 1
15061 * 10987654321098765432109876543210
15062 * 001000 11001001101
15063 * rt -----
15064 * rs -----
15065 * rd -----
15066 */
15067 std::string NMD::SUBQH_R_W(uint64 instruction)
15068 {
15069 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15070 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15071 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15072
15073 std::string rd = GPR(copy(rd_value));
15074 std::string rs = GPR(copy(rs_value));
15075 std::string rt = GPR(copy(rt_value));
15076
15077 return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
15078 }
15079
15080
15081 /*
15082 * SUBQH.W rd, rs, rt - Subtract Fractional Words And Shift Right to Halve
15083 * Results
15084 *
15085 * 3 2 1
15086 * 10987654321098765432109876543210
15087 * 001000 01010001101
15088 * rt -----
15089 * rs -----
15090 * rd -----
15091 */
15092 std::string NMD::SUBQH_W(uint64 instruction)
15093 {
15094 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15095 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15096 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15097
15098 std::string rd = GPR(copy(rd_value));
15099 std::string rs = GPR(copy(rs_value));
15100 std::string rt = GPR(copy(rt_value));
15101
15102 return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
15103 }
15104
15105
15106 /*
15107 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15108 *
15109 * 3 2 1
15110 * 10987654321098765432109876543210
15111 * 001000 00010001101
15112 * rt -----
15113 * rs -----
15114 * rd -----
15115 */
15116 std::string NMD::SUBU_16_(uint64 instruction)
15117 {
15118 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15119 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15120 uint64 rd3_value = extract_rd3_3_2_1(instruction);
15121
15122 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
15123 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
15124 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
15125
15126 return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
15127 }
15128
15129
15130 /*
15131 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15132 *
15133 * 3 2 1
15134 * 10987654321098765432109876543210
15135 * 001000 00010001101
15136 * rt -----
15137 * rs -----
15138 * rd -----
15139 */
15140 std::string NMD::SUBU_32_(uint64 instruction)
15141 {
15142 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15143 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15144 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15145
15146 std::string rd = GPR(copy(rd_value));
15147 std::string rs = GPR(copy(rs_value));
15148 std::string rt = GPR(copy(rt_value));
15149
15150 return img::format("SUBU %s, %s, %s", rd, rs, rt);
15151 }
15152
15153
15154 /*
15155 * SUBU.PH rd, rs, rt - Subtract Unsigned Integer Halfwords
15156 *
15157 * 3 2 1
15158 * 10987654321098765432109876543210
15159 * 001000 01100001101
15160 * rt -----
15161 * rs -----
15162 * rd -----
15163 */
15164 std::string NMD::SUBU_PH(uint64 instruction)
15165 {
15166 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15167 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15168 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15169
15170 std::string rd = GPR(copy(rd_value));
15171 std::string rs = GPR(copy(rs_value));
15172 std::string rt = GPR(copy(rt_value));
15173
15174 return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
15175 }
15176
15177
15178 /*
15179 * SUBU.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector
15180 *
15181 * 3 2 1
15182 * 10987654321098765432109876543210
15183 * 001000 01011001101
15184 * rt -----
15185 * rs -----
15186 * rd -----
15187 */
15188 std::string NMD::SUBU_QB(uint64 instruction)
15189 {
15190 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15191 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15192 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15193
15194 std::string rd = GPR(copy(rd_value));
15195 std::string rs = GPR(copy(rs_value));
15196 std::string rt = GPR(copy(rt_value));
15197
15198 return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
15199 }
15200
15201
15202 /*
15203 * SUBU_S.PH rd, rs, rt - Subtract Unsigned Integer Halfwords (saturating)
15204 *
15205 * 3 2 1
15206 * 10987654321098765432109876543210
15207 * 001000 11100001101
15208 * rt -----
15209 * rs -----
15210 * rd -----
15211 */
15212 std::string NMD::SUBU_S_PH(uint64 instruction)
15213 {
15214 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15215 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15216 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15217
15218 std::string rd = GPR(copy(rd_value));
15219 std::string rs = GPR(copy(rs_value));
15220 std::string rt = GPR(copy(rt_value));
15221
15222 return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
15223 }
15224
15225
15226 /*
15227 * SUBU_S.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector (saturating)
15228 *
15229 * 3 2 1
15230 * 10987654321098765432109876543210
15231 * 001000 11011001101
15232 * rt -----
15233 * rs -----
15234 * rd -----
15235 */
15236 std::string NMD::SUBU_S_QB(uint64 instruction)
15237 {
15238 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15239 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15240 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15241
15242 std::string rd = GPR(copy(rd_value));
15243 std::string rs = GPR(copy(rs_value));
15244 std::string rt = GPR(copy(rt_value));
15245
15246 return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
15247 }
15248
15249
15250 /*
15251 * SUBUH.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15252 * Results
15253 *
15254 * 3 2 1
15255 * 10987654321098765432109876543210
15256 * 001000 01101001101
15257 * rt -----
15258 * rs -----
15259 * rd -----
15260 */
15261 std::string NMD::SUBUH_QB(uint64 instruction)
15262 {
15263 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15264 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15265 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15266
15267 std::string rd = GPR(copy(rd_value));
15268 std::string rs = GPR(copy(rs_value));
15269 std::string rt = GPR(copy(rt_value));
15270
15271 return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
15272 }
15273
15274
15275 /*
15276 * SUBUH_R.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15277 * Results (rounding)
15278 *
15279 * 3 2 1
15280 * 10987654321098765432109876543210
15281 * 001000 11101001101
15282 * rt -----
15283 * rs -----
15284 * rd -----
15285 */
15286 std::string NMD::SUBUH_R_QB(uint64 instruction)
15287 {
15288 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15289 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15290 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15291
15292 std::string rd = GPR(copy(rd_value));
15293 std::string rs = GPR(copy(rs_value));
15294 std::string rt = GPR(copy(rt_value));
15295
15296 return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
15297 }
15298
15299
15300 /*
15301 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15302 *
15303 * 3 2 1
15304 * 10987654321098765432109876543210
15305 * 001000 00010001101
15306 * rt -----
15307 * rs -----
15308 * rd -----
15309 */
15310 std::string NMD::SW_16_(uint64 instruction)
15311 {
15312 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15313 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15314 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
15315
15316 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
15317 std::string u = IMMEDIATE(copy(u_value));
15318 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
15319
15320 return img::format("SW %s, %s(%s)", rtz3, u, rs3);
15321 }
15322
15323
15324 /*
15325 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15326 *
15327 * 3 2 1
15328 * 10987654321098765432109876543210
15329 * 001000 00010001101
15330 * rt -----
15331 * rs -----
15332 * rd -----
15333 */
15334 std::string NMD::SW_4X4_(uint64 instruction)
15335 {
15336 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
15337 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
15338 uint64 u_value = extract_u_3_8__s2(instruction);
15339
15340 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
15341 std::string u = IMMEDIATE(copy(u_value));
15342 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
15343
15344 return img::format("SW %s, %s(%s)", rtz4, u, rs4);
15345 }
15346
15347
15348 /*
15349 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15350 *
15351 * 3 2 1
15352 * 10987654321098765432109876543210
15353 * 001000 00010001101
15354 * rt -----
15355 * rs -----
15356 * rd -----
15357 */
15358 std::string NMD::SW_GP16_(uint64 instruction)
15359 {
15360 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
15361 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15362
15363 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
15364 std::string u = IMMEDIATE(copy(u_value));
15365
15366 return img::format("SW %s, %s($%d)", rtz3, u, 28);
15367 }
15368
15369
15370 /*
15371 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15372 *
15373 * 3 2 1
15374 * 10987654321098765432109876543210
15375 * 001000 00010001101
15376 * rt -----
15377 * rs -----
15378 * rd -----
15379 */
15380 std::string NMD::SW_GP_(uint64 instruction)
15381 {
15382 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15383 uint64 u_value = extract_u_20_to_2__s2(instruction);
15384
15385 std::string rt = GPR(copy(rt_value));
15386 std::string u = IMMEDIATE(copy(u_value));
15387
15388 return img::format("SW %s, %s($%d)", rt, u, 28);
15389 }
15390
15391
15392 /*
15393 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15394 *
15395 * 3 2 1
15396 * 10987654321098765432109876543210
15397 * 001000 00010001101
15398 * rt -----
15399 * rs -----
15400 * rd -----
15401 */
15402 std::string NMD::SW_S9_(uint64 instruction)
15403 {
15404 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15405 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15406 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15407
15408 std::string rt = GPR(copy(rt_value));
15409 std::string s = IMMEDIATE(copy(s_value));
15410 std::string rs = GPR(copy(rs_value));
15411
15412 return img::format("SW %s, %s(%s)", rt, s, rs);
15413 }
15414
15415
15416 /*
15417 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15418 *
15419 * 3 2 1
15420 * 10987654321098765432109876543210
15421 * 001000 00010001101
15422 * rt -----
15423 * rs -----
15424 * rd -----
15425 */
15426 std::string NMD::SW_SP_(uint64 instruction)
15427 {
15428 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
15429 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
15430
15431 std::string rt = GPR(copy(rt_value));
15432 std::string u = IMMEDIATE(copy(u_value));
15433
15434 return img::format("SW %s, %s($%d)", rt, u, 29);
15435 }
15436
15437
15438 /*
15439 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15440 *
15441 * 3 2 1
15442 * 10987654321098765432109876543210
15443 * 001000 00010001101
15444 * rt -----
15445 * rs -----
15446 * rd -----
15447 */
15448 std::string NMD::SW_U12_(uint64 instruction)
15449 {
15450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15452 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15453
15454 std::string rt = GPR(copy(rt_value));
15455 std::string u = IMMEDIATE(copy(u_value));
15456 std::string rs = GPR(copy(rs_value));
15457
15458 return img::format("SW %s, %s(%s)", rt, u, rs);
15459 }
15460
15461
15462 /*
15463 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15464 *
15465 * 3 2 1
15466 * 10987654321098765432109876543210
15467 * 001000 00010001101
15468 * rt -----
15469 * rs -----
15470 * rd -----
15471 */
15472 std::string NMD::SWC1_GP_(uint64 instruction)
15473 {
15474 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15475 uint64 u_value = extract_u_17_to_2__s2(instruction);
15476
15477 std::string ft = FPR(copy(ft_value));
15478 std::string u = IMMEDIATE(copy(u_value));
15479
15480 return img::format("SWC1 %s, %s($%d)", ft, u, 28);
15481 }
15482
15483
15484 /*
15485 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15486 *
15487 * 3 2 1
15488 * 10987654321098765432109876543210
15489 * 001000 00010001101
15490 * rt -----
15491 * rs -----
15492 * rd -----
15493 */
15494 std::string NMD::SWC1_S9_(uint64 instruction)
15495 {
15496 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15497 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15498 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15499
15500 std::string ft = FPR(copy(ft_value));
15501 std::string s = IMMEDIATE(copy(s_value));
15502 std::string rs = GPR(copy(rs_value));
15503
15504 return img::format("SWC1 %s, %s(%s)", ft, s, rs);
15505 }
15506
15507
15508 /*
15509 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15510 *
15511 * 3 2 1
15512 * 10987654321098765432109876543210
15513 * 001000 00010001101
15514 * rt -----
15515 * rs -----
15516 * rd -----
15517 */
15518 std::string NMD::SWC1_U12_(uint64 instruction)
15519 {
15520 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15521 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15522 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15523
15524 std::string ft = FPR(copy(ft_value));
15525 std::string u = IMMEDIATE(copy(u_value));
15526 std::string rs = GPR(copy(rs_value));
15527
15528 return img::format("SWC1 %s, %s(%s)", ft, u, rs);
15529 }
15530
15531
15532 /*
15533 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15534 *
15535 * 3 2 1
15536 * 10987654321098765432109876543210
15537 * 001000 00010001101
15538 * rt -----
15539 * rs -----
15540 * rd -----
15541 */
15542 std::string NMD::SWC1X(uint64 instruction)
15543 {
15544 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15545 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15546 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15547
15548 std::string ft = FPR(copy(ft_value));
15549 std::string rs = GPR(copy(rs_value));
15550 std::string rt = GPR(copy(rt_value));
15551
15552 return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
15553 }
15554
15555
15556 /*
15557 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15558 *
15559 * 3 2 1
15560 * 10987654321098765432109876543210
15561 * 001000 00010001101
15562 * rt -----
15563 * rs -----
15564 * rd -----
15565 */
15566 std::string NMD::SWC1XS(uint64 instruction)
15567 {
15568 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15569 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15570 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15571
15572 std::string ft = FPR(copy(ft_value));
15573 std::string rs = GPR(copy(rs_value));
15574 std::string rt = GPR(copy(rt_value));
15575
15576 return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
15577 }
15578
15579
15580 /*
15581 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15582 *
15583 * 3 2 1
15584 * 10987654321098765432109876543210
15585 * 001000 00010001101
15586 * rt -----
15587 * rs -----
15588 * rd -----
15589 */
15590 std::string NMD::SWC2(uint64 instruction)
15591 {
15592 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15593 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15594 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15595
15596 std::string cs = CPR(copy(cs_value));
15597 std::string s = IMMEDIATE(copy(s_value));
15598 std::string rs = GPR(copy(rs_value));
15599
15600 return img::format("SWC2 %s, %s(%s)", cs, s, rs);
15601 }
15602
15603
15604 /*
15605 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15606 *
15607 * 3 2 1
15608 * 10987654321098765432109876543210
15609 * 001000 00010001101
15610 * rt -----
15611 * rs -----
15612 * rd -----
15613 */
15614 std::string NMD::SWE(uint64 instruction)
15615 {
15616 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15617 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15618 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15619
15620 std::string rt = GPR(copy(rt_value));
15621 std::string s = IMMEDIATE(copy(s_value));
15622 std::string rs = GPR(copy(rs_value));
15623
15624 return img::format("SWE %s, %s(%s)", rt, s, rs);
15625 }
15626
15627
15628 /*
15629 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15630 *
15631 * 3 2 1
15632 * 10987654321098765432109876543210
15633 * 001000 00010001101
15634 * rt -----
15635 * rs -----
15636 * rd -----
15637 */
15638 std::string NMD::SWM(uint64 instruction)
15639 {
15640 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15641 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15642 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15643 uint64 count3_value = extract_count3_14_13_12(instruction);
15644
15645 std::string rt = GPR(copy(rt_value));
15646 std::string s = IMMEDIATE(copy(s_value));
15647 std::string rs = GPR(copy(rs_value));
15648 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
15649
15650 return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
15651 }
15652
15653
15654 /*
15655 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15656 *
15657 * 3 2 1
15658 * 10987654321098765432109876543210
15659 * 001000 00010001101
15660 * rt -----
15661 * rs -----
15662 * rd -----
15663 */
15664 std::string NMD::SWPC_48_(uint64 instruction)
15665 {
15666 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15667 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
15668
15669 std::string rt = GPR(copy(rt_value));
15670 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
15671
15672 return img::format("SWPC %s, %s", rt, s);
15673 }
15674
15675
15676 /*
15677 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15678 *
15679 * 3 2 1
15680 * 10987654321098765432109876543210
15681 * 001000 00010001101
15682 * rt -----
15683 * rs -----
15684 * rd -----
15685 */
15686 std::string NMD::SWX(uint64 instruction)
15687 {
15688 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15689 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15690 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15691
15692 std::string rd = GPR(copy(rd_value));
15693 std::string rs = GPR(copy(rs_value));
15694 std::string rt = GPR(copy(rt_value));
15695
15696 return img::format("SWX %s, %s(%s)", rd, rs, rt);
15697 }
15698
15699
15700 /*
15701 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15702 *
15703 * 3 2 1
15704 * 10987654321098765432109876543210
15705 * 001000 00010001101
15706 * rt -----
15707 * rs -----
15708 * rd -----
15709 */
15710 std::string NMD::SWXS(uint64 instruction)
15711 {
15712 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15713 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15714 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15715
15716 std::string rd = GPR(copy(rd_value));
15717 std::string rs = GPR(copy(rs_value));
15718 std::string rt = GPR(copy(rt_value));
15719
15720 return img::format("SWXS %s, %s(%s)", rd, rs, rt);
15721 }
15722
15723
15724 /*
15725 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15726 *
15727 * 3 2 1
15728 * 10987654321098765432109876543210
15729 * 001000 00010001101
15730 * rt -----
15731 * rs -----
15732 * rd -----
15733 */
15734 std::string NMD::SYNC(uint64 instruction)
15735 {
15736 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15737
15738 std::string stype = IMMEDIATE(copy(stype_value));
15739
15740 return img::format("SYNC %s", stype);
15741 }
15742
15743
15744 /*
15745 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15746 *
15747 * 3 2 1
15748 * 10987654321098765432109876543210
15749 * 001000 00010001101
15750 * rt -----
15751 * rs -----
15752 * rd -----
15753 */
15754 std::string NMD::SYNCI(uint64 instruction)
15755 {
15756 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15757 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15758
15759 std::string s = IMMEDIATE(copy(s_value));
15760 std::string rs = GPR(copy(rs_value));
15761
15762 return img::format("SYNCI %s(%s)", s, rs);
15763 }
15764
15765
15766 /*
15767 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15768 *
15769 * 3 2 1
15770 * 10987654321098765432109876543210
15771 * 001000 00010001101
15772 * rt -----
15773 * rs -----
15774 * rd -----
15775 */
15776 std::string NMD::SYNCIE(uint64 instruction)
15777 {
15778 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15779 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15780
15781 std::string s = IMMEDIATE(copy(s_value));
15782 std::string rs = GPR(copy(rs_value));
15783
15784 return img::format("SYNCIE %s(%s)", s, rs);
15785 }
15786
15787
15788 /*
15789 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15790 *
15791 * 3 2 1
15792 * 10987654321098765432109876543210
15793 * 001000 00010001101
15794 * rt -----
15795 * rs -----
15796 * rd -----
15797 */
15798 std::string NMD::SYSCALL_16_(uint64 instruction)
15799 {
15800 uint64 code_value = extract_code_1_0(instruction);
15801
15802 std::string code = IMMEDIATE(copy(code_value));
15803
15804 return img::format("SYSCALL %s", code);
15805 }
15806
15807
15808 /*
15809 * SYSCALL code - System Call. Cause a System Call Exception
15810 *
15811 * 3 2 1
15812 * 10987654321098765432109876543210
15813 * 00000000000010
15814 * code ------------------
15815 */
15816 std::string NMD::SYSCALL_32_(uint64 instruction)
15817 {
15818 uint64 code_value = extract_code_17_to_0(instruction);
15819
15820 std::string code = IMMEDIATE(copy(code_value));
15821
15822 return img::format("SYSCALL %s", code);
15823 }
15824
15825
15826 /*
15827 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15828 *
15829 * 3 2 1
15830 * 10987654321098765432109876543210
15831 * 001000 00010001101
15832 * rt -----
15833 * rs -----
15834 * rd -----
15835 */
15836 std::string NMD::TEQ(uint64 instruction)
15837 {
15838 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15839 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15840
15841 std::string rs = GPR(copy(rs_value));
15842 std::string rt = GPR(copy(rt_value));
15843
15844 return img::format("TEQ %s, %s", rs, rt);
15845 }
15846
15847
15848 /*
15849 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15850 *
15851 * 3 2 1
15852 * 10987654321098765432109876543210
15853 * 001000 00010001101
15854 * rt -----
15855 * rs -----
15856 * rd -----
15857 */
15858 std::string NMD::TLBGINV(uint64 instruction)
15859 {
15860 (void)instruction;
15861
15862 return "TLBGINV ";
15863 }
15864
15865
15866 /*
15867 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15868 *
15869 * 3 2 1
15870 * 10987654321098765432109876543210
15871 * 001000 00010001101
15872 * rt -----
15873 * rs -----
15874 * rd -----
15875 */
15876 std::string NMD::TLBGINVF(uint64 instruction)
15877 {
15878 (void)instruction;
15879
15880 return "TLBGINVF ";
15881 }
15882
15883
15884 /*
15885 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15886 *
15887 * 3 2 1
15888 * 10987654321098765432109876543210
15889 * 001000 00010001101
15890 * rt -----
15891 * rs -----
15892 * rd -----
15893 */
15894 std::string NMD::TLBGP(uint64 instruction)
15895 {
15896 (void)instruction;
15897
15898 return "TLBGP ";
15899 }
15900
15901
15902 /*
15903 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15904 *
15905 * 3 2 1
15906 * 10987654321098765432109876543210
15907 * 001000 00010001101
15908 * rt -----
15909 * rs -----
15910 * rd -----
15911 */
15912 std::string NMD::TLBGR(uint64 instruction)
15913 {
15914 (void)instruction;
15915
15916 return "TLBGR ";
15917 }
15918
15919
15920 /*
15921 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15922 *
15923 * 3 2 1
15924 * 10987654321098765432109876543210
15925 * 001000 00010001101
15926 * rt -----
15927 * rs -----
15928 * rd -----
15929 */
15930 std::string NMD::TLBGWI(uint64 instruction)
15931 {
15932 (void)instruction;
15933
15934 return "TLBGWI ";
15935 }
15936
15937
15938 /*
15939 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15940 *
15941 * 3 2 1
15942 * 10987654321098765432109876543210
15943 * 001000 00010001101
15944 * rt -----
15945 * rs -----
15946 * rd -----
15947 */
15948 std::string NMD::TLBGWR(uint64 instruction)
15949 {
15950 (void)instruction;
15951
15952 return "TLBGWR ";
15953 }
15954
15955
15956 /*
15957 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15958 *
15959 * 3 2 1
15960 * 10987654321098765432109876543210
15961 * 001000 00010001101
15962 * rt -----
15963 * rs -----
15964 * rd -----
15965 */
15966 std::string NMD::TLBINV(uint64 instruction)
15967 {
15968 (void)instruction;
15969
15970 return "TLBINV ";
15971 }
15972
15973
15974 /*
15975 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15976 *
15977 * 3 2 1
15978 * 10987654321098765432109876543210
15979 * 001000 00010001101
15980 * rt -----
15981 * rs -----
15982 * rd -----
15983 */
15984 std::string NMD::TLBINVF(uint64 instruction)
15985 {
15986 (void)instruction;
15987
15988 return "TLBINVF ";
15989 }
15990
15991
15992 /*
15993 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15994 *
15995 * 3 2 1
15996 * 10987654321098765432109876543210
15997 * 001000 00010001101
15998 * rt -----
15999 * rs -----
16000 * rd -----
16001 */
16002 std::string NMD::TLBP(uint64 instruction)
16003 {
16004 (void)instruction;
16005
16006 return "TLBP ";
16007 }
16008
16009
16010 /*
16011 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16012 *
16013 * 3 2 1
16014 * 10987654321098765432109876543210
16015 * 001000 00010001101
16016 * rt -----
16017 * rs -----
16018 * rd -----
16019 */
16020 std::string NMD::TLBR(uint64 instruction)
16021 {
16022 (void)instruction;
16023
16024 return "TLBR ";
16025 }
16026
16027
16028 /*
16029 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16030 *
16031 * 3 2 1
16032 * 10987654321098765432109876543210
16033 * 001000 00010001101
16034 * rt -----
16035 * rs -----
16036 * rd -----
16037 */
16038 std::string NMD::TLBWI(uint64 instruction)
16039 {
16040 (void)instruction;
16041
16042 return "TLBWI ";
16043 }
16044
16045
16046 /*
16047 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16048 *
16049 * 3 2 1
16050 * 10987654321098765432109876543210
16051 * 001000 00010001101
16052 * rt -----
16053 * rs -----
16054 * rd -----
16055 */
16056 std::string NMD::TLBWR(uint64 instruction)
16057 {
16058 (void)instruction;
16059
16060 return "TLBWR ";
16061 }
16062
16063
16064 /*
16065 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16066 *
16067 * 3 2 1
16068 * 10987654321098765432109876543210
16069 * 001000 00010001101
16070 * rt -----
16071 * rs -----
16072 * rd -----
16073 */
16074 std::string NMD::TNE(uint64 instruction)
16075 {
16076 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16077 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16078
16079 std::string rs = GPR(copy(rs_value));
16080 std::string rt = GPR(copy(rt_value));
16081
16082 return img::format("TNE %s, %s", rs, rt);
16083 }
16084
16085
16086 /*
16087 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16088 *
16089 * 3 2 1
16090 * 10987654321098765432109876543210
16091 * 001000 00010001101
16092 * rt -----
16093 * rs -----
16094 * rd -----
16095 */
16096 std::string NMD::TRUNC_L_D(uint64 instruction)
16097 {
16098 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16099 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16100
16101 std::string ft = FPR(copy(ft_value));
16102 std::string fs = FPR(copy(fs_value));
16103
16104 return img::format("TRUNC.L.D %s, %s", ft, fs);
16105 }
16106
16107
16108 /*
16109 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16110 *
16111 * 3 2 1
16112 * 10987654321098765432109876543210
16113 * 001000 00010001101
16114 * rt -----
16115 * rs -----
16116 * rd -----
16117 */
16118 std::string NMD::TRUNC_L_S(uint64 instruction)
16119 {
16120 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16121 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16122
16123 std::string ft = FPR(copy(ft_value));
16124 std::string fs = FPR(copy(fs_value));
16125
16126 return img::format("TRUNC.L.S %s, %s", ft, fs);
16127 }
16128
16129
16130 /*
16131 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16132 *
16133 * 3 2 1
16134 * 10987654321098765432109876543210
16135 * 001000 00010001101
16136 * rt -----
16137 * rs -----
16138 * rd -----
16139 */
16140 std::string NMD::TRUNC_W_D(uint64 instruction)
16141 {
16142 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16143 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16144
16145 std::string ft = FPR(copy(ft_value));
16146 std::string fs = FPR(copy(fs_value));
16147
16148 return img::format("TRUNC.W.D %s, %s", ft, fs);
16149 }
16150
16151
16152 /*
16153 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16154 *
16155 * 3 2 1
16156 * 10987654321098765432109876543210
16157 * 001000 00010001101
16158 * rt -----
16159 * rs -----
16160 * rd -----
16161 */
16162 std::string NMD::TRUNC_W_S(uint64 instruction)
16163 {
16164 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16165 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16166
16167 std::string ft = FPR(copy(ft_value));
16168 std::string fs = FPR(copy(fs_value));
16169
16170 return img::format("TRUNC.W.S %s, %s", ft, fs);
16171 }
16172
16173
16174 /*
16175 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16176 *
16177 * 3 2 1
16178 * 10987654321098765432109876543210
16179 * 001000 00010001101
16180 * rt -----
16181 * rs -----
16182 * rd -----
16183 */
16184 std::string NMD::UALDM(uint64 instruction)
16185 {
16186 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16187 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16188 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16189 uint64 count3_value = extract_count3_14_13_12(instruction);
16190
16191 std::string rt = GPR(copy(rt_value));
16192 std::string s = IMMEDIATE(copy(s_value));
16193 std::string rs = GPR(copy(rs_value));
16194 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16195
16196 return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
16197 }
16198
16199
16200 /*
16201 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16202 *
16203 * 3 2 1
16204 * 10987654321098765432109876543210
16205 * 001000 00010001101
16206 * rt -----
16207 * rs -----
16208 * rd -----
16209 */
16210 std::string NMD::UALH(uint64 instruction)
16211 {
16212 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16214 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16215
16216 std::string rt = GPR(copy(rt_value));
16217 std::string s = IMMEDIATE(copy(s_value));
16218 std::string rs = GPR(copy(rs_value));
16219
16220 return img::format("UALH %s, %s(%s)", rt, s, rs);
16221 }
16222
16223
16224 /*
16225 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16226 *
16227 * 3 2 1
16228 * 10987654321098765432109876543210
16229 * 001000 00010001101
16230 * rt -----
16231 * rs -----
16232 * rd -----
16233 */
16234 std::string NMD::UALWM(uint64 instruction)
16235 {
16236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16238 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16239 uint64 count3_value = extract_count3_14_13_12(instruction);
16240
16241 std::string rt = GPR(copy(rt_value));
16242 std::string s = IMMEDIATE(copy(s_value));
16243 std::string rs = GPR(copy(rs_value));
16244 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16245
16246 return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
16247 }
16248
16249
16250 /*
16251 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16252 *
16253 * 3 2 1
16254 * 10987654321098765432109876543210
16255 * 001000 00010001101
16256 * rt -----
16257 * rs -----
16258 * rd -----
16259 */
16260 std::string NMD::UASDM(uint64 instruction)
16261 {
16262 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16263 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16264 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16265 uint64 count3_value = extract_count3_14_13_12(instruction);
16266
16267 std::string rt = GPR(copy(rt_value));
16268 std::string s = IMMEDIATE(copy(s_value));
16269 std::string rs = GPR(copy(rs_value));
16270 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16271
16272 return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
16273 }
16274
16275
16276 /*
16277 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16278 *
16279 * 3 2 1
16280 * 10987654321098765432109876543210
16281 * 001000 00010001101
16282 * rt -----
16283 * rs -----
16284 * rd -----
16285 */
16286 std::string NMD::UASH(uint64 instruction)
16287 {
16288 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16289 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16290 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16291
16292 std::string rt = GPR(copy(rt_value));
16293 std::string s = IMMEDIATE(copy(s_value));
16294 std::string rs = GPR(copy(rs_value));
16295
16296 return img::format("UASH %s, %s(%s)", rt, s, 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 */
16310 std::string NMD::UASWM(uint64 instruction)
16311 {
16312 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16313 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16314 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16315 uint64 count3_value = extract_count3_14_13_12(instruction);
16316
16317 std::string rt = GPR(copy(rt_value));
16318 std::string s = IMMEDIATE(copy(s_value));
16319 std::string rs = GPR(copy(rs_value));
16320 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16321
16322 return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
16323 }
16324
16325
16326 /*
16327 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16328 *
16329 * 3 2 1
16330 * 10987654321098765432109876543210
16331 * 001000 00010001101
16332 * rt -----
16333 * rs -----
16334 * rd -----
16335 */
16336 std::string NMD::UDI(uint64 instruction)
16337 {
16338 uint64 op_value = extract_op_25_to_3(instruction);
16339
16340 std::string op = IMMEDIATE(copy(op_value));
16341
16342 return img::format("UDI %s", op);
16343 }
16344
16345
16346 /*
16347 * WAIT code - Enter Wait State
16348 *
16349 * 3 2 1
16350 * 10987654321098765432109876543210
16351 * 001000 1100001101111111
16352 * code ----------
16353 */
16354 std::string NMD::WAIT(uint64 instruction)
16355 {
16356 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
16357
16358 std::string code = IMMEDIATE(copy(code_value));
16359
16360 return img::format("WAIT %s", code);
16361 }
16362
16363
16364 /*
16365 * WRDSP rt, mask - Write Fields to DSPControl Register from a GPR
16366 *
16367 * 3 2 1
16368 * 10987654321098765432109876543210
16369 * 001000 01011001111111
16370 * rt -----
16371 * mask -------
16372 */
16373 std::string NMD::WRDSP(uint64 instruction)
16374 {
16375 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16376 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
16377
16378 std::string rt = GPR(copy(rt_value));
16379 std::string mask = IMMEDIATE(copy(mask_value));
16380
16381 return img::format("WRDSP %s, %s", rt, mask);
16382 }
16383
16384
16385 /*
16386 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16387 *
16388 * 3 2 1
16389 * 10987654321098765432109876543210
16390 * 001000 00010001101
16391 * rt -----
16392 * rs -----
16393 * rd -----
16394 */
16395 std::string NMD::WRPGPR(uint64 instruction)
16396 {
16397 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16398 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16399
16400 std::string rt = GPR(copy(rt_value));
16401 std::string rs = GPR(copy(rs_value));
16402
16403 return img::format("WRPGPR %s, %s", rt, rs);
16404 }
16405
16406
16407 /*
16408 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16409 *
16410 * 3 2 1
16411 * 10987654321098765432109876543210
16412 * 001000 00010001101
16413 * rt -----
16414 * rs -----
16415 * rd -----
16416 */
16417 std::string NMD::XOR_16_(uint64 instruction)
16418 {
16419 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16420 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16421
16422 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
16423 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
16424
16425 return img::format("XOR %s, %s", rs3, rt3);
16426 }
16427
16428
16429 /*
16430 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16431 *
16432 * 3 2 1
16433 * 10987654321098765432109876543210
16434 * 001000 00010001101
16435 * rt -----
16436 * rs -----
16437 * rd -----
16438 */
16439 std::string NMD::XOR_32_(uint64 instruction)
16440 {
16441 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16442 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16443 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
16444
16445 std::string rd = GPR(copy(rd_value));
16446 std::string rs = GPR(copy(rs_value));
16447 std::string rt = GPR(copy(rt_value));
16448
16449 return img::format("XOR %s, %s, %s", rd, rs, rt);
16450 }
16451
16452
16453 /*
16454 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16455 *
16456 * 3 2 1
16457 * 10987654321098765432109876543210
16458 * 001000 00010001101
16459 * rt -----
16460 * rs -----
16461 * rd -----
16462 */
16463 std::string NMD::XORI(uint64 instruction)
16464 {
16465 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16466 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16467 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
16468
16469 std::string rt = GPR(copy(rt_value));
16470 std::string rs = GPR(copy(rs_value));
16471 std::string u = IMMEDIATE(copy(u_value));
16472
16473 return img::format("XORI %s, %s, %s", rt, rs, u);
16474 }
16475
16476
16477 /*
16478 * YIELD rt, rs -
16479 *
16480 * 3 2 1
16481 * 10987654321098765432109876543210
16482 * 001000 00010001101
16483 * rt -----
16484 * rs -----
16485 */
16486 std::string NMD::YIELD(uint64 instruction)
16487 {
16488 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16489 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16490
16491 std::string rt = GPR(copy(rt_value));
16492 std::string rs = GPR(copy(rs_value));
16493
16494 return img::format("YIELD %s, %s", rt, rs);
16495 }
16496
16497
16498
16499 NMD::Pool NMD::P_SYSCALL[2] = {
16500 { instruction , 0 , 0 , 32,
16501 0xfffc0000, 0x00080000, &NMD::SYSCALL_32_ , 0,
16502 0x0 }, /* SYSCALL[32] */
16503 { instruction , 0 , 0 , 32,
16504 0xfffc0000, 0x000c0000, &NMD::HYPCALL , 0,
16505 CP0_ | VZ_ }, /* HYPCALL */
16506 };
16507
16508
16509 NMD::Pool NMD::P_RI[4] = {
16510 { instruction , 0 , 0 , 32,
16511 0xfff80000, 0x00000000, &NMD::SIGRIE , 0,
16512 0x0 }, /* SIGRIE */
16513 { pool , P_SYSCALL , 2 , 32,
16514 0xfff80000, 0x00080000, 0 , 0,
16515 0x0 }, /* P.SYSCALL */
16516 { instruction , 0 , 0 , 32,
16517 0xfff80000, 0x00100000, &NMD::BREAK_32_ , 0,
16518 0x0 }, /* BREAK[32] */
16519 { instruction , 0 , 0 , 32,
16520 0xfff80000, 0x00180000, &NMD::SDBBP_32_ , 0,
16521 EJTAG_ }, /* SDBBP[32] */
16522 };
16523
16524
16525 NMD::Pool NMD::P_ADDIU[2] = {
16526 { pool , P_RI , 4 , 32,
16527 0xffe00000, 0x00000000, 0 , 0,
16528 0x0 }, /* P.RI */
16529 { instruction , 0 , 0 , 32,
16530 0xfc000000, 0x00000000, &NMD::ADDIU_32_ , &NMD::ADDIU_32__cond ,
16531 0x0 }, /* ADDIU[32] */
16532 };
16533
16534
16535 NMD::Pool NMD::P_TRAP[2] = {
16536 { instruction , 0 , 0 , 32,
16537 0xfc0007ff, 0x20000000, &NMD::TEQ , 0,
16538 XMMS_ }, /* TEQ */
16539 { instruction , 0 , 0 , 32,
16540 0xfc0007ff, 0x20000400, &NMD::TNE , 0,
16541 XMMS_ }, /* TNE */
16542 };
16543
16544
16545 NMD::Pool NMD::P_CMOVE[2] = {
16546 { instruction , 0 , 0 , 32,
16547 0xfc0007ff, 0x20000210, &NMD::MOVZ , 0,
16548 0x0 }, /* MOVZ */
16549 { instruction , 0 , 0 , 32,
16550 0xfc0007ff, 0x20000610, &NMD::MOVN , 0,
16551 0x0 }, /* MOVN */
16552 };
16553
16554
16555 NMD::Pool NMD::P_D_MT_VPE[2] = {
16556 { instruction , 0 , 0 , 32,
16557 0xfc1f3fff, 0x20010ab0, &NMD::DMT , 0,
16558 MT_ }, /* DMT */
16559 { instruction , 0 , 0 , 32,
16560 0xfc1f3fff, 0x20000ab0, &NMD::DVPE , 0,
16561 MT_ }, /* DVPE */
16562 };
16563
16564
16565 NMD::Pool NMD::P_E_MT_VPE[2] = {
16566 { instruction , 0 , 0 , 32,
16567 0xfc1f3fff, 0x20010eb0, &NMD::EMT , 0,
16568 MT_ }, /* EMT */
16569 { instruction , 0 , 0 , 32,
16570 0xfc1f3fff, 0x20000eb0, &NMD::EVPE , 0,
16571 MT_ }, /* EVPE */
16572 };
16573
16574
16575 NMD::Pool NMD::_P_MT_VPE[2] = {
16576 { pool , P_D_MT_VPE , 2 , 32,
16577 0xfc003fff, 0x20000ab0, 0 , 0,
16578 0x0 }, /* P.D_MT_VPE */
16579 { pool , P_E_MT_VPE , 2 , 32,
16580 0xfc003fff, 0x20000eb0, 0 , 0,
16581 0x0 }, /* P.E_MT_VPE */
16582 };
16583
16584
16585 NMD::Pool NMD::P_MT_VPE[8] = {
16586 { reserved_block , 0 , 0 , 32,
16587 0xfc003bff, 0x200002b0, 0 , 0,
16588 0x0 }, /* P.MT_VPE~*(0) */
16589 { pool , _P_MT_VPE , 2 , 32,
16590 0xfc003bff, 0x20000ab0, 0 , 0,
16591 0x0 }, /* _P.MT_VPE */
16592 { reserved_block , 0 , 0 , 32,
16593 0xfc003bff, 0x200012b0, 0 , 0,
16594 0x0 }, /* P.MT_VPE~*(2) */
16595 { reserved_block , 0 , 0 , 32,
16596 0xfc003bff, 0x20001ab0, 0 , 0,
16597 0x0 }, /* P.MT_VPE~*(3) */
16598 { reserved_block , 0 , 0 , 32,
16599 0xfc003bff, 0x200022b0, 0 , 0,
16600 0x0 }, /* P.MT_VPE~*(4) */
16601 { reserved_block , 0 , 0 , 32,
16602 0xfc003bff, 0x20002ab0, 0 , 0,
16603 0x0 }, /* P.MT_VPE~*(5) */
16604 { reserved_block , 0 , 0 , 32,
16605 0xfc003bff, 0x200032b0, 0 , 0,
16606 0x0 }, /* P.MT_VPE~*(6) */
16607 { reserved_block , 0 , 0 , 32,
16608 0xfc003bff, 0x20003ab0, 0 , 0,
16609 0x0 }, /* P.MT_VPE~*(7) */
16610 };
16611
16612
16613 NMD::Pool NMD::P_DVP[2] = {
16614 { instruction , 0 , 0 , 32,
16615 0xfc00ffff, 0x20000390, &NMD::DVP , 0,
16616 0x0 }, /* DVP */
16617 { instruction , 0 , 0 , 32,
16618 0xfc00ffff, 0x20000790, &NMD::EVP , 0,
16619 0x0 }, /* EVP */
16620 };
16621
16622
16623 NMD::Pool NMD::P_SLTU[2] = {
16624 { pool , P_DVP , 2 , 32,
16625 0xfc00fbff, 0x20000390, 0 , 0,
16626 0x0 }, /* P.DVP */
16627 { instruction , 0 , 0 , 32,
16628 0xfc0003ff, 0x20000390, &NMD::SLTU , &NMD::SLTU_cond ,
16629 0x0 }, /* SLTU */
16630 };
16631
16632
16633 NMD::Pool NMD::_POOL32A0[128] = {
16634 { pool , P_TRAP , 2 , 32,
16635 0xfc0003ff, 0x20000000, 0 , 0,
16636 0x0 }, /* P.TRAP */
16637 { instruction , 0 , 0 , 32,
16638 0xfc0003ff, 0x20000008, &NMD::SEB , 0,
16639 XMMS_ }, /* SEB */
16640 { instruction , 0 , 0 , 32,
16641 0xfc0003ff, 0x20000010, &NMD::SLLV , 0,
16642 0x0 }, /* SLLV */
16643 { instruction , 0 , 0 , 32,
16644 0xfc0003ff, 0x20000018, &NMD::MUL_32_ , 0,
16645 0x0 }, /* MUL[32] */
16646 { reserved_block , 0 , 0 , 32,
16647 0xfc0003ff, 0x20000020, 0 , 0,
16648 0x0 }, /* _POOL32A0~*(4) */
16649 { reserved_block , 0 , 0 , 32,
16650 0xfc0003ff, 0x20000028, 0 , 0,
16651 0x0 }, /* _POOL32A0~*(5) */
16652 { instruction , 0 , 0 , 32,
16653 0xfc0003ff, 0x20000030, &NMD::MFC0 , 0,
16654 0x0 }, /* MFC0 */
16655 { instruction , 0 , 0 , 32,
16656 0xfc0003ff, 0x20000038, &NMD::MFHC0 , 0,
16657 CP0_ | MVH_ }, /* MFHC0 */
16658 { reserved_block , 0 , 0 , 32,
16659 0xfc0003ff, 0x20000040, 0 , 0,
16660 0x0 }, /* _POOL32A0~*(8) */
16661 { instruction , 0 , 0 , 32,
16662 0xfc0003ff, 0x20000048, &NMD::SEH , 0,
16663 0x0 }, /* SEH */
16664 { instruction , 0 , 0 , 32,
16665 0xfc0003ff, 0x20000050, &NMD::SRLV , 0,
16666 0x0 }, /* SRLV */
16667 { instruction , 0 , 0 , 32,
16668 0xfc0003ff, 0x20000058, &NMD::MUH , 0,
16669 0x0 }, /* MUH */
16670 { reserved_block , 0 , 0 , 32,
16671 0xfc0003ff, 0x20000060, 0 , 0,
16672 0x0 }, /* _POOL32A0~*(12) */
16673 { reserved_block , 0 , 0 , 32,
16674 0xfc0003ff, 0x20000068, 0 , 0,
16675 0x0 }, /* _POOL32A0~*(13) */
16676 { instruction , 0 , 0 , 32,
16677 0xfc0003ff, 0x20000070, &NMD::MTC0 , 0,
16678 CP0_ }, /* MTC0 */
16679 { instruction , 0 , 0 , 32,
16680 0xfc0003ff, 0x20000078, &NMD::MTHC0 , 0,
16681 CP0_ | MVH_ }, /* MTHC0 */
16682 { reserved_block , 0 , 0 , 32,
16683 0xfc0003ff, 0x20000080, 0 , 0,
16684 0x0 }, /* _POOL32A0~*(16) */
16685 { reserved_block , 0 , 0 , 32,
16686 0xfc0003ff, 0x20000088, 0 , 0,
16687 0x0 }, /* _POOL32A0~*(17) */
16688 { instruction , 0 , 0 , 32,
16689 0xfc0003ff, 0x20000090, &NMD::SRAV , 0,
16690 0x0 }, /* SRAV */
16691 { instruction , 0 , 0 , 32,
16692 0xfc0003ff, 0x20000098, &NMD::MULU , 0,
16693 0x0 }, /* MULU */
16694 { reserved_block , 0 , 0 , 32,
16695 0xfc0003ff, 0x200000a0, 0 , 0,
16696 0x0 }, /* _POOL32A0~*(20) */
16697 { reserved_block , 0 , 0 , 32,
16698 0xfc0003ff, 0x200000a8, 0 , 0,
16699 0x0 }, /* _POOL32A0~*(21) */
16700 { instruction , 0 , 0 , 32,
16701 0xfc0003ff, 0x200000b0, &NMD::MFGC0 , 0,
16702 CP0_ | VZ_ }, /* MFGC0 */
16703 { instruction , 0 , 0 , 32,
16704 0xfc0003ff, 0x200000b8, &NMD::MFHGC0 , 0,
16705 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16706 { reserved_block , 0 , 0 , 32,
16707 0xfc0003ff, 0x200000c0, 0 , 0,
16708 0x0 }, /* _POOL32A0~*(24) */
16709 { reserved_block , 0 , 0 , 32,
16710 0xfc0003ff, 0x200000c8, 0 , 0,
16711 0x0 }, /* _POOL32A0~*(25) */
16712 { instruction , 0 , 0 , 32,
16713 0xfc0003ff, 0x200000d0, &NMD::ROTRV , 0,
16714 0x0 }, /* ROTRV */
16715 { instruction , 0 , 0 , 32,
16716 0xfc0003ff, 0x200000d8, &NMD::MUHU , 0,
16717 0x0 }, /* MUHU */
16718 { reserved_block , 0 , 0 , 32,
16719 0xfc0003ff, 0x200000e0, 0 , 0,
16720 0x0 }, /* _POOL32A0~*(28) */
16721 { reserved_block , 0 , 0 , 32,
16722 0xfc0003ff, 0x200000e8, 0 , 0,
16723 0x0 }, /* _POOL32A0~*(29) */
16724 { instruction , 0 , 0 , 32,
16725 0xfc0003ff, 0x200000f0, &NMD::MTGC0 , 0,
16726 CP0_ | VZ_ }, /* MTGC0 */
16727 { instruction , 0 , 0 , 32,
16728 0xfc0003ff, 0x200000f8, &NMD::MTHGC0 , 0,
16729 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16730 { reserved_block , 0 , 0 , 32,
16731 0xfc0003ff, 0x20000100, 0 , 0,
16732 0x0 }, /* _POOL32A0~*(32) */
16733 { reserved_block , 0 , 0 , 32,
16734 0xfc0003ff, 0x20000108, 0 , 0,
16735 0x0 }, /* _POOL32A0~*(33) */
16736 { instruction , 0 , 0 , 32,
16737 0xfc0003ff, 0x20000110, &NMD::ADD , 0,
16738 XMMS_ }, /* ADD */
16739 { instruction , 0 , 0 , 32,
16740 0xfc0003ff, 0x20000118, &NMD::DIV , 0,
16741 0x0 }, /* DIV */
16742 { reserved_block , 0 , 0 , 32,
16743 0xfc0003ff, 0x20000120, 0 , 0,
16744 0x0 }, /* _POOL32A0~*(36) */
16745 { reserved_block , 0 , 0 , 32,
16746 0xfc0003ff, 0x20000128, 0 , 0,
16747 0x0 }, /* _POOL32A0~*(37) */
16748 { instruction , 0 , 0 , 32,
16749 0xfc0003ff, 0x20000130, &NMD::DMFC0 , 0,
16750 CP0_ | MIPS64_ }, /* DMFC0 */
16751 { reserved_block , 0 , 0 , 32,
16752 0xfc0003ff, 0x20000138, 0 , 0,
16753 0x0 }, /* _POOL32A0~*(39) */
16754 { reserved_block , 0 , 0 , 32,
16755 0xfc0003ff, 0x20000140, 0 , 0,
16756 0x0 }, /* _POOL32A0~*(40) */
16757 { reserved_block , 0 , 0 , 32,
16758 0xfc0003ff, 0x20000148, 0 , 0,
16759 0x0 }, /* _POOL32A0~*(41) */
16760 { instruction , 0 , 0 , 32,
16761 0xfc0003ff, 0x20000150, &NMD::ADDU_32_ , 0,
16762 0x0 }, /* ADDU[32] */
16763 { instruction , 0 , 0 , 32,
16764 0xfc0003ff, 0x20000158, &NMD::MOD , 0,
16765 0x0 }, /* MOD */
16766 { reserved_block , 0 , 0 , 32,
16767 0xfc0003ff, 0x20000160, 0 , 0,
16768 0x0 }, /* _POOL32A0~*(44) */
16769 { reserved_block , 0 , 0 , 32,
16770 0xfc0003ff, 0x20000168, 0 , 0,
16771 0x0 }, /* _POOL32A0~*(45) */
16772 { instruction , 0 , 0 , 32,
16773 0xfc0003ff, 0x20000170, &NMD::DMTC0 , 0,
16774 CP0_ | MIPS64_ }, /* DMTC0 */
16775 { reserved_block , 0 , 0 , 32,
16776 0xfc0003ff, 0x20000178, 0 , 0,
16777 0x0 }, /* _POOL32A0~*(47) */
16778 { reserved_block , 0 , 0 , 32,
16779 0xfc0003ff, 0x20000180, 0 , 0,
16780 0x0 }, /* _POOL32A0~*(48) */
16781 { reserved_block , 0 , 0 , 32,
16782 0xfc0003ff, 0x20000188, 0 , 0,
16783 0x0 }, /* _POOL32A0~*(49) */
16784 { instruction , 0 , 0 , 32,
16785 0xfc0003ff, 0x20000190, &NMD::SUB , 0,
16786 XMMS_ }, /* SUB */
16787 { instruction , 0 , 0 , 32,
16788 0xfc0003ff, 0x20000198, &NMD::DIVU , 0,
16789 0x0 }, /* DIVU */
16790 { reserved_block , 0 , 0 , 32,
16791 0xfc0003ff, 0x200001a0, 0 , 0,
16792 0x0 }, /* _POOL32A0~*(52) */
16793 { reserved_block , 0 , 0 , 32,
16794 0xfc0003ff, 0x200001a8, 0 , 0,
16795 0x0 }, /* _POOL32A0~*(53) */
16796 { instruction , 0 , 0 , 32,
16797 0xfc0003ff, 0x200001b0, &NMD::DMFGC0 , 0,
16798 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16799 { reserved_block , 0 , 0 , 32,
16800 0xfc0003ff, 0x200001b8, 0 , 0,
16801 0x0 }, /* _POOL32A0~*(55) */
16802 { instruction , 0 , 0 , 32,
16803 0xfc0003ff, 0x200001c0, &NMD::RDHWR , 0,
16804 XMMS_ }, /* RDHWR */
16805 { reserved_block , 0 , 0 , 32,
16806 0xfc0003ff, 0x200001c8, 0 , 0,
16807 0x0 }, /* _POOL32A0~*(57) */
16808 { instruction , 0 , 0 , 32,
16809 0xfc0003ff, 0x200001d0, &NMD::SUBU_32_ , 0,
16810 0x0 }, /* SUBU[32] */
16811 { instruction , 0 , 0 , 32,
16812 0xfc0003ff, 0x200001d8, &NMD::MODU , 0,
16813 0x0 }, /* MODU */
16814 { reserved_block , 0 , 0 , 32,
16815 0xfc0003ff, 0x200001e0, 0 , 0,
16816 0x0 }, /* _POOL32A0~*(60) */
16817 { reserved_block , 0 , 0 , 32,
16818 0xfc0003ff, 0x200001e8, 0 , 0,
16819 0x0 }, /* _POOL32A0~*(61) */
16820 { instruction , 0 , 0 , 32,
16821 0xfc0003ff, 0x200001f0, &NMD::DMTGC0 , 0,
16822 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16823 { reserved_block , 0 , 0 , 32,
16824 0xfc0003ff, 0x200001f8, 0 , 0,
16825 0x0 }, /* _POOL32A0~*(63) */
16826 { reserved_block , 0 , 0 , 32,
16827 0xfc0003ff, 0x20000200, 0 , 0,
16828 0x0 }, /* _POOL32A0~*(64) */
16829 { reserved_block , 0 , 0 , 32,
16830 0xfc0003ff, 0x20000208, 0 , 0,
16831 0x0 }, /* _POOL32A0~*(65) */
16832 { pool , P_CMOVE , 2 , 32,
16833 0xfc0003ff, 0x20000210, 0 , 0,
16834 0x0 }, /* P.CMOVE */
16835 { reserved_block , 0 , 0 , 32,
16836 0xfc0003ff, 0x20000218, 0 , 0,
16837 0x0 }, /* _POOL32A0~*(67) */
16838 { reserved_block , 0 , 0 , 32,
16839 0xfc0003ff, 0x20000220, 0 , 0,
16840 0x0 }, /* _POOL32A0~*(68) */
16841 { instruction , 0 , 0 , 32,
16842 0xfc0003ff, 0x20000228, &NMD::FORK , 0,
16843 MT_ }, /* FORK */
16844 { instruction , 0 , 0 , 32,
16845 0xfc0003ff, 0x20000230, &NMD::MFTR , 0,
16846 MT_ }, /* MFTR */
16847 { instruction , 0 , 0 , 32,
16848 0xfc0003ff, 0x20000238, &NMD::MFHTR , 0,
16849 MT_ }, /* MFHTR */
16850 { reserved_block , 0 , 0 , 32,
16851 0xfc0003ff, 0x20000240, 0 , 0,
16852 0x0 }, /* _POOL32A0~*(72) */
16853 { reserved_block , 0 , 0 , 32,
16854 0xfc0003ff, 0x20000248, 0 , 0,
16855 0x0 }, /* _POOL32A0~*(73) */
16856 { instruction , 0 , 0 , 32,
16857 0xfc0003ff, 0x20000250, &NMD::AND_32_ , 0,
16858 0x0 }, /* AND[32] */
16859 { reserved_block , 0 , 0 , 32,
16860 0xfc0003ff, 0x20000258, 0 , 0,
16861 0x0 }, /* _POOL32A0~*(75) */
16862 { reserved_block , 0 , 0 , 32,
16863 0xfc0003ff, 0x20000260, 0 , 0,
16864 0x0 }, /* _POOL32A0~*(76) */
16865 { instruction , 0 , 0 , 32,
16866 0xfc0003ff, 0x20000268, &NMD::YIELD , 0,
16867 MT_ }, /* YIELD */
16868 { instruction , 0 , 0 , 32,
16869 0xfc0003ff, 0x20000270, &NMD::MTTR , 0,
16870 MT_ }, /* MTTR */
16871 { instruction , 0 , 0 , 32,
16872 0xfc0003ff, 0x20000278, &NMD::MTHTR , 0,
16873 MT_ }, /* MTHTR */
16874 { reserved_block , 0 , 0 , 32,
16875 0xfc0003ff, 0x20000280, 0 , 0,
16876 0x0 }, /* _POOL32A0~*(80) */
16877 { reserved_block , 0 , 0 , 32,
16878 0xfc0003ff, 0x20000288, 0 , 0,
16879 0x0 }, /* _POOL32A0~*(81) */
16880 { instruction , 0 , 0 , 32,
16881 0xfc0003ff, 0x20000290, &NMD::OR_32_ , 0,
16882 0x0 }, /* OR[32] */
16883 { reserved_block , 0 , 0 , 32,
16884 0xfc0003ff, 0x20000298, 0 , 0,
16885 0x0 }, /* _POOL32A0~*(83) */
16886 { reserved_block , 0 , 0 , 32,
16887 0xfc0003ff, 0x200002a0, 0 , 0,
16888 0x0 }, /* _POOL32A0~*(84) */
16889 { reserved_block , 0 , 0 , 32,
16890 0xfc0003ff, 0x200002a8, 0 , 0,
16891 0x0 }, /* _POOL32A0~*(85) */
16892 { pool , P_MT_VPE , 8 , 32,
16893 0xfc0003ff, 0x200002b0, 0 , 0,
16894 0x0 }, /* P.MT_VPE */
16895 { reserved_block , 0 , 0 , 32,
16896 0xfc0003ff, 0x200002b8, 0 , 0,
16897 0x0 }, /* _POOL32A0~*(87) */
16898 { reserved_block , 0 , 0 , 32,
16899 0xfc0003ff, 0x200002c0, 0 , 0,
16900 0x0 }, /* _POOL32A0~*(88) */
16901 { reserved_block , 0 , 0 , 32,
16902 0xfc0003ff, 0x200002c8, 0 , 0,
16903 0x0 }, /* _POOL32A0~*(89) */
16904 { instruction , 0 , 0 , 32,
16905 0xfc0003ff, 0x200002d0, &NMD::NOR , 0,
16906 0x0 }, /* NOR */
16907 { reserved_block , 0 , 0 , 32,
16908 0xfc0003ff, 0x200002d8, 0 , 0,
16909 0x0 }, /* _POOL32A0~*(91) */
16910 { reserved_block , 0 , 0 , 32,
16911 0xfc0003ff, 0x200002e0, 0 , 0,
16912 0x0 }, /* _POOL32A0~*(92) */
16913 { reserved_block , 0 , 0 , 32,
16914 0xfc0003ff, 0x200002e8, 0 , 0,
16915 0x0 }, /* _POOL32A0~*(93) */
16916 { reserved_block , 0 , 0 , 32,
16917 0xfc0003ff, 0x200002f0, 0 , 0,
16918 0x0 }, /* _POOL32A0~*(94) */
16919 { reserved_block , 0 , 0 , 32,
16920 0xfc0003ff, 0x200002f8, 0 , 0,
16921 0x0 }, /* _POOL32A0~*(95) */
16922 { reserved_block , 0 , 0 , 32,
16923 0xfc0003ff, 0x20000300, 0 , 0,
16924 0x0 }, /* _POOL32A0~*(96) */
16925 { reserved_block , 0 , 0 , 32,
16926 0xfc0003ff, 0x20000308, 0 , 0,
16927 0x0 }, /* _POOL32A0~*(97) */
16928 { instruction , 0 , 0 , 32,
16929 0xfc0003ff, 0x20000310, &NMD::XOR_32_ , 0,
16930 0x0 }, /* XOR[32] */
16931 { reserved_block , 0 , 0 , 32,
16932 0xfc0003ff, 0x20000318, 0 , 0,
16933 0x0 }, /* _POOL32A0~*(99) */
16934 { reserved_block , 0 , 0 , 32,
16935 0xfc0003ff, 0x20000320, 0 , 0,
16936 0x0 }, /* _POOL32A0~*(100) */
16937 { reserved_block , 0 , 0 , 32,
16938 0xfc0003ff, 0x20000328, 0 , 0,
16939 0x0 }, /* _POOL32A0~*(101) */
16940 { reserved_block , 0 , 0 , 32,
16941 0xfc0003ff, 0x20000330, 0 , 0,
16942 0x0 }, /* _POOL32A0~*(102) */
16943 { reserved_block , 0 , 0 , 32,
16944 0xfc0003ff, 0x20000338, 0 , 0,
16945 0x0 }, /* _POOL32A0~*(103) */
16946 { reserved_block , 0 , 0 , 32,
16947 0xfc0003ff, 0x20000340, 0 , 0,
16948 0x0 }, /* _POOL32A0~*(104) */
16949 { reserved_block , 0 , 0 , 32,
16950 0xfc0003ff, 0x20000348, 0 , 0,
16951 0x0 }, /* _POOL32A0~*(105) */
16952 { instruction , 0 , 0 , 32,
16953 0xfc0003ff, 0x20000350, &NMD::SLT , 0,
16954 0x0 }, /* SLT */
16955 { reserved_block , 0 , 0 , 32,
16956 0xfc0003ff, 0x20000358, 0 , 0,
16957 0x0 }, /* _POOL32A0~*(107) */
16958 { reserved_block , 0 , 0 , 32,
16959 0xfc0003ff, 0x20000360, 0 , 0,
16960 0x0 }, /* _POOL32A0~*(108) */
16961 { reserved_block , 0 , 0 , 32,
16962 0xfc0003ff, 0x20000368, 0 , 0,
16963 0x0 }, /* _POOL32A0~*(109) */
16964 { reserved_block , 0 , 0 , 32,
16965 0xfc0003ff, 0x20000370, 0 , 0,
16966 0x0 }, /* _POOL32A0~*(110) */
16967 { reserved_block , 0 , 0 , 32,
16968 0xfc0003ff, 0x20000378, 0 , 0,
16969 0x0 }, /* _POOL32A0~*(111) */
16970 { reserved_block , 0 , 0 , 32,
16971 0xfc0003ff, 0x20000380, 0 , 0,
16972 0x0 }, /* _POOL32A0~*(112) */
16973 { reserved_block , 0 , 0 , 32,
16974 0xfc0003ff, 0x20000388, 0 , 0,
16975 0x0 }, /* _POOL32A0~*(113) */
16976 { pool , P_SLTU , 2 , 32,
16977 0xfc0003ff, 0x20000390, 0 , 0,
16978 0x0 }, /* P.SLTU */
16979 { reserved_block , 0 , 0 , 32,
16980 0xfc0003ff, 0x20000398, 0 , 0,
16981 0x0 }, /* _POOL32A0~*(115) */
16982 { reserved_block , 0 , 0 , 32,
16983 0xfc0003ff, 0x200003a0, 0 , 0,
16984 0x0 }, /* _POOL32A0~*(116) */
16985 { reserved_block , 0 , 0 , 32,
16986 0xfc0003ff, 0x200003a8, 0 , 0,
16987 0x0 }, /* _POOL32A0~*(117) */
16988 { reserved_block , 0 , 0 , 32,
16989 0xfc0003ff, 0x200003b0, 0 , 0,
16990 0x0 }, /* _POOL32A0~*(118) */
16991 { reserved_block , 0 , 0 , 32,
16992 0xfc0003ff, 0x200003b8, 0 , 0,
16993 0x0 }, /* _POOL32A0~*(119) */
16994 { reserved_block , 0 , 0 , 32,
16995 0xfc0003ff, 0x200003c0, 0 , 0,
16996 0x0 }, /* _POOL32A0~*(120) */
16997 { reserved_block , 0 , 0 , 32,
16998 0xfc0003ff, 0x200003c8, 0 , 0,
16999 0x0 }, /* _POOL32A0~*(121) */
17000 { instruction , 0 , 0 , 32,
17001 0xfc0003ff, 0x200003d0, &NMD::SOV , 0,
17002 0x0 }, /* SOV */
17003 { reserved_block , 0 , 0 , 32,
17004 0xfc0003ff, 0x200003d8, 0 , 0,
17005 0x0 }, /* _POOL32A0~*(123) */
17006 { reserved_block , 0 , 0 , 32,
17007 0xfc0003ff, 0x200003e0, 0 , 0,
17008 0x0 }, /* _POOL32A0~*(124) */
17009 { reserved_block , 0 , 0 , 32,
17010 0xfc0003ff, 0x200003e8, 0 , 0,
17011 0x0 }, /* _POOL32A0~*(125) */
17012 { reserved_block , 0 , 0 , 32,
17013 0xfc0003ff, 0x200003f0, 0 , 0,
17014 0x0 }, /* _POOL32A0~*(126) */
17015 { reserved_block , 0 , 0 , 32,
17016 0xfc0003ff, 0x200003f8, 0 , 0,
17017 0x0 }, /* _POOL32A0~*(127) */
17018 };
17019
17020
17021 NMD::Pool NMD::ADDQ__S__PH[2] = {
17022 { instruction , 0 , 0 , 32,
17023 0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH , 0,
17024 DSP_ }, /* ADDQ.PH */
17025 { instruction , 0 , 0 , 32,
17026 0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH , 0,
17027 DSP_ }, /* ADDQ_S.PH */
17028 };
17029
17030
17031 NMD::Pool NMD::MUL__S__PH[2] = {
17032 { instruction , 0 , 0 , 32,
17033 0xfc0007ff, 0x2000002d, &NMD::MUL_PH , 0,
17034 DSP_ }, /* MUL.PH */
17035 { instruction , 0 , 0 , 32,
17036 0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH , 0,
17037 DSP_ }, /* MUL_S.PH */
17038 };
17039
17040
17041 NMD::Pool NMD::ADDQH__R__PH[2] = {
17042 { instruction , 0 , 0 , 32,
17043 0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH , 0,
17044 DSP_ }, /* ADDQH.PH */
17045 { instruction , 0 , 0 , 32,
17046 0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH , 0,
17047 DSP_ }, /* ADDQH_R.PH */
17048 };
17049
17050
17051 NMD::Pool NMD::ADDQH__R__W[2] = {
17052 { instruction , 0 , 0 , 32,
17053 0xfc0007ff, 0x2000008d, &NMD::ADDQH_W , 0,
17054 DSP_ }, /* ADDQH.W */
17055 { instruction , 0 , 0 , 32,
17056 0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W , 0,
17057 DSP_ }, /* ADDQH_R.W */
17058 };
17059
17060
17061 NMD::Pool NMD::ADDU__S__QB[2] = {
17062 { instruction , 0 , 0 , 32,
17063 0xfc0007ff, 0x200000cd, &NMD::ADDU_QB , 0,
17064 DSP_ }, /* ADDU.QB */
17065 { instruction , 0 , 0 , 32,
17066 0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB , 0,
17067 DSP_ }, /* ADDU_S.QB */
17068 };
17069
17070
17071 NMD::Pool NMD::ADDU__S__PH[2] = {
17072 { instruction , 0 , 0 , 32,
17073 0xfc0007ff, 0x2000010d, &NMD::ADDU_PH , 0,
17074 DSP_ }, /* ADDU.PH */
17075 { instruction , 0 , 0 , 32,
17076 0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH , 0,
17077 DSP_ }, /* ADDU_S.PH */
17078 };
17079
17080
17081 NMD::Pool NMD::ADDUH__R__QB[2] = {
17082 { instruction , 0 , 0 , 32,
17083 0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB , 0,
17084 DSP_ }, /* ADDUH.QB */
17085 { instruction , 0 , 0 , 32,
17086 0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB , 0,
17087 DSP_ }, /* ADDUH_R.QB */
17088 };
17089
17090
17091 NMD::Pool NMD::SHRAV__R__PH[2] = {
17092 { instruction , 0 , 0 , 32,
17093 0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH , 0,
17094 DSP_ }, /* SHRAV.PH */
17095 { instruction , 0 , 0 , 32,
17096 0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH , 0,
17097 DSP_ }, /* SHRAV_R.PH */
17098 };
17099
17100
17101 NMD::Pool NMD::SHRAV__R__QB[2] = {
17102 { instruction , 0 , 0 , 32,
17103 0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB , 0,
17104 DSP_ }, /* SHRAV.QB */
17105 { instruction , 0 , 0 , 32,
17106 0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB , 0,
17107 DSP_ }, /* SHRAV_R.QB */
17108 };
17109
17110
17111 NMD::Pool NMD::SUBQ__S__PH[2] = {
17112 { instruction , 0 , 0 , 32,
17113 0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH , 0,
17114 DSP_ }, /* SUBQ.PH */
17115 { instruction , 0 , 0 , 32,
17116 0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH , 0,
17117 DSP_ }, /* SUBQ_S.PH */
17118 };
17119
17120
17121 NMD::Pool NMD::SUBQH__R__PH[2] = {
17122 { instruction , 0 , 0 , 32,
17123 0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH , 0,
17124 DSP_ }, /* SUBQH.PH */
17125 { instruction , 0 , 0 , 32,
17126 0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH , 0,
17127 DSP_ }, /* SUBQH_R.PH */
17128 };
17129
17130
17131 NMD::Pool NMD::SUBQH__R__W[2] = {
17132 { instruction , 0 , 0 , 32,
17133 0xfc0007ff, 0x2000028d, &NMD::SUBQH_W , 0,
17134 DSP_ }, /* SUBQH.W */
17135 { instruction , 0 , 0 , 32,
17136 0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W , 0,
17137 DSP_ }, /* SUBQH_R.W */
17138 };
17139
17140
17141 NMD::Pool NMD::SUBU__S__QB[2] = {
17142 { instruction , 0 , 0 , 32,
17143 0xfc0007ff, 0x200002cd, &NMD::SUBU_QB , 0,
17144 DSP_ }, /* SUBU.QB */
17145 { instruction , 0 , 0 , 32,
17146 0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB , 0,
17147 DSP_ }, /* SUBU_S.QB */
17148 };
17149
17150
17151 NMD::Pool NMD::SUBU__S__PH[2] = {
17152 { instruction , 0 , 0 , 32,
17153 0xfc0007ff, 0x2000030d, &NMD::SUBU_PH , 0,
17154 DSP_ }, /* SUBU.PH */
17155 { instruction , 0 , 0 , 32,
17156 0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH , 0,
17157 DSP_ }, /* SUBU_S.PH */
17158 };
17159
17160
17161 NMD::Pool NMD::SHRA__R__PH[2] = {
17162 { instruction , 0 , 0 , 32,
17163 0xfc0007ff, 0x20000335, &NMD::SHRA_PH , 0,
17164 DSP_ }, /* SHRA.PH */
17165 { instruction , 0 , 0 , 32,
17166 0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH , 0,
17167 DSP_ }, /* SHRA_R.PH */
17168 };
17169
17170
17171 NMD::Pool NMD::SUBUH__R__QB[2] = {
17172 { instruction , 0 , 0 , 32,
17173 0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB , 0,
17174 DSP_ }, /* SUBUH.QB */
17175 { instruction , 0 , 0 , 32,
17176 0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB , 0,
17177 DSP_ }, /* SUBUH_R.QB */
17178 };
17179
17180
17181 NMD::Pool NMD::SHLLV__S__PH[2] = {
17182 { instruction , 0 , 0 , 32,
17183 0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH , 0,
17184 DSP_ }, /* SHLLV.PH */
17185 { instruction , 0 , 0 , 32,
17186 0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH , 0,
17187 DSP_ }, /* SHLLV_S.PH */
17188 };
17189
17190
17191 NMD::Pool NMD::SHLL__S__PH[4] = {
17192 { instruction , 0 , 0 , 32,
17193 0xfc000fff, 0x200003b5, &NMD::SHLL_PH , 0,
17194 DSP_ }, /* SHLL.PH */
17195 { reserved_block , 0 , 0 , 32,
17196 0xfc000fff, 0x200007b5, 0 , 0,
17197 0x0 }, /* SHLL[_S].PH~*(1) */
17198 { instruction , 0 , 0 , 32,
17199 0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH , 0,
17200 DSP_ }, /* SHLL_S.PH */
17201 { reserved_block , 0 , 0 , 32,
17202 0xfc000fff, 0x20000fb5, 0 , 0,
17203 0x0 }, /* SHLL[_S].PH~*(3) */
17204 };
17205
17206
17207 NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
17208 { instruction , 0 , 0 , 32,
17209 0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W , 0,
17210 DSP_ }, /* PRECR_SRA.PH.W */
17211 { instruction , 0 , 0 , 32,
17212 0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
17213 DSP_ }, /* PRECR_SRA_R.PH.W */
17214 };
17215
17216
17217 NMD::Pool NMD::_POOL32A5[128] = {
17218 { instruction , 0 , 0 , 32,
17219 0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH , 0,
17220 DSP_ }, /* CMP.EQ.PH */
17221 { pool , ADDQ__S__PH , 2 , 32,
17222 0xfc0003ff, 0x2000000d, 0 , 0,
17223 0x0 }, /* ADDQ[_S].PH */
17224 { reserved_block , 0 , 0 , 32,
17225 0xfc0003ff, 0x20000015, 0 , 0,
17226 0x0 }, /* _POOL32A5~*(2) */
17227 { instruction , 0 , 0 , 32,
17228 0xfc0003ff, 0x2000001d, &NMD::SHILO , 0,
17229 DSP_ }, /* SHILO */
17230 { instruction , 0 , 0 , 32,
17231 0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL , 0,
17232 DSP_ }, /* MULEQ_S.W.PHL */
17233 { pool , MUL__S__PH , 2 , 32,
17234 0xfc0003ff, 0x2000002d, 0 , 0,
17235 0x0 }, /* MUL[_S].PH */
17236 { reserved_block , 0 , 0 , 32,
17237 0xfc0003ff, 0x20000035, 0 , 0,
17238 0x0 }, /* _POOL32A5~*(6) */
17239 { instruction , 0 , 0 , 32,
17240 0xfc0003ff, 0x2000003d, &NMD::REPL_PH , 0,
17241 DSP_ }, /* REPL.PH */
17242 { instruction , 0 , 0 , 32,
17243 0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH , 0,
17244 DSP_ }, /* CMP.LT.PH */
17245 { pool , ADDQH__R__PH , 2 , 32,
17246 0xfc0003ff, 0x2000004d, 0 , 0,
17247 0x0 }, /* ADDQH[_R].PH */
17248 { reserved_block , 0 , 0 , 32,
17249 0xfc0003ff, 0x20000055, 0 , 0,
17250 0x0 }, /* _POOL32A5~*(10) */
17251 { reserved_block , 0 , 0 , 32,
17252 0xfc0003ff, 0x2000005d, 0 , 0,
17253 0x0 }, /* _POOL32A5~*(11) */
17254 { instruction , 0 , 0 , 32,
17255 0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR , 0,
17256 DSP_ }, /* MULEQ_S.W.PHR */
17257 { instruction , 0 , 0 , 32,
17258 0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH , 0,
17259 DSP_ }, /* PRECR.QB.PH */
17260 { reserved_block , 0 , 0 , 32,
17261 0xfc0003ff, 0x20000075, 0 , 0,
17262 0x0 }, /* _POOL32A5~*(14) */
17263 { reserved_block , 0 , 0 , 32,
17264 0xfc0003ff, 0x2000007d, 0 , 0,
17265 0x0 }, /* _POOL32A5~*(15) */
17266 { instruction , 0 , 0 , 32,
17267 0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH , 0,
17268 DSP_ }, /* CMP.LE.PH */
17269 { pool , ADDQH__R__W , 2 , 32,
17270 0xfc0003ff, 0x2000008d, 0 , 0,
17271 0x0 }, /* ADDQH[_R].W */
17272 { instruction , 0 , 0 , 32,
17273 0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL , 0,
17274 DSP_ }, /* MULEU_S.PH.QBL */
17275 { reserved_block , 0 , 0 , 32,
17276 0xfc0003ff, 0x2000009d, 0 , 0,
17277 0x0 }, /* _POOL32A5~*(19) */
17278 { reserved_block , 0 , 0 , 32,
17279 0xfc0003ff, 0x200000a5, 0 , 0,
17280 0x0 }, /* _POOL32A5~*(20) */
17281 { instruction , 0 , 0 , 32,
17282 0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH , 0,
17283 DSP_ }, /* PRECRQ.QB.PH */
17284 { reserved_block , 0 , 0 , 32,
17285 0xfc0003ff, 0x200000b5, 0 , 0,
17286 0x0 }, /* _POOL32A5~*(22) */
17287 { reserved_block , 0 , 0 , 32,
17288 0xfc0003ff, 0x200000bd, 0 , 0,
17289 0x0 }, /* _POOL32A5~*(23) */
17290 { instruction , 0 , 0 , 32,
17291 0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB , 0,
17292 DSP_ }, /* CMPGU.EQ.QB */
17293 { pool , ADDU__S__QB , 2 , 32,
17294 0xfc0003ff, 0x200000cd, 0 , 0,
17295 0x0 }, /* ADDU[_S].QB */
17296 { instruction , 0 , 0 , 32,
17297 0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR , 0,
17298 DSP_ }, /* MULEU_S.PH.QBR */
17299 { reserved_block , 0 , 0 , 32,
17300 0xfc0003ff, 0x200000dd, 0 , 0,
17301 0x0 }, /* _POOL32A5~*(27) */
17302 { reserved_block , 0 , 0 , 32,
17303 0xfc0003ff, 0x200000e5, 0 , 0,
17304 0x0 }, /* _POOL32A5~*(28) */
17305 { instruction , 0 , 0 , 32,
17306 0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W , 0,
17307 DSP_ }, /* PRECRQ.PH.W */
17308 { reserved_block , 0 , 0 , 32,
17309 0xfc0003ff, 0x200000f5, 0 , 0,
17310 0x0 }, /* _POOL32A5~*(30) */
17311 { reserved_block , 0 , 0 , 32,
17312 0xfc0003ff, 0x200000fd, 0 , 0,
17313 0x0 }, /* _POOL32A5~*(31) */
17314 { instruction , 0 , 0 , 32,
17315 0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB , 0,
17316 DSP_ }, /* CMPGU.LT.QB */
17317 { pool , ADDU__S__PH , 2 , 32,
17318 0xfc0003ff, 0x2000010d, 0 , 0,
17319 0x0 }, /* ADDU[_S].PH */
17320 { instruction , 0 , 0 , 32,
17321 0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH , 0,
17322 DSP_ }, /* MULQ_RS.PH */
17323 { reserved_block , 0 , 0 , 32,
17324 0xfc0003ff, 0x2000011d, 0 , 0,
17325 0x0 }, /* _POOL32A5~*(35) */
17326 { reserved_block , 0 , 0 , 32,
17327 0xfc0003ff, 0x20000125, 0 , 0,
17328 0x0 }, /* _POOL32A5~*(36) */
17329 { instruction , 0 , 0 , 32,
17330 0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W , 0,
17331 DSP_ }, /* PRECRQ_RS.PH.W */
17332 { reserved_block , 0 , 0 , 32,
17333 0xfc0003ff, 0x20000135, 0 , 0,
17334 0x0 }, /* _POOL32A5~*(38) */
17335 { reserved_block , 0 , 0 , 32,
17336 0xfc0003ff, 0x2000013d, 0 , 0,
17337 0x0 }, /* _POOL32A5~*(39) */
17338 { instruction , 0 , 0 , 32,
17339 0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB , 0,
17340 DSP_ }, /* CMPGU.LE.QB */
17341 { pool , ADDUH__R__QB , 2 , 32,
17342 0xfc0003ff, 0x2000014d, 0 , 0,
17343 0x0 }, /* ADDUH[_R].QB */
17344 { instruction , 0 , 0 , 32,
17345 0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH , 0,
17346 DSP_ }, /* MULQ_S.PH */
17347 { reserved_block , 0 , 0 , 32,
17348 0xfc0003ff, 0x2000015d, 0 , 0,
17349 0x0 }, /* _POOL32A5~*(43) */
17350 { reserved_block , 0 , 0 , 32,
17351 0xfc0003ff, 0x20000165, 0 , 0,
17352 0x0 }, /* _POOL32A5~*(44) */
17353 { instruction , 0 , 0 , 32,
17354 0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH , 0,
17355 DSP_ }, /* PRECRQU_S.QB.PH */
17356 { reserved_block , 0 , 0 , 32,
17357 0xfc0003ff, 0x20000175, 0 , 0,
17358 0x0 }, /* _POOL32A5~*(46) */
17359 { reserved_block , 0 , 0 , 32,
17360 0xfc0003ff, 0x2000017d, 0 , 0,
17361 0x0 }, /* _POOL32A5~*(47) */
17362 { instruction , 0 , 0 , 32,
17363 0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB , 0,
17364 DSP_ }, /* CMPGDU.EQ.QB */
17365 { pool , SHRAV__R__PH , 2 , 32,
17366 0xfc0003ff, 0x2000018d, 0 , 0,
17367 0x0 }, /* SHRAV[_R].PH */
17368 { instruction , 0 , 0 , 32,
17369 0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W , 0,
17370 DSP_ }, /* MULQ_RS.W */
17371 { reserved_block , 0 , 0 , 32,
17372 0xfc0003ff, 0x2000019d, 0 , 0,
17373 0x0 }, /* _POOL32A5~*(51) */
17374 { reserved_block , 0 , 0 , 32,
17375 0xfc0003ff, 0x200001a5, 0 , 0,
17376 0x0 }, /* _POOL32A5~*(52) */
17377 { instruction , 0 , 0 , 32,
17378 0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH , 0,
17379 DSP_ }, /* PACKRL.PH */
17380 { reserved_block , 0 , 0 , 32,
17381 0xfc0003ff, 0x200001b5, 0 , 0,
17382 0x0 }, /* _POOL32A5~*(54) */
17383 { reserved_block , 0 , 0 , 32,
17384 0xfc0003ff, 0x200001bd, 0 , 0,
17385 0x0 }, /* _POOL32A5~*(55) */
17386 { instruction , 0 , 0 , 32,
17387 0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB , 0,
17388 DSP_ }, /* CMPGDU.LT.QB */
17389 { pool , SHRAV__R__QB , 2 , 32,
17390 0xfc0003ff, 0x200001cd, 0 , 0,
17391 0x0 }, /* SHRAV[_R].QB */
17392 { instruction , 0 , 0 , 32,
17393 0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W , 0,
17394 DSP_ }, /* MULQ_S.W */
17395 { reserved_block , 0 , 0 , 32,
17396 0xfc0003ff, 0x200001dd, 0 , 0,
17397 0x0 }, /* _POOL32A5~*(59) */
17398 { reserved_block , 0 , 0 , 32,
17399 0xfc0003ff, 0x200001e5, 0 , 0,
17400 0x0 }, /* _POOL32A5~*(60) */
17401 { instruction , 0 , 0 , 32,
17402 0xfc0003ff, 0x200001ed, &NMD::PICK_QB , 0,
17403 DSP_ }, /* PICK.QB */
17404 { reserved_block , 0 , 0 , 32,
17405 0xfc0003ff, 0x200001f5, 0 , 0,
17406 0x0 }, /* _POOL32A5~*(62) */
17407 { reserved_block , 0 , 0 , 32,
17408 0xfc0003ff, 0x200001fd, 0 , 0,
17409 0x0 }, /* _POOL32A5~*(63) */
17410 { instruction , 0 , 0 , 32,
17411 0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB , 0,
17412 DSP_ }, /* CMPGDU.LE.QB */
17413 { pool , SUBQ__S__PH , 2 , 32,
17414 0xfc0003ff, 0x2000020d, 0 , 0,
17415 0x0 }, /* SUBQ[_S].PH */
17416 { instruction , 0 , 0 , 32,
17417 0xfc0003ff, 0x20000215, &NMD::APPEND , 0,
17418 DSP_ }, /* APPEND */
17419 { reserved_block , 0 , 0 , 32,
17420 0xfc0003ff, 0x2000021d, 0 , 0,
17421 0x0 }, /* _POOL32A5~*(67) */
17422 { reserved_block , 0 , 0 , 32,
17423 0xfc0003ff, 0x20000225, 0 , 0,
17424 0x0 }, /* _POOL32A5~*(68) */
17425 { instruction , 0 , 0 , 32,
17426 0xfc0003ff, 0x2000022d, &NMD::PICK_PH , 0,
17427 DSP_ }, /* PICK.PH */
17428 { reserved_block , 0 , 0 , 32,
17429 0xfc0003ff, 0x20000235, 0 , 0,
17430 0x0 }, /* _POOL32A5~*(70) */
17431 { reserved_block , 0 , 0 , 32,
17432 0xfc0003ff, 0x2000023d, 0 , 0,
17433 0x0 }, /* _POOL32A5~*(71) */
17434 { instruction , 0 , 0 , 32,
17435 0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB , 0,
17436 DSP_ }, /* CMPU.EQ.QB */
17437 { pool , SUBQH__R__PH , 2 , 32,
17438 0xfc0003ff, 0x2000024d, 0 , 0,
17439 0x0 }, /* SUBQH[_R].PH */
17440 { instruction , 0 , 0 , 32,
17441 0xfc0003ff, 0x20000255, &NMD::PREPEND , 0,
17442 DSP_ }, /* PREPEND */
17443 { reserved_block , 0 , 0 , 32,
17444 0xfc0003ff, 0x2000025d, 0 , 0,
17445 0x0 }, /* _POOL32A5~*(75) */
17446 { reserved_block , 0 , 0 , 32,
17447 0xfc0003ff, 0x20000265, 0 , 0,
17448 0x0 }, /* _POOL32A5~*(76) */
17449 { reserved_block , 0 , 0 , 32,
17450 0xfc0003ff, 0x2000026d, 0 , 0,
17451 0x0 }, /* _POOL32A5~*(77) */
17452 { reserved_block , 0 , 0 , 32,
17453 0xfc0003ff, 0x20000275, 0 , 0,
17454 0x0 }, /* _POOL32A5~*(78) */
17455 { reserved_block , 0 , 0 , 32,
17456 0xfc0003ff, 0x2000027d, 0 , 0,
17457 0x0 }, /* _POOL32A5~*(79) */
17458 { instruction , 0 , 0 , 32,
17459 0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB , 0,
17460 DSP_ }, /* CMPU.LT.QB */
17461 { pool , SUBQH__R__W , 2 , 32,
17462 0xfc0003ff, 0x2000028d, 0 , 0,
17463 0x0 }, /* SUBQH[_R].W */
17464 { instruction , 0 , 0 , 32,
17465 0xfc0003ff, 0x20000295, &NMD::MODSUB , 0,
17466 DSP_ }, /* MODSUB */
17467 { reserved_block , 0 , 0 , 32,
17468 0xfc0003ff, 0x2000029d, 0 , 0,
17469 0x0 }, /* _POOL32A5~*(83) */
17470 { reserved_block , 0 , 0 , 32,
17471 0xfc0003ff, 0x200002a5, 0 , 0,
17472 0x0 }, /* _POOL32A5~*(84) */
17473 { reserved_block , 0 , 0 , 32,
17474 0xfc0003ff, 0x200002ad, 0 , 0,
17475 0x0 }, /* _POOL32A5~*(85) */
17476 { reserved_block , 0 , 0 , 32,
17477 0xfc0003ff, 0x200002b5, 0 , 0,
17478 0x0 }, /* _POOL32A5~*(86) */
17479 { reserved_block , 0 , 0 , 32,
17480 0xfc0003ff, 0x200002bd, 0 , 0,
17481 0x0 }, /* _POOL32A5~*(87) */
17482 { instruction , 0 , 0 , 32,
17483 0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB , 0,
17484 DSP_ }, /* CMPU.LE.QB */
17485 { pool , SUBU__S__QB , 2 , 32,
17486 0xfc0003ff, 0x200002cd, 0 , 0,
17487 0x0 }, /* SUBU[_S].QB */
17488 { instruction , 0 , 0 , 32,
17489 0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W , 0,
17490 DSP_ }, /* SHRAV_R.W */
17491 { reserved_block , 0 , 0 , 32,
17492 0xfc0003ff, 0x200002dd, 0 , 0,
17493 0x0 }, /* _POOL32A5~*(91) */
17494 { reserved_block , 0 , 0 , 32,
17495 0xfc0003ff, 0x200002e5, 0 , 0,
17496 0x0 }, /* _POOL32A5~*(92) */
17497 { reserved_block , 0 , 0 , 32,
17498 0xfc0003ff, 0x200002ed, 0 , 0,
17499 0x0 }, /* _POOL32A5~*(93) */
17500 { instruction , 0 , 0 , 32,
17501 0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W , 0,
17502 DSP_ }, /* SHRA_R.W */
17503 { reserved_block , 0 , 0 , 32,
17504 0xfc0003ff, 0x200002fd, 0 , 0,
17505 0x0 }, /* _POOL32A5~*(95) */
17506 { instruction , 0 , 0 , 32,
17507 0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W , 0,
17508 DSP_ }, /* ADDQ_S.W */
17509 { pool , SUBU__S__PH , 2 , 32,
17510 0xfc0003ff, 0x2000030d, 0 , 0,
17511 0x0 }, /* SUBU[_S].PH */
17512 { instruction , 0 , 0 , 32,
17513 0xfc0003ff, 0x20000315, &NMD::SHRLV_PH , 0,
17514 DSP_ }, /* SHRLV.PH */
17515 { reserved_block , 0 , 0 , 32,
17516 0xfc0003ff, 0x2000031d, 0 , 0,
17517 0x0 }, /* _POOL32A5~*(99) */
17518 { reserved_block , 0 , 0 , 32,
17519 0xfc0003ff, 0x20000325, 0 , 0,
17520 0x0 }, /* _POOL32A5~*(100) */
17521 { reserved_block , 0 , 0 , 32,
17522 0xfc0003ff, 0x2000032d, 0 , 0,
17523 0x0 }, /* _POOL32A5~*(101) */
17524 { pool , SHRA__R__PH , 2 , 32,
17525 0xfc0003ff, 0x20000335, 0 , 0,
17526 0x0 }, /* SHRA[_R].PH */
17527 { reserved_block , 0 , 0 , 32,
17528 0xfc0003ff, 0x2000033d, 0 , 0,
17529 0x0 }, /* _POOL32A5~*(103) */
17530 { instruction , 0 , 0 , 32,
17531 0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W , 0,
17532 DSP_ }, /* SUBQ_S.W */
17533 { pool , SUBUH__R__QB , 2 , 32,
17534 0xfc0003ff, 0x2000034d, 0 , 0,
17535 0x0 }, /* SUBUH[_R].QB */
17536 { instruction , 0 , 0 , 32,
17537 0xfc0003ff, 0x20000355, &NMD::SHRLV_QB , 0,
17538 DSP_ }, /* SHRLV.QB */
17539 { reserved_block , 0 , 0 , 32,
17540 0xfc0003ff, 0x2000035d, 0 , 0,
17541 0x0 }, /* _POOL32A5~*(107) */
17542 { reserved_block , 0 , 0 , 32,
17543 0xfc0003ff, 0x20000365, 0 , 0,
17544 0x0 }, /* _POOL32A5~*(108) */
17545 { reserved_block , 0 , 0 , 32,
17546 0xfc0003ff, 0x2000036d, 0 , 0,
17547 0x0 }, /* _POOL32A5~*(109) */
17548 { reserved_block , 0 , 0 , 32,
17549 0xfc0003ff, 0x20000375, 0 , 0,
17550 0x0 }, /* _POOL32A5~*(110) */
17551 { reserved_block , 0 , 0 , 32,
17552 0xfc0003ff, 0x2000037d, 0 , 0,
17553 0x0 }, /* _POOL32A5~*(111) */
17554 { instruction , 0 , 0 , 32,
17555 0xfc0003ff, 0x20000385, &NMD::ADDSC , 0,
17556 DSP_ }, /* ADDSC */
17557 { pool , SHLLV__S__PH , 2 , 32,
17558 0xfc0003ff, 0x2000038d, 0 , 0,
17559 0x0 }, /* SHLLV[_S].PH */
17560 { instruction , 0 , 0 , 32,
17561 0xfc0003ff, 0x20000395, &NMD::SHLLV_QB , 0,
17562 DSP_ }, /* SHLLV.QB */
17563 { reserved_block , 0 , 0 , 32,
17564 0xfc0003ff, 0x2000039d, 0 , 0,
17565 0x0 }, /* _POOL32A5~*(115) */
17566 { reserved_block , 0 , 0 , 32,
17567 0xfc0003ff, 0x200003a5, 0 , 0,
17568 0x0 }, /* _POOL32A5~*(116) */
17569 { reserved_block , 0 , 0 , 32,
17570 0xfc0003ff, 0x200003ad, 0 , 0,
17571 0x0 }, /* _POOL32A5~*(117) */
17572 { pool , SHLL__S__PH , 4 , 32,
17573 0xfc0003ff, 0x200003b5, 0 , 0,
17574 0x0 }, /* SHLL[_S].PH */
17575 { reserved_block , 0 , 0 , 32,
17576 0xfc0003ff, 0x200003bd, 0 , 0,
17577 0x0 }, /* _POOL32A5~*(119) */
17578 { instruction , 0 , 0 , 32,
17579 0xfc0003ff, 0x200003c5, &NMD::ADDWC , 0,
17580 DSP_ }, /* ADDWC */
17581 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17582 0xfc0003ff, 0x200003cd, 0 , 0,
17583 0x0 }, /* PRECR_SRA[_R].PH.W */
17584 { instruction , 0 , 0 , 32,
17585 0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W , 0,
17586 DSP_ }, /* SHLLV_S.W */
17587 { reserved_block , 0 , 0 , 32,
17588 0xfc0003ff, 0x200003dd, 0 , 0,
17589 0x0 }, /* _POOL32A5~*(123) */
17590 { reserved_block , 0 , 0 , 32,
17591 0xfc0003ff, 0x200003e5, 0 , 0,
17592 0x0 }, /* _POOL32A5~*(124) */
17593 { reserved_block , 0 , 0 , 32,
17594 0xfc0003ff, 0x200003ed, 0 , 0,
17595 0x0 }, /* _POOL32A5~*(125) */
17596 { instruction , 0 , 0 , 32,
17597 0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W , 0,
17598 DSP_ }, /* SHLL_S.W */
17599 { reserved_block , 0 , 0 , 32,
17600 0xfc0003ff, 0x200003fd, 0 , 0,
17601 0x0 }, /* _POOL32A5~*(127) */
17602 };
17603
17604
17605 NMD::Pool NMD::PP_LSX[16] = {
17606 { instruction , 0 , 0 , 32,
17607 0xfc0007ff, 0x20000007, &NMD::LBX , 0,
17608 0x0 }, /* LBX */
17609 { instruction , 0 , 0 , 32,
17610 0xfc0007ff, 0x20000087, &NMD::SBX , 0,
17611 XMMS_ }, /* SBX */
17612 { instruction , 0 , 0 , 32,
17613 0xfc0007ff, 0x20000107, &NMD::LBUX , 0,
17614 0x0 }, /* LBUX */
17615 { reserved_block , 0 , 0 , 32,
17616 0xfc0007ff, 0x20000187, 0 , 0,
17617 0x0 }, /* PP.LSX~*(3) */
17618 { instruction , 0 , 0 , 32,
17619 0xfc0007ff, 0x20000207, &NMD::LHX , 0,
17620 0x0 }, /* LHX */
17621 { instruction , 0 , 0 , 32,
17622 0xfc0007ff, 0x20000287, &NMD::SHX , 0,
17623 XMMS_ }, /* SHX */
17624 { instruction , 0 , 0 , 32,
17625 0xfc0007ff, 0x20000307, &NMD::LHUX , 0,
17626 0x0 }, /* LHUX */
17627 { instruction , 0 , 0 , 32,
17628 0xfc0007ff, 0x20000387, &NMD::LWUX , 0,
17629 MIPS64_ }, /* LWUX */
17630 { instruction , 0 , 0 , 32,
17631 0xfc0007ff, 0x20000407, &NMD::LWX , 0,
17632 0x0 }, /* LWX */
17633 { instruction , 0 , 0 , 32,
17634 0xfc0007ff, 0x20000487, &NMD::SWX , 0,
17635 XMMS_ }, /* SWX */
17636 { instruction , 0 , 0 , 32,
17637 0xfc0007ff, 0x20000507, &NMD::LWC1X , 0,
17638 CP1_ }, /* LWC1X */
17639 { instruction , 0 , 0 , 32,
17640 0xfc0007ff, 0x20000587, &NMD::SWC1X , 0,
17641 CP1_ }, /* SWC1X */
17642 { instruction , 0 , 0 , 32,
17643 0xfc0007ff, 0x20000607, &NMD::LDX , 0,
17644 MIPS64_ }, /* LDX */
17645 { instruction , 0 , 0 , 32,
17646 0xfc0007ff, 0x20000687, &NMD::SDX , 0,
17647 MIPS64_ }, /* SDX */
17648 { instruction , 0 , 0 , 32,
17649 0xfc0007ff, 0x20000707, &NMD::LDC1X , 0,
17650 CP1_ }, /* LDC1X */
17651 { instruction , 0 , 0 , 32,
17652 0xfc0007ff, 0x20000787, &NMD::SDC1X , 0,
17653 CP1_ }, /* SDC1X */
17654 };
17655
17656
17657 NMD::Pool NMD::PP_LSXS[16] = {
17658 { reserved_block , 0 , 0 , 32,
17659 0xfc0007ff, 0x20000047, 0 , 0,
17660 0x0 }, /* PP.LSXS~*(0) */
17661 { reserved_block , 0 , 0 , 32,
17662 0xfc0007ff, 0x200000c7, 0 , 0,
17663 0x0 }, /* PP.LSXS~*(1) */
17664 { reserved_block , 0 , 0 , 32,
17665 0xfc0007ff, 0x20000147, 0 , 0,
17666 0x0 }, /* PP.LSXS~*(2) */
17667 { reserved_block , 0 , 0 , 32,
17668 0xfc0007ff, 0x200001c7, 0 , 0,
17669 0x0 }, /* PP.LSXS~*(3) */
17670 { instruction , 0 , 0 , 32,
17671 0xfc0007ff, 0x20000247, &NMD::LHXS , 0,
17672 0x0 }, /* LHXS */
17673 { instruction , 0 , 0 , 32,
17674 0xfc0007ff, 0x200002c7, &NMD::SHXS , 0,
17675 XMMS_ }, /* SHXS */
17676 { instruction , 0 , 0 , 32,
17677 0xfc0007ff, 0x20000347, &NMD::LHUXS , 0,
17678 0x0 }, /* LHUXS */
17679 { instruction , 0 , 0 , 32,
17680 0xfc0007ff, 0x200003c7, &NMD::LWUXS , 0,
17681 MIPS64_ }, /* LWUXS */
17682 { instruction , 0 , 0 , 32,
17683 0xfc0007ff, 0x20000447, &NMD::LWXS_32_ , 0,
17684 0x0 }, /* LWXS[32] */
17685 { instruction , 0 , 0 , 32,
17686 0xfc0007ff, 0x200004c7, &NMD::SWXS , 0,
17687 XMMS_ }, /* SWXS */
17688 { instruction , 0 , 0 , 32,
17689 0xfc0007ff, 0x20000547, &NMD::LWC1XS , 0,
17690 CP1_ }, /* LWC1XS */
17691 { instruction , 0 , 0 , 32,
17692 0xfc0007ff, 0x200005c7, &NMD::SWC1XS , 0,
17693 CP1_ }, /* SWC1XS */
17694 { instruction , 0 , 0 , 32,
17695 0xfc0007ff, 0x20000647, &NMD::LDXS , 0,
17696 MIPS64_ }, /* LDXS */
17697 { instruction , 0 , 0 , 32,
17698 0xfc0007ff, 0x200006c7, &NMD::SDXS , 0,
17699 MIPS64_ }, /* SDXS */
17700 { instruction , 0 , 0 , 32,
17701 0xfc0007ff, 0x20000747, &NMD::LDC1XS , 0,
17702 CP1_ }, /* LDC1XS */
17703 { instruction , 0 , 0 , 32,
17704 0xfc0007ff, 0x200007c7, &NMD::SDC1XS , 0,
17705 CP1_ }, /* SDC1XS */
17706 };
17707
17708
17709 NMD::Pool NMD::P_LSX[2] = {
17710 { pool , PP_LSX , 16 , 32,
17711 0xfc00007f, 0x20000007, 0 , 0,
17712 0x0 }, /* PP.LSX */
17713 { pool , PP_LSXS , 16 , 32,
17714 0xfc00007f, 0x20000047, 0 , 0,
17715 0x0 }, /* PP.LSXS */
17716 };
17717
17718
17719 NMD::Pool NMD::POOL32Axf_1_0[4] = {
17720 { instruction , 0 , 0 , 32,
17721 0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_ , 0,
17722 DSP_ }, /* MFHI[DSP] */
17723 { instruction , 0 , 0 , 32,
17724 0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_ , 0,
17725 DSP_ }, /* MFLO[DSP] */
17726 { instruction , 0 , 0 , 32,
17727 0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_ , 0,
17728 DSP_ }, /* MTHI[DSP] */
17729 { instruction , 0 , 0 , 32,
17730 0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_ , 0,
17731 DSP_ }, /* MTLO[DSP] */
17732 };
17733
17734
17735 NMD::Pool NMD::POOL32Axf_1_1[4] = {
17736 { instruction , 0 , 0 , 32,
17737 0xfc003fff, 0x2000027f, &NMD::MTHLIP , 0,
17738 DSP_ }, /* MTHLIP */
17739 { instruction , 0 , 0 , 32,
17740 0xfc003fff, 0x2000127f, &NMD::SHILOV , 0,
17741 DSP_ }, /* SHILOV */
17742 { reserved_block , 0 , 0 , 32,
17743 0xfc003fff, 0x2000227f, 0 , 0,
17744 0x0 }, /* POOL32Axf_1_1~*(2) */
17745 { reserved_block , 0 , 0 , 32,
17746 0xfc003fff, 0x2000327f, 0 , 0,
17747 0x0 }, /* POOL32Axf_1_1~*(3) */
17748 };
17749
17750
17751 NMD::Pool NMD::POOL32Axf_1_3[4] = {
17752 { instruction , 0 , 0 , 32,
17753 0xfc003fff, 0x2000067f, &NMD::RDDSP , 0,
17754 DSP_ }, /* RDDSP */
17755 { instruction , 0 , 0 , 32,
17756 0xfc003fff, 0x2000167f, &NMD::WRDSP , 0,
17757 DSP_ }, /* WRDSP */
17758 { instruction , 0 , 0 , 32,
17759 0xfc003fff, 0x2000267f, &NMD::EXTP , 0,
17760 DSP_ }, /* EXTP */
17761 { instruction , 0 , 0 , 32,
17762 0xfc003fff, 0x2000367f, &NMD::EXTPDP , 0,
17763 DSP_ }, /* EXTPDP */
17764 };
17765
17766
17767 NMD::Pool NMD::POOL32Axf_1_4[2] = {
17768 { instruction , 0 , 0 , 32,
17769 0xfc001fff, 0x2000087f, &NMD::SHLL_QB , 0,
17770 DSP_ }, /* SHLL.QB */
17771 { instruction , 0 , 0 , 32,
17772 0xfc001fff, 0x2000187f, &NMD::SHRL_QB , 0,
17773 DSP_ }, /* SHRL.QB */
17774 };
17775
17776
17777 NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
17778 { instruction , 0 , 0 , 32,
17779 0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR , 0,
17780 DSP_ }, /* MAQ_S.W.PHR */
17781 { instruction , 0 , 0 , 32,
17782 0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR , 0,
17783 DSP_ }, /* MAQ_SA.W.PHR */
17784 };
17785
17786
17787 NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
17788 { instruction , 0 , 0 , 32,
17789 0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL , 0,
17790 DSP_ }, /* MAQ_S.W.PHL */
17791 { instruction , 0 , 0 , 32,
17792 0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL , 0,
17793 DSP_ }, /* MAQ_SA.W.PHL */
17794 };
17795
17796
17797 NMD::Pool NMD::POOL32Axf_1_5[2] = {
17798 { pool , MAQ_S_A__W_PHR , 2 , 32,
17799 0xfc001fff, 0x20000a7f, 0 , 0,
17800 0x0 }, /* MAQ_S[A].W.PHR */
17801 { pool , MAQ_S_A__W_PHL , 2 , 32,
17802 0xfc001fff, 0x20001a7f, 0 , 0,
17803 0x0 }, /* MAQ_S[A].W.PHL */
17804 };
17805
17806
17807 NMD::Pool NMD::POOL32Axf_1_7[4] = {
17808 { instruction , 0 , 0 , 32,
17809 0xfc003fff, 0x20000e7f, &NMD::EXTR_W , 0,
17810 DSP_ }, /* EXTR.W */
17811 { instruction , 0 , 0 , 32,
17812 0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W , 0,
17813 DSP_ }, /* EXTR_R.W */
17814 { instruction , 0 , 0 , 32,
17815 0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W , 0,
17816 DSP_ }, /* EXTR_RS.W */
17817 { instruction , 0 , 0 , 32,
17818 0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H , 0,
17819 DSP_ }, /* EXTR_S.H */
17820 };
17821
17822
17823 NMD::Pool NMD::POOL32Axf_1[8] = {
17824 { pool , POOL32Axf_1_0 , 4 , 32,
17825 0xfc000fff, 0x2000007f, 0 , 0,
17826 0x0 }, /* POOL32Axf_1_0 */
17827 { pool , POOL32Axf_1_1 , 4 , 32,
17828 0xfc000fff, 0x2000027f, 0 , 0,
17829 0x0 }, /* POOL32Axf_1_1 */
17830 { reserved_block , 0 , 0 , 32,
17831 0xfc000fff, 0x2000047f, 0 , 0,
17832 0x0 }, /* POOL32Axf_1~*(2) */
17833 { pool , POOL32Axf_1_3 , 4 , 32,
17834 0xfc000fff, 0x2000067f, 0 , 0,
17835 0x0 }, /* POOL32Axf_1_3 */
17836 { pool , POOL32Axf_1_4 , 2 , 32,
17837 0xfc000fff, 0x2000087f, 0 , 0,
17838 0x0 }, /* POOL32Axf_1_4 */
17839 { pool , POOL32Axf_1_5 , 2 , 32,
17840 0xfc000fff, 0x20000a7f, 0 , 0,
17841 0x0 }, /* POOL32Axf_1_5 */
17842 { reserved_block , 0 , 0 , 32,
17843 0xfc000fff, 0x20000c7f, 0 , 0,
17844 0x0 }, /* POOL32Axf_1~*(6) */
17845 { pool , POOL32Axf_1_7 , 4 , 32,
17846 0xfc000fff, 0x20000e7f, 0 , 0,
17847 0x0 }, /* POOL32Axf_1_7 */
17848 };
17849
17850
17851 NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
17852 { instruction , 0 , 0 , 32,
17853 0xfc003fff, 0x200000bf, &NMD::DPA_W_PH , 0,
17854 DSP_ }, /* DPA.W.PH */
17855 { instruction , 0 , 0 , 32,
17856 0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH , 0,
17857 DSP_ }, /* DPAQ_S.W.PH */
17858 { instruction , 0 , 0 , 32,
17859 0xfc003fff, 0x200004bf, &NMD::DPS_W_PH , 0,
17860 DSP_ }, /* DPS.W.PH */
17861 { instruction , 0 , 0 , 32,
17862 0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH , 0,
17863 DSP_ }, /* DPSQ_S.W.PH */
17864 { reserved_block , 0 , 0 , 32,
17865 0xfc003fff, 0x200008bf, 0 , 0,
17866 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17867 { instruction , 0 , 0 , 32,
17868 0xfc003fff, 0x20000abf, &NMD::MADD_DSP_ , 0,
17869 DSP_ }, /* MADD[DSP] */
17870 { instruction , 0 , 0 , 32,
17871 0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_ , 0,
17872 DSP_ }, /* MULT[DSP] */
17873 { instruction , 0 , 0 , 32,
17874 0xfc003fff, 0x20000ebf, &NMD::EXTRV_W , 0,
17875 DSP_ }, /* EXTRV.W */
17876 };
17877
17878
17879 NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
17880 { instruction , 0 , 0 , 32,
17881 0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH , 0,
17882 DSP_ }, /* DPAX.W.PH */
17883 { instruction , 0 , 0 , 32,
17884 0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W , 0,
17885 DSP_ }, /* DPAQ_SA.L.W */
17886 { instruction , 0 , 0 , 32,
17887 0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH , 0,
17888 DSP_ }, /* DPSX.W.PH */
17889 { instruction , 0 , 0 , 32,
17890 0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W , 0,
17891 DSP_ }, /* DPSQ_SA.L.W */
17892 { reserved_block , 0 , 0 , 32,
17893 0xfc003fff, 0x200018bf, 0 , 0,
17894 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17895 { instruction , 0 , 0 , 32,
17896 0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_ , 0,
17897 DSP_ }, /* MADDU[DSP] */
17898 { instruction , 0 , 0 , 32,
17899 0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_ , 0,
17900 DSP_ }, /* MULTU[DSP] */
17901 { instruction , 0 , 0 , 32,
17902 0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W , 0,
17903 DSP_ }, /* EXTRV_R.W */
17904 };
17905
17906
17907 NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
17908 { instruction , 0 , 0 , 32,
17909 0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL , 0,
17910 DSP_ }, /* DPAU.H.QBL */
17911 { instruction , 0 , 0 , 32,
17912 0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH , 0,
17913 DSP_ }, /* DPAQX_S.W.PH */
17914 { instruction , 0 , 0 , 32,
17915 0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL , 0,
17916 DSP_ }, /* DPSU.H.QBL */
17917 { instruction , 0 , 0 , 32,
17918 0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH , 0,
17919 DSP_ }, /* DPSQX_S.W.PH */
17920 { instruction , 0 , 0 , 32,
17921 0xfc003fff, 0x200028bf, &NMD::EXTPV , 0,
17922 DSP_ }, /* EXTPV */
17923 { instruction , 0 , 0 , 32,
17924 0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_ , 0,
17925 DSP_ }, /* MSUB[DSP] */
17926 { instruction , 0 , 0 , 32,
17927 0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH , 0,
17928 DSP_ }, /* MULSA.W.PH */
17929 { instruction , 0 , 0 , 32,
17930 0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W , 0,
17931 DSP_ }, /* EXTRV_RS.W */
17932 };
17933
17934
17935 NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
17936 { instruction , 0 , 0 , 32,
17937 0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR , 0,
17938 DSP_ }, /* DPAU.H.QBR */
17939 { instruction , 0 , 0 , 32,
17940 0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH , 0,
17941 DSP_ }, /* DPAQX_SA.W.PH */
17942 { instruction , 0 , 0 , 32,
17943 0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR , 0,
17944 DSP_ }, /* DPSU.H.QBR */
17945 { instruction , 0 , 0 , 32,
17946 0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH , 0,
17947 DSP_ }, /* DPSQX_SA.W.PH */
17948 { instruction , 0 , 0 , 32,
17949 0xfc003fff, 0x200038bf, &NMD::EXTPDPV , 0,
17950 DSP_ }, /* EXTPDPV */
17951 { instruction , 0 , 0 , 32,
17952 0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_ , 0,
17953 DSP_ }, /* MSUBU[DSP] */
17954 { instruction , 0 , 0 , 32,
17955 0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH , 0,
17956 DSP_ }, /* MULSAQ_S.W.PH */
17957 { instruction , 0 , 0 , 32,
17958 0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H , 0,
17959 DSP_ }, /* EXTRV_S.H */
17960 };
17961
17962
17963 NMD::Pool NMD::POOL32Axf_2[4] = {
17964 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
17965 0xfc0031ff, 0x200000bf, 0 , 0,
17966 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
17967 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
17968 0xfc0031ff, 0x200010bf, 0 , 0,
17969 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
17970 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
17971 0xfc0031ff, 0x200020bf, 0 , 0,
17972 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
17973 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
17974 0xfc0031ff, 0x200030bf, 0 , 0,
17975 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
17976 };
17977
17978
17979 NMD::Pool NMD::POOL32Axf_4[128] = {
17980 { instruction , 0 , 0 , 32,
17981 0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB , 0,
17982 DSP_ }, /* ABSQ_S.QB */
17983 { instruction , 0 , 0 , 32,
17984 0xfc00ffff, 0x2000033f, &NMD::REPLV_PH , 0,
17985 DSP_ }, /* REPLV.PH */
17986 { reserved_block , 0 , 0 , 32,
17987 0xfc00ffff, 0x2000053f, 0 , 0,
17988 0x0 }, /* POOL32Axf_4~*(2) */
17989 { reserved_block , 0 , 0 , 32,
17990 0xfc00ffff, 0x2000073f, 0 , 0,
17991 0x0 }, /* POOL32Axf_4~*(3) */
17992 { reserved_block , 0 , 0 , 32,
17993 0xfc00ffff, 0x2000093f, 0 , 0,
17994 0x0 }, /* POOL32Axf_4~*(4) */
17995 { reserved_block , 0 , 0 , 32,
17996 0xfc00ffff, 0x20000b3f, 0 , 0,
17997 0x0 }, /* POOL32Axf_4~*(5) */
17998 { reserved_block , 0 , 0 , 32,
17999 0xfc00ffff, 0x20000d3f, 0 , 0,
18000 0x0 }, /* POOL32Axf_4~*(6) */
18001 { reserved_block , 0 , 0 , 32,
18002 0xfc00ffff, 0x20000f3f, 0 , 0,
18003 0x0 }, /* POOL32Axf_4~*(7) */
18004 { instruction , 0 , 0 , 32,
18005 0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH , 0,
18006 DSP_ }, /* ABSQ_S.PH */
18007 { instruction , 0 , 0 , 32,
18008 0xfc00ffff, 0x2000133f, &NMD::REPLV_QB , 0,
18009 DSP_ }, /* REPLV.QB */
18010 { reserved_block , 0 , 0 , 32,
18011 0xfc00ffff, 0x2000153f, 0 , 0,
18012 0x0 }, /* POOL32Axf_4~*(10) */
18013 { reserved_block , 0 , 0 , 32,
18014 0xfc00ffff, 0x2000173f, 0 , 0,
18015 0x0 }, /* POOL32Axf_4~*(11) */
18016 { reserved_block , 0 , 0 , 32,
18017 0xfc00ffff, 0x2000193f, 0 , 0,
18018 0x0 }, /* POOL32Axf_4~*(12) */
18019 { reserved_block , 0 , 0 , 32,
18020 0xfc00ffff, 0x20001b3f, 0 , 0,
18021 0x0 }, /* POOL32Axf_4~*(13) */
18022 { reserved_block , 0 , 0 , 32,
18023 0xfc00ffff, 0x20001d3f, 0 , 0,
18024 0x0 }, /* POOL32Axf_4~*(14) */
18025 { reserved_block , 0 , 0 , 32,
18026 0xfc00ffff, 0x20001f3f, 0 , 0,
18027 0x0 }, /* POOL32Axf_4~*(15) */
18028 { instruction , 0 , 0 , 32,
18029 0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W , 0,
18030 DSP_ }, /* ABSQ_S.W */
18031 { reserved_block , 0 , 0 , 32,
18032 0xfc00ffff, 0x2000233f, 0 , 0,
18033 0x0 }, /* POOL32Axf_4~*(17) */
18034 { reserved_block , 0 , 0 , 32,
18035 0xfc00ffff, 0x2000253f, 0 , 0,
18036 0x0 }, /* POOL32Axf_4~*(18) */
18037 { reserved_block , 0 , 0 , 32,
18038 0xfc00ffff, 0x2000273f, 0 , 0,
18039 0x0 }, /* POOL32Axf_4~*(19) */
18040 { reserved_block , 0 , 0 , 32,
18041 0xfc00ffff, 0x2000293f, 0 , 0,
18042 0x0 }, /* POOL32Axf_4~*(20) */
18043 { reserved_block , 0 , 0 , 32,
18044 0xfc00ffff, 0x20002b3f, 0 , 0,
18045 0x0 }, /* POOL32Axf_4~*(21) */
18046 { reserved_block , 0 , 0 , 32,
18047 0xfc00ffff, 0x20002d3f, 0 , 0,
18048 0x0 }, /* POOL32Axf_4~*(22) */
18049 { reserved_block , 0 , 0 , 32,
18050 0xfc00ffff, 0x20002f3f, 0 , 0,
18051 0x0 }, /* POOL32Axf_4~*(23) */
18052 { reserved_block , 0 , 0 , 32,
18053 0xfc00ffff, 0x2000313f, 0 , 0,
18054 0x0 }, /* POOL32Axf_4~*(24) */
18055 { reserved_block , 0 , 0 , 32,
18056 0xfc00ffff, 0x2000333f, 0 , 0,
18057 0x0 }, /* POOL32Axf_4~*(25) */
18058 { reserved_block , 0 , 0 , 32,
18059 0xfc00ffff, 0x2000353f, 0 , 0,
18060 0x0 }, /* POOL32Axf_4~*(26) */
18061 { reserved_block , 0 , 0 , 32,
18062 0xfc00ffff, 0x2000373f, 0 , 0,
18063 0x0 }, /* POOL32Axf_4~*(27) */
18064 { reserved_block , 0 , 0 , 32,
18065 0xfc00ffff, 0x2000393f, 0 , 0,
18066 0x0 }, /* POOL32Axf_4~*(28) */
18067 { reserved_block , 0 , 0 , 32,
18068 0xfc00ffff, 0x20003b3f, 0 , 0,
18069 0x0 }, /* POOL32Axf_4~*(29) */
18070 { reserved_block , 0 , 0 , 32,
18071 0xfc00ffff, 0x20003d3f, 0 , 0,
18072 0x0 }, /* POOL32Axf_4~*(30) */
18073 { reserved_block , 0 , 0 , 32,
18074 0xfc00ffff, 0x20003f3f, 0 , 0,
18075 0x0 }, /* POOL32Axf_4~*(31) */
18076 { instruction , 0 , 0 , 32,
18077 0xfc00ffff, 0x2000413f, &NMD::INSV , 0,
18078 DSP_ }, /* INSV */
18079 { reserved_block , 0 , 0 , 32,
18080 0xfc00ffff, 0x2000433f, 0 , 0,
18081 0x0 }, /* POOL32Axf_4~*(33) */
18082 { reserved_block , 0 , 0 , 32,
18083 0xfc00ffff, 0x2000453f, 0 , 0,
18084 0x0 }, /* POOL32Axf_4~*(34) */
18085 { reserved_block , 0 , 0 , 32,
18086 0xfc00ffff, 0x2000473f, 0 , 0,
18087 0x0 }, /* POOL32Axf_4~*(35) */
18088 { reserved_block , 0 , 0 , 32,
18089 0xfc00ffff, 0x2000493f, 0 , 0,
18090 0x0 }, /* POOL32Axf_4~*(36) */
18091 { instruction , 0 , 0 , 32,
18092 0xfc00ffff, 0x20004b3f, &NMD::CLO , 0,
18093 XMMS_ }, /* CLO */
18094 { instruction , 0 , 0 , 32,
18095 0xfc00ffff, 0x20004d3f, &NMD::MFC2 , 0,
18096 CP2_ }, /* MFC2 */
18097 { reserved_block , 0 , 0 , 32,
18098 0xfc00ffff, 0x20004f3f, 0 , 0,
18099 0x0 }, /* POOL32Axf_4~*(39) */
18100 { instruction , 0 , 0 , 32,
18101 0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL , 0,
18102 DSP_ }, /* PRECEQ.W.PHL */
18103 { reserved_block , 0 , 0 , 32,
18104 0xfc00ffff, 0x2000533f, 0 , 0,
18105 0x0 }, /* POOL32Axf_4~*(41) */
18106 { reserved_block , 0 , 0 , 32,
18107 0xfc00ffff, 0x2000553f, 0 , 0,
18108 0x0 }, /* POOL32Axf_4~*(42) */
18109 { reserved_block , 0 , 0 , 32,
18110 0xfc00ffff, 0x2000573f, 0 , 0,
18111 0x0 }, /* POOL32Axf_4~*(43) */
18112 { reserved_block , 0 , 0 , 32,
18113 0xfc00ffff, 0x2000593f, 0 , 0,
18114 0x0 }, /* POOL32Axf_4~*(44) */
18115 { instruction , 0 , 0 , 32,
18116 0xfc00ffff, 0x20005b3f, &NMD::CLZ , 0,
18117 XMMS_ }, /* CLZ */
18118 { instruction , 0 , 0 , 32,
18119 0xfc00ffff, 0x20005d3f, &NMD::MTC2 , 0,
18120 CP2_ }, /* MTC2 */
18121 { reserved_block , 0 , 0 , 32,
18122 0xfc00ffff, 0x20005f3f, 0 , 0,
18123 0x0 }, /* POOL32Axf_4~*(47) */
18124 { instruction , 0 , 0 , 32,
18125 0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR , 0,
18126 DSP_ }, /* PRECEQ.W.PHR */
18127 { reserved_block , 0 , 0 , 32,
18128 0xfc00ffff, 0x2000633f, 0 , 0,
18129 0x0 }, /* POOL32Axf_4~*(49) */
18130 { reserved_block , 0 , 0 , 32,
18131 0xfc00ffff, 0x2000653f, 0 , 0,
18132 0x0 }, /* POOL32Axf_4~*(50) */
18133 { reserved_block , 0 , 0 , 32,
18134 0xfc00ffff, 0x2000673f, 0 , 0,
18135 0x0 }, /* POOL32Axf_4~*(51) */
18136 { reserved_block , 0 , 0 , 32,
18137 0xfc00ffff, 0x2000693f, 0 , 0,
18138 0x0 }, /* POOL32Axf_4~*(52) */
18139 { reserved_block , 0 , 0 , 32,
18140 0xfc00ffff, 0x20006b3f, 0 , 0,
18141 0x0 }, /* POOL32Axf_4~*(53) */
18142 { instruction , 0 , 0 , 32,
18143 0xfc00ffff, 0x20006d3f, &NMD::DMFC2 , 0,
18144 CP2_ }, /* DMFC2 */
18145 { reserved_block , 0 , 0 , 32,
18146 0xfc00ffff, 0x20006f3f, 0 , 0,
18147 0x0 }, /* POOL32Axf_4~*(55) */
18148 { instruction , 0 , 0 , 32,
18149 0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL , 0,
18150 DSP_ }, /* PRECEQU.PH.QBL */
18151 { instruction , 0 , 0 , 32,
18152 0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA , 0,
18153 DSP_ }, /* PRECEQU.PH.QBLA */
18154 { reserved_block , 0 , 0 , 32,
18155 0xfc00ffff, 0x2000753f, 0 , 0,
18156 0x0 }, /* POOL32Axf_4~*(58) */
18157 { reserved_block , 0 , 0 , 32,
18158 0xfc00ffff, 0x2000773f, 0 , 0,
18159 0x0 }, /* POOL32Axf_4~*(59) */
18160 { reserved_block , 0 , 0 , 32,
18161 0xfc00ffff, 0x2000793f, 0 , 0,
18162 0x0 }, /* POOL32Axf_4~*(60) */
18163 { reserved_block , 0 , 0 , 32,
18164 0xfc00ffff, 0x20007b3f, 0 , 0,
18165 0x0 }, /* POOL32Axf_4~*(61) */
18166 { instruction , 0 , 0 , 32,
18167 0xfc00ffff, 0x20007d3f, &NMD::DMTC2 , 0,
18168 CP2_ }, /* DMTC2 */
18169 { reserved_block , 0 , 0 , 32,
18170 0xfc00ffff, 0x20007f3f, 0 , 0,
18171 0x0 }, /* POOL32Axf_4~*(63) */
18172 { reserved_block , 0 , 0 , 32,
18173 0xfc00ffff, 0x2000813f, 0 , 0,
18174 0x0 }, /* POOL32Axf_4~*(64) */
18175 { reserved_block , 0 , 0 , 32,
18176 0xfc00ffff, 0x2000833f, 0 , 0,
18177 0x0 }, /* POOL32Axf_4~*(65) */
18178 { reserved_block , 0 , 0 , 32,
18179 0xfc00ffff, 0x2000853f, 0 , 0,
18180 0x0 }, /* POOL32Axf_4~*(66) */
18181 { reserved_block , 0 , 0 , 32,
18182 0xfc00ffff, 0x2000873f, 0 , 0,
18183 0x0 }, /* POOL32Axf_4~*(67) */
18184 { reserved_block , 0 , 0 , 32,
18185 0xfc00ffff, 0x2000893f, 0 , 0,
18186 0x0 }, /* POOL32Axf_4~*(68) */
18187 { reserved_block , 0 , 0 , 32,
18188 0xfc00ffff, 0x20008b3f, 0 , 0,
18189 0x0 }, /* POOL32Axf_4~*(69) */
18190 { instruction , 0 , 0 , 32,
18191 0xfc00ffff, 0x20008d3f, &NMD::MFHC2 , 0,
18192 CP2_ }, /* MFHC2 */
18193 { reserved_block , 0 , 0 , 32,
18194 0xfc00ffff, 0x20008f3f, 0 , 0,
18195 0x0 }, /* POOL32Axf_4~*(71) */
18196 { instruction , 0 , 0 , 32,
18197 0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR , 0,
18198 DSP_ }, /* PRECEQU.PH.QBR */
18199 { instruction , 0 , 0 , 32,
18200 0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA , 0,
18201 DSP_ }, /* PRECEQU.PH.QBRA */
18202 { reserved_block , 0 , 0 , 32,
18203 0xfc00ffff, 0x2000953f, 0 , 0,
18204 0x0 }, /* POOL32Axf_4~*(74) */
18205 { reserved_block , 0 , 0 , 32,
18206 0xfc00ffff, 0x2000973f, 0 , 0,
18207 0x0 }, /* POOL32Axf_4~*(75) */
18208 { reserved_block , 0 , 0 , 32,
18209 0xfc00ffff, 0x2000993f, 0 , 0,
18210 0x0 }, /* POOL32Axf_4~*(76) */
18211 { reserved_block , 0 , 0 , 32,
18212 0xfc00ffff, 0x20009b3f, 0 , 0,
18213 0x0 }, /* POOL32Axf_4~*(77) */
18214 { instruction , 0 , 0 , 32,
18215 0xfc00ffff, 0x20009d3f, &NMD::MTHC2 , 0,
18216 CP2_ }, /* MTHC2 */
18217 { reserved_block , 0 , 0 , 32,
18218 0xfc00ffff, 0x20009f3f, 0 , 0,
18219 0x0 }, /* POOL32Axf_4~*(79) */
18220 { reserved_block , 0 , 0 , 32,
18221 0xfc00ffff, 0x2000a13f, 0 , 0,
18222 0x0 }, /* POOL32Axf_4~*(80) */
18223 { reserved_block , 0 , 0 , 32,
18224 0xfc00ffff, 0x2000a33f, 0 , 0,
18225 0x0 }, /* POOL32Axf_4~*(81) */
18226 { reserved_block , 0 , 0 , 32,
18227 0xfc00ffff, 0x2000a53f, 0 , 0,
18228 0x0 }, /* POOL32Axf_4~*(82) */
18229 { reserved_block , 0 , 0 , 32,
18230 0xfc00ffff, 0x2000a73f, 0 , 0,
18231 0x0 }, /* POOL32Axf_4~*(83) */
18232 { reserved_block , 0 , 0 , 32,
18233 0xfc00ffff, 0x2000a93f, 0 , 0,
18234 0x0 }, /* POOL32Axf_4~*(84) */
18235 { reserved_block , 0 , 0 , 32,
18236 0xfc00ffff, 0x2000ab3f, 0 , 0,
18237 0x0 }, /* POOL32Axf_4~*(85) */
18238 { reserved_block , 0 , 0 , 32,
18239 0xfc00ffff, 0x2000ad3f, 0 , 0,
18240 0x0 }, /* POOL32Axf_4~*(86) */
18241 { reserved_block , 0 , 0 , 32,
18242 0xfc00ffff, 0x2000af3f, 0 , 0,
18243 0x0 }, /* POOL32Axf_4~*(87) */
18244 { instruction , 0 , 0 , 32,
18245 0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL , 0,
18246 DSP_ }, /* PRECEU.PH.QBL */
18247 { instruction , 0 , 0 , 32,
18248 0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA , 0,
18249 DSP_ }, /* PRECEU.PH.QBLA */
18250 { reserved_block , 0 , 0 , 32,
18251 0xfc00ffff, 0x2000b53f, 0 , 0,
18252 0x0 }, /* POOL32Axf_4~*(90) */
18253 { reserved_block , 0 , 0 , 32,
18254 0xfc00ffff, 0x2000b73f, 0 , 0,
18255 0x0 }, /* POOL32Axf_4~*(91) */
18256 { reserved_block , 0 , 0 , 32,
18257 0xfc00ffff, 0x2000b93f, 0 , 0,
18258 0x0 }, /* POOL32Axf_4~*(92) */
18259 { reserved_block , 0 , 0 , 32,
18260 0xfc00ffff, 0x2000bb3f, 0 , 0,
18261 0x0 }, /* POOL32Axf_4~*(93) */
18262 { reserved_block , 0 , 0 , 32,
18263 0xfc00ffff, 0x2000bd3f, 0 , 0,
18264 0x0 }, /* POOL32Axf_4~*(94) */
18265 { reserved_block , 0 , 0 , 32,
18266 0xfc00ffff, 0x2000bf3f, 0 , 0,
18267 0x0 }, /* POOL32Axf_4~*(95) */
18268 { reserved_block , 0 , 0 , 32,
18269 0xfc00ffff, 0x2000c13f, 0 , 0,
18270 0x0 }, /* POOL32Axf_4~*(96) */
18271 { reserved_block , 0 , 0 , 32,
18272 0xfc00ffff, 0x2000c33f, 0 , 0,
18273 0x0 }, /* POOL32Axf_4~*(97) */
18274 { reserved_block , 0 , 0 , 32,
18275 0xfc00ffff, 0x2000c53f, 0 , 0,
18276 0x0 }, /* POOL32Axf_4~*(98) */
18277 { reserved_block , 0 , 0 , 32,
18278 0xfc00ffff, 0x2000c73f, 0 , 0,
18279 0x0 }, /* POOL32Axf_4~*(99) */
18280 { reserved_block , 0 , 0 , 32,
18281 0xfc00ffff, 0x2000c93f, 0 , 0,
18282 0x0 }, /* POOL32Axf_4~*(100) */
18283 { reserved_block , 0 , 0 , 32,
18284 0xfc00ffff, 0x2000cb3f, 0 , 0,
18285 0x0 }, /* POOL32Axf_4~*(101) */
18286 { instruction , 0 , 0 , 32,
18287 0xfc00ffff, 0x2000cd3f, &NMD::CFC2 , 0,
18288 CP2_ }, /* CFC2 */
18289 { reserved_block , 0 , 0 , 32,
18290 0xfc00ffff, 0x2000cf3f, 0 , 0,
18291 0x0 }, /* POOL32Axf_4~*(103) */
18292 { instruction , 0 , 0 , 32,
18293 0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR , 0,
18294 DSP_ }, /* PRECEU.PH.QBR */
18295 { instruction , 0 , 0 , 32,
18296 0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA , 0,
18297 DSP_ }, /* PRECEU.PH.QBRA */
18298 { reserved_block , 0 , 0 , 32,
18299 0xfc00ffff, 0x2000d53f, 0 , 0,
18300 0x0 }, /* POOL32Axf_4~*(106) */
18301 { reserved_block , 0 , 0 , 32,
18302 0xfc00ffff, 0x2000d73f, 0 , 0,
18303 0x0 }, /* POOL32Axf_4~*(107) */
18304 { reserved_block , 0 , 0 , 32,
18305 0xfc00ffff, 0x2000d93f, 0 , 0,
18306 0x0 }, /* POOL32Axf_4~*(108) */
18307 { reserved_block , 0 , 0 , 32,
18308 0xfc00ffff, 0x2000db3f, 0 , 0,
18309 0x0 }, /* POOL32Axf_4~*(109) */
18310 { instruction , 0 , 0 , 32,
18311 0xfc00ffff, 0x2000dd3f, &NMD::CTC2 , 0,
18312 CP2_ }, /* CTC2 */
18313 { reserved_block , 0 , 0 , 32,
18314 0xfc00ffff, 0x2000df3f, 0 , 0,
18315 0x0 }, /* POOL32Axf_4~*(111) */
18316 { reserved_block , 0 , 0 , 32,
18317 0xfc00ffff, 0x2000e13f, 0 , 0,
18318 0x0 }, /* POOL32Axf_4~*(112) */
18319 { reserved_block , 0 , 0 , 32,
18320 0xfc00ffff, 0x2000e33f, 0 , 0,
18321 0x0 }, /* POOL32Axf_4~*(113) */
18322 { reserved_block , 0 , 0 , 32,
18323 0xfc00ffff, 0x2000e53f, 0 , 0,
18324 0x0 }, /* POOL32Axf_4~*(114) */
18325 { reserved_block , 0 , 0 , 32,
18326 0xfc00ffff, 0x2000e73f, 0 , 0,
18327 0x0 }, /* POOL32Axf_4~*(115) */
18328 { reserved_block , 0 , 0 , 32,
18329 0xfc00ffff, 0x2000e93f, 0 , 0,
18330 0x0 }, /* POOL32Axf_4~*(116) */
18331 { reserved_block , 0 , 0 , 32,
18332 0xfc00ffff, 0x2000eb3f, 0 , 0,
18333 0x0 }, /* POOL32Axf_4~*(117) */
18334 { reserved_block , 0 , 0 , 32,
18335 0xfc00ffff, 0x2000ed3f, 0 , 0,
18336 0x0 }, /* POOL32Axf_4~*(118) */
18337 { reserved_block , 0 , 0 , 32,
18338 0xfc00ffff, 0x2000ef3f, 0 , 0,
18339 0x0 }, /* POOL32Axf_4~*(119) */
18340 { instruction , 0 , 0 , 32,
18341 0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB , 0,
18342 DSP_ }, /* RADDU.W.QB */
18343 { reserved_block , 0 , 0 , 32,
18344 0xfc00ffff, 0x2000f33f, 0 , 0,
18345 0x0 }, /* POOL32Axf_4~*(121) */
18346 { reserved_block , 0 , 0 , 32,
18347 0xfc00ffff, 0x2000f53f, 0 , 0,
18348 0x0 }, /* POOL32Axf_4~*(122) */
18349 { reserved_block , 0 , 0 , 32,
18350 0xfc00ffff, 0x2000f73f, 0 , 0,
18351 0x0 }, /* POOL32Axf_4~*(123) */
18352 { reserved_block , 0 , 0 , 32,
18353 0xfc00ffff, 0x2000f93f, 0 , 0,
18354 0x0 }, /* POOL32Axf_4~*(124) */
18355 { reserved_block , 0 , 0 , 32,
18356 0xfc00ffff, 0x2000fb3f, 0 , 0,
18357 0x0 }, /* POOL32Axf_4~*(125) */
18358 { reserved_block , 0 , 0 , 32,
18359 0xfc00ffff, 0x2000fd3f, 0 , 0,
18360 0x0 }, /* POOL32Axf_4~*(126) */
18361 { reserved_block , 0 , 0 , 32,
18362 0xfc00ffff, 0x2000ff3f, 0 , 0,
18363 0x0 }, /* POOL32Axf_4~*(127) */
18364 };
18365
18366
18367 NMD::Pool NMD::POOL32Axf_5_group0[32] = {
18368 { instruction , 0 , 0 , 32,
18369 0xfc00ffff, 0x2000017f, &NMD::TLBGP , 0,
18370 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18371 { instruction , 0 , 0 , 32,
18372 0xfc00ffff, 0x2000037f, &NMD::TLBP , 0,
18373 CP0_ | TLB_ }, /* TLBP */
18374 { instruction , 0 , 0 , 32,
18375 0xfc00ffff, 0x2000057f, &NMD::TLBGINV , 0,
18376 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18377 { instruction , 0 , 0 , 32,
18378 0xfc00ffff, 0x2000077f, &NMD::TLBINV , 0,
18379 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18380 { reserved_block , 0 , 0 , 32,
18381 0xfc00ffff, 0x2000097f, 0 , 0,
18382 0x0 }, /* POOL32Axf_5_group0~*(4) */
18383 { reserved_block , 0 , 0 , 32,
18384 0xfc00ffff, 0x20000b7f, 0 , 0,
18385 0x0 }, /* POOL32Axf_5_group0~*(5) */
18386 { reserved_block , 0 , 0 , 32,
18387 0xfc00ffff, 0x20000d7f, 0 , 0,
18388 0x0 }, /* POOL32Axf_5_group0~*(6) */
18389 { reserved_block , 0 , 0 , 32,
18390 0xfc00ffff, 0x20000f7f, 0 , 0,
18391 0x0 }, /* POOL32Axf_5_group0~*(7) */
18392 { instruction , 0 , 0 , 32,
18393 0xfc00ffff, 0x2000117f, &NMD::TLBGR , 0,
18394 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18395 { instruction , 0 , 0 , 32,
18396 0xfc00ffff, 0x2000137f, &NMD::TLBR , 0,
18397 CP0_ | TLB_ }, /* TLBR */
18398 { instruction , 0 , 0 , 32,
18399 0xfc00ffff, 0x2000157f, &NMD::TLBGINVF , 0,
18400 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18401 { instruction , 0 , 0 , 32,
18402 0xfc00ffff, 0x2000177f, &NMD::TLBINVF , 0,
18403 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18404 { reserved_block , 0 , 0 , 32,
18405 0xfc00ffff, 0x2000197f, 0 , 0,
18406 0x0 }, /* POOL32Axf_5_group0~*(12) */
18407 { reserved_block , 0 , 0 , 32,
18408 0xfc00ffff, 0x20001b7f, 0 , 0,
18409 0x0 }, /* POOL32Axf_5_group0~*(13) */
18410 { reserved_block , 0 , 0 , 32,
18411 0xfc00ffff, 0x20001d7f, 0 , 0,
18412 0x0 }, /* POOL32Axf_5_group0~*(14) */
18413 { reserved_block , 0 , 0 , 32,
18414 0xfc00ffff, 0x20001f7f, 0 , 0,
18415 0x0 }, /* POOL32Axf_5_group0~*(15) */
18416 { instruction , 0 , 0 , 32,
18417 0xfc00ffff, 0x2000217f, &NMD::TLBGWI , 0,
18418 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18419 { instruction , 0 , 0 , 32,
18420 0xfc00ffff, 0x2000237f, &NMD::TLBWI , 0,
18421 CP0_ | TLB_ }, /* TLBWI */
18422 { reserved_block , 0 , 0 , 32,
18423 0xfc00ffff, 0x2000257f, 0 , 0,
18424 0x0 }, /* POOL32Axf_5_group0~*(18) */
18425 { reserved_block , 0 , 0 , 32,
18426 0xfc00ffff, 0x2000277f, 0 , 0,
18427 0x0 }, /* POOL32Axf_5_group0~*(19) */
18428 { reserved_block , 0 , 0 , 32,
18429 0xfc00ffff, 0x2000297f, 0 , 0,
18430 0x0 }, /* POOL32Axf_5_group0~*(20) */
18431 { reserved_block , 0 , 0 , 32,
18432 0xfc00ffff, 0x20002b7f, 0 , 0,
18433 0x0 }, /* POOL32Axf_5_group0~*(21) */
18434 { reserved_block , 0 , 0 , 32,
18435 0xfc00ffff, 0x20002d7f, 0 , 0,
18436 0x0 }, /* POOL32Axf_5_group0~*(22) */
18437 { reserved_block , 0 , 0 , 32,
18438 0xfc00ffff, 0x20002f7f, 0 , 0,
18439 0x0 }, /* POOL32Axf_5_group0~*(23) */
18440 { instruction , 0 , 0 , 32,
18441 0xfc00ffff, 0x2000317f, &NMD::TLBGWR , 0,
18442 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18443 { instruction , 0 , 0 , 32,
18444 0xfc00ffff, 0x2000337f, &NMD::TLBWR , 0,
18445 CP0_ | TLB_ }, /* TLBWR */
18446 { reserved_block , 0 , 0 , 32,
18447 0xfc00ffff, 0x2000357f, 0 , 0,
18448 0x0 }, /* POOL32Axf_5_group0~*(26) */
18449 { reserved_block , 0 , 0 , 32,
18450 0xfc00ffff, 0x2000377f, 0 , 0,
18451 0x0 }, /* POOL32Axf_5_group0~*(27) */
18452 { reserved_block , 0 , 0 , 32,
18453 0xfc00ffff, 0x2000397f, 0 , 0,
18454 0x0 }, /* POOL32Axf_5_group0~*(28) */
18455 { reserved_block , 0 , 0 , 32,
18456 0xfc00ffff, 0x20003b7f, 0 , 0,
18457 0x0 }, /* POOL32Axf_5_group0~*(29) */
18458 { reserved_block , 0 , 0 , 32,
18459 0xfc00ffff, 0x20003d7f, 0 , 0,
18460 0x0 }, /* POOL32Axf_5_group0~*(30) */
18461 { reserved_block , 0 , 0 , 32,
18462 0xfc00ffff, 0x20003f7f, 0 , 0,
18463 0x0 }, /* POOL32Axf_5_group0~*(31) */
18464 };
18465
18466
18467 NMD::Pool NMD::POOL32Axf_5_group1[32] = {
18468 { reserved_block , 0 , 0 , 32,
18469 0xfc00ffff, 0x2000417f, 0 , 0,
18470 0x0 }, /* POOL32Axf_5_group1~*(0) */
18471 { reserved_block , 0 , 0 , 32,
18472 0xfc00ffff, 0x2000437f, 0 , 0,
18473 0x0 }, /* POOL32Axf_5_group1~*(1) */
18474 { reserved_block , 0 , 0 , 32,
18475 0xfc00ffff, 0x2000457f, 0 , 0,
18476 0x0 }, /* POOL32Axf_5_group1~*(2) */
18477 { instruction , 0 , 0 , 32,
18478 0xfc00ffff, 0x2000477f, &NMD::DI , 0,
18479 0x0 }, /* DI */
18480 { reserved_block , 0 , 0 , 32,
18481 0xfc00ffff, 0x2000497f, 0 , 0,
18482 0x0 }, /* POOL32Axf_5_group1~*(4) */
18483 { reserved_block , 0 , 0 , 32,
18484 0xfc00ffff, 0x20004b7f, 0 , 0,
18485 0x0 }, /* POOL32Axf_5_group1~*(5) */
18486 { reserved_block , 0 , 0 , 32,
18487 0xfc00ffff, 0x20004d7f, 0 , 0,
18488 0x0 }, /* POOL32Axf_5_group1~*(6) */
18489 { reserved_block , 0 , 0 , 32,
18490 0xfc00ffff, 0x20004f7f, 0 , 0,
18491 0x0 }, /* POOL32Axf_5_group1~*(7) */
18492 { reserved_block , 0 , 0 , 32,
18493 0xfc00ffff, 0x2000517f, 0 , 0,
18494 0x0 }, /* POOL32Axf_5_group1~*(8) */
18495 { reserved_block , 0 , 0 , 32,
18496 0xfc00ffff, 0x2000537f, 0 , 0,
18497 0x0 }, /* POOL32Axf_5_group1~*(9) */
18498 { reserved_block , 0 , 0 , 32,
18499 0xfc00ffff, 0x2000557f, 0 , 0,
18500 0x0 }, /* POOL32Axf_5_group1~*(10) */
18501 { instruction , 0 , 0 , 32,
18502 0xfc00ffff, 0x2000577f, &NMD::EI , 0,
18503 0x0 }, /* EI */
18504 { reserved_block , 0 , 0 , 32,
18505 0xfc00ffff, 0x2000597f, 0 , 0,
18506 0x0 }, /* POOL32Axf_5_group1~*(12) */
18507 { reserved_block , 0 , 0 , 32,
18508 0xfc00ffff, 0x20005b7f, 0 , 0,
18509 0x0 }, /* POOL32Axf_5_group1~*(13) */
18510 { reserved_block , 0 , 0 , 32,
18511 0xfc00ffff, 0x20005d7f, 0 , 0,
18512 0x0 }, /* POOL32Axf_5_group1~*(14) */
18513 { reserved_block , 0 , 0 , 32,
18514 0xfc00ffff, 0x20005f7f, 0 , 0,
18515 0x0 }, /* POOL32Axf_5_group1~*(15) */
18516 { reserved_block , 0 , 0 , 32,
18517 0xfc00ffff, 0x2000617f, 0 , 0,
18518 0x0 }, /* POOL32Axf_5_group1~*(16) */
18519 { reserved_block , 0 , 0 , 32,
18520 0xfc00ffff, 0x2000637f, 0 , 0,
18521 0x0 }, /* POOL32Axf_5_group1~*(17) */
18522 { reserved_block , 0 , 0 , 32,
18523 0xfc00ffff, 0x2000657f, 0 , 0,
18524 0x0 }, /* POOL32Axf_5_group1~*(18) */
18525 { reserved_block , 0 , 0 , 32,
18526 0xfc00ffff, 0x2000677f, 0 , 0,
18527 0x0 }, /* POOL32Axf_5_group1~*(19) */
18528 { reserved_block , 0 , 0 , 32,
18529 0xfc00ffff, 0x2000697f, 0 , 0,
18530 0x0 }, /* POOL32Axf_5_group1~*(20) */
18531 { reserved_block , 0 , 0 , 32,
18532 0xfc00ffff, 0x20006b7f, 0 , 0,
18533 0x0 }, /* POOL32Axf_5_group1~*(21) */
18534 { reserved_block , 0 , 0 , 32,
18535 0xfc00ffff, 0x20006d7f, 0 , 0,
18536 0x0 }, /* POOL32Axf_5_group1~*(22) */
18537 { reserved_block , 0 , 0 , 32,
18538 0xfc00ffff, 0x20006f7f, 0 , 0,
18539 0x0 }, /* POOL32Axf_5_group1~*(23) */
18540 { reserved_block , 0 , 0 , 32,
18541 0xfc00ffff, 0x2000717f, 0 , 0,
18542 0x0 }, /* POOL32Axf_5_group1~*(24) */
18543 { reserved_block , 0 , 0 , 32,
18544 0xfc00ffff, 0x2000737f, 0 , 0,
18545 0x0 }, /* POOL32Axf_5_group1~*(25) */
18546 { reserved_block , 0 , 0 , 32,
18547 0xfc00ffff, 0x2000757f, 0 , 0,
18548 0x0 }, /* POOL32Axf_5_group1~*(26) */
18549 { reserved_block , 0 , 0 , 32,
18550 0xfc00ffff, 0x2000777f, 0 , 0,
18551 0x0 }, /* POOL32Axf_5_group1~*(27) */
18552 { reserved_block , 0 , 0 , 32,
18553 0xfc00ffff, 0x2000797f, 0 , 0,
18554 0x0 }, /* POOL32Axf_5_group1~*(28) */
18555 { reserved_block , 0 , 0 , 32,
18556 0xfc00ffff, 0x20007b7f, 0 , 0,
18557 0x0 }, /* POOL32Axf_5_group1~*(29) */
18558 { reserved_block , 0 , 0 , 32,
18559 0xfc00ffff, 0x20007d7f, 0 , 0,
18560 0x0 }, /* POOL32Axf_5_group1~*(30) */
18561 { reserved_block , 0 , 0 , 32,
18562 0xfc00ffff, 0x20007f7f, 0 , 0,
18563 0x0 }, /* POOL32Axf_5_group1~*(31) */
18564 };
18565
18566
18567 NMD::Pool NMD::ERETx[2] = {
18568 { instruction , 0 , 0 , 32,
18569 0xfc01ffff, 0x2000f37f, &NMD::ERET , 0,
18570 0x0 }, /* ERET */
18571 { instruction , 0 , 0 , 32,
18572 0xfc01ffff, 0x2001f37f, &NMD::ERETNC , 0,
18573 0x0 }, /* ERETNC */
18574 };
18575
18576
18577 NMD::Pool NMD::POOL32Axf_5_group3[32] = {
18578 { reserved_block , 0 , 0 , 32,
18579 0xfc00ffff, 0x2000c17f, 0 , 0,
18580 0x0 }, /* POOL32Axf_5_group3~*(0) */
18581 { instruction , 0 , 0 , 32,
18582 0xfc00ffff, 0x2000c37f, &NMD::WAIT , 0,
18583 0x0 }, /* WAIT */
18584 { reserved_block , 0 , 0 , 32,
18585 0xfc00ffff, 0x2000c57f, 0 , 0,
18586 0x0 }, /* POOL32Axf_5_group3~*(2) */
18587 { reserved_block , 0 , 0 , 32,
18588 0xfc00ffff, 0x2000c77f, 0 , 0,
18589 0x0 }, /* POOL32Axf_5_group3~*(3) */
18590 { reserved_block , 0 , 0 , 32,
18591 0xfc00ffff, 0x2000c97f, 0 , 0,
18592 0x0 }, /* POOL32Axf_5_group3~*(4) */
18593 { reserved_block , 0 , 0 , 32,
18594 0xfc00ffff, 0x2000cb7f, 0 , 0,
18595 0x0 }, /* POOL32Axf_5_group3~*(5) */
18596 { reserved_block , 0 , 0 , 32,
18597 0xfc00ffff, 0x2000cd7f, 0 , 0,
18598 0x0 }, /* POOL32Axf_5_group3~*(6) */
18599 { reserved_block , 0 , 0 , 32,
18600 0xfc00ffff, 0x2000cf7f, 0 , 0,
18601 0x0 }, /* POOL32Axf_5_group3~*(7) */
18602 { reserved_block , 0 , 0 , 32,
18603 0xfc00ffff, 0x2000d17f, 0 , 0,
18604 0x0 }, /* POOL32Axf_5_group3~*(8) */
18605 { instruction , 0 , 0 , 32,
18606 0xfc00ffff, 0x2000d37f, &NMD::IRET , 0,
18607 MCU_ }, /* IRET */
18608 { reserved_block , 0 , 0 , 32,
18609 0xfc00ffff, 0x2000d57f, 0 , 0,
18610 0x0 }, /* POOL32Axf_5_group3~*(10) */
18611 { reserved_block , 0 , 0 , 32,
18612 0xfc00ffff, 0x2000d77f, 0 , 0,
18613 0x0 }, /* POOL32Axf_5_group3~*(11) */
18614 { reserved_block , 0 , 0 , 32,
18615 0xfc00ffff, 0x2000d97f, 0 , 0,
18616 0x0 }, /* POOL32Axf_5_group3~*(12) */
18617 { reserved_block , 0 , 0 , 32,
18618 0xfc00ffff, 0x2000db7f, 0 , 0,
18619 0x0 }, /* POOL32Axf_5_group3~*(13) */
18620 { reserved_block , 0 , 0 , 32,
18621 0xfc00ffff, 0x2000dd7f, 0 , 0,
18622 0x0 }, /* POOL32Axf_5_group3~*(14) */
18623 { reserved_block , 0 , 0 , 32,
18624 0xfc00ffff, 0x2000df7f, 0 , 0,
18625 0x0 }, /* POOL32Axf_5_group3~*(15) */
18626 { instruction , 0 , 0 , 32,
18627 0xfc00ffff, 0x2000e17f, &NMD::RDPGPR , 0,
18628 CP0_ }, /* RDPGPR */
18629 { instruction , 0 , 0 , 32,
18630 0xfc00ffff, 0x2000e37f, &NMD::DERET , 0,
18631 EJTAG_ }, /* DERET */
18632 { reserved_block , 0 , 0 , 32,
18633 0xfc00ffff, 0x2000e57f, 0 , 0,
18634 0x0 }, /* POOL32Axf_5_group3~*(18) */
18635 { reserved_block , 0 , 0 , 32,
18636 0xfc00ffff, 0x2000e77f, 0 , 0,
18637 0x0 }, /* POOL32Axf_5_group3~*(19) */
18638 { reserved_block , 0 , 0 , 32,
18639 0xfc00ffff, 0x2000e97f, 0 , 0,
18640 0x0 }, /* POOL32Axf_5_group3~*(20) */
18641 { reserved_block , 0 , 0 , 32,
18642 0xfc00ffff, 0x2000eb7f, 0 , 0,
18643 0x0 }, /* POOL32Axf_5_group3~*(21) */
18644 { reserved_block , 0 , 0 , 32,
18645 0xfc00ffff, 0x2000ed7f, 0 , 0,
18646 0x0 }, /* POOL32Axf_5_group3~*(22) */
18647 { reserved_block , 0 , 0 , 32,
18648 0xfc00ffff, 0x2000ef7f, 0 , 0,
18649 0x0 }, /* POOL32Axf_5_group3~*(23) */
18650 { instruction , 0 , 0 , 32,
18651 0xfc00ffff, 0x2000f17f, &NMD::WRPGPR , 0,
18652 CP0_ }, /* WRPGPR */
18653 { pool , ERETx , 2 , 32,
18654 0xfc00ffff, 0x2000f37f, 0 , 0,
18655 0x0 }, /* ERETx */
18656 { reserved_block , 0 , 0 , 32,
18657 0xfc00ffff, 0x2000f57f, 0 , 0,
18658 0x0 }, /* POOL32Axf_5_group3~*(26) */
18659 { reserved_block , 0 , 0 , 32,
18660 0xfc00ffff, 0x2000f77f, 0 , 0,
18661 0x0 }, /* POOL32Axf_5_group3~*(27) */
18662 { reserved_block , 0 , 0 , 32,
18663 0xfc00ffff, 0x2000f97f, 0 , 0,
18664 0x0 }, /* POOL32Axf_5_group3~*(28) */
18665 { reserved_block , 0 , 0 , 32,
18666 0xfc00ffff, 0x2000fb7f, 0 , 0,
18667 0x0 }, /* POOL32Axf_5_group3~*(29) */
18668 { reserved_block , 0 , 0 , 32,
18669 0xfc00ffff, 0x2000fd7f, 0 , 0,
18670 0x0 }, /* POOL32Axf_5_group3~*(30) */
18671 { reserved_block , 0 , 0 , 32,
18672 0xfc00ffff, 0x2000ff7f, 0 , 0,
18673 0x0 }, /* POOL32Axf_5_group3~*(31) */
18674 };
18675
18676
18677 NMD::Pool NMD::POOL32Axf_5[4] = {
18678 { pool , POOL32Axf_5_group0 , 32 , 32,
18679 0xfc00c1ff, 0x2000017f, 0 , 0,
18680 0x0 }, /* POOL32Axf_5_group0 */
18681 { pool , POOL32Axf_5_group1 , 32 , 32,
18682 0xfc00c1ff, 0x2000417f, 0 , 0,
18683 0x0 }, /* POOL32Axf_5_group1 */
18684 { reserved_block , 0 , 0 , 32,
18685 0xfc00c1ff, 0x2000817f, 0 , 0,
18686 0x0 }, /* POOL32Axf_5~*(2) */
18687 { pool , POOL32Axf_5_group3 , 32 , 32,
18688 0xfc00c1ff, 0x2000c17f, 0 , 0,
18689 0x0 }, /* POOL32Axf_5_group3 */
18690 };
18691
18692
18693 NMD::Pool NMD::SHRA__R__QB[2] = {
18694 { instruction , 0 , 0 , 32,
18695 0xfc001fff, 0x200001ff, &NMD::SHRA_QB , 0,
18696 DSP_ }, /* SHRA.QB */
18697 { instruction , 0 , 0 , 32,
18698 0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB , 0,
18699 DSP_ }, /* SHRA_R.QB */
18700 };
18701
18702
18703 NMD::Pool NMD::POOL32Axf_7[8] = {
18704 { pool , SHRA__R__QB , 2 , 32,
18705 0xfc000fff, 0x200001ff, 0 , 0,
18706 0x0 }, /* SHRA[_R].QB */
18707 { instruction , 0 , 0 , 32,
18708 0xfc000fff, 0x200003ff, &NMD::SHRL_PH , 0,
18709 DSP_ }, /* SHRL.PH */
18710 { instruction , 0 , 0 , 32,
18711 0xfc000fff, 0x200005ff, &NMD::REPL_QB , 0,
18712 DSP_ }, /* REPL.QB */
18713 { reserved_block , 0 , 0 , 32,
18714 0xfc000fff, 0x200007ff, 0 , 0,
18715 0x0 }, /* POOL32Axf_7~*(3) */
18716 { reserved_block , 0 , 0 , 32,
18717 0xfc000fff, 0x200009ff, 0 , 0,
18718 0x0 }, /* POOL32Axf_7~*(4) */
18719 { reserved_block , 0 , 0 , 32,
18720 0xfc000fff, 0x20000bff, 0 , 0,
18721 0x0 }, /* POOL32Axf_7~*(5) */
18722 { reserved_block , 0 , 0 , 32,
18723 0xfc000fff, 0x20000dff, 0 , 0,
18724 0x0 }, /* POOL32Axf_7~*(6) */
18725 { reserved_block , 0 , 0 , 32,
18726 0xfc000fff, 0x20000fff, 0 , 0,
18727 0x0 }, /* POOL32Axf_7~*(7) */
18728 };
18729
18730
18731 NMD::Pool NMD::POOL32Axf[8] = {
18732 { reserved_block , 0 , 0 , 32,
18733 0xfc0001ff, 0x2000003f, 0 , 0,
18734 0x0 }, /* POOL32Axf~*(0) */
18735 { pool , POOL32Axf_1 , 8 , 32,
18736 0xfc0001ff, 0x2000007f, 0 , 0,
18737 0x0 }, /* POOL32Axf_1 */
18738 { pool , POOL32Axf_2 , 4 , 32,
18739 0xfc0001ff, 0x200000bf, 0 , 0,
18740 0x0 }, /* POOL32Axf_2 */
18741 { reserved_block , 0 , 0 , 32,
18742 0xfc0001ff, 0x200000ff, 0 , 0,
18743 0x0 }, /* POOL32Axf~*(3) */
18744 { pool , POOL32Axf_4 , 128 , 32,
18745 0xfc0001ff, 0x2000013f, 0 , 0,
18746 0x0 }, /* POOL32Axf_4 */
18747 { pool , POOL32Axf_5 , 4 , 32,
18748 0xfc0001ff, 0x2000017f, 0 , 0,
18749 0x0 }, /* POOL32Axf_5 */
18750 { reserved_block , 0 , 0 , 32,
18751 0xfc0001ff, 0x200001bf, 0 , 0,
18752 0x0 }, /* POOL32Axf~*(6) */
18753 { pool , POOL32Axf_7 , 8 , 32,
18754 0xfc0001ff, 0x200001ff, 0 , 0,
18755 0x0 }, /* POOL32Axf_7 */
18756 };
18757
18758
18759 NMD::Pool NMD::_POOL32A7[8] = {
18760 { pool , P_LSX , 2 , 32,
18761 0xfc00003f, 0x20000007, 0 , 0,
18762 0x0 }, /* P.LSX */
18763 { instruction , 0 , 0 , 32,
18764 0xfc00003f, 0x2000000f, &NMD::LSA , 0,
18765 0x0 }, /* LSA */
18766 { reserved_block , 0 , 0 , 32,
18767 0xfc00003f, 0x20000017, 0 , 0,
18768 0x0 }, /* _POOL32A7~*(2) */
18769 { instruction , 0 , 0 , 32,
18770 0xfc00003f, 0x2000001f, &NMD::EXTW , 0,
18771 0x0 }, /* EXTW */
18772 { reserved_block , 0 , 0 , 32,
18773 0xfc00003f, 0x20000027, 0 , 0,
18774 0x0 }, /* _POOL32A7~*(4) */
18775 { reserved_block , 0 , 0 , 32,
18776 0xfc00003f, 0x2000002f, 0 , 0,
18777 0x0 }, /* _POOL32A7~*(5) */
18778 { reserved_block , 0 , 0 , 32,
18779 0xfc00003f, 0x20000037, 0 , 0,
18780 0x0 }, /* _POOL32A7~*(6) */
18781 { pool , POOL32Axf , 8 , 32,
18782 0xfc00003f, 0x2000003f, 0 , 0,
18783 0x0 }, /* POOL32Axf */
18784 };
18785
18786
18787 NMD::Pool NMD::P32A[8] = {
18788 { pool , _POOL32A0 , 128 , 32,
18789 0xfc000007, 0x20000000, 0 , 0,
18790 0x0 }, /* _POOL32A0 */
18791 { instruction , 0 , 0 , 32,
18792 0xfc000007, 0x20000001, &NMD::SPECIAL2 , 0,
18793 UDI_ }, /* SPECIAL2 */
18794 { instruction , 0 , 0 , 32,
18795 0xfc000007, 0x20000002, &NMD::COP2_1 , 0,
18796 CP2_ }, /* COP2_1 */
18797 { instruction , 0 , 0 , 32,
18798 0xfc000007, 0x20000003, &NMD::UDI , 0,
18799 UDI_ }, /* UDI */
18800 { reserved_block , 0 , 0 , 32,
18801 0xfc000007, 0x20000004, 0 , 0,
18802 0x0 }, /* P32A~*(4) */
18803 { pool , _POOL32A5 , 128 , 32,
18804 0xfc000007, 0x20000005, 0 , 0,
18805 0x0 }, /* _POOL32A5 */
18806 { reserved_block , 0 , 0 , 32,
18807 0xfc000007, 0x20000006, 0 , 0,
18808 0x0 }, /* P32A~*(6) */
18809 { pool , _POOL32A7 , 8 , 32,
18810 0xfc000007, 0x20000007, 0 , 0,
18811 0x0 }, /* _POOL32A7 */
18812 };
18813
18814
18815 NMD::Pool NMD::P_GP_D[2] = {
18816 { instruction , 0 , 0 , 32,
18817 0xfc000007, 0x40000001, &NMD::LD_GP_ , 0,
18818 MIPS64_ }, /* LD[GP] */
18819 { instruction , 0 , 0 , 32,
18820 0xfc000007, 0x40000005, &NMD::SD_GP_ , 0,
18821 MIPS64_ }, /* SD[GP] */
18822 };
18823
18824
18825 NMD::Pool NMD::P_GP_W[4] = {
18826 { instruction , 0 , 0 , 32,
18827 0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_ , 0,
18828 0x0 }, /* ADDIU[GP.W] */
18829 { pool , P_GP_D , 2 , 32,
18830 0xfc000003, 0x40000001, 0 , 0,
18831 0x0 }, /* P.GP.D */
18832 { instruction , 0 , 0 , 32,
18833 0xfc000003, 0x40000002, &NMD::LW_GP_ , 0,
18834 0x0 }, /* LW[GP] */
18835 { instruction , 0 , 0 , 32,
18836 0xfc000003, 0x40000003, &NMD::SW_GP_ , 0,
18837 0x0 }, /* SW[GP] */
18838 };
18839
18840
18841 NMD::Pool NMD::POOL48I[32] = {
18842 { instruction , 0 , 0 , 48,
18843 0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_ , 0,
18844 XMMS_ }, /* LI[48] */
18845 { instruction , 0 , 0 , 48,
18846 0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_ , 0,
18847 XMMS_ }, /* ADDIU[48] */
18848 { instruction , 0 , 0 , 48,
18849 0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_ , 0,
18850 XMMS_ }, /* ADDIU[GP48] */
18851 { instruction , 0 , 0 , 48,
18852 0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_ , 0,
18853 XMMS_ }, /* ADDIUPC[48] */
18854 { reserved_block , 0 , 0 , 48,
18855 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18856 0x0 }, /* POOL48I~*(4) */
18857 { reserved_block , 0 , 0 , 48,
18858 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18859 0x0 }, /* POOL48I~*(5) */
18860 { reserved_block , 0 , 0 , 48,
18861 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18862 0x0 }, /* POOL48I~*(6) */
18863 { reserved_block , 0 , 0 , 48,
18864 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18865 0x0 }, /* POOL48I~*(7) */
18866 { reserved_block , 0 , 0 , 48,
18867 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18868 0x0 }, /* POOL48I~*(8) */
18869 { reserved_block , 0 , 0 , 48,
18870 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18871 0x0 }, /* POOL48I~*(9) */
18872 { reserved_block , 0 , 0 , 48,
18873 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18874 0x0 }, /* POOL48I~*(10) */
18875 { instruction , 0 , 0 , 48,
18876 0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_ , 0,
18877 XMMS_ }, /* LWPC[48] */
18878 { reserved_block , 0 , 0 , 48,
18879 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18880 0x0 }, /* POOL48I~*(12) */
18881 { reserved_block , 0 , 0 , 48,
18882 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18883 0x0 }, /* POOL48I~*(13) */
18884 { reserved_block , 0 , 0 , 48,
18885 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18886 0x0 }, /* POOL48I~*(14) */
18887 { instruction , 0 , 0 , 48,
18888 0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_ , 0,
18889 XMMS_ }, /* SWPC[48] */
18890 { reserved_block , 0 , 0 , 48,
18891 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18892 0x0 }, /* POOL48I~*(16) */
18893 { instruction , 0 , 0 , 48,
18894 0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_ , 0,
18895 MIPS64_ }, /* DADDIU[48] */
18896 { reserved_block , 0 , 0 , 48,
18897 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18898 0x0 }, /* POOL48I~*(18) */
18899 { reserved_block , 0 , 0 , 48,
18900 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18901 0x0 }, /* POOL48I~*(19) */
18902 { instruction , 0 , 0 , 48,
18903 0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_ , 0,
18904 MIPS64_ }, /* DLUI[48] */
18905 { reserved_block , 0 , 0 , 48,
18906 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18907 0x0 }, /* POOL48I~*(21) */
18908 { reserved_block , 0 , 0 , 48,
18909 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18910 0x0 }, /* POOL48I~*(22) */
18911 { reserved_block , 0 , 0 , 48,
18912 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18913 0x0 }, /* POOL48I~*(23) */
18914 { reserved_block , 0 , 0 , 48,
18915 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18916 0x0 }, /* POOL48I~*(24) */
18917 { reserved_block , 0 , 0 , 48,
18918 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18919 0x0 }, /* POOL48I~*(25) */
18920 { reserved_block , 0 , 0 , 48,
18921 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18922 0x0 }, /* POOL48I~*(26) */
18923 { instruction , 0 , 0 , 48,
18924 0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_ , 0,
18925 MIPS64_ }, /* LDPC[48] */
18926 { reserved_block , 0 , 0 , 48,
18927 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18928 0x0 }, /* POOL48I~*(28) */
18929 { reserved_block , 0 , 0 , 48,
18930 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18931 0x0 }, /* POOL48I~*(29) */
18932 { reserved_block , 0 , 0 , 48,
18933 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18934 0x0 }, /* POOL48I~*(30) */
18935 { instruction , 0 , 0 , 48,
18936 0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_ , 0,
18937 MIPS64_ }, /* SDPC[48] */
18938 };
18939
18940
18941 NMD::Pool NMD::PP_SR[4] = {
18942 { instruction , 0 , 0 , 32,
18943 0xfc10f003, 0x80003000, &NMD::SAVE_32_ , 0,
18944 0x0 }, /* SAVE[32] */
18945 { reserved_block , 0 , 0 , 32,
18946 0xfc10f003, 0x80003001, 0 , 0,
18947 0x0 }, /* PP.SR~*(1) */
18948 { instruction , 0 , 0 , 32,
18949 0xfc10f003, 0x80003002, &NMD::RESTORE_32_ , 0,
18950 0x0 }, /* RESTORE[32] */
18951 { return_instruction , 0 , 0 , 32,
18952 0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_ , 0,
18953 0x0 }, /* RESTORE.JRC[32] */
18954 };
18955
18956
18957 NMD::Pool NMD::P_SR_F[8] = {
18958 { instruction , 0 , 0 , 32,
18959 0xfc10f007, 0x80103000, &NMD::SAVEF , 0,
18960 CP1_ }, /* SAVEF */
18961 { instruction , 0 , 0 , 32,
18962 0xfc10f007, 0x80103001, &NMD::RESTOREF , 0,
18963 CP1_ }, /* RESTOREF */
18964 { reserved_block , 0 , 0 , 32,
18965 0xfc10f007, 0x80103002, 0 , 0,
18966 0x0 }, /* P.SR.F~*(2) */
18967 { reserved_block , 0 , 0 , 32,
18968 0xfc10f007, 0x80103003, 0 , 0,
18969 0x0 }, /* P.SR.F~*(3) */
18970 { reserved_block , 0 , 0 , 32,
18971 0xfc10f007, 0x80103004, 0 , 0,
18972 0x0 }, /* P.SR.F~*(4) */
18973 { reserved_block , 0 , 0 , 32,
18974 0xfc10f007, 0x80103005, 0 , 0,
18975 0x0 }, /* P.SR.F~*(5) */
18976 { reserved_block , 0 , 0 , 32,
18977 0xfc10f007, 0x80103006, 0 , 0,
18978 0x0 }, /* P.SR.F~*(6) */
18979 { reserved_block , 0 , 0 , 32,
18980 0xfc10f007, 0x80103007, 0 , 0,
18981 0x0 }, /* P.SR.F~*(7) */
18982 };
18983
18984
18985 NMD::Pool NMD::P_SR[2] = {
18986 { pool , PP_SR , 4 , 32,
18987 0xfc10f000, 0x80003000, 0 , 0,
18988 0x0 }, /* PP.SR */
18989 { pool , P_SR_F , 8 , 32,
18990 0xfc10f000, 0x80103000, 0 , 0,
18991 0x0 }, /* P.SR.F */
18992 };
18993
18994
18995 NMD::Pool NMD::P_SLL[5] = {
18996 { instruction , 0 , 0 , 32,
18997 0xffe0f1ff, 0x8000c000, &NMD::NOP_32_ , 0,
18998 0x0 }, /* NOP[32] */
18999 { instruction , 0 , 0 , 32,
19000 0xffe0f1ff, 0x8000c003, &NMD::EHB , 0,
19001 0x0 }, /* EHB */
19002 { instruction , 0 , 0 , 32,
19003 0xffe0f1ff, 0x8000c005, &NMD::PAUSE , 0,
19004 0x0 }, /* PAUSE */
19005 { instruction , 0 , 0 , 32,
19006 0xffe0f1ff, 0x8000c006, &NMD::SYNC , 0,
19007 0x0 }, /* SYNC */
19008 { instruction , 0 , 0 , 32,
19009 0xfc00f1e0, 0x8000c000, &NMD::SLL_32_ , 0,
19010 0x0 }, /* SLL[32] */
19011 };
19012
19013
19014 NMD::Pool NMD::P_SHIFT[16] = {
19015 { pool , P_SLL , 5 , 32,
19016 0xfc00f1e0, 0x8000c000, 0 , 0,
19017 0x0 }, /* P.SLL */
19018 { reserved_block , 0 , 0 , 32,
19019 0xfc00f1e0, 0x8000c020, 0 , 0,
19020 0x0 }, /* P.SHIFT~*(1) */
19021 { instruction , 0 , 0 , 32,
19022 0xfc00f1e0, 0x8000c040, &NMD::SRL_32_ , 0,
19023 0x0 }, /* SRL[32] */
19024 { reserved_block , 0 , 0 , 32,
19025 0xfc00f1e0, 0x8000c060, 0 , 0,
19026 0x0 }, /* P.SHIFT~*(3) */
19027 { instruction , 0 , 0 , 32,
19028 0xfc00f1e0, 0x8000c080, &NMD::SRA , 0,
19029 0x0 }, /* SRA */
19030 { reserved_block , 0 , 0 , 32,
19031 0xfc00f1e0, 0x8000c0a0, 0 , 0,
19032 0x0 }, /* P.SHIFT~*(5) */
19033 { instruction , 0 , 0 , 32,
19034 0xfc00f1e0, 0x8000c0c0, &NMD::ROTR , 0,
19035 0x0 }, /* ROTR */
19036 { reserved_block , 0 , 0 , 32,
19037 0xfc00f1e0, 0x8000c0e0, 0 , 0,
19038 0x0 }, /* P.SHIFT~*(7) */
19039 { instruction , 0 , 0 , 32,
19040 0xfc00f1e0, 0x8000c100, &NMD::DSLL , 0,
19041 MIPS64_ }, /* DSLL */
19042 { instruction , 0 , 0 , 32,
19043 0xfc00f1e0, 0x8000c120, &NMD::DSLL32 , 0,
19044 MIPS64_ }, /* DSLL32 */
19045 { instruction , 0 , 0 , 32,
19046 0xfc00f1e0, 0x8000c140, &NMD::DSRL , 0,
19047 MIPS64_ }, /* DSRL */
19048 { instruction , 0 , 0 , 32,
19049 0xfc00f1e0, 0x8000c160, &NMD::DSRL32 , 0,
19050 MIPS64_ }, /* DSRL32 */
19051 { instruction , 0 , 0 , 32,
19052 0xfc00f1e0, 0x8000c180, &NMD::DSRA , 0,
19053 MIPS64_ }, /* DSRA */
19054 { instruction , 0 , 0 , 32,
19055 0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32 , 0,
19056 MIPS64_ }, /* DSRA32 */
19057 { instruction , 0 , 0 , 32,
19058 0xfc00f1e0, 0x8000c1c0, &NMD::DROTR , 0,
19059 MIPS64_ }, /* DROTR */
19060 { instruction , 0 , 0 , 32,
19061 0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32 , 0,
19062 MIPS64_ }, /* DROTR32 */
19063 };
19064
19065
19066 NMD::Pool NMD::P_ROTX[4] = {
19067 { instruction , 0 , 0 , 32,
19068 0xfc00f820, 0x8000d000, &NMD::ROTX , 0,
19069 XMMS_ }, /* ROTX */
19070 { reserved_block , 0 , 0 , 32,
19071 0xfc00f820, 0x8000d020, 0 , 0,
19072 0x0 }, /* P.ROTX~*(1) */
19073 { reserved_block , 0 , 0 , 32,
19074 0xfc00f820, 0x8000d800, 0 , 0,
19075 0x0 }, /* P.ROTX~*(2) */
19076 { reserved_block , 0 , 0 , 32,
19077 0xfc00f820, 0x8000d820, 0 , 0,
19078 0x0 }, /* P.ROTX~*(3) */
19079 };
19080
19081
19082 NMD::Pool NMD::P_INS[4] = {
19083 { instruction , 0 , 0 , 32,
19084 0xfc00f820, 0x8000e000, &NMD::INS , 0,
19085 XMMS_ }, /* INS */
19086 { instruction , 0 , 0 , 32,
19087 0xfc00f820, 0x8000e020, &NMD::DINSU , 0,
19088 MIPS64_ }, /* DINSU */
19089 { instruction , 0 , 0 , 32,
19090 0xfc00f820, 0x8000e800, &NMD::DINSM , 0,
19091 MIPS64_ }, /* DINSM */
19092 { instruction , 0 , 0 , 32,
19093 0xfc00f820, 0x8000e820, &NMD::DINS , 0,
19094 MIPS64_ }, /* DINS */
19095 };
19096
19097
19098 NMD::Pool NMD::P_EXT[4] = {
19099 { instruction , 0 , 0 , 32,
19100 0xfc00f820, 0x8000f000, &NMD::EXT , 0,
19101 XMMS_ }, /* EXT */
19102 { instruction , 0 , 0 , 32,
19103 0xfc00f820, 0x8000f020, &NMD::DEXTU , 0,
19104 MIPS64_ }, /* DEXTU */
19105 { instruction , 0 , 0 , 32,
19106 0xfc00f820, 0x8000f800, &NMD::DEXTM , 0,
19107 MIPS64_ }, /* DEXTM */
19108 { instruction , 0 , 0 , 32,
19109 0xfc00f820, 0x8000f820, &NMD::DEXT , 0,
19110 MIPS64_ }, /* DEXT */
19111 };
19112
19113
19114 NMD::Pool NMD::P_U12[16] = {
19115 { instruction , 0 , 0 , 32,
19116 0xfc00f000, 0x80000000, &NMD::ORI , 0,
19117 0x0 }, /* ORI */
19118 { instruction , 0 , 0 , 32,
19119 0xfc00f000, 0x80001000, &NMD::XORI , 0,
19120 0x0 }, /* XORI */
19121 { instruction , 0 , 0 , 32,
19122 0xfc00f000, 0x80002000, &NMD::ANDI_32_ , 0,
19123 0x0 }, /* ANDI[32] */
19124 { pool , P_SR , 2 , 32,
19125 0xfc00f000, 0x80003000, 0 , 0,
19126 0x0 }, /* P.SR */
19127 { instruction , 0 , 0 , 32,
19128 0xfc00f000, 0x80004000, &NMD::SLTI , 0,
19129 0x0 }, /* SLTI */
19130 { instruction , 0 , 0 , 32,
19131 0xfc00f000, 0x80005000, &NMD::SLTIU , 0,
19132 0x0 }, /* SLTIU */
19133 { instruction , 0 , 0 , 32,
19134 0xfc00f000, 0x80006000, &NMD::SEQI , 0,
19135 0x0 }, /* SEQI */
19136 { reserved_block , 0 , 0 , 32,
19137 0xfc00f000, 0x80007000, 0 , 0,
19138 0x0 }, /* P.U12~*(7) */
19139 { instruction , 0 , 0 , 32,
19140 0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_ , 0,
19141 0x0 }, /* ADDIU[NEG] */
19142 { instruction , 0 , 0 , 32,
19143 0xfc00f000, 0x80009000, &NMD::DADDIU_U12_ , 0,
19144 MIPS64_ }, /* DADDIU[U12] */
19145 { instruction , 0 , 0 , 32,
19146 0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_ , 0,
19147 MIPS64_ }, /* DADDIU[NEG] */
19148 { instruction , 0 , 0 , 32,
19149 0xfc00f000, 0x8000b000, &NMD::DROTX , 0,
19150 MIPS64_ }, /* DROTX */
19151 { pool , P_SHIFT , 16 , 32,
19152 0xfc00f000, 0x8000c000, 0 , 0,
19153 0x0 }, /* P.SHIFT */
19154 { pool , P_ROTX , 4 , 32,
19155 0xfc00f000, 0x8000d000, 0 , 0,
19156 0x0 }, /* P.ROTX */
19157 { pool , P_INS , 4 , 32,
19158 0xfc00f000, 0x8000e000, 0 , 0,
19159 0x0 }, /* P.INS */
19160 { pool , P_EXT , 4 , 32,
19161 0xfc00f000, 0x8000f000, 0 , 0,
19162 0x0 }, /* P.EXT */
19163 };
19164
19165
19166 NMD::Pool NMD::RINT_fmt[2] = {
19167 { instruction , 0 , 0 , 32,
19168 0xfc0003ff, 0xa0000020, &NMD::RINT_S , 0,
19169 CP1_ }, /* RINT.S */
19170 { instruction , 0 , 0 , 32,
19171 0xfc0003ff, 0xa0000220, &NMD::RINT_D , 0,
19172 CP1_ }, /* RINT.D */
19173 };
19174
19175
19176 NMD::Pool NMD::ADD_fmt0[2] = {
19177 { instruction , 0 , 0 , 32,
19178 0xfc0003ff, 0xa0000030, &NMD::ADD_S , 0,
19179 CP1_ }, /* ADD.S */
19180 { reserved_block , 0 , 0 , 32,
19181 0xfc0003ff, 0xa0000230, 0 , 0,
19182 CP1_ }, /* ADD.fmt0~*(1) */
19183 };
19184
19185
19186 NMD::Pool NMD::SELEQZ_fmt[2] = {
19187 { instruction , 0 , 0 , 32,
19188 0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S , 0,
19189 CP1_ }, /* SELEQZ.S */
19190 { instruction , 0 , 0 , 32,
19191 0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D , 0,
19192 CP1_ }, /* SELEQZ.D */
19193 };
19194
19195
19196 NMD::Pool NMD::CLASS_fmt[2] = {
19197 { instruction , 0 , 0 , 32,
19198 0xfc0003ff, 0xa0000060, &NMD::CLASS_S , 0,
19199 CP1_ }, /* CLASS.S */
19200 { instruction , 0 , 0 , 32,
19201 0xfc0003ff, 0xa0000260, &NMD::CLASS_D , 0,
19202 CP1_ }, /* CLASS.D */
19203 };
19204
19205
19206 NMD::Pool NMD::SUB_fmt0[2] = {
19207 { instruction , 0 , 0 , 32,
19208 0xfc0003ff, 0xa0000070, &NMD::SUB_S , 0,
19209 CP1_ }, /* SUB.S */
19210 { reserved_block , 0 , 0 , 32,
19211 0xfc0003ff, 0xa0000270, 0 , 0,
19212 CP1_ }, /* SUB.fmt0~*(1) */
19213 };
19214
19215
19216 NMD::Pool NMD::SELNEZ_fmt[2] = {
19217 { instruction , 0 , 0 , 32,
19218 0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S , 0,
19219 CP1_ }, /* SELNEZ.S */
19220 { instruction , 0 , 0 , 32,
19221 0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D , 0,
19222 CP1_ }, /* SELNEZ.D */
19223 };
19224
19225
19226 NMD::Pool NMD::MUL_fmt0[2] = {
19227 { instruction , 0 , 0 , 32,
19228 0xfc0003ff, 0xa00000b0, &NMD::MUL_S , 0,
19229 CP1_ }, /* MUL.S */
19230 { reserved_block , 0 , 0 , 32,
19231 0xfc0003ff, 0xa00002b0, 0 , 0,
19232 CP1_ }, /* MUL.fmt0~*(1) */
19233 };
19234
19235
19236 NMD::Pool NMD::SEL_fmt[2] = {
19237 { instruction , 0 , 0 , 32,
19238 0xfc0003ff, 0xa00000b8, &NMD::SEL_S , 0,
19239 CP1_ }, /* SEL.S */
19240 { instruction , 0 , 0 , 32,
19241 0xfc0003ff, 0xa00002b8, &NMD::SEL_D , 0,
19242 CP1_ }, /* SEL.D */
19243 };
19244
19245
19246 NMD::Pool NMD::DIV_fmt0[2] = {
19247 { instruction , 0 , 0 , 32,
19248 0xfc0003ff, 0xa00000f0, &NMD::DIV_S , 0,
19249 CP1_ }, /* DIV.S */
19250 { reserved_block , 0 , 0 , 32,
19251 0xfc0003ff, 0xa00002f0, 0 , 0,
19252 CP1_ }, /* DIV.fmt0~*(1) */
19253 };
19254
19255
19256 NMD::Pool NMD::ADD_fmt1[2] = {
19257 { instruction , 0 , 0 , 32,
19258 0xfc0003ff, 0xa0000130, &NMD::ADD_D , 0,
19259 CP1_ }, /* ADD.D */
19260 { reserved_block , 0 , 0 , 32,
19261 0xfc0003ff, 0xa0000330, 0 , 0,
19262 CP1_ }, /* ADD.fmt1~*(1) */
19263 };
19264
19265
19266 NMD::Pool NMD::SUB_fmt1[2] = {
19267 { instruction , 0 , 0 , 32,
19268 0xfc0003ff, 0xa0000170, &NMD::SUB_D , 0,
19269 CP1_ }, /* SUB.D */
19270 { reserved_block , 0 , 0 , 32,
19271 0xfc0003ff, 0xa0000370, 0 , 0,
19272 CP1_ }, /* SUB.fmt1~*(1) */
19273 };
19274
19275
19276 NMD::Pool NMD::MUL_fmt1[2] = {
19277 { instruction , 0 , 0 , 32,
19278 0xfc0003ff, 0xa00001b0, &NMD::MUL_D , 0,
19279 CP1_ }, /* MUL.D */
19280 { reserved_block , 0 , 0 , 32,
19281 0xfc0003ff, 0xa00003b0, 0 , 0,
19282 CP1_ }, /* MUL.fmt1~*(1) */
19283 };
19284
19285
19286 NMD::Pool NMD::MADDF_fmt[2] = {
19287 { instruction , 0 , 0 , 32,
19288 0xfc0003ff, 0xa00001b8, &NMD::MADDF_S , 0,
19289 CP1_ }, /* MADDF.S */
19290 { instruction , 0 , 0 , 32,
19291 0xfc0003ff, 0xa00003b8, &NMD::MADDF_D , 0,
19292 CP1_ }, /* MADDF.D */
19293 };
19294
19295
19296 NMD::Pool NMD::DIV_fmt1[2] = {
19297 { instruction , 0 , 0 , 32,
19298 0xfc0003ff, 0xa00001f0, &NMD::DIV_D , 0,
19299 CP1_ }, /* DIV.D */
19300 { reserved_block , 0 , 0 , 32,
19301 0xfc0003ff, 0xa00003f0, 0 , 0,
19302 CP1_ }, /* DIV.fmt1~*(1) */
19303 };
19304
19305
19306 NMD::Pool NMD::MSUBF_fmt[2] = {
19307 { instruction , 0 , 0 , 32,
19308 0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S , 0,
19309 CP1_ }, /* MSUBF.S */
19310 { instruction , 0 , 0 , 32,
19311 0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D , 0,
19312 CP1_ }, /* MSUBF.D */
19313 };
19314
19315
19316 NMD::Pool NMD::POOL32F_0[64] = {
19317 { reserved_block , 0 , 0 , 32,
19318 0xfc0001ff, 0xa0000000, 0 , 0,
19319 CP1_ }, /* POOL32F_0~*(0) */
19320 { reserved_block , 0 , 0 , 32,
19321 0xfc0001ff, 0xa0000008, 0 , 0,
19322 CP1_ }, /* POOL32F_0~*(1) */
19323 { reserved_block , 0 , 0 , 32,
19324 0xfc0001ff, 0xa0000010, 0 , 0,
19325 CP1_ }, /* POOL32F_0~*(2) */
19326 { reserved_block , 0 , 0 , 32,
19327 0xfc0001ff, 0xa0000018, 0 , 0,
19328 CP1_ }, /* POOL32F_0~*(3) */
19329 { pool , RINT_fmt , 2 , 32,
19330 0xfc0001ff, 0xa0000020, 0 , 0,
19331 CP1_ }, /* RINT.fmt */
19332 { reserved_block , 0 , 0 , 32,
19333 0xfc0001ff, 0xa0000028, 0 , 0,
19334 CP1_ }, /* POOL32F_0~*(5) */
19335 { pool , ADD_fmt0 , 2 , 32,
19336 0xfc0001ff, 0xa0000030, 0 , 0,
19337 CP1_ }, /* ADD.fmt0 */
19338 { pool , SELEQZ_fmt , 2 , 32,
19339 0xfc0001ff, 0xa0000038, 0 , 0,
19340 CP1_ }, /* SELEQZ.fmt */
19341 { reserved_block , 0 , 0 , 32,
19342 0xfc0001ff, 0xa0000040, 0 , 0,
19343 CP1_ }, /* POOL32F_0~*(8) */
19344 { reserved_block , 0 , 0 , 32,
19345 0xfc0001ff, 0xa0000048, 0 , 0,
19346 CP1_ }, /* POOL32F_0~*(9) */
19347 { reserved_block , 0 , 0 , 32,
19348 0xfc0001ff, 0xa0000050, 0 , 0,
19349 CP1_ }, /* POOL32F_0~*(10) */
19350 { reserved_block , 0 , 0 , 32,
19351 0xfc0001ff, 0xa0000058, 0 , 0,
19352 CP1_ }, /* POOL32F_0~*(11) */
19353 { pool , CLASS_fmt , 2 , 32,
19354 0xfc0001ff, 0xa0000060, 0 , 0,
19355 CP1_ }, /* CLASS.fmt */
19356 { reserved_block , 0 , 0 , 32,
19357 0xfc0001ff, 0xa0000068, 0 , 0,
19358 CP1_ }, /* POOL32F_0~*(13) */
19359 { pool , SUB_fmt0 , 2 , 32,
19360 0xfc0001ff, 0xa0000070, 0 , 0,
19361 CP1_ }, /* SUB.fmt0 */
19362 { pool , SELNEZ_fmt , 2 , 32,
19363 0xfc0001ff, 0xa0000078, 0 , 0,
19364 CP1_ }, /* SELNEZ.fmt */
19365 { reserved_block , 0 , 0 , 32,
19366 0xfc0001ff, 0xa0000080, 0 , 0,
19367 CP1_ }, /* POOL32F_0~*(16) */
19368 { reserved_block , 0 , 0 , 32,
19369 0xfc0001ff, 0xa0000088, 0 , 0,
19370 CP1_ }, /* POOL32F_0~*(17) */
19371 { reserved_block , 0 , 0 , 32,
19372 0xfc0001ff, 0xa0000090, 0 , 0,
19373 CP1_ }, /* POOL32F_0~*(18) */
19374 { reserved_block , 0 , 0 , 32,
19375 0xfc0001ff, 0xa0000098, 0 , 0,
19376 CP1_ }, /* POOL32F_0~*(19) */
19377 { reserved_block , 0 , 0 , 32,
19378 0xfc0001ff, 0xa00000a0, 0 , 0,
19379 CP1_ }, /* POOL32F_0~*(20) */
19380 { reserved_block , 0 , 0 , 32,
19381 0xfc0001ff, 0xa00000a8, 0 , 0,
19382 CP1_ }, /* POOL32F_0~*(21) */
19383 { pool , MUL_fmt0 , 2 , 32,
19384 0xfc0001ff, 0xa00000b0, 0 , 0,
19385 CP1_ }, /* MUL.fmt0 */
19386 { pool , SEL_fmt , 2 , 32,
19387 0xfc0001ff, 0xa00000b8, 0 , 0,
19388 CP1_ }, /* SEL.fmt */
19389 { reserved_block , 0 , 0 , 32,
19390 0xfc0001ff, 0xa00000c0, 0 , 0,
19391 CP1_ }, /* POOL32F_0~*(24) */
19392 { reserved_block , 0 , 0 , 32,
19393 0xfc0001ff, 0xa00000c8, 0 , 0,
19394 CP1_ }, /* POOL32F_0~*(25) */
19395 { reserved_block , 0 , 0 , 32,
19396 0xfc0001ff, 0xa00000d0, 0 , 0,
19397 CP1_ }, /* POOL32F_0~*(26) */
19398 { reserved_block , 0 , 0 , 32,
19399 0xfc0001ff, 0xa00000d8, 0 , 0,
19400 CP1_ }, /* POOL32F_0~*(27) */
19401 { reserved_block , 0 , 0 , 32,
19402 0xfc0001ff, 0xa00000e0, 0 , 0,
19403 CP1_ }, /* POOL32F_0~*(28) */
19404 { reserved_block , 0 , 0 , 32,
19405 0xfc0001ff, 0xa00000e8, 0 , 0,
19406 CP1_ }, /* POOL32F_0~*(29) */
19407 { pool , DIV_fmt0 , 2 , 32,
19408 0xfc0001ff, 0xa00000f0, 0 , 0,
19409 CP1_ }, /* DIV.fmt0 */
19410 { reserved_block , 0 , 0 , 32,
19411 0xfc0001ff, 0xa00000f8, 0 , 0,
19412 CP1_ }, /* POOL32F_0~*(31) */
19413 { reserved_block , 0 , 0 , 32,
19414 0xfc0001ff, 0xa0000100, 0 , 0,
19415 CP1_ }, /* POOL32F_0~*(32) */
19416 { reserved_block , 0 , 0 , 32,
19417 0xfc0001ff, 0xa0000108, 0 , 0,
19418 CP1_ }, /* POOL32F_0~*(33) */
19419 { reserved_block , 0 , 0 , 32,
19420 0xfc0001ff, 0xa0000110, 0 , 0,
19421 CP1_ }, /* POOL32F_0~*(34) */
19422 { reserved_block , 0 , 0 , 32,
19423 0xfc0001ff, 0xa0000118, 0 , 0,
19424 CP1_ }, /* POOL32F_0~*(35) */
19425 { reserved_block , 0 , 0 , 32,
19426 0xfc0001ff, 0xa0000120, 0 , 0,
19427 CP1_ }, /* POOL32F_0~*(36) */
19428 { reserved_block , 0 , 0 , 32,
19429 0xfc0001ff, 0xa0000128, 0 , 0,
19430 CP1_ }, /* POOL32F_0~*(37) */
19431 { pool , ADD_fmt1 , 2 , 32,
19432 0xfc0001ff, 0xa0000130, 0 , 0,
19433 CP1_ }, /* ADD.fmt1 */
19434 { reserved_block , 0 , 0 , 32,
19435 0xfc0001ff, 0xa0000138, 0 , 0,
19436 CP1_ }, /* POOL32F_0~*(39) */
19437 { reserved_block , 0 , 0 , 32,
19438 0xfc0001ff, 0xa0000140, 0 , 0,
19439 CP1_ }, /* POOL32F_0~*(40) */
19440 { reserved_block , 0 , 0 , 32,
19441 0xfc0001ff, 0xa0000148, 0 , 0,
19442 CP1_ }, /* POOL32F_0~*(41) */
19443 { reserved_block , 0 , 0 , 32,
19444 0xfc0001ff, 0xa0000150, 0 , 0,
19445 CP1_ }, /* POOL32F_0~*(42) */
19446 { reserved_block , 0 , 0 , 32,
19447 0xfc0001ff, 0xa0000158, 0 , 0,
19448 CP1_ }, /* POOL32F_0~*(43) */
19449 { reserved_block , 0 , 0 , 32,
19450 0xfc0001ff, 0xa0000160, 0 , 0,
19451 CP1_ }, /* POOL32F_0~*(44) */
19452 { reserved_block , 0 , 0 , 32,
19453 0xfc0001ff, 0xa0000168, 0 , 0,
19454 CP1_ }, /* POOL32F_0~*(45) */
19455 { pool , SUB_fmt1 , 2 , 32,
19456 0xfc0001ff, 0xa0000170, 0 , 0,
19457 CP1_ }, /* SUB.fmt1 */
19458 { reserved_block , 0 , 0 , 32,
19459 0xfc0001ff, 0xa0000178, 0 , 0,
19460 CP1_ }, /* POOL32F_0~*(47) */
19461 { reserved_block , 0 , 0 , 32,
19462 0xfc0001ff, 0xa0000180, 0 , 0,
19463 CP1_ }, /* POOL32F_0~*(48) */
19464 { reserved_block , 0 , 0 , 32,
19465 0xfc0001ff, 0xa0000188, 0 , 0,
19466 CP1_ }, /* POOL32F_0~*(49) */
19467 { reserved_block , 0 , 0 , 32,
19468 0xfc0001ff, 0xa0000190, 0 , 0,
19469 CP1_ }, /* POOL32F_0~*(50) */
19470 { reserved_block , 0 , 0 , 32,
19471 0xfc0001ff, 0xa0000198, 0 , 0,
19472 CP1_ }, /* POOL32F_0~*(51) */
19473 { reserved_block , 0 , 0 , 32,
19474 0xfc0001ff, 0xa00001a0, 0 , 0,
19475 CP1_ }, /* POOL32F_0~*(52) */
19476 { reserved_block , 0 , 0 , 32,
19477 0xfc0001ff, 0xa00001a8, 0 , 0,
19478 CP1_ }, /* POOL32F_0~*(53) */
19479 { pool , MUL_fmt1 , 2 , 32,
19480 0xfc0001ff, 0xa00001b0, 0 , 0,
19481 CP1_ }, /* MUL.fmt1 */
19482 { pool , MADDF_fmt , 2 , 32,
19483 0xfc0001ff, 0xa00001b8, 0 , 0,
19484 CP1_ }, /* MADDF.fmt */
19485 { reserved_block , 0 , 0 , 32,
19486 0xfc0001ff, 0xa00001c0, 0 , 0,
19487 CP1_ }, /* POOL32F_0~*(56) */
19488 { reserved_block , 0 , 0 , 32,
19489 0xfc0001ff, 0xa00001c8, 0 , 0,
19490 CP1_ }, /* POOL32F_0~*(57) */
19491 { reserved_block , 0 , 0 , 32,
19492 0xfc0001ff, 0xa00001d0, 0 , 0,
19493 CP1_ }, /* POOL32F_0~*(58) */
19494 { reserved_block , 0 , 0 , 32,
19495 0xfc0001ff, 0xa00001d8, 0 , 0,
19496 CP1_ }, /* POOL32F_0~*(59) */
19497 { reserved_block , 0 , 0 , 32,
19498 0xfc0001ff, 0xa00001e0, 0 , 0,
19499 CP1_ }, /* POOL32F_0~*(60) */
19500 { reserved_block , 0 , 0 , 32,
19501 0xfc0001ff, 0xa00001e8, 0 , 0,
19502 CP1_ }, /* POOL32F_0~*(61) */
19503 { pool , DIV_fmt1 , 2 , 32,
19504 0xfc0001ff, 0xa00001f0, 0 , 0,
19505 CP1_ }, /* DIV.fmt1 */
19506 { pool , MSUBF_fmt , 2 , 32,
19507 0xfc0001ff, 0xa00001f8, 0 , 0,
19508 CP1_ }, /* MSUBF.fmt */
19509 };
19510
19511
19512 NMD::Pool NMD::MIN_fmt[2] = {
19513 { instruction , 0 , 0 , 32,
19514 0xfc00023f, 0xa0000003, &NMD::MIN_S , 0,
19515 CP1_ }, /* MIN.S */
19516 { instruction , 0 , 0 , 32,
19517 0xfc00023f, 0xa0000203, &NMD::MIN_D , 0,
19518 CP1_ }, /* MIN.D */
19519 };
19520
19521
19522 NMD::Pool NMD::MAX_fmt[2] = {
19523 { instruction , 0 , 0 , 32,
19524 0xfc00023f, 0xa000000b, &NMD::MAX_S , 0,
19525 CP1_ }, /* MAX.S */
19526 { instruction , 0 , 0 , 32,
19527 0xfc00023f, 0xa000020b, &NMD::MAX_D , 0,
19528 CP1_ }, /* MAX.D */
19529 };
19530
19531
19532 NMD::Pool NMD::MINA_fmt[2] = {
19533 { instruction , 0 , 0 , 32,
19534 0xfc00023f, 0xa0000023, &NMD::MINA_S , 0,
19535 CP1_ }, /* MINA.S */
19536 { instruction , 0 , 0 , 32,
19537 0xfc00023f, 0xa0000223, &NMD::MINA_D , 0,
19538 CP1_ }, /* MINA.D */
19539 };
19540
19541
19542 NMD::Pool NMD::MAXA_fmt[2] = {
19543 { instruction , 0 , 0 , 32,
19544 0xfc00023f, 0xa000002b, &NMD::MAXA_S , 0,
19545 CP1_ }, /* MAXA.S */
19546 { instruction , 0 , 0 , 32,
19547 0xfc00023f, 0xa000022b, &NMD::MAXA_D , 0,
19548 CP1_ }, /* MAXA.D */
19549 };
19550
19551
19552 NMD::Pool NMD::CVT_L_fmt[2] = {
19553 { instruction , 0 , 0 , 32,
19554 0xfc007fff, 0xa000013b, &NMD::CVT_L_S , 0,
19555 CP1_ }, /* CVT.L.S */
19556 { instruction , 0 , 0 , 32,
19557 0xfc007fff, 0xa000413b, &NMD::CVT_L_D , 0,
19558 CP1_ }, /* CVT.L.D */
19559 };
19560
19561
19562 NMD::Pool NMD::RSQRT_fmt[2] = {
19563 { instruction , 0 , 0 , 32,
19564 0xfc007fff, 0xa000023b, &NMD::RSQRT_S , 0,
19565 CP1_ }, /* RSQRT.S */
19566 { instruction , 0 , 0 , 32,
19567 0xfc007fff, 0xa000423b, &NMD::RSQRT_D , 0,
19568 CP1_ }, /* RSQRT.D */
19569 };
19570
19571
19572 NMD::Pool NMD::FLOOR_L_fmt[2] = {
19573 { instruction , 0 , 0 , 32,
19574 0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S , 0,
19575 CP1_ }, /* FLOOR.L.S */
19576 { instruction , 0 , 0 , 32,
19577 0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D , 0,
19578 CP1_ }, /* FLOOR.L.D */
19579 };
19580
19581
19582 NMD::Pool NMD::CVT_W_fmt[2] = {
19583 { instruction , 0 , 0 , 32,
19584 0xfc007fff, 0xa000093b, &NMD::CVT_W_S , 0,
19585 CP1_ }, /* CVT.W.S */
19586 { instruction , 0 , 0 , 32,
19587 0xfc007fff, 0xa000493b, &NMD::CVT_W_D , 0,
19588 CP1_ }, /* CVT.W.D */
19589 };
19590
19591
19592 NMD::Pool NMD::SQRT_fmt[2] = {
19593 { instruction , 0 , 0 , 32,
19594 0xfc007fff, 0xa0000a3b, &NMD::SQRT_S , 0,
19595 CP1_ }, /* SQRT.S */
19596 { instruction , 0 , 0 , 32,
19597 0xfc007fff, 0xa0004a3b, &NMD::SQRT_D , 0,
19598 CP1_ }, /* SQRT.D */
19599 };
19600
19601
19602 NMD::Pool NMD::FLOOR_W_fmt[2] = {
19603 { instruction , 0 , 0 , 32,
19604 0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S , 0,
19605 CP1_ }, /* FLOOR.W.S */
19606 { instruction , 0 , 0 , 32,
19607 0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D , 0,
19608 CP1_ }, /* FLOOR.W.D */
19609 };
19610
19611
19612 NMD::Pool NMD::RECIP_fmt[2] = {
19613 { instruction , 0 , 0 , 32,
19614 0xfc007fff, 0xa000123b, &NMD::RECIP_S , 0,
19615 CP1_ }, /* RECIP.S */
19616 { instruction , 0 , 0 , 32,
19617 0xfc007fff, 0xa000523b, &NMD::RECIP_D , 0,
19618 CP1_ }, /* RECIP.D */
19619 };
19620
19621
19622 NMD::Pool NMD::CEIL_L_fmt[2] = {
19623 { instruction , 0 , 0 , 32,
19624 0xfc007fff, 0xa000133b, &NMD::CEIL_L_S , 0,
19625 CP1_ }, /* CEIL.L.S */
19626 { instruction , 0 , 0 , 32,
19627 0xfc007fff, 0xa000533b, &NMD::CEIL_L_D , 0,
19628 CP1_ }, /* CEIL.L.D */
19629 };
19630
19631
19632 NMD::Pool NMD::CEIL_W_fmt[2] = {
19633 { instruction , 0 , 0 , 32,
19634 0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S , 0,
19635 CP1_ }, /* CEIL.W.S */
19636 { instruction , 0 , 0 , 32,
19637 0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D , 0,
19638 CP1_ }, /* CEIL.W.D */
19639 };
19640
19641
19642 NMD::Pool NMD::TRUNC_L_fmt[2] = {
19643 { instruction , 0 , 0 , 32,
19644 0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S , 0,
19645 CP1_ }, /* TRUNC.L.S */
19646 { instruction , 0 , 0 , 32,
19647 0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D , 0,
19648 CP1_ }, /* TRUNC.L.D */
19649 };
19650
19651
19652 NMD::Pool NMD::TRUNC_W_fmt[2] = {
19653 { instruction , 0 , 0 , 32,
19654 0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S , 0,
19655 CP1_ }, /* TRUNC.W.S */
19656 { instruction , 0 , 0 , 32,
19657 0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D , 0,
19658 CP1_ }, /* TRUNC.W.D */
19659 };
19660
19661
19662 NMD::Pool NMD::ROUND_L_fmt[2] = {
19663 { instruction , 0 , 0 , 32,
19664 0xfc007fff, 0xa000333b, &NMD::ROUND_L_S , 0,
19665 CP1_ }, /* ROUND.L.S */
19666 { instruction , 0 , 0 , 32,
19667 0xfc007fff, 0xa000733b, &NMD::ROUND_L_D , 0,
19668 CP1_ }, /* ROUND.L.D */
19669 };
19670
19671
19672 NMD::Pool NMD::ROUND_W_fmt[2] = {
19673 { instruction , 0 , 0 , 32,
19674 0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S , 0,
19675 CP1_ }, /* ROUND.W.S */
19676 { instruction , 0 , 0 , 32,
19677 0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D , 0,
19678 CP1_ }, /* ROUND.W.D */
19679 };
19680
19681
19682 NMD::Pool NMD::POOL32Fxf_0[64] = {
19683 { reserved_block , 0 , 0 , 32,
19684 0xfc003fff, 0xa000003b, 0 , 0,
19685 CP1_ }, /* POOL32Fxf_0~*(0) */
19686 { pool , CVT_L_fmt , 2 , 32,
19687 0xfc003fff, 0xa000013b, 0 , 0,
19688 CP1_ }, /* CVT.L.fmt */
19689 { pool , RSQRT_fmt , 2 , 32,
19690 0xfc003fff, 0xa000023b, 0 , 0,
19691 CP1_ }, /* RSQRT.fmt */
19692 { pool , FLOOR_L_fmt , 2 , 32,
19693 0xfc003fff, 0xa000033b, 0 , 0,
19694 CP1_ }, /* FLOOR.L.fmt */
19695 { reserved_block , 0 , 0 , 32,
19696 0xfc003fff, 0xa000043b, 0 , 0,
19697 CP1_ }, /* POOL32Fxf_0~*(4) */
19698 { reserved_block , 0 , 0 , 32,
19699 0xfc003fff, 0xa000053b, 0 , 0,
19700 CP1_ }, /* POOL32Fxf_0~*(5) */
19701 { reserved_block , 0 , 0 , 32,
19702 0xfc003fff, 0xa000063b, 0 , 0,
19703 CP1_ }, /* POOL32Fxf_0~*(6) */
19704 { reserved_block , 0 , 0 , 32,
19705 0xfc003fff, 0xa000073b, 0 , 0,
19706 CP1_ }, /* POOL32Fxf_0~*(7) */
19707 { reserved_block , 0 , 0 , 32,
19708 0xfc003fff, 0xa000083b, 0 , 0,
19709 CP1_ }, /* POOL32Fxf_0~*(8) */
19710 { pool , CVT_W_fmt , 2 , 32,
19711 0xfc003fff, 0xa000093b, 0 , 0,
19712 CP1_ }, /* CVT.W.fmt */
19713 { pool , SQRT_fmt , 2 , 32,
19714 0xfc003fff, 0xa0000a3b, 0 , 0,
19715 CP1_ }, /* SQRT.fmt */
19716 { pool , FLOOR_W_fmt , 2 , 32,
19717 0xfc003fff, 0xa0000b3b, 0 , 0,
19718 CP1_ }, /* FLOOR.W.fmt */
19719 { reserved_block , 0 , 0 , 32,
19720 0xfc003fff, 0xa0000c3b, 0 , 0,
19721 CP1_ }, /* POOL32Fxf_0~*(12) */
19722 { reserved_block , 0 , 0 , 32,
19723 0xfc003fff, 0xa0000d3b, 0 , 0,
19724 CP1_ }, /* POOL32Fxf_0~*(13) */
19725 { reserved_block , 0 , 0 , 32,
19726 0xfc003fff, 0xa0000e3b, 0 , 0,
19727 CP1_ }, /* POOL32Fxf_0~*(14) */
19728 { reserved_block , 0 , 0 , 32,
19729 0xfc003fff, 0xa0000f3b, 0 , 0,
19730 CP1_ }, /* POOL32Fxf_0~*(15) */
19731 { instruction , 0 , 0 , 32,
19732 0xfc003fff, 0xa000103b, &NMD::CFC1 , 0,
19733 CP1_ }, /* CFC1 */
19734 { reserved_block , 0 , 0 , 32,
19735 0xfc003fff, 0xa000113b, 0 , 0,
19736 CP1_ }, /* POOL32Fxf_0~*(17) */
19737 { pool , RECIP_fmt , 2 , 32,
19738 0xfc003fff, 0xa000123b, 0 , 0,
19739 CP1_ }, /* RECIP.fmt */
19740 { pool , CEIL_L_fmt , 2 , 32,
19741 0xfc003fff, 0xa000133b, 0 , 0,
19742 CP1_ }, /* CEIL.L.fmt */
19743 { reserved_block , 0 , 0 , 32,
19744 0xfc003fff, 0xa000143b, 0 , 0,
19745 CP1_ }, /* POOL32Fxf_0~*(20) */
19746 { reserved_block , 0 , 0 , 32,
19747 0xfc003fff, 0xa000153b, 0 , 0,
19748 CP1_ }, /* POOL32Fxf_0~*(21) */
19749 { reserved_block , 0 , 0 , 32,
19750 0xfc003fff, 0xa000163b, 0 , 0,
19751 CP1_ }, /* POOL32Fxf_0~*(22) */
19752 { reserved_block , 0 , 0 , 32,
19753 0xfc003fff, 0xa000173b, 0 , 0,
19754 CP1_ }, /* POOL32Fxf_0~*(23) */
19755 { instruction , 0 , 0 , 32,
19756 0xfc003fff, 0xa000183b, &NMD::CTC1 , 0,
19757 CP1_ }, /* CTC1 */
19758 { reserved_block , 0 , 0 , 32,
19759 0xfc003fff, 0xa000193b, 0 , 0,
19760 CP1_ }, /* POOL32Fxf_0~*(25) */
19761 { reserved_block , 0 , 0 , 32,
19762 0xfc003fff, 0xa0001a3b, 0 , 0,
19763 CP1_ }, /* POOL32Fxf_0~*(26) */
19764 { pool , CEIL_W_fmt , 2 , 32,
19765 0xfc003fff, 0xa0001b3b, 0 , 0,
19766 CP1_ }, /* CEIL.W.fmt */
19767 { reserved_block , 0 , 0 , 32,
19768 0xfc003fff, 0xa0001c3b, 0 , 0,
19769 CP1_ }, /* POOL32Fxf_0~*(28) */
19770 { reserved_block , 0 , 0 , 32,
19771 0xfc003fff, 0xa0001d3b, 0 , 0,
19772 CP1_ }, /* POOL32Fxf_0~*(29) */
19773 { reserved_block , 0 , 0 , 32,
19774 0xfc003fff, 0xa0001e3b, 0 , 0,
19775 CP1_ }, /* POOL32Fxf_0~*(30) */
19776 { reserved_block , 0 , 0 , 32,
19777 0xfc003fff, 0xa0001f3b, 0 , 0,
19778 CP1_ }, /* POOL32Fxf_0~*(31) */
19779 { instruction , 0 , 0 , 32,
19780 0xfc003fff, 0xa000203b, &NMD::MFC1 , 0,
19781 CP1_ }, /* MFC1 */
19782 { instruction , 0 , 0 , 32,
19783 0xfc003fff, 0xa000213b, &NMD::CVT_S_PL , 0,
19784 CP1_ }, /* CVT.S.PL */
19785 { reserved_block , 0 , 0 , 32,
19786 0xfc003fff, 0xa000223b, 0 , 0,
19787 CP1_ }, /* POOL32Fxf_0~*(34) */
19788 { pool , TRUNC_L_fmt , 2 , 32,
19789 0xfc003fff, 0xa000233b, 0 , 0,
19790 CP1_ }, /* TRUNC.L.fmt */
19791 { instruction , 0 , 0 , 32,
19792 0xfc003fff, 0xa000243b, &NMD::DMFC1 , 0,
19793 CP1_ | MIPS64_ }, /* DMFC1 */
19794 { reserved_block , 0 , 0 , 32,
19795 0xfc003fff, 0xa000253b, 0 , 0,
19796 CP1_ }, /* POOL32Fxf_0~*(37) */
19797 { reserved_block , 0 , 0 , 32,
19798 0xfc003fff, 0xa000263b, 0 , 0,
19799 CP1_ }, /* POOL32Fxf_0~*(38) */
19800 { reserved_block , 0 , 0 , 32,
19801 0xfc003fff, 0xa000273b, 0 , 0,
19802 CP1_ }, /* POOL32Fxf_0~*(39) */
19803 { instruction , 0 , 0 , 32,
19804 0xfc003fff, 0xa000283b, &NMD::MTC1 , 0,
19805 CP1_ }, /* MTC1 */
19806 { instruction , 0 , 0 , 32,
19807 0xfc003fff, 0xa000293b, &NMD::CVT_S_PU , 0,
19808 CP1_ }, /* CVT.S.PU */
19809 { reserved_block , 0 , 0 , 32,
19810 0xfc003fff, 0xa0002a3b, 0 , 0,
19811 CP1_ }, /* POOL32Fxf_0~*(42) */
19812 { pool , TRUNC_W_fmt , 2 , 32,
19813 0xfc003fff, 0xa0002b3b, 0 , 0,
19814 CP1_ }, /* TRUNC.W.fmt */
19815 { instruction , 0 , 0 , 32,
19816 0xfc003fff, 0xa0002c3b, &NMD::DMTC1 , 0,
19817 CP1_ | MIPS64_ }, /* DMTC1 */
19818 { reserved_block , 0 , 0 , 32,
19819 0xfc003fff, 0xa0002d3b, 0 , 0,
19820 CP1_ }, /* POOL32Fxf_0~*(45) */
19821 { reserved_block , 0 , 0 , 32,
19822 0xfc003fff, 0xa0002e3b, 0 , 0,
19823 CP1_ }, /* POOL32Fxf_0~*(46) */
19824 { reserved_block , 0 , 0 , 32,
19825 0xfc003fff, 0xa0002f3b, 0 , 0,
19826 CP1_ }, /* POOL32Fxf_0~*(47) */
19827 { instruction , 0 , 0 , 32,
19828 0xfc003fff, 0xa000303b, &NMD::MFHC1 , 0,
19829 CP1_ }, /* MFHC1 */
19830 { reserved_block , 0 , 0 , 32,
19831 0xfc003fff, 0xa000313b, 0 , 0,
19832 CP1_ }, /* POOL32Fxf_0~*(49) */
19833 { reserved_block , 0 , 0 , 32,
19834 0xfc003fff, 0xa000323b, 0 , 0,
19835 CP1_ }, /* POOL32Fxf_0~*(50) */
19836 { pool , ROUND_L_fmt , 2 , 32,
19837 0xfc003fff, 0xa000333b, 0 , 0,
19838 CP1_ }, /* ROUND.L.fmt */
19839 { reserved_block , 0 , 0 , 32,
19840 0xfc003fff, 0xa000343b, 0 , 0,
19841 CP1_ }, /* POOL32Fxf_0~*(52) */
19842 { reserved_block , 0 , 0 , 32,
19843 0xfc003fff, 0xa000353b, 0 , 0,
19844 CP1_ }, /* POOL32Fxf_0~*(53) */
19845 { reserved_block , 0 , 0 , 32,
19846 0xfc003fff, 0xa000363b, 0 , 0,
19847 CP1_ }, /* POOL32Fxf_0~*(54) */
19848 { reserved_block , 0 , 0 , 32,
19849 0xfc003fff, 0xa000373b, 0 , 0,
19850 CP1_ }, /* POOL32Fxf_0~*(55) */
19851 { instruction , 0 , 0 , 32,
19852 0xfc003fff, 0xa000383b, &NMD::MTHC1 , 0,
19853 CP1_ }, /* MTHC1 */
19854 { reserved_block , 0 , 0 , 32,
19855 0xfc003fff, 0xa000393b, 0 , 0,
19856 CP1_ }, /* POOL32Fxf_0~*(57) */
19857 { reserved_block , 0 , 0 , 32,
19858 0xfc003fff, 0xa0003a3b, 0 , 0,
19859 CP1_ }, /* POOL32Fxf_0~*(58) */
19860 { pool , ROUND_W_fmt , 2 , 32,
19861 0xfc003fff, 0xa0003b3b, 0 , 0,
19862 CP1_ }, /* ROUND.W.fmt */
19863 { reserved_block , 0 , 0 , 32,
19864 0xfc003fff, 0xa0003c3b, 0 , 0,
19865 CP1_ }, /* POOL32Fxf_0~*(60) */
19866 { reserved_block , 0 , 0 , 32,
19867 0xfc003fff, 0xa0003d3b, 0 , 0,
19868 CP1_ }, /* POOL32Fxf_0~*(61) */
19869 { reserved_block , 0 , 0 , 32,
19870 0xfc003fff, 0xa0003e3b, 0 , 0,
19871 CP1_ }, /* POOL32Fxf_0~*(62) */
19872 { reserved_block , 0 , 0 , 32,
19873 0xfc003fff, 0xa0003f3b, 0 , 0,
19874 CP1_ }, /* POOL32Fxf_0~*(63) */
19875 };
19876
19877
19878 NMD::Pool NMD::MOV_fmt[4] = {
19879 { instruction , 0 , 0 , 32,
19880 0xfc007fff, 0xa000007b, &NMD::MOV_S , 0,
19881 CP1_ }, /* MOV.S */
19882 { instruction , 0 , 0 , 32,
19883 0xfc007fff, 0xa000207b, &NMD::MOV_D , 0,
19884 CP1_ }, /* MOV.D */
19885 { reserved_block , 0 , 0 , 32,
19886 0xfc007fff, 0xa000407b, 0 , 0,
19887 CP1_ }, /* MOV.fmt~*(2) */
19888 { reserved_block , 0 , 0 , 32,
19889 0xfc007fff, 0xa000607b, 0 , 0,
19890 CP1_ }, /* MOV.fmt~*(3) */
19891 };
19892
19893
19894 NMD::Pool NMD::ABS_fmt[4] = {
19895 { instruction , 0 , 0 , 32,
19896 0xfc007fff, 0xa000037b, &NMD::ABS_S , 0,
19897 CP1_ }, /* ABS.S */
19898 { instruction , 0 , 0 , 32,
19899 0xfc007fff, 0xa000237b, &NMD::ABS_D , 0,
19900 CP1_ }, /* ABS.D */
19901 { reserved_block , 0 , 0 , 32,
19902 0xfc007fff, 0xa000437b, 0 , 0,
19903 CP1_ }, /* ABS.fmt~*(2) */
19904 { reserved_block , 0 , 0 , 32,
19905 0xfc007fff, 0xa000637b, 0 , 0,
19906 CP1_ }, /* ABS.fmt~*(3) */
19907 };
19908
19909
19910 NMD::Pool NMD::NEG_fmt[4] = {
19911 { instruction , 0 , 0 , 32,
19912 0xfc007fff, 0xa0000b7b, &NMD::NEG_S , 0,
19913 CP1_ }, /* NEG.S */
19914 { instruction , 0 , 0 , 32,
19915 0xfc007fff, 0xa0002b7b, &NMD::NEG_D , 0,
19916 CP1_ }, /* NEG.D */
19917 { reserved_block , 0 , 0 , 32,
19918 0xfc007fff, 0xa0004b7b, 0 , 0,
19919 CP1_ }, /* NEG.fmt~*(2) */
19920 { reserved_block , 0 , 0 , 32,
19921 0xfc007fff, 0xa0006b7b, 0 , 0,
19922 CP1_ }, /* NEG.fmt~*(3) */
19923 };
19924
19925
19926 NMD::Pool NMD::CVT_D_fmt[4] = {
19927 { instruction , 0 , 0 , 32,
19928 0xfc007fff, 0xa000137b, &NMD::CVT_D_S , 0,
19929 CP1_ }, /* CVT.D.S */
19930 { instruction , 0 , 0 , 32,
19931 0xfc007fff, 0xa000337b, &NMD::CVT_D_W , 0,
19932 CP1_ }, /* CVT.D.W */
19933 { instruction , 0 , 0 , 32,
19934 0xfc007fff, 0xa000537b, &NMD::CVT_D_L , 0,
19935 CP1_ }, /* CVT.D.L */
19936 { reserved_block , 0 , 0 , 32,
19937 0xfc007fff, 0xa000737b, 0 , 0,
19938 CP1_ }, /* CVT.D.fmt~*(3) */
19939 };
19940
19941
19942 NMD::Pool NMD::CVT_S_fmt[4] = {
19943 { instruction , 0 , 0 , 32,
19944 0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D , 0,
19945 CP1_ }, /* CVT.S.D */
19946 { instruction , 0 , 0 , 32,
19947 0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W , 0,
19948 CP1_ }, /* CVT.S.W */
19949 { instruction , 0 , 0 , 32,
19950 0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L , 0,
19951 CP1_ }, /* CVT.S.L */
19952 { reserved_block , 0 , 0 , 32,
19953 0xfc007fff, 0xa0007b7b, 0 , 0,
19954 CP1_ }, /* CVT.S.fmt~*(3) */
19955 };
19956
19957
19958 NMD::Pool NMD::POOL32Fxf_1[32] = {
19959 { pool , MOV_fmt , 4 , 32,
19960 0xfc001fff, 0xa000007b, 0 , 0,
19961 CP1_ }, /* MOV.fmt */
19962 { reserved_block , 0 , 0 , 32,
19963 0xfc001fff, 0xa000017b, 0 , 0,
19964 CP1_ }, /* POOL32Fxf_1~*(1) */
19965 { reserved_block , 0 , 0 , 32,
19966 0xfc001fff, 0xa000027b, 0 , 0,
19967 CP1_ }, /* POOL32Fxf_1~*(2) */
19968 { pool , ABS_fmt , 4 , 32,
19969 0xfc001fff, 0xa000037b, 0 , 0,
19970 CP1_ }, /* ABS.fmt */
19971 { reserved_block , 0 , 0 , 32,
19972 0xfc001fff, 0xa000047b, 0 , 0,
19973 CP1_ }, /* POOL32Fxf_1~*(4) */
19974 { reserved_block , 0 , 0 , 32,
19975 0xfc001fff, 0xa000057b, 0 , 0,
19976 CP1_ }, /* POOL32Fxf_1~*(5) */
19977 { reserved_block , 0 , 0 , 32,
19978 0xfc001fff, 0xa000067b, 0 , 0,
19979 CP1_ }, /* POOL32Fxf_1~*(6) */
19980 { reserved_block , 0 , 0 , 32,
19981 0xfc001fff, 0xa000077b, 0 , 0,
19982 CP1_ }, /* POOL32Fxf_1~*(7) */
19983 { reserved_block , 0 , 0 , 32,
19984 0xfc001fff, 0xa000087b, 0 , 0,
19985 CP1_ }, /* POOL32Fxf_1~*(8) */
19986 { reserved_block , 0 , 0 , 32,
19987 0xfc001fff, 0xa000097b, 0 , 0,
19988 CP1_ }, /* POOL32Fxf_1~*(9) */
19989 { reserved_block , 0 , 0 , 32,
19990 0xfc001fff, 0xa0000a7b, 0 , 0,
19991 CP1_ }, /* POOL32Fxf_1~*(10) */
19992 { pool , NEG_fmt , 4 , 32,
19993 0xfc001fff, 0xa0000b7b, 0 , 0,
19994 CP1_ }, /* NEG.fmt */
19995 { reserved_block , 0 , 0 , 32,
19996 0xfc001fff, 0xa0000c7b, 0 , 0,
19997 CP1_ }, /* POOL32Fxf_1~*(12) */
19998 { reserved_block , 0 , 0 , 32,
19999 0xfc001fff, 0xa0000d7b, 0 , 0,
20000 CP1_ }, /* POOL32Fxf_1~*(13) */
20001 { reserved_block , 0 , 0 , 32,
20002 0xfc001fff, 0xa0000e7b, 0 , 0,
20003 CP1_ }, /* POOL32Fxf_1~*(14) */
20004 { reserved_block , 0 , 0 , 32,
20005 0xfc001fff, 0xa0000f7b, 0 , 0,
20006 CP1_ }, /* POOL32Fxf_1~*(15) */
20007 { reserved_block , 0 , 0 , 32,
20008 0xfc001fff, 0xa000107b, 0 , 0,
20009 CP1_ }, /* POOL32Fxf_1~*(16) */
20010 { reserved_block , 0 , 0 , 32,
20011 0xfc001fff, 0xa000117b, 0 , 0,
20012 CP1_ }, /* POOL32Fxf_1~*(17) */
20013 { reserved_block , 0 , 0 , 32,
20014 0xfc001fff, 0xa000127b, 0 , 0,
20015 CP1_ }, /* POOL32Fxf_1~*(18) */
20016 { pool , CVT_D_fmt , 4 , 32,
20017 0xfc001fff, 0xa000137b, 0 , 0,
20018 CP1_ }, /* CVT.D.fmt */
20019 { reserved_block , 0 , 0 , 32,
20020 0xfc001fff, 0xa000147b, 0 , 0,
20021 CP1_ }, /* POOL32Fxf_1~*(20) */
20022 { reserved_block , 0 , 0 , 32,
20023 0xfc001fff, 0xa000157b, 0 , 0,
20024 CP1_ }, /* POOL32Fxf_1~*(21) */
20025 { reserved_block , 0 , 0 , 32,
20026 0xfc001fff, 0xa000167b, 0 , 0,
20027 CP1_ }, /* POOL32Fxf_1~*(22) */
20028 { reserved_block , 0 , 0 , 32,
20029 0xfc001fff, 0xa000177b, 0 , 0,
20030 CP1_ }, /* POOL32Fxf_1~*(23) */
20031 { reserved_block , 0 , 0 , 32,
20032 0xfc001fff, 0xa000187b, 0 , 0,
20033 CP1_ }, /* POOL32Fxf_1~*(24) */
20034 { reserved_block , 0 , 0 , 32,
20035 0xfc001fff, 0xa000197b, 0 , 0,
20036 CP1_ }, /* POOL32Fxf_1~*(25) */
20037 { reserved_block , 0 , 0 , 32,
20038 0xfc001fff, 0xa0001a7b, 0 , 0,
20039 CP1_ }, /* POOL32Fxf_1~*(26) */
20040 { pool , CVT_S_fmt , 4 , 32,
20041 0xfc001fff, 0xa0001b7b, 0 , 0,
20042 CP1_ }, /* CVT.S.fmt */
20043 { reserved_block , 0 , 0 , 32,
20044 0xfc001fff, 0xa0001c7b, 0 , 0,
20045 CP1_ }, /* POOL32Fxf_1~*(28) */
20046 { reserved_block , 0 , 0 , 32,
20047 0xfc001fff, 0xa0001d7b, 0 , 0,
20048 CP1_ }, /* POOL32Fxf_1~*(29) */
20049 { reserved_block , 0 , 0 , 32,
20050 0xfc001fff, 0xa0001e7b, 0 , 0,
20051 CP1_ }, /* POOL32Fxf_1~*(30) */
20052 { reserved_block , 0 , 0 , 32,
20053 0xfc001fff, 0xa0001f7b, 0 , 0,
20054 CP1_ }, /* POOL32Fxf_1~*(31) */
20055 };
20056
20057
20058 NMD::Pool NMD::POOL32Fxf[4] = {
20059 { pool , POOL32Fxf_0 , 64 , 32,
20060 0xfc0000ff, 0xa000003b, 0 , 0,
20061 CP1_ }, /* POOL32Fxf_0 */
20062 { pool , POOL32Fxf_1 , 32 , 32,
20063 0xfc0000ff, 0xa000007b, 0 , 0,
20064 CP1_ }, /* POOL32Fxf_1 */
20065 { reserved_block , 0 , 0 , 32,
20066 0xfc0000ff, 0xa00000bb, 0 , 0,
20067 CP1_ }, /* POOL32Fxf~*(2) */
20068 { reserved_block , 0 , 0 , 32,
20069 0xfc0000ff, 0xa00000fb, 0 , 0,
20070 CP1_ }, /* POOL32Fxf~*(3) */
20071 };
20072
20073
20074 NMD::Pool NMD::POOL32F_3[8] = {
20075 { pool , MIN_fmt , 2 , 32,
20076 0xfc00003f, 0xa0000003, 0 , 0,
20077 CP1_ }, /* MIN.fmt */
20078 { pool , MAX_fmt , 2 , 32,
20079 0xfc00003f, 0xa000000b, 0 , 0,
20080 CP1_ }, /* MAX.fmt */
20081 { reserved_block , 0 , 0 , 32,
20082 0xfc00003f, 0xa0000013, 0 , 0,
20083 CP1_ }, /* POOL32F_3~*(2) */
20084 { reserved_block , 0 , 0 , 32,
20085 0xfc00003f, 0xa000001b, 0 , 0,
20086 CP1_ }, /* POOL32F_3~*(3) */
20087 { pool , MINA_fmt , 2 , 32,
20088 0xfc00003f, 0xa0000023, 0 , 0,
20089 CP1_ }, /* MINA.fmt */
20090 { pool , MAXA_fmt , 2 , 32,
20091 0xfc00003f, 0xa000002b, 0 , 0,
20092 CP1_ }, /* MAXA.fmt */
20093 { reserved_block , 0 , 0 , 32,
20094 0xfc00003f, 0xa0000033, 0 , 0,
20095 CP1_ }, /* POOL32F_3~*(6) */
20096 { pool , POOL32Fxf , 4 , 32,
20097 0xfc00003f, 0xa000003b, 0 , 0,
20098 CP1_ }, /* POOL32Fxf */
20099 };
20100
20101
20102 NMD::Pool NMD::CMP_condn_S[32] = {
20103 { instruction , 0 , 0 , 32,
20104 0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S , 0,
20105 CP1_ }, /* CMP.AF.S */
20106 { instruction , 0 , 0 , 32,
20107 0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S , 0,
20108 CP1_ }, /* CMP.UN.S */
20109 { instruction , 0 , 0 , 32,
20110 0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S , 0,
20111 CP1_ }, /* CMP.EQ.S */
20112 { instruction , 0 , 0 , 32,
20113 0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S , 0,
20114 CP1_ }, /* CMP.UEQ.S */
20115 { instruction , 0 , 0 , 32,
20116 0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S , 0,
20117 CP1_ }, /* CMP.LT.S */
20118 { instruction , 0 , 0 , 32,
20119 0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S , 0,
20120 CP1_ }, /* CMP.ULT.S */
20121 { instruction , 0 , 0 , 32,
20122 0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S , 0,
20123 CP1_ }, /* CMP.LE.S */
20124 { instruction , 0 , 0 , 32,
20125 0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S , 0,
20126 CP1_ }, /* CMP.ULE.S */
20127 { instruction , 0 , 0 , 32,
20128 0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S , 0,
20129 CP1_ }, /* CMP.SAF.S */
20130 { instruction , 0 , 0 , 32,
20131 0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S , 0,
20132 CP1_ }, /* CMP.SUN.S */
20133 { instruction , 0 , 0 , 32,
20134 0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S , 0,
20135 CP1_ }, /* CMP.SEQ.S */
20136 { instruction , 0 , 0 , 32,
20137 0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S , 0,
20138 CP1_ }, /* CMP.SUEQ.S */
20139 { instruction , 0 , 0 , 32,
20140 0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S , 0,
20141 CP1_ }, /* CMP.SLT.S */
20142 { instruction , 0 , 0 , 32,
20143 0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S , 0,
20144 CP1_ }, /* CMP.SULT.S */
20145 { instruction , 0 , 0 , 32,
20146 0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S , 0,
20147 CP1_ }, /* CMP.SLE.S */
20148 { instruction , 0 , 0 , 32,
20149 0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S , 0,
20150 CP1_ }, /* CMP.SULE.S */
20151 { reserved_block , 0 , 0 , 32,
20152 0xfc0007ff, 0xa0000405, 0 , 0,
20153 CP1_ }, /* CMP.condn.S~*(16) */
20154 { instruction , 0 , 0 , 32,
20155 0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S , 0,
20156 CP1_ }, /* CMP.OR.S */
20157 { instruction , 0 , 0 , 32,
20158 0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S , 0,
20159 CP1_ }, /* CMP.UNE.S */
20160 { instruction , 0 , 0 , 32,
20161 0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S , 0,
20162 CP1_ }, /* CMP.NE.S */
20163 { reserved_block , 0 , 0 , 32,
20164 0xfc0007ff, 0xa0000505, 0 , 0,
20165 CP1_ }, /* CMP.condn.S~*(20) */
20166 { reserved_block , 0 , 0 , 32,
20167 0xfc0007ff, 0xa0000545, 0 , 0,
20168 CP1_ }, /* CMP.condn.S~*(21) */
20169 { reserved_block , 0 , 0 , 32,
20170 0xfc0007ff, 0xa0000585, 0 , 0,
20171 CP1_ }, /* CMP.condn.S~*(22) */
20172 { reserved_block , 0 , 0 , 32,
20173 0xfc0007ff, 0xa00005c5, 0 , 0,
20174 CP1_ }, /* CMP.condn.S~*(23) */
20175 { reserved_block , 0 , 0 , 32,
20176 0xfc0007ff, 0xa0000605, 0 , 0,
20177 CP1_ }, /* CMP.condn.S~*(24) */
20178 { instruction , 0 , 0 , 32,
20179 0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S , 0,
20180 CP1_ }, /* CMP.SOR.S */
20181 { instruction , 0 , 0 , 32,
20182 0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S , 0,
20183 CP1_ }, /* CMP.SUNE.S */
20184 { instruction , 0 , 0 , 32,
20185 0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S , 0,
20186 CP1_ }, /* CMP.SNE.S */
20187 { reserved_block , 0 , 0 , 32,
20188 0xfc0007ff, 0xa0000705, 0 , 0,
20189 CP1_ }, /* CMP.condn.S~*(28) */
20190 { reserved_block , 0 , 0 , 32,
20191 0xfc0007ff, 0xa0000745, 0 , 0,
20192 CP1_ }, /* CMP.condn.S~*(29) */
20193 { reserved_block , 0 , 0 , 32,
20194 0xfc0007ff, 0xa0000785, 0 , 0,
20195 CP1_ }, /* CMP.condn.S~*(30) */
20196 { reserved_block , 0 , 0 , 32,
20197 0xfc0007ff, 0xa00007c5, 0 , 0,
20198 CP1_ }, /* CMP.condn.S~*(31) */
20199 };
20200
20201
20202 NMD::Pool NMD::CMP_condn_D[32] = {
20203 { instruction , 0 , 0 , 32,
20204 0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D , 0,
20205 CP1_ }, /* CMP.AF.D */
20206 { instruction , 0 , 0 , 32,
20207 0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D , 0,
20208 CP1_ }, /* CMP.UN.D */
20209 { instruction , 0 , 0 , 32,
20210 0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D , 0,
20211 CP1_ }, /* CMP.EQ.D */
20212 { instruction , 0 , 0 , 32,
20213 0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D , 0,
20214 CP1_ }, /* CMP.UEQ.D */
20215 { instruction , 0 , 0 , 32,
20216 0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D , 0,
20217 CP1_ }, /* CMP.LT.D */
20218 { instruction , 0 , 0 , 32,
20219 0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D , 0,
20220 CP1_ }, /* CMP.ULT.D */
20221 { instruction , 0 , 0 , 32,
20222 0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D , 0,
20223 CP1_ }, /* CMP.LE.D */
20224 { instruction , 0 , 0 , 32,
20225 0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D , 0,
20226 CP1_ }, /* CMP.ULE.D */
20227 { instruction , 0 , 0 , 32,
20228 0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D , 0,
20229 CP1_ }, /* CMP.SAF.D */
20230 { instruction , 0 , 0 , 32,
20231 0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D , 0,
20232 CP1_ }, /* CMP.SUN.D */
20233 { instruction , 0 , 0 , 32,
20234 0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D , 0,
20235 CP1_ }, /* CMP.SEQ.D */
20236 { instruction , 0 , 0 , 32,
20237 0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D , 0,
20238 CP1_ }, /* CMP.SUEQ.D */
20239 { instruction , 0 , 0 , 32,
20240 0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D , 0,
20241 CP1_ }, /* CMP.SLT.D */
20242 { instruction , 0 , 0 , 32,
20243 0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D , 0,
20244 CP1_ }, /* CMP.SULT.D */
20245 { instruction , 0 , 0 , 32,
20246 0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D , 0,
20247 CP1_ }, /* CMP.SLE.D */
20248 { instruction , 0 , 0 , 32,
20249 0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D , 0,
20250 CP1_ }, /* CMP.SULE.D */
20251 { reserved_block , 0 , 0 , 32,
20252 0xfc0007ff, 0xa0000415, 0 , 0,
20253 CP1_ }, /* CMP.condn.D~*(16) */
20254 { instruction , 0 , 0 , 32,
20255 0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D , 0,
20256 CP1_ }, /* CMP.OR.D */
20257 { instruction , 0 , 0 , 32,
20258 0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D , 0,
20259 CP1_ }, /* CMP.UNE.D */
20260 { instruction , 0 , 0 , 32,
20261 0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D , 0,
20262 CP1_ }, /* CMP.NE.D */
20263 { reserved_block , 0 , 0 , 32,
20264 0xfc0007ff, 0xa0000515, 0 , 0,
20265 CP1_ }, /* CMP.condn.D~*(20) */
20266 { reserved_block , 0 , 0 , 32,
20267 0xfc0007ff, 0xa0000555, 0 , 0,
20268 CP1_ }, /* CMP.condn.D~*(21) */
20269 { reserved_block , 0 , 0 , 32,
20270 0xfc0007ff, 0xa0000595, 0 , 0,
20271 CP1_ }, /* CMP.condn.D~*(22) */
20272 { reserved_block , 0 , 0 , 32,
20273 0xfc0007ff, 0xa00005d5, 0 , 0,
20274 CP1_ }, /* CMP.condn.D~*(23) */
20275 { reserved_block , 0 , 0 , 32,
20276 0xfc0007ff, 0xa0000615, 0 , 0,
20277 CP1_ }, /* CMP.condn.D~*(24) */
20278 { instruction , 0 , 0 , 32,
20279 0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D , 0,
20280 CP1_ }, /* CMP.SOR.D */
20281 { instruction , 0 , 0 , 32,
20282 0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D , 0,
20283 CP1_ }, /* CMP.SUNE.D */
20284 { instruction , 0 , 0 , 32,
20285 0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D , 0,
20286 CP1_ }, /* CMP.SNE.D */
20287 { reserved_block , 0 , 0 , 32,
20288 0xfc0007ff, 0xa0000715, 0 , 0,
20289 CP1_ }, /* CMP.condn.D~*(28) */
20290 { reserved_block , 0 , 0 , 32,
20291 0xfc0007ff, 0xa0000755, 0 , 0,
20292 CP1_ }, /* CMP.condn.D~*(29) */
20293 { reserved_block , 0 , 0 , 32,
20294 0xfc0007ff, 0xa0000795, 0 , 0,
20295 CP1_ }, /* CMP.condn.D~*(30) */
20296 { reserved_block , 0 , 0 , 32,
20297 0xfc0007ff, 0xa00007d5, 0 , 0,
20298 CP1_ }, /* CMP.condn.D~*(31) */
20299 };
20300
20301
20302 NMD::Pool NMD::POOL32F_5[8] = {
20303 { pool , CMP_condn_S , 32 , 32,
20304 0xfc00003f, 0xa0000005, 0 , 0,
20305 CP1_ }, /* CMP.condn.S */
20306 { reserved_block , 0 , 0 , 32,
20307 0xfc00003f, 0xa000000d, 0 , 0,
20308 CP1_ }, /* POOL32F_5~*(1) */
20309 { pool , CMP_condn_D , 32 , 32,
20310 0xfc00003f, 0xa0000015, 0 , 0,
20311 CP1_ }, /* CMP.condn.D */
20312 { reserved_block , 0 , 0 , 32,
20313 0xfc00003f, 0xa000001d, 0 , 0,
20314 CP1_ }, /* POOL32F_5~*(3) */
20315 { reserved_block , 0 , 0 , 32,
20316 0xfc00003f, 0xa0000025, 0 , 0,
20317 CP1_ }, /* POOL32F_5~*(4) */
20318 { reserved_block , 0 , 0 , 32,
20319 0xfc00003f, 0xa000002d, 0 , 0,
20320 CP1_ }, /* POOL32F_5~*(5) */
20321 { reserved_block , 0 , 0 , 32,
20322 0xfc00003f, 0xa0000035, 0 , 0,
20323 CP1_ }, /* POOL32F_5~*(6) */
20324 { reserved_block , 0 , 0 , 32,
20325 0xfc00003f, 0xa000003d, 0 , 0,
20326 CP1_ }, /* POOL32F_5~*(7) */
20327 };
20328
20329
20330 NMD::Pool NMD::POOL32F[8] = {
20331 { pool , POOL32F_0 , 64 , 32,
20332 0xfc000007, 0xa0000000, 0 , 0,
20333 CP1_ }, /* POOL32F_0 */
20334 { reserved_block , 0 , 0 , 32,
20335 0xfc000007, 0xa0000001, 0 , 0,
20336 CP1_ }, /* POOL32F~*(1) */
20337 { reserved_block , 0 , 0 , 32,
20338 0xfc000007, 0xa0000002, 0 , 0,
20339 CP1_ }, /* POOL32F~*(2) */
20340 { pool , POOL32F_3 , 8 , 32,
20341 0xfc000007, 0xa0000003, 0 , 0,
20342 CP1_ }, /* POOL32F_3 */
20343 { reserved_block , 0 , 0 , 32,
20344 0xfc000007, 0xa0000004, 0 , 0,
20345 CP1_ }, /* POOL32F~*(4) */
20346 { pool , POOL32F_5 , 8 , 32,
20347 0xfc000007, 0xa0000005, 0 , 0,
20348 CP1_ }, /* POOL32F_5 */
20349 { reserved_block , 0 , 0 , 32,
20350 0xfc000007, 0xa0000006, 0 , 0,
20351 CP1_ }, /* POOL32F~*(6) */
20352 { reserved_block , 0 , 0 , 32,
20353 0xfc000007, 0xa0000007, 0 , 0,
20354 CP1_ }, /* POOL32F~*(7) */
20355 };
20356
20357
20358 NMD::Pool NMD::POOL32S_0[64] = {
20359 { reserved_block , 0 , 0 , 32,
20360 0xfc0001ff, 0xc0000000, 0 , 0,
20361 0x0 }, /* POOL32S_0~*(0) */
20362 { instruction , 0 , 0 , 32,
20363 0xfc0001ff, 0xc0000008, &NMD::DLSA , 0,
20364 MIPS64_ }, /* DLSA */
20365 { instruction , 0 , 0 , 32,
20366 0xfc0001ff, 0xc0000010, &NMD::DSLLV , 0,
20367 MIPS64_ }, /* DSLLV */
20368 { instruction , 0 , 0 , 32,
20369 0xfc0001ff, 0xc0000018, &NMD::DMUL , 0,
20370 MIPS64_ }, /* DMUL */
20371 { reserved_block , 0 , 0 , 32,
20372 0xfc0001ff, 0xc0000020, 0 , 0,
20373 0x0 }, /* POOL32S_0~*(4) */
20374 { reserved_block , 0 , 0 , 32,
20375 0xfc0001ff, 0xc0000028, 0 , 0,
20376 0x0 }, /* POOL32S_0~*(5) */
20377 { reserved_block , 0 , 0 , 32,
20378 0xfc0001ff, 0xc0000030, 0 , 0,
20379 0x0 }, /* POOL32S_0~*(6) */
20380 { reserved_block , 0 , 0 , 32,
20381 0xfc0001ff, 0xc0000038, 0 , 0,
20382 0x0 }, /* POOL32S_0~*(7) */
20383 { reserved_block , 0 , 0 , 32,
20384 0xfc0001ff, 0xc0000040, 0 , 0,
20385 0x0 }, /* POOL32S_0~*(8) */
20386 { reserved_block , 0 , 0 , 32,
20387 0xfc0001ff, 0xc0000048, 0 , 0,
20388 0x0 }, /* POOL32S_0~*(9) */
20389 { instruction , 0 , 0 , 32,
20390 0xfc0001ff, 0xc0000050, &NMD::DSRLV , 0,
20391 MIPS64_ }, /* DSRLV */
20392 { instruction , 0 , 0 , 32,
20393 0xfc0001ff, 0xc0000058, &NMD::DMUH , 0,
20394 MIPS64_ }, /* DMUH */
20395 { reserved_block , 0 , 0 , 32,
20396 0xfc0001ff, 0xc0000060, 0 , 0,
20397 0x0 }, /* POOL32S_0~*(12) */
20398 { reserved_block , 0 , 0 , 32,
20399 0xfc0001ff, 0xc0000068, 0 , 0,
20400 0x0 }, /* POOL32S_0~*(13) */
20401 { reserved_block , 0 , 0 , 32,
20402 0xfc0001ff, 0xc0000070, 0 , 0,
20403 0x0 }, /* POOL32S_0~*(14) */
20404 { reserved_block , 0 , 0 , 32,
20405 0xfc0001ff, 0xc0000078, 0 , 0,
20406 0x0 }, /* POOL32S_0~*(15) */
20407 { reserved_block , 0 , 0 , 32,
20408 0xfc0001ff, 0xc0000080, 0 , 0,
20409 0x0 }, /* POOL32S_0~*(16) */
20410 { reserved_block , 0 , 0 , 32,
20411 0xfc0001ff, 0xc0000088, 0 , 0,
20412 0x0 }, /* POOL32S_0~*(17) */
20413 { instruction , 0 , 0 , 32,
20414 0xfc0001ff, 0xc0000090, &NMD::DSRAV , 0,
20415 MIPS64_ }, /* DSRAV */
20416 { instruction , 0 , 0 , 32,
20417 0xfc0001ff, 0xc0000098, &NMD::DMULU , 0,
20418 MIPS64_ }, /* DMULU */
20419 { reserved_block , 0 , 0 , 32,
20420 0xfc0001ff, 0xc00000a0, 0 , 0,
20421 0x0 }, /* POOL32S_0~*(20) */
20422 { reserved_block , 0 , 0 , 32,
20423 0xfc0001ff, 0xc00000a8, 0 , 0,
20424 0x0 }, /* POOL32S_0~*(21) */
20425 { reserved_block , 0 , 0 , 32,
20426 0xfc0001ff, 0xc00000b0, 0 , 0,
20427 0x0 }, /* POOL32S_0~*(22) */
20428 { reserved_block , 0 , 0 , 32,
20429 0xfc0001ff, 0xc00000b8, 0 , 0,
20430 0x0 }, /* POOL32S_0~*(23) */
20431 { reserved_block , 0 , 0 , 32,
20432 0xfc0001ff, 0xc00000c0, 0 , 0,
20433 0x0 }, /* POOL32S_0~*(24) */
20434 { reserved_block , 0 , 0 , 32,
20435 0xfc0001ff, 0xc00000c8, 0 , 0,
20436 0x0 }, /* POOL32S_0~*(25) */
20437 { instruction , 0 , 0 , 32,
20438 0xfc0001ff, 0xc00000d0, &NMD::DROTRV , 0,
20439 MIPS64_ }, /* DROTRV */
20440 { instruction , 0 , 0 , 32,
20441 0xfc0001ff, 0xc00000d8, &NMD::DMUHU , 0,
20442 MIPS64_ }, /* DMUHU */
20443 { reserved_block , 0 , 0 , 32,
20444 0xfc0001ff, 0xc00000e0, 0 , 0,
20445 0x0 }, /* POOL32S_0~*(28) */
20446 { reserved_block , 0 , 0 , 32,
20447 0xfc0001ff, 0xc00000e8, 0 , 0,
20448 0x0 }, /* POOL32S_0~*(29) */
20449 { reserved_block , 0 , 0 , 32,
20450 0xfc0001ff, 0xc00000f0, 0 , 0,
20451 0x0 }, /* POOL32S_0~*(30) */
20452 { reserved_block , 0 , 0 , 32,
20453 0xfc0001ff, 0xc00000f8, 0 , 0,
20454 0x0 }, /* POOL32S_0~*(31) */
20455 { reserved_block , 0 , 0 , 32,
20456 0xfc0001ff, 0xc0000100, 0 , 0,
20457 0x0 }, /* POOL32S_0~*(32) */
20458 { reserved_block , 0 , 0 , 32,
20459 0xfc0001ff, 0xc0000108, 0 , 0,
20460 0x0 }, /* POOL32S_0~*(33) */
20461 { instruction , 0 , 0 , 32,
20462 0xfc0001ff, 0xc0000110, &NMD::DADD , 0,
20463 MIPS64_ }, /* DADD */
20464 { instruction , 0 , 0 , 32,
20465 0xfc0001ff, 0xc0000118, &NMD::DDIV , 0,
20466 MIPS64_ }, /* DDIV */
20467 { reserved_block , 0 , 0 , 32,
20468 0xfc0001ff, 0xc0000120, 0 , 0,
20469 0x0 }, /* POOL32S_0~*(36) */
20470 { reserved_block , 0 , 0 , 32,
20471 0xfc0001ff, 0xc0000128, 0 , 0,
20472 0x0 }, /* POOL32S_0~*(37) */
20473 { reserved_block , 0 , 0 , 32,
20474 0xfc0001ff, 0xc0000130, 0 , 0,
20475 0x0 }, /* POOL32S_0~*(38) */
20476 { reserved_block , 0 , 0 , 32,
20477 0xfc0001ff, 0xc0000138, 0 , 0,
20478 0x0 }, /* POOL32S_0~*(39) */
20479 { reserved_block , 0 , 0 , 32,
20480 0xfc0001ff, 0xc0000140, 0 , 0,
20481 0x0 }, /* POOL32S_0~*(40) */
20482 { reserved_block , 0 , 0 , 32,
20483 0xfc0001ff, 0xc0000148, 0 , 0,
20484 0x0 }, /* POOL32S_0~*(41) */
20485 { instruction , 0 , 0 , 32,
20486 0xfc0001ff, 0xc0000150, &NMD::DADDU , 0,
20487 MIPS64_ }, /* DADDU */
20488 { instruction , 0 , 0 , 32,
20489 0xfc0001ff, 0xc0000158, &NMD::DMOD , 0,
20490 MIPS64_ }, /* DMOD */
20491 { reserved_block , 0 , 0 , 32,
20492 0xfc0001ff, 0xc0000160, 0 , 0,
20493 0x0 }, /* POOL32S_0~*(44) */
20494 { reserved_block , 0 , 0 , 32,
20495 0xfc0001ff, 0xc0000168, 0 , 0,
20496 0x0 }, /* POOL32S_0~*(45) */
20497 { reserved_block , 0 , 0 , 32,
20498 0xfc0001ff, 0xc0000170, 0 , 0,
20499 0x0 }, /* POOL32S_0~*(46) */
20500 { reserved_block , 0 , 0 , 32,
20501 0xfc0001ff, 0xc0000178, 0 , 0,
20502 0x0 }, /* POOL32S_0~*(47) */
20503 { reserved_block , 0 , 0 , 32,
20504 0xfc0001ff, 0xc0000180, 0 , 0,
20505 0x0 }, /* POOL32S_0~*(48) */
20506 { reserved_block , 0 , 0 , 32,
20507 0xfc0001ff, 0xc0000188, 0 , 0,
20508 0x0 }, /* POOL32S_0~*(49) */
20509 { instruction , 0 , 0 , 32,
20510 0xfc0001ff, 0xc0000190, &NMD::DSUB , 0,
20511 MIPS64_ }, /* DSUB */
20512 { instruction , 0 , 0 , 32,
20513 0xfc0001ff, 0xc0000198, &NMD::DDIVU , 0,
20514 MIPS64_ }, /* DDIVU */
20515 { reserved_block , 0 , 0 , 32,
20516 0xfc0001ff, 0xc00001a0, 0 , 0,
20517 0x0 }, /* POOL32S_0~*(52) */
20518 { reserved_block , 0 , 0 , 32,
20519 0xfc0001ff, 0xc00001a8, 0 , 0,
20520 0x0 }, /* POOL32S_0~*(53) */
20521 { reserved_block , 0 , 0 , 32,
20522 0xfc0001ff, 0xc00001b0, 0 , 0,
20523 0x0 }, /* POOL32S_0~*(54) */
20524 { reserved_block , 0 , 0 , 32,
20525 0xfc0001ff, 0xc00001b8, 0 , 0,
20526 0x0 }, /* POOL32S_0~*(55) */
20527 { reserved_block , 0 , 0 , 32,
20528 0xfc0001ff, 0xc00001c0, 0 , 0,
20529 0x0 }, /* POOL32S_0~*(56) */
20530 { reserved_block , 0 , 0 , 32,
20531 0xfc0001ff, 0xc00001c8, 0 , 0,
20532 0x0 }, /* POOL32S_0~*(57) */
20533 { instruction , 0 , 0 , 32,
20534 0xfc0001ff, 0xc00001d0, &NMD::DSUBU , 0,
20535 MIPS64_ }, /* DSUBU */
20536 { instruction , 0 , 0 , 32,
20537 0xfc0001ff, 0xc00001d8, &NMD::DMODU , 0,
20538 MIPS64_ }, /* DMODU */
20539 { reserved_block , 0 , 0 , 32,
20540 0xfc0001ff, 0xc00001e0, 0 , 0,
20541 0x0 }, /* POOL32S_0~*(60) */
20542 { reserved_block , 0 , 0 , 32,
20543 0xfc0001ff, 0xc00001e8, 0 , 0,
20544 0x0 }, /* POOL32S_0~*(61) */
20545 { reserved_block , 0 , 0 , 32,
20546 0xfc0001ff, 0xc00001f0, 0 , 0,
20547 0x0 }, /* POOL32S_0~*(62) */
20548 { reserved_block , 0 , 0 , 32,
20549 0xfc0001ff, 0xc00001f8, 0 , 0,
20550 0x0 }, /* POOL32S_0~*(63) */
20551 };
20552
20553
20554 NMD::Pool NMD::POOL32Sxf_4[128] = {
20555 { reserved_block , 0 , 0 , 32,
20556 0xfc00ffff, 0xc000013c, 0 , 0,
20557 0x0 }, /* POOL32Sxf_4~*(0) */
20558 { reserved_block , 0 , 0 , 32,
20559 0xfc00ffff, 0xc000033c, 0 , 0,
20560 0x0 }, /* POOL32Sxf_4~*(1) */
20561 { reserved_block , 0 , 0 , 32,
20562 0xfc00ffff, 0xc000053c, 0 , 0,
20563 0x0 }, /* POOL32Sxf_4~*(2) */
20564 { reserved_block , 0 , 0 , 32,
20565 0xfc00ffff, 0xc000073c, 0 , 0,
20566 0x0 }, /* POOL32Sxf_4~*(3) */
20567 { reserved_block , 0 , 0 , 32,
20568 0xfc00ffff, 0xc000093c, 0 , 0,
20569 0x0 }, /* POOL32Sxf_4~*(4) */
20570 { reserved_block , 0 , 0 , 32,
20571 0xfc00ffff, 0xc0000b3c, 0 , 0,
20572 0x0 }, /* POOL32Sxf_4~*(5) */
20573 { reserved_block , 0 , 0 , 32,
20574 0xfc00ffff, 0xc0000d3c, 0 , 0,
20575 0x0 }, /* POOL32Sxf_4~*(6) */
20576 { reserved_block , 0 , 0 , 32,
20577 0xfc00ffff, 0xc0000f3c, 0 , 0,
20578 0x0 }, /* POOL32Sxf_4~*(7) */
20579 { reserved_block , 0 , 0 , 32,
20580 0xfc00ffff, 0xc000113c, 0 , 0,
20581 0x0 }, /* POOL32Sxf_4~*(8) */
20582 { reserved_block , 0 , 0 , 32,
20583 0xfc00ffff, 0xc000133c, 0 , 0,
20584 0x0 }, /* POOL32Sxf_4~*(9) */
20585 { reserved_block , 0 , 0 , 32,
20586 0xfc00ffff, 0xc000153c, 0 , 0,
20587 0x0 }, /* POOL32Sxf_4~*(10) */
20588 { reserved_block , 0 , 0 , 32,
20589 0xfc00ffff, 0xc000173c, 0 , 0,
20590 0x0 }, /* POOL32Sxf_4~*(11) */
20591 { reserved_block , 0 , 0 , 32,
20592 0xfc00ffff, 0xc000193c, 0 , 0,
20593 0x0 }, /* POOL32Sxf_4~*(12) */
20594 { reserved_block , 0 , 0 , 32,
20595 0xfc00ffff, 0xc0001b3c, 0 , 0,
20596 0x0 }, /* POOL32Sxf_4~*(13) */
20597 { reserved_block , 0 , 0 , 32,
20598 0xfc00ffff, 0xc0001d3c, 0 , 0,
20599 0x0 }, /* POOL32Sxf_4~*(14) */
20600 { reserved_block , 0 , 0 , 32,
20601 0xfc00ffff, 0xc0001f3c, 0 , 0,
20602 0x0 }, /* POOL32Sxf_4~*(15) */
20603 { reserved_block , 0 , 0 , 32,
20604 0xfc00ffff, 0xc000213c, 0 , 0,
20605 0x0 }, /* POOL32Sxf_4~*(16) */
20606 { reserved_block , 0 , 0 , 32,
20607 0xfc00ffff, 0xc000233c, 0 , 0,
20608 0x0 }, /* POOL32Sxf_4~*(17) */
20609 { reserved_block , 0 , 0 , 32,
20610 0xfc00ffff, 0xc000253c, 0 , 0,
20611 0x0 }, /* POOL32Sxf_4~*(18) */
20612 { reserved_block , 0 , 0 , 32,
20613 0xfc00ffff, 0xc000273c, 0 , 0,
20614 0x0 }, /* POOL32Sxf_4~*(19) */
20615 { reserved_block , 0 , 0 , 32,
20616 0xfc00ffff, 0xc000293c, 0 , 0,
20617 0x0 }, /* POOL32Sxf_4~*(20) */
20618 { reserved_block , 0 , 0 , 32,
20619 0xfc00ffff, 0xc0002b3c, 0 , 0,
20620 0x0 }, /* POOL32Sxf_4~*(21) */
20621 { reserved_block , 0 , 0 , 32,
20622 0xfc00ffff, 0xc0002d3c, 0 , 0,
20623 0x0 }, /* POOL32Sxf_4~*(22) */
20624 { reserved_block , 0 , 0 , 32,
20625 0xfc00ffff, 0xc0002f3c, 0 , 0,
20626 0x0 }, /* POOL32Sxf_4~*(23) */
20627 { reserved_block , 0 , 0 , 32,
20628 0xfc00ffff, 0xc000313c, 0 , 0,
20629 0x0 }, /* POOL32Sxf_4~*(24) */
20630 { reserved_block , 0 , 0 , 32,
20631 0xfc00ffff, 0xc000333c, 0 , 0,
20632 0x0 }, /* POOL32Sxf_4~*(25) */
20633 { reserved_block , 0 , 0 , 32,
20634 0xfc00ffff, 0xc000353c, 0 , 0,
20635 0x0 }, /* POOL32Sxf_4~*(26) */
20636 { reserved_block , 0 , 0 , 32,
20637 0xfc00ffff, 0xc000373c, 0 , 0,
20638 0x0 }, /* POOL32Sxf_4~*(27) */
20639 { reserved_block , 0 , 0 , 32,
20640 0xfc00ffff, 0xc000393c, 0 , 0,
20641 0x0 }, /* POOL32Sxf_4~*(28) */
20642 { reserved_block , 0 , 0 , 32,
20643 0xfc00ffff, 0xc0003b3c, 0 , 0,
20644 0x0 }, /* POOL32Sxf_4~*(29) */
20645 { reserved_block , 0 , 0 , 32,
20646 0xfc00ffff, 0xc0003d3c, 0 , 0,
20647 0x0 }, /* POOL32Sxf_4~*(30) */
20648 { reserved_block , 0 , 0 , 32,
20649 0xfc00ffff, 0xc0003f3c, 0 , 0,
20650 0x0 }, /* POOL32Sxf_4~*(31) */
20651 { reserved_block , 0 , 0 , 32,
20652 0xfc00ffff, 0xc000413c, 0 , 0,
20653 0x0 }, /* POOL32Sxf_4~*(32) */
20654 { reserved_block , 0 , 0 , 32,
20655 0xfc00ffff, 0xc000433c, 0 , 0,
20656 0x0 }, /* POOL32Sxf_4~*(33) */
20657 { reserved_block , 0 , 0 , 32,
20658 0xfc00ffff, 0xc000453c, 0 , 0,
20659 0x0 }, /* POOL32Sxf_4~*(34) */
20660 { reserved_block , 0 , 0 , 32,
20661 0xfc00ffff, 0xc000473c, 0 , 0,
20662 0x0 }, /* POOL32Sxf_4~*(35) */
20663 { reserved_block , 0 , 0 , 32,
20664 0xfc00ffff, 0xc000493c, 0 , 0,
20665 0x0 }, /* POOL32Sxf_4~*(36) */
20666 { instruction , 0 , 0 , 32,
20667 0xfc00ffff, 0xc0004b3c, &NMD::DCLO , 0,
20668 MIPS64_ }, /* DCLO */
20669 { reserved_block , 0 , 0 , 32,
20670 0xfc00ffff, 0xc0004d3c, 0 , 0,
20671 0x0 }, /* POOL32Sxf_4~*(38) */
20672 { reserved_block , 0 , 0 , 32,
20673 0xfc00ffff, 0xc0004f3c, 0 , 0,
20674 0x0 }, /* POOL32Sxf_4~*(39) */
20675 { reserved_block , 0 , 0 , 32,
20676 0xfc00ffff, 0xc000513c, 0 , 0,
20677 0x0 }, /* POOL32Sxf_4~*(40) */
20678 { reserved_block , 0 , 0 , 32,
20679 0xfc00ffff, 0xc000533c, 0 , 0,
20680 0x0 }, /* POOL32Sxf_4~*(41) */
20681 { reserved_block , 0 , 0 , 32,
20682 0xfc00ffff, 0xc000553c, 0 , 0,
20683 0x0 }, /* POOL32Sxf_4~*(42) */
20684 { reserved_block , 0 , 0 , 32,
20685 0xfc00ffff, 0xc000573c, 0 , 0,
20686 0x0 }, /* POOL32Sxf_4~*(43) */
20687 { reserved_block , 0 , 0 , 32,
20688 0xfc00ffff, 0xc000593c, 0 , 0,
20689 0x0 }, /* POOL32Sxf_4~*(44) */
20690 { instruction , 0 , 0 , 32,
20691 0xfc00ffff, 0xc0005b3c, &NMD::DCLZ , 0,
20692 MIPS64_ }, /* DCLZ */
20693 { reserved_block , 0 , 0 , 32,
20694 0xfc00ffff, 0xc0005d3c, 0 , 0,
20695 0x0 }, /* POOL32Sxf_4~*(46) */
20696 { reserved_block , 0 , 0 , 32,
20697 0xfc00ffff, 0xc0005f3c, 0 , 0,
20698 0x0 }, /* POOL32Sxf_4~*(47) */
20699 { reserved_block , 0 , 0 , 32,
20700 0xfc00ffff, 0xc000613c, 0 , 0,
20701 0x0 }, /* POOL32Sxf_4~*(48) */
20702 { reserved_block , 0 , 0 , 32,
20703 0xfc00ffff, 0xc000633c, 0 , 0,
20704 0x0 }, /* POOL32Sxf_4~*(49) */
20705 { reserved_block , 0 , 0 , 32,
20706 0xfc00ffff, 0xc000653c, 0 , 0,
20707 0x0 }, /* POOL32Sxf_4~*(50) */
20708 { reserved_block , 0 , 0 , 32,
20709 0xfc00ffff, 0xc000673c, 0 , 0,
20710 0x0 }, /* POOL32Sxf_4~*(51) */
20711 { reserved_block , 0 , 0 , 32,
20712 0xfc00ffff, 0xc000693c, 0 , 0,
20713 0x0 }, /* POOL32Sxf_4~*(52) */
20714 { reserved_block , 0 , 0 , 32,
20715 0xfc00ffff, 0xc0006b3c, 0 , 0,
20716 0x0 }, /* POOL32Sxf_4~*(53) */
20717 { reserved_block , 0 , 0 , 32,
20718 0xfc00ffff, 0xc0006d3c, 0 , 0,
20719 0x0 }, /* POOL32Sxf_4~*(54) */
20720 { reserved_block , 0 , 0 , 32,
20721 0xfc00ffff, 0xc0006f3c, 0 , 0,
20722 0x0 }, /* POOL32Sxf_4~*(55) */
20723 { reserved_block , 0 , 0 , 32,
20724 0xfc00ffff, 0xc000713c, 0 , 0,
20725 0x0 }, /* POOL32Sxf_4~*(56) */
20726 { reserved_block , 0 , 0 , 32,
20727 0xfc00ffff, 0xc000733c, 0 , 0,
20728 0x0 }, /* POOL32Sxf_4~*(57) */
20729 { reserved_block , 0 , 0 , 32,
20730 0xfc00ffff, 0xc000753c, 0 , 0,
20731 0x0 }, /* POOL32Sxf_4~*(58) */
20732 { reserved_block , 0 , 0 , 32,
20733 0xfc00ffff, 0xc000773c, 0 , 0,
20734 0x0 }, /* POOL32Sxf_4~*(59) */
20735 { reserved_block , 0 , 0 , 32,
20736 0xfc00ffff, 0xc000793c, 0 , 0,
20737 0x0 }, /* POOL32Sxf_4~*(60) */
20738 { reserved_block , 0 , 0 , 32,
20739 0xfc00ffff, 0xc0007b3c, 0 , 0,
20740 0x0 }, /* POOL32Sxf_4~*(61) */
20741 { reserved_block , 0 , 0 , 32,
20742 0xfc00ffff, 0xc0007d3c, 0 , 0,
20743 0x0 }, /* POOL32Sxf_4~*(62) */
20744 { reserved_block , 0 , 0 , 32,
20745 0xfc00ffff, 0xc0007f3c, 0 , 0,
20746 0x0 }, /* POOL32Sxf_4~*(63) */
20747 { reserved_block , 0 , 0 , 32,
20748 0xfc00ffff, 0xc000813c, 0 , 0,
20749 0x0 }, /* POOL32Sxf_4~*(64) */
20750 { reserved_block , 0 , 0 , 32,
20751 0xfc00ffff, 0xc000833c, 0 , 0,
20752 0x0 }, /* POOL32Sxf_4~*(65) */
20753 { reserved_block , 0 , 0 , 32,
20754 0xfc00ffff, 0xc000853c, 0 , 0,
20755 0x0 }, /* POOL32Sxf_4~*(66) */
20756 { reserved_block , 0 , 0 , 32,
20757 0xfc00ffff, 0xc000873c, 0 , 0,
20758 0x0 }, /* POOL32Sxf_4~*(67) */
20759 { reserved_block , 0 , 0 , 32,
20760 0xfc00ffff, 0xc000893c, 0 , 0,
20761 0x0 }, /* POOL32Sxf_4~*(68) */
20762 { reserved_block , 0 , 0 , 32,
20763 0xfc00ffff, 0xc0008b3c, 0 , 0,
20764 0x0 }, /* POOL32Sxf_4~*(69) */
20765 { reserved_block , 0 , 0 , 32,
20766 0xfc00ffff, 0xc0008d3c, 0 , 0,
20767 0x0 }, /* POOL32Sxf_4~*(70) */
20768 { reserved_block , 0 , 0 , 32,
20769 0xfc00ffff, 0xc0008f3c, 0 , 0,
20770 0x0 }, /* POOL32Sxf_4~*(71) */
20771 { reserved_block , 0 , 0 , 32,
20772 0xfc00ffff, 0xc000913c, 0 , 0,
20773 0x0 }, /* POOL32Sxf_4~*(72) */
20774 { reserved_block , 0 , 0 , 32,
20775 0xfc00ffff, 0xc000933c, 0 , 0,
20776 0x0 }, /* POOL32Sxf_4~*(73) */
20777 { reserved_block , 0 , 0 , 32,
20778 0xfc00ffff, 0xc000953c, 0 , 0,
20779 0x0 }, /* POOL32Sxf_4~*(74) */
20780 { reserved_block , 0 , 0 , 32,
20781 0xfc00ffff, 0xc000973c, 0 , 0,
20782 0x0 }, /* POOL32Sxf_4~*(75) */
20783 { reserved_block , 0 , 0 , 32,
20784 0xfc00ffff, 0xc000993c, 0 , 0,
20785 0x0 }, /* POOL32Sxf_4~*(76) */
20786 { reserved_block , 0 , 0 , 32,
20787 0xfc00ffff, 0xc0009b3c, 0 , 0,
20788 0x0 }, /* POOL32Sxf_4~*(77) */
20789 { reserved_block , 0 , 0 , 32,
20790 0xfc00ffff, 0xc0009d3c, 0 , 0,
20791 0x0 }, /* POOL32Sxf_4~*(78) */
20792 { reserved_block , 0 , 0 , 32,
20793 0xfc00ffff, 0xc0009f3c, 0 , 0,
20794 0x0 }, /* POOL32Sxf_4~*(79) */
20795 { reserved_block , 0 , 0 , 32,
20796 0xfc00ffff, 0xc000a13c, 0 , 0,
20797 0x0 }, /* POOL32Sxf_4~*(80) */
20798 { reserved_block , 0 , 0 , 32,
20799 0xfc00ffff, 0xc000a33c, 0 , 0,
20800 0x0 }, /* POOL32Sxf_4~*(81) */
20801 { reserved_block , 0 , 0 , 32,
20802 0xfc00ffff, 0xc000a53c, 0 , 0,
20803 0x0 }, /* POOL32Sxf_4~*(82) */
20804 { reserved_block , 0 , 0 , 32,
20805 0xfc00ffff, 0xc000a73c, 0 , 0,
20806 0x0 }, /* POOL32Sxf_4~*(83) */
20807 { reserved_block , 0 , 0 , 32,
20808 0xfc00ffff, 0xc000a93c, 0 , 0,
20809 0x0 }, /* POOL32Sxf_4~*(84) */
20810 { reserved_block , 0 , 0 , 32,
20811 0xfc00ffff, 0xc000ab3c, 0 , 0,
20812 0x0 }, /* POOL32Sxf_4~*(85) */
20813 { reserved_block , 0 , 0 , 32,
20814 0xfc00ffff, 0xc000ad3c, 0 , 0,
20815 0x0 }, /* POOL32Sxf_4~*(86) */
20816 { reserved_block , 0 , 0 , 32,
20817 0xfc00ffff, 0xc000af3c, 0 , 0,
20818 0x0 }, /* POOL32Sxf_4~*(87) */
20819 { reserved_block , 0 , 0 , 32,
20820 0xfc00ffff, 0xc000b13c, 0 , 0,
20821 0x0 }, /* POOL32Sxf_4~*(88) */
20822 { reserved_block , 0 , 0 , 32,
20823 0xfc00ffff, 0xc000b33c, 0 , 0,
20824 0x0 }, /* POOL32Sxf_4~*(89) */
20825 { reserved_block , 0 , 0 , 32,
20826 0xfc00ffff, 0xc000b53c, 0 , 0,
20827 0x0 }, /* POOL32Sxf_4~*(90) */
20828 { reserved_block , 0 , 0 , 32,
20829 0xfc00ffff, 0xc000b73c, 0 , 0,
20830 0x0 }, /* POOL32Sxf_4~*(91) */
20831 { reserved_block , 0 , 0 , 32,
20832 0xfc00ffff, 0xc000b93c, 0 , 0,
20833 0x0 }, /* POOL32Sxf_4~*(92) */
20834 { reserved_block , 0 , 0 , 32,
20835 0xfc00ffff, 0xc000bb3c, 0 , 0,
20836 0x0 }, /* POOL32Sxf_4~*(93) */
20837 { reserved_block , 0 , 0 , 32,
20838 0xfc00ffff, 0xc000bd3c, 0 , 0,
20839 0x0 }, /* POOL32Sxf_4~*(94) */
20840 { reserved_block , 0 , 0 , 32,
20841 0xfc00ffff, 0xc000bf3c, 0 , 0,
20842 0x0 }, /* POOL32Sxf_4~*(95) */
20843 { reserved_block , 0 , 0 , 32,
20844 0xfc00ffff, 0xc000c13c, 0 , 0,
20845 0x0 }, /* POOL32Sxf_4~*(96) */
20846 { reserved_block , 0 , 0 , 32,
20847 0xfc00ffff, 0xc000c33c, 0 , 0,
20848 0x0 }, /* POOL32Sxf_4~*(97) */
20849 { reserved_block , 0 , 0 , 32,
20850 0xfc00ffff, 0xc000c53c, 0 , 0,
20851 0x0 }, /* POOL32Sxf_4~*(98) */
20852 { reserved_block , 0 , 0 , 32,
20853 0xfc00ffff, 0xc000c73c, 0 , 0,
20854 0x0 }, /* POOL32Sxf_4~*(99) */
20855 { reserved_block , 0 , 0 , 32,
20856 0xfc00ffff, 0xc000c93c, 0 , 0,
20857 0x0 }, /* POOL32Sxf_4~*(100) */
20858 { reserved_block , 0 , 0 , 32,
20859 0xfc00ffff, 0xc000cb3c, 0 , 0,
20860 0x0 }, /* POOL32Sxf_4~*(101) */
20861 { reserved_block , 0 , 0 , 32,
20862 0xfc00ffff, 0xc000cd3c, 0 , 0,
20863 0x0 }, /* POOL32Sxf_4~*(102) */
20864 { reserved_block , 0 , 0 , 32,
20865 0xfc00ffff, 0xc000cf3c, 0 , 0,
20866 0x0 }, /* POOL32Sxf_4~*(103) */
20867 { reserved_block , 0 , 0 , 32,
20868 0xfc00ffff, 0xc000d13c, 0 , 0,
20869 0x0 }, /* POOL32Sxf_4~*(104) */
20870 { reserved_block , 0 , 0 , 32,
20871 0xfc00ffff, 0xc000d33c, 0 , 0,
20872 0x0 }, /* POOL32Sxf_4~*(105) */
20873 { reserved_block , 0 , 0 , 32,
20874 0xfc00ffff, 0xc000d53c, 0 , 0,
20875 0x0 }, /* POOL32Sxf_4~*(106) */
20876 { reserved_block , 0 , 0 , 32,
20877 0xfc00ffff, 0xc000d73c, 0 , 0,
20878 0x0 }, /* POOL32Sxf_4~*(107) */
20879 { reserved_block , 0 , 0 , 32,
20880 0xfc00ffff, 0xc000d93c, 0 , 0,
20881 0x0 }, /* POOL32Sxf_4~*(108) */
20882 { reserved_block , 0 , 0 , 32,
20883 0xfc00ffff, 0xc000db3c, 0 , 0,
20884 0x0 }, /* POOL32Sxf_4~*(109) */
20885 { reserved_block , 0 , 0 , 32,
20886 0xfc00ffff, 0xc000dd3c, 0 , 0,
20887 0x0 }, /* POOL32Sxf_4~*(110) */
20888 { reserved_block , 0 , 0 , 32,
20889 0xfc00ffff, 0xc000df3c, 0 , 0,
20890 0x0 }, /* POOL32Sxf_4~*(111) */
20891 { reserved_block , 0 , 0 , 32,
20892 0xfc00ffff, 0xc000e13c, 0 , 0,
20893 0x0 }, /* POOL32Sxf_4~*(112) */
20894 { reserved_block , 0 , 0 , 32,
20895 0xfc00ffff, 0xc000e33c, 0 , 0,
20896 0x0 }, /* POOL32Sxf_4~*(113) */
20897 { reserved_block , 0 , 0 , 32,
20898 0xfc00ffff, 0xc000e53c, 0 , 0,
20899 0x0 }, /* POOL32Sxf_4~*(114) */
20900 { reserved_block , 0 , 0 , 32,
20901 0xfc00ffff, 0xc000e73c, 0 , 0,
20902 0x0 }, /* POOL32Sxf_4~*(115) */
20903 { reserved_block , 0 , 0 , 32,
20904 0xfc00ffff, 0xc000e93c, 0 , 0,
20905 0x0 }, /* POOL32Sxf_4~*(116) */
20906 { reserved_block , 0 , 0 , 32,
20907 0xfc00ffff, 0xc000eb3c, 0 , 0,
20908 0x0 }, /* POOL32Sxf_4~*(117) */
20909 { reserved_block , 0 , 0 , 32,
20910 0xfc00ffff, 0xc000ed3c, 0 , 0,
20911 0x0 }, /* POOL32Sxf_4~*(118) */
20912 { reserved_block , 0 , 0 , 32,
20913 0xfc00ffff, 0xc000ef3c, 0 , 0,
20914 0x0 }, /* POOL32Sxf_4~*(119) */
20915 { reserved_block , 0 , 0 , 32,
20916 0xfc00ffff, 0xc000f13c, 0 , 0,
20917 0x0 }, /* POOL32Sxf_4~*(120) */
20918 { reserved_block , 0 , 0 , 32,
20919 0xfc00ffff, 0xc000f33c, 0 , 0,
20920 0x0 }, /* POOL32Sxf_4~*(121) */
20921 { reserved_block , 0 , 0 , 32,
20922 0xfc00ffff, 0xc000f53c, 0 , 0,
20923 0x0 }, /* POOL32Sxf_4~*(122) */
20924 { reserved_block , 0 , 0 , 32,
20925 0xfc00ffff, 0xc000f73c, 0 , 0,
20926 0x0 }, /* POOL32Sxf_4~*(123) */
20927 { reserved_block , 0 , 0 , 32,
20928 0xfc00ffff, 0xc000f93c, 0 , 0,
20929 0x0 }, /* POOL32Sxf_4~*(124) */
20930 { reserved_block , 0 , 0 , 32,
20931 0xfc00ffff, 0xc000fb3c, 0 , 0,
20932 0x0 }, /* POOL32Sxf_4~*(125) */
20933 { reserved_block , 0 , 0 , 32,
20934 0xfc00ffff, 0xc000fd3c, 0 , 0,
20935 0x0 }, /* POOL32Sxf_4~*(126) */
20936 { reserved_block , 0 , 0 , 32,
20937 0xfc00ffff, 0xc000ff3c, 0 , 0,
20938 0x0 }, /* POOL32Sxf_4~*(127) */
20939 };
20940
20941
20942 NMD::Pool NMD::POOL32Sxf[8] = {
20943 { reserved_block , 0 , 0 , 32,
20944 0xfc0001ff, 0xc000003c, 0 , 0,
20945 0x0 }, /* POOL32Sxf~*(0) */
20946 { reserved_block , 0 , 0 , 32,
20947 0xfc0001ff, 0xc000007c, 0 , 0,
20948 0x0 }, /* POOL32Sxf~*(1) */
20949 { reserved_block , 0 , 0 , 32,
20950 0xfc0001ff, 0xc00000bc, 0 , 0,
20951 0x0 }, /* POOL32Sxf~*(2) */
20952 { reserved_block , 0 , 0 , 32,
20953 0xfc0001ff, 0xc00000fc, 0 , 0,
20954 0x0 }, /* POOL32Sxf~*(3) */
20955 { pool , POOL32Sxf_4 , 128 , 32,
20956 0xfc0001ff, 0xc000013c, 0 , 0,
20957 0x0 }, /* POOL32Sxf_4 */
20958 { reserved_block , 0 , 0 , 32,
20959 0xfc0001ff, 0xc000017c, 0 , 0,
20960 0x0 }, /* POOL32Sxf~*(5) */
20961 { reserved_block , 0 , 0 , 32,
20962 0xfc0001ff, 0xc00001bc, 0 , 0,
20963 0x0 }, /* POOL32Sxf~*(6) */
20964 { reserved_block , 0 , 0 , 32,
20965 0xfc0001ff, 0xc00001fc, 0 , 0,
20966 0x0 }, /* POOL32Sxf~*(7) */
20967 };
20968
20969
20970 NMD::Pool NMD::POOL32S_4[8] = {
20971 { instruction , 0 , 0 , 32,
20972 0xfc00003f, 0xc0000004, &NMD::EXTD , 0,
20973 MIPS64_ }, /* EXTD */
20974 { instruction , 0 , 0 , 32,
20975 0xfc00003f, 0xc000000c, &NMD::EXTD32 , 0,
20976 MIPS64_ }, /* EXTD32 */
20977 { reserved_block , 0 , 0 , 32,
20978 0xfc00003f, 0xc0000014, 0 , 0,
20979 0x0 }, /* POOL32S_4~*(2) */
20980 { reserved_block , 0 , 0 , 32,
20981 0xfc00003f, 0xc000001c, 0 , 0,
20982 0x0 }, /* POOL32S_4~*(3) */
20983 { reserved_block , 0 , 0 , 32,
20984 0xfc00003f, 0xc0000024, 0 , 0,
20985 0x0 }, /* POOL32S_4~*(4) */
20986 { reserved_block , 0 , 0 , 32,
20987 0xfc00003f, 0xc000002c, 0 , 0,
20988 0x0 }, /* POOL32S_4~*(5) */
20989 { reserved_block , 0 , 0 , 32,
20990 0xfc00003f, 0xc0000034, 0 , 0,
20991 0x0 }, /* POOL32S_4~*(6) */
20992 { pool , POOL32Sxf , 8 , 32,
20993 0xfc00003f, 0xc000003c, 0 , 0,
20994 0x0 }, /* POOL32Sxf */
20995 };
20996
20997
20998 NMD::Pool NMD::POOL32S[8] = {
20999 { pool , POOL32S_0 , 64 , 32,
21000 0xfc000007, 0xc0000000, 0 , 0,
21001 0x0 }, /* POOL32S_0 */
21002 { reserved_block , 0 , 0 , 32,
21003 0xfc000007, 0xc0000001, 0 , 0,
21004 0x0 }, /* POOL32S~*(1) */
21005 { reserved_block , 0 , 0 , 32,
21006 0xfc000007, 0xc0000002, 0 , 0,
21007 0x0 }, /* POOL32S~*(2) */
21008 { reserved_block , 0 , 0 , 32,
21009 0xfc000007, 0xc0000003, 0 , 0,
21010 0x0 }, /* POOL32S~*(3) */
21011 { pool , POOL32S_4 , 8 , 32,
21012 0xfc000007, 0xc0000004, 0 , 0,
21013 0x0 }, /* POOL32S_4 */
21014 { reserved_block , 0 , 0 , 32,
21015 0xfc000007, 0xc0000005, 0 , 0,
21016 0x0 }, /* POOL32S~*(5) */
21017 { reserved_block , 0 , 0 , 32,
21018 0xfc000007, 0xc0000006, 0 , 0,
21019 0x0 }, /* POOL32S~*(6) */
21020 { reserved_block , 0 , 0 , 32,
21021 0xfc000007, 0xc0000007, 0 , 0,
21022 0x0 }, /* POOL32S~*(7) */
21023 };
21024
21025
21026 NMD::Pool NMD::P_LUI[2] = {
21027 { instruction , 0 , 0 , 32,
21028 0xfc000002, 0xe0000000, &NMD::LUI , 0,
21029 0x0 }, /* LUI */
21030 { instruction , 0 , 0 , 32,
21031 0xfc000002, 0xe0000002, &NMD::ALUIPC , 0,
21032 0x0 }, /* ALUIPC */
21033 };
21034
21035
21036 NMD::Pool NMD::P_GP_LH[2] = {
21037 { instruction , 0 , 0 , 32,
21038 0xfc1c0001, 0x44100000, &NMD::LH_GP_ , 0,
21039 0x0 }, /* LH[GP] */
21040 { instruction , 0 , 0 , 32,
21041 0xfc1c0001, 0x44100001, &NMD::LHU_GP_ , 0,
21042 0x0 }, /* LHU[GP] */
21043 };
21044
21045
21046 NMD::Pool NMD::P_GP_SH[2] = {
21047 { instruction , 0 , 0 , 32,
21048 0xfc1c0001, 0x44140000, &NMD::SH_GP_ , 0,
21049 0x0 }, /* SH[GP] */
21050 { reserved_block , 0 , 0 , 32,
21051 0xfc1c0001, 0x44140001, 0 , 0,
21052 0x0 }, /* P.GP.SH~*(1) */
21053 };
21054
21055
21056 NMD::Pool NMD::P_GP_CP1[4] = {
21057 { instruction , 0 , 0 , 32,
21058 0xfc1c0003, 0x44180000, &NMD::LWC1_GP_ , 0,
21059 CP1_ }, /* LWC1[GP] */
21060 { instruction , 0 , 0 , 32,
21061 0xfc1c0003, 0x44180001, &NMD::SWC1_GP_ , 0,
21062 CP1_ }, /* SWC1[GP] */
21063 { instruction , 0 , 0 , 32,
21064 0xfc1c0003, 0x44180002, &NMD::LDC1_GP_ , 0,
21065 CP1_ }, /* LDC1[GP] */
21066 { instruction , 0 , 0 , 32,
21067 0xfc1c0003, 0x44180003, &NMD::SDC1_GP_ , 0,
21068 CP1_ }, /* SDC1[GP] */
21069 };
21070
21071
21072 NMD::Pool NMD::P_GP_M64[4] = {
21073 { instruction , 0 , 0 , 32,
21074 0xfc1c0003, 0x441c0000, &NMD::LWU_GP_ , 0,
21075 MIPS64_ }, /* LWU[GP] */
21076 { reserved_block , 0 , 0 , 32,
21077 0xfc1c0003, 0x441c0001, 0 , 0,
21078 0x0 }, /* P.GP.M64~*(1) */
21079 { reserved_block , 0 , 0 , 32,
21080 0xfc1c0003, 0x441c0002, 0 , 0,
21081 0x0 }, /* P.GP.M64~*(2) */
21082 { reserved_block , 0 , 0 , 32,
21083 0xfc1c0003, 0x441c0003, 0 , 0,
21084 0x0 }, /* P.GP.M64~*(3) */
21085 };
21086
21087
21088 NMD::Pool NMD::P_GP_BH[8] = {
21089 { instruction , 0 , 0 , 32,
21090 0xfc1c0000, 0x44000000, &NMD::LB_GP_ , 0,
21091 0x0 }, /* LB[GP] */
21092 { instruction , 0 , 0 , 32,
21093 0xfc1c0000, 0x44040000, &NMD::SB_GP_ , 0,
21094 0x0 }, /* SB[GP] */
21095 { instruction , 0 , 0 , 32,
21096 0xfc1c0000, 0x44080000, &NMD::LBU_GP_ , 0,
21097 0x0 }, /* LBU[GP] */
21098 { instruction , 0 , 0 , 32,
21099 0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_ , 0,
21100 0x0 }, /* ADDIU[GP.B] */
21101 { pool , P_GP_LH , 2 , 32,
21102 0xfc1c0000, 0x44100000, 0 , 0,
21103 0x0 }, /* P.GP.LH */
21104 { pool , P_GP_SH , 2 , 32,
21105 0xfc1c0000, 0x44140000, 0 , 0,
21106 0x0 }, /* P.GP.SH */
21107 { pool , P_GP_CP1 , 4 , 32,
21108 0xfc1c0000, 0x44180000, 0 , 0,
21109 0x0 }, /* P.GP.CP1 */
21110 { pool , P_GP_M64 , 4 , 32,
21111 0xfc1c0000, 0x441c0000, 0 , 0,
21112 0x0 }, /* P.GP.M64 */
21113 };
21114
21115
21116 NMD::Pool NMD::P_LS_U12[16] = {
21117 { instruction , 0 , 0 , 32,
21118 0xfc00f000, 0x84000000, &NMD::LB_U12_ , 0,
21119 0x0 }, /* LB[U12] */
21120 { instruction , 0 , 0 , 32,
21121 0xfc00f000, 0x84001000, &NMD::SB_U12_ , 0,
21122 0x0 }, /* SB[U12] */
21123 { instruction , 0 , 0 , 32,
21124 0xfc00f000, 0x84002000, &NMD::LBU_U12_ , 0,
21125 0x0 }, /* LBU[U12] */
21126 { instruction , 0 , 0 , 32,
21127 0xfc00f000, 0x84003000, &NMD::PREF_U12_ , 0,
21128 0x0 }, /* PREF[U12] */
21129 { instruction , 0 , 0 , 32,
21130 0xfc00f000, 0x84004000, &NMD::LH_U12_ , 0,
21131 0x0 }, /* LH[U12] */
21132 { instruction , 0 , 0 , 32,
21133 0xfc00f000, 0x84005000, &NMD::SH_U12_ , 0,
21134 0x0 }, /* SH[U12] */
21135 { instruction , 0 , 0 , 32,
21136 0xfc00f000, 0x84006000, &NMD::LHU_U12_ , 0,
21137 0x0 }, /* LHU[U12] */
21138 { instruction , 0 , 0 , 32,
21139 0xfc00f000, 0x84007000, &NMD::LWU_U12_ , 0,
21140 MIPS64_ }, /* LWU[U12] */
21141 { instruction , 0 , 0 , 32,
21142 0xfc00f000, 0x84008000, &NMD::LW_U12_ , 0,
21143 0x0 }, /* LW[U12] */
21144 { instruction , 0 , 0 , 32,
21145 0xfc00f000, 0x84009000, &NMD::SW_U12_ , 0,
21146 0x0 }, /* SW[U12] */
21147 { instruction , 0 , 0 , 32,
21148 0xfc00f000, 0x8400a000, &NMD::LWC1_U12_ , 0,
21149 CP1_ }, /* LWC1[U12] */
21150 { instruction , 0 , 0 , 32,
21151 0xfc00f000, 0x8400b000, &NMD::SWC1_U12_ , 0,
21152 CP1_ }, /* SWC1[U12] */
21153 { instruction , 0 , 0 , 32,
21154 0xfc00f000, 0x8400c000, &NMD::LD_U12_ , 0,
21155 MIPS64_ }, /* LD[U12] */
21156 { instruction , 0 , 0 , 32,
21157 0xfc00f000, 0x8400d000, &NMD::SD_U12_ , 0,
21158 MIPS64_ }, /* SD[U12] */
21159 { instruction , 0 , 0 , 32,
21160 0xfc00f000, 0x8400e000, &NMD::LDC1_U12_ , 0,
21161 CP1_ }, /* LDC1[U12] */
21162 { instruction , 0 , 0 , 32,
21163 0xfc00f000, 0x8400f000, &NMD::SDC1_U12_ , 0,
21164 CP1_ }, /* SDC1[U12] */
21165 };
21166
21167
21168 NMD::Pool NMD::P_PREF_S9_[2] = {
21169 { instruction , 0 , 0 , 32,
21170 0xffe07f00, 0xa7e01800, &NMD::SYNCI , 0,
21171 0x0 }, /* SYNCI */
21172 { instruction , 0 , 0 , 32,
21173 0xfc007f00, 0xa4001800, &NMD::PREF_S9_ , &NMD::PREF_S9__cond ,
21174 0x0 }, /* PREF[S9] */
21175 };
21176
21177
21178 NMD::Pool NMD::P_LS_S0[16] = {
21179 { instruction , 0 , 0 , 32,
21180 0xfc007f00, 0xa4000000, &NMD::LB_S9_ , 0,
21181 0x0 }, /* LB[S9] */
21182 { instruction , 0 , 0 , 32,
21183 0xfc007f00, 0xa4000800, &NMD::SB_S9_ , 0,
21184 0x0 }, /* SB[S9] */
21185 { instruction , 0 , 0 , 32,
21186 0xfc007f00, 0xa4001000, &NMD::LBU_S9_ , 0,
21187 0x0 }, /* LBU[S9] */
21188 { pool , P_PREF_S9_ , 2 , 32,
21189 0xfc007f00, 0xa4001800, 0 , 0,
21190 0x0 }, /* P.PREF[S9] */
21191 { instruction , 0 , 0 , 32,
21192 0xfc007f00, 0xa4002000, &NMD::LH_S9_ , 0,
21193 0x0 }, /* LH[S9] */
21194 { instruction , 0 , 0 , 32,
21195 0xfc007f00, 0xa4002800, &NMD::SH_S9_ , 0,
21196 0x0 }, /* SH[S9] */
21197 { instruction , 0 , 0 , 32,
21198 0xfc007f00, 0xa4003000, &NMD::LHU_S9_ , 0,
21199 0x0 }, /* LHU[S9] */
21200 { instruction , 0 , 0 , 32,
21201 0xfc007f00, 0xa4003800, &NMD::LWU_S9_ , 0,
21202 MIPS64_ }, /* LWU[S9] */
21203 { instruction , 0 , 0 , 32,
21204 0xfc007f00, 0xa4004000, &NMD::LW_S9_ , 0,
21205 0x0 }, /* LW[S9] */
21206 { instruction , 0 , 0 , 32,
21207 0xfc007f00, 0xa4004800, &NMD::SW_S9_ , 0,
21208 0x0 }, /* SW[S9] */
21209 { instruction , 0 , 0 , 32,
21210 0xfc007f00, 0xa4005000, &NMD::LWC1_S9_ , 0,
21211 CP1_ }, /* LWC1[S9] */
21212 { instruction , 0 , 0 , 32,
21213 0xfc007f00, 0xa4005800, &NMD::SWC1_S9_ , 0,
21214 CP1_ }, /* SWC1[S9] */
21215 { instruction , 0 , 0 , 32,
21216 0xfc007f00, 0xa4006000, &NMD::LD_S9_ , 0,
21217 MIPS64_ }, /* LD[S9] */
21218 { instruction , 0 , 0 , 32,
21219 0xfc007f00, 0xa4006800, &NMD::SD_S9_ , 0,
21220 MIPS64_ }, /* SD[S9] */
21221 { instruction , 0 , 0 , 32,
21222 0xfc007f00, 0xa4007000, &NMD::LDC1_S9_ , 0,
21223 CP1_ }, /* LDC1[S9] */
21224 { instruction , 0 , 0 , 32,
21225 0xfc007f00, 0xa4007800, &NMD::SDC1_S9_ , 0,
21226 CP1_ }, /* SDC1[S9] */
21227 };
21228
21229
21230 NMD::Pool NMD::ASET_ACLR[2] = {
21231 { instruction , 0 , 0 , 32,
21232 0xfe007f00, 0xa4001100, &NMD::ASET , 0,
21233 MCU_ }, /* ASET */
21234 { instruction , 0 , 0 , 32,
21235 0xfe007f00, 0xa6001100, &NMD::ACLR , 0,
21236 MCU_ }, /* ACLR */
21237 };
21238
21239
21240 NMD::Pool NMD::P_LL[4] = {
21241 { instruction , 0 , 0 , 32,
21242 0xfc007f03, 0xa4005100, &NMD::LL , 0,
21243 0x0 }, /* LL */
21244 { instruction , 0 , 0 , 32,
21245 0xfc007f03, 0xa4005101, &NMD::LLWP , 0,
21246 XNP_ }, /* LLWP */
21247 { reserved_block , 0 , 0 , 32,
21248 0xfc007f03, 0xa4005102, 0 , 0,
21249 0x0 }, /* P.LL~*(2) */
21250 { reserved_block , 0 , 0 , 32,
21251 0xfc007f03, 0xa4005103, 0 , 0,
21252 0x0 }, /* P.LL~*(3) */
21253 };
21254
21255
21256 NMD::Pool NMD::P_SC[4] = {
21257 { instruction , 0 , 0 , 32,
21258 0xfc007f03, 0xa4005900, &NMD::SC , 0,
21259 0x0 }, /* SC */
21260 { instruction , 0 , 0 , 32,
21261 0xfc007f03, 0xa4005901, &NMD::SCWP , 0,
21262 XNP_ }, /* SCWP */
21263 { reserved_block , 0 , 0 , 32,
21264 0xfc007f03, 0xa4005902, 0 , 0,
21265 0x0 }, /* P.SC~*(2) */
21266 { reserved_block , 0 , 0 , 32,
21267 0xfc007f03, 0xa4005903, 0 , 0,
21268 0x0 }, /* P.SC~*(3) */
21269 };
21270
21271
21272 NMD::Pool NMD::P_LLD[8] = {
21273 { instruction , 0 , 0 , 32,
21274 0xfc007f07, 0xa4007100, &NMD::LLD , 0,
21275 MIPS64_ }, /* LLD */
21276 { instruction , 0 , 0 , 32,
21277 0xfc007f07, 0xa4007101, &NMD::LLDP , 0,
21278 MIPS64_ }, /* LLDP */
21279 { reserved_block , 0 , 0 , 32,
21280 0xfc007f07, 0xa4007102, 0 , 0,
21281 0x0 }, /* P.LLD~*(2) */
21282 { reserved_block , 0 , 0 , 32,
21283 0xfc007f07, 0xa4007103, 0 , 0,
21284 0x0 }, /* P.LLD~*(3) */
21285 { reserved_block , 0 , 0 , 32,
21286 0xfc007f07, 0xa4007104, 0 , 0,
21287 0x0 }, /* P.LLD~*(4) */
21288 { reserved_block , 0 , 0 , 32,
21289 0xfc007f07, 0xa4007105, 0 , 0,
21290 0x0 }, /* P.LLD~*(5) */
21291 { reserved_block , 0 , 0 , 32,
21292 0xfc007f07, 0xa4007106, 0 , 0,
21293 0x0 }, /* P.LLD~*(6) */
21294 { reserved_block , 0 , 0 , 32,
21295 0xfc007f07, 0xa4007107, 0 , 0,
21296 0x0 }, /* P.LLD~*(7) */
21297 };
21298
21299
21300 NMD::Pool NMD::P_SCD[8] = {
21301 { instruction , 0 , 0 , 32,
21302 0xfc007f07, 0xa4007900, &NMD::SCD , 0,
21303 MIPS64_ }, /* SCD */
21304 { instruction , 0 , 0 , 32,
21305 0xfc007f07, 0xa4007901, &NMD::SCDP , 0,
21306 MIPS64_ }, /* SCDP */
21307 { reserved_block , 0 , 0 , 32,
21308 0xfc007f07, 0xa4007902, 0 , 0,
21309 0x0 }, /* P.SCD~*(2) */
21310 { reserved_block , 0 , 0 , 32,
21311 0xfc007f07, 0xa4007903, 0 , 0,
21312 0x0 }, /* P.SCD~*(3) */
21313 { reserved_block , 0 , 0 , 32,
21314 0xfc007f07, 0xa4007904, 0 , 0,
21315 0x0 }, /* P.SCD~*(4) */
21316 { reserved_block , 0 , 0 , 32,
21317 0xfc007f07, 0xa4007905, 0 , 0,
21318 0x0 }, /* P.SCD~*(5) */
21319 { reserved_block , 0 , 0 , 32,
21320 0xfc007f07, 0xa4007906, 0 , 0,
21321 0x0 }, /* P.SCD~*(6) */
21322 { reserved_block , 0 , 0 , 32,
21323 0xfc007f07, 0xa4007907, 0 , 0,
21324 0x0 }, /* P.SCD~*(7) */
21325 };
21326
21327
21328 NMD::Pool NMD::P_LS_S1[16] = {
21329 { reserved_block , 0 , 0 , 32,
21330 0xfc007f00, 0xa4000100, 0 , 0,
21331 0x0 }, /* P.LS.S1~*(0) */
21332 { reserved_block , 0 , 0 , 32,
21333 0xfc007f00, 0xa4000900, 0 , 0,
21334 0x0 }, /* P.LS.S1~*(1) */
21335 { pool , ASET_ACLR , 2 , 32,
21336 0xfc007f00, 0xa4001100, 0 , 0,
21337 0x0 }, /* ASET_ACLR */
21338 { reserved_block , 0 , 0 , 32,
21339 0xfc007f00, 0xa4001900, 0 , 0,
21340 0x0 }, /* P.LS.S1~*(3) */
21341 { instruction , 0 , 0 , 32,
21342 0xfc007f00, 0xa4002100, &NMD::UALH , 0,
21343 XMMS_ }, /* UALH */
21344 { instruction , 0 , 0 , 32,
21345 0xfc007f00, 0xa4002900, &NMD::UASH , 0,
21346 XMMS_ }, /* UASH */
21347 { reserved_block , 0 , 0 , 32,
21348 0xfc007f00, 0xa4003100, 0 , 0,
21349 0x0 }, /* P.LS.S1~*(6) */
21350 { instruction , 0 , 0 , 32,
21351 0xfc007f00, 0xa4003900, &NMD::CACHE , 0,
21352 CP0_ }, /* CACHE */
21353 { instruction , 0 , 0 , 32,
21354 0xfc007f00, 0xa4004100, &NMD::LWC2 , 0,
21355 CP2_ }, /* LWC2 */
21356 { instruction , 0 , 0 , 32,
21357 0xfc007f00, 0xa4004900, &NMD::SWC2 , 0,
21358 CP2_ }, /* SWC2 */
21359 { pool , P_LL , 4 , 32,
21360 0xfc007f00, 0xa4005100, 0 , 0,
21361 0x0 }, /* P.LL */
21362 { pool , P_SC , 4 , 32,
21363 0xfc007f00, 0xa4005900, 0 , 0,
21364 0x0 }, /* P.SC */
21365 { instruction , 0 , 0 , 32,
21366 0xfc007f00, 0xa4006100, &NMD::LDC2 , 0,
21367 CP2_ }, /* LDC2 */
21368 { instruction , 0 , 0 , 32,
21369 0xfc007f00, 0xa4006900, &NMD::SDC2 , 0,
21370 CP2_ }, /* SDC2 */
21371 { pool , P_LLD , 8 , 32,
21372 0xfc007f00, 0xa4007100, 0 , 0,
21373 0x0 }, /* P.LLD */
21374 { pool , P_SCD , 8 , 32,
21375 0xfc007f00, 0xa4007900, 0 , 0,
21376 0x0 }, /* P.SCD */
21377 };
21378
21379
21380 NMD::Pool NMD::P_PREFE[2] = {
21381 { instruction , 0 , 0 , 32,
21382 0xffe07f00, 0xa7e01a00, &NMD::SYNCIE , 0,
21383 CP0_ | EVA_ }, /* SYNCIE */
21384 { instruction , 0 , 0 , 32,
21385 0xfc007f00, 0xa4001a00, &NMD::PREFE , &NMD::PREFE_cond ,
21386 CP0_ | EVA_ }, /* PREFE */
21387 };
21388
21389
21390 NMD::Pool NMD::P_LLE[4] = {
21391 { instruction , 0 , 0 , 32,
21392 0xfc007f03, 0xa4005200, &NMD::LLE , 0,
21393 CP0_ | EVA_ }, /* LLE */
21394 { instruction , 0 , 0 , 32,
21395 0xfc007f03, 0xa4005201, &NMD::LLWPE , 0,
21396 CP0_ | EVA_ }, /* LLWPE */
21397 { reserved_block , 0 , 0 , 32,
21398 0xfc007f03, 0xa4005202, 0 , 0,
21399 0x0 }, /* P.LLE~*(2) */
21400 { reserved_block , 0 , 0 , 32,
21401 0xfc007f03, 0xa4005203, 0 , 0,
21402 0x0 }, /* P.LLE~*(3) */
21403 };
21404
21405
21406 NMD::Pool NMD::P_SCE[4] = {
21407 { instruction , 0 , 0 , 32,
21408 0xfc007f03, 0xa4005a00, &NMD::SCE , 0,
21409 CP0_ | EVA_ }, /* SCE */
21410 { instruction , 0 , 0 , 32,
21411 0xfc007f03, 0xa4005a01, &NMD::SCWPE , 0,
21412 CP0_ | EVA_ }, /* SCWPE */
21413 { reserved_block , 0 , 0 , 32,
21414 0xfc007f03, 0xa4005a02, 0 , 0,
21415 0x0 }, /* P.SCE~*(2) */
21416 { reserved_block , 0 , 0 , 32,
21417 0xfc007f03, 0xa4005a03, 0 , 0,
21418 0x0 }, /* P.SCE~*(3) */
21419 };
21420
21421
21422 NMD::Pool NMD::P_LS_E0[16] = {
21423 { instruction , 0 , 0 , 32,
21424 0xfc007f00, 0xa4000200, &NMD::LBE , 0,
21425 CP0_ | EVA_ }, /* LBE */
21426 { instruction , 0 , 0 , 32,
21427 0xfc007f00, 0xa4000a00, &NMD::SBE , 0,
21428 CP0_ | EVA_ }, /* SBE */
21429 { instruction , 0 , 0 , 32,
21430 0xfc007f00, 0xa4001200, &NMD::LBUE , 0,
21431 CP0_ | EVA_ }, /* LBUE */
21432 { pool , P_PREFE , 2 , 32,
21433 0xfc007f00, 0xa4001a00, 0 , 0,
21434 0x0 }, /* P.PREFE */
21435 { instruction , 0 , 0 , 32,
21436 0xfc007f00, 0xa4002200, &NMD::LHE , 0,
21437 CP0_ | EVA_ }, /* LHE */
21438 { instruction , 0 , 0 , 32,
21439 0xfc007f00, 0xa4002a00, &NMD::SHE , 0,
21440 CP0_ | EVA_ }, /* SHE */
21441 { instruction , 0 , 0 , 32,
21442 0xfc007f00, 0xa4003200, &NMD::LHUE , 0,
21443 CP0_ | EVA_ }, /* LHUE */
21444 { instruction , 0 , 0 , 32,
21445 0xfc007f00, 0xa4003a00, &NMD::CACHEE , 0,
21446 CP0_ | EVA_ }, /* CACHEE */
21447 { instruction , 0 , 0 , 32,
21448 0xfc007f00, 0xa4004200, &NMD::LWE , 0,
21449 CP0_ | EVA_ }, /* LWE */
21450 { instruction , 0 , 0 , 32,
21451 0xfc007f00, 0xa4004a00, &NMD::SWE , 0,
21452 CP0_ | EVA_ }, /* SWE */
21453 { pool , P_LLE , 4 , 32,
21454 0xfc007f00, 0xa4005200, 0 , 0,
21455 0x0 }, /* P.LLE */
21456 { pool , P_SCE , 4 , 32,
21457 0xfc007f00, 0xa4005a00, 0 , 0,
21458 0x0 }, /* P.SCE */
21459 { reserved_block , 0 , 0 , 32,
21460 0xfc007f00, 0xa4006200, 0 , 0,
21461 0x0 }, /* P.LS.E0~*(12) */
21462 { reserved_block , 0 , 0 , 32,
21463 0xfc007f00, 0xa4006a00, 0 , 0,
21464 0x0 }, /* P.LS.E0~*(13) */
21465 { reserved_block , 0 , 0 , 32,
21466 0xfc007f00, 0xa4007200, 0 , 0,
21467 0x0 }, /* P.LS.E0~*(14) */
21468 { reserved_block , 0 , 0 , 32,
21469 0xfc007f00, 0xa4007a00, 0 , 0,
21470 0x0 }, /* P.LS.E0~*(15) */
21471 };
21472
21473
21474 NMD::Pool NMD::P_LS_WM[2] = {
21475 { instruction , 0 , 0 , 32,
21476 0xfc000f00, 0xa4000400, &NMD::LWM , 0,
21477 XMMS_ }, /* LWM */
21478 { instruction , 0 , 0 , 32,
21479 0xfc000f00, 0xa4000c00, &NMD::SWM , 0,
21480 XMMS_ }, /* SWM */
21481 };
21482
21483
21484 NMD::Pool NMD::P_LS_UAWM[2] = {
21485 { instruction , 0 , 0 , 32,
21486 0xfc000f00, 0xa4000500, &NMD::UALWM , 0,
21487 XMMS_ }, /* UALWM */
21488 { instruction , 0 , 0 , 32,
21489 0xfc000f00, 0xa4000d00, &NMD::UASWM , 0,
21490 XMMS_ }, /* UASWM */
21491 };
21492
21493
21494 NMD::Pool NMD::P_LS_DM[2] = {
21495 { instruction , 0 , 0 , 32,
21496 0xfc000f00, 0xa4000600, &NMD::LDM , 0,
21497 MIPS64_ }, /* LDM */
21498 { instruction , 0 , 0 , 32,
21499 0xfc000f00, 0xa4000e00, &NMD::SDM , 0,
21500 MIPS64_ }, /* SDM */
21501 };
21502
21503
21504 NMD::Pool NMD::P_LS_UADM[2] = {
21505 { instruction , 0 , 0 , 32,
21506 0xfc000f00, 0xa4000700, &NMD::UALDM , 0,
21507 MIPS64_ }, /* UALDM */
21508 { instruction , 0 , 0 , 32,
21509 0xfc000f00, 0xa4000f00, &NMD::UASDM , 0,
21510 MIPS64_ }, /* UASDM */
21511 };
21512
21513
21514 NMD::Pool NMD::P_LS_S9[8] = {
21515 { pool , P_LS_S0 , 16 , 32,
21516 0xfc000700, 0xa4000000, 0 , 0,
21517 0x0 }, /* P.LS.S0 */
21518 { pool , P_LS_S1 , 16 , 32,
21519 0xfc000700, 0xa4000100, 0 , 0,
21520 0x0 }, /* P.LS.S1 */
21521 { pool , P_LS_E0 , 16 , 32,
21522 0xfc000700, 0xa4000200, 0 , 0,
21523 0x0 }, /* P.LS.E0 */
21524 { reserved_block , 0 , 0 , 32,
21525 0xfc000700, 0xa4000300, 0 , 0,
21526 0x0 }, /* P.LS.S9~*(3) */
21527 { pool , P_LS_WM , 2 , 32,
21528 0xfc000700, 0xa4000400, 0 , 0,
21529 0x0 }, /* P.LS.WM */
21530 { pool , P_LS_UAWM , 2 , 32,
21531 0xfc000700, 0xa4000500, 0 , 0,
21532 0x0 }, /* P.LS.UAWM */
21533 { pool , P_LS_DM , 2 , 32,
21534 0xfc000700, 0xa4000600, 0 , 0,
21535 0x0 }, /* P.LS.DM */
21536 { pool , P_LS_UADM , 2 , 32,
21537 0xfc000700, 0xa4000700, 0 , 0,
21538 0x0 }, /* P.LS.UADM */
21539 };
21540
21541
21542 NMD::Pool NMD::P_BAL[2] = {
21543 { branch_instruction , 0 , 0 , 32,
21544 0xfe000000, 0x28000000, &NMD::BC_32_ , 0,
21545 0x0 }, /* BC[32] */
21546 { call_instruction , 0 , 0 , 32,
21547 0xfe000000, 0x2a000000, &NMD::BALC_32_ , 0,
21548 0x0 }, /* BALC[32] */
21549 };
21550
21551
21552 NMD::Pool NMD::P_BALRSC[2] = {
21553 { branch_instruction , 0 , 0 , 32,
21554 0xffe0f000, 0x48008000, &NMD::BRSC , 0,
21555 0x0 }, /* BRSC */
21556 { call_instruction , 0 , 0 , 32,
21557 0xfc00f000, 0x48008000, &NMD::BALRSC , &NMD::BALRSC_cond ,
21558 0x0 }, /* BALRSC */
21559 };
21560
21561
21562 NMD::Pool NMD::P_J[16] = {
21563 { call_instruction , 0 , 0 , 32,
21564 0xfc00f000, 0x48000000, &NMD::JALRC_32_ , 0,
21565 0x0 }, /* JALRC[32] */
21566 { call_instruction , 0 , 0 , 32,
21567 0xfc00f000, 0x48001000, &NMD::JALRC_HB , 0,
21568 0x0 }, /* JALRC.HB */
21569 { reserved_block , 0 , 0 , 32,
21570 0xfc00f000, 0x48002000, 0 , 0,
21571 0x0 }, /* P.J~*(2) */
21572 { reserved_block , 0 , 0 , 32,
21573 0xfc00f000, 0x48003000, 0 , 0,
21574 0x0 }, /* P.J~*(3) */
21575 { reserved_block , 0 , 0 , 32,
21576 0xfc00f000, 0x48004000, 0 , 0,
21577 0x0 }, /* P.J~*(4) */
21578 { reserved_block , 0 , 0 , 32,
21579 0xfc00f000, 0x48005000, 0 , 0,
21580 0x0 }, /* P.J~*(5) */
21581 { reserved_block , 0 , 0 , 32,
21582 0xfc00f000, 0x48006000, 0 , 0,
21583 0x0 }, /* P.J~*(6) */
21584 { reserved_block , 0 , 0 , 32,
21585 0xfc00f000, 0x48007000, 0 , 0,
21586 0x0 }, /* P.J~*(7) */
21587 { pool , P_BALRSC , 2 , 32,
21588 0xfc00f000, 0x48008000, 0 , 0,
21589 0x0 }, /* P.BALRSC */
21590 { reserved_block , 0 , 0 , 32,
21591 0xfc00f000, 0x48009000, 0 , 0,
21592 0x0 }, /* P.J~*(9) */
21593 { reserved_block , 0 , 0 , 32,
21594 0xfc00f000, 0x4800a000, 0 , 0,
21595 0x0 }, /* P.J~*(10) */
21596 { reserved_block , 0 , 0 , 32,
21597 0xfc00f000, 0x4800b000, 0 , 0,
21598 0x0 }, /* P.J~*(11) */
21599 { reserved_block , 0 , 0 , 32,
21600 0xfc00f000, 0x4800c000, 0 , 0,
21601 0x0 }, /* P.J~*(12) */
21602 { reserved_block , 0 , 0 , 32,
21603 0xfc00f000, 0x4800d000, 0 , 0,
21604 0x0 }, /* P.J~*(13) */
21605 { reserved_block , 0 , 0 , 32,
21606 0xfc00f000, 0x4800e000, 0 , 0,
21607 0x0 }, /* P.J~*(14) */
21608 { reserved_block , 0 , 0 , 32,
21609 0xfc00f000, 0x4800f000, 0 , 0,
21610 0x0 }, /* P.J~*(15) */
21611 };
21612
21613
21614 NMD::Pool NMD::P_BR3A[32] = {
21615 { branch_instruction , 0 , 0 , 32,
21616 0xfc1fc000, 0x88004000, &NMD::BC1EQZC , 0,
21617 CP1_ }, /* BC1EQZC */
21618 { branch_instruction , 0 , 0 , 32,
21619 0xfc1fc000, 0x88014000, &NMD::BC1NEZC , 0,
21620 CP1_ }, /* BC1NEZC */
21621 { branch_instruction , 0 , 0 , 32,
21622 0xfc1fc000, 0x88024000, &NMD::BC2EQZC , 0,
21623 CP2_ }, /* BC2EQZC */
21624 { branch_instruction , 0 , 0 , 32,
21625 0xfc1fc000, 0x88034000, &NMD::BC2NEZC , 0,
21626 CP2_ }, /* BC2NEZC */
21627 { branch_instruction , 0 , 0 , 32,
21628 0xfc1fc000, 0x88044000, &NMD::BPOSGE32C , 0,
21629 DSP_ }, /* BPOSGE32C */
21630 { reserved_block , 0 , 0 , 32,
21631 0xfc1fc000, 0x88054000, 0 , 0,
21632 0x0 }, /* P.BR3A~*(5) */
21633 { reserved_block , 0 , 0 , 32,
21634 0xfc1fc000, 0x88064000, 0 , 0,
21635 0x0 }, /* P.BR3A~*(6) */
21636 { reserved_block , 0 , 0 , 32,
21637 0xfc1fc000, 0x88074000, 0 , 0,
21638 0x0 }, /* P.BR3A~*(7) */
21639 { reserved_block , 0 , 0 , 32,
21640 0xfc1fc000, 0x88084000, 0 , 0,
21641 0x0 }, /* P.BR3A~*(8) */
21642 { reserved_block , 0 , 0 , 32,
21643 0xfc1fc000, 0x88094000, 0 , 0,
21644 0x0 }, /* P.BR3A~*(9) */
21645 { reserved_block , 0 , 0 , 32,
21646 0xfc1fc000, 0x880a4000, 0 , 0,
21647 0x0 }, /* P.BR3A~*(10) */
21648 { reserved_block , 0 , 0 , 32,
21649 0xfc1fc000, 0x880b4000, 0 , 0,
21650 0x0 }, /* P.BR3A~*(11) */
21651 { reserved_block , 0 , 0 , 32,
21652 0xfc1fc000, 0x880c4000, 0 , 0,
21653 0x0 }, /* P.BR3A~*(12) */
21654 { reserved_block , 0 , 0 , 32,
21655 0xfc1fc000, 0x880d4000, 0 , 0,
21656 0x0 }, /* P.BR3A~*(13) */
21657 { reserved_block , 0 , 0 , 32,
21658 0xfc1fc000, 0x880e4000, 0 , 0,
21659 0x0 }, /* P.BR3A~*(14) */
21660 { reserved_block , 0 , 0 , 32,
21661 0xfc1fc000, 0x880f4000, 0 , 0,
21662 0x0 }, /* P.BR3A~*(15) */
21663 { reserved_block , 0 , 0 , 32,
21664 0xfc1fc000, 0x88104000, 0 , 0,
21665 0x0 }, /* P.BR3A~*(16) */
21666 { reserved_block , 0 , 0 , 32,
21667 0xfc1fc000, 0x88114000, 0 , 0,
21668 0x0 }, /* P.BR3A~*(17) */
21669 { reserved_block , 0 , 0 , 32,
21670 0xfc1fc000, 0x88124000, 0 , 0,
21671 0x0 }, /* P.BR3A~*(18) */
21672 { reserved_block , 0 , 0 , 32,
21673 0xfc1fc000, 0x88134000, 0 , 0,
21674 0x0 }, /* P.BR3A~*(19) */
21675 { reserved_block , 0 , 0 , 32,
21676 0xfc1fc000, 0x88144000, 0 , 0,
21677 0x0 }, /* P.BR3A~*(20) */
21678 { reserved_block , 0 , 0 , 32,
21679 0xfc1fc000, 0x88154000, 0 , 0,
21680 0x0 }, /* P.BR3A~*(21) */
21681 { reserved_block , 0 , 0 , 32,
21682 0xfc1fc000, 0x88164000, 0 , 0,
21683 0x0 }, /* P.BR3A~*(22) */
21684 { reserved_block , 0 , 0 , 32,
21685 0xfc1fc000, 0x88174000, 0 , 0,
21686 0x0 }, /* P.BR3A~*(23) */
21687 { reserved_block , 0 , 0 , 32,
21688 0xfc1fc000, 0x88184000, 0 , 0,
21689 0x0 }, /* P.BR3A~*(24) */
21690 { reserved_block , 0 , 0 , 32,
21691 0xfc1fc000, 0x88194000, 0 , 0,
21692 0x0 }, /* P.BR3A~*(25) */
21693 { reserved_block , 0 , 0 , 32,
21694 0xfc1fc000, 0x881a4000, 0 , 0,
21695 0x0 }, /* P.BR3A~*(26) */
21696 { reserved_block , 0 , 0 , 32,
21697 0xfc1fc000, 0x881b4000, 0 , 0,
21698 0x0 }, /* P.BR3A~*(27) */
21699 { reserved_block , 0 , 0 , 32,
21700 0xfc1fc000, 0x881c4000, 0 , 0,
21701 0x0 }, /* P.BR3A~*(28) */
21702 { reserved_block , 0 , 0 , 32,
21703 0xfc1fc000, 0x881d4000, 0 , 0,
21704 0x0 }, /* P.BR3A~*(29) */
21705 { reserved_block , 0 , 0 , 32,
21706 0xfc1fc000, 0x881e4000, 0 , 0,
21707 0x0 }, /* P.BR3A~*(30) */
21708 { reserved_block , 0 , 0 , 32,
21709 0xfc1fc000, 0x881f4000, 0 , 0,
21710 0x0 }, /* P.BR3A~*(31) */
21711 };
21712
21713
21714 NMD::Pool NMD::P_BR1[4] = {
21715 { branch_instruction , 0 , 0 , 32,
21716 0xfc00c000, 0x88000000, &NMD::BEQC_32_ , 0,
21717 0x0 }, /* BEQC[32] */
21718 { pool , P_BR3A , 32 , 32,
21719 0xfc00c000, 0x88004000, 0 , 0,
21720 0x0 }, /* P.BR3A */
21721 { branch_instruction , 0 , 0 , 32,
21722 0xfc00c000, 0x88008000, &NMD::BGEC , 0,
21723 0x0 }, /* BGEC */
21724 { branch_instruction , 0 , 0 , 32,
21725 0xfc00c000, 0x8800c000, &NMD::BGEUC , 0,
21726 0x0 }, /* BGEUC */
21727 };
21728
21729
21730 NMD::Pool NMD::P_BR2[4] = {
21731 { branch_instruction , 0 , 0 , 32,
21732 0xfc00c000, 0xa8000000, &NMD::BNEC_32_ , 0,
21733 0x0 }, /* BNEC[32] */
21734 { reserved_block , 0 , 0 , 32,
21735 0xfc00c000, 0xa8004000, 0 , 0,
21736 0x0 }, /* P.BR2~*(1) */
21737 { branch_instruction , 0 , 0 , 32,
21738 0xfc00c000, 0xa8008000, &NMD::BLTC , 0,
21739 0x0 }, /* BLTC */
21740 { branch_instruction , 0 , 0 , 32,
21741 0xfc00c000, 0xa800c000, &NMD::BLTUC , 0,
21742 0x0 }, /* BLTUC */
21743 };
21744
21745
21746 NMD::Pool NMD::P_BRI[8] = {
21747 { branch_instruction , 0 , 0 , 32,
21748 0xfc1c0000, 0xc8000000, &NMD::BEQIC , 0,
21749 0x0 }, /* BEQIC */
21750 { branch_instruction , 0 , 0 , 32,
21751 0xfc1c0000, 0xc8040000, &NMD::BBEQZC , 0,
21752 XMMS_ }, /* BBEQZC */
21753 { branch_instruction , 0 , 0 , 32,
21754 0xfc1c0000, 0xc8080000, &NMD::BGEIC , 0,
21755 0x0 }, /* BGEIC */
21756 { branch_instruction , 0 , 0 , 32,
21757 0xfc1c0000, 0xc80c0000, &NMD::BGEIUC , 0,
21758 0x0 }, /* BGEIUC */
21759 { branch_instruction , 0 , 0 , 32,
21760 0xfc1c0000, 0xc8100000, &NMD::BNEIC , 0,
21761 0x0 }, /* BNEIC */
21762 { branch_instruction , 0 , 0 , 32,
21763 0xfc1c0000, 0xc8140000, &NMD::BBNEZC , 0,
21764 XMMS_ }, /* BBNEZC */
21765 { branch_instruction , 0 , 0 , 32,
21766 0xfc1c0000, 0xc8180000, &NMD::BLTIC , 0,
21767 0x0 }, /* BLTIC */
21768 { branch_instruction , 0 , 0 , 32,
21769 0xfc1c0000, 0xc81c0000, &NMD::BLTIUC , 0,
21770 0x0 }, /* BLTIUC */
21771 };
21772
21773
21774 NMD::Pool NMD::P32[32] = {
21775 { pool , P_ADDIU , 2 , 32,
21776 0xfc000000, 0x00000000, 0 , 0,
21777 0x0 }, /* P.ADDIU */
21778 { pool , P32A , 8 , 32,
21779 0xfc000000, 0x20000000, 0 , 0,
21780 0x0 }, /* P32A */
21781 { pool , P_GP_W , 4 , 32,
21782 0xfc000000, 0x40000000, 0 , 0,
21783 0x0 }, /* P.GP.W */
21784 { pool , POOL48I , 32 , 48,
21785 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21786 0x0 }, /* POOL48I */
21787 { pool , P_U12 , 16 , 32,
21788 0xfc000000, 0x80000000, 0 , 0,
21789 0x0 }, /* P.U12 */
21790 { pool , POOL32F , 8 , 32,
21791 0xfc000000, 0xa0000000, 0 , 0,
21792 CP1_ }, /* POOL32F */
21793 { pool , POOL32S , 8 , 32,
21794 0xfc000000, 0xc0000000, 0 , 0,
21795 0x0 }, /* POOL32S */
21796 { pool , P_LUI , 2 , 32,
21797 0xfc000000, 0xe0000000, 0 , 0,
21798 0x0 }, /* P.LUI */
21799 { instruction , 0 , 0 , 32,
21800 0xfc000000, 0x04000000, &NMD::ADDIUPC_32_ , 0,
21801 0x0 }, /* ADDIUPC[32] */
21802 { reserved_block , 0 , 0 , 32,
21803 0xfc000000, 0x24000000, 0 , 0,
21804 0x0 }, /* P32~*(5) */
21805 { pool , P_GP_BH , 8 , 32,
21806 0xfc000000, 0x44000000, 0 , 0,
21807 0x0 }, /* P.GP.BH */
21808 { reserved_block , 0 , 0 , 32,
21809 0xfc000000, 0x64000000, 0 , 0,
21810 0x0 }, /* P32~*(13) */
21811 { pool , P_LS_U12 , 16 , 32,
21812 0xfc000000, 0x84000000, 0 , 0,
21813 0x0 }, /* P.LS.U12 */
21814 { pool , P_LS_S9 , 8 , 32,
21815 0xfc000000, 0xa4000000, 0 , 0,
21816 0x0 }, /* P.LS.S9 */
21817 { reserved_block , 0 , 0 , 32,
21818 0xfc000000, 0xc4000000, 0 , 0,
21819 0x0 }, /* P32~*(25) */
21820 { reserved_block , 0 , 0 , 32,
21821 0xfc000000, 0xe4000000, 0 , 0,
21822 0x0 }, /* P32~*(29) */
21823 { call_instruction , 0 , 0 , 32,
21824 0xfc000000, 0x08000000, &NMD::MOVE_BALC , 0,
21825 XMMS_ }, /* MOVE.BALC */
21826 { pool , P_BAL , 2 , 32,
21827 0xfc000000, 0x28000000, 0 , 0,
21828 0x0 }, /* P.BAL */
21829 { pool , P_J , 16 , 32,
21830 0xfc000000, 0x48000000, 0 , 0,
21831 0x0 }, /* P.J */
21832 { reserved_block , 0 , 0 , 32,
21833 0xfc000000, 0x68000000, 0 , 0,
21834 0x0 }, /* P32~*(14) */
21835 { pool , P_BR1 , 4 , 32,
21836 0xfc000000, 0x88000000, 0 , 0,
21837 0x0 }, /* P.BR1 */
21838 { pool , P_BR2 , 4 , 32,
21839 0xfc000000, 0xa8000000, 0 , 0,
21840 0x0 }, /* P.BR2 */
21841 { pool , P_BRI , 8 , 32,
21842 0xfc000000, 0xc8000000, 0 , 0,
21843 0x0 }, /* P.BRI */
21844 { reserved_block , 0 , 0 , 32,
21845 0xfc000000, 0xe8000000, 0 , 0,
21846 0x0 }, /* P32~*(30) */
21847 { reserved_block , 0 , 0 , 32,
21848 0xfc000000, 0x0c000000, 0 , 0,
21849 0x0 }, /* P32~*(3) */
21850 { reserved_block , 0 , 0 , 32,
21851 0xfc000000, 0x2c000000, 0 , 0,
21852 0x0 }, /* P32~*(7) */
21853 { reserved_block , 0 , 0 , 32,
21854 0xfc000000, 0x4c000000, 0 , 0,
21855 0x0 }, /* P32~*(11) */
21856 { reserved_block , 0 , 0 , 32,
21857 0xfc000000, 0x6c000000, 0 , 0,
21858 0x0 }, /* P32~*(15) */
21859 { reserved_block , 0 , 0 , 32,
21860 0xfc000000, 0x8c000000, 0 , 0,
21861 0x0 }, /* P32~*(19) */
21862 { reserved_block , 0 , 0 , 32,
21863 0xfc000000, 0xac000000, 0 , 0,
21864 0x0 }, /* P32~*(23) */
21865 { reserved_block , 0 , 0 , 32,
21866 0xfc000000, 0xcc000000, 0 , 0,
21867 0x0 }, /* P32~*(27) */
21868 { reserved_block , 0 , 0 , 32,
21869 0xfc000000, 0xec000000, 0 , 0,
21870 0x0 }, /* P32~*(31) */
21871 };
21872
21873
21874 NMD::Pool NMD::P16_SYSCALL[2] = {
21875 { instruction , 0 , 0 , 16,
21876 0xfffc , 0x1008 , &NMD::SYSCALL_16_ , 0,
21877 0x0 }, /* SYSCALL[16] */
21878 { instruction , 0 , 0 , 16,
21879 0xfffc , 0x100c , &NMD::HYPCALL_16_ , 0,
21880 CP0_ | VZ_ }, /* HYPCALL[16] */
21881 };
21882
21883
21884 NMD::Pool NMD::P16_RI[4] = {
21885 { reserved_block , 0 , 0 , 16,
21886 0xfff8 , 0x1000 , 0 , 0,
21887 0x0 }, /* P16.RI~*(0) */
21888 { pool , P16_SYSCALL , 2 , 16,
21889 0xfff8 , 0x1008 , 0 , 0,
21890 0x0 }, /* P16.SYSCALL */
21891 { instruction , 0 , 0 , 16,
21892 0xfff8 , 0x1010 , &NMD::BREAK_16_ , 0,
21893 0x0 }, /* BREAK[16] */
21894 { instruction , 0 , 0 , 16,
21895 0xfff8 , 0x1018 , &NMD::SDBBP_16_ , 0,
21896 EJTAG_ }, /* SDBBP[16] */
21897 };
21898
21899
21900 NMD::Pool NMD::P16_MV[2] = {
21901 { pool , P16_RI , 4 , 16,
21902 0xffe0 , 0x1000 , 0 , 0,
21903 0x0 }, /* P16.RI */
21904 { instruction , 0 , 0 , 16,
21905 0xfc00 , 0x1000 , &NMD::MOVE , &NMD::MOVE_cond ,
21906 0x0 }, /* MOVE */
21907 };
21908
21909
21910 NMD::Pool NMD::P16_SHIFT[2] = {
21911 { instruction , 0 , 0 , 16,
21912 0xfc08 , 0x3000 , &NMD::SLL_16_ , 0,
21913 0x0 }, /* SLL[16] */
21914 { instruction , 0 , 0 , 16,
21915 0xfc08 , 0x3008 , &NMD::SRL_16_ , 0,
21916 0x0 }, /* SRL[16] */
21917 };
21918
21919
21920 NMD::Pool NMD::POOL16C_00[4] = {
21921 { instruction , 0 , 0 , 16,
21922 0xfc0f , 0x5000 , &NMD::NOT_16_ , 0,
21923 0x0 }, /* NOT[16] */
21924 { instruction , 0 , 0 , 16,
21925 0xfc0f , 0x5004 , &NMD::XOR_16_ , 0,
21926 0x0 }, /* XOR[16] */
21927 { instruction , 0 , 0 , 16,
21928 0xfc0f , 0x5008 , &NMD::AND_16_ , 0,
21929 0x0 }, /* AND[16] */
21930 { instruction , 0 , 0 , 16,
21931 0xfc0f , 0x500c , &NMD::OR_16_ , 0,
21932 0x0 }, /* OR[16] */
21933 };
21934
21935
21936 NMD::Pool NMD::POOL16C_0[2] = {
21937 { pool , POOL16C_00 , 4 , 16,
21938 0xfc03 , 0x5000 , 0 , 0,
21939 0x0 }, /* POOL16C_00 */
21940 { reserved_block , 0 , 0 , 16,
21941 0xfc03 , 0x5002 , 0 , 0,
21942 0x0 }, /* POOL16C_0~*(1) */
21943 };
21944
21945
21946 NMD::Pool NMD::P16C[2] = {
21947 { pool , POOL16C_0 , 2 , 16,
21948 0xfc01 , 0x5000 , 0 , 0,
21949 0x0 }, /* POOL16C_0 */
21950 { instruction , 0 , 0 , 16,
21951 0xfc01 , 0x5001 , &NMD::LWXS_16_ , 0,
21952 0x0 }, /* LWXS[16] */
21953 };
21954
21955
21956 NMD::Pool NMD::P16_A1[2] = {
21957 { reserved_block , 0 , 0 , 16,
21958 0xfc40 , 0x7000 , 0 , 0,
21959 0x0 }, /* P16.A1~*(0) */
21960 { instruction , 0 , 0 , 16,
21961 0xfc40 , 0x7040 , &NMD::ADDIU_R1_SP_ , 0,
21962 0x0 }, /* ADDIU[R1.SP] */
21963 };
21964
21965
21966 NMD::Pool NMD::P_ADDIU_RS5_[2] = {
21967 { instruction , 0 , 0 , 16,
21968 0xffe8 , 0x9008 , &NMD::NOP_16_ , 0,
21969 0x0 }, /* NOP[16] */
21970 { instruction , 0 , 0 , 16,
21971 0xfc08 , 0x9008 , &NMD::ADDIU_RS5_ , &NMD::ADDIU_RS5__cond ,
21972 0x0 }, /* ADDIU[RS5] */
21973 };
21974
21975
21976 NMD::Pool NMD::P16_A2[2] = {
21977 { instruction , 0 , 0 , 16,
21978 0xfc08 , 0x9000 , &NMD::ADDIU_R2_ , 0,
21979 0x0 }, /* ADDIU[R2] */
21980 { pool , P_ADDIU_RS5_ , 2 , 16,
21981 0xfc08 , 0x9008 , 0 , 0,
21982 0x0 }, /* P.ADDIU[RS5] */
21983 };
21984
21985
21986 NMD::Pool NMD::P16_ADDU[2] = {
21987 { instruction , 0 , 0 , 16,
21988 0xfc01 , 0xb000 , &NMD::ADDU_16_ , 0,
21989 0x0 }, /* ADDU[16] */
21990 { instruction , 0 , 0 , 16,
21991 0xfc01 , 0xb001 , &NMD::SUBU_16_ , 0,
21992 0x0 }, /* SUBU[16] */
21993 };
21994
21995
21996 NMD::Pool NMD::P16_JRC[2] = {
21997 { branch_instruction , 0 , 0 , 16,
21998 0xfc1f , 0xd800 , &NMD::JRC , 0,
21999 0x0 }, /* JRC */
22000 { call_instruction , 0 , 0 , 16,
22001 0xfc1f , 0xd810 , &NMD::JALRC_16_ , 0,
22002 0x0 }, /* JALRC[16] */
22003 };
22004
22005
22006 NMD::Pool NMD::P16_BR1[2] = {
22007 { branch_instruction , 0 , 0 , 16,
22008 0xfc00 , 0xd800 , &NMD::BEQC_16_ , &NMD::BEQC_16__cond ,
22009 XMMS_ }, /* BEQC[16] */
22010 { branch_instruction , 0 , 0 , 16,
22011 0xfc00 , 0xd800 , &NMD::BNEC_16_ , &NMD::BNEC_16__cond ,
22012 XMMS_ }, /* BNEC[16] */
22013 };
22014
22015
22016 NMD::Pool NMD::P16_BR[2] = {
22017 { pool , P16_JRC , 2 , 16,
22018 0xfc0f , 0xd800 , 0 , 0,
22019 0x0 }, /* P16.JRC */
22020 { pool , P16_BR1 , 2 , 16,
22021 0xfc00 , 0xd800 , 0 , &NMD::P16_BR1_cond ,
22022 0x0 }, /* P16.BR1 */
22023 };
22024
22025
22026 NMD::Pool NMD::P16_SR[2] = {
22027 { instruction , 0 , 0 , 16,
22028 0xfd00 , 0x1c00 , &NMD::SAVE_16_ , 0,
22029 0x0 }, /* SAVE[16] */
22030 { return_instruction , 0 , 0 , 16,
22031 0xfd00 , 0x1d00 , &NMD::RESTORE_JRC_16_ , 0,
22032 0x0 }, /* RESTORE.JRC[16] */
22033 };
22034
22035
22036 NMD::Pool NMD::P16_4X4[4] = {
22037 { instruction , 0 , 0 , 16,
22038 0xfd08 , 0x3c00 , &NMD::ADDU_4X4_ , 0,
22039 XMMS_ }, /* ADDU[4X4] */
22040 { instruction , 0 , 0 , 16,
22041 0xfd08 , 0x3c08 , &NMD::MUL_4X4_ , 0,
22042 XMMS_ }, /* MUL[4X4] */
22043 { reserved_block , 0 , 0 , 16,
22044 0xfd08 , 0x3d00 , 0 , 0,
22045 0x0 }, /* P16.4X4~*(2) */
22046 { reserved_block , 0 , 0 , 16,
22047 0xfd08 , 0x3d08 , 0 , 0,
22048 0x0 }, /* P16.4X4~*(3) */
22049 };
22050
22051
22052 NMD::Pool NMD::P16_LB[4] = {
22053 { instruction , 0 , 0 , 16,
22054 0xfc0c , 0x5c00 , &NMD::LB_16_ , 0,
22055 0x0 }, /* LB[16] */
22056 { instruction , 0 , 0 , 16,
22057 0xfc0c , 0x5c04 , &NMD::SB_16_ , 0,
22058 0x0 }, /* SB[16] */
22059 { instruction , 0 , 0 , 16,
22060 0xfc0c , 0x5c08 , &NMD::LBU_16_ , 0,
22061 0x0 }, /* LBU[16] */
22062 { reserved_block , 0 , 0 , 16,
22063 0xfc0c , 0x5c0c , 0 , 0,
22064 0x0 }, /* P16.LB~*(3) */
22065 };
22066
22067
22068 NMD::Pool NMD::P16_LH[4] = {
22069 { instruction , 0 , 0 , 16,
22070 0xfc09 , 0x7c00 , &NMD::LH_16_ , 0,
22071 0x0 }, /* LH[16] */
22072 { instruction , 0 , 0 , 16,
22073 0xfc09 , 0x7c01 , &NMD::SH_16_ , 0,
22074 0x0 }, /* SH[16] */
22075 { instruction , 0 , 0 , 16,
22076 0xfc09 , 0x7c08 , &NMD::LHU_16_ , 0,
22077 0x0 }, /* LHU[16] */
22078 { reserved_block , 0 , 0 , 16,
22079 0xfc09 , 0x7c09 , 0 , 0,
22080 0x0 }, /* P16.LH~*(3) */
22081 };
22082
22083
22084 NMD::Pool NMD::P16[32] = {
22085 { pool , P16_MV , 2 , 16,
22086 0xfc00 , 0x1000 , 0 , 0,
22087 0x0 }, /* P16.MV */
22088 { pool , P16_SHIFT , 2 , 16,
22089 0xfc00 , 0x3000 , 0 , 0,
22090 0x0 }, /* P16.SHIFT */
22091 { pool , P16C , 2 , 16,
22092 0xfc00 , 0x5000 , 0 , 0,
22093 0x0 }, /* P16C */
22094 { pool , P16_A1 , 2 , 16,
22095 0xfc00 , 0x7000 , 0 , 0,
22096 0x0 }, /* P16.A1 */
22097 { pool , P16_A2 , 2 , 16,
22098 0xfc00 , 0x9000 , 0 , 0,
22099 0x0 }, /* P16.A2 */
22100 { pool , P16_ADDU , 2 , 16,
22101 0xfc00 , 0xb000 , 0 , 0,
22102 0x0 }, /* P16.ADDU */
22103 { instruction , 0 , 0 , 16,
22104 0xfc00 , 0xd000 , &NMD::LI_16_ , 0,
22105 0x0 }, /* LI[16] */
22106 { instruction , 0 , 0 , 16,
22107 0xfc00 , 0xf000 , &NMD::ANDI_16_ , 0,
22108 0x0 }, /* ANDI[16] */
22109 { instruction , 0 , 0 , 16,
22110 0xfc00 , 0x1400 , &NMD::LW_16_ , 0,
22111 0x0 }, /* LW[16] */
22112 { instruction , 0 , 0 , 16,
22113 0xfc00 , 0x3400 , &NMD::LW_SP_ , 0,
22114 0x0 }, /* LW[SP] */
22115 { instruction , 0 , 0 , 16,
22116 0xfc00 , 0x5400 , &NMD::LW_GP16_ , 0,
22117 0x0 }, /* LW[GP16] */
22118 { instruction , 0 , 0 , 16,
22119 0xfc00 , 0x7400 , &NMD::LW_4X4_ , 0,
22120 XMMS_ }, /* LW[4X4] */
22121 { instruction , 0 , 0 , 16,
22122 0xfc00 , 0x9400 , &NMD::SW_16_ , 0,
22123 0x0 }, /* SW[16] */
22124 { instruction , 0 , 0 , 16,
22125 0xfc00 , 0xb400 , &NMD::SW_SP_ , 0,
22126 0x0 }, /* SW[SP] */
22127 { instruction , 0 , 0 , 16,
22128 0xfc00 , 0xd400 , &NMD::SW_GP16_ , 0,
22129 0x0 }, /* SW[GP16] */
22130 { instruction , 0 , 0 , 16,
22131 0xfc00 , 0xf400 , &NMD::SW_4X4_ , 0,
22132 XMMS_ }, /* SW[4X4] */
22133 { branch_instruction , 0 , 0 , 16,
22134 0xfc00 , 0x1800 , &NMD::BC_16_ , 0,
22135 0x0 }, /* BC[16] */
22136 { call_instruction , 0 , 0 , 16,
22137 0xfc00 , 0x3800 , &NMD::BALC_16_ , 0,
22138 0x0 }, /* BALC[16] */
22139 { reserved_block , 0 , 0 , 16,
22140 0xfc00 , 0x5800 , 0 , 0,
22141 0x0 }, /* P16~*(10) */
22142 { reserved_block , 0 , 0 , 16,
22143 0xfc00 , 0x7800 , 0 , 0,
22144 0x0 }, /* P16~*(14) */
22145 { branch_instruction , 0 , 0 , 16,
22146 0xfc00 , 0x9800 , &NMD::BEQZC_16_ , 0,
22147 0x0 }, /* BEQZC[16] */
22148 { branch_instruction , 0 , 0 , 16,
22149 0xfc00 , 0xb800 , &NMD::BNEZC_16_ , 0,
22150 0x0 }, /* BNEZC[16] */
22151 { pool , P16_BR , 2 , 16,
22152 0xfc00 , 0xd800 , 0 , 0,
22153 0x0 }, /* P16.BR */
22154 { reserved_block , 0 , 0 , 16,
22155 0xfc00 , 0xf800 , 0 , 0,
22156 0x0 }, /* P16~*(30) */
22157 { pool , P16_SR , 2 , 16,
22158 0xfc00 , 0x1c00 , 0 , 0,
22159 0x0 }, /* P16.SR */
22160 { pool , P16_4X4 , 4 , 16,
22161 0xfc00 , 0x3c00 , 0 , 0,
22162 0x0 }, /* P16.4X4 */
22163 { pool , P16_LB , 4 , 16,
22164 0xfc00 , 0x5c00 , 0 , 0,
22165 0x0 }, /* P16.LB */
22166 { pool , P16_LH , 4 , 16,
22167 0xfc00 , 0x7c00 , 0 , 0,
22168 0x0 }, /* P16.LH */
22169 { reserved_block , 0 , 0 , 16,
22170 0xfc00 , 0x9c00 , 0 , 0,
22171 0x0 }, /* P16~*(19) */
22172 { instruction , 0 , 0 , 16,
22173 0xfc00 , 0xbc00 , &NMD::MOVEP , 0,
22174 XMMS_ }, /* MOVEP */
22175 { reserved_block , 0 , 0 , 16,
22176 0xfc00 , 0xdc00 , 0 , 0,
22177 0x0 }, /* P16~*(27) */
22178 { instruction , 0 , 0 , 16,
22179 0xfc00 , 0xfc00 , &NMD::MOVEP_REV_ , 0,
22180 XMMS_ }, /* MOVEP[REV] */
22181 };
22182
22183
22184 NMD::Pool NMD::MAJOR[2] = {
22185 { pool , P32 , 32 , 32,
22186 0x10000000, 0x00000000, 0 , 0,
22187 0x0 }, /* P32 */
22188 { pool , P16 , 32 , 16,
22189 0x1000 , 0x1000 , 0 , 0,
22190 0x0 }, /* P16 */
22191 };
Random patches