]> git.proxmox.com Git - mirror_qemu.git/blob - disas/nanomips.cpp
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
disas: nanoMIPS: Comment the decoder of 'gpr1' gpr encoding type
[mirror_qemu.git] / disas / nanomips.cpp
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 /*
393 * NMD::decode_gpr_gpr1() - decoder for 'gpr1' gpr encoding type
394 *
395 * Map a 1-bit code to the 5-bit register space according to this pattern:
396 *
397 * 1 0
398 * | |
399 * | |
400 * | └---------------------┐
401 * └---------------------┐ |
402 * | |
403 * | |
404 * | |
405 * | |
406 * 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
407 * 3 2 1 0
408 *
409 * Used in handling following instruction:
410 *
411 * - MOVE.BALC
412 */
413 uint64 NMD::decode_gpr_gpr1(uint64 d)
414 {
415 static uint64 register_list[] = { 4, 5 };
416 return renumber_registers(d, register_list,
417 sizeof(register_list) / sizeof(register_list[0]));
418 }
419
420
421 /*
422 * NMD::decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
423 *
424 * Map a 4-bit code to the 5-bit register space according to this pattern:
425 *
426 * 1 0
427 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
428 * | | | | | | | | | | | | | | | |
429 * | | | | | | | | | | | | └---------------------┐
430 * | | | | | | | | | | | └---------------┐ |
431 * | | | | | | | | | | └---------------┐ | |
432 * | | | | | | | | | └---------------┐ | | |
433 * | | | | | | | | └---------------┐ | | | |
434 * | | | | | | | | | | | | | | | |
435 * | | | | | | | | | | | | | | | |
436 * 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
437 * 3 2 1 0
438 *
439 * This pattern is the same one used for 'gpr4' gpr encoding type, except for
440 * the input value 3, that is mapped to the output value 0 instead of 11.
441 *
442 * Used in handling following instructions:
443 *
444 * - MOVE.BALC
445 * - MOVEP
446 * - SW[4X4]
447 */
448 uint64 NMD::decode_gpr_gpr4_zero(uint64 d)
449 {
450 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
451 16, 17, 18, 19, 20, 21, 22, 23 };
452 return renumber_registers(d, register_list,
453 sizeof(register_list) / sizeof(register_list[0]));
454 }
455
456
457 /*
458 * NMD::decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
459 *
460 * Map a 4-bit code to the 5-bit register space according to this pattern:
461 *
462 * 1 0
463 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
464 * | | | | | | | | | | | | | | | |
465 * | | | | | | | | | | | | | | | |
466 * | | | | | | | | | | | └---------------┐
467 * | | | | | | | | | | └---------------┐ |
468 * | | | | | | | | | └---------------┐ | |
469 * | | | | | | | | └---------------┐ | | |
470 * | | | | | | | | | | | | | | | |
471 * | | | | | | | | | | | | | | | |
472 * 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
473 * 3 2 1 0
474 *
475 * Used in handling following instructions:
476 *
477 * - ADDU[4X4]
478 * - LW[4X4]
479 * - MOVEP[REV]
480 * - MUL[4X4]
481 * - SW[4X4]
482 */
483 uint64 NMD::decode_gpr_gpr4(uint64 d)
484 {
485 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
486 16, 17, 18, 19, 20, 21, 22, 23 };
487 return renumber_registers(d, register_list,
488 sizeof(register_list) / sizeof(register_list[0]));
489 }
490
491
492 /*
493 * NMD::decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
494 *
495 * Map a 2-bit code to the 5-bit register space according to this pattern:
496 *
497 * 3 2 1 0
498 * | | | |
499 * | | | |
500 * | | | └-------------------┐
501 * | | └-------------------┐ |
502 * | └-------------------┐ | |
503 * └-------------------┐ | | |
504 * | | | |
505 * | | | |
506 * 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
507 * 3 2 1 0
508 *
509 * Used in handling following instructions:
510 *
511 * - MOVEP
512 * - MOVEP[REV]
513 */
514 uint64 NMD::decode_gpr_gpr2_reg1(uint64 d)
515 {
516 static uint64 register_list[] = { 4, 5, 6, 7 };
517 return renumber_registers(d, register_list,
518 sizeof(register_list) / sizeof(register_list[0]));
519 }
520
521
522 /*
523 * NMD::decode_gpr_gpr2_reg2() - decoder for 'gpr2.reg2' gpr encoding type
524 *
525 * Map a 2-bit code to the 5-bit register space according to this pattern:
526 *
527 * 3 2 1 0
528 * | | | |
529 * | | | |
530 * | | | └-----------------┐
531 * | | └-----------------┐ |
532 * | └-----------------┐ | |
533 * └-----------------┐ | | |
534 * | | | |
535 * | | | |
536 * 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
537 * 3 2 1 0
538 *
539 * Used in handling following instructions:
540 *
541 * - MOVEP
542 * - MOVEP[REV]
543 */
544 uint64 NMD::decode_gpr_gpr2_reg2(uint64 d)
545 {
546 static uint64 register_list[] = { 5, 6, 7, 8 };
547 return renumber_registers(d, register_list,
548 sizeof(register_list) / sizeof(register_list[0]));
549 }
550
551
552 uint64 NMD::copy(uint64 d)
553 {
554 return d;
555 }
556
557
558 int64 NMD::copy(int64 d)
559 {
560 return d;
561 }
562
563
564 int64 NMD::neg_copy(uint64 d)
565 {
566 return 0ll - d;
567 }
568
569
570 int64 NMD::neg_copy(int64 d)
571 {
572 return -d;
573 }
574
575
576 /* strange wrapper around gpr3 */
577 uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
578 {
579 return decode_gpr_gpr3(d);
580 }
581
582
583 /* strange wrapper around gpr3 */
584 uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
585 {
586 return decode_gpr_gpr3(d);
587 }
588
589
590 /* nop - done by extraction function */
591 uint64 NMD::encode_s_from_address(uint64 d)
592 {
593 return d;
594 }
595
596
597 /* nop - done by extraction function */
598 uint64 NMD::encode_u_from_address(uint64 d)
599 {
600 return d;
601 }
602
603
604 /* nop - done by extraction function */
605 uint64 NMD::encode_s_from_s_hi(uint64 d)
606 {
607 return d;
608 }
609
610
611 uint64 NMD::encode_count3_from_count(uint64 d)
612 {
613 IMGASSERTONCE(d < 8);
614 return d == 0ull ? 8ull : d;
615 }
616
617
618 uint64 NMD::encode_shift3_from_shift(uint64 d)
619 {
620 IMGASSERTONCE(d < 8);
621 return d == 0ull ? 8ull : d;
622 }
623
624
625 /* special value for load literal */
626 int64 NMD::encode_eu_from_s_li16(uint64 d)
627 {
628 IMGASSERTONCE(d < 128);
629 return d == 127 ? -1 : (int64)d;
630 }
631
632
633 uint64 NMD::encode_msbd_from_size(uint64 d)
634 {
635 IMGASSERTONCE(d < 32);
636 return d + 1;
637 }
638
639
640 uint64 NMD::encode_eu_from_u_andi16(uint64 d)
641 {
642 IMGASSERTONCE(d < 16);
643 if (d == 12) {
644 return 0x00ffull;
645 }
646 if (d == 13) {
647 return 0xffffull;
648 }
649 return d;
650 }
651
652
653 uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
654 {
655 IMGASSERTONCE(0);
656 return d;
657 }
658
659
660 /* save16 / restore16 ???? */
661 uint64 NMD::encode_rt1_from_rt(uint64 d)
662 {
663 return d ? 31 : 30;
664 }
665
666
667 /* ? */
668 uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
669 {
670 return d;
671 }
672
673
674 std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
675 {
676 std::string str;
677
678 for (uint64 counter = 0; counter != count; counter++) {
679 bool use_gp = gp && (counter == count - 1);
680 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
681 str += img::format(",%s", GPR(this_rt));
682 }
683
684 return str;
685 }
686
687
688 std::string NMD::GPR(uint64 reg)
689 {
690 static const char *gpr_reg[32] = {
691 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
692 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
693 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
694 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
695 };
696
697 if (reg < 32) {
698 return gpr_reg[reg];
699 }
700
701 throw std::runtime_error(img::format("Invalid GPR register index %" PRIu64,
702 reg));
703 }
704
705
706 std::string NMD::FPR(uint64 reg)
707 {
708 static const char *fpr_reg[32] = {
709 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
710 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
711 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
712 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
713 };
714
715 if (reg < 32) {
716 return fpr_reg[reg];
717 }
718
719 throw std::runtime_error(img::format("Invalid FPR register index %" PRIu64,
720 reg));
721 }
722
723
724 std::string NMD::AC(uint64 reg)
725 {
726 static const char *ac_reg[4] = {
727 "ac0", "ac1", "ac2", "ac3"
728 };
729
730 if (reg < 4) {
731 return ac_reg[reg];
732 }
733
734 throw std::runtime_error(img::format("Invalid AC register index %" PRIu64,
735 reg));
736 }
737
738
739 std::string NMD::IMMEDIATE(uint64 value)
740 {
741 return img::format("0x%" PRIx64, value);
742 }
743
744
745 std::string NMD::IMMEDIATE(int64 value)
746 {
747 return img::format("%" PRId64, value);
748 }
749
750
751 std::string NMD::CPR(uint64 reg)
752 {
753 /* needs more work */
754 return img::format("CP%" PRIu64, reg);
755 }
756
757
758 std::string NMD::ADDRESS(uint64 value, int instruction_size)
759 {
760 /* token for string replace */
761 /* const char TOKEN_REPLACE = (char)0xa2; */
762 img::address address = m_pc + value + instruction_size;
763 /* symbol replacement */
764 /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
765 return to_string(address);
766 }
767
768
769 uint64 NMD::extract_op_code_value(const uint16 * data, int size)
770 {
771 switch (size) {
772 case 16:
773 return data[0];
774 case 32:
775 return ((uint64)data[0] << 16) | data[1];
776 case 48:
777 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
778 default:
779 return data[0];
780 }
781 }
782
783
784 int NMD::Disassemble(const uint16 * data, std::string & dis,
785 NMD::TABLE_ENTRY_TYPE & type)
786 {
787 return Disassemble(data, dis, type, MAJOR, 2);
788 }
789
790
791 /*
792 * Recurse through tables until the instruction is found then return
793 * the string and size
794 *
795 * inputs:
796 * pointer to a word stream,
797 * disassember table and size
798 * returns:
799 * instruction size - negative is error
800 * disassembly string - on error will constain error string
801 */
802 int NMD::Disassemble(const uint16 * data, std::string & dis,
803 NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
804 int table_size)
805 {
806 try
807 {
808 for (int i = 0; i < table_size; i++) {
809 uint64 op_code = extract_op_code_value(data,
810 table[i].instructions_size);
811 if ((op_code & table[i].mask) == table[i].value) {
812 /* possible match */
813 conditional_function cond = table[i].condition;
814 if ((cond == 0) || (this->*cond)(op_code)) {
815 try
816 {
817 if (table[i].type == pool) {
818 return Disassemble(data, dis, type,
819 table[i].next_table,
820 table[i].next_table_size);
821 } else if ((table[i].type == instruction) ||
822 (table[i].type == call_instruction) ||
823 (table[i].type == branch_instruction) ||
824 (table[i].type == return_instruction)) {
825 if ((table[i].attributes != 0) &&
826 (m_requested_instruction_categories &
827 table[i].attributes) == 0) {
828 /*
829 * failed due to instruction having
830 * an ASE attribute and the requested version
831 * not having that attribute
832 */
833 dis = "ASE attribute missmatch";
834 return -5;
835 }
836 disassembly_function dis_fn = table[i].disassembly;
837 if (dis_fn == 0) {
838 dis = "disassembler failure - bad table entry";
839 return -6;
840 }
841 type = table[i].type;
842 dis = (this->*dis_fn)(op_code);
843 return table[i].instructions_size;
844 } else {
845 dis = "reserved instruction";
846 return -2;
847 }
848 }
849 catch (std::runtime_error & e)
850 {
851 dis = e.what();
852 return -3; /* runtime error */
853 }
854 }
855 }
856 }
857 }
858 catch (std::exception & e)
859 {
860 dis = e.what();
861 return -4; /* runtime error */
862 }
863
864 dis = "failed to disassemble";
865 return -1; /* failed to disassemble */
866 }
867
868
869 uint64 NMD::extract_code_18_to_0(uint64 instruction)
870 {
871 uint64 value = 0;
872 value |= extract_bits(instruction, 0, 19);
873 return value;
874 }
875
876
877 uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
878 {
879 uint64 value = 0;
880 value |= extract_bits(instruction, 0, 3);
881 return value;
882 }
883
884
885 uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
886 {
887 uint64 value = 0;
888 value |= extract_bits(instruction, 3, 9) << 3;
889 return value;
890 }
891
892
893 uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
894 {
895 uint64 value = 0;
896 value |= extract_bits(instruction, 0, 4);
897 return value;
898 }
899
900
901 uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
902 {
903 uint64 value = 0;
904 value |= extract_bits(instruction, 7, 3);
905 return value;
906 }
907
908
909 uint64 NMD::extract_u_17_to_1__s1(uint64 instruction)
910 {
911 uint64 value = 0;
912 value |= extract_bits(instruction, 1, 17) << 1;
913 return value;
914 }
915
916
917 int64 NMD::extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
918 {
919 int64 value = 0;
920 value |= extract_bits(instruction, 11, 10);
921 value = sign_extend(value, 9);
922 return value;
923 }
924
925
926 int64 NMD::extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
927 {
928 int64 value = 0;
929 value |= extract_bits(instruction, 0, 1) << 11;
930 value |= extract_bits(instruction, 1, 10) << 1;
931 value = sign_extend(value, 11);
932 return value;
933 }
934
935
936 uint64 NMD::extract_u_10(uint64 instruction)
937 {
938 uint64 value = 0;
939 value |= extract_bits(instruction, 10, 1);
940 return value;
941 }
942
943
944 uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
945 {
946 uint64 value = 0;
947 value |= extract_bits(instruction, 21, 3);
948 value |= extract_bits(instruction, 25, 1) << 3;
949 return value;
950 }
951
952
953 uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
954 {
955 uint64 value = 0;
956 value |= extract_bits(instruction, 11, 5);
957 return value;
958 }
959
960
961 uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
962 {
963 uint64 value = 0;
964 value |= extract_bits(instruction, 0, 5);
965 return value;
966 }
967
968
969 uint64 NMD::extract_shiftx_10_9_8_7__s1(uint64 instruction)
970 {
971 uint64 value = 0;
972 value |= extract_bits(instruction, 7, 4) << 1;
973 return value;
974 }
975
976
977 uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
978 {
979 uint64 value = 0;
980 value |= extract_bits(instruction, 21, 5);
981 return value;
982 }
983
984
985 uint64 NMD::extract_count3_14_13_12(uint64 instruction)
986 {
987 uint64 value = 0;
988 value |= extract_bits(instruction, 12, 3);
989 return value;
990 }
991
992
993 int64 NMD::extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
994 {
995 int64 value = 0;
996 value |= extract_bits(instruction, 0, 1) << 31;
997 value |= extract_bits(instruction, 2, 10) << 21;
998 value |= extract_bits(instruction, 12, 9) << 12;
999 value = sign_extend(value, 31);
1000 return value;
1001 }
1002
1003
1004 int64 NMD::extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
1005 {
1006 int64 value = 0;
1007 value |= extract_bits(instruction, 0, 1) << 7;
1008 value |= extract_bits(instruction, 1, 6) << 1;
1009 value = sign_extend(value, 7);
1010 return value;
1011 }
1012
1013
1014 uint64 NMD::extract_u2_10_9(uint64 instruction)
1015 {
1016 uint64 value = 0;
1017 value |= extract_bits(instruction, 9, 2);
1018 return value;
1019 }
1020
1021
1022 uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
1023 {
1024 uint64 value = 0;
1025 value |= extract_bits(instruction, 16, 10);
1026 return value;
1027 }
1028
1029
1030 uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
1031 {
1032 uint64 value = 0;
1033 value |= extract_bits(instruction, 16, 5);
1034 return value;
1035 }
1036
1037
1038 uint64 NMD::extract_u_2_1__s1(uint64 instruction)
1039 {
1040 uint64 value = 0;
1041 value |= extract_bits(instruction, 1, 2) << 1;
1042 return value;
1043 }
1044
1045
1046 uint64 NMD::extract_stripe_6(uint64 instruction)
1047 {
1048 uint64 value = 0;
1049 value |= extract_bits(instruction, 6, 1);
1050 return value;
1051 }
1052
1053
1054 uint64 NMD::extract_ac_13_12(uint64 instruction)
1055 {
1056 uint64 value = 0;
1057 value |= extract_bits(instruction, 14, 2);
1058 return value;
1059 }
1060
1061
1062 uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
1063 {
1064 uint64 value = 0;
1065 value |= extract_bits(instruction, 16, 5);
1066 return value;
1067 }
1068
1069
1070 uint64 NMD::extract_rdl_25_24(uint64 instruction)
1071 {
1072 uint64 value = 0;
1073 value |= extract_bits(instruction, 24, 1);
1074 return value;
1075 }
1076
1077
1078 int64 NMD::extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
1079 {
1080 int64 value = 0;
1081 value |= extract_bits(instruction, 0, 1) << 10;
1082 value |= extract_bits(instruction, 1, 9) << 1;
1083 value = sign_extend(value, 10);
1084 return value;
1085 }
1086
1087
1088 uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
1089 {
1090 uint64 value = 0;
1091 value |= extract_bits(instruction, 0, 7);
1092 return value;
1093 }
1094
1095
1096 uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
1097 {
1098 uint64 value = 0;
1099 value |= extract_bits(instruction, 0, 6);
1100 return value;
1101 }
1102
1103
1104 uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
1105 {
1106 uint64 value = 0;
1107 value |= extract_bits(instruction, 16, 4);
1108 return value;
1109 }
1110
1111
1112 uint64 NMD::extract_code_2_1_0(uint64 instruction)
1113 {
1114 uint64 value = 0;
1115 value |= extract_bits(instruction, 0, 3);
1116 return value;
1117 }
1118
1119
1120 uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
1121 {
1122 uint64 value = 0;
1123 value |= extract_bits(instruction, 0, 12);
1124 return value;
1125 }
1126
1127
1128 uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
1129 {
1130 uint64 value = 0;
1131 value |= extract_bits(instruction, 0, 5);
1132 return value;
1133 }
1134
1135
1136 uint64 NMD::extract_u_20_to_3__s3(uint64 instruction)
1137 {
1138 uint64 value = 0;
1139 value |= extract_bits(instruction, 3, 18) << 3;
1140 return value;
1141 }
1142
1143
1144 uint64 NMD::extract_u_3_2_1_0__s2(uint64 instruction)
1145 {
1146 uint64 value = 0;
1147 value |= extract_bits(instruction, 0, 4) << 2;
1148 return value;
1149 }
1150
1151
1152 uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
1153 {
1154 uint64 value = 0;
1155 value |= extract_bits(instruction, 3, 23);
1156 return value;
1157 }
1158
1159
1160 uint64 NMD::extract_u_2_1_0__s2(uint64 instruction)
1161 {
1162 uint64 value = 0;
1163 value |= extract_bits(instruction, 0, 3) << 2;
1164 return value;
1165 }
1166
1167
1168 uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
1169 {
1170 uint64 value = 0;
1171 value |= extract_bits(instruction, 1, 3);
1172 return value;
1173 }
1174
1175
1176 uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
1177 {
1178 uint64 value = 0;
1179 value |= extract_bits(instruction, 12, 4);
1180 return value;
1181 }
1182
1183
1184 uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
1185 {
1186 uint64 value = 0;
1187 value |= extract_bits(instruction, 21, 5);
1188 return value;
1189 }
1190
1191
1192 uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
1193 {
1194 uint64 value = 0;
1195 value |= extract_bits(instruction, 3, 5);
1196 return value;
1197 }
1198
1199
1200 uint64 NMD::extract_u_17_to_0(uint64 instruction)
1201 {
1202 uint64 value = 0;
1203 value |= extract_bits(instruction, 0, 18);
1204 return value;
1205 }
1206
1207
1208 uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
1209 {
1210 uint64 value = 0;
1211 value |= extract_bits(instruction, 0, 3);
1212 value |= extract_bits(instruction, 4, 1) << 3;
1213 return value;
1214 }
1215
1216
1217 int64 NMD::extract_s__se21_0_20_to_1_s1(uint64 instruction)
1218 {
1219 int64 value = 0;
1220 value |= extract_bits(instruction, 0, 1) << 21;
1221 value |= extract_bits(instruction, 1, 20) << 1;
1222 value = sign_extend(value, 21);
1223 return value;
1224 }
1225
1226
1227 uint64 NMD::extract_op_25_to_3(uint64 instruction)
1228 {
1229 uint64 value = 0;
1230 value |= extract_bits(instruction, 3, 23);
1231 return value;
1232 }
1233
1234
1235 uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
1236 {
1237 uint64 value = 0;
1238 value |= extract_bits(instruction, 0, 3);
1239 value |= extract_bits(instruction, 4, 1) << 3;
1240 return value;
1241 }
1242
1243
1244 uint64 NMD::extract_bit_23_22_21(uint64 instruction)
1245 {
1246 uint64 value = 0;
1247 value |= extract_bits(instruction, 21, 3);
1248 return value;
1249 }
1250
1251
1252 uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
1253 {
1254 uint64 value = 0;
1255 value |= extract_bits(instruction, 37, 5);
1256 return value;
1257 }
1258
1259
1260 int64 NMD::extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
1261 {
1262 int64 value = 0;
1263 value |= extract_bits(instruction, 16, 6);
1264 value = sign_extend(value, 5);
1265 return value;
1266 }
1267
1268
1269 uint64 NMD::extract_rd2_3_8(uint64 instruction)
1270 {
1271 uint64 value = 0;
1272 value |= extract_bits(instruction, 3, 1) << 1;
1273 value |= extract_bits(instruction, 8, 1);
1274 return value;
1275 }
1276
1277
1278 uint64 NMD::extract_code_17_to_0(uint64 instruction)
1279 {
1280 uint64 value = 0;
1281 value |= extract_bits(instruction, 0, 18);
1282 return value;
1283 }
1284
1285
1286 uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
1287 {
1288 uint64 value = 0;
1289 value |= extract_bits(instruction, 16, 5);
1290 return value;
1291 }
1292
1293
1294 int64 NMD::extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
1295 {
1296 int64 value = 0;
1297 value |= extract_bits(instruction, 2, 6) << 2;
1298 value |= extract_bits(instruction, 15, 1) << 8;
1299 value = sign_extend(value, 8);
1300 return value;
1301 }
1302
1303
1304 uint64 NMD::extract_u_15_to_0(uint64 instruction)
1305 {
1306 uint64 value = 0;
1307 value |= extract_bits(instruction, 0, 16);
1308 return value;
1309 }
1310
1311
1312 uint64 NMD::extract_fs_20_19_18_17_16(uint64 instruction)
1313 {
1314 uint64 value = 0;
1315 value |= extract_bits(instruction, 16, 5);
1316 return value;
1317 }
1318
1319
1320 int64 NMD::extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
1321 {
1322 int64 value = 0;
1323 value |= extract_bits(instruction, 0, 8);
1324 value |= extract_bits(instruction, 15, 1) << 8;
1325 value = sign_extend(value, 8);
1326 return value;
1327 }
1328
1329
1330 uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
1331 {
1332 uint64 value = 0;
1333 value |= extract_bits(instruction, 16, 5);
1334 return value;
1335 }
1336
1337
1338 uint64 NMD::extract_rtl_11(uint64 instruction)
1339 {
1340 uint64 value = 0;
1341 value |= extract_bits(instruction, 9, 1);
1342 return value;
1343 }
1344
1345
1346 uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
1347 {
1348 uint64 value = 0;
1349 value |= extract_bits(instruction, 16, 5);
1350 return value;
1351 }
1352
1353
1354 uint64 NMD::extract_sel_13_12_11(uint64 instruction)
1355 {
1356 uint64 value = 0;
1357 value |= extract_bits(instruction, 11, 3);
1358 return value;
1359 }
1360
1361
1362 uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
1363 {
1364 uint64 value = 0;
1365 value |= extract_bits(instruction, 0, 5);
1366 return value;
1367 }
1368
1369
1370 uint64 NMD::extract_gp_2(uint64 instruction)
1371 {
1372 uint64 value = 0;
1373 value |= extract_bits(instruction, 2, 1);
1374 return value;
1375 }
1376
1377
1378 uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
1379 {
1380 uint64 value = 0;
1381 value |= extract_bits(instruction, 7, 3);
1382 return value;
1383 }
1384
1385
1386 uint64 NMD::extract_ft_25_24_23_22_21(uint64 instruction)
1387 {
1388 uint64 value = 0;
1389 value |= extract_bits(instruction, 21, 5);
1390 return value;
1391 }
1392
1393
1394 uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
1395 {
1396 uint64 value = 0;
1397 value |= extract_bits(instruction, 11, 7);
1398 return value;
1399 }
1400
1401
1402 uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
1403 {
1404 uint64 value = 0;
1405 value |= extract_bits(instruction, 16, 5);
1406 return value;
1407 }
1408
1409
1410 uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
1411 {
1412 uint64 value = 0;
1413 value |= extract_bits(instruction, 5, 3);
1414 value |= extract_bits(instruction, 9, 1) << 3;
1415 return value;
1416 }
1417
1418
1419 uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
1420 {
1421 uint64 value = 0;
1422 value |= extract_bits(instruction, 6, 5);
1423 return value;
1424 }
1425
1426
1427 uint64 NMD::extract_u_5_4_3_2_1_0__s2(uint64 instruction)
1428 {
1429 uint64 value = 0;
1430 value |= extract_bits(instruction, 0, 6) << 2;
1431 return value;
1432 }
1433
1434
1435 uint64 NMD::extract_sa_15_14_13(uint64 instruction)
1436 {
1437 uint64 value = 0;
1438 value |= extract_bits(instruction, 13, 3);
1439 return value;
1440 }
1441
1442
1443 int64 NMD::extract_s__se14_0_13_to_1_s1(uint64 instruction)
1444 {
1445 int64 value = 0;
1446 value |= extract_bits(instruction, 0, 1) << 14;
1447 value |= extract_bits(instruction, 1, 13) << 1;
1448 value = sign_extend(value, 14);
1449 return value;
1450 }
1451
1452
1453 uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
1454 {
1455 uint64 value = 0;
1456 value |= extract_bits(instruction, 4, 3);
1457 return value;
1458 }
1459
1460
1461 uint64 NMD::extract_u_31_to_0__s32(uint64 instruction)
1462 {
1463 uint64 value = 0;
1464 value |= extract_bits(instruction, 0, 32) << 32;
1465 return value;
1466 }
1467
1468
1469 uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
1470 {
1471 uint64 value = 0;
1472 value |= extract_bits(instruction, 6, 5);
1473 return value;
1474 }
1475
1476
1477 uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
1478 {
1479 uint64 value = 0;
1480 value |= extract_bits(instruction, 21, 5);
1481 return value;
1482 }
1483
1484
1485 uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1486 {
1487 uint64 value = 0;
1488 value |= extract_bits(instruction, 6, 6);
1489 return value;
1490 }
1491
1492
1493 uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
1494 {
1495 uint64 value = 0;
1496 value |= extract_bits(instruction, 5, 5);
1497 return value;
1498 }
1499
1500
1501 uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
1502 {
1503 uint64 value = 0;
1504 value |= extract_bits(instruction, 21, 5);
1505 return value;
1506 }
1507
1508
1509 uint64 NMD::extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
1510 {
1511 uint64 value = 0;
1512 value |= extract_bits(instruction, 0, 7) << 2;
1513 return value;
1514 }
1515
1516
1517 uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
1518 {
1519 uint64 value = 0;
1520 value |= extract_bits(instruction, 11, 6);
1521 return value;
1522 }
1523
1524
1525 uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1526 {
1527 uint64 value = 0;
1528 value |= extract_bits(instruction, 14, 7);
1529 return value;
1530 }
1531
1532
1533 uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
1534 {
1535 uint64 value = 0;
1536 value |= extract_bits(instruction, 0, 4);
1537 return value;
1538 }
1539
1540
1541 uint64 NMD::extract_u_7_6_5_4__s4(uint64 instruction)
1542 {
1543 uint64 value = 0;
1544 value |= extract_bits(instruction, 4, 4) << 4;
1545 return value;
1546 }
1547
1548
1549 int64 NMD::extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
1550 {
1551 int64 value = 0;
1552 value |= extract_bits(instruction, 3, 5) << 3;
1553 value |= extract_bits(instruction, 15, 1) << 8;
1554 value = sign_extend(value, 8);
1555 return value;
1556 }
1557
1558
1559 uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
1560 {
1561 uint64 value = 0;
1562 value |= extract_bits(instruction, 11, 5);
1563 return value;
1564 }
1565
1566
1567 int64 NMD::extract_s__se31_15_to_0_31_to_16(uint64 instruction)
1568 {
1569 int64 value = 0;
1570 value |= extract_bits(instruction, 0, 16) << 16;
1571 value |= extract_bits(instruction, 16, 16);
1572 value = sign_extend(value, 31);
1573 return value;
1574 }
1575
1576
1577 uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1578 {
1579 uint64 value = 0;
1580 value |= extract_bits(instruction, 13, 8);
1581 return value;
1582 }
1583
1584
1585 uint64 NMD::extract_u_17_to_2__s2(uint64 instruction)
1586 {
1587 uint64 value = 0;
1588 value |= extract_bits(instruction, 2, 16) << 2;
1589 return value;
1590 }
1591
1592
1593 uint64 NMD::extract_rd_15_14_13_12_11(uint64 instruction)
1594 {
1595 uint64 value = 0;
1596 value |= extract_bits(instruction, 11, 5);
1597 return value;
1598 }
1599
1600
1601 uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
1602 {
1603 uint64 value = 0;
1604 value |= extract_bits(instruction, 16, 5);
1605 return value;
1606 }
1607
1608
1609 uint64 NMD::extract_code_1_0(uint64 instruction)
1610 {
1611 uint64 value = 0;
1612 value |= extract_bits(instruction, 0, 2);
1613 return value;
1614 }
1615
1616
1617 int64 NMD::extract_s__se25_0_24_to_1_s1(uint64 instruction)
1618 {
1619 int64 value = 0;
1620 value |= extract_bits(instruction, 0, 1) << 25;
1621 value |= extract_bits(instruction, 1, 24) << 1;
1622 value = sign_extend(value, 25);
1623 return value;
1624 }
1625
1626
1627 uint64 NMD::extract_u_1_0(uint64 instruction)
1628 {
1629 uint64 value = 0;
1630 value |= extract_bits(instruction, 0, 2);
1631 return value;
1632 }
1633
1634
1635 uint64 NMD::extract_u_3_8__s2(uint64 instruction)
1636 {
1637 uint64 value = 0;
1638 value |= extract_bits(instruction, 3, 1) << 3;
1639 value |= extract_bits(instruction, 8, 1) << 2;
1640 return value;
1641 }
1642
1643
1644 uint64 NMD::extract_fd_15_14_13_12_11(uint64 instruction)
1645 {
1646 uint64 value = 0;
1647 value |= extract_bits(instruction, 11, 5);
1648 return value;
1649 }
1650
1651
1652 uint64 NMD::extract_u_4_3_2_1_0__s2(uint64 instruction)
1653 {
1654 uint64 value = 0;
1655 value |= extract_bits(instruction, 0, 5) << 2;
1656 return value;
1657 }
1658
1659
1660 uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
1661 {
1662 uint64 value = 0;
1663 value |= extract_bits(instruction, 5, 3);
1664 value |= extract_bits(instruction, 9, 1) << 3;
1665 return value;
1666 }
1667
1668
1669 uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
1670 {
1671 uint64 value = 0;
1672 value |= extract_bits(instruction, 11, 5);
1673 return value;
1674 }
1675
1676
1677 uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
1678 {
1679 uint64 value = 0;
1680 value |= extract_bits(instruction, 21, 5);
1681 return value;
1682 }
1683
1684
1685 uint64 NMD::extract_u_20_to_2__s2(uint64 instruction)
1686 {
1687 uint64 value = 0;
1688 value |= extract_bits(instruction, 2, 19) << 2;
1689 return value;
1690 }
1691
1692
1693 int64 NMD::extract_s__se3_4_2_1_0(uint64 instruction)
1694 {
1695 int64 value = 0;
1696 value |= extract_bits(instruction, 0, 3);
1697 value |= extract_bits(instruction, 4, 1) << 3;
1698 value = sign_extend(value, 3);
1699 return value;
1700 }
1701
1702
1703 uint64 NMD::extract_u_3_2_1_0__s1(uint64 instruction)
1704 {
1705 uint64 value = 0;
1706 value |= extract_bits(instruction, 0, 4) << 1;
1707 return value;
1708 }
1709
1710
1711
1712 bool NMD::ADDIU_32__cond(uint64 instruction)
1713 {
1714 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1715 return rt != 0;
1716 }
1717
1718
1719 bool NMD::ADDIU_RS5__cond(uint64 instruction)
1720 {
1721 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1722 return rt != 0;
1723 }
1724
1725
1726 bool NMD::BALRSC_cond(uint64 instruction)
1727 {
1728 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1729 return rt != 0;
1730 }
1731
1732
1733 bool NMD::BEQC_16__cond(uint64 instruction)
1734 {
1735 uint64 rs3 = extract_rs3_6_5_4(instruction);
1736 uint64 rt3 = extract_rt3_9_8_7(instruction);
1737 uint64 u = extract_u_3_2_1_0__s1(instruction);
1738 return rs3 < rt3 && u != 0;
1739 }
1740
1741
1742 bool NMD::BNEC_16__cond(uint64 instruction)
1743 {
1744 uint64 rs3 = extract_rs3_6_5_4(instruction);
1745 uint64 rt3 = extract_rt3_9_8_7(instruction);
1746 uint64 u = extract_u_3_2_1_0__s1(instruction);
1747 return rs3 >= rt3 && u != 0;
1748 }
1749
1750
1751 bool NMD::MOVE_cond(uint64 instruction)
1752 {
1753 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1754 return rt != 0;
1755 }
1756
1757
1758 bool NMD::P16_BR1_cond(uint64 instruction)
1759 {
1760 uint64 u = extract_u_3_2_1_0__s1(instruction);
1761 return u != 0;
1762 }
1763
1764
1765 bool NMD::PREF_S9__cond(uint64 instruction)
1766 {
1767 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1768 return hint != 31;
1769 }
1770
1771
1772 bool NMD::PREFE_cond(uint64 instruction)
1773 {
1774 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1775 return hint != 31;
1776 }
1777
1778
1779 bool NMD::SLTU_cond(uint64 instruction)
1780 {
1781 uint64 rd = extract_rd_15_14_13_12_11(instruction);
1782 return rd != 0;
1783 }
1784
1785
1786
1787 /*
1788 * ABS.D fd, fs - Floating Point Absolute Value
1789 *
1790 * 3 2 1
1791 * 10987654321098765432109876543210
1792 * 010001 00000 000101
1793 * fmt -----
1794 * fs -----
1795 * fd -----
1796 */
1797 std::string NMD::ABS_D(uint64 instruction)
1798 {
1799 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1800 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1801
1802 std::string fs = FPR(copy(fs_value));
1803 std::string fd = FPR(copy(fd_value));
1804
1805 return img::format("ABS.D %s, %s", fd, fs);
1806 }
1807
1808
1809 /*
1810 * ABS.S fd, fs - Floating Point Absolute Value
1811 *
1812 * 3 2 1
1813 * 10987654321098765432109876543210
1814 * 010001 00000 000101
1815 * fmt -----
1816 * fd -----
1817 * fs -----
1818 */
1819 std::string NMD::ABS_S(uint64 instruction)
1820 {
1821 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1822 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1823
1824 std::string fs = FPR(copy(fs_value));
1825 std::string fd = FPR(copy(fd_value));
1826
1827 return img::format("ABS.S %s, %s", fd, fs);
1828 }
1829
1830
1831 /*
1832 * ABSQ_S.PH rt, rs - Find Absolute Value of Two Fractional Halfwords
1833 *
1834 * 3 2 1
1835 * 10987654321098765432109876543210
1836 * 001000 0001000100111111
1837 * rt -----
1838 * rs -----
1839 */
1840 std::string NMD::ABSQ_S_PH(uint64 instruction)
1841 {
1842 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1843 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1844
1845 std::string rt = GPR(copy(rt_value));
1846 std::string rs = GPR(copy(rs_value));
1847
1848 return img::format("ABSQ_S.PH %s, %s", rt, rs);
1849 }
1850
1851
1852 /*
1853 * ABSQ_S.QB rt, rs - Find Absolute Value of Four Fractional Byte Values
1854 *
1855 * 3 2 1
1856 * 10987654321098765432109876543210
1857 * 001000 0000000100111111
1858 * rt -----
1859 * rs -----
1860 */
1861 std::string NMD::ABSQ_S_QB(uint64 instruction)
1862 {
1863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1864 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1865
1866 std::string rt = GPR(copy(rt_value));
1867 std::string rs = GPR(copy(rs_value));
1868
1869 return img::format("ABSQ_S.QB %s, %s", rt, rs);
1870 }
1871
1872
1873 /*
1874 *
1875 *
1876 * 3 2 1
1877 * 10987654321098765432109876543210
1878 * 001000 0010000100111111
1879 * rt -----
1880 * rs -----
1881 */
1882 std::string NMD::ABSQ_S_W(uint64 instruction)
1883 {
1884 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1885 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1886
1887 std::string rt = GPR(copy(rt_value));
1888 std::string rs = GPR(copy(rs_value));
1889
1890 return img::format("ABSQ_S.W %s, %s", rt, rs);
1891 }
1892
1893
1894 /*
1895 *
1896 *
1897 * 3 2 1
1898 * 10987654321098765432109876543210
1899 * 001000 0010000100111111
1900 * rt -----
1901 * rs -----
1902 */
1903 std::string NMD::ACLR(uint64 instruction)
1904 {
1905 uint64 bit_value = extract_bit_23_22_21(instruction);
1906 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1907 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
1908
1909 std::string bit = IMMEDIATE(copy(bit_value));
1910 std::string s = IMMEDIATE(copy(s_value));
1911 std::string rs = GPR(copy(rs_value));
1912
1913 return img::format("ACLR %s, %s(%s)", bit, s, rs);
1914 }
1915
1916
1917 /*
1918 *
1919 *
1920 * 3 2 1
1921 * 10987654321098765432109876543210
1922 * 001000 0010000100111111
1923 * rt -----
1924 * rs -----
1925 */
1926 std::string NMD::ADD(uint64 instruction)
1927 {
1928 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1929 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1930 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1931
1932 std::string rd = GPR(copy(rd_value));
1933 std::string rs = GPR(copy(rs_value));
1934 std::string rt = GPR(copy(rt_value));
1935
1936 return img::format("ADD %s, %s, %s", rd, rs, rt);
1937 }
1938
1939
1940 /*
1941 * ADD.D fd, fs, ft - Floating Point Add
1942 *
1943 * 3 2 1
1944 * 10987654321098765432109876543210
1945 * 010001 000101
1946 * fmt -----
1947 * ft -----
1948 * fs -----
1949 * fd -----
1950 */
1951 std::string NMD::ADD_D(uint64 instruction)
1952 {
1953 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1954 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1955 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1956
1957 std::string ft = FPR(copy(ft_value));
1958 std::string fs = FPR(copy(fs_value));
1959 std::string fd = FPR(copy(fd_value));
1960
1961 return img::format("ADD.D %s, %s, %s", fd, fs, ft);
1962 }
1963
1964
1965 /*
1966 * ADD.S fd, fs, ft - Floating Point Add
1967 *
1968 * 3 2 1
1969 * 10987654321098765432109876543210
1970 * 010001 000101
1971 * fmt -----
1972 * ft -----
1973 * fs -----
1974 * fd -----
1975 */
1976 std::string NMD::ADD_S(uint64 instruction)
1977 {
1978 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1979 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1980 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1981
1982 std::string ft = FPR(copy(ft_value));
1983 std::string fs = FPR(copy(fs_value));
1984 std::string fd = FPR(copy(fd_value));
1985
1986 return img::format("ADD.S %s, %s, %s", fd, fs, ft);
1987 }
1988
1989
1990 /*
1991 *
1992 *
1993 * 3 2 1
1994 * 10987654321098765432109876543210
1995 * 001000 0010000100111111
1996 * rt -----
1997 * rs -----
1998 */
1999 std::string NMD::ADDIU_32_(uint64 instruction)
2000 {
2001 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2002 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2003 uint64 u_value = extract_u_15_to_0(instruction);
2004
2005 std::string rt = GPR(copy(rt_value));
2006 std::string rs = GPR(copy(rs_value));
2007 std::string u = IMMEDIATE(copy(u_value));
2008
2009 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2010 }
2011
2012
2013 /*
2014 *
2015 *
2016 * 3 2 1
2017 * 10987654321098765432109876543210
2018 * 001000 0010000100111111
2019 * rt -----
2020 * rs -----
2021 */
2022 std::string NMD::ADDIU_48_(uint64 instruction)
2023 {
2024 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2025 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
2026
2027 std::string rt = GPR(copy(rt_value));
2028 std::string s = IMMEDIATE(copy(s_value));
2029
2030 return img::format("ADDIU %s, %s", rt, s);
2031 }
2032
2033
2034 /*
2035 *
2036 *
2037 * 3 2 1
2038 * 10987654321098765432109876543210
2039 * 001000 0010000100111111
2040 * rt -----
2041 * rs -----
2042 */
2043 std::string NMD::ADDIU_GP48_(uint64 instruction)
2044 {
2045 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2046 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
2047
2048 std::string rt = GPR(copy(rt_value));
2049 std::string s = IMMEDIATE(copy(s_value));
2050
2051 return img::format("ADDIU %s, $%d, %s", rt, 28, s);
2052 }
2053
2054
2055 /*
2056 *
2057 *
2058 * 3 2 1
2059 * 10987654321098765432109876543210
2060 * 001000 0010000100111111
2061 * rt -----
2062 * rs -----
2063 */
2064 std::string NMD::ADDIU_GP_B_(uint64 instruction)
2065 {
2066 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2067 uint64 u_value = extract_u_17_to_0(instruction);
2068
2069 std::string rt = GPR(copy(rt_value));
2070 std::string u = IMMEDIATE(copy(u_value));
2071
2072 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2073 }
2074
2075
2076 /*
2077 *
2078 *
2079 * 3 2 1
2080 * 10987654321098765432109876543210
2081 * 001000 0010000100111111
2082 * rt -----
2083 * rs -----
2084 */
2085 std::string NMD::ADDIU_GP_W_(uint64 instruction)
2086 {
2087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2088 uint64 u_value = extract_u_20_to_2__s2(instruction);
2089
2090 std::string rt = GPR(copy(rt_value));
2091 std::string u = IMMEDIATE(copy(u_value));
2092
2093 return img::format("ADDIU %s, $%d, %s", rt, 28, u);
2094 }
2095
2096
2097 /*
2098 *
2099 *
2100 * 3 2 1
2101 * 10987654321098765432109876543210
2102 * 001000 0010000100111111
2103 * rt -----
2104 * rs -----
2105 */
2106 std::string NMD::ADDIU_NEG_(uint64 instruction)
2107 {
2108 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2109 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2110 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2111
2112 std::string rt = GPR(copy(rt_value));
2113 std::string rs = GPR(copy(rs_value));
2114 std::string u = IMMEDIATE(neg_copy(u_value));
2115
2116 return img::format("ADDIU %s, %s, %s", rt, rs, u);
2117 }
2118
2119
2120 /*
2121 *
2122 *
2123 * 3 2 1
2124 * 10987654321098765432109876543210
2125 * 001000 0010000100111111
2126 * rt -----
2127 * rs -----
2128 */
2129 std::string NMD::ADDIU_R1_SP_(uint64 instruction)
2130 {
2131 uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
2132 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2133
2134 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2135 std::string u = IMMEDIATE(copy(u_value));
2136
2137 return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
2138 }
2139
2140
2141 /*
2142 *
2143 *
2144 * 3 2 1
2145 * 10987654321098765432109876543210
2146 * 001000 0010000100111111
2147 * rt -----
2148 * rs -----
2149 */
2150 std::string NMD::ADDIU_R2_(uint64 instruction)
2151 {
2152 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2153 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2154 uint64 u_value = extract_u_2_1_0__s2(instruction);
2155
2156 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2157 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2158 std::string u = IMMEDIATE(copy(u_value));
2159
2160 return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
2161 }
2162
2163
2164 /*
2165 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
2166 *
2167 * 5432109876543210
2168 * 100100 1
2169 * rt -----
2170 * s - ---
2171 */
2172 std::string NMD::ADDIU_RS5_(uint64 instruction)
2173 {
2174 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
2175 int64 s_value = extract_s__se3_4_2_1_0(instruction);
2176
2177 std::string rt = GPR(copy(rt_value));
2178 std::string s = IMMEDIATE(copy(s_value));
2179
2180 return img::format("ADDIU %s, %s", rt, s);
2181 }
2182
2183
2184 /*
2185 *
2186 *
2187 * 3 2 1
2188 * 10987654321098765432109876543210
2189 * 001000 x1110000101
2190 * rt -----
2191 * rs -----
2192 * rd -----
2193 */
2194 std::string NMD::ADDIUPC_32_(uint64 instruction)
2195 {
2196 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2197 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
2198
2199 std::string rt = GPR(copy(rt_value));
2200 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2201
2202 return img::format("ADDIUPC %s, %s", rt, s);
2203 }
2204
2205
2206 /*
2207 *
2208 *
2209 * 3 2 1
2210 * 10987654321098765432109876543210
2211 * 001000 x1110000101
2212 * rt -----
2213 * rs -----
2214 * rd -----
2215 */
2216 std::string NMD::ADDIUPC_48_(uint64 instruction)
2217 {
2218 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
2219 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
2220
2221 std::string rt = GPR(copy(rt_value));
2222 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
2223
2224 return img::format("ADDIUPC %s, %s", rt, s);
2225 }
2226
2227
2228 /*
2229 * ADDQ.PH rd, rt, rs - Add Fractional Halfword Vectors
2230 *
2231 * 3 2 1
2232 * 10987654321098765432109876543210
2233 * 001000 00000001101
2234 * rt -----
2235 * rs -----
2236 * rd -----
2237 */
2238 std::string NMD::ADDQ_PH(uint64 instruction)
2239 {
2240 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2242 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2243
2244 std::string rd = GPR(copy(rd_value));
2245 std::string rs = GPR(copy(rs_value));
2246 std::string rt = GPR(copy(rt_value));
2247
2248 return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
2249 }
2250
2251
2252 /*
2253 * ADDQ_S.PH rd, rt, rs - Add Fractional Halfword Vectors
2254 *
2255 * 3 2 1
2256 * 10987654321098765432109876543210
2257 * 001000 10000001101
2258 * rt -----
2259 * rs -----
2260 * rd -----
2261 */
2262 std::string NMD::ADDQ_S_PH(uint64 instruction)
2263 {
2264 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2265 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2266 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2267
2268 std::string rd = GPR(copy(rd_value));
2269 std::string rs = GPR(copy(rs_value));
2270 std::string rt = GPR(copy(rt_value));
2271
2272 return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
2273 }
2274
2275
2276 /*
2277 * ADDQ_S.W rd, rt, rs - Add Fractional Words
2278 *
2279 * 3 2 1
2280 * 10987654321098765432109876543210
2281 * 001000 x1100000101
2282 * rt -----
2283 * rs -----
2284 * rd -----
2285 */
2286 std::string NMD::ADDQ_S_W(uint64 instruction)
2287 {
2288 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2289 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2290 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2291
2292 std::string rd = GPR(copy(rd_value));
2293 std::string rs = GPR(copy(rs_value));
2294 std::string rt = GPR(copy(rt_value));
2295
2296 return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2297 }
2298
2299
2300 /*
2301 * ADDQH.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2302 * to Halve Results
2303 *
2304 * 3 2 1
2305 * 10987654321098765432109876543210
2306 * 001000 00001001101
2307 * rt -----
2308 * rs -----
2309 * rd -----
2310 */
2311 std::string NMD::ADDQH_PH(uint64 instruction)
2312 {
2313 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2314 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2315 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2316
2317 std::string rd = GPR(copy(rd_value));
2318 std::string rs = GPR(copy(rs_value));
2319 std::string rt = GPR(copy(rt_value));
2320
2321 return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2322 }
2323
2324
2325 /*
2326 * ADDQH_R.PH rd, rt, rs - Add Fractional Halfword Vectors And Shift Right
2327 * to Halve Results
2328 *
2329 * 3 2 1
2330 * 10987654321098765432109876543210
2331 * 001000 10001001101
2332 * rt -----
2333 * rs -----
2334 * rd -----
2335 */
2336 std::string NMD::ADDQH_R_PH(uint64 instruction)
2337 {
2338 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2339 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2340 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2341
2342 std::string rd = GPR(copy(rd_value));
2343 std::string rs = GPR(copy(rs_value));
2344 std::string rt = GPR(copy(rt_value));
2345
2346 return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2347 }
2348
2349
2350 /*
2351 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2352 *
2353 * 3 2 1
2354 * 10987654321098765432109876543210
2355 * 001000 00010001101
2356 * rt -----
2357 * rs -----
2358 * rd -----
2359 */
2360 std::string NMD::ADDQH_R_W(uint64 instruction)
2361 {
2362 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2363 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2364 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2365
2366 std::string rd = GPR(copy(rd_value));
2367 std::string rs = GPR(copy(rs_value));
2368 std::string rt = GPR(copy(rt_value));
2369
2370 return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2371 }
2372
2373
2374 /*
2375 * ADDQH.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
2376 *
2377 * 3 2 1
2378 * 10987654321098765432109876543210
2379 * 001000 10010001101
2380 * rt -----
2381 * rs -----
2382 * rd -----
2383 */
2384 std::string NMD::ADDQH_W(uint64 instruction)
2385 {
2386 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2387 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2388 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2389
2390 std::string rd = GPR(copy(rd_value));
2391 std::string rs = GPR(copy(rs_value));
2392 std::string rt = GPR(copy(rt_value));
2393
2394 return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
2395 }
2396
2397
2398 /*
2399 * ADDSC rd, rt, rs - Add Signed Word and Set Carry Bit
2400 *
2401 * 3 2 1
2402 * 10987654321098765432109876543210
2403 * 001000 x1110000101
2404 * rt -----
2405 * rs -----
2406 * rd -----
2407 */
2408 std::string NMD::ADDSC(uint64 instruction)
2409 {
2410 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2411 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2412 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2413
2414 std::string rd = GPR(copy(rd_value));
2415 std::string rs = GPR(copy(rs_value));
2416 std::string rt = GPR(copy(rt_value));
2417
2418 return img::format("ADDSC %s, %s, %s", rd, rs, rt);
2419 }
2420
2421
2422 /*
2423 * ADDU[16] rd3, rs3, rt3 -
2424 *
2425 * 5432109876543210
2426 * 101100 0
2427 * rt3 ---
2428 * rs3 ---
2429 * rd3 ---
2430 */
2431 std::string NMD::ADDU_16_(uint64 instruction)
2432 {
2433 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2434 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2435 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2436
2437 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2438 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2439 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
2440
2441 return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
2442 }
2443
2444
2445 /*
2446 *
2447 *
2448 * 3 2 1
2449 * 10987654321098765432109876543210
2450 * 001000 x1110000101
2451 * rt -----
2452 * rs -----
2453 * rd -----
2454 */
2455 std::string NMD::ADDU_32_(uint64 instruction)
2456 {
2457 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2458 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2459 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2460
2461 std::string rd = GPR(copy(rd_value));
2462 std::string rs = GPR(copy(rs_value));
2463 std::string rt = GPR(copy(rt_value));
2464
2465 return img::format("ADDU %s, %s, %s", rd, rs, rt);
2466 }
2467
2468
2469 /*
2470 *
2471 *
2472 * 3 2 1
2473 * 10987654321098765432109876543210
2474 * 001000 x1110000101
2475 * rt -----
2476 * rs -----
2477 * rd -----
2478 */
2479 std::string NMD::ADDU_4X4_(uint64 instruction)
2480 {
2481 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2482 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2483
2484 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
2485 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
2486
2487 return img::format("ADDU %s, %s", rs4, rt4);
2488 }
2489
2490
2491 /*
2492 * ADDU.PH rd, rt, rs - Unsigned Add Integer Halfwords
2493 *
2494 * 3 2 1
2495 * 10987654321098765432109876543210
2496 * 001000 00100001101
2497 * rt -----
2498 * rs -----
2499 * rd -----
2500 */
2501 std::string NMD::ADDU_PH(uint64 instruction)
2502 {
2503 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2504 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2505 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2506
2507 std::string rd = GPR(copy(rd_value));
2508 std::string rs = GPR(copy(rs_value));
2509 std::string rt = GPR(copy(rt_value));
2510
2511 return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
2512 }
2513
2514
2515 /*
2516 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2517 *
2518 * 3 2 1
2519 * 10987654321098765432109876543210
2520 * 001000 00011001101
2521 * rt -----
2522 * rs -----
2523 * rd -----
2524 */
2525 std::string NMD::ADDU_QB(uint64 instruction)
2526 {
2527 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2528 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2529 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2530
2531 std::string rd = GPR(copy(rd_value));
2532 std::string rs = GPR(copy(rs_value));
2533 std::string rt = GPR(copy(rt_value));
2534
2535 return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
2536 }
2537
2538
2539 /*
2540 * ADDU_S.PH rd, rt, rs - Unsigned Add Integer Halfwords
2541 *
2542 * 3 2 1
2543 * 10987654321098765432109876543210
2544 * 001000 10100001101
2545 * rt -----
2546 * rs -----
2547 * rd -----
2548 */
2549 std::string NMD::ADDU_S_PH(uint64 instruction)
2550 {
2551 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2552 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2553 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2554
2555 std::string rd = GPR(copy(rd_value));
2556 std::string rs = GPR(copy(rs_value));
2557 std::string rt = GPR(copy(rt_value));
2558
2559 return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2560 }
2561
2562
2563 /*
2564 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2565 *
2566 * 3 2 1
2567 * 10987654321098765432109876543210
2568 * 001000 10011001101
2569 * rt -----
2570 * rs -----
2571 * rd -----
2572 */
2573 std::string NMD::ADDU_S_QB(uint64 instruction)
2574 {
2575 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2576 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2577 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2578
2579 std::string rd = GPR(copy(rd_value));
2580 std::string rs = GPR(copy(rs_value));
2581 std::string rt = GPR(copy(rt_value));
2582
2583 return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2584 }
2585
2586
2587 /*
2588 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2589 * to Halve Results
2590 *
2591 * 3 2 1
2592 * 10987654321098765432109876543210
2593 * 001000 00101001101
2594 * rt -----
2595 * rs -----
2596 * rd -----
2597 */
2598 std::string NMD::ADDUH_QB(uint64 instruction)
2599 {
2600 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2602 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2603
2604 std::string rd = GPR(copy(rd_value));
2605 std::string rs = GPR(copy(rs_value));
2606 std::string rt = GPR(copy(rt_value));
2607
2608 return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2609 }
2610
2611
2612 /*
2613 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2614 * to Halve Results
2615 *
2616 * 3 2 1
2617 * 10987654321098765432109876543210
2618 * 001000 10101001101
2619 * rt -----
2620 * rs -----
2621 * rd -----
2622 */
2623 std::string NMD::ADDUH_R_QB(uint64 instruction)
2624 {
2625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2626 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2627 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2628
2629 std::string rd = GPR(copy(rd_value));
2630 std::string rs = GPR(copy(rs_value));
2631 std::string rt = GPR(copy(rt_value));
2632
2633 return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2634 }
2635
2636 /*
2637 * ADDWC rd, rt, rs - Add Word with Carry Bit
2638 *
2639 * 3 2 1
2640 * 10987654321098765432109876543210
2641 * 001000 x1111000101
2642 * rt -----
2643 * rs -----
2644 * rd -----
2645 */
2646 std::string NMD::ADDWC(uint64 instruction)
2647 {
2648 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2649 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2650 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2651
2652 std::string rd = GPR(copy(rd_value));
2653 std::string rs = GPR(copy(rs_value));
2654 std::string rt = GPR(copy(rt_value));
2655
2656 return img::format("ADDWC %s, %s, %s", rd, rs, rt);
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::ALUIPC(uint64 instruction)
2671 {
2672 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2673 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
2674
2675 std::string rt = GPR(copy(rt_value));
2676 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2677
2678 return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2679 }
2680
2681
2682 /*
2683 * AND[16] rt3, rs3 -
2684 *
2685 * 5432109876543210
2686 * 101100
2687 * rt3 ---
2688 * rs3 ---
2689 * eu ----
2690 */
2691 std::string NMD::AND_16_(uint64 instruction)
2692 {
2693 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2694 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2695
2696 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2697 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2698
2699 return img::format("AND %s, %s", rs3, rt3);
2700 }
2701
2702
2703 /*
2704 *
2705 *
2706 * 3 2 1
2707 * 10987654321098765432109876543210
2708 * 001000 x1110000101
2709 * rt -----
2710 * rs -----
2711 * rd -----
2712 */
2713 std::string NMD::AND_32_(uint64 instruction)
2714 {
2715 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2716 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2717 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2718
2719 std::string rd = GPR(copy(rd_value));
2720 std::string rs = GPR(copy(rs_value));
2721 std::string rt = GPR(copy(rt_value));
2722
2723 return img::format("AND %s, %s, %s", rd, rs, rt);
2724 }
2725
2726
2727 /*
2728 * ANDI rt, rs, u -
2729 *
2730 * 5432109876543210
2731 * 101100
2732 * rt3 ---
2733 * rs3 ---
2734 * eu ----
2735 */
2736 std::string NMD::ANDI_16_(uint64 instruction)
2737 {
2738 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2739 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2740 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2741
2742 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
2743 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
2744 std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
2745
2746 return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
2747 }
2748
2749
2750 /*
2751 *
2752 *
2753 * 3 2 1
2754 * 10987654321098765432109876543210
2755 * 001000 x1110000101
2756 * rt -----
2757 * rs -----
2758 * rd -----
2759 */
2760 std::string NMD::ANDI_32_(uint64 instruction)
2761 {
2762 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2763 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2764 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2765
2766 std::string rt = GPR(copy(rt_value));
2767 std::string rs = GPR(copy(rs_value));
2768 std::string u = IMMEDIATE(copy(u_value));
2769
2770 return img::format("ANDI %s, %s, %s", rt, rs, u);
2771 }
2772
2773
2774 /*
2775 *
2776 *
2777 * 3 2 1
2778 * 10987654321098765432109876543210
2779 * 001000 x1110000101
2780 * rt -----
2781 * rs -----
2782 * rd -----
2783 */
2784 std::string NMD::APPEND(uint64 instruction)
2785 {
2786 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2787 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2788 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2789
2790 std::string rt = GPR(copy(rt_value));
2791 std::string rs = GPR(copy(rs_value));
2792 std::string sa = IMMEDIATE(copy(sa_value));
2793
2794 return img::format("APPEND %s, %s, %s", rt, rs, sa);
2795 }
2796
2797
2798 /*
2799 *
2800 *
2801 * 3 2 1
2802 * 10987654321098765432109876543210
2803 * 001000 x1110000101
2804 * rt -----
2805 * rs -----
2806 * rd -----
2807 */
2808 std::string NMD::ASET(uint64 instruction)
2809 {
2810 uint64 bit_value = extract_bit_23_22_21(instruction);
2811 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2812 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
2813
2814 std::string bit = IMMEDIATE(copy(bit_value));
2815 std::string s = IMMEDIATE(copy(s_value));
2816 std::string rs = GPR(copy(rs_value));
2817
2818 return img::format("ASET %s, %s(%s)", bit, s, rs);
2819 }
2820
2821
2822 /*
2823 *
2824 *
2825 * 3 2 1
2826 * 10987654321098765432109876543210
2827 * 001000 x1110000101
2828 * rt -----
2829 * rs -----
2830 * rd -----
2831 */
2832 std::string NMD::BALC_16_(uint64 instruction)
2833 {
2834 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2835
2836 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2837
2838 return img::format("BALC %s", s);
2839 }
2840
2841
2842 /*
2843 *
2844 *
2845 * 3 2 1
2846 * 10987654321098765432109876543210
2847 * 001000 x1110000101
2848 * rt -----
2849 * rs -----
2850 * rd -----
2851 */
2852 std::string NMD::BALC_32_(uint64 instruction)
2853 {
2854 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2855
2856 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2857
2858 return img::format("BALC %s", s);
2859 }
2860
2861
2862 /*
2863 *
2864 *
2865 * 3 2 1
2866 * 10987654321098765432109876543210
2867 * 001000 x1110000101
2868 * rt -----
2869 * rs -----
2870 * rd -----
2871 */
2872 std::string NMD::BALRSC(uint64 instruction)
2873 {
2874 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2875 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2876
2877 std::string rt = GPR(copy(rt_value));
2878 std::string rs = GPR(copy(rs_value));
2879
2880 return img::format("BALRSC %s, %s", rt, rs);
2881 }
2882
2883
2884 /*
2885 *
2886 *
2887 * 3 2 1
2888 * 10987654321098765432109876543210
2889 * 001000 x1110000101
2890 * rt -----
2891 * rs -----
2892 * rd -----
2893 */
2894 std::string NMD::BBEQZC(uint64 instruction)
2895 {
2896 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2897 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2898 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2899
2900 std::string rt = GPR(copy(rt_value));
2901 std::string bit = IMMEDIATE(copy(bit_value));
2902 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2903
2904 return img::format("BBEQZC %s, %s, %s", rt, bit, s);
2905 }
2906
2907
2908 /*
2909 *
2910 *
2911 * 3 2 1
2912 * 10987654321098765432109876543210
2913 * 001000 x1110000101
2914 * rt -----
2915 * rs -----
2916 * rd -----
2917 */
2918 std::string NMD::BBNEZC(uint64 instruction)
2919 {
2920 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2921 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2922 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2923
2924 std::string rt = GPR(copy(rt_value));
2925 std::string bit = IMMEDIATE(copy(bit_value));
2926 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2927
2928 return img::format("BBNEZC %s, %s, %s", rt, bit, s);
2929 }
2930
2931
2932 /*
2933 *
2934 *
2935 * 3 2 1
2936 * 10987654321098765432109876543210
2937 * 001000 x1110000101
2938 * rt -----
2939 * rs -----
2940 * rd -----
2941 */
2942 std::string NMD::BC_16_(uint64 instruction)
2943 {
2944 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2945
2946 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
2947
2948 return img::format("BC %s", s);
2949 }
2950
2951
2952 /*
2953 *
2954 *
2955 * 3 2 1
2956 * 10987654321098765432109876543210
2957 * 001000 x1110000101
2958 * rt -----
2959 * rs -----
2960 * rd -----
2961 */
2962 std::string NMD::BC_32_(uint64 instruction)
2963 {
2964 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2965
2966 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2967
2968 return img::format("BC %s", s);
2969 }
2970
2971
2972 /*
2973 *
2974 *
2975 * 3 2 1
2976 * 10987654321098765432109876543210
2977 * 001000 x1110000101
2978 * rt -----
2979 * rs -----
2980 * rd -----
2981 */
2982 std::string NMD::BC1EQZC(uint64 instruction)
2983 {
2984 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2985 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2986
2987 std::string ft = FPR(copy(ft_value));
2988 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
2989
2990 return img::format("BC1EQZC %s, %s", ft, s);
2991 }
2992
2993
2994 /*
2995 *
2996 *
2997 * 3 2 1
2998 * 10987654321098765432109876543210
2999 * 001000 x1110000101
3000 * rt -----
3001 * rs -----
3002 * rd -----
3003 */
3004 std::string NMD::BC1NEZC(uint64 instruction)
3005 {
3006 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3007 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3008
3009 std::string ft = FPR(copy(ft_value));
3010 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3011
3012 return img::format("BC1NEZC %s, %s", ft, s);
3013 }
3014
3015
3016 /*
3017 *
3018 *
3019 * 3 2 1
3020 * 10987654321098765432109876543210
3021 * 001000 x1110000101
3022 * rt -----
3023 * rs -----
3024 * rd -----
3025 */
3026 std::string NMD::BC2EQZC(uint64 instruction)
3027 {
3028 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3029 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3030
3031 std::string ct = CPR(copy(ct_value));
3032 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3033
3034 return img::format("BC2EQZC %s, %s", ct, s);
3035 }
3036
3037
3038 /*
3039 *
3040 *
3041 * 3 2 1
3042 * 10987654321098765432109876543210
3043 * 001000 x1110000101
3044 * rt -----
3045 * rs -----
3046 * rd -----
3047 */
3048 std::string NMD::BC2NEZC(uint64 instruction)
3049 {
3050 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
3051 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3052
3053 std::string ct = CPR(copy(ct_value));
3054 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3055
3056 return img::format("BC2NEZC %s, %s", ct, s);
3057 }
3058
3059
3060 /*
3061 *
3062 *
3063 * 3 2 1
3064 * 10987654321098765432109876543210
3065 * 001000 x1110000101
3066 * rt -----
3067 * rs -----
3068 * rd -----
3069 */
3070 std::string NMD::BEQC_16_(uint64 instruction)
3071 {
3072 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3073 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3074 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
3075
3076 std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
3077 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3078 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3079
3080 return img::format("BEQC %s, %s, %s", rs3, rt3, u);
3081 }
3082
3083
3084 /*
3085 *
3086 *
3087 * 3 2 1
3088 * 10987654321098765432109876543210
3089 * 001000 x1110000101
3090 * rt -----
3091 * rs -----
3092 * rd -----
3093 */
3094 std::string NMD::BEQC_32_(uint64 instruction)
3095 {
3096 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3097 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3098 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3099
3100 std::string rs = GPR(copy(rs_value));
3101 std::string rt = GPR(copy(rt_value));
3102 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3103
3104 return img::format("BEQC %s, %s, %s", rs, rt, s);
3105 }
3106
3107
3108 /*
3109 *
3110 *
3111 * 3 2 1
3112 * 10987654321098765432109876543210
3113 * 001000 x1110000101
3114 * rt -----
3115 * rs -----
3116 * rd -----
3117 */
3118 std::string NMD::BEQIC(uint64 instruction)
3119 {
3120 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3121 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3122 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3123
3124 std::string rt = GPR(copy(rt_value));
3125 std::string u = IMMEDIATE(copy(u_value));
3126 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3127
3128 return img::format("BEQIC %s, %s, %s", rt, u, s);
3129 }
3130
3131
3132 /*
3133 *
3134 *
3135 * 3 2 1
3136 * 10987654321098765432109876543210
3137 * 001000 x1110000101
3138 * rt -----
3139 * rs -----
3140 * rd -----
3141 */
3142 std::string NMD::BEQZC_16_(uint64 instruction)
3143 {
3144 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3145 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3146
3147 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3148 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3149
3150 return img::format("BEQZC %s, %s", rt3, s);
3151 }
3152
3153
3154 /*
3155 *
3156 *
3157 * 3 2 1
3158 * 10987654321098765432109876543210
3159 * 001000 x1110000101
3160 * rt -----
3161 * rs -----
3162 * rd -----
3163 */
3164 std::string NMD::BGEC(uint64 instruction)
3165 {
3166 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3167 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3168 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3169
3170 std::string rs = GPR(copy(rs_value));
3171 std::string rt = GPR(copy(rt_value));
3172 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3173
3174 return img::format("BGEC %s, %s, %s", rs, rt, s);
3175 }
3176
3177
3178 /*
3179 *
3180 *
3181 * 3 2 1
3182 * 10987654321098765432109876543210
3183 * 001000 x1110000101
3184 * rt -----
3185 * rs -----
3186 * rd -----
3187 */
3188 std::string NMD::BGEIC(uint64 instruction)
3189 {
3190 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3191 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3192 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3193
3194 std::string rt = GPR(copy(rt_value));
3195 std::string u = IMMEDIATE(copy(u_value));
3196 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3197
3198 return img::format("BGEIC %s, %s, %s", rt, u, s);
3199 }
3200
3201
3202 /*
3203 *
3204 *
3205 * 3 2 1
3206 * 10987654321098765432109876543210
3207 * 001000 x1110000101
3208 * rt -----
3209 * rs -----
3210 * rd -----
3211 */
3212 std::string NMD::BGEIUC(uint64 instruction)
3213 {
3214 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3215 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3216 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3217
3218 std::string rt = GPR(copy(rt_value));
3219 std::string u = IMMEDIATE(copy(u_value));
3220 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3221
3222 return img::format("BGEIUC %s, %s, %s", rt, u, s);
3223 }
3224
3225
3226 /*
3227 *
3228 *
3229 * 3 2 1
3230 * 10987654321098765432109876543210
3231 * 001000 x1110000101
3232 * rt -----
3233 * rs -----
3234 * rd -----
3235 */
3236 std::string NMD::BGEUC(uint64 instruction)
3237 {
3238 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3239 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3240 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3241
3242 std::string rs = GPR(copy(rs_value));
3243 std::string rt = GPR(copy(rt_value));
3244 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3245
3246 return img::format("BGEUC %s, %s, %s", rs, rt, s);
3247 }
3248
3249
3250 /*
3251 *
3252 *
3253 * 3 2 1
3254 * 10987654321098765432109876543210
3255 * 001000 x1110000101
3256 * rt -----
3257 * rs -----
3258 * rd -----
3259 */
3260 std::string NMD::BLTC(uint64 instruction)
3261 {
3262 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3263 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3264 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3265
3266 std::string rs = GPR(copy(rs_value));
3267 std::string rt = GPR(copy(rt_value));
3268 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3269
3270 return img::format("BLTC %s, %s, %s", rs, rt, s);
3271 }
3272
3273
3274 /*
3275 *
3276 *
3277 * 3 2 1
3278 * 10987654321098765432109876543210
3279 * 001000 x1110000101
3280 * rt -----
3281 * rs -----
3282 * rd -----
3283 */
3284 std::string NMD::BLTIC(uint64 instruction)
3285 {
3286 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3287 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3288 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3289
3290 std::string rt = GPR(copy(rt_value));
3291 std::string u = IMMEDIATE(copy(u_value));
3292 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3293
3294 return img::format("BLTIC %s, %s, %s", rt, u, s);
3295 }
3296
3297
3298 /*
3299 *
3300 *
3301 * 3 2 1
3302 * 10987654321098765432109876543210
3303 * 001000 x1110000101
3304 * rt -----
3305 * rs -----
3306 * rd -----
3307 */
3308 std::string NMD::BLTIUC(uint64 instruction)
3309 {
3310 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3311 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3312 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3313
3314 std::string rt = GPR(copy(rt_value));
3315 std::string u = IMMEDIATE(copy(u_value));
3316 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3317
3318 return img::format("BLTIUC %s, %s, %s", rt, u, s);
3319 }
3320
3321
3322 /*
3323 *
3324 *
3325 * 3 2 1
3326 * 10987654321098765432109876543210
3327 * 001000 x1110000101
3328 * rt -----
3329 * rs -----
3330 * rd -----
3331 */
3332 std::string NMD::BLTUC(uint64 instruction)
3333 {
3334 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3335 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3336 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3337
3338 std::string rs = GPR(copy(rs_value));
3339 std::string rt = GPR(copy(rt_value));
3340 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3341
3342 return img::format("BLTUC %s, %s, %s", rs, rt, s);
3343 }
3344
3345
3346 /*
3347 *
3348 *
3349 * 3 2 1
3350 * 10987654321098765432109876543210
3351 * 001000 x1110000101
3352 * rt -----
3353 * rs -----
3354 * rd -----
3355 */
3356 std::string NMD::BNEC_16_(uint64 instruction)
3357 {
3358 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3359 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3360 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
3361
3362 std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
3363 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3364 std::string u = ADDRESS(encode_u_from_address(u_value), 2);
3365
3366 return img::format("BNEC %s, %s, %s", rs3, rt3, u);
3367 }
3368
3369
3370 /*
3371 *
3372 *
3373 * 3 2 1
3374 * 10987654321098765432109876543210
3375 * 001000 x1110000101
3376 * rt -----
3377 * rs -----
3378 * rd -----
3379 */
3380 std::string NMD::BNEC_32_(uint64 instruction)
3381 {
3382 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3383 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3384 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3385
3386 std::string rs = GPR(copy(rs_value));
3387 std::string rt = GPR(copy(rt_value));
3388 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3389
3390 return img::format("BNEC %s, %s, %s", rs, rt, s);
3391 }
3392
3393
3394 /*
3395 *
3396 *
3397 * 3 2 1
3398 * 10987654321098765432109876543210
3399 * 001000 x1110000101
3400 * rt -----
3401 * rs -----
3402 * rd -----
3403 */
3404 std::string NMD::BNEIC(uint64 instruction)
3405 {
3406 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3407 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3408 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3409
3410 std::string rt = GPR(copy(rt_value));
3411 std::string u = IMMEDIATE(copy(u_value));
3412 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3413
3414 return img::format("BNEIC %s, %s, %s", rt, u, s);
3415 }
3416
3417
3418 /*
3419 *
3420 *
3421 * 3 2 1
3422 * 10987654321098765432109876543210
3423 * 001000 x1110000101
3424 * rt -----
3425 * rs -----
3426 * rd -----
3427 */
3428 std::string NMD::BNEZC_16_(uint64 instruction)
3429 {
3430 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3431 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3432
3433 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
3434 std::string s = ADDRESS(encode_s_from_address(s_value), 2);
3435
3436 return img::format("BNEZC %s, %s", rt3, s);
3437 }
3438
3439
3440 /*
3441 *
3442 *
3443 * 3 2 1
3444 * 10987654321098765432109876543210
3445 * 001000 x1110000101
3446 * rt -----
3447 * rs -----
3448 * rd -----
3449 */
3450 std::string NMD::BPOSGE32C(uint64 instruction)
3451 {
3452 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3453
3454 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
3455
3456 return img::format("BPOSGE32C %s", s);
3457 }
3458
3459
3460 /*
3461 *
3462 *
3463 * 3 2 1
3464 * 10987654321098765432109876543210
3465 * 001000 x1110000101
3466 * rt -----
3467 * rs -----
3468 * rd -----
3469 */
3470 std::string NMD::BREAK_16_(uint64 instruction)
3471 {
3472 uint64 code_value = extract_code_2_1_0(instruction);
3473
3474 std::string code = IMMEDIATE(copy(code_value));
3475
3476 return img::format("BREAK %s", code);
3477 }
3478
3479
3480 /*
3481 * BREAK code - Break. Cause a Breakpoint exception
3482 *
3483 * 3 2 1
3484 * 10987654321098765432109876543210
3485 * 001000 x1110000101
3486 * rt -----
3487 * rs -----
3488 * rd -----
3489 */
3490 std::string NMD::BREAK_32_(uint64 instruction)
3491 {
3492 uint64 code_value = extract_code_18_to_0(instruction);
3493
3494 std::string code = IMMEDIATE(copy(code_value));
3495
3496 return img::format("BREAK %s", code);
3497 }
3498
3499
3500 /*
3501 *
3502 *
3503 * 3 2 1
3504 * 10987654321098765432109876543210
3505 * 001000 x1110000101
3506 * rt -----
3507 * rs -----
3508 * rd -----
3509 */
3510 std::string NMD::BRSC(uint64 instruction)
3511 {
3512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3513
3514 std::string rs = GPR(copy(rs_value));
3515
3516 return img::format("BRSC %s", rs);
3517 }
3518
3519
3520 /*
3521 *
3522 *
3523 * 3 2 1
3524 * 10987654321098765432109876543210
3525 * 001000 x1110000101
3526 * rt -----
3527 * rs -----
3528 * rd -----
3529 */
3530 std::string NMD::CACHE(uint64 instruction)
3531 {
3532 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3533 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3534 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3535
3536 std::string op = IMMEDIATE(copy(op_value));
3537 std::string s = IMMEDIATE(copy(s_value));
3538 std::string rs = GPR(copy(rs_value));
3539
3540 return img::format("CACHE %s, %s(%s)", op, s, rs);
3541 }
3542
3543
3544 /*
3545 *
3546 *
3547 * 3 2 1
3548 * 10987654321098765432109876543210
3549 * 001000 x1110000101
3550 * rt -----
3551 * rs -----
3552 * rd -----
3553 */
3554 std::string NMD::CACHEE(uint64 instruction)
3555 {
3556 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3557 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3558 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3559
3560 std::string op = IMMEDIATE(copy(op_value));
3561 std::string s = IMMEDIATE(copy(s_value));
3562 std::string rs = GPR(copy(rs_value));
3563
3564 return img::format("CACHEE %s, %s(%s)", op, s, rs);
3565 }
3566
3567
3568 /*
3569 *
3570 *
3571 * 3 2 1
3572 * 10987654321098765432109876543210
3573 * 001000 x1110000101
3574 * rt -----
3575 * rs -----
3576 * rd -----
3577 */
3578 std::string NMD::CEIL_L_D(uint64 instruction)
3579 {
3580 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3581 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3582
3583 std::string ft = FPR(copy(ft_value));
3584 std::string fs = FPR(copy(fs_value));
3585
3586 return img::format("CEIL.L.D %s, %s", ft, fs);
3587 }
3588
3589
3590 /*
3591 *
3592 *
3593 * 3 2 1
3594 * 10987654321098765432109876543210
3595 * 001000 x1110000101
3596 * rt -----
3597 * rs -----
3598 * rd -----
3599 */
3600 std::string NMD::CEIL_L_S(uint64 instruction)
3601 {
3602 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3603 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3604
3605 std::string ft = FPR(copy(ft_value));
3606 std::string fs = FPR(copy(fs_value));
3607
3608 return img::format("CEIL.L.S %s, %s", ft, fs);
3609 }
3610
3611
3612 /*
3613 *
3614 *
3615 * 3 2 1
3616 * 10987654321098765432109876543210
3617 * 001000 x1110000101
3618 * rt -----
3619 * rs -----
3620 * rd -----
3621 */
3622 std::string NMD::CEIL_W_D(uint64 instruction)
3623 {
3624 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3625 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3626
3627 std::string ft = FPR(copy(ft_value));
3628 std::string fs = FPR(copy(fs_value));
3629
3630 return img::format("CEIL.W.D %s, %s", ft, fs);
3631 }
3632
3633
3634 /*
3635 *
3636 *
3637 * 3 2 1
3638 * 10987654321098765432109876543210
3639 * 001000 x1110000101
3640 * rt -----
3641 * rs -----
3642 * rd -----
3643 */
3644 std::string NMD::CEIL_W_S(uint64 instruction)
3645 {
3646 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3647 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3648
3649 std::string ft = FPR(copy(ft_value));
3650 std::string fs = FPR(copy(fs_value));
3651
3652 return img::format("CEIL.W.S %s, %s", ft, fs);
3653 }
3654
3655
3656 /*
3657 *
3658 *
3659 * 3 2 1
3660 * 10987654321098765432109876543210
3661 * 001000 x1110000101
3662 * rt -----
3663 * rs -----
3664 * rd -----
3665 */
3666 std::string NMD::CFC1(uint64 instruction)
3667 {
3668 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3669 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3670
3671 std::string rt = GPR(copy(rt_value));
3672 std::string cs = CPR(copy(cs_value));
3673
3674 return img::format("CFC1 %s, %s", rt, cs);
3675 }
3676
3677
3678 /*
3679 *
3680 *
3681 * 3 2 1
3682 * 10987654321098765432109876543210
3683 * 001000 x1110000101
3684 * rt -----
3685 * rs -----
3686 * rd -----
3687 */
3688 std::string NMD::CFC2(uint64 instruction)
3689 {
3690 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3691 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3692
3693 std::string rt = GPR(copy(rt_value));
3694 std::string cs = CPR(copy(cs_value));
3695
3696 return img::format("CFC2 %s, %s", rt, cs);
3697 }
3698
3699
3700 /*
3701 *
3702 *
3703 * 3 2 1
3704 * 10987654321098765432109876543210
3705 * 001000 x1110000101
3706 * rt -----
3707 * rs -----
3708 * rd -----
3709 */
3710 std::string NMD::CLASS_D(uint64 instruction)
3711 {
3712 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3713 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3714
3715 std::string ft = FPR(copy(ft_value));
3716 std::string fs = FPR(copy(fs_value));
3717
3718 return img::format("CLASS.D %s, %s", ft, fs);
3719 }
3720
3721
3722 /*
3723 *
3724 *
3725 * 3 2 1
3726 * 10987654321098765432109876543210
3727 * 001000 x1110000101
3728 * rt -----
3729 * rs -----
3730 * rd -----
3731 */
3732 std::string NMD::CLASS_S(uint64 instruction)
3733 {
3734 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3735 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3736
3737 std::string ft = FPR(copy(ft_value));
3738 std::string fs = FPR(copy(fs_value));
3739
3740 return img::format("CLASS.S %s, %s", ft, fs);
3741 }
3742
3743
3744 /*
3745 *
3746 *
3747 * 3 2 1
3748 * 10987654321098765432109876543210
3749 * 001000 x1110000101
3750 * rt -----
3751 * rs -----
3752 * rd -----
3753 */
3754 std::string NMD::CLO(uint64 instruction)
3755 {
3756 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3757 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3758
3759 std::string rt = GPR(copy(rt_value));
3760 std::string rs = GPR(copy(rs_value));
3761
3762 return img::format("CLO %s, %s", rt, rs);
3763 }
3764
3765
3766 /*
3767 *
3768 *
3769 * 3 2 1
3770 * 10987654321098765432109876543210
3771 * 001000 x1110000101
3772 * rt -----
3773 * rs -----
3774 * rd -----
3775 */
3776 std::string NMD::CLZ(uint64 instruction)
3777 {
3778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3779 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3780
3781 std::string rt = GPR(copy(rt_value));
3782 std::string rs = GPR(copy(rs_value));
3783
3784 return img::format("CLZ %s, %s", rt, rs);
3785 }
3786
3787
3788 /*
3789 *
3790 *
3791 * 3 2 1
3792 * 10987654321098765432109876543210
3793 * 001000 x1110000101
3794 * rt -----
3795 * rs -----
3796 * rd -----
3797 */
3798 std::string NMD::CMP_AF_D(uint64 instruction)
3799 {
3800 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3801 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3802 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3803
3804 std::string fd = FPR(copy(fd_value));
3805 std::string fs = FPR(copy(fs_value));
3806 std::string ft = FPR(copy(ft_value));
3807
3808 return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3809 }
3810
3811
3812 /*
3813 *
3814 *
3815 * 3 2 1
3816 * 10987654321098765432109876543210
3817 * 001000 x1110000101
3818 * rt -----
3819 * rs -----
3820 * rd -----
3821 */
3822 std::string NMD::CMP_AF_S(uint64 instruction)
3823 {
3824 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3825 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3826 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3827
3828 std::string fd = FPR(copy(fd_value));
3829 std::string fs = FPR(copy(fs_value));
3830 std::string ft = FPR(copy(ft_value));
3831
3832 return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3833 }
3834
3835
3836 /*
3837 *
3838 *
3839 * 3 2 1
3840 * 10987654321098765432109876543210
3841 * 001000 x1110000101
3842 * rt -----
3843 * rs -----
3844 * rd -----
3845 */
3846 std::string NMD::CMP_EQ_D(uint64 instruction)
3847 {
3848 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3849 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3850 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3851
3852 std::string fd = FPR(copy(fd_value));
3853 std::string fs = FPR(copy(fs_value));
3854 std::string ft = FPR(copy(ft_value));
3855
3856 return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3857 }
3858
3859
3860 /*
3861 *
3862 *
3863 * 3 2 1
3864 * 10987654321098765432109876543210
3865 * 001000 x1110000101
3866 * rt -----
3867 * rs -----
3868 * rd -----
3869 */
3870 std::string NMD::CMP_EQ_PH(uint64 instruction)
3871 {
3872 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3873 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3874
3875 std::string rs = GPR(copy(rs_value));
3876 std::string rt = GPR(copy(rt_value));
3877
3878 return img::format("CMP.EQ.PH %s, %s", rs, rt);
3879 }
3880
3881
3882 /*
3883 *
3884 *
3885 * 3 2 1
3886 * 10987654321098765432109876543210
3887 * 001000 x1110000101
3888 * rt -----
3889 * rs -----
3890 * rd -----
3891 */
3892 std::string NMD::CMP_EQ_S(uint64 instruction)
3893 {
3894 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3895 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3896 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3897
3898 std::string fd = FPR(copy(fd_value));
3899 std::string fs = FPR(copy(fs_value));
3900 std::string ft = FPR(copy(ft_value));
3901
3902 return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3903 }
3904
3905
3906 /*
3907 *
3908 *
3909 * 3 2 1
3910 * 10987654321098765432109876543210
3911 * 001000 x1110000101
3912 * rt -----
3913 * rs -----
3914 * rd -----
3915 */
3916 std::string NMD::CMP_LE_D(uint64 instruction)
3917 {
3918 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3919 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3920 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3921
3922 std::string fd = FPR(copy(fd_value));
3923 std::string fs = FPR(copy(fs_value));
3924 std::string ft = FPR(copy(ft_value));
3925
3926 return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3927 }
3928
3929
3930 /*
3931 *
3932 *
3933 * 3 2 1
3934 * 10987654321098765432109876543210
3935 * 001000 x1110000101
3936 * rt -----
3937 * rs -----
3938 * rd -----
3939 */
3940 std::string NMD::CMP_LE_PH(uint64 instruction)
3941 {
3942 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3943 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3944
3945 std::string rs = GPR(copy(rs_value));
3946 std::string rt = GPR(copy(rt_value));
3947
3948 return img::format("CMP.LE.PH %s, %s", rs, rt);
3949 }
3950
3951
3952 /*
3953 *
3954 *
3955 * 3 2 1
3956 * 10987654321098765432109876543210
3957 * 001000 x1110000101
3958 * rt -----
3959 * rs -----
3960 * rd -----
3961 */
3962 std::string NMD::CMP_LE_S(uint64 instruction)
3963 {
3964 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3965 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3966 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3967
3968 std::string fd = FPR(copy(fd_value));
3969 std::string fs = FPR(copy(fs_value));
3970 std::string ft = FPR(copy(ft_value));
3971
3972 return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3973 }
3974
3975
3976 /*
3977 *
3978 *
3979 * 3 2 1
3980 * 10987654321098765432109876543210
3981 * 001000 x1110000101
3982 * rt -----
3983 * rs -----
3984 * rd -----
3985 */
3986 std::string NMD::CMP_LT_D(uint64 instruction)
3987 {
3988 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3989 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3990 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3991
3992 std::string fd = FPR(copy(fd_value));
3993 std::string fs = FPR(copy(fs_value));
3994 std::string ft = FPR(copy(ft_value));
3995
3996 return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
3997 }
3998
3999
4000 /*
4001 *
4002 *
4003 * 3 2 1
4004 * 10987654321098765432109876543210
4005 * 001000 x1110000101
4006 * rt -----
4007 * rs -----
4008 * rd -----
4009 */
4010 std::string NMD::CMP_LT_PH(uint64 instruction)
4011 {
4012 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4013 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4014
4015 std::string rs = GPR(copy(rs_value));
4016 std::string rt = GPR(copy(rt_value));
4017
4018 return img::format("CMP.LT.PH %s, %s", rs, rt);
4019 }
4020
4021
4022 /*
4023 *
4024 *
4025 * 3 2 1
4026 * 10987654321098765432109876543210
4027 * 001000 x1110000101
4028 * rt -----
4029 * rs -----
4030 * rd -----
4031 */
4032 std::string NMD::CMP_LT_S(uint64 instruction)
4033 {
4034 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4035 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4036 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4037
4038 std::string fd = FPR(copy(fd_value));
4039 std::string fs = FPR(copy(fs_value));
4040 std::string ft = FPR(copy(ft_value));
4041
4042 return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
4043 }
4044
4045
4046 /*
4047 *
4048 *
4049 * 3 2 1
4050 * 10987654321098765432109876543210
4051 * 001000 x1110000101
4052 * rt -----
4053 * rs -----
4054 * rd -----
4055 */
4056 std::string NMD::CMP_NE_D(uint64 instruction)
4057 {
4058 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4059 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4060 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4061
4062 std::string fd = FPR(copy(fd_value));
4063 std::string fs = FPR(copy(fs_value));
4064 std::string ft = FPR(copy(ft_value));
4065
4066 return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
4067 }
4068
4069
4070 /*
4071 *
4072 *
4073 * 3 2 1
4074 * 10987654321098765432109876543210
4075 * 001000 x1110000101
4076 * rt -----
4077 * rs -----
4078 * rd -----
4079 */
4080 std::string NMD::CMP_NE_S(uint64 instruction)
4081 {
4082 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4083 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4084 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4085
4086 std::string fd = FPR(copy(fd_value));
4087 std::string fs = FPR(copy(fs_value));
4088 std::string ft = FPR(copy(ft_value));
4089
4090 return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
4091 }
4092
4093
4094 /*
4095 *
4096 *
4097 * 3 2 1
4098 * 10987654321098765432109876543210
4099 * 001000 x1110000101
4100 * rt -----
4101 * rs -----
4102 * rd -----
4103 */
4104 std::string NMD::CMP_OR_D(uint64 instruction)
4105 {
4106 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4107 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4108 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4109
4110 std::string fd = FPR(copy(fd_value));
4111 std::string fs = FPR(copy(fs_value));
4112 std::string ft = FPR(copy(ft_value));
4113
4114 return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
4115 }
4116
4117
4118 /*
4119 *
4120 *
4121 * 3 2 1
4122 * 10987654321098765432109876543210
4123 * 001000 x1110000101
4124 * rt -----
4125 * rs -----
4126 * rd -----
4127 */
4128 std::string NMD::CMP_OR_S(uint64 instruction)
4129 {
4130 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4131 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4132 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4133
4134 std::string fd = FPR(copy(fd_value));
4135 std::string fs = FPR(copy(fs_value));
4136 std::string ft = FPR(copy(ft_value));
4137
4138 return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
4139 }
4140
4141
4142 /*
4143 *
4144 *
4145 * 3 2 1
4146 * 10987654321098765432109876543210
4147 * 001000 x1110000101
4148 * rt -----
4149 * rs -----
4150 * rd -----
4151 */
4152 std::string NMD::CMP_SAF_D(uint64 instruction)
4153 {
4154 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4155 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4156 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4157
4158 std::string fd = FPR(copy(fd_value));
4159 std::string fs = FPR(copy(fs_value));
4160 std::string ft = FPR(copy(ft_value));
4161
4162 return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
4163 }
4164
4165
4166 /*
4167 *
4168 *
4169 * 3 2 1
4170 * 10987654321098765432109876543210
4171 * 001000 x1110000101
4172 * rt -----
4173 * rs -----
4174 * rd -----
4175 */
4176 std::string NMD::CMP_SAF_S(uint64 instruction)
4177 {
4178 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4179 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4180 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4181
4182 std::string fd = FPR(copy(fd_value));
4183 std::string fs = FPR(copy(fs_value));
4184 std::string ft = FPR(copy(ft_value));
4185
4186 return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
4187 }
4188
4189
4190 /*
4191 *
4192 *
4193 * 3 2 1
4194 * 10987654321098765432109876543210
4195 * 001000 x1110000101
4196 * rt -----
4197 * rs -----
4198 * rd -----
4199 */
4200 std::string NMD::CMP_SEQ_D(uint64 instruction)
4201 {
4202 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4203 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4204 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4205
4206 std::string fd = FPR(copy(fd_value));
4207 std::string fs = FPR(copy(fs_value));
4208 std::string ft = FPR(copy(ft_value));
4209
4210 return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
4211 }
4212
4213
4214 /*
4215 *
4216 *
4217 * 3 2 1
4218 * 10987654321098765432109876543210
4219 * 001000 x1110000101
4220 * rt -----
4221 * rs -----
4222 * rd -----
4223 */
4224 std::string NMD::CMP_SEQ_S(uint64 instruction)
4225 {
4226 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4227 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4228 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4229
4230 std::string fd = FPR(copy(fd_value));
4231 std::string fs = FPR(copy(fs_value));
4232 std::string ft = FPR(copy(ft_value));
4233
4234 return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
4235 }
4236
4237
4238 /*
4239 *
4240 *
4241 * 3 2 1
4242 * 10987654321098765432109876543210
4243 * 001000 x1110000101
4244 * rt -----
4245 * rs -----
4246 * rd -----
4247 */
4248 std::string NMD::CMP_SLE_D(uint64 instruction)
4249 {
4250 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4251 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4252 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4253
4254 std::string fd = FPR(copy(fd_value));
4255 std::string fs = FPR(copy(fs_value));
4256 std::string ft = FPR(copy(ft_value));
4257
4258 return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
4259 }
4260
4261
4262 /*
4263 *
4264 *
4265 * 3 2 1
4266 * 10987654321098765432109876543210
4267 * 001000 x1110000101
4268 * rt -----
4269 * rs -----
4270 * rd -----
4271 */
4272 std::string NMD::CMP_SLE_S(uint64 instruction)
4273 {
4274 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4275 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4276 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4277
4278 std::string fd = FPR(copy(fd_value));
4279 std::string fs = FPR(copy(fs_value));
4280 std::string ft = FPR(copy(ft_value));
4281
4282 return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
4283 }
4284
4285
4286 /*
4287 *
4288 *
4289 * 3 2 1
4290 * 10987654321098765432109876543210
4291 * 001000 x1110000101
4292 * rt -----
4293 * rs -----
4294 * rd -----
4295 */
4296 std::string NMD::CMP_SLT_D(uint64 instruction)
4297 {
4298 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4299 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4300 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4301
4302 std::string fd = FPR(copy(fd_value));
4303 std::string fs = FPR(copy(fs_value));
4304 std::string ft = FPR(copy(ft_value));
4305
4306 return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4307 }
4308
4309
4310 /*
4311 *
4312 *
4313 * 3 2 1
4314 * 10987654321098765432109876543210
4315 * 001000 x1110000101
4316 * rt -----
4317 * rs -----
4318 * rd -----
4319 */
4320 std::string NMD::CMP_SLT_S(uint64 instruction)
4321 {
4322 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4323 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4324 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4325
4326 std::string fd = FPR(copy(fd_value));
4327 std::string fs = FPR(copy(fs_value));
4328 std::string ft = FPR(copy(ft_value));
4329
4330 return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4331 }
4332
4333
4334 /*
4335 *
4336 *
4337 * 3 2 1
4338 * 10987654321098765432109876543210
4339 * 001000 x1110000101
4340 * rt -----
4341 * rs -----
4342 * rd -----
4343 */
4344 std::string NMD::CMP_SNE_D(uint64 instruction)
4345 {
4346 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4347 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4348 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4349
4350 std::string fd = FPR(copy(fd_value));
4351 std::string fs = FPR(copy(fs_value));
4352 std::string ft = FPR(copy(ft_value));
4353
4354 return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4355 }
4356
4357
4358 /*
4359 *
4360 *
4361 * 3 2 1
4362 * 10987654321098765432109876543210
4363 * 001000 x1110000101
4364 * rt -----
4365 * rs -----
4366 * rd -----
4367 */
4368 std::string NMD::CMP_SNE_S(uint64 instruction)
4369 {
4370 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4371 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4372 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4373
4374 std::string fd = FPR(copy(fd_value));
4375 std::string fs = FPR(copy(fs_value));
4376 std::string ft = FPR(copy(ft_value));
4377
4378 return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4379 }
4380
4381
4382 /*
4383 *
4384 *
4385 * 3 2 1
4386 * 10987654321098765432109876543210
4387 * 001000 x1110000101
4388 * rt -----
4389 * rs -----
4390 * rd -----
4391 */
4392 std::string NMD::CMP_SOR_D(uint64 instruction)
4393 {
4394 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4395 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4396 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4397
4398 std::string fd = FPR(copy(fd_value));
4399 std::string fs = FPR(copy(fs_value));
4400 std::string ft = FPR(copy(ft_value));
4401
4402 return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4403 }
4404
4405
4406 /*
4407 *
4408 *
4409 * 3 2 1
4410 * 10987654321098765432109876543210
4411 * 001000 x1110000101
4412 * rt -----
4413 * rs -----
4414 * rd -----
4415 */
4416 std::string NMD::CMP_SOR_S(uint64 instruction)
4417 {
4418 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4419 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4420 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4421
4422 std::string fd = FPR(copy(fd_value));
4423 std::string fs = FPR(copy(fs_value));
4424 std::string ft = FPR(copy(ft_value));
4425
4426 return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4427 }
4428
4429
4430 /*
4431 *
4432 *
4433 * 3 2 1
4434 * 10987654321098765432109876543210
4435 * 001000 x1110000101
4436 * rt -----
4437 * rs -----
4438 * rd -----
4439 */
4440 std::string NMD::CMP_SUEQ_D(uint64 instruction)
4441 {
4442 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4443 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4444 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4445
4446 std::string fd = FPR(copy(fd_value));
4447 std::string fs = FPR(copy(fs_value));
4448 std::string ft = FPR(copy(ft_value));
4449
4450 return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4451 }
4452
4453
4454 /*
4455 *
4456 *
4457 * 3 2 1
4458 * 10987654321098765432109876543210
4459 * 001000 x1110000101
4460 * rt -----
4461 * rs -----
4462 * rd -----
4463 */
4464 std::string NMD::CMP_SUEQ_S(uint64 instruction)
4465 {
4466 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4467 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4468 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4469
4470 std::string fd = FPR(copy(fd_value));
4471 std::string fs = FPR(copy(fs_value));
4472 std::string ft = FPR(copy(ft_value));
4473
4474 return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4475 }
4476
4477
4478 /*
4479 *
4480 *
4481 * 3 2 1
4482 * 10987654321098765432109876543210
4483 * 001000 x1110000101
4484 * rt -----
4485 * rs -----
4486 * rd -----
4487 */
4488 std::string NMD::CMP_SULE_D(uint64 instruction)
4489 {
4490 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4491 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4492 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4493
4494 std::string fd = FPR(copy(fd_value));
4495 std::string fs = FPR(copy(fs_value));
4496 std::string ft = FPR(copy(ft_value));
4497
4498 return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4499 }
4500
4501
4502 /*
4503 *
4504 *
4505 * 3 2 1
4506 * 10987654321098765432109876543210
4507 * 001000 x1110000101
4508 * rt -----
4509 * rs -----
4510 * rd -----
4511 */
4512 std::string NMD::CMP_SULE_S(uint64 instruction)
4513 {
4514 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4515 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4516 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4517
4518 std::string fd = FPR(copy(fd_value));
4519 std::string fs = FPR(copy(fs_value));
4520 std::string ft = FPR(copy(ft_value));
4521
4522 return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4523 }
4524
4525
4526 /*
4527 *
4528 *
4529 * 3 2 1
4530 * 10987654321098765432109876543210
4531 * 001000 x1110000101
4532 * rt -----
4533 * rs -----
4534 * rd -----
4535 */
4536 std::string NMD::CMP_SULT_D(uint64 instruction)
4537 {
4538 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4539 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4540 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4541
4542 std::string fd = FPR(copy(fd_value));
4543 std::string fs = FPR(copy(fs_value));
4544 std::string ft = FPR(copy(ft_value));
4545
4546 return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4547 }
4548
4549
4550 /*
4551 *
4552 *
4553 * 3 2 1
4554 * 10987654321098765432109876543210
4555 * 001000 x1110000101
4556 * rt -----
4557 * rs -----
4558 * rd -----
4559 */
4560 std::string NMD::CMP_SULT_S(uint64 instruction)
4561 {
4562 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4563 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4564 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4565
4566 std::string fd = FPR(copy(fd_value));
4567 std::string fs = FPR(copy(fs_value));
4568 std::string ft = FPR(copy(ft_value));
4569
4570 return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4571 }
4572
4573
4574 /*
4575 *
4576 *
4577 * 3 2 1
4578 * 10987654321098765432109876543210
4579 * 001000 x1110000101
4580 * rt -----
4581 * rs -----
4582 * rd -----
4583 */
4584 std::string NMD::CMP_SUN_D(uint64 instruction)
4585 {
4586 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4587 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4588 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4589
4590 std::string fd = FPR(copy(fd_value));
4591 std::string fs = FPR(copy(fs_value));
4592 std::string ft = FPR(copy(ft_value));
4593
4594 return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4595 }
4596
4597
4598 /*
4599 *
4600 *
4601 * 3 2 1
4602 * 10987654321098765432109876543210
4603 * 001000 x1110000101
4604 * rt -----
4605 * rs -----
4606 * rd -----
4607 */
4608 std::string NMD::CMP_SUNE_D(uint64 instruction)
4609 {
4610 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4611 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4612 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4613
4614 std::string fd = FPR(copy(fd_value));
4615 std::string fs = FPR(copy(fs_value));
4616 std::string ft = FPR(copy(ft_value));
4617
4618 return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4619 }
4620
4621
4622 /*
4623 *
4624 *
4625 * 3 2 1
4626 * 10987654321098765432109876543210
4627 * 001000 x1110000101
4628 * rt -----
4629 * rs -----
4630 * rd -----
4631 */
4632 std::string NMD::CMP_SUNE_S(uint64 instruction)
4633 {
4634 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4635 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4636 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4637
4638 std::string fd = FPR(copy(fd_value));
4639 std::string fs = FPR(copy(fs_value));
4640 std::string ft = FPR(copy(ft_value));
4641
4642 return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4643 }
4644
4645
4646 /*
4647 *
4648 *
4649 * 3 2 1
4650 * 10987654321098765432109876543210
4651 * 001000 x1110000101
4652 * rt -----
4653 * rs -----
4654 * rd -----
4655 */
4656 std::string NMD::CMP_SUN_S(uint64 instruction)
4657 {
4658 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4659 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4660 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4661
4662 std::string fd = FPR(copy(fd_value));
4663 std::string fs = FPR(copy(fs_value));
4664 std::string ft = FPR(copy(ft_value));
4665
4666 return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4667 }
4668
4669
4670 /*
4671 *
4672 *
4673 * 3 2 1
4674 * 10987654321098765432109876543210
4675 * 001000 x1110000101
4676 * rt -----
4677 * rs -----
4678 * rd -----
4679 */
4680 std::string NMD::CMP_UEQ_D(uint64 instruction)
4681 {
4682 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4683 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4684 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4685
4686 std::string fd = FPR(copy(fd_value));
4687 std::string fs = FPR(copy(fs_value));
4688 std::string ft = FPR(copy(ft_value));
4689
4690 return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4691 }
4692
4693
4694 /*
4695 *
4696 *
4697 * 3 2 1
4698 * 10987654321098765432109876543210
4699 * 001000 x1110000101
4700 * rt -----
4701 * rs -----
4702 * rd -----
4703 */
4704 std::string NMD::CMP_UEQ_S(uint64 instruction)
4705 {
4706 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4707 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4708 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4709
4710 std::string fd = FPR(copy(fd_value));
4711 std::string fs = FPR(copy(fs_value));
4712 std::string ft = FPR(copy(ft_value));
4713
4714 return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4715 }
4716
4717
4718 /*
4719 *
4720 *
4721 * 3 2 1
4722 * 10987654321098765432109876543210
4723 * 001000 x1110000101
4724 * rt -----
4725 * rs -----
4726 * rd -----
4727 */
4728 std::string NMD::CMP_ULE_D(uint64 instruction)
4729 {
4730 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4731 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4732 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4733
4734 std::string fd = FPR(copy(fd_value));
4735 std::string fs = FPR(copy(fs_value));
4736 std::string ft = FPR(copy(ft_value));
4737
4738 return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4739 }
4740
4741
4742 /*
4743 *
4744 *
4745 * 3 2 1
4746 * 10987654321098765432109876543210
4747 * 001000 x1110000101
4748 * rt -----
4749 * rs -----
4750 * rd -----
4751 */
4752 std::string NMD::CMP_ULE_S(uint64 instruction)
4753 {
4754 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4755 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4756 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4757
4758 std::string fd = FPR(copy(fd_value));
4759 std::string fs = FPR(copy(fs_value));
4760 std::string ft = FPR(copy(ft_value));
4761
4762 return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4763 }
4764
4765
4766 /*
4767 *
4768 *
4769 * 3 2 1
4770 * 10987654321098765432109876543210
4771 * 001000 x1110000101
4772 * rt -----
4773 * rs -----
4774 * rd -----
4775 */
4776 std::string NMD::CMP_ULT_D(uint64 instruction)
4777 {
4778 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4779 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4780 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4781
4782 std::string fd = FPR(copy(fd_value));
4783 std::string fs = FPR(copy(fs_value));
4784 std::string ft = FPR(copy(ft_value));
4785
4786 return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4787 }
4788
4789
4790 /*
4791 *
4792 *
4793 * 3 2 1
4794 * 10987654321098765432109876543210
4795 * 001000 x1110000101
4796 * rt -----
4797 * rs -----
4798 * rd -----
4799 */
4800 std::string NMD::CMP_ULT_S(uint64 instruction)
4801 {
4802 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4803 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4804 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4805
4806 std::string fd = FPR(copy(fd_value));
4807 std::string fs = FPR(copy(fs_value));
4808 std::string ft = FPR(copy(ft_value));
4809
4810 return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4811 }
4812
4813
4814 /*
4815 *
4816 *
4817 * 3 2 1
4818 * 10987654321098765432109876543210
4819 * 001000 x1110000101
4820 * rt -----
4821 * rs -----
4822 * rd -----
4823 */
4824 std::string NMD::CMP_UN_D(uint64 instruction)
4825 {
4826 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4827 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4828 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4829
4830 std::string fd = FPR(copy(fd_value));
4831 std::string fs = FPR(copy(fs_value));
4832 std::string ft = FPR(copy(ft_value));
4833
4834 return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4835 }
4836
4837
4838 /*
4839 *
4840 *
4841 * 3 2 1
4842 * 10987654321098765432109876543210
4843 * 001000 x1110000101
4844 * rt -----
4845 * rs -----
4846 * rd -----
4847 */
4848 std::string NMD::CMP_UNE_D(uint64 instruction)
4849 {
4850 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4851 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4852 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4853
4854 std::string fd = FPR(copy(fd_value));
4855 std::string fs = FPR(copy(fs_value));
4856 std::string ft = FPR(copy(ft_value));
4857
4858 return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4859 }
4860
4861
4862 /*
4863 *
4864 *
4865 * 3 2 1
4866 * 10987654321098765432109876543210
4867 * 001000 x1110000101
4868 * rt -----
4869 * rs -----
4870 * rd -----
4871 */
4872 std::string NMD::CMP_UNE_S(uint64 instruction)
4873 {
4874 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4875 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4876 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4877
4878 std::string fd = FPR(copy(fd_value));
4879 std::string fs = FPR(copy(fs_value));
4880 std::string ft = FPR(copy(ft_value));
4881
4882 return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4883 }
4884
4885
4886 /*
4887 *
4888 *
4889 * 3 2 1
4890 * 10987654321098765432109876543210
4891 * 001000 x1110000101
4892 * rt -----
4893 * rs -----
4894 * rd -----
4895 */
4896 std::string NMD::CMP_UN_S(uint64 instruction)
4897 {
4898 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4899 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4900 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4901
4902 std::string fd = FPR(copy(fd_value));
4903 std::string fs = FPR(copy(fs_value));
4904 std::string ft = FPR(copy(ft_value));
4905
4906 return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4907 }
4908
4909
4910 /*
4911 *
4912 *
4913 * 3 2 1
4914 * 10987654321098765432109876543210
4915 * 001000 x1110000101
4916 * rt -----
4917 * rs -----
4918 * rd -----
4919 */
4920 std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
4921 {
4922 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4923 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4924 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4925
4926 std::string rd = GPR(copy(rd_value));
4927 std::string rs = GPR(copy(rs_value));
4928 std::string rt = GPR(copy(rt_value));
4929
4930 return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4931 }
4932
4933
4934 /*
4935 *
4936 *
4937 * 3 2 1
4938 * 10987654321098765432109876543210
4939 * 001000 x1110000101
4940 * rt -----
4941 * rs -----
4942 * rd -----
4943 */
4944 std::string NMD::CMPGDU_LE_QB(uint64 instruction)
4945 {
4946 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4947 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4948 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4949
4950 std::string rd = GPR(copy(rd_value));
4951 std::string rs = GPR(copy(rs_value));
4952 std::string rt = GPR(copy(rt_value));
4953
4954 return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4955 }
4956
4957
4958 /*
4959 *
4960 *
4961 * 3 2 1
4962 * 10987654321098765432109876543210
4963 * 001000 x1110000101
4964 * rt -----
4965 * rs -----
4966 * rd -----
4967 */
4968 std::string NMD::CMPGDU_LT_QB(uint64 instruction)
4969 {
4970 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4971 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4972 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4973
4974 std::string rd = GPR(copy(rd_value));
4975 std::string rs = GPR(copy(rs_value));
4976 std::string rt = GPR(copy(rt_value));
4977
4978 return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4979 }
4980
4981
4982 /*
4983 *
4984 *
4985 * 3 2 1
4986 * 10987654321098765432109876543210
4987 * 001000 x1110000101
4988 * rt -----
4989 * rs -----
4990 * rd -----
4991 */
4992 std::string NMD::CMPGU_EQ_QB(uint64 instruction)
4993 {
4994 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4995 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4996 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4997
4998 std::string rd = GPR(copy(rd_value));
4999 std::string rs = GPR(copy(rs_value));
5000 std::string rt = GPR(copy(rt_value));
5001
5002 return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
5003 }
5004
5005
5006 /*
5007 *
5008 *
5009 * 3 2 1
5010 * 10987654321098765432109876543210
5011 * 001000 x1110000101
5012 * rt -----
5013 * rs -----
5014 * rd -----
5015 */
5016 std::string NMD::CMPGU_LE_QB(uint64 instruction)
5017 {
5018 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5019 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5020 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5021
5022 std::string rd = GPR(copy(rd_value));
5023 std::string rs = GPR(copy(rs_value));
5024 std::string rt = GPR(copy(rt_value));
5025
5026 return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
5027 }
5028
5029
5030 /*
5031 *
5032 *
5033 * 3 2 1
5034 * 10987654321098765432109876543210
5035 * 001000 x1110000101
5036 * rt -----
5037 * rs -----
5038 * rd -----
5039 */
5040 std::string NMD::CMPGU_LT_QB(uint64 instruction)
5041 {
5042 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5043 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5044 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5045
5046 std::string rd = GPR(copy(rd_value));
5047 std::string rs = GPR(copy(rs_value));
5048 std::string rt = GPR(copy(rt_value));
5049
5050 return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
5051 }
5052
5053
5054 /*
5055 *
5056 *
5057 * 3 2 1
5058 * 10987654321098765432109876543210
5059 * 001000 x1110000101
5060 * rt -----
5061 * rs -----
5062 * rd -----
5063 */
5064 std::string NMD::CMPU_EQ_QB(uint64 instruction)
5065 {
5066 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5067 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5068
5069 std::string rs = GPR(copy(rs_value));
5070 std::string rt = GPR(copy(rt_value));
5071
5072 return img::format("CMPU.EQ.QB %s, %s", rs, rt);
5073 }
5074
5075
5076 /*
5077 *
5078 *
5079 * 3 2 1
5080 * 10987654321098765432109876543210
5081 * 001000 x1110000101
5082 * rt -----
5083 * rs -----
5084 * rd -----
5085 */
5086 std::string NMD::CMPU_LE_QB(uint64 instruction)
5087 {
5088 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5089 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5090
5091 std::string rs = GPR(copy(rs_value));
5092 std::string rt = GPR(copy(rt_value));
5093
5094 return img::format("CMPU.LE.QB %s, %s", rs, rt);
5095 }
5096
5097
5098 /*
5099 *
5100 *
5101 * 3 2 1
5102 * 10987654321098765432109876543210
5103 * 001000 x1110000101
5104 * rt -----
5105 * rs -----
5106 * rd -----
5107 */
5108 std::string NMD::CMPU_LT_QB(uint64 instruction)
5109 {
5110 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5111 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5112
5113 std::string rs = GPR(copy(rs_value));
5114 std::string rt = GPR(copy(rt_value));
5115
5116 return img::format("CMPU.LT.QB %s, %s", rs, rt);
5117 }
5118
5119
5120 /*
5121 *
5122 *
5123 * 3 2 1
5124 * 10987654321098765432109876543210
5125 * 001000 x1110000101
5126 * rt -----
5127 * rs -----
5128 * rd -----
5129 */
5130 std::string NMD::COP2_1(uint64 instruction)
5131 {
5132 uint64 cofun_value = extract_cofun_25_24_23(instruction);
5133
5134 std::string cofun = IMMEDIATE(copy(cofun_value));
5135
5136 return img::format("COP2_1 %s", cofun);
5137 }
5138
5139
5140 /*
5141 *
5142 *
5143 * 3 2 1
5144 * 10987654321098765432109876543210
5145 * 001000 x1110000101
5146 * rt -----
5147 * rs -----
5148 * rd -----
5149 */
5150 std::string NMD::CTC1(uint64 instruction)
5151 {
5152 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5153 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5154
5155 std::string rt = GPR(copy(rt_value));
5156 std::string cs = CPR(copy(cs_value));
5157
5158 return img::format("CTC1 %s, %s", rt, cs);
5159 }
5160
5161
5162 /*
5163 *
5164 *
5165 * 3 2 1
5166 * 10987654321098765432109876543210
5167 * 001000 x1110000101
5168 * rt -----
5169 * rs -----
5170 * rd -----
5171 */
5172 std::string NMD::CTC2(uint64 instruction)
5173 {
5174 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5175 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5176
5177 std::string rt = GPR(copy(rt_value));
5178 std::string cs = CPR(copy(cs_value));
5179
5180 return img::format("CTC2 %s, %s", rt, cs);
5181 }
5182
5183
5184 /*
5185 *
5186 *
5187 * 3 2 1
5188 * 10987654321098765432109876543210
5189 * 001000 x1110000101
5190 * rt -----
5191 * rs -----
5192 * rd -----
5193 */
5194 std::string NMD::CVT_D_L(uint64 instruction)
5195 {
5196 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5197 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5198
5199 std::string ft = FPR(copy(ft_value));
5200 std::string fs = FPR(copy(fs_value));
5201
5202 return img::format("CVT.D.L %s, %s", ft, fs);
5203 }
5204
5205
5206 /*
5207 *
5208 *
5209 * 3 2 1
5210 * 10987654321098765432109876543210
5211 * 001000 x1110000101
5212 * rt -----
5213 * rs -----
5214 * rd -----
5215 */
5216 std::string NMD::CVT_D_S(uint64 instruction)
5217 {
5218 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5219 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5220
5221 std::string ft = FPR(copy(ft_value));
5222 std::string fs = FPR(copy(fs_value));
5223
5224 return img::format("CVT.D.S %s, %s", ft, fs);
5225 }
5226
5227
5228 /*
5229 *
5230 *
5231 * 3 2 1
5232 * 10987654321098765432109876543210
5233 * 001000 x1110000101
5234 * rt -----
5235 * rs -----
5236 * rd -----
5237 */
5238 std::string NMD::CVT_D_W(uint64 instruction)
5239 {
5240 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5241 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5242
5243 std::string ft = FPR(copy(ft_value));
5244 std::string fs = FPR(copy(fs_value));
5245
5246 return img::format("CVT.D.W %s, %s", ft, fs);
5247 }
5248
5249
5250 /*
5251 *
5252 *
5253 * 3 2 1
5254 * 10987654321098765432109876543210
5255 * 001000 x1110000101
5256 * rt -----
5257 * rs -----
5258 * rd -----
5259 */
5260 std::string NMD::CVT_L_D(uint64 instruction)
5261 {
5262 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5263 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5264
5265 std::string ft = FPR(copy(ft_value));
5266 std::string fs = FPR(copy(fs_value));
5267
5268 return img::format("CVT.L.D %s, %s", ft, fs);
5269 }
5270
5271
5272 /*
5273 *
5274 *
5275 * 3 2 1
5276 * 10987654321098765432109876543210
5277 * 001000 x1110000101
5278 * rt -----
5279 * rs -----
5280 * rd -----
5281 */
5282 std::string NMD::CVT_L_S(uint64 instruction)
5283 {
5284 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5285 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5286
5287 std::string ft = FPR(copy(ft_value));
5288 std::string fs = FPR(copy(fs_value));
5289
5290 return img::format("CVT.L.S %s, %s", ft, fs);
5291 }
5292
5293
5294 /*
5295 *
5296 *
5297 * 3 2 1
5298 * 10987654321098765432109876543210
5299 * 001000 x1110000101
5300 * rt -----
5301 * rs -----
5302 * rd -----
5303 */
5304 std::string NMD::CVT_S_D(uint64 instruction)
5305 {
5306 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5307 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5308
5309 std::string ft = FPR(copy(ft_value));
5310 std::string fs = FPR(copy(fs_value));
5311
5312 return img::format("CVT.S.D %s, %s", ft, fs);
5313 }
5314
5315
5316 /*
5317 *
5318 *
5319 * 3 2 1
5320 * 10987654321098765432109876543210
5321 * 001000 x1110000101
5322 * rt -----
5323 * rs -----
5324 * rd -----
5325 */
5326 std::string NMD::CVT_S_L(uint64 instruction)
5327 {
5328 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5329 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5330
5331 std::string ft = FPR(copy(ft_value));
5332 std::string fs = FPR(copy(fs_value));
5333
5334 return img::format("CVT.S.L %s, %s", ft, fs);
5335 }
5336
5337
5338 /*
5339 *
5340 *
5341 * 3 2 1
5342 * 10987654321098765432109876543210
5343 * 001000 x1110000101
5344 * rt -----
5345 * rs -----
5346 * rd -----
5347 */
5348 std::string NMD::CVT_S_PL(uint64 instruction)
5349 {
5350 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5351 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5352
5353 std::string ft = FPR(copy(ft_value));
5354 std::string fs = FPR(copy(fs_value));
5355
5356 return img::format("CVT.S.PL %s, %s", ft, fs);
5357 }
5358
5359
5360 /*
5361 *
5362 *
5363 * 3 2 1
5364 * 10987654321098765432109876543210
5365 * 001000 x1110000101
5366 * rt -----
5367 * rs -----
5368 * rd -----
5369 */
5370 std::string NMD::CVT_S_PU(uint64 instruction)
5371 {
5372 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5373 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5374
5375 std::string ft = FPR(copy(ft_value));
5376 std::string fs = FPR(copy(fs_value));
5377
5378 return img::format("CVT.S.PU %s, %s", ft, fs);
5379 }
5380
5381
5382 /*
5383 *
5384 *
5385 * 3 2 1
5386 * 10987654321098765432109876543210
5387 * 001000 x1110000101
5388 * rt -----
5389 * rs -----
5390 * rd -----
5391 */
5392 std::string NMD::CVT_S_W(uint64 instruction)
5393 {
5394 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5395 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5396
5397 std::string ft = FPR(copy(ft_value));
5398 std::string fs = FPR(copy(fs_value));
5399
5400 return img::format("CVT.S.W %s, %s", ft, fs);
5401 }
5402
5403
5404 /*
5405 *
5406 *
5407 * 3 2 1
5408 * 10987654321098765432109876543210
5409 * 001000 x1110000101
5410 * rt -----
5411 * rs -----
5412 * rd -----
5413 */
5414 std::string NMD::CVT_W_D(uint64 instruction)
5415 {
5416 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5417 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5418
5419 std::string ft = FPR(copy(ft_value));
5420 std::string fs = FPR(copy(fs_value));
5421
5422 return img::format("CVT.W.D %s, %s", ft, fs);
5423 }
5424
5425
5426 /*
5427 *
5428 *
5429 * 3 2 1
5430 * 10987654321098765432109876543210
5431 * 001000 x1110000101
5432 * rt -----
5433 * rs -----
5434 * rd -----
5435 */
5436 std::string NMD::CVT_W_S(uint64 instruction)
5437 {
5438 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5439 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5440
5441 std::string ft = FPR(copy(ft_value));
5442 std::string fs = FPR(copy(fs_value));
5443
5444 return img::format("CVT.W.S %s, %s", ft, fs);
5445 }
5446
5447
5448 /*
5449 *
5450 *
5451 * 3 2 1
5452 * 10987654321098765432109876543210
5453 * 001000 x1110000101
5454 * rt -----
5455 * rs -----
5456 * rd -----
5457 */
5458 std::string NMD::DADDIU_48_(uint64 instruction)
5459 {
5460 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5461 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
5462
5463 std::string rt = GPR(copy(rt_value));
5464 std::string s = IMMEDIATE(copy(s_value));
5465
5466 return img::format("DADDIU %s, %s", rt, s);
5467 }
5468
5469
5470 /*
5471 *
5472 *
5473 * 3 2 1
5474 * 10987654321098765432109876543210
5475 * 001000 x1110000101
5476 * rt -----
5477 * rs -----
5478 * rd -----
5479 */
5480 std::string NMD::DADDIU_NEG_(uint64 instruction)
5481 {
5482 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5483 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5484 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5485
5486 std::string rt = GPR(copy(rt_value));
5487 std::string rs = GPR(copy(rs_value));
5488 std::string u = IMMEDIATE(neg_copy(u_value));
5489
5490 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5491 }
5492
5493
5494 /*
5495 *
5496 *
5497 * 3 2 1
5498 * 10987654321098765432109876543210
5499 * 001000 x1110000101
5500 * rt -----
5501 * rs -----
5502 * rd -----
5503 */
5504 std::string NMD::DADDIU_U12_(uint64 instruction)
5505 {
5506 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5507 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5508 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5509
5510 std::string rt = GPR(copy(rt_value));
5511 std::string rs = GPR(copy(rs_value));
5512 std::string u = IMMEDIATE(copy(u_value));
5513
5514 return img::format("DADDIU %s, %s, %s", rt, rs, u);
5515 }
5516
5517
5518 /*
5519 *
5520 *
5521 * 3 2 1
5522 * 10987654321098765432109876543210
5523 * 001000 x1110000101
5524 * rt -----
5525 * rs -----
5526 * rd -----
5527 */
5528 std::string NMD::DADD(uint64 instruction)
5529 {
5530 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5531 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5532 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5533
5534 std::string rd = GPR(copy(rd_value));
5535 std::string rs = GPR(copy(rs_value));
5536 std::string rt = GPR(copy(rt_value));
5537
5538 return img::format("DADD %s, %s, %s", rd, rs, rt);
5539 }
5540
5541
5542 /*
5543 *
5544 *
5545 * 3 2 1
5546 * 10987654321098765432109876543210
5547 * 001000 x1110000101
5548 * rt -----
5549 * rs -----
5550 * rd -----
5551 */
5552 std::string NMD::DADDU(uint64 instruction)
5553 {
5554 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5555 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5556 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5557
5558 std::string rd = GPR(copy(rd_value));
5559 std::string rs = GPR(copy(rs_value));
5560 std::string rt = GPR(copy(rt_value));
5561
5562 return img::format("DADDU %s, %s, %s", rd, rs, rt);
5563 }
5564
5565
5566 /*
5567 *
5568 *
5569 * 3 2 1
5570 * 10987654321098765432109876543210
5571 * 001000 x1110000101
5572 * rt -----
5573 * rs -----
5574 * rd -----
5575 */
5576 std::string NMD::DCLO(uint64 instruction)
5577 {
5578 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5579 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5580
5581 std::string rt = GPR(copy(rt_value));
5582 std::string rs = GPR(copy(rs_value));
5583
5584 return img::format("DCLO %s, %s", rt, rs);
5585 }
5586
5587
5588 /*
5589 *
5590 *
5591 * 3 2 1
5592 * 10987654321098765432109876543210
5593 * 001000 x1110000101
5594 * rt -----
5595 * rs -----
5596 * rd -----
5597 */
5598 std::string NMD::DCLZ(uint64 instruction)
5599 {
5600 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5602
5603 std::string rt = GPR(copy(rt_value));
5604 std::string rs = GPR(copy(rs_value));
5605
5606 return img::format("DCLZ %s, %s", rt, rs);
5607 }
5608
5609
5610 /*
5611 *
5612 *
5613 * 3 2 1
5614 * 10987654321098765432109876543210
5615 * 001000 x1110000101
5616 * rt -----
5617 * rs -----
5618 * rd -----
5619 */
5620 std::string NMD::DDIV(uint64 instruction)
5621 {
5622 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5624 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5625
5626 std::string rd = GPR(copy(rd_value));
5627 std::string rs = GPR(copy(rs_value));
5628 std::string rt = GPR(copy(rt_value));
5629
5630 return img::format("DDIV %s, %s, %s", rd, rs, rt);
5631 }
5632
5633
5634 /*
5635 *
5636 *
5637 * 3 2 1
5638 * 10987654321098765432109876543210
5639 * 001000 x1110000101
5640 * rt -----
5641 * rs -----
5642 * rd -----
5643 */
5644 std::string NMD::DDIVU(uint64 instruction)
5645 {
5646 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5647 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5648 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5649
5650 std::string rd = GPR(copy(rd_value));
5651 std::string rs = GPR(copy(rs_value));
5652 std::string rt = GPR(copy(rt_value));
5653
5654 return img::format("DDIVU %s, %s, %s", rd, rs, rt);
5655 }
5656
5657
5658 /*
5659 *
5660 *
5661 * 3 2 1
5662 * 10987654321098765432109876543210
5663 * 001000 x1110000101
5664 * rt -----
5665 * rs -----
5666 * rd -----
5667 */
5668 std::string NMD::DERET(uint64 instruction)
5669 {
5670 (void)instruction;
5671
5672 return "DERET ";
5673 }
5674
5675
5676 /*
5677 *
5678 *
5679 * 3 2 1
5680 * 10987654321098765432109876543210
5681 * 001000 x1110000101
5682 * rt -----
5683 * rs -----
5684 * rd -----
5685 */
5686 std::string NMD::DEXTM(uint64 instruction)
5687 {
5688 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5689 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5690 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5691 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5692
5693 std::string rt = GPR(copy(rt_value));
5694 std::string rs = GPR(copy(rs_value));
5695 std::string lsb = IMMEDIATE(copy(lsb_value));
5696 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5697
5698 return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
5699 }
5700
5701
5702 /*
5703 *
5704 *
5705 * 3 2 1
5706 * 10987654321098765432109876543210
5707 * 001000 x1110000101
5708 * rt -----
5709 * rs -----
5710 * rd -----
5711 */
5712 std::string NMD::DEXT(uint64 instruction)
5713 {
5714 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5715 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5716 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5717 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5718
5719 std::string rt = GPR(copy(rt_value));
5720 std::string rs = GPR(copy(rs_value));
5721 std::string lsb = IMMEDIATE(copy(lsb_value));
5722 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5723
5724 return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
5725 }
5726
5727
5728 /*
5729 *
5730 *
5731 * 3 2 1
5732 * 10987654321098765432109876543210
5733 * 001000 x1110000101
5734 * rt -----
5735 * rs -----
5736 * rd -----
5737 */
5738 std::string NMD::DEXTU(uint64 instruction)
5739 {
5740 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5741 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5742 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5743 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5744
5745 std::string rt = GPR(copy(rt_value));
5746 std::string rs = GPR(copy(rs_value));
5747 std::string lsb = IMMEDIATE(copy(lsb_value));
5748 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
5749
5750 return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
5751 }
5752
5753
5754 /*
5755 *
5756 *
5757 * 3 2 1
5758 * 10987654321098765432109876543210
5759 * 001000 x1110000101
5760 * rt -----
5761 * rs -----
5762 * rd -----
5763 */
5764 std::string NMD::DINSM(uint64 instruction)
5765 {
5766 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5767 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5768 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5769 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5770
5771 std::string rt = GPR(copy(rt_value));
5772 std::string rs = GPR(copy(rs_value));
5773 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5774 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5775 /* !!!!!!!!!! - no conversion function */
5776
5777 return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
5778 /* hand edited */
5779 }
5780
5781
5782 /*
5783 *
5784 *
5785 * 3 2 1
5786 * 10987654321098765432109876543210
5787 * 001000 x1110000101
5788 * rt -----
5789 * rs -----
5790 * rd -----
5791 */
5792 std::string NMD::DINS(uint64 instruction)
5793 {
5794 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5795 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5796 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5797 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5798
5799 std::string rt = GPR(copy(rt_value));
5800 std::string rs = GPR(copy(rs_value));
5801 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5802 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5803 /* !!!!!!!!!! - no conversion function */
5804
5805 return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
5806 /* hand edited */
5807 }
5808
5809
5810 /*
5811 *
5812 *
5813 * 3 2 1
5814 * 10987654321098765432109876543210
5815 * 001000 x1110000101
5816 * rt -----
5817 * rs -----
5818 * rd -----
5819 */
5820 std::string NMD::DINSU(uint64 instruction)
5821 {
5822 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5823 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5824 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5825 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5826
5827 std::string rt = GPR(copy(rt_value));
5828 std::string rs = GPR(copy(rs_value));
5829 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
5830 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
5831 /* !!!!!!!!!! - no conversion function */
5832
5833 return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
5834 /* hand edited */
5835 }
5836
5837
5838 /*
5839 *
5840 *
5841 * 3 2 1
5842 * 10987654321098765432109876543210
5843 * 001000 x1110000101
5844 * rt -----
5845 * rs -----
5846 * rd -----
5847 */
5848 std::string NMD::DI(uint64 instruction)
5849 {
5850 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5851
5852 std::string rt = GPR(copy(rt_value));
5853
5854 return img::format("DI %s", rt);
5855 }
5856
5857
5858 /*
5859 *
5860 *
5861 * 3 2 1
5862 * 10987654321098765432109876543210
5863 * 001000 x1110000101
5864 * rt -----
5865 * rs -----
5866 * rd -----
5867 */
5868 std::string NMD::DIV(uint64 instruction)
5869 {
5870 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5871 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5872 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5873
5874 std::string rd = GPR(copy(rd_value));
5875 std::string rs = GPR(copy(rs_value));
5876 std::string rt = GPR(copy(rt_value));
5877
5878 return img::format("DIV %s, %s, %s", rd, rs, rt);
5879 }
5880
5881
5882 /*
5883 *
5884 *
5885 * 3 2 1
5886 * 10987654321098765432109876543210
5887 * 001000 x1110000101
5888 * rt -----
5889 * rs -----
5890 * rd -----
5891 */
5892 std::string NMD::DIV_D(uint64 instruction)
5893 {
5894 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5895 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5896 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5897
5898 std::string fd = FPR(copy(fd_value));
5899 std::string fs = FPR(copy(fs_value));
5900 std::string ft = FPR(copy(ft_value));
5901
5902 return img::format("DIV.D %s, %s, %s", fd, fs, ft);
5903 }
5904
5905
5906 /*
5907 *
5908 *
5909 * 3 2 1
5910 * 10987654321098765432109876543210
5911 * 001000 x1110000101
5912 * rt -----
5913 * rs -----
5914 * rd -----
5915 */
5916 std::string NMD::DIV_S(uint64 instruction)
5917 {
5918 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5919 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5920 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5921
5922 std::string fd = FPR(copy(fd_value));
5923 std::string fs = FPR(copy(fs_value));
5924 std::string ft = FPR(copy(ft_value));
5925
5926 return img::format("DIV.S %s, %s, %s", fd, fs, ft);
5927 }
5928
5929
5930 /*
5931 *
5932 *
5933 * 3 2 1
5934 * 10987654321098765432109876543210
5935 * 001000 x1110000101
5936 * rt -----
5937 * rs -----
5938 * rd -----
5939 */
5940 std::string NMD::DIVU(uint64 instruction)
5941 {
5942 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5943 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5944 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5945
5946 std::string rd = GPR(copy(rd_value));
5947 std::string rs = GPR(copy(rs_value));
5948 std::string rt = GPR(copy(rt_value));
5949
5950 return img::format("DIVU %s, %s, %s", rd, rs, rt);
5951 }
5952
5953
5954 /*
5955 *
5956 *
5957 * 3 2 1
5958 * 10987654321098765432109876543210
5959 * 001000 x1110000101
5960 * rt -----
5961 * rs -----
5962 * rd -----
5963 */
5964 std::string NMD::DLSA(uint64 instruction)
5965 {
5966 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5967 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5968 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5969 uint64 u2_value = extract_u2_10_9(instruction);
5970
5971 std::string rd = GPR(copy(rd_value));
5972 std::string rs = GPR(copy(rs_value));
5973 std::string rt = GPR(copy(rt_value));
5974 std::string u2 = IMMEDIATE(copy(u2_value));
5975
5976 return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
5977 }
5978
5979
5980 /*
5981 *
5982 *
5983 * 3 2 1
5984 * 10987654321098765432109876543210
5985 * 001000 x1110000101
5986 * rt -----
5987 * rs -----
5988 * rd -----
5989 */
5990 std::string NMD::DLUI_48_(uint64 instruction)
5991 {
5992 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5993 uint64 u_value = extract_u_31_to_0__s32(instruction);
5994
5995 std::string rt = GPR(copy(rt_value));
5996 std::string u = IMMEDIATE(copy(u_value));
5997
5998 return img::format("DLUI %s, %s", rt, u);
5999 }
6000
6001
6002 /*
6003 *
6004 *
6005 * 3 2 1
6006 * 10987654321098765432109876543210
6007 * 001000 x1110000101
6008 * rt -----
6009 * rs -----
6010 * rd -----
6011 */
6012 std::string NMD::DMFC0(uint64 instruction)
6013 {
6014 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6015 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6016 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6017
6018 std::string rt = GPR(copy(rt_value));
6019 std::string c0s = CPR(copy(c0s_value));
6020 std::string sel = IMMEDIATE(copy(sel_value));
6021
6022 return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
6023 }
6024
6025
6026 /*
6027 *
6028 *
6029 * 3 2 1
6030 * 10987654321098765432109876543210
6031 * 001000 x1110000101
6032 * rt -----
6033 * rs -----
6034 * rd -----
6035 */
6036 std::string NMD::DMFC1(uint64 instruction)
6037 {
6038 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6039 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
6040
6041 std::string rt = GPR(copy(rt_value));
6042 std::string fs = FPR(copy(fs_value));
6043
6044 return img::format("DMFC1 %s, %s", rt, fs);
6045 }
6046
6047
6048 /*
6049 *
6050 *
6051 * 3 2 1
6052 * 10987654321098765432109876543210
6053 * 001000 x1110000101
6054 * rt -----
6055 * rs -----
6056 * rd -----
6057 */
6058 std::string NMD::DMFC2(uint64 instruction)
6059 {
6060 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6061 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6062
6063 std::string rt = GPR(copy(rt_value));
6064 std::string cs = CPR(copy(cs_value));
6065
6066 return img::format("DMFC2 %s, %s", rt, cs);
6067 }
6068
6069
6070 /*
6071 *
6072 *
6073 * 3 2 1
6074 * 10987654321098765432109876543210
6075 * 001000 x1110000101
6076 * rt -----
6077 * rs -----
6078 * rd -----
6079 */
6080 std::string NMD::DMFGC0(uint64 instruction)
6081 {
6082 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6083 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6084 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6085
6086 std::string rt = GPR(copy(rt_value));
6087 std::string c0s = CPR(copy(c0s_value));
6088 std::string sel = IMMEDIATE(copy(sel_value));
6089
6090 return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
6091 }
6092
6093
6094 /*
6095 *
6096 *
6097 * 3 2 1
6098 * 10987654321098765432109876543210
6099 * 001000 x1110000101
6100 * rt -----
6101 * rs -----
6102 * rd -----
6103 */
6104 std::string NMD::DMOD(uint64 instruction)
6105 {
6106 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6107 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6108 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6109
6110 std::string rd = GPR(copy(rd_value));
6111 std::string rs = GPR(copy(rs_value));
6112 std::string rt = GPR(copy(rt_value));
6113
6114 return img::format("DMOD %s, %s, %s", rd, rs, rt);
6115 }
6116
6117
6118 /*
6119 *
6120 *
6121 * 3 2 1
6122 * 10987654321098765432109876543210
6123 * 001000 x1110000101
6124 * rt -----
6125 * rs -----
6126 * rd -----
6127 */
6128 std::string NMD::DMODU(uint64 instruction)
6129 {
6130 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6131 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6132 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6133
6134 std::string rd = GPR(copy(rd_value));
6135 std::string rs = GPR(copy(rs_value));
6136 std::string rt = GPR(copy(rt_value));
6137
6138 return img::format("DMODU %s, %s, %s", rd, rs, rt);
6139 }
6140
6141
6142 /*
6143 *
6144 *
6145 * 3 2 1
6146 * 10987654321098765432109876543210
6147 * 001000 x1110000101
6148 * rt -----
6149 * rs -----
6150 * rd -----
6151 */
6152 std::string NMD::DMTC0(uint64 instruction)
6153 {
6154 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6155 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6156 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6157
6158 std::string rt = GPR(copy(rt_value));
6159 std::string c0s = CPR(copy(c0s_value));
6160 std::string sel = IMMEDIATE(copy(sel_value));
6161
6162 return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
6163 }
6164
6165
6166 /*
6167 *
6168 *
6169 * 3 2 1
6170 * 10987654321098765432109876543210
6171 * 001000 x1110000101
6172 * rt -----
6173 * rs -----
6174 * rd -----
6175 */
6176 std::string NMD::DMTC1(uint64 instruction)
6177 {
6178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6179 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
6180
6181 std::string rt = GPR(copy(rt_value));
6182 std::string fs = FPR(copy(fs_value));
6183
6184 return img::format("DMTC1 %s, %s", rt, fs);
6185 }
6186
6187
6188 /*
6189 *
6190 *
6191 * 3 2 1
6192 * 10987654321098765432109876543210
6193 * 001000 x1110000101
6194 * rt -----
6195 * rs -----
6196 * rd -----
6197 */
6198 std::string NMD::DMTC2(uint64 instruction)
6199 {
6200 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6201 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
6202
6203 std::string rt = GPR(copy(rt_value));
6204 std::string cs = CPR(copy(cs_value));
6205
6206 return img::format("DMTC2 %s, %s", rt, cs);
6207 }
6208
6209
6210 /*
6211 *
6212 *
6213 * 3 2 1
6214 * 10987654321098765432109876543210
6215 * 001000 x1110000101
6216 * rt -----
6217 * rs -----
6218 * rd -----
6219 */
6220 std::string NMD::DMTGC0(uint64 instruction)
6221 {
6222 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6223 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
6224 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
6225
6226 std::string rt = GPR(copy(rt_value));
6227 std::string c0s = CPR(copy(c0s_value));
6228 std::string sel = IMMEDIATE(copy(sel_value));
6229
6230 return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
6231 }
6232
6233
6234 /*
6235 *
6236 *
6237 * 3 2 1
6238 * 10987654321098765432109876543210
6239 * 001000 x1110000101
6240 * rt -----
6241 * rs -----
6242 * rd -----
6243 */
6244 std::string NMD::DMT(uint64 instruction)
6245 {
6246 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6247
6248 std::string rt = GPR(copy(rt_value));
6249
6250 return img::format("DMT %s", rt);
6251 }
6252
6253
6254 /*
6255 *
6256 *
6257 * 3 2 1
6258 * 10987654321098765432109876543210
6259 * 001000 x1110000101
6260 * rt -----
6261 * rs -----
6262 * rd -----
6263 */
6264 std::string NMD::DMUH(uint64 instruction)
6265 {
6266 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6267 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6268 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6269
6270 std::string rd = GPR(copy(rd_value));
6271 std::string rs = GPR(copy(rs_value));
6272 std::string rt = GPR(copy(rt_value));
6273
6274 return img::format("DMUH %s, %s, %s", rd, rs, rt);
6275 }
6276
6277
6278 /*
6279 *
6280 *
6281 * 3 2 1
6282 * 10987654321098765432109876543210
6283 * 001000 x1110000101
6284 * rt -----
6285 * rs -----
6286 * rd -----
6287 */
6288 std::string NMD::DMUHU(uint64 instruction)
6289 {
6290 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6291 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6292 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6293
6294 std::string rd = GPR(copy(rd_value));
6295 std::string rs = GPR(copy(rs_value));
6296 std::string rt = GPR(copy(rt_value));
6297
6298 return img::format("DMUHU %s, %s, %s", rd, rs, rt);
6299 }
6300
6301
6302 /*
6303 *
6304 *
6305 * 3 2 1
6306 * 10987654321098765432109876543210
6307 * 001000 x1110000101
6308 * rt -----
6309 * rs -----
6310 * rd -----
6311 */
6312 std::string NMD::DMUL(uint64 instruction)
6313 {
6314 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6315 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6316 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6317
6318 std::string rd = GPR(copy(rd_value));
6319 std::string rs = GPR(copy(rs_value));
6320 std::string rt = GPR(copy(rt_value));
6321
6322 return img::format("DMUL %s, %s, %s", rd, rs, rt);
6323 }
6324
6325
6326 /*
6327 *
6328 *
6329 * 3 2 1
6330 * 10987654321098765432109876543210
6331 * 001000 x1110000101
6332 * rt -----
6333 * rs -----
6334 * rd -----
6335 */
6336 std::string NMD::DMULU(uint64 instruction)
6337 {
6338 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6339 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6340 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6341
6342 std::string rd = GPR(copy(rd_value));
6343 std::string rs = GPR(copy(rs_value));
6344 std::string rt = GPR(copy(rt_value));
6345
6346 return img::format("DMULU %s, %s, %s", rd, rs, rt);
6347 }
6348
6349
6350 /*
6351 *
6352 *
6353 * 3 2 1
6354 * 10987654321098765432109876543210
6355 * 001000 x1110000101
6356 * rt -----
6357 * rs -----
6358 * rd -----
6359 */
6360 std::string NMD::DPA_W_PH(uint64 instruction)
6361 {
6362 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6363 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6364 uint64 ac_value = extract_ac_13_12(instruction);
6365
6366 std::string ac = AC(copy(ac_value));
6367 std::string rs = GPR(copy(rs_value));
6368 std::string rt = GPR(copy(rt_value));
6369
6370 return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6371 }
6372
6373
6374 /*
6375 *
6376 *
6377 * 3 2 1
6378 * 10987654321098765432109876543210
6379 * 001000 x1110000101
6380 * rt -----
6381 * rs -----
6382 * rd -----
6383 */
6384 std::string NMD::DPAQ_SA_L_W(uint64 instruction)
6385 {
6386 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6387 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6388 uint64 ac_value = extract_ac_13_12(instruction);
6389
6390 std::string ac = AC(copy(ac_value));
6391 std::string rs = GPR(copy(rs_value));
6392 std::string rt = GPR(copy(rt_value));
6393
6394 return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6395 }
6396
6397
6398 /*
6399 *
6400 *
6401 * 3 2 1
6402 * 10987654321098765432109876543210
6403 * 001000 x1110000101
6404 * rt -----
6405 * rs -----
6406 * rd -----
6407 */
6408 std::string NMD::DPAQ_S_W_PH(uint64 instruction)
6409 {
6410 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6411 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6412 uint64 ac_value = extract_ac_13_12(instruction);
6413
6414 std::string ac = AC(copy(ac_value));
6415 std::string rs = GPR(copy(rs_value));
6416 std::string rt = GPR(copy(rt_value));
6417
6418 return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6419 }
6420
6421
6422 /*
6423 *
6424 *
6425 * 3 2 1
6426 * 10987654321098765432109876543210
6427 * 001000 x1110000101
6428 * rt -----
6429 * rs -----
6430 * rd -----
6431 */
6432 std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
6433 {
6434 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6435 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6436 uint64 ac_value = extract_ac_13_12(instruction);
6437
6438 std::string ac = AC(copy(ac_value));
6439 std::string rs = GPR(copy(rs_value));
6440 std::string rt = GPR(copy(rt_value));
6441
6442 return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6443 }
6444
6445
6446 /*
6447 *
6448 *
6449 * 3 2 1
6450 * 10987654321098765432109876543210
6451 * 001000 x1110000101
6452 * rt -----
6453 * rs -----
6454 * rd -----
6455 */
6456 std::string NMD::DPAQX_S_W_PH(uint64 instruction)
6457 {
6458 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6459 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6460 uint64 ac_value = extract_ac_13_12(instruction);
6461
6462 std::string ac = AC(copy(ac_value));
6463 std::string rs = GPR(copy(rs_value));
6464 std::string rt = GPR(copy(rt_value));
6465
6466 return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6467 }
6468
6469
6470 /*
6471 *
6472 *
6473 * 3 2 1
6474 * 10987654321098765432109876543210
6475 * 001000 x1110000101
6476 * rt -----
6477 * rs -----
6478 * rd -----
6479 */
6480 std::string NMD::DPAU_H_QBL(uint64 instruction)
6481 {
6482 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6483 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6484 uint64 ac_value = extract_ac_13_12(instruction);
6485
6486 std::string ac = AC(copy(ac_value));
6487 std::string rs = GPR(copy(rs_value));
6488 std::string rt = GPR(copy(rt_value));
6489
6490 return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6491 }
6492
6493
6494 /*
6495 *
6496 *
6497 * 3 2 1
6498 * 10987654321098765432109876543210
6499 * 001000 x1110000101
6500 * rt -----
6501 * rs -----
6502 * rd -----
6503 */
6504 std::string NMD::DPAU_H_QBR(uint64 instruction)
6505 {
6506 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6507 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6508 uint64 ac_value = extract_ac_13_12(instruction);
6509
6510 std::string ac = AC(copy(ac_value));
6511 std::string rs = GPR(copy(rs_value));
6512 std::string rt = GPR(copy(rt_value));
6513
6514 return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6515 }
6516
6517
6518 /*
6519 *
6520 *
6521 * 3 2 1
6522 * 10987654321098765432109876543210
6523 * 001000 x1110000101
6524 * rt -----
6525 * rs -----
6526 * rd -----
6527 */
6528 std::string NMD::DPAX_W_PH(uint64 instruction)
6529 {
6530 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6531 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6532 uint64 ac_value = extract_ac_13_12(instruction);
6533
6534 std::string ac = AC(copy(ac_value));
6535 std::string rs = GPR(copy(rs_value));
6536 std::string rt = GPR(copy(rt_value));
6537
6538 return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6539 }
6540
6541
6542 /*
6543 *
6544 *
6545 * 3 2 1
6546 * 10987654321098765432109876543210
6547 * 001000 x1110000101
6548 * rt -----
6549 * rs -----
6550 * rd -----
6551 */
6552 std::string NMD::DPS_W_PH(uint64 instruction)
6553 {
6554 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6555 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6556 uint64 ac_value = extract_ac_13_12(instruction);
6557
6558 std::string ac = AC(copy(ac_value));
6559 std::string rs = GPR(copy(rs_value));
6560 std::string rt = GPR(copy(rt_value));
6561
6562 return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6563 }
6564
6565
6566 /*
6567 *
6568 *
6569 * 3 2 1
6570 * 10987654321098765432109876543210
6571 * 001000 x1110000101
6572 * rt -----
6573 * rs -----
6574 * rd -----
6575 */
6576 std::string NMD::DPSQ_SA_L_W(uint64 instruction)
6577 {
6578 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6579 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6580 uint64 ac_value = extract_ac_13_12(instruction);
6581
6582 std::string ac = AC(copy(ac_value));
6583 std::string rs = GPR(copy(rs_value));
6584 std::string rt = GPR(copy(rt_value));
6585
6586 return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6587 }
6588
6589
6590 /*
6591 *
6592 *
6593 * 3 2 1
6594 * 10987654321098765432109876543210
6595 * 001000 x1110000101
6596 * rt -----
6597 * rs -----
6598 * rd -----
6599 */
6600 std::string NMD::DPSQ_S_W_PH(uint64 instruction)
6601 {
6602 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6603 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6604 uint64 ac_value = extract_ac_13_12(instruction);
6605
6606 std::string ac = AC(copy(ac_value));
6607 std::string rs = GPR(copy(rs_value));
6608 std::string rt = GPR(copy(rt_value));
6609
6610 return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6611 }
6612
6613
6614 /*
6615 *
6616 *
6617 * 3 2 1
6618 * 10987654321098765432109876543210
6619 * 001000 x1110000101
6620 * rt -----
6621 * rs -----
6622 * rd -----
6623 */
6624 std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
6625 {
6626 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6627 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6628 uint64 ac_value = extract_ac_13_12(instruction);
6629
6630 std::string ac = AC(copy(ac_value));
6631 std::string rs = GPR(copy(rs_value));
6632 std::string rt = GPR(copy(rt_value));
6633
6634 return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6635 }
6636
6637
6638 /*
6639 *
6640 *
6641 * 3 2 1
6642 * 10987654321098765432109876543210
6643 * 001000 x1110000101
6644 * rt -----
6645 * rs -----
6646 * rd -----
6647 */
6648 std::string NMD::DPSQX_S_W_PH(uint64 instruction)
6649 {
6650 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6651 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6652 uint64 ac_value = extract_ac_13_12(instruction);
6653
6654 std::string ac = AC(copy(ac_value));
6655 std::string rs = GPR(copy(rs_value));
6656 std::string rt = GPR(copy(rt_value));
6657
6658 return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6659 }
6660
6661
6662 /*
6663 *
6664 *
6665 * 3 2 1
6666 * 10987654321098765432109876543210
6667 * 001000 x1110000101
6668 * rt -----
6669 * rs -----
6670 * rd -----
6671 */
6672 std::string NMD::DPSU_H_QBL(uint64 instruction)
6673 {
6674 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6675 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6676 uint64 ac_value = extract_ac_13_12(instruction);
6677
6678 std::string ac = AC(copy(ac_value));
6679 std::string rs = GPR(copy(rs_value));
6680 std::string rt = GPR(copy(rt_value));
6681
6682 return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6683 }
6684
6685
6686 /*
6687 *
6688 *
6689 * 3 2 1
6690 * 10987654321098765432109876543210
6691 * 001000 x1110000101
6692 * rt -----
6693 * rs -----
6694 * rd -----
6695 */
6696 std::string NMD::DPSU_H_QBR(uint64 instruction)
6697 {
6698 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6699 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6700 uint64 ac_value = extract_ac_13_12(instruction);
6701
6702 std::string ac = AC(copy(ac_value));
6703 std::string rs = GPR(copy(rs_value));
6704 std::string rt = GPR(copy(rt_value));
6705
6706 return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6707 }
6708
6709
6710 /*
6711 *
6712 *
6713 * 3 2 1
6714 * 10987654321098765432109876543210
6715 * 001000 x1110000101
6716 * rt -----
6717 * rs -----
6718 * rd -----
6719 */
6720 std::string NMD::DPSX_W_PH(uint64 instruction)
6721 {
6722 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6723 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6724 uint64 ac_value = extract_ac_13_12(instruction);
6725
6726 std::string ac = AC(copy(ac_value));
6727 std::string rs = GPR(copy(rs_value));
6728 std::string rt = GPR(copy(rt_value));
6729
6730 return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6731 }
6732
6733
6734 /*
6735 * DROTR -
6736 *
6737 * 3 2 1
6738 * 10987654321098765432109876543210
6739 * 001000 x1110000101
6740 * rt -----
6741 * rs -----
6742 * rd -----
6743 */
6744 std::string NMD::DROTR(uint64 instruction)
6745 {
6746 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6747 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6748 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6749
6750 std::string rt = GPR(copy(rt_value));
6751 std::string rs = GPR(copy(rs_value));
6752 std::string shift = IMMEDIATE(copy(shift_value));
6753
6754 return img::format("DROTR %s, %s, %s", rt, rs, shift);
6755 }
6756
6757
6758 /*
6759 * DROTR[32] -
6760 *
6761 * 3 2 1
6762 * 10987654321098765432109876543210
6763 * 10o000 1100xxx0110
6764 * rt -----
6765 * rs -----
6766 * shift -----
6767 */
6768 std::string NMD::DROTR32(uint64 instruction)
6769 {
6770 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6771 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6772 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6773
6774 std::string rt = GPR(copy(rt_value));
6775 std::string rs = GPR(copy(rs_value));
6776 std::string shift = IMMEDIATE(copy(shift_value));
6777
6778 return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
6779 }
6780
6781
6782 /*
6783 *
6784 *
6785 * 3 2 1
6786 * 10987654321098765432109876543210
6787 * 001000 x1110000101
6788 * rt -----
6789 * rs -----
6790 * rd -----
6791 */
6792 std::string NMD::DROTRV(uint64 instruction)
6793 {
6794 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6795 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6796 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6797
6798 std::string rd = GPR(copy(rd_value));
6799 std::string rs = GPR(copy(rs_value));
6800 std::string rt = GPR(copy(rt_value));
6801
6802 return img::format("DROTRV %s, %s, %s", rd, rs, rt);
6803 }
6804
6805
6806 /*
6807 *
6808 *
6809 * 3 2 1
6810 * 10987654321098765432109876543210
6811 * 001000 x1110000101
6812 * rt -----
6813 * rs -----
6814 * rd -----
6815 */
6816 std::string NMD::DROTX(uint64 instruction)
6817 {
6818 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6819 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6820 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6821 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6822
6823 std::string rt = GPR(copy(rt_value));
6824 std::string rs = GPR(copy(rs_value));
6825 std::string shift = IMMEDIATE(copy(shift_value));
6826 std::string shiftx = IMMEDIATE(copy(shiftx_value));
6827
6828 return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
6829 }
6830
6831
6832 /*
6833 * DSLL -
6834 *
6835 * 3 2 1
6836 * 10987654321098765432109876543210
6837 * 10o000 1100xxx0000
6838 * rt -----
6839 * rs -----
6840 * shift -----
6841 */
6842 std::string NMD::DSLL(uint64 instruction)
6843 {
6844 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6845 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6846 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6847
6848 std::string rt = GPR(copy(rt_value));
6849 std::string rs = GPR(copy(rs_value));
6850 std::string shift = IMMEDIATE(copy(shift_value));
6851
6852 return img::format("DSLL %s, %s, %s", rt, rs, shift);
6853 }
6854
6855
6856 /*
6857 * DSLL[32] -
6858 *
6859 * 3 2 1
6860 * 10987654321098765432109876543210
6861 * 10o000 1100xxx0000
6862 * rt -----
6863 * rs -----
6864 * shift -----
6865 */
6866 std::string NMD::DSLL32(uint64 instruction)
6867 {
6868 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6869 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6870 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6871
6872 std::string rt = GPR(copy(rt_value));
6873 std::string rs = GPR(copy(rs_value));
6874 std::string shift = IMMEDIATE(copy(shift_value));
6875
6876 return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
6877 }
6878
6879
6880 /*
6881 *
6882 *
6883 * 3 2 1
6884 * 10987654321098765432109876543210
6885 * 001000 x1110000101
6886 * rt -----
6887 * rs -----
6888 * rd -----
6889 */
6890 std::string NMD::DSLLV(uint64 instruction)
6891 {
6892 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6893 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6894 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6895
6896 std::string rd = GPR(copy(rd_value));
6897 std::string rs = GPR(copy(rs_value));
6898 std::string rt = GPR(copy(rt_value));
6899
6900 return img::format("DSLLV %s, %s, %s", rd, rs, rt);
6901 }
6902
6903
6904 /*
6905 * DSRA -
6906 *
6907 * 3 2 1
6908 * 10987654321098765432109876543210
6909 * 10o000 1100xxx0100
6910 * rt -----
6911 * rs -----
6912 * shift -----
6913 */
6914 std::string NMD::DSRA(uint64 instruction)
6915 {
6916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6917 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6918 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6919
6920 std::string rt = GPR(copy(rt_value));
6921 std::string rs = GPR(copy(rs_value));
6922 std::string shift = IMMEDIATE(copy(shift_value));
6923
6924 return img::format("DSRA %s, %s, %s", rt, rs, shift);
6925 }
6926
6927
6928 /*
6929 * DSRA[32] -
6930 *
6931 * 3 2 1
6932 * 10987654321098765432109876543210
6933 * 10o000 1100xxx0100
6934 * rt -----
6935 * rs -----
6936 * shift -----
6937 */
6938 std::string NMD::DSRA32(uint64 instruction)
6939 {
6940 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6941 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6942 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6943
6944 std::string rt = GPR(copy(rt_value));
6945 std::string rs = GPR(copy(rs_value));
6946 std::string shift = IMMEDIATE(copy(shift_value));
6947
6948 return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
6949 }
6950
6951
6952 /*
6953 *
6954 *
6955 * 3 2 1
6956 * 10987654321098765432109876543210
6957 * 001000 x1110000101
6958 * rt -----
6959 * rs -----
6960 * rd -----
6961 */
6962 std::string NMD::DSRAV(uint64 instruction)
6963 {
6964 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6965 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6966 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6967
6968 std::string rd = GPR(copy(rd_value));
6969 std::string rs = GPR(copy(rs_value));
6970 std::string rt = GPR(copy(rt_value));
6971
6972 return img::format("DSRAV %s, %s, %s", rd, rs, rt);
6973 }
6974
6975
6976 /*
6977 * DSRL -
6978 *
6979 * 3 2 1
6980 * 10987654321098765432109876543210
6981 * 10o000 1100xxx0100
6982 * rt -----
6983 * rs -----
6984 * shift -----
6985 */
6986 std::string NMD::DSRL(uint64 instruction)
6987 {
6988 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6989 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6990 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6991
6992 std::string rt = GPR(copy(rt_value));
6993 std::string rs = GPR(copy(rs_value));
6994 std::string shift = IMMEDIATE(copy(shift_value));
6995
6996 return img::format("DSRL %s, %s, %s", rt, rs, shift);
6997 }
6998
6999
7000 /*
7001 * DSRL[32] -
7002 *
7003 * 3 2 1
7004 * 10987654321098765432109876543210
7005 * 10o000 1100xxx0010
7006 * rt -----
7007 * rs -----
7008 * shift -----
7009 */
7010 std::string NMD::DSRL32(uint64 instruction)
7011 {
7012 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7013 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7014 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
7015
7016 std::string rt = GPR(copy(rt_value));
7017 std::string rs = GPR(copy(rs_value));
7018 std::string shift = IMMEDIATE(copy(shift_value));
7019
7020 return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
7021 }
7022
7023
7024 /*
7025 *
7026 *
7027 * 3 2 1
7028 * 10987654321098765432109876543210
7029 * 001000 x1110000101
7030 * rt -----
7031 * rs -----
7032 * rd -----
7033 */
7034 std::string NMD::DSRLV(uint64 instruction)
7035 {
7036 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7037 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7038 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7039
7040 std::string rd = GPR(copy(rd_value));
7041 std::string rs = GPR(copy(rs_value));
7042 std::string rt = GPR(copy(rt_value));
7043
7044 return img::format("DSRLV %s, %s, %s", rd, rs, rt);
7045 }
7046
7047
7048 /*
7049 *
7050 *
7051 * 3 2 1
7052 * 10987654321098765432109876543210
7053 * 001000 x1110000101
7054 * rt -----
7055 * rs -----
7056 * rd -----
7057 */
7058 std::string NMD::DSUB(uint64 instruction)
7059 {
7060 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7061 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7062 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7063
7064 std::string rd = GPR(copy(rd_value));
7065 std::string rs = GPR(copy(rs_value));
7066 std::string rt = GPR(copy(rt_value));
7067
7068 return img::format("DSUB %s, %s, %s", rd, rs, rt);
7069 }
7070
7071
7072 /*
7073 *
7074 *
7075 * 3 2 1
7076 * 10987654321098765432109876543210
7077 * 001000 x1110000101
7078 * rt -----
7079 * rs -----
7080 * rd -----
7081 */
7082 std::string NMD::DSUBU(uint64 instruction)
7083 {
7084 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7085 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7086 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7087
7088 std::string rd = GPR(copy(rd_value));
7089 std::string rs = GPR(copy(rs_value));
7090 std::string rt = GPR(copy(rt_value));
7091
7092 return img::format("DSUBU %s, %s, %s", rd, rs, rt);
7093 }
7094
7095
7096 /*
7097 *
7098 *
7099 * 3 2 1
7100 * 10987654321098765432109876543210
7101 * 001000 x1110000101
7102 * rt -----
7103 * rs -----
7104 * rd -----
7105 */
7106 std::string NMD::DVPE(uint64 instruction)
7107 {
7108 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7109
7110 std::string rt = GPR(copy(rt_value));
7111
7112 return img::format("DVPE %s", rt);
7113 }
7114
7115
7116 /*
7117 *
7118 *
7119 * 3 2 1
7120 * 10987654321098765432109876543210
7121 * 001000 x1110000101
7122 * rt -----
7123 * rs -----
7124 * rd -----
7125 */
7126 std::string NMD::DVP(uint64 instruction)
7127 {
7128 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7129
7130 std::string rt = GPR(copy(rt_value));
7131
7132 return img::format("DVP %s", rt);
7133 }
7134
7135
7136 /*
7137 *
7138 *
7139 * 3 2 1
7140 * 10987654321098765432109876543210
7141 * 001000 x1110000101
7142 * rt -----
7143 * rs -----
7144 * rd -----
7145 */
7146 std::string NMD::EHB(uint64 instruction)
7147 {
7148 (void)instruction;
7149
7150 return "EHB ";
7151 }
7152
7153
7154 /*
7155 *
7156 *
7157 * 3 2 1
7158 * 10987654321098765432109876543210
7159 * 001000 x1110000101
7160 * rt -----
7161 * rs -----
7162 * rd -----
7163 */
7164 std::string NMD::EI(uint64 instruction)
7165 {
7166 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7167
7168 std::string rt = GPR(copy(rt_value));
7169
7170 return img::format("EI %s", rt);
7171 }
7172
7173
7174 /*
7175 *
7176 *
7177 * 3 2 1
7178 * 10987654321098765432109876543210
7179 * 001000 x1110000101
7180 * rt -----
7181 * rs -----
7182 * rd -----
7183 */
7184 std::string NMD::EMT(uint64 instruction)
7185 {
7186 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7187
7188 std::string rt = GPR(copy(rt_value));
7189
7190 return img::format("EMT %s", rt);
7191 }
7192
7193
7194 /*
7195 *
7196 *
7197 * 3 2 1
7198 * 10987654321098765432109876543210
7199 * 001000 x1110000101
7200 * rt -----
7201 * rs -----
7202 * rd -----
7203 */
7204 std::string NMD::ERET(uint64 instruction)
7205 {
7206 (void)instruction;
7207
7208 return "ERET ";
7209 }
7210
7211
7212 /*
7213 *
7214 *
7215 * 3 2 1
7216 * 10987654321098765432109876543210
7217 * 001000 x1110000101
7218 * rt -----
7219 * rs -----
7220 * rd -----
7221 */
7222 std::string NMD::ERETNC(uint64 instruction)
7223 {
7224 (void)instruction;
7225
7226 return "ERETNC ";
7227 }
7228
7229
7230 /*
7231 *
7232 *
7233 * 3 2 1
7234 * 10987654321098765432109876543210
7235 * 001000 x1110000101
7236 * rt -----
7237 * rs -----
7238 * rd -----
7239 */
7240 std::string NMD::EVP(uint64 instruction)
7241 {
7242 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7243
7244 std::string rt = GPR(copy(rt_value));
7245
7246 return img::format("EVP %s", rt);
7247 }
7248
7249
7250 /*
7251 *
7252 *
7253 * 3 2 1
7254 * 10987654321098765432109876543210
7255 * 001000 x1110000101
7256 * rt -----
7257 * rs -----
7258 * rd -----
7259 */
7260 std::string NMD::EVPE(uint64 instruction)
7261 {
7262 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7263
7264 std::string rt = GPR(copy(rt_value));
7265
7266 return img::format("EVPE %s", rt);
7267 }
7268
7269
7270 /*
7271 *
7272 *
7273 * 3 2 1
7274 * 10987654321098765432109876543210
7275 * 001000 x1110000101
7276 * rt -----
7277 * rs -----
7278 * rd -----
7279 */
7280 std::string NMD::EXT(uint64 instruction)
7281 {
7282 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7283 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7284 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7285 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7286
7287 std::string rt = GPR(copy(rt_value));
7288 std::string rs = GPR(copy(rs_value));
7289 std::string lsb = IMMEDIATE(copy(lsb_value));
7290 std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
7291
7292 return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
7293 }
7294
7295
7296 /*
7297 *
7298 *
7299 * 3 2 1
7300 * 10987654321098765432109876543210
7301 * 001000 x1110000101
7302 * rt -----
7303 * rs -----
7304 * rd -----
7305 */
7306 std::string NMD::EXTD(uint64 instruction)
7307 {
7308 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7309 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7310 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7311 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7312
7313 std::string rd = GPR(copy(rd_value));
7314 std::string rs = GPR(copy(rs_value));
7315 std::string rt = GPR(copy(rt_value));
7316 std::string shift = IMMEDIATE(copy(shift_value));
7317
7318 return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
7319 }
7320
7321
7322 /*
7323 *
7324 *
7325 * 3 2 1
7326 * 10987654321098765432109876543210
7327 * 001000 x1110000101
7328 * rt -----
7329 * rs -----
7330 * rd -----
7331 */
7332 std::string NMD::EXTD32(uint64 instruction)
7333 {
7334 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7335 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7336 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7337 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7338
7339 std::string rd = GPR(copy(rd_value));
7340 std::string rs = GPR(copy(rs_value));
7341 std::string rt = GPR(copy(rt_value));
7342 std::string shift = IMMEDIATE(copy(shift_value));
7343
7344 return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
7345 }
7346
7347
7348 /*
7349 *
7350 *
7351 * 3 2 1
7352 * 10987654321098765432109876543210
7353 * 001000 x1110000101
7354 * rt -----
7355 * rs -----
7356 * rd -----
7357 */
7358 std::string NMD::EXTPDP(uint64 instruction)
7359 {
7360 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7361 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7362 uint64 ac_value = extract_ac_13_12(instruction);
7363
7364 std::string rt = GPR(copy(rt_value));
7365 std::string ac = AC(copy(ac_value));
7366 std::string size = IMMEDIATE(copy(size_value));
7367
7368 return img::format("EXTPDP %s, %s, %s", rt, ac, size);
7369 }
7370
7371
7372 /*
7373 *
7374 *
7375 * 3 2 1
7376 * 10987654321098765432109876543210
7377 * 001000 x1110000101
7378 * rt -----
7379 * rs -----
7380 * rd -----
7381 */
7382 std::string NMD::EXTPDPV(uint64 instruction)
7383 {
7384 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7385 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7386 uint64 ac_value = extract_ac_13_12(instruction);
7387
7388 std::string rt = GPR(copy(rt_value));
7389 std::string ac = AC(copy(ac_value));
7390 std::string rs = GPR(copy(rs_value));
7391
7392 return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
7393 }
7394
7395
7396 /*
7397 *
7398 *
7399 * 3 2 1
7400 * 10987654321098765432109876543210
7401 * 001000 x1110000101
7402 * rt -----
7403 * rs -----
7404 * rd -----
7405 */
7406 std::string NMD::EXTP(uint64 instruction)
7407 {
7408 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7409 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7410 uint64 ac_value = extract_ac_13_12(instruction);
7411
7412 std::string rt = GPR(copy(rt_value));
7413 std::string ac = AC(copy(ac_value));
7414 std::string size = IMMEDIATE(copy(size_value));
7415
7416 return img::format("EXTP %s, %s, %s", rt, ac, size);
7417 }
7418
7419
7420 /*
7421 *
7422 *
7423 * 3 2 1
7424 * 10987654321098765432109876543210
7425 * 001000 x1110000101
7426 * rt -----
7427 * rs -----
7428 * rd -----
7429 */
7430 std::string NMD::EXTPV(uint64 instruction)
7431 {
7432 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7433 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7434 uint64 ac_value = extract_ac_13_12(instruction);
7435
7436 std::string rt = GPR(copy(rt_value));
7437 std::string ac = AC(copy(ac_value));
7438 std::string rs = GPR(copy(rs_value));
7439
7440 return img::format("EXTPV %s, %s, %s", rt, ac, rs);
7441 }
7442
7443
7444 /*
7445 *
7446 *
7447 * 3 2 1
7448 * 10987654321098765432109876543210
7449 * 001000 x1110000101
7450 * rt -----
7451 * rs -----
7452 * rd -----
7453 */
7454 std::string NMD::EXTR_RS_W(uint64 instruction)
7455 {
7456 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7457 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7458 uint64 ac_value = extract_ac_13_12(instruction);
7459
7460 std::string rt = GPR(copy(rt_value));
7461 std::string ac = AC(copy(ac_value));
7462 std::string shift = IMMEDIATE(copy(shift_value));
7463
7464 return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
7465 }
7466
7467
7468 /*
7469 *
7470 *
7471 * 3 2 1
7472 * 10987654321098765432109876543210
7473 * 001000 x1110000101
7474 * rt -----
7475 * rs -----
7476 * rd -----
7477 */
7478 std::string NMD::EXTR_R_W(uint64 instruction)
7479 {
7480 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7481 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7482 uint64 ac_value = extract_ac_13_12(instruction);
7483
7484 std::string rt = GPR(copy(rt_value));
7485 std::string ac = AC(copy(ac_value));
7486 std::string shift = IMMEDIATE(copy(shift_value));
7487
7488 return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
7489 }
7490
7491
7492 /*
7493 *
7494 *
7495 * 3 2 1
7496 * 10987654321098765432109876543210
7497 * 001000 x1110000101
7498 * rt -----
7499 * rs -----
7500 * rd -----
7501 */
7502 std::string NMD::EXTR_S_H(uint64 instruction)
7503 {
7504 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7505 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7506 uint64 ac_value = extract_ac_13_12(instruction);
7507
7508 std::string rt = GPR(copy(rt_value));
7509 std::string ac = AC(copy(ac_value));
7510 std::string shift = IMMEDIATE(copy(shift_value));
7511
7512 return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
7513 }
7514
7515
7516 /*
7517 *
7518 *
7519 * 3 2 1
7520 * 10987654321098765432109876543210
7521 * 001000 x1110000101
7522 * rt -----
7523 * rs -----
7524 * rd -----
7525 */
7526 std::string NMD::EXTR_W(uint64 instruction)
7527 {
7528 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7529 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7530 uint64 ac_value = extract_ac_13_12(instruction);
7531
7532 std::string rt = GPR(copy(rt_value));
7533 std::string ac = AC(copy(ac_value));
7534 std::string shift = IMMEDIATE(copy(shift_value));
7535
7536 return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
7537 }
7538
7539
7540 /*
7541 *
7542 *
7543 * 3 2 1
7544 * 10987654321098765432109876543210
7545 * 001000 x1110000101
7546 * rt -----
7547 * rs -----
7548 * rd -----
7549 */
7550 std::string NMD::EXTRV_RS_W(uint64 instruction)
7551 {
7552 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7553 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7554 uint64 ac_value = extract_ac_13_12(instruction);
7555
7556 std::string rt = GPR(copy(rt_value));
7557 std::string ac = AC(copy(ac_value));
7558 std::string rs = GPR(copy(rs_value));
7559
7560 return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7561 }
7562
7563
7564 /*
7565 *
7566 *
7567 * 3 2 1
7568 * 10987654321098765432109876543210
7569 * 001000 x1110000101
7570 * rt -----
7571 * rs -----
7572 * rd -----
7573 */
7574 std::string NMD::EXTRV_R_W(uint64 instruction)
7575 {
7576 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7577 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7578 uint64 ac_value = extract_ac_13_12(instruction);
7579
7580 std::string rt = GPR(copy(rt_value));
7581 std::string ac = AC(copy(ac_value));
7582 std::string rs = GPR(copy(rs_value));
7583
7584 return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7585 }
7586
7587
7588 /*
7589 *
7590 *
7591 * 3 2 1
7592 * 10987654321098765432109876543210
7593 * 001000 x1110000101
7594 * rt -----
7595 * rs -----
7596 * rd -----
7597 */
7598 std::string NMD::EXTRV_S_H(uint64 instruction)
7599 {
7600 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7602 uint64 ac_value = extract_ac_13_12(instruction);
7603
7604 std::string rt = GPR(copy(rt_value));
7605 std::string ac = AC(copy(ac_value));
7606 std::string rs = GPR(copy(rs_value));
7607
7608 return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7609 }
7610
7611
7612 /*
7613 *
7614 *
7615 * 3 2 1
7616 * 10987654321098765432109876543210
7617 * 001000 x1110000101
7618 * rt -----
7619 * rs -----
7620 * rd -----
7621 */
7622 std::string NMD::EXTRV_W(uint64 instruction)
7623 {
7624 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7625 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7626 uint64 ac_value = extract_ac_13_12(instruction);
7627
7628 std::string rt = GPR(copy(rt_value));
7629 std::string ac = AC(copy(ac_value));
7630 std::string rs = GPR(copy(rs_value));
7631
7632 return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
7633 }
7634
7635
7636 /*
7637 * EXTW - Extract Word
7638 *
7639 * 3 2 1
7640 * 10987654321098765432109876543210
7641 * 001000 011111
7642 * rt -----
7643 * rs -----
7644 * rd -----
7645 * shift -----
7646 */
7647 std::string NMD::EXTW(uint64 instruction)
7648 {
7649 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7650 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7651 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7652 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7653
7654 std::string rd = GPR(copy(rd_value));
7655 std::string rs = GPR(copy(rs_value));
7656 std::string rt = GPR(copy(rt_value));
7657 std::string shift = IMMEDIATE(copy(shift_value));
7658
7659 return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
7660 }
7661
7662
7663 /*
7664 *
7665 *
7666 * 3 2 1
7667 * 10987654321098765432109876543210
7668 * 001000 x1110000101
7669 * rt -----
7670 * rs -----
7671 * rd -----
7672 */
7673 std::string NMD::FLOOR_L_D(uint64 instruction)
7674 {
7675 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7676 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7677
7678 std::string ft = FPR(copy(ft_value));
7679 std::string fs = FPR(copy(fs_value));
7680
7681 return img::format("FLOOR.L.D %s, %s", ft, fs);
7682 }
7683
7684
7685 /*
7686 *
7687 *
7688 * 3 2 1
7689 * 10987654321098765432109876543210
7690 * 001000 x1110000101
7691 * rt -----
7692 * rs -----
7693 * rd -----
7694 */
7695 std::string NMD::FLOOR_L_S(uint64 instruction)
7696 {
7697 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7698 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7699
7700 std::string ft = FPR(copy(ft_value));
7701 std::string fs = FPR(copy(fs_value));
7702
7703 return img::format("FLOOR.L.S %s, %s", ft, fs);
7704 }
7705
7706
7707 /*
7708 *
7709 *
7710 * 3 2 1
7711 * 10987654321098765432109876543210
7712 * 001000 x1110000101
7713 * rt -----
7714 * rs -----
7715 * rd -----
7716 */
7717 std::string NMD::FLOOR_W_D(uint64 instruction)
7718 {
7719 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7720 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7721
7722 std::string ft = FPR(copy(ft_value));
7723 std::string fs = FPR(copy(fs_value));
7724
7725 return img::format("FLOOR.W.D %s, %s", ft, fs);
7726 }
7727
7728
7729 /*
7730 *
7731 *
7732 * 3 2 1
7733 * 10987654321098765432109876543210
7734 * 001000 x1110000101
7735 * rt -----
7736 * rs -----
7737 * rd -----
7738 */
7739 std::string NMD::FLOOR_W_S(uint64 instruction)
7740 {
7741 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7742 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7743
7744 std::string ft = FPR(copy(ft_value));
7745 std::string fs = FPR(copy(fs_value));
7746
7747 return img::format("FLOOR.W.S %s, %s", ft, fs);
7748 }
7749
7750
7751 /*
7752 *
7753 *
7754 * 3 2 1
7755 * 10987654321098765432109876543210
7756 * 001000 x1110000101
7757 * rt -----
7758 * rs -----
7759 * rd -----
7760 */
7761 std::string NMD::FORK(uint64 instruction)
7762 {
7763 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7764 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7765 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7766
7767 std::string rd = GPR(copy(rd_value));
7768 std::string rs = GPR(copy(rs_value));
7769 std::string rt = GPR(copy(rt_value));
7770
7771 return img::format("FORK %s, %s, %s", rd, rs, rt);
7772 }
7773
7774
7775 /*
7776 *
7777 *
7778 * 3 2 1
7779 * 10987654321098765432109876543210
7780 * 001000 x1110000101
7781 * rt -----
7782 * rs -----
7783 * rd -----
7784 */
7785 std::string NMD::HYPCALL(uint64 instruction)
7786 {
7787 uint64 code_value = extract_code_17_to_0(instruction);
7788
7789 std::string code = IMMEDIATE(copy(code_value));
7790
7791 return img::format("HYPCALL %s", code);
7792 }
7793
7794
7795 /*
7796 *
7797 *
7798 * 3 2 1
7799 * 10987654321098765432109876543210
7800 * 001000 x1110000101
7801 * rt -----
7802 * rs -----
7803 * rd -----
7804 */
7805 std::string NMD::HYPCALL_16_(uint64 instruction)
7806 {
7807 uint64 code_value = extract_code_1_0(instruction);
7808
7809 std::string code = IMMEDIATE(copy(code_value));
7810
7811 return img::format("HYPCALL %s", code);
7812 }
7813
7814
7815 /*
7816 *
7817 *
7818 * 3 2 1
7819 * 10987654321098765432109876543210
7820 * 001000 x1110000101
7821 * rt -----
7822 * rs -----
7823 * rd -----
7824 */
7825 std::string NMD::INS(uint64 instruction)
7826 {
7827 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7828 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7829 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7830 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7831
7832 std::string rt = GPR(copy(rt_value));
7833 std::string rs = GPR(copy(rs_value));
7834 std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
7835 std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
7836 /* !!!!!!!!!! - no conversion function */
7837
7838 return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
7839 /* hand edited */
7840 }
7841
7842
7843 /*
7844 *
7845 *
7846 * 3 2 1
7847 * 10987654321098765432109876543210
7848 * 001000 x1110000101
7849 * rt -----
7850 * rs -----
7851 * rd -----
7852 */
7853 std::string NMD::INSV(uint64 instruction)
7854 {
7855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7856 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7857
7858 std::string rt = GPR(copy(rt_value));
7859 std::string rs = GPR(copy(rs_value));
7860
7861 return img::format("INSV %s, %s", rt, rs);
7862 }
7863
7864
7865 /*
7866 *
7867 *
7868 * 3 2 1
7869 * 10987654321098765432109876543210
7870 * 001000 x1110000101
7871 * rt -----
7872 * rs -----
7873 * rd -----
7874 */
7875 std::string NMD::IRET(uint64 instruction)
7876 {
7877 (void)instruction;
7878
7879 return "IRET ";
7880 }
7881
7882
7883 /*
7884 *
7885 *
7886 * 3 2 1
7887 * 10987654321098765432109876543210
7888 * 001000 x1110000101
7889 * rt -----
7890 * rs -----
7891 * rd -----
7892 */
7893 std::string NMD::JALRC_16_(uint64 instruction)
7894 {
7895 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7896
7897 std::string rt = GPR(copy(rt_value));
7898
7899 return img::format("JALRC $%d, %s", 31, rt);
7900 }
7901
7902
7903 /*
7904 *
7905 *
7906 * 3 2 1
7907 * 10987654321098765432109876543210
7908 * 001000 x1110000101
7909 * rt -----
7910 * rs -----
7911 * rd -----
7912 */
7913 std::string NMD::JALRC_32_(uint64 instruction)
7914 {
7915 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7916 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7917
7918 std::string rt = GPR(copy(rt_value));
7919 std::string rs = GPR(copy(rs_value));
7920
7921 return img::format("JALRC %s, %s", rt, rs);
7922 }
7923
7924
7925 /*
7926 *
7927 *
7928 * 3 2 1
7929 * 10987654321098765432109876543210
7930 * 001000 x1110000101
7931 * rt -----
7932 * rs -----
7933 * rd -----
7934 */
7935 std::string NMD::JALRC_HB(uint64 instruction)
7936 {
7937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7939
7940 std::string rt = GPR(copy(rt_value));
7941 std::string rs = GPR(copy(rs_value));
7942
7943 return img::format("JALRC.HB %s, %s", rt, rs);
7944 }
7945
7946
7947 /*
7948 *
7949 *
7950 * 3 2 1
7951 * 10987654321098765432109876543210
7952 * 001000 x1110000101
7953 * rt -----
7954 * rs -----
7955 * rd -----
7956 */
7957 std::string NMD::JRC(uint64 instruction)
7958 {
7959 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7960
7961 std::string rt = GPR(copy(rt_value));
7962
7963 return img::format("JRC %s", rt);
7964 }
7965
7966
7967 /*
7968 *
7969 *
7970 * 3 2 1
7971 * 10987654321098765432109876543210
7972 * 001000 x1110000101
7973 * rt -----
7974 * rs -----
7975 * rd -----
7976 */
7977 std::string NMD::LB_16_(uint64 instruction)
7978 {
7979 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7980 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7981 uint64 u_value = extract_u_1_0(instruction);
7982
7983 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
7984 std::string u = IMMEDIATE(copy(u_value));
7985 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
7986
7987 return img::format("LB %s, %s(%s)", rt3, u, rs3);
7988 }
7989
7990
7991 /*
7992 *
7993 *
7994 * 3 2 1
7995 * 10987654321098765432109876543210
7996 * 001000 x1110000101
7997 * rt -----
7998 * rs -----
7999 * rd -----
8000 */
8001 std::string NMD::LB_GP_(uint64 instruction)
8002 {
8003 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8004 uint64 u_value = extract_u_17_to_0(instruction);
8005
8006 std::string rt = GPR(copy(rt_value));
8007 std::string u = IMMEDIATE(copy(u_value));
8008
8009 return img::format("LB %s, %s($%d)", rt, u, 28);
8010 }
8011
8012
8013 /*
8014 *
8015 *
8016 * 3 2 1
8017 * 10987654321098765432109876543210
8018 * 001000 x1110000101
8019 * rt -----
8020 * rs -----
8021 * rd -----
8022 */
8023 std::string NMD::LB_S9_(uint64 instruction)
8024 {
8025 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8026 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8027 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8028
8029 std::string rt = GPR(copy(rt_value));
8030 std::string s = IMMEDIATE(copy(s_value));
8031 std::string rs = GPR(copy(rs_value));
8032
8033 return img::format("LB %s, %s(%s)", rt, s, rs);
8034 }
8035
8036
8037 /*
8038 *
8039 *
8040 * 3 2 1
8041 * 10987654321098765432109876543210
8042 * 001000 x1110000101
8043 * rt -----
8044 * rs -----
8045 * rd -----
8046 */
8047 std::string NMD::LB_U12_(uint64 instruction)
8048 {
8049 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8050 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8051 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8052
8053 std::string rt = GPR(copy(rt_value));
8054 std::string u = IMMEDIATE(copy(u_value));
8055 std::string rs = GPR(copy(rs_value));
8056
8057 return img::format("LB %s, %s(%s)", rt, u, rs);
8058 }
8059
8060
8061 /*
8062 *
8063 *
8064 * 3 2 1
8065 * 10987654321098765432109876543210
8066 * 001000 x1110000101
8067 * rt -----
8068 * rs -----
8069 * rd -----
8070 */
8071 std::string NMD::LBE(uint64 instruction)
8072 {
8073 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8074 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8075 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8076
8077 std::string rt = GPR(copy(rt_value));
8078 std::string s = IMMEDIATE(copy(s_value));
8079 std::string rs = GPR(copy(rs_value));
8080
8081 return img::format("LBE %s, %s(%s)", rt, s, rs);
8082 }
8083
8084
8085 /*
8086 *
8087 *
8088 * 3 2 1
8089 * 10987654321098765432109876543210
8090 * 001000 x1110000101
8091 * rt -----
8092 * rs -----
8093 * rd -----
8094 */
8095 std::string NMD::LBU_16_(uint64 instruction)
8096 {
8097 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8098 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8099 uint64 u_value = extract_u_1_0(instruction);
8100
8101 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8102 std::string u = IMMEDIATE(copy(u_value));
8103 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8104
8105 return img::format("LBU %s, %s(%s)", rt3, u, rs3);
8106 }
8107
8108
8109 /*
8110 *
8111 *
8112 * 3 2 1
8113 * 10987654321098765432109876543210
8114 * 001000 x1110000101
8115 * rt -----
8116 * rs -----
8117 * rd -----
8118 */
8119 std::string NMD::LBU_GP_(uint64 instruction)
8120 {
8121 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8122 uint64 u_value = extract_u_17_to_0(instruction);
8123
8124 std::string rt = GPR(copy(rt_value));
8125 std::string u = IMMEDIATE(copy(u_value));
8126
8127 return img::format("LBU %s, %s($%d)", rt, u, 28);
8128 }
8129
8130
8131 /*
8132 *
8133 *
8134 * 3 2 1
8135 * 10987654321098765432109876543210
8136 * 001000 x1110000101
8137 * rt -----
8138 * rs -----
8139 * rd -----
8140 */
8141 std::string NMD::LBU_S9_(uint64 instruction)
8142 {
8143 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8144 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8145 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8146
8147 std::string rt = GPR(copy(rt_value));
8148 std::string s = IMMEDIATE(copy(s_value));
8149 std::string rs = GPR(copy(rs_value));
8150
8151 return img::format("LBU %s, %s(%s)", rt, s, rs);
8152 }
8153
8154
8155 /*
8156 *
8157 *
8158 * 3 2 1
8159 * 10987654321098765432109876543210
8160 * 001000 x1110000101
8161 * rt -----
8162 * rs -----
8163 * rd -----
8164 */
8165 std::string NMD::LBU_U12_(uint64 instruction)
8166 {
8167 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8168 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8169 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8170
8171 std::string rt = GPR(copy(rt_value));
8172 std::string u = IMMEDIATE(copy(u_value));
8173 std::string rs = GPR(copy(rs_value));
8174
8175 return img::format("LBU %s, %s(%s)", rt, u, rs);
8176 }
8177
8178
8179 /*
8180 *
8181 *
8182 * 3 2 1
8183 * 10987654321098765432109876543210
8184 * 001000 x1110000101
8185 * rt -----
8186 * rs -----
8187 * rd -----
8188 */
8189 std::string NMD::LBUE(uint64 instruction)
8190 {
8191 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8192 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8193 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8194
8195 std::string rt = GPR(copy(rt_value));
8196 std::string s = IMMEDIATE(copy(s_value));
8197 std::string rs = GPR(copy(rs_value));
8198
8199 return img::format("LBUE %s, %s(%s)", rt, s, rs);
8200 }
8201
8202
8203 /*
8204 *
8205 *
8206 * 3 2 1
8207 * 10987654321098765432109876543210
8208 * 001000 x1110000101
8209 * rt -----
8210 * rs -----
8211 * rd -----
8212 */
8213 std::string NMD::LBUX(uint64 instruction)
8214 {
8215 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8216 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8217 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8218
8219 std::string rd = GPR(copy(rd_value));
8220 std::string rs = GPR(copy(rs_value));
8221 std::string rt = GPR(copy(rt_value));
8222
8223 return img::format("LBUX %s, %s(%s)", rd, rs, rt);
8224 }
8225
8226
8227 /*
8228 *
8229 *
8230 * 3 2 1
8231 * 10987654321098765432109876543210
8232 * 001000 x1110000101
8233 * rt -----
8234 * rs -----
8235 * rd -----
8236 */
8237 std::string NMD::LBX(uint64 instruction)
8238 {
8239 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8240 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8241 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8242
8243 std::string rd = GPR(copy(rd_value));
8244 std::string rs = GPR(copy(rs_value));
8245 std::string rt = GPR(copy(rt_value));
8246
8247 return img::format("LBX %s, %s(%s)", rd, rs, rt);
8248 }
8249
8250
8251 /*
8252 *
8253 *
8254 * 3 2 1
8255 * 10987654321098765432109876543210
8256 * 001000 x1110000101
8257 * rt -----
8258 * rs -----
8259 * rd -----
8260 */
8261 std::string NMD::LD_GP_(uint64 instruction)
8262 {
8263 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8264 uint64 u_value = extract_u_20_to_3__s3(instruction);
8265
8266 std::string rt = GPR(copy(rt_value));
8267 std::string u = IMMEDIATE(copy(u_value));
8268
8269 return img::format("LD %s, %s($%d)", rt, u, 28);
8270 }
8271
8272
8273 /*
8274 *
8275 *
8276 * 3 2 1
8277 * 10987654321098765432109876543210
8278 * 001000 x1110000101
8279 * rt -----
8280 * rs -----
8281 * rd -----
8282 */
8283 std::string NMD::LD_S9_(uint64 instruction)
8284 {
8285 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8286 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8287 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8288
8289 std::string rt = GPR(copy(rt_value));
8290 std::string s = IMMEDIATE(copy(s_value));
8291 std::string rs = GPR(copy(rs_value));
8292
8293 return img::format("LD %s, %s(%s)", rt, s, rs);
8294 }
8295
8296
8297 /*
8298 *
8299 *
8300 * 3 2 1
8301 * 10987654321098765432109876543210
8302 * 001000 x1110000101
8303 * rt -----
8304 * rs -----
8305 * rd -----
8306 */
8307 std::string NMD::LD_U12_(uint64 instruction)
8308 {
8309 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8310 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8311 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8312
8313 std::string rt = GPR(copy(rt_value));
8314 std::string u = IMMEDIATE(copy(u_value));
8315 std::string rs = GPR(copy(rs_value));
8316
8317 return img::format("LD %s, %s(%s)", rt, u, rs);
8318 }
8319
8320
8321 /*
8322 *
8323 *
8324 * 3 2 1
8325 * 10987654321098765432109876543210
8326 * 001000 x1110000101
8327 * rt -----
8328 * rs -----
8329 * rd -----
8330 */
8331 std::string NMD::LDC1_GP_(uint64 instruction)
8332 {
8333 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8334 uint64 u_value = extract_u_17_to_2__s2(instruction);
8335
8336 std::string ft = FPR(copy(ft_value));
8337 std::string u = IMMEDIATE(copy(u_value));
8338
8339 return img::format("LDC1 %s, %s($%d)", ft, u, 28);
8340 }
8341
8342
8343 /*
8344 *
8345 *
8346 * 3 2 1
8347 * 10987654321098765432109876543210
8348 * 001000 x1110000101
8349 * rt -----
8350 * rs -----
8351 * rd -----
8352 */
8353 std::string NMD::LDC1_S9_(uint64 instruction)
8354 {
8355 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8356 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8357 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8358
8359 std::string ft = FPR(copy(ft_value));
8360 std::string s = IMMEDIATE(copy(s_value));
8361 std::string rs = GPR(copy(rs_value));
8362
8363 return img::format("LDC1 %s, %s(%s)", ft, s, rs);
8364 }
8365
8366
8367 /*
8368 *
8369 *
8370 * 3 2 1
8371 * 10987654321098765432109876543210
8372 * 001000 x1110000101
8373 * rt -----
8374 * rs -----
8375 * rd -----
8376 */
8377 std::string NMD::LDC1_U12_(uint64 instruction)
8378 {
8379 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8380 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8381 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8382
8383 std::string ft = FPR(copy(ft_value));
8384 std::string u = IMMEDIATE(copy(u_value));
8385 std::string rs = GPR(copy(rs_value));
8386
8387 return img::format("LDC1 %s, %s(%s)", ft, u, rs);
8388 }
8389
8390
8391 /*
8392 *
8393 *
8394 * 3 2 1
8395 * 10987654321098765432109876543210
8396 * 001000 x1110000101
8397 * rt -----
8398 * rs -----
8399 * rd -----
8400 */
8401 std::string NMD::LDC1XS(uint64 instruction)
8402 {
8403 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8404 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8405 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8406
8407 std::string ft = FPR(copy(ft_value));
8408 std::string rs = GPR(copy(rs_value));
8409 std::string rt = GPR(copy(rt_value));
8410
8411 return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
8412 }
8413
8414
8415 /*
8416 *
8417 *
8418 * 3 2 1
8419 * 10987654321098765432109876543210
8420 * 001000 x1110000101
8421 * rt -----
8422 * rs -----
8423 * rd -----
8424 */
8425 std::string NMD::LDC1X(uint64 instruction)
8426 {
8427 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8428 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8429 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8430
8431 std::string ft = FPR(copy(ft_value));
8432 std::string rs = GPR(copy(rs_value));
8433 std::string rt = GPR(copy(rt_value));
8434
8435 return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
8436 }
8437
8438
8439 /*
8440 *
8441 *
8442 * 3 2 1
8443 * 10987654321098765432109876543210
8444 * 001000 x1110000101
8445 * rt -----
8446 * rs -----
8447 * rd -----
8448 */
8449 std::string NMD::LDC2(uint64 instruction)
8450 {
8451 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8452 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8453 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8454
8455 std::string ct = CPR(copy(ct_value));
8456 std::string s = IMMEDIATE(copy(s_value));
8457 std::string rs = GPR(copy(rs_value));
8458
8459 return img::format("LDC2 %s, %s(%s)", ct, s, rs);
8460 }
8461
8462
8463 /*
8464 *
8465 *
8466 * 3 2 1
8467 * 10987654321098765432109876543210
8468 * 001000 x1110000101
8469 * rt -----
8470 * rs -----
8471 * rd -----
8472 */
8473 std::string NMD::LDM(uint64 instruction)
8474 {
8475 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8476 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8477 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8478 uint64 count3_value = extract_count3_14_13_12(instruction);
8479
8480 std::string rt = GPR(copy(rt_value));
8481 std::string s = IMMEDIATE(copy(s_value));
8482 std::string rs = GPR(copy(rs_value));
8483 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
8484
8485 return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
8486 }
8487
8488
8489 /*
8490 *
8491 *
8492 * 3 2 1
8493 * 10987654321098765432109876543210
8494 * 001000 x1110000101
8495 * rt -----
8496 * rs -----
8497 * rd -----
8498 */
8499 std::string NMD::LDPC_48_(uint64 instruction)
8500 {
8501 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8502 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8503
8504 std::string rt = GPR(copy(rt_value));
8505 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
8506
8507 return img::format("LDPC %s, %s", rt, s);
8508 }
8509
8510
8511 /*
8512 *
8513 *
8514 * 3 2 1
8515 * 10987654321098765432109876543210
8516 * 001000 x1110000101
8517 * rt -----
8518 * rs -----
8519 * rd -----
8520 */
8521 std::string NMD::LDX(uint64 instruction)
8522 {
8523 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8524 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8525 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8526
8527 std::string rd = GPR(copy(rd_value));
8528 std::string rs = GPR(copy(rs_value));
8529 std::string rt = GPR(copy(rt_value));
8530
8531 return img::format("LDX %s, %s(%s)", rd, rs, rt);
8532 }
8533
8534
8535 /*
8536 *
8537 *
8538 * 3 2 1
8539 * 10987654321098765432109876543210
8540 * 001000 x1110000101
8541 * rt -----
8542 * rs -----
8543 * rd -----
8544 */
8545 std::string NMD::LDXS(uint64 instruction)
8546 {
8547 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8548 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8549 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8550
8551 std::string rd = GPR(copy(rd_value));
8552 std::string rs = GPR(copy(rs_value));
8553 std::string rt = GPR(copy(rt_value));
8554
8555 return img::format("LDXS %s, %s(%s)", rd, rs, rt);
8556 }
8557
8558
8559 /*
8560 *
8561 *
8562 * 3 2 1
8563 * 10987654321098765432109876543210
8564 * 001000 x1110000101
8565 * rt -----
8566 * rs -----
8567 * rd -----
8568 */
8569 std::string NMD::LH_16_(uint64 instruction)
8570 {
8571 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8572 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8573 uint64 u_value = extract_u_2_1__s1(instruction);
8574
8575 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8576 std::string u = IMMEDIATE(copy(u_value));
8577 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8578
8579 return img::format("LH %s, %s(%s)", rt3, u, rs3);
8580 }
8581
8582
8583 /*
8584 *
8585 *
8586 * 3 2 1
8587 * 10987654321098765432109876543210
8588 * 001000 x1110000101
8589 * rt -----
8590 * rs -----
8591 * rd -----
8592 */
8593 std::string NMD::LH_GP_(uint64 instruction)
8594 {
8595 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8596 uint64 u_value = extract_u_17_to_1__s1(instruction);
8597
8598 std::string rt = GPR(copy(rt_value));
8599 std::string u = IMMEDIATE(copy(u_value));
8600
8601 return img::format("LH %s, %s($%d)", rt, u, 28);
8602 }
8603
8604
8605 /*
8606 *
8607 *
8608 * 3 2 1
8609 * 10987654321098765432109876543210
8610 * 001000 x1110000101
8611 * rt -----
8612 * rs -----
8613 * rd -----
8614 */
8615 std::string NMD::LH_S9_(uint64 instruction)
8616 {
8617 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8618 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8619 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8620
8621 std::string rt = GPR(copy(rt_value));
8622 std::string s = IMMEDIATE(copy(s_value));
8623 std::string rs = GPR(copy(rs_value));
8624
8625 return img::format("LH %s, %s(%s)", rt, s, rs);
8626 }
8627
8628
8629 /*
8630 *
8631 *
8632 * 3 2 1
8633 * 10987654321098765432109876543210
8634 * 001000 x1110000101
8635 * rt -----
8636 * rs -----
8637 * rd -----
8638 */
8639 std::string NMD::LH_U12_(uint64 instruction)
8640 {
8641 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8642 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8643 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8644
8645 std::string rt = GPR(copy(rt_value));
8646 std::string u = IMMEDIATE(copy(u_value));
8647 std::string rs = GPR(copy(rs_value));
8648
8649 return img::format("LH %s, %s(%s)", rt, u, rs);
8650 }
8651
8652
8653 /*
8654 *
8655 *
8656 * 3 2 1
8657 * 10987654321098765432109876543210
8658 * 001000 x1110000101
8659 * rt -----
8660 * rs -----
8661 * rd -----
8662 */
8663 std::string NMD::LHE(uint64 instruction)
8664 {
8665 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8666 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8667 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8668
8669 std::string rt = GPR(copy(rt_value));
8670 std::string s = IMMEDIATE(copy(s_value));
8671 std::string rs = GPR(copy(rs_value));
8672
8673 return img::format("LHE %s, %s(%s)", rt, s, rs);
8674 }
8675
8676
8677 /*
8678 *
8679 *
8680 * 3 2 1
8681 * 10987654321098765432109876543210
8682 * 001000 x1110000101
8683 * rt -----
8684 * rs -----
8685 * rd -----
8686 */
8687 std::string NMD::LHU_16_(uint64 instruction)
8688 {
8689 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8690 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8691 uint64 u_value = extract_u_2_1__s1(instruction);
8692
8693 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8694 std::string u = IMMEDIATE(copy(u_value));
8695 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
8696
8697 return img::format("LHU %s, %s(%s)", rt3, u, rs3);
8698 }
8699
8700
8701 /*
8702 *
8703 *
8704 * 3 2 1
8705 * 10987654321098765432109876543210
8706 * 001000 x1110000101
8707 * rt -----
8708 * rs -----
8709 * rd -----
8710 */
8711 std::string NMD::LHU_GP_(uint64 instruction)
8712 {
8713 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8714 uint64 u_value = extract_u_17_to_1__s1(instruction);
8715
8716 std::string rt = GPR(copy(rt_value));
8717 std::string u = IMMEDIATE(copy(u_value));
8718
8719 return img::format("LHU %s, %s($%d)", rt, u, 28);
8720 }
8721
8722
8723 /*
8724 *
8725 *
8726 * 3 2 1
8727 * 10987654321098765432109876543210
8728 * 001000 x1110000101
8729 * rt -----
8730 * rs -----
8731 * rd -----
8732 */
8733 std::string NMD::LHU_S9_(uint64 instruction)
8734 {
8735 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8737 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8738
8739 std::string rt = GPR(copy(rt_value));
8740 std::string s = IMMEDIATE(copy(s_value));
8741 std::string rs = GPR(copy(rs_value));
8742
8743 return img::format("LHU %s, %s(%s)", rt, s, rs);
8744 }
8745
8746
8747 /*
8748 *
8749 *
8750 * 3 2 1
8751 * 10987654321098765432109876543210
8752 * 001000 x1110000101
8753 * rt -----
8754 * rs -----
8755 * rd -----
8756 */
8757 std::string NMD::LHU_U12_(uint64 instruction)
8758 {
8759 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8760 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8761 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8762
8763 std::string rt = GPR(copy(rt_value));
8764 std::string u = IMMEDIATE(copy(u_value));
8765 std::string rs = GPR(copy(rs_value));
8766
8767 return img::format("LHU %s, %s(%s)", rt, u, rs);
8768 }
8769
8770
8771 /*
8772 *
8773 *
8774 * 3 2 1
8775 * 10987654321098765432109876543210
8776 * 001000 x1110000101
8777 * rt -----
8778 * rs -----
8779 * rd -----
8780 */
8781 std::string NMD::LHUE(uint64 instruction)
8782 {
8783 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8784 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8785 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8786
8787 std::string rt = GPR(copy(rt_value));
8788 std::string s = IMMEDIATE(copy(s_value));
8789 std::string rs = GPR(copy(rs_value));
8790
8791 return img::format("LHUE %s, %s(%s)", rt, s, rs);
8792 }
8793
8794
8795 /*
8796 *
8797 *
8798 * 3 2 1
8799 * 10987654321098765432109876543210
8800 * 001000 x1110000101
8801 * rt -----
8802 * rs -----
8803 * rd -----
8804 */
8805 std::string NMD::LHUX(uint64 instruction)
8806 {
8807 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8808 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8809 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8810
8811 std::string rd = GPR(copy(rd_value));
8812 std::string rs = GPR(copy(rs_value));
8813 std::string rt = GPR(copy(rt_value));
8814
8815 return img::format("LHUX %s, %s(%s)", rd, rs, rt);
8816 }
8817
8818
8819 /*
8820 *
8821 *
8822 * 3 2 1
8823 * 10987654321098765432109876543210
8824 * 001000 x1110000101
8825 * rt -----
8826 * rs -----
8827 * rd -----
8828 */
8829 std::string NMD::LHUXS(uint64 instruction)
8830 {
8831 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8832 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8833 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8834
8835 std::string rd = GPR(copy(rd_value));
8836 std::string rs = GPR(copy(rs_value));
8837 std::string rt = GPR(copy(rt_value));
8838
8839 return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
8840 }
8841
8842
8843 /*
8844 *
8845 *
8846 * 3 2 1
8847 * 10987654321098765432109876543210
8848 * 001000 x1110000101
8849 * rt -----
8850 * rs -----
8851 * rd -----
8852 */
8853 std::string NMD::LHXS(uint64 instruction)
8854 {
8855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8856 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8857 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8858
8859 std::string rd = GPR(copy(rd_value));
8860 std::string rs = GPR(copy(rs_value));
8861 std::string rt = GPR(copy(rt_value));
8862
8863 return img::format("LHXS %s, %s(%s)", rd, rs, rt);
8864 }
8865
8866
8867 /*
8868 *
8869 *
8870 * 3 2 1
8871 * 10987654321098765432109876543210
8872 * 001000 x1110000101
8873 * rt -----
8874 * rs -----
8875 * rd -----
8876 */
8877 std::string NMD::LHX(uint64 instruction)
8878 {
8879 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8880 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8881 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8882
8883 std::string rd = GPR(copy(rd_value));
8884 std::string rs = GPR(copy(rs_value));
8885 std::string rt = GPR(copy(rt_value));
8886
8887 return img::format("LHX %s, %s(%s)", rd, rs, rt);
8888 }
8889
8890
8891 /*
8892 *
8893 *
8894 * 3 2 1
8895 * 10987654321098765432109876543210
8896 * 001000 x1110000101
8897 * rt -----
8898 * rs -----
8899 * rd -----
8900 */
8901 std::string NMD::LI_16_(uint64 instruction)
8902 {
8903 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8904 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8905
8906 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
8907 std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
8908
8909 return img::format("LI %s, %s", rt3, eu);
8910 }
8911
8912
8913 /*
8914 *
8915 *
8916 * 3 2 1
8917 * 10987654321098765432109876543210
8918 * 001000 x1110000101
8919 * rt -----
8920 * rs -----
8921 * rd -----
8922 */
8923 std::string NMD::LI_48_(uint64 instruction)
8924 {
8925 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8926 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8927
8928 std::string rt = GPR(copy(rt_value));
8929 std::string s = IMMEDIATE(copy(s_value));
8930
8931 return img::format("LI %s, %s", rt, s);
8932 }
8933
8934
8935 /*
8936 *
8937 *
8938 * 3 2 1
8939 * 10987654321098765432109876543210
8940 * 001000 x1110000101
8941 * rt -----
8942 * rs -----
8943 * rd -----
8944 */
8945 std::string NMD::LL(uint64 instruction)
8946 {
8947 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8948 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8949 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8950
8951 std::string rt = GPR(copy(rt_value));
8952 std::string s = IMMEDIATE(copy(s_value));
8953 std::string rs = GPR(copy(rs_value));
8954
8955 return img::format("LL %s, %s(%s)", rt, s, rs);
8956 }
8957
8958
8959 /*
8960 *
8961 *
8962 * 3 2 1
8963 * 10987654321098765432109876543210
8964 * 001000 x1110000101
8965 * rt -----
8966 * rs -----
8967 * rd -----
8968 */
8969 std::string NMD::LLD(uint64 instruction)
8970 {
8971 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8972 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8973 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
8974
8975 std::string rt = GPR(copy(rt_value));
8976 std::string s = IMMEDIATE(copy(s_value));
8977 std::string rs = GPR(copy(rs_value));
8978
8979 return img::format("LLD %s, %s(%s)", rt, s, rs);
8980 }
8981
8982
8983 /*
8984 *
8985 *
8986 * 3 2 1
8987 * 10987654321098765432109876543210
8988 * 001000 x1110000101
8989 * rt -----
8990 * rs -----
8991 * rd -----
8992 */
8993 std::string NMD::LLDP(uint64 instruction)
8994 {
8995 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8996 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8997 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8998
8999 std::string rt = GPR(copy(rt_value));
9000 std::string ru = GPR(copy(ru_value));
9001 std::string rs = GPR(copy(rs_value));
9002
9003 return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
9004 }
9005
9006
9007 /*
9008 *
9009 *
9010 * 3 2 1
9011 * 10987654321098765432109876543210
9012 * 001000 x1110000101
9013 * rt -----
9014 * rs -----
9015 * rd -----
9016 */
9017 std::string NMD::LLE(uint64 instruction)
9018 {
9019 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9020 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9021 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
9022
9023 std::string rt = GPR(copy(rt_value));
9024 std::string s = IMMEDIATE(copy(s_value));
9025 std::string rs = GPR(copy(rs_value));
9026
9027 return img::format("LLE %s, %s(%s)", rt, s, rs);
9028 }
9029
9030
9031 /*
9032 *
9033 *
9034 * 3 2 1
9035 * 10987654321098765432109876543210
9036 * 001000 x1110000101
9037 * rt -----
9038 * rs -----
9039 * rd -----
9040 */
9041 std::string NMD::LLWP(uint64 instruction)
9042 {
9043 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9044 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9045 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9046
9047 std::string rt = GPR(copy(rt_value));
9048 std::string ru = GPR(copy(ru_value));
9049 std::string rs = GPR(copy(rs_value));
9050
9051 return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
9052 }
9053
9054
9055 /*
9056 *
9057 *
9058 * 3 2 1
9059 * 10987654321098765432109876543210
9060 * 001000 x1110000101
9061 * rt -----
9062 * rs -----
9063 * rd -----
9064 */
9065 std::string NMD::LLWPE(uint64 instruction)
9066 {
9067 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9068 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9069 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
9070
9071 std::string rt = GPR(copy(rt_value));
9072 std::string ru = GPR(copy(ru_value));
9073 std::string rs = GPR(copy(rs_value));
9074
9075 return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
9076 }
9077
9078
9079 /*
9080 *
9081 *
9082 * 3 2 1
9083 * 10987654321098765432109876543210
9084 * 001000 x1110000101
9085 * rt -----
9086 * rs -----
9087 * rd -----
9088 */
9089 std::string NMD::LSA(uint64 instruction)
9090 {
9091 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9092 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9093 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9094 uint64 u2_value = extract_u2_10_9(instruction);
9095
9096 std::string rd = GPR(copy(rd_value));
9097 std::string rs = GPR(copy(rs_value));
9098 std::string rt = GPR(copy(rt_value));
9099 std::string u2 = IMMEDIATE(copy(u2_value));
9100
9101 return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
9102 }
9103
9104
9105 /*
9106 *
9107 *
9108 * 3 2 1
9109 * 10987654321098765432109876543210
9110 * 001000 x1110000101
9111 * rt -----
9112 * rs -----
9113 * rd -----
9114 */
9115 std::string NMD::LUI(uint64 instruction)
9116 {
9117 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9118 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
9119
9120 std::string rt = GPR(copy(rt_value));
9121 std::string s = IMMEDIATE(copy(s_value));
9122
9123 return img::format("LUI %s, %%hi(%s)", rt, s);
9124 }
9125
9126
9127 /*
9128 *
9129 *
9130 * 3 2 1
9131 * 10987654321098765432109876543210
9132 * 001000 x1110000101
9133 * rt -----
9134 * rs -----
9135 * rd -----
9136 */
9137 std::string NMD::LW_16_(uint64 instruction)
9138 {
9139 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9140 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9141 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
9142
9143 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
9144 std::string u = IMMEDIATE(copy(u_value));
9145 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
9146
9147 return img::format("LW %s, %s(%s)", rt3, u, rs3);
9148 }
9149
9150
9151 /*
9152 *
9153 *
9154 * 3 2 1
9155 * 10987654321098765432109876543210
9156 * 001000 x1110000101
9157 * rt -----
9158 * rs -----
9159 * rd -----
9160 */
9161 std::string NMD::LW_4X4_(uint64 instruction)
9162 {
9163 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
9164 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
9165 uint64 u_value = extract_u_3_8__s2(instruction);
9166
9167 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
9168 std::string u = IMMEDIATE(copy(u_value));
9169 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
9170
9171 return img::format("LW %s, %s(%s)", rt4, u, rs4);
9172 }
9173
9174
9175 /*
9176 *
9177 *
9178 * 3 2 1
9179 * 10987654321098765432109876543210
9180 * 001000 x1110000101
9181 * rt -----
9182 * rs -----
9183 * rd -----
9184 */
9185 std::string NMD::LW_GP_(uint64 instruction)
9186 {
9187 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9188 uint64 u_value = extract_u_20_to_2__s2(instruction);
9189
9190 std::string rt = GPR(copy(rt_value));
9191 std::string u = IMMEDIATE(copy(u_value));
9192
9193 return img::format("LW %s, %s($%d)", rt, u, 28);
9194 }
9195
9196
9197 /*
9198 *
9199 *
9200 * 3 2 1
9201 * 10987654321098765432109876543210
9202 * 001000 x1110000101
9203 * rt -----
9204 * rs -----
9205 * rd -----
9206 */
9207 std::string NMD::LW_GP16_(uint64 instruction)
9208 {
9209 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9210 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
9211
9212 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
9213 std::string u = IMMEDIATE(copy(u_value));
9214
9215 return img::format("LW %s, %s($%d)", rt3, u, 28);
9216 }
9217
9218
9219 /*
9220 *
9221 *
9222 * 3 2 1
9223 * 10987654321098765432109876543210
9224 * 001000 x1110000101
9225 * rt -----
9226 * rs -----
9227 * rd -----
9228 */
9229 std::string NMD::LW_S9_(uint64 instruction)
9230 {
9231 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9232 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9233 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9234
9235 std::string rt = GPR(copy(rt_value));
9236 std::string s = IMMEDIATE(copy(s_value));
9237 std::string rs = GPR(copy(rs_value));
9238
9239 return img::format("LW %s, %s(%s)", rt, s, rs);
9240 }
9241
9242
9243 /*
9244 *
9245 *
9246 * 3 2 1
9247 * 10987654321098765432109876543210
9248 * 001000 x1110000101
9249 * rt -----
9250 * rs -----
9251 * rd -----
9252 */
9253 std::string NMD::LW_SP_(uint64 instruction)
9254 {
9255 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
9256 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
9257
9258 std::string rt = GPR(copy(rt_value));
9259 std::string u = IMMEDIATE(copy(u_value));
9260
9261 return img::format("LW %s, %s($%d)", rt, u, 29);
9262 }
9263
9264
9265 /*
9266 *
9267 *
9268 * 3 2 1
9269 * 10987654321098765432109876543210
9270 * 001000 x1110000101
9271 * rt -----
9272 * rs -----
9273 * rd -----
9274 */
9275 std::string NMD::LW_U12_(uint64 instruction)
9276 {
9277 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9278 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9279 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9280
9281 std::string rt = GPR(copy(rt_value));
9282 std::string u = IMMEDIATE(copy(u_value));
9283 std::string rs = GPR(copy(rs_value));
9284
9285 return img::format("LW %s, %s(%s)", rt, u, rs);
9286 }
9287
9288
9289 /*
9290 *
9291 *
9292 * 3 2 1
9293 * 10987654321098765432109876543210
9294 * 001000 x1110000101
9295 * rt -----
9296 * rs -----
9297 * rd -----
9298 */
9299 std::string NMD::LWC1_GP_(uint64 instruction)
9300 {
9301 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9302 uint64 u_value = extract_u_17_to_2__s2(instruction);
9303
9304 std::string ft = FPR(copy(ft_value));
9305 std::string u = IMMEDIATE(copy(u_value));
9306
9307 return img::format("LWC1 %s, %s($%d)", ft, u, 28);
9308 }
9309
9310
9311 /*
9312 *
9313 *
9314 * 3 2 1
9315 * 10987654321098765432109876543210
9316 * 001000 x1110000101
9317 * rt -----
9318 * rs -----
9319 * rd -----
9320 */
9321 std::string NMD::LWC1_S9_(uint64 instruction)
9322 {
9323 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9324 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9325 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9326
9327 std::string ft = FPR(copy(ft_value));
9328 std::string s = IMMEDIATE(copy(s_value));
9329 std::string rs = GPR(copy(rs_value));
9330
9331 return img::format("LWC1 %s, %s(%s)", ft, s, rs);
9332 }
9333
9334
9335 /*
9336 *
9337 *
9338 * 3 2 1
9339 * 10987654321098765432109876543210
9340 * 001000 x1110000101
9341 * rt -----
9342 * rs -----
9343 * rd -----
9344 */
9345 std::string NMD::LWC1_U12_(uint64 instruction)
9346 {
9347 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9348 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9349 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9350
9351 std::string ft = FPR(copy(ft_value));
9352 std::string u = IMMEDIATE(copy(u_value));
9353 std::string rs = GPR(copy(rs_value));
9354
9355 return img::format("LWC1 %s, %s(%s)", ft, u, rs);
9356 }
9357
9358
9359 /*
9360 *
9361 *
9362 * 3 2 1
9363 * 10987654321098765432109876543210
9364 * 001000 x1110000101
9365 * rt -----
9366 * rs -----
9367 * rd -----
9368 */
9369 std::string NMD::LWC1X(uint64 instruction)
9370 {
9371 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9373 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9374
9375 std::string ft = FPR(copy(ft_value));
9376 std::string rs = GPR(copy(rs_value));
9377 std::string rt = GPR(copy(rt_value));
9378
9379 return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
9380 }
9381
9382
9383 /*
9384 *
9385 *
9386 * 3 2 1
9387 * 10987654321098765432109876543210
9388 * 001000 x1110000101
9389 * rt -----
9390 * rs -----
9391 * rd -----
9392 */
9393 std::string NMD::LWC1XS(uint64 instruction)
9394 {
9395 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9397 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9398
9399 std::string ft = FPR(copy(ft_value));
9400 std::string rs = GPR(copy(rs_value));
9401 std::string rt = GPR(copy(rt_value));
9402
9403 return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
9404 }
9405
9406
9407 /*
9408 *
9409 *
9410 * 3 2 1
9411 * 10987654321098765432109876543210
9412 * 001000 x1110000101
9413 * rt -----
9414 * rs -----
9415 * rd -----
9416 */
9417 std::string NMD::LWC2(uint64 instruction)
9418 {
9419 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9420 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9421 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9422
9423 std::string ct = CPR(copy(ct_value));
9424 std::string s = IMMEDIATE(copy(s_value));
9425 std::string rs = GPR(copy(rs_value));
9426
9427 return img::format("LWC2 %s, %s(%s)", ct, s, rs);
9428 }
9429
9430
9431 /*
9432 *
9433 *
9434 * 3 2 1
9435 * 10987654321098765432109876543210
9436 * 001000 x1110000101
9437 * rt -----
9438 * rs -----
9439 * rd -----
9440 */
9441 std::string NMD::LWE(uint64 instruction)
9442 {
9443 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9444 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9445 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9446
9447 std::string rt = GPR(copy(rt_value));
9448 std::string s = IMMEDIATE(copy(s_value));
9449 std::string rs = GPR(copy(rs_value));
9450
9451 return img::format("LWE %s, %s(%s)", rt, s, rs);
9452 }
9453
9454
9455 /*
9456 *
9457 *
9458 * 3 2 1
9459 * 10987654321098765432109876543210
9460 * 001000 x1110000101
9461 * rt -----
9462 * rs -----
9463 * rd -----
9464 */
9465 std::string NMD::LWM(uint64 instruction)
9466 {
9467 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9468 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9469 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9470 uint64 count3_value = extract_count3_14_13_12(instruction);
9471
9472 std::string rt = GPR(copy(rt_value));
9473 std::string s = IMMEDIATE(copy(s_value));
9474 std::string rs = GPR(copy(rs_value));
9475 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
9476
9477 return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
9478 }
9479
9480
9481 /*
9482 *
9483 *
9484 * 3 2 1
9485 * 10987654321098765432109876543210
9486 * 001000 x1110000101
9487 * rt -----
9488 * rs -----
9489 * rd -----
9490 */
9491 std::string NMD::LWPC_48_(uint64 instruction)
9492 {
9493 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9494 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
9495
9496 std::string rt = GPR(copy(rt_value));
9497 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
9498
9499 return img::format("LWPC %s, %s", rt, s);
9500 }
9501
9502
9503 /*
9504 *
9505 *
9506 * 3 2 1
9507 * 10987654321098765432109876543210
9508 * 001000 x1110000101
9509 * rt -----
9510 * rs -----
9511 * rd -----
9512 */
9513 std::string NMD::LWU_GP_(uint64 instruction)
9514 {
9515 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9516 uint64 u_value = extract_u_17_to_2__s2(instruction);
9517
9518 std::string rt = GPR(copy(rt_value));
9519 std::string u = IMMEDIATE(copy(u_value));
9520
9521 return img::format("LWU %s, %s($%d)", rt, u, 28);
9522 }
9523
9524
9525 /*
9526 *
9527 *
9528 * 3 2 1
9529 * 10987654321098765432109876543210
9530 * 001000 x1110000101
9531 * rt -----
9532 * rs -----
9533 * rd -----
9534 */
9535 std::string NMD::LWU_S9_(uint64 instruction)
9536 {
9537 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9538 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9539 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9540
9541 std::string rt = GPR(copy(rt_value));
9542 std::string s = IMMEDIATE(copy(s_value));
9543 std::string rs = GPR(copy(rs_value));
9544
9545 return img::format("LWU %s, %s(%s)", rt, s, rs);
9546 }
9547
9548
9549 /*
9550 *
9551 *
9552 * 3 2 1
9553 * 10987654321098765432109876543210
9554 * 001000 x1110000101
9555 * rt -----
9556 * rs -----
9557 * rd -----
9558 */
9559 std::string NMD::LWU_U12_(uint64 instruction)
9560 {
9561 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9562 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9563 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9564
9565 std::string rt = GPR(copy(rt_value));
9566 std::string u = IMMEDIATE(copy(u_value));
9567 std::string rs = GPR(copy(rs_value));
9568
9569 return img::format("LWU %s, %s(%s)", rt, u, rs);
9570 }
9571
9572
9573 /*
9574 *
9575 *
9576 * 3 2 1
9577 * 10987654321098765432109876543210
9578 * 001000 x1110000101
9579 * rt -----
9580 * rs -----
9581 * rd -----
9582 */
9583 std::string NMD::LWUX(uint64 instruction)
9584 {
9585 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9586 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9587 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9588
9589 std::string rd = GPR(copy(rd_value));
9590 std::string rs = GPR(copy(rs_value));
9591 std::string rt = GPR(copy(rt_value));
9592
9593 return img::format("LWUX %s, %s(%s)", rd, rs, rt);
9594 }
9595
9596
9597 /*
9598 *
9599 *
9600 * 3 2 1
9601 * 10987654321098765432109876543210
9602 * 001000 x1110000101
9603 * rt -----
9604 * rs -----
9605 * rd -----
9606 */
9607 std::string NMD::LWUXS(uint64 instruction)
9608 {
9609 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9611 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9612
9613 std::string rd = GPR(copy(rd_value));
9614 std::string rs = GPR(copy(rs_value));
9615 std::string rt = GPR(copy(rt_value));
9616
9617 return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
9618 }
9619
9620
9621 /*
9622 *
9623 *
9624 * 3 2 1
9625 * 10987654321098765432109876543210
9626 * 001000 x1110000101
9627 * rt -----
9628 * rs -----
9629 * rd -----
9630 */
9631 std::string NMD::LWX(uint64 instruction)
9632 {
9633 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9634 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9635 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9636
9637 std::string rd = GPR(copy(rd_value));
9638 std::string rs = GPR(copy(rs_value));
9639 std::string rt = GPR(copy(rt_value));
9640
9641 return img::format("LWX %s, %s(%s)", rd, rs, rt);
9642 }
9643
9644
9645 /*
9646 *
9647 *
9648 * 3 2 1
9649 * 10987654321098765432109876543210
9650 * 001000 x1110000101
9651 * rt -----
9652 * rs -----
9653 * rd -----
9654 */
9655 std::string NMD::LWXS_16_(uint64 instruction)
9656 {
9657 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9658 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9659 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9660
9661 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
9662 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
9663 std::string rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
9664
9665 return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
9666 }
9667
9668
9669 /*
9670 *
9671 *
9672 * 3 2 1
9673 * 10987654321098765432109876543210
9674 * 001000 x1110000101
9675 * rt -----
9676 * rs -----
9677 * rd -----
9678 */
9679 std::string NMD::LWXS_32_(uint64 instruction)
9680 {
9681 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9682 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9683 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9684
9685 std::string rd = GPR(copy(rd_value));
9686 std::string rs = GPR(copy(rs_value));
9687 std::string rt = GPR(copy(rt_value));
9688
9689 return img::format("LWXS %s, %s(%s)", rd, rs, rt);
9690 }
9691
9692
9693 /*
9694 *
9695 *
9696 * 3 2 1
9697 * 10987654321098765432109876543210
9698 * 001000 x1110000101
9699 * rt -----
9700 * rs -----
9701 * rd -----
9702 */
9703 std::string NMD::MADD_DSP_(uint64 instruction)
9704 {
9705 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9706 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9707 uint64 ac_value = extract_ac_13_12(instruction);
9708
9709 std::string ac = AC(copy(ac_value));
9710 std::string rs = GPR(copy(rs_value));
9711 std::string rt = GPR(copy(rt_value));
9712
9713 return img::format("MADD %s, %s, %s", ac, rs, rt);
9714 }
9715
9716
9717 /*
9718 *
9719 *
9720 * 3 2 1
9721 * 10987654321098765432109876543210
9722 * 001000 x1110000101
9723 * rt -----
9724 * rs -----
9725 * rd -----
9726 */
9727 std::string NMD::MADDF_D(uint64 instruction)
9728 {
9729 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9730 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9731 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9732
9733 std::string fd = FPR(copy(fd_value));
9734 std::string fs = FPR(copy(fs_value));
9735 std::string ft = FPR(copy(ft_value));
9736
9737 return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
9738 }
9739
9740
9741 /*
9742 *
9743 *
9744 * 3 2 1
9745 * 10987654321098765432109876543210
9746 * 001000 x1110000101
9747 * rt -----
9748 * rs -----
9749 * rd -----
9750 */
9751 std::string NMD::MADDF_S(uint64 instruction)
9752 {
9753 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9754 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9755 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9756
9757 std::string fd = FPR(copy(fd_value));
9758 std::string fs = FPR(copy(fs_value));
9759 std::string ft = FPR(copy(ft_value));
9760
9761 return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
9762 }
9763
9764
9765 /*
9766 *
9767 *
9768 * 3 2 1
9769 * 10987654321098765432109876543210
9770 * 001000 x1110000101
9771 * rt -----
9772 * rs -----
9773 * rd -----
9774 */
9775 std::string NMD::MADDU_DSP_(uint64 instruction)
9776 {
9777 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9778 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9779 uint64 ac_value = extract_ac_13_12(instruction);
9780
9781 std::string ac = AC(copy(ac_value));
9782 std::string rs = GPR(copy(rs_value));
9783 std::string rt = GPR(copy(rt_value));
9784
9785 return img::format("MADDU %s, %s, %s", ac, rs, rt);
9786 }
9787
9788
9789 /*
9790 *
9791 *
9792 * 3 2 1
9793 * 10987654321098765432109876543210
9794 * 001000 x1110000101
9795 * rt -----
9796 * rs -----
9797 * rd -----
9798 */
9799 std::string NMD::MAQ_S_W_PHL(uint64 instruction)
9800 {
9801 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9802 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9803 uint64 ac_value = extract_ac_13_12(instruction);
9804
9805 std::string ac = AC(copy(ac_value));
9806 std::string rs = GPR(copy(rs_value));
9807 std::string rt = GPR(copy(rt_value));
9808
9809 return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9810 }
9811
9812
9813 /*
9814 *
9815 *
9816 * 3 2 1
9817 * 10987654321098765432109876543210
9818 * 001000 x1110000101
9819 * rt -----
9820 * rs -----
9821 * rd -----
9822 */
9823 std::string NMD::MAQ_S_W_PHR(uint64 instruction)
9824 {
9825 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9826 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9827 uint64 ac_value = extract_ac_13_12(instruction);
9828
9829 std::string ac = AC(copy(ac_value));
9830 std::string rs = GPR(copy(rs_value));
9831 std::string rt = GPR(copy(rt_value));
9832
9833 return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9834 }
9835
9836
9837 /*
9838 *
9839 *
9840 * 3 2 1
9841 * 10987654321098765432109876543210
9842 * 001000 x1110000101
9843 * rt -----
9844 * rs -----
9845 * rd -----
9846 */
9847 std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
9848 {
9849 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9850 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9851 uint64 ac_value = extract_ac_13_12(instruction);
9852
9853 std::string ac = AC(copy(ac_value));
9854 std::string rs = GPR(copy(rs_value));
9855 std::string rt = GPR(copy(rt_value));
9856
9857 return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9858 }
9859
9860
9861 /*
9862 *
9863 *
9864 * 3 2 1
9865 * 10987654321098765432109876543210
9866 * 001000 x1110000101
9867 * rt -----
9868 * rs -----
9869 * rd -----
9870 */
9871 std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
9872 {
9873 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9874 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9875 uint64 ac_value = extract_ac_13_12(instruction);
9876
9877 std::string ac = AC(copy(ac_value));
9878 std::string rs = GPR(copy(rs_value));
9879 std::string rt = GPR(copy(rt_value));
9880
9881 return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9882 }
9883
9884
9885 /*
9886 *
9887 *
9888 * 3 2 1
9889 * 10987654321098765432109876543210
9890 * 001000 x1110000101
9891 * rt -----
9892 * rs -----
9893 * rd -----
9894 */
9895 std::string NMD::MAX_D(uint64 instruction)
9896 {
9897 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9898 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9899 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9900
9901 std::string fd = FPR(copy(fd_value));
9902 std::string fs = FPR(copy(fs_value));
9903 std::string ft = FPR(copy(ft_value));
9904
9905 return img::format("MAX.D %s, %s, %s", fd, fs, ft);
9906 }
9907
9908
9909 /*
9910 *
9911 *
9912 * 3 2 1
9913 * 10987654321098765432109876543210
9914 * 001000 x1110000101
9915 * rt -----
9916 * rs -----
9917 * rd -----
9918 */
9919 std::string NMD::MAX_S(uint64 instruction)
9920 {
9921 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9922 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9923 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9924
9925 std::string fd = FPR(copy(fd_value));
9926 std::string fs = FPR(copy(fs_value));
9927 std::string ft = FPR(copy(ft_value));
9928
9929 return img::format("MAX.S %s, %s, %s", fd, fs, ft);
9930 }
9931
9932
9933 /*
9934 *
9935 *
9936 * 3 2 1
9937 * 10987654321098765432109876543210
9938 * 001000 x1110000101
9939 * rt -----
9940 * rs -----
9941 * rd -----
9942 */
9943 std::string NMD::MAXA_D(uint64 instruction)
9944 {
9945 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9946 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9947 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9948
9949 std::string fd = FPR(copy(fd_value));
9950 std::string fs = FPR(copy(fs_value));
9951 std::string ft = FPR(copy(ft_value));
9952
9953 return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
9954 }
9955
9956
9957 /*
9958 *
9959 *
9960 * 3 2 1
9961 * 10987654321098765432109876543210
9962 * 001000 x1110000101
9963 * rt -----
9964 * rs -----
9965 * rd -----
9966 */
9967 std::string NMD::MAXA_S(uint64 instruction)
9968 {
9969 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9970 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9971 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9972
9973 std::string fd = FPR(copy(fd_value));
9974 std::string fs = FPR(copy(fs_value));
9975 std::string ft = FPR(copy(ft_value));
9976
9977 return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
9978 }
9979
9980
9981 /*
9982 *
9983 *
9984 * 3 2 1
9985 * 10987654321098765432109876543210
9986 * 001000 x1110000101
9987 * rt -----
9988 * rs -----
9989 * rd -----
9990 */
9991 std::string NMD::MFC0(uint64 instruction)
9992 {
9993 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9994 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9995 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9996
9997 std::string rt = GPR(copy(rt_value));
9998 std::string c0s = CPR(copy(c0s_value));
9999 std::string sel = IMMEDIATE(copy(sel_value));
10000
10001 return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
10002 }
10003
10004
10005 /*
10006 *
10007 *
10008 * 3 2 1
10009 * 10987654321098765432109876543210
10010 * 001000 x1110000101
10011 * rt -----
10012 * rs -----
10013 * rd -----
10014 */
10015 std::string NMD::MFC1(uint64 instruction)
10016 {
10017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10018 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10019
10020 std::string rt = GPR(copy(rt_value));
10021 std::string fs = FPR(copy(fs_value));
10022
10023 return img::format("MFC1 %s, %s", rt, fs);
10024 }
10025
10026
10027 /*
10028 *
10029 *
10030 * 3 2 1
10031 * 10987654321098765432109876543210
10032 * 001000 x1110000101
10033 * rt -----
10034 * rs -----
10035 * rd -----
10036 */
10037 std::string NMD::MFC2(uint64 instruction)
10038 {
10039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10040 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10041
10042 std::string rt = GPR(copy(rt_value));
10043 std::string cs = CPR(copy(cs_value));
10044
10045 return img::format("MFC2 %s, %s", rt, cs);
10046 }
10047
10048
10049 /*
10050 *
10051 *
10052 * 3 2 1
10053 * 10987654321098765432109876543210
10054 * 001000 x1110000101
10055 * rt -----
10056 * rs -----
10057 * rd -----
10058 */
10059 std::string NMD::MFGC0(uint64 instruction)
10060 {
10061 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10062 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10063 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10064
10065 std::string rt = GPR(copy(rt_value));
10066 std::string c0s = CPR(copy(c0s_value));
10067 std::string sel = IMMEDIATE(copy(sel_value));
10068
10069 return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
10070 }
10071
10072
10073 /*
10074 *
10075 *
10076 * 3 2 1
10077 * 10987654321098765432109876543210
10078 * 001000 x1110000101
10079 * rt -----
10080 * rs -----
10081 * rd -----
10082 */
10083 std::string NMD::MFHC0(uint64 instruction)
10084 {
10085 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10086 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10087 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10088
10089 std::string rt = GPR(copy(rt_value));
10090 std::string c0s = CPR(copy(c0s_value));
10091 std::string sel = IMMEDIATE(copy(sel_value));
10092
10093 return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
10094 }
10095
10096
10097 /*
10098 *
10099 *
10100 * 3 2 1
10101 * 10987654321098765432109876543210
10102 * 001000 x1110000101
10103 * rt -----
10104 * rs -----
10105 * rd -----
10106 */
10107 std::string NMD::MFHC1(uint64 instruction)
10108 {
10109 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10110 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10111
10112 std::string rt = GPR(copy(rt_value));
10113 std::string fs = FPR(copy(fs_value));
10114
10115 return img::format("MFHC1 %s, %s", rt, fs);
10116 }
10117
10118
10119 /*
10120 *
10121 *
10122 * 3 2 1
10123 * 10987654321098765432109876543210
10124 * 001000 x1110000101
10125 * rt -----
10126 * rs -----
10127 * rd -----
10128 */
10129 std::string NMD::MFHC2(uint64 instruction)
10130 {
10131 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10132 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10133
10134 std::string rt = GPR(copy(rt_value));
10135 std::string cs = CPR(copy(cs_value));
10136
10137 return img::format("MFHC2 %s, %s", rt, cs);
10138 }
10139
10140
10141 /*
10142 *
10143 *
10144 * 3 2 1
10145 * 10987654321098765432109876543210
10146 * 001000 x1110000101
10147 * rt -----
10148 * rs -----
10149 * rd -----
10150 */
10151 std::string NMD::MFHGC0(uint64 instruction)
10152 {
10153 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10154 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10155 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10156
10157 std::string rt = GPR(copy(rt_value));
10158 std::string c0s = CPR(copy(c0s_value));
10159 std::string sel = IMMEDIATE(copy(sel_value));
10160
10161 return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
10162 }
10163
10164
10165 /*
10166 *
10167 *
10168 * 3 2 1
10169 * 10987654321098765432109876543210
10170 * 001000 x1110000101
10171 * rt -----
10172 * rs -----
10173 * rd -----
10174 */
10175 std::string NMD::MFHI_DSP_(uint64 instruction)
10176 {
10177 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10178 uint64 ac_value = extract_ac_13_12(instruction);
10179
10180 std::string rt = GPR(copy(rt_value));
10181 std::string ac = AC(copy(ac_value));
10182
10183 return img::format("MFHI %s, %s", rt, ac);
10184 }
10185
10186
10187 /*
10188 *
10189 *
10190 * 3 2 1
10191 * 10987654321098765432109876543210
10192 * 001000 x1110000101
10193 * rt -----
10194 * rs -----
10195 * rd -----
10196 */
10197 std::string NMD::MFHTR(uint64 instruction)
10198 {
10199 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10200 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10201 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10202 uint64 u_value = extract_u_10(instruction);
10203
10204 std::string rt = GPR(copy(rt_value));
10205 std::string c0s = IMMEDIATE(copy(c0s_value));
10206 std::string u = IMMEDIATE(copy(u_value));
10207 std::string sel = IMMEDIATE(copy(sel_value));
10208
10209 return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
10210 }
10211
10212
10213 /*
10214 *
10215 *
10216 * 3 2 1
10217 * 10987654321098765432109876543210
10218 * 001000 x1110000101
10219 * rt -----
10220 * rs -----
10221 * rd -----
10222 */
10223 std::string NMD::MFLO_DSP_(uint64 instruction)
10224 {
10225 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10226 uint64 ac_value = extract_ac_13_12(instruction);
10227
10228 std::string rt = GPR(copy(rt_value));
10229 std::string ac = AC(copy(ac_value));
10230
10231 return img::format("MFLO %s, %s", rt, ac);
10232 }
10233
10234
10235 /*
10236 *
10237 *
10238 * 3 2 1
10239 * 10987654321098765432109876543210
10240 * 001000 x1110000101
10241 * rt -----
10242 * rs -----
10243 * rd -----
10244 */
10245 std::string NMD::MFTR(uint64 instruction)
10246 {
10247 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10248 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10249 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10250 uint64 u_value = extract_u_10(instruction);
10251
10252 std::string rt = GPR(copy(rt_value));
10253 std::string c0s = IMMEDIATE(copy(c0s_value));
10254 std::string u = IMMEDIATE(copy(u_value));
10255 std::string sel = IMMEDIATE(copy(sel_value));
10256
10257 return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
10258 }
10259
10260
10261 /*
10262 *
10263 *
10264 * 3 2 1
10265 * 10987654321098765432109876543210
10266 * 001000 x1110000101
10267 * rt -----
10268 * rs -----
10269 * rd -----
10270 */
10271 std::string NMD::MIN_D(uint64 instruction)
10272 {
10273 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10274 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10275 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10276
10277 std::string fd = FPR(copy(fd_value));
10278 std::string fs = FPR(copy(fs_value));
10279 std::string ft = FPR(copy(ft_value));
10280
10281 return img::format("MIN.D %s, %s, %s", fd, fs, ft);
10282 }
10283
10284
10285 /*
10286 *
10287 *
10288 * 3 2 1
10289 * 10987654321098765432109876543210
10290 * 001000 x1110000101
10291 * rt -----
10292 * rs -----
10293 * rd -----
10294 */
10295 std::string NMD::MIN_S(uint64 instruction)
10296 {
10297 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10298 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10299 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10300
10301 std::string fd = FPR(copy(fd_value));
10302 std::string fs = FPR(copy(fs_value));
10303 std::string ft = FPR(copy(ft_value));
10304
10305 return img::format("MIN.S %s, %s, %s", fd, fs, ft);
10306 }
10307
10308
10309 /*
10310 *
10311 *
10312 * 3 2 1
10313 * 10987654321098765432109876543210
10314 * 001000 x1110000101
10315 * rt -----
10316 * rs -----
10317 * rd -----
10318 */
10319 std::string NMD::MINA_D(uint64 instruction)
10320 {
10321 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10322 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10323 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10324
10325 std::string fd = FPR(copy(fd_value));
10326 std::string fs = FPR(copy(fs_value));
10327 std::string ft = FPR(copy(ft_value));
10328
10329 return img::format("MINA.D %s, %s, %s", fd, fs, ft);
10330 }
10331
10332
10333 /*
10334 *
10335 *
10336 * 3 2 1
10337 * 10987654321098765432109876543210
10338 * 001000 x1110000101
10339 * rt -----
10340 * rs -----
10341 * rd -----
10342 */
10343 std::string NMD::MINA_S(uint64 instruction)
10344 {
10345 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10346 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10347 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10348
10349 std::string fd = FPR(copy(fd_value));
10350 std::string fs = FPR(copy(fs_value));
10351 std::string ft = FPR(copy(ft_value));
10352
10353 return img::format("MINA.S %s, %s, %s", fd, fs, ft);
10354 }
10355
10356
10357 /*
10358 *
10359 *
10360 * 3 2 1
10361 * 10987654321098765432109876543210
10362 * 001000 x1110000101
10363 * rt -----
10364 * rs -----
10365 * rd -----
10366 */
10367 std::string NMD::MOD(uint64 instruction)
10368 {
10369 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10370 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10371 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10372
10373 std::string rd = GPR(copy(rd_value));
10374 std::string rs = GPR(copy(rs_value));
10375 std::string rt = GPR(copy(rt_value));
10376
10377 return img::format("MOD %s, %s, %s", rd, rs, rt);
10378 }
10379
10380
10381 /*
10382 *
10383 *
10384 * 3 2 1
10385 * 10987654321098765432109876543210
10386 * 001000 x1110000101
10387 * rt -----
10388 * rs -----
10389 * rd -----
10390 */
10391 std::string NMD::MODSUB(uint64 instruction)
10392 {
10393 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10394 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10395 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10396
10397 std::string rd = GPR(copy(rd_value));
10398 std::string rs = GPR(copy(rs_value));
10399 std::string rt = GPR(copy(rt_value));
10400
10401 return img::format("MODSUB %s, %s, %s", rd, rs, rt);
10402 }
10403
10404
10405 /*
10406 *
10407 *
10408 * 3 2 1
10409 * 10987654321098765432109876543210
10410 * 001000 x1110000101
10411 * rt -----
10412 * rs -----
10413 * rd -----
10414 */
10415 std::string NMD::MODU(uint64 instruction)
10416 {
10417 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10418 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10419 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10420
10421 std::string rd = GPR(copy(rd_value));
10422 std::string rs = GPR(copy(rs_value));
10423 std::string rt = GPR(copy(rt_value));
10424
10425 return img::format("MODU %s, %s, %s", rd, rs, rt);
10426 }
10427
10428
10429 /*
10430 *
10431 *
10432 * 3 2 1
10433 * 10987654321098765432109876543210
10434 * 001000 x1110000101
10435 * rt -----
10436 * rs -----
10437 * rd -----
10438 */
10439 std::string NMD::MOV_D(uint64 instruction)
10440 {
10441 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10442 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10443
10444 std::string ft = FPR(copy(ft_value));
10445 std::string fs = FPR(copy(fs_value));
10446
10447 return img::format("MOV.D %s, %s", ft, fs);
10448 }
10449
10450
10451 /*
10452 *
10453 *
10454 * 3 2 1
10455 * 10987654321098765432109876543210
10456 * 001000 x1110000101
10457 * rt -----
10458 * rs -----
10459 * rd -----
10460 */
10461 std::string NMD::MOV_S(uint64 instruction)
10462 {
10463 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10464 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10465
10466 std::string ft = FPR(copy(ft_value));
10467 std::string fs = FPR(copy(fs_value));
10468
10469 return img::format("MOV.S %s, %s", ft, fs);
10470 }
10471
10472
10473 /*
10474 *
10475 *
10476 * 3 2 1
10477 * 10987654321098765432109876543210
10478 * 001000 x1110000101
10479 * rt -----
10480 * rs -----
10481 * rd -----
10482 */
10483 std::string NMD::MOVE_BALC(uint64 instruction)
10484 {
10485 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10486 uint64 rd1_value = extract_rdl_25_24(instruction);
10487 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
10488
10489 std::string rd1 = GPR(decode_gpr_gpr1(rd1_value));
10490 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
10491 std::string s = ADDRESS(encode_s_from_address(s_value), 4);
10492
10493 return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10494 }
10495
10496
10497 /*
10498 *
10499 *
10500 * 3 2 1
10501 * 10987654321098765432109876543210
10502 * 001000 x1110000101
10503 * rt -----
10504 * rs -----
10505 * rd -----
10506 */
10507 std::string NMD::MOVEP(uint64 instruction)
10508 {
10509 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10510 uint64 rd2_value = extract_rd2_3_8(instruction);
10511 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10512
10513 std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
10514 std::string re2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
10515 /* !!!!!!!!!! - no conversion function */
10516 std::string rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
10517 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
10518
10519 return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10520 /* hand edited */
10521 }
10522
10523
10524 /*
10525 *
10526 *
10527 * 3 2 1
10528 * 10987654321098765432109876543210
10529 * 001000 x1110000101
10530 * rt -----
10531 * rs -----
10532 * rd -----
10533 */
10534 std::string NMD::MOVEP_REV_(uint64 instruction)
10535 {
10536 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10537 uint64 rd2_value = extract_rd2_3_8(instruction);
10538 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10539
10540 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
10541 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
10542 std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
10543 std::string rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
10544 /* !!!!!!!!!! - no conversion function */
10545
10546 return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10547 /* hand edited */
10548 }
10549
10550
10551 /*
10552 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10553 *
10554 * 3 2 1
10555 * 10987654321098765432109876543210
10556 * 001000 00010001101
10557 * rt -----
10558 * rs -----
10559 * rd -----
10560 */
10561 std::string NMD::MOVE(uint64 instruction)
10562 {
10563 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10564 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10565
10566 std::string rt = GPR(copy(rt_value));
10567 std::string rs = GPR(copy(rs_value));
10568
10569 return img::format("MOVE %s, %s", rt, rs);
10570 }
10571
10572
10573 /*
10574 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10575 *
10576 * 3 2 1
10577 * 10987654321098765432109876543210
10578 * 001000 00010001101
10579 * rt -----
10580 * rs -----
10581 * rd -----
10582 */
10583 std::string NMD::MOVN(uint64 instruction)
10584 {
10585 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10586 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10587 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10588
10589 std::string rd = GPR(copy(rd_value));
10590 std::string rs = GPR(copy(rs_value));
10591 std::string rt = GPR(copy(rt_value));
10592
10593 return img::format("MOVN %s, %s, %s", rd, rs, rt);
10594 }
10595
10596
10597 /*
10598 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10599 *
10600 * 3 2 1
10601 * 10987654321098765432109876543210
10602 * 001000 00010001101
10603 * rt -----
10604 * rs -----
10605 * rd -----
10606 */
10607 std::string NMD::MOVZ(uint64 instruction)
10608 {
10609 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10611 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10612
10613 std::string rd = GPR(copy(rd_value));
10614 std::string rs = GPR(copy(rs_value));
10615 std::string rt = GPR(copy(rt_value));
10616
10617 return img::format("MOVZ %s, %s, %s", rd, rs, rt);
10618 }
10619
10620
10621 /*
10622 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10623 *
10624 * 3 2 1
10625 * 10987654321098765432109876543210
10626 * 001000 00010001101
10627 * rt -----
10628 * rs -----
10629 * rd -----
10630 */
10631 std::string NMD::MSUB_DSP_(uint64 instruction)
10632 {
10633 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10634 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10635 uint64 ac_value = extract_ac_13_12(instruction);
10636
10637 std::string ac = AC(copy(ac_value));
10638 std::string rs = GPR(copy(rs_value));
10639 std::string rt = GPR(copy(rt_value));
10640
10641 return img::format("MSUB %s, %s, %s", ac, rs, rt);
10642 }
10643
10644
10645 /*
10646 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10647 *
10648 * 3 2 1
10649 * 10987654321098765432109876543210
10650 * 001000 00010001101
10651 * rt -----
10652 * rs -----
10653 * rd -----
10654 */
10655 std::string NMD::MSUBF_D(uint64 instruction)
10656 {
10657 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10658 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10659 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10660
10661 std::string fd = FPR(copy(fd_value));
10662 std::string fs = FPR(copy(fs_value));
10663 std::string ft = FPR(copy(ft_value));
10664
10665 return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
10666 }
10667
10668
10669 /*
10670 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10671 *
10672 * 3 2 1
10673 * 10987654321098765432109876543210
10674 * 001000 00010001101
10675 * rt -----
10676 * rs -----
10677 * rd -----
10678 */
10679 std::string NMD::MSUBF_S(uint64 instruction)
10680 {
10681 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10682 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10683 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10684
10685 std::string fd = FPR(copy(fd_value));
10686 std::string fs = FPR(copy(fs_value));
10687 std::string ft = FPR(copy(ft_value));
10688
10689 return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
10690 }
10691
10692
10693 /*
10694 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10695 *
10696 * 3 2 1
10697 * 10987654321098765432109876543210
10698 * 001000 00010001101
10699 * rt -----
10700 * rs -----
10701 * rd -----
10702 */
10703 std::string NMD::MSUBU_DSP_(uint64 instruction)
10704 {
10705 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10706 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10707 uint64 ac_value = extract_ac_13_12(instruction);
10708
10709 std::string ac = AC(copy(ac_value));
10710 std::string rs = GPR(copy(rs_value));
10711 std::string rt = GPR(copy(rt_value));
10712
10713 return img::format("MSUBU %s, %s, %s", ac, rs, rt);
10714 }
10715
10716
10717 /*
10718 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10719 *
10720 * 3 2 1
10721 * 10987654321098765432109876543210
10722 * 001000 00010001101
10723 * rt -----
10724 * rs -----
10725 * rd -----
10726 */
10727 std::string NMD::MTC0(uint64 instruction)
10728 {
10729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10730 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10731 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10732
10733 std::string rt = GPR(copy(rt_value));
10734 std::string c0s = CPR(copy(c0s_value));
10735 std::string sel = IMMEDIATE(copy(sel_value));
10736
10737 return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
10738 }
10739
10740
10741 /*
10742 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10743 *
10744 * 3 2 1
10745 * 10987654321098765432109876543210
10746 * 001000 00010001101
10747 * rt -----
10748 * rs -----
10749 * rd -----
10750 */
10751 std::string NMD::MTC1(uint64 instruction)
10752 {
10753 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10754 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10755
10756 std::string rt = GPR(copy(rt_value));
10757 std::string fs = FPR(copy(fs_value));
10758
10759 return img::format("MTC1 %s, %s", rt, fs);
10760 }
10761
10762
10763 /*
10764 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10765 *
10766 * 3 2 1
10767 * 10987654321098765432109876543210
10768 * 001000 00010001101
10769 * rt -----
10770 * rs -----
10771 * rd -----
10772 */
10773 std::string NMD::MTC2(uint64 instruction)
10774 {
10775 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10776 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10777
10778 std::string rt = GPR(copy(rt_value));
10779 std::string cs = CPR(copy(cs_value));
10780
10781 return img::format("MTC2 %s, %s", rt, cs);
10782 }
10783
10784
10785 /*
10786 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10787 *
10788 * 3 2 1
10789 * 10987654321098765432109876543210
10790 * 001000 00010001101
10791 * rt -----
10792 * rs -----
10793 * rd -----
10794 */
10795 std::string NMD::MTGC0(uint64 instruction)
10796 {
10797 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10798 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10799 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10800
10801 std::string rt = GPR(copy(rt_value));
10802 std::string c0s = CPR(copy(c0s_value));
10803 std::string sel = IMMEDIATE(copy(sel_value));
10804
10805 return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
10806 }
10807
10808
10809 /*
10810 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10811 *
10812 * 3 2 1
10813 * 10987654321098765432109876543210
10814 * 001000 00010001101
10815 * rt -----
10816 * rs -----
10817 * rd -----
10818 */
10819 std::string NMD::MTHC0(uint64 instruction)
10820 {
10821 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10822 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10823 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10824
10825 std::string rt = GPR(copy(rt_value));
10826 std::string c0s = CPR(copy(c0s_value));
10827 std::string sel = IMMEDIATE(copy(sel_value));
10828
10829 return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
10830 }
10831
10832
10833 /*
10834 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10835 *
10836 * 3 2 1
10837 * 10987654321098765432109876543210
10838 * 001000 00010001101
10839 * rt -----
10840 * rs -----
10841 * rd -----
10842 */
10843 std::string NMD::MTHC1(uint64 instruction)
10844 {
10845 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10846 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10847
10848 std::string rt = GPR(copy(rt_value));
10849 std::string fs = FPR(copy(fs_value));
10850
10851 return img::format("MTHC1 %s, %s", rt, fs);
10852 }
10853
10854
10855 /*
10856 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10857 *
10858 * 3 2 1
10859 * 10987654321098765432109876543210
10860 * 001000 00010001101
10861 * rt -----
10862 * rs -----
10863 * rd -----
10864 */
10865 std::string NMD::MTHC2(uint64 instruction)
10866 {
10867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10868 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10869
10870 std::string rt = GPR(copy(rt_value));
10871 std::string cs = CPR(copy(cs_value));
10872
10873 return img::format("MTHC2 %s, %s", rt, cs);
10874 }
10875
10876
10877 /*
10878 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10879 *
10880 * 3 2 1
10881 * 10987654321098765432109876543210
10882 * 001000 00010001101
10883 * rt -----
10884 * rs -----
10885 * rd -----
10886 */
10887 std::string NMD::MTHGC0(uint64 instruction)
10888 {
10889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10890 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10891 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10892
10893 std::string rt = GPR(copy(rt_value));
10894 std::string c0s = CPR(copy(c0s_value));
10895 std::string sel = IMMEDIATE(copy(sel_value));
10896
10897 return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
10898 }
10899
10900
10901 /*
10902 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10903 *
10904 * 3 2 1
10905 * 10987654321098765432109876543210
10906 * 001000 00010001101
10907 * rt -----
10908 * rs -----
10909 * rd -----
10910 */
10911 std::string NMD::MTHI_DSP_(uint64 instruction)
10912 {
10913 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10914 uint64 ac_value = extract_ac_13_12(instruction);
10915
10916 std::string rs = GPR(copy(rs_value));
10917 std::string ac = AC(copy(ac_value));
10918
10919 return img::format("MTHI %s, %s", rs, ac);
10920 }
10921
10922
10923 /*
10924 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10925 *
10926 * 3 2 1
10927 * 10987654321098765432109876543210
10928 * 001000 00010001101
10929 * rt -----
10930 * rs -----
10931 * rd -----
10932 */
10933 std::string NMD::MTHLIP(uint64 instruction)
10934 {
10935 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10936 uint64 ac_value = extract_ac_13_12(instruction);
10937
10938 std::string rs = GPR(copy(rs_value));
10939 std::string ac = AC(copy(ac_value));
10940
10941 return img::format("MTHLIP %s, %s", rs, ac);
10942 }
10943
10944
10945 /*
10946 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10947 *
10948 * 3 2 1
10949 * 10987654321098765432109876543210
10950 * 001000 00010001101
10951 * rt -----
10952 * rs -----
10953 * rd -----
10954 */
10955 std::string NMD::MTHTR(uint64 instruction)
10956 {
10957 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10958 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10959 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10960 uint64 u_value = extract_u_10(instruction);
10961
10962 std::string rt = GPR(copy(rt_value));
10963 std::string c0s = IMMEDIATE(copy(c0s_value));
10964 std::string u = IMMEDIATE(copy(u_value));
10965 std::string sel = IMMEDIATE(copy(sel_value));
10966
10967 return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
10968 }
10969
10970
10971 /*
10972 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10973 *
10974 * 3 2 1
10975 * 10987654321098765432109876543210
10976 * 001000 00010001101
10977 * rt -----
10978 * rs -----
10979 * rd -----
10980 */
10981 std::string NMD::MTLO_DSP_(uint64 instruction)
10982 {
10983 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10984 uint64 ac_value = extract_ac_13_12(instruction);
10985
10986 std::string rs = GPR(copy(rs_value));
10987 std::string ac = AC(copy(ac_value));
10988
10989 return img::format("MTLO %s, %s", rs, ac);
10990 }
10991
10992
10993 /*
10994 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10995 *
10996 * 3 2 1
10997 * 10987654321098765432109876543210
10998 * 001000 00010001101
10999 * rt -----
11000 * rs -----
11001 * rd -----
11002 */
11003 std::string NMD::MTTR(uint64 instruction)
11004 {
11005 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11006 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
11007 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
11008 uint64 u_value = extract_u_10(instruction);
11009
11010 std::string rt = GPR(copy(rt_value));
11011 std::string c0s = IMMEDIATE(copy(c0s_value));
11012 std::string u = IMMEDIATE(copy(u_value));
11013 std::string sel = IMMEDIATE(copy(sel_value));
11014
11015 return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
11016 }
11017
11018
11019 /*
11020 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11021 *
11022 * 3 2 1
11023 * 10987654321098765432109876543210
11024 * 001000 00010001101
11025 * rt -----
11026 * rs -----
11027 * rd -----
11028 */
11029 std::string NMD::MUH(uint64 instruction)
11030 {
11031 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11032 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11033 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11034
11035 std::string rd = GPR(copy(rd_value));
11036 std::string rs = GPR(copy(rs_value));
11037 std::string rt = GPR(copy(rt_value));
11038
11039 return img::format("MUH %s, %s, %s", rd, rs, rt);
11040 }
11041
11042
11043 /*
11044 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11045 *
11046 * 3 2 1
11047 * 10987654321098765432109876543210
11048 * 001000 00010001101
11049 * rt -----
11050 * rs -----
11051 * rd -----
11052 */
11053 std::string NMD::MUHU(uint64 instruction)
11054 {
11055 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11056 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11057 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11058
11059 std::string rd = GPR(copy(rd_value));
11060 std::string rs = GPR(copy(rs_value));
11061 std::string rt = GPR(copy(rt_value));
11062
11063 return img::format("MUHU %s, %s, %s", rd, rs, rt);
11064 }
11065
11066
11067 /*
11068 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11069 *
11070 * 3 2 1
11071 * 10987654321098765432109876543210
11072 * 001000 00010001101
11073 * rt -----
11074 * rs -----
11075 * rd -----
11076 */
11077 std::string NMD::MUL_32_(uint64 instruction)
11078 {
11079 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11080 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11081 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11082
11083 std::string rd = GPR(copy(rd_value));
11084 std::string rs = GPR(copy(rs_value));
11085 std::string rt = GPR(copy(rt_value));
11086
11087 return img::format("MUL %s, %s, %s", rd, rs, rt);
11088 }
11089
11090
11091 /*
11092 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11093 *
11094 * 3 2 1
11095 * 10987654321098765432109876543210
11096 * 001000 00010001101
11097 * rt -----
11098 * rs -----
11099 * rd -----
11100 */
11101 std::string NMD::MUL_4X4_(uint64 instruction)
11102 {
11103 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
11104 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
11105
11106 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
11107 std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
11108
11109 return img::format("MUL %s, %s", rs4, rt4);
11110 }
11111
11112
11113 /*
11114 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11115 *
11116 * 3 2 1
11117 * 10987654321098765432109876543210
11118 * 001000 00010001101
11119 * rt -----
11120 * rs -----
11121 * rd -----
11122 */
11123 std::string NMD::MUL_D(uint64 instruction)
11124 {
11125 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11126 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11127 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
11128
11129 std::string fd = FPR(copy(fd_value));
11130 std::string fs = FPR(copy(fs_value));
11131 std::string ft = FPR(copy(ft_value));
11132
11133 return img::format("MUL.D %s, %s, %s", fd, fs, ft);
11134 }
11135
11136
11137 /*
11138 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11139 *
11140 * 3 2 1
11141 * 10987654321098765432109876543210
11142 * 001000 00010001101
11143 * rt -----
11144 * rs -----
11145 * rd -----
11146 */
11147 std::string NMD::MUL_PH(uint64 instruction)
11148 {
11149 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11150 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11151 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11152
11153 std::string rd = GPR(copy(rd_value));
11154 std::string rs = GPR(copy(rs_value));
11155 std::string rt = GPR(copy(rt_value));
11156
11157 return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
11158 }
11159
11160
11161 /*
11162 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11163 *
11164 * 3 2 1
11165 * 10987654321098765432109876543210
11166 * 001000 00010001101
11167 * rt -----
11168 * rs -----
11169 * rd -----
11170 */
11171 std::string NMD::MUL_S_PH(uint64 instruction)
11172 {
11173 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11174 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11175 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11176
11177 std::string rd = GPR(copy(rd_value));
11178 std::string rs = GPR(copy(rs_value));
11179 std::string rt = GPR(copy(rt_value));
11180
11181 return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
11182 }
11183
11184
11185 /*
11186 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11187 *
11188 * 3 2 1
11189 * 10987654321098765432109876543210
11190 * 001000 00010001101
11191 * rt -----
11192 * rs -----
11193 * rd -----
11194 */
11195 std::string NMD::MUL_S(uint64 instruction)
11196 {
11197 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11198 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11199 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
11200
11201 std::string fd = FPR(copy(fd_value));
11202 std::string fs = FPR(copy(fs_value));
11203 std::string ft = FPR(copy(ft_value));
11204
11205 return img::format("MUL.S %s, %s, %s", fd, fs, ft);
11206 }
11207
11208
11209 /*
11210 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11211 *
11212 * 3 2 1
11213 * 10987654321098765432109876543210
11214 * 001000 00010001101
11215 * rt -----
11216 * rs -----
11217 * rd -----
11218 */
11219 std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
11220 {
11221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11222 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11223 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11224
11225 std::string rd = GPR(copy(rd_value));
11226 std::string rs = GPR(copy(rs_value));
11227 std::string rt = GPR(copy(rt_value));
11228
11229 return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
11230 }
11231
11232
11233 /*
11234 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11235 *
11236 * 3 2 1
11237 * 10987654321098765432109876543210
11238 * 001000 00010001101
11239 * rt -----
11240 * rs -----
11241 * rd -----
11242 */
11243 std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
11244 {
11245 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11246 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11247 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11248
11249 std::string rd = GPR(copy(rd_value));
11250 std::string rs = GPR(copy(rs_value));
11251 std::string rt = GPR(copy(rt_value));
11252
11253 return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
11254 }
11255
11256
11257 /*
11258 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11259 *
11260 * 3 2 1
11261 * 10987654321098765432109876543210
11262 * 001000 00010001101
11263 * rt -----
11264 * rs -----
11265 * rd -----
11266 */
11267 std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
11268 {
11269 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11270 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11271 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11272
11273 std::string rd = GPR(copy(rd_value));
11274 std::string rs = GPR(copy(rs_value));
11275 std::string rt = GPR(copy(rt_value));
11276
11277 return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
11278 }
11279
11280
11281 /*
11282 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11283 *
11284 * 3 2 1
11285 * 10987654321098765432109876543210
11286 * 001000 00010001101
11287 * rt -----
11288 * rs -----
11289 * rd -----
11290 */
11291 std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
11292 {
11293 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11294 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11295 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11296
11297 std::string rd = GPR(copy(rd_value));
11298 std::string rs = GPR(copy(rs_value));
11299 std::string rt = GPR(copy(rt_value));
11300
11301 return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
11302 }
11303
11304
11305 /*
11306 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11307 *
11308 * 3 2 1
11309 * 10987654321098765432109876543210
11310 * 001000 00010001101
11311 * rt -----
11312 * rs -----
11313 * rd -----
11314 */
11315 std::string NMD::MULQ_RS_PH(uint64 instruction)
11316 {
11317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11318 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11319 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11320
11321 std::string rd = GPR(copy(rd_value));
11322 std::string rs = GPR(copy(rs_value));
11323 std::string rt = GPR(copy(rt_value));
11324
11325 return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
11326 }
11327
11328
11329 /*
11330 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11331 *
11332 * 3 2 1
11333 * 10987654321098765432109876543210
11334 * 001000 00010001101
11335 * rt -----
11336 * rs -----
11337 * rd -----
11338 */
11339 std::string NMD::MULQ_RS_W(uint64 instruction)
11340 {
11341 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11342 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11343 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11344
11345 std::string rd = GPR(copy(rd_value));
11346 std::string rs = GPR(copy(rs_value));
11347 std::string rt = GPR(copy(rt_value));
11348
11349 return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
11350 }
11351
11352
11353 /*
11354 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11355 *
11356 * 3 2 1
11357 * 10987654321098765432109876543210
11358 * 001000 00010001101
11359 * rt -----
11360 * rs -----
11361 * rd -----
11362 */
11363 std::string NMD::MULQ_S_PH(uint64 instruction)
11364 {
11365 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11366 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11367 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11368
11369 std::string rd = GPR(copy(rd_value));
11370 std::string rs = GPR(copy(rs_value));
11371 std::string rt = GPR(copy(rt_value));
11372
11373 return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
11374 }
11375
11376
11377 /*
11378 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11379 *
11380 * 3 2 1
11381 * 10987654321098765432109876543210
11382 * 001000 00010001101
11383 * rt -----
11384 * rs -----
11385 * rd -----
11386 */
11387 std::string NMD::MULQ_S_W(uint64 instruction)
11388 {
11389 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11390 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11391 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11392
11393 std::string rd = GPR(copy(rd_value));
11394 std::string rs = GPR(copy(rs_value));
11395 std::string rt = GPR(copy(rt_value));
11396
11397 return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11398 }
11399
11400
11401 /*
11402 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11403 *
11404 * 3 2 1
11405 * 10987654321098765432109876543210
11406 * 001000 00010001101
11407 * rt -----
11408 * rs -----
11409 * rd -----
11410 */
11411 std::string NMD::MULSA_W_PH(uint64 instruction)
11412 {
11413 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11414 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11415 uint64 ac_value = extract_ac_13_12(instruction);
11416
11417 std::string ac = AC(copy(ac_value));
11418 std::string rs = GPR(copy(rs_value));
11419 std::string rt = GPR(copy(rt_value));
11420
11421 return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11422 }
11423
11424
11425 /*
11426 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11427 *
11428 * 3 2 1
11429 * 10987654321098765432109876543210
11430 * 001000 00010001101
11431 * rt -----
11432 * rs -----
11433 * rd -----
11434 */
11435 std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
11436 {
11437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11438 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11439 uint64 ac_value = extract_ac_13_12(instruction);
11440
11441 std::string ac = AC(copy(ac_value));
11442 std::string rs = GPR(copy(rs_value));
11443 std::string rt = GPR(copy(rt_value));
11444
11445 return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11446 }
11447
11448
11449 /*
11450 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11451 *
11452 * 3 2 1
11453 * 10987654321098765432109876543210
11454 * 001000 00010001101
11455 * rt -----
11456 * rs -----
11457 * rd -----
11458 */
11459 std::string NMD::MULT_DSP_(uint64 instruction)
11460 {
11461 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11462 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11463 uint64 ac_value = extract_ac_13_12(instruction);
11464
11465 std::string ac = AC(copy(ac_value));
11466 std::string rs = GPR(copy(rs_value));
11467 std::string rt = GPR(copy(rt_value));
11468
11469 return img::format("MULT %s, %s, %s", ac, rs, rt);
11470 }
11471
11472
11473 /*
11474 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11475 *
11476 * 3 2 1
11477 * 10987654321098765432109876543210
11478 * 001000 00010001101
11479 * rt -----
11480 * rs -----
11481 * rd -----
11482 */
11483 std::string NMD::MULTU_DSP_(uint64 instruction)
11484 {
11485 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11486 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11487 uint64 ac_value = extract_ac_13_12(instruction);
11488
11489 std::string ac = AC(copy(ac_value));
11490 std::string rs = GPR(copy(rs_value));
11491 std::string rt = GPR(copy(rt_value));
11492
11493 return img::format("MULTU %s, %s, %s", ac, rs, rt);
11494 }
11495
11496
11497 /*
11498 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11499 *
11500 * 3 2 1
11501 * 10987654321098765432109876543210
11502 * 001000 00010001101
11503 * rt -----
11504 * rs -----
11505 * rd -----
11506 */
11507 std::string NMD::MULU(uint64 instruction)
11508 {
11509 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11510 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11511 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11512
11513 std::string rd = GPR(copy(rd_value));
11514 std::string rs = GPR(copy(rs_value));
11515 std::string rt = GPR(copy(rt_value));
11516
11517 return img::format("MULU %s, %s, %s", rd, rs, rt);
11518 }
11519
11520
11521 /*
11522 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11523 *
11524 * 3 2 1
11525 * 10987654321098765432109876543210
11526 * 001000 00010001101
11527 * rt -----
11528 * rs -----
11529 * rd -----
11530 */
11531 std::string NMD::NEG_D(uint64 instruction)
11532 {
11533 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11534 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11535
11536 std::string ft = FPR(copy(ft_value));
11537 std::string fs = FPR(copy(fs_value));
11538
11539 return img::format("NEG.D %s, %s", ft, fs);
11540 }
11541
11542
11543 /*
11544 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11545 *
11546 * 3 2 1
11547 * 10987654321098765432109876543210
11548 * 001000 00010001101
11549 * rt -----
11550 * rs -----
11551 * rd -----
11552 */
11553 std::string NMD::NEG_S(uint64 instruction)
11554 {
11555 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11556 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11557
11558 std::string ft = FPR(copy(ft_value));
11559 std::string fs = FPR(copy(fs_value));
11560
11561 return img::format("NEG.S %s, %s", ft, fs);
11562 }
11563
11564
11565 /*
11566 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11567 *
11568 * 3 2 1
11569 * 10987654321098765432109876543210
11570 * 001000 00010001101
11571 * rt -----
11572 * rs -----
11573 * rd -----
11574 */
11575 std::string NMD::NOP_16_(uint64 instruction)
11576 {
11577 (void)instruction;
11578
11579 return "NOP ";
11580 }
11581
11582
11583 /*
11584 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11585 *
11586 * 3 2 1
11587 * 10987654321098765432109876543210
11588 * 001000 00010001101
11589 * rt -----
11590 * rs -----
11591 * rd -----
11592 */
11593 std::string NMD::NOP_32_(uint64 instruction)
11594 {
11595 (void)instruction;
11596
11597 return "NOP ";
11598 }
11599
11600
11601 /*
11602 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11603 *
11604 * 3 2 1
11605 * 10987654321098765432109876543210
11606 * 001000 00010001101
11607 * rt -----
11608 * rs -----
11609 * rd -----
11610 */
11611 std::string NMD::NOR(uint64 instruction)
11612 {
11613 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11614 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11615 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11616
11617 std::string rd = GPR(copy(rd_value));
11618 std::string rs = GPR(copy(rs_value));
11619 std::string rt = GPR(copy(rt_value));
11620
11621 return img::format("NOR %s, %s, %s", rd, rs, rt);
11622 }
11623
11624
11625 /*
11626 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11627 *
11628 * 3 2 1
11629 * 10987654321098765432109876543210
11630 * 001000 00010001101
11631 * rt -----
11632 * rs -----
11633 * rd -----
11634 */
11635 std::string NMD::NOT_16_(uint64 instruction)
11636 {
11637 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11638 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11639
11640 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
11641 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
11642
11643 return img::format("NOT %s, %s", rt3, rs3);
11644 }
11645
11646
11647 /*
11648 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11649 *
11650 * 3 2 1
11651 * 10987654321098765432109876543210
11652 * 001000 00010001101
11653 * rt -----
11654 * rs -----
11655 * rd -----
11656 */
11657 std::string NMD::OR_16_(uint64 instruction)
11658 {
11659 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11660 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11661
11662 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
11663 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
11664
11665 return img::format("OR %s, %s", rs3, rt3);
11666 }
11667
11668
11669 /*
11670 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11671 *
11672 * 3 2 1
11673 * 10987654321098765432109876543210
11674 * 001000 00010001101
11675 * rt -----
11676 * rs -----
11677 * rd -----
11678 */
11679 std::string NMD::OR_32_(uint64 instruction)
11680 {
11681 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11682 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11683 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11684
11685 std::string rd = GPR(copy(rd_value));
11686 std::string rs = GPR(copy(rs_value));
11687 std::string rt = GPR(copy(rt_value));
11688
11689 return img::format("OR %s, %s, %s", rd, rs, rt);
11690 }
11691
11692
11693 /*
11694 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11695 *
11696 * 3 2 1
11697 * 10987654321098765432109876543210
11698 * 001000 00010001101
11699 * rt -----
11700 * rs -----
11701 * rd -----
11702 */
11703 std::string NMD::ORI(uint64 instruction)
11704 {
11705 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11706 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11707 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11708
11709 std::string rt = GPR(copy(rt_value));
11710 std::string rs = GPR(copy(rs_value));
11711 std::string u = IMMEDIATE(copy(u_value));
11712
11713 return img::format("ORI %s, %s, %s", rt, rs, u);
11714 }
11715
11716
11717 /*
11718 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11719 *
11720 * 3 2 1
11721 * 10987654321098765432109876543210
11722 * 001000 00010001101
11723 * rt -----
11724 * rs -----
11725 * rd -----
11726 */
11727 std::string NMD::PACKRL_PH(uint64 instruction)
11728 {
11729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11730 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11731 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11732
11733 std::string rd = GPR(copy(rd_value));
11734 std::string rs = GPR(copy(rs_value));
11735 std::string rt = GPR(copy(rt_value));
11736
11737 return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11738 }
11739
11740
11741 /*
11742 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11743 *
11744 * 3 2 1
11745 * 10987654321098765432109876543210
11746 * 001000 00010001101
11747 * rt -----
11748 * rs -----
11749 * rd -----
11750 */
11751 std::string NMD::PAUSE(uint64 instruction)
11752 {
11753 (void)instruction;
11754
11755 return "PAUSE ";
11756 }
11757
11758
11759 /*
11760 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11761 *
11762 * 3 2 1
11763 * 10987654321098765432109876543210
11764 * 001000 00010001101
11765 * rt -----
11766 * rs -----
11767 * rd -----
11768 */
11769 std::string NMD::PICK_PH(uint64 instruction)
11770 {
11771 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11772 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11773 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11774
11775 std::string rd = GPR(copy(rd_value));
11776 std::string rs = GPR(copy(rs_value));
11777 std::string rt = GPR(copy(rt_value));
11778
11779 return img::format("PICK.PH %s, %s, %s", rd, rs, rt);
11780 }
11781
11782
11783 /*
11784 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11785 *
11786 * 3 2 1
11787 * 10987654321098765432109876543210
11788 * 001000 00010001101
11789 * rt -----
11790 * rs -----
11791 * rd -----
11792 */
11793 std::string NMD::PICK_QB(uint64 instruction)
11794 {
11795 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11796 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11797 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11798
11799 std::string rd = GPR(copy(rd_value));
11800 std::string rs = GPR(copy(rs_value));
11801 std::string rt = GPR(copy(rt_value));
11802
11803 return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
11804 }
11805
11806
11807 /*
11808 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11809 *
11810 * 3 2 1
11811 * 10987654321098765432109876543210
11812 * 001000 00010001101
11813 * rt -----
11814 * rs -----
11815 * rd -----
11816 */
11817 std::string NMD::PRECEQ_W_PHL(uint64 instruction)
11818 {
11819 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11820 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11821
11822 std::string rt = GPR(copy(rt_value));
11823 std::string rs = GPR(copy(rs_value));
11824
11825 return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
11826 }
11827
11828
11829 /*
11830 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11831 *
11832 * 3 2 1
11833 * 10987654321098765432109876543210
11834 * 001000 00010001101
11835 * rt -----
11836 * rs -----
11837 * rd -----
11838 */
11839 std::string NMD::PRECEQ_W_PHR(uint64 instruction)
11840 {
11841 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11842 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11843
11844 std::string rt = GPR(copy(rt_value));
11845 std::string rs = GPR(copy(rs_value));
11846
11847 return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
11848 }
11849
11850
11851 /*
11852 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11853 *
11854 * 3 2 1
11855 * 10987654321098765432109876543210
11856 * 001000 00010001101
11857 * rt -----
11858 * rs -----
11859 * rd -----
11860 */
11861 std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
11862 {
11863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11864 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11865
11866 std::string rt = GPR(copy(rt_value));
11867 std::string rs = GPR(copy(rs_value));
11868
11869 return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11870 }
11871
11872
11873 /*
11874 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11875 *
11876 * 3 2 1
11877 * 10987654321098765432109876543210
11878 * 001000 00010001101
11879 * rt -----
11880 * rs -----
11881 * rd -----
11882 */
11883 std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
11884 {
11885 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11886 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11887
11888 std::string rt = GPR(copy(rt_value));
11889 std::string rs = GPR(copy(rs_value));
11890
11891 return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
11892 }
11893
11894
11895 /*
11896 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11897 *
11898 * 3 2 1
11899 * 10987654321098765432109876543210
11900 * 001000 00010001101
11901 * rt -----
11902 * rs -----
11903 * rd -----
11904 */
11905 std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
11906 {
11907 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11908 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11909
11910 std::string rt = GPR(copy(rt_value));
11911 std::string rs = GPR(copy(rs_value));
11912
11913 return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11914 }
11915
11916
11917 /*
11918 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11919 *
11920 * 3 2 1
11921 * 10987654321098765432109876543210
11922 * 001000 00010001101
11923 * rt -----
11924 * rs -----
11925 * rd -----
11926 */
11927 std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
11928 {
11929 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11930 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11931
11932 std::string rt = GPR(copy(rt_value));
11933 std::string rs = GPR(copy(rs_value));
11934
11935 return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
11936 }
11937
11938
11939 /*
11940 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11941 *
11942 * 3 2 1
11943 * 10987654321098765432109876543210
11944 * 001000 00010001101
11945 * rt -----
11946 * rs -----
11947 * rd -----
11948 */
11949 std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
11950 {
11951 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11953
11954 std::string rt = GPR(copy(rt_value));
11955 std::string rs = GPR(copy(rs_value));
11956
11957 return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
11958 }
11959
11960
11961 /*
11962 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11963 *
11964 * 3 2 1
11965 * 10987654321098765432109876543210
11966 * 001000 00010001101
11967 * rt -----
11968 * rs -----
11969 * rd -----
11970 */
11971 std::string NMD::PRECEU_PH_QBL(uint64 instruction)
11972 {
11973 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11974 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11975
11976 std::string rt = GPR(copy(rt_value));
11977 std::string rs = GPR(copy(rs_value));
11978
11979 return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
11980 }
11981
11982
11983 /*
11984 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11985 *
11986 * 3 2 1
11987 * 10987654321098765432109876543210
11988 * 001000 00010001101
11989 * rt -----
11990 * rs -----
11991 * rd -----
11992 */
11993 std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
11994 {
11995 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11996 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11997
11998 std::string rt = GPR(copy(rt_value));
11999 std::string rs = GPR(copy(rs_value));
12000
12001 return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
12002 }
12003
12004
12005 /*
12006 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12007 *
12008 * 3 2 1
12009 * 10987654321098765432109876543210
12010 * 001000 00010001101
12011 * rt -----
12012 * rs -----
12013 * rd -----
12014 */
12015 std::string NMD::PRECEU_PH_QBR(uint64 instruction)
12016 {
12017 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12018 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12019
12020 std::string rt = GPR(copy(rt_value));
12021 std::string rs = GPR(copy(rs_value));
12022
12023 return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
12024 }
12025
12026
12027 /*
12028 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
12029 *
12030 * 3 2 1
12031 * 10987654321098765432109876543210
12032 * 001000 00010001101
12033 * rt -----
12034 * rs -----
12035 * rd -----
12036 */
12037 std::string NMD::PRECR_QB_PH(uint64 instruction)
12038 {
12039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12040 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12041 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12042
12043 std::string rd = GPR(copy(rd_value));
12044 std::string rs = GPR(copy(rs_value));
12045 std::string rt = GPR(copy(rt_value));
12046
12047 return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
12048 }
12049
12050
12051 /*
12052 *
12053 *
12054 * 3 2 1
12055 * 10987654321098765432109876543210
12056 * 001000 x1110000101
12057 * rt -----
12058 * rs -----
12059 * rd -----
12060 */
12061 std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
12062 {
12063 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12064 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12065 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12066
12067 std::string rt = GPR(copy(rt_value));
12068 std::string rs = GPR(copy(rs_value));
12069 std::string sa = IMMEDIATE(copy(sa_value));
12070
12071 return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
12072 }
12073
12074
12075 /*
12076 *
12077 *
12078 * 3 2 1
12079 * 10987654321098765432109876543210
12080 * 001000 x1110000101
12081 * rt -----
12082 * rs -----
12083 * rd -----
12084 */
12085 std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
12086 {
12087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12089 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12090
12091 std::string rt = GPR(copy(rt_value));
12092 std::string rs = GPR(copy(rs_value));
12093 std::string sa = IMMEDIATE(copy(sa_value));
12094
12095 return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
12096 }
12097
12098
12099 /*
12100 *
12101 *
12102 * 3 2 1
12103 * 10987654321098765432109876543210
12104 * 001000 x1110000101
12105 * rt -----
12106 * rs -----
12107 * rd -----
12108 */
12109 std::string NMD::PRECRQ_PH_W(uint64 instruction)
12110 {
12111 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12112 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12113 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12114
12115 std::string rd = GPR(copy(rd_value));
12116 std::string rs = GPR(copy(rs_value));
12117 std::string rt = GPR(copy(rt_value));
12118
12119 return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
12120 }
12121
12122
12123 /*
12124 *
12125 *
12126 * 3 2 1
12127 * 10987654321098765432109876543210
12128 * 001000 x1110000101
12129 * rt -----
12130 * rs -----
12131 * rd -----
12132 */
12133 std::string NMD::PRECRQ_QB_PH(uint64 instruction)
12134 {
12135 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12136 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12137 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12138
12139 std::string rd = GPR(copy(rd_value));
12140 std::string rs = GPR(copy(rs_value));
12141 std::string rt = GPR(copy(rt_value));
12142
12143 return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
12144 }
12145
12146
12147 /*
12148 *
12149 *
12150 * 3 2 1
12151 * 10987654321098765432109876543210
12152 * 001000 x1110000101
12153 * rt -----
12154 * rs -----
12155 * rd -----
12156 */
12157 std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
12158 {
12159 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12160 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12161 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12162
12163 std::string rd = GPR(copy(rd_value));
12164 std::string rs = GPR(copy(rs_value));
12165 std::string rt = GPR(copy(rt_value));
12166
12167 return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
12168 }
12169
12170
12171 /*
12172 *
12173 *
12174 * 3 2 1
12175 * 10987654321098765432109876543210
12176 * 001000 x1110000101
12177 * rt -----
12178 * rs -----
12179 * rd -----
12180 */
12181 std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
12182 {
12183 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12184 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12185 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12186
12187 std::string rd = GPR(copy(rd_value));
12188 std::string rs = GPR(copy(rs_value));
12189 std::string rt = GPR(copy(rt_value));
12190
12191 return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
12192 }
12193
12194
12195 /*
12196 *
12197 *
12198 * 3 2 1
12199 * 10987654321098765432109876543210
12200 * 001000 x1110000101
12201 * rt -----
12202 * rs -----
12203 * rd -----
12204 */
12205 std::string NMD::PREF_S9_(uint64 instruction)
12206 {
12207 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12208 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12209 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12210
12211 std::string hint = IMMEDIATE(copy(hint_value));
12212 std::string s = IMMEDIATE(copy(s_value));
12213 std::string rs = GPR(copy(rs_value));
12214
12215 return img::format("PREF %s, %s(%s)", hint, s, rs);
12216 }
12217
12218
12219 /*
12220 *
12221 *
12222 * 3 2 1
12223 * 10987654321098765432109876543210
12224 * 001000 x1110000101
12225 * rt -----
12226 * rs -----
12227 * rd -----
12228 */
12229 std::string NMD::PREF_U12_(uint64 instruction)
12230 {
12231 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12232 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12233 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12234
12235 std::string hint = IMMEDIATE(copy(hint_value));
12236 std::string u = IMMEDIATE(copy(u_value));
12237 std::string rs = GPR(copy(rs_value));
12238
12239 return img::format("PREF %s, %s(%s)", hint, u, rs);
12240 }
12241
12242
12243 /*
12244 *
12245 *
12246 * 3 2 1
12247 * 10987654321098765432109876543210
12248 * 001000 x1110000101
12249 * rt -----
12250 * rs -----
12251 * rd -----
12252 */
12253 std::string NMD::PREFE(uint64 instruction)
12254 {
12255 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
12256 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12257 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12258
12259 std::string hint = IMMEDIATE(copy(hint_value));
12260 std::string s = IMMEDIATE(copy(s_value));
12261 std::string rs = GPR(copy(rs_value));
12262
12263 return img::format("PREFE %s, %s(%s)", hint, s, rs);
12264 }
12265
12266
12267 /*
12268 *
12269 *
12270 * 3 2 1
12271 * 10987654321098765432109876543210
12272 * 001000 x1110000101
12273 * rt -----
12274 * rs -----
12275 * rd -----
12276 */
12277 std::string NMD::PREPEND(uint64 instruction)
12278 {
12279 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12280 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12281 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
12282
12283 std::string rt = GPR(copy(rt_value));
12284 std::string rs = GPR(copy(rs_value));
12285 std::string sa = IMMEDIATE(copy(sa_value));
12286
12287 return img::format("PREPEND %s, %s, %s", rt, rs, sa);
12288 }
12289
12290
12291 /*
12292 *
12293 *
12294 * 3 2 1
12295 * 10987654321098765432109876543210
12296 * 001000 x1110000101
12297 * rt -----
12298 * rs -----
12299 * rd -----
12300 */
12301 std::string NMD::RADDU_W_QB(uint64 instruction)
12302 {
12303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12305
12306 std::string rt = GPR(copy(rt_value));
12307 std::string rs = GPR(copy(rs_value));
12308
12309 return img::format("RADDU.W.QB %s, %s", rt, rs);
12310 }
12311
12312
12313 /*
12314 *
12315 *
12316 * 3 2 1
12317 * 10987654321098765432109876543210
12318 * 001000 x1110000101
12319 * rt -----
12320 * rs -----
12321 * rd -----
12322 */
12323 std::string NMD::RDDSP(uint64 instruction)
12324 {
12325 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12326 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
12327
12328 std::string rt = GPR(copy(rt_value));
12329 std::string mask = IMMEDIATE(copy(mask_value));
12330
12331 return img::format("RDDSP %s, %s", rt, mask);
12332 }
12333
12334
12335 /*
12336 *
12337 *
12338 * 3 2 1
12339 * 10987654321098765432109876543210
12340 * 001000 x1110000101
12341 * rt -----
12342 * rs -----
12343 * rd -----
12344 */
12345 std::string NMD::RDHWR(uint64 instruction)
12346 {
12347 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12348 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
12349 uint64 sel_value = extract_sel_13_12_11(instruction);
12350
12351 std::string rt = GPR(copy(rt_value));
12352 std::string hs = CPR(copy(hs_value));
12353 std::string sel = IMMEDIATE(copy(sel_value));
12354
12355 return img::format("RDHWR %s, %s, %s", rt, hs, sel);
12356 }
12357
12358
12359 /*
12360 *
12361 *
12362 * 3 2 1
12363 * 10987654321098765432109876543210
12364 * 001000 x1110000101
12365 * rt -----
12366 * rs -----
12367 * rd -----
12368 */
12369 std::string NMD::RDPGPR(uint64 instruction)
12370 {
12371 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12373
12374 std::string rt = GPR(copy(rt_value));
12375 std::string rs = GPR(copy(rs_value));
12376
12377 return img::format("RDPGPR %s, %s", rt, rs);
12378 }
12379
12380
12381 /*
12382 *
12383 *
12384 * 3 2 1
12385 * 10987654321098765432109876543210
12386 * 001000 x1110000101
12387 * rt -----
12388 * rs -----
12389 * rd -----
12390 */
12391 std::string NMD::RECIP_D(uint64 instruction)
12392 {
12393 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12394 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12395
12396 std::string ft = FPR(copy(ft_value));
12397 std::string fs = FPR(copy(fs_value));
12398
12399 return img::format("RECIP.D %s, %s", ft, fs);
12400 }
12401
12402
12403 /*
12404 *
12405 *
12406 * 3 2 1
12407 * 10987654321098765432109876543210
12408 * 001000 x1110000101
12409 * rt -----
12410 * rs -----
12411 * rd -----
12412 */
12413 std::string NMD::RECIP_S(uint64 instruction)
12414 {
12415 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12416 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12417
12418 std::string ft = FPR(copy(ft_value));
12419 std::string fs = FPR(copy(fs_value));
12420
12421 return img::format("RECIP.S %s, %s", ft, fs);
12422 }
12423
12424
12425 /*
12426 *
12427 *
12428 * 3 2 1
12429 * 10987654321098765432109876543210
12430 * 001000 x1110000101
12431 * rt -----
12432 * rs -----
12433 * rd -----
12434 */
12435 std::string NMD::REPL_PH(uint64 instruction)
12436 {
12437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12438 int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
12439
12440 std::string rt = GPR(copy(rt_value));
12441 std::string s = IMMEDIATE(copy(s_value));
12442
12443 return img::format("REPL.PH %s, %s", rt, s);
12444 }
12445
12446
12447 /*
12448 *
12449 *
12450 * 3 2 1
12451 * 10987654321098765432109876543210
12452 * 001000 x1110000101
12453 * rt -----
12454 * rs -----
12455 * rd -----
12456 */
12457 std::string NMD::REPL_QB(uint64 instruction)
12458 {
12459 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12460 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12461
12462 std::string rt = GPR(copy(rt_value));
12463 std::string u = IMMEDIATE(copy(u_value));
12464
12465 return img::format("REPL.QB %s, %s", rt, u);
12466 }
12467
12468
12469 /*
12470 *
12471 *
12472 * 3 2 1
12473 * 10987654321098765432109876543210
12474 * 001000 x1110000101
12475 * rt -----
12476 * rs -----
12477 * rd -----
12478 */
12479 std::string NMD::REPLV_PH(uint64 instruction)
12480 {
12481 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12482 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12483
12484 std::string rt = GPR(copy(rt_value));
12485 std::string rs = GPR(copy(rs_value));
12486
12487 return img::format("REPLV.PH %s, %s", rt, rs);
12488 }
12489
12490
12491 /*
12492 *
12493 *
12494 * 3 2 1
12495 * 10987654321098765432109876543210
12496 * 001000 x1110000101
12497 * rt -----
12498 * rs -----
12499 * rd -----
12500 */
12501 std::string NMD::REPLV_QB(uint64 instruction)
12502 {
12503 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12504 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12505
12506 std::string rt = GPR(copy(rt_value));
12507 std::string rs = GPR(copy(rs_value));
12508
12509 return img::format("REPLV.QB %s, %s", rt, rs);
12510 }
12511
12512
12513 /*
12514 *
12515 *
12516 * 3 2 1
12517 * 10987654321098765432109876543210
12518 * 001000 x1110000101
12519 * rt -----
12520 * rs -----
12521 * rd -----
12522 */
12523 std::string NMD::RESTORE_32_(uint64 instruction)
12524 {
12525 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12526 uint64 count_value = extract_count_19_18_17_16(instruction);
12527 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12528 uint64 gp_value = extract_gp_2(instruction);
12529
12530 std::string u = IMMEDIATE(copy(u_value));
12531 return img::format("RESTORE %s%s", u,
12532 save_restore_list(rt_value, count_value, gp_value));
12533 }
12534
12535
12536 /*
12537 *
12538 *
12539 * 3 2 1
12540 * 10987654321098765432109876543210
12541 * 001000 x1110000101
12542 * rt -----
12543 * rs -----
12544 * rd -----
12545 */
12546 std::string NMD::RESTORE_JRC_16_(uint64 instruction)
12547 {
12548 uint64 rt1_value = extract_rtl_11(instruction);
12549 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12550 uint64 count_value = extract_count_3_2_1_0(instruction);
12551
12552 std::string u = IMMEDIATE(copy(u_value));
12553 return img::format("RESTORE.JRC %s%s", u,
12554 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12555 }
12556
12557
12558 /*
12559 *
12560 *
12561 * 3 2 1
12562 * 10987654321098765432109876543210
12563 * 001000 x1110000101
12564 * rt -----
12565 * rs -----
12566 * rd -----
12567 */
12568 std::string NMD::RESTORE_JRC_32_(uint64 instruction)
12569 {
12570 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12571 uint64 count_value = extract_count_19_18_17_16(instruction);
12572 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12573 uint64 gp_value = extract_gp_2(instruction);
12574
12575 std::string u = IMMEDIATE(copy(u_value));
12576 return img::format("RESTORE.JRC %s%s", u,
12577 save_restore_list(rt_value, count_value, gp_value));
12578 }
12579
12580
12581 /*
12582 *
12583 *
12584 * 3 2 1
12585 * 10987654321098765432109876543210
12586 * 001000 x1110000101
12587 * rt -----
12588 * rs -----
12589 * rd -----
12590 */
12591 std::string NMD::RESTOREF(uint64 instruction)
12592 {
12593 uint64 count_value = extract_count_19_18_17_16(instruction);
12594 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12595
12596 std::string u = IMMEDIATE(copy(u_value));
12597 std::string count = IMMEDIATE(copy(count_value));
12598
12599 return img::format("RESTOREF %s, %s", u, count);
12600 }
12601
12602
12603 /*
12604 *
12605 *
12606 * 3 2 1
12607 * 10987654321098765432109876543210
12608 * 001000 x1110000101
12609 * rt -----
12610 * rs -----
12611 * rd -----
12612 */
12613 std::string NMD::RINT_D(uint64 instruction)
12614 {
12615 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12616 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12617
12618 std::string ft = FPR(copy(ft_value));
12619 std::string fs = FPR(copy(fs_value));
12620
12621 return img::format("RINT.D %s, %s", ft, fs);
12622 }
12623
12624
12625 /*
12626 *
12627 *
12628 * 3 2 1
12629 * 10987654321098765432109876543210
12630 * 001000 x1110000101
12631 * rt -----
12632 * rs -----
12633 * rd -----
12634 */
12635 std::string NMD::RINT_S(uint64 instruction)
12636 {
12637 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12638 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12639
12640 std::string ft = FPR(copy(ft_value));
12641 std::string fs = FPR(copy(fs_value));
12642
12643 return img::format("RINT.S %s, %s", ft, fs);
12644 }
12645
12646
12647 /*
12648 *
12649 *
12650 * 3 2 1
12651 * 10987654321098765432109876543210
12652 * 001000 x1110000101
12653 * rt -----
12654 * rs -----
12655 * rd -----
12656 */
12657 std::string NMD::ROTR(uint64 instruction)
12658 {
12659 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12661 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12662
12663 std::string rt = GPR(copy(rt_value));
12664 std::string rs = GPR(copy(rs_value));
12665 std::string shift = IMMEDIATE(copy(shift_value));
12666
12667 return img::format("ROTR %s, %s, %s", rt, rs, shift);
12668 }
12669
12670
12671 /*
12672 *
12673 *
12674 * 3 2 1
12675 * 10987654321098765432109876543210
12676 * 001000 x1110000101
12677 * rt -----
12678 * rs -----
12679 * rd -----
12680 */
12681 std::string NMD::ROTRV(uint64 instruction)
12682 {
12683 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12684 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12685 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12686
12687 std::string rd = GPR(copy(rd_value));
12688 std::string rs = GPR(copy(rs_value));
12689 std::string rt = GPR(copy(rt_value));
12690
12691 return img::format("ROTRV %s, %s, %s", rd, rs, rt);
12692 }
12693
12694
12695 /*
12696 *
12697 *
12698 * 3 2 1
12699 * 10987654321098765432109876543210
12700 * 001000 x1110000101
12701 * rt -----
12702 * rs -----
12703 * rd -----
12704 */
12705 std::string NMD::ROTX(uint64 instruction)
12706 {
12707 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12708 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12709 uint64 shiftx_value = extract_shiftx_10_9_8_7__s1(instruction);
12710 uint64 stripe_value = extract_stripe_6(instruction);
12711 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12712
12713 std::string rt = GPR(copy(rt_value));
12714 std::string rs = GPR(copy(rs_value));
12715 std::string shift = IMMEDIATE(copy(shift_value));
12716 std::string shiftx = IMMEDIATE(copy(shiftx_value));
12717 std::string stripe = IMMEDIATE(copy(stripe_value));
12718
12719 return img::format("ROTX %s, %s, %s, %s, %s",
12720 rt, rs, shift, shiftx, stripe);
12721 }
12722
12723
12724 /*
12725 *
12726 *
12727 * 3 2 1
12728 * 10987654321098765432109876543210
12729 * 001000 x1110000101
12730 * rt -----
12731 * rs -----
12732 * rd -----
12733 */
12734 std::string NMD::ROUND_L_D(uint64 instruction)
12735 {
12736 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12737 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12738
12739 std::string ft = FPR(copy(ft_value));
12740 std::string fs = FPR(copy(fs_value));
12741
12742 return img::format("ROUND.L.D %s, %s", ft, fs);
12743 }
12744
12745
12746 /*
12747 *
12748 *
12749 * 3 2 1
12750 * 10987654321098765432109876543210
12751 * 001000 x1110000101
12752 * rt -----
12753 * rs -----
12754 * rd -----
12755 */
12756 std::string NMD::ROUND_L_S(uint64 instruction)
12757 {
12758 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12759 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12760
12761 std::string ft = FPR(copy(ft_value));
12762 std::string fs = FPR(copy(fs_value));
12763
12764 return img::format("ROUND.L.S %s, %s", ft, fs);
12765 }
12766
12767
12768 /*
12769 *
12770 *
12771 * 3 2 1
12772 * 10987654321098765432109876543210
12773 * 001000 x1110000101
12774 * rt -----
12775 * rs -----
12776 * rd -----
12777 */
12778 std::string NMD::ROUND_W_D(uint64 instruction)
12779 {
12780 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12781 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12782
12783 std::string ft = FPR(copy(ft_value));
12784 std::string fs = FPR(copy(fs_value));
12785
12786 return img::format("ROUND.W.D %s, %s", ft, fs);
12787 }
12788
12789
12790 /*
12791 *
12792 *
12793 * 3 2 1
12794 * 10987654321098765432109876543210
12795 * 001000 x1110000101
12796 * rt -----
12797 * rs -----
12798 * rd -----
12799 */
12800 std::string NMD::ROUND_W_S(uint64 instruction)
12801 {
12802 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12803 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12804
12805 std::string ft = FPR(copy(ft_value));
12806 std::string fs = FPR(copy(fs_value));
12807
12808 return img::format("ROUND.W.S %s, %s", ft, fs);
12809 }
12810
12811
12812 /*
12813 *
12814 *
12815 * 3 2 1
12816 * 10987654321098765432109876543210
12817 * 001000 x1110000101
12818 * rt -----
12819 * rs -----
12820 * rd -----
12821 */
12822 std::string NMD::RSQRT_D(uint64 instruction)
12823 {
12824 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12825 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12826
12827 std::string ft = FPR(copy(ft_value));
12828 std::string fs = FPR(copy(fs_value));
12829
12830 return img::format("RSQRT.D %s, %s", ft, fs);
12831 }
12832
12833
12834 /*
12835 *
12836 *
12837 * 3 2 1
12838 * 10987654321098765432109876543210
12839 * 001000 x1110000101
12840 * rt -----
12841 * rs -----
12842 * rd -----
12843 */
12844 std::string NMD::RSQRT_S(uint64 instruction)
12845 {
12846 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12847 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12848
12849 std::string ft = FPR(copy(ft_value));
12850 std::string fs = FPR(copy(fs_value));
12851
12852 return img::format("RSQRT.S %s, %s", ft, fs);
12853 }
12854
12855
12856 /*
12857 *
12858 *
12859 * 3 2 1
12860 * 10987654321098765432109876543210
12861 * 001000 01001001101
12862 * rt -----
12863 * rs -----
12864 * rd -----
12865 */
12866 std::string NMD::SAVE_16_(uint64 instruction)
12867 {
12868 uint64 rt1_value = extract_rtl_11(instruction);
12869 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12870 uint64 count_value = extract_count_3_2_1_0(instruction);
12871
12872 std::string u = IMMEDIATE(copy(u_value));
12873 return img::format("SAVE %s%s", u,
12874 save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
12875 }
12876
12877
12878 /*
12879 *
12880 *
12881 * 3 2 1
12882 * 10987654321098765432109876543210
12883 * 001000 01001001101
12884 * rt -----
12885 * rs -----
12886 * rd -----
12887 */
12888 std::string NMD::SAVE_32_(uint64 instruction)
12889 {
12890 uint64 count_value = extract_count_19_18_17_16(instruction);
12891 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12892 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12893 uint64 gp_value = extract_gp_2(instruction);
12894
12895 std::string u = IMMEDIATE(copy(u_value));
12896 return img::format("SAVE %s%s", u,
12897 save_restore_list(rt_value, count_value, gp_value));
12898 }
12899
12900
12901 /*
12902 *
12903 *
12904 * 3 2 1
12905 * 10987654321098765432109876543210
12906 * 001000 01001001101
12907 * rt -----
12908 * rs -----
12909 * rd -----
12910 */
12911 std::string NMD::SAVEF(uint64 instruction)
12912 {
12913 uint64 count_value = extract_count_19_18_17_16(instruction);
12914 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12915
12916 std::string u = IMMEDIATE(copy(u_value));
12917 std::string count = IMMEDIATE(copy(count_value));
12918
12919 return img::format("SAVEF %s, %s", u, count);
12920 }
12921
12922
12923 /*
12924 *
12925 *
12926 * 3 2 1
12927 * 10987654321098765432109876543210
12928 * 001000 01001001101
12929 * rt -----
12930 * rs -----
12931 * rd -----
12932 */
12933 std::string NMD::SB_16_(uint64 instruction)
12934 {
12935 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12936 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12937 uint64 u_value = extract_u_1_0(instruction);
12938
12939 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
12940 std::string u = IMMEDIATE(copy(u_value));
12941 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
12942
12943 return img::format("SB %s, %s(%s)", rtz3, u, rs3);
12944 }
12945
12946
12947 /*
12948 *
12949 *
12950 * 3 2 1
12951 * 10987654321098765432109876543210
12952 * 001000 01001001101
12953 * rt -----
12954 * rs -----
12955 * rd -----
12956 */
12957 std::string NMD::SB_GP_(uint64 instruction)
12958 {
12959 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12960 uint64 u_value = extract_u_17_to_0(instruction);
12961
12962 std::string rt = GPR(copy(rt_value));
12963 std::string u = IMMEDIATE(copy(u_value));
12964
12965 return img::format("SB %s, %s($%d)", rt, u, 28);
12966 }
12967
12968
12969 /*
12970 *
12971 *
12972 * 3 2 1
12973 * 10987654321098765432109876543210
12974 * 001000 01001001101
12975 * rt -----
12976 * rs -----
12977 * rd -----
12978 */
12979 std::string NMD::SB_S9_(uint64 instruction)
12980 {
12981 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12982 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12983 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12984
12985 std::string rt = GPR(copy(rt_value));
12986 std::string s = IMMEDIATE(copy(s_value));
12987 std::string rs = GPR(copy(rs_value));
12988
12989 return img::format("SB %s, %s(%s)", rt, s, rs);
12990 }
12991
12992
12993 /*
12994 *
12995 *
12996 * 3 2 1
12997 * 10987654321098765432109876543210
12998 * 001000 01001001101
12999 * rt -----
13000 * rs -----
13001 * rd -----
13002 */
13003 std::string NMD::SB_U12_(uint64 instruction)
13004 {
13005 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13006 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13007 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13008
13009 std::string rt = GPR(copy(rt_value));
13010 std::string u = IMMEDIATE(copy(u_value));
13011 std::string rs = GPR(copy(rs_value));
13012
13013 return img::format("SB %s, %s(%s)", rt, u, rs);
13014 }
13015
13016
13017 /*
13018 *
13019 *
13020 * 3 2 1
13021 * 10987654321098765432109876543210
13022 * 001000 01001001101
13023 * rt -----
13024 * rs -----
13025 * rd -----
13026 */
13027 std::string NMD::SBE(uint64 instruction)
13028 {
13029 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13030 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13031 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13032
13033 std::string rt = GPR(copy(rt_value));
13034 std::string s = IMMEDIATE(copy(s_value));
13035 std::string rs = GPR(copy(rs_value));
13036
13037 return img::format("SBE %s, %s(%s)", rt, s, rs);
13038 }
13039
13040
13041 /*
13042 *
13043 *
13044 * 3 2 1
13045 * 10987654321098765432109876543210
13046 * 001000 01001001101
13047 * rt -----
13048 * rs -----
13049 * rd -----
13050 */
13051 std::string NMD::SBX(uint64 instruction)
13052 {
13053 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13054 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13055 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13056
13057 std::string rd = GPR(copy(rd_value));
13058 std::string rs = GPR(copy(rs_value));
13059 std::string rt = GPR(copy(rt_value));
13060
13061 return img::format("SBX %s, %s(%s)", rd, rs, rt);
13062 }
13063
13064
13065 /*
13066 *
13067 *
13068 * 3 2 1
13069 * 10987654321098765432109876543210
13070 * 001000 01001001101
13071 * rt -----
13072 * rs -----
13073 * rd -----
13074 */
13075 std::string NMD::SC(uint64 instruction)
13076 {
13077 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13078 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13079 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
13080
13081 std::string rt = GPR(copy(rt_value));
13082 std::string s = IMMEDIATE(copy(s_value));
13083 std::string rs = GPR(copy(rs_value));
13084
13085 return img::format("SC %s, %s(%s)", rt, s, rs);
13086 }
13087
13088
13089 /*
13090 *
13091 *
13092 * 3 2 1
13093 * 10987654321098765432109876543210
13094 * 001000 01001001101
13095 * rt -----
13096 * rs -----
13097 * rd -----
13098 */
13099 std::string NMD::SCD(uint64 instruction)
13100 {
13101 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13102 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13103 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
13104
13105 std::string rt = GPR(copy(rt_value));
13106 std::string s = IMMEDIATE(copy(s_value));
13107 std::string rs = GPR(copy(rs_value));
13108
13109 return img::format("SCD %s, %s(%s)", rt, s, rs);
13110 }
13111
13112
13113 /*
13114 *
13115 *
13116 * 3 2 1
13117 * 10987654321098765432109876543210
13118 * 001000 01001001101
13119 * rt -----
13120 * rs -----
13121 * rd -----
13122 */
13123 std::string NMD::SCDP(uint64 instruction)
13124 {
13125 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13126 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13127 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13128
13129 std::string rt = GPR(copy(rt_value));
13130 std::string ru = GPR(copy(ru_value));
13131 std::string rs = GPR(copy(rs_value));
13132
13133 return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
13134 }
13135
13136
13137 /*
13138 *
13139 *
13140 * 3 2 1
13141 * 10987654321098765432109876543210
13142 * 001000 01001001101
13143 * rt -----
13144 * rs -----
13145 * rd -----
13146 */
13147 std::string NMD::SCE(uint64 instruction)
13148 {
13149 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13150 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13151 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
13152
13153 std::string rt = GPR(copy(rt_value));
13154 std::string s = IMMEDIATE(copy(s_value));
13155 std::string rs = GPR(copy(rs_value));
13156
13157 return img::format("SCE %s, %s(%s)", rt, s, rs);
13158 }
13159
13160
13161 /*
13162 *
13163 *
13164 * 3 2 1
13165 * 10987654321098765432109876543210
13166 * 001000 01001001101
13167 * rt -----
13168 * rs -----
13169 * rd -----
13170 */
13171 std::string NMD::SCWP(uint64 instruction)
13172 {
13173 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13174 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13175 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13176
13177 std::string rt = GPR(copy(rt_value));
13178 std::string ru = GPR(copy(ru_value));
13179 std::string rs = GPR(copy(rs_value));
13180
13181 return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
13182 }
13183
13184
13185 /*
13186 *
13187 *
13188 * 3 2 1
13189 * 10987654321098765432109876543210
13190 * 001000 01001001101
13191 * rt -----
13192 * rs -----
13193 * rd -----
13194 */
13195 std::string NMD::SCWPE(uint64 instruction)
13196 {
13197 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13198 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13199 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
13200
13201 std::string rt = GPR(copy(rt_value));
13202 std::string ru = GPR(copy(ru_value));
13203 std::string rs = GPR(copy(rs_value));
13204
13205 return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
13206 }
13207
13208
13209 /*
13210 *
13211 *
13212 * 3 2 1
13213 * 10987654321098765432109876543210
13214 * 001000 01001001101
13215 * rt -----
13216 * rs -----
13217 * rd -----
13218 */
13219 std::string NMD::SD_GP_(uint64 instruction)
13220 {
13221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13222 uint64 u_value = extract_u_20_to_3__s3(instruction);
13223
13224 std::string rt = GPR(copy(rt_value));
13225 std::string u = IMMEDIATE(copy(u_value));
13226
13227 return img::format("SD %s, %s($%d)", rt, u, 28);
13228 }
13229
13230
13231 /*
13232 *
13233 *
13234 * 3 2 1
13235 * 10987654321098765432109876543210
13236 * 001000 01001001101
13237 * rt -----
13238 * rs -----
13239 * rd -----
13240 */
13241 std::string NMD::SD_S9_(uint64 instruction)
13242 {
13243 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13244 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13245 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13246
13247 std::string rt = GPR(copy(rt_value));
13248 std::string s = IMMEDIATE(copy(s_value));
13249 std::string rs = GPR(copy(rs_value));
13250
13251 return img::format("SD %s, %s(%s)", rt, s, rs);
13252 }
13253
13254
13255 /*
13256 *
13257 *
13258 * 3 2 1
13259 * 10987654321098765432109876543210
13260 * 001000 01001001101
13261 * rt -----
13262 * rs -----
13263 * rd -----
13264 */
13265 std::string NMD::SD_U12_(uint64 instruction)
13266 {
13267 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13268 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13269 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13270
13271 std::string rt = GPR(copy(rt_value));
13272 std::string u = IMMEDIATE(copy(u_value));
13273 std::string rs = GPR(copy(rs_value));
13274
13275 return img::format("SD %s, %s(%s)", rt, u, rs);
13276 }
13277
13278
13279 /*
13280 *
13281 *
13282 * 3 2 1
13283 * 10987654321098765432109876543210
13284 * 001000 01001001101
13285 * rt -----
13286 * rs -----
13287 * rd -----
13288 */
13289 std::string NMD::SDBBP_16_(uint64 instruction)
13290 {
13291 uint64 code_value = extract_code_2_1_0(instruction);
13292
13293 std::string code = IMMEDIATE(copy(code_value));
13294
13295 return img::format("SDBBP %s", code);
13296 }
13297
13298
13299 /*
13300 *
13301 *
13302 * 3 2 1
13303 * 10987654321098765432109876543210
13304 * 001000 01001001101
13305 * rt -----
13306 * rs -----
13307 * rd -----
13308 */
13309 std::string NMD::SDBBP_32_(uint64 instruction)
13310 {
13311 uint64 code_value = extract_code_18_to_0(instruction);
13312
13313 std::string code = IMMEDIATE(copy(code_value));
13314
13315 return img::format("SDBBP %s", code);
13316 }
13317
13318
13319 /*
13320 *
13321 *
13322 * 3 2 1
13323 * 10987654321098765432109876543210
13324 * 001000 01001001101
13325 * rt -----
13326 * rs -----
13327 * rd -----
13328 */
13329 std::string NMD::SDC1_GP_(uint64 instruction)
13330 {
13331 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13332 uint64 u_value = extract_u_17_to_2__s2(instruction);
13333
13334 std::string ft = FPR(copy(ft_value));
13335 std::string u = IMMEDIATE(copy(u_value));
13336
13337 return img::format("SDC1 %s, %s($%d)", ft, u, 28);
13338 }
13339
13340
13341 /*
13342 *
13343 *
13344 * 3 2 1
13345 * 10987654321098765432109876543210
13346 * 001000 01001001101
13347 * rt -----
13348 * rs -----
13349 * rd -----
13350 */
13351 std::string NMD::SDC1_S9_(uint64 instruction)
13352 {
13353 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13355 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13356
13357 std::string ft = FPR(copy(ft_value));
13358 std::string s = IMMEDIATE(copy(s_value));
13359 std::string rs = GPR(copy(rs_value));
13360
13361 return img::format("SDC1 %s, %s(%s)", ft, s, rs);
13362 }
13363
13364
13365 /*
13366 *
13367 *
13368 * 3 2 1
13369 * 10987654321098765432109876543210
13370 * 001000 01001001101
13371 * rt -----
13372 * rs -----
13373 * rd -----
13374 */
13375 std::string NMD::SDC1_U12_(uint64 instruction)
13376 {
13377 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13378 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13379 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13380
13381 std::string ft = FPR(copy(ft_value));
13382 std::string u = IMMEDIATE(copy(u_value));
13383 std::string rs = GPR(copy(rs_value));
13384
13385 return img::format("SDC1 %s, %s(%s)", ft, u, rs);
13386 }
13387
13388
13389 /*
13390 *
13391 *
13392 * 3 2 1
13393 * 10987654321098765432109876543210
13394 * 001000 01001001101
13395 * rt -----
13396 * rs -----
13397 * rd -----
13398 */
13399 std::string NMD::SDC1X(uint64 instruction)
13400 {
13401 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13402 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13403 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13404
13405 std::string ft = FPR(copy(ft_value));
13406 std::string rs = GPR(copy(rs_value));
13407 std::string rt = GPR(copy(rt_value));
13408
13409 return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
13410 }
13411
13412
13413 /*
13414 *
13415 *
13416 * 3 2 1
13417 * 10987654321098765432109876543210
13418 * 001000 01001001101
13419 * rt -----
13420 * rs -----
13421 * rd -----
13422 */
13423 std::string NMD::SDC1XS(uint64 instruction)
13424 {
13425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13426 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13427 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13428
13429 std::string ft = FPR(copy(ft_value));
13430 std::string rs = GPR(copy(rs_value));
13431 std::string rt = GPR(copy(rt_value));
13432
13433 return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
13434 }
13435
13436
13437 /*
13438 *
13439 *
13440 * 3 2 1
13441 * 10987654321098765432109876543210
13442 * 001000 01001001101
13443 * rt -----
13444 * rs -----
13445 * rd -----
13446 */
13447 std::string NMD::SDC2(uint64 instruction)
13448 {
13449 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
13450 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13451 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13452
13453 std::string cs = CPR(copy(cs_value));
13454 std::string s = IMMEDIATE(copy(s_value));
13455 std::string rs = GPR(copy(rs_value));
13456
13457 return img::format("SDC2 %s, %s(%s)", cs, s, rs);
13458 }
13459
13460
13461 /*
13462 *
13463 *
13464 * 3 2 1
13465 * 10987654321098765432109876543210
13466 * 001000 01001001101
13467 * rt -----
13468 * rs -----
13469 * rd -----
13470 */
13471 std::string NMD::SDM(uint64 instruction)
13472 {
13473 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13474 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13475 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13476 uint64 count3_value = extract_count3_14_13_12(instruction);
13477
13478 std::string rt = GPR(copy(rt_value));
13479 std::string s = IMMEDIATE(copy(s_value));
13480 std::string rs = GPR(copy(rs_value));
13481 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
13482
13483 return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
13484 }
13485
13486
13487 /*
13488 *
13489 *
13490 * 3 2 1
13491 * 10987654321098765432109876543210
13492 * 001000 01001001101
13493 * rt -----
13494 * rs -----
13495 * rd -----
13496 */
13497 std::string NMD::SDPC_48_(uint64 instruction)
13498 {
13499 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13500 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
13501
13502 std::string rt = GPR(copy(rt_value));
13503 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
13504
13505 return img::format("SDPC %s, %s", rt, s);
13506 }
13507
13508
13509 /*
13510 *
13511 *
13512 * 3 2 1
13513 * 10987654321098765432109876543210
13514 * 001000 01001001101
13515 * rt -----
13516 * rs -----
13517 * rd -----
13518 */
13519 std::string NMD::SDXS(uint64 instruction)
13520 {
13521 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13522 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13523 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13524
13525 std::string rd = GPR(copy(rd_value));
13526 std::string rs = GPR(copy(rs_value));
13527 std::string rt = GPR(copy(rt_value));
13528
13529 return img::format("SDXS %s, %s(%s)", rd, rs, rt);
13530 }
13531
13532
13533 /*
13534 *
13535 *
13536 * 3 2 1
13537 * 10987654321098765432109876543210
13538 * 001000 01001001101
13539 * rt -----
13540 * rs -----
13541 * rd -----
13542 */
13543 std::string NMD::SDX(uint64 instruction)
13544 {
13545 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13546 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13547 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13548
13549 std::string rd = GPR(copy(rd_value));
13550 std::string rs = GPR(copy(rs_value));
13551 std::string rt = GPR(copy(rt_value));
13552
13553 return img::format("SDX %s, %s(%s)", rd, rs, rt);
13554 }
13555
13556
13557 /*
13558 *
13559 *
13560 * 3 2 1
13561 * 10987654321098765432109876543210
13562 * 001000 01001001101
13563 * rt -----
13564 * rs -----
13565 * rd -----
13566 */
13567 std::string NMD::SEB(uint64 instruction)
13568 {
13569 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13570 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13571
13572 std::string rt = GPR(copy(rt_value));
13573 std::string rs = GPR(copy(rs_value));
13574
13575 return img::format("SEB %s, %s", rt, rs);
13576 }
13577
13578
13579 /*
13580 *
13581 *
13582 * 3 2 1
13583 * 10987654321098765432109876543210
13584 * 001000 01001001101
13585 * rt -----
13586 * rs -----
13587 * rd -----
13588 */
13589 std::string NMD::SEH(uint64 instruction)
13590 {
13591 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13592 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13593
13594 std::string rt = GPR(copy(rt_value));
13595 std::string rs = GPR(copy(rs_value));
13596
13597 return img::format("SEH %s, %s", rt, rs);
13598 }
13599
13600
13601 /*
13602 *
13603 *
13604 * 3 2 1
13605 * 10987654321098765432109876543210
13606 * 001000 01001001101
13607 * rt -----
13608 * rs -----
13609 * rd -----
13610 */
13611 std::string NMD::SEL_D(uint64 instruction)
13612 {
13613 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13614 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13615 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13616
13617 std::string fd = FPR(copy(fd_value));
13618 std::string fs = FPR(copy(fs_value));
13619 std::string ft = FPR(copy(ft_value));
13620
13621 return img::format("SEL.D %s, %s, %s", fd, fs, ft);
13622 }
13623
13624
13625 /*
13626 *
13627 *
13628 * 3 2 1
13629 * 10987654321098765432109876543210
13630 * 001000 01001001101
13631 * rt -----
13632 * rs -----
13633 * rd -----
13634 */
13635 std::string NMD::SEL_S(uint64 instruction)
13636 {
13637 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13638 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13639 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13640
13641 std::string fd = FPR(copy(fd_value));
13642 std::string fs = FPR(copy(fs_value));
13643 std::string ft = FPR(copy(ft_value));
13644
13645 return img::format("SEL.S %s, %s, %s", fd, fs, ft);
13646 }
13647
13648
13649 /*
13650 *
13651 *
13652 * 3 2 1
13653 * 10987654321098765432109876543210
13654 * 001000 01001001101
13655 * rt -----
13656 * rs -----
13657 * rd -----
13658 */
13659 std::string NMD::SELEQZ_D(uint64 instruction)
13660 {
13661 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13662 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13663 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13664
13665 std::string fd = FPR(copy(fd_value));
13666 std::string fs = FPR(copy(fs_value));
13667 std::string ft = FPR(copy(ft_value));
13668
13669 return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13670 }
13671
13672
13673 /*
13674 *
13675 *
13676 * 3 2 1
13677 * 10987654321098765432109876543210
13678 * 001000 01001001101
13679 * rt -----
13680 * rs -----
13681 * rd -----
13682 */
13683 std::string NMD::SELEQZ_S(uint64 instruction)
13684 {
13685 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13686 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13687 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13688
13689 std::string fd = FPR(copy(fd_value));
13690 std::string fs = FPR(copy(fs_value));
13691 std::string ft = FPR(copy(ft_value));
13692
13693 return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13694 }
13695
13696
13697 /*
13698 *
13699 *
13700 * 3 2 1
13701 * 10987654321098765432109876543210
13702 * 001000 01001001101
13703 * rt -----
13704 * rs -----
13705 * rd -----
13706 */
13707 std::string NMD::SELNEZ_D(uint64 instruction)
13708 {
13709 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13710 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13711 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13712
13713 std::string fd = FPR(copy(fd_value));
13714 std::string fs = FPR(copy(fs_value));
13715 std::string ft = FPR(copy(ft_value));
13716
13717 return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13718 }
13719
13720
13721 /*
13722 *
13723 *
13724 * 3 2 1
13725 * 10987654321098765432109876543210
13726 * 001000 01001001101
13727 * rt -----
13728 * rs -----
13729 * rd -----
13730 */
13731 std::string NMD::SELNEZ_S(uint64 instruction)
13732 {
13733 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13734 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13735 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13736
13737 std::string fd = FPR(copy(fd_value));
13738 std::string fs = FPR(copy(fs_value));
13739 std::string ft = FPR(copy(ft_value));
13740
13741 return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13742 }
13743
13744
13745 /*
13746 *
13747 *
13748 * 3 2 1
13749 * 10987654321098765432109876543210
13750 * 001000 01001001101
13751 * rt -----
13752 * rs -----
13753 * rd -----
13754 */
13755 std::string NMD::SEQI(uint64 instruction)
13756 {
13757 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13758 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13759 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13760
13761 std::string rt = GPR(copy(rt_value));
13762 std::string rs = GPR(copy(rs_value));
13763 std::string u = IMMEDIATE(copy(u_value));
13764
13765 return img::format("SEQI %s, %s, %s", rt, rs, u);
13766 }
13767
13768
13769 /*
13770 *
13771 *
13772 * 3 2 1
13773 * 10987654321098765432109876543210
13774 * 001000 01001001101
13775 * rt -----
13776 * rs -----
13777 * rd -----
13778 */
13779 std::string NMD::SH_16_(uint64 instruction)
13780 {
13781 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13782 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13783 uint64 u_value = extract_u_2_1__s1(instruction);
13784
13785 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
13786 std::string u = IMMEDIATE(copy(u_value));
13787 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
13788
13789 return img::format("SH %s, %s(%s)", rtz3, u, rs3);
13790 }
13791
13792
13793 /*
13794 *
13795 *
13796 * 3 2 1
13797 * 10987654321098765432109876543210
13798 * 001000 01001001101
13799 * rt -----
13800 * rs -----
13801 * rd -----
13802 */
13803 std::string NMD::SH_GP_(uint64 instruction)
13804 {
13805 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13806 uint64 u_value = extract_u_17_to_1__s1(instruction);
13807
13808 std::string rt = GPR(copy(rt_value));
13809 std::string u = IMMEDIATE(copy(u_value));
13810
13811 return img::format("SH %s, %s($%d)", rt, u, 28);
13812 }
13813
13814
13815 /*
13816 *
13817 *
13818 * 3 2 1
13819 * 10987654321098765432109876543210
13820 * 001000 01001001101
13821 * rt -----
13822 * rs -----
13823 * rd -----
13824 */
13825 std::string NMD::SH_S9_(uint64 instruction)
13826 {
13827 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13828 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13829 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13830
13831 std::string rt = GPR(copy(rt_value));
13832 std::string s = IMMEDIATE(copy(s_value));
13833 std::string rs = GPR(copy(rs_value));
13834
13835 return img::format("SH %s, %s(%s)", rt, s, rs);
13836 }
13837
13838
13839 /*
13840 *
13841 *
13842 * 3 2 1
13843 * 10987654321098765432109876543210
13844 * 001000 01001001101
13845 * rt -----
13846 * rs -----
13847 * rd -----
13848 */
13849 std::string NMD::SH_U12_(uint64 instruction)
13850 {
13851 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13852 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13853 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13854
13855 std::string rt = GPR(copy(rt_value));
13856 std::string u = IMMEDIATE(copy(u_value));
13857 std::string rs = GPR(copy(rs_value));
13858
13859 return img::format("SH %s, %s(%s)", rt, u, rs);
13860 }
13861
13862
13863 /*
13864 *
13865 *
13866 * 3 2 1
13867 * 10987654321098765432109876543210
13868 * 001000 01001001101
13869 * rt -----
13870 * rs -----
13871 * rd -----
13872 */
13873 std::string NMD::SHE(uint64 instruction)
13874 {
13875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13876 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13877 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13878
13879 std::string rt = GPR(copy(rt_value));
13880 std::string s = IMMEDIATE(copy(s_value));
13881 std::string rs = GPR(copy(rs_value));
13882
13883 return img::format("SHE %s, %s(%s)", rt, s, rs);
13884 }
13885
13886
13887 /*
13888 * SHILO ac, shift - Shift an Accumulator Value Leaving the Result in the Same
13889 * Accumulator
13890 *
13891 * 3 2 1
13892 * 10987654321098765432109876543210
13893 * 001000xxxx xxxx0000011101
13894 * shift ------
13895 * ac --
13896 */
13897 std::string NMD::SHILO(uint64 instruction)
13898 {
13899 int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
13900 uint64 ac_value = extract_ac_13_12(instruction);
13901
13902 std::string shift = IMMEDIATE(copy(shift_value));
13903 std::string ac = AC(copy(ac_value));
13904
13905 return img::format("SHILO %s, %s", ac, shift);
13906 }
13907
13908
13909 /*
13910 * SHILOV ac, rs - Variable Shift of Accumulator Value Leaving the Result in
13911 * the Same Accumulator
13912 *
13913 * 3 2 1
13914 * 10987654321098765432109876543210
13915 * 001000xxxxx 01001001111111
13916 * rs -----
13917 * ac --
13918 */
13919 std::string NMD::SHILOV(uint64 instruction)
13920 {
13921 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13922 uint64 ac_value = extract_ac_13_12(instruction);
13923
13924 std::string rs = GPR(copy(rs_value));
13925 std::string ac = AC(copy(ac_value));
13926
13927 return img::format("SHILOV %s, %s", ac, rs);
13928 }
13929
13930
13931 /*
13932 * SHLL.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords
13933 *
13934 * 3 2 1
13935 * 10987654321098765432109876543210
13936 * 001000 001110110101
13937 * rt -----
13938 * rs -----
13939 * sa ----
13940 */
13941 std::string NMD::SHLL_PH(uint64 instruction)
13942 {
13943 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13944 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13945 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13946
13947 std::string rt = GPR(copy(rt_value));
13948 std::string rs = GPR(copy(rs_value));
13949 std::string sa = IMMEDIATE(copy(sa_value));
13950
13951 return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
13952 }
13953
13954
13955 /*
13956 * SHLL.QB rt, rs, sa - Shift Left Logical Vector Quad Bytes
13957 *
13958 * 3 2 1
13959 * 10987654321098765432109876543210
13960 * 001000 0100001111111
13961 * rt -----
13962 * rs -----
13963 * sa ---
13964 */
13965 std::string NMD::SHLL_QB(uint64 instruction)
13966 {
13967 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13968 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13969 uint64 sa_value = extract_sa_15_14_13(instruction);
13970
13971 std::string rt = GPR(copy(rt_value));
13972 std::string rs = GPR(copy(rs_value));
13973 std::string sa = IMMEDIATE(copy(sa_value));
13974
13975 return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
13976 }
13977
13978
13979 /*
13980 * SHLL_S.PH rt, rs, sa - Shift Left Logical Vector Pair Halfwords (saturated)
13981 *
13982 * 3 2 1
13983 * 10987654321098765432109876543210
13984 * 001000 001110110101
13985 * rt -----
13986 * rs -----
13987 * sa ----
13988 */
13989 std::string NMD::SHLL_S_PH(uint64 instruction)
13990 {
13991 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13992 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13993 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13994
13995 std::string rt = GPR(copy(rt_value));
13996 std::string rs = GPR(copy(rs_value));
13997 std::string sa = IMMEDIATE(copy(sa_value));
13998
13999 return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
14000 }
14001
14002
14003 /*
14004 *
14005 *
14006 * 3 2 1
14007 * 10987654321098765432109876543210
14008 * 001000 01001001101
14009 * rt -----
14010 * rs -----
14011 * rd -----
14012 */
14013 std::string NMD::SHLL_S_W(uint64 instruction)
14014 {
14015 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14016 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14017 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14018
14019 std::string rt = GPR(copy(rt_value));
14020 std::string rs = GPR(copy(rs_value));
14021 std::string sa = IMMEDIATE(copy(sa_value));
14022
14023 return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
14024 }
14025
14026
14027 /*
14028 *
14029 *
14030 * 3 2 1
14031 * 10987654321098765432109876543210
14032 * 001000 01001001101
14033 * rt -----
14034 * rs -----
14035 * rd -----
14036 */
14037 std::string NMD::SHLLV_PH(uint64 instruction)
14038 {
14039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14040 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14041 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14042
14043 std::string rd = GPR(copy(rd_value));
14044 std::string rt = GPR(copy(rt_value));
14045 std::string rs = GPR(copy(rs_value));
14046
14047 return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
14048 }
14049
14050
14051 /*
14052 *
14053 *
14054 * 3 2 1
14055 * 10987654321098765432109876543210
14056 * 001000 01001001101
14057 * rt -----
14058 * rs -----
14059 * rd -----
14060 */
14061 std::string NMD::SHLLV_QB(uint64 instruction)
14062 {
14063 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14064 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14065 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14066
14067 std::string rd = GPR(copy(rd_value));
14068 std::string rt = GPR(copy(rt_value));
14069 std::string rs = GPR(copy(rs_value));
14070
14071 return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
14072 }
14073
14074
14075 /*
14076 *
14077 *
14078 * 3 2 1
14079 * 10987654321098765432109876543210
14080 * 001000 01001001101
14081 * rt -----
14082 * rs -----
14083 * rd -----
14084 */
14085 std::string NMD::SHLLV_S_PH(uint64 instruction)
14086 {
14087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14089 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14090
14091 std::string rd = GPR(copy(rd_value));
14092 std::string rt = GPR(copy(rt_value));
14093 std::string rs = GPR(copy(rs_value));
14094
14095 return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
14096 }
14097
14098
14099 /*
14100 *
14101 *
14102 * 3 2 1
14103 * 10987654321098765432109876543210
14104 * 001000 01001001101
14105 * rt -----
14106 * rs -----
14107 * rd -----
14108 */
14109 std::string NMD::SHLLV_S_W(uint64 instruction)
14110 {
14111 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14112 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14113 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14114
14115 std::string rd = GPR(copy(rd_value));
14116 std::string rt = GPR(copy(rt_value));
14117 std::string rs = GPR(copy(rs_value));
14118
14119 return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
14120 }
14121
14122
14123 /*
14124 *
14125 *
14126 * 3 2 1
14127 * 10987654321098765432109876543210
14128 * 001000 01001001101
14129 * rt -----
14130 * rs -----
14131 * rd -----
14132 */
14133 std::string NMD::SHRA_PH(uint64 instruction)
14134 {
14135 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14136 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14137 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14138
14139 std::string rt = GPR(copy(rt_value));
14140 std::string rs = GPR(copy(rs_value));
14141 std::string sa = IMMEDIATE(copy(sa_value));
14142
14143 return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
14144 }
14145
14146
14147 /*
14148 *
14149 *
14150 * 3 2 1
14151 * 10987654321098765432109876543210
14152 * 001000 01001001101
14153 * rt -----
14154 * rs -----
14155 * rd -----
14156 */
14157 std::string NMD::SHRA_QB(uint64 instruction)
14158 {
14159 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14160 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14161 uint64 sa_value = extract_sa_15_14_13(instruction);
14162
14163 std::string rt = GPR(copy(rt_value));
14164 std::string rs = GPR(copy(rs_value));
14165 std::string sa = IMMEDIATE(copy(sa_value));
14166
14167 return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
14168 }
14169
14170
14171 /*
14172 *
14173 *
14174 * 3 2 1
14175 * 10987654321098765432109876543210
14176 * 001000 01001001101
14177 * rt -----
14178 * rs -----
14179 * rd -----
14180 */
14181 std::string NMD::SHRA_R_PH(uint64 instruction)
14182 {
14183 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14184 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14185 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14186
14187 std::string rt = GPR(copy(rt_value));
14188 std::string rs = GPR(copy(rs_value));
14189 std::string sa = IMMEDIATE(copy(sa_value));
14190
14191 return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
14192 }
14193
14194
14195 /*
14196 *
14197 *
14198 * 3 2 1
14199 * 10987654321098765432109876543210
14200 * 001000 01001001101
14201 * rt -----
14202 * rs -----
14203 * rd -----
14204 */
14205 std::string NMD::SHRA_R_QB(uint64 instruction)
14206 {
14207 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14208 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14209 uint64 sa_value = extract_sa_15_14_13(instruction);
14210
14211 std::string rt = GPR(copy(rt_value));
14212 std::string rs = GPR(copy(rs_value));
14213 std::string sa = IMMEDIATE(copy(sa_value));
14214
14215 return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
14216 }
14217
14218
14219 /*
14220 *
14221 *
14222 * 3 2 1
14223 * 10987654321098765432109876543210
14224 * 001000 01001001101
14225 * rt -----
14226 * rs -----
14227 * rd -----
14228 */
14229 std::string NMD::SHRA_R_W(uint64 instruction)
14230 {
14231 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14232 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14233 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
14234
14235 std::string rt = GPR(copy(rt_value));
14236 std::string rs = GPR(copy(rs_value));
14237 std::string sa = IMMEDIATE(copy(sa_value));
14238
14239 return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
14240 }
14241
14242
14243 /*
14244 *
14245 *
14246 * 3 2 1
14247 * 10987654321098765432109876543210
14248 * 001000 01001001101
14249 * rt -----
14250 * rs -----
14251 * rd -----
14252 */
14253 std::string NMD::SHRAV_PH(uint64 instruction)
14254 {
14255 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14256 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14257 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14258
14259 std::string rd = GPR(copy(rd_value));
14260 std::string rt = GPR(copy(rt_value));
14261 std::string rs = GPR(copy(rs_value));
14262
14263 return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
14264 }
14265
14266
14267 /*
14268 *
14269 *
14270 * 3 2 1
14271 * 10987654321098765432109876543210
14272 * 001000 01001001101
14273 * rt -----
14274 * rs -----
14275 * rd -----
14276 */
14277 std::string NMD::SHRAV_QB(uint64 instruction)
14278 {
14279 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14280 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14281 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14282
14283 std::string rd = GPR(copy(rd_value));
14284 std::string rt = GPR(copy(rt_value));
14285 std::string rs = GPR(copy(rs_value));
14286
14287 return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
14288 }
14289
14290
14291 /*
14292 *
14293 *
14294 * 3 2 1
14295 * 10987654321098765432109876543210
14296 * 001000 01001001101
14297 * rt -----
14298 * rs -----
14299 * rd -----
14300 */
14301 std::string NMD::SHRAV_R_PH(uint64 instruction)
14302 {
14303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14305 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14306
14307 std::string rd = GPR(copy(rd_value));
14308 std::string rt = GPR(copy(rt_value));
14309 std::string rs = GPR(copy(rs_value));
14310
14311 return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
14312 }
14313
14314
14315 /*
14316 *
14317 *
14318 * 3 2 1
14319 * 10987654321098765432109876543210
14320 * 001000 01001001101
14321 * rt -----
14322 * rs -----
14323 * rd -----
14324 */
14325 std::string NMD::SHRAV_R_QB(uint64 instruction)
14326 {
14327 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14328 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14329 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14330
14331 std::string rd = GPR(copy(rd_value));
14332 std::string rt = GPR(copy(rt_value));
14333 std::string rs = GPR(copy(rs_value));
14334
14335 return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
14336 }
14337
14338
14339 /*
14340 *
14341 *
14342 * 3 2 1
14343 * 10987654321098765432109876543210
14344 * 001000 01001001101
14345 * rt -----
14346 * rs -----
14347 * rd -----
14348 */
14349 std::string NMD::SHRAV_R_W(uint64 instruction)
14350 {
14351 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14352 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14353 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14354
14355 std::string rd = GPR(copy(rd_value));
14356 std::string rt = GPR(copy(rt_value));
14357 std::string rs = GPR(copy(rs_value));
14358
14359 return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
14360 }
14361
14362
14363 /*
14364 *
14365 *
14366 * 3 2 1
14367 * 10987654321098765432109876543210
14368 * 001000 01001001101
14369 * rt -----
14370 * rs -----
14371 * rd -----
14372 */
14373 std::string NMD::SHRL_PH(uint64 instruction)
14374 {
14375 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14376 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14377 uint64 sa_value = extract_sa_15_14_13_12(instruction);
14378
14379 std::string rt = GPR(copy(rt_value));
14380 std::string rs = GPR(copy(rs_value));
14381 std::string sa = IMMEDIATE(copy(sa_value));
14382
14383 return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
14384 }
14385
14386
14387 /*
14388 *
14389 *
14390 * 3 2 1
14391 * 10987654321098765432109876543210
14392 * 001000 01001001101
14393 * rt -----
14394 * rs -----
14395 * rd -----
14396 */
14397 std::string NMD::SHRL_QB(uint64 instruction)
14398 {
14399 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14400 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14401 uint64 sa_value = extract_sa_15_14_13(instruction);
14402
14403 std::string rt = GPR(copy(rt_value));
14404 std::string rs = GPR(copy(rs_value));
14405 std::string sa = IMMEDIATE(copy(sa_value));
14406
14407 return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
14408 }
14409
14410
14411 /*
14412 *
14413 *
14414 * 3 2 1
14415 * 10987654321098765432109876543210
14416 * 001000 01001001101
14417 * rt -----
14418 * rs -----
14419 * rd -----
14420 */
14421 std::string NMD::SHRLV_PH(uint64 instruction)
14422 {
14423 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14424 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14425 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14426
14427 std::string rd = GPR(copy(rd_value));
14428 std::string rt = GPR(copy(rt_value));
14429 std::string rs = GPR(copy(rs_value));
14430
14431 return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14432 }
14433
14434
14435 /*
14436 *
14437 *
14438 * 3 2 1
14439 * 10987654321098765432109876543210
14440 * 001000 01001001101
14441 * rt -----
14442 * rs -----
14443 * rd -----
14444 */
14445 std::string NMD::SHRLV_QB(uint64 instruction)
14446 {
14447 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14448 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14449 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14450
14451 std::string rd = GPR(copy(rd_value));
14452 std::string rt = GPR(copy(rt_value));
14453 std::string rs = GPR(copy(rs_value));
14454
14455 return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14456 }
14457
14458
14459 /*
14460 *
14461 *
14462 * 3 2 1
14463 * 10987654321098765432109876543210
14464 * 001000 01001001101
14465 * rt -----
14466 * rs -----
14467 * rd -----
14468 */
14469 std::string NMD::SHX(uint64 instruction)
14470 {
14471 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14472 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14473 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14474
14475 std::string rd = GPR(copy(rd_value));
14476 std::string rs = GPR(copy(rs_value));
14477 std::string rt = GPR(copy(rt_value));
14478
14479 return img::format("SHX %s, %s(%s)", rd, rs, rt);
14480 }
14481
14482
14483 /*
14484 *
14485 *
14486 * 3 2 1
14487 * 10987654321098765432109876543210
14488 * 001000 01001001101
14489 * rt -----
14490 * rs -----
14491 * rd -----
14492 */
14493 std::string NMD::SHXS(uint64 instruction)
14494 {
14495 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14496 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14497 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14498
14499 std::string rd = GPR(copy(rd_value));
14500 std::string rs = GPR(copy(rs_value));
14501 std::string rt = GPR(copy(rt_value));
14502
14503 return img::format("SHXS %s, %s(%s)", rd, rs, rt);
14504 }
14505
14506
14507 /*
14508 *
14509 *
14510 * 3 2 1
14511 * 10987654321098765432109876543210
14512 * 001000 01001001101
14513 * rt -----
14514 * rs -----
14515 * rd -----
14516 */
14517 std::string NMD::SIGRIE(uint64 instruction)
14518 {
14519 uint64 code_value = extract_code_18_to_0(instruction);
14520
14521 std::string code = IMMEDIATE(copy(code_value));
14522
14523 return img::format("SIGRIE %s", code);
14524 }
14525
14526
14527 /*
14528 *
14529 *
14530 * 3 2 1
14531 * 10987654321098765432109876543210
14532 * 001000 01001001101
14533 * rt -----
14534 * rs -----
14535 * rd -----
14536 */
14537 std::string NMD::SLL_16_(uint64 instruction)
14538 {
14539 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14540 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14541 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14542
14543 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14544 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
14545 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14546
14547 return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
14548 }
14549
14550
14551 /*
14552 *
14553 *
14554 * 3 2 1
14555 * 10987654321098765432109876543210
14556 * 001000 01001001101
14557 * rt -----
14558 * rs -----
14559 * rd -----
14560 */
14561 std::string NMD::SLL_32_(uint64 instruction)
14562 {
14563 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14564 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14565 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14566
14567 std::string rt = GPR(copy(rt_value));
14568 std::string rs = GPR(copy(rs_value));
14569 std::string shift = IMMEDIATE(copy(shift_value));
14570
14571 return img::format("SLL %s, %s, %s", rt, rs, shift);
14572 }
14573
14574
14575 /*
14576 *
14577 *
14578 * 3 2 1
14579 * 10987654321098765432109876543210
14580 * 001000 01001001101
14581 * rt -----
14582 * rs -----
14583 * rd -----
14584 */
14585 std::string NMD::SLLV(uint64 instruction)
14586 {
14587 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14588 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14589 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14590
14591 std::string rd = GPR(copy(rd_value));
14592 std::string rs = GPR(copy(rs_value));
14593 std::string rt = GPR(copy(rt_value));
14594
14595 return img::format("SLLV %s, %s, %s", rd, rs, rt);
14596 }
14597
14598
14599 /*
14600 *
14601 *
14602 * 3 2 1
14603 * 10987654321098765432109876543210
14604 * 001000 01001001101
14605 * rt -----
14606 * rs -----
14607 * rd -----
14608 */
14609 std::string NMD::SLT(uint64 instruction)
14610 {
14611 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14612 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14613 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14614
14615 std::string rd = GPR(copy(rd_value));
14616 std::string rs = GPR(copy(rs_value));
14617 std::string rt = GPR(copy(rt_value));
14618
14619 return img::format("SLT %s, %s, %s", rd, rs, rt);
14620 }
14621
14622
14623 /*
14624 *
14625 *
14626 * 3 2 1
14627 * 10987654321098765432109876543210
14628 * 001000 01001001101
14629 * rt -----
14630 * rs -----
14631 * rd -----
14632 */
14633 std::string NMD::SLTI(uint64 instruction)
14634 {
14635 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14636 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14637 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14638
14639 std::string rt = GPR(copy(rt_value));
14640 std::string rs = GPR(copy(rs_value));
14641 std::string u = IMMEDIATE(copy(u_value));
14642
14643 return img::format("SLTI %s, %s, %s", rt, rs, u);
14644 }
14645
14646
14647 /*
14648 *
14649 *
14650 * 3 2 1
14651 * 10987654321098765432109876543210
14652 * 001000 01001001101
14653 * rt -----
14654 * rs -----
14655 * rd -----
14656 */
14657 std::string NMD::SLTIU(uint64 instruction)
14658 {
14659 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14661 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14662
14663 std::string rt = GPR(copy(rt_value));
14664 std::string rs = GPR(copy(rs_value));
14665 std::string u = IMMEDIATE(copy(u_value));
14666
14667 return img::format("SLTIU %s, %s, %s", rt, rs, u);
14668 }
14669
14670
14671 /*
14672 *
14673 *
14674 * 3 2 1
14675 * 10987654321098765432109876543210
14676 * 001000 01001001101
14677 * rt -----
14678 * rs -----
14679 * rd -----
14680 */
14681 std::string NMD::SLTU(uint64 instruction)
14682 {
14683 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14684 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14685 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14686
14687 std::string rd = GPR(copy(rd_value));
14688 std::string rs = GPR(copy(rs_value));
14689 std::string rt = GPR(copy(rt_value));
14690
14691 return img::format("SLTU %s, %s, %s", rd, rs, rt);
14692 }
14693
14694
14695 /*
14696 *
14697 *
14698 * 3 2 1
14699 * 10987654321098765432109876543210
14700 * 001000 01001001101
14701 * rt -----
14702 * rs -----
14703 * rd -----
14704 */
14705 std::string NMD::SOV(uint64 instruction)
14706 {
14707 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14708 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14709 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14710
14711 std::string rd = GPR(copy(rd_value));
14712 std::string rs = GPR(copy(rs_value));
14713 std::string rt = GPR(copy(rt_value));
14714
14715 return img::format("SOV %s, %s, %s", rd, rs, rt);
14716 }
14717
14718
14719 /*
14720 *
14721 *
14722 * 3 2 1
14723 * 10987654321098765432109876543210
14724 * 001000 01001001101
14725 * rt -----
14726 * rs -----
14727 * rd -----
14728 */
14729 std::string NMD::SPECIAL2(uint64 instruction)
14730 {
14731 uint64 op_value = extract_op_25_to_3(instruction);
14732
14733 std::string op = IMMEDIATE(copy(op_value));
14734
14735 return img::format("SPECIAL2 %s", op);
14736 }
14737
14738
14739 /*
14740 *
14741 *
14742 * 3 2 1
14743 * 10987654321098765432109876543210
14744 * 001000 01001001101
14745 * rt -----
14746 * rs -----
14747 * rd -----
14748 */
14749 std::string NMD::SQRT_D(uint64 instruction)
14750 {
14751 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14752 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14753
14754 std::string ft = FPR(copy(ft_value));
14755 std::string fs = FPR(copy(fs_value));
14756
14757 return img::format("SQRT.D %s, %s", ft, fs);
14758 }
14759
14760
14761 /*
14762 *
14763 *
14764 * 3 2 1
14765 * 10987654321098765432109876543210
14766 * 001000 01001001101
14767 * rt -----
14768 * rs -----
14769 * rd -----
14770 */
14771 std::string NMD::SQRT_S(uint64 instruction)
14772 {
14773 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14774 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14775
14776 std::string ft = FPR(copy(ft_value));
14777 std::string fs = FPR(copy(fs_value));
14778
14779 return img::format("SQRT.S %s, %s", ft, fs);
14780 }
14781
14782
14783 /*
14784 * SRA rd, rt, sa - Shift Word Right Arithmetic
14785 *
14786 * 3 2 1
14787 * 10987654321098765432109876543210
14788 * 00000000000 000011
14789 * rt -----
14790 * rd -----
14791 * sa -----
14792 */
14793 std::string NMD::SRA(uint64 instruction)
14794 {
14795 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14796 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14797 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14798
14799 std::string rt = GPR(copy(rt_value));
14800 std::string rs = GPR(copy(rs_value));
14801 std::string shift = IMMEDIATE(copy(shift_value));
14802
14803 return img::format("SRA %s, %s, %s", rt, rs, shift);
14804 }
14805
14806
14807 /*
14808 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14809 *
14810 * 3 2 1
14811 * 10987654321098765432109876543210
14812 * 001000 00000000111
14813 * rs -----
14814 * rt -----
14815 * rd -----
14816 */
14817 std::string NMD::SRAV(uint64 instruction)
14818 {
14819 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14820 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14821 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14822
14823 std::string rd = GPR(copy(rd_value));
14824 std::string rs = GPR(copy(rs_value));
14825 std::string rt = GPR(copy(rt_value));
14826
14827 return img::format("SRAV %s, %s, %s", rd, rs, rt);
14828 }
14829
14830
14831 /*
14832 *
14833 *
14834 * 3 2 1
14835 * 10987654321098765432109876543210
14836 * 001000 00000000111
14837 * rs -----
14838 * rt -----
14839 * rd -----
14840 */
14841 std::string NMD::SRL_16_(uint64 instruction)
14842 {
14843 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14844 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14845 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14846
14847 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
14848 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
14849 std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
14850
14851 return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
14852 }
14853
14854
14855 /*
14856 *
14857 *
14858 * 3 2 1
14859 * 10987654321098765432109876543210
14860 * 001000 01001001101
14861 * rt -----
14862 * rs -----
14863 * rd -----
14864 */
14865 std::string NMD::SRL_32_(uint64 instruction)
14866 {
14867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14868 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14869 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14870
14871 std::string rt = GPR(copy(rt_value));
14872 std::string rs = GPR(copy(rs_value));
14873 std::string shift = IMMEDIATE(copy(shift_value));
14874
14875 return img::format("SRL %s, %s, %s", rt, rs, shift);
14876 }
14877
14878
14879 /*
14880 *
14881 *
14882 * 3 2 1
14883 * 10987654321098765432109876543210
14884 * 001000 01001001101
14885 * rt -----
14886 * rs -----
14887 * rd -----
14888 */
14889 std::string NMD::SRLV(uint64 instruction)
14890 {
14891 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14892 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14893 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14894
14895 std::string rd = GPR(copy(rd_value));
14896 std::string rs = GPR(copy(rs_value));
14897 std::string rt = GPR(copy(rt_value));
14898
14899 return img::format("SRLV %s, %s, %s", rd, rs, rt);
14900 }
14901
14902
14903 /*
14904 *
14905 *
14906 * 3 2 1
14907 * 10987654321098765432109876543210
14908 * 001000 01001001101
14909 * rt -----
14910 * rs -----
14911 * rd -----
14912 */
14913 std::string NMD::SUB(uint64 instruction)
14914 {
14915 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14916 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14917 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14918
14919 std::string rd = GPR(copy(rd_value));
14920 std::string rs = GPR(copy(rs_value));
14921 std::string rt = GPR(copy(rt_value));
14922
14923 return img::format("SUB %s, %s, %s", rd, rs, rt);
14924 }
14925
14926
14927 /*
14928 *
14929 *
14930 * 3 2 1
14931 * 10987654321098765432109876543210
14932 * 001000 01001001101
14933 * rt -----
14934 * rs -----
14935 * rd -----
14936 */
14937 std::string NMD::SUB_D(uint64 instruction)
14938 {
14939 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14940 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14941 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14942
14943 std::string fd = FPR(copy(fd_value));
14944 std::string fs = FPR(copy(fs_value));
14945 std::string ft = FPR(copy(ft_value));
14946
14947 return img::format("SUB.D %s, %s, %s", fd, fs, ft);
14948 }
14949
14950
14951 /*
14952 *
14953 *
14954 * 3 2 1
14955 * 10987654321098765432109876543210
14956 * 001000 01001001101
14957 * rt -----
14958 * rs -----
14959 * rd -----
14960 */
14961 std::string NMD::SUB_S(uint64 instruction)
14962 {
14963 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14964 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14965 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14966
14967 std::string fd = FPR(copy(fd_value));
14968 std::string fs = FPR(copy(fs_value));
14969 std::string ft = FPR(copy(ft_value));
14970
14971 return img::format("SUB.S %s, %s, %s", fd, fs, ft);
14972 }
14973
14974
14975 /*
14976 *
14977 *
14978 * 3 2 1
14979 * 10987654321098765432109876543210
14980 * 001000 01001001101
14981 * rt -----
14982 * rs -----
14983 * rd -----
14984 */
14985 std::string NMD::SUBQ_PH(uint64 instruction)
14986 {
14987 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14988 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14989 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14990
14991 std::string rd = GPR(copy(rd_value));
14992 std::string rs = GPR(copy(rs_value));
14993 std::string rt = GPR(copy(rt_value));
14994
14995 return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
14996 }
14997
14998
14999 /*
15000 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15001 * to Halve Results
15002 *
15003 * 3 2 1
15004 * 10987654321098765432109876543210
15005 * 001000 01001001101
15006 * rt -----
15007 * rs -----
15008 * rd -----
15009 */
15010 std::string NMD::SUBQ_S_PH(uint64 instruction)
15011 {
15012 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15013 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15014 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15015
15016 std::string rd = GPR(copy(rd_value));
15017 std::string rs = GPR(copy(rs_value));
15018 std::string rt = GPR(copy(rt_value));
15019
15020 return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
15021 }
15022
15023
15024 /*
15025 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15026 * to Halve Results
15027 *
15028 * 3 2 1
15029 * 10987654321098765432109876543210
15030 * 001000 01001001101
15031 * rt -----
15032 * rs -----
15033 * rd -----
15034 */
15035 std::string NMD::SUBQ_S_W(uint64 instruction)
15036 {
15037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15038 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15039 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15040
15041 std::string rd = GPR(copy(rd_value));
15042 std::string rs = GPR(copy(rs_value));
15043 std::string rt = GPR(copy(rt_value));
15044
15045 return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
15046 }
15047
15048
15049 /*
15050 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15051 * to Halve Results
15052 *
15053 * 3 2 1
15054 * 10987654321098765432109876543210
15055 * 001000 01001001101
15056 * rt -----
15057 * rs -----
15058 * rd -----
15059 */
15060 std::string NMD::SUBQH_PH(uint64 instruction)
15061 {
15062 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15063 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15064 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15065
15066 std::string rd = GPR(copy(rd_value));
15067 std::string rs = GPR(copy(rs_value));
15068 std::string rt = GPR(copy(rt_value));
15069
15070 return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
15071 }
15072
15073
15074 /*
15075 * SUBQH.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15076 * to Halve Results
15077 *
15078 * 3 2 1
15079 * 10987654321098765432109876543210
15080 * 001000 01001001101
15081 * rt -----
15082 * rs -----
15083 * rd -----
15084 */
15085 std::string NMD::SUBQH_R_PH(uint64 instruction)
15086 {
15087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15089 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15090
15091 std::string rd = GPR(copy(rd_value));
15092 std::string rs = GPR(copy(rs_value));
15093 std::string rt = GPR(copy(rt_value));
15094
15095 return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
15096 }
15097
15098
15099 /*
15100 * SUBQH_R.PH rd, rt, rs - Subtract Fractional Halfword Vectors And Shift Right
15101 * to Halve Results (rounding)
15102 *
15103 * 3 2 1
15104 * 10987654321098765432109876543210
15105 * 001000 11001001101
15106 * rt -----
15107 * rs -----
15108 * rd -----
15109 */
15110 std::string NMD::SUBQH_R_W(uint64 instruction)
15111 {
15112 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15113 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15114 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15115
15116 std::string rd = GPR(copy(rd_value));
15117 std::string rs = GPR(copy(rs_value));
15118 std::string rt = GPR(copy(rt_value));
15119
15120 return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
15121 }
15122
15123
15124 /*
15125 * SUBQH.W rd, rs, rt - Subtract Fractional Words And Shift Right to Halve
15126 * Results
15127 *
15128 * 3 2 1
15129 * 10987654321098765432109876543210
15130 * 001000 01010001101
15131 * rt -----
15132 * rs -----
15133 * rd -----
15134 */
15135 std::string NMD::SUBQH_W(uint64 instruction)
15136 {
15137 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15138 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15139 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15140
15141 std::string rd = GPR(copy(rd_value));
15142 std::string rs = GPR(copy(rs_value));
15143 std::string rt = GPR(copy(rt_value));
15144
15145 return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
15146 }
15147
15148
15149 /*
15150 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15151 *
15152 * 3 2 1
15153 * 10987654321098765432109876543210
15154 * 001000 00010001101
15155 * rt -----
15156 * rs -----
15157 * rd -----
15158 */
15159 std::string NMD::SUBU_16_(uint64 instruction)
15160 {
15161 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15162 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15163 uint64 rd3_value = extract_rd3_3_2_1(instruction);
15164
15165 std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
15166 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
15167 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
15168
15169 return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
15170 }
15171
15172
15173 /*
15174 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15175 *
15176 * 3 2 1
15177 * 10987654321098765432109876543210
15178 * 001000 00010001101
15179 * rt -----
15180 * rs -----
15181 * rd -----
15182 */
15183 std::string NMD::SUBU_32_(uint64 instruction)
15184 {
15185 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15186 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15187 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15188
15189 std::string rd = GPR(copy(rd_value));
15190 std::string rs = GPR(copy(rs_value));
15191 std::string rt = GPR(copy(rt_value));
15192
15193 return img::format("SUBU %s, %s, %s", rd, rs, rt);
15194 }
15195
15196
15197 /*
15198 * SUBU.PH rd, rs, rt - Subtract Unsigned Integer Halfwords
15199 *
15200 * 3 2 1
15201 * 10987654321098765432109876543210
15202 * 001000 01100001101
15203 * rt -----
15204 * rs -----
15205 * rd -----
15206 */
15207 std::string NMD::SUBU_PH(uint64 instruction)
15208 {
15209 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15210 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15211 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15212
15213 std::string rd = GPR(copy(rd_value));
15214 std::string rs = GPR(copy(rs_value));
15215 std::string rt = GPR(copy(rt_value));
15216
15217 return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
15218 }
15219
15220
15221 /*
15222 * SUBU.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector
15223 *
15224 * 3 2 1
15225 * 10987654321098765432109876543210
15226 * 001000 01011001101
15227 * rt -----
15228 * rs -----
15229 * rd -----
15230 */
15231 std::string NMD::SUBU_QB(uint64 instruction)
15232 {
15233 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15234 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15235 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15236
15237 std::string rd = GPR(copy(rd_value));
15238 std::string rs = GPR(copy(rs_value));
15239 std::string rt = GPR(copy(rt_value));
15240
15241 return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
15242 }
15243
15244
15245 /*
15246 * SUBU_S.PH rd, rs, rt - Subtract Unsigned Integer Halfwords (saturating)
15247 *
15248 * 3 2 1
15249 * 10987654321098765432109876543210
15250 * 001000 11100001101
15251 * rt -----
15252 * rs -----
15253 * rd -----
15254 */
15255 std::string NMD::SUBU_S_PH(uint64 instruction)
15256 {
15257 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15258 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15259 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15260
15261 std::string rd = GPR(copy(rd_value));
15262 std::string rs = GPR(copy(rs_value));
15263 std::string rt = GPR(copy(rt_value));
15264
15265 return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
15266 }
15267
15268
15269 /*
15270 * SUBU_S.QB rd, rs, rt - Subtract Unsigned Quad Byte Vector (saturating)
15271 *
15272 * 3 2 1
15273 * 10987654321098765432109876543210
15274 * 001000 11011001101
15275 * rt -----
15276 * rs -----
15277 * rd -----
15278 */
15279 std::string NMD::SUBU_S_QB(uint64 instruction)
15280 {
15281 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15282 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15283 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15284
15285 std::string rd = GPR(copy(rd_value));
15286 std::string rs = GPR(copy(rs_value));
15287 std::string rt = GPR(copy(rt_value));
15288
15289 return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
15290 }
15291
15292
15293 /*
15294 * SUBUH.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15295 * Results
15296 *
15297 * 3 2 1
15298 * 10987654321098765432109876543210
15299 * 001000 01101001101
15300 * rt -----
15301 * rs -----
15302 * rd -----
15303 */
15304 std::string NMD::SUBUH_QB(uint64 instruction)
15305 {
15306 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15307 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15308 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15309
15310 std::string rd = GPR(copy(rd_value));
15311 std::string rs = GPR(copy(rs_value));
15312 std::string rt = GPR(copy(rt_value));
15313
15314 return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
15315 }
15316
15317
15318 /*
15319 * SUBUH_R.QB rd, rs, rt - Subtract Unsigned Bytes And Right Shift to Halve
15320 * Results (rounding)
15321 *
15322 * 3 2 1
15323 * 10987654321098765432109876543210
15324 * 001000 11101001101
15325 * rt -----
15326 * rs -----
15327 * rd -----
15328 */
15329 std::string NMD::SUBUH_R_QB(uint64 instruction)
15330 {
15331 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15332 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15333 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15334
15335 std::string rd = GPR(copy(rd_value));
15336 std::string rs = GPR(copy(rs_value));
15337 std::string rt = GPR(copy(rt_value));
15338
15339 return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
15340 }
15341
15342
15343 /*
15344 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15345 *
15346 * 3 2 1
15347 * 10987654321098765432109876543210
15348 * 001000 00010001101
15349 * rt -----
15350 * rs -----
15351 * rd -----
15352 */
15353 std::string NMD::SW_16_(uint64 instruction)
15354 {
15355 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15356 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15357 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
15358
15359 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
15360 std::string u = IMMEDIATE(copy(u_value));
15361 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
15362
15363 return img::format("SW %s, %s(%s)", rtz3, u, rs3);
15364 }
15365
15366
15367 /*
15368 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15369 *
15370 * 3 2 1
15371 * 10987654321098765432109876543210
15372 * 001000 00010001101
15373 * rt -----
15374 * rs -----
15375 * rd -----
15376 */
15377 std::string NMD::SW_4X4_(uint64 instruction)
15378 {
15379 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
15380 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
15381 uint64 u_value = extract_u_3_8__s2(instruction);
15382
15383 std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
15384 std::string u = IMMEDIATE(copy(u_value));
15385 std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
15386
15387 return img::format("SW %s, %s(%s)", rtz4, u, rs4);
15388 }
15389
15390
15391 /*
15392 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15393 *
15394 * 3 2 1
15395 * 10987654321098765432109876543210
15396 * 001000 00010001101
15397 * rt -----
15398 * rs -----
15399 * rd -----
15400 */
15401 std::string NMD::SW_GP16_(uint64 instruction)
15402 {
15403 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
15404 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
15405
15406 std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
15407 std::string u = IMMEDIATE(copy(u_value));
15408
15409 return img::format("SW %s, %s($%d)", rtz3, u, 28);
15410 }
15411
15412
15413 /*
15414 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15415 *
15416 * 3 2 1
15417 * 10987654321098765432109876543210
15418 * 001000 00010001101
15419 * rt -----
15420 * rs -----
15421 * rd -----
15422 */
15423 std::string NMD::SW_GP_(uint64 instruction)
15424 {
15425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15426 uint64 u_value = extract_u_20_to_2__s2(instruction);
15427
15428 std::string rt = GPR(copy(rt_value));
15429 std::string u = IMMEDIATE(copy(u_value));
15430
15431 return img::format("SW %s, %s($%d)", rt, u, 28);
15432 }
15433
15434
15435 /*
15436 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15437 *
15438 * 3 2 1
15439 * 10987654321098765432109876543210
15440 * 001000 00010001101
15441 * rt -----
15442 * rs -----
15443 * rd -----
15444 */
15445 std::string NMD::SW_S9_(uint64 instruction)
15446 {
15447 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15448 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15449 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15450
15451 std::string rt = GPR(copy(rt_value));
15452 std::string s = IMMEDIATE(copy(s_value));
15453 std::string rs = GPR(copy(rs_value));
15454
15455 return img::format("SW %s, %s(%s)", rt, s, rs);
15456 }
15457
15458
15459 /*
15460 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15461 *
15462 * 3 2 1
15463 * 10987654321098765432109876543210
15464 * 001000 00010001101
15465 * rt -----
15466 * rs -----
15467 * rd -----
15468 */
15469 std::string NMD::SW_SP_(uint64 instruction)
15470 {
15471 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
15472 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
15473
15474 std::string rt = GPR(copy(rt_value));
15475 std::string u = IMMEDIATE(copy(u_value));
15476
15477 return img::format("SW %s, %s($%d)", rt, u, 29);
15478 }
15479
15480
15481 /*
15482 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15483 *
15484 * 3 2 1
15485 * 10987654321098765432109876543210
15486 * 001000 00010001101
15487 * rt -----
15488 * rs -----
15489 * rd -----
15490 */
15491 std::string NMD::SW_U12_(uint64 instruction)
15492 {
15493 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15494 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15495 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15496
15497 std::string rt = GPR(copy(rt_value));
15498 std::string u = IMMEDIATE(copy(u_value));
15499 std::string rs = GPR(copy(rs_value));
15500
15501 return img::format("SW %s, %s(%s)", rt, u, rs);
15502 }
15503
15504
15505 /*
15506 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15507 *
15508 * 3 2 1
15509 * 10987654321098765432109876543210
15510 * 001000 00010001101
15511 * rt -----
15512 * rs -----
15513 * rd -----
15514 */
15515 std::string NMD::SWC1_GP_(uint64 instruction)
15516 {
15517 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15518 uint64 u_value = extract_u_17_to_2__s2(instruction);
15519
15520 std::string ft = FPR(copy(ft_value));
15521 std::string u = IMMEDIATE(copy(u_value));
15522
15523 return img::format("SWC1 %s, %s($%d)", ft, u, 28);
15524 }
15525
15526
15527 /*
15528 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15529 *
15530 * 3 2 1
15531 * 10987654321098765432109876543210
15532 * 001000 00010001101
15533 * rt -----
15534 * rs -----
15535 * rd -----
15536 */
15537 std::string NMD::SWC1_S9_(uint64 instruction)
15538 {
15539 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15540 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15541 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15542
15543 std::string ft = FPR(copy(ft_value));
15544 std::string s = IMMEDIATE(copy(s_value));
15545 std::string rs = GPR(copy(rs_value));
15546
15547 return img::format("SWC1 %s, %s(%s)", ft, s, rs);
15548 }
15549
15550
15551 /*
15552 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15553 *
15554 * 3 2 1
15555 * 10987654321098765432109876543210
15556 * 001000 00010001101
15557 * rt -----
15558 * rs -----
15559 * rd -----
15560 */
15561 std::string NMD::SWC1_U12_(uint64 instruction)
15562 {
15563 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15564 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15565 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15566
15567 std::string ft = FPR(copy(ft_value));
15568 std::string u = IMMEDIATE(copy(u_value));
15569 std::string rs = GPR(copy(rs_value));
15570
15571 return img::format("SWC1 %s, %s(%s)", ft, u, rs);
15572 }
15573
15574
15575 /*
15576 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15577 *
15578 * 3 2 1
15579 * 10987654321098765432109876543210
15580 * 001000 00010001101
15581 * rt -----
15582 * rs -----
15583 * rd -----
15584 */
15585 std::string NMD::SWC1X(uint64 instruction)
15586 {
15587 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15588 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15589 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15590
15591 std::string ft = FPR(copy(ft_value));
15592 std::string rs = GPR(copy(rs_value));
15593 std::string rt = GPR(copy(rt_value));
15594
15595 return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
15596 }
15597
15598
15599 /*
15600 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15601 *
15602 * 3 2 1
15603 * 10987654321098765432109876543210
15604 * 001000 00010001101
15605 * rt -----
15606 * rs -----
15607 * rd -----
15608 */
15609 std::string NMD::SWC1XS(uint64 instruction)
15610 {
15611 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15612 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15613 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15614
15615 std::string ft = FPR(copy(ft_value));
15616 std::string rs = GPR(copy(rs_value));
15617 std::string rt = GPR(copy(rt_value));
15618
15619 return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
15620 }
15621
15622
15623 /*
15624 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15625 *
15626 * 3 2 1
15627 * 10987654321098765432109876543210
15628 * 001000 00010001101
15629 * rt -----
15630 * rs -----
15631 * rd -----
15632 */
15633 std::string NMD::SWC2(uint64 instruction)
15634 {
15635 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15636 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15637 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15638
15639 std::string cs = CPR(copy(cs_value));
15640 std::string s = IMMEDIATE(copy(s_value));
15641 std::string rs = GPR(copy(rs_value));
15642
15643 return img::format("SWC2 %s, %s(%s)", cs, s, rs);
15644 }
15645
15646
15647 /*
15648 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15649 *
15650 * 3 2 1
15651 * 10987654321098765432109876543210
15652 * 001000 00010001101
15653 * rt -----
15654 * rs -----
15655 * rd -----
15656 */
15657 std::string NMD::SWE(uint64 instruction)
15658 {
15659 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15661 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15662
15663 std::string rt = GPR(copy(rt_value));
15664 std::string s = IMMEDIATE(copy(s_value));
15665 std::string rs = GPR(copy(rs_value));
15666
15667 return img::format("SWE %s, %s(%s)", rt, s, rs);
15668 }
15669
15670
15671 /*
15672 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15673 *
15674 * 3 2 1
15675 * 10987654321098765432109876543210
15676 * 001000 00010001101
15677 * rt -----
15678 * rs -----
15679 * rd -----
15680 */
15681 std::string NMD::SWM(uint64 instruction)
15682 {
15683 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15684 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15685 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15686 uint64 count3_value = extract_count3_14_13_12(instruction);
15687
15688 std::string rt = GPR(copy(rt_value));
15689 std::string s = IMMEDIATE(copy(s_value));
15690 std::string rs = GPR(copy(rs_value));
15691 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
15692
15693 return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
15694 }
15695
15696
15697 /*
15698 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15699 *
15700 * 3 2 1
15701 * 10987654321098765432109876543210
15702 * 001000 00010001101
15703 * rt -----
15704 * rs -----
15705 * rd -----
15706 */
15707 std::string NMD::SWPC_48_(uint64 instruction)
15708 {
15709 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15710 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
15711
15712 std::string rt = GPR(copy(rt_value));
15713 std::string s = ADDRESS(encode_s_from_address(s_value), 6);
15714
15715 return img::format("SWPC %s, %s", rt, s);
15716 }
15717
15718
15719 /*
15720 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15721 *
15722 * 3 2 1
15723 * 10987654321098765432109876543210
15724 * 001000 00010001101
15725 * rt -----
15726 * rs -----
15727 * rd -----
15728 */
15729 std::string NMD::SWX(uint64 instruction)
15730 {
15731 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15732 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15733 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15734
15735 std::string rd = GPR(copy(rd_value));
15736 std::string rs = GPR(copy(rs_value));
15737 std::string rt = GPR(copy(rt_value));
15738
15739 return img::format("SWX %s, %s(%s)", rd, rs, rt);
15740 }
15741
15742
15743 /*
15744 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15745 *
15746 * 3 2 1
15747 * 10987654321098765432109876543210
15748 * 001000 00010001101
15749 * rt -----
15750 * rs -----
15751 * rd -----
15752 */
15753 std::string NMD::SWXS(uint64 instruction)
15754 {
15755 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15756 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15757 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15758
15759 std::string rd = GPR(copy(rd_value));
15760 std::string rs = GPR(copy(rs_value));
15761 std::string rt = GPR(copy(rt_value));
15762
15763 return img::format("SWXS %s, %s(%s)", rd, rs, rt);
15764 }
15765
15766
15767 /*
15768 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15769 *
15770 * 3 2 1
15771 * 10987654321098765432109876543210
15772 * 001000 00010001101
15773 * rt -----
15774 * rs -----
15775 * rd -----
15776 */
15777 std::string NMD::SYNC(uint64 instruction)
15778 {
15779 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15780
15781 std::string stype = IMMEDIATE(copy(stype_value));
15782
15783 return img::format("SYNC %s", stype);
15784 }
15785
15786
15787 /*
15788 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15789 *
15790 * 3 2 1
15791 * 10987654321098765432109876543210
15792 * 001000 00010001101
15793 * rt -----
15794 * rs -----
15795 * rd -----
15796 */
15797 std::string NMD::SYNCI(uint64 instruction)
15798 {
15799 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15800 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15801
15802 std::string s = IMMEDIATE(copy(s_value));
15803 std::string rs = GPR(copy(rs_value));
15804
15805 return img::format("SYNCI %s(%s)", s, rs);
15806 }
15807
15808
15809 /*
15810 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15811 *
15812 * 3 2 1
15813 * 10987654321098765432109876543210
15814 * 001000 00010001101
15815 * rt -----
15816 * rs -----
15817 * rd -----
15818 */
15819 std::string NMD::SYNCIE(uint64 instruction)
15820 {
15821 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15822 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15823
15824 std::string s = IMMEDIATE(copy(s_value));
15825 std::string rs = GPR(copy(rs_value));
15826
15827 return img::format("SYNCIE %s(%s)", s, rs);
15828 }
15829
15830
15831 /*
15832 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15833 *
15834 * 3 2 1
15835 * 10987654321098765432109876543210
15836 * 001000 00010001101
15837 * rt -----
15838 * rs -----
15839 * rd -----
15840 */
15841 std::string NMD::SYSCALL_16_(uint64 instruction)
15842 {
15843 uint64 code_value = extract_code_1_0(instruction);
15844
15845 std::string code = IMMEDIATE(copy(code_value));
15846
15847 return img::format("SYSCALL %s", code);
15848 }
15849
15850
15851 /*
15852 * SYSCALL code - System Call. Cause a System Call Exception
15853 *
15854 * 3 2 1
15855 * 10987654321098765432109876543210
15856 * 00000000000010
15857 * code ------------------
15858 */
15859 std::string NMD::SYSCALL_32_(uint64 instruction)
15860 {
15861 uint64 code_value = extract_code_17_to_0(instruction);
15862
15863 std::string code = IMMEDIATE(copy(code_value));
15864
15865 return img::format("SYSCALL %s", code);
15866 }
15867
15868
15869 /*
15870 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15871 *
15872 * 3 2 1
15873 * 10987654321098765432109876543210
15874 * 001000 00010001101
15875 * rt -----
15876 * rs -----
15877 * rd -----
15878 */
15879 std::string NMD::TEQ(uint64 instruction)
15880 {
15881 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15882 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15883
15884 std::string rs = GPR(copy(rs_value));
15885 std::string rt = GPR(copy(rt_value));
15886
15887 return img::format("TEQ %s, %s", rs, rt);
15888 }
15889
15890
15891 /*
15892 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15893 *
15894 * 3 2 1
15895 * 10987654321098765432109876543210
15896 * 001000 00010001101
15897 * rt -----
15898 * rs -----
15899 * rd -----
15900 */
15901 std::string NMD::TLBGINV(uint64 instruction)
15902 {
15903 (void)instruction;
15904
15905 return "TLBGINV ";
15906 }
15907
15908
15909 /*
15910 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15911 *
15912 * 3 2 1
15913 * 10987654321098765432109876543210
15914 * 001000 00010001101
15915 * rt -----
15916 * rs -----
15917 * rd -----
15918 */
15919 std::string NMD::TLBGINVF(uint64 instruction)
15920 {
15921 (void)instruction;
15922
15923 return "TLBGINVF ";
15924 }
15925
15926
15927 /*
15928 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15929 *
15930 * 3 2 1
15931 * 10987654321098765432109876543210
15932 * 001000 00010001101
15933 * rt -----
15934 * rs -----
15935 * rd -----
15936 */
15937 std::string NMD::TLBGP(uint64 instruction)
15938 {
15939 (void)instruction;
15940
15941 return "TLBGP ";
15942 }
15943
15944
15945 /*
15946 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15947 *
15948 * 3 2 1
15949 * 10987654321098765432109876543210
15950 * 001000 00010001101
15951 * rt -----
15952 * rs -----
15953 * rd -----
15954 */
15955 std::string NMD::TLBGR(uint64 instruction)
15956 {
15957 (void)instruction;
15958
15959 return "TLBGR ";
15960 }
15961
15962
15963 /*
15964 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15965 *
15966 * 3 2 1
15967 * 10987654321098765432109876543210
15968 * 001000 00010001101
15969 * rt -----
15970 * rs -----
15971 * rd -----
15972 */
15973 std::string NMD::TLBGWI(uint64 instruction)
15974 {
15975 (void)instruction;
15976
15977 return "TLBGWI ";
15978 }
15979
15980
15981 /*
15982 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15983 *
15984 * 3 2 1
15985 * 10987654321098765432109876543210
15986 * 001000 00010001101
15987 * rt -----
15988 * rs -----
15989 * rd -----
15990 */
15991 std::string NMD::TLBGWR(uint64 instruction)
15992 {
15993 (void)instruction;
15994
15995 return "TLBGWR ";
15996 }
15997
15998
15999 /*
16000 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16001 *
16002 * 3 2 1
16003 * 10987654321098765432109876543210
16004 * 001000 00010001101
16005 * rt -----
16006 * rs -----
16007 * rd -----
16008 */
16009 std::string NMD::TLBINV(uint64 instruction)
16010 {
16011 (void)instruction;
16012
16013 return "TLBINV ";
16014 }
16015
16016
16017 /*
16018 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16019 *
16020 * 3 2 1
16021 * 10987654321098765432109876543210
16022 * 001000 00010001101
16023 * rt -----
16024 * rs -----
16025 * rd -----
16026 */
16027 std::string NMD::TLBINVF(uint64 instruction)
16028 {
16029 (void)instruction;
16030
16031 return "TLBINVF ";
16032 }
16033
16034
16035 /*
16036 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16037 *
16038 * 3 2 1
16039 * 10987654321098765432109876543210
16040 * 001000 00010001101
16041 * rt -----
16042 * rs -----
16043 * rd -----
16044 */
16045 std::string NMD::TLBP(uint64 instruction)
16046 {
16047 (void)instruction;
16048
16049 return "TLBP ";
16050 }
16051
16052
16053 /*
16054 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16055 *
16056 * 3 2 1
16057 * 10987654321098765432109876543210
16058 * 001000 00010001101
16059 * rt -----
16060 * rs -----
16061 * rd -----
16062 */
16063 std::string NMD::TLBR(uint64 instruction)
16064 {
16065 (void)instruction;
16066
16067 return "TLBR ";
16068 }
16069
16070
16071 /*
16072 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16073 *
16074 * 3 2 1
16075 * 10987654321098765432109876543210
16076 * 001000 00010001101
16077 * rt -----
16078 * rs -----
16079 * rd -----
16080 */
16081 std::string NMD::TLBWI(uint64 instruction)
16082 {
16083 (void)instruction;
16084
16085 return "TLBWI ";
16086 }
16087
16088
16089 /*
16090 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16091 *
16092 * 3 2 1
16093 * 10987654321098765432109876543210
16094 * 001000 00010001101
16095 * rt -----
16096 * rs -----
16097 * rd -----
16098 */
16099 std::string NMD::TLBWR(uint64 instruction)
16100 {
16101 (void)instruction;
16102
16103 return "TLBWR ";
16104 }
16105
16106
16107 /*
16108 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16109 *
16110 * 3 2 1
16111 * 10987654321098765432109876543210
16112 * 001000 00010001101
16113 * rt -----
16114 * rs -----
16115 * rd -----
16116 */
16117 std::string NMD::TNE(uint64 instruction)
16118 {
16119 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16120 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16121
16122 std::string rs = GPR(copy(rs_value));
16123 std::string rt = GPR(copy(rt_value));
16124
16125 return img::format("TNE %s, %s", rs, rt);
16126 }
16127
16128
16129 /*
16130 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16131 *
16132 * 3 2 1
16133 * 10987654321098765432109876543210
16134 * 001000 00010001101
16135 * rt -----
16136 * rs -----
16137 * rd -----
16138 */
16139 std::string NMD::TRUNC_L_D(uint64 instruction)
16140 {
16141 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16142 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16143
16144 std::string ft = FPR(copy(ft_value));
16145 std::string fs = FPR(copy(fs_value));
16146
16147 return img::format("TRUNC.L.D %s, %s", ft, fs);
16148 }
16149
16150
16151 /*
16152 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16153 *
16154 * 3 2 1
16155 * 10987654321098765432109876543210
16156 * 001000 00010001101
16157 * rt -----
16158 * rs -----
16159 * rd -----
16160 */
16161 std::string NMD::TRUNC_L_S(uint64 instruction)
16162 {
16163 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16164 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16165
16166 std::string ft = FPR(copy(ft_value));
16167 std::string fs = FPR(copy(fs_value));
16168
16169 return img::format("TRUNC.L.S %s, %s", ft, fs);
16170 }
16171
16172
16173 /*
16174 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16175 *
16176 * 3 2 1
16177 * 10987654321098765432109876543210
16178 * 001000 00010001101
16179 * rt -----
16180 * rs -----
16181 * rd -----
16182 */
16183 std::string NMD::TRUNC_W_D(uint64 instruction)
16184 {
16185 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16186 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16187
16188 std::string ft = FPR(copy(ft_value));
16189 std::string fs = FPR(copy(fs_value));
16190
16191 return img::format("TRUNC.W.D %s, %s", ft, fs);
16192 }
16193
16194
16195 /*
16196 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16197 *
16198 * 3 2 1
16199 * 10987654321098765432109876543210
16200 * 001000 00010001101
16201 * rt -----
16202 * rs -----
16203 * rd -----
16204 */
16205 std::string NMD::TRUNC_W_S(uint64 instruction)
16206 {
16207 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
16208 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
16209
16210 std::string ft = FPR(copy(ft_value));
16211 std::string fs = FPR(copy(fs_value));
16212
16213 return img::format("TRUNC.W.S %s, %s", ft, fs);
16214 }
16215
16216
16217 /*
16218 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16219 *
16220 * 3 2 1
16221 * 10987654321098765432109876543210
16222 * 001000 00010001101
16223 * rt -----
16224 * rs -----
16225 * rd -----
16226 */
16227 std::string NMD::UALDM(uint64 instruction)
16228 {
16229 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16230 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16231 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16232 uint64 count3_value = extract_count3_14_13_12(instruction);
16233
16234 std::string rt = GPR(copy(rt_value));
16235 std::string s = IMMEDIATE(copy(s_value));
16236 std::string rs = GPR(copy(rs_value));
16237 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16238
16239 return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
16240 }
16241
16242
16243 /*
16244 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16245 *
16246 * 3 2 1
16247 * 10987654321098765432109876543210
16248 * 001000 00010001101
16249 * rt -----
16250 * rs -----
16251 * rd -----
16252 */
16253 std::string NMD::UALH(uint64 instruction)
16254 {
16255 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16256 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16257 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16258
16259 std::string rt = GPR(copy(rt_value));
16260 std::string s = IMMEDIATE(copy(s_value));
16261 std::string rs = GPR(copy(rs_value));
16262
16263 return img::format("UALH %s, %s(%s)", rt, s, rs);
16264 }
16265
16266
16267 /*
16268 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16269 *
16270 * 3 2 1
16271 * 10987654321098765432109876543210
16272 * 001000 00010001101
16273 * rt -----
16274 * rs -----
16275 * rd -----
16276 */
16277 std::string NMD::UALWM(uint64 instruction)
16278 {
16279 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16280 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16281 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16282 uint64 count3_value = extract_count3_14_13_12(instruction);
16283
16284 std::string rt = GPR(copy(rt_value));
16285 std::string s = IMMEDIATE(copy(s_value));
16286 std::string rs = GPR(copy(rs_value));
16287 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16288
16289 return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
16290 }
16291
16292
16293 /*
16294 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16295 *
16296 * 3 2 1
16297 * 10987654321098765432109876543210
16298 * 001000 00010001101
16299 * rt -----
16300 * rs -----
16301 * rd -----
16302 */
16303 std::string NMD::UASDM(uint64 instruction)
16304 {
16305 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16306 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16307 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16308 uint64 count3_value = extract_count3_14_13_12(instruction);
16309
16310 std::string rt = GPR(copy(rt_value));
16311 std::string s = IMMEDIATE(copy(s_value));
16312 std::string rs = GPR(copy(rs_value));
16313 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16314
16315 return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
16316 }
16317
16318
16319 /*
16320 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16321 *
16322 * 3 2 1
16323 * 10987654321098765432109876543210
16324 * 001000 00010001101
16325 * rt -----
16326 * rs -----
16327 * rd -----
16328 */
16329 std::string NMD::UASH(uint64 instruction)
16330 {
16331 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16332 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16333 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16334
16335 std::string rt = GPR(copy(rt_value));
16336 std::string s = IMMEDIATE(copy(s_value));
16337 std::string rs = GPR(copy(rs_value));
16338
16339 return img::format("UASH %s, %s(%s)", rt, s, rs);
16340 }
16341
16342
16343 /*
16344 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16345 *
16346 * 3 2 1
16347 * 10987654321098765432109876543210
16348 * 001000 00010001101
16349 * rt -----
16350 * rs -----
16351 * rd -----
16352 */
16353 std::string NMD::UASWM(uint64 instruction)
16354 {
16355 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16356 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16357 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
16358 uint64 count3_value = extract_count3_14_13_12(instruction);
16359
16360 std::string rt = GPR(copy(rt_value));
16361 std::string s = IMMEDIATE(copy(s_value));
16362 std::string rs = GPR(copy(rs_value));
16363 std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
16364
16365 return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
16366 }
16367
16368
16369 /*
16370 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16371 *
16372 * 3 2 1
16373 * 10987654321098765432109876543210
16374 * 001000 00010001101
16375 * rt -----
16376 * rs -----
16377 * rd -----
16378 */
16379 std::string NMD::UDI(uint64 instruction)
16380 {
16381 uint64 op_value = extract_op_25_to_3(instruction);
16382
16383 std::string op = IMMEDIATE(copy(op_value));
16384
16385 return img::format("UDI %s", op);
16386 }
16387
16388
16389 /*
16390 * WAIT code - Enter Wait State
16391 *
16392 * 3 2 1
16393 * 10987654321098765432109876543210
16394 * 001000 1100001101111111
16395 * code ----------
16396 */
16397 std::string NMD::WAIT(uint64 instruction)
16398 {
16399 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
16400
16401 std::string code = IMMEDIATE(copy(code_value));
16402
16403 return img::format("WAIT %s", code);
16404 }
16405
16406
16407 /*
16408 * WRDSP rt, mask - Write Fields to DSPControl Register from a GPR
16409 *
16410 * 3 2 1
16411 * 10987654321098765432109876543210
16412 * 001000 01011001111111
16413 * rt -----
16414 * mask -------
16415 */
16416 std::string NMD::WRDSP(uint64 instruction)
16417 {
16418 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16419 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
16420
16421 std::string rt = GPR(copy(rt_value));
16422 std::string mask = IMMEDIATE(copy(mask_value));
16423
16424 return img::format("WRDSP %s, %s", rt, mask);
16425 }
16426
16427
16428 /*
16429 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16430 *
16431 * 3 2 1
16432 * 10987654321098765432109876543210
16433 * 001000 00010001101
16434 * rt -----
16435 * rs -----
16436 * rd -----
16437 */
16438 std::string NMD::WRPGPR(uint64 instruction)
16439 {
16440 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16441 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16442
16443 std::string rt = GPR(copy(rt_value));
16444 std::string rs = GPR(copy(rs_value));
16445
16446 return img::format("WRPGPR %s, %s", rt, rs);
16447 }
16448
16449
16450 /*
16451 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16452 *
16453 * 3 2 1
16454 * 10987654321098765432109876543210
16455 * 001000 00010001101
16456 * rt -----
16457 * rs -----
16458 * rd -----
16459 */
16460 std::string NMD::XOR_16_(uint64 instruction)
16461 {
16462 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16463 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16464
16465 std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
16466 std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
16467
16468 return img::format("XOR %s, %s", rs3, rt3);
16469 }
16470
16471
16472 /*
16473 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16474 *
16475 * 3 2 1
16476 * 10987654321098765432109876543210
16477 * 001000 00010001101
16478 * rt -----
16479 * rs -----
16480 * rd -----
16481 */
16482 std::string NMD::XOR_32_(uint64 instruction)
16483 {
16484 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16485 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16486 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
16487
16488 std::string rd = GPR(copy(rd_value));
16489 std::string rs = GPR(copy(rs_value));
16490 std::string rt = GPR(copy(rt_value));
16491
16492 return img::format("XOR %s, %s, %s", rd, rs, rt);
16493 }
16494
16495
16496 /*
16497 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16498 *
16499 * 3 2 1
16500 * 10987654321098765432109876543210
16501 * 001000 00010001101
16502 * rt -----
16503 * rs -----
16504 * rd -----
16505 */
16506 std::string NMD::XORI(uint64 instruction)
16507 {
16508 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16509 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16510 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
16511
16512 std::string rt = GPR(copy(rt_value));
16513 std::string rs = GPR(copy(rs_value));
16514 std::string u = IMMEDIATE(copy(u_value));
16515
16516 return img::format("XORI %s, %s, %s", rt, rs, u);
16517 }
16518
16519
16520 /*
16521 * YIELD rt, rs -
16522 *
16523 * 3 2 1
16524 * 10987654321098765432109876543210
16525 * 001000 00010001101
16526 * rt -----
16527 * rs -----
16528 */
16529 std::string NMD::YIELD(uint64 instruction)
16530 {
16531 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16532 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16533
16534 std::string rt = GPR(copy(rt_value));
16535 std::string rs = GPR(copy(rs_value));
16536
16537 return img::format("YIELD %s, %s", rt, rs);
16538 }
16539
16540
16541
16542 NMD::Pool NMD::P_SYSCALL[2] = {
16543 { instruction , 0 , 0 , 32,
16544 0xfffc0000, 0x00080000, &NMD::SYSCALL_32_ , 0,
16545 0x0 }, /* SYSCALL[32] */
16546 { instruction , 0 , 0 , 32,
16547 0xfffc0000, 0x000c0000, &NMD::HYPCALL , 0,
16548 CP0_ | VZ_ }, /* HYPCALL */
16549 };
16550
16551
16552 NMD::Pool NMD::P_RI[4] = {
16553 { instruction , 0 , 0 , 32,
16554 0xfff80000, 0x00000000, &NMD::SIGRIE , 0,
16555 0x0 }, /* SIGRIE */
16556 { pool , P_SYSCALL , 2 , 32,
16557 0xfff80000, 0x00080000, 0 , 0,
16558 0x0 }, /* P.SYSCALL */
16559 { instruction , 0 , 0 , 32,
16560 0xfff80000, 0x00100000, &NMD::BREAK_32_ , 0,
16561 0x0 }, /* BREAK[32] */
16562 { instruction , 0 , 0 , 32,
16563 0xfff80000, 0x00180000, &NMD::SDBBP_32_ , 0,
16564 EJTAG_ }, /* SDBBP[32] */
16565 };
16566
16567
16568 NMD::Pool NMD::P_ADDIU[2] = {
16569 { pool , P_RI , 4 , 32,
16570 0xffe00000, 0x00000000, 0 , 0,
16571 0x0 }, /* P.RI */
16572 { instruction , 0 , 0 , 32,
16573 0xfc000000, 0x00000000, &NMD::ADDIU_32_ , &NMD::ADDIU_32__cond ,
16574 0x0 }, /* ADDIU[32] */
16575 };
16576
16577
16578 NMD::Pool NMD::P_TRAP[2] = {
16579 { instruction , 0 , 0 , 32,
16580 0xfc0007ff, 0x20000000, &NMD::TEQ , 0,
16581 XMMS_ }, /* TEQ */
16582 { instruction , 0 , 0 , 32,
16583 0xfc0007ff, 0x20000400, &NMD::TNE , 0,
16584 XMMS_ }, /* TNE */
16585 };
16586
16587
16588 NMD::Pool NMD::P_CMOVE[2] = {
16589 { instruction , 0 , 0 , 32,
16590 0xfc0007ff, 0x20000210, &NMD::MOVZ , 0,
16591 0x0 }, /* MOVZ */
16592 { instruction , 0 , 0 , 32,
16593 0xfc0007ff, 0x20000610, &NMD::MOVN , 0,
16594 0x0 }, /* MOVN */
16595 };
16596
16597
16598 NMD::Pool NMD::P_D_MT_VPE[2] = {
16599 { instruction , 0 , 0 , 32,
16600 0xfc1f3fff, 0x20010ab0, &NMD::DMT , 0,
16601 MT_ }, /* DMT */
16602 { instruction , 0 , 0 , 32,
16603 0xfc1f3fff, 0x20000ab0, &NMD::DVPE , 0,
16604 MT_ }, /* DVPE */
16605 };
16606
16607
16608 NMD::Pool NMD::P_E_MT_VPE[2] = {
16609 { instruction , 0 , 0 , 32,
16610 0xfc1f3fff, 0x20010eb0, &NMD::EMT , 0,
16611 MT_ }, /* EMT */
16612 { instruction , 0 , 0 , 32,
16613 0xfc1f3fff, 0x20000eb0, &NMD::EVPE , 0,
16614 MT_ }, /* EVPE */
16615 };
16616
16617
16618 NMD::Pool NMD::_P_MT_VPE[2] = {
16619 { pool , P_D_MT_VPE , 2 , 32,
16620 0xfc003fff, 0x20000ab0, 0 , 0,
16621 0x0 }, /* P.D_MT_VPE */
16622 { pool , P_E_MT_VPE , 2 , 32,
16623 0xfc003fff, 0x20000eb0, 0 , 0,
16624 0x0 }, /* P.E_MT_VPE */
16625 };
16626
16627
16628 NMD::Pool NMD::P_MT_VPE[8] = {
16629 { reserved_block , 0 , 0 , 32,
16630 0xfc003bff, 0x200002b0, 0 , 0,
16631 0x0 }, /* P.MT_VPE~*(0) */
16632 { pool , _P_MT_VPE , 2 , 32,
16633 0xfc003bff, 0x20000ab0, 0 , 0,
16634 0x0 }, /* _P.MT_VPE */
16635 { reserved_block , 0 , 0 , 32,
16636 0xfc003bff, 0x200012b0, 0 , 0,
16637 0x0 }, /* P.MT_VPE~*(2) */
16638 { reserved_block , 0 , 0 , 32,
16639 0xfc003bff, 0x20001ab0, 0 , 0,
16640 0x0 }, /* P.MT_VPE~*(3) */
16641 { reserved_block , 0 , 0 , 32,
16642 0xfc003bff, 0x200022b0, 0 , 0,
16643 0x0 }, /* P.MT_VPE~*(4) */
16644 { reserved_block , 0 , 0 , 32,
16645 0xfc003bff, 0x20002ab0, 0 , 0,
16646 0x0 }, /* P.MT_VPE~*(5) */
16647 { reserved_block , 0 , 0 , 32,
16648 0xfc003bff, 0x200032b0, 0 , 0,
16649 0x0 }, /* P.MT_VPE~*(6) */
16650 { reserved_block , 0 , 0 , 32,
16651 0xfc003bff, 0x20003ab0, 0 , 0,
16652 0x0 }, /* P.MT_VPE~*(7) */
16653 };
16654
16655
16656 NMD::Pool NMD::P_DVP[2] = {
16657 { instruction , 0 , 0 , 32,
16658 0xfc00ffff, 0x20000390, &NMD::DVP , 0,
16659 0x0 }, /* DVP */
16660 { instruction , 0 , 0 , 32,
16661 0xfc00ffff, 0x20000790, &NMD::EVP , 0,
16662 0x0 }, /* EVP */
16663 };
16664
16665
16666 NMD::Pool NMD::P_SLTU[2] = {
16667 { pool , P_DVP , 2 , 32,
16668 0xfc00fbff, 0x20000390, 0 , 0,
16669 0x0 }, /* P.DVP */
16670 { instruction , 0 , 0 , 32,
16671 0xfc0003ff, 0x20000390, &NMD::SLTU , &NMD::SLTU_cond ,
16672 0x0 }, /* SLTU */
16673 };
16674
16675
16676 NMD::Pool NMD::_POOL32A0[128] = {
16677 { pool , P_TRAP , 2 , 32,
16678 0xfc0003ff, 0x20000000, 0 , 0,
16679 0x0 }, /* P.TRAP */
16680 { instruction , 0 , 0 , 32,
16681 0xfc0003ff, 0x20000008, &NMD::SEB , 0,
16682 XMMS_ }, /* SEB */
16683 { instruction , 0 , 0 , 32,
16684 0xfc0003ff, 0x20000010, &NMD::SLLV , 0,
16685 0x0 }, /* SLLV */
16686 { instruction , 0 , 0 , 32,
16687 0xfc0003ff, 0x20000018, &NMD::MUL_32_ , 0,
16688 0x0 }, /* MUL[32] */
16689 { reserved_block , 0 , 0 , 32,
16690 0xfc0003ff, 0x20000020, 0 , 0,
16691 0x0 }, /* _POOL32A0~*(4) */
16692 { reserved_block , 0 , 0 , 32,
16693 0xfc0003ff, 0x20000028, 0 , 0,
16694 0x0 }, /* _POOL32A0~*(5) */
16695 { instruction , 0 , 0 , 32,
16696 0xfc0003ff, 0x20000030, &NMD::MFC0 , 0,
16697 0x0 }, /* MFC0 */
16698 { instruction , 0 , 0 , 32,
16699 0xfc0003ff, 0x20000038, &NMD::MFHC0 , 0,
16700 CP0_ | MVH_ }, /* MFHC0 */
16701 { reserved_block , 0 , 0 , 32,
16702 0xfc0003ff, 0x20000040, 0 , 0,
16703 0x0 }, /* _POOL32A0~*(8) */
16704 { instruction , 0 , 0 , 32,
16705 0xfc0003ff, 0x20000048, &NMD::SEH , 0,
16706 0x0 }, /* SEH */
16707 { instruction , 0 , 0 , 32,
16708 0xfc0003ff, 0x20000050, &NMD::SRLV , 0,
16709 0x0 }, /* SRLV */
16710 { instruction , 0 , 0 , 32,
16711 0xfc0003ff, 0x20000058, &NMD::MUH , 0,
16712 0x0 }, /* MUH */
16713 { reserved_block , 0 , 0 , 32,
16714 0xfc0003ff, 0x20000060, 0 , 0,
16715 0x0 }, /* _POOL32A0~*(12) */
16716 { reserved_block , 0 , 0 , 32,
16717 0xfc0003ff, 0x20000068, 0 , 0,
16718 0x0 }, /* _POOL32A0~*(13) */
16719 { instruction , 0 , 0 , 32,
16720 0xfc0003ff, 0x20000070, &NMD::MTC0 , 0,
16721 CP0_ }, /* MTC0 */
16722 { instruction , 0 , 0 , 32,
16723 0xfc0003ff, 0x20000078, &NMD::MTHC0 , 0,
16724 CP0_ | MVH_ }, /* MTHC0 */
16725 { reserved_block , 0 , 0 , 32,
16726 0xfc0003ff, 0x20000080, 0 , 0,
16727 0x0 }, /* _POOL32A0~*(16) */
16728 { reserved_block , 0 , 0 , 32,
16729 0xfc0003ff, 0x20000088, 0 , 0,
16730 0x0 }, /* _POOL32A0~*(17) */
16731 { instruction , 0 , 0 , 32,
16732 0xfc0003ff, 0x20000090, &NMD::SRAV , 0,
16733 0x0 }, /* SRAV */
16734 { instruction , 0 , 0 , 32,
16735 0xfc0003ff, 0x20000098, &NMD::MULU , 0,
16736 0x0 }, /* MULU */
16737 { reserved_block , 0 , 0 , 32,
16738 0xfc0003ff, 0x200000a0, 0 , 0,
16739 0x0 }, /* _POOL32A0~*(20) */
16740 { reserved_block , 0 , 0 , 32,
16741 0xfc0003ff, 0x200000a8, 0 , 0,
16742 0x0 }, /* _POOL32A0~*(21) */
16743 { instruction , 0 , 0 , 32,
16744 0xfc0003ff, 0x200000b0, &NMD::MFGC0 , 0,
16745 CP0_ | VZ_ }, /* MFGC0 */
16746 { instruction , 0 , 0 , 32,
16747 0xfc0003ff, 0x200000b8, &NMD::MFHGC0 , 0,
16748 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16749 { reserved_block , 0 , 0 , 32,
16750 0xfc0003ff, 0x200000c0, 0 , 0,
16751 0x0 }, /* _POOL32A0~*(24) */
16752 { reserved_block , 0 , 0 , 32,
16753 0xfc0003ff, 0x200000c8, 0 , 0,
16754 0x0 }, /* _POOL32A0~*(25) */
16755 { instruction , 0 , 0 , 32,
16756 0xfc0003ff, 0x200000d0, &NMD::ROTRV , 0,
16757 0x0 }, /* ROTRV */
16758 { instruction , 0 , 0 , 32,
16759 0xfc0003ff, 0x200000d8, &NMD::MUHU , 0,
16760 0x0 }, /* MUHU */
16761 { reserved_block , 0 , 0 , 32,
16762 0xfc0003ff, 0x200000e0, 0 , 0,
16763 0x0 }, /* _POOL32A0~*(28) */
16764 { reserved_block , 0 , 0 , 32,
16765 0xfc0003ff, 0x200000e8, 0 , 0,
16766 0x0 }, /* _POOL32A0~*(29) */
16767 { instruction , 0 , 0 , 32,
16768 0xfc0003ff, 0x200000f0, &NMD::MTGC0 , 0,
16769 CP0_ | VZ_ }, /* MTGC0 */
16770 { instruction , 0 , 0 , 32,
16771 0xfc0003ff, 0x200000f8, &NMD::MTHGC0 , 0,
16772 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16773 { reserved_block , 0 , 0 , 32,
16774 0xfc0003ff, 0x20000100, 0 , 0,
16775 0x0 }, /* _POOL32A0~*(32) */
16776 { reserved_block , 0 , 0 , 32,
16777 0xfc0003ff, 0x20000108, 0 , 0,
16778 0x0 }, /* _POOL32A0~*(33) */
16779 { instruction , 0 , 0 , 32,
16780 0xfc0003ff, 0x20000110, &NMD::ADD , 0,
16781 XMMS_ }, /* ADD */
16782 { instruction , 0 , 0 , 32,
16783 0xfc0003ff, 0x20000118, &NMD::DIV , 0,
16784 0x0 }, /* DIV */
16785 { reserved_block , 0 , 0 , 32,
16786 0xfc0003ff, 0x20000120, 0 , 0,
16787 0x0 }, /* _POOL32A0~*(36) */
16788 { reserved_block , 0 , 0 , 32,
16789 0xfc0003ff, 0x20000128, 0 , 0,
16790 0x0 }, /* _POOL32A0~*(37) */
16791 { instruction , 0 , 0 , 32,
16792 0xfc0003ff, 0x20000130, &NMD::DMFC0 , 0,
16793 CP0_ | MIPS64_ }, /* DMFC0 */
16794 { reserved_block , 0 , 0 , 32,
16795 0xfc0003ff, 0x20000138, 0 , 0,
16796 0x0 }, /* _POOL32A0~*(39) */
16797 { reserved_block , 0 , 0 , 32,
16798 0xfc0003ff, 0x20000140, 0 , 0,
16799 0x0 }, /* _POOL32A0~*(40) */
16800 { reserved_block , 0 , 0 , 32,
16801 0xfc0003ff, 0x20000148, 0 , 0,
16802 0x0 }, /* _POOL32A0~*(41) */
16803 { instruction , 0 , 0 , 32,
16804 0xfc0003ff, 0x20000150, &NMD::ADDU_32_ , 0,
16805 0x0 }, /* ADDU[32] */
16806 { instruction , 0 , 0 , 32,
16807 0xfc0003ff, 0x20000158, &NMD::MOD , 0,
16808 0x0 }, /* MOD */
16809 { reserved_block , 0 , 0 , 32,
16810 0xfc0003ff, 0x20000160, 0 , 0,
16811 0x0 }, /* _POOL32A0~*(44) */
16812 { reserved_block , 0 , 0 , 32,
16813 0xfc0003ff, 0x20000168, 0 , 0,
16814 0x0 }, /* _POOL32A0~*(45) */
16815 { instruction , 0 , 0 , 32,
16816 0xfc0003ff, 0x20000170, &NMD::DMTC0 , 0,
16817 CP0_ | MIPS64_ }, /* DMTC0 */
16818 { reserved_block , 0 , 0 , 32,
16819 0xfc0003ff, 0x20000178, 0 , 0,
16820 0x0 }, /* _POOL32A0~*(47) */
16821 { reserved_block , 0 , 0 , 32,
16822 0xfc0003ff, 0x20000180, 0 , 0,
16823 0x0 }, /* _POOL32A0~*(48) */
16824 { reserved_block , 0 , 0 , 32,
16825 0xfc0003ff, 0x20000188, 0 , 0,
16826 0x0 }, /* _POOL32A0~*(49) */
16827 { instruction , 0 , 0 , 32,
16828 0xfc0003ff, 0x20000190, &NMD::SUB , 0,
16829 XMMS_ }, /* SUB */
16830 { instruction , 0 , 0 , 32,
16831 0xfc0003ff, 0x20000198, &NMD::DIVU , 0,
16832 0x0 }, /* DIVU */
16833 { reserved_block , 0 , 0 , 32,
16834 0xfc0003ff, 0x200001a0, 0 , 0,
16835 0x0 }, /* _POOL32A0~*(52) */
16836 { reserved_block , 0 , 0 , 32,
16837 0xfc0003ff, 0x200001a8, 0 , 0,
16838 0x0 }, /* _POOL32A0~*(53) */
16839 { instruction , 0 , 0 , 32,
16840 0xfc0003ff, 0x200001b0, &NMD::DMFGC0 , 0,
16841 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16842 { reserved_block , 0 , 0 , 32,
16843 0xfc0003ff, 0x200001b8, 0 , 0,
16844 0x0 }, /* _POOL32A0~*(55) */
16845 { instruction , 0 , 0 , 32,
16846 0xfc0003ff, 0x200001c0, &NMD::RDHWR , 0,
16847 XMMS_ }, /* RDHWR */
16848 { reserved_block , 0 , 0 , 32,
16849 0xfc0003ff, 0x200001c8, 0 , 0,
16850 0x0 }, /* _POOL32A0~*(57) */
16851 { instruction , 0 , 0 , 32,
16852 0xfc0003ff, 0x200001d0, &NMD::SUBU_32_ , 0,
16853 0x0 }, /* SUBU[32] */
16854 { instruction , 0 , 0 , 32,
16855 0xfc0003ff, 0x200001d8, &NMD::MODU , 0,
16856 0x0 }, /* MODU */
16857 { reserved_block , 0 , 0 , 32,
16858 0xfc0003ff, 0x200001e0, 0 , 0,
16859 0x0 }, /* _POOL32A0~*(60) */
16860 { reserved_block , 0 , 0 , 32,
16861 0xfc0003ff, 0x200001e8, 0 , 0,
16862 0x0 }, /* _POOL32A0~*(61) */
16863 { instruction , 0 , 0 , 32,
16864 0xfc0003ff, 0x200001f0, &NMD::DMTGC0 , 0,
16865 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16866 { reserved_block , 0 , 0 , 32,
16867 0xfc0003ff, 0x200001f8, 0 , 0,
16868 0x0 }, /* _POOL32A0~*(63) */
16869 { reserved_block , 0 , 0 , 32,
16870 0xfc0003ff, 0x20000200, 0 , 0,
16871 0x0 }, /* _POOL32A0~*(64) */
16872 { reserved_block , 0 , 0 , 32,
16873 0xfc0003ff, 0x20000208, 0 , 0,
16874 0x0 }, /* _POOL32A0~*(65) */
16875 { pool , P_CMOVE , 2 , 32,
16876 0xfc0003ff, 0x20000210, 0 , 0,
16877 0x0 }, /* P.CMOVE */
16878 { reserved_block , 0 , 0 , 32,
16879 0xfc0003ff, 0x20000218, 0 , 0,
16880 0x0 }, /* _POOL32A0~*(67) */
16881 { reserved_block , 0 , 0 , 32,
16882 0xfc0003ff, 0x20000220, 0 , 0,
16883 0x0 }, /* _POOL32A0~*(68) */
16884 { instruction , 0 , 0 , 32,
16885 0xfc0003ff, 0x20000228, &NMD::FORK , 0,
16886 MT_ }, /* FORK */
16887 { instruction , 0 , 0 , 32,
16888 0xfc0003ff, 0x20000230, &NMD::MFTR , 0,
16889 MT_ }, /* MFTR */
16890 { instruction , 0 , 0 , 32,
16891 0xfc0003ff, 0x20000238, &NMD::MFHTR , 0,
16892 MT_ }, /* MFHTR */
16893 { reserved_block , 0 , 0 , 32,
16894 0xfc0003ff, 0x20000240, 0 , 0,
16895 0x0 }, /* _POOL32A0~*(72) */
16896 { reserved_block , 0 , 0 , 32,
16897 0xfc0003ff, 0x20000248, 0 , 0,
16898 0x0 }, /* _POOL32A0~*(73) */
16899 { instruction , 0 , 0 , 32,
16900 0xfc0003ff, 0x20000250, &NMD::AND_32_ , 0,
16901 0x0 }, /* AND[32] */
16902 { reserved_block , 0 , 0 , 32,
16903 0xfc0003ff, 0x20000258, 0 , 0,
16904 0x0 }, /* _POOL32A0~*(75) */
16905 { reserved_block , 0 , 0 , 32,
16906 0xfc0003ff, 0x20000260, 0 , 0,
16907 0x0 }, /* _POOL32A0~*(76) */
16908 { instruction , 0 , 0 , 32,
16909 0xfc0003ff, 0x20000268, &NMD::YIELD , 0,
16910 MT_ }, /* YIELD */
16911 { instruction , 0 , 0 , 32,
16912 0xfc0003ff, 0x20000270, &NMD::MTTR , 0,
16913 MT_ }, /* MTTR */
16914 { instruction , 0 , 0 , 32,
16915 0xfc0003ff, 0x20000278, &NMD::MTHTR , 0,
16916 MT_ }, /* MTHTR */
16917 { reserved_block , 0 , 0 , 32,
16918 0xfc0003ff, 0x20000280, 0 , 0,
16919 0x0 }, /* _POOL32A0~*(80) */
16920 { reserved_block , 0 , 0 , 32,
16921 0xfc0003ff, 0x20000288, 0 , 0,
16922 0x0 }, /* _POOL32A0~*(81) */
16923 { instruction , 0 , 0 , 32,
16924 0xfc0003ff, 0x20000290, &NMD::OR_32_ , 0,
16925 0x0 }, /* OR[32] */
16926 { reserved_block , 0 , 0 , 32,
16927 0xfc0003ff, 0x20000298, 0 , 0,
16928 0x0 }, /* _POOL32A0~*(83) */
16929 { reserved_block , 0 , 0 , 32,
16930 0xfc0003ff, 0x200002a0, 0 , 0,
16931 0x0 }, /* _POOL32A0~*(84) */
16932 { reserved_block , 0 , 0 , 32,
16933 0xfc0003ff, 0x200002a8, 0 , 0,
16934 0x0 }, /* _POOL32A0~*(85) */
16935 { pool , P_MT_VPE , 8 , 32,
16936 0xfc0003ff, 0x200002b0, 0 , 0,
16937 0x0 }, /* P.MT_VPE */
16938 { reserved_block , 0 , 0 , 32,
16939 0xfc0003ff, 0x200002b8, 0 , 0,
16940 0x0 }, /* _POOL32A0~*(87) */
16941 { reserved_block , 0 , 0 , 32,
16942 0xfc0003ff, 0x200002c0, 0 , 0,
16943 0x0 }, /* _POOL32A0~*(88) */
16944 { reserved_block , 0 , 0 , 32,
16945 0xfc0003ff, 0x200002c8, 0 , 0,
16946 0x0 }, /* _POOL32A0~*(89) */
16947 { instruction , 0 , 0 , 32,
16948 0xfc0003ff, 0x200002d0, &NMD::NOR , 0,
16949 0x0 }, /* NOR */
16950 { reserved_block , 0 , 0 , 32,
16951 0xfc0003ff, 0x200002d8, 0 , 0,
16952 0x0 }, /* _POOL32A0~*(91) */
16953 { reserved_block , 0 , 0 , 32,
16954 0xfc0003ff, 0x200002e0, 0 , 0,
16955 0x0 }, /* _POOL32A0~*(92) */
16956 { reserved_block , 0 , 0 , 32,
16957 0xfc0003ff, 0x200002e8, 0 , 0,
16958 0x0 }, /* _POOL32A0~*(93) */
16959 { reserved_block , 0 , 0 , 32,
16960 0xfc0003ff, 0x200002f0, 0 , 0,
16961 0x0 }, /* _POOL32A0~*(94) */
16962 { reserved_block , 0 , 0 , 32,
16963 0xfc0003ff, 0x200002f8, 0 , 0,
16964 0x0 }, /* _POOL32A0~*(95) */
16965 { reserved_block , 0 , 0 , 32,
16966 0xfc0003ff, 0x20000300, 0 , 0,
16967 0x0 }, /* _POOL32A0~*(96) */
16968 { reserved_block , 0 , 0 , 32,
16969 0xfc0003ff, 0x20000308, 0 , 0,
16970 0x0 }, /* _POOL32A0~*(97) */
16971 { instruction , 0 , 0 , 32,
16972 0xfc0003ff, 0x20000310, &NMD::XOR_32_ , 0,
16973 0x0 }, /* XOR[32] */
16974 { reserved_block , 0 , 0 , 32,
16975 0xfc0003ff, 0x20000318, 0 , 0,
16976 0x0 }, /* _POOL32A0~*(99) */
16977 { reserved_block , 0 , 0 , 32,
16978 0xfc0003ff, 0x20000320, 0 , 0,
16979 0x0 }, /* _POOL32A0~*(100) */
16980 { reserved_block , 0 , 0 , 32,
16981 0xfc0003ff, 0x20000328, 0 , 0,
16982 0x0 }, /* _POOL32A0~*(101) */
16983 { reserved_block , 0 , 0 , 32,
16984 0xfc0003ff, 0x20000330, 0 , 0,
16985 0x0 }, /* _POOL32A0~*(102) */
16986 { reserved_block , 0 , 0 , 32,
16987 0xfc0003ff, 0x20000338, 0 , 0,
16988 0x0 }, /* _POOL32A0~*(103) */
16989 { reserved_block , 0 , 0 , 32,
16990 0xfc0003ff, 0x20000340, 0 , 0,
16991 0x0 }, /* _POOL32A0~*(104) */
16992 { reserved_block , 0 , 0 , 32,
16993 0xfc0003ff, 0x20000348, 0 , 0,
16994 0x0 }, /* _POOL32A0~*(105) */
16995 { instruction , 0 , 0 , 32,
16996 0xfc0003ff, 0x20000350, &NMD::SLT , 0,
16997 0x0 }, /* SLT */
16998 { reserved_block , 0 , 0 , 32,
16999 0xfc0003ff, 0x20000358, 0 , 0,
17000 0x0 }, /* _POOL32A0~*(107) */
17001 { reserved_block , 0 , 0 , 32,
17002 0xfc0003ff, 0x20000360, 0 , 0,
17003 0x0 }, /* _POOL32A0~*(108) */
17004 { reserved_block , 0 , 0 , 32,
17005 0xfc0003ff, 0x20000368, 0 , 0,
17006 0x0 }, /* _POOL32A0~*(109) */
17007 { reserved_block , 0 , 0 , 32,
17008 0xfc0003ff, 0x20000370, 0 , 0,
17009 0x0 }, /* _POOL32A0~*(110) */
17010 { reserved_block , 0 , 0 , 32,
17011 0xfc0003ff, 0x20000378, 0 , 0,
17012 0x0 }, /* _POOL32A0~*(111) */
17013 { reserved_block , 0 , 0 , 32,
17014 0xfc0003ff, 0x20000380, 0 , 0,
17015 0x0 }, /* _POOL32A0~*(112) */
17016 { reserved_block , 0 , 0 , 32,
17017 0xfc0003ff, 0x20000388, 0 , 0,
17018 0x0 }, /* _POOL32A0~*(113) */
17019 { pool , P_SLTU , 2 , 32,
17020 0xfc0003ff, 0x20000390, 0 , 0,
17021 0x0 }, /* P.SLTU */
17022 { reserved_block , 0 , 0 , 32,
17023 0xfc0003ff, 0x20000398, 0 , 0,
17024 0x0 }, /* _POOL32A0~*(115) */
17025 { reserved_block , 0 , 0 , 32,
17026 0xfc0003ff, 0x200003a0, 0 , 0,
17027 0x0 }, /* _POOL32A0~*(116) */
17028 { reserved_block , 0 , 0 , 32,
17029 0xfc0003ff, 0x200003a8, 0 , 0,
17030 0x0 }, /* _POOL32A0~*(117) */
17031 { reserved_block , 0 , 0 , 32,
17032 0xfc0003ff, 0x200003b0, 0 , 0,
17033 0x0 }, /* _POOL32A0~*(118) */
17034 { reserved_block , 0 , 0 , 32,
17035 0xfc0003ff, 0x200003b8, 0 , 0,
17036 0x0 }, /* _POOL32A0~*(119) */
17037 { reserved_block , 0 , 0 , 32,
17038 0xfc0003ff, 0x200003c0, 0 , 0,
17039 0x0 }, /* _POOL32A0~*(120) */
17040 { reserved_block , 0 , 0 , 32,
17041 0xfc0003ff, 0x200003c8, 0 , 0,
17042 0x0 }, /* _POOL32A0~*(121) */
17043 { instruction , 0 , 0 , 32,
17044 0xfc0003ff, 0x200003d0, &NMD::SOV , 0,
17045 0x0 }, /* SOV */
17046 { reserved_block , 0 , 0 , 32,
17047 0xfc0003ff, 0x200003d8, 0 , 0,
17048 0x0 }, /* _POOL32A0~*(123) */
17049 { reserved_block , 0 , 0 , 32,
17050 0xfc0003ff, 0x200003e0, 0 , 0,
17051 0x0 }, /* _POOL32A0~*(124) */
17052 { reserved_block , 0 , 0 , 32,
17053 0xfc0003ff, 0x200003e8, 0 , 0,
17054 0x0 }, /* _POOL32A0~*(125) */
17055 { reserved_block , 0 , 0 , 32,
17056 0xfc0003ff, 0x200003f0, 0 , 0,
17057 0x0 }, /* _POOL32A0~*(126) */
17058 { reserved_block , 0 , 0 , 32,
17059 0xfc0003ff, 0x200003f8, 0 , 0,
17060 0x0 }, /* _POOL32A0~*(127) */
17061 };
17062
17063
17064 NMD::Pool NMD::ADDQ__S__PH[2] = {
17065 { instruction , 0 , 0 , 32,
17066 0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH , 0,
17067 DSP_ }, /* ADDQ.PH */
17068 { instruction , 0 , 0 , 32,
17069 0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH , 0,
17070 DSP_ }, /* ADDQ_S.PH */
17071 };
17072
17073
17074 NMD::Pool NMD::MUL__S__PH[2] = {
17075 { instruction , 0 , 0 , 32,
17076 0xfc0007ff, 0x2000002d, &NMD::MUL_PH , 0,
17077 DSP_ }, /* MUL.PH */
17078 { instruction , 0 , 0 , 32,
17079 0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH , 0,
17080 DSP_ }, /* MUL_S.PH */
17081 };
17082
17083
17084 NMD::Pool NMD::ADDQH__R__PH[2] = {
17085 { instruction , 0 , 0 , 32,
17086 0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH , 0,
17087 DSP_ }, /* ADDQH.PH */
17088 { instruction , 0 , 0 , 32,
17089 0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH , 0,
17090 DSP_ }, /* ADDQH_R.PH */
17091 };
17092
17093
17094 NMD::Pool NMD::ADDQH__R__W[2] = {
17095 { instruction , 0 , 0 , 32,
17096 0xfc0007ff, 0x2000008d, &NMD::ADDQH_W , 0,
17097 DSP_ }, /* ADDQH.W */
17098 { instruction , 0 , 0 , 32,
17099 0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W , 0,
17100 DSP_ }, /* ADDQH_R.W */
17101 };
17102
17103
17104 NMD::Pool NMD::ADDU__S__QB[2] = {
17105 { instruction , 0 , 0 , 32,
17106 0xfc0007ff, 0x200000cd, &NMD::ADDU_QB , 0,
17107 DSP_ }, /* ADDU.QB */
17108 { instruction , 0 , 0 , 32,
17109 0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB , 0,
17110 DSP_ }, /* ADDU_S.QB */
17111 };
17112
17113
17114 NMD::Pool NMD::ADDU__S__PH[2] = {
17115 { instruction , 0 , 0 , 32,
17116 0xfc0007ff, 0x2000010d, &NMD::ADDU_PH , 0,
17117 DSP_ }, /* ADDU.PH */
17118 { instruction , 0 , 0 , 32,
17119 0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH , 0,
17120 DSP_ }, /* ADDU_S.PH */
17121 };
17122
17123
17124 NMD::Pool NMD::ADDUH__R__QB[2] = {
17125 { instruction , 0 , 0 , 32,
17126 0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB , 0,
17127 DSP_ }, /* ADDUH.QB */
17128 { instruction , 0 , 0 , 32,
17129 0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB , 0,
17130 DSP_ }, /* ADDUH_R.QB */
17131 };
17132
17133
17134 NMD::Pool NMD::SHRAV__R__PH[2] = {
17135 { instruction , 0 , 0 , 32,
17136 0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH , 0,
17137 DSP_ }, /* SHRAV.PH */
17138 { instruction , 0 , 0 , 32,
17139 0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH , 0,
17140 DSP_ }, /* SHRAV_R.PH */
17141 };
17142
17143
17144 NMD::Pool NMD::SHRAV__R__QB[2] = {
17145 { instruction , 0 , 0 , 32,
17146 0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB , 0,
17147 DSP_ }, /* SHRAV.QB */
17148 { instruction , 0 , 0 , 32,
17149 0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB , 0,
17150 DSP_ }, /* SHRAV_R.QB */
17151 };
17152
17153
17154 NMD::Pool NMD::SUBQ__S__PH[2] = {
17155 { instruction , 0 , 0 , 32,
17156 0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH , 0,
17157 DSP_ }, /* SUBQ.PH */
17158 { instruction , 0 , 0 , 32,
17159 0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH , 0,
17160 DSP_ }, /* SUBQ_S.PH */
17161 };
17162
17163
17164 NMD::Pool NMD::SUBQH__R__PH[2] = {
17165 { instruction , 0 , 0 , 32,
17166 0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH , 0,
17167 DSP_ }, /* SUBQH.PH */
17168 { instruction , 0 , 0 , 32,
17169 0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH , 0,
17170 DSP_ }, /* SUBQH_R.PH */
17171 };
17172
17173
17174 NMD::Pool NMD::SUBQH__R__W[2] = {
17175 { instruction , 0 , 0 , 32,
17176 0xfc0007ff, 0x2000028d, &NMD::SUBQH_W , 0,
17177 DSP_ }, /* SUBQH.W */
17178 { instruction , 0 , 0 , 32,
17179 0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W , 0,
17180 DSP_ }, /* SUBQH_R.W */
17181 };
17182
17183
17184 NMD::Pool NMD::SUBU__S__QB[2] = {
17185 { instruction , 0 , 0 , 32,
17186 0xfc0007ff, 0x200002cd, &NMD::SUBU_QB , 0,
17187 DSP_ }, /* SUBU.QB */
17188 { instruction , 0 , 0 , 32,
17189 0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB , 0,
17190 DSP_ }, /* SUBU_S.QB */
17191 };
17192
17193
17194 NMD::Pool NMD::SUBU__S__PH[2] = {
17195 { instruction , 0 , 0 , 32,
17196 0xfc0007ff, 0x2000030d, &NMD::SUBU_PH , 0,
17197 DSP_ }, /* SUBU.PH */
17198 { instruction , 0 , 0 , 32,
17199 0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH , 0,
17200 DSP_ }, /* SUBU_S.PH */
17201 };
17202
17203
17204 NMD::Pool NMD::SHRA__R__PH[2] = {
17205 { instruction , 0 , 0 , 32,
17206 0xfc0007ff, 0x20000335, &NMD::SHRA_PH , 0,
17207 DSP_ }, /* SHRA.PH */
17208 { instruction , 0 , 0 , 32,
17209 0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH , 0,
17210 DSP_ }, /* SHRA_R.PH */
17211 };
17212
17213
17214 NMD::Pool NMD::SUBUH__R__QB[2] = {
17215 { instruction , 0 , 0 , 32,
17216 0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB , 0,
17217 DSP_ }, /* SUBUH.QB */
17218 { instruction , 0 , 0 , 32,
17219 0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB , 0,
17220 DSP_ }, /* SUBUH_R.QB */
17221 };
17222
17223
17224 NMD::Pool NMD::SHLLV__S__PH[2] = {
17225 { instruction , 0 , 0 , 32,
17226 0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH , 0,
17227 DSP_ }, /* SHLLV.PH */
17228 { instruction , 0 , 0 , 32,
17229 0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH , 0,
17230 DSP_ }, /* SHLLV_S.PH */
17231 };
17232
17233
17234 NMD::Pool NMD::SHLL__S__PH[4] = {
17235 { instruction , 0 , 0 , 32,
17236 0xfc000fff, 0x200003b5, &NMD::SHLL_PH , 0,
17237 DSP_ }, /* SHLL.PH */
17238 { reserved_block , 0 , 0 , 32,
17239 0xfc000fff, 0x200007b5, 0 , 0,
17240 0x0 }, /* SHLL[_S].PH~*(1) */
17241 { instruction , 0 , 0 , 32,
17242 0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH , 0,
17243 DSP_ }, /* SHLL_S.PH */
17244 { reserved_block , 0 , 0 , 32,
17245 0xfc000fff, 0x20000fb5, 0 , 0,
17246 0x0 }, /* SHLL[_S].PH~*(3) */
17247 };
17248
17249
17250 NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
17251 { instruction , 0 , 0 , 32,
17252 0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W , 0,
17253 DSP_ }, /* PRECR_SRA.PH.W */
17254 { instruction , 0 , 0 , 32,
17255 0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
17256 DSP_ }, /* PRECR_SRA_R.PH.W */
17257 };
17258
17259
17260 NMD::Pool NMD::_POOL32A5[128] = {
17261 { instruction , 0 , 0 , 32,
17262 0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH , 0,
17263 DSP_ }, /* CMP.EQ.PH */
17264 { pool , ADDQ__S__PH , 2 , 32,
17265 0xfc0003ff, 0x2000000d, 0 , 0,
17266 0x0 }, /* ADDQ[_S].PH */
17267 { reserved_block , 0 , 0 , 32,
17268 0xfc0003ff, 0x20000015, 0 , 0,
17269 0x0 }, /* _POOL32A5~*(2) */
17270 { instruction , 0 , 0 , 32,
17271 0xfc0003ff, 0x2000001d, &NMD::SHILO , 0,
17272 DSP_ }, /* SHILO */
17273 { instruction , 0 , 0 , 32,
17274 0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL , 0,
17275 DSP_ }, /* MULEQ_S.W.PHL */
17276 { pool , MUL__S__PH , 2 , 32,
17277 0xfc0003ff, 0x2000002d, 0 , 0,
17278 0x0 }, /* MUL[_S].PH */
17279 { reserved_block , 0 , 0 , 32,
17280 0xfc0003ff, 0x20000035, 0 , 0,
17281 0x0 }, /* _POOL32A5~*(6) */
17282 { instruction , 0 , 0 , 32,
17283 0xfc0003ff, 0x2000003d, &NMD::REPL_PH , 0,
17284 DSP_ }, /* REPL.PH */
17285 { instruction , 0 , 0 , 32,
17286 0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH , 0,
17287 DSP_ }, /* CMP.LT.PH */
17288 { pool , ADDQH__R__PH , 2 , 32,
17289 0xfc0003ff, 0x2000004d, 0 , 0,
17290 0x0 }, /* ADDQH[_R].PH */
17291 { reserved_block , 0 , 0 , 32,
17292 0xfc0003ff, 0x20000055, 0 , 0,
17293 0x0 }, /* _POOL32A5~*(10) */
17294 { reserved_block , 0 , 0 , 32,
17295 0xfc0003ff, 0x2000005d, 0 , 0,
17296 0x0 }, /* _POOL32A5~*(11) */
17297 { instruction , 0 , 0 , 32,
17298 0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR , 0,
17299 DSP_ }, /* MULEQ_S.W.PHR */
17300 { instruction , 0 , 0 , 32,
17301 0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH , 0,
17302 DSP_ }, /* PRECR.QB.PH */
17303 { reserved_block , 0 , 0 , 32,
17304 0xfc0003ff, 0x20000075, 0 , 0,
17305 0x0 }, /* _POOL32A5~*(14) */
17306 { reserved_block , 0 , 0 , 32,
17307 0xfc0003ff, 0x2000007d, 0 , 0,
17308 0x0 }, /* _POOL32A5~*(15) */
17309 { instruction , 0 , 0 , 32,
17310 0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH , 0,
17311 DSP_ }, /* CMP.LE.PH */
17312 { pool , ADDQH__R__W , 2 , 32,
17313 0xfc0003ff, 0x2000008d, 0 , 0,
17314 0x0 }, /* ADDQH[_R].W */
17315 { instruction , 0 , 0 , 32,
17316 0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL , 0,
17317 DSP_ }, /* MULEU_S.PH.QBL */
17318 { reserved_block , 0 , 0 , 32,
17319 0xfc0003ff, 0x2000009d, 0 , 0,
17320 0x0 }, /* _POOL32A5~*(19) */
17321 { reserved_block , 0 , 0 , 32,
17322 0xfc0003ff, 0x200000a5, 0 , 0,
17323 0x0 }, /* _POOL32A5~*(20) */
17324 { instruction , 0 , 0 , 32,
17325 0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH , 0,
17326 DSP_ }, /* PRECRQ.QB.PH */
17327 { reserved_block , 0 , 0 , 32,
17328 0xfc0003ff, 0x200000b5, 0 , 0,
17329 0x0 }, /* _POOL32A5~*(22) */
17330 { reserved_block , 0 , 0 , 32,
17331 0xfc0003ff, 0x200000bd, 0 , 0,
17332 0x0 }, /* _POOL32A5~*(23) */
17333 { instruction , 0 , 0 , 32,
17334 0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB , 0,
17335 DSP_ }, /* CMPGU.EQ.QB */
17336 { pool , ADDU__S__QB , 2 , 32,
17337 0xfc0003ff, 0x200000cd, 0 , 0,
17338 0x0 }, /* ADDU[_S].QB */
17339 { instruction , 0 , 0 , 32,
17340 0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR , 0,
17341 DSP_ }, /* MULEU_S.PH.QBR */
17342 { reserved_block , 0 , 0 , 32,
17343 0xfc0003ff, 0x200000dd, 0 , 0,
17344 0x0 }, /* _POOL32A5~*(27) */
17345 { reserved_block , 0 , 0 , 32,
17346 0xfc0003ff, 0x200000e5, 0 , 0,
17347 0x0 }, /* _POOL32A5~*(28) */
17348 { instruction , 0 , 0 , 32,
17349 0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W , 0,
17350 DSP_ }, /* PRECRQ.PH.W */
17351 { reserved_block , 0 , 0 , 32,
17352 0xfc0003ff, 0x200000f5, 0 , 0,
17353 0x0 }, /* _POOL32A5~*(30) */
17354 { reserved_block , 0 , 0 , 32,
17355 0xfc0003ff, 0x200000fd, 0 , 0,
17356 0x0 }, /* _POOL32A5~*(31) */
17357 { instruction , 0 , 0 , 32,
17358 0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB , 0,
17359 DSP_ }, /* CMPGU.LT.QB */
17360 { pool , ADDU__S__PH , 2 , 32,
17361 0xfc0003ff, 0x2000010d, 0 , 0,
17362 0x0 }, /* ADDU[_S].PH */
17363 { instruction , 0 , 0 , 32,
17364 0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH , 0,
17365 DSP_ }, /* MULQ_RS.PH */
17366 { reserved_block , 0 , 0 , 32,
17367 0xfc0003ff, 0x2000011d, 0 , 0,
17368 0x0 }, /* _POOL32A5~*(35) */
17369 { reserved_block , 0 , 0 , 32,
17370 0xfc0003ff, 0x20000125, 0 , 0,
17371 0x0 }, /* _POOL32A5~*(36) */
17372 { instruction , 0 , 0 , 32,
17373 0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W , 0,
17374 DSP_ }, /* PRECRQ_RS.PH.W */
17375 { reserved_block , 0 , 0 , 32,
17376 0xfc0003ff, 0x20000135, 0 , 0,
17377 0x0 }, /* _POOL32A5~*(38) */
17378 { reserved_block , 0 , 0 , 32,
17379 0xfc0003ff, 0x2000013d, 0 , 0,
17380 0x0 }, /* _POOL32A5~*(39) */
17381 { instruction , 0 , 0 , 32,
17382 0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB , 0,
17383 DSP_ }, /* CMPGU.LE.QB */
17384 { pool , ADDUH__R__QB , 2 , 32,
17385 0xfc0003ff, 0x2000014d, 0 , 0,
17386 0x0 }, /* ADDUH[_R].QB */
17387 { instruction , 0 , 0 , 32,
17388 0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH , 0,
17389 DSP_ }, /* MULQ_S.PH */
17390 { reserved_block , 0 , 0 , 32,
17391 0xfc0003ff, 0x2000015d, 0 , 0,
17392 0x0 }, /* _POOL32A5~*(43) */
17393 { reserved_block , 0 , 0 , 32,
17394 0xfc0003ff, 0x20000165, 0 , 0,
17395 0x0 }, /* _POOL32A5~*(44) */
17396 { instruction , 0 , 0 , 32,
17397 0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH , 0,
17398 DSP_ }, /* PRECRQU_S.QB.PH */
17399 { reserved_block , 0 , 0 , 32,
17400 0xfc0003ff, 0x20000175, 0 , 0,
17401 0x0 }, /* _POOL32A5~*(46) */
17402 { reserved_block , 0 , 0 , 32,
17403 0xfc0003ff, 0x2000017d, 0 , 0,
17404 0x0 }, /* _POOL32A5~*(47) */
17405 { instruction , 0 , 0 , 32,
17406 0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB , 0,
17407 DSP_ }, /* CMPGDU.EQ.QB */
17408 { pool , SHRAV__R__PH , 2 , 32,
17409 0xfc0003ff, 0x2000018d, 0 , 0,
17410 0x0 }, /* SHRAV[_R].PH */
17411 { instruction , 0 , 0 , 32,
17412 0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W , 0,
17413 DSP_ }, /* MULQ_RS.W */
17414 { reserved_block , 0 , 0 , 32,
17415 0xfc0003ff, 0x2000019d, 0 , 0,
17416 0x0 }, /* _POOL32A5~*(51) */
17417 { reserved_block , 0 , 0 , 32,
17418 0xfc0003ff, 0x200001a5, 0 , 0,
17419 0x0 }, /* _POOL32A5~*(52) */
17420 { instruction , 0 , 0 , 32,
17421 0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH , 0,
17422 DSP_ }, /* PACKRL.PH */
17423 { reserved_block , 0 , 0 , 32,
17424 0xfc0003ff, 0x200001b5, 0 , 0,
17425 0x0 }, /* _POOL32A5~*(54) */
17426 { reserved_block , 0 , 0 , 32,
17427 0xfc0003ff, 0x200001bd, 0 , 0,
17428 0x0 }, /* _POOL32A5~*(55) */
17429 { instruction , 0 , 0 , 32,
17430 0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB , 0,
17431 DSP_ }, /* CMPGDU.LT.QB */
17432 { pool , SHRAV__R__QB , 2 , 32,
17433 0xfc0003ff, 0x200001cd, 0 , 0,
17434 0x0 }, /* SHRAV[_R].QB */
17435 { instruction , 0 , 0 , 32,
17436 0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W , 0,
17437 DSP_ }, /* MULQ_S.W */
17438 { reserved_block , 0 , 0 , 32,
17439 0xfc0003ff, 0x200001dd, 0 , 0,
17440 0x0 }, /* _POOL32A5~*(59) */
17441 { reserved_block , 0 , 0 , 32,
17442 0xfc0003ff, 0x200001e5, 0 , 0,
17443 0x0 }, /* _POOL32A5~*(60) */
17444 { instruction , 0 , 0 , 32,
17445 0xfc0003ff, 0x200001ed, &NMD::PICK_QB , 0,
17446 DSP_ }, /* PICK.QB */
17447 { reserved_block , 0 , 0 , 32,
17448 0xfc0003ff, 0x200001f5, 0 , 0,
17449 0x0 }, /* _POOL32A5~*(62) */
17450 { reserved_block , 0 , 0 , 32,
17451 0xfc0003ff, 0x200001fd, 0 , 0,
17452 0x0 }, /* _POOL32A5~*(63) */
17453 { instruction , 0 , 0 , 32,
17454 0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB , 0,
17455 DSP_ }, /* CMPGDU.LE.QB */
17456 { pool , SUBQ__S__PH , 2 , 32,
17457 0xfc0003ff, 0x2000020d, 0 , 0,
17458 0x0 }, /* SUBQ[_S].PH */
17459 { instruction , 0 , 0 , 32,
17460 0xfc0003ff, 0x20000215, &NMD::APPEND , 0,
17461 DSP_ }, /* APPEND */
17462 { reserved_block , 0 , 0 , 32,
17463 0xfc0003ff, 0x2000021d, 0 , 0,
17464 0x0 }, /* _POOL32A5~*(67) */
17465 { reserved_block , 0 , 0 , 32,
17466 0xfc0003ff, 0x20000225, 0 , 0,
17467 0x0 }, /* _POOL32A5~*(68) */
17468 { instruction , 0 , 0 , 32,
17469 0xfc0003ff, 0x2000022d, &NMD::PICK_PH , 0,
17470 DSP_ }, /* PICK.PH */
17471 { reserved_block , 0 , 0 , 32,
17472 0xfc0003ff, 0x20000235, 0 , 0,
17473 0x0 }, /* _POOL32A5~*(70) */
17474 { reserved_block , 0 , 0 , 32,
17475 0xfc0003ff, 0x2000023d, 0 , 0,
17476 0x0 }, /* _POOL32A5~*(71) */
17477 { instruction , 0 , 0 , 32,
17478 0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB , 0,
17479 DSP_ }, /* CMPU.EQ.QB */
17480 { pool , SUBQH__R__PH , 2 , 32,
17481 0xfc0003ff, 0x2000024d, 0 , 0,
17482 0x0 }, /* SUBQH[_R].PH */
17483 { instruction , 0 , 0 , 32,
17484 0xfc0003ff, 0x20000255, &NMD::PREPEND , 0,
17485 DSP_ }, /* PREPEND */
17486 { reserved_block , 0 , 0 , 32,
17487 0xfc0003ff, 0x2000025d, 0 , 0,
17488 0x0 }, /* _POOL32A5~*(75) */
17489 { reserved_block , 0 , 0 , 32,
17490 0xfc0003ff, 0x20000265, 0 , 0,
17491 0x0 }, /* _POOL32A5~*(76) */
17492 { reserved_block , 0 , 0 , 32,
17493 0xfc0003ff, 0x2000026d, 0 , 0,
17494 0x0 }, /* _POOL32A5~*(77) */
17495 { reserved_block , 0 , 0 , 32,
17496 0xfc0003ff, 0x20000275, 0 , 0,
17497 0x0 }, /* _POOL32A5~*(78) */
17498 { reserved_block , 0 , 0 , 32,
17499 0xfc0003ff, 0x2000027d, 0 , 0,
17500 0x0 }, /* _POOL32A5~*(79) */
17501 { instruction , 0 , 0 , 32,
17502 0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB , 0,
17503 DSP_ }, /* CMPU.LT.QB */
17504 { pool , SUBQH__R__W , 2 , 32,
17505 0xfc0003ff, 0x2000028d, 0 , 0,
17506 0x0 }, /* SUBQH[_R].W */
17507 { instruction , 0 , 0 , 32,
17508 0xfc0003ff, 0x20000295, &NMD::MODSUB , 0,
17509 DSP_ }, /* MODSUB */
17510 { reserved_block , 0 , 0 , 32,
17511 0xfc0003ff, 0x2000029d, 0 , 0,
17512 0x0 }, /* _POOL32A5~*(83) */
17513 { reserved_block , 0 , 0 , 32,
17514 0xfc0003ff, 0x200002a5, 0 , 0,
17515 0x0 }, /* _POOL32A5~*(84) */
17516 { reserved_block , 0 , 0 , 32,
17517 0xfc0003ff, 0x200002ad, 0 , 0,
17518 0x0 }, /* _POOL32A5~*(85) */
17519 { reserved_block , 0 , 0 , 32,
17520 0xfc0003ff, 0x200002b5, 0 , 0,
17521 0x0 }, /* _POOL32A5~*(86) */
17522 { reserved_block , 0 , 0 , 32,
17523 0xfc0003ff, 0x200002bd, 0 , 0,
17524 0x0 }, /* _POOL32A5~*(87) */
17525 { instruction , 0 , 0 , 32,
17526 0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB , 0,
17527 DSP_ }, /* CMPU.LE.QB */
17528 { pool , SUBU__S__QB , 2 , 32,
17529 0xfc0003ff, 0x200002cd, 0 , 0,
17530 0x0 }, /* SUBU[_S].QB */
17531 { instruction , 0 , 0 , 32,
17532 0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W , 0,
17533 DSP_ }, /* SHRAV_R.W */
17534 { reserved_block , 0 , 0 , 32,
17535 0xfc0003ff, 0x200002dd, 0 , 0,
17536 0x0 }, /* _POOL32A5~*(91) */
17537 { reserved_block , 0 , 0 , 32,
17538 0xfc0003ff, 0x200002e5, 0 , 0,
17539 0x0 }, /* _POOL32A5~*(92) */
17540 { reserved_block , 0 , 0 , 32,
17541 0xfc0003ff, 0x200002ed, 0 , 0,
17542 0x0 }, /* _POOL32A5~*(93) */
17543 { instruction , 0 , 0 , 32,
17544 0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W , 0,
17545 DSP_ }, /* SHRA_R.W */
17546 { reserved_block , 0 , 0 , 32,
17547 0xfc0003ff, 0x200002fd, 0 , 0,
17548 0x0 }, /* _POOL32A5~*(95) */
17549 { instruction , 0 , 0 , 32,
17550 0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W , 0,
17551 DSP_ }, /* ADDQ_S.W */
17552 { pool , SUBU__S__PH , 2 , 32,
17553 0xfc0003ff, 0x2000030d, 0 , 0,
17554 0x0 }, /* SUBU[_S].PH */
17555 { instruction , 0 , 0 , 32,
17556 0xfc0003ff, 0x20000315, &NMD::SHRLV_PH , 0,
17557 DSP_ }, /* SHRLV.PH */
17558 { reserved_block , 0 , 0 , 32,
17559 0xfc0003ff, 0x2000031d, 0 , 0,
17560 0x0 }, /* _POOL32A5~*(99) */
17561 { reserved_block , 0 , 0 , 32,
17562 0xfc0003ff, 0x20000325, 0 , 0,
17563 0x0 }, /* _POOL32A5~*(100) */
17564 { reserved_block , 0 , 0 , 32,
17565 0xfc0003ff, 0x2000032d, 0 , 0,
17566 0x0 }, /* _POOL32A5~*(101) */
17567 { pool , SHRA__R__PH , 2 , 32,
17568 0xfc0003ff, 0x20000335, 0 , 0,
17569 0x0 }, /* SHRA[_R].PH */
17570 { reserved_block , 0 , 0 , 32,
17571 0xfc0003ff, 0x2000033d, 0 , 0,
17572 0x0 }, /* _POOL32A5~*(103) */
17573 { instruction , 0 , 0 , 32,
17574 0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W , 0,
17575 DSP_ }, /* SUBQ_S.W */
17576 { pool , SUBUH__R__QB , 2 , 32,
17577 0xfc0003ff, 0x2000034d, 0 , 0,
17578 0x0 }, /* SUBUH[_R].QB */
17579 { instruction , 0 , 0 , 32,
17580 0xfc0003ff, 0x20000355, &NMD::SHRLV_QB , 0,
17581 DSP_ }, /* SHRLV.QB */
17582 { reserved_block , 0 , 0 , 32,
17583 0xfc0003ff, 0x2000035d, 0 , 0,
17584 0x0 }, /* _POOL32A5~*(107) */
17585 { reserved_block , 0 , 0 , 32,
17586 0xfc0003ff, 0x20000365, 0 , 0,
17587 0x0 }, /* _POOL32A5~*(108) */
17588 { reserved_block , 0 , 0 , 32,
17589 0xfc0003ff, 0x2000036d, 0 , 0,
17590 0x0 }, /* _POOL32A5~*(109) */
17591 { reserved_block , 0 , 0 , 32,
17592 0xfc0003ff, 0x20000375, 0 , 0,
17593 0x0 }, /* _POOL32A5~*(110) */
17594 { reserved_block , 0 , 0 , 32,
17595 0xfc0003ff, 0x2000037d, 0 , 0,
17596 0x0 }, /* _POOL32A5~*(111) */
17597 { instruction , 0 , 0 , 32,
17598 0xfc0003ff, 0x20000385, &NMD::ADDSC , 0,
17599 DSP_ }, /* ADDSC */
17600 { pool , SHLLV__S__PH , 2 , 32,
17601 0xfc0003ff, 0x2000038d, 0 , 0,
17602 0x0 }, /* SHLLV[_S].PH */
17603 { instruction , 0 , 0 , 32,
17604 0xfc0003ff, 0x20000395, &NMD::SHLLV_QB , 0,
17605 DSP_ }, /* SHLLV.QB */
17606 { reserved_block , 0 , 0 , 32,
17607 0xfc0003ff, 0x2000039d, 0 , 0,
17608 0x0 }, /* _POOL32A5~*(115) */
17609 { reserved_block , 0 , 0 , 32,
17610 0xfc0003ff, 0x200003a5, 0 , 0,
17611 0x0 }, /* _POOL32A5~*(116) */
17612 { reserved_block , 0 , 0 , 32,
17613 0xfc0003ff, 0x200003ad, 0 , 0,
17614 0x0 }, /* _POOL32A5~*(117) */
17615 { pool , SHLL__S__PH , 4 , 32,
17616 0xfc0003ff, 0x200003b5, 0 , 0,
17617 0x0 }, /* SHLL[_S].PH */
17618 { reserved_block , 0 , 0 , 32,
17619 0xfc0003ff, 0x200003bd, 0 , 0,
17620 0x0 }, /* _POOL32A5~*(119) */
17621 { instruction , 0 , 0 , 32,
17622 0xfc0003ff, 0x200003c5, &NMD::ADDWC , 0,
17623 DSP_ }, /* ADDWC */
17624 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17625 0xfc0003ff, 0x200003cd, 0 , 0,
17626 0x0 }, /* PRECR_SRA[_R].PH.W */
17627 { instruction , 0 , 0 , 32,
17628 0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W , 0,
17629 DSP_ }, /* SHLLV_S.W */
17630 { reserved_block , 0 , 0 , 32,
17631 0xfc0003ff, 0x200003dd, 0 , 0,
17632 0x0 }, /* _POOL32A5~*(123) */
17633 { reserved_block , 0 , 0 , 32,
17634 0xfc0003ff, 0x200003e5, 0 , 0,
17635 0x0 }, /* _POOL32A5~*(124) */
17636 { reserved_block , 0 , 0 , 32,
17637 0xfc0003ff, 0x200003ed, 0 , 0,
17638 0x0 }, /* _POOL32A5~*(125) */
17639 { instruction , 0 , 0 , 32,
17640 0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W , 0,
17641 DSP_ }, /* SHLL_S.W */
17642 { reserved_block , 0 , 0 , 32,
17643 0xfc0003ff, 0x200003fd, 0 , 0,
17644 0x0 }, /* _POOL32A5~*(127) */
17645 };
17646
17647
17648 NMD::Pool NMD::PP_LSX[16] = {
17649 { instruction , 0 , 0 , 32,
17650 0xfc0007ff, 0x20000007, &NMD::LBX , 0,
17651 0x0 }, /* LBX */
17652 { instruction , 0 , 0 , 32,
17653 0xfc0007ff, 0x20000087, &NMD::SBX , 0,
17654 XMMS_ }, /* SBX */
17655 { instruction , 0 , 0 , 32,
17656 0xfc0007ff, 0x20000107, &NMD::LBUX , 0,
17657 0x0 }, /* LBUX */
17658 { reserved_block , 0 , 0 , 32,
17659 0xfc0007ff, 0x20000187, 0 , 0,
17660 0x0 }, /* PP.LSX~*(3) */
17661 { instruction , 0 , 0 , 32,
17662 0xfc0007ff, 0x20000207, &NMD::LHX , 0,
17663 0x0 }, /* LHX */
17664 { instruction , 0 , 0 , 32,
17665 0xfc0007ff, 0x20000287, &NMD::SHX , 0,
17666 XMMS_ }, /* SHX */
17667 { instruction , 0 , 0 , 32,
17668 0xfc0007ff, 0x20000307, &NMD::LHUX , 0,
17669 0x0 }, /* LHUX */
17670 { instruction , 0 , 0 , 32,
17671 0xfc0007ff, 0x20000387, &NMD::LWUX , 0,
17672 MIPS64_ }, /* LWUX */
17673 { instruction , 0 , 0 , 32,
17674 0xfc0007ff, 0x20000407, &NMD::LWX , 0,
17675 0x0 }, /* LWX */
17676 { instruction , 0 , 0 , 32,
17677 0xfc0007ff, 0x20000487, &NMD::SWX , 0,
17678 XMMS_ }, /* SWX */
17679 { instruction , 0 , 0 , 32,
17680 0xfc0007ff, 0x20000507, &NMD::LWC1X , 0,
17681 CP1_ }, /* LWC1X */
17682 { instruction , 0 , 0 , 32,
17683 0xfc0007ff, 0x20000587, &NMD::SWC1X , 0,
17684 CP1_ }, /* SWC1X */
17685 { instruction , 0 , 0 , 32,
17686 0xfc0007ff, 0x20000607, &NMD::LDX , 0,
17687 MIPS64_ }, /* LDX */
17688 { instruction , 0 , 0 , 32,
17689 0xfc0007ff, 0x20000687, &NMD::SDX , 0,
17690 MIPS64_ }, /* SDX */
17691 { instruction , 0 , 0 , 32,
17692 0xfc0007ff, 0x20000707, &NMD::LDC1X , 0,
17693 CP1_ }, /* LDC1X */
17694 { instruction , 0 , 0 , 32,
17695 0xfc0007ff, 0x20000787, &NMD::SDC1X , 0,
17696 CP1_ }, /* SDC1X */
17697 };
17698
17699
17700 NMD::Pool NMD::PP_LSXS[16] = {
17701 { reserved_block , 0 , 0 , 32,
17702 0xfc0007ff, 0x20000047, 0 , 0,
17703 0x0 }, /* PP.LSXS~*(0) */
17704 { reserved_block , 0 , 0 , 32,
17705 0xfc0007ff, 0x200000c7, 0 , 0,
17706 0x0 }, /* PP.LSXS~*(1) */
17707 { reserved_block , 0 , 0 , 32,
17708 0xfc0007ff, 0x20000147, 0 , 0,
17709 0x0 }, /* PP.LSXS~*(2) */
17710 { reserved_block , 0 , 0 , 32,
17711 0xfc0007ff, 0x200001c7, 0 , 0,
17712 0x0 }, /* PP.LSXS~*(3) */
17713 { instruction , 0 , 0 , 32,
17714 0xfc0007ff, 0x20000247, &NMD::LHXS , 0,
17715 0x0 }, /* LHXS */
17716 { instruction , 0 , 0 , 32,
17717 0xfc0007ff, 0x200002c7, &NMD::SHXS , 0,
17718 XMMS_ }, /* SHXS */
17719 { instruction , 0 , 0 , 32,
17720 0xfc0007ff, 0x20000347, &NMD::LHUXS , 0,
17721 0x0 }, /* LHUXS */
17722 { instruction , 0 , 0 , 32,
17723 0xfc0007ff, 0x200003c7, &NMD::LWUXS , 0,
17724 MIPS64_ }, /* LWUXS */
17725 { instruction , 0 , 0 , 32,
17726 0xfc0007ff, 0x20000447, &NMD::LWXS_32_ , 0,
17727 0x0 }, /* LWXS[32] */
17728 { instruction , 0 , 0 , 32,
17729 0xfc0007ff, 0x200004c7, &NMD::SWXS , 0,
17730 XMMS_ }, /* SWXS */
17731 { instruction , 0 , 0 , 32,
17732 0xfc0007ff, 0x20000547, &NMD::LWC1XS , 0,
17733 CP1_ }, /* LWC1XS */
17734 { instruction , 0 , 0 , 32,
17735 0xfc0007ff, 0x200005c7, &NMD::SWC1XS , 0,
17736 CP1_ }, /* SWC1XS */
17737 { instruction , 0 , 0 , 32,
17738 0xfc0007ff, 0x20000647, &NMD::LDXS , 0,
17739 MIPS64_ }, /* LDXS */
17740 { instruction , 0 , 0 , 32,
17741 0xfc0007ff, 0x200006c7, &NMD::SDXS , 0,
17742 MIPS64_ }, /* SDXS */
17743 { instruction , 0 , 0 , 32,
17744 0xfc0007ff, 0x20000747, &NMD::LDC1XS , 0,
17745 CP1_ }, /* LDC1XS */
17746 { instruction , 0 , 0 , 32,
17747 0xfc0007ff, 0x200007c7, &NMD::SDC1XS , 0,
17748 CP1_ }, /* SDC1XS */
17749 };
17750
17751
17752 NMD::Pool NMD::P_LSX[2] = {
17753 { pool , PP_LSX , 16 , 32,
17754 0xfc00007f, 0x20000007, 0 , 0,
17755 0x0 }, /* PP.LSX */
17756 { pool , PP_LSXS , 16 , 32,
17757 0xfc00007f, 0x20000047, 0 , 0,
17758 0x0 }, /* PP.LSXS */
17759 };
17760
17761
17762 NMD::Pool NMD::POOL32Axf_1_0[4] = {
17763 { instruction , 0 , 0 , 32,
17764 0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_ , 0,
17765 DSP_ }, /* MFHI[DSP] */
17766 { instruction , 0 , 0 , 32,
17767 0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_ , 0,
17768 DSP_ }, /* MFLO[DSP] */
17769 { instruction , 0 , 0 , 32,
17770 0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_ , 0,
17771 DSP_ }, /* MTHI[DSP] */
17772 { instruction , 0 , 0 , 32,
17773 0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_ , 0,
17774 DSP_ }, /* MTLO[DSP] */
17775 };
17776
17777
17778 NMD::Pool NMD::POOL32Axf_1_1[4] = {
17779 { instruction , 0 , 0 , 32,
17780 0xfc003fff, 0x2000027f, &NMD::MTHLIP , 0,
17781 DSP_ }, /* MTHLIP */
17782 { instruction , 0 , 0 , 32,
17783 0xfc003fff, 0x2000127f, &NMD::SHILOV , 0,
17784 DSP_ }, /* SHILOV */
17785 { reserved_block , 0 , 0 , 32,
17786 0xfc003fff, 0x2000227f, 0 , 0,
17787 0x0 }, /* POOL32Axf_1_1~*(2) */
17788 { reserved_block , 0 , 0 , 32,
17789 0xfc003fff, 0x2000327f, 0 , 0,
17790 0x0 }, /* POOL32Axf_1_1~*(3) */
17791 };
17792
17793
17794 NMD::Pool NMD::POOL32Axf_1_3[4] = {
17795 { instruction , 0 , 0 , 32,
17796 0xfc003fff, 0x2000067f, &NMD::RDDSP , 0,
17797 DSP_ }, /* RDDSP */
17798 { instruction , 0 , 0 , 32,
17799 0xfc003fff, 0x2000167f, &NMD::WRDSP , 0,
17800 DSP_ }, /* WRDSP */
17801 { instruction , 0 , 0 , 32,
17802 0xfc003fff, 0x2000267f, &NMD::EXTP , 0,
17803 DSP_ }, /* EXTP */
17804 { instruction , 0 , 0 , 32,
17805 0xfc003fff, 0x2000367f, &NMD::EXTPDP , 0,
17806 DSP_ }, /* EXTPDP */
17807 };
17808
17809
17810 NMD::Pool NMD::POOL32Axf_1_4[2] = {
17811 { instruction , 0 , 0 , 32,
17812 0xfc001fff, 0x2000087f, &NMD::SHLL_QB , 0,
17813 DSP_ }, /* SHLL.QB */
17814 { instruction , 0 , 0 , 32,
17815 0xfc001fff, 0x2000187f, &NMD::SHRL_QB , 0,
17816 DSP_ }, /* SHRL.QB */
17817 };
17818
17819
17820 NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
17821 { instruction , 0 , 0 , 32,
17822 0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR , 0,
17823 DSP_ }, /* MAQ_S.W.PHR */
17824 { instruction , 0 , 0 , 32,
17825 0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR , 0,
17826 DSP_ }, /* MAQ_SA.W.PHR */
17827 };
17828
17829
17830 NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
17831 { instruction , 0 , 0 , 32,
17832 0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL , 0,
17833 DSP_ }, /* MAQ_S.W.PHL */
17834 { instruction , 0 , 0 , 32,
17835 0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL , 0,
17836 DSP_ }, /* MAQ_SA.W.PHL */
17837 };
17838
17839
17840 NMD::Pool NMD::POOL32Axf_1_5[2] = {
17841 { pool , MAQ_S_A__W_PHR , 2 , 32,
17842 0xfc001fff, 0x20000a7f, 0 , 0,
17843 0x0 }, /* MAQ_S[A].W.PHR */
17844 { pool , MAQ_S_A__W_PHL , 2 , 32,
17845 0xfc001fff, 0x20001a7f, 0 , 0,
17846 0x0 }, /* MAQ_S[A].W.PHL */
17847 };
17848
17849
17850 NMD::Pool NMD::POOL32Axf_1_7[4] = {
17851 { instruction , 0 , 0 , 32,
17852 0xfc003fff, 0x20000e7f, &NMD::EXTR_W , 0,
17853 DSP_ }, /* EXTR.W */
17854 { instruction , 0 , 0 , 32,
17855 0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W , 0,
17856 DSP_ }, /* EXTR_R.W */
17857 { instruction , 0 , 0 , 32,
17858 0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W , 0,
17859 DSP_ }, /* EXTR_RS.W */
17860 { instruction , 0 , 0 , 32,
17861 0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H , 0,
17862 DSP_ }, /* EXTR_S.H */
17863 };
17864
17865
17866 NMD::Pool NMD::POOL32Axf_1[8] = {
17867 { pool , POOL32Axf_1_0 , 4 , 32,
17868 0xfc000fff, 0x2000007f, 0 , 0,
17869 0x0 }, /* POOL32Axf_1_0 */
17870 { pool , POOL32Axf_1_1 , 4 , 32,
17871 0xfc000fff, 0x2000027f, 0 , 0,
17872 0x0 }, /* POOL32Axf_1_1 */
17873 { reserved_block , 0 , 0 , 32,
17874 0xfc000fff, 0x2000047f, 0 , 0,
17875 0x0 }, /* POOL32Axf_1~*(2) */
17876 { pool , POOL32Axf_1_3 , 4 , 32,
17877 0xfc000fff, 0x2000067f, 0 , 0,
17878 0x0 }, /* POOL32Axf_1_3 */
17879 { pool , POOL32Axf_1_4 , 2 , 32,
17880 0xfc000fff, 0x2000087f, 0 , 0,
17881 0x0 }, /* POOL32Axf_1_4 */
17882 { pool , POOL32Axf_1_5 , 2 , 32,
17883 0xfc000fff, 0x20000a7f, 0 , 0,
17884 0x0 }, /* POOL32Axf_1_5 */
17885 { reserved_block , 0 , 0 , 32,
17886 0xfc000fff, 0x20000c7f, 0 , 0,
17887 0x0 }, /* POOL32Axf_1~*(6) */
17888 { pool , POOL32Axf_1_7 , 4 , 32,
17889 0xfc000fff, 0x20000e7f, 0 , 0,
17890 0x0 }, /* POOL32Axf_1_7 */
17891 };
17892
17893
17894 NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
17895 { instruction , 0 , 0 , 32,
17896 0xfc003fff, 0x200000bf, &NMD::DPA_W_PH , 0,
17897 DSP_ }, /* DPA.W.PH */
17898 { instruction , 0 , 0 , 32,
17899 0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH , 0,
17900 DSP_ }, /* DPAQ_S.W.PH */
17901 { instruction , 0 , 0 , 32,
17902 0xfc003fff, 0x200004bf, &NMD::DPS_W_PH , 0,
17903 DSP_ }, /* DPS.W.PH */
17904 { instruction , 0 , 0 , 32,
17905 0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH , 0,
17906 DSP_ }, /* DPSQ_S.W.PH */
17907 { reserved_block , 0 , 0 , 32,
17908 0xfc003fff, 0x200008bf, 0 , 0,
17909 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17910 { instruction , 0 , 0 , 32,
17911 0xfc003fff, 0x20000abf, &NMD::MADD_DSP_ , 0,
17912 DSP_ }, /* MADD[DSP] */
17913 { instruction , 0 , 0 , 32,
17914 0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_ , 0,
17915 DSP_ }, /* MULT[DSP] */
17916 { instruction , 0 , 0 , 32,
17917 0xfc003fff, 0x20000ebf, &NMD::EXTRV_W , 0,
17918 DSP_ }, /* EXTRV.W */
17919 };
17920
17921
17922 NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
17923 { instruction , 0 , 0 , 32,
17924 0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH , 0,
17925 DSP_ }, /* DPAX.W.PH */
17926 { instruction , 0 , 0 , 32,
17927 0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W , 0,
17928 DSP_ }, /* DPAQ_SA.L.W */
17929 { instruction , 0 , 0 , 32,
17930 0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH , 0,
17931 DSP_ }, /* DPSX.W.PH */
17932 { instruction , 0 , 0 , 32,
17933 0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W , 0,
17934 DSP_ }, /* DPSQ_SA.L.W */
17935 { reserved_block , 0 , 0 , 32,
17936 0xfc003fff, 0x200018bf, 0 , 0,
17937 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17938 { instruction , 0 , 0 , 32,
17939 0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_ , 0,
17940 DSP_ }, /* MADDU[DSP] */
17941 { instruction , 0 , 0 , 32,
17942 0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_ , 0,
17943 DSP_ }, /* MULTU[DSP] */
17944 { instruction , 0 , 0 , 32,
17945 0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W , 0,
17946 DSP_ }, /* EXTRV_R.W */
17947 };
17948
17949
17950 NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
17951 { instruction , 0 , 0 , 32,
17952 0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL , 0,
17953 DSP_ }, /* DPAU.H.QBL */
17954 { instruction , 0 , 0 , 32,
17955 0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH , 0,
17956 DSP_ }, /* DPAQX_S.W.PH */
17957 { instruction , 0 , 0 , 32,
17958 0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL , 0,
17959 DSP_ }, /* DPSU.H.QBL */
17960 { instruction , 0 , 0 , 32,
17961 0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH , 0,
17962 DSP_ }, /* DPSQX_S.W.PH */
17963 { instruction , 0 , 0 , 32,
17964 0xfc003fff, 0x200028bf, &NMD::EXTPV , 0,
17965 DSP_ }, /* EXTPV */
17966 { instruction , 0 , 0 , 32,
17967 0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_ , 0,
17968 DSP_ }, /* MSUB[DSP] */
17969 { instruction , 0 , 0 , 32,
17970 0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH , 0,
17971 DSP_ }, /* MULSA.W.PH */
17972 { instruction , 0 , 0 , 32,
17973 0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W , 0,
17974 DSP_ }, /* EXTRV_RS.W */
17975 };
17976
17977
17978 NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
17979 { instruction , 0 , 0 , 32,
17980 0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR , 0,
17981 DSP_ }, /* DPAU.H.QBR */
17982 { instruction , 0 , 0 , 32,
17983 0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH , 0,
17984 DSP_ }, /* DPAQX_SA.W.PH */
17985 { instruction , 0 , 0 , 32,
17986 0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR , 0,
17987 DSP_ }, /* DPSU.H.QBR */
17988 { instruction , 0 , 0 , 32,
17989 0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH , 0,
17990 DSP_ }, /* DPSQX_SA.W.PH */
17991 { instruction , 0 , 0 , 32,
17992 0xfc003fff, 0x200038bf, &NMD::EXTPDPV , 0,
17993 DSP_ }, /* EXTPDPV */
17994 { instruction , 0 , 0 , 32,
17995 0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_ , 0,
17996 DSP_ }, /* MSUBU[DSP] */
17997 { instruction , 0 , 0 , 32,
17998 0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH , 0,
17999 DSP_ }, /* MULSAQ_S.W.PH */
18000 { instruction , 0 , 0 , 32,
18001 0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H , 0,
18002 DSP_ }, /* EXTRV_S.H */
18003 };
18004
18005
18006 NMD::Pool NMD::POOL32Axf_2[4] = {
18007 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
18008 0xfc0031ff, 0x200000bf, 0 , 0,
18009 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
18010 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
18011 0xfc0031ff, 0x200010bf, 0 , 0,
18012 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
18013 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
18014 0xfc0031ff, 0x200020bf, 0 , 0,
18015 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
18016 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
18017 0xfc0031ff, 0x200030bf, 0 , 0,
18018 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
18019 };
18020
18021
18022 NMD::Pool NMD::POOL32Axf_4[128] = {
18023 { instruction , 0 , 0 , 32,
18024 0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB , 0,
18025 DSP_ }, /* ABSQ_S.QB */
18026 { instruction , 0 , 0 , 32,
18027 0xfc00ffff, 0x2000033f, &NMD::REPLV_PH , 0,
18028 DSP_ }, /* REPLV.PH */
18029 { reserved_block , 0 , 0 , 32,
18030 0xfc00ffff, 0x2000053f, 0 , 0,
18031 0x0 }, /* POOL32Axf_4~*(2) */
18032 { reserved_block , 0 , 0 , 32,
18033 0xfc00ffff, 0x2000073f, 0 , 0,
18034 0x0 }, /* POOL32Axf_4~*(3) */
18035 { reserved_block , 0 , 0 , 32,
18036 0xfc00ffff, 0x2000093f, 0 , 0,
18037 0x0 }, /* POOL32Axf_4~*(4) */
18038 { reserved_block , 0 , 0 , 32,
18039 0xfc00ffff, 0x20000b3f, 0 , 0,
18040 0x0 }, /* POOL32Axf_4~*(5) */
18041 { reserved_block , 0 , 0 , 32,
18042 0xfc00ffff, 0x20000d3f, 0 , 0,
18043 0x0 }, /* POOL32Axf_4~*(6) */
18044 { reserved_block , 0 , 0 , 32,
18045 0xfc00ffff, 0x20000f3f, 0 , 0,
18046 0x0 }, /* POOL32Axf_4~*(7) */
18047 { instruction , 0 , 0 , 32,
18048 0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH , 0,
18049 DSP_ }, /* ABSQ_S.PH */
18050 { instruction , 0 , 0 , 32,
18051 0xfc00ffff, 0x2000133f, &NMD::REPLV_QB , 0,
18052 DSP_ }, /* REPLV.QB */
18053 { reserved_block , 0 , 0 , 32,
18054 0xfc00ffff, 0x2000153f, 0 , 0,
18055 0x0 }, /* POOL32Axf_4~*(10) */
18056 { reserved_block , 0 , 0 , 32,
18057 0xfc00ffff, 0x2000173f, 0 , 0,
18058 0x0 }, /* POOL32Axf_4~*(11) */
18059 { reserved_block , 0 , 0 , 32,
18060 0xfc00ffff, 0x2000193f, 0 , 0,
18061 0x0 }, /* POOL32Axf_4~*(12) */
18062 { reserved_block , 0 , 0 , 32,
18063 0xfc00ffff, 0x20001b3f, 0 , 0,
18064 0x0 }, /* POOL32Axf_4~*(13) */
18065 { reserved_block , 0 , 0 , 32,
18066 0xfc00ffff, 0x20001d3f, 0 , 0,
18067 0x0 }, /* POOL32Axf_4~*(14) */
18068 { reserved_block , 0 , 0 , 32,
18069 0xfc00ffff, 0x20001f3f, 0 , 0,
18070 0x0 }, /* POOL32Axf_4~*(15) */
18071 { instruction , 0 , 0 , 32,
18072 0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W , 0,
18073 DSP_ }, /* ABSQ_S.W */
18074 { reserved_block , 0 , 0 , 32,
18075 0xfc00ffff, 0x2000233f, 0 , 0,
18076 0x0 }, /* POOL32Axf_4~*(17) */
18077 { reserved_block , 0 , 0 , 32,
18078 0xfc00ffff, 0x2000253f, 0 , 0,
18079 0x0 }, /* POOL32Axf_4~*(18) */
18080 { reserved_block , 0 , 0 , 32,
18081 0xfc00ffff, 0x2000273f, 0 , 0,
18082 0x0 }, /* POOL32Axf_4~*(19) */
18083 { reserved_block , 0 , 0 , 32,
18084 0xfc00ffff, 0x2000293f, 0 , 0,
18085 0x0 }, /* POOL32Axf_4~*(20) */
18086 { reserved_block , 0 , 0 , 32,
18087 0xfc00ffff, 0x20002b3f, 0 , 0,
18088 0x0 }, /* POOL32Axf_4~*(21) */
18089 { reserved_block , 0 , 0 , 32,
18090 0xfc00ffff, 0x20002d3f, 0 , 0,
18091 0x0 }, /* POOL32Axf_4~*(22) */
18092 { reserved_block , 0 , 0 , 32,
18093 0xfc00ffff, 0x20002f3f, 0 , 0,
18094 0x0 }, /* POOL32Axf_4~*(23) */
18095 { reserved_block , 0 , 0 , 32,
18096 0xfc00ffff, 0x2000313f, 0 , 0,
18097 0x0 }, /* POOL32Axf_4~*(24) */
18098 { reserved_block , 0 , 0 , 32,
18099 0xfc00ffff, 0x2000333f, 0 , 0,
18100 0x0 }, /* POOL32Axf_4~*(25) */
18101 { reserved_block , 0 , 0 , 32,
18102 0xfc00ffff, 0x2000353f, 0 , 0,
18103 0x0 }, /* POOL32Axf_4~*(26) */
18104 { reserved_block , 0 , 0 , 32,
18105 0xfc00ffff, 0x2000373f, 0 , 0,
18106 0x0 }, /* POOL32Axf_4~*(27) */
18107 { reserved_block , 0 , 0 , 32,
18108 0xfc00ffff, 0x2000393f, 0 , 0,
18109 0x0 }, /* POOL32Axf_4~*(28) */
18110 { reserved_block , 0 , 0 , 32,
18111 0xfc00ffff, 0x20003b3f, 0 , 0,
18112 0x0 }, /* POOL32Axf_4~*(29) */
18113 { reserved_block , 0 , 0 , 32,
18114 0xfc00ffff, 0x20003d3f, 0 , 0,
18115 0x0 }, /* POOL32Axf_4~*(30) */
18116 { reserved_block , 0 , 0 , 32,
18117 0xfc00ffff, 0x20003f3f, 0 , 0,
18118 0x0 }, /* POOL32Axf_4~*(31) */
18119 { instruction , 0 , 0 , 32,
18120 0xfc00ffff, 0x2000413f, &NMD::INSV , 0,
18121 DSP_ }, /* INSV */
18122 { reserved_block , 0 , 0 , 32,
18123 0xfc00ffff, 0x2000433f, 0 , 0,
18124 0x0 }, /* POOL32Axf_4~*(33) */
18125 { reserved_block , 0 , 0 , 32,
18126 0xfc00ffff, 0x2000453f, 0 , 0,
18127 0x0 }, /* POOL32Axf_4~*(34) */
18128 { reserved_block , 0 , 0 , 32,
18129 0xfc00ffff, 0x2000473f, 0 , 0,
18130 0x0 }, /* POOL32Axf_4~*(35) */
18131 { reserved_block , 0 , 0 , 32,
18132 0xfc00ffff, 0x2000493f, 0 , 0,
18133 0x0 }, /* POOL32Axf_4~*(36) */
18134 { instruction , 0 , 0 , 32,
18135 0xfc00ffff, 0x20004b3f, &NMD::CLO , 0,
18136 XMMS_ }, /* CLO */
18137 { instruction , 0 , 0 , 32,
18138 0xfc00ffff, 0x20004d3f, &NMD::MFC2 , 0,
18139 CP2_ }, /* MFC2 */
18140 { reserved_block , 0 , 0 , 32,
18141 0xfc00ffff, 0x20004f3f, 0 , 0,
18142 0x0 }, /* POOL32Axf_4~*(39) */
18143 { instruction , 0 , 0 , 32,
18144 0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL , 0,
18145 DSP_ }, /* PRECEQ.W.PHL */
18146 { reserved_block , 0 , 0 , 32,
18147 0xfc00ffff, 0x2000533f, 0 , 0,
18148 0x0 }, /* POOL32Axf_4~*(41) */
18149 { reserved_block , 0 , 0 , 32,
18150 0xfc00ffff, 0x2000553f, 0 , 0,
18151 0x0 }, /* POOL32Axf_4~*(42) */
18152 { reserved_block , 0 , 0 , 32,
18153 0xfc00ffff, 0x2000573f, 0 , 0,
18154 0x0 }, /* POOL32Axf_4~*(43) */
18155 { reserved_block , 0 , 0 , 32,
18156 0xfc00ffff, 0x2000593f, 0 , 0,
18157 0x0 }, /* POOL32Axf_4~*(44) */
18158 { instruction , 0 , 0 , 32,
18159 0xfc00ffff, 0x20005b3f, &NMD::CLZ , 0,
18160 XMMS_ }, /* CLZ */
18161 { instruction , 0 , 0 , 32,
18162 0xfc00ffff, 0x20005d3f, &NMD::MTC2 , 0,
18163 CP2_ }, /* MTC2 */
18164 { reserved_block , 0 , 0 , 32,
18165 0xfc00ffff, 0x20005f3f, 0 , 0,
18166 0x0 }, /* POOL32Axf_4~*(47) */
18167 { instruction , 0 , 0 , 32,
18168 0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR , 0,
18169 DSP_ }, /* PRECEQ.W.PHR */
18170 { reserved_block , 0 , 0 , 32,
18171 0xfc00ffff, 0x2000633f, 0 , 0,
18172 0x0 }, /* POOL32Axf_4~*(49) */
18173 { reserved_block , 0 , 0 , 32,
18174 0xfc00ffff, 0x2000653f, 0 , 0,
18175 0x0 }, /* POOL32Axf_4~*(50) */
18176 { reserved_block , 0 , 0 , 32,
18177 0xfc00ffff, 0x2000673f, 0 , 0,
18178 0x0 }, /* POOL32Axf_4~*(51) */
18179 { reserved_block , 0 , 0 , 32,
18180 0xfc00ffff, 0x2000693f, 0 , 0,
18181 0x0 }, /* POOL32Axf_4~*(52) */
18182 { reserved_block , 0 , 0 , 32,
18183 0xfc00ffff, 0x20006b3f, 0 , 0,
18184 0x0 }, /* POOL32Axf_4~*(53) */
18185 { instruction , 0 , 0 , 32,
18186 0xfc00ffff, 0x20006d3f, &NMD::DMFC2 , 0,
18187 CP2_ }, /* DMFC2 */
18188 { reserved_block , 0 , 0 , 32,
18189 0xfc00ffff, 0x20006f3f, 0 , 0,
18190 0x0 }, /* POOL32Axf_4~*(55) */
18191 { instruction , 0 , 0 , 32,
18192 0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL , 0,
18193 DSP_ }, /* PRECEQU.PH.QBL */
18194 { instruction , 0 , 0 , 32,
18195 0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA , 0,
18196 DSP_ }, /* PRECEQU.PH.QBLA */
18197 { reserved_block , 0 , 0 , 32,
18198 0xfc00ffff, 0x2000753f, 0 , 0,
18199 0x0 }, /* POOL32Axf_4~*(58) */
18200 { reserved_block , 0 , 0 , 32,
18201 0xfc00ffff, 0x2000773f, 0 , 0,
18202 0x0 }, /* POOL32Axf_4~*(59) */
18203 { reserved_block , 0 , 0 , 32,
18204 0xfc00ffff, 0x2000793f, 0 , 0,
18205 0x0 }, /* POOL32Axf_4~*(60) */
18206 { reserved_block , 0 , 0 , 32,
18207 0xfc00ffff, 0x20007b3f, 0 , 0,
18208 0x0 }, /* POOL32Axf_4~*(61) */
18209 { instruction , 0 , 0 , 32,
18210 0xfc00ffff, 0x20007d3f, &NMD::DMTC2 , 0,
18211 CP2_ }, /* DMTC2 */
18212 { reserved_block , 0 , 0 , 32,
18213 0xfc00ffff, 0x20007f3f, 0 , 0,
18214 0x0 }, /* POOL32Axf_4~*(63) */
18215 { reserved_block , 0 , 0 , 32,
18216 0xfc00ffff, 0x2000813f, 0 , 0,
18217 0x0 }, /* POOL32Axf_4~*(64) */
18218 { reserved_block , 0 , 0 , 32,
18219 0xfc00ffff, 0x2000833f, 0 , 0,
18220 0x0 }, /* POOL32Axf_4~*(65) */
18221 { reserved_block , 0 , 0 , 32,
18222 0xfc00ffff, 0x2000853f, 0 , 0,
18223 0x0 }, /* POOL32Axf_4~*(66) */
18224 { reserved_block , 0 , 0 , 32,
18225 0xfc00ffff, 0x2000873f, 0 , 0,
18226 0x0 }, /* POOL32Axf_4~*(67) */
18227 { reserved_block , 0 , 0 , 32,
18228 0xfc00ffff, 0x2000893f, 0 , 0,
18229 0x0 }, /* POOL32Axf_4~*(68) */
18230 { reserved_block , 0 , 0 , 32,
18231 0xfc00ffff, 0x20008b3f, 0 , 0,
18232 0x0 }, /* POOL32Axf_4~*(69) */
18233 { instruction , 0 , 0 , 32,
18234 0xfc00ffff, 0x20008d3f, &NMD::MFHC2 , 0,
18235 CP2_ }, /* MFHC2 */
18236 { reserved_block , 0 , 0 , 32,
18237 0xfc00ffff, 0x20008f3f, 0 , 0,
18238 0x0 }, /* POOL32Axf_4~*(71) */
18239 { instruction , 0 , 0 , 32,
18240 0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR , 0,
18241 DSP_ }, /* PRECEQU.PH.QBR */
18242 { instruction , 0 , 0 , 32,
18243 0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA , 0,
18244 DSP_ }, /* PRECEQU.PH.QBRA */
18245 { reserved_block , 0 , 0 , 32,
18246 0xfc00ffff, 0x2000953f, 0 , 0,
18247 0x0 }, /* POOL32Axf_4~*(74) */
18248 { reserved_block , 0 , 0 , 32,
18249 0xfc00ffff, 0x2000973f, 0 , 0,
18250 0x0 }, /* POOL32Axf_4~*(75) */
18251 { reserved_block , 0 , 0 , 32,
18252 0xfc00ffff, 0x2000993f, 0 , 0,
18253 0x0 }, /* POOL32Axf_4~*(76) */
18254 { reserved_block , 0 , 0 , 32,
18255 0xfc00ffff, 0x20009b3f, 0 , 0,
18256 0x0 }, /* POOL32Axf_4~*(77) */
18257 { instruction , 0 , 0 , 32,
18258 0xfc00ffff, 0x20009d3f, &NMD::MTHC2 , 0,
18259 CP2_ }, /* MTHC2 */
18260 { reserved_block , 0 , 0 , 32,
18261 0xfc00ffff, 0x20009f3f, 0 , 0,
18262 0x0 }, /* POOL32Axf_4~*(79) */
18263 { reserved_block , 0 , 0 , 32,
18264 0xfc00ffff, 0x2000a13f, 0 , 0,
18265 0x0 }, /* POOL32Axf_4~*(80) */
18266 { reserved_block , 0 , 0 , 32,
18267 0xfc00ffff, 0x2000a33f, 0 , 0,
18268 0x0 }, /* POOL32Axf_4~*(81) */
18269 { reserved_block , 0 , 0 , 32,
18270 0xfc00ffff, 0x2000a53f, 0 , 0,
18271 0x0 }, /* POOL32Axf_4~*(82) */
18272 { reserved_block , 0 , 0 , 32,
18273 0xfc00ffff, 0x2000a73f, 0 , 0,
18274 0x0 }, /* POOL32Axf_4~*(83) */
18275 { reserved_block , 0 , 0 , 32,
18276 0xfc00ffff, 0x2000a93f, 0 , 0,
18277 0x0 }, /* POOL32Axf_4~*(84) */
18278 { reserved_block , 0 , 0 , 32,
18279 0xfc00ffff, 0x2000ab3f, 0 , 0,
18280 0x0 }, /* POOL32Axf_4~*(85) */
18281 { reserved_block , 0 , 0 , 32,
18282 0xfc00ffff, 0x2000ad3f, 0 , 0,
18283 0x0 }, /* POOL32Axf_4~*(86) */
18284 { reserved_block , 0 , 0 , 32,
18285 0xfc00ffff, 0x2000af3f, 0 , 0,
18286 0x0 }, /* POOL32Axf_4~*(87) */
18287 { instruction , 0 , 0 , 32,
18288 0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL , 0,
18289 DSP_ }, /* PRECEU.PH.QBL */
18290 { instruction , 0 , 0 , 32,
18291 0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA , 0,
18292 DSP_ }, /* PRECEU.PH.QBLA */
18293 { reserved_block , 0 , 0 , 32,
18294 0xfc00ffff, 0x2000b53f, 0 , 0,
18295 0x0 }, /* POOL32Axf_4~*(90) */
18296 { reserved_block , 0 , 0 , 32,
18297 0xfc00ffff, 0x2000b73f, 0 , 0,
18298 0x0 }, /* POOL32Axf_4~*(91) */
18299 { reserved_block , 0 , 0 , 32,
18300 0xfc00ffff, 0x2000b93f, 0 , 0,
18301 0x0 }, /* POOL32Axf_4~*(92) */
18302 { reserved_block , 0 , 0 , 32,
18303 0xfc00ffff, 0x2000bb3f, 0 , 0,
18304 0x0 }, /* POOL32Axf_4~*(93) */
18305 { reserved_block , 0 , 0 , 32,
18306 0xfc00ffff, 0x2000bd3f, 0 , 0,
18307 0x0 }, /* POOL32Axf_4~*(94) */
18308 { reserved_block , 0 , 0 , 32,
18309 0xfc00ffff, 0x2000bf3f, 0 , 0,
18310 0x0 }, /* POOL32Axf_4~*(95) */
18311 { reserved_block , 0 , 0 , 32,
18312 0xfc00ffff, 0x2000c13f, 0 , 0,
18313 0x0 }, /* POOL32Axf_4~*(96) */
18314 { reserved_block , 0 , 0 , 32,
18315 0xfc00ffff, 0x2000c33f, 0 , 0,
18316 0x0 }, /* POOL32Axf_4~*(97) */
18317 { reserved_block , 0 , 0 , 32,
18318 0xfc00ffff, 0x2000c53f, 0 , 0,
18319 0x0 }, /* POOL32Axf_4~*(98) */
18320 { reserved_block , 0 , 0 , 32,
18321 0xfc00ffff, 0x2000c73f, 0 , 0,
18322 0x0 }, /* POOL32Axf_4~*(99) */
18323 { reserved_block , 0 , 0 , 32,
18324 0xfc00ffff, 0x2000c93f, 0 , 0,
18325 0x0 }, /* POOL32Axf_4~*(100) */
18326 { reserved_block , 0 , 0 , 32,
18327 0xfc00ffff, 0x2000cb3f, 0 , 0,
18328 0x0 }, /* POOL32Axf_4~*(101) */
18329 { instruction , 0 , 0 , 32,
18330 0xfc00ffff, 0x2000cd3f, &NMD::CFC2 , 0,
18331 CP2_ }, /* CFC2 */
18332 { reserved_block , 0 , 0 , 32,
18333 0xfc00ffff, 0x2000cf3f, 0 , 0,
18334 0x0 }, /* POOL32Axf_4~*(103) */
18335 { instruction , 0 , 0 , 32,
18336 0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR , 0,
18337 DSP_ }, /* PRECEU.PH.QBR */
18338 { instruction , 0 , 0 , 32,
18339 0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA , 0,
18340 DSP_ }, /* PRECEU.PH.QBRA */
18341 { reserved_block , 0 , 0 , 32,
18342 0xfc00ffff, 0x2000d53f, 0 , 0,
18343 0x0 }, /* POOL32Axf_4~*(106) */
18344 { reserved_block , 0 , 0 , 32,
18345 0xfc00ffff, 0x2000d73f, 0 , 0,
18346 0x0 }, /* POOL32Axf_4~*(107) */
18347 { reserved_block , 0 , 0 , 32,
18348 0xfc00ffff, 0x2000d93f, 0 , 0,
18349 0x0 }, /* POOL32Axf_4~*(108) */
18350 { reserved_block , 0 , 0 , 32,
18351 0xfc00ffff, 0x2000db3f, 0 , 0,
18352 0x0 }, /* POOL32Axf_4~*(109) */
18353 { instruction , 0 , 0 , 32,
18354 0xfc00ffff, 0x2000dd3f, &NMD::CTC2 , 0,
18355 CP2_ }, /* CTC2 */
18356 { reserved_block , 0 , 0 , 32,
18357 0xfc00ffff, 0x2000df3f, 0 , 0,
18358 0x0 }, /* POOL32Axf_4~*(111) */
18359 { reserved_block , 0 , 0 , 32,
18360 0xfc00ffff, 0x2000e13f, 0 , 0,
18361 0x0 }, /* POOL32Axf_4~*(112) */
18362 { reserved_block , 0 , 0 , 32,
18363 0xfc00ffff, 0x2000e33f, 0 , 0,
18364 0x0 }, /* POOL32Axf_4~*(113) */
18365 { reserved_block , 0 , 0 , 32,
18366 0xfc00ffff, 0x2000e53f, 0 , 0,
18367 0x0 }, /* POOL32Axf_4~*(114) */
18368 { reserved_block , 0 , 0 , 32,
18369 0xfc00ffff, 0x2000e73f, 0 , 0,
18370 0x0 }, /* POOL32Axf_4~*(115) */
18371 { reserved_block , 0 , 0 , 32,
18372 0xfc00ffff, 0x2000e93f, 0 , 0,
18373 0x0 }, /* POOL32Axf_4~*(116) */
18374 { reserved_block , 0 , 0 , 32,
18375 0xfc00ffff, 0x2000eb3f, 0 , 0,
18376 0x0 }, /* POOL32Axf_4~*(117) */
18377 { reserved_block , 0 , 0 , 32,
18378 0xfc00ffff, 0x2000ed3f, 0 , 0,
18379 0x0 }, /* POOL32Axf_4~*(118) */
18380 { reserved_block , 0 , 0 , 32,
18381 0xfc00ffff, 0x2000ef3f, 0 , 0,
18382 0x0 }, /* POOL32Axf_4~*(119) */
18383 { instruction , 0 , 0 , 32,
18384 0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB , 0,
18385 DSP_ }, /* RADDU.W.QB */
18386 { reserved_block , 0 , 0 , 32,
18387 0xfc00ffff, 0x2000f33f, 0 , 0,
18388 0x0 }, /* POOL32Axf_4~*(121) */
18389 { reserved_block , 0 , 0 , 32,
18390 0xfc00ffff, 0x2000f53f, 0 , 0,
18391 0x0 }, /* POOL32Axf_4~*(122) */
18392 { reserved_block , 0 , 0 , 32,
18393 0xfc00ffff, 0x2000f73f, 0 , 0,
18394 0x0 }, /* POOL32Axf_4~*(123) */
18395 { reserved_block , 0 , 0 , 32,
18396 0xfc00ffff, 0x2000f93f, 0 , 0,
18397 0x0 }, /* POOL32Axf_4~*(124) */
18398 { reserved_block , 0 , 0 , 32,
18399 0xfc00ffff, 0x2000fb3f, 0 , 0,
18400 0x0 }, /* POOL32Axf_4~*(125) */
18401 { reserved_block , 0 , 0 , 32,
18402 0xfc00ffff, 0x2000fd3f, 0 , 0,
18403 0x0 }, /* POOL32Axf_4~*(126) */
18404 { reserved_block , 0 , 0 , 32,
18405 0xfc00ffff, 0x2000ff3f, 0 , 0,
18406 0x0 }, /* POOL32Axf_4~*(127) */
18407 };
18408
18409
18410 NMD::Pool NMD::POOL32Axf_5_group0[32] = {
18411 { instruction , 0 , 0 , 32,
18412 0xfc00ffff, 0x2000017f, &NMD::TLBGP , 0,
18413 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18414 { instruction , 0 , 0 , 32,
18415 0xfc00ffff, 0x2000037f, &NMD::TLBP , 0,
18416 CP0_ | TLB_ }, /* TLBP */
18417 { instruction , 0 , 0 , 32,
18418 0xfc00ffff, 0x2000057f, &NMD::TLBGINV , 0,
18419 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18420 { instruction , 0 , 0 , 32,
18421 0xfc00ffff, 0x2000077f, &NMD::TLBINV , 0,
18422 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18423 { reserved_block , 0 , 0 , 32,
18424 0xfc00ffff, 0x2000097f, 0 , 0,
18425 0x0 }, /* POOL32Axf_5_group0~*(4) */
18426 { reserved_block , 0 , 0 , 32,
18427 0xfc00ffff, 0x20000b7f, 0 , 0,
18428 0x0 }, /* POOL32Axf_5_group0~*(5) */
18429 { reserved_block , 0 , 0 , 32,
18430 0xfc00ffff, 0x20000d7f, 0 , 0,
18431 0x0 }, /* POOL32Axf_5_group0~*(6) */
18432 { reserved_block , 0 , 0 , 32,
18433 0xfc00ffff, 0x20000f7f, 0 , 0,
18434 0x0 }, /* POOL32Axf_5_group0~*(7) */
18435 { instruction , 0 , 0 , 32,
18436 0xfc00ffff, 0x2000117f, &NMD::TLBGR , 0,
18437 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18438 { instruction , 0 , 0 , 32,
18439 0xfc00ffff, 0x2000137f, &NMD::TLBR , 0,
18440 CP0_ | TLB_ }, /* TLBR */
18441 { instruction , 0 , 0 , 32,
18442 0xfc00ffff, 0x2000157f, &NMD::TLBGINVF , 0,
18443 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18444 { instruction , 0 , 0 , 32,
18445 0xfc00ffff, 0x2000177f, &NMD::TLBINVF , 0,
18446 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18447 { reserved_block , 0 , 0 , 32,
18448 0xfc00ffff, 0x2000197f, 0 , 0,
18449 0x0 }, /* POOL32Axf_5_group0~*(12) */
18450 { reserved_block , 0 , 0 , 32,
18451 0xfc00ffff, 0x20001b7f, 0 , 0,
18452 0x0 }, /* POOL32Axf_5_group0~*(13) */
18453 { reserved_block , 0 , 0 , 32,
18454 0xfc00ffff, 0x20001d7f, 0 , 0,
18455 0x0 }, /* POOL32Axf_5_group0~*(14) */
18456 { reserved_block , 0 , 0 , 32,
18457 0xfc00ffff, 0x20001f7f, 0 , 0,
18458 0x0 }, /* POOL32Axf_5_group0~*(15) */
18459 { instruction , 0 , 0 , 32,
18460 0xfc00ffff, 0x2000217f, &NMD::TLBGWI , 0,
18461 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18462 { instruction , 0 , 0 , 32,
18463 0xfc00ffff, 0x2000237f, &NMD::TLBWI , 0,
18464 CP0_ | TLB_ }, /* TLBWI */
18465 { reserved_block , 0 , 0 , 32,
18466 0xfc00ffff, 0x2000257f, 0 , 0,
18467 0x0 }, /* POOL32Axf_5_group0~*(18) */
18468 { reserved_block , 0 , 0 , 32,
18469 0xfc00ffff, 0x2000277f, 0 , 0,
18470 0x0 }, /* POOL32Axf_5_group0~*(19) */
18471 { reserved_block , 0 , 0 , 32,
18472 0xfc00ffff, 0x2000297f, 0 , 0,
18473 0x0 }, /* POOL32Axf_5_group0~*(20) */
18474 { reserved_block , 0 , 0 , 32,
18475 0xfc00ffff, 0x20002b7f, 0 , 0,
18476 0x0 }, /* POOL32Axf_5_group0~*(21) */
18477 { reserved_block , 0 , 0 , 32,
18478 0xfc00ffff, 0x20002d7f, 0 , 0,
18479 0x0 }, /* POOL32Axf_5_group0~*(22) */
18480 { reserved_block , 0 , 0 , 32,
18481 0xfc00ffff, 0x20002f7f, 0 , 0,
18482 0x0 }, /* POOL32Axf_5_group0~*(23) */
18483 { instruction , 0 , 0 , 32,
18484 0xfc00ffff, 0x2000317f, &NMD::TLBGWR , 0,
18485 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18486 { instruction , 0 , 0 , 32,
18487 0xfc00ffff, 0x2000337f, &NMD::TLBWR , 0,
18488 CP0_ | TLB_ }, /* TLBWR */
18489 { reserved_block , 0 , 0 , 32,
18490 0xfc00ffff, 0x2000357f, 0 , 0,
18491 0x0 }, /* POOL32Axf_5_group0~*(26) */
18492 { reserved_block , 0 , 0 , 32,
18493 0xfc00ffff, 0x2000377f, 0 , 0,
18494 0x0 }, /* POOL32Axf_5_group0~*(27) */
18495 { reserved_block , 0 , 0 , 32,
18496 0xfc00ffff, 0x2000397f, 0 , 0,
18497 0x0 }, /* POOL32Axf_5_group0~*(28) */
18498 { reserved_block , 0 , 0 , 32,
18499 0xfc00ffff, 0x20003b7f, 0 , 0,
18500 0x0 }, /* POOL32Axf_5_group0~*(29) */
18501 { reserved_block , 0 , 0 , 32,
18502 0xfc00ffff, 0x20003d7f, 0 , 0,
18503 0x0 }, /* POOL32Axf_5_group0~*(30) */
18504 { reserved_block , 0 , 0 , 32,
18505 0xfc00ffff, 0x20003f7f, 0 , 0,
18506 0x0 }, /* POOL32Axf_5_group0~*(31) */
18507 };
18508
18509
18510 NMD::Pool NMD::POOL32Axf_5_group1[32] = {
18511 { reserved_block , 0 , 0 , 32,
18512 0xfc00ffff, 0x2000417f, 0 , 0,
18513 0x0 }, /* POOL32Axf_5_group1~*(0) */
18514 { reserved_block , 0 , 0 , 32,
18515 0xfc00ffff, 0x2000437f, 0 , 0,
18516 0x0 }, /* POOL32Axf_5_group1~*(1) */
18517 { reserved_block , 0 , 0 , 32,
18518 0xfc00ffff, 0x2000457f, 0 , 0,
18519 0x0 }, /* POOL32Axf_5_group1~*(2) */
18520 { instruction , 0 , 0 , 32,
18521 0xfc00ffff, 0x2000477f, &NMD::DI , 0,
18522 0x0 }, /* DI */
18523 { reserved_block , 0 , 0 , 32,
18524 0xfc00ffff, 0x2000497f, 0 , 0,
18525 0x0 }, /* POOL32Axf_5_group1~*(4) */
18526 { reserved_block , 0 , 0 , 32,
18527 0xfc00ffff, 0x20004b7f, 0 , 0,
18528 0x0 }, /* POOL32Axf_5_group1~*(5) */
18529 { reserved_block , 0 , 0 , 32,
18530 0xfc00ffff, 0x20004d7f, 0 , 0,
18531 0x0 }, /* POOL32Axf_5_group1~*(6) */
18532 { reserved_block , 0 , 0 , 32,
18533 0xfc00ffff, 0x20004f7f, 0 , 0,
18534 0x0 }, /* POOL32Axf_5_group1~*(7) */
18535 { reserved_block , 0 , 0 , 32,
18536 0xfc00ffff, 0x2000517f, 0 , 0,
18537 0x0 }, /* POOL32Axf_5_group1~*(8) */
18538 { reserved_block , 0 , 0 , 32,
18539 0xfc00ffff, 0x2000537f, 0 , 0,
18540 0x0 }, /* POOL32Axf_5_group1~*(9) */
18541 { reserved_block , 0 , 0 , 32,
18542 0xfc00ffff, 0x2000557f, 0 , 0,
18543 0x0 }, /* POOL32Axf_5_group1~*(10) */
18544 { instruction , 0 , 0 , 32,
18545 0xfc00ffff, 0x2000577f, &NMD::EI , 0,
18546 0x0 }, /* EI */
18547 { reserved_block , 0 , 0 , 32,
18548 0xfc00ffff, 0x2000597f, 0 , 0,
18549 0x0 }, /* POOL32Axf_5_group1~*(12) */
18550 { reserved_block , 0 , 0 , 32,
18551 0xfc00ffff, 0x20005b7f, 0 , 0,
18552 0x0 }, /* POOL32Axf_5_group1~*(13) */
18553 { reserved_block , 0 , 0 , 32,
18554 0xfc00ffff, 0x20005d7f, 0 , 0,
18555 0x0 }, /* POOL32Axf_5_group1~*(14) */
18556 { reserved_block , 0 , 0 , 32,
18557 0xfc00ffff, 0x20005f7f, 0 , 0,
18558 0x0 }, /* POOL32Axf_5_group1~*(15) */
18559 { reserved_block , 0 , 0 , 32,
18560 0xfc00ffff, 0x2000617f, 0 , 0,
18561 0x0 }, /* POOL32Axf_5_group1~*(16) */
18562 { reserved_block , 0 , 0 , 32,
18563 0xfc00ffff, 0x2000637f, 0 , 0,
18564 0x0 }, /* POOL32Axf_5_group1~*(17) */
18565 { reserved_block , 0 , 0 , 32,
18566 0xfc00ffff, 0x2000657f, 0 , 0,
18567 0x0 }, /* POOL32Axf_5_group1~*(18) */
18568 { reserved_block , 0 , 0 , 32,
18569 0xfc00ffff, 0x2000677f, 0 , 0,
18570 0x0 }, /* POOL32Axf_5_group1~*(19) */
18571 { reserved_block , 0 , 0 , 32,
18572 0xfc00ffff, 0x2000697f, 0 , 0,
18573 0x0 }, /* POOL32Axf_5_group1~*(20) */
18574 { reserved_block , 0 , 0 , 32,
18575 0xfc00ffff, 0x20006b7f, 0 , 0,
18576 0x0 }, /* POOL32Axf_5_group1~*(21) */
18577 { reserved_block , 0 , 0 , 32,
18578 0xfc00ffff, 0x20006d7f, 0 , 0,
18579 0x0 }, /* POOL32Axf_5_group1~*(22) */
18580 { reserved_block , 0 , 0 , 32,
18581 0xfc00ffff, 0x20006f7f, 0 , 0,
18582 0x0 }, /* POOL32Axf_5_group1~*(23) */
18583 { reserved_block , 0 , 0 , 32,
18584 0xfc00ffff, 0x2000717f, 0 , 0,
18585 0x0 }, /* POOL32Axf_5_group1~*(24) */
18586 { reserved_block , 0 , 0 , 32,
18587 0xfc00ffff, 0x2000737f, 0 , 0,
18588 0x0 }, /* POOL32Axf_5_group1~*(25) */
18589 { reserved_block , 0 , 0 , 32,
18590 0xfc00ffff, 0x2000757f, 0 , 0,
18591 0x0 }, /* POOL32Axf_5_group1~*(26) */
18592 { reserved_block , 0 , 0 , 32,
18593 0xfc00ffff, 0x2000777f, 0 , 0,
18594 0x0 }, /* POOL32Axf_5_group1~*(27) */
18595 { reserved_block , 0 , 0 , 32,
18596 0xfc00ffff, 0x2000797f, 0 , 0,
18597 0x0 }, /* POOL32Axf_5_group1~*(28) */
18598 { reserved_block , 0 , 0 , 32,
18599 0xfc00ffff, 0x20007b7f, 0 , 0,
18600 0x0 }, /* POOL32Axf_5_group1~*(29) */
18601 { reserved_block , 0 , 0 , 32,
18602 0xfc00ffff, 0x20007d7f, 0 , 0,
18603 0x0 }, /* POOL32Axf_5_group1~*(30) */
18604 { reserved_block , 0 , 0 , 32,
18605 0xfc00ffff, 0x20007f7f, 0 , 0,
18606 0x0 }, /* POOL32Axf_5_group1~*(31) */
18607 };
18608
18609
18610 NMD::Pool NMD::ERETx[2] = {
18611 { instruction , 0 , 0 , 32,
18612 0xfc01ffff, 0x2000f37f, &NMD::ERET , 0,
18613 0x0 }, /* ERET */
18614 { instruction , 0 , 0 , 32,
18615 0xfc01ffff, 0x2001f37f, &NMD::ERETNC , 0,
18616 0x0 }, /* ERETNC */
18617 };
18618
18619
18620 NMD::Pool NMD::POOL32Axf_5_group3[32] = {
18621 { reserved_block , 0 , 0 , 32,
18622 0xfc00ffff, 0x2000c17f, 0 , 0,
18623 0x0 }, /* POOL32Axf_5_group3~*(0) */
18624 { instruction , 0 , 0 , 32,
18625 0xfc00ffff, 0x2000c37f, &NMD::WAIT , 0,
18626 0x0 }, /* WAIT */
18627 { reserved_block , 0 , 0 , 32,
18628 0xfc00ffff, 0x2000c57f, 0 , 0,
18629 0x0 }, /* POOL32Axf_5_group3~*(2) */
18630 { reserved_block , 0 , 0 , 32,
18631 0xfc00ffff, 0x2000c77f, 0 , 0,
18632 0x0 }, /* POOL32Axf_5_group3~*(3) */
18633 { reserved_block , 0 , 0 , 32,
18634 0xfc00ffff, 0x2000c97f, 0 , 0,
18635 0x0 }, /* POOL32Axf_5_group3~*(4) */
18636 { reserved_block , 0 , 0 , 32,
18637 0xfc00ffff, 0x2000cb7f, 0 , 0,
18638 0x0 }, /* POOL32Axf_5_group3~*(5) */
18639 { reserved_block , 0 , 0 , 32,
18640 0xfc00ffff, 0x2000cd7f, 0 , 0,
18641 0x0 }, /* POOL32Axf_5_group3~*(6) */
18642 { reserved_block , 0 , 0 , 32,
18643 0xfc00ffff, 0x2000cf7f, 0 , 0,
18644 0x0 }, /* POOL32Axf_5_group3~*(7) */
18645 { reserved_block , 0 , 0 , 32,
18646 0xfc00ffff, 0x2000d17f, 0 , 0,
18647 0x0 }, /* POOL32Axf_5_group3~*(8) */
18648 { instruction , 0 , 0 , 32,
18649 0xfc00ffff, 0x2000d37f, &NMD::IRET , 0,
18650 MCU_ }, /* IRET */
18651 { reserved_block , 0 , 0 , 32,
18652 0xfc00ffff, 0x2000d57f, 0 , 0,
18653 0x0 }, /* POOL32Axf_5_group3~*(10) */
18654 { reserved_block , 0 , 0 , 32,
18655 0xfc00ffff, 0x2000d77f, 0 , 0,
18656 0x0 }, /* POOL32Axf_5_group3~*(11) */
18657 { reserved_block , 0 , 0 , 32,
18658 0xfc00ffff, 0x2000d97f, 0 , 0,
18659 0x0 }, /* POOL32Axf_5_group3~*(12) */
18660 { reserved_block , 0 , 0 , 32,
18661 0xfc00ffff, 0x2000db7f, 0 , 0,
18662 0x0 }, /* POOL32Axf_5_group3~*(13) */
18663 { reserved_block , 0 , 0 , 32,
18664 0xfc00ffff, 0x2000dd7f, 0 , 0,
18665 0x0 }, /* POOL32Axf_5_group3~*(14) */
18666 { reserved_block , 0 , 0 , 32,
18667 0xfc00ffff, 0x2000df7f, 0 , 0,
18668 0x0 }, /* POOL32Axf_5_group3~*(15) */
18669 { instruction , 0 , 0 , 32,
18670 0xfc00ffff, 0x2000e17f, &NMD::RDPGPR , 0,
18671 CP0_ }, /* RDPGPR */
18672 { instruction , 0 , 0 , 32,
18673 0xfc00ffff, 0x2000e37f, &NMD::DERET , 0,
18674 EJTAG_ }, /* DERET */
18675 { reserved_block , 0 , 0 , 32,
18676 0xfc00ffff, 0x2000e57f, 0 , 0,
18677 0x0 }, /* POOL32Axf_5_group3~*(18) */
18678 { reserved_block , 0 , 0 , 32,
18679 0xfc00ffff, 0x2000e77f, 0 , 0,
18680 0x0 }, /* POOL32Axf_5_group3~*(19) */
18681 { reserved_block , 0 , 0 , 32,
18682 0xfc00ffff, 0x2000e97f, 0 , 0,
18683 0x0 }, /* POOL32Axf_5_group3~*(20) */
18684 { reserved_block , 0 , 0 , 32,
18685 0xfc00ffff, 0x2000eb7f, 0 , 0,
18686 0x0 }, /* POOL32Axf_5_group3~*(21) */
18687 { reserved_block , 0 , 0 , 32,
18688 0xfc00ffff, 0x2000ed7f, 0 , 0,
18689 0x0 }, /* POOL32Axf_5_group3~*(22) */
18690 { reserved_block , 0 , 0 , 32,
18691 0xfc00ffff, 0x2000ef7f, 0 , 0,
18692 0x0 }, /* POOL32Axf_5_group3~*(23) */
18693 { instruction , 0 , 0 , 32,
18694 0xfc00ffff, 0x2000f17f, &NMD::WRPGPR , 0,
18695 CP0_ }, /* WRPGPR */
18696 { pool , ERETx , 2 , 32,
18697 0xfc00ffff, 0x2000f37f, 0 , 0,
18698 0x0 }, /* ERETx */
18699 { reserved_block , 0 , 0 , 32,
18700 0xfc00ffff, 0x2000f57f, 0 , 0,
18701 0x0 }, /* POOL32Axf_5_group3~*(26) */
18702 { reserved_block , 0 , 0 , 32,
18703 0xfc00ffff, 0x2000f77f, 0 , 0,
18704 0x0 }, /* POOL32Axf_5_group3~*(27) */
18705 { reserved_block , 0 , 0 , 32,
18706 0xfc00ffff, 0x2000f97f, 0 , 0,
18707 0x0 }, /* POOL32Axf_5_group3~*(28) */
18708 { reserved_block , 0 , 0 , 32,
18709 0xfc00ffff, 0x2000fb7f, 0 , 0,
18710 0x0 }, /* POOL32Axf_5_group3~*(29) */
18711 { reserved_block , 0 , 0 , 32,
18712 0xfc00ffff, 0x2000fd7f, 0 , 0,
18713 0x0 }, /* POOL32Axf_5_group3~*(30) */
18714 { reserved_block , 0 , 0 , 32,
18715 0xfc00ffff, 0x2000ff7f, 0 , 0,
18716 0x0 }, /* POOL32Axf_5_group3~*(31) */
18717 };
18718
18719
18720 NMD::Pool NMD::POOL32Axf_5[4] = {
18721 { pool , POOL32Axf_5_group0 , 32 , 32,
18722 0xfc00c1ff, 0x2000017f, 0 , 0,
18723 0x0 }, /* POOL32Axf_5_group0 */
18724 { pool , POOL32Axf_5_group1 , 32 , 32,
18725 0xfc00c1ff, 0x2000417f, 0 , 0,
18726 0x0 }, /* POOL32Axf_5_group1 */
18727 { reserved_block , 0 , 0 , 32,
18728 0xfc00c1ff, 0x2000817f, 0 , 0,
18729 0x0 }, /* POOL32Axf_5~*(2) */
18730 { pool , POOL32Axf_5_group3 , 32 , 32,
18731 0xfc00c1ff, 0x2000c17f, 0 , 0,
18732 0x0 }, /* POOL32Axf_5_group3 */
18733 };
18734
18735
18736 NMD::Pool NMD::SHRA__R__QB[2] = {
18737 { instruction , 0 , 0 , 32,
18738 0xfc001fff, 0x200001ff, &NMD::SHRA_QB , 0,
18739 DSP_ }, /* SHRA.QB */
18740 { instruction , 0 , 0 , 32,
18741 0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB , 0,
18742 DSP_ }, /* SHRA_R.QB */
18743 };
18744
18745
18746 NMD::Pool NMD::POOL32Axf_7[8] = {
18747 { pool , SHRA__R__QB , 2 , 32,
18748 0xfc000fff, 0x200001ff, 0 , 0,
18749 0x0 }, /* SHRA[_R].QB */
18750 { instruction , 0 , 0 , 32,
18751 0xfc000fff, 0x200003ff, &NMD::SHRL_PH , 0,
18752 DSP_ }, /* SHRL.PH */
18753 { instruction , 0 , 0 , 32,
18754 0xfc000fff, 0x200005ff, &NMD::REPL_QB , 0,
18755 DSP_ }, /* REPL.QB */
18756 { reserved_block , 0 , 0 , 32,
18757 0xfc000fff, 0x200007ff, 0 , 0,
18758 0x0 }, /* POOL32Axf_7~*(3) */
18759 { reserved_block , 0 , 0 , 32,
18760 0xfc000fff, 0x200009ff, 0 , 0,
18761 0x0 }, /* POOL32Axf_7~*(4) */
18762 { reserved_block , 0 , 0 , 32,
18763 0xfc000fff, 0x20000bff, 0 , 0,
18764 0x0 }, /* POOL32Axf_7~*(5) */
18765 { reserved_block , 0 , 0 , 32,
18766 0xfc000fff, 0x20000dff, 0 , 0,
18767 0x0 }, /* POOL32Axf_7~*(6) */
18768 { reserved_block , 0 , 0 , 32,
18769 0xfc000fff, 0x20000fff, 0 , 0,
18770 0x0 }, /* POOL32Axf_7~*(7) */
18771 };
18772
18773
18774 NMD::Pool NMD::POOL32Axf[8] = {
18775 { reserved_block , 0 , 0 , 32,
18776 0xfc0001ff, 0x2000003f, 0 , 0,
18777 0x0 }, /* POOL32Axf~*(0) */
18778 { pool , POOL32Axf_1 , 8 , 32,
18779 0xfc0001ff, 0x2000007f, 0 , 0,
18780 0x0 }, /* POOL32Axf_1 */
18781 { pool , POOL32Axf_2 , 4 , 32,
18782 0xfc0001ff, 0x200000bf, 0 , 0,
18783 0x0 }, /* POOL32Axf_2 */
18784 { reserved_block , 0 , 0 , 32,
18785 0xfc0001ff, 0x200000ff, 0 , 0,
18786 0x0 }, /* POOL32Axf~*(3) */
18787 { pool , POOL32Axf_4 , 128 , 32,
18788 0xfc0001ff, 0x2000013f, 0 , 0,
18789 0x0 }, /* POOL32Axf_4 */
18790 { pool , POOL32Axf_5 , 4 , 32,
18791 0xfc0001ff, 0x2000017f, 0 , 0,
18792 0x0 }, /* POOL32Axf_5 */
18793 { reserved_block , 0 , 0 , 32,
18794 0xfc0001ff, 0x200001bf, 0 , 0,
18795 0x0 }, /* POOL32Axf~*(6) */
18796 { pool , POOL32Axf_7 , 8 , 32,
18797 0xfc0001ff, 0x200001ff, 0 , 0,
18798 0x0 }, /* POOL32Axf_7 */
18799 };
18800
18801
18802 NMD::Pool NMD::_POOL32A7[8] = {
18803 { pool , P_LSX , 2 , 32,
18804 0xfc00003f, 0x20000007, 0 , 0,
18805 0x0 }, /* P.LSX */
18806 { instruction , 0 , 0 , 32,
18807 0xfc00003f, 0x2000000f, &NMD::LSA , 0,
18808 0x0 }, /* LSA */
18809 { reserved_block , 0 , 0 , 32,
18810 0xfc00003f, 0x20000017, 0 , 0,
18811 0x0 }, /* _POOL32A7~*(2) */
18812 { instruction , 0 , 0 , 32,
18813 0xfc00003f, 0x2000001f, &NMD::EXTW , 0,
18814 0x0 }, /* EXTW */
18815 { reserved_block , 0 , 0 , 32,
18816 0xfc00003f, 0x20000027, 0 , 0,
18817 0x0 }, /* _POOL32A7~*(4) */
18818 { reserved_block , 0 , 0 , 32,
18819 0xfc00003f, 0x2000002f, 0 , 0,
18820 0x0 }, /* _POOL32A7~*(5) */
18821 { reserved_block , 0 , 0 , 32,
18822 0xfc00003f, 0x20000037, 0 , 0,
18823 0x0 }, /* _POOL32A7~*(6) */
18824 { pool , POOL32Axf , 8 , 32,
18825 0xfc00003f, 0x2000003f, 0 , 0,
18826 0x0 }, /* POOL32Axf */
18827 };
18828
18829
18830 NMD::Pool NMD::P32A[8] = {
18831 { pool , _POOL32A0 , 128 , 32,
18832 0xfc000007, 0x20000000, 0 , 0,
18833 0x0 }, /* _POOL32A0 */
18834 { instruction , 0 , 0 , 32,
18835 0xfc000007, 0x20000001, &NMD::SPECIAL2 , 0,
18836 UDI_ }, /* SPECIAL2 */
18837 { instruction , 0 , 0 , 32,
18838 0xfc000007, 0x20000002, &NMD::COP2_1 , 0,
18839 CP2_ }, /* COP2_1 */
18840 { instruction , 0 , 0 , 32,
18841 0xfc000007, 0x20000003, &NMD::UDI , 0,
18842 UDI_ }, /* UDI */
18843 { reserved_block , 0 , 0 , 32,
18844 0xfc000007, 0x20000004, 0 , 0,
18845 0x0 }, /* P32A~*(4) */
18846 { pool , _POOL32A5 , 128 , 32,
18847 0xfc000007, 0x20000005, 0 , 0,
18848 0x0 }, /* _POOL32A5 */
18849 { reserved_block , 0 , 0 , 32,
18850 0xfc000007, 0x20000006, 0 , 0,
18851 0x0 }, /* P32A~*(6) */
18852 { pool , _POOL32A7 , 8 , 32,
18853 0xfc000007, 0x20000007, 0 , 0,
18854 0x0 }, /* _POOL32A7 */
18855 };
18856
18857
18858 NMD::Pool NMD::P_GP_D[2] = {
18859 { instruction , 0 , 0 , 32,
18860 0xfc000007, 0x40000001, &NMD::LD_GP_ , 0,
18861 MIPS64_ }, /* LD[GP] */
18862 { instruction , 0 , 0 , 32,
18863 0xfc000007, 0x40000005, &NMD::SD_GP_ , 0,
18864 MIPS64_ }, /* SD[GP] */
18865 };
18866
18867
18868 NMD::Pool NMD::P_GP_W[4] = {
18869 { instruction , 0 , 0 , 32,
18870 0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_ , 0,
18871 0x0 }, /* ADDIU[GP.W] */
18872 { pool , P_GP_D , 2 , 32,
18873 0xfc000003, 0x40000001, 0 , 0,
18874 0x0 }, /* P.GP.D */
18875 { instruction , 0 , 0 , 32,
18876 0xfc000003, 0x40000002, &NMD::LW_GP_ , 0,
18877 0x0 }, /* LW[GP] */
18878 { instruction , 0 , 0 , 32,
18879 0xfc000003, 0x40000003, &NMD::SW_GP_ , 0,
18880 0x0 }, /* SW[GP] */
18881 };
18882
18883
18884 NMD::Pool NMD::POOL48I[32] = {
18885 { instruction , 0 , 0 , 48,
18886 0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_ , 0,
18887 XMMS_ }, /* LI[48] */
18888 { instruction , 0 , 0 , 48,
18889 0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_ , 0,
18890 XMMS_ }, /* ADDIU[48] */
18891 { instruction , 0 , 0 , 48,
18892 0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_ , 0,
18893 XMMS_ }, /* ADDIU[GP48] */
18894 { instruction , 0 , 0 , 48,
18895 0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_ , 0,
18896 XMMS_ }, /* ADDIUPC[48] */
18897 { reserved_block , 0 , 0 , 48,
18898 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18899 0x0 }, /* POOL48I~*(4) */
18900 { reserved_block , 0 , 0 , 48,
18901 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18902 0x0 }, /* POOL48I~*(5) */
18903 { reserved_block , 0 , 0 , 48,
18904 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18905 0x0 }, /* POOL48I~*(6) */
18906 { reserved_block , 0 , 0 , 48,
18907 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18908 0x0 }, /* POOL48I~*(7) */
18909 { reserved_block , 0 , 0 , 48,
18910 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18911 0x0 }, /* POOL48I~*(8) */
18912 { reserved_block , 0 , 0 , 48,
18913 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18914 0x0 }, /* POOL48I~*(9) */
18915 { reserved_block , 0 , 0 , 48,
18916 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18917 0x0 }, /* POOL48I~*(10) */
18918 { instruction , 0 , 0 , 48,
18919 0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_ , 0,
18920 XMMS_ }, /* LWPC[48] */
18921 { reserved_block , 0 , 0 , 48,
18922 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18923 0x0 }, /* POOL48I~*(12) */
18924 { reserved_block , 0 , 0 , 48,
18925 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18926 0x0 }, /* POOL48I~*(13) */
18927 { reserved_block , 0 , 0 , 48,
18928 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18929 0x0 }, /* POOL48I~*(14) */
18930 { instruction , 0 , 0 , 48,
18931 0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_ , 0,
18932 XMMS_ }, /* SWPC[48] */
18933 { reserved_block , 0 , 0 , 48,
18934 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18935 0x0 }, /* POOL48I~*(16) */
18936 { instruction , 0 , 0 , 48,
18937 0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_ , 0,
18938 MIPS64_ }, /* DADDIU[48] */
18939 { reserved_block , 0 , 0 , 48,
18940 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18941 0x0 }, /* POOL48I~*(18) */
18942 { reserved_block , 0 , 0 , 48,
18943 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18944 0x0 }, /* POOL48I~*(19) */
18945 { instruction , 0 , 0 , 48,
18946 0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_ , 0,
18947 MIPS64_ }, /* DLUI[48] */
18948 { reserved_block , 0 , 0 , 48,
18949 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18950 0x0 }, /* POOL48I~*(21) */
18951 { reserved_block , 0 , 0 , 48,
18952 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18953 0x0 }, /* POOL48I~*(22) */
18954 { reserved_block , 0 , 0 , 48,
18955 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18956 0x0 }, /* POOL48I~*(23) */
18957 { reserved_block , 0 , 0 , 48,
18958 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18959 0x0 }, /* POOL48I~*(24) */
18960 { reserved_block , 0 , 0 , 48,
18961 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18962 0x0 }, /* POOL48I~*(25) */
18963 { reserved_block , 0 , 0 , 48,
18964 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18965 0x0 }, /* POOL48I~*(26) */
18966 { instruction , 0 , 0 , 48,
18967 0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_ , 0,
18968 MIPS64_ }, /* LDPC[48] */
18969 { reserved_block , 0 , 0 , 48,
18970 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18971 0x0 }, /* POOL48I~*(28) */
18972 { reserved_block , 0 , 0 , 48,
18973 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18974 0x0 }, /* POOL48I~*(29) */
18975 { reserved_block , 0 , 0 , 48,
18976 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18977 0x0 }, /* POOL48I~*(30) */
18978 { instruction , 0 , 0 , 48,
18979 0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_ , 0,
18980 MIPS64_ }, /* SDPC[48] */
18981 };
18982
18983
18984 NMD::Pool NMD::PP_SR[4] = {
18985 { instruction , 0 , 0 , 32,
18986 0xfc10f003, 0x80003000, &NMD::SAVE_32_ , 0,
18987 0x0 }, /* SAVE[32] */
18988 { reserved_block , 0 , 0 , 32,
18989 0xfc10f003, 0x80003001, 0 , 0,
18990 0x0 }, /* PP.SR~*(1) */
18991 { instruction , 0 , 0 , 32,
18992 0xfc10f003, 0x80003002, &NMD::RESTORE_32_ , 0,
18993 0x0 }, /* RESTORE[32] */
18994 { return_instruction , 0 , 0 , 32,
18995 0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_ , 0,
18996 0x0 }, /* RESTORE.JRC[32] */
18997 };
18998
18999
19000 NMD::Pool NMD::P_SR_F[8] = {
19001 { instruction , 0 , 0 , 32,
19002 0xfc10f007, 0x80103000, &NMD::SAVEF , 0,
19003 CP1_ }, /* SAVEF */
19004 { instruction , 0 , 0 , 32,
19005 0xfc10f007, 0x80103001, &NMD::RESTOREF , 0,
19006 CP1_ }, /* RESTOREF */
19007 { reserved_block , 0 , 0 , 32,
19008 0xfc10f007, 0x80103002, 0 , 0,
19009 0x0 }, /* P.SR.F~*(2) */
19010 { reserved_block , 0 , 0 , 32,
19011 0xfc10f007, 0x80103003, 0 , 0,
19012 0x0 }, /* P.SR.F~*(3) */
19013 { reserved_block , 0 , 0 , 32,
19014 0xfc10f007, 0x80103004, 0 , 0,
19015 0x0 }, /* P.SR.F~*(4) */
19016 { reserved_block , 0 , 0 , 32,
19017 0xfc10f007, 0x80103005, 0 , 0,
19018 0x0 }, /* P.SR.F~*(5) */
19019 { reserved_block , 0 , 0 , 32,
19020 0xfc10f007, 0x80103006, 0 , 0,
19021 0x0 }, /* P.SR.F~*(6) */
19022 { reserved_block , 0 , 0 , 32,
19023 0xfc10f007, 0x80103007, 0 , 0,
19024 0x0 }, /* P.SR.F~*(7) */
19025 };
19026
19027
19028 NMD::Pool NMD::P_SR[2] = {
19029 { pool , PP_SR , 4 , 32,
19030 0xfc10f000, 0x80003000, 0 , 0,
19031 0x0 }, /* PP.SR */
19032 { pool , P_SR_F , 8 , 32,
19033 0xfc10f000, 0x80103000, 0 , 0,
19034 0x0 }, /* P.SR.F */
19035 };
19036
19037
19038 NMD::Pool NMD::P_SLL[5] = {
19039 { instruction , 0 , 0 , 32,
19040 0xffe0f1ff, 0x8000c000, &NMD::NOP_32_ , 0,
19041 0x0 }, /* NOP[32] */
19042 { instruction , 0 , 0 , 32,
19043 0xffe0f1ff, 0x8000c003, &NMD::EHB , 0,
19044 0x0 }, /* EHB */
19045 { instruction , 0 , 0 , 32,
19046 0xffe0f1ff, 0x8000c005, &NMD::PAUSE , 0,
19047 0x0 }, /* PAUSE */
19048 { instruction , 0 , 0 , 32,
19049 0xffe0f1ff, 0x8000c006, &NMD::SYNC , 0,
19050 0x0 }, /* SYNC */
19051 { instruction , 0 , 0 , 32,
19052 0xfc00f1e0, 0x8000c000, &NMD::SLL_32_ , 0,
19053 0x0 }, /* SLL[32] */
19054 };
19055
19056
19057 NMD::Pool NMD::P_SHIFT[16] = {
19058 { pool , P_SLL , 5 , 32,
19059 0xfc00f1e0, 0x8000c000, 0 , 0,
19060 0x0 }, /* P.SLL */
19061 { reserved_block , 0 , 0 , 32,
19062 0xfc00f1e0, 0x8000c020, 0 , 0,
19063 0x0 }, /* P.SHIFT~*(1) */
19064 { instruction , 0 , 0 , 32,
19065 0xfc00f1e0, 0x8000c040, &NMD::SRL_32_ , 0,
19066 0x0 }, /* SRL[32] */
19067 { reserved_block , 0 , 0 , 32,
19068 0xfc00f1e0, 0x8000c060, 0 , 0,
19069 0x0 }, /* P.SHIFT~*(3) */
19070 { instruction , 0 , 0 , 32,
19071 0xfc00f1e0, 0x8000c080, &NMD::SRA , 0,
19072 0x0 }, /* SRA */
19073 { reserved_block , 0 , 0 , 32,
19074 0xfc00f1e0, 0x8000c0a0, 0 , 0,
19075 0x0 }, /* P.SHIFT~*(5) */
19076 { instruction , 0 , 0 , 32,
19077 0xfc00f1e0, 0x8000c0c0, &NMD::ROTR , 0,
19078 0x0 }, /* ROTR */
19079 { reserved_block , 0 , 0 , 32,
19080 0xfc00f1e0, 0x8000c0e0, 0 , 0,
19081 0x0 }, /* P.SHIFT~*(7) */
19082 { instruction , 0 , 0 , 32,
19083 0xfc00f1e0, 0x8000c100, &NMD::DSLL , 0,
19084 MIPS64_ }, /* DSLL */
19085 { instruction , 0 , 0 , 32,
19086 0xfc00f1e0, 0x8000c120, &NMD::DSLL32 , 0,
19087 MIPS64_ }, /* DSLL32 */
19088 { instruction , 0 , 0 , 32,
19089 0xfc00f1e0, 0x8000c140, &NMD::DSRL , 0,
19090 MIPS64_ }, /* DSRL */
19091 { instruction , 0 , 0 , 32,
19092 0xfc00f1e0, 0x8000c160, &NMD::DSRL32 , 0,
19093 MIPS64_ }, /* DSRL32 */
19094 { instruction , 0 , 0 , 32,
19095 0xfc00f1e0, 0x8000c180, &NMD::DSRA , 0,
19096 MIPS64_ }, /* DSRA */
19097 { instruction , 0 , 0 , 32,
19098 0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32 , 0,
19099 MIPS64_ }, /* DSRA32 */
19100 { instruction , 0 , 0 , 32,
19101 0xfc00f1e0, 0x8000c1c0, &NMD::DROTR , 0,
19102 MIPS64_ }, /* DROTR */
19103 { instruction , 0 , 0 , 32,
19104 0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32 , 0,
19105 MIPS64_ }, /* DROTR32 */
19106 };
19107
19108
19109 NMD::Pool NMD::P_ROTX[4] = {
19110 { instruction , 0 , 0 , 32,
19111 0xfc00f820, 0x8000d000, &NMD::ROTX , 0,
19112 XMMS_ }, /* ROTX */
19113 { reserved_block , 0 , 0 , 32,
19114 0xfc00f820, 0x8000d020, 0 , 0,
19115 0x0 }, /* P.ROTX~*(1) */
19116 { reserved_block , 0 , 0 , 32,
19117 0xfc00f820, 0x8000d800, 0 , 0,
19118 0x0 }, /* P.ROTX~*(2) */
19119 { reserved_block , 0 , 0 , 32,
19120 0xfc00f820, 0x8000d820, 0 , 0,
19121 0x0 }, /* P.ROTX~*(3) */
19122 };
19123
19124
19125 NMD::Pool NMD::P_INS[4] = {
19126 { instruction , 0 , 0 , 32,
19127 0xfc00f820, 0x8000e000, &NMD::INS , 0,
19128 XMMS_ }, /* INS */
19129 { instruction , 0 , 0 , 32,
19130 0xfc00f820, 0x8000e020, &NMD::DINSU , 0,
19131 MIPS64_ }, /* DINSU */
19132 { instruction , 0 , 0 , 32,
19133 0xfc00f820, 0x8000e800, &NMD::DINSM , 0,
19134 MIPS64_ }, /* DINSM */
19135 { instruction , 0 , 0 , 32,
19136 0xfc00f820, 0x8000e820, &NMD::DINS , 0,
19137 MIPS64_ }, /* DINS */
19138 };
19139
19140
19141 NMD::Pool NMD::P_EXT[4] = {
19142 { instruction , 0 , 0 , 32,
19143 0xfc00f820, 0x8000f000, &NMD::EXT , 0,
19144 XMMS_ }, /* EXT */
19145 { instruction , 0 , 0 , 32,
19146 0xfc00f820, 0x8000f020, &NMD::DEXTU , 0,
19147 MIPS64_ }, /* DEXTU */
19148 { instruction , 0 , 0 , 32,
19149 0xfc00f820, 0x8000f800, &NMD::DEXTM , 0,
19150 MIPS64_ }, /* DEXTM */
19151 { instruction , 0 , 0 , 32,
19152 0xfc00f820, 0x8000f820, &NMD::DEXT , 0,
19153 MIPS64_ }, /* DEXT */
19154 };
19155
19156
19157 NMD::Pool NMD::P_U12[16] = {
19158 { instruction , 0 , 0 , 32,
19159 0xfc00f000, 0x80000000, &NMD::ORI , 0,
19160 0x0 }, /* ORI */
19161 { instruction , 0 , 0 , 32,
19162 0xfc00f000, 0x80001000, &NMD::XORI , 0,
19163 0x0 }, /* XORI */
19164 { instruction , 0 , 0 , 32,
19165 0xfc00f000, 0x80002000, &NMD::ANDI_32_ , 0,
19166 0x0 }, /* ANDI[32] */
19167 { pool , P_SR , 2 , 32,
19168 0xfc00f000, 0x80003000, 0 , 0,
19169 0x0 }, /* P.SR */
19170 { instruction , 0 , 0 , 32,
19171 0xfc00f000, 0x80004000, &NMD::SLTI , 0,
19172 0x0 }, /* SLTI */
19173 { instruction , 0 , 0 , 32,
19174 0xfc00f000, 0x80005000, &NMD::SLTIU , 0,
19175 0x0 }, /* SLTIU */
19176 { instruction , 0 , 0 , 32,
19177 0xfc00f000, 0x80006000, &NMD::SEQI , 0,
19178 0x0 }, /* SEQI */
19179 { reserved_block , 0 , 0 , 32,
19180 0xfc00f000, 0x80007000, 0 , 0,
19181 0x0 }, /* P.U12~*(7) */
19182 { instruction , 0 , 0 , 32,
19183 0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_ , 0,
19184 0x0 }, /* ADDIU[NEG] */
19185 { instruction , 0 , 0 , 32,
19186 0xfc00f000, 0x80009000, &NMD::DADDIU_U12_ , 0,
19187 MIPS64_ }, /* DADDIU[U12] */
19188 { instruction , 0 , 0 , 32,
19189 0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_ , 0,
19190 MIPS64_ }, /* DADDIU[NEG] */
19191 { instruction , 0 , 0 , 32,
19192 0xfc00f000, 0x8000b000, &NMD::DROTX , 0,
19193 MIPS64_ }, /* DROTX */
19194 { pool , P_SHIFT , 16 , 32,
19195 0xfc00f000, 0x8000c000, 0 , 0,
19196 0x0 }, /* P.SHIFT */
19197 { pool , P_ROTX , 4 , 32,
19198 0xfc00f000, 0x8000d000, 0 , 0,
19199 0x0 }, /* P.ROTX */
19200 { pool , P_INS , 4 , 32,
19201 0xfc00f000, 0x8000e000, 0 , 0,
19202 0x0 }, /* P.INS */
19203 { pool , P_EXT , 4 , 32,
19204 0xfc00f000, 0x8000f000, 0 , 0,
19205 0x0 }, /* P.EXT */
19206 };
19207
19208
19209 NMD::Pool NMD::RINT_fmt[2] = {
19210 { instruction , 0 , 0 , 32,
19211 0xfc0003ff, 0xa0000020, &NMD::RINT_S , 0,
19212 CP1_ }, /* RINT.S */
19213 { instruction , 0 , 0 , 32,
19214 0xfc0003ff, 0xa0000220, &NMD::RINT_D , 0,
19215 CP1_ }, /* RINT.D */
19216 };
19217
19218
19219 NMD::Pool NMD::ADD_fmt0[2] = {
19220 { instruction , 0 , 0 , 32,
19221 0xfc0003ff, 0xa0000030, &NMD::ADD_S , 0,
19222 CP1_ }, /* ADD.S */
19223 { reserved_block , 0 , 0 , 32,
19224 0xfc0003ff, 0xa0000230, 0 , 0,
19225 CP1_ }, /* ADD.fmt0~*(1) */
19226 };
19227
19228
19229 NMD::Pool NMD::SELEQZ_fmt[2] = {
19230 { instruction , 0 , 0 , 32,
19231 0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S , 0,
19232 CP1_ }, /* SELEQZ.S */
19233 { instruction , 0 , 0 , 32,
19234 0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D , 0,
19235 CP1_ }, /* SELEQZ.D */
19236 };
19237
19238
19239 NMD::Pool NMD::CLASS_fmt[2] = {
19240 { instruction , 0 , 0 , 32,
19241 0xfc0003ff, 0xa0000060, &NMD::CLASS_S , 0,
19242 CP1_ }, /* CLASS.S */
19243 { instruction , 0 , 0 , 32,
19244 0xfc0003ff, 0xa0000260, &NMD::CLASS_D , 0,
19245 CP1_ }, /* CLASS.D */
19246 };
19247
19248
19249 NMD::Pool NMD::SUB_fmt0[2] = {
19250 { instruction , 0 , 0 , 32,
19251 0xfc0003ff, 0xa0000070, &NMD::SUB_S , 0,
19252 CP1_ }, /* SUB.S */
19253 { reserved_block , 0 , 0 , 32,
19254 0xfc0003ff, 0xa0000270, 0 , 0,
19255 CP1_ }, /* SUB.fmt0~*(1) */
19256 };
19257
19258
19259 NMD::Pool NMD::SELNEZ_fmt[2] = {
19260 { instruction , 0 , 0 , 32,
19261 0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S , 0,
19262 CP1_ }, /* SELNEZ.S */
19263 { instruction , 0 , 0 , 32,
19264 0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D , 0,
19265 CP1_ }, /* SELNEZ.D */
19266 };
19267
19268
19269 NMD::Pool NMD::MUL_fmt0[2] = {
19270 { instruction , 0 , 0 , 32,
19271 0xfc0003ff, 0xa00000b0, &NMD::MUL_S , 0,
19272 CP1_ }, /* MUL.S */
19273 { reserved_block , 0 , 0 , 32,
19274 0xfc0003ff, 0xa00002b0, 0 , 0,
19275 CP1_ }, /* MUL.fmt0~*(1) */
19276 };
19277
19278
19279 NMD::Pool NMD::SEL_fmt[2] = {
19280 { instruction , 0 , 0 , 32,
19281 0xfc0003ff, 0xa00000b8, &NMD::SEL_S , 0,
19282 CP1_ }, /* SEL.S */
19283 { instruction , 0 , 0 , 32,
19284 0xfc0003ff, 0xa00002b8, &NMD::SEL_D , 0,
19285 CP1_ }, /* SEL.D */
19286 };
19287
19288
19289 NMD::Pool NMD::DIV_fmt0[2] = {
19290 { instruction , 0 , 0 , 32,
19291 0xfc0003ff, 0xa00000f0, &NMD::DIV_S , 0,
19292 CP1_ }, /* DIV.S */
19293 { reserved_block , 0 , 0 , 32,
19294 0xfc0003ff, 0xa00002f0, 0 , 0,
19295 CP1_ }, /* DIV.fmt0~*(1) */
19296 };
19297
19298
19299 NMD::Pool NMD::ADD_fmt1[2] = {
19300 { instruction , 0 , 0 , 32,
19301 0xfc0003ff, 0xa0000130, &NMD::ADD_D , 0,
19302 CP1_ }, /* ADD.D */
19303 { reserved_block , 0 , 0 , 32,
19304 0xfc0003ff, 0xa0000330, 0 , 0,
19305 CP1_ }, /* ADD.fmt1~*(1) */
19306 };
19307
19308
19309 NMD::Pool NMD::SUB_fmt1[2] = {
19310 { instruction , 0 , 0 , 32,
19311 0xfc0003ff, 0xa0000170, &NMD::SUB_D , 0,
19312 CP1_ }, /* SUB.D */
19313 { reserved_block , 0 , 0 , 32,
19314 0xfc0003ff, 0xa0000370, 0 , 0,
19315 CP1_ }, /* SUB.fmt1~*(1) */
19316 };
19317
19318
19319 NMD::Pool NMD::MUL_fmt1[2] = {
19320 { instruction , 0 , 0 , 32,
19321 0xfc0003ff, 0xa00001b0, &NMD::MUL_D , 0,
19322 CP1_ }, /* MUL.D */
19323 { reserved_block , 0 , 0 , 32,
19324 0xfc0003ff, 0xa00003b0, 0 , 0,
19325 CP1_ }, /* MUL.fmt1~*(1) */
19326 };
19327
19328
19329 NMD::Pool NMD::MADDF_fmt[2] = {
19330 { instruction , 0 , 0 , 32,
19331 0xfc0003ff, 0xa00001b8, &NMD::MADDF_S , 0,
19332 CP1_ }, /* MADDF.S */
19333 { instruction , 0 , 0 , 32,
19334 0xfc0003ff, 0xa00003b8, &NMD::MADDF_D , 0,
19335 CP1_ }, /* MADDF.D */
19336 };
19337
19338
19339 NMD::Pool NMD::DIV_fmt1[2] = {
19340 { instruction , 0 , 0 , 32,
19341 0xfc0003ff, 0xa00001f0, &NMD::DIV_D , 0,
19342 CP1_ }, /* DIV.D */
19343 { reserved_block , 0 , 0 , 32,
19344 0xfc0003ff, 0xa00003f0, 0 , 0,
19345 CP1_ }, /* DIV.fmt1~*(1) */
19346 };
19347
19348
19349 NMD::Pool NMD::MSUBF_fmt[2] = {
19350 { instruction , 0 , 0 , 32,
19351 0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S , 0,
19352 CP1_ }, /* MSUBF.S */
19353 { instruction , 0 , 0 , 32,
19354 0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D , 0,
19355 CP1_ }, /* MSUBF.D */
19356 };
19357
19358
19359 NMD::Pool NMD::POOL32F_0[64] = {
19360 { reserved_block , 0 , 0 , 32,
19361 0xfc0001ff, 0xa0000000, 0 , 0,
19362 CP1_ }, /* POOL32F_0~*(0) */
19363 { reserved_block , 0 , 0 , 32,
19364 0xfc0001ff, 0xa0000008, 0 , 0,
19365 CP1_ }, /* POOL32F_0~*(1) */
19366 { reserved_block , 0 , 0 , 32,
19367 0xfc0001ff, 0xa0000010, 0 , 0,
19368 CP1_ }, /* POOL32F_0~*(2) */
19369 { reserved_block , 0 , 0 , 32,
19370 0xfc0001ff, 0xa0000018, 0 , 0,
19371 CP1_ }, /* POOL32F_0~*(3) */
19372 { pool , RINT_fmt , 2 , 32,
19373 0xfc0001ff, 0xa0000020, 0 , 0,
19374 CP1_ }, /* RINT.fmt */
19375 { reserved_block , 0 , 0 , 32,
19376 0xfc0001ff, 0xa0000028, 0 , 0,
19377 CP1_ }, /* POOL32F_0~*(5) */
19378 { pool , ADD_fmt0 , 2 , 32,
19379 0xfc0001ff, 0xa0000030, 0 , 0,
19380 CP1_ }, /* ADD.fmt0 */
19381 { pool , SELEQZ_fmt , 2 , 32,
19382 0xfc0001ff, 0xa0000038, 0 , 0,
19383 CP1_ }, /* SELEQZ.fmt */
19384 { reserved_block , 0 , 0 , 32,
19385 0xfc0001ff, 0xa0000040, 0 , 0,
19386 CP1_ }, /* POOL32F_0~*(8) */
19387 { reserved_block , 0 , 0 , 32,
19388 0xfc0001ff, 0xa0000048, 0 , 0,
19389 CP1_ }, /* POOL32F_0~*(9) */
19390 { reserved_block , 0 , 0 , 32,
19391 0xfc0001ff, 0xa0000050, 0 , 0,
19392 CP1_ }, /* POOL32F_0~*(10) */
19393 { reserved_block , 0 , 0 , 32,
19394 0xfc0001ff, 0xa0000058, 0 , 0,
19395 CP1_ }, /* POOL32F_0~*(11) */
19396 { pool , CLASS_fmt , 2 , 32,
19397 0xfc0001ff, 0xa0000060, 0 , 0,
19398 CP1_ }, /* CLASS.fmt */
19399 { reserved_block , 0 , 0 , 32,
19400 0xfc0001ff, 0xa0000068, 0 , 0,
19401 CP1_ }, /* POOL32F_0~*(13) */
19402 { pool , SUB_fmt0 , 2 , 32,
19403 0xfc0001ff, 0xa0000070, 0 , 0,
19404 CP1_ }, /* SUB.fmt0 */
19405 { pool , SELNEZ_fmt , 2 , 32,
19406 0xfc0001ff, 0xa0000078, 0 , 0,
19407 CP1_ }, /* SELNEZ.fmt */
19408 { reserved_block , 0 , 0 , 32,
19409 0xfc0001ff, 0xa0000080, 0 , 0,
19410 CP1_ }, /* POOL32F_0~*(16) */
19411 { reserved_block , 0 , 0 , 32,
19412 0xfc0001ff, 0xa0000088, 0 , 0,
19413 CP1_ }, /* POOL32F_0~*(17) */
19414 { reserved_block , 0 , 0 , 32,
19415 0xfc0001ff, 0xa0000090, 0 , 0,
19416 CP1_ }, /* POOL32F_0~*(18) */
19417 { reserved_block , 0 , 0 , 32,
19418 0xfc0001ff, 0xa0000098, 0 , 0,
19419 CP1_ }, /* POOL32F_0~*(19) */
19420 { reserved_block , 0 , 0 , 32,
19421 0xfc0001ff, 0xa00000a0, 0 , 0,
19422 CP1_ }, /* POOL32F_0~*(20) */
19423 { reserved_block , 0 , 0 , 32,
19424 0xfc0001ff, 0xa00000a8, 0 , 0,
19425 CP1_ }, /* POOL32F_0~*(21) */
19426 { pool , MUL_fmt0 , 2 , 32,
19427 0xfc0001ff, 0xa00000b0, 0 , 0,
19428 CP1_ }, /* MUL.fmt0 */
19429 { pool , SEL_fmt , 2 , 32,
19430 0xfc0001ff, 0xa00000b8, 0 , 0,
19431 CP1_ }, /* SEL.fmt */
19432 { reserved_block , 0 , 0 , 32,
19433 0xfc0001ff, 0xa00000c0, 0 , 0,
19434 CP1_ }, /* POOL32F_0~*(24) */
19435 { reserved_block , 0 , 0 , 32,
19436 0xfc0001ff, 0xa00000c8, 0 , 0,
19437 CP1_ }, /* POOL32F_0~*(25) */
19438 { reserved_block , 0 , 0 , 32,
19439 0xfc0001ff, 0xa00000d0, 0 , 0,
19440 CP1_ }, /* POOL32F_0~*(26) */
19441 { reserved_block , 0 , 0 , 32,
19442 0xfc0001ff, 0xa00000d8, 0 , 0,
19443 CP1_ }, /* POOL32F_0~*(27) */
19444 { reserved_block , 0 , 0 , 32,
19445 0xfc0001ff, 0xa00000e0, 0 , 0,
19446 CP1_ }, /* POOL32F_0~*(28) */
19447 { reserved_block , 0 , 0 , 32,
19448 0xfc0001ff, 0xa00000e8, 0 , 0,
19449 CP1_ }, /* POOL32F_0~*(29) */
19450 { pool , DIV_fmt0 , 2 , 32,
19451 0xfc0001ff, 0xa00000f0, 0 , 0,
19452 CP1_ }, /* DIV.fmt0 */
19453 { reserved_block , 0 , 0 , 32,
19454 0xfc0001ff, 0xa00000f8, 0 , 0,
19455 CP1_ }, /* POOL32F_0~*(31) */
19456 { reserved_block , 0 , 0 , 32,
19457 0xfc0001ff, 0xa0000100, 0 , 0,
19458 CP1_ }, /* POOL32F_0~*(32) */
19459 { reserved_block , 0 , 0 , 32,
19460 0xfc0001ff, 0xa0000108, 0 , 0,
19461 CP1_ }, /* POOL32F_0~*(33) */
19462 { reserved_block , 0 , 0 , 32,
19463 0xfc0001ff, 0xa0000110, 0 , 0,
19464 CP1_ }, /* POOL32F_0~*(34) */
19465 { reserved_block , 0 , 0 , 32,
19466 0xfc0001ff, 0xa0000118, 0 , 0,
19467 CP1_ }, /* POOL32F_0~*(35) */
19468 { reserved_block , 0 , 0 , 32,
19469 0xfc0001ff, 0xa0000120, 0 , 0,
19470 CP1_ }, /* POOL32F_0~*(36) */
19471 { reserved_block , 0 , 0 , 32,
19472 0xfc0001ff, 0xa0000128, 0 , 0,
19473 CP1_ }, /* POOL32F_0~*(37) */
19474 { pool , ADD_fmt1 , 2 , 32,
19475 0xfc0001ff, 0xa0000130, 0 , 0,
19476 CP1_ }, /* ADD.fmt1 */
19477 { reserved_block , 0 , 0 , 32,
19478 0xfc0001ff, 0xa0000138, 0 , 0,
19479 CP1_ }, /* POOL32F_0~*(39) */
19480 { reserved_block , 0 , 0 , 32,
19481 0xfc0001ff, 0xa0000140, 0 , 0,
19482 CP1_ }, /* POOL32F_0~*(40) */
19483 { reserved_block , 0 , 0 , 32,
19484 0xfc0001ff, 0xa0000148, 0 , 0,
19485 CP1_ }, /* POOL32F_0~*(41) */
19486 { reserved_block , 0 , 0 , 32,
19487 0xfc0001ff, 0xa0000150, 0 , 0,
19488 CP1_ }, /* POOL32F_0~*(42) */
19489 { reserved_block , 0 , 0 , 32,
19490 0xfc0001ff, 0xa0000158, 0 , 0,
19491 CP1_ }, /* POOL32F_0~*(43) */
19492 { reserved_block , 0 , 0 , 32,
19493 0xfc0001ff, 0xa0000160, 0 , 0,
19494 CP1_ }, /* POOL32F_0~*(44) */
19495 { reserved_block , 0 , 0 , 32,
19496 0xfc0001ff, 0xa0000168, 0 , 0,
19497 CP1_ }, /* POOL32F_0~*(45) */
19498 { pool , SUB_fmt1 , 2 , 32,
19499 0xfc0001ff, 0xa0000170, 0 , 0,
19500 CP1_ }, /* SUB.fmt1 */
19501 { reserved_block , 0 , 0 , 32,
19502 0xfc0001ff, 0xa0000178, 0 , 0,
19503 CP1_ }, /* POOL32F_0~*(47) */
19504 { reserved_block , 0 , 0 , 32,
19505 0xfc0001ff, 0xa0000180, 0 , 0,
19506 CP1_ }, /* POOL32F_0~*(48) */
19507 { reserved_block , 0 , 0 , 32,
19508 0xfc0001ff, 0xa0000188, 0 , 0,
19509 CP1_ }, /* POOL32F_0~*(49) */
19510 { reserved_block , 0 , 0 , 32,
19511 0xfc0001ff, 0xa0000190, 0 , 0,
19512 CP1_ }, /* POOL32F_0~*(50) */
19513 { reserved_block , 0 , 0 , 32,
19514 0xfc0001ff, 0xa0000198, 0 , 0,
19515 CP1_ }, /* POOL32F_0~*(51) */
19516 { reserved_block , 0 , 0 , 32,
19517 0xfc0001ff, 0xa00001a0, 0 , 0,
19518 CP1_ }, /* POOL32F_0~*(52) */
19519 { reserved_block , 0 , 0 , 32,
19520 0xfc0001ff, 0xa00001a8, 0 , 0,
19521 CP1_ }, /* POOL32F_0~*(53) */
19522 { pool , MUL_fmt1 , 2 , 32,
19523 0xfc0001ff, 0xa00001b0, 0 , 0,
19524 CP1_ }, /* MUL.fmt1 */
19525 { pool , MADDF_fmt , 2 , 32,
19526 0xfc0001ff, 0xa00001b8, 0 , 0,
19527 CP1_ }, /* MADDF.fmt */
19528 { reserved_block , 0 , 0 , 32,
19529 0xfc0001ff, 0xa00001c0, 0 , 0,
19530 CP1_ }, /* POOL32F_0~*(56) */
19531 { reserved_block , 0 , 0 , 32,
19532 0xfc0001ff, 0xa00001c8, 0 , 0,
19533 CP1_ }, /* POOL32F_0~*(57) */
19534 { reserved_block , 0 , 0 , 32,
19535 0xfc0001ff, 0xa00001d0, 0 , 0,
19536 CP1_ }, /* POOL32F_0~*(58) */
19537 { reserved_block , 0 , 0 , 32,
19538 0xfc0001ff, 0xa00001d8, 0 , 0,
19539 CP1_ }, /* POOL32F_0~*(59) */
19540 { reserved_block , 0 , 0 , 32,
19541 0xfc0001ff, 0xa00001e0, 0 , 0,
19542 CP1_ }, /* POOL32F_0~*(60) */
19543 { reserved_block , 0 , 0 , 32,
19544 0xfc0001ff, 0xa00001e8, 0 , 0,
19545 CP1_ }, /* POOL32F_0~*(61) */
19546 { pool , DIV_fmt1 , 2 , 32,
19547 0xfc0001ff, 0xa00001f0, 0 , 0,
19548 CP1_ }, /* DIV.fmt1 */
19549 { pool , MSUBF_fmt , 2 , 32,
19550 0xfc0001ff, 0xa00001f8, 0 , 0,
19551 CP1_ }, /* MSUBF.fmt */
19552 };
19553
19554
19555 NMD::Pool NMD::MIN_fmt[2] = {
19556 { instruction , 0 , 0 , 32,
19557 0xfc00023f, 0xa0000003, &NMD::MIN_S , 0,
19558 CP1_ }, /* MIN.S */
19559 { instruction , 0 , 0 , 32,
19560 0xfc00023f, 0xa0000203, &NMD::MIN_D , 0,
19561 CP1_ }, /* MIN.D */
19562 };
19563
19564
19565 NMD::Pool NMD::MAX_fmt[2] = {
19566 { instruction , 0 , 0 , 32,
19567 0xfc00023f, 0xa000000b, &NMD::MAX_S , 0,
19568 CP1_ }, /* MAX.S */
19569 { instruction , 0 , 0 , 32,
19570 0xfc00023f, 0xa000020b, &NMD::MAX_D , 0,
19571 CP1_ }, /* MAX.D */
19572 };
19573
19574
19575 NMD::Pool NMD::MINA_fmt[2] = {
19576 { instruction , 0 , 0 , 32,
19577 0xfc00023f, 0xa0000023, &NMD::MINA_S , 0,
19578 CP1_ }, /* MINA.S */
19579 { instruction , 0 , 0 , 32,
19580 0xfc00023f, 0xa0000223, &NMD::MINA_D , 0,
19581 CP1_ }, /* MINA.D */
19582 };
19583
19584
19585 NMD::Pool NMD::MAXA_fmt[2] = {
19586 { instruction , 0 , 0 , 32,
19587 0xfc00023f, 0xa000002b, &NMD::MAXA_S , 0,
19588 CP1_ }, /* MAXA.S */
19589 { instruction , 0 , 0 , 32,
19590 0xfc00023f, 0xa000022b, &NMD::MAXA_D , 0,
19591 CP1_ }, /* MAXA.D */
19592 };
19593
19594
19595 NMD::Pool NMD::CVT_L_fmt[2] = {
19596 { instruction , 0 , 0 , 32,
19597 0xfc007fff, 0xa000013b, &NMD::CVT_L_S , 0,
19598 CP1_ }, /* CVT.L.S */
19599 { instruction , 0 , 0 , 32,
19600 0xfc007fff, 0xa000413b, &NMD::CVT_L_D , 0,
19601 CP1_ }, /* CVT.L.D */
19602 };
19603
19604
19605 NMD::Pool NMD::RSQRT_fmt[2] = {
19606 { instruction , 0 , 0 , 32,
19607 0xfc007fff, 0xa000023b, &NMD::RSQRT_S , 0,
19608 CP1_ }, /* RSQRT.S */
19609 { instruction , 0 , 0 , 32,
19610 0xfc007fff, 0xa000423b, &NMD::RSQRT_D , 0,
19611 CP1_ }, /* RSQRT.D */
19612 };
19613
19614
19615 NMD::Pool NMD::FLOOR_L_fmt[2] = {
19616 { instruction , 0 , 0 , 32,
19617 0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S , 0,
19618 CP1_ }, /* FLOOR.L.S */
19619 { instruction , 0 , 0 , 32,
19620 0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D , 0,
19621 CP1_ }, /* FLOOR.L.D */
19622 };
19623
19624
19625 NMD::Pool NMD::CVT_W_fmt[2] = {
19626 { instruction , 0 , 0 , 32,
19627 0xfc007fff, 0xa000093b, &NMD::CVT_W_S , 0,
19628 CP1_ }, /* CVT.W.S */
19629 { instruction , 0 , 0 , 32,
19630 0xfc007fff, 0xa000493b, &NMD::CVT_W_D , 0,
19631 CP1_ }, /* CVT.W.D */
19632 };
19633
19634
19635 NMD::Pool NMD::SQRT_fmt[2] = {
19636 { instruction , 0 , 0 , 32,
19637 0xfc007fff, 0xa0000a3b, &NMD::SQRT_S , 0,
19638 CP1_ }, /* SQRT.S */
19639 { instruction , 0 , 0 , 32,
19640 0xfc007fff, 0xa0004a3b, &NMD::SQRT_D , 0,
19641 CP1_ }, /* SQRT.D */
19642 };
19643
19644
19645 NMD::Pool NMD::FLOOR_W_fmt[2] = {
19646 { instruction , 0 , 0 , 32,
19647 0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S , 0,
19648 CP1_ }, /* FLOOR.W.S */
19649 { instruction , 0 , 0 , 32,
19650 0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D , 0,
19651 CP1_ }, /* FLOOR.W.D */
19652 };
19653
19654
19655 NMD::Pool NMD::RECIP_fmt[2] = {
19656 { instruction , 0 , 0 , 32,
19657 0xfc007fff, 0xa000123b, &NMD::RECIP_S , 0,
19658 CP1_ }, /* RECIP.S */
19659 { instruction , 0 , 0 , 32,
19660 0xfc007fff, 0xa000523b, &NMD::RECIP_D , 0,
19661 CP1_ }, /* RECIP.D */
19662 };
19663
19664
19665 NMD::Pool NMD::CEIL_L_fmt[2] = {
19666 { instruction , 0 , 0 , 32,
19667 0xfc007fff, 0xa000133b, &NMD::CEIL_L_S , 0,
19668 CP1_ }, /* CEIL.L.S */
19669 { instruction , 0 , 0 , 32,
19670 0xfc007fff, 0xa000533b, &NMD::CEIL_L_D , 0,
19671 CP1_ }, /* CEIL.L.D */
19672 };
19673
19674
19675 NMD::Pool NMD::CEIL_W_fmt[2] = {
19676 { instruction , 0 , 0 , 32,
19677 0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S , 0,
19678 CP1_ }, /* CEIL.W.S */
19679 { instruction , 0 , 0 , 32,
19680 0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D , 0,
19681 CP1_ }, /* CEIL.W.D */
19682 };
19683
19684
19685 NMD::Pool NMD::TRUNC_L_fmt[2] = {
19686 { instruction , 0 , 0 , 32,
19687 0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S , 0,
19688 CP1_ }, /* TRUNC.L.S */
19689 { instruction , 0 , 0 , 32,
19690 0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D , 0,
19691 CP1_ }, /* TRUNC.L.D */
19692 };
19693
19694
19695 NMD::Pool NMD::TRUNC_W_fmt[2] = {
19696 { instruction , 0 , 0 , 32,
19697 0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S , 0,
19698 CP1_ }, /* TRUNC.W.S */
19699 { instruction , 0 , 0 , 32,
19700 0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D , 0,
19701 CP1_ }, /* TRUNC.W.D */
19702 };
19703
19704
19705 NMD::Pool NMD::ROUND_L_fmt[2] = {
19706 { instruction , 0 , 0 , 32,
19707 0xfc007fff, 0xa000333b, &NMD::ROUND_L_S , 0,
19708 CP1_ }, /* ROUND.L.S */
19709 { instruction , 0 , 0 , 32,
19710 0xfc007fff, 0xa000733b, &NMD::ROUND_L_D , 0,
19711 CP1_ }, /* ROUND.L.D */
19712 };
19713
19714
19715 NMD::Pool NMD::ROUND_W_fmt[2] = {
19716 { instruction , 0 , 0 , 32,
19717 0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S , 0,
19718 CP1_ }, /* ROUND.W.S */
19719 { instruction , 0 , 0 , 32,
19720 0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D , 0,
19721 CP1_ }, /* ROUND.W.D */
19722 };
19723
19724
19725 NMD::Pool NMD::POOL32Fxf_0[64] = {
19726 { reserved_block , 0 , 0 , 32,
19727 0xfc003fff, 0xa000003b, 0 , 0,
19728 CP1_ }, /* POOL32Fxf_0~*(0) */
19729 { pool , CVT_L_fmt , 2 , 32,
19730 0xfc003fff, 0xa000013b, 0 , 0,
19731 CP1_ }, /* CVT.L.fmt */
19732 { pool , RSQRT_fmt , 2 , 32,
19733 0xfc003fff, 0xa000023b, 0 , 0,
19734 CP1_ }, /* RSQRT.fmt */
19735 { pool , FLOOR_L_fmt , 2 , 32,
19736 0xfc003fff, 0xa000033b, 0 , 0,
19737 CP1_ }, /* FLOOR.L.fmt */
19738 { reserved_block , 0 , 0 , 32,
19739 0xfc003fff, 0xa000043b, 0 , 0,
19740 CP1_ }, /* POOL32Fxf_0~*(4) */
19741 { reserved_block , 0 , 0 , 32,
19742 0xfc003fff, 0xa000053b, 0 , 0,
19743 CP1_ }, /* POOL32Fxf_0~*(5) */
19744 { reserved_block , 0 , 0 , 32,
19745 0xfc003fff, 0xa000063b, 0 , 0,
19746 CP1_ }, /* POOL32Fxf_0~*(6) */
19747 { reserved_block , 0 , 0 , 32,
19748 0xfc003fff, 0xa000073b, 0 , 0,
19749 CP1_ }, /* POOL32Fxf_0~*(7) */
19750 { reserved_block , 0 , 0 , 32,
19751 0xfc003fff, 0xa000083b, 0 , 0,
19752 CP1_ }, /* POOL32Fxf_0~*(8) */
19753 { pool , CVT_W_fmt , 2 , 32,
19754 0xfc003fff, 0xa000093b, 0 , 0,
19755 CP1_ }, /* CVT.W.fmt */
19756 { pool , SQRT_fmt , 2 , 32,
19757 0xfc003fff, 0xa0000a3b, 0 , 0,
19758 CP1_ }, /* SQRT.fmt */
19759 { pool , FLOOR_W_fmt , 2 , 32,
19760 0xfc003fff, 0xa0000b3b, 0 , 0,
19761 CP1_ }, /* FLOOR.W.fmt */
19762 { reserved_block , 0 , 0 , 32,
19763 0xfc003fff, 0xa0000c3b, 0 , 0,
19764 CP1_ }, /* POOL32Fxf_0~*(12) */
19765 { reserved_block , 0 , 0 , 32,
19766 0xfc003fff, 0xa0000d3b, 0 , 0,
19767 CP1_ }, /* POOL32Fxf_0~*(13) */
19768 { reserved_block , 0 , 0 , 32,
19769 0xfc003fff, 0xa0000e3b, 0 , 0,
19770 CP1_ }, /* POOL32Fxf_0~*(14) */
19771 { reserved_block , 0 , 0 , 32,
19772 0xfc003fff, 0xa0000f3b, 0 , 0,
19773 CP1_ }, /* POOL32Fxf_0~*(15) */
19774 { instruction , 0 , 0 , 32,
19775 0xfc003fff, 0xa000103b, &NMD::CFC1 , 0,
19776 CP1_ }, /* CFC1 */
19777 { reserved_block , 0 , 0 , 32,
19778 0xfc003fff, 0xa000113b, 0 , 0,
19779 CP1_ }, /* POOL32Fxf_0~*(17) */
19780 { pool , RECIP_fmt , 2 , 32,
19781 0xfc003fff, 0xa000123b, 0 , 0,
19782 CP1_ }, /* RECIP.fmt */
19783 { pool , CEIL_L_fmt , 2 , 32,
19784 0xfc003fff, 0xa000133b, 0 , 0,
19785 CP1_ }, /* CEIL.L.fmt */
19786 { reserved_block , 0 , 0 , 32,
19787 0xfc003fff, 0xa000143b, 0 , 0,
19788 CP1_ }, /* POOL32Fxf_0~*(20) */
19789 { reserved_block , 0 , 0 , 32,
19790 0xfc003fff, 0xa000153b, 0 , 0,
19791 CP1_ }, /* POOL32Fxf_0~*(21) */
19792 { reserved_block , 0 , 0 , 32,
19793 0xfc003fff, 0xa000163b, 0 , 0,
19794 CP1_ }, /* POOL32Fxf_0~*(22) */
19795 { reserved_block , 0 , 0 , 32,
19796 0xfc003fff, 0xa000173b, 0 , 0,
19797 CP1_ }, /* POOL32Fxf_0~*(23) */
19798 { instruction , 0 , 0 , 32,
19799 0xfc003fff, 0xa000183b, &NMD::CTC1 , 0,
19800 CP1_ }, /* CTC1 */
19801 { reserved_block , 0 , 0 , 32,
19802 0xfc003fff, 0xa000193b, 0 , 0,
19803 CP1_ }, /* POOL32Fxf_0~*(25) */
19804 { reserved_block , 0 , 0 , 32,
19805 0xfc003fff, 0xa0001a3b, 0 , 0,
19806 CP1_ }, /* POOL32Fxf_0~*(26) */
19807 { pool , CEIL_W_fmt , 2 , 32,
19808 0xfc003fff, 0xa0001b3b, 0 , 0,
19809 CP1_ }, /* CEIL.W.fmt */
19810 { reserved_block , 0 , 0 , 32,
19811 0xfc003fff, 0xa0001c3b, 0 , 0,
19812 CP1_ }, /* POOL32Fxf_0~*(28) */
19813 { reserved_block , 0 , 0 , 32,
19814 0xfc003fff, 0xa0001d3b, 0 , 0,
19815 CP1_ }, /* POOL32Fxf_0~*(29) */
19816 { reserved_block , 0 , 0 , 32,
19817 0xfc003fff, 0xa0001e3b, 0 , 0,
19818 CP1_ }, /* POOL32Fxf_0~*(30) */
19819 { reserved_block , 0 , 0 , 32,
19820 0xfc003fff, 0xa0001f3b, 0 , 0,
19821 CP1_ }, /* POOL32Fxf_0~*(31) */
19822 { instruction , 0 , 0 , 32,
19823 0xfc003fff, 0xa000203b, &NMD::MFC1 , 0,
19824 CP1_ }, /* MFC1 */
19825 { instruction , 0 , 0 , 32,
19826 0xfc003fff, 0xa000213b, &NMD::CVT_S_PL , 0,
19827 CP1_ }, /* CVT.S.PL */
19828 { reserved_block , 0 , 0 , 32,
19829 0xfc003fff, 0xa000223b, 0 , 0,
19830 CP1_ }, /* POOL32Fxf_0~*(34) */
19831 { pool , TRUNC_L_fmt , 2 , 32,
19832 0xfc003fff, 0xa000233b, 0 , 0,
19833 CP1_ }, /* TRUNC.L.fmt */
19834 { instruction , 0 , 0 , 32,
19835 0xfc003fff, 0xa000243b, &NMD::DMFC1 , 0,
19836 CP1_ | MIPS64_ }, /* DMFC1 */
19837 { reserved_block , 0 , 0 , 32,
19838 0xfc003fff, 0xa000253b, 0 , 0,
19839 CP1_ }, /* POOL32Fxf_0~*(37) */
19840 { reserved_block , 0 , 0 , 32,
19841 0xfc003fff, 0xa000263b, 0 , 0,
19842 CP1_ }, /* POOL32Fxf_0~*(38) */
19843 { reserved_block , 0 , 0 , 32,
19844 0xfc003fff, 0xa000273b, 0 , 0,
19845 CP1_ }, /* POOL32Fxf_0~*(39) */
19846 { instruction , 0 , 0 , 32,
19847 0xfc003fff, 0xa000283b, &NMD::MTC1 , 0,
19848 CP1_ }, /* MTC1 */
19849 { instruction , 0 , 0 , 32,
19850 0xfc003fff, 0xa000293b, &NMD::CVT_S_PU , 0,
19851 CP1_ }, /* CVT.S.PU */
19852 { reserved_block , 0 , 0 , 32,
19853 0xfc003fff, 0xa0002a3b, 0 , 0,
19854 CP1_ }, /* POOL32Fxf_0~*(42) */
19855 { pool , TRUNC_W_fmt , 2 , 32,
19856 0xfc003fff, 0xa0002b3b, 0 , 0,
19857 CP1_ }, /* TRUNC.W.fmt */
19858 { instruction , 0 , 0 , 32,
19859 0xfc003fff, 0xa0002c3b, &NMD::DMTC1 , 0,
19860 CP1_ | MIPS64_ }, /* DMTC1 */
19861 { reserved_block , 0 , 0 , 32,
19862 0xfc003fff, 0xa0002d3b, 0 , 0,
19863 CP1_ }, /* POOL32Fxf_0~*(45) */
19864 { reserved_block , 0 , 0 , 32,
19865 0xfc003fff, 0xa0002e3b, 0 , 0,
19866 CP1_ }, /* POOL32Fxf_0~*(46) */
19867 { reserved_block , 0 , 0 , 32,
19868 0xfc003fff, 0xa0002f3b, 0 , 0,
19869 CP1_ }, /* POOL32Fxf_0~*(47) */
19870 { instruction , 0 , 0 , 32,
19871 0xfc003fff, 0xa000303b, &NMD::MFHC1 , 0,
19872 CP1_ }, /* MFHC1 */
19873 { reserved_block , 0 , 0 , 32,
19874 0xfc003fff, 0xa000313b, 0 , 0,
19875 CP1_ }, /* POOL32Fxf_0~*(49) */
19876 { reserved_block , 0 , 0 , 32,
19877 0xfc003fff, 0xa000323b, 0 , 0,
19878 CP1_ }, /* POOL32Fxf_0~*(50) */
19879 { pool , ROUND_L_fmt , 2 , 32,
19880 0xfc003fff, 0xa000333b, 0 , 0,
19881 CP1_ }, /* ROUND.L.fmt */
19882 { reserved_block , 0 , 0 , 32,
19883 0xfc003fff, 0xa000343b, 0 , 0,
19884 CP1_ }, /* POOL32Fxf_0~*(52) */
19885 { reserved_block , 0 , 0 , 32,
19886 0xfc003fff, 0xa000353b, 0 , 0,
19887 CP1_ }, /* POOL32Fxf_0~*(53) */
19888 { reserved_block , 0 , 0 , 32,
19889 0xfc003fff, 0xa000363b, 0 , 0,
19890 CP1_ }, /* POOL32Fxf_0~*(54) */
19891 { reserved_block , 0 , 0 , 32,
19892 0xfc003fff, 0xa000373b, 0 , 0,
19893 CP1_ }, /* POOL32Fxf_0~*(55) */
19894 { instruction , 0 , 0 , 32,
19895 0xfc003fff, 0xa000383b, &NMD::MTHC1 , 0,
19896 CP1_ }, /* MTHC1 */
19897 { reserved_block , 0 , 0 , 32,
19898 0xfc003fff, 0xa000393b, 0 , 0,
19899 CP1_ }, /* POOL32Fxf_0~*(57) */
19900 { reserved_block , 0 , 0 , 32,
19901 0xfc003fff, 0xa0003a3b, 0 , 0,
19902 CP1_ }, /* POOL32Fxf_0~*(58) */
19903 { pool , ROUND_W_fmt , 2 , 32,
19904 0xfc003fff, 0xa0003b3b, 0 , 0,
19905 CP1_ }, /* ROUND.W.fmt */
19906 { reserved_block , 0 , 0 , 32,
19907 0xfc003fff, 0xa0003c3b, 0 , 0,
19908 CP1_ }, /* POOL32Fxf_0~*(60) */
19909 { reserved_block , 0 , 0 , 32,
19910 0xfc003fff, 0xa0003d3b, 0 , 0,
19911 CP1_ }, /* POOL32Fxf_0~*(61) */
19912 { reserved_block , 0 , 0 , 32,
19913 0xfc003fff, 0xa0003e3b, 0 , 0,
19914 CP1_ }, /* POOL32Fxf_0~*(62) */
19915 { reserved_block , 0 , 0 , 32,
19916 0xfc003fff, 0xa0003f3b, 0 , 0,
19917 CP1_ }, /* POOL32Fxf_0~*(63) */
19918 };
19919
19920
19921 NMD::Pool NMD::MOV_fmt[4] = {
19922 { instruction , 0 , 0 , 32,
19923 0xfc007fff, 0xa000007b, &NMD::MOV_S , 0,
19924 CP1_ }, /* MOV.S */
19925 { instruction , 0 , 0 , 32,
19926 0xfc007fff, 0xa000207b, &NMD::MOV_D , 0,
19927 CP1_ }, /* MOV.D */
19928 { reserved_block , 0 , 0 , 32,
19929 0xfc007fff, 0xa000407b, 0 , 0,
19930 CP1_ }, /* MOV.fmt~*(2) */
19931 { reserved_block , 0 , 0 , 32,
19932 0xfc007fff, 0xa000607b, 0 , 0,
19933 CP1_ }, /* MOV.fmt~*(3) */
19934 };
19935
19936
19937 NMD::Pool NMD::ABS_fmt[4] = {
19938 { instruction , 0 , 0 , 32,
19939 0xfc007fff, 0xa000037b, &NMD::ABS_S , 0,
19940 CP1_ }, /* ABS.S */
19941 { instruction , 0 , 0 , 32,
19942 0xfc007fff, 0xa000237b, &NMD::ABS_D , 0,
19943 CP1_ }, /* ABS.D */
19944 { reserved_block , 0 , 0 , 32,
19945 0xfc007fff, 0xa000437b, 0 , 0,
19946 CP1_ }, /* ABS.fmt~*(2) */
19947 { reserved_block , 0 , 0 , 32,
19948 0xfc007fff, 0xa000637b, 0 , 0,
19949 CP1_ }, /* ABS.fmt~*(3) */
19950 };
19951
19952
19953 NMD::Pool NMD::NEG_fmt[4] = {
19954 { instruction , 0 , 0 , 32,
19955 0xfc007fff, 0xa0000b7b, &NMD::NEG_S , 0,
19956 CP1_ }, /* NEG.S */
19957 { instruction , 0 , 0 , 32,
19958 0xfc007fff, 0xa0002b7b, &NMD::NEG_D , 0,
19959 CP1_ }, /* NEG.D */
19960 { reserved_block , 0 , 0 , 32,
19961 0xfc007fff, 0xa0004b7b, 0 , 0,
19962 CP1_ }, /* NEG.fmt~*(2) */
19963 { reserved_block , 0 , 0 , 32,
19964 0xfc007fff, 0xa0006b7b, 0 , 0,
19965 CP1_ }, /* NEG.fmt~*(3) */
19966 };
19967
19968
19969 NMD::Pool NMD::CVT_D_fmt[4] = {
19970 { instruction , 0 , 0 , 32,
19971 0xfc007fff, 0xa000137b, &NMD::CVT_D_S , 0,
19972 CP1_ }, /* CVT.D.S */
19973 { instruction , 0 , 0 , 32,
19974 0xfc007fff, 0xa000337b, &NMD::CVT_D_W , 0,
19975 CP1_ }, /* CVT.D.W */
19976 { instruction , 0 , 0 , 32,
19977 0xfc007fff, 0xa000537b, &NMD::CVT_D_L , 0,
19978 CP1_ }, /* CVT.D.L */
19979 { reserved_block , 0 , 0 , 32,
19980 0xfc007fff, 0xa000737b, 0 , 0,
19981 CP1_ }, /* CVT.D.fmt~*(3) */
19982 };
19983
19984
19985 NMD::Pool NMD::CVT_S_fmt[4] = {
19986 { instruction , 0 , 0 , 32,
19987 0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D , 0,
19988 CP1_ }, /* CVT.S.D */
19989 { instruction , 0 , 0 , 32,
19990 0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W , 0,
19991 CP1_ }, /* CVT.S.W */
19992 { instruction , 0 , 0 , 32,
19993 0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L , 0,
19994 CP1_ }, /* CVT.S.L */
19995 { reserved_block , 0 , 0 , 32,
19996 0xfc007fff, 0xa0007b7b, 0 , 0,
19997 CP1_ }, /* CVT.S.fmt~*(3) */
19998 };
19999
20000
20001 NMD::Pool NMD::POOL32Fxf_1[32] = {
20002 { pool , MOV_fmt , 4 , 32,
20003 0xfc001fff, 0xa000007b, 0 , 0,
20004 CP1_ }, /* MOV.fmt */
20005 { reserved_block , 0 , 0 , 32,
20006 0xfc001fff, 0xa000017b, 0 , 0,
20007 CP1_ }, /* POOL32Fxf_1~*(1) */
20008 { reserved_block , 0 , 0 , 32,
20009 0xfc001fff, 0xa000027b, 0 , 0,
20010 CP1_ }, /* POOL32Fxf_1~*(2) */
20011 { pool , ABS_fmt , 4 , 32,
20012 0xfc001fff, 0xa000037b, 0 , 0,
20013 CP1_ }, /* ABS.fmt */
20014 { reserved_block , 0 , 0 , 32,
20015 0xfc001fff, 0xa000047b, 0 , 0,
20016 CP1_ }, /* POOL32Fxf_1~*(4) */
20017 { reserved_block , 0 , 0 , 32,
20018 0xfc001fff, 0xa000057b, 0 , 0,
20019 CP1_ }, /* POOL32Fxf_1~*(5) */
20020 { reserved_block , 0 , 0 , 32,
20021 0xfc001fff, 0xa000067b, 0 , 0,
20022 CP1_ }, /* POOL32Fxf_1~*(6) */
20023 { reserved_block , 0 , 0 , 32,
20024 0xfc001fff, 0xa000077b, 0 , 0,
20025 CP1_ }, /* POOL32Fxf_1~*(7) */
20026 { reserved_block , 0 , 0 , 32,
20027 0xfc001fff, 0xa000087b, 0 , 0,
20028 CP1_ }, /* POOL32Fxf_1~*(8) */
20029 { reserved_block , 0 , 0 , 32,
20030 0xfc001fff, 0xa000097b, 0 , 0,
20031 CP1_ }, /* POOL32Fxf_1~*(9) */
20032 { reserved_block , 0 , 0 , 32,
20033 0xfc001fff, 0xa0000a7b, 0 , 0,
20034 CP1_ }, /* POOL32Fxf_1~*(10) */
20035 { pool , NEG_fmt , 4 , 32,
20036 0xfc001fff, 0xa0000b7b, 0 , 0,
20037 CP1_ }, /* NEG.fmt */
20038 { reserved_block , 0 , 0 , 32,
20039 0xfc001fff, 0xa0000c7b, 0 , 0,
20040 CP1_ }, /* POOL32Fxf_1~*(12) */
20041 { reserved_block , 0 , 0 , 32,
20042 0xfc001fff, 0xa0000d7b, 0 , 0,
20043 CP1_ }, /* POOL32Fxf_1~*(13) */
20044 { reserved_block , 0 , 0 , 32,
20045 0xfc001fff, 0xa0000e7b, 0 , 0,
20046 CP1_ }, /* POOL32Fxf_1~*(14) */
20047 { reserved_block , 0 , 0 , 32,
20048 0xfc001fff, 0xa0000f7b, 0 , 0,
20049 CP1_ }, /* POOL32Fxf_1~*(15) */
20050 { reserved_block , 0 , 0 , 32,
20051 0xfc001fff, 0xa000107b, 0 , 0,
20052 CP1_ }, /* POOL32Fxf_1~*(16) */
20053 { reserved_block , 0 , 0 , 32,
20054 0xfc001fff, 0xa000117b, 0 , 0,
20055 CP1_ }, /* POOL32Fxf_1~*(17) */
20056 { reserved_block , 0 , 0 , 32,
20057 0xfc001fff, 0xa000127b, 0 , 0,
20058 CP1_ }, /* POOL32Fxf_1~*(18) */
20059 { pool , CVT_D_fmt , 4 , 32,
20060 0xfc001fff, 0xa000137b, 0 , 0,
20061 CP1_ }, /* CVT.D.fmt */
20062 { reserved_block , 0 , 0 , 32,
20063 0xfc001fff, 0xa000147b, 0 , 0,
20064 CP1_ }, /* POOL32Fxf_1~*(20) */
20065 { reserved_block , 0 , 0 , 32,
20066 0xfc001fff, 0xa000157b, 0 , 0,
20067 CP1_ }, /* POOL32Fxf_1~*(21) */
20068 { reserved_block , 0 , 0 , 32,
20069 0xfc001fff, 0xa000167b, 0 , 0,
20070 CP1_ }, /* POOL32Fxf_1~*(22) */
20071 { reserved_block , 0 , 0 , 32,
20072 0xfc001fff, 0xa000177b, 0 , 0,
20073 CP1_ }, /* POOL32Fxf_1~*(23) */
20074 { reserved_block , 0 , 0 , 32,
20075 0xfc001fff, 0xa000187b, 0 , 0,
20076 CP1_ }, /* POOL32Fxf_1~*(24) */
20077 { reserved_block , 0 , 0 , 32,
20078 0xfc001fff, 0xa000197b, 0 , 0,
20079 CP1_ }, /* POOL32Fxf_1~*(25) */
20080 { reserved_block , 0 , 0 , 32,
20081 0xfc001fff, 0xa0001a7b, 0 , 0,
20082 CP1_ }, /* POOL32Fxf_1~*(26) */
20083 { pool , CVT_S_fmt , 4 , 32,
20084 0xfc001fff, 0xa0001b7b, 0 , 0,
20085 CP1_ }, /* CVT.S.fmt */
20086 { reserved_block , 0 , 0 , 32,
20087 0xfc001fff, 0xa0001c7b, 0 , 0,
20088 CP1_ }, /* POOL32Fxf_1~*(28) */
20089 { reserved_block , 0 , 0 , 32,
20090 0xfc001fff, 0xa0001d7b, 0 , 0,
20091 CP1_ }, /* POOL32Fxf_1~*(29) */
20092 { reserved_block , 0 , 0 , 32,
20093 0xfc001fff, 0xa0001e7b, 0 , 0,
20094 CP1_ }, /* POOL32Fxf_1~*(30) */
20095 { reserved_block , 0 , 0 , 32,
20096 0xfc001fff, 0xa0001f7b, 0 , 0,
20097 CP1_ }, /* POOL32Fxf_1~*(31) */
20098 };
20099
20100
20101 NMD::Pool NMD::POOL32Fxf[4] = {
20102 { pool , POOL32Fxf_0 , 64 , 32,
20103 0xfc0000ff, 0xa000003b, 0 , 0,
20104 CP1_ }, /* POOL32Fxf_0 */
20105 { pool , POOL32Fxf_1 , 32 , 32,
20106 0xfc0000ff, 0xa000007b, 0 , 0,
20107 CP1_ }, /* POOL32Fxf_1 */
20108 { reserved_block , 0 , 0 , 32,
20109 0xfc0000ff, 0xa00000bb, 0 , 0,
20110 CP1_ }, /* POOL32Fxf~*(2) */
20111 { reserved_block , 0 , 0 , 32,
20112 0xfc0000ff, 0xa00000fb, 0 , 0,
20113 CP1_ }, /* POOL32Fxf~*(3) */
20114 };
20115
20116
20117 NMD::Pool NMD::POOL32F_3[8] = {
20118 { pool , MIN_fmt , 2 , 32,
20119 0xfc00003f, 0xa0000003, 0 , 0,
20120 CP1_ }, /* MIN.fmt */
20121 { pool , MAX_fmt , 2 , 32,
20122 0xfc00003f, 0xa000000b, 0 , 0,
20123 CP1_ }, /* MAX.fmt */
20124 { reserved_block , 0 , 0 , 32,
20125 0xfc00003f, 0xa0000013, 0 , 0,
20126 CP1_ }, /* POOL32F_3~*(2) */
20127 { reserved_block , 0 , 0 , 32,
20128 0xfc00003f, 0xa000001b, 0 , 0,
20129 CP1_ }, /* POOL32F_3~*(3) */
20130 { pool , MINA_fmt , 2 , 32,
20131 0xfc00003f, 0xa0000023, 0 , 0,
20132 CP1_ }, /* MINA.fmt */
20133 { pool , MAXA_fmt , 2 , 32,
20134 0xfc00003f, 0xa000002b, 0 , 0,
20135 CP1_ }, /* MAXA.fmt */
20136 { reserved_block , 0 , 0 , 32,
20137 0xfc00003f, 0xa0000033, 0 , 0,
20138 CP1_ }, /* POOL32F_3~*(6) */
20139 { pool , POOL32Fxf , 4 , 32,
20140 0xfc00003f, 0xa000003b, 0 , 0,
20141 CP1_ }, /* POOL32Fxf */
20142 };
20143
20144
20145 NMD::Pool NMD::CMP_condn_S[32] = {
20146 { instruction , 0 , 0 , 32,
20147 0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S , 0,
20148 CP1_ }, /* CMP.AF.S */
20149 { instruction , 0 , 0 , 32,
20150 0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S , 0,
20151 CP1_ }, /* CMP.UN.S */
20152 { instruction , 0 , 0 , 32,
20153 0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S , 0,
20154 CP1_ }, /* CMP.EQ.S */
20155 { instruction , 0 , 0 , 32,
20156 0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S , 0,
20157 CP1_ }, /* CMP.UEQ.S */
20158 { instruction , 0 , 0 , 32,
20159 0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S , 0,
20160 CP1_ }, /* CMP.LT.S */
20161 { instruction , 0 , 0 , 32,
20162 0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S , 0,
20163 CP1_ }, /* CMP.ULT.S */
20164 { instruction , 0 , 0 , 32,
20165 0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S , 0,
20166 CP1_ }, /* CMP.LE.S */
20167 { instruction , 0 , 0 , 32,
20168 0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S , 0,
20169 CP1_ }, /* CMP.ULE.S */
20170 { instruction , 0 , 0 , 32,
20171 0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S , 0,
20172 CP1_ }, /* CMP.SAF.S */
20173 { instruction , 0 , 0 , 32,
20174 0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S , 0,
20175 CP1_ }, /* CMP.SUN.S */
20176 { instruction , 0 , 0 , 32,
20177 0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S , 0,
20178 CP1_ }, /* CMP.SEQ.S */
20179 { instruction , 0 , 0 , 32,
20180 0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S , 0,
20181 CP1_ }, /* CMP.SUEQ.S */
20182 { instruction , 0 , 0 , 32,
20183 0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S , 0,
20184 CP1_ }, /* CMP.SLT.S */
20185 { instruction , 0 , 0 , 32,
20186 0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S , 0,
20187 CP1_ }, /* CMP.SULT.S */
20188 { instruction , 0 , 0 , 32,
20189 0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S , 0,
20190 CP1_ }, /* CMP.SLE.S */
20191 { instruction , 0 , 0 , 32,
20192 0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S , 0,
20193 CP1_ }, /* CMP.SULE.S */
20194 { reserved_block , 0 , 0 , 32,
20195 0xfc0007ff, 0xa0000405, 0 , 0,
20196 CP1_ }, /* CMP.condn.S~*(16) */
20197 { instruction , 0 , 0 , 32,
20198 0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S , 0,
20199 CP1_ }, /* CMP.OR.S */
20200 { instruction , 0 , 0 , 32,
20201 0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S , 0,
20202 CP1_ }, /* CMP.UNE.S */
20203 { instruction , 0 , 0 , 32,
20204 0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S , 0,
20205 CP1_ }, /* CMP.NE.S */
20206 { reserved_block , 0 , 0 , 32,
20207 0xfc0007ff, 0xa0000505, 0 , 0,
20208 CP1_ }, /* CMP.condn.S~*(20) */
20209 { reserved_block , 0 , 0 , 32,
20210 0xfc0007ff, 0xa0000545, 0 , 0,
20211 CP1_ }, /* CMP.condn.S~*(21) */
20212 { reserved_block , 0 , 0 , 32,
20213 0xfc0007ff, 0xa0000585, 0 , 0,
20214 CP1_ }, /* CMP.condn.S~*(22) */
20215 { reserved_block , 0 , 0 , 32,
20216 0xfc0007ff, 0xa00005c5, 0 , 0,
20217 CP1_ }, /* CMP.condn.S~*(23) */
20218 { reserved_block , 0 , 0 , 32,
20219 0xfc0007ff, 0xa0000605, 0 , 0,
20220 CP1_ }, /* CMP.condn.S~*(24) */
20221 { instruction , 0 , 0 , 32,
20222 0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S , 0,
20223 CP1_ }, /* CMP.SOR.S */
20224 { instruction , 0 , 0 , 32,
20225 0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S , 0,
20226 CP1_ }, /* CMP.SUNE.S */
20227 { instruction , 0 , 0 , 32,
20228 0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S , 0,
20229 CP1_ }, /* CMP.SNE.S */
20230 { reserved_block , 0 , 0 , 32,
20231 0xfc0007ff, 0xa0000705, 0 , 0,
20232 CP1_ }, /* CMP.condn.S~*(28) */
20233 { reserved_block , 0 , 0 , 32,
20234 0xfc0007ff, 0xa0000745, 0 , 0,
20235 CP1_ }, /* CMP.condn.S~*(29) */
20236 { reserved_block , 0 , 0 , 32,
20237 0xfc0007ff, 0xa0000785, 0 , 0,
20238 CP1_ }, /* CMP.condn.S~*(30) */
20239 { reserved_block , 0 , 0 , 32,
20240 0xfc0007ff, 0xa00007c5, 0 , 0,
20241 CP1_ }, /* CMP.condn.S~*(31) */
20242 };
20243
20244
20245 NMD::Pool NMD::CMP_condn_D[32] = {
20246 { instruction , 0 , 0 , 32,
20247 0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D , 0,
20248 CP1_ }, /* CMP.AF.D */
20249 { instruction , 0 , 0 , 32,
20250 0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D , 0,
20251 CP1_ }, /* CMP.UN.D */
20252 { instruction , 0 , 0 , 32,
20253 0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D , 0,
20254 CP1_ }, /* CMP.EQ.D */
20255 { instruction , 0 , 0 , 32,
20256 0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D , 0,
20257 CP1_ }, /* CMP.UEQ.D */
20258 { instruction , 0 , 0 , 32,
20259 0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D , 0,
20260 CP1_ }, /* CMP.LT.D */
20261 { instruction , 0 , 0 , 32,
20262 0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D , 0,
20263 CP1_ }, /* CMP.ULT.D */
20264 { instruction , 0 , 0 , 32,
20265 0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D , 0,
20266 CP1_ }, /* CMP.LE.D */
20267 { instruction , 0 , 0 , 32,
20268 0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D , 0,
20269 CP1_ }, /* CMP.ULE.D */
20270 { instruction , 0 , 0 , 32,
20271 0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D , 0,
20272 CP1_ }, /* CMP.SAF.D */
20273 { instruction , 0 , 0 , 32,
20274 0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D , 0,
20275 CP1_ }, /* CMP.SUN.D */
20276 { instruction , 0 , 0 , 32,
20277 0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D , 0,
20278 CP1_ }, /* CMP.SEQ.D */
20279 { instruction , 0 , 0 , 32,
20280 0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D , 0,
20281 CP1_ }, /* CMP.SUEQ.D */
20282 { instruction , 0 , 0 , 32,
20283 0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D , 0,
20284 CP1_ }, /* CMP.SLT.D */
20285 { instruction , 0 , 0 , 32,
20286 0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D , 0,
20287 CP1_ }, /* CMP.SULT.D */
20288 { instruction , 0 , 0 , 32,
20289 0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D , 0,
20290 CP1_ }, /* CMP.SLE.D */
20291 { instruction , 0 , 0 , 32,
20292 0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D , 0,
20293 CP1_ }, /* CMP.SULE.D */
20294 { reserved_block , 0 , 0 , 32,
20295 0xfc0007ff, 0xa0000415, 0 , 0,
20296 CP1_ }, /* CMP.condn.D~*(16) */
20297 { instruction , 0 , 0 , 32,
20298 0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D , 0,
20299 CP1_ }, /* CMP.OR.D */
20300 { instruction , 0 , 0 , 32,
20301 0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D , 0,
20302 CP1_ }, /* CMP.UNE.D */
20303 { instruction , 0 , 0 , 32,
20304 0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D , 0,
20305 CP1_ }, /* CMP.NE.D */
20306 { reserved_block , 0 , 0 , 32,
20307 0xfc0007ff, 0xa0000515, 0 , 0,
20308 CP1_ }, /* CMP.condn.D~*(20) */
20309 { reserved_block , 0 , 0 , 32,
20310 0xfc0007ff, 0xa0000555, 0 , 0,
20311 CP1_ }, /* CMP.condn.D~*(21) */
20312 { reserved_block , 0 , 0 , 32,
20313 0xfc0007ff, 0xa0000595, 0 , 0,
20314 CP1_ }, /* CMP.condn.D~*(22) */
20315 { reserved_block , 0 , 0 , 32,
20316 0xfc0007ff, 0xa00005d5, 0 , 0,
20317 CP1_ }, /* CMP.condn.D~*(23) */
20318 { reserved_block , 0 , 0 , 32,
20319 0xfc0007ff, 0xa0000615, 0 , 0,
20320 CP1_ }, /* CMP.condn.D~*(24) */
20321 { instruction , 0 , 0 , 32,
20322 0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D , 0,
20323 CP1_ }, /* CMP.SOR.D */
20324 { instruction , 0 , 0 , 32,
20325 0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D , 0,
20326 CP1_ }, /* CMP.SUNE.D */
20327 { instruction , 0 , 0 , 32,
20328 0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D , 0,
20329 CP1_ }, /* CMP.SNE.D */
20330 { reserved_block , 0 , 0 , 32,
20331 0xfc0007ff, 0xa0000715, 0 , 0,
20332 CP1_ }, /* CMP.condn.D~*(28) */
20333 { reserved_block , 0 , 0 , 32,
20334 0xfc0007ff, 0xa0000755, 0 , 0,
20335 CP1_ }, /* CMP.condn.D~*(29) */
20336 { reserved_block , 0 , 0 , 32,
20337 0xfc0007ff, 0xa0000795, 0 , 0,
20338 CP1_ }, /* CMP.condn.D~*(30) */
20339 { reserved_block , 0 , 0 , 32,
20340 0xfc0007ff, 0xa00007d5, 0 , 0,
20341 CP1_ }, /* CMP.condn.D~*(31) */
20342 };
20343
20344
20345 NMD::Pool NMD::POOL32F_5[8] = {
20346 { pool , CMP_condn_S , 32 , 32,
20347 0xfc00003f, 0xa0000005, 0 , 0,
20348 CP1_ }, /* CMP.condn.S */
20349 { reserved_block , 0 , 0 , 32,
20350 0xfc00003f, 0xa000000d, 0 , 0,
20351 CP1_ }, /* POOL32F_5~*(1) */
20352 { pool , CMP_condn_D , 32 , 32,
20353 0xfc00003f, 0xa0000015, 0 , 0,
20354 CP1_ }, /* CMP.condn.D */
20355 { reserved_block , 0 , 0 , 32,
20356 0xfc00003f, 0xa000001d, 0 , 0,
20357 CP1_ }, /* POOL32F_5~*(3) */
20358 { reserved_block , 0 , 0 , 32,
20359 0xfc00003f, 0xa0000025, 0 , 0,
20360 CP1_ }, /* POOL32F_5~*(4) */
20361 { reserved_block , 0 , 0 , 32,
20362 0xfc00003f, 0xa000002d, 0 , 0,
20363 CP1_ }, /* POOL32F_5~*(5) */
20364 { reserved_block , 0 , 0 , 32,
20365 0xfc00003f, 0xa0000035, 0 , 0,
20366 CP1_ }, /* POOL32F_5~*(6) */
20367 { reserved_block , 0 , 0 , 32,
20368 0xfc00003f, 0xa000003d, 0 , 0,
20369 CP1_ }, /* POOL32F_5~*(7) */
20370 };
20371
20372
20373 NMD::Pool NMD::POOL32F[8] = {
20374 { pool , POOL32F_0 , 64 , 32,
20375 0xfc000007, 0xa0000000, 0 , 0,
20376 CP1_ }, /* POOL32F_0 */
20377 { reserved_block , 0 , 0 , 32,
20378 0xfc000007, 0xa0000001, 0 , 0,
20379 CP1_ }, /* POOL32F~*(1) */
20380 { reserved_block , 0 , 0 , 32,
20381 0xfc000007, 0xa0000002, 0 , 0,
20382 CP1_ }, /* POOL32F~*(2) */
20383 { pool , POOL32F_3 , 8 , 32,
20384 0xfc000007, 0xa0000003, 0 , 0,
20385 CP1_ }, /* POOL32F_3 */
20386 { reserved_block , 0 , 0 , 32,
20387 0xfc000007, 0xa0000004, 0 , 0,
20388 CP1_ }, /* POOL32F~*(4) */
20389 { pool , POOL32F_5 , 8 , 32,
20390 0xfc000007, 0xa0000005, 0 , 0,
20391 CP1_ }, /* POOL32F_5 */
20392 { reserved_block , 0 , 0 , 32,
20393 0xfc000007, 0xa0000006, 0 , 0,
20394 CP1_ }, /* POOL32F~*(6) */
20395 { reserved_block , 0 , 0 , 32,
20396 0xfc000007, 0xa0000007, 0 , 0,
20397 CP1_ }, /* POOL32F~*(7) */
20398 };
20399
20400
20401 NMD::Pool NMD::POOL32S_0[64] = {
20402 { reserved_block , 0 , 0 , 32,
20403 0xfc0001ff, 0xc0000000, 0 , 0,
20404 0x0 }, /* POOL32S_0~*(0) */
20405 { instruction , 0 , 0 , 32,
20406 0xfc0001ff, 0xc0000008, &NMD::DLSA , 0,
20407 MIPS64_ }, /* DLSA */
20408 { instruction , 0 , 0 , 32,
20409 0xfc0001ff, 0xc0000010, &NMD::DSLLV , 0,
20410 MIPS64_ }, /* DSLLV */
20411 { instruction , 0 , 0 , 32,
20412 0xfc0001ff, 0xc0000018, &NMD::DMUL , 0,
20413 MIPS64_ }, /* DMUL */
20414 { reserved_block , 0 , 0 , 32,
20415 0xfc0001ff, 0xc0000020, 0 , 0,
20416 0x0 }, /* POOL32S_0~*(4) */
20417 { reserved_block , 0 , 0 , 32,
20418 0xfc0001ff, 0xc0000028, 0 , 0,
20419 0x0 }, /* POOL32S_0~*(5) */
20420 { reserved_block , 0 , 0 , 32,
20421 0xfc0001ff, 0xc0000030, 0 , 0,
20422 0x0 }, /* POOL32S_0~*(6) */
20423 { reserved_block , 0 , 0 , 32,
20424 0xfc0001ff, 0xc0000038, 0 , 0,
20425 0x0 }, /* POOL32S_0~*(7) */
20426 { reserved_block , 0 , 0 , 32,
20427 0xfc0001ff, 0xc0000040, 0 , 0,
20428 0x0 }, /* POOL32S_0~*(8) */
20429 { reserved_block , 0 , 0 , 32,
20430 0xfc0001ff, 0xc0000048, 0 , 0,
20431 0x0 }, /* POOL32S_0~*(9) */
20432 { instruction , 0 , 0 , 32,
20433 0xfc0001ff, 0xc0000050, &NMD::DSRLV , 0,
20434 MIPS64_ }, /* DSRLV */
20435 { instruction , 0 , 0 , 32,
20436 0xfc0001ff, 0xc0000058, &NMD::DMUH , 0,
20437 MIPS64_ }, /* DMUH */
20438 { reserved_block , 0 , 0 , 32,
20439 0xfc0001ff, 0xc0000060, 0 , 0,
20440 0x0 }, /* POOL32S_0~*(12) */
20441 { reserved_block , 0 , 0 , 32,
20442 0xfc0001ff, 0xc0000068, 0 , 0,
20443 0x0 }, /* POOL32S_0~*(13) */
20444 { reserved_block , 0 , 0 , 32,
20445 0xfc0001ff, 0xc0000070, 0 , 0,
20446 0x0 }, /* POOL32S_0~*(14) */
20447 { reserved_block , 0 , 0 , 32,
20448 0xfc0001ff, 0xc0000078, 0 , 0,
20449 0x0 }, /* POOL32S_0~*(15) */
20450 { reserved_block , 0 , 0 , 32,
20451 0xfc0001ff, 0xc0000080, 0 , 0,
20452 0x0 }, /* POOL32S_0~*(16) */
20453 { reserved_block , 0 , 0 , 32,
20454 0xfc0001ff, 0xc0000088, 0 , 0,
20455 0x0 }, /* POOL32S_0~*(17) */
20456 { instruction , 0 , 0 , 32,
20457 0xfc0001ff, 0xc0000090, &NMD::DSRAV , 0,
20458 MIPS64_ }, /* DSRAV */
20459 { instruction , 0 , 0 , 32,
20460 0xfc0001ff, 0xc0000098, &NMD::DMULU , 0,
20461 MIPS64_ }, /* DMULU */
20462 { reserved_block , 0 , 0 , 32,
20463 0xfc0001ff, 0xc00000a0, 0 , 0,
20464 0x0 }, /* POOL32S_0~*(20) */
20465 { reserved_block , 0 , 0 , 32,
20466 0xfc0001ff, 0xc00000a8, 0 , 0,
20467 0x0 }, /* POOL32S_0~*(21) */
20468 { reserved_block , 0 , 0 , 32,
20469 0xfc0001ff, 0xc00000b0, 0 , 0,
20470 0x0 }, /* POOL32S_0~*(22) */
20471 { reserved_block , 0 , 0 , 32,
20472 0xfc0001ff, 0xc00000b8, 0 , 0,
20473 0x0 }, /* POOL32S_0~*(23) */
20474 { reserved_block , 0 , 0 , 32,
20475 0xfc0001ff, 0xc00000c0, 0 , 0,
20476 0x0 }, /* POOL32S_0~*(24) */
20477 { reserved_block , 0 , 0 , 32,
20478 0xfc0001ff, 0xc00000c8, 0 , 0,
20479 0x0 }, /* POOL32S_0~*(25) */
20480 { instruction , 0 , 0 , 32,
20481 0xfc0001ff, 0xc00000d0, &NMD::DROTRV , 0,
20482 MIPS64_ }, /* DROTRV */
20483 { instruction , 0 , 0 , 32,
20484 0xfc0001ff, 0xc00000d8, &NMD::DMUHU , 0,
20485 MIPS64_ }, /* DMUHU */
20486 { reserved_block , 0 , 0 , 32,
20487 0xfc0001ff, 0xc00000e0, 0 , 0,
20488 0x0 }, /* POOL32S_0~*(28) */
20489 { reserved_block , 0 , 0 , 32,
20490 0xfc0001ff, 0xc00000e8, 0 , 0,
20491 0x0 }, /* POOL32S_0~*(29) */
20492 { reserved_block , 0 , 0 , 32,
20493 0xfc0001ff, 0xc00000f0, 0 , 0,
20494 0x0 }, /* POOL32S_0~*(30) */
20495 { reserved_block , 0 , 0 , 32,
20496 0xfc0001ff, 0xc00000f8, 0 , 0,
20497 0x0 }, /* POOL32S_0~*(31) */
20498 { reserved_block , 0 , 0 , 32,
20499 0xfc0001ff, 0xc0000100, 0 , 0,
20500 0x0 }, /* POOL32S_0~*(32) */
20501 { reserved_block , 0 , 0 , 32,
20502 0xfc0001ff, 0xc0000108, 0 , 0,
20503 0x0 }, /* POOL32S_0~*(33) */
20504 { instruction , 0 , 0 , 32,
20505 0xfc0001ff, 0xc0000110, &NMD::DADD , 0,
20506 MIPS64_ }, /* DADD */
20507 { instruction , 0 , 0 , 32,
20508 0xfc0001ff, 0xc0000118, &NMD::DDIV , 0,
20509 MIPS64_ }, /* DDIV */
20510 { reserved_block , 0 , 0 , 32,
20511 0xfc0001ff, 0xc0000120, 0 , 0,
20512 0x0 }, /* POOL32S_0~*(36) */
20513 { reserved_block , 0 , 0 , 32,
20514 0xfc0001ff, 0xc0000128, 0 , 0,
20515 0x0 }, /* POOL32S_0~*(37) */
20516 { reserved_block , 0 , 0 , 32,
20517 0xfc0001ff, 0xc0000130, 0 , 0,
20518 0x0 }, /* POOL32S_0~*(38) */
20519 { reserved_block , 0 , 0 , 32,
20520 0xfc0001ff, 0xc0000138, 0 , 0,
20521 0x0 }, /* POOL32S_0~*(39) */
20522 { reserved_block , 0 , 0 , 32,
20523 0xfc0001ff, 0xc0000140, 0 , 0,
20524 0x0 }, /* POOL32S_0~*(40) */
20525 { reserved_block , 0 , 0 , 32,
20526 0xfc0001ff, 0xc0000148, 0 , 0,
20527 0x0 }, /* POOL32S_0~*(41) */
20528 { instruction , 0 , 0 , 32,
20529 0xfc0001ff, 0xc0000150, &NMD::DADDU , 0,
20530 MIPS64_ }, /* DADDU */
20531 { instruction , 0 , 0 , 32,
20532 0xfc0001ff, 0xc0000158, &NMD::DMOD , 0,
20533 MIPS64_ }, /* DMOD */
20534 { reserved_block , 0 , 0 , 32,
20535 0xfc0001ff, 0xc0000160, 0 , 0,
20536 0x0 }, /* POOL32S_0~*(44) */
20537 { reserved_block , 0 , 0 , 32,
20538 0xfc0001ff, 0xc0000168, 0 , 0,
20539 0x0 }, /* POOL32S_0~*(45) */
20540 { reserved_block , 0 , 0 , 32,
20541 0xfc0001ff, 0xc0000170, 0 , 0,
20542 0x0 }, /* POOL32S_0~*(46) */
20543 { reserved_block , 0 , 0 , 32,
20544 0xfc0001ff, 0xc0000178, 0 , 0,
20545 0x0 }, /* POOL32S_0~*(47) */
20546 { reserved_block , 0 , 0 , 32,
20547 0xfc0001ff, 0xc0000180, 0 , 0,
20548 0x0 }, /* POOL32S_0~*(48) */
20549 { reserved_block , 0 , 0 , 32,
20550 0xfc0001ff, 0xc0000188, 0 , 0,
20551 0x0 }, /* POOL32S_0~*(49) */
20552 { instruction , 0 , 0 , 32,
20553 0xfc0001ff, 0xc0000190, &NMD::DSUB , 0,
20554 MIPS64_ }, /* DSUB */
20555 { instruction , 0 , 0 , 32,
20556 0xfc0001ff, 0xc0000198, &NMD::DDIVU , 0,
20557 MIPS64_ }, /* DDIVU */
20558 { reserved_block , 0 , 0 , 32,
20559 0xfc0001ff, 0xc00001a0, 0 , 0,
20560 0x0 }, /* POOL32S_0~*(52) */
20561 { reserved_block , 0 , 0 , 32,
20562 0xfc0001ff, 0xc00001a8, 0 , 0,
20563 0x0 }, /* POOL32S_0~*(53) */
20564 { reserved_block , 0 , 0 , 32,
20565 0xfc0001ff, 0xc00001b0, 0 , 0,
20566 0x0 }, /* POOL32S_0~*(54) */
20567 { reserved_block , 0 , 0 , 32,
20568 0xfc0001ff, 0xc00001b8, 0 , 0,
20569 0x0 }, /* POOL32S_0~*(55) */
20570 { reserved_block , 0 , 0 , 32,
20571 0xfc0001ff, 0xc00001c0, 0 , 0,
20572 0x0 }, /* POOL32S_0~*(56) */
20573 { reserved_block , 0 , 0 , 32,
20574 0xfc0001ff, 0xc00001c8, 0 , 0,
20575 0x0 }, /* POOL32S_0~*(57) */
20576 { instruction , 0 , 0 , 32,
20577 0xfc0001ff, 0xc00001d0, &NMD::DSUBU , 0,
20578 MIPS64_ }, /* DSUBU */
20579 { instruction , 0 , 0 , 32,
20580 0xfc0001ff, 0xc00001d8, &NMD::DMODU , 0,
20581 MIPS64_ }, /* DMODU */
20582 { reserved_block , 0 , 0 , 32,
20583 0xfc0001ff, 0xc00001e0, 0 , 0,
20584 0x0 }, /* POOL32S_0~*(60) */
20585 { reserved_block , 0 , 0 , 32,
20586 0xfc0001ff, 0xc00001e8, 0 , 0,
20587 0x0 }, /* POOL32S_0~*(61) */
20588 { reserved_block , 0 , 0 , 32,
20589 0xfc0001ff, 0xc00001f0, 0 , 0,
20590 0x0 }, /* POOL32S_0~*(62) */
20591 { reserved_block , 0 , 0 , 32,
20592 0xfc0001ff, 0xc00001f8, 0 , 0,
20593 0x0 }, /* POOL32S_0~*(63) */
20594 };
20595
20596
20597 NMD::Pool NMD::POOL32Sxf_4[128] = {
20598 { reserved_block , 0 , 0 , 32,
20599 0xfc00ffff, 0xc000013c, 0 , 0,
20600 0x0 }, /* POOL32Sxf_4~*(0) */
20601 { reserved_block , 0 , 0 , 32,
20602 0xfc00ffff, 0xc000033c, 0 , 0,
20603 0x0 }, /* POOL32Sxf_4~*(1) */
20604 { reserved_block , 0 , 0 , 32,
20605 0xfc00ffff, 0xc000053c, 0 , 0,
20606 0x0 }, /* POOL32Sxf_4~*(2) */
20607 { reserved_block , 0 , 0 , 32,
20608 0xfc00ffff, 0xc000073c, 0 , 0,
20609 0x0 }, /* POOL32Sxf_4~*(3) */
20610 { reserved_block , 0 , 0 , 32,
20611 0xfc00ffff, 0xc000093c, 0 , 0,
20612 0x0 }, /* POOL32Sxf_4~*(4) */
20613 { reserved_block , 0 , 0 , 32,
20614 0xfc00ffff, 0xc0000b3c, 0 , 0,
20615 0x0 }, /* POOL32Sxf_4~*(5) */
20616 { reserved_block , 0 , 0 , 32,
20617 0xfc00ffff, 0xc0000d3c, 0 , 0,
20618 0x0 }, /* POOL32Sxf_4~*(6) */
20619 { reserved_block , 0 , 0 , 32,
20620 0xfc00ffff, 0xc0000f3c, 0 , 0,
20621 0x0 }, /* POOL32Sxf_4~*(7) */
20622 { reserved_block , 0 , 0 , 32,
20623 0xfc00ffff, 0xc000113c, 0 , 0,
20624 0x0 }, /* POOL32Sxf_4~*(8) */
20625 { reserved_block , 0 , 0 , 32,
20626 0xfc00ffff, 0xc000133c, 0 , 0,
20627 0x0 }, /* POOL32Sxf_4~*(9) */
20628 { reserved_block , 0 , 0 , 32,
20629 0xfc00ffff, 0xc000153c, 0 , 0,
20630 0x0 }, /* POOL32Sxf_4~*(10) */
20631 { reserved_block , 0 , 0 , 32,
20632 0xfc00ffff, 0xc000173c, 0 , 0,
20633 0x0 }, /* POOL32Sxf_4~*(11) */
20634 { reserved_block , 0 , 0 , 32,
20635 0xfc00ffff, 0xc000193c, 0 , 0,
20636 0x0 }, /* POOL32Sxf_4~*(12) */
20637 { reserved_block , 0 , 0 , 32,
20638 0xfc00ffff, 0xc0001b3c, 0 , 0,
20639 0x0 }, /* POOL32Sxf_4~*(13) */
20640 { reserved_block , 0 , 0 , 32,
20641 0xfc00ffff, 0xc0001d3c, 0 , 0,
20642 0x0 }, /* POOL32Sxf_4~*(14) */
20643 { reserved_block , 0 , 0 , 32,
20644 0xfc00ffff, 0xc0001f3c, 0 , 0,
20645 0x0 }, /* POOL32Sxf_4~*(15) */
20646 { reserved_block , 0 , 0 , 32,
20647 0xfc00ffff, 0xc000213c, 0 , 0,
20648 0x0 }, /* POOL32Sxf_4~*(16) */
20649 { reserved_block , 0 , 0 , 32,
20650 0xfc00ffff, 0xc000233c, 0 , 0,
20651 0x0 }, /* POOL32Sxf_4~*(17) */
20652 { reserved_block , 0 , 0 , 32,
20653 0xfc00ffff, 0xc000253c, 0 , 0,
20654 0x0 }, /* POOL32Sxf_4~*(18) */
20655 { reserved_block , 0 , 0 , 32,
20656 0xfc00ffff, 0xc000273c, 0 , 0,
20657 0x0 }, /* POOL32Sxf_4~*(19) */
20658 { reserved_block , 0 , 0 , 32,
20659 0xfc00ffff, 0xc000293c, 0 , 0,
20660 0x0 }, /* POOL32Sxf_4~*(20) */
20661 { reserved_block , 0 , 0 , 32,
20662 0xfc00ffff, 0xc0002b3c, 0 , 0,
20663 0x0 }, /* POOL32Sxf_4~*(21) */
20664 { reserved_block , 0 , 0 , 32,
20665 0xfc00ffff, 0xc0002d3c, 0 , 0,
20666 0x0 }, /* POOL32Sxf_4~*(22) */
20667 { reserved_block , 0 , 0 , 32,
20668 0xfc00ffff, 0xc0002f3c, 0 , 0,
20669 0x0 }, /* POOL32Sxf_4~*(23) */
20670 { reserved_block , 0 , 0 , 32,
20671 0xfc00ffff, 0xc000313c, 0 , 0,
20672 0x0 }, /* POOL32Sxf_4~*(24) */
20673 { reserved_block , 0 , 0 , 32,
20674 0xfc00ffff, 0xc000333c, 0 , 0,
20675 0x0 }, /* POOL32Sxf_4~*(25) */
20676 { reserved_block , 0 , 0 , 32,
20677 0xfc00ffff, 0xc000353c, 0 , 0,
20678 0x0 }, /* POOL32Sxf_4~*(26) */
20679 { reserved_block , 0 , 0 , 32,
20680 0xfc00ffff, 0xc000373c, 0 , 0,
20681 0x0 }, /* POOL32Sxf_4~*(27) */
20682 { reserved_block , 0 , 0 , 32,
20683 0xfc00ffff, 0xc000393c, 0 , 0,
20684 0x0 }, /* POOL32Sxf_4~*(28) */
20685 { reserved_block , 0 , 0 , 32,
20686 0xfc00ffff, 0xc0003b3c, 0 , 0,
20687 0x0 }, /* POOL32Sxf_4~*(29) */
20688 { reserved_block , 0 , 0 , 32,
20689 0xfc00ffff, 0xc0003d3c, 0 , 0,
20690 0x0 }, /* POOL32Sxf_4~*(30) */
20691 { reserved_block , 0 , 0 , 32,
20692 0xfc00ffff, 0xc0003f3c, 0 , 0,
20693 0x0 }, /* POOL32Sxf_4~*(31) */
20694 { reserved_block , 0 , 0 , 32,
20695 0xfc00ffff, 0xc000413c, 0 , 0,
20696 0x0 }, /* POOL32Sxf_4~*(32) */
20697 { reserved_block , 0 , 0 , 32,
20698 0xfc00ffff, 0xc000433c, 0 , 0,
20699 0x0 }, /* POOL32Sxf_4~*(33) */
20700 { reserved_block , 0 , 0 , 32,
20701 0xfc00ffff, 0xc000453c, 0 , 0,
20702 0x0 }, /* POOL32Sxf_4~*(34) */
20703 { reserved_block , 0 , 0 , 32,
20704 0xfc00ffff, 0xc000473c, 0 , 0,
20705 0x0 }, /* POOL32Sxf_4~*(35) */
20706 { reserved_block , 0 , 0 , 32,
20707 0xfc00ffff, 0xc000493c, 0 , 0,
20708 0x0 }, /* POOL32Sxf_4~*(36) */
20709 { instruction , 0 , 0 , 32,
20710 0xfc00ffff, 0xc0004b3c, &NMD::DCLO , 0,
20711 MIPS64_ }, /* DCLO */
20712 { reserved_block , 0 , 0 , 32,
20713 0xfc00ffff, 0xc0004d3c, 0 , 0,
20714 0x0 }, /* POOL32Sxf_4~*(38) */
20715 { reserved_block , 0 , 0 , 32,
20716 0xfc00ffff, 0xc0004f3c, 0 , 0,
20717 0x0 }, /* POOL32Sxf_4~*(39) */
20718 { reserved_block , 0 , 0 , 32,
20719 0xfc00ffff, 0xc000513c, 0 , 0,
20720 0x0 }, /* POOL32Sxf_4~*(40) */
20721 { reserved_block , 0 , 0 , 32,
20722 0xfc00ffff, 0xc000533c, 0 , 0,
20723 0x0 }, /* POOL32Sxf_4~*(41) */
20724 { reserved_block , 0 , 0 , 32,
20725 0xfc00ffff, 0xc000553c, 0 , 0,
20726 0x0 }, /* POOL32Sxf_4~*(42) */
20727 { reserved_block , 0 , 0 , 32,
20728 0xfc00ffff, 0xc000573c, 0 , 0,
20729 0x0 }, /* POOL32Sxf_4~*(43) */
20730 { reserved_block , 0 , 0 , 32,
20731 0xfc00ffff, 0xc000593c, 0 , 0,
20732 0x0 }, /* POOL32Sxf_4~*(44) */
20733 { instruction , 0 , 0 , 32,
20734 0xfc00ffff, 0xc0005b3c, &NMD::DCLZ , 0,
20735 MIPS64_ }, /* DCLZ */
20736 { reserved_block , 0 , 0 , 32,
20737 0xfc00ffff, 0xc0005d3c, 0 , 0,
20738 0x0 }, /* POOL32Sxf_4~*(46) */
20739 { reserved_block , 0 , 0 , 32,
20740 0xfc00ffff, 0xc0005f3c, 0 , 0,
20741 0x0 }, /* POOL32Sxf_4~*(47) */
20742 { reserved_block , 0 , 0 , 32,
20743 0xfc00ffff, 0xc000613c, 0 , 0,
20744 0x0 }, /* POOL32Sxf_4~*(48) */
20745 { reserved_block , 0 , 0 , 32,
20746 0xfc00ffff, 0xc000633c, 0 , 0,
20747 0x0 }, /* POOL32Sxf_4~*(49) */
20748 { reserved_block , 0 , 0 , 32,
20749 0xfc00ffff, 0xc000653c, 0 , 0,
20750 0x0 }, /* POOL32Sxf_4~*(50) */
20751 { reserved_block , 0 , 0 , 32,
20752 0xfc00ffff, 0xc000673c, 0 , 0,
20753 0x0 }, /* POOL32Sxf_4~*(51) */
20754 { reserved_block , 0 , 0 , 32,
20755 0xfc00ffff, 0xc000693c, 0 , 0,
20756 0x0 }, /* POOL32Sxf_4~*(52) */
20757 { reserved_block , 0 , 0 , 32,
20758 0xfc00ffff, 0xc0006b3c, 0 , 0,
20759 0x0 }, /* POOL32Sxf_4~*(53) */
20760 { reserved_block , 0 , 0 , 32,
20761 0xfc00ffff, 0xc0006d3c, 0 , 0,
20762 0x0 }, /* POOL32Sxf_4~*(54) */
20763 { reserved_block , 0 , 0 , 32,
20764 0xfc00ffff, 0xc0006f3c, 0 , 0,
20765 0x0 }, /* POOL32Sxf_4~*(55) */
20766 { reserved_block , 0 , 0 , 32,
20767 0xfc00ffff, 0xc000713c, 0 , 0,
20768 0x0 }, /* POOL32Sxf_4~*(56) */
20769 { reserved_block , 0 , 0 , 32,
20770 0xfc00ffff, 0xc000733c, 0 , 0,
20771 0x0 }, /* POOL32Sxf_4~*(57) */
20772 { reserved_block , 0 , 0 , 32,
20773 0xfc00ffff, 0xc000753c, 0 , 0,
20774 0x0 }, /* POOL32Sxf_4~*(58) */
20775 { reserved_block , 0 , 0 , 32,
20776 0xfc00ffff, 0xc000773c, 0 , 0,
20777 0x0 }, /* POOL32Sxf_4~*(59) */
20778 { reserved_block , 0 , 0 , 32,
20779 0xfc00ffff, 0xc000793c, 0 , 0,
20780 0x0 }, /* POOL32Sxf_4~*(60) */
20781 { reserved_block , 0 , 0 , 32,
20782 0xfc00ffff, 0xc0007b3c, 0 , 0,
20783 0x0 }, /* POOL32Sxf_4~*(61) */
20784 { reserved_block , 0 , 0 , 32,
20785 0xfc00ffff, 0xc0007d3c, 0 , 0,
20786 0x0 }, /* POOL32Sxf_4~*(62) */
20787 { reserved_block , 0 , 0 , 32,
20788 0xfc00ffff, 0xc0007f3c, 0 , 0,
20789 0x0 }, /* POOL32Sxf_4~*(63) */
20790 { reserved_block , 0 , 0 , 32,
20791 0xfc00ffff, 0xc000813c, 0 , 0,
20792 0x0 }, /* POOL32Sxf_4~*(64) */
20793 { reserved_block , 0 , 0 , 32,
20794 0xfc00ffff, 0xc000833c, 0 , 0,
20795 0x0 }, /* POOL32Sxf_4~*(65) */
20796 { reserved_block , 0 , 0 , 32,
20797 0xfc00ffff, 0xc000853c, 0 , 0,
20798 0x0 }, /* POOL32Sxf_4~*(66) */
20799 { reserved_block , 0 , 0 , 32,
20800 0xfc00ffff, 0xc000873c, 0 , 0,
20801 0x0 }, /* POOL32Sxf_4~*(67) */
20802 { reserved_block , 0 , 0 , 32,
20803 0xfc00ffff, 0xc000893c, 0 , 0,
20804 0x0 }, /* POOL32Sxf_4~*(68) */
20805 { reserved_block , 0 , 0 , 32,
20806 0xfc00ffff, 0xc0008b3c, 0 , 0,
20807 0x0 }, /* POOL32Sxf_4~*(69) */
20808 { reserved_block , 0 , 0 , 32,
20809 0xfc00ffff, 0xc0008d3c, 0 , 0,
20810 0x0 }, /* POOL32Sxf_4~*(70) */
20811 { reserved_block , 0 , 0 , 32,
20812 0xfc00ffff, 0xc0008f3c, 0 , 0,
20813 0x0 }, /* POOL32Sxf_4~*(71) */
20814 { reserved_block , 0 , 0 , 32,
20815 0xfc00ffff, 0xc000913c, 0 , 0,
20816 0x0 }, /* POOL32Sxf_4~*(72) */
20817 { reserved_block , 0 , 0 , 32,
20818 0xfc00ffff, 0xc000933c, 0 , 0,
20819 0x0 }, /* POOL32Sxf_4~*(73) */
20820 { reserved_block , 0 , 0 , 32,
20821 0xfc00ffff, 0xc000953c, 0 , 0,
20822 0x0 }, /* POOL32Sxf_4~*(74) */
20823 { reserved_block , 0 , 0 , 32,
20824 0xfc00ffff, 0xc000973c, 0 , 0,
20825 0x0 }, /* POOL32Sxf_4~*(75) */
20826 { reserved_block , 0 , 0 , 32,
20827 0xfc00ffff, 0xc000993c, 0 , 0,
20828 0x0 }, /* POOL32Sxf_4~*(76) */
20829 { reserved_block , 0 , 0 , 32,
20830 0xfc00ffff, 0xc0009b3c, 0 , 0,
20831 0x0 }, /* POOL32Sxf_4~*(77) */
20832 { reserved_block , 0 , 0 , 32,
20833 0xfc00ffff, 0xc0009d3c, 0 , 0,
20834 0x0 }, /* POOL32Sxf_4~*(78) */
20835 { reserved_block , 0 , 0 , 32,
20836 0xfc00ffff, 0xc0009f3c, 0 , 0,
20837 0x0 }, /* POOL32Sxf_4~*(79) */
20838 { reserved_block , 0 , 0 , 32,
20839 0xfc00ffff, 0xc000a13c, 0 , 0,
20840 0x0 }, /* POOL32Sxf_4~*(80) */
20841 { reserved_block , 0 , 0 , 32,
20842 0xfc00ffff, 0xc000a33c, 0 , 0,
20843 0x0 }, /* POOL32Sxf_4~*(81) */
20844 { reserved_block , 0 , 0 , 32,
20845 0xfc00ffff, 0xc000a53c, 0 , 0,
20846 0x0 }, /* POOL32Sxf_4~*(82) */
20847 { reserved_block , 0 , 0 , 32,
20848 0xfc00ffff, 0xc000a73c, 0 , 0,
20849 0x0 }, /* POOL32Sxf_4~*(83) */
20850 { reserved_block , 0 , 0 , 32,
20851 0xfc00ffff, 0xc000a93c, 0 , 0,
20852 0x0 }, /* POOL32Sxf_4~*(84) */
20853 { reserved_block , 0 , 0 , 32,
20854 0xfc00ffff, 0xc000ab3c, 0 , 0,
20855 0x0 }, /* POOL32Sxf_4~*(85) */
20856 { reserved_block , 0 , 0 , 32,
20857 0xfc00ffff, 0xc000ad3c, 0 , 0,
20858 0x0 }, /* POOL32Sxf_4~*(86) */
20859 { reserved_block , 0 , 0 , 32,
20860 0xfc00ffff, 0xc000af3c, 0 , 0,
20861 0x0 }, /* POOL32Sxf_4~*(87) */
20862 { reserved_block , 0 , 0 , 32,
20863 0xfc00ffff, 0xc000b13c, 0 , 0,
20864 0x0 }, /* POOL32Sxf_4~*(88) */
20865 { reserved_block , 0 , 0 , 32,
20866 0xfc00ffff, 0xc000b33c, 0 , 0,
20867 0x0 }, /* POOL32Sxf_4~*(89) */
20868 { reserved_block , 0 , 0 , 32,
20869 0xfc00ffff, 0xc000b53c, 0 , 0,
20870 0x0 }, /* POOL32Sxf_4~*(90) */
20871 { reserved_block , 0 , 0 , 32,
20872 0xfc00ffff, 0xc000b73c, 0 , 0,
20873 0x0 }, /* POOL32Sxf_4~*(91) */
20874 { reserved_block , 0 , 0 , 32,
20875 0xfc00ffff, 0xc000b93c, 0 , 0,
20876 0x0 }, /* POOL32Sxf_4~*(92) */
20877 { reserved_block , 0 , 0 , 32,
20878 0xfc00ffff, 0xc000bb3c, 0 , 0,
20879 0x0 }, /* POOL32Sxf_4~*(93) */
20880 { reserved_block , 0 , 0 , 32,
20881 0xfc00ffff, 0xc000bd3c, 0 , 0,
20882 0x0 }, /* POOL32Sxf_4~*(94) */
20883 { reserved_block , 0 , 0 , 32,
20884 0xfc00ffff, 0xc000bf3c, 0 , 0,
20885 0x0 }, /* POOL32Sxf_4~*(95) */
20886 { reserved_block , 0 , 0 , 32,
20887 0xfc00ffff, 0xc000c13c, 0 , 0,
20888 0x0 }, /* POOL32Sxf_4~*(96) */
20889 { reserved_block , 0 , 0 , 32,
20890 0xfc00ffff, 0xc000c33c, 0 , 0,
20891 0x0 }, /* POOL32Sxf_4~*(97) */
20892 { reserved_block , 0 , 0 , 32,
20893 0xfc00ffff, 0xc000c53c, 0 , 0,
20894 0x0 }, /* POOL32Sxf_4~*(98) */
20895 { reserved_block , 0 , 0 , 32,
20896 0xfc00ffff, 0xc000c73c, 0 , 0,
20897 0x0 }, /* POOL32Sxf_4~*(99) */
20898 { reserved_block , 0 , 0 , 32,
20899 0xfc00ffff, 0xc000c93c, 0 , 0,
20900 0x0 }, /* POOL32Sxf_4~*(100) */
20901 { reserved_block , 0 , 0 , 32,
20902 0xfc00ffff, 0xc000cb3c, 0 , 0,
20903 0x0 }, /* POOL32Sxf_4~*(101) */
20904 { reserved_block , 0 , 0 , 32,
20905 0xfc00ffff, 0xc000cd3c, 0 , 0,
20906 0x0 }, /* POOL32Sxf_4~*(102) */
20907 { reserved_block , 0 , 0 , 32,
20908 0xfc00ffff, 0xc000cf3c, 0 , 0,
20909 0x0 }, /* POOL32Sxf_4~*(103) */
20910 { reserved_block , 0 , 0 , 32,
20911 0xfc00ffff, 0xc000d13c, 0 , 0,
20912 0x0 }, /* POOL32Sxf_4~*(104) */
20913 { reserved_block , 0 , 0 , 32,
20914 0xfc00ffff, 0xc000d33c, 0 , 0,
20915 0x0 }, /* POOL32Sxf_4~*(105) */
20916 { reserved_block , 0 , 0 , 32,
20917 0xfc00ffff, 0xc000d53c, 0 , 0,
20918 0x0 }, /* POOL32Sxf_4~*(106) */
20919 { reserved_block , 0 , 0 , 32,
20920 0xfc00ffff, 0xc000d73c, 0 , 0,
20921 0x0 }, /* POOL32Sxf_4~*(107) */
20922 { reserved_block , 0 , 0 , 32,
20923 0xfc00ffff, 0xc000d93c, 0 , 0,
20924 0x0 }, /* POOL32Sxf_4~*(108) */
20925 { reserved_block , 0 , 0 , 32,
20926 0xfc00ffff, 0xc000db3c, 0 , 0,
20927 0x0 }, /* POOL32Sxf_4~*(109) */
20928 { reserved_block , 0 , 0 , 32,
20929 0xfc00ffff, 0xc000dd3c, 0 , 0,
20930 0x0 }, /* POOL32Sxf_4~*(110) */
20931 { reserved_block , 0 , 0 , 32,
20932 0xfc00ffff, 0xc000df3c, 0 , 0,
20933 0x0 }, /* POOL32Sxf_4~*(111) */
20934 { reserved_block , 0 , 0 , 32,
20935 0xfc00ffff, 0xc000e13c, 0 , 0,
20936 0x0 }, /* POOL32Sxf_4~*(112) */
20937 { reserved_block , 0 , 0 , 32,
20938 0xfc00ffff, 0xc000e33c, 0 , 0,
20939 0x0 }, /* POOL32Sxf_4~*(113) */
20940 { reserved_block , 0 , 0 , 32,
20941 0xfc00ffff, 0xc000e53c, 0 , 0,
20942 0x0 }, /* POOL32Sxf_4~*(114) */
20943 { reserved_block , 0 , 0 , 32,
20944 0xfc00ffff, 0xc000e73c, 0 , 0,
20945 0x0 }, /* POOL32Sxf_4~*(115) */
20946 { reserved_block , 0 , 0 , 32,
20947 0xfc00ffff, 0xc000e93c, 0 , 0,
20948 0x0 }, /* POOL32Sxf_4~*(116) */
20949 { reserved_block , 0 , 0 , 32,
20950 0xfc00ffff, 0xc000eb3c, 0 , 0,
20951 0x0 }, /* POOL32Sxf_4~*(117) */
20952 { reserved_block , 0 , 0 , 32,
20953 0xfc00ffff, 0xc000ed3c, 0 , 0,
20954 0x0 }, /* POOL32Sxf_4~*(118) */
20955 { reserved_block , 0 , 0 , 32,
20956 0xfc00ffff, 0xc000ef3c, 0 , 0,
20957 0x0 }, /* POOL32Sxf_4~*(119) */
20958 { reserved_block , 0 , 0 , 32,
20959 0xfc00ffff, 0xc000f13c, 0 , 0,
20960 0x0 }, /* POOL32Sxf_4~*(120) */
20961 { reserved_block , 0 , 0 , 32,
20962 0xfc00ffff, 0xc000f33c, 0 , 0,
20963 0x0 }, /* POOL32Sxf_4~*(121) */
20964 { reserved_block , 0 , 0 , 32,
20965 0xfc00ffff, 0xc000f53c, 0 , 0,
20966 0x0 }, /* POOL32Sxf_4~*(122) */
20967 { reserved_block , 0 , 0 , 32,
20968 0xfc00ffff, 0xc000f73c, 0 , 0,
20969 0x0 }, /* POOL32Sxf_4~*(123) */
20970 { reserved_block , 0 , 0 , 32,
20971 0xfc00ffff, 0xc000f93c, 0 , 0,
20972 0x0 }, /* POOL32Sxf_4~*(124) */
20973 { reserved_block , 0 , 0 , 32,
20974 0xfc00ffff, 0xc000fb3c, 0 , 0,
20975 0x0 }, /* POOL32Sxf_4~*(125) */
20976 { reserved_block , 0 , 0 , 32,
20977 0xfc00ffff, 0xc000fd3c, 0 , 0,
20978 0x0 }, /* POOL32Sxf_4~*(126) */
20979 { reserved_block , 0 , 0 , 32,
20980 0xfc00ffff, 0xc000ff3c, 0 , 0,
20981 0x0 }, /* POOL32Sxf_4~*(127) */
20982 };
20983
20984
20985 NMD::Pool NMD::POOL32Sxf[8] = {
20986 { reserved_block , 0 , 0 , 32,
20987 0xfc0001ff, 0xc000003c, 0 , 0,
20988 0x0 }, /* POOL32Sxf~*(0) */
20989 { reserved_block , 0 , 0 , 32,
20990 0xfc0001ff, 0xc000007c, 0 , 0,
20991 0x0 }, /* POOL32Sxf~*(1) */
20992 { reserved_block , 0 , 0 , 32,
20993 0xfc0001ff, 0xc00000bc, 0 , 0,
20994 0x0 }, /* POOL32Sxf~*(2) */
20995 { reserved_block , 0 , 0 , 32,
20996 0xfc0001ff, 0xc00000fc, 0 , 0,
20997 0x0 }, /* POOL32Sxf~*(3) */
20998 { pool , POOL32Sxf_4 , 128 , 32,
20999 0xfc0001ff, 0xc000013c, 0 , 0,
21000 0x0 }, /* POOL32Sxf_4 */
21001 { reserved_block , 0 , 0 , 32,
21002 0xfc0001ff, 0xc000017c, 0 , 0,
21003 0x0 }, /* POOL32Sxf~*(5) */
21004 { reserved_block , 0 , 0 , 32,
21005 0xfc0001ff, 0xc00001bc, 0 , 0,
21006 0x0 }, /* POOL32Sxf~*(6) */
21007 { reserved_block , 0 , 0 , 32,
21008 0xfc0001ff, 0xc00001fc, 0 , 0,
21009 0x0 }, /* POOL32Sxf~*(7) */
21010 };
21011
21012
21013 NMD::Pool NMD::POOL32S_4[8] = {
21014 { instruction , 0 , 0 , 32,
21015 0xfc00003f, 0xc0000004, &NMD::EXTD , 0,
21016 MIPS64_ }, /* EXTD */
21017 { instruction , 0 , 0 , 32,
21018 0xfc00003f, 0xc000000c, &NMD::EXTD32 , 0,
21019 MIPS64_ }, /* EXTD32 */
21020 { reserved_block , 0 , 0 , 32,
21021 0xfc00003f, 0xc0000014, 0 , 0,
21022 0x0 }, /* POOL32S_4~*(2) */
21023 { reserved_block , 0 , 0 , 32,
21024 0xfc00003f, 0xc000001c, 0 , 0,
21025 0x0 }, /* POOL32S_4~*(3) */
21026 { reserved_block , 0 , 0 , 32,
21027 0xfc00003f, 0xc0000024, 0 , 0,
21028 0x0 }, /* POOL32S_4~*(4) */
21029 { reserved_block , 0 , 0 , 32,
21030 0xfc00003f, 0xc000002c, 0 , 0,
21031 0x0 }, /* POOL32S_4~*(5) */
21032 { reserved_block , 0 , 0 , 32,
21033 0xfc00003f, 0xc0000034, 0 , 0,
21034 0x0 }, /* POOL32S_4~*(6) */
21035 { pool , POOL32Sxf , 8 , 32,
21036 0xfc00003f, 0xc000003c, 0 , 0,
21037 0x0 }, /* POOL32Sxf */
21038 };
21039
21040
21041 NMD::Pool NMD::POOL32S[8] = {
21042 { pool , POOL32S_0 , 64 , 32,
21043 0xfc000007, 0xc0000000, 0 , 0,
21044 0x0 }, /* POOL32S_0 */
21045 { reserved_block , 0 , 0 , 32,
21046 0xfc000007, 0xc0000001, 0 , 0,
21047 0x0 }, /* POOL32S~*(1) */
21048 { reserved_block , 0 , 0 , 32,
21049 0xfc000007, 0xc0000002, 0 , 0,
21050 0x0 }, /* POOL32S~*(2) */
21051 { reserved_block , 0 , 0 , 32,
21052 0xfc000007, 0xc0000003, 0 , 0,
21053 0x0 }, /* POOL32S~*(3) */
21054 { pool , POOL32S_4 , 8 , 32,
21055 0xfc000007, 0xc0000004, 0 , 0,
21056 0x0 }, /* POOL32S_4 */
21057 { reserved_block , 0 , 0 , 32,
21058 0xfc000007, 0xc0000005, 0 , 0,
21059 0x0 }, /* POOL32S~*(5) */
21060 { reserved_block , 0 , 0 , 32,
21061 0xfc000007, 0xc0000006, 0 , 0,
21062 0x0 }, /* POOL32S~*(6) */
21063 { reserved_block , 0 , 0 , 32,
21064 0xfc000007, 0xc0000007, 0 , 0,
21065 0x0 }, /* POOL32S~*(7) */
21066 };
21067
21068
21069 NMD::Pool NMD::P_LUI[2] = {
21070 { instruction , 0 , 0 , 32,
21071 0xfc000002, 0xe0000000, &NMD::LUI , 0,
21072 0x0 }, /* LUI */
21073 { instruction , 0 , 0 , 32,
21074 0xfc000002, 0xe0000002, &NMD::ALUIPC , 0,
21075 0x0 }, /* ALUIPC */
21076 };
21077
21078
21079 NMD::Pool NMD::P_GP_LH[2] = {
21080 { instruction , 0 , 0 , 32,
21081 0xfc1c0001, 0x44100000, &NMD::LH_GP_ , 0,
21082 0x0 }, /* LH[GP] */
21083 { instruction , 0 , 0 , 32,
21084 0xfc1c0001, 0x44100001, &NMD::LHU_GP_ , 0,
21085 0x0 }, /* LHU[GP] */
21086 };
21087
21088
21089 NMD::Pool NMD::P_GP_SH[2] = {
21090 { instruction , 0 , 0 , 32,
21091 0xfc1c0001, 0x44140000, &NMD::SH_GP_ , 0,
21092 0x0 }, /* SH[GP] */
21093 { reserved_block , 0 , 0 , 32,
21094 0xfc1c0001, 0x44140001, 0 , 0,
21095 0x0 }, /* P.GP.SH~*(1) */
21096 };
21097
21098
21099 NMD::Pool NMD::P_GP_CP1[4] = {
21100 { instruction , 0 , 0 , 32,
21101 0xfc1c0003, 0x44180000, &NMD::LWC1_GP_ , 0,
21102 CP1_ }, /* LWC1[GP] */
21103 { instruction , 0 , 0 , 32,
21104 0xfc1c0003, 0x44180001, &NMD::SWC1_GP_ , 0,
21105 CP1_ }, /* SWC1[GP] */
21106 { instruction , 0 , 0 , 32,
21107 0xfc1c0003, 0x44180002, &NMD::LDC1_GP_ , 0,
21108 CP1_ }, /* LDC1[GP] */
21109 { instruction , 0 , 0 , 32,
21110 0xfc1c0003, 0x44180003, &NMD::SDC1_GP_ , 0,
21111 CP1_ }, /* SDC1[GP] */
21112 };
21113
21114
21115 NMD::Pool NMD::P_GP_M64[4] = {
21116 { instruction , 0 , 0 , 32,
21117 0xfc1c0003, 0x441c0000, &NMD::LWU_GP_ , 0,
21118 MIPS64_ }, /* LWU[GP] */
21119 { reserved_block , 0 , 0 , 32,
21120 0xfc1c0003, 0x441c0001, 0 , 0,
21121 0x0 }, /* P.GP.M64~*(1) */
21122 { reserved_block , 0 , 0 , 32,
21123 0xfc1c0003, 0x441c0002, 0 , 0,
21124 0x0 }, /* P.GP.M64~*(2) */
21125 { reserved_block , 0 , 0 , 32,
21126 0xfc1c0003, 0x441c0003, 0 , 0,
21127 0x0 }, /* P.GP.M64~*(3) */
21128 };
21129
21130
21131 NMD::Pool NMD::P_GP_BH[8] = {
21132 { instruction , 0 , 0 , 32,
21133 0xfc1c0000, 0x44000000, &NMD::LB_GP_ , 0,
21134 0x0 }, /* LB[GP] */
21135 { instruction , 0 , 0 , 32,
21136 0xfc1c0000, 0x44040000, &NMD::SB_GP_ , 0,
21137 0x0 }, /* SB[GP] */
21138 { instruction , 0 , 0 , 32,
21139 0xfc1c0000, 0x44080000, &NMD::LBU_GP_ , 0,
21140 0x0 }, /* LBU[GP] */
21141 { instruction , 0 , 0 , 32,
21142 0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_ , 0,
21143 0x0 }, /* ADDIU[GP.B] */
21144 { pool , P_GP_LH , 2 , 32,
21145 0xfc1c0000, 0x44100000, 0 , 0,
21146 0x0 }, /* P.GP.LH */
21147 { pool , P_GP_SH , 2 , 32,
21148 0xfc1c0000, 0x44140000, 0 , 0,
21149 0x0 }, /* P.GP.SH */
21150 { pool , P_GP_CP1 , 4 , 32,
21151 0xfc1c0000, 0x44180000, 0 , 0,
21152 0x0 }, /* P.GP.CP1 */
21153 { pool , P_GP_M64 , 4 , 32,
21154 0xfc1c0000, 0x441c0000, 0 , 0,
21155 0x0 }, /* P.GP.M64 */
21156 };
21157
21158
21159 NMD::Pool NMD::P_LS_U12[16] = {
21160 { instruction , 0 , 0 , 32,
21161 0xfc00f000, 0x84000000, &NMD::LB_U12_ , 0,
21162 0x0 }, /* LB[U12] */
21163 { instruction , 0 , 0 , 32,
21164 0xfc00f000, 0x84001000, &NMD::SB_U12_ , 0,
21165 0x0 }, /* SB[U12] */
21166 { instruction , 0 , 0 , 32,
21167 0xfc00f000, 0x84002000, &NMD::LBU_U12_ , 0,
21168 0x0 }, /* LBU[U12] */
21169 { instruction , 0 , 0 , 32,
21170 0xfc00f000, 0x84003000, &NMD::PREF_U12_ , 0,
21171 0x0 }, /* PREF[U12] */
21172 { instruction , 0 , 0 , 32,
21173 0xfc00f000, 0x84004000, &NMD::LH_U12_ , 0,
21174 0x0 }, /* LH[U12] */
21175 { instruction , 0 , 0 , 32,
21176 0xfc00f000, 0x84005000, &NMD::SH_U12_ , 0,
21177 0x0 }, /* SH[U12] */
21178 { instruction , 0 , 0 , 32,
21179 0xfc00f000, 0x84006000, &NMD::LHU_U12_ , 0,
21180 0x0 }, /* LHU[U12] */
21181 { instruction , 0 , 0 , 32,
21182 0xfc00f000, 0x84007000, &NMD::LWU_U12_ , 0,
21183 MIPS64_ }, /* LWU[U12] */
21184 { instruction , 0 , 0 , 32,
21185 0xfc00f000, 0x84008000, &NMD::LW_U12_ , 0,
21186 0x0 }, /* LW[U12] */
21187 { instruction , 0 , 0 , 32,
21188 0xfc00f000, 0x84009000, &NMD::SW_U12_ , 0,
21189 0x0 }, /* SW[U12] */
21190 { instruction , 0 , 0 , 32,
21191 0xfc00f000, 0x8400a000, &NMD::LWC1_U12_ , 0,
21192 CP1_ }, /* LWC1[U12] */
21193 { instruction , 0 , 0 , 32,
21194 0xfc00f000, 0x8400b000, &NMD::SWC1_U12_ , 0,
21195 CP1_ }, /* SWC1[U12] */
21196 { instruction , 0 , 0 , 32,
21197 0xfc00f000, 0x8400c000, &NMD::LD_U12_ , 0,
21198 MIPS64_ }, /* LD[U12] */
21199 { instruction , 0 , 0 , 32,
21200 0xfc00f000, 0x8400d000, &NMD::SD_U12_ , 0,
21201 MIPS64_ }, /* SD[U12] */
21202 { instruction , 0 , 0 , 32,
21203 0xfc00f000, 0x8400e000, &NMD::LDC1_U12_ , 0,
21204 CP1_ }, /* LDC1[U12] */
21205 { instruction , 0 , 0 , 32,
21206 0xfc00f000, 0x8400f000, &NMD::SDC1_U12_ , 0,
21207 CP1_ }, /* SDC1[U12] */
21208 };
21209
21210
21211 NMD::Pool NMD::P_PREF_S9_[2] = {
21212 { instruction , 0 , 0 , 32,
21213 0xffe07f00, 0xa7e01800, &NMD::SYNCI , 0,
21214 0x0 }, /* SYNCI */
21215 { instruction , 0 , 0 , 32,
21216 0xfc007f00, 0xa4001800, &NMD::PREF_S9_ , &NMD::PREF_S9__cond ,
21217 0x0 }, /* PREF[S9] */
21218 };
21219
21220
21221 NMD::Pool NMD::P_LS_S0[16] = {
21222 { instruction , 0 , 0 , 32,
21223 0xfc007f00, 0xa4000000, &NMD::LB_S9_ , 0,
21224 0x0 }, /* LB[S9] */
21225 { instruction , 0 , 0 , 32,
21226 0xfc007f00, 0xa4000800, &NMD::SB_S9_ , 0,
21227 0x0 }, /* SB[S9] */
21228 { instruction , 0 , 0 , 32,
21229 0xfc007f00, 0xa4001000, &NMD::LBU_S9_ , 0,
21230 0x0 }, /* LBU[S9] */
21231 { pool , P_PREF_S9_ , 2 , 32,
21232 0xfc007f00, 0xa4001800, 0 , 0,
21233 0x0 }, /* P.PREF[S9] */
21234 { instruction , 0 , 0 , 32,
21235 0xfc007f00, 0xa4002000, &NMD::LH_S9_ , 0,
21236 0x0 }, /* LH[S9] */
21237 { instruction , 0 , 0 , 32,
21238 0xfc007f00, 0xa4002800, &NMD::SH_S9_ , 0,
21239 0x0 }, /* SH[S9] */
21240 { instruction , 0 , 0 , 32,
21241 0xfc007f00, 0xa4003000, &NMD::LHU_S9_ , 0,
21242 0x0 }, /* LHU[S9] */
21243 { instruction , 0 , 0 , 32,
21244 0xfc007f00, 0xa4003800, &NMD::LWU_S9_ , 0,
21245 MIPS64_ }, /* LWU[S9] */
21246 { instruction , 0 , 0 , 32,
21247 0xfc007f00, 0xa4004000, &NMD::LW_S9_ , 0,
21248 0x0 }, /* LW[S9] */
21249 { instruction , 0 , 0 , 32,
21250 0xfc007f00, 0xa4004800, &NMD::SW_S9_ , 0,
21251 0x0 }, /* SW[S9] */
21252 { instruction , 0 , 0 , 32,
21253 0xfc007f00, 0xa4005000, &NMD::LWC1_S9_ , 0,
21254 CP1_ }, /* LWC1[S9] */
21255 { instruction , 0 , 0 , 32,
21256 0xfc007f00, 0xa4005800, &NMD::SWC1_S9_ , 0,
21257 CP1_ }, /* SWC1[S9] */
21258 { instruction , 0 , 0 , 32,
21259 0xfc007f00, 0xa4006000, &NMD::LD_S9_ , 0,
21260 MIPS64_ }, /* LD[S9] */
21261 { instruction , 0 , 0 , 32,
21262 0xfc007f00, 0xa4006800, &NMD::SD_S9_ , 0,
21263 MIPS64_ }, /* SD[S9] */
21264 { instruction , 0 , 0 , 32,
21265 0xfc007f00, 0xa4007000, &NMD::LDC1_S9_ , 0,
21266 CP1_ }, /* LDC1[S9] */
21267 { instruction , 0 , 0 , 32,
21268 0xfc007f00, 0xa4007800, &NMD::SDC1_S9_ , 0,
21269 CP1_ }, /* SDC1[S9] */
21270 };
21271
21272
21273 NMD::Pool NMD::ASET_ACLR[2] = {
21274 { instruction , 0 , 0 , 32,
21275 0xfe007f00, 0xa4001100, &NMD::ASET , 0,
21276 MCU_ }, /* ASET */
21277 { instruction , 0 , 0 , 32,
21278 0xfe007f00, 0xa6001100, &NMD::ACLR , 0,
21279 MCU_ }, /* ACLR */
21280 };
21281
21282
21283 NMD::Pool NMD::P_LL[4] = {
21284 { instruction , 0 , 0 , 32,
21285 0xfc007f03, 0xa4005100, &NMD::LL , 0,
21286 0x0 }, /* LL */
21287 { instruction , 0 , 0 , 32,
21288 0xfc007f03, 0xa4005101, &NMD::LLWP , 0,
21289 XNP_ }, /* LLWP */
21290 { reserved_block , 0 , 0 , 32,
21291 0xfc007f03, 0xa4005102, 0 , 0,
21292 0x0 }, /* P.LL~*(2) */
21293 { reserved_block , 0 , 0 , 32,
21294 0xfc007f03, 0xa4005103, 0 , 0,
21295 0x0 }, /* P.LL~*(3) */
21296 };
21297
21298
21299 NMD::Pool NMD::P_SC[4] = {
21300 { instruction , 0 , 0 , 32,
21301 0xfc007f03, 0xa4005900, &NMD::SC , 0,
21302 0x0 }, /* SC */
21303 { instruction , 0 , 0 , 32,
21304 0xfc007f03, 0xa4005901, &NMD::SCWP , 0,
21305 XNP_ }, /* SCWP */
21306 { reserved_block , 0 , 0 , 32,
21307 0xfc007f03, 0xa4005902, 0 , 0,
21308 0x0 }, /* P.SC~*(2) */
21309 { reserved_block , 0 , 0 , 32,
21310 0xfc007f03, 0xa4005903, 0 , 0,
21311 0x0 }, /* P.SC~*(3) */
21312 };
21313
21314
21315 NMD::Pool NMD::P_LLD[8] = {
21316 { instruction , 0 , 0 , 32,
21317 0xfc007f07, 0xa4007100, &NMD::LLD , 0,
21318 MIPS64_ }, /* LLD */
21319 { instruction , 0 , 0 , 32,
21320 0xfc007f07, 0xa4007101, &NMD::LLDP , 0,
21321 MIPS64_ }, /* LLDP */
21322 { reserved_block , 0 , 0 , 32,
21323 0xfc007f07, 0xa4007102, 0 , 0,
21324 0x0 }, /* P.LLD~*(2) */
21325 { reserved_block , 0 , 0 , 32,
21326 0xfc007f07, 0xa4007103, 0 , 0,
21327 0x0 }, /* P.LLD~*(3) */
21328 { reserved_block , 0 , 0 , 32,
21329 0xfc007f07, 0xa4007104, 0 , 0,
21330 0x0 }, /* P.LLD~*(4) */
21331 { reserved_block , 0 , 0 , 32,
21332 0xfc007f07, 0xa4007105, 0 , 0,
21333 0x0 }, /* P.LLD~*(5) */
21334 { reserved_block , 0 , 0 , 32,
21335 0xfc007f07, 0xa4007106, 0 , 0,
21336 0x0 }, /* P.LLD~*(6) */
21337 { reserved_block , 0 , 0 , 32,
21338 0xfc007f07, 0xa4007107, 0 , 0,
21339 0x0 }, /* P.LLD~*(7) */
21340 };
21341
21342
21343 NMD::Pool NMD::P_SCD[8] = {
21344 { instruction , 0 , 0 , 32,
21345 0xfc007f07, 0xa4007900, &NMD::SCD , 0,
21346 MIPS64_ }, /* SCD */
21347 { instruction , 0 , 0 , 32,
21348 0xfc007f07, 0xa4007901, &NMD::SCDP , 0,
21349 MIPS64_ }, /* SCDP */
21350 { reserved_block , 0 , 0 , 32,
21351 0xfc007f07, 0xa4007902, 0 , 0,
21352 0x0 }, /* P.SCD~*(2) */
21353 { reserved_block , 0 , 0 , 32,
21354 0xfc007f07, 0xa4007903, 0 , 0,
21355 0x0 }, /* P.SCD~*(3) */
21356 { reserved_block , 0 , 0 , 32,
21357 0xfc007f07, 0xa4007904, 0 , 0,
21358 0x0 }, /* P.SCD~*(4) */
21359 { reserved_block , 0 , 0 , 32,
21360 0xfc007f07, 0xa4007905, 0 , 0,
21361 0x0 }, /* P.SCD~*(5) */
21362 { reserved_block , 0 , 0 , 32,
21363 0xfc007f07, 0xa4007906, 0 , 0,
21364 0x0 }, /* P.SCD~*(6) */
21365 { reserved_block , 0 , 0 , 32,
21366 0xfc007f07, 0xa4007907, 0 , 0,
21367 0x0 }, /* P.SCD~*(7) */
21368 };
21369
21370
21371 NMD::Pool NMD::P_LS_S1[16] = {
21372 { reserved_block , 0 , 0 , 32,
21373 0xfc007f00, 0xa4000100, 0 , 0,
21374 0x0 }, /* P.LS.S1~*(0) */
21375 { reserved_block , 0 , 0 , 32,
21376 0xfc007f00, 0xa4000900, 0 , 0,
21377 0x0 }, /* P.LS.S1~*(1) */
21378 { pool , ASET_ACLR , 2 , 32,
21379 0xfc007f00, 0xa4001100, 0 , 0,
21380 0x0 }, /* ASET_ACLR */
21381 { reserved_block , 0 , 0 , 32,
21382 0xfc007f00, 0xa4001900, 0 , 0,
21383 0x0 }, /* P.LS.S1~*(3) */
21384 { instruction , 0 , 0 , 32,
21385 0xfc007f00, 0xa4002100, &NMD::UALH , 0,
21386 XMMS_ }, /* UALH */
21387 { instruction , 0 , 0 , 32,
21388 0xfc007f00, 0xa4002900, &NMD::UASH , 0,
21389 XMMS_ }, /* UASH */
21390 { reserved_block , 0 , 0 , 32,
21391 0xfc007f00, 0xa4003100, 0 , 0,
21392 0x0 }, /* P.LS.S1~*(6) */
21393 { instruction , 0 , 0 , 32,
21394 0xfc007f00, 0xa4003900, &NMD::CACHE , 0,
21395 CP0_ }, /* CACHE */
21396 { instruction , 0 , 0 , 32,
21397 0xfc007f00, 0xa4004100, &NMD::LWC2 , 0,
21398 CP2_ }, /* LWC2 */
21399 { instruction , 0 , 0 , 32,
21400 0xfc007f00, 0xa4004900, &NMD::SWC2 , 0,
21401 CP2_ }, /* SWC2 */
21402 { pool , P_LL , 4 , 32,
21403 0xfc007f00, 0xa4005100, 0 , 0,
21404 0x0 }, /* P.LL */
21405 { pool , P_SC , 4 , 32,
21406 0xfc007f00, 0xa4005900, 0 , 0,
21407 0x0 }, /* P.SC */
21408 { instruction , 0 , 0 , 32,
21409 0xfc007f00, 0xa4006100, &NMD::LDC2 , 0,
21410 CP2_ }, /* LDC2 */
21411 { instruction , 0 , 0 , 32,
21412 0xfc007f00, 0xa4006900, &NMD::SDC2 , 0,
21413 CP2_ }, /* SDC2 */
21414 { pool , P_LLD , 8 , 32,
21415 0xfc007f00, 0xa4007100, 0 , 0,
21416 0x0 }, /* P.LLD */
21417 { pool , P_SCD , 8 , 32,
21418 0xfc007f00, 0xa4007900, 0 , 0,
21419 0x0 }, /* P.SCD */
21420 };
21421
21422
21423 NMD::Pool NMD::P_PREFE[2] = {
21424 { instruction , 0 , 0 , 32,
21425 0xffe07f00, 0xa7e01a00, &NMD::SYNCIE , 0,
21426 CP0_ | EVA_ }, /* SYNCIE */
21427 { instruction , 0 , 0 , 32,
21428 0xfc007f00, 0xa4001a00, &NMD::PREFE , &NMD::PREFE_cond ,
21429 CP0_ | EVA_ }, /* PREFE */
21430 };
21431
21432
21433 NMD::Pool NMD::P_LLE[4] = {
21434 { instruction , 0 , 0 , 32,
21435 0xfc007f03, 0xa4005200, &NMD::LLE , 0,
21436 CP0_ | EVA_ }, /* LLE */
21437 { instruction , 0 , 0 , 32,
21438 0xfc007f03, 0xa4005201, &NMD::LLWPE , 0,
21439 CP0_ | EVA_ }, /* LLWPE */
21440 { reserved_block , 0 , 0 , 32,
21441 0xfc007f03, 0xa4005202, 0 , 0,
21442 0x0 }, /* P.LLE~*(2) */
21443 { reserved_block , 0 , 0 , 32,
21444 0xfc007f03, 0xa4005203, 0 , 0,
21445 0x0 }, /* P.LLE~*(3) */
21446 };
21447
21448
21449 NMD::Pool NMD::P_SCE[4] = {
21450 { instruction , 0 , 0 , 32,
21451 0xfc007f03, 0xa4005a00, &NMD::SCE , 0,
21452 CP0_ | EVA_ }, /* SCE */
21453 { instruction , 0 , 0 , 32,
21454 0xfc007f03, 0xa4005a01, &NMD::SCWPE , 0,
21455 CP0_ | EVA_ }, /* SCWPE */
21456 { reserved_block , 0 , 0 , 32,
21457 0xfc007f03, 0xa4005a02, 0 , 0,
21458 0x0 }, /* P.SCE~*(2) */
21459 { reserved_block , 0 , 0 , 32,
21460 0xfc007f03, 0xa4005a03, 0 , 0,
21461 0x0 }, /* P.SCE~*(3) */
21462 };
21463
21464
21465 NMD::Pool NMD::P_LS_E0[16] = {
21466 { instruction , 0 , 0 , 32,
21467 0xfc007f00, 0xa4000200, &NMD::LBE , 0,
21468 CP0_ | EVA_ }, /* LBE */
21469 { instruction , 0 , 0 , 32,
21470 0xfc007f00, 0xa4000a00, &NMD::SBE , 0,
21471 CP0_ | EVA_ }, /* SBE */
21472 { instruction , 0 , 0 , 32,
21473 0xfc007f00, 0xa4001200, &NMD::LBUE , 0,
21474 CP0_ | EVA_ }, /* LBUE */
21475 { pool , P_PREFE , 2 , 32,
21476 0xfc007f00, 0xa4001a00, 0 , 0,
21477 0x0 }, /* P.PREFE */
21478 { instruction , 0 , 0 , 32,
21479 0xfc007f00, 0xa4002200, &NMD::LHE , 0,
21480 CP0_ | EVA_ }, /* LHE */
21481 { instruction , 0 , 0 , 32,
21482 0xfc007f00, 0xa4002a00, &NMD::SHE , 0,
21483 CP0_ | EVA_ }, /* SHE */
21484 { instruction , 0 , 0 , 32,
21485 0xfc007f00, 0xa4003200, &NMD::LHUE , 0,
21486 CP0_ | EVA_ }, /* LHUE */
21487 { instruction , 0 , 0 , 32,
21488 0xfc007f00, 0xa4003a00, &NMD::CACHEE , 0,
21489 CP0_ | EVA_ }, /* CACHEE */
21490 { instruction , 0 , 0 , 32,
21491 0xfc007f00, 0xa4004200, &NMD::LWE , 0,
21492 CP0_ | EVA_ }, /* LWE */
21493 { instruction , 0 , 0 , 32,
21494 0xfc007f00, 0xa4004a00, &NMD::SWE , 0,
21495 CP0_ | EVA_ }, /* SWE */
21496 { pool , P_LLE , 4 , 32,
21497 0xfc007f00, 0xa4005200, 0 , 0,
21498 0x0 }, /* P.LLE */
21499 { pool , P_SCE , 4 , 32,
21500 0xfc007f00, 0xa4005a00, 0 , 0,
21501 0x0 }, /* P.SCE */
21502 { reserved_block , 0 , 0 , 32,
21503 0xfc007f00, 0xa4006200, 0 , 0,
21504 0x0 }, /* P.LS.E0~*(12) */
21505 { reserved_block , 0 , 0 , 32,
21506 0xfc007f00, 0xa4006a00, 0 , 0,
21507 0x0 }, /* P.LS.E0~*(13) */
21508 { reserved_block , 0 , 0 , 32,
21509 0xfc007f00, 0xa4007200, 0 , 0,
21510 0x0 }, /* P.LS.E0~*(14) */
21511 { reserved_block , 0 , 0 , 32,
21512 0xfc007f00, 0xa4007a00, 0 , 0,
21513 0x0 }, /* P.LS.E0~*(15) */
21514 };
21515
21516
21517 NMD::Pool NMD::P_LS_WM[2] = {
21518 { instruction , 0 , 0 , 32,
21519 0xfc000f00, 0xa4000400, &NMD::LWM , 0,
21520 XMMS_ }, /* LWM */
21521 { instruction , 0 , 0 , 32,
21522 0xfc000f00, 0xa4000c00, &NMD::SWM , 0,
21523 XMMS_ }, /* SWM */
21524 };
21525
21526
21527 NMD::Pool NMD::P_LS_UAWM[2] = {
21528 { instruction , 0 , 0 , 32,
21529 0xfc000f00, 0xa4000500, &NMD::UALWM , 0,
21530 XMMS_ }, /* UALWM */
21531 { instruction , 0 , 0 , 32,
21532 0xfc000f00, 0xa4000d00, &NMD::UASWM , 0,
21533 XMMS_ }, /* UASWM */
21534 };
21535
21536
21537 NMD::Pool NMD::P_LS_DM[2] = {
21538 { instruction , 0 , 0 , 32,
21539 0xfc000f00, 0xa4000600, &NMD::LDM , 0,
21540 MIPS64_ }, /* LDM */
21541 { instruction , 0 , 0 , 32,
21542 0xfc000f00, 0xa4000e00, &NMD::SDM , 0,
21543 MIPS64_ }, /* SDM */
21544 };
21545
21546
21547 NMD::Pool NMD::P_LS_UADM[2] = {
21548 { instruction , 0 , 0 , 32,
21549 0xfc000f00, 0xa4000700, &NMD::UALDM , 0,
21550 MIPS64_ }, /* UALDM */
21551 { instruction , 0 , 0 , 32,
21552 0xfc000f00, 0xa4000f00, &NMD::UASDM , 0,
21553 MIPS64_ }, /* UASDM */
21554 };
21555
21556
21557 NMD::Pool NMD::P_LS_S9[8] = {
21558 { pool , P_LS_S0 , 16 , 32,
21559 0xfc000700, 0xa4000000, 0 , 0,
21560 0x0 }, /* P.LS.S0 */
21561 { pool , P_LS_S1 , 16 , 32,
21562 0xfc000700, 0xa4000100, 0 , 0,
21563 0x0 }, /* P.LS.S1 */
21564 { pool , P_LS_E0 , 16 , 32,
21565 0xfc000700, 0xa4000200, 0 , 0,
21566 0x0 }, /* P.LS.E0 */
21567 { reserved_block , 0 , 0 , 32,
21568 0xfc000700, 0xa4000300, 0 , 0,
21569 0x0 }, /* P.LS.S9~*(3) */
21570 { pool , P_LS_WM , 2 , 32,
21571 0xfc000700, 0xa4000400, 0 , 0,
21572 0x0 }, /* P.LS.WM */
21573 { pool , P_LS_UAWM , 2 , 32,
21574 0xfc000700, 0xa4000500, 0 , 0,
21575 0x0 }, /* P.LS.UAWM */
21576 { pool , P_LS_DM , 2 , 32,
21577 0xfc000700, 0xa4000600, 0 , 0,
21578 0x0 }, /* P.LS.DM */
21579 { pool , P_LS_UADM , 2 , 32,
21580 0xfc000700, 0xa4000700, 0 , 0,
21581 0x0 }, /* P.LS.UADM */
21582 };
21583
21584
21585 NMD::Pool NMD::P_BAL[2] = {
21586 { branch_instruction , 0 , 0 , 32,
21587 0xfe000000, 0x28000000, &NMD::BC_32_ , 0,
21588 0x0 }, /* BC[32] */
21589 { call_instruction , 0 , 0 , 32,
21590 0xfe000000, 0x2a000000, &NMD::BALC_32_ , 0,
21591 0x0 }, /* BALC[32] */
21592 };
21593
21594
21595 NMD::Pool NMD::P_BALRSC[2] = {
21596 { branch_instruction , 0 , 0 , 32,
21597 0xffe0f000, 0x48008000, &NMD::BRSC , 0,
21598 0x0 }, /* BRSC */
21599 { call_instruction , 0 , 0 , 32,
21600 0xfc00f000, 0x48008000, &NMD::BALRSC , &NMD::BALRSC_cond ,
21601 0x0 }, /* BALRSC */
21602 };
21603
21604
21605 NMD::Pool NMD::P_J[16] = {
21606 { call_instruction , 0 , 0 , 32,
21607 0xfc00f000, 0x48000000, &NMD::JALRC_32_ , 0,
21608 0x0 }, /* JALRC[32] */
21609 { call_instruction , 0 , 0 , 32,
21610 0xfc00f000, 0x48001000, &NMD::JALRC_HB , 0,
21611 0x0 }, /* JALRC.HB */
21612 { reserved_block , 0 , 0 , 32,
21613 0xfc00f000, 0x48002000, 0 , 0,
21614 0x0 }, /* P.J~*(2) */
21615 { reserved_block , 0 , 0 , 32,
21616 0xfc00f000, 0x48003000, 0 , 0,
21617 0x0 }, /* P.J~*(3) */
21618 { reserved_block , 0 , 0 , 32,
21619 0xfc00f000, 0x48004000, 0 , 0,
21620 0x0 }, /* P.J~*(4) */
21621 { reserved_block , 0 , 0 , 32,
21622 0xfc00f000, 0x48005000, 0 , 0,
21623 0x0 }, /* P.J~*(5) */
21624 { reserved_block , 0 , 0 , 32,
21625 0xfc00f000, 0x48006000, 0 , 0,
21626 0x0 }, /* P.J~*(6) */
21627 { reserved_block , 0 , 0 , 32,
21628 0xfc00f000, 0x48007000, 0 , 0,
21629 0x0 }, /* P.J~*(7) */
21630 { pool , P_BALRSC , 2 , 32,
21631 0xfc00f000, 0x48008000, 0 , 0,
21632 0x0 }, /* P.BALRSC */
21633 { reserved_block , 0 , 0 , 32,
21634 0xfc00f000, 0x48009000, 0 , 0,
21635 0x0 }, /* P.J~*(9) */
21636 { reserved_block , 0 , 0 , 32,
21637 0xfc00f000, 0x4800a000, 0 , 0,
21638 0x0 }, /* P.J~*(10) */
21639 { reserved_block , 0 , 0 , 32,
21640 0xfc00f000, 0x4800b000, 0 , 0,
21641 0x0 }, /* P.J~*(11) */
21642 { reserved_block , 0 , 0 , 32,
21643 0xfc00f000, 0x4800c000, 0 , 0,
21644 0x0 }, /* P.J~*(12) */
21645 { reserved_block , 0 , 0 , 32,
21646 0xfc00f000, 0x4800d000, 0 , 0,
21647 0x0 }, /* P.J~*(13) */
21648 { reserved_block , 0 , 0 , 32,
21649 0xfc00f000, 0x4800e000, 0 , 0,
21650 0x0 }, /* P.J~*(14) */
21651 { reserved_block , 0 , 0 , 32,
21652 0xfc00f000, 0x4800f000, 0 , 0,
21653 0x0 }, /* P.J~*(15) */
21654 };
21655
21656
21657 NMD::Pool NMD::P_BR3A[32] = {
21658 { branch_instruction , 0 , 0 , 32,
21659 0xfc1fc000, 0x88004000, &NMD::BC1EQZC , 0,
21660 CP1_ }, /* BC1EQZC */
21661 { branch_instruction , 0 , 0 , 32,
21662 0xfc1fc000, 0x88014000, &NMD::BC1NEZC , 0,
21663 CP1_ }, /* BC1NEZC */
21664 { branch_instruction , 0 , 0 , 32,
21665 0xfc1fc000, 0x88024000, &NMD::BC2EQZC , 0,
21666 CP2_ }, /* BC2EQZC */
21667 { branch_instruction , 0 , 0 , 32,
21668 0xfc1fc000, 0x88034000, &NMD::BC2NEZC , 0,
21669 CP2_ }, /* BC2NEZC */
21670 { branch_instruction , 0 , 0 , 32,
21671 0xfc1fc000, 0x88044000, &NMD::BPOSGE32C , 0,
21672 DSP_ }, /* BPOSGE32C */
21673 { reserved_block , 0 , 0 , 32,
21674 0xfc1fc000, 0x88054000, 0 , 0,
21675 0x0 }, /* P.BR3A~*(5) */
21676 { reserved_block , 0 , 0 , 32,
21677 0xfc1fc000, 0x88064000, 0 , 0,
21678 0x0 }, /* P.BR3A~*(6) */
21679 { reserved_block , 0 , 0 , 32,
21680 0xfc1fc000, 0x88074000, 0 , 0,
21681 0x0 }, /* P.BR3A~*(7) */
21682 { reserved_block , 0 , 0 , 32,
21683 0xfc1fc000, 0x88084000, 0 , 0,
21684 0x0 }, /* P.BR3A~*(8) */
21685 { reserved_block , 0 , 0 , 32,
21686 0xfc1fc000, 0x88094000, 0 , 0,
21687 0x0 }, /* P.BR3A~*(9) */
21688 { reserved_block , 0 , 0 , 32,
21689 0xfc1fc000, 0x880a4000, 0 , 0,
21690 0x0 }, /* P.BR3A~*(10) */
21691 { reserved_block , 0 , 0 , 32,
21692 0xfc1fc000, 0x880b4000, 0 , 0,
21693 0x0 }, /* P.BR3A~*(11) */
21694 { reserved_block , 0 , 0 , 32,
21695 0xfc1fc000, 0x880c4000, 0 , 0,
21696 0x0 }, /* P.BR3A~*(12) */
21697 { reserved_block , 0 , 0 , 32,
21698 0xfc1fc000, 0x880d4000, 0 , 0,
21699 0x0 }, /* P.BR3A~*(13) */
21700 { reserved_block , 0 , 0 , 32,
21701 0xfc1fc000, 0x880e4000, 0 , 0,
21702 0x0 }, /* P.BR3A~*(14) */
21703 { reserved_block , 0 , 0 , 32,
21704 0xfc1fc000, 0x880f4000, 0 , 0,
21705 0x0 }, /* P.BR3A~*(15) */
21706 { reserved_block , 0 , 0 , 32,
21707 0xfc1fc000, 0x88104000, 0 , 0,
21708 0x0 }, /* P.BR3A~*(16) */
21709 { reserved_block , 0 , 0 , 32,
21710 0xfc1fc000, 0x88114000, 0 , 0,
21711 0x0 }, /* P.BR3A~*(17) */
21712 { reserved_block , 0 , 0 , 32,
21713 0xfc1fc000, 0x88124000, 0 , 0,
21714 0x0 }, /* P.BR3A~*(18) */
21715 { reserved_block , 0 , 0 , 32,
21716 0xfc1fc000, 0x88134000, 0 , 0,
21717 0x0 }, /* P.BR3A~*(19) */
21718 { reserved_block , 0 , 0 , 32,
21719 0xfc1fc000, 0x88144000, 0 , 0,
21720 0x0 }, /* P.BR3A~*(20) */
21721 { reserved_block , 0 , 0 , 32,
21722 0xfc1fc000, 0x88154000, 0 , 0,
21723 0x0 }, /* P.BR3A~*(21) */
21724 { reserved_block , 0 , 0 , 32,
21725 0xfc1fc000, 0x88164000, 0 , 0,
21726 0x0 }, /* P.BR3A~*(22) */
21727 { reserved_block , 0 , 0 , 32,
21728 0xfc1fc000, 0x88174000, 0 , 0,
21729 0x0 }, /* P.BR3A~*(23) */
21730 { reserved_block , 0 , 0 , 32,
21731 0xfc1fc000, 0x88184000, 0 , 0,
21732 0x0 }, /* P.BR3A~*(24) */
21733 { reserved_block , 0 , 0 , 32,
21734 0xfc1fc000, 0x88194000, 0 , 0,
21735 0x0 }, /* P.BR3A~*(25) */
21736 { reserved_block , 0 , 0 , 32,
21737 0xfc1fc000, 0x881a4000, 0 , 0,
21738 0x0 }, /* P.BR3A~*(26) */
21739 { reserved_block , 0 , 0 , 32,
21740 0xfc1fc000, 0x881b4000, 0 , 0,
21741 0x0 }, /* P.BR3A~*(27) */
21742 { reserved_block , 0 , 0 , 32,
21743 0xfc1fc000, 0x881c4000, 0 , 0,
21744 0x0 }, /* P.BR3A~*(28) */
21745 { reserved_block , 0 , 0 , 32,
21746 0xfc1fc000, 0x881d4000, 0 , 0,
21747 0x0 }, /* P.BR3A~*(29) */
21748 { reserved_block , 0 , 0 , 32,
21749 0xfc1fc000, 0x881e4000, 0 , 0,
21750 0x0 }, /* P.BR3A~*(30) */
21751 { reserved_block , 0 , 0 , 32,
21752 0xfc1fc000, 0x881f4000, 0 , 0,
21753 0x0 }, /* P.BR3A~*(31) */
21754 };
21755
21756
21757 NMD::Pool NMD::P_BR1[4] = {
21758 { branch_instruction , 0 , 0 , 32,
21759 0xfc00c000, 0x88000000, &NMD::BEQC_32_ , 0,
21760 0x0 }, /* BEQC[32] */
21761 { pool , P_BR3A , 32 , 32,
21762 0xfc00c000, 0x88004000, 0 , 0,
21763 0x0 }, /* P.BR3A */
21764 { branch_instruction , 0 , 0 , 32,
21765 0xfc00c000, 0x88008000, &NMD::BGEC , 0,
21766 0x0 }, /* BGEC */
21767 { branch_instruction , 0 , 0 , 32,
21768 0xfc00c000, 0x8800c000, &NMD::BGEUC , 0,
21769 0x0 }, /* BGEUC */
21770 };
21771
21772
21773 NMD::Pool NMD::P_BR2[4] = {
21774 { branch_instruction , 0 , 0 , 32,
21775 0xfc00c000, 0xa8000000, &NMD::BNEC_32_ , 0,
21776 0x0 }, /* BNEC[32] */
21777 { reserved_block , 0 , 0 , 32,
21778 0xfc00c000, 0xa8004000, 0 , 0,
21779 0x0 }, /* P.BR2~*(1) */
21780 { branch_instruction , 0 , 0 , 32,
21781 0xfc00c000, 0xa8008000, &NMD::BLTC , 0,
21782 0x0 }, /* BLTC */
21783 { branch_instruction , 0 , 0 , 32,
21784 0xfc00c000, 0xa800c000, &NMD::BLTUC , 0,
21785 0x0 }, /* BLTUC */
21786 };
21787
21788
21789 NMD::Pool NMD::P_BRI[8] = {
21790 { branch_instruction , 0 , 0 , 32,
21791 0xfc1c0000, 0xc8000000, &NMD::BEQIC , 0,
21792 0x0 }, /* BEQIC */
21793 { branch_instruction , 0 , 0 , 32,
21794 0xfc1c0000, 0xc8040000, &NMD::BBEQZC , 0,
21795 XMMS_ }, /* BBEQZC */
21796 { branch_instruction , 0 , 0 , 32,
21797 0xfc1c0000, 0xc8080000, &NMD::BGEIC , 0,
21798 0x0 }, /* BGEIC */
21799 { branch_instruction , 0 , 0 , 32,
21800 0xfc1c0000, 0xc80c0000, &NMD::BGEIUC , 0,
21801 0x0 }, /* BGEIUC */
21802 { branch_instruction , 0 , 0 , 32,
21803 0xfc1c0000, 0xc8100000, &NMD::BNEIC , 0,
21804 0x0 }, /* BNEIC */
21805 { branch_instruction , 0 , 0 , 32,
21806 0xfc1c0000, 0xc8140000, &NMD::BBNEZC , 0,
21807 XMMS_ }, /* BBNEZC */
21808 { branch_instruction , 0 , 0 , 32,
21809 0xfc1c0000, 0xc8180000, &NMD::BLTIC , 0,
21810 0x0 }, /* BLTIC */
21811 { branch_instruction , 0 , 0 , 32,
21812 0xfc1c0000, 0xc81c0000, &NMD::BLTIUC , 0,
21813 0x0 }, /* BLTIUC */
21814 };
21815
21816
21817 NMD::Pool NMD::P32[32] = {
21818 { pool , P_ADDIU , 2 , 32,
21819 0xfc000000, 0x00000000, 0 , 0,
21820 0x0 }, /* P.ADDIU */
21821 { pool , P32A , 8 , 32,
21822 0xfc000000, 0x20000000, 0 , 0,
21823 0x0 }, /* P32A */
21824 { pool , P_GP_W , 4 , 32,
21825 0xfc000000, 0x40000000, 0 , 0,
21826 0x0 }, /* P.GP.W */
21827 { pool , POOL48I , 32 , 48,
21828 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21829 0x0 }, /* POOL48I */
21830 { pool , P_U12 , 16 , 32,
21831 0xfc000000, 0x80000000, 0 , 0,
21832 0x0 }, /* P.U12 */
21833 { pool , POOL32F , 8 , 32,
21834 0xfc000000, 0xa0000000, 0 , 0,
21835 CP1_ }, /* POOL32F */
21836 { pool , POOL32S , 8 , 32,
21837 0xfc000000, 0xc0000000, 0 , 0,
21838 0x0 }, /* POOL32S */
21839 { pool , P_LUI , 2 , 32,
21840 0xfc000000, 0xe0000000, 0 , 0,
21841 0x0 }, /* P.LUI */
21842 { instruction , 0 , 0 , 32,
21843 0xfc000000, 0x04000000, &NMD::ADDIUPC_32_ , 0,
21844 0x0 }, /* ADDIUPC[32] */
21845 { reserved_block , 0 , 0 , 32,
21846 0xfc000000, 0x24000000, 0 , 0,
21847 0x0 }, /* P32~*(5) */
21848 { pool , P_GP_BH , 8 , 32,
21849 0xfc000000, 0x44000000, 0 , 0,
21850 0x0 }, /* P.GP.BH */
21851 { reserved_block , 0 , 0 , 32,
21852 0xfc000000, 0x64000000, 0 , 0,
21853 0x0 }, /* P32~*(13) */
21854 { pool , P_LS_U12 , 16 , 32,
21855 0xfc000000, 0x84000000, 0 , 0,
21856 0x0 }, /* P.LS.U12 */
21857 { pool , P_LS_S9 , 8 , 32,
21858 0xfc000000, 0xa4000000, 0 , 0,
21859 0x0 }, /* P.LS.S9 */
21860 { reserved_block , 0 , 0 , 32,
21861 0xfc000000, 0xc4000000, 0 , 0,
21862 0x0 }, /* P32~*(25) */
21863 { reserved_block , 0 , 0 , 32,
21864 0xfc000000, 0xe4000000, 0 , 0,
21865 0x0 }, /* P32~*(29) */
21866 { call_instruction , 0 , 0 , 32,
21867 0xfc000000, 0x08000000, &NMD::MOVE_BALC , 0,
21868 XMMS_ }, /* MOVE.BALC */
21869 { pool , P_BAL , 2 , 32,
21870 0xfc000000, 0x28000000, 0 , 0,
21871 0x0 }, /* P.BAL */
21872 { pool , P_J , 16 , 32,
21873 0xfc000000, 0x48000000, 0 , 0,
21874 0x0 }, /* P.J */
21875 { reserved_block , 0 , 0 , 32,
21876 0xfc000000, 0x68000000, 0 , 0,
21877 0x0 }, /* P32~*(14) */
21878 { pool , P_BR1 , 4 , 32,
21879 0xfc000000, 0x88000000, 0 , 0,
21880 0x0 }, /* P.BR1 */
21881 { pool , P_BR2 , 4 , 32,
21882 0xfc000000, 0xa8000000, 0 , 0,
21883 0x0 }, /* P.BR2 */
21884 { pool , P_BRI , 8 , 32,
21885 0xfc000000, 0xc8000000, 0 , 0,
21886 0x0 }, /* P.BRI */
21887 { reserved_block , 0 , 0 , 32,
21888 0xfc000000, 0xe8000000, 0 , 0,
21889 0x0 }, /* P32~*(30) */
21890 { reserved_block , 0 , 0 , 32,
21891 0xfc000000, 0x0c000000, 0 , 0,
21892 0x0 }, /* P32~*(3) */
21893 { reserved_block , 0 , 0 , 32,
21894 0xfc000000, 0x2c000000, 0 , 0,
21895 0x0 }, /* P32~*(7) */
21896 { reserved_block , 0 , 0 , 32,
21897 0xfc000000, 0x4c000000, 0 , 0,
21898 0x0 }, /* P32~*(11) */
21899 { reserved_block , 0 , 0 , 32,
21900 0xfc000000, 0x6c000000, 0 , 0,
21901 0x0 }, /* P32~*(15) */
21902 { reserved_block , 0 , 0 , 32,
21903 0xfc000000, 0x8c000000, 0 , 0,
21904 0x0 }, /* P32~*(19) */
21905 { reserved_block , 0 , 0 , 32,
21906 0xfc000000, 0xac000000, 0 , 0,
21907 0x0 }, /* P32~*(23) */
21908 { reserved_block , 0 , 0 , 32,
21909 0xfc000000, 0xcc000000, 0 , 0,
21910 0x0 }, /* P32~*(27) */
21911 { reserved_block , 0 , 0 , 32,
21912 0xfc000000, 0xec000000, 0 , 0,
21913 0x0 }, /* P32~*(31) */
21914 };
21915
21916
21917 NMD::Pool NMD::P16_SYSCALL[2] = {
21918 { instruction , 0 , 0 , 16,
21919 0xfffc , 0x1008 , &NMD::SYSCALL_16_ , 0,
21920 0x0 }, /* SYSCALL[16] */
21921 { instruction , 0 , 0 , 16,
21922 0xfffc , 0x100c , &NMD::HYPCALL_16_ , 0,
21923 CP0_ | VZ_ }, /* HYPCALL[16] */
21924 };
21925
21926
21927 NMD::Pool NMD::P16_RI[4] = {
21928 { reserved_block , 0 , 0 , 16,
21929 0xfff8 , 0x1000 , 0 , 0,
21930 0x0 }, /* P16.RI~*(0) */
21931 { pool , P16_SYSCALL , 2 , 16,
21932 0xfff8 , 0x1008 , 0 , 0,
21933 0x0 }, /* P16.SYSCALL */
21934 { instruction , 0 , 0 , 16,
21935 0xfff8 , 0x1010 , &NMD::BREAK_16_ , 0,
21936 0x0 }, /* BREAK[16] */
21937 { instruction , 0 , 0 , 16,
21938 0xfff8 , 0x1018 , &NMD::SDBBP_16_ , 0,
21939 EJTAG_ }, /* SDBBP[16] */
21940 };
21941
21942
21943 NMD::Pool NMD::P16_MV[2] = {
21944 { pool , P16_RI , 4 , 16,
21945 0xffe0 , 0x1000 , 0 , 0,
21946 0x0 }, /* P16.RI */
21947 { instruction , 0 , 0 , 16,
21948 0xfc00 , 0x1000 , &NMD::MOVE , &NMD::MOVE_cond ,
21949 0x0 }, /* MOVE */
21950 };
21951
21952
21953 NMD::Pool NMD::P16_SHIFT[2] = {
21954 { instruction , 0 , 0 , 16,
21955 0xfc08 , 0x3000 , &NMD::SLL_16_ , 0,
21956 0x0 }, /* SLL[16] */
21957 { instruction , 0 , 0 , 16,
21958 0xfc08 , 0x3008 , &NMD::SRL_16_ , 0,
21959 0x0 }, /* SRL[16] */
21960 };
21961
21962
21963 NMD::Pool NMD::POOL16C_00[4] = {
21964 { instruction , 0 , 0 , 16,
21965 0xfc0f , 0x5000 , &NMD::NOT_16_ , 0,
21966 0x0 }, /* NOT[16] */
21967 { instruction , 0 , 0 , 16,
21968 0xfc0f , 0x5004 , &NMD::XOR_16_ , 0,
21969 0x0 }, /* XOR[16] */
21970 { instruction , 0 , 0 , 16,
21971 0xfc0f , 0x5008 , &NMD::AND_16_ , 0,
21972 0x0 }, /* AND[16] */
21973 { instruction , 0 , 0 , 16,
21974 0xfc0f , 0x500c , &NMD::OR_16_ , 0,
21975 0x0 }, /* OR[16] */
21976 };
21977
21978
21979 NMD::Pool NMD::POOL16C_0[2] = {
21980 { pool , POOL16C_00 , 4 , 16,
21981 0xfc03 , 0x5000 , 0 , 0,
21982 0x0 }, /* POOL16C_00 */
21983 { reserved_block , 0 , 0 , 16,
21984 0xfc03 , 0x5002 , 0 , 0,
21985 0x0 }, /* POOL16C_0~*(1) */
21986 };
21987
21988
21989 NMD::Pool NMD::P16C[2] = {
21990 { pool , POOL16C_0 , 2 , 16,
21991 0xfc01 , 0x5000 , 0 , 0,
21992 0x0 }, /* POOL16C_0 */
21993 { instruction , 0 , 0 , 16,
21994 0xfc01 , 0x5001 , &NMD::LWXS_16_ , 0,
21995 0x0 }, /* LWXS[16] */
21996 };
21997
21998
21999 NMD::Pool NMD::P16_A1[2] = {
22000 { reserved_block , 0 , 0 , 16,
22001 0xfc40 , 0x7000 , 0 , 0,
22002 0x0 }, /* P16.A1~*(0) */
22003 { instruction , 0 , 0 , 16,
22004 0xfc40 , 0x7040 , &NMD::ADDIU_R1_SP_ , 0,
22005 0x0 }, /* ADDIU[R1.SP] */
22006 };
22007
22008
22009 NMD::Pool NMD::P_ADDIU_RS5_[2] = {
22010 { instruction , 0 , 0 , 16,
22011 0xffe8 , 0x9008 , &NMD::NOP_16_ , 0,
22012 0x0 }, /* NOP[16] */
22013 { instruction , 0 , 0 , 16,
22014 0xfc08 , 0x9008 , &NMD::ADDIU_RS5_ , &NMD::ADDIU_RS5__cond ,
22015 0x0 }, /* ADDIU[RS5] */
22016 };
22017
22018
22019 NMD::Pool NMD::P16_A2[2] = {
22020 { instruction , 0 , 0 , 16,
22021 0xfc08 , 0x9000 , &NMD::ADDIU_R2_ , 0,
22022 0x0 }, /* ADDIU[R2] */
22023 { pool , P_ADDIU_RS5_ , 2 , 16,
22024 0xfc08 , 0x9008 , 0 , 0,
22025 0x0 }, /* P.ADDIU[RS5] */
22026 };
22027
22028
22029 NMD::Pool NMD::P16_ADDU[2] = {
22030 { instruction , 0 , 0 , 16,
22031 0xfc01 , 0xb000 , &NMD::ADDU_16_ , 0,
22032 0x0 }, /* ADDU[16] */
22033 { instruction , 0 , 0 , 16,
22034 0xfc01 , 0xb001 , &NMD::SUBU_16_ , 0,
22035 0x0 }, /* SUBU[16] */
22036 };
22037
22038
22039 NMD::Pool NMD::P16_JRC[2] = {
22040 { branch_instruction , 0 , 0 , 16,
22041 0xfc1f , 0xd800 , &NMD::JRC , 0,
22042 0x0 }, /* JRC */
22043 { call_instruction , 0 , 0 , 16,
22044 0xfc1f , 0xd810 , &NMD::JALRC_16_ , 0,
22045 0x0 }, /* JALRC[16] */
22046 };
22047
22048
22049 NMD::Pool NMD::P16_BR1[2] = {
22050 { branch_instruction , 0 , 0 , 16,
22051 0xfc00 , 0xd800 , &NMD::BEQC_16_ , &NMD::BEQC_16__cond ,
22052 XMMS_ }, /* BEQC[16] */
22053 { branch_instruction , 0 , 0 , 16,
22054 0xfc00 , 0xd800 , &NMD::BNEC_16_ , &NMD::BNEC_16__cond ,
22055 XMMS_ }, /* BNEC[16] */
22056 };
22057
22058
22059 NMD::Pool NMD::P16_BR[2] = {
22060 { pool , P16_JRC , 2 , 16,
22061 0xfc0f , 0xd800 , 0 , 0,
22062 0x0 }, /* P16.JRC */
22063 { pool , P16_BR1 , 2 , 16,
22064 0xfc00 , 0xd800 , 0 , &NMD::P16_BR1_cond ,
22065 0x0 }, /* P16.BR1 */
22066 };
22067
22068
22069 NMD::Pool NMD::P16_SR[2] = {
22070 { instruction , 0 , 0 , 16,
22071 0xfd00 , 0x1c00 , &NMD::SAVE_16_ , 0,
22072 0x0 }, /* SAVE[16] */
22073 { return_instruction , 0 , 0 , 16,
22074 0xfd00 , 0x1d00 , &NMD::RESTORE_JRC_16_ , 0,
22075 0x0 }, /* RESTORE.JRC[16] */
22076 };
22077
22078
22079 NMD::Pool NMD::P16_4X4[4] = {
22080 { instruction , 0 , 0 , 16,
22081 0xfd08 , 0x3c00 , &NMD::ADDU_4X4_ , 0,
22082 XMMS_ }, /* ADDU[4X4] */
22083 { instruction , 0 , 0 , 16,
22084 0xfd08 , 0x3c08 , &NMD::MUL_4X4_ , 0,
22085 XMMS_ }, /* MUL[4X4] */
22086 { reserved_block , 0 , 0 , 16,
22087 0xfd08 , 0x3d00 , 0 , 0,
22088 0x0 }, /* P16.4X4~*(2) */
22089 { reserved_block , 0 , 0 , 16,
22090 0xfd08 , 0x3d08 , 0 , 0,
22091 0x0 }, /* P16.4X4~*(3) */
22092 };
22093
22094
22095 NMD::Pool NMD::P16_LB[4] = {
22096 { instruction , 0 , 0 , 16,
22097 0xfc0c , 0x5c00 , &NMD::LB_16_ , 0,
22098 0x0 }, /* LB[16] */
22099 { instruction , 0 , 0 , 16,
22100 0xfc0c , 0x5c04 , &NMD::SB_16_ , 0,
22101 0x0 }, /* SB[16] */
22102 { instruction , 0 , 0 , 16,
22103 0xfc0c , 0x5c08 , &NMD::LBU_16_ , 0,
22104 0x0 }, /* LBU[16] */
22105 { reserved_block , 0 , 0 , 16,
22106 0xfc0c , 0x5c0c , 0 , 0,
22107 0x0 }, /* P16.LB~*(3) */
22108 };
22109
22110
22111 NMD::Pool NMD::P16_LH[4] = {
22112 { instruction , 0 , 0 , 16,
22113 0xfc09 , 0x7c00 , &NMD::LH_16_ , 0,
22114 0x0 }, /* LH[16] */
22115 { instruction , 0 , 0 , 16,
22116 0xfc09 , 0x7c01 , &NMD::SH_16_ , 0,
22117 0x0 }, /* SH[16] */
22118 { instruction , 0 , 0 , 16,
22119 0xfc09 , 0x7c08 , &NMD::LHU_16_ , 0,
22120 0x0 }, /* LHU[16] */
22121 { reserved_block , 0 , 0 , 16,
22122 0xfc09 , 0x7c09 , 0 , 0,
22123 0x0 }, /* P16.LH~*(3) */
22124 };
22125
22126
22127 NMD::Pool NMD::P16[32] = {
22128 { pool , P16_MV , 2 , 16,
22129 0xfc00 , 0x1000 , 0 , 0,
22130 0x0 }, /* P16.MV */
22131 { pool , P16_SHIFT , 2 , 16,
22132 0xfc00 , 0x3000 , 0 , 0,
22133 0x0 }, /* P16.SHIFT */
22134 { pool , P16C , 2 , 16,
22135 0xfc00 , 0x5000 , 0 , 0,
22136 0x0 }, /* P16C */
22137 { pool , P16_A1 , 2 , 16,
22138 0xfc00 , 0x7000 , 0 , 0,
22139 0x0 }, /* P16.A1 */
22140 { pool , P16_A2 , 2 , 16,
22141 0xfc00 , 0x9000 , 0 , 0,
22142 0x0 }, /* P16.A2 */
22143 { pool , P16_ADDU , 2 , 16,
22144 0xfc00 , 0xb000 , 0 , 0,
22145 0x0 }, /* P16.ADDU */
22146 { instruction , 0 , 0 , 16,
22147 0xfc00 , 0xd000 , &NMD::LI_16_ , 0,
22148 0x0 }, /* LI[16] */
22149 { instruction , 0 , 0 , 16,
22150 0xfc00 , 0xf000 , &NMD::ANDI_16_ , 0,
22151 0x0 }, /* ANDI[16] */
22152 { instruction , 0 , 0 , 16,
22153 0xfc00 , 0x1400 , &NMD::LW_16_ , 0,
22154 0x0 }, /* LW[16] */
22155 { instruction , 0 , 0 , 16,
22156 0xfc00 , 0x3400 , &NMD::LW_SP_ , 0,
22157 0x0 }, /* LW[SP] */
22158 { instruction , 0 , 0 , 16,
22159 0xfc00 , 0x5400 , &NMD::LW_GP16_ , 0,
22160 0x0 }, /* LW[GP16] */
22161 { instruction , 0 , 0 , 16,
22162 0xfc00 , 0x7400 , &NMD::LW_4X4_ , 0,
22163 XMMS_ }, /* LW[4X4] */
22164 { instruction , 0 , 0 , 16,
22165 0xfc00 , 0x9400 , &NMD::SW_16_ , 0,
22166 0x0 }, /* SW[16] */
22167 { instruction , 0 , 0 , 16,
22168 0xfc00 , 0xb400 , &NMD::SW_SP_ , 0,
22169 0x0 }, /* SW[SP] */
22170 { instruction , 0 , 0 , 16,
22171 0xfc00 , 0xd400 , &NMD::SW_GP16_ , 0,
22172 0x0 }, /* SW[GP16] */
22173 { instruction , 0 , 0 , 16,
22174 0xfc00 , 0xf400 , &NMD::SW_4X4_ , 0,
22175 XMMS_ }, /* SW[4X4] */
22176 { branch_instruction , 0 , 0 , 16,
22177 0xfc00 , 0x1800 , &NMD::BC_16_ , 0,
22178 0x0 }, /* BC[16] */
22179 { call_instruction , 0 , 0 , 16,
22180 0xfc00 , 0x3800 , &NMD::BALC_16_ , 0,
22181 0x0 }, /* BALC[16] */
22182 { reserved_block , 0 , 0 , 16,
22183 0xfc00 , 0x5800 , 0 , 0,
22184 0x0 }, /* P16~*(10) */
22185 { reserved_block , 0 , 0 , 16,
22186 0xfc00 , 0x7800 , 0 , 0,
22187 0x0 }, /* P16~*(14) */
22188 { branch_instruction , 0 , 0 , 16,
22189 0xfc00 , 0x9800 , &NMD::BEQZC_16_ , 0,
22190 0x0 }, /* BEQZC[16] */
22191 { branch_instruction , 0 , 0 , 16,
22192 0xfc00 , 0xb800 , &NMD::BNEZC_16_ , 0,
22193 0x0 }, /* BNEZC[16] */
22194 { pool , P16_BR , 2 , 16,
22195 0xfc00 , 0xd800 , 0 , 0,
22196 0x0 }, /* P16.BR */
22197 { reserved_block , 0 , 0 , 16,
22198 0xfc00 , 0xf800 , 0 , 0,
22199 0x0 }, /* P16~*(30) */
22200 { pool , P16_SR , 2 , 16,
22201 0xfc00 , 0x1c00 , 0 , 0,
22202 0x0 }, /* P16.SR */
22203 { pool , P16_4X4 , 4 , 16,
22204 0xfc00 , 0x3c00 , 0 , 0,
22205 0x0 }, /* P16.4X4 */
22206 { pool , P16_LB , 4 , 16,
22207 0xfc00 , 0x5c00 , 0 , 0,
22208 0x0 }, /* P16.LB */
22209 { pool , P16_LH , 4 , 16,
22210 0xfc00 , 0x7c00 , 0 , 0,
22211 0x0 }, /* P16.LH */
22212 { reserved_block , 0 , 0 , 16,
22213 0xfc00 , 0x9c00 , 0 , 0,
22214 0x0 }, /* P16~*(19) */
22215 { instruction , 0 , 0 , 16,
22216 0xfc00 , 0xbc00 , &NMD::MOVEP , 0,
22217 XMMS_ }, /* MOVEP */
22218 { reserved_block , 0 , 0 , 16,
22219 0xfc00 , 0xdc00 , 0 , 0,
22220 0x0 }, /* P16~*(27) */
22221 { instruction , 0 , 0 , 16,
22222 0xfc00 , 0xfc00 , &NMD::MOVEP_REV_ , 0,
22223 XMMS_ }, /* MOVEP[REV] */
22224 };
22225
22226
22227 NMD::Pool NMD::MAJOR[2] = {
22228 { pool , P32 , 32 , 32,
22229 0x10000000, 0x00000000, 0 , 0,
22230 0x0 }, /* P32 */
22231 { pool , P16 , 32 , 16,
22232 0x1000 , 0x1000 , 0 , 0,
22233 0x0 }, /* P16 */
22234 };
QEMU mirror