?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qapi: better docs for calc-dirty-rate and friends
[qemu/armbru.git] / disas / nanomips.c
bloba0253598dd6562aecd4b68c7e2dbb5baa0db5740
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 /*
24 * Documentation used while implementing this component:
25 *
26 * [1] "MIPS® Architecture Base: nanoMIPS32(tm) Instruction Set Technical
27 * Reference Manual", Revision 01.01, April 27, 2018
28 */
29
30 #include "qemu/osdep.h"
31 #include "disas/dis-asm.h"
32
33 typedef int64_t int64;
34 typedef uint64_t uint64;
35 typedef uint32_t uint32;
36 typedef uint16_t uint16;
37 typedef uint64_t img_address;
38
39 typedef enum {
40 instruction,
41 call_instruction,
42 branch_instruction,
43 return_instruction,
44 reserved_block,
45 pool,
46 } TABLE_ENTRY_TYPE;
47
48 typedef enum {
49 MIPS64_ = 0x00000001,
50 XNP_ = 0x00000002,
51 XMMS_ = 0x00000004,
52 EVA_ = 0x00000008,
53 DSP_ = 0x00000010,
54 MT_ = 0x00000020,
55 EJTAG_ = 0x00000040,
56 TLBINV_ = 0x00000080,
57 CP0_ = 0x00000100,
58 CP1_ = 0x00000200,
59 CP2_ = 0x00000400,
60 UDI_ = 0x00000800,
61 MCU_ = 0x00001000,
62 VZ_ = 0x00002000,
63 TLB_ = 0x00004000,
64 MVH_ = 0x00008000,
65 ALL_ATTRIBUTES = 0xffffffffull,
66 } TABLE_ATTRIBUTE_TYPE;
67
68 typedef struct Dis_info {
69 img_address m_pc;
70 fprintf_function fprintf_func;
71 FILE *stream;
72 sigjmp_buf buf;
73 } Dis_info;
74
75 typedef bool (*conditional_function)(uint64 instruction);
76 typedef char * (*disassembly_function)(uint64 instruction,
77 Dis_info *info);
78
79 typedef struct Pool {
80 TABLE_ENTRY_TYPE type;
81 const struct Pool *next_table;
82 int next_table_size;
83 int instructions_size;
84 uint64 mask;
85 uint64 value;
86 disassembly_function disassembly;
87 conditional_function condition;
88 uint64 attributes;
89 } Pool;
90
91 #define IMGASSERTONCE(test)
92
93
94 static char * G_GNUC_PRINTF(1, 2) img_format(const char *format, ...)
95 {
96 char *buffer;
97 va_list args;
98 va_start(args, format);
99 buffer = g_strdup_vprintf(format, args);
100 va_end(args);
101 return buffer;
102 }
103
104
105 static char *to_string(img_address a)
106 {
107 return g_strdup_printf("0x%" PRIx64, a);
108 }
109
110
111 static uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
112 {
113 return (data << (64 - (bit_size + bit_offset))) >> (64 - bit_size);
114 }
115
116
117 static int64 sign_extend(int64 data, int msb)
118 {
119 uint64 shift = 63 - msb;
120 return (data << shift) >> shift;
121 }
122
123
124 static uint64 renumber_registers(uint64 index, uint64 *register_list,
125 size_t register_list_size, Dis_info *info)
126 {
127 if (index < register_list_size) {
128 return register_list[index];
129 }
130
131 info->fprintf_func(info->stream, "Invalid register mapping index %" PRIu64
132 ", size of list = %zu", index, register_list_size);
133 siglongjmp(info->buf, 1);
134 }
135
136
137 /*
138 * decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
139 *
140 * Map a 4-bit code to the 5-bit register space according to this pattern:
141 *
142 * 1 0
143 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
144 * | | | | | | | | | | | | | | | |
145 * | | | | | | | | | | | | | | | |
146 * | | | | | | | | | | | └---------------┐
147 * | | | | | | | | | | └---------------┐ |
148 * | | | | | | | | | └---------------┐ | |
149 * | | | | | | | | └---------------┐ | | |
150 * | | | | | | | | | | | | | | | |
151 * | | | | | | | | | | | | | | | |
152 * 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
153 * 3 2 1 0
154 *
155 * Used in handling following instructions:
156 *
157 * - ADDU[4X4]
158 * - LW[4X4]
159 * - MOVEP[REV]
160 * - MUL[4X4]
161 * - SW[4X4]
162 */
163 static uint64 decode_gpr_gpr4(uint64 d, Dis_info *info)
164 {
165 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
166 16, 17, 18, 19, 20, 21, 22, 23 };
167 return renumber_registers(d, register_list,
168 sizeof(register_list) / sizeof(register_list[0]), info);
169 }
170
171
172 /*
173 * decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
174 *
175 * Map a 4-bit code to the 5-bit register space according to this pattern:
176 *
177 * 1 0
178 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
179 * | | | | | | | | | | | | | | | |
180 * | | | | | | | | | | | | └---------------------┐
181 * | | | | | | | | | | | └---------------┐ |
182 * | | | | | | | | | | └---------------┐ | |
183 * | | | | | | | | | └---------------┐ | | |
184 * | | | | | | | | └---------------┐ | | | |
185 * | | | | | | | | | | | | | | | |
186 * | | | | | | | | | | | | | | | |
187 * 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
188 * 3 2 1 0
189 *
190 * This pattern is the same one used for 'gpr4' gpr encoding type, except for
191 * the input value 3, that is mapped to the output value 0 instead of 11.
192 *
193 * Used in handling following instructions:
194 *
195 * - MOVE.BALC
196 * - MOVEP
197 * - SW[4X4]
198 */
199 static uint64 decode_gpr_gpr4_zero(uint64 d, Dis_info *info)
200 {
201 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
202 16, 17, 18, 19, 20, 21, 22, 23 };
203 return renumber_registers(d, register_list,
204 sizeof(register_list) / sizeof(register_list[0]), info);
205 }
206
207
208 /*
209 * decode_gpr_gpr3() - decoder for 'gpr3' gpr encoding type
210 *
211 * Map a 3-bit code to the 5-bit register space according to this pattern:
212 *
213 * 7 6 5 4 3 2 1 0
214 * | | | | | | | |
215 * | | | | | | | |
216 * | | | └-----------------------┐
217 * | | └-----------------------┐ |
218 * | └-----------------------┐ | |
219 * └-----------------------┐ | | |
220 * | | | | | | | |
221 * ┌-------┘ | | | | | | |
222 * | ┌-------┘ | | | | | |
223 * | | ┌-------┘ | | | | |
224 * | | | ┌-------┘ | | | |
225 * | | | | | | | |
226 * 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
227 * 3 2 1 0
228 *
229 * Used in handling following instructions:
230 *
231 * - ADDIU[R1.SP]
232 * - ADDIU[R2]
233 * - ADDU[16]
234 * - AND[16]
235 * - ANDI[16]
236 * - BEQC[16]
237 * - BEQZC[16]
238 * - BNEC[16]
239 * - BNEZC[16]
240 * - LB[16]
241 * - LBU[16]
242 * - LH[16]
243 * - LHU[16]
244 * - LI[16]
245 * - LW[16]
246 * - LW[GP16]
247 * - LWXS[16]
248 * - NOT[16]
249 * - OR[16]
250 * - SB[16]
251 * - SH[16]
252 * - SLL[16]
253 * - SRL[16]
254 * - SUBU[16]
255 * - SW[16]
256 * - XOR[16]
257 */
258 static uint64 decode_gpr_gpr3(uint64 d, Dis_info *info)
259 {
260 static uint64 register_list[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
261 return renumber_registers(d, register_list,
262 sizeof(register_list) / sizeof(register_list[0]), info);
263 }
264
265
266 /*
267 * decode_gpr_gpr3_src_store() - decoder for 'gpr3.src.store' gpr encoding
268 * type
269 *
270 * Map a 3-bit code to the 5-bit register space according to this pattern:
271 *
272 * 7 6 5 4 3 2 1 0
273 * | | | | | | | |
274 * | | | | | | | └-----------------------┐
275 * | | | └-----------------------┐ |
276 * | | └-----------------------┐ | |
277 * | └-----------------------┐ | | |
278 * └-----------------------┐ | | | |
279 * | | | | | | | |
280 * ┌-------┘ | | | | | | |
281 * | ┌-------┘ | | | | | |
282 * | | ┌-------┘ | | | | |
283 * | | | | | | | |
284 * | | | | | | | |
285 * 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
286 * 3 2 1 0
287 *
288 * This pattern is the same one used for 'gpr3' gpr encoding type, except for
289 * the input value 0, that is mapped to the output value 0 instead of 16.
290 *
291 * Used in handling following instructions:
292 *
293 * - SB[16]
294 * - SH[16]
295 * - SW[16]
296 * - SW[GP16]
297 */
298 static uint64 decode_gpr_gpr3_src_store(uint64 d, Dis_info *info)
299 {
300 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
301 return renumber_registers(d, register_list,
302 sizeof(register_list) / sizeof(register_list[0]), info);
303 }
304
305
306 /*
307 * decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
308 *
309 * Map a 2-bit code to the 5-bit register space according to this pattern:
310 *
311 * 3 2 1 0
312 * | | | |
313 * | | | |
314 * | | | └-------------------┐
315 * | | └-------------------┐ |
316 * | └-------------------┐ | |
317 * └-------------------┐ | | |
318 * | | | |
319 * | | | |
320 * 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
321 * 3 2 1 0
322 *
323 * Used in handling following instructions:
324 *
325 * - MOVEP
326 * - MOVEP[REV]
327 */
328 static uint64 decode_gpr_gpr2_reg1(uint64 d, Dis_info *info)
329 {
330 static uint64 register_list[] = { 4, 5, 6, 7 };
331 return renumber_registers(d, register_list,
332 sizeof(register_list) / sizeof(register_list[0]), info);
333 }
334
335
336 /*
337 * decode_gpr_gpr2_reg2() - decoder for 'gpr2.reg2' gpr encoding type
338 *
339 * Map a 2-bit code to the 5-bit register space according to this pattern:
340 *
341 * 3 2 1 0
342 * | | | |
343 * | | | |
344 * | | | └-----------------┐
345 * | | └-----------------┐ |
346 * | └-----------------┐ | |
347 * └-----------------┐ | | |
348 * | | | |
349 * | | | |
350 * 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
351 * 3 2 1 0
352 *
353 * Used in handling following instructions:
354 *
355 * - MOVEP
356 * - MOVEP[REV]
357 */
358 static uint64 decode_gpr_gpr2_reg2(uint64 d, Dis_info *info)
359 {
360 static uint64 register_list[] = { 5, 6, 7, 8 };
361 return renumber_registers(d, register_list,
362 sizeof(register_list) / sizeof(register_list[0]), info);
363 }
364
365
366 /*
367 * decode_gpr_gpr1() - decoder for 'gpr1' gpr encoding type
368 *
369 * Map a 1-bit code to the 5-bit register space according to this pattern:
370 *
371 * 1 0
372 * | |
373 * | |
374 * | └---------------------┐
375 * └---------------------┐ |
376 * | |
377 * | |
378 * | |
379 * | |
380 * 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
381 * 3 2 1 0
382 *
383 * Used in handling following instruction:
384 *
385 * - MOVE.BALC
386 */
387 static uint64 decode_gpr_gpr1(uint64 d, Dis_info *info)
388 {
389 static uint64 register_list[] = { 4, 5 };
390 return renumber_registers(d, register_list,
391 sizeof(register_list) / sizeof(register_list[0]), info);
392 }
393
394
395 static int64 neg_copy(uint64 d)
396 {
397 return 0ll - d;
398 }
399
400
401 static uint64 encode_count3_from_count(uint64 d)
402 {
403 IMGASSERTONCE(d < 8);
404 return d == 0ull ? 8ull : d;
405 }
406
407
408 static uint64 encode_shift3_from_shift(uint64 d)
409 {
410 IMGASSERTONCE(d < 8);
411 return d == 0ull ? 8ull : d;
412 }
413
414
415 /* special value for load literal */
416 static int64 encode_eu_from_s_li16(uint64 d)
417 {
418 IMGASSERTONCE(d < 128);
419 return d == 127 ? -1 : (int64)d;
420 }
421
422
423 static uint64 encode_msbd_from_size(uint64 d)
424 {
425 IMGASSERTONCE(d < 32);
426 return d + 1;
427 }
428
429
430 static uint64 encode_eu_from_u_andi16(uint64 d)
431 {
432 IMGASSERTONCE(d < 16);
433 if (d == 12) {
434 return 0x00ffull;
435 }
436 if (d == 13) {
437 return 0xffffull;
438 }
439 return d;
440 }
441
442
443 /* save16 / restore16 ???? */
444 static uint64 encode_rt1_from_rt(uint64 d)
445 {
446 return d ? 31 : 30;
447 }
448
449
450 static const char *GPR(uint64 reg, Dis_info *info)
451 {
452 static const char *gpr_reg[32] = {
453 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
454 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
455 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
456 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
457 };
458
459 if (reg < 32) {
460 return gpr_reg[reg];
461 }
462
463 info->fprintf_func(info->stream, "Invalid GPR register index %" PRIu64,
464 reg);
465 siglongjmp(info->buf, 1);
466 }
467
468
469 static char *save_restore_list(uint64 rt, uint64 count, uint64 gp,
470 Dis_info *info)
471 {
472 char *reg_list[34];
473 reg_list[0] = (char *)"";
474
475 assert(count <= 32);
476 for (uint64 counter = 0; counter != count; counter++) {
477 bool use_gp = gp && (counter == count - 1);
478 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
479 /* glib usage below requires casting away const */
480 reg_list[counter + 1] = (char *)GPR(this_rt, info);
481 }
482 reg_list[count + 1] = NULL;
483
484 return g_strjoinv(",", reg_list);
485 }
486
487
488 static const char *FPR(uint64 reg, Dis_info *info)
489 {
490 static const char *fpr_reg[32] = {
491 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
492 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
493 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
494 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
495 };
496
497 if (reg < 32) {
498 return fpr_reg[reg];
499 }
500
501 info->fprintf_func(info->stream, "Invalid FPR register index %" PRIu64,
502 reg);
503 siglongjmp(info->buf, 1);
504 }
505
506
507 static const char *AC(uint64 reg, Dis_info *info)
508 {
509 static const char *ac_reg[4] = {
510 "ac0", "ac1", "ac2", "ac3"
511 };
512
513 if (reg < 4) {
514 return ac_reg[reg];
515 }
516
517 info->fprintf_func(info->stream, "Invalid AC register index %" PRIu64,
518 reg);
519 siglongjmp(info->buf, 1);
520 }
521
522
523 static char *ADDRESS(uint64 value, int instruction_size, Dis_info *info)
524 {
525 /* token for string replace */
526 img_address address = info->m_pc + value + instruction_size;
527 /* symbol replacement */
528 return to_string(address);
529 }
530
531
532 static uint64 extract_op_code_value(const uint16 *data, int size)
533 {
534 switch (size) {
535 case 16:
536 return data[0];
537 case 32:
538 return ((uint64)data[0] << 16) | data[1];
539 case 48:
540 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
541 default:
542 return data[0];
543 }
544 }
545
546
547 /*
548 * Recurse through tables until the instruction is found then return
549 * the string and size
550 *
551 * inputs:
552 * pointer to a word stream,
553 * disassember table and size
554 * returns:
555 * instruction size - negative is error
556 * disassembly string - on error will constain error string
557 */
558 static int Disassemble(const uint16 *data, char **dis,
559 TABLE_ENTRY_TYPE *type, const Pool *table,
560 int table_size, Dis_info *info)
561 {
562 for (int i = 0; i < table_size; i++) {
563 uint64 op_code = extract_op_code_value(data,
564 table[i].instructions_size);
565 if ((op_code & table[i].mask) == table[i].value) {
566 /* possible match */
567 conditional_function cond = table[i].condition;
568 if ((cond == NULL) || cond(op_code)) {
569 if (table[i].type == pool) {
570 return Disassemble(data, dis, type,
571 table[i].next_table,
572 table[i].next_table_size,
573 info);
574 } else if ((table[i].type == instruction) ||
575 (table[i].type == call_instruction) ||
576 (table[i].type == branch_instruction) ||
577 (table[i].type == return_instruction)) {
578 disassembly_function dis_fn = table[i].disassembly;
579 if (dis_fn == 0) {
580 *dis = g_strdup(
581 "disassembler failure - bad table entry");
582 return -6;
583 }
584 *type = table[i].type;
585 *dis = dis_fn(op_code, info);
586 return table[i].instructions_size;
587 } else {
588 *dis = g_strdup("reserved instruction");
589 return -2;
590 }
591 }
592 }
593 }
594 *dis = g_strdup("failed to disassemble");
595 return -1; /* failed to disassemble */
596 }
597
598
599 static uint64 extract_code_18_to_0(uint64 instruction)
600 {
601 uint64 value = 0;
602 value |= extract_bits(instruction, 0, 19);
603 return value;
604 }
605
606
607 static uint64 extract_shift3_2_1_0(uint64 instruction)
608 {
609 uint64 value = 0;
610 value |= extract_bits(instruction, 0, 3);
611 return value;
612 }
613
614
615 static uint64 extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
616 {
617 uint64 value = 0;
618 value |= extract_bits(instruction, 3, 9) << 3;
619 return value;
620 }
621
622
623 static uint64 extract_count_3_2_1_0(uint64 instruction)
624 {
625 uint64 value = 0;
626 value |= extract_bits(instruction, 0, 4);
627 return value;
628 }
629
630
631 static uint64 extract_rtz3_9_8_7(uint64 instruction)
632 {
633 uint64 value = 0;
634 value |= extract_bits(instruction, 7, 3);
635 return value;
636 }
637
638
639 static uint64 extract_u_17_to_1__s1(uint64 instruction)
640 {
641 uint64 value = 0;
642 value |= extract_bits(instruction, 1, 17) << 1;
643 return value;
644 }
645
646
647 static int64 extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
648 {
649 int64 value = 0;
650 value |= extract_bits(instruction, 11, 10);
651 value = sign_extend(value, 9);
652 return value;
653 }
654
655
656 static int64 extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
657 {
658 int64 value = 0;
659 value |= extract_bits(instruction, 0, 1) << 11;
660 value |= extract_bits(instruction, 1, 10) << 1;
661 value = sign_extend(value, 11);
662 return value;
663 }
664
665
666 static uint64 extract_u_10(uint64 instruction)
667 {
668 uint64 value = 0;
669 value |= extract_bits(instruction, 10, 1);
670 return value;
671 }
672
673
674 static uint64 extract_rtz4_27_26_25_23_22_21(uint64 instruction)
675 {
676 uint64 value = 0;
677 value |= extract_bits(instruction, 21, 3);
678 value |= extract_bits(instruction, 25, 1) << 3;
679 return value;
680 }
681
682
683 static uint64 extract_sa_15_14_13_12_11(uint64 instruction)
684 {
685 uint64 value = 0;
686 value |= extract_bits(instruction, 11, 5);
687 return value;
688 }
689
690
691 static uint64 extract_shift_4_3_2_1_0(uint64 instruction)
692 {
693 uint64 value = 0;
694 value |= extract_bits(instruction, 0, 5);
695 return value;
696 }
697
698
699 static uint64 extract_shiftx_10_9_8_7__s1(uint64 instruction)
700 {
701 uint64 value = 0;
702 value |= extract_bits(instruction, 7, 4) << 1;
703 return value;
704 }
705
706
707 static uint64 extract_hint_25_24_23_22_21(uint64 instruction)
708 {
709 uint64 value = 0;
710 value |= extract_bits(instruction, 21, 5);
711 return value;
712 }
713
714
715 static uint64 extract_count3_14_13_12(uint64 instruction)
716 {
717 uint64 value = 0;
718 value |= extract_bits(instruction, 12, 3);
719 return value;
720 }
721
722
723 static int64 extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
724 {
725 int64 value = 0;
726 value |= extract_bits(instruction, 0, 1) << 31;
727 value |= extract_bits(instruction, 2, 10) << 21;
728 value |= extract_bits(instruction, 12, 9) << 12;
729 value = sign_extend(value, 31);
730 return value;
731 }
732
733
734 static int64 extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
735 {
736 int64 value = 0;
737 value |= extract_bits(instruction, 0, 1) << 7;
738 value |= extract_bits(instruction, 1, 6) << 1;
739 value = sign_extend(value, 7);
740 return value;
741 }
742
743
744 static uint64 extract_u2_10_9(uint64 instruction)
745 {
746 uint64 value = 0;
747 value |= extract_bits(instruction, 9, 2);
748 return value;
749 }
750
751
752 static uint64 extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
753 {
754 uint64 value = 0;
755 value |= extract_bits(instruction, 16, 10);
756 return value;
757 }
758
759
760 static uint64 extract_rs_20_19_18_17_16(uint64 instruction)
761 {
762 uint64 value = 0;
763 value |= extract_bits(instruction, 16, 5);
764 return value;
765 }
766
767
768 static uint64 extract_u_2_1__s1(uint64 instruction)
769 {
770 uint64 value = 0;
771 value |= extract_bits(instruction, 1, 2) << 1;
772 return value;
773 }
774
775
776 static uint64 extract_stripe_6(uint64 instruction)
777 {
778 uint64 value = 0;
779 value |= extract_bits(instruction, 6, 1);
780 return value;
781 }
782
783
784 static uint64 extract_ac_15_14(uint64 instruction)
785 {
786 uint64 value = 0;
787 value |= extract_bits(instruction, 14, 2);
788 return value;
789 }
790
791
792 static uint64 extract_shift_20_19_18_17_16(uint64 instruction)
793 {
794 uint64 value = 0;
795 value |= extract_bits(instruction, 16, 5);
796 return value;
797 }
798
799
800 static uint64 extract_rdl_25_24(uint64 instruction)
801 {
802 uint64 value = 0;
803 value |= extract_bits(instruction, 24, 1);
804 return value;
805 }
806
807
808 static int64 extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
809 {
810 int64 value = 0;
811 value |= extract_bits(instruction, 0, 1) << 10;
812 value |= extract_bits(instruction, 1, 9) << 1;
813 value = sign_extend(value, 10);
814 return value;
815 }
816
817
818 static uint64 extract_eu_6_5_4_3_2_1_0(uint64 instruction)
819 {
820 uint64 value = 0;
821 value |= extract_bits(instruction, 0, 7);
822 return value;
823 }
824
825
826 static uint64 extract_shift_5_4_3_2_1_0(uint64 instruction)
827 {
828 uint64 value = 0;
829 value |= extract_bits(instruction, 0, 6);
830 return value;
831 }
832
833
834 static uint64 extract_count_19_18_17_16(uint64 instruction)
835 {
836 uint64 value = 0;
837 value |= extract_bits(instruction, 16, 4);
838 return value;
839 }
840
841
842 static uint64 extract_code_2_1_0(uint64 instruction)
843 {
844 uint64 value = 0;
845 value |= extract_bits(instruction, 0, 3);
846 return value;
847 }
848
849
850 static uint64 extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
851 {
852 uint64 value = 0;
853 value |= extract_bits(instruction, 0, 12);
854 return value;
855 }
856
857
858 static uint64 extract_rs_4_3_2_1_0(uint64 instruction)
859 {
860 uint64 value = 0;
861 value |= extract_bits(instruction, 0, 5);
862 return value;
863 }
864
865
866 static uint64 extract_u_20_to_3__s3(uint64 instruction)
867 {
868 uint64 value = 0;
869 value |= extract_bits(instruction, 3, 18) << 3;
870 return value;
871 }
872
873
874 static uint64 extract_u_3_2_1_0__s2(uint64 instruction)
875 {
876 uint64 value = 0;
877 value |= extract_bits(instruction, 0, 4) << 2;
878 return value;
879 }
880
881
882 static uint64 extract_cofun_25_24_23(uint64 instruction)
883 {
884 uint64 value = 0;
885 value |= extract_bits(instruction, 3, 23);
886 return value;
887 }
888
889
890 static uint64 extract_u_2_1_0__s2(uint64 instruction)
891 {
892 uint64 value = 0;
893 value |= extract_bits(instruction, 0, 3) << 2;
894 return value;
895 }
896
897
898 static uint64 extract_rd3_3_2_1(uint64 instruction)
899 {
900 uint64 value = 0;
901 value |= extract_bits(instruction, 1, 3);
902 return value;
903 }
904
905
906 static uint64 extract_sa_15_14_13_12(uint64 instruction)
907 {
908 uint64 value = 0;
909 value |= extract_bits(instruction, 12, 4);
910 return value;
911 }
912
913
914 static uint64 extract_rt_25_24_23_22_21(uint64 instruction)
915 {
916 uint64 value = 0;
917 value |= extract_bits(instruction, 21, 5);
918 return value;
919 }
920
921
922 static uint64 extract_ru_7_6_5_4_3(uint64 instruction)
923 {
924 uint64 value = 0;
925 value |= extract_bits(instruction, 3, 5);
926 return value;
927 }
928
929
930 static uint64 extract_u_17_to_0(uint64 instruction)
931 {
932 uint64 value = 0;
933 value |= extract_bits(instruction, 0, 18);
934 return value;
935 }
936
937
938 static uint64 extract_rsz4_4_2_1_0(uint64 instruction)
939 {
940 uint64 value = 0;
941 value |= extract_bits(instruction, 0, 3);
942 value |= extract_bits(instruction, 4, 1) << 3;
943 return value;
944 }
945
946
947 static int64 extract_s__se21_0_20_to_1_s1(uint64 instruction)
948 {
949 int64 value = 0;
950 value |= extract_bits(instruction, 0, 1) << 21;
951 value |= extract_bits(instruction, 1, 20) << 1;
952 value = sign_extend(value, 21);
953 return value;
954 }
955
956
957 static uint64 extract_op_25_to_3(uint64 instruction)
958 {
959 uint64 value = 0;
960 value |= extract_bits(instruction, 3, 23);
961 return value;
962 }
963
964
965 static uint64 extract_rs4_4_2_1_0(uint64 instruction)
966 {
967 uint64 value = 0;
968 value |= extract_bits(instruction, 0, 3);
969 value |= extract_bits(instruction, 4, 1) << 3;
970 return value;
971 }
972
973
974 static uint64 extract_bit_23_22_21(uint64 instruction)
975 {
976 uint64 value = 0;
977 value |= extract_bits(instruction, 21, 3);
978 return value;
979 }
980
981
982 static uint64 extract_rt_41_40_39_38_37(uint64 instruction)
983 {
984 uint64 value = 0;
985 value |= extract_bits(instruction, 37, 5);
986 return value;
987 }
988
989
990 static int64 extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
991 {
992 int64 value = 0;
993 value |= extract_bits(instruction, 16, 6);
994 value = sign_extend(value, 5);
995 return value;
996 }
997
998
999 static uint64 extract_rd2_3_8(uint64 instruction)
1000 {
1001 uint64 value = 0;
1002 value |= extract_bits(instruction, 3, 1) << 1;
1003 value |= extract_bits(instruction, 8, 1);
1004 return value;
1005 }
1006
1007
1008 static uint64 extract_code_17_to_0(uint64 instruction)
1009 {
1010 uint64 value = 0;
1011 value |= extract_bits(instruction, 0, 18);
1012 return value;
1013 }
1014
1015
1016 static uint64 extract_size_20_19_18_17_16(uint64 instruction)
1017 {
1018 uint64 value = 0;
1019 value |= extract_bits(instruction, 16, 5);
1020 return value;
1021 }
1022
1023
1024 static int64 extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
1025 {
1026 int64 value = 0;
1027 value |= extract_bits(instruction, 2, 6) << 2;
1028 value |= extract_bits(instruction, 15, 1) << 8;
1029 value = sign_extend(value, 8);
1030 return value;
1031 }
1032
1033
1034 static uint64 extract_u_15_to_0(uint64 instruction)
1035 {
1036 uint64 value = 0;
1037 value |= extract_bits(instruction, 0, 16);
1038 return value;
1039 }
1040
1041
1042 static uint64 extract_fs_20_19_18_17_16(uint64 instruction)
1043 {
1044 uint64 value = 0;
1045 value |= extract_bits(instruction, 16, 5);
1046 return value;
1047 }
1048
1049
1050 static int64 extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
1051 {
1052 int64 value = 0;
1053 value |= extract_bits(instruction, 0, 8);
1054 value |= extract_bits(instruction, 15, 1) << 8;
1055 value = sign_extend(value, 8);
1056 return value;
1057 }
1058
1059
1060 static uint64 extract_stype_20_19_18_17_16(uint64 instruction)
1061 {
1062 uint64 value = 0;
1063 value |= extract_bits(instruction, 16, 5);
1064 return value;
1065 }
1066
1067
1068 static uint64 extract_rtl_11(uint64 instruction)
1069 {
1070 uint64 value = 0;
1071 value |= extract_bits(instruction, 9, 1);
1072 return value;
1073 }
1074
1075
1076 static uint64 extract_hs_20_19_18_17_16(uint64 instruction)
1077 {
1078 uint64 value = 0;
1079 value |= extract_bits(instruction, 16, 5);
1080 return value;
1081 }
1082
1083
1084 static uint64 extract_sel_13_12_11(uint64 instruction)
1085 {
1086 uint64 value = 0;
1087 value |= extract_bits(instruction, 11, 3);
1088 return value;
1089 }
1090
1091
1092 static uint64 extract_lsb_4_3_2_1_0(uint64 instruction)
1093 {
1094 uint64 value = 0;
1095 value |= extract_bits(instruction, 0, 5);
1096 return value;
1097 }
1098
1099
1100 static uint64 extract_gp_2(uint64 instruction)
1101 {
1102 uint64 value = 0;
1103 value |= extract_bits(instruction, 2, 1);
1104 return value;
1105 }
1106
1107
1108 static uint64 extract_rt3_9_8_7(uint64 instruction)
1109 {
1110 uint64 value = 0;
1111 value |= extract_bits(instruction, 7, 3);
1112 return value;
1113 }
1114
1115
1116 static uint64 extract_ft_25_24_23_22_21(uint64 instruction)
1117 {
1118 uint64 value = 0;
1119 value |= extract_bits(instruction, 21, 5);
1120 return value;
1121 }
1122
1123
1124 static uint64 extract_u_17_16_15_14_13_12_11(uint64 instruction)
1125 {
1126 uint64 value = 0;
1127 value |= extract_bits(instruction, 11, 7);
1128 return value;
1129 }
1130
1131
1132 static uint64 extract_cs_20_19_18_17_16(uint64 instruction)
1133 {
1134 uint64 value = 0;
1135 value |= extract_bits(instruction, 16, 5);
1136 return value;
1137 }
1138
1139
1140 static uint64 extract_rt4_9_7_6_5(uint64 instruction)
1141 {
1142 uint64 value = 0;
1143 value |= extract_bits(instruction, 5, 3);
1144 value |= extract_bits(instruction, 9, 1) << 3;
1145 return value;
1146 }
1147
1148
1149 static uint64 extract_msbt_10_9_8_7_6(uint64 instruction)
1150 {
1151 uint64 value = 0;
1152 value |= extract_bits(instruction, 6, 5);
1153 return value;
1154 }
1155
1156
1157 static uint64 extract_u_5_4_3_2_1_0__s2(uint64 instruction)
1158 {
1159 uint64 value = 0;
1160 value |= extract_bits(instruction, 0, 6) << 2;
1161 return value;
1162 }
1163
1164
1165 static uint64 extract_sa_15_14_13(uint64 instruction)
1166 {
1167 uint64 value = 0;
1168 value |= extract_bits(instruction, 13, 3);
1169 return value;
1170 }
1171
1172
1173 static int64 extract_s__se14_0_13_to_1_s1(uint64 instruction)
1174 {
1175 int64 value = 0;
1176 value |= extract_bits(instruction, 0, 1) << 14;
1177 value |= extract_bits(instruction, 1, 13) << 1;
1178 value = sign_extend(value, 14);
1179 return value;
1180 }
1181
1182
1183 static uint64 extract_rs3_6_5_4(uint64 instruction)
1184 {
1185 uint64 value = 0;
1186 value |= extract_bits(instruction, 4, 3);
1187 return value;
1188 }
1189
1190
1191 static uint64 extract_u_31_to_0__s32(uint64 instruction)
1192 {
1193 uint64 value = 0;
1194 value |= extract_bits(instruction, 0, 32) << 32;
1195 return value;
1196 }
1197
1198
1199 static uint64 extract_shift_10_9_8_7_6(uint64 instruction)
1200 {
1201 uint64 value = 0;
1202 value |= extract_bits(instruction, 6, 5);
1203 return value;
1204 }
1205
1206
1207 static uint64 extract_cs_25_24_23_22_21(uint64 instruction)
1208 {
1209 uint64 value = 0;
1210 value |= extract_bits(instruction, 21, 5);
1211 return value;
1212 }
1213
1214
1215 static uint64 extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1216 {
1217 uint64 value = 0;
1218 value |= extract_bits(instruction, 6, 6);
1219 return value;
1220 }
1221
1222
1223 static uint64 extract_rt_9_8_7_6_5(uint64 instruction)
1224 {
1225 uint64 value = 0;
1226 value |= extract_bits(instruction, 5, 5);
1227 return value;
1228 }
1229
1230
1231 static uint64 extract_op_25_24_23_22_21(uint64 instruction)
1232 {
1233 uint64 value = 0;
1234 value |= extract_bits(instruction, 21, 5);
1235 return value;
1236 }
1237
1238
1239 static uint64 extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
1240 {
1241 uint64 value = 0;
1242 value |= extract_bits(instruction, 0, 7) << 2;
1243 return value;
1244 }
1245
1246
1247 static uint64 extract_bit_16_15_14_13_12_11(uint64 instruction)
1248 {
1249 uint64 value = 0;
1250 value |= extract_bits(instruction, 11, 6);
1251 return value;
1252 }
1253
1254
1255 static uint64 extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1256 {
1257 uint64 value = 0;
1258 value |= extract_bits(instruction, 14, 7);
1259 return value;
1260 }
1261
1262
1263 static uint64 extract_eu_3_2_1_0(uint64 instruction)
1264 {
1265 uint64 value = 0;
1266 value |= extract_bits(instruction, 0, 4);
1267 return value;
1268 }
1269
1270
1271 static uint64 extract_u_7_6_5_4__s4(uint64 instruction)
1272 {
1273 uint64 value = 0;
1274 value |= extract_bits(instruction, 4, 4) << 4;
1275 return value;
1276 }
1277
1278
1279 static int64 extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
1280 {
1281 int64 value = 0;
1282 value |= extract_bits(instruction, 3, 5) << 3;
1283 value |= extract_bits(instruction, 15, 1) << 8;
1284 value = sign_extend(value, 8);
1285 return value;
1286 }
1287
1288
1289 static uint64 extract_ft_15_14_13_12_11(uint64 instruction)
1290 {
1291 uint64 value = 0;
1292 value |= extract_bits(instruction, 11, 5);
1293 return value;
1294 }
1295
1296
1297 static int64 extract_s__se31_15_to_0_31_to_16(uint64 instruction)
1298 {
1299 int64 value = 0;
1300 value |= extract_bits(instruction, 0, 16) << 16;
1301 value |= extract_bits(instruction, 16, 16);
1302 value = sign_extend(value, 31);
1303 return value;
1304 }
1305
1306
1307 static uint64 extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1308 {
1309 uint64 value = 0;
1310 value |= extract_bits(instruction, 13, 8);
1311 return value;
1312 }
1313
1314
1315 static uint64 extract_u_17_to_2__s2(uint64 instruction)
1316 {
1317 uint64 value = 0;
1318 value |= extract_bits(instruction, 2, 16) << 2;
1319 return value;
1320 }
1321
1322
1323 static uint64 extract_rd_15_14_13_12_11(uint64 instruction)
1324 {
1325 uint64 value = 0;
1326 value |= extract_bits(instruction, 11, 5);
1327 return value;
1328 }
1329
1330
1331 static uint64 extract_c0s_20_19_18_17_16(uint64 instruction)
1332 {
1333 uint64 value = 0;
1334 value |= extract_bits(instruction, 16, 5);
1335 return value;
1336 }
1337
1338
1339 static uint64 extract_code_1_0(uint64 instruction)
1340 {
1341 uint64 value = 0;
1342 value |= extract_bits(instruction, 0, 2);
1343 return value;
1344 }
1345
1346
1347 static int64 extract_s__se25_0_24_to_1_s1(uint64 instruction)
1348 {
1349 int64 value = 0;
1350 value |= extract_bits(instruction, 0, 1) << 25;
1351 value |= extract_bits(instruction, 1, 24) << 1;
1352 value = sign_extend(value, 25);
1353 return value;
1354 }
1355
1356
1357 static uint64 extract_u_1_0(uint64 instruction)
1358 {
1359 uint64 value = 0;
1360 value |= extract_bits(instruction, 0, 2);
1361 return value;
1362 }
1363
1364
1365 static uint64 extract_u_3_8__s2(uint64 instruction)
1366 {
1367 uint64 value = 0;
1368 value |= extract_bits(instruction, 3, 1) << 3;
1369 value |= extract_bits(instruction, 8, 1) << 2;
1370 return value;
1371 }
1372
1373
1374 static uint64 extract_fd_15_14_13_12_11(uint64 instruction)
1375 {
1376 uint64 value = 0;
1377 value |= extract_bits(instruction, 11, 5);
1378 return value;
1379 }
1380
1381
1382 static uint64 extract_u_4_3_2_1_0__s2(uint64 instruction)
1383 {
1384 uint64 value = 0;
1385 value |= extract_bits(instruction, 0, 5) << 2;
1386 return value;
1387 }
1388
1389
1390 static uint64 extract_rtz4_9_7_6_5(uint64 instruction)
1391 {
1392 uint64 value = 0;
1393 value |= extract_bits(instruction, 5, 3);
1394 value |= extract_bits(instruction, 9, 1) << 3;
1395 return value;
1396 }
1397
1398
1399 static uint64 extract_sel_15_14_13_12_11(uint64 instruction)
1400 {
1401 uint64 value = 0;
1402 value |= extract_bits(instruction, 11, 5);
1403 return value;
1404 }
1405
1406
1407 static uint64 extract_ct_25_24_23_22_21(uint64 instruction)
1408 {
1409 uint64 value = 0;
1410 value |= extract_bits(instruction, 21, 5);
1411 return value;
1412 }
1413
1414
1415 static uint64 extract_u_20_to_2__s2(uint64 instruction)
1416 {
1417 uint64 value = 0;
1418 value |= extract_bits(instruction, 2, 19) << 2;
1419 return value;
1420 }
1421
1422
1423 static int64 extract_s__se3_4_2_1_0(uint64 instruction)
1424 {
1425 int64 value = 0;
1426 value |= extract_bits(instruction, 0, 3);
1427 value |= extract_bits(instruction, 4, 1) << 3;
1428 value = sign_extend(value, 3);
1429 return value;
1430 }
1431
1432
1433 static uint64 extract_u_3_2_1_0__s1(uint64 instruction)
1434 {
1435 uint64 value = 0;
1436 value |= extract_bits(instruction, 0, 4) << 1;
1437 return value;
1438 }
1439
1440
1441
1442 static bool ADDIU_32__cond(uint64 instruction)
1443 {
1444 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1445 return rt != 0;
1446 }
1447
1448
1449 static bool ADDIU_RS5__cond(uint64 instruction)
1450 {
1451 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1452 return rt != 0;
1453 }
1454
1455
1456 static bool BALRSC_cond(uint64 instruction)
1457 {
1458 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1459 return rt != 0;
1460 }
1461
1462
1463 static bool BEQC_16__cond(uint64 instruction)
1464 {
1465 uint64 rs3 = extract_rs3_6_5_4(instruction);
1466 uint64 rt3 = extract_rt3_9_8_7(instruction);
1467 uint64 u = extract_u_3_2_1_0__s1(instruction);
1468 return rs3 < rt3 && u != 0;
1469 }
1470
1471
1472 static bool BNEC_16__cond(uint64 instruction)
1473 {
1474 uint64 rs3 = extract_rs3_6_5_4(instruction);
1475 uint64 rt3 = extract_rt3_9_8_7(instruction);
1476 uint64 u = extract_u_3_2_1_0__s1(instruction);
1477 return rs3 >= rt3 && u != 0;
1478 }
1479
1480
1481 static bool MOVE_cond(uint64 instruction)
1482 {
1483 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1484 return rt != 0;
1485 }
1486
1487
1488 static bool P16_BR1_cond(uint64 instruction)
1489 {
1490 uint64 u = extract_u_3_2_1_0__s1(instruction);
1491 return u != 0;
1492 }
1493
1494
1495 static bool PREF_S9__cond(uint64 instruction)
1496 {
1497 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1498 return hint != 31;
1499 }
1500
1501
1502 static bool PREFE_cond(uint64 instruction)
1503 {
1504 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1505 return hint != 31;
1506 }
1507
1508
1509 static bool SLTU_cond(uint64 instruction)
1510 {
1511 uint64 rd = extract_rd_15_14_13_12_11(instruction);
1512 return rd != 0;
1513 }
1514
1515
1516
1517 /*
1518 * ABS.D fd, fs - Floating Point Absolute Value
1519 *
1520 * 3 2 1
1521 * 10987654321098765432109876543210
1522 * 010001 00000 000101
1523 * fmt -----
1524 * fs -----
1525 * fd -----
1526 */
1527 static char *ABS_D(uint64 instruction, Dis_info *info)
1528 {
1529 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1530 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1531
1532 const char *fs = FPR(fs_value, info);
1533 const char *fd = FPR(fd_value, info);
1534
1535 return img_format("ABS.D %s, %s", fd, fs);
1536 }
1537
1538
1539 /*
1540 * ABS.S fd, fs - Floating Point Absolute Value
1541 *
1542 * 3 2 1
1543 * 10987654321098765432109876543210
1544 * 010001 00000 000101
1545 * fmt -----
1546 * fd -----
1547 * fs -----
1548 */
1549 static char *ABS_S(uint64 instruction, Dis_info *info)
1550 {
1551 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1552 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1553
1554 const char *fs = FPR(fs_value, info);
1555 const char *fd = FPR(fd_value, info);
1556
1557 return img_format("ABS.S %s, %s", fd, fs);
1558 }
1559
1560
1561 /*
1562 * [DSP] ABSQ_S.PH rt, rs - Find absolute value of two fractional halfwords
1563 * with 16-bit saturation
1564 *
1565 * 3 2 1
1566 * 10987654321098765432109876543210
1567 * 001000 0001000100111111
1568 * rt -----
1569 * rs -----
1570 */
1571 static char *ABSQ_S_PH(uint64 instruction, Dis_info *info)
1572 {
1573 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1574 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1575
1576 const char *rt = GPR(rt_value, info);
1577 const char *rs = GPR(rs_value, info);
1578
1579 return img_format("ABSQ_S.PH %s, %s", rt, rs);
1580 }
1581
1582
1583 /*
1584 * [DSP] ABSQ_S.QB rt, rs - Find absolute value of four fractional byte values
1585 * with 8-bit saturation
1586 *
1587 * 3 2 1
1588 * 10987654321098765432109876543210
1589 * 001000 0000000100111111
1590 * rt -----
1591 * rs -----
1592 */
1593 static char *ABSQ_S_QB(uint64 instruction, Dis_info *info)
1594 {
1595 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1596 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1597
1598 const char *rt = GPR(rt_value, info);
1599 const char *rs = GPR(rs_value, info);
1600
1601 return img_format("ABSQ_S.QB %s, %s", rt, rs);
1602 }
1603
1604
1605 /*
1606 * [DSP] ABSQ_S.W rt, rs - Find absolute value of fractional word with 32-bit
1607 * saturation
1608 *
1609 * 3 2 1
1610 * 10987654321098765432109876543210
1611 * 001000 0010000100111111
1612 * rt -----
1613 * rs -----
1614 */
1615 static char *ABSQ_S_W(uint64 instruction, Dis_info *info)
1616 {
1617 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1618 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1619
1620 const char *rt = GPR(rt_value, info);
1621 const char *rs = GPR(rs_value, info);
1622
1623 return img_format("ABSQ_S.W %s, %s", rt, rs);
1624 }
1625
1626
1627 /*
1628 *
1629 *
1630 * 3 2 1
1631 * 10987654321098765432109876543210
1632 * 001000 0010000100111111
1633 * rt -----
1634 * rs -----
1635 */
1636 static char *ACLR(uint64 instruction, Dis_info *info)
1637 {
1638 uint64 bit_value = extract_bit_23_22_21(instruction);
1639 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1640 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
1641
1642 const char *rs = GPR(rs_value, info);
1643
1644 return img_format("ACLR 0x%" PRIx64 ", %" PRId64 "(%s)",
1645 bit_value, s_value, rs);
1646 }
1647
1648
1649 /*
1650 *
1651 *
1652 * 3 2 1
1653 * 10987654321098765432109876543210
1654 * 001000 0010000100111111
1655 * rt -----
1656 * rs -----
1657 */
1658 static char *ADD(uint64 instruction, Dis_info *info)
1659 {
1660 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1661 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1662 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1663
1664 const char *rd = GPR(rd_value, info);
1665 const char *rs = GPR(rs_value, info);
1666 const char *rt = GPR(rt_value, info);
1667
1668 return img_format("ADD %s, %s, %s", rd, rs, rt);
1669 }
1670
1671
1672 /*
1673 * ADD.D fd, fs, ft - Floating Point Add
1674 *
1675 * 3 2 1
1676 * 10987654321098765432109876543210
1677 * 010001 000101
1678 * fmt -----
1679 * ft -----
1680 * fs -----
1681 * fd -----
1682 */
1683 static char *ADD_D(uint64 instruction, Dis_info *info)
1684 {
1685 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1686 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1687 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1688
1689 const char *ft = FPR(ft_value, info);
1690 const char *fs = FPR(fs_value, info);
1691 const char *fd = FPR(fd_value, info);
1692
1693 return img_format("ADD.D %s, %s, %s", fd, fs, ft);
1694 }
1695
1696
1697 /*
1698 * ADD.S fd, fs, ft - Floating Point Add
1699 *
1700 * 3 2 1
1701 * 10987654321098765432109876543210
1702 * 010001 000101
1703 * fmt -----
1704 * ft -----
1705 * fs -----
1706 * fd -----
1707 */
1708 static char *ADD_S(uint64 instruction, Dis_info *info)
1709 {
1710 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1711 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1712 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1713
1714 const char *ft = FPR(ft_value, info);
1715 const char *fs = FPR(fs_value, info);
1716 const char *fd = FPR(fd_value, info);
1717
1718 return img_format("ADD.S %s, %s, %s", fd, fs, ft);
1719 }
1720
1721
1722 /*
1723 *
1724 *
1725 * 3 2 1
1726 * 10987654321098765432109876543210
1727 * 001000 0010000100111111
1728 * rt -----
1729 * rs -----
1730 */
1731 static char *ADDIU_32_(uint64 instruction, Dis_info *info)
1732 {
1733 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1734 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1735 uint64 u_value = extract_u_15_to_0(instruction);
1736
1737 const char *rt = GPR(rt_value, info);
1738 const char *rs = GPR(rs_value, info);
1739
1740 return img_format("ADDIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
1741 }
1742
1743
1744 /*
1745 *
1746 *
1747 * 3 2 1
1748 * 10987654321098765432109876543210
1749 * 001000 0010000100111111
1750 * rt -----
1751 * rs -----
1752 */
1753 static char *ADDIU_48_(uint64 instruction, Dis_info *info)
1754 {
1755 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1756 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1757
1758 const char *rt = GPR(rt_value, info);
1759
1760 return img_format("ADDIU %s, %" PRId64, rt, s_value);
1761 }
1762
1763
1764 /*
1765 *
1766 *
1767 * 3 2 1
1768 * 10987654321098765432109876543210
1769 * 001000 0010000100111111
1770 * rt -----
1771 * rs -----
1772 */
1773 static char *ADDIU_GP48_(uint64 instruction, Dis_info *info)
1774 {
1775 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1776 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1777
1778 const char *rt = GPR(rt_value, info);
1779
1780 return img_format("ADDIU %s, $%d, %" PRId64, rt, 28, s_value);
1781 }
1782
1783
1784 /*
1785 *
1786 *
1787 * 3 2 1
1788 * 10987654321098765432109876543210
1789 * 001000 0010000100111111
1790 * rt -----
1791 * rs -----
1792 */
1793 static char *ADDIU_GP_B_(uint64 instruction, Dis_info *info)
1794 {
1795 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1796 uint64 u_value = extract_u_17_to_0(instruction);
1797
1798 const char *rt = GPR(rt_value, info);
1799
1800 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt, 28, u_value);
1801 }
1802
1803
1804 /*
1805 *
1806 *
1807 * 3 2 1
1808 * 10987654321098765432109876543210
1809 * 001000 0010000100111111
1810 * rt -----
1811 * rs -----
1812 */
1813 static char *ADDIU_GP_W_(uint64 instruction, Dis_info *info)
1814 {
1815 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1816 uint64 u_value = extract_u_20_to_2__s2(instruction);
1817
1818 const char *rt = GPR(rt_value, info);
1819
1820 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt, 28, u_value);
1821 }
1822
1823
1824 /*
1825 *
1826 *
1827 * 3 2 1
1828 * 10987654321098765432109876543210
1829 * 001000 0010000100111111
1830 * rt -----
1831 * rs -----
1832 */
1833 static char *ADDIU_NEG_(uint64 instruction, Dis_info *info)
1834 {
1835 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1836 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1837 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
1838
1839 const char *rt = GPR(rt_value, info);
1840 const char *rs = GPR(rs_value, info);
1841 int64 u = neg_copy(u_value);
1842
1843 return img_format("ADDIU %s, %s, %" PRId64, rt, rs, u);
1844 }
1845
1846
1847 /*
1848 *
1849 *
1850 * 3 2 1
1851 * 10987654321098765432109876543210
1852 * 001000 0010000100111111
1853 * rt -----
1854 * rs -----
1855 */
1856 static char *ADDIU_R1_SP_(uint64 instruction, Dis_info *info)
1857 {
1858 uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
1859 uint64 rt3_value = extract_rt3_9_8_7(instruction);
1860
1861 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
1862
1863 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt3, 29, u_value);
1864 }
1865
1866
1867 /*
1868 *
1869 *
1870 * 3 2 1
1871 * 10987654321098765432109876543210
1872 * 001000 0010000100111111
1873 * rt -----
1874 * rs -----
1875 */
1876 static char *ADDIU_R2_(uint64 instruction, Dis_info *info)
1877 {
1878 uint64 rt3_value = extract_rt3_9_8_7(instruction);
1879 uint64 rs3_value = extract_rs3_6_5_4(instruction);
1880 uint64 u_value = extract_u_2_1_0__s2(instruction);
1881
1882 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
1883 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
1884
1885 return img_format("ADDIU %s, %s, 0x%" PRIx64, rt3, rs3, u_value);
1886 }
1887
1888
1889 /*
1890 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
1891 *
1892 * 5432109876543210
1893 * 100100 1
1894 * rt -----
1895 * s - ---
1896 */
1897 static char *ADDIU_RS5_(uint64 instruction, Dis_info *info)
1898 {
1899 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
1900 int64 s_value = extract_s__se3_4_2_1_0(instruction);
1901
1902 const char *rt = GPR(rt_value, info);
1903
1904 return img_format("ADDIU %s, %" PRId64, rt, s_value);
1905 }
1906
1907
1908 /*
1909 *
1910 *
1911 * 3 2 1
1912 * 10987654321098765432109876543210
1913 * 001000 x1110000101
1914 * rt -----
1915 * rs -----
1916 * rd -----
1917 */
1918 static char *ADDIUPC_32_(uint64 instruction, Dis_info *info)
1919 {
1920 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1921 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
1922
1923 const char *rt = GPR(rt_value, info);
1924 g_autofree char *s = ADDRESS(s_value, 4, info);
1925
1926 return img_format("ADDIUPC %s, %s", rt, s);
1927 }
1928
1929
1930 /*
1931 *
1932 *
1933 * 3 2 1
1934 * 10987654321098765432109876543210
1935 * 001000 x1110000101
1936 * rt -----
1937 * rs -----
1938 * rd -----
1939 */
1940 static char *ADDIUPC_48_(uint64 instruction, Dis_info *info)
1941 {
1942 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1943 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1944
1945 const char *rt = GPR(rt_value, info);
1946 g_autofree char *s = ADDRESS(s_value, 6, info);
1947
1948 return img_format("ADDIUPC %s, %s", rt, s);
1949 }
1950
1951
1952 /*
1953 * [DSP] ADDQ.PH rd, rt, rs - Add fractional halfword vectors
1954 *
1955 * 3 2 1
1956 * 10987654321098765432109876543210
1957 * 001000 00000001101
1958 * rt -----
1959 * rs -----
1960 * rd -----
1961 */
1962 static char *ADDQ_PH(uint64 instruction, Dis_info *info)
1963 {
1964 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1965 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1966 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1967
1968 const char *rd = GPR(rd_value, info);
1969 const char *rs = GPR(rs_value, info);
1970 const char *rt = GPR(rt_value, info);
1971
1972 return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
1973 }
1974
1975
1976 /*
1977 * [DSP] ADDQ_S.PH rd, rt, rs - Add fractional halfword vectors with 16-bit
1978 * saturation
1979 *
1980 * 3 2 1
1981 * 10987654321098765432109876543210
1982 * 001000 10000001101
1983 * rt -----
1984 * rs -----
1985 * rd -----
1986 */
1987 static char *ADDQ_S_PH(uint64 instruction, Dis_info *info)
1988 {
1989 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1990 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1991 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1992
1993 const char *rd = GPR(rd_value, info);
1994 const char *rs = GPR(rs_value, info);
1995 const char *rt = GPR(rt_value, info);
1996
1997 return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
1998 }
1999
2000
2001 /*
2002 * [DSP] ADDQ_S.W rd, rt, rs - Add fractional words with 32-bit saturation
2003 *
2004 * 3 2 1
2005 * 10987654321098765432109876543210
2006 * 001000 x1100000101
2007 * rt -----
2008 * rs -----
2009 * rd -----
2010 */
2011 static char *ADDQ_S_W(uint64 instruction, Dis_info *info)
2012 {
2013 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2014 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2015 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2016
2017 const char *rd = GPR(rd_value, info);
2018 const char *rs = GPR(rs_value, info);
2019 const char *rt = GPR(rt_value, info);
2020
2021 return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
2022 }
2023
2024
2025 /*
2026 * [DSP] ADDQH.PH rd, rt, rs - Add fractional halfword vectors and shift
2027 * right to halve results
2028 *
2029 * 3 2 1
2030 * 10987654321098765432109876543210
2031 * 001000 00001001101
2032 * rt -----
2033 * rs -----
2034 * rd -----
2035 */
2036 static char *ADDQH_PH(uint64 instruction, Dis_info *info)
2037 {
2038 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2039 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2040 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2041
2042 const char *rd = GPR(rd_value, info);
2043 const char *rs = GPR(rs_value, info);
2044 const char *rt = GPR(rt_value, info);
2045
2046 return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
2047 }
2048
2049
2050 /*
2051 * [DSP] ADDQH_R.PH rd, rt, rs - Add fractional halfword vectors and shift
2052 * right to halve results with rounding
2053 *
2054 * 3 2 1
2055 * 10987654321098765432109876543210
2056 * 001000 10001001101
2057 * rt -----
2058 * rs -----
2059 * rd -----
2060 */
2061 static char *ADDQH_R_PH(uint64 instruction, Dis_info *info)
2062 {
2063 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2064 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2065 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2066
2067 const char *rd = GPR(rd_value, info);
2068 const char *rs = GPR(rs_value, info);
2069 const char *rt = GPR(rt_value, info);
2070
2071 return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
2072 }
2073
2074
2075 /*
2076 * [DSP] ADDQH_R.W rd, rt, rs - Add fractional words and shift right to halve
2077 * results with rounding
2078 *
2079 * 3 2 1
2080 * 10987654321098765432109876543210
2081 * 001000 00010001101
2082 * rt -----
2083 * rs -----
2084 * rd -----
2085 */
2086 static char *ADDQH_R_W(uint64 instruction, Dis_info *info)
2087 {
2088 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2089 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2090 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2091
2092 const char *rd = GPR(rd_value, info);
2093 const char *rs = GPR(rs_value, info);
2094 const char *rt = GPR(rt_value, info);
2095
2096 return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2097 }
2098
2099
2100 /*
2101 * [DSP] ADDQH.W rd, rt, rs - Add fractional words and shift right to halve
2102 * results
2103 *
2104 * 3 2 1
2105 * 10987654321098765432109876543210
2106 * 001000 10010001101
2107 * rt -----
2108 * rs -----
2109 * rd -----
2110 */
2111 static char *ADDQH_W(uint64 instruction, Dis_info *info)
2112 {
2113 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2114 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2115 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2116
2117 const char *rd = GPR(rd_value, info);
2118 const char *rs = GPR(rs_value, info);
2119 const char *rt = GPR(rt_value, info);
2120
2121 return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
2122 }
2123
2124
2125 /*
2126 * [DSP] ADDSC rd, rt, rs - Add two signed words and set carry bit
2127 *
2128 * 3 2 1
2129 * 10987654321098765432109876543210
2130 * 001000 x1110000101
2131 * rt -----
2132 * rs -----
2133 * rd -----
2134 */
2135 static char *ADDSC(uint64 instruction, Dis_info *info)
2136 {
2137 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2138 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2139 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2140
2141 const char *rd = GPR(rd_value, info);
2142 const char *rs = GPR(rs_value, info);
2143 const char *rt = GPR(rt_value, info);
2144
2145 return img_format("ADDSC %s, %s, %s", rd, rs, rt);
2146 }
2147
2148
2149 /*
2150 * ADDU[16] rd3, rs3, rt3 -
2151 *
2152 * 5432109876543210
2153 * 101100 0
2154 * rt3 ---
2155 * rs3 ---
2156 * rd3 ---
2157 */
2158 static char *ADDU_16_(uint64 instruction, Dis_info *info)
2159 {
2160 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2161 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2162 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2163
2164 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2165 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2166 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
2167
2168 return img_format("ADDU %s, %s, %s", rd3, rs3, rt3);
2169 }
2170
2171
2172 /*
2173 *
2174 *
2175 * 3 2 1
2176 * 10987654321098765432109876543210
2177 * 001000 x1110000101
2178 * rt -----
2179 * rs -----
2180 * rd -----
2181 */
2182 static char *ADDU_32_(uint64 instruction, Dis_info *info)
2183 {
2184 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2185 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2186 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2187
2188 const char *rd = GPR(rd_value, info);
2189 const char *rs = GPR(rs_value, info);
2190 const char *rt = GPR(rt_value, info);
2191
2192 return img_format("ADDU %s, %s, %s", rd, rs, rt);
2193 }
2194
2195
2196 /*
2197 *
2198 *
2199 * 3 2 1
2200 * 10987654321098765432109876543210
2201 * 001000 x1110000101
2202 * rt -----
2203 * rs -----
2204 * rd -----
2205 */
2206 static char *ADDU_4X4_(uint64 instruction, Dis_info *info)
2207 {
2208 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2209 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2210
2211 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
2212 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
2213
2214 return img_format("ADDU %s, %s", rs4, rt4);
2215 }
2216
2217
2218 /*
2219 * [DSP] ADDU.PH rd, rt, rs - Add two pairs of unsigned halfwords
2220 *
2221 * 3 2 1
2222 * 10987654321098765432109876543210
2223 * 001000 00100001101
2224 * rt -----
2225 * rs -----
2226 * rd -----
2227 */
2228 static char *ADDU_PH(uint64 instruction, Dis_info *info)
2229 {
2230 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2231 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2232 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2233
2234 const char *rd = GPR(rd_value, info);
2235 const char *rs = GPR(rs_value, info);
2236 const char *rt = GPR(rt_value, info);
2237
2238 return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
2239 }
2240
2241
2242 /*
2243 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2244 *
2245 * 3 2 1
2246 * 10987654321098765432109876543210
2247 * 001000 00011001101
2248 * rt -----
2249 * rs -----
2250 * rd -----
2251 */
2252 static char *ADDU_QB(uint64 instruction, Dis_info *info)
2253 {
2254 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2255 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2256 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2257
2258 const char *rd = GPR(rd_value, info);
2259 const char *rs = GPR(rs_value, info);
2260 const char *rt = GPR(rt_value, info);
2261
2262 return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
2263 }
2264
2265
2266 /*
2267 * [DSP] ADDU_S.PH rd, rt, rs - Add two pairs of unsigned halfwords with 16-bit
2268 * saturation
2269 *
2270 * 3 2 1
2271 * 10987654321098765432109876543210
2272 * 001000 10100001101
2273 * rt -----
2274 * rs -----
2275 * rd -----
2276 */
2277 static char *ADDU_S_PH(uint64 instruction, Dis_info *info)
2278 {
2279 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2280 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2281 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2282
2283 const char *rd = GPR(rd_value, info);
2284 const char *rs = GPR(rs_value, info);
2285 const char *rt = GPR(rt_value, info);
2286
2287 return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2288 }
2289
2290
2291 /*
2292 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2293 *
2294 * 3 2 1
2295 * 10987654321098765432109876543210
2296 * 001000 10011001101
2297 * rt -----
2298 * rs -----
2299 * rd -----
2300 */
2301 static char *ADDU_S_QB(uint64 instruction, Dis_info *info)
2302 {
2303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2305 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2306
2307 const char *rd = GPR(rd_value, info);
2308 const char *rs = GPR(rs_value, info);
2309 const char *rt = GPR(rt_value, info);
2310
2311 return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2312 }
2313
2314
2315 /*
2316 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2317 * to Halve Results
2318 *
2319 * 3 2 1
2320 * 10987654321098765432109876543210
2321 * 001000 00101001101
2322 * rt -----
2323 * rs -----
2324 * rd -----
2325 */
2326 static char *ADDUH_QB(uint64 instruction, Dis_info *info)
2327 {
2328 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2329 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2330 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2331
2332 const char *rd = GPR(rd_value, info);
2333 const char *rs = GPR(rs_value, info);
2334 const char *rt = GPR(rt_value, info);
2335
2336 return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2337 }
2338
2339
2340 /*
2341 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2342 * to Halve Results
2343 *
2344 * 3 2 1
2345 * 10987654321098765432109876543210
2346 * 001000 10101001101
2347 * rt -----
2348 * rs -----
2349 * rd -----
2350 */
2351 static char *ADDUH_R_QB(uint64 instruction, Dis_info *info)
2352 {
2353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2355 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2356
2357 const char *rd = GPR(rd_value, info);
2358 const char *rs = GPR(rs_value, info);
2359 const char *rt = GPR(rt_value, info);
2360
2361 return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2362 }
2363
2364 /*
2365 * ADDWC rd, rt, rs - Add Word with Carry Bit
2366 *
2367 * 3 2 1
2368 * 10987654321098765432109876543210
2369 * 001000 x1111000101
2370 * rt -----
2371 * rs -----
2372 * rd -----
2373 */
2374 static char *ADDWC(uint64 instruction, Dis_info *info)
2375 {
2376 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2377 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2378 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2379
2380 const char *rd = GPR(rd_value, info);
2381 const char *rs = GPR(rs_value, info);
2382 const char *rt = GPR(rt_value, info);
2383
2384 return img_format("ADDWC %s, %s, %s", rd, rs, rt);
2385 }
2386
2387
2388 /*
2389 *
2390 *
2391 * 3 2 1
2392 * 10987654321098765432109876543210
2393 * 001000 x1110000101
2394 * rt -----
2395 * rs -----
2396 * rd -----
2397 */
2398 static char *ALUIPC(uint64 instruction, Dis_info *info)
2399 {
2400 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2401 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
2402
2403 const char *rt = GPR(rt_value, info);
2404 g_autofree char *s = ADDRESS(s_value, 4, info);
2405
2406 return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2407 }
2408
2409
2410 /*
2411 * AND[16] rt3, rs3 -
2412 *
2413 * 5432109876543210
2414 * 101100
2415 * rt3 ---
2416 * rs3 ---
2417 * eu ----
2418 */
2419 static char *AND_16_(uint64 instruction, Dis_info *info)
2420 {
2421 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2422 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2423
2424 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2425 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2426
2427 return img_format("AND %s, %s", rs3, rt3);
2428 }
2429
2430
2431 /*
2432 *
2433 *
2434 * 3 2 1
2435 * 10987654321098765432109876543210
2436 * 001000 x1110000101
2437 * rt -----
2438 * rs -----
2439 * rd -----
2440 */
2441 static char *AND_32_(uint64 instruction, Dis_info *info)
2442 {
2443 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2444 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2445 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2446
2447 const char *rd = GPR(rd_value, info);
2448 const char *rs = GPR(rs_value, info);
2449 const char *rt = GPR(rt_value, info);
2450
2451 return img_format("AND %s, %s, %s", rd, rs, rt);
2452 }
2453
2454
2455 /*
2456 * ANDI rt, rs, u -
2457 *
2458 * 5432109876543210
2459 * 101100
2460 * rt3 ---
2461 * rs3 ---
2462 * eu ----
2463 */
2464 static char *ANDI_16_(uint64 instruction, Dis_info *info)
2465 {
2466 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2467 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2468 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2469
2470 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2471 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2472 uint64 eu = encode_eu_from_u_andi16(eu_value);
2473
2474 return img_format("ANDI %s, %s, 0x%" PRIx64, rt3, rs3, eu);
2475 }
2476
2477
2478 /*
2479 *
2480 *
2481 * 3 2 1
2482 * 10987654321098765432109876543210
2483 * 001000 x1110000101
2484 * rt -----
2485 * rs -----
2486 * rd -----
2487 */
2488 static char *ANDI_32_(uint64 instruction, Dis_info *info)
2489 {
2490 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2491 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2492 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2493
2494 const char *rt = GPR(rt_value, info);
2495 const char *rs = GPR(rs_value, info);
2496
2497 return img_format("ANDI %s, %s, 0x%" PRIx64, rt, rs, u_value);
2498 }
2499
2500
2501 /*
2502 *
2503 *
2504 * 3 2 1
2505 * 10987654321098765432109876543210
2506 * 001000 x1110000101
2507 * rt -----
2508 * rs -----
2509 * rd -----
2510 */
2511 static char *APPEND(uint64 instruction, Dis_info *info)
2512 {
2513 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2514 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2515 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2516
2517 const char *rt = GPR(rt_value, info);
2518 const char *rs = GPR(rs_value, info);
2519
2520 return img_format("APPEND %s, %s, 0x%" PRIx64, rt, rs, sa_value);
2521 }
2522
2523
2524 /*
2525 *
2526 *
2527 * 3 2 1
2528 * 10987654321098765432109876543210
2529 * 001000 x1110000101
2530 * rt -----
2531 * rs -----
2532 * rd -----
2533 */
2534 static char *ASET(uint64 instruction, Dis_info *info)
2535 {
2536 uint64 bit_value = extract_bit_23_22_21(instruction);
2537 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2538 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
2539
2540 const char *rs = GPR(rs_value, info);
2541
2542 return img_format("ASET 0x%" PRIx64 ", %" PRId64 "(%s)",
2543 bit_value, s_value, rs);
2544 }
2545
2546
2547 /*
2548 *
2549 *
2550 * 3 2 1
2551 * 10987654321098765432109876543210
2552 * 001000 x1110000101
2553 * rt -----
2554 * rs -----
2555 * rd -----
2556 */
2557 static char *BALC_16_(uint64 instruction, Dis_info *info)
2558 {
2559 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2560
2561 g_autofree char *s = ADDRESS(s_value, 2, info);
2562
2563 return img_format("BALC %s", s);
2564 }
2565
2566
2567 /*
2568 *
2569 *
2570 * 3 2 1
2571 * 10987654321098765432109876543210
2572 * 001000 x1110000101
2573 * rt -----
2574 * rs -----
2575 * rd -----
2576 */
2577 static char *BALC_32_(uint64 instruction, Dis_info *info)
2578 {
2579 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2580
2581 g_autofree char *s = ADDRESS(s_value, 4, info);
2582
2583 return img_format("BALC %s", s);
2584 }
2585
2586
2587 /*
2588 *
2589 *
2590 * 3 2 1
2591 * 10987654321098765432109876543210
2592 * 001000 x1110000101
2593 * rt -----
2594 * rs -----
2595 * rd -----
2596 */
2597 static char *BALRSC(uint64 instruction, Dis_info *info)
2598 {
2599 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2600 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2601
2602 const char *rt = GPR(rt_value, info);
2603 const char *rs = GPR(rs_value, info);
2604
2605 return img_format("BALRSC %s, %s", rt, rs);
2606 }
2607
2608
2609 /*
2610 *
2611 *
2612 * 3 2 1
2613 * 10987654321098765432109876543210
2614 * 001000 x1110000101
2615 * rt -----
2616 * rs -----
2617 * rd -----
2618 */
2619 static char *BBEQZC(uint64 instruction, Dis_info *info)
2620 {
2621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2622 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2623 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2624
2625 const char *rt = GPR(rt_value, info);
2626 g_autofree char *s = ADDRESS(s_value, 4, info);
2627
2628 return img_format("BBEQZC %s, 0x%" PRIx64 ", %s", rt, bit_value, s);
2629 }
2630
2631
2632 /*
2633 *
2634 *
2635 * 3 2 1
2636 * 10987654321098765432109876543210
2637 * 001000 x1110000101
2638 * rt -----
2639 * rs -----
2640 * rd -----
2641 */
2642 static char *BBNEZC(uint64 instruction, Dis_info *info)
2643 {
2644 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2645 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2646 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2647
2648 const char *rt = GPR(rt_value, info);
2649 g_autofree char *s = ADDRESS(s_value, 4, info);
2650
2651 return img_format("BBNEZC %s, 0x%" PRIx64 ", %s", rt, bit_value, s);
2652 }
2653
2654
2655 /*
2656 *
2657 *
2658 * 3 2 1
2659 * 10987654321098765432109876543210
2660 * 001000 x1110000101
2661 * rt -----
2662 * rs -----
2663 * rd -----
2664 */
2665 static char *BC_16_(uint64 instruction, Dis_info *info)
2666 {
2667 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2668
2669 g_autofree char *s = ADDRESS(s_value, 2, info);
2670
2671 return img_format("BC %s", s);
2672 }
2673
2674
2675 /*
2676 *
2677 *
2678 * 3 2 1
2679 * 10987654321098765432109876543210
2680 * 001000 x1110000101
2681 * rt -----
2682 * rs -----
2683 * rd -----
2684 */
2685 static char *BC_32_(uint64 instruction, Dis_info *info)
2686 {
2687 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2688
2689 g_autofree char *s = ADDRESS(s_value, 4, info);
2690
2691 return img_format("BC %s", s);
2692 }
2693
2694
2695 /*
2696 *
2697 *
2698 * 3 2 1
2699 * 10987654321098765432109876543210
2700 * 001000 x1110000101
2701 * rt -----
2702 * rs -----
2703 * rd -----
2704 */
2705 static char *BC1EQZC(uint64 instruction, Dis_info *info)
2706 {
2707 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2708 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2709
2710 const char *ft = FPR(ft_value, info);
2711 g_autofree char *s = ADDRESS(s_value, 4, info);
2712
2713 return img_format("BC1EQZC %s, %s", ft, s);
2714 }
2715
2716
2717 /*
2718 *
2719 *
2720 * 3 2 1
2721 * 10987654321098765432109876543210
2722 * 001000 x1110000101
2723 * rt -----
2724 * rs -----
2725 * rd -----
2726 */
2727 static char *BC1NEZC(uint64 instruction, Dis_info *info)
2728 {
2729 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2730 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2731
2732 const char *ft = FPR(ft_value, info);
2733 g_autofree char *s = ADDRESS(s_value, 4, info);
2734
2735 return img_format("BC1NEZC %s, %s", ft, s);
2736 }
2737
2738
2739 /*
2740 *
2741 *
2742 * 3 2 1
2743 * 10987654321098765432109876543210
2744 * 001000 x1110000101
2745 * rt -----
2746 * rs -----
2747 * rd -----
2748 */
2749 static char *BC2EQZC(uint64 instruction, Dis_info *info)
2750 {
2751 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
2752 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2753
2754 g_autofree char *s = ADDRESS(s_value, 4, info);
2755
2756 return img_format("BC2EQZC CP%" PRIu64 ", %s", ct_value, s);
2757 }
2758
2759
2760 /*
2761 *
2762 *
2763 * 3 2 1
2764 * 10987654321098765432109876543210
2765 * 001000 x1110000101
2766 * rt -----
2767 * rs -----
2768 * rd -----
2769 */
2770 static char *BC2NEZC(uint64 instruction, Dis_info *info)
2771 {
2772 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
2773 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2774
2775 g_autofree char *s = ADDRESS(s_value, 4, info);
2776
2777 return img_format("BC2NEZC CP%" PRIu64 ", %s", ct_value, s);
2778 }
2779
2780
2781 /*
2782 *
2783 *
2784 * 3 2 1
2785 * 10987654321098765432109876543210
2786 * 001000 x1110000101
2787 * rt -----
2788 * rs -----
2789 * rd -----
2790 */
2791 static char *BEQC_16_(uint64 instruction, Dis_info *info)
2792 {
2793 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2794 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2795 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
2796
2797 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2798 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2799 g_autofree char *u = ADDRESS(u_value, 2, info);
2800
2801 return img_format("BEQC %s, %s, %s", rs3, rt3, u);
2802 }
2803
2804
2805 /*
2806 *
2807 *
2808 * 3 2 1
2809 * 10987654321098765432109876543210
2810 * 001000 x1110000101
2811 * rt -----
2812 * rs -----
2813 * rd -----
2814 */
2815 static char *BEQC_32_(uint64 instruction, Dis_info *info)
2816 {
2817 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2818 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2819 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2820
2821 const char *rs = GPR(rs_value, info);
2822 const char *rt = GPR(rt_value, info);
2823 g_autofree char *s = ADDRESS(s_value, 4, info);
2824
2825 return img_format("BEQC %s, %s, %s", rs, rt, s);
2826 }
2827
2828
2829 /*
2830 *
2831 *
2832 * 3 2 1
2833 * 10987654321098765432109876543210
2834 * 001000 x1110000101
2835 * rt -----
2836 * rs -----
2837 * rd -----
2838 */
2839 static char *BEQIC(uint64 instruction, Dis_info *info)
2840 {
2841 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2842 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2843 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2844
2845 const char *rt = GPR(rt_value, info);
2846 g_autofree char *s = ADDRESS(s_value, 4, info);
2847
2848 return img_format("BEQIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2849 }
2850
2851
2852 /*
2853 *
2854 *
2855 * 3 2 1
2856 * 10987654321098765432109876543210
2857 * 001000 x1110000101
2858 * rt -----
2859 * rs -----
2860 * rd -----
2861 */
2862 static char *BEQZC_16_(uint64 instruction, Dis_info *info)
2863 {
2864 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2865 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
2866
2867 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2868 g_autofree char *s = ADDRESS(s_value, 2, info);
2869
2870 return img_format("BEQZC %s, %s", rt3, s);
2871 }
2872
2873
2874 /*
2875 *
2876 *
2877 * 3 2 1
2878 * 10987654321098765432109876543210
2879 * 001000 x1110000101
2880 * rt -----
2881 * rs -----
2882 * rd -----
2883 */
2884 static char *BGEC(uint64 instruction, Dis_info *info)
2885 {
2886 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2887 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2888 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2889
2890 const char *rs = GPR(rs_value, info);
2891 const char *rt = GPR(rt_value, info);
2892 g_autofree char *s = ADDRESS(s_value, 4, info);
2893
2894 return img_format("BGEC %s, %s, %s", rs, rt, s);
2895 }
2896
2897
2898 /*
2899 *
2900 *
2901 * 3 2 1
2902 * 10987654321098765432109876543210
2903 * 001000 x1110000101
2904 * rt -----
2905 * rs -----
2906 * rd -----
2907 */
2908 static char *BGEIC(uint64 instruction, Dis_info *info)
2909 {
2910 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2911 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2912 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2913
2914 const char *rt = GPR(rt_value, info);
2915 g_autofree char *s = ADDRESS(s_value, 4, info);
2916
2917 return img_format("BGEIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2918 }
2919
2920
2921 /*
2922 *
2923 *
2924 * 3 2 1
2925 * 10987654321098765432109876543210
2926 * 001000 x1110000101
2927 * rt -----
2928 * rs -----
2929 * rd -----
2930 */
2931 static char *BGEIUC(uint64 instruction, Dis_info *info)
2932 {
2933 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2934 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2935 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2936
2937 const char *rt = GPR(rt_value, info);
2938 g_autofree char *s = ADDRESS(s_value, 4, info);
2939
2940 return img_format("BGEIUC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2941 }
2942
2943
2944 /*
2945 *
2946 *
2947 * 3 2 1
2948 * 10987654321098765432109876543210
2949 * 001000 x1110000101
2950 * rt -----
2951 * rs -----
2952 * rd -----
2953 */
2954 static char *BGEUC(uint64 instruction, Dis_info *info)
2955 {
2956 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2957 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2958 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2959
2960 const char *rs = GPR(rs_value, info);
2961 const char *rt = GPR(rt_value, info);
2962 g_autofree char *s = ADDRESS(s_value, 4, info);
2963
2964 return img_format("BGEUC %s, %s, %s", rs, rt, s);
2965 }
2966
2967
2968 /*
2969 *
2970 *
2971 * 3 2 1
2972 * 10987654321098765432109876543210
2973 * 001000 x1110000101
2974 * rt -----
2975 * rs -----
2976 * rd -----
2977 */
2978 static char *BLTC(uint64 instruction, Dis_info *info)
2979 {
2980 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2981 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2982 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2983
2984 const char *rs = GPR(rs_value, info);
2985 const char *rt = GPR(rt_value, info);
2986 g_autofree char *s = ADDRESS(s_value, 4, info);
2987
2988 return img_format("BLTC %s, %s, %s", rs, rt, s);
2989 }
2990
2991
2992 /*
2993 *
2994 *
2995 * 3 2 1
2996 * 10987654321098765432109876543210
2997 * 001000 x1110000101
2998 * rt -----
2999 * rs -----
3000 * rd -----
3001 */
3002 static char *BLTIC(uint64 instruction, Dis_info *info)
3003 {
3004 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3005 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3006 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3007
3008 const char *rt = GPR(rt_value, info);
3009 g_autofree char *s = ADDRESS(s_value, 4, info);
3010
3011 return img_format("BLTIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
3012 }
3013
3014
3015 /*
3016 *
3017 *
3018 * 3 2 1
3019 * 10987654321098765432109876543210
3020 * 001000 x1110000101
3021 * rt -----
3022 * rs -----
3023 * rd -----
3024 */
3025 static char *BLTIUC(uint64 instruction, Dis_info *info)
3026 {
3027 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3028 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3029 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3030
3031 const char *rt = GPR(rt_value, info);
3032 g_autofree char *s = ADDRESS(s_value, 4, info);
3033
3034 return img_format("BLTIUC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
3035 }
3036
3037
3038 /*
3039 *
3040 *
3041 * 3 2 1
3042 * 10987654321098765432109876543210
3043 * 001000 x1110000101
3044 * rt -----
3045 * rs -----
3046 * rd -----
3047 */
3048 static char *BLTUC(uint64 instruction, Dis_info *info)
3049 {
3050 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3051 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3052 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3053
3054 const char *rs = GPR(rs_value, info);
3055 const char *rt = GPR(rt_value, info);
3056 g_autofree char *s = ADDRESS(s_value, 4, info);
3057
3058 return img_format("BLTUC %s, %s, %s", rs, rt, s);
3059 }
3060
3061
3062 /*
3063 *
3064 *
3065 * 3 2 1
3066 * 10987654321098765432109876543210
3067 * 001000 x1110000101
3068 * rt -----
3069 * rs -----
3070 * rd -----
3071 */
3072 static char *BNEC_16_(uint64 instruction, Dis_info *info)
3073 {
3074 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3075 uint64 rs3_value = extract_rs3_6_5_4(instruction);
3076 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
3077
3078 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
3079 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
3080 g_autofree char *u = ADDRESS(u_value, 2, info);
3081
3082 return img_format("BNEC %s, %s, %s", rs3, rt3, u);
3083 }
3084
3085
3086 /*
3087 *
3088 *
3089 * 3 2 1
3090 * 10987654321098765432109876543210
3091 * 001000 x1110000101
3092 * rt -----
3093 * rs -----
3094 * rd -----
3095 */
3096 static char *BNEC_32_(uint64 instruction, Dis_info *info)
3097 {
3098 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3099 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3100 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3101
3102 const char *rs = GPR(rs_value, info);
3103 const char *rt = GPR(rt_value, info);
3104 g_autofree char *s = ADDRESS(s_value, 4, info);
3105
3106 return img_format("BNEC %s, %s, %s", rs, rt, s);
3107 }
3108
3109
3110 /*
3111 *
3112 *
3113 * 3 2 1
3114 * 10987654321098765432109876543210
3115 * 001000 x1110000101
3116 * rt -----
3117 * rs -----
3118 * rd -----
3119 */
3120 static char *BNEIC(uint64 instruction, Dis_info *info)
3121 {
3122 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3123 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3124 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3125
3126 const char *rt = GPR(rt_value, info);
3127 g_autofree char *s = ADDRESS(s_value, 4, info);
3128
3129 return img_format("BNEIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
3130 }
3131
3132
3133 /*
3134 *
3135 *
3136 * 3 2 1
3137 * 10987654321098765432109876543210
3138 * 001000 x1110000101
3139 * rt -----
3140 * rs -----
3141 * rd -----
3142 */
3143 static char *BNEZC_16_(uint64 instruction, Dis_info *info)
3144 {
3145 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3146 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3147
3148 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
3149 g_autofree char *s = ADDRESS(s_value, 2, info);
3150
3151 return img_format("BNEZC %s, %s", rt3, s);
3152 }
3153
3154
3155 /*
3156 * [DSP] BPOSGE32C offset - Branch on greater than or equal to value 32 in
3157 * DSPControl Pos field
3158 *
3159 * 3 2 1
3160 * 10987654321098765432109876543210
3161 * 100010xxxxx0010001
3162 * s[13:1] -------------
3163 * s[14] -
3164 */
3165 static char *BPOSGE32C(uint64 instruction, Dis_info *info)
3166 {
3167 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3168
3169 g_autofree char *s = ADDRESS(s_value, 4, info);
3170
3171 return img_format("BPOSGE32C %s", s);
3172 }
3173
3174
3175 /*
3176 *
3177 *
3178 * 3 2 1
3179 * 10987654321098765432109876543210
3180 * 001000 x1110000101
3181 * rt -----
3182 * rs -----
3183 * rd -----
3184 */
3185 static char *BREAK_16_(uint64 instruction, Dis_info *info)
3186 {
3187 uint64 code_value = extract_code_2_1_0(instruction);
3188
3189
3190 return img_format("BREAK 0x%" PRIx64, code_value);
3191 }
3192
3193
3194 /*
3195 * BREAK code - Break. Cause a Breakpoint exception
3196 *
3197 * 3 2 1
3198 * 10987654321098765432109876543210
3199 * 001000 x1110000101
3200 * rt -----
3201 * rs -----
3202 * rd -----
3203 */
3204 static char *BREAK_32_(uint64 instruction, Dis_info *info)
3205 {
3206 uint64 code_value = extract_code_18_to_0(instruction);
3207
3208
3209 return img_format("BREAK 0x%" PRIx64, code_value);
3210 }
3211
3212
3213 /*
3214 *
3215 *
3216 * 3 2 1
3217 * 10987654321098765432109876543210
3218 * 001000 x1110000101
3219 * rt -----
3220 * rs -----
3221 * rd -----
3222 */
3223 static char *BRSC(uint64 instruction, Dis_info *info)
3224 {
3225 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3226
3227 const char *rs = GPR(rs_value, info);
3228
3229 return img_format("BRSC %s", rs);
3230 }
3231
3232
3233 /*
3234 *
3235 *
3236 * 3 2 1
3237 * 10987654321098765432109876543210
3238 * 001000 x1110000101
3239 * rt -----
3240 * rs -----
3241 * rd -----
3242 */
3243 static char *CACHE(uint64 instruction, Dis_info *info)
3244 {
3245 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3246 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3247 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3248
3249 const char *rs = GPR(rs_value, info);
3250
3251 return img_format("CACHE 0x%" PRIx64 ", %" PRId64 "(%s)",
3252 op_value, s_value, rs);
3253 }
3254
3255
3256 /*
3257 *
3258 *
3259 * 3 2 1
3260 * 10987654321098765432109876543210
3261 * 001000 x1110000101
3262 * rt -----
3263 * rs -----
3264 * rd -----
3265 */
3266 static char *CACHEE(uint64 instruction, Dis_info *info)
3267 {
3268 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3269 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3270 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3271
3272 const char *rs = GPR(rs_value, info);
3273
3274 return img_format("CACHEE 0x%" PRIx64 ", %" PRId64 "(%s)",
3275 op_value, s_value, rs);
3276 }
3277
3278
3279 /*
3280 *
3281 *
3282 * 3 2 1
3283 * 10987654321098765432109876543210
3284 * 001000 x1110000101
3285 * rt -----
3286 * rs -----
3287 * rd -----
3288 */
3289 static char *CEIL_L_D(uint64 instruction, Dis_info *info)
3290 {
3291 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3292 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3293
3294 const char *ft = FPR(ft_value, info);
3295 const char *fs = FPR(fs_value, info);
3296
3297 return img_format("CEIL.L.D %s, %s", ft, fs);
3298 }
3299
3300
3301 /*
3302 *
3303 *
3304 * 3 2 1
3305 * 10987654321098765432109876543210
3306 * 001000 x1110000101
3307 * rt -----
3308 * rs -----
3309 * rd -----
3310 */
3311 static char *CEIL_L_S(uint64 instruction, Dis_info *info)
3312 {
3313 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3314 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3315
3316 const char *ft = FPR(ft_value, info);
3317 const char *fs = FPR(fs_value, info);
3318
3319 return img_format("CEIL.L.S %s, %s", ft, fs);
3320 }
3321
3322
3323 /*
3324 *
3325 *
3326 * 3 2 1
3327 * 10987654321098765432109876543210
3328 * 001000 x1110000101
3329 * rt -----
3330 * rs -----
3331 * rd -----
3332 */
3333 static char *CEIL_W_D(uint64 instruction, Dis_info *info)
3334 {
3335 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3336 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3337
3338 const char *ft = FPR(ft_value, info);
3339 const char *fs = FPR(fs_value, info);
3340
3341 return img_format("CEIL.W.D %s, %s", ft, fs);
3342 }
3343
3344
3345 /*
3346 *
3347 *
3348 * 3 2 1
3349 * 10987654321098765432109876543210
3350 * 001000 x1110000101
3351 * rt -----
3352 * rs -----
3353 * rd -----
3354 */
3355 static char *CEIL_W_S(uint64 instruction, Dis_info *info)
3356 {
3357 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3358 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3359
3360 const char *ft = FPR(ft_value, info);
3361 const char *fs = FPR(fs_value, info);
3362
3363 return img_format("CEIL.W.S %s, %s", ft, fs);
3364 }
3365
3366
3367 /*
3368 *
3369 *
3370 * 3 2 1
3371 * 10987654321098765432109876543210
3372 * 001000 x1110000101
3373 * rt -----
3374 * rs -----
3375 * rd -----
3376 */
3377 static char *CFC1(uint64 instruction, Dis_info *info)
3378 {
3379 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3380 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3381
3382 const char *rt = GPR(rt_value, info);
3383
3384 return img_format("CFC1 %s, CP%" PRIu64, rt, cs_value);
3385 }
3386
3387
3388 /*
3389 *
3390 *
3391 * 3 2 1
3392 * 10987654321098765432109876543210
3393 * 001000 x1110000101
3394 * rt -----
3395 * rs -----
3396 * rd -----
3397 */
3398 static char *CFC2(uint64 instruction, Dis_info *info)
3399 {
3400 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3401 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3402
3403 const char *rt = GPR(rt_value, info);
3404
3405 return img_format("CFC2 %s, CP%" PRIu64, rt, cs_value);
3406 }
3407
3408
3409 /*
3410 *
3411 *
3412 * 3 2 1
3413 * 10987654321098765432109876543210
3414 * 001000 x1110000101
3415 * rt -----
3416 * rs -----
3417 * rd -----
3418 */
3419 static char *CLASS_D(uint64 instruction, Dis_info *info)
3420 {
3421 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3422 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3423
3424 const char *ft = FPR(ft_value, info);
3425 const char *fs = FPR(fs_value, info);
3426
3427 return img_format("CLASS.D %s, %s", ft, fs);
3428 }
3429
3430
3431 /*
3432 *
3433 *
3434 * 3 2 1
3435 * 10987654321098765432109876543210
3436 * 001000 x1110000101
3437 * rt -----
3438 * rs -----
3439 * rd -----
3440 */
3441 static char *CLASS_S(uint64 instruction, Dis_info *info)
3442 {
3443 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3444 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3445
3446 const char *ft = FPR(ft_value, info);
3447 const char *fs = FPR(fs_value, info);
3448
3449 return img_format("CLASS.S %s, %s", ft, fs);
3450 }
3451
3452
3453 /*
3454 *
3455 *
3456 * 3 2 1
3457 * 10987654321098765432109876543210
3458 * 001000 x1110000101
3459 * rt -----
3460 * rs -----
3461 * rd -----
3462 */
3463 static char *CLO(uint64 instruction, Dis_info *info)
3464 {
3465 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3466 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3467
3468 const char *rt = GPR(rt_value, info);
3469 const char *rs = GPR(rs_value, info);
3470
3471 return img_format("CLO %s, %s", rt, rs);
3472 }
3473
3474
3475 /*
3476 *
3477 *
3478 * 3 2 1
3479 * 10987654321098765432109876543210
3480 * 001000 x1110000101
3481 * rt -----
3482 * rs -----
3483 * rd -----
3484 */
3485 static char *CLZ(uint64 instruction, Dis_info *info)
3486 {
3487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3489
3490 const char *rt = GPR(rt_value, info);
3491 const char *rs = GPR(rs_value, info);
3492
3493 return img_format("CLZ %s, %s", rt, rs);
3494 }
3495
3496
3497 /*
3498 *
3499 *
3500 * 3 2 1
3501 * 10987654321098765432109876543210
3502 * 001000 x1110000101
3503 * rt -----
3504 * rs -----
3505 * rd -----
3506 */
3507 static char *CMP_AF_D(uint64 instruction, Dis_info *info)
3508 {
3509 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3510 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3511 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3512
3513 const char *fd = FPR(fd_value, info);
3514 const char *fs = FPR(fs_value, info);
3515 const char *ft = FPR(ft_value, info);
3516
3517 return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3518 }
3519
3520
3521 /*
3522 *
3523 *
3524 * 3 2 1
3525 * 10987654321098765432109876543210
3526 * 001000 x1110000101
3527 * rt -----
3528 * rs -----
3529 * rd -----
3530 */
3531 static char *CMP_AF_S(uint64 instruction, Dis_info *info)
3532 {
3533 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3534 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3535 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3536
3537 const char *fd = FPR(fd_value, info);
3538 const char *fs = FPR(fs_value, info);
3539 const char *ft = FPR(ft_value, info);
3540
3541 return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3542 }
3543
3544
3545 /*
3546 *
3547 *
3548 * 3 2 1
3549 * 10987654321098765432109876543210
3550 * 001000 x1110000101
3551 * rt -----
3552 * rs -----
3553 * rd -----
3554 */
3555 static char *CMP_EQ_D(uint64 instruction, Dis_info *info)
3556 {
3557 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3558 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3559 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3560
3561 const char *fd = FPR(fd_value, info);
3562 const char *fs = FPR(fs_value, info);
3563 const char *ft = FPR(ft_value, info);
3564
3565 return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3566 }
3567
3568
3569 /*
3570 * [DSP] CMP.EQ.PH rs, rt - Compare vectors of signed integer halfword values
3571 *
3572 * 3 2 1
3573 * 10987654321098765432109876543210
3574 * 001000 xxxxxx0000000101
3575 * rt -----
3576 * rs -----
3577 */
3578 static char *CMP_EQ_PH(uint64 instruction, Dis_info *info)
3579 {
3580 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3581 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3582
3583 const char *rs = GPR(rs_value, info);
3584 const char *rt = GPR(rt_value, info);
3585
3586 return img_format("CMP.EQ.PH %s, %s", rs, rt);
3587 }
3588
3589
3590 /*
3591 *
3592 *
3593 * 3 2 1
3594 * 10987654321098765432109876543210
3595 * 001000 x1110000101
3596 * rt -----
3597 * rs -----
3598 * rd -----
3599 */
3600 static char *CMP_EQ_S(uint64 instruction, Dis_info *info)
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 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3605
3606 const char *fd = FPR(fd_value, info);
3607 const char *fs = FPR(fs_value, info);
3608 const char *ft = FPR(ft_value, info);
3609
3610 return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3611 }
3612
3613
3614 /*
3615 *
3616 *
3617 * 3 2 1
3618 * 10987654321098765432109876543210
3619 * 001000 x1110000101
3620 * rt -----
3621 * rs -----
3622 * rd -----
3623 */
3624 static char *CMP_LE_D(uint64 instruction, Dis_info *info)
3625 {
3626 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3627 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3628 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3629
3630 const char *fd = FPR(fd_value, info);
3631 const char *fs = FPR(fs_value, info);
3632 const char *ft = FPR(ft_value, info);
3633
3634 return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3635 }
3636
3637
3638 /*
3639 * [DSP] CMP.LE.PH rs, rt - Compare vectors of signed integer halfword values
3640 *
3641 * 3 2 1
3642 * 10987654321098765432109876543210
3643 * 001000 xxxxxx0010000101
3644 * rt -----
3645 * rs -----
3646 */
3647 static char *CMP_LE_PH(uint64 instruction, Dis_info *info)
3648 {
3649 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3650 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3651
3652 const char *rs = GPR(rs_value, info);
3653 const char *rt = GPR(rt_value, info);
3654
3655 return img_format("CMP.LE.PH %s, %s", rs, rt);
3656 }
3657
3658
3659 /*
3660 *
3661 *
3662 * 3 2 1
3663 * 10987654321098765432109876543210
3664 * 001000 x1110000101
3665 * rt -----
3666 * rs -----
3667 * rd -----
3668 */
3669 static char *CMP_LE_S(uint64 instruction, Dis_info *info)
3670 {
3671 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3672 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3673 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3674
3675 const char *fd = FPR(fd_value, info);
3676 const char *fs = FPR(fs_value, info);
3677 const char *ft = FPR(ft_value, info);
3678
3679 return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3680 }
3681
3682
3683 /*
3684 *
3685 *
3686 * 3 2 1
3687 * 10987654321098765432109876543210
3688 * 001000 x1110000101
3689 * rt -----
3690 * rs -----
3691 * rd -----
3692 */
3693 static char *CMP_LT_D(uint64 instruction, Dis_info *info)
3694 {
3695 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3696 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3697 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3698
3699 const char *fd = FPR(fd_value, info);
3700 const char *fs = FPR(fs_value, info);
3701 const char *ft = FPR(ft_value, info);
3702
3703 return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
3704 }
3705
3706
3707 /*
3708 * [DSP] CMP.LT.PH rs, rt - Compare vectors of signed integer halfword values
3709 *
3710 * 3 2 1
3711 * 10987654321098765432109876543210
3712 * 001000 xxxxxx0001000101
3713 * rt -----
3714 * rs -----
3715 */
3716 static char *CMP_LT_PH(uint64 instruction, Dis_info *info)
3717 {
3718 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3719 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3720
3721 const char *rs = GPR(rs_value, info);
3722 const char *rt = GPR(rt_value, info);
3723
3724 return img_format("CMP.LT.PH %s, %s", rs, rt);
3725 }
3726
3727
3728 /*
3729 *
3730 *
3731 * 3 2 1
3732 * 10987654321098765432109876543210
3733 * 001000 x1110000101
3734 * rt -----
3735 * rs -----
3736 * rd -----
3737 */
3738 static char *CMP_LT_S(uint64 instruction, Dis_info *info)
3739 {
3740 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3741 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3742 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3743
3744 const char *fd = FPR(fd_value, info);
3745 const char *fs = FPR(fs_value, info);
3746 const char *ft = FPR(ft_value, info);
3747
3748 return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
3749 }
3750
3751
3752 /*
3753 *
3754 *
3755 * 3 2 1
3756 * 10987654321098765432109876543210
3757 * 001000 x1110000101
3758 * rt -----
3759 * rs -----
3760 * rd -----
3761 */
3762 static char *CMP_NE_D(uint64 instruction, Dis_info *info)
3763 {
3764 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3765 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3766 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3767
3768 const char *fd = FPR(fd_value, info);
3769 const char *fs = FPR(fs_value, info);
3770 const char *ft = FPR(ft_value, info);
3771
3772 return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
3773 }
3774
3775
3776 /*
3777 *
3778 *
3779 * 3 2 1
3780 * 10987654321098765432109876543210
3781 * 001000 x1110000101
3782 * rt -----
3783 * rs -----
3784 * rd -----
3785 */
3786 static char *CMP_NE_S(uint64 instruction, Dis_info *info)
3787 {
3788 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3789 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3790 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3791
3792 const char *fd = FPR(fd_value, info);
3793 const char *fs = FPR(fs_value, info);
3794 const char *ft = FPR(ft_value, info);
3795
3796 return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
3797 }
3798
3799
3800 /*
3801 *
3802 *
3803 * 3 2 1
3804 * 10987654321098765432109876543210
3805 * 001000 x1110000101
3806 * rt -----
3807 * rs -----
3808 * rd -----
3809 */
3810 static char *CMP_OR_D(uint64 instruction, Dis_info *info)
3811 {
3812 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3813 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3814 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3815
3816 const char *fd = FPR(fd_value, info);
3817 const char *fs = FPR(fs_value, info);
3818 const char *ft = FPR(ft_value, info);
3819
3820 return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
3821 }
3822
3823
3824 /*
3825 *
3826 *
3827 * 3 2 1
3828 * 10987654321098765432109876543210
3829 * 001000 x1110000101
3830 * rt -----
3831 * rs -----
3832 * rd -----
3833 */
3834 static char *CMP_OR_S(uint64 instruction, Dis_info *info)
3835 {
3836 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3837 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3838 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3839
3840 const char *fd = FPR(fd_value, info);
3841 const char *fs = FPR(fs_value, info);
3842 const char *ft = FPR(ft_value, info);
3843
3844 return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
3845 }
3846
3847
3848 /*
3849 *
3850 *
3851 * 3 2 1
3852 * 10987654321098765432109876543210
3853 * 001000 x1110000101
3854 * rt -----
3855 * rs -----
3856 * rd -----
3857 */
3858 static char *CMP_SAF_D(uint64 instruction, Dis_info *info)
3859 {
3860 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3861 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3862 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3863
3864 const char *fd = FPR(fd_value, info);
3865 const char *fs = FPR(fs_value, info);
3866 const char *ft = FPR(ft_value, info);
3867
3868 return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
3869 }
3870
3871
3872 /*
3873 *
3874 *
3875 * 3 2 1
3876 * 10987654321098765432109876543210
3877 * 001000 x1110000101
3878 * rt -----
3879 * rs -----
3880 * rd -----
3881 */
3882 static char *CMP_SAF_S(uint64 instruction, Dis_info *info)
3883 {
3884 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3885 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3886 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3887
3888 const char *fd = FPR(fd_value, info);
3889 const char *fs = FPR(fs_value, info);
3890 const char *ft = FPR(ft_value, info);
3891
3892 return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
3893 }
3894
3895
3896 /*
3897 *
3898 *
3899 * 3 2 1
3900 * 10987654321098765432109876543210
3901 * 001000 x1110000101
3902 * rt -----
3903 * rs -----
3904 * rd -----
3905 */
3906 static char *CMP_SEQ_D(uint64 instruction, Dis_info *info)
3907 {
3908 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3909 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3910 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3911
3912 const char *fd = FPR(fd_value, info);
3913 const char *fs = FPR(fs_value, info);
3914 const char *ft = FPR(ft_value, info);
3915
3916 return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
3917 }
3918
3919
3920 /*
3921 *
3922 *
3923 * 3 2 1
3924 * 10987654321098765432109876543210
3925 * 001000 x1110000101
3926 * rt -----
3927 * rs -----
3928 * rd -----
3929 */
3930 static char *CMP_SEQ_S(uint64 instruction, Dis_info *info)
3931 {
3932 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3933 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3934 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3935
3936 const char *fd = FPR(fd_value, info);
3937 const char *fs = FPR(fs_value, info);
3938 const char *ft = FPR(ft_value, info);
3939
3940 return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
3941 }
3942
3943
3944 /*
3945 *
3946 *
3947 * 3 2 1
3948 * 10987654321098765432109876543210
3949 * 001000 x1110000101
3950 * rt -----
3951 * rs -----
3952 * rd -----
3953 */
3954 static char *CMP_SLE_D(uint64 instruction, Dis_info *info)
3955 {
3956 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3957 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3958 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3959
3960 const char *fd = FPR(fd_value, info);
3961 const char *fs = FPR(fs_value, info);
3962 const char *ft = FPR(ft_value, info);
3963
3964 return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
3965 }
3966
3967
3968 /*
3969 *
3970 *
3971 * 3 2 1
3972 * 10987654321098765432109876543210
3973 * 001000 x1110000101
3974 * rt -----
3975 * rs -----
3976 * rd -----
3977 */
3978 static char *CMP_SLE_S(uint64 instruction, Dis_info *info)
3979 {
3980 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3981 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3982 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3983
3984 const char *fd = FPR(fd_value, info);
3985 const char *fs = FPR(fs_value, info);
3986 const char *ft = FPR(ft_value, info);
3987
3988 return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
3989 }
3990
3991
3992 /*
3993 *
3994 *
3995 * 3 2 1
3996 * 10987654321098765432109876543210
3997 * 001000 x1110000101
3998 * rt -----
3999 * rs -----
4000 * rd -----
4001 */
4002 static char *CMP_SLT_D(uint64 instruction, Dis_info *info)
4003 {
4004 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4005 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4006 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4007
4008 const char *fd = FPR(fd_value, info);
4009 const char *fs = FPR(fs_value, info);
4010 const char *ft = FPR(ft_value, info);
4011
4012 return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
4013 }
4014
4015
4016 /*
4017 *
4018 *
4019 * 3 2 1
4020 * 10987654321098765432109876543210
4021 * 001000 x1110000101
4022 * rt -----
4023 * rs -----
4024 * rd -----
4025 */
4026 static char *CMP_SLT_S(uint64 instruction, Dis_info *info)
4027 {
4028 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4029 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4030 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4031
4032 const char *fd = FPR(fd_value, info);
4033 const char *fs = FPR(fs_value, info);
4034 const char *ft = FPR(ft_value, info);
4035
4036 return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
4037 }
4038
4039
4040 /*
4041 *
4042 *
4043 * 3 2 1
4044 * 10987654321098765432109876543210
4045 * 001000 x1110000101
4046 * rt -----
4047 * rs -----
4048 * rd -----
4049 */
4050 static char *CMP_SNE_D(uint64 instruction, Dis_info *info)
4051 {
4052 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4053 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4054 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4055
4056 const char *fd = FPR(fd_value, info);
4057 const char *fs = FPR(fs_value, info);
4058 const char *ft = FPR(ft_value, info);
4059
4060 return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
4061 }
4062
4063
4064 /*
4065 *
4066 *
4067 * 3 2 1
4068 * 10987654321098765432109876543210
4069 * 001000 x1110000101
4070 * rt -----
4071 * rs -----
4072 * rd -----
4073 */
4074 static char *CMP_SNE_S(uint64 instruction, Dis_info *info)
4075 {
4076 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4077 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4078 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4079
4080 const char *fd = FPR(fd_value, info);
4081 const char *fs = FPR(fs_value, info);
4082 const char *ft = FPR(ft_value, info);
4083
4084 return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
4085 }
4086
4087
4088 /*
4089 *
4090 *
4091 * 3 2 1
4092 * 10987654321098765432109876543210
4093 * 001000 x1110000101
4094 * rt -----
4095 * rs -----
4096 * rd -----
4097 */
4098 static char *CMP_SOR_D(uint64 instruction, Dis_info *info)
4099 {
4100 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4101 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4102 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4103
4104 const char *fd = FPR(fd_value, info);
4105 const char *fs = FPR(fs_value, info);
4106 const char *ft = FPR(ft_value, info);
4107
4108 return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4109 }
4110
4111
4112 /*
4113 *
4114 *
4115 * 3 2 1
4116 * 10987654321098765432109876543210
4117 * 001000 x1110000101
4118 * rt -----
4119 * rs -----
4120 * rd -----
4121 */
4122 static char *CMP_SOR_S(uint64 instruction, Dis_info *info)
4123 {
4124 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4125 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4126 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4127
4128 const char *fd = FPR(fd_value, info);
4129 const char *fs = FPR(fs_value, info);
4130 const char *ft = FPR(ft_value, info);
4131
4132 return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4133 }
4134
4135
4136 /*
4137 *
4138 *
4139 * 3 2 1
4140 * 10987654321098765432109876543210
4141 * 001000 x1110000101
4142 * rt -----
4143 * rs -----
4144 * rd -----
4145 */
4146 static char *CMP_SUEQ_D(uint64 instruction, Dis_info *info)
4147 {
4148 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4149 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4150 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4151
4152 const char *fd = FPR(fd_value, info);
4153 const char *fs = FPR(fs_value, info);
4154 const char *ft = FPR(ft_value, info);
4155
4156 return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4157 }
4158
4159
4160 /*
4161 *
4162 *
4163 * 3 2 1
4164 * 10987654321098765432109876543210
4165 * 001000 x1110000101
4166 * rt -----
4167 * rs -----
4168 * rd -----
4169 */
4170 static char *CMP_SUEQ_S(uint64 instruction, Dis_info *info)
4171 {
4172 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4173 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4174 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4175
4176 const char *fd = FPR(fd_value, info);
4177 const char *fs = FPR(fs_value, info);
4178 const char *ft = FPR(ft_value, info);
4179
4180 return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4181 }
4182
4183
4184 /*
4185 *
4186 *
4187 * 3 2 1
4188 * 10987654321098765432109876543210
4189 * 001000 x1110000101
4190 * rt -----
4191 * rs -----
4192 * rd -----
4193 */
4194 static char *CMP_SULE_D(uint64 instruction, Dis_info *info)
4195 {
4196 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4197 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4198 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4199
4200 const char *fd = FPR(fd_value, info);
4201 const char *fs = FPR(fs_value, info);
4202 const char *ft = FPR(ft_value, info);
4203
4204 return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4205 }
4206
4207
4208 /*
4209 *
4210 *
4211 * 3 2 1
4212 * 10987654321098765432109876543210
4213 * 001000 x1110000101
4214 * rt -----
4215 * rs -----
4216 * rd -----
4217 */
4218 static char *CMP_SULE_S(uint64 instruction, Dis_info *info)
4219 {
4220 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4221 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4222 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4223
4224 const char *fd = FPR(fd_value, info);
4225 const char *fs = FPR(fs_value, info);
4226 const char *ft = FPR(ft_value, info);
4227
4228 return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4229 }
4230
4231
4232 /*
4233 *
4234 *
4235 * 3 2 1
4236 * 10987654321098765432109876543210
4237 * 001000 x1110000101
4238 * rt -----
4239 * rs -----
4240 * rd -----
4241 */
4242 static char *CMP_SULT_D(uint64 instruction, Dis_info *info)
4243 {
4244 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4245 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4246 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4247
4248 const char *fd = FPR(fd_value, info);
4249 const char *fs = FPR(fs_value, info);
4250 const char *ft = FPR(ft_value, info);
4251
4252 return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4253 }
4254
4255
4256 /*
4257 *
4258 *
4259 * 3 2 1
4260 * 10987654321098765432109876543210
4261 * 001000 x1110000101
4262 * rt -----
4263 * rs -----
4264 * rd -----
4265 */
4266 static char *CMP_SULT_S(uint64 instruction, Dis_info *info)
4267 {
4268 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4269 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4270 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4271
4272 const char *fd = FPR(fd_value, info);
4273 const char *fs = FPR(fs_value, info);
4274 const char *ft = FPR(ft_value, info);
4275
4276 return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4277 }
4278
4279
4280 /*
4281 *
4282 *
4283 * 3 2 1
4284 * 10987654321098765432109876543210
4285 * 001000 x1110000101
4286 * rt -----
4287 * rs -----
4288 * rd -----
4289 */
4290 static char *CMP_SUN_D(uint64 instruction, Dis_info *info)
4291 {
4292 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4293 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4294 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4295
4296 const char *fd = FPR(fd_value, info);
4297 const char *fs = FPR(fs_value, info);
4298 const char *ft = FPR(ft_value, info);
4299
4300 return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4301 }
4302
4303
4304 /*
4305 *
4306 *
4307 * 3 2 1
4308 * 10987654321098765432109876543210
4309 * 001000 x1110000101
4310 * rt -----
4311 * rs -----
4312 * rd -----
4313 */
4314 static char *CMP_SUNE_D(uint64 instruction, Dis_info *info)
4315 {
4316 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4317 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4318 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4319
4320 const char *fd = FPR(fd_value, info);
4321 const char *fs = FPR(fs_value, info);
4322 const char *ft = FPR(ft_value, info);
4323
4324 return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4325 }
4326
4327
4328 /*
4329 *
4330 *
4331 * 3 2 1
4332 * 10987654321098765432109876543210
4333 * 001000 x1110000101
4334 * rt -----
4335 * rs -----
4336 * rd -----
4337 */
4338 static char *CMP_SUNE_S(uint64 instruction, Dis_info *info)
4339 {
4340 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4341 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4342 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4343
4344 const char *fd = FPR(fd_value, info);
4345 const char *fs = FPR(fs_value, info);
4346 const char *ft = FPR(ft_value, info);
4347
4348 return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4349 }
4350
4351
4352 /*
4353 *
4354 *
4355 * 3 2 1
4356 * 10987654321098765432109876543210
4357 * 001000 x1110000101
4358 * rt -----
4359 * rs -----
4360 * rd -----
4361 */
4362 static char *CMP_SUN_S(uint64 instruction, Dis_info *info)
4363 {
4364 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4365 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4366 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4367
4368 const char *fd = FPR(fd_value, info);
4369 const char *fs = FPR(fs_value, info);
4370 const char *ft = FPR(ft_value, info);
4371
4372 return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4373 }
4374
4375
4376 /*
4377 *
4378 *
4379 * 3 2 1
4380 * 10987654321098765432109876543210
4381 * 001000 x1110000101
4382 * rt -----
4383 * rs -----
4384 * rd -----
4385 */
4386 static char *CMP_UEQ_D(uint64 instruction, Dis_info *info)
4387 {
4388 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4389 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4390 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4391
4392 const char *fd = FPR(fd_value, info);
4393 const char *fs = FPR(fs_value, info);
4394 const char *ft = FPR(ft_value, info);
4395
4396 return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4397 }
4398
4399
4400 /*
4401 *
4402 *
4403 * 3 2 1
4404 * 10987654321098765432109876543210
4405 * 001000 x1110000101
4406 * rt -----
4407 * rs -----
4408 * rd -----
4409 */
4410 static char *CMP_UEQ_S(uint64 instruction, Dis_info *info)
4411 {
4412 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4413 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4414 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4415
4416 const char *fd = FPR(fd_value, info);
4417 const char *fs = FPR(fs_value, info);
4418 const char *ft = FPR(ft_value, info);
4419
4420 return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4421 }
4422
4423
4424 /*
4425 *
4426 *
4427 * 3 2 1
4428 * 10987654321098765432109876543210
4429 * 001000 x1110000101
4430 * rt -----
4431 * rs -----
4432 * rd -----
4433 */
4434 static char *CMP_ULE_D(uint64 instruction, Dis_info *info)
4435 {
4436 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4437 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4438 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4439
4440 const char *fd = FPR(fd_value, info);
4441 const char *fs = FPR(fs_value, info);
4442 const char *ft = FPR(ft_value, info);
4443
4444 return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4445 }
4446
4447
4448 /*
4449 *
4450 *
4451 * 3 2 1
4452 * 10987654321098765432109876543210
4453 * 001000 x1110000101
4454 * rt -----
4455 * rs -----
4456 * rd -----
4457 */
4458 static char *CMP_ULE_S(uint64 instruction, Dis_info *info)
4459 {
4460 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4461 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4462 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4463
4464 const char *fd = FPR(fd_value, info);
4465 const char *fs = FPR(fs_value, info);
4466 const char *ft = FPR(ft_value, info);
4467
4468 return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4469 }
4470
4471
4472 /*
4473 *
4474 *
4475 * 3 2 1
4476 * 10987654321098765432109876543210
4477 * 001000 x1110000101
4478 * rt -----
4479 * rs -----
4480 * rd -----
4481 */
4482 static char *CMP_ULT_D(uint64 instruction, Dis_info *info)
4483 {
4484 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4485 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4486 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4487
4488 const char *fd = FPR(fd_value, info);
4489 const char *fs = FPR(fs_value, info);
4490 const char *ft = FPR(ft_value, info);
4491
4492 return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4493 }
4494
4495
4496 /*
4497 *
4498 *
4499 * 3 2 1
4500 * 10987654321098765432109876543210
4501 * 001000 x1110000101
4502 * rt -----
4503 * rs -----
4504 * rd -----
4505 */
4506 static char *CMP_ULT_S(uint64 instruction, Dis_info *info)
4507 {
4508 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4509 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4510 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4511
4512 const char *fd = FPR(fd_value, info);
4513 const char *fs = FPR(fs_value, info);
4514 const char *ft = FPR(ft_value, info);
4515
4516 return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4517 }
4518
4519
4520 /*
4521 *
4522 *
4523 * 3 2 1
4524 * 10987654321098765432109876543210
4525 * 001000 x1110000101
4526 * rt -----
4527 * rs -----
4528 * rd -----
4529 */
4530 static char *CMP_UN_D(uint64 instruction, Dis_info *info)
4531 {
4532 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4533 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4534 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4535
4536 const char *fd = FPR(fd_value, info);
4537 const char *fs = FPR(fs_value, info);
4538 const char *ft = FPR(ft_value, info);
4539
4540 return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4541 }
4542
4543
4544 /*
4545 *
4546 *
4547 * 3 2 1
4548 * 10987654321098765432109876543210
4549 * 001000 x1110000101
4550 * rt -----
4551 * rs -----
4552 * rd -----
4553 */
4554 static char *CMP_UNE_D(uint64 instruction, Dis_info *info)
4555 {
4556 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4557 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4558 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4559
4560 const char *fd = FPR(fd_value, info);
4561 const char *fs = FPR(fs_value, info);
4562 const char *ft = FPR(ft_value, info);
4563
4564 return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4565 }
4566
4567
4568 /*
4569 *
4570 *
4571 * 3 2 1
4572 * 10987654321098765432109876543210
4573 * 001000 x1110000101
4574 * rt -----
4575 * rs -----
4576 * rd -----
4577 */
4578 static char *CMP_UNE_S(uint64 instruction, Dis_info *info)
4579 {
4580 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4581 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4582 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4583
4584 const char *fd = FPR(fd_value, info);
4585 const char *fs = FPR(fs_value, info);
4586 const char *ft = FPR(ft_value, info);
4587
4588 return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4589 }
4590
4591
4592 /*
4593 *
4594 *
4595 * 3 2 1
4596 * 10987654321098765432109876543210
4597 * 001000 x1110000101
4598 * rt -----
4599 * rs -----
4600 * rd -----
4601 */
4602 static char *CMP_UN_S(uint64 instruction, Dis_info *info)
4603 {
4604 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4605 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4606 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4607
4608 const char *fd = FPR(fd_value, info);
4609 const char *fs = FPR(fs_value, info);
4610 const char *ft = FPR(ft_value, info);
4611
4612 return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4613 }
4614
4615
4616 /*
4617 * [DSP] CMPGDU.EQ.QB rd, rs, rt - Compare unsigned vector of
4618 * four bytes and write result to GPR and DSPControl
4619 *
4620 * 3 2 1
4621 * 10987654321098765432109876543210
4622 * 001000 x0110000101
4623 * rt -----
4624 * rs -----
4625 * rd -----
4626 */
4627 static char *CMPGDU_EQ_QB(uint64 instruction, Dis_info *info)
4628 {
4629 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4630 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4631 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4632
4633 const char *rd = GPR(rd_value, info);
4634 const char *rs = GPR(rs_value, info);
4635 const char *rt = GPR(rt_value, info);
4636
4637 return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4638 }
4639
4640
4641 /*
4642 * [DSP] CMPGDU.LE.QB rd, rs, rt - Compare unsigned vector of
4643 * four bytes and write result to GPR and DSPControl
4644 *
4645 * 3 2 1
4646 * 10987654321098765432109876543210
4647 * 001000 x1000000101
4648 * rt -----
4649 * rs -----
4650 * rd -----
4651 */
4652 static char *CMPGDU_LE_QB(uint64 instruction, Dis_info *info)
4653 {
4654 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4655 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4656 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4657
4658 const char *rd = GPR(rd_value, info);
4659 const char *rs = GPR(rs_value, info);
4660 const char *rt = GPR(rt_value, info);
4661
4662 return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4663 }
4664
4665
4666 /*
4667 * [DSP] CMPGDU.EQ.QB rd, rs, rt - Compare unsigned vector of
4668 * four bytes and write result to GPR and DSPControl
4669 *
4670 * 3 2 1
4671 * 10987654321098765432109876543210
4672 * 001000 x0111000101
4673 * rt -----
4674 * rs -----
4675 * rd -----
4676 */
4677 static char *CMPGDU_LT_QB(uint64 instruction, Dis_info *info)
4678 {
4679 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4680 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4681 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4682
4683 const char *rd = GPR(rd_value, info);
4684 const char *rs = GPR(rs_value, info);
4685 const char *rt = GPR(rt_value, info);
4686
4687 return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4688 }
4689
4690
4691 /*
4692 * [DSP] CMPGU.EQ.QB rd, rs, rt - Compare vectors of unsigned
4693 * byte values and write result to a GPR
4694 *
4695 * 3 2 1
4696 * 10987654321098765432109876543210
4697 * 001000 x0011000101
4698 * rt -----
4699 * rs -----
4700 * rd -----
4701 */
4702 static char *CMPGU_EQ_QB(uint64 instruction, Dis_info *info)
4703 {
4704 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4705 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4706 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4707
4708 const char *rd = GPR(rd_value, info);
4709 const char *rs = GPR(rs_value, info);
4710 const char *rt = GPR(rt_value, info);
4711
4712 return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
4713 }
4714
4715
4716 /*
4717 * [DSP] CMPGU.LE.QB rd, rs, rt - Compare vectors of unsigned
4718 * byte values and write result to a GPR
4719 *
4720 * 3 2 1
4721 * 10987654321098765432109876543210
4722 * 001000 x0101000101
4723 * rt -----
4724 * rs -----
4725 * rd -----
4726 */
4727 static char *CMPGU_LE_QB(uint64 instruction, Dis_info *info)
4728 {
4729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4730 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4731 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4732
4733 const char *rd = GPR(rd_value, info);
4734 const char *rs = GPR(rs_value, info);
4735 const char *rt = GPR(rt_value, info);
4736
4737 return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
4738 }
4739
4740
4741 /*
4742 * [DSP] CMPGU.LT.QB rd, rs, rt - Compare vectors of unsigned
4743 * byte values and write result to a GPR
4744 *
4745 * 3 2 1
4746 * 10987654321098765432109876543210
4747 * 001000 x0100000101
4748 * rt -----
4749 * rs -----
4750 * rd -----
4751 */
4752 static char *CMPGU_LT_QB(uint64 instruction, Dis_info *info)
4753 {
4754 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4755 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4756 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4757
4758 const char *rd = GPR(rd_value, info);
4759 const char *rs = GPR(rs_value, info);
4760 const char *rt = GPR(rt_value, info);
4761
4762 return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
4763 }
4764
4765
4766 /*
4767 * [DSP] CMPU.EQ.QB rd, rs, rt - Compare vectors of unsigned
4768 * byte values
4769 *
4770 * 3 2 1
4771 * 10987654321098765432109876543210
4772 * 001000 xxxxxx1001000101
4773 * rt -----
4774 * rs -----
4775 */
4776 static char *CMPU_EQ_QB(uint64 instruction, Dis_info *info)
4777 {
4778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4779 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4780
4781 const char *rs = GPR(rs_value, info);
4782 const char *rt = GPR(rt_value, info);
4783
4784 return img_format("CMPU.EQ.QB %s, %s", rs, rt);
4785 }
4786
4787
4788 /*
4789 * [DSP] CMPU.LE.QB rd, rs, rt - Compare vectors of unsigned
4790 * byte values
4791 *
4792 * 3 2 1
4793 * 10987654321098765432109876543210
4794 * 001000 xxxxxx1011000101
4795 * rt -----
4796 * rs -----
4797 */
4798 static char *CMPU_LE_QB(uint64 instruction, Dis_info *info)
4799 {
4800 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4801 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4802
4803 const char *rs = GPR(rs_value, info);
4804 const char *rt = GPR(rt_value, info);
4805
4806 return img_format("CMPU.LE.QB %s, %s", rs, rt);
4807 }
4808
4809
4810 /*
4811 * [DSP] CMPU.LT.QB rd, rs, rt - Compare vectors of unsigned
4812 * byte values
4813 *
4814 * 3 2 1
4815 * 10987654321098765432109876543210
4816 * 001000 xxxxxx1010000101
4817 * rt -----
4818 * rs -----
4819 */
4820 static char *CMPU_LT_QB(uint64 instruction, Dis_info *info)
4821 {
4822 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4823 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4824
4825 const char *rs = GPR(rs_value, info);
4826 const char *rt = GPR(rt_value, info);
4827
4828 return img_format("CMPU.LT.QB %s, %s", rs, rt);
4829 }
4830
4831
4832 /*
4833 *
4834 *
4835 * 3 2 1
4836 * 10987654321098765432109876543210
4837 * 001000 x1110000101
4838 * rt -----
4839 * rs -----
4840 * rd -----
4841 */
4842 static char *COP2_1(uint64 instruction, Dis_info *info)
4843 {
4844 uint64 cofun_value = extract_cofun_25_24_23(instruction);
4845
4846
4847 return img_format("COP2_1 0x%" PRIx64, cofun_value);
4848 }
4849
4850
4851 /*
4852 *
4853 *
4854 * 3 2 1
4855 * 10987654321098765432109876543210
4856 * 001000 x1110000101
4857 * rt -----
4858 * rs -----
4859 * rd -----
4860 */
4861 static char *CTC1(uint64 instruction, Dis_info *info)
4862 {
4863 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4864 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
4865
4866 const char *rt = GPR(rt_value, info);
4867
4868 return img_format("CTC1 %s, CP%" PRIu64, rt, cs_value);
4869 }
4870
4871
4872 /*
4873 *
4874 *
4875 * 3 2 1
4876 * 10987654321098765432109876543210
4877 * 001000 x1110000101
4878 * rt -----
4879 * rs -----
4880 * rd -----
4881 */
4882 static char *CTC2(uint64 instruction, Dis_info *info)
4883 {
4884 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4885 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
4886
4887 const char *rt = GPR(rt_value, info);
4888
4889 return img_format("CTC2 %s, CP%" PRIu64, rt, cs_value);
4890 }
4891
4892
4893 /*
4894 *
4895 *
4896 * 3 2 1
4897 * 10987654321098765432109876543210
4898 * 001000 x1110000101
4899 * rt -----
4900 * rs -----
4901 * rd -----
4902 */
4903 static char *CVT_D_L(uint64 instruction, Dis_info *info)
4904 {
4905 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4906 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4907
4908 const char *ft = FPR(ft_value, info);
4909 const char *fs = FPR(fs_value, info);
4910
4911 return img_format("CVT.D.L %s, %s", ft, fs);
4912 }
4913
4914
4915 /*
4916 *
4917 *
4918 * 3 2 1
4919 * 10987654321098765432109876543210
4920 * 001000 x1110000101
4921 * rt -----
4922 * rs -----
4923 * rd -----
4924 */
4925 static char *CVT_D_S(uint64 instruction, Dis_info *info)
4926 {
4927 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4928 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4929
4930 const char *ft = FPR(ft_value, info);
4931 const char *fs = FPR(fs_value, info);
4932
4933 return img_format("CVT.D.S %s, %s", ft, fs);
4934 }
4935
4936
4937 /*
4938 *
4939 *
4940 * 3 2 1
4941 * 10987654321098765432109876543210
4942 * 001000 x1110000101
4943 * rt -----
4944 * rs -----
4945 * rd -----
4946 */
4947 static char *CVT_D_W(uint64 instruction, Dis_info *info)
4948 {
4949 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4950 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4951
4952 const char *ft = FPR(ft_value, info);
4953 const char *fs = FPR(fs_value, info);
4954
4955 return img_format("CVT.D.W %s, %s", ft, fs);
4956 }
4957
4958
4959 /*
4960 *
4961 *
4962 * 3 2 1
4963 * 10987654321098765432109876543210
4964 * 001000 x1110000101
4965 * rt -----
4966 * rs -----
4967 * rd -----
4968 */
4969 static char *CVT_L_D(uint64 instruction, Dis_info *info)
4970 {
4971 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4972 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4973
4974 const char *ft = FPR(ft_value, info);
4975 const char *fs = FPR(fs_value, info);
4976
4977 return img_format("CVT.L.D %s, %s", ft, fs);
4978 }
4979
4980
4981 /*
4982 *
4983 *
4984 * 3 2 1
4985 * 10987654321098765432109876543210
4986 * 001000 x1110000101
4987 * rt -----
4988 * rs -----
4989 * rd -----
4990 */
4991 static char *CVT_L_S(uint64 instruction, Dis_info *info)
4992 {
4993 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4994 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4995
4996 const char *ft = FPR(ft_value, info);
4997 const char *fs = FPR(fs_value, info);
4998
4999 return img_format("CVT.L.S %s, %s", ft, fs);
5000 }
5001
5002
5003 /*
5004 *
5005 *
5006 * 3 2 1
5007 * 10987654321098765432109876543210
5008 * 001000 x1110000101
5009 * rt -----
5010 * rs -----
5011 * rd -----
5012 */
5013 static char *CVT_S_D(uint64 instruction, Dis_info *info)
5014 {
5015 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5016 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5017
5018 const char *ft = FPR(ft_value, info);
5019 const char *fs = FPR(fs_value, info);
5020
5021 return img_format("CVT.S.D %s, %s", ft, fs);
5022 }
5023
5024
5025 /*
5026 *
5027 *
5028 * 3 2 1
5029 * 10987654321098765432109876543210
5030 * 001000 x1110000101
5031 * rt -----
5032 * rs -----
5033 * rd -----
5034 */
5035 static char *CVT_S_L(uint64 instruction, Dis_info *info)
5036 {
5037 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5038 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5039
5040 const char *ft = FPR(ft_value, info);
5041 const char *fs = FPR(fs_value, info);
5042
5043 return img_format("CVT.S.L %s, %s", ft, fs);
5044 }
5045
5046
5047 /*
5048 *
5049 *
5050 * 3 2 1
5051 * 10987654321098765432109876543210
5052 * 001000 x1110000101
5053 * rt -----
5054 * rs -----
5055 * rd -----
5056 */
5057 static char *CVT_S_PL(uint64 instruction, Dis_info *info)
5058 {
5059 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5060 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5061
5062 const char *ft = FPR(ft_value, info);
5063 const char *fs = FPR(fs_value, info);
5064
5065 return img_format("CVT.S.PL %s, %s", ft, fs);
5066 }
5067
5068
5069 /*
5070 *
5071 *
5072 * 3 2 1
5073 * 10987654321098765432109876543210
5074 * 001000 x1110000101
5075 * rt -----
5076 * rs -----
5077 * rd -----
5078 */
5079 static char *CVT_S_PU(uint64 instruction, Dis_info *info)
5080 {
5081 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5082 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5083
5084 const char *ft = FPR(ft_value, info);
5085 const char *fs = FPR(fs_value, info);
5086
5087 return img_format("CVT.S.PU %s, %s", ft, fs);
5088 }
5089
5090
5091 /*
5092 *
5093 *
5094 * 3 2 1
5095 * 10987654321098765432109876543210
5096 * 001000 x1110000101
5097 * rt -----
5098 * rs -----
5099 * rd -----
5100 */
5101 static char *CVT_S_W(uint64 instruction, Dis_info *info)
5102 {
5103 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5104 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5105
5106 const char *ft = FPR(ft_value, info);
5107 const char *fs = FPR(fs_value, info);
5108
5109 return img_format("CVT.S.W %s, %s", ft, fs);
5110 }
5111
5112
5113 /*
5114 *
5115 *
5116 * 3 2 1
5117 * 10987654321098765432109876543210
5118 * 001000 x1110000101
5119 * rt -----
5120 * rs -----
5121 * rd -----
5122 */
5123 static char *CVT_W_D(uint64 instruction, Dis_info *info)
5124 {
5125 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5126 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5127
5128 const char *ft = FPR(ft_value, info);
5129 const char *fs = FPR(fs_value, info);
5130
5131 return img_format("CVT.W.D %s, %s", ft, fs);
5132 }
5133
5134
5135 /*
5136 *
5137 *
5138 * 3 2 1
5139 * 10987654321098765432109876543210
5140 * 001000 x1110000101
5141 * rt -----
5142 * rs -----
5143 * rd -----
5144 */
5145 static char *CVT_W_S(uint64 instruction, Dis_info *info)
5146 {
5147 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5148 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5149
5150 const char *ft = FPR(ft_value, info);
5151 const char *fs = FPR(fs_value, info);
5152
5153 return img_format("CVT.W.S %s, %s", ft, fs);
5154 }
5155
5156
5157 /*
5158 *
5159 *
5160 * 3 2 1
5161 * 10987654321098765432109876543210
5162 * 001000 x1110000101
5163 * rt -----
5164 * rs -----
5165 * rd -----
5166 */
5167 static char *DADDIU_48_(uint64 instruction, Dis_info *info)
5168 {
5169 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5170 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
5171
5172 const char *rt = GPR(rt_value, info);
5173
5174 return img_format("DADDIU %s, %" PRId64, rt, s_value);
5175 }
5176
5177
5178 /*
5179 *
5180 *
5181 * 3 2 1
5182 * 10987654321098765432109876543210
5183 * 001000 x1110000101
5184 * rt -----
5185 * rs -----
5186 * rd -----
5187 */
5188 static char *DADDIU_NEG_(uint64 instruction, Dis_info *info)
5189 {
5190 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5191 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5192 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5193
5194 const char *rt = GPR(rt_value, info);
5195 const char *rs = GPR(rs_value, info);
5196 int64 u = neg_copy(u_value);
5197
5198 return img_format("DADDIU %s, %s, %" PRId64, rt, rs, u);
5199 }
5200
5201
5202 /*
5203 *
5204 *
5205 * 3 2 1
5206 * 10987654321098765432109876543210
5207 * 001000 x1110000101
5208 * rt -----
5209 * rs -----
5210 * rd -----
5211 */
5212 static char *DADDIU_U12_(uint64 instruction, Dis_info *info)
5213 {
5214 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5215 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5216 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5217
5218 const char *rt = GPR(rt_value, info);
5219 const char *rs = GPR(rs_value, info);
5220
5221 return img_format("DADDIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
5222 }
5223
5224
5225 /*
5226 *
5227 *
5228 * 3 2 1
5229 * 10987654321098765432109876543210
5230 * 001000 x1110000101
5231 * rt -----
5232 * rs -----
5233 * rd -----
5234 */
5235 static char *DADD(uint64 instruction, Dis_info *info)
5236 {
5237 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5238 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5239 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5240
5241 const char *rd = GPR(rd_value, info);
5242 const char *rs = GPR(rs_value, info);
5243 const char *rt = GPR(rt_value, info);
5244
5245 return img_format("DADD %s, %s, %s", rd, rs, rt);
5246 }
5247
5248
5249 /*
5250 *
5251 *
5252 * 3 2 1
5253 * 10987654321098765432109876543210
5254 * 001000 x1110000101
5255 * rt -----
5256 * rs -----
5257 * rd -----
5258 */
5259 static char *DADDU(uint64 instruction, Dis_info *info)
5260 {
5261 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5262 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5263 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5264
5265 const char *rd = GPR(rd_value, info);
5266 const char *rs = GPR(rs_value, info);
5267 const char *rt = GPR(rt_value, info);
5268
5269 return img_format("DADDU %s, %s, %s", rd, rs, rt);
5270 }
5271
5272
5273 /*
5274 *
5275 *
5276 * 3 2 1
5277 * 10987654321098765432109876543210
5278 * 001000 x1110000101
5279 * rt -----
5280 * rs -----
5281 * rd -----
5282 */
5283 static char *DCLO(uint64 instruction, Dis_info *info)
5284 {
5285 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5286 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5287
5288 const char *rt = GPR(rt_value, info);
5289 const char *rs = GPR(rs_value, info);
5290
5291 return img_format("DCLO %s, %s", rt, rs);
5292 }
5293
5294
5295 /*
5296 *
5297 *
5298 * 3 2 1
5299 * 10987654321098765432109876543210
5300 * 001000 x1110000101
5301 * rt -----
5302 * rs -----
5303 * rd -----
5304 */
5305 static char *DCLZ(uint64 instruction, Dis_info *info)
5306 {
5307 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5308 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5309
5310 const char *rt = GPR(rt_value, info);
5311 const char *rs = GPR(rs_value, info);
5312
5313 return img_format("DCLZ %s, %s", rt, rs);
5314 }
5315
5316
5317 /*
5318 *
5319 *
5320 * 3 2 1
5321 * 10987654321098765432109876543210
5322 * 001000 x1110000101
5323 * rt -----
5324 * rs -----
5325 * rd -----
5326 */
5327 static char *DDIV(uint64 instruction, Dis_info *info)
5328 {
5329 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5330 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5331 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5332
5333 const char *rd = GPR(rd_value, info);
5334 const char *rs = GPR(rs_value, info);
5335 const char *rt = GPR(rt_value, info);
5336
5337 return img_format("DDIV %s, %s, %s", rd, rs, rt);
5338 }
5339
5340
5341 /*
5342 *
5343 *
5344 * 3 2 1
5345 * 10987654321098765432109876543210
5346 * 001000 x1110000101
5347 * rt -----
5348 * rs -----
5349 * rd -----
5350 */
5351 static char *DDIVU(uint64 instruction, Dis_info *info)
5352 {
5353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5355 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5356
5357 const char *rd = GPR(rd_value, info);
5358 const char *rs = GPR(rs_value, info);
5359 const char *rt = GPR(rt_value, info);
5360
5361 return img_format("DDIVU %s, %s, %s", rd, rs, rt);
5362 }
5363
5364
5365 /*
5366 *
5367 *
5368 * 3 2 1
5369 * 10987654321098765432109876543210
5370 * 001000 x1110000101
5371 * rt -----
5372 * rs -----
5373 * rd -----
5374 */
5375 static char *DERET(uint64 instruction, Dis_info *info)
5376 {
5377 (void)instruction;
5378
5379 return g_strdup("DERET ");
5380 }
5381
5382
5383 /*
5384 *
5385 *
5386 * 3 2 1
5387 * 10987654321098765432109876543210
5388 * 001000 x1110000101
5389 * rt -----
5390 * rs -----
5391 * rd -----
5392 */
5393 static char *DEXTM(uint64 instruction, Dis_info *info)
5394 {
5395 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5397 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5398 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5399
5400 const char *rt = GPR(rt_value, info);
5401 const char *rs = GPR(rs_value, info);
5402 uint64 msbd = encode_msbd_from_size(msbd_value);
5403
5404 return img_format("DEXTM %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5405 rt, rs, lsb_value, msbd);
5406 }
5407
5408
5409 /*
5410 *
5411 *
5412 * 3 2 1
5413 * 10987654321098765432109876543210
5414 * 001000 x1110000101
5415 * rt -----
5416 * rs -----
5417 * rd -----
5418 */
5419 static char *DEXT(uint64 instruction, Dis_info *info)
5420 {
5421 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5422 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5423 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5424 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5425
5426 const char *rt = GPR(rt_value, info);
5427 const char *rs = GPR(rs_value, info);
5428 uint64 msbd = encode_msbd_from_size(msbd_value);
5429
5430 return img_format("DEXT %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5431 rt, rs, lsb_value, msbd);
5432 }
5433
5434
5435 /*
5436 *
5437 *
5438 * 3 2 1
5439 * 10987654321098765432109876543210
5440 * 001000 x1110000101
5441 * rt -----
5442 * rs -----
5443 * rd -----
5444 */
5445 static char *DEXTU(uint64 instruction, Dis_info *info)
5446 {
5447 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5448 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5449 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5450 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5451
5452 const char *rt = GPR(rt_value, info);
5453 const char *rs = GPR(rs_value, info);
5454 uint64 msbd = encode_msbd_from_size(msbd_value);
5455
5456 return img_format("DEXTU %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5457 rt, rs, lsb_value, msbd);
5458 }
5459
5460
5461 /*
5462 *
5463 *
5464 * 3 2 1
5465 * 10987654321098765432109876543210
5466 * 001000 x1110000101
5467 * rt -----
5468 * rs -----
5469 * rd -----
5470 */
5471 static char *DINSM(uint64 instruction, Dis_info *info)
5472 {
5473 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5474 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5475 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5476 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5477
5478 const char *rt = GPR(rt_value, info);
5479 const char *rs = GPR(rs_value, info);
5480 /* !!!!!!!!!! - no conversion function */
5481
5482 return img_format("DINSM %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5483 rt, rs, lsb_value, msbd_value);
5484 /* hand edited */
5485 }
5486
5487
5488 /*
5489 *
5490 *
5491 * 3 2 1
5492 * 10987654321098765432109876543210
5493 * 001000 x1110000101
5494 * rt -----
5495 * rs -----
5496 * rd -----
5497 */
5498 static char *DINS(uint64 instruction, Dis_info *info)
5499 {
5500 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5501 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5502 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5503 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5504
5505 const char *rt = GPR(rt_value, info);
5506 const char *rs = GPR(rs_value, info);
5507 /* !!!!!!!!!! - no conversion function */
5508
5509 return img_format("DINS %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5510 rt, rs, lsb_value, msbd_value);
5511 /* hand edited */
5512 }
5513
5514
5515 /*
5516 *
5517 *
5518 * 3 2 1
5519 * 10987654321098765432109876543210
5520 * 001000 x1110000101
5521 * rt -----
5522 * rs -----
5523 * rd -----
5524 */
5525 static char *DINSU(uint64 instruction, Dis_info *info)
5526 {
5527 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5528 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5529 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5530 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5531
5532 const char *rt = GPR(rt_value, info);
5533 const char *rs = GPR(rs_value, info);
5534 /* !!!!!!!!!! - no conversion function */
5535
5536 return img_format("DINSU %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5537 rt, rs, lsb_value, msbd_value);
5538 /* hand edited */
5539 }
5540
5541
5542 /*
5543 *
5544 *
5545 * 3 2 1
5546 * 10987654321098765432109876543210
5547 * 001000 x1110000101
5548 * rt -----
5549 * rs -----
5550 * rd -----
5551 */
5552 static char *DI(uint64 instruction, Dis_info *info)
5553 {
5554 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5555
5556 const char *rt = GPR(rt_value, info);
5557
5558 return img_format("DI %s", rt);
5559 }
5560
5561
5562 /*
5563 *
5564 *
5565 * 3 2 1
5566 * 10987654321098765432109876543210
5567 * 001000 x1110000101
5568 * rt -----
5569 * rs -----
5570 * rd -----
5571 */
5572 static char *DIV(uint64 instruction, Dis_info *info)
5573 {
5574 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5575 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5576 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5577
5578 const char *rd = GPR(rd_value, info);
5579 const char *rs = GPR(rs_value, info);
5580 const char *rt = GPR(rt_value, info);
5581
5582 return img_format("DIV %s, %s, %s", rd, rs, rt);
5583 }
5584
5585
5586 /*
5587 *
5588 *
5589 * 3 2 1
5590 * 10987654321098765432109876543210
5591 * 001000 x1110000101
5592 * rt -----
5593 * rs -----
5594 * rd -----
5595 */
5596 static char *DIV_D(uint64 instruction, Dis_info *info)
5597 {
5598 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5599 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5600 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5601
5602 const char *fd = FPR(fd_value, info);
5603 const char *fs = FPR(fs_value, info);
5604 const char *ft = FPR(ft_value, info);
5605
5606 return img_format("DIV.D %s, %s, %s", fd, fs, ft);
5607 }
5608
5609
5610 /*
5611 *
5612 *
5613 * 3 2 1
5614 * 10987654321098765432109876543210
5615 * 001000 x1110000101
5616 * rt -----
5617 * rs -----
5618 * rd -----
5619 */
5620 static char *DIV_S(uint64 instruction, Dis_info *info)
5621 {
5622 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5623 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5624 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5625
5626 const char *fd = FPR(fd_value, info);
5627 const char *fs = FPR(fs_value, info);
5628 const char *ft = FPR(ft_value, info);
5629
5630 return img_format("DIV.S %s, %s, %s", fd, fs, ft);
5631 }
5632
5633
5634 /*
5635 *
5636 *
5637 * 3 2 1
5638 * 10987654321098765432109876543210
5639 * 001000 x1110000101
5640 * rt -----
5641 * rs -----
5642 * rd -----
5643 */
5644 static char *DIVU(uint64 instruction, Dis_info *info)
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 const char *rd = GPR(rd_value, info);
5651 const char *rs = GPR(rs_value, info);
5652 const char *rt = GPR(rt_value, info);
5653
5654 return img_format("DIVU %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 static char *DLSA(uint64 instruction, Dis_info *info)
5669 {
5670 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5671 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5672 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5673 uint64 u2_value = extract_u2_10_9(instruction);
5674
5675 const char *rd = GPR(rd_value, info);
5676 const char *rs = GPR(rs_value, info);
5677 const char *rt = GPR(rt_value, info);
5678
5679 return img_format("DLSA %s, %s, %s, 0x%" PRIx64, rd, rs, rt, u2_value);
5680 }
5681
5682
5683 /*
5684 *
5685 *
5686 * 3 2 1
5687 * 10987654321098765432109876543210
5688 * 001000 x1110000101
5689 * rt -----
5690 * rs -----
5691 * rd -----
5692 */
5693 static char *DLUI_48_(uint64 instruction, Dis_info *info)
5694 {
5695 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5696 uint64 u_value = extract_u_31_to_0__s32(instruction);
5697
5698 const char *rt = GPR(rt_value, info);
5699
5700 return img_format("DLUI %s, 0x%" PRIx64, rt, u_value);
5701 }
5702
5703
5704 /*
5705 *
5706 *
5707 * 3 2 1
5708 * 10987654321098765432109876543210
5709 * 001000 x1110000101
5710 * rt -----
5711 * rs -----
5712 * rd -----
5713 */
5714 static char *DMFC0(uint64 instruction, Dis_info *info)
5715 {
5716 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5717 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5718 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5719
5720 const char *rt = GPR(rt_value, info);
5721
5722 return img_format("DMFC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5723 rt, c0s_value, sel_value);
5724 }
5725
5726
5727 /*
5728 *
5729 *
5730 * 3 2 1
5731 * 10987654321098765432109876543210
5732 * 001000 x1110000101
5733 * rt -----
5734 * rs -----
5735 * rd -----
5736 */
5737 static char *DMFC1(uint64 instruction, Dis_info *info)
5738 {
5739 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5740 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5741
5742 const char *rt = GPR(rt_value, info);
5743 const char *fs = FPR(fs_value, info);
5744
5745 return img_format("DMFC1 %s, %s", rt, fs);
5746 }
5747
5748
5749 /*
5750 *
5751 *
5752 * 3 2 1
5753 * 10987654321098765432109876543210
5754 * 001000 x1110000101
5755 * rt -----
5756 * rs -----
5757 * rd -----
5758 */
5759 static char *DMFC2(uint64 instruction, Dis_info *info)
5760 {
5761 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5762 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5763
5764 const char *rt = GPR(rt_value, info);
5765
5766 return img_format("DMFC2 %s, CP%" PRIu64, rt, cs_value);
5767 }
5768
5769
5770 /*
5771 *
5772 *
5773 * 3 2 1
5774 * 10987654321098765432109876543210
5775 * 001000 x1110000101
5776 * rt -----
5777 * rs -----
5778 * rd -----
5779 */
5780 static char *DMFGC0(uint64 instruction, Dis_info *info)
5781 {
5782 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5783 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5784 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5785
5786 const char *rt = GPR(rt_value, info);
5787
5788 return img_format("DMFGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5789 rt, c0s_value, sel_value);
5790 }
5791
5792
5793 /*
5794 *
5795 *
5796 * 3 2 1
5797 * 10987654321098765432109876543210
5798 * 001000 x1110000101
5799 * rt -----
5800 * rs -----
5801 * rd -----
5802 */
5803 static char *DMOD(uint64 instruction, Dis_info *info)
5804 {
5805 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5806 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5807 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5808
5809 const char *rd = GPR(rd_value, info);
5810 const char *rs = GPR(rs_value, info);
5811 const char *rt = GPR(rt_value, info);
5812
5813 return img_format("DMOD %s, %s, %s", rd, rs, rt);
5814 }
5815
5816
5817 /*
5818 *
5819 *
5820 * 3 2 1
5821 * 10987654321098765432109876543210
5822 * 001000 x1110000101
5823 * rt -----
5824 * rs -----
5825 * rd -----
5826 */
5827 static char *DMODU(uint64 instruction, Dis_info *info)
5828 {
5829 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5830 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5831 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5832
5833 const char *rd = GPR(rd_value, info);
5834 const char *rs = GPR(rs_value, info);
5835 const char *rt = GPR(rt_value, info);
5836
5837 return img_format("DMODU %s, %s, %s", rd, rs, rt);
5838 }
5839
5840
5841 /*
5842 *
5843 *
5844 * 3 2 1
5845 * 10987654321098765432109876543210
5846 * 001000 x1110000101
5847 * rt -----
5848 * rs -----
5849 * rd -----
5850 */
5851 static char *DMTC0(uint64 instruction, Dis_info *info)
5852 {
5853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5854 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5855 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5856
5857 const char *rt = GPR(rt_value, info);
5858
5859 return img_format("DMTC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5860 rt, c0s_value, sel_value);
5861 }
5862
5863
5864 /*
5865 *
5866 *
5867 * 3 2 1
5868 * 10987654321098765432109876543210
5869 * 001000 x1110000101
5870 * rt -----
5871 * rs -----
5872 * rd -----
5873 */
5874 static char *DMTC1(uint64 instruction, Dis_info *info)
5875 {
5876 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5877 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5878
5879 const char *rt = GPR(rt_value, info);
5880 const char *fs = FPR(fs_value, info);
5881
5882 return img_format("DMTC1 %s, %s", rt, fs);
5883 }
5884
5885
5886 /*
5887 *
5888 *
5889 * 3 2 1
5890 * 10987654321098765432109876543210
5891 * 001000 x1110000101
5892 * rt -----
5893 * rs -----
5894 * rd -----
5895 */
5896 static char *DMTC2(uint64 instruction, Dis_info *info)
5897 {
5898 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5899 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5900
5901 const char *rt = GPR(rt_value, info);
5902
5903 return img_format("DMTC2 %s, CP%" PRIu64, rt, cs_value);
5904 }
5905
5906
5907 /*
5908 *
5909 *
5910 * 3 2 1
5911 * 10987654321098765432109876543210
5912 * 001000 x1110000101
5913 * rt -----
5914 * rs -----
5915 * rd -----
5916 */
5917 static char *DMTGC0(uint64 instruction, Dis_info *info)
5918 {
5919 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5920 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5921 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5922
5923 const char *rt = GPR(rt_value, info);
5924
5925 return img_format("DMTGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5926 rt, c0s_value, sel_value);
5927 }
5928
5929
5930 /*
5931 *
5932 *
5933 * 3 2 1
5934 * 10987654321098765432109876543210
5935 * 001000 x1110000101
5936 * rt -----
5937 * rs -----
5938 * rd -----
5939 */
5940 static char *DMT(uint64 instruction, Dis_info *info)
5941 {
5942 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5943
5944 const char *rt = GPR(rt_value, info);
5945
5946 return img_format("DMT %s", rt);
5947 }
5948
5949
5950 /*
5951 *
5952 *
5953 * 3 2 1
5954 * 10987654321098765432109876543210
5955 * 001000 x1110000101
5956 * rt -----
5957 * rs -----
5958 * rd -----
5959 */
5960 static char *DMUH(uint64 instruction, Dis_info *info)
5961 {
5962 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5963 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5964 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5965
5966 const char *rd = GPR(rd_value, info);
5967 const char *rs = GPR(rs_value, info);
5968 const char *rt = GPR(rt_value, info);
5969
5970 return img_format("DMUH %s, %s, %s", rd, rs, rt);
5971 }
5972
5973
5974 /*
5975 *
5976 *
5977 * 3 2 1
5978 * 10987654321098765432109876543210
5979 * 001000 x1110000101
5980 * rt -----
5981 * rs -----
5982 * rd -----
5983 */
5984 static char *DMUHU(uint64 instruction, Dis_info *info)
5985 {
5986 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5987 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5988 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5989
5990 const char *rd = GPR(rd_value, info);
5991 const char *rs = GPR(rs_value, info);
5992 const char *rt = GPR(rt_value, info);
5993
5994 return img_format("DMUHU %s, %s, %s", rd, rs, rt);
5995 }
5996
5997
5998 /*
5999 *
6000 *
6001 * 3 2 1
6002 * 10987654321098765432109876543210
6003 * 001000 x1110000101
6004 * rt -----
6005 * rs -----
6006 * rd -----
6007 */
6008 static char *DMUL(uint64 instruction, Dis_info *info)
6009 {
6010 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6011 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6012 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6013
6014 const char *rd = GPR(rd_value, info);
6015 const char *rs = GPR(rs_value, info);
6016 const char *rt = GPR(rt_value, info);
6017
6018 return img_format("DMUL %s, %s, %s", rd, rs, rt);
6019 }
6020
6021
6022 /*
6023 *
6024 *
6025 * 3 2 1
6026 * 10987654321098765432109876543210
6027 * 001000 x1110000101
6028 * rt -----
6029 * rs -----
6030 * rd -----
6031 */
6032 static char *DMULU(uint64 instruction, Dis_info *info)
6033 {
6034 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6035 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6036 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6037
6038 const char *rd = GPR(rd_value, info);
6039 const char *rs = GPR(rs_value, info);
6040 const char *rt = GPR(rt_value, info);
6041
6042 return img_format("DMULU %s, %s, %s", rd, rs, rt);
6043 }
6044
6045
6046 /*
6047 * [DSP] DPA.W.PH ac, rs, rt - Dot product with accumulate on
6048 * vector integer halfword elements
6049 *
6050 * 3 2 1
6051 * 10987654321098765432109876543210
6052 * 001000 00000010111111
6053 * rt -----
6054 * rs -----
6055 * ac --
6056 */
6057 static char *DPA_W_PH(uint64 instruction, Dis_info *info)
6058 {
6059 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6060 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6061 uint64 ac_value = extract_ac_15_14(instruction);
6062
6063 const char *ac = AC(ac_value, info);
6064 const char *rs = GPR(rs_value, info);
6065 const char *rt = GPR(rt_value, info);
6066
6067 return img_format("DPA.W.PH %s, %s, %s", ac, rs, rt);
6068 }
6069
6070
6071 /*
6072 *
6073 *
6074 * 3 2 1
6075 * 10987654321098765432109876543210
6076 * 001000 x1110000101
6077 * rt -----
6078 * rs -----
6079 * rd -----
6080 */
6081 static char *DPAQ_SA_L_W(uint64 instruction, Dis_info *info)
6082 {
6083 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6084 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6085 uint64 ac_value = extract_ac_15_14(instruction);
6086
6087 const char *ac = AC(ac_value, info);
6088 const char *rs = GPR(rs_value, info);
6089 const char *rt = GPR(rt_value, info);
6090
6091 return img_format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
6092 }
6093
6094
6095 /*
6096 *
6097 *
6098 * 3 2 1
6099 * 10987654321098765432109876543210
6100 * 001000 x1110000101
6101 * rt -----
6102 * rs -----
6103 * rd -----
6104 */
6105 static char *DPAQ_S_W_PH(uint64 instruction, Dis_info *info)
6106 {
6107 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6108 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6109 uint64 ac_value = extract_ac_15_14(instruction);
6110
6111 const char *ac = AC(ac_value, info);
6112 const char *rs = GPR(rs_value, info);
6113 const char *rt = GPR(rt_value, info);
6114
6115 return img_format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
6116 }
6117
6118
6119 /*
6120 *
6121 *
6122 * 3 2 1
6123 * 10987654321098765432109876543210
6124 * 001000 x1110000101
6125 * rt -----
6126 * rs -----
6127 * rd -----
6128 */
6129 static char *DPAQX_SA_W_PH(uint64 instruction, Dis_info *info)
6130 {
6131 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6132 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6133 uint64 ac_value = extract_ac_15_14(instruction);
6134
6135 const char *ac = AC(ac_value, info);
6136 const char *rs = GPR(rs_value, info);
6137 const char *rt = GPR(rt_value, info);
6138
6139 return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6140 }
6141
6142
6143 /*
6144 *
6145 *
6146 * 3 2 1
6147 * 10987654321098765432109876543210
6148 * 001000 x1110000101
6149 * rt -----
6150 * rs -----
6151 * rd -----
6152 */
6153 static char *DPAQX_S_W_PH(uint64 instruction, Dis_info *info)
6154 {
6155 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6156 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6157 uint64 ac_value = extract_ac_15_14(instruction);
6158
6159 const char *ac = AC(ac_value, info);
6160 const char *rs = GPR(rs_value, info);
6161 const char *rt = GPR(rt_value, info);
6162
6163 return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6164 }
6165
6166
6167 /*
6168 *
6169 *
6170 * 3 2 1
6171 * 10987654321098765432109876543210
6172 * 001000 x1110000101
6173 * rt -----
6174 * rs -----
6175 * rd -----
6176 */
6177 static char *DPAU_H_QBL(uint64 instruction, Dis_info *info)
6178 {
6179 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6180 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6181 uint64 ac_value = extract_ac_15_14(instruction);
6182
6183 const char *ac = AC(ac_value, info);
6184 const char *rs = GPR(rs_value, info);
6185 const char *rt = GPR(rt_value, info);
6186
6187 return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6188 }
6189
6190
6191 /*
6192 *
6193 *
6194 * 3 2 1
6195 * 10987654321098765432109876543210
6196 * 001000 x1110000101
6197 * rt -----
6198 * rs -----
6199 * rd -----
6200 */
6201 static char *DPAU_H_QBR(uint64 instruction, Dis_info *info)
6202 {
6203 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6204 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6205 uint64 ac_value = extract_ac_15_14(instruction);
6206
6207 const char *ac = AC(ac_value, info);
6208 const char *rs = GPR(rs_value, info);
6209 const char *rt = GPR(rt_value, info);
6210
6211 return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6212 }
6213
6214
6215 /*
6216 *
6217 *
6218 * 3 2 1
6219 * 10987654321098765432109876543210
6220 * 001000 x1110000101
6221 * rt -----
6222 * rs -----
6223 * rd -----
6224 */
6225 static char *DPAX_W_PH(uint64 instruction, Dis_info *info)
6226 {
6227 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6228 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6229 uint64 ac_value = extract_ac_15_14(instruction);
6230
6231 const char *ac = AC(ac_value, info);
6232 const char *rs = GPR(rs_value, info);
6233 const char *rt = GPR(rt_value, info);
6234
6235 return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6236 }
6237
6238
6239 /*
6240 *
6241 *
6242 * 3 2 1
6243 * 10987654321098765432109876543210
6244 * 001000 x1110000101
6245 * rt -----
6246 * rs -----
6247 * rd -----
6248 */
6249 static char *DPS_W_PH(uint64 instruction, Dis_info *info)
6250 {
6251 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6252 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6253 uint64 ac_value = extract_ac_15_14(instruction);
6254
6255 const char *ac = AC(ac_value, info);
6256 const char *rs = GPR(rs_value, info);
6257 const char *rt = GPR(rt_value, info);
6258
6259 return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6260 }
6261
6262
6263 /*
6264 *
6265 *
6266 * 3 2 1
6267 * 10987654321098765432109876543210
6268 * 001000 x1110000101
6269 * rt -----
6270 * rs -----
6271 * rd -----
6272 */
6273 static char *DPSQ_SA_L_W(uint64 instruction, Dis_info *info)
6274 {
6275 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6276 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6277 uint64 ac_value = extract_ac_15_14(instruction);
6278
6279 const char *ac = AC(ac_value, info);
6280 const char *rs = GPR(rs_value, info);
6281 const char *rt = GPR(rt_value, info);
6282
6283 return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6284 }
6285
6286
6287 /*
6288 *
6289 *
6290 * 3 2 1
6291 * 10987654321098765432109876543210
6292 * 001000 x1110000101
6293 * rt -----
6294 * rs -----
6295 * rd -----
6296 */
6297 static char *DPSQ_S_W_PH(uint64 instruction, Dis_info *info)
6298 {
6299 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6300 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6301 uint64 ac_value = extract_ac_15_14(instruction);
6302
6303 const char *ac = AC(ac_value, info);
6304 const char *rs = GPR(rs_value, info);
6305 const char *rt = GPR(rt_value, info);
6306
6307 return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6308 }
6309
6310
6311 /*
6312 *
6313 *
6314 * 3 2 1
6315 * 10987654321098765432109876543210
6316 * 001000 x1110000101
6317 * rt -----
6318 * rs -----
6319 * rd -----
6320 */
6321 static char *DPSQX_SA_W_PH(uint64 instruction, Dis_info *info)
6322 {
6323 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6324 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6325 uint64 ac_value = extract_ac_15_14(instruction);
6326
6327 const char *ac = AC(ac_value, info);
6328 const char *rs = GPR(rs_value, info);
6329 const char *rt = GPR(rt_value, info);
6330
6331 return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6332 }
6333
6334
6335 /*
6336 *
6337 *
6338 * 3 2 1
6339 * 10987654321098765432109876543210
6340 * 001000 x1110000101
6341 * rt -----
6342 * rs -----
6343 * rd -----
6344 */
6345 static char *DPSQX_S_W_PH(uint64 instruction, Dis_info *info)
6346 {
6347 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6348 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6349 uint64 ac_value = extract_ac_15_14(instruction);
6350
6351 const char *ac = AC(ac_value, info);
6352 const char *rs = GPR(rs_value, info);
6353 const char *rt = GPR(rt_value, info);
6354
6355 return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6356 }
6357
6358
6359 /*
6360 *
6361 *
6362 * 3 2 1
6363 * 10987654321098765432109876543210
6364 * 001000 x1110000101
6365 * rt -----
6366 * rs -----
6367 * rd -----
6368 */
6369 static char *DPSU_H_QBL(uint64 instruction, Dis_info *info)
6370 {
6371 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6372 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6373 uint64 ac_value = extract_ac_15_14(instruction);
6374
6375 const char *ac = AC(ac_value, info);
6376 const char *rs = GPR(rs_value, info);
6377 const char *rt = GPR(rt_value, info);
6378
6379 return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6380 }
6381
6382
6383 /*
6384 *
6385 *
6386 * 3 2 1
6387 * 10987654321098765432109876543210
6388 * 001000 x1110000101
6389 * rt -----
6390 * rs -----
6391 * rd -----
6392 */
6393 static char *DPSU_H_QBR(uint64 instruction, Dis_info *info)
6394 {
6395 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6396 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6397 uint64 ac_value = extract_ac_15_14(instruction);
6398
6399 const char *ac = AC(ac_value, info);
6400 const char *rs = GPR(rs_value, info);
6401 const char *rt = GPR(rt_value, info);
6402
6403 return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6404 }
6405
6406
6407 /*
6408 *
6409 *
6410 * 3 2 1
6411 * 10987654321098765432109876543210
6412 * 001000 x1110000101
6413 * rt -----
6414 * rs -----
6415 * rd -----
6416 */
6417 static char *DPSX_W_PH(uint64 instruction, Dis_info *info)
6418 {
6419 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6420 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6421 uint64 ac_value = extract_ac_15_14(instruction);
6422
6423 const char *ac = AC(ac_value, info);
6424 const char *rs = GPR(rs_value, info);
6425 const char *rt = GPR(rt_value, info);
6426
6427 return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6428 }
6429
6430
6431 /*
6432 * DROTR -
6433 *
6434 * 3 2 1
6435 * 10987654321098765432109876543210
6436 * 001000 x1110000101
6437 * rt -----
6438 * rs -----
6439 * rd -----
6440 */
6441 static char *DROTR(uint64 instruction, Dis_info *info)
6442 {
6443 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6444 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6445 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6446
6447 const char *rt = GPR(rt_value, info);
6448 const char *rs = GPR(rs_value, info);
6449
6450 return img_format("DROTR %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6451 }
6452
6453
6454 /*
6455 * DROTR[32] -
6456 *
6457 * 3 2 1
6458 * 10987654321098765432109876543210
6459 * 10o000 1100xxx0110
6460 * rt -----
6461 * rs -----
6462 * shift -----
6463 */
6464 static char *DROTR32(uint64 instruction, Dis_info *info)
6465 {
6466 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6467 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6468 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6469
6470 const char *rt = GPR(rt_value, info);
6471 const char *rs = GPR(rs_value, info);
6472
6473 return img_format("DROTR32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6474 }
6475
6476
6477 /*
6478 *
6479 *
6480 * 3 2 1
6481 * 10987654321098765432109876543210
6482 * 001000 x1110000101
6483 * rt -----
6484 * rs -----
6485 * rd -----
6486 */
6487 static char *DROTRV(uint64 instruction, Dis_info *info)
6488 {
6489 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6490 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6491 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6492
6493 const char *rd = GPR(rd_value, info);
6494 const char *rs = GPR(rs_value, info);
6495 const char *rt = GPR(rt_value, info);
6496
6497 return img_format("DROTRV %s, %s, %s", rd, rs, rt);
6498 }
6499
6500
6501 /*
6502 *
6503 *
6504 * 3 2 1
6505 * 10987654321098765432109876543210
6506 * 001000 x1110000101
6507 * rt -----
6508 * rs -----
6509 * rd -----
6510 */
6511 static char *DROTX(uint64 instruction, Dis_info *info)
6512 {
6513 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6514 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6515 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6516 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6517
6518 const char *rt = GPR(rt_value, info);
6519 const char *rs = GPR(rs_value, info);
6520
6521 return img_format("DROTX %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
6522 rt, rs, shift_value, shiftx_value);
6523 }
6524
6525
6526 /*
6527 * DSLL -
6528 *
6529 * 3 2 1
6530 * 10987654321098765432109876543210
6531 * 10o000 1100xxx0000
6532 * rt -----
6533 * rs -----
6534 * shift -----
6535 */
6536 static char *DSLL(uint64 instruction, Dis_info *info)
6537 {
6538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6539 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6540 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6541
6542 const char *rt = GPR(rt_value, info);
6543 const char *rs = GPR(rs_value, info);
6544
6545 return img_format("DSLL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6546 }
6547
6548
6549 /*
6550 * DSLL[32] -
6551 *
6552 * 3 2 1
6553 * 10987654321098765432109876543210
6554 * 10o000 1100xxx0000
6555 * rt -----
6556 * rs -----
6557 * shift -----
6558 */
6559 static char *DSLL32(uint64 instruction, Dis_info *info)
6560 {
6561 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6562 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6563 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6564
6565 const char *rt = GPR(rt_value, info);
6566 const char *rs = GPR(rs_value, info);
6567
6568 return img_format("DSLL32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6569 }
6570
6571
6572 /*
6573 *
6574 *
6575 * 3 2 1
6576 * 10987654321098765432109876543210
6577 * 001000 x1110000101
6578 * rt -----
6579 * rs -----
6580 * rd -----
6581 */
6582 static char *DSLLV(uint64 instruction, Dis_info *info)
6583 {
6584 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6585 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6586 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6587
6588 const char *rd = GPR(rd_value, info);
6589 const char *rs = GPR(rs_value, info);
6590 const char *rt = GPR(rt_value, info);
6591
6592 return img_format("DSLLV %s, %s, %s", rd, rs, rt);
6593 }
6594
6595
6596 /*
6597 * DSRA -
6598 *
6599 * 3 2 1
6600 * 10987654321098765432109876543210
6601 * 10o000 1100xxx0100
6602 * rt -----
6603 * rs -----
6604 * shift -----
6605 */
6606 static char *DSRA(uint64 instruction, Dis_info *info)
6607 {
6608 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6609 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6610 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6611
6612 const char *rt = GPR(rt_value, info);
6613 const char *rs = GPR(rs_value, info);
6614
6615 return img_format("DSRA %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6616 }
6617
6618
6619 /*
6620 * DSRA[32] -
6621 *
6622 * 3 2 1
6623 * 10987654321098765432109876543210
6624 * 10o000 1100xxx0100
6625 * rt -----
6626 * rs -----
6627 * shift -----
6628 */
6629 static char *DSRA32(uint64 instruction, Dis_info *info)
6630 {
6631 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6632 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6633 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6634
6635 const char *rt = GPR(rt_value, info);
6636 const char *rs = GPR(rs_value, info);
6637
6638 return img_format("DSRA32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6639 }
6640
6641
6642 /*
6643 *
6644 *
6645 * 3 2 1
6646 * 10987654321098765432109876543210
6647 * 001000 x1110000101
6648 * rt -----
6649 * rs -----
6650 * rd -----
6651 */
6652 static char *DSRAV(uint64 instruction, Dis_info *info)
6653 {
6654 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6655 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6656 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6657
6658 const char *rd = GPR(rd_value, info);
6659 const char *rs = GPR(rs_value, info);
6660 const char *rt = GPR(rt_value, info);
6661
6662 return img_format("DSRAV %s, %s, %s", rd, rs, rt);
6663 }
6664
6665
6666 /*
6667 * DSRL -
6668 *
6669 * 3 2 1
6670 * 10987654321098765432109876543210
6671 * 10o000 1100xxx0100
6672 * rt -----
6673 * rs -----
6674 * shift -----
6675 */
6676 static char *DSRL(uint64 instruction, Dis_info *info)
6677 {
6678 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6679 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6680 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6681
6682 const char *rt = GPR(rt_value, info);
6683 const char *rs = GPR(rs_value, info);
6684
6685 return img_format("DSRL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6686 }
6687
6688
6689 /*
6690 * DSRL[32] -
6691 *
6692 * 3 2 1
6693 * 10987654321098765432109876543210
6694 * 10o000 1100xxx0010
6695 * rt -----
6696 * rs -----
6697 * shift -----
6698 */
6699 static char *DSRL32(uint64 instruction, Dis_info *info)
6700 {
6701 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6702 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6703 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6704
6705 const char *rt = GPR(rt_value, info);
6706 const char *rs = GPR(rs_value, info);
6707
6708 return img_format("DSRL32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6709 }
6710
6711
6712 /*
6713 *
6714 *
6715 * 3 2 1
6716 * 10987654321098765432109876543210
6717 * 001000 x1110000101
6718 * rt -----
6719 * rs -----
6720 * rd -----
6721 */
6722 static char *DSRLV(uint64 instruction, Dis_info *info)
6723 {
6724 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6725 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6726 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6727
6728 const char *rd = GPR(rd_value, info);
6729 const char *rs = GPR(rs_value, info);
6730 const char *rt = GPR(rt_value, info);
6731
6732 return img_format("DSRLV %s, %s, %s", rd, rs, rt);
6733 }
6734
6735
6736 /*
6737 *
6738 *
6739 * 3 2 1
6740 * 10987654321098765432109876543210
6741 * 001000 x1110000101
6742 * rt -----
6743 * rs -----
6744 * rd -----
6745 */
6746 static char *DSUB(uint64 instruction, Dis_info *info)
6747 {
6748 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6749 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6750 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6751
6752 const char *rd = GPR(rd_value, info);
6753 const char *rs = GPR(rs_value, info);
6754 const char *rt = GPR(rt_value, info);
6755
6756 return img_format("DSUB %s, %s, %s", rd, rs, rt);
6757 }
6758
6759
6760 /*
6761 *
6762 *
6763 * 3 2 1
6764 * 10987654321098765432109876543210
6765 * 001000 x1110000101
6766 * rt -----
6767 * rs -----
6768 * rd -----
6769 */
6770 static char *DSUBU(uint64 instruction, Dis_info *info)
6771 {
6772 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6773 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6774 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6775
6776 const char *rd = GPR(rd_value, info);
6777 const char *rs = GPR(rs_value, info);
6778 const char *rt = GPR(rt_value, info);
6779
6780 return img_format("DSUBU %s, %s, %s", rd, rs, rt);
6781 }
6782
6783
6784 /*
6785 *
6786 *
6787 * 3 2 1
6788 * 10987654321098765432109876543210
6789 * 001000 x1110000101
6790 * rt -----
6791 * rs -----
6792 * rd -----
6793 */
6794 static char *DVPE(uint64 instruction, Dis_info *info)
6795 {
6796 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6797
6798 const char *rt = GPR(rt_value, info);
6799
6800 return img_format("DVPE %s", rt);
6801 }
6802
6803
6804 /*
6805 *
6806 *
6807 * 3 2 1
6808 * 10987654321098765432109876543210
6809 * 001000 x1110000101
6810 * rt -----
6811 * rs -----
6812 * rd -----
6813 */
6814 static char *DVP(uint64 instruction, Dis_info *info)
6815 {
6816 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6817
6818 const char *rt = GPR(rt_value, info);
6819
6820 return img_format("DVP %s", rt);
6821 }
6822
6823
6824 /*
6825 *
6826 *
6827 * 3 2 1
6828 * 10987654321098765432109876543210
6829 * 001000 x1110000101
6830 * rt -----
6831 * rs -----
6832 * rd -----
6833 */
6834 static char *EHB(uint64 instruction, Dis_info *info)
6835 {
6836 (void)instruction;
6837
6838 return g_strdup("EHB ");
6839 }
6840
6841
6842 /*
6843 *
6844 *
6845 * 3 2 1
6846 * 10987654321098765432109876543210
6847 * 001000 x1110000101
6848 * rt -----
6849 * rs -----
6850 * rd -----
6851 */
6852 static char *EI(uint64 instruction, Dis_info *info)
6853 {
6854 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6855
6856 const char *rt = GPR(rt_value, info);
6857
6858 return img_format("EI %s", rt);
6859 }
6860
6861
6862 /*
6863 *
6864 *
6865 * 3 2 1
6866 * 10987654321098765432109876543210
6867 * 001000 x1110000101
6868 * rt -----
6869 * rs -----
6870 * rd -----
6871 */
6872 static char *EMT(uint64 instruction, Dis_info *info)
6873 {
6874 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6875
6876 const char *rt = GPR(rt_value, info);
6877
6878 return img_format("EMT %s", rt);
6879 }
6880
6881
6882 /*
6883 *
6884 *
6885 * 3 2 1
6886 * 10987654321098765432109876543210
6887 * 001000 x1110000101
6888 * rt -----
6889 * rs -----
6890 * rd -----
6891 */
6892 static char *ERET(uint64 instruction, Dis_info *info)
6893 {
6894 (void)instruction;
6895
6896 return g_strdup("ERET ");
6897 }
6898
6899
6900 /*
6901 *
6902 *
6903 * 3 2 1
6904 * 10987654321098765432109876543210
6905 * 001000 x1110000101
6906 * rt -----
6907 * rs -----
6908 * rd -----
6909 */
6910 static char *ERETNC(uint64 instruction, Dis_info *info)
6911 {
6912 (void)instruction;
6913
6914 return g_strdup("ERETNC ");
6915 }
6916
6917
6918 /*
6919 *
6920 *
6921 * 3 2 1
6922 * 10987654321098765432109876543210
6923 * 001000 x1110000101
6924 * rt -----
6925 * rs -----
6926 * rd -----
6927 */
6928 static char *EVP(uint64 instruction, Dis_info *info)
6929 {
6930 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6931
6932 const char *rt = GPR(rt_value, info);
6933
6934 return img_format("EVP %s", rt);
6935 }
6936
6937
6938 /*
6939 *
6940 *
6941 * 3 2 1
6942 * 10987654321098765432109876543210
6943 * 001000 x1110000101
6944 * rt -----
6945 * rs -----
6946 * rd -----
6947 */
6948 static char *EVPE(uint64 instruction, Dis_info *info)
6949 {
6950 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6951
6952 const char *rt = GPR(rt_value, info);
6953
6954 return img_format("EVPE %s", rt);
6955 }
6956
6957
6958 /*
6959 *
6960 *
6961 * 3 2 1
6962 * 10987654321098765432109876543210
6963 * 001000 x1110000101
6964 * rt -----
6965 * rs -----
6966 * rd -----
6967 */
6968 static char *EXT(uint64 instruction, Dis_info *info)
6969 {
6970 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6971 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6972 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
6973 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
6974
6975 const char *rt = GPR(rt_value, info);
6976 const char *rs = GPR(rs_value, info);
6977 uint64 msbd = encode_msbd_from_size(msbd_value);
6978
6979 return img_format("EXT %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
6980 rt, rs, lsb_value, msbd);
6981 }
6982
6983
6984 /*
6985 *
6986 *
6987 * 3 2 1
6988 * 10987654321098765432109876543210
6989 * 001000 x1110000101
6990 * rt -----
6991 * rs -----
6992 * rd -----
6993 */
6994 static char *EXTD(uint64 instruction, Dis_info *info)
6995 {
6996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6997 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6998 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6999 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7000
7001 const char *rd = GPR(rd_value, info);
7002 const char *rs = GPR(rs_value, info);
7003 const char *rt = GPR(rt_value, info);
7004
7005 return img_format("EXTD %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
7006 }
7007
7008
7009 /*
7010 *
7011 *
7012 * 3 2 1
7013 * 10987654321098765432109876543210
7014 * 001000 x1110000101
7015 * rt -----
7016 * rs -----
7017 * rd -----
7018 */
7019 static char *EXTD32(uint64 instruction, Dis_info *info)
7020 {
7021 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7022 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7023 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7024 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7025
7026 const char *rd = GPR(rd_value, info);
7027 const char *rs = GPR(rs_value, info);
7028 const char *rt = GPR(rt_value, info);
7029
7030 return img_format("EXTD32 %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
7031 }
7032
7033
7034 /*
7035 *
7036 *
7037 * 3 2 1
7038 * 10987654321098765432109876543210
7039 * 001000 x1110000101
7040 * rt -----
7041 * rs -----
7042 * rd -----
7043 */
7044 static char *EXTPDP(uint64 instruction, Dis_info *info)
7045 {
7046 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7047 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7048 uint64 ac_value = extract_ac_15_14(instruction);
7049
7050 const char *rt = GPR(rt_value, info);
7051 const char *ac = AC(ac_value, info);
7052
7053 return img_format("EXTPDP %s, %s, 0x%" PRIx64, rt, ac, size_value);
7054 }
7055
7056
7057 /*
7058 *
7059 *
7060 * 3 2 1
7061 * 10987654321098765432109876543210
7062 * 001000 x1110000101
7063 * rt -----
7064 * rs -----
7065 * rd -----
7066 */
7067 static char *EXTPDPV(uint64 instruction, Dis_info *info)
7068 {
7069 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7070 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7071 uint64 ac_value = extract_ac_15_14(instruction);
7072
7073 const char *rt = GPR(rt_value, info);
7074 const char *ac = AC(ac_value, info);
7075 const char *rs = GPR(rs_value, info);
7076
7077 return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
7078 }
7079
7080
7081 /*
7082 *
7083 *
7084 * 3 2 1
7085 * 10987654321098765432109876543210
7086 * 001000 x1110000101
7087 * rt -----
7088 * rs -----
7089 * rd -----
7090 */
7091 static char *EXTP(uint64 instruction, Dis_info *info)
7092 {
7093 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7094 uint64 size_value = extract_size_20_19_18_17_16(instruction);
7095 uint64 ac_value = extract_ac_15_14(instruction);
7096
7097 const char *rt = GPR(rt_value, info);
7098 const char *ac = AC(ac_value, info);
7099
7100 return img_format("EXTP %s, %s, 0x%" PRIx64, rt, ac, size_value);
7101 }
7102
7103
7104 /*
7105 *
7106 *
7107 * 3 2 1
7108 * 10987654321098765432109876543210
7109 * 001000 x1110000101
7110 * rt -----
7111 * rs -----
7112 * rd -----
7113 */
7114 static char *EXTPV(uint64 instruction, Dis_info *info)
7115 {
7116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7117 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7118 uint64 ac_value = extract_ac_15_14(instruction);
7119
7120 const char *rt = GPR(rt_value, info);
7121 const char *ac = AC(ac_value, info);
7122 const char *rs = GPR(rs_value, info);
7123
7124 return img_format("EXTPV %s, %s, %s", rt, ac, rs);
7125 }
7126
7127
7128 /*
7129 * [DSP] EXTR_RS.W rt, ac, shift - Extract word value from accumulator to GPR
7130 * with right shift
7131 *
7132 * 3 2 1
7133 * 10987654321098765432109876543210
7134 * 001000 10111001111111
7135 * rt -----
7136 * shift -----
7137 * ac --
7138 */
7139 static char *EXTR_RS_W(uint64 instruction, Dis_info *info)
7140 {
7141 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7142 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7143 uint64 ac_value = extract_ac_15_14(instruction);
7144
7145 const char *rt = GPR(rt_value, info);
7146 const char *ac = AC(ac_value, info);
7147
7148 return img_format("EXTR_RS.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7149 }
7150
7151
7152 /*
7153 * [DSP] EXTR_R.W rt, ac, shift - Extract word value from accumulator to GPR
7154 * with right shift
7155 *
7156 * 3 2 1
7157 * 10987654321098765432109876543210
7158 * 001000 01111001111111
7159 * rt -----
7160 * shift -----
7161 * ac --
7162 */
7163 static char *EXTR_R_W(uint64 instruction, Dis_info *info)
7164 {
7165 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7166 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7167 uint64 ac_value = extract_ac_15_14(instruction);
7168
7169 const char *rt = GPR(rt_value, info);
7170 const char *ac = AC(ac_value, info);
7171
7172 return img_format("EXTR_R.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7173 }
7174
7175
7176 /*
7177 * [DSP] EXTR_S.H rt, ac, shift - Extract halfword value from accumulator
7178 * to GPR with right shift and saturate
7179 *
7180 * 3 2 1
7181 * 10987654321098765432109876543210
7182 * 001000 11111001111111
7183 * rt -----
7184 * shift -----
7185 * ac --
7186 */
7187 static char *EXTR_S_H(uint64 instruction, Dis_info *info)
7188 {
7189 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7190 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7191 uint64 ac_value = extract_ac_15_14(instruction);
7192
7193 const char *rt = GPR(rt_value, info);
7194 const char *ac = AC(ac_value, info);
7195
7196 return img_format("EXTR_S.H %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7197 }
7198
7199
7200 /*
7201 * [DSP] EXTR.W rt, ac, shift - Extract word value from accumulator to GPR
7202 * with right shift
7203 *
7204 * 3 2 1
7205 * 10987654321098765432109876543210
7206 * 001000 00111001111111
7207 * rt -----
7208 * shift -----
7209 * ac --
7210 */
7211 static char *EXTR_W(uint64 instruction, Dis_info *info)
7212 {
7213 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7214 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7215 uint64 ac_value = extract_ac_15_14(instruction);
7216
7217 const char *rt = GPR(rt_value, info);
7218 const char *ac = AC(ac_value, info);
7219
7220 return img_format("EXTR.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7221 }
7222
7223
7224 /*
7225 * [DSP] EXTRV_RS.W rt, ac, rs - Extract word value with variable
7226 * right shift from accumulator to GPR
7227 *
7228 * 3 2 1
7229 * 10987654321098765432109876543210
7230 * 001000 10111010111111
7231 * rt -----
7232 * rs -----
7233 * ac --
7234 */
7235 static char *EXTRV_RS_W(uint64 instruction, Dis_info *info)
7236 {
7237 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7238 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7239 uint64 ac_value = extract_ac_15_14(instruction);
7240
7241 const char *rt = GPR(rt_value, info);
7242 const char *ac = AC(ac_value, info);
7243 const char *rs = GPR(rs_value, info);
7244
7245 return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7246 }
7247
7248
7249 /*
7250 * [DSP] EXTRV_R.W rt, ac, rs - Extract word value with variable
7251 * right shift from accumulator to GPR
7252 *
7253 * 3 2 1
7254 * 10987654321098765432109876543210
7255 * 001000 01111010111111
7256 * rt -----
7257 * rs -----
7258 * ac --
7259 */
7260 static char *EXTRV_R_W(uint64 instruction, Dis_info *info)
7261 {
7262 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7263 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7264 uint64 ac_value = extract_ac_15_14(instruction);
7265
7266 const char *rt = GPR(rt_value, info);
7267 const char *ac = AC(ac_value, info);
7268 const char *rs = GPR(rs_value, info);
7269
7270 return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7271 }
7272
7273
7274 /*
7275 * [DSP] EXTRV_S.H rt, ac, rs - Extract halfword value variable from
7276 * accumulator to GPR with right shift and saturate
7277 *
7278 * 3 2 1
7279 * 10987654321098765432109876543210
7280 * 001000 11111010111111
7281 * rt -----
7282 * rs -----
7283 * ac --
7284 */
7285 static char *EXTRV_S_H(uint64 instruction, Dis_info *info)
7286 {
7287 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7288 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7289 uint64 ac_value = extract_ac_15_14(instruction);
7290
7291 const char *rt = GPR(rt_value, info);
7292 const char *ac = AC(ac_value, info);
7293 const char *rs = GPR(rs_value, info);
7294
7295 return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7296 }
7297
7298
7299 /*
7300 * [DSP] EXTRV.W rt, ac, rs - Extract word value with variable
7301 * right shift from accumulator to GPR
7302 *
7303 * 3 2 1
7304 * 10987654321098765432109876543210
7305 * 001000 00111010111111
7306 * rt -----
7307 * rs -----
7308 * ac --
7309 */
7310 static char *EXTRV_W(uint64 instruction, Dis_info *info)
7311 {
7312 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7313 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7314 uint64 ac_value = extract_ac_15_14(instruction);
7315
7316 const char *rt = GPR(rt_value, info);
7317 const char *ac = AC(ac_value, info);
7318 const char *rs = GPR(rs_value, info);
7319
7320 return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
7321 }
7322
7323
7324 /*
7325 * EXTW - Extract Word
7326 *
7327 * 3 2 1
7328 * 10987654321098765432109876543210
7329 * 001000 011111
7330 * rt -----
7331 * rs -----
7332 * rd -----
7333 * shift -----
7334 */
7335 static char *EXTW(uint64 instruction, Dis_info *info)
7336 {
7337 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7338 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7339 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7340 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7341
7342 const char *rd = GPR(rd_value, info);
7343 const char *rs = GPR(rs_value, info);
7344 const char *rt = GPR(rt_value, info);
7345
7346 return img_format("EXTW %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
7347 }
7348
7349
7350 /*
7351 *
7352 *
7353 * 3 2 1
7354 * 10987654321098765432109876543210
7355 * 001000 x1110000101
7356 * rt -----
7357 * rs -----
7358 * rd -----
7359 */
7360 static char *FLOOR_L_D(uint64 instruction, Dis_info *info)
7361 {
7362 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7363 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7364
7365 const char *ft = FPR(ft_value, info);
7366 const char *fs = FPR(fs_value, info);
7367
7368 return img_format("FLOOR.L.D %s, %s", ft, fs);
7369 }
7370
7371
7372 /*
7373 *
7374 *
7375 * 3 2 1
7376 * 10987654321098765432109876543210
7377 * 001000 x1110000101
7378 * rt -----
7379 * rs -----
7380 * rd -----
7381 */
7382 static char *FLOOR_L_S(uint64 instruction, Dis_info *info)
7383 {
7384 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7385 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7386
7387 const char *ft = FPR(ft_value, info);
7388 const char *fs = FPR(fs_value, info);
7389
7390 return img_format("FLOOR.L.S %s, %s", ft, fs);
7391 }
7392
7393
7394 /*
7395 *
7396 *
7397 * 3 2 1
7398 * 10987654321098765432109876543210
7399 * 001000 x1110000101
7400 * rt -----
7401 * rs -----
7402 * rd -----
7403 */
7404 static char *FLOOR_W_D(uint64 instruction, Dis_info *info)
7405 {
7406 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7407 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7408
7409 const char *ft = FPR(ft_value, info);
7410 const char *fs = FPR(fs_value, info);
7411
7412 return img_format("FLOOR.W.D %s, %s", ft, fs);
7413 }
7414
7415
7416 /*
7417 *
7418 *
7419 * 3 2 1
7420 * 10987654321098765432109876543210
7421 * 001000 x1110000101
7422 * rt -----
7423 * rs -----
7424 * rd -----
7425 */
7426 static char *FLOOR_W_S(uint64 instruction, Dis_info *info)
7427 {
7428 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7429 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7430
7431 const char *ft = FPR(ft_value, info);
7432 const char *fs = FPR(fs_value, info);
7433
7434 return img_format("FLOOR.W.S %s, %s", ft, fs);
7435 }
7436
7437
7438 /*
7439 *
7440 *
7441 * 3 2 1
7442 * 10987654321098765432109876543210
7443 * 001000 x1110000101
7444 * rt -----
7445 * rs -----
7446 * rd -----
7447 */
7448 static char *FORK(uint64 instruction, Dis_info *info)
7449 {
7450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7452 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7453
7454 const char *rd = GPR(rd_value, info);
7455 const char *rs = GPR(rs_value, info);
7456 const char *rt = GPR(rt_value, info);
7457
7458 return img_format("FORK %s, %s, %s", rd, rs, rt);
7459 }
7460
7461
7462 /*
7463 *
7464 *
7465 * 3 2 1
7466 * 10987654321098765432109876543210
7467 * 001000 x1110000101
7468 * rt -----
7469 * rs -----
7470 * rd -----
7471 */
7472 static char *HYPCALL(uint64 instruction, Dis_info *info)
7473 {
7474 uint64 code_value = extract_code_17_to_0(instruction);
7475
7476
7477 return img_format("HYPCALL 0x%" PRIx64, code_value);
7478 }
7479
7480
7481 /*
7482 *
7483 *
7484 * 3 2 1
7485 * 10987654321098765432109876543210
7486 * 001000 x1110000101
7487 * rt -----
7488 * rs -----
7489 * rd -----
7490 */
7491 static char *HYPCALL_16_(uint64 instruction, Dis_info *info)
7492 {
7493 uint64 code_value = extract_code_1_0(instruction);
7494
7495
7496 return img_format("HYPCALL 0x%" PRIx64, code_value);
7497 }
7498
7499
7500 /*
7501 *
7502 *
7503 * 3 2 1
7504 * 10987654321098765432109876543210
7505 * 001000 x1110000101
7506 * rt -----
7507 * rs -----
7508 * rd -----
7509 */
7510 static char *INS(uint64 instruction, Dis_info *info)
7511 {
7512 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7513 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7514 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7515 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7516
7517 const char *rt = GPR(rt_value, info);
7518 const char *rs = GPR(rs_value, info);
7519 /* !!!!!!!!!! - no conversion function */
7520
7521 return img_format("INS %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
7522 rt, rs, lsb_value, msbd_value);
7523 /* hand edited */
7524 }
7525
7526
7527 /*
7528 * [DSP] INSV rt, rs - Insert bit field variable
7529 *
7530 * 3 2 1
7531 * 10987654321098765432109876543210
7532 * 001000 0100000100111111
7533 * rt -----
7534 * rs -----
7535 */
7536 static char *INSV(uint64 instruction, Dis_info *info)
7537 {
7538 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7539 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7540
7541 const char *rt = GPR(rt_value, info);
7542 const char *rs = GPR(rs_value, info);
7543
7544 return img_format("INSV %s, %s", rt, rs);
7545 }
7546
7547
7548 /*
7549 *
7550 *
7551 * 3 2 1
7552 * 10987654321098765432109876543210
7553 * 001000 x1110000101
7554 * rt -----
7555 * rs -----
7556 * rd -----
7557 */
7558 static char *IRET(uint64 instruction, Dis_info *info)
7559 {
7560 (void)instruction;
7561
7562 return g_strdup("IRET ");
7563 }
7564
7565
7566 /*
7567 *
7568 *
7569 * 3 2 1
7570 * 10987654321098765432109876543210
7571 * 001000 x1110000101
7572 * rt -----
7573 * rs -----
7574 * rd -----
7575 */
7576 static char *JALRC_16_(uint64 instruction, Dis_info *info)
7577 {
7578 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7579
7580 const char *rt = GPR(rt_value, info);
7581
7582 return img_format("JALRC $%d, %s", 31, rt);
7583 }
7584
7585
7586 /*
7587 *
7588 *
7589 * 3 2 1
7590 * 10987654321098765432109876543210
7591 * 001000 x1110000101
7592 * rt -----
7593 * rs -----
7594 * rd -----
7595 */
7596 static char *JALRC_32_(uint64 instruction, Dis_info *info)
7597 {
7598 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7600
7601 const char *rt = GPR(rt_value, info);
7602 const char *rs = GPR(rs_value, info);
7603
7604 return img_format("JALRC %s, %s", rt, rs);
7605 }
7606
7607
7608 /*
7609 *
7610 *
7611 * 3 2 1
7612 * 10987654321098765432109876543210
7613 * 001000 x1110000101
7614 * rt -----
7615 * rs -----
7616 * rd -----
7617 */
7618 static char *JALRC_HB(uint64 instruction, Dis_info *info)
7619 {
7620 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7621 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7622
7623 const char *rt = GPR(rt_value, info);
7624 const char *rs = GPR(rs_value, info);
7625
7626 return img_format("JALRC.HB %s, %s", rt, rs);
7627 }
7628
7629
7630 /*
7631 *
7632 *
7633 * 3 2 1
7634 * 10987654321098765432109876543210
7635 * 001000 x1110000101
7636 * rt -----
7637 * rs -----
7638 * rd -----
7639 */
7640 static char *JRC(uint64 instruction, Dis_info *info)
7641 {
7642 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7643
7644 const char *rt = GPR(rt_value, info);
7645
7646 return img_format("JRC %s", rt);
7647 }
7648
7649
7650 /*
7651 *
7652 *
7653 * 3 2 1
7654 * 10987654321098765432109876543210
7655 * 001000 x1110000101
7656 * rt -----
7657 * rs -----
7658 * rd -----
7659 */
7660 static char *LB_16_(uint64 instruction, Dis_info *info)
7661 {
7662 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7663 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7664 uint64 u_value = extract_u_1_0(instruction);
7665
7666 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
7667 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
7668
7669 return img_format("LB %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
7670 }
7671
7672
7673 /*
7674 *
7675 *
7676 * 3 2 1
7677 * 10987654321098765432109876543210
7678 * 001000 x1110000101
7679 * rt -----
7680 * rs -----
7681 * rd -----
7682 */
7683 static char *LB_GP_(uint64 instruction, Dis_info *info)
7684 {
7685 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7686 uint64 u_value = extract_u_17_to_0(instruction);
7687
7688 const char *rt = GPR(rt_value, info);
7689
7690 return img_format("LB %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7691 }
7692
7693
7694 /*
7695 *
7696 *
7697 * 3 2 1
7698 * 10987654321098765432109876543210
7699 * 001000 x1110000101
7700 * rt -----
7701 * rs -----
7702 * rd -----
7703 */
7704 static char *LB_S9_(uint64 instruction, Dis_info *info)
7705 {
7706 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7707 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7708 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7709
7710 const char *rt = GPR(rt_value, info);
7711 const char *rs = GPR(rs_value, info);
7712
7713 return img_format("LB %s, %" PRId64 "(%s)", rt, s_value, rs);
7714 }
7715
7716
7717 /*
7718 *
7719 *
7720 * 3 2 1
7721 * 10987654321098765432109876543210
7722 * 001000 x1110000101
7723 * rt -----
7724 * rs -----
7725 * rd -----
7726 */
7727 static char *LB_U12_(uint64 instruction, Dis_info *info)
7728 {
7729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7730 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7731 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7732
7733 const char *rt = GPR(rt_value, info);
7734 const char *rs = GPR(rs_value, info);
7735
7736 return img_format("LB %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7737 }
7738
7739
7740 /*
7741 *
7742 *
7743 * 3 2 1
7744 * 10987654321098765432109876543210
7745 * 001000 x1110000101
7746 * rt -----
7747 * rs -----
7748 * rd -----
7749 */
7750 static char *LBE(uint64 instruction, Dis_info *info)
7751 {
7752 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7753 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7754 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7755
7756 const char *rt = GPR(rt_value, info);
7757 const char *rs = GPR(rs_value, info);
7758
7759 return img_format("LBE %s, %" PRId64 "(%s)", rt, s_value, rs);
7760 }
7761
7762
7763 /*
7764 *
7765 *
7766 * 3 2 1
7767 * 10987654321098765432109876543210
7768 * 001000 x1110000101
7769 * rt -----
7770 * rs -----
7771 * rd -----
7772 */
7773 static char *LBU_16_(uint64 instruction, Dis_info *info)
7774 {
7775 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7776 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7777 uint64 u_value = extract_u_1_0(instruction);
7778
7779 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
7780 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
7781
7782 return img_format("LBU %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
7783 }
7784
7785
7786 /*
7787 *
7788 *
7789 * 3 2 1
7790 * 10987654321098765432109876543210
7791 * 001000 x1110000101
7792 * rt -----
7793 * rs -----
7794 * rd -----
7795 */
7796 static char *LBU_GP_(uint64 instruction, Dis_info *info)
7797 {
7798 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7799 uint64 u_value = extract_u_17_to_0(instruction);
7800
7801 const char *rt = GPR(rt_value, info);
7802
7803 return img_format("LBU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7804 }
7805
7806
7807 /*
7808 *
7809 *
7810 * 3 2 1
7811 * 10987654321098765432109876543210
7812 * 001000 x1110000101
7813 * rt -----
7814 * rs -----
7815 * rd -----
7816 */
7817 static char *LBU_S9_(uint64 instruction, Dis_info *info)
7818 {
7819 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7820 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7821 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7822
7823 const char *rt = GPR(rt_value, info);
7824 const char *rs = GPR(rs_value, info);
7825
7826 return img_format("LBU %s, %" PRId64 "(%s)", rt, s_value, rs);
7827 }
7828
7829
7830 /*
7831 *
7832 *
7833 * 3 2 1
7834 * 10987654321098765432109876543210
7835 * 001000 x1110000101
7836 * rt -----
7837 * rs -----
7838 * rd -----
7839 */
7840 static char *LBU_U12_(uint64 instruction, Dis_info *info)
7841 {
7842 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7843 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7844 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7845
7846 const char *rt = GPR(rt_value, info);
7847 const char *rs = GPR(rs_value, info);
7848
7849 return img_format("LBU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7850 }
7851
7852
7853 /*
7854 *
7855 *
7856 * 3 2 1
7857 * 10987654321098765432109876543210
7858 * 001000 x1110000101
7859 * rt -----
7860 * rs -----
7861 * rd -----
7862 */
7863 static char *LBUE(uint64 instruction, Dis_info *info)
7864 {
7865 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7866 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7867 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7868
7869 const char *rt = GPR(rt_value, info);
7870 const char *rs = GPR(rs_value, info);
7871
7872 return img_format("LBUE %s, %" PRId64 "(%s)", rt, s_value, rs);
7873 }
7874
7875
7876 /*
7877 *
7878 *
7879 * 3 2 1
7880 * 10987654321098765432109876543210
7881 * 001000 x1110000101
7882 * rt -----
7883 * rs -----
7884 * rd -----
7885 */
7886 static char *LBUX(uint64 instruction, Dis_info *info)
7887 {
7888 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7889 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7890 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7891
7892 const char *rd = GPR(rd_value, info);
7893 const char *rs = GPR(rs_value, info);
7894 const char *rt = GPR(rt_value, info);
7895
7896 return img_format("LBUX %s, %s(%s)", rd, rs, rt);
7897 }
7898
7899
7900 /*
7901 *
7902 *
7903 * 3 2 1
7904 * 10987654321098765432109876543210
7905 * 001000 x1110000101
7906 * rt -----
7907 * rs -----
7908 * rd -----
7909 */
7910 static char *LBX(uint64 instruction, Dis_info *info)
7911 {
7912 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7913 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7914 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7915
7916 const char *rd = GPR(rd_value, info);
7917 const char *rs = GPR(rs_value, info);
7918 const char *rt = GPR(rt_value, info);
7919
7920 return img_format("LBX %s, %s(%s)", rd, rs, rt);
7921 }
7922
7923
7924 /*
7925 *
7926 *
7927 * 3 2 1
7928 * 10987654321098765432109876543210
7929 * 001000 x1110000101
7930 * rt -----
7931 * rs -----
7932 * rd -----
7933 */
7934 static char *LD_GP_(uint64 instruction, Dis_info *info)
7935 {
7936 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7937 uint64 u_value = extract_u_20_to_3__s3(instruction);
7938
7939 const char *rt = GPR(rt_value, info);
7940
7941 return img_format("LD %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7942 }
7943
7944
7945 /*
7946 *
7947 *
7948 * 3 2 1
7949 * 10987654321098765432109876543210
7950 * 001000 x1110000101
7951 * rt -----
7952 * rs -----
7953 * rd -----
7954 */
7955 static char *LD_S9_(uint64 instruction, Dis_info *info)
7956 {
7957 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7958 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7959 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7960
7961 const char *rt = GPR(rt_value, info);
7962 const char *rs = GPR(rs_value, info);
7963
7964 return img_format("LD %s, %" PRId64 "(%s)", rt, s_value, rs);
7965 }
7966
7967
7968 /*
7969 *
7970 *
7971 * 3 2 1
7972 * 10987654321098765432109876543210
7973 * 001000 x1110000101
7974 * rt -----
7975 * rs -----
7976 * rd -----
7977 */
7978 static char *LD_U12_(uint64 instruction, Dis_info *info)
7979 {
7980 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7981 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7982 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7983
7984 const char *rt = GPR(rt_value, info);
7985 const char *rs = GPR(rs_value, info);
7986
7987 return img_format("LD %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7988 }
7989
7990
7991 /*
7992 *
7993 *
7994 * 3 2 1
7995 * 10987654321098765432109876543210
7996 * 001000 x1110000101
7997 * rt -----
7998 * rs -----
7999 * rd -----
8000 */
8001 static char *LDC1_GP_(uint64 instruction, Dis_info *info)
8002 {
8003 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8004 uint64 u_value = extract_u_17_to_2__s2(instruction);
8005
8006 const char *ft = FPR(ft_value, info);
8007
8008 return img_format("LDC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
8009 }
8010
8011
8012 /*
8013 *
8014 *
8015 * 3 2 1
8016 * 10987654321098765432109876543210
8017 * 001000 x1110000101
8018 * rt -----
8019 * rs -----
8020 * rd -----
8021 */
8022 static char *LDC1_S9_(uint64 instruction, Dis_info *info)
8023 {
8024 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8025 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8026 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8027
8028 const char *ft = FPR(ft_value, info);
8029 const char *rs = GPR(rs_value, info);
8030
8031 return img_format("LDC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
8032 }
8033
8034
8035 /*
8036 *
8037 *
8038 * 3 2 1
8039 * 10987654321098765432109876543210
8040 * 001000 x1110000101
8041 * rt -----
8042 * rs -----
8043 * rd -----
8044 */
8045 static char *LDC1_U12_(uint64 instruction, Dis_info *info)
8046 {
8047 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8048 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8049 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8050
8051 const char *ft = FPR(ft_value, info);
8052 const char *rs = GPR(rs_value, info);
8053
8054 return img_format("LDC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
8055 }
8056
8057
8058 /*
8059 *
8060 *
8061 * 3 2 1
8062 * 10987654321098765432109876543210
8063 * 001000 x1110000101
8064 * rt -----
8065 * rs -----
8066 * rd -----
8067 */
8068 static char *LDC1XS(uint64 instruction, Dis_info *info)
8069 {
8070 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8071 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8072 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8073
8074 const char *ft = FPR(ft_value, info);
8075 const char *rs = GPR(rs_value, info);
8076 const char *rt = GPR(rt_value, info);
8077
8078 return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
8079 }
8080
8081
8082 /*
8083 *
8084 *
8085 * 3 2 1
8086 * 10987654321098765432109876543210
8087 * 001000 x1110000101
8088 * rt -----
8089 * rs -----
8090 * rd -----
8091 */
8092 static char *LDC1X(uint64 instruction, Dis_info *info)
8093 {
8094 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8095 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8096 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8097
8098 const char *ft = FPR(ft_value, info);
8099 const char *rs = GPR(rs_value, info);
8100 const char *rt = GPR(rt_value, info);
8101
8102 return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
8103 }
8104
8105
8106 /*
8107 *
8108 *
8109 * 3 2 1
8110 * 10987654321098765432109876543210
8111 * 001000 x1110000101
8112 * rt -----
8113 * rs -----
8114 * rd -----
8115 */
8116 static char *LDC2(uint64 instruction, Dis_info *info)
8117 {
8118 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8119 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8120 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8121
8122 const char *rs = GPR(rs_value, info);
8123
8124 return img_format("LDC2 CP%" PRIu64 ", %" PRId64 "(%s)",
8125 ct_value, s_value, rs);
8126 }
8127
8128
8129 /*
8130 *
8131 *
8132 * 3 2 1
8133 * 10987654321098765432109876543210
8134 * 001000 x1110000101
8135 * rt -----
8136 * rs -----
8137 * rd -----
8138 */
8139 static char *LDM(uint64 instruction, Dis_info *info)
8140 {
8141 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8142 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8143 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8144 uint64 count3_value = extract_count3_14_13_12(instruction);
8145
8146 const char *rt = GPR(rt_value, info);
8147 const char *rs = GPR(rs_value, info);
8148 uint64 count3 = encode_count3_from_count(count3_value);
8149
8150 return img_format("LDM %s, %" PRId64 "(%s), 0x%" PRIx64,
8151 rt, s_value, rs, count3);
8152 }
8153
8154
8155 /*
8156 *
8157 *
8158 * 3 2 1
8159 * 10987654321098765432109876543210
8160 * 001000 x1110000101
8161 * rt -----
8162 * rs -----
8163 * rd -----
8164 */
8165 static char *LDPC_48_(uint64 instruction, Dis_info *info)
8166 {
8167 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8168 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8169
8170 const char *rt = GPR(rt_value, info);
8171 g_autofree char *s = ADDRESS(s_value, 6, info);
8172
8173 return img_format("LDPC %s, %s", rt, s);
8174 }
8175
8176
8177 /*
8178 *
8179 *
8180 * 3 2 1
8181 * 10987654321098765432109876543210
8182 * 001000 x1110000101
8183 * rt -----
8184 * rs -----
8185 * rd -----
8186 */
8187 static char *LDX(uint64 instruction, Dis_info *info)
8188 {
8189 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8190 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8191 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8192
8193 const char *rd = GPR(rd_value, info);
8194 const char *rs = GPR(rs_value, info);
8195 const char *rt = GPR(rt_value, info);
8196
8197 return img_format("LDX %s, %s(%s)", rd, rs, rt);
8198 }
8199
8200
8201 /*
8202 *
8203 *
8204 * 3 2 1
8205 * 10987654321098765432109876543210
8206 * 001000 x1110000101
8207 * rt -----
8208 * rs -----
8209 * rd -----
8210 */
8211 static char *LDXS(uint64 instruction, Dis_info *info)
8212 {
8213 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8214 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8215 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8216
8217 const char *rd = GPR(rd_value, info);
8218 const char *rs = GPR(rs_value, info);
8219 const char *rt = GPR(rt_value, info);
8220
8221 return img_format("LDXS %s, %s(%s)", rd, rs, rt);
8222 }
8223
8224
8225 /*
8226 *
8227 *
8228 * 3 2 1
8229 * 10987654321098765432109876543210
8230 * 001000 x1110000101
8231 * rt -----
8232 * rs -----
8233 * rd -----
8234 */
8235 static char *LH_16_(uint64 instruction, Dis_info *info)
8236 {
8237 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8238 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8239 uint64 u_value = extract_u_2_1__s1(instruction);
8240
8241 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8242 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8243
8244 return img_format("LH %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8245 }
8246
8247
8248 /*
8249 *
8250 *
8251 * 3 2 1
8252 * 10987654321098765432109876543210
8253 * 001000 x1110000101
8254 * rt -----
8255 * rs -----
8256 * rd -----
8257 */
8258 static char *LH_GP_(uint64 instruction, Dis_info *info)
8259 {
8260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8261 uint64 u_value = extract_u_17_to_1__s1(instruction);
8262
8263 const char *rt = GPR(rt_value, info);
8264
8265 return img_format("LH %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8266 }
8267
8268
8269 /*
8270 *
8271 *
8272 * 3 2 1
8273 * 10987654321098765432109876543210
8274 * 001000 x1110000101
8275 * rt -----
8276 * rs -----
8277 * rd -----
8278 */
8279 static char *LH_S9_(uint64 instruction, Dis_info *info)
8280 {
8281 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8282 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8283 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8284
8285 const char *rt = GPR(rt_value, info);
8286 const char *rs = GPR(rs_value, info);
8287
8288 return img_format("LH %s, %" PRId64 "(%s)", rt, s_value, rs);
8289 }
8290
8291
8292 /*
8293 *
8294 *
8295 * 3 2 1
8296 * 10987654321098765432109876543210
8297 * 001000 x1110000101
8298 * rt -----
8299 * rs -----
8300 * rd -----
8301 */
8302 static char *LH_U12_(uint64 instruction, Dis_info *info)
8303 {
8304 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8305 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8306 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8307
8308 const char *rt = GPR(rt_value, info);
8309 const char *rs = GPR(rs_value, info);
8310
8311 return img_format("LH %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8312 }
8313
8314
8315 /*
8316 *
8317 *
8318 * 3 2 1
8319 * 10987654321098765432109876543210
8320 * 001000 x1110000101
8321 * rt -----
8322 * rs -----
8323 * rd -----
8324 */
8325 static char *LHE(uint64 instruction, Dis_info *info)
8326 {
8327 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8328 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8329 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8330
8331 const char *rt = GPR(rt_value, info);
8332 const char *rs = GPR(rs_value, info);
8333
8334 return img_format("LHE %s, %" PRId64 "(%s)", rt, s_value, rs);
8335 }
8336
8337
8338 /*
8339 *
8340 *
8341 * 3 2 1
8342 * 10987654321098765432109876543210
8343 * 001000 x1110000101
8344 * rt -----
8345 * rs -----
8346 * rd -----
8347 */
8348 static char *LHU_16_(uint64 instruction, Dis_info *info)
8349 {
8350 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8351 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8352 uint64 u_value = extract_u_2_1__s1(instruction);
8353
8354 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8355 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8356
8357 return img_format("LHU %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8358 }
8359
8360
8361 /*
8362 *
8363 *
8364 * 3 2 1
8365 * 10987654321098765432109876543210
8366 * 001000 x1110000101
8367 * rt -----
8368 * rs -----
8369 * rd -----
8370 */
8371 static char *LHU_GP_(uint64 instruction, Dis_info *info)
8372 {
8373 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8374 uint64 u_value = extract_u_17_to_1__s1(instruction);
8375
8376 const char *rt = GPR(rt_value, info);
8377
8378 return img_format("LHU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8379 }
8380
8381
8382 /*
8383 *
8384 *
8385 * 3 2 1
8386 * 10987654321098765432109876543210
8387 * 001000 x1110000101
8388 * rt -----
8389 * rs -----
8390 * rd -----
8391 */
8392 static char *LHU_S9_(uint64 instruction, Dis_info *info)
8393 {
8394 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8395 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8396 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8397
8398 const char *rt = GPR(rt_value, info);
8399 const char *rs = GPR(rs_value, info);
8400
8401 return img_format("LHU %s, %" PRId64 "(%s)", rt, s_value, rs);
8402 }
8403
8404
8405 /*
8406 *
8407 *
8408 * 3 2 1
8409 * 10987654321098765432109876543210
8410 * 001000 x1110000101
8411 * rt -----
8412 * rs -----
8413 * rd -----
8414 */
8415 static char *LHU_U12_(uint64 instruction, Dis_info *info)
8416 {
8417 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8418 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8419 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8420
8421 const char *rt = GPR(rt_value, info);
8422 const char *rs = GPR(rs_value, info);
8423
8424 return img_format("LHU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8425 }
8426
8427
8428 /*
8429 *
8430 *
8431 * 3 2 1
8432 * 10987654321098765432109876543210
8433 * 001000 x1110000101
8434 * rt -----
8435 * rs -----
8436 * rd -----
8437 */
8438 static char *LHUE(uint64 instruction, Dis_info *info)
8439 {
8440 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8441 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8442 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8443
8444 const char *rt = GPR(rt_value, info);
8445 const char *rs = GPR(rs_value, info);
8446
8447 return img_format("LHUE %s, %" PRId64 "(%s)", rt, s_value, rs);
8448 }
8449
8450
8451 /*
8452 *
8453 *
8454 * 3 2 1
8455 * 10987654321098765432109876543210
8456 * 001000 x1110000101
8457 * rt -----
8458 * rs -----
8459 * rd -----
8460 */
8461 static char *LHUX(uint64 instruction, Dis_info *info)
8462 {
8463 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8464 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8465 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8466
8467 const char *rd = GPR(rd_value, info);
8468 const char *rs = GPR(rs_value, info);
8469 const char *rt = GPR(rt_value, info);
8470
8471 return img_format("LHUX %s, %s(%s)", rd, rs, rt);
8472 }
8473
8474
8475 /*
8476 *
8477 *
8478 * 3 2 1
8479 * 10987654321098765432109876543210
8480 * 001000 x1110000101
8481 * rt -----
8482 * rs -----
8483 * rd -----
8484 */
8485 static char *LHUXS(uint64 instruction, Dis_info *info)
8486 {
8487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8489 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8490
8491 const char *rd = GPR(rd_value, info);
8492 const char *rs = GPR(rs_value, info);
8493 const char *rt = GPR(rt_value, info);
8494
8495 return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
8496 }
8497
8498
8499 /*
8500 *
8501 *
8502 * 3 2 1
8503 * 10987654321098765432109876543210
8504 * 001000 x1110000101
8505 * rt -----
8506 * rs -----
8507 * rd -----
8508 */
8509 static char *LHXS(uint64 instruction, Dis_info *info)
8510 {
8511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8513 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8514
8515 const char *rd = GPR(rd_value, info);
8516 const char *rs = GPR(rs_value, info);
8517 const char *rt = GPR(rt_value, info);
8518
8519 return img_format("LHXS %s, %s(%s)", rd, rs, rt);
8520 }
8521
8522
8523 /*
8524 *
8525 *
8526 * 3 2 1
8527 * 10987654321098765432109876543210
8528 * 001000 x1110000101
8529 * rt -----
8530 * rs -----
8531 * rd -----
8532 */
8533 static char *LHX(uint64 instruction, Dis_info *info)
8534 {
8535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8536 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8537 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8538
8539 const char *rd = GPR(rd_value, info);
8540 const char *rs = GPR(rs_value, info);
8541 const char *rt = GPR(rt_value, info);
8542
8543 return img_format("LHX %s, %s(%s)", rd, rs, rt);
8544 }
8545
8546
8547 /*
8548 *
8549 *
8550 * 3 2 1
8551 * 10987654321098765432109876543210
8552 * 001000 x1110000101
8553 * rt -----
8554 * rs -----
8555 * rd -----
8556 */
8557 static char *LI_16_(uint64 instruction, Dis_info *info)
8558 {
8559 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8560 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8561
8562 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8563 int64 eu = encode_eu_from_s_li16(eu_value);
8564
8565 return img_format("LI %s, %" PRId64, rt3, eu);
8566 }
8567
8568
8569 /*
8570 *
8571 *
8572 * 3 2 1
8573 * 10987654321098765432109876543210
8574 * 001000 x1110000101
8575 * rt -----
8576 * rs -----
8577 * rd -----
8578 */
8579 static char *LI_48_(uint64 instruction, Dis_info *info)
8580 {
8581 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8582 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8583
8584 const char *rt = GPR(rt_value, info);
8585
8586 return img_format("LI %s, %" PRId64, rt, s_value);
8587 }
8588
8589
8590 /*
8591 *
8592 *
8593 * 3 2 1
8594 * 10987654321098765432109876543210
8595 * 001000 x1110000101
8596 * rt -----
8597 * rs -----
8598 * rd -----
8599 */
8600 static char *LL(uint64 instruction, Dis_info *info)
8601 {
8602 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8603 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8604 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8605
8606 const char *rt = GPR(rt_value, info);
8607 const char *rs = GPR(rs_value, info);
8608
8609 return img_format("LL %s, %" PRId64 "(%s)", rt, s_value, rs);
8610 }
8611
8612
8613 /*
8614 *
8615 *
8616 * 3 2 1
8617 * 10987654321098765432109876543210
8618 * 001000 x1110000101
8619 * rt -----
8620 * rs -----
8621 * rd -----
8622 */
8623 static char *LLD(uint64 instruction, Dis_info *info)
8624 {
8625 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8626 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8627 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
8628
8629 const char *rt = GPR(rt_value, info);
8630 const char *rs = GPR(rs_value, info);
8631
8632 return img_format("LLD %s, %" PRId64 "(%s)", rt, s_value, rs);
8633 }
8634
8635
8636 /*
8637 *
8638 *
8639 * 3 2 1
8640 * 10987654321098765432109876543210
8641 * 001000 x1110000101
8642 * rt -----
8643 * rs -----
8644 * rd -----
8645 */
8646 static char *LLDP(uint64 instruction, Dis_info *info)
8647 {
8648 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8649 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8650 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8651
8652 const char *rt = GPR(rt_value, info);
8653 const char *ru = GPR(ru_value, info);
8654 const char *rs = GPR(rs_value, info);
8655
8656 return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
8657 }
8658
8659
8660 /*
8661 *
8662 *
8663 * 3 2 1
8664 * 10987654321098765432109876543210
8665 * 001000 x1110000101
8666 * rt -----
8667 * rs -----
8668 * rd -----
8669 */
8670 static char *LLE(uint64 instruction, Dis_info *info)
8671 {
8672 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8673 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8674 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8675
8676 const char *rt = GPR(rt_value, info);
8677 const char *rs = GPR(rs_value, info);
8678
8679 return img_format("LLE %s, %" PRId64 "(%s)", rt, s_value, rs);
8680 }
8681
8682
8683 /*
8684 *
8685 *
8686 * 3 2 1
8687 * 10987654321098765432109876543210
8688 * 001000 x1110000101
8689 * rt -----
8690 * rs -----
8691 * rd -----
8692 */
8693 static char *LLWP(uint64 instruction, Dis_info *info)
8694 {
8695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8696 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8697 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8698
8699 const char *rt = GPR(rt_value, info);
8700 const char *ru = GPR(ru_value, info);
8701 const char *rs = GPR(rs_value, info);
8702
8703 return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
8704 }
8705
8706
8707 /*
8708 *
8709 *
8710 * 3 2 1
8711 * 10987654321098765432109876543210
8712 * 001000 x1110000101
8713 * rt -----
8714 * rs -----
8715 * rd -----
8716 */
8717 static char *LLWPE(uint64 instruction, Dis_info *info)
8718 {
8719 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8720 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8721 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8722
8723 const char *rt = GPR(rt_value, info);
8724 const char *ru = GPR(ru_value, info);
8725 const char *rs = GPR(rs_value, info);
8726
8727 return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
8728 }
8729
8730
8731 /*
8732 *
8733 *
8734 * 3 2 1
8735 * 10987654321098765432109876543210
8736 * 001000 x1110000101
8737 * rt -----
8738 * rs -----
8739 * rd -----
8740 */
8741 static char *LSA(uint64 instruction, Dis_info *info)
8742 {
8743 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8744 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8745 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8746 uint64 u2_value = extract_u2_10_9(instruction);
8747
8748 const char *rd = GPR(rd_value, info);
8749 const char *rs = GPR(rs_value, info);
8750 const char *rt = GPR(rt_value, info);
8751
8752 return img_format("LSA %s, %s, %s, 0x%" PRIx64, rd, rs, rt, u2_value);
8753 }
8754
8755
8756 /*
8757 *
8758 *
8759 * 3 2 1
8760 * 10987654321098765432109876543210
8761 * 001000 x1110000101
8762 * rt -----
8763 * rs -----
8764 * rd -----
8765 */
8766 static char *LUI(uint64 instruction, Dis_info *info)
8767 {
8768 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8769 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
8770
8771 const char *rt = GPR(rt_value, info);
8772
8773 return img_format("LUI %s, %%hi(%" PRId64 ")", rt, s_value);
8774 }
8775
8776
8777 /*
8778 *
8779 *
8780 * 3 2 1
8781 * 10987654321098765432109876543210
8782 * 001000 x1110000101
8783 * rt -----
8784 * rs -----
8785 * rd -----
8786 */
8787 static char *LW_16_(uint64 instruction, Dis_info *info)
8788 {
8789 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8790 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8791 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
8792
8793 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8794 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8795
8796 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8797 }
8798
8799
8800 /*
8801 *
8802 *
8803 * 3 2 1
8804 * 10987654321098765432109876543210
8805 * 001000 x1110000101
8806 * rt -----
8807 * rs -----
8808 * rd -----
8809 */
8810 static char *LW_4X4_(uint64 instruction, Dis_info *info)
8811 {
8812 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
8813 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
8814 uint64 u_value = extract_u_3_8__s2(instruction);
8815
8816 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
8817 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
8818
8819 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt4, u_value, rs4);
8820 }
8821
8822
8823 /*
8824 *
8825 *
8826 * 3 2 1
8827 * 10987654321098765432109876543210
8828 * 001000 x1110000101
8829 * rt -----
8830 * rs -----
8831 * rd -----
8832 */
8833 static char *LW_GP_(uint64 instruction, Dis_info *info)
8834 {
8835 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8836 uint64 u_value = extract_u_20_to_2__s2(instruction);
8837
8838 const char *rt = GPR(rt_value, info);
8839
8840 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8841 }
8842
8843
8844 /*
8845 *
8846 *
8847 * 3 2 1
8848 * 10987654321098765432109876543210
8849 * 001000 x1110000101
8850 * rt -----
8851 * rs -----
8852 * rd -----
8853 */
8854 static char *LW_GP16_(uint64 instruction, Dis_info *info)
8855 {
8856 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8857 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
8858
8859 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8860
8861 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt3, u_value, 28);
8862 }
8863
8864
8865 /*
8866 *
8867 *
8868 * 3 2 1
8869 * 10987654321098765432109876543210
8870 * 001000 x1110000101
8871 * rt -----
8872 * rs -----
8873 * rd -----
8874 */
8875 static char *LW_S9_(uint64 instruction, Dis_info *info)
8876 {
8877 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8878 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8879 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8880
8881 const char *rt = GPR(rt_value, info);
8882 const char *rs = GPR(rs_value, info);
8883
8884 return img_format("LW %s, %" PRId64 "(%s)", rt, s_value, rs);
8885 }
8886
8887
8888 /*
8889 *
8890 *
8891 * 3 2 1
8892 * 10987654321098765432109876543210
8893 * 001000 x1110000101
8894 * rt -----
8895 * rs -----
8896 * rd -----
8897 */
8898 static char *LW_SP_(uint64 instruction, Dis_info *info)
8899 {
8900 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
8901 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
8902
8903 const char *rt = GPR(rt_value, info);
8904
8905 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt, u_value, 29);
8906 }
8907
8908
8909 /*
8910 *
8911 *
8912 * 3 2 1
8913 * 10987654321098765432109876543210
8914 * 001000 x1110000101
8915 * rt -----
8916 * rs -----
8917 * rd -----
8918 */
8919 static char *LW_U12_(uint64 instruction, Dis_info *info)
8920 {
8921 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8922 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8923 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8924
8925 const char *rt = GPR(rt_value, info);
8926 const char *rs = GPR(rs_value, info);
8927
8928 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8929 }
8930
8931
8932 /*
8933 *
8934 *
8935 * 3 2 1
8936 * 10987654321098765432109876543210
8937 * 001000 x1110000101
8938 * rt -----
8939 * rs -----
8940 * rd -----
8941 */
8942 static char *LWC1_GP_(uint64 instruction, Dis_info *info)
8943 {
8944 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8945 uint64 u_value = extract_u_17_to_2__s2(instruction);
8946
8947 const char *ft = FPR(ft_value, info);
8948
8949 return img_format("LWC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
8950 }
8951
8952
8953 /*
8954 *
8955 *
8956 * 3 2 1
8957 * 10987654321098765432109876543210
8958 * 001000 x1110000101
8959 * rt -----
8960 * rs -----
8961 * rd -----
8962 */
8963 static char *LWC1_S9_(uint64 instruction, Dis_info *info)
8964 {
8965 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8966 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8967 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8968
8969 const char *ft = FPR(ft_value, info);
8970 const char *rs = GPR(rs_value, info);
8971
8972 return img_format("LWC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
8973 }
8974
8975
8976 /*
8977 *
8978 *
8979 * 3 2 1
8980 * 10987654321098765432109876543210
8981 * 001000 x1110000101
8982 * rt -----
8983 * rs -----
8984 * rd -----
8985 */
8986 static char *LWC1_U12_(uint64 instruction, Dis_info *info)
8987 {
8988 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8989 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8990 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8991
8992 const char *ft = FPR(ft_value, info);
8993 const char *rs = GPR(rs_value, info);
8994
8995 return img_format("LWC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
8996 }
8997
8998
8999 /*
9000 *
9001 *
9002 * 3 2 1
9003 * 10987654321098765432109876543210
9004 * 001000 x1110000101
9005 * rt -----
9006 * rs -----
9007 * rd -----
9008 */
9009 static char *LWC1X(uint64 instruction, Dis_info *info)
9010 {
9011 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9012 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9013 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9014
9015 const char *ft = FPR(ft_value, info);
9016 const char *rs = GPR(rs_value, info);
9017 const char *rt = GPR(rt_value, info);
9018
9019 return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
9020 }
9021
9022
9023 /*
9024 *
9025 *
9026 * 3 2 1
9027 * 10987654321098765432109876543210
9028 * 001000 x1110000101
9029 * rt -----
9030 * rs -----
9031 * rd -----
9032 */
9033 static char *LWC1XS(uint64 instruction, Dis_info *info)
9034 {
9035 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9036 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9037 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
9038
9039 const char *ft = FPR(ft_value, info);
9040 const char *rs = GPR(rs_value, info);
9041 const char *rt = GPR(rt_value, info);
9042
9043 return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
9044 }
9045
9046
9047 /*
9048 *
9049 *
9050 * 3 2 1
9051 * 10987654321098765432109876543210
9052 * 001000 x1110000101
9053 * rt -----
9054 * rs -----
9055 * rd -----
9056 */
9057 static char *LWC2(uint64 instruction, Dis_info *info)
9058 {
9059 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
9060 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9061 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9062
9063 const char *rs = GPR(rs_value, info);
9064
9065 return img_format("LWC2 CP%" PRIu64 ", %" PRId64 "(%s)",
9066 ct_value, s_value, rs);
9067 }
9068
9069
9070 /*
9071 *
9072 *
9073 * 3 2 1
9074 * 10987654321098765432109876543210
9075 * 001000 x1110000101
9076 * rt -----
9077 * rs -----
9078 * rd -----
9079 */
9080 static char *LWE(uint64 instruction, Dis_info *info)
9081 {
9082 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9083 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9084 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9085
9086 const char *rt = GPR(rt_value, info);
9087 const char *rs = GPR(rs_value, info);
9088
9089 return img_format("LWE %s, %" PRId64 "(%s)", rt, s_value, rs);
9090 }
9091
9092
9093 /*
9094 *
9095 *
9096 * 3 2 1
9097 * 10987654321098765432109876543210
9098 * 001000 x1110000101
9099 * rt -----
9100 * rs -----
9101 * rd -----
9102 */
9103 static char *LWM(uint64 instruction, Dis_info *info)
9104 {
9105 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9106 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9107 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9108 uint64 count3_value = extract_count3_14_13_12(instruction);
9109
9110 const char *rt = GPR(rt_value, info);
9111 const char *rs = GPR(rs_value, info);
9112 uint64 count3 = encode_count3_from_count(count3_value);
9113
9114 return img_format("LWM %s, %" PRId64 "(%s), 0x%" PRIx64,
9115 rt, s_value, rs, count3);
9116 }
9117
9118
9119 /*
9120 *
9121 *
9122 * 3 2 1
9123 * 10987654321098765432109876543210
9124 * 001000 x1110000101
9125 * rt -----
9126 * rs -----
9127 * rd -----
9128 */
9129 static char *LWPC_48_(uint64 instruction, Dis_info *info)
9130 {
9131 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9132 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
9133
9134 const char *rt = GPR(rt_value, info);
9135 g_autofree char *s = ADDRESS(s_value, 6, info);
9136
9137 return img_format("LWPC %s, %s", rt, s);
9138 }
9139
9140
9141 /*
9142 *
9143 *
9144 * 3 2 1
9145 * 10987654321098765432109876543210
9146 * 001000 x1110000101
9147 * rt -----
9148 * rs -----
9149 * rd -----
9150 */
9151 static char *LWU_GP_(uint64 instruction, Dis_info *info)
9152 {
9153 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9154 uint64 u_value = extract_u_17_to_2__s2(instruction);
9155
9156 const char *rt = GPR(rt_value, info);
9157
9158 return img_format("LWU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
9159 }
9160
9161
9162 /*
9163 *
9164 *
9165 * 3 2 1
9166 * 10987654321098765432109876543210
9167 * 001000 x1110000101
9168 * rt -----
9169 * rs -----
9170 * rd -----
9171 */
9172 static char *LWU_S9_(uint64 instruction, Dis_info *info)
9173 {
9174 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9175 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9176 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9177
9178 const char *rt = GPR(rt_value, info);
9179 const char *rs = GPR(rs_value, info);
9180
9181 return img_format("LWU %s, %" PRId64 "(%s)", rt, s_value, rs);
9182 }
9183
9184
9185 /*
9186 *
9187 *
9188 * 3 2 1
9189 * 10987654321098765432109876543210
9190 * 001000 x1110000101
9191 * rt -----
9192 * rs -----
9193 * rd -----
9194 */
9195 static char *LWU_U12_(uint64 instruction, Dis_info *info)
9196 {
9197 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9198 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9199 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9200
9201 const char *rt = GPR(rt_value, info);
9202 const char *rs = GPR(rs_value, info);
9203
9204 return img_format("LWU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
9205 }
9206
9207
9208 /*
9209 *
9210 *
9211 * 3 2 1
9212 * 10987654321098765432109876543210
9213 * 001000 x1110000101
9214 * rt -----
9215 * rs -----
9216 * rd -----
9217 */
9218 static char *LWUX(uint64 instruction, Dis_info *info)
9219 {
9220 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9221 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9222 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9223
9224 const char *rd = GPR(rd_value, info);
9225 const char *rs = GPR(rs_value, info);
9226 const char *rt = GPR(rt_value, info);
9227
9228 return img_format("LWUX %s, %s(%s)", rd, rs, rt);
9229 }
9230
9231
9232 /*
9233 *
9234 *
9235 * 3 2 1
9236 * 10987654321098765432109876543210
9237 * 001000 x1110000101
9238 * rt -----
9239 * rs -----
9240 * rd -----
9241 */
9242 static char *LWUXS(uint64 instruction, Dis_info *info)
9243 {
9244 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9245 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9246 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9247
9248 const char *rd = GPR(rd_value, info);
9249 const char *rs = GPR(rs_value, info);
9250 const char *rt = GPR(rt_value, info);
9251
9252 return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
9253 }
9254
9255
9256 /*
9257 *
9258 *
9259 * 3 2 1
9260 * 10987654321098765432109876543210
9261 * 001000 x1110000101
9262 * rt -----
9263 * rs -----
9264 * rd -----
9265 */
9266 static char *LWX(uint64 instruction, Dis_info *info)
9267 {
9268 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9269 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9270 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9271
9272 const char *rd = GPR(rd_value, info);
9273 const char *rs = GPR(rs_value, info);
9274 const char *rt = GPR(rt_value, info);
9275
9276 return img_format("LWX %s, %s(%s)", rd, rs, rt);
9277 }
9278
9279
9280 /*
9281 *
9282 *
9283 * 3 2 1
9284 * 10987654321098765432109876543210
9285 * 001000 x1110000101
9286 * rt -----
9287 * rs -----
9288 * rd -----
9289 */
9290 static char *LWXS_16_(uint64 instruction, Dis_info *info)
9291 {
9292 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9293 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9294 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9295
9296 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
9297 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
9298 uint64 rt3 = decode_gpr_gpr3(rt3_value, info);
9299
9300 return img_format("LWXS %s, %s(0x%" PRIx64 ")", rd3, rs3, rt3);
9301 }
9302
9303
9304 /*
9305 *
9306 *
9307 * 3 2 1
9308 * 10987654321098765432109876543210
9309 * 001000 x1110000101
9310 * rt -----
9311 * rs -----
9312 * rd -----
9313 */
9314 static char *LWXS_32_(uint64 instruction, Dis_info *info)
9315 {
9316 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9317 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9318 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9319
9320 const char *rd = GPR(rd_value, info);
9321 const char *rs = GPR(rs_value, info);
9322 const char *rt = GPR(rt_value, info);
9323
9324 return img_format("LWXS %s, %s(%s)", rd, rs, rt);
9325 }
9326
9327
9328 /*
9329 * [DSP] MADD ac, rs, rt - Multiply two words and add to the specified
9330 * accumulator
9331 *
9332 * 3 2 1
9333 * 10987654321098765432109876543210
9334 * 001000 x1110000101
9335 * rt -----
9336 * rs -----
9337 * rd -----
9338 */
9339 static char *MADD_DSP_(uint64 instruction, Dis_info *info)
9340 {
9341 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9342 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9343 uint64 ac_value = extract_ac_15_14(instruction);
9344
9345 const char *ac = AC(ac_value, info);
9346 const char *rs = GPR(rs_value, info);
9347 const char *rt = GPR(rt_value, info);
9348
9349 return img_format("MADD %s, %s, %s", ac, rs, rt);
9350 }
9351
9352
9353 /*
9354 *
9355 *
9356 * 3 2 1
9357 * 10987654321098765432109876543210
9358 * 001000 x1110000101
9359 * rt -----
9360 * rs -----
9361 * rd -----
9362 */
9363 static char *MADDF_D(uint64 instruction, Dis_info *info)
9364 {
9365 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9366 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9367 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9368
9369 const char *fd = FPR(fd_value, info);
9370 const char *fs = FPR(fs_value, info);
9371 const char *ft = FPR(ft_value, info);
9372
9373 return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
9374 }
9375
9376
9377 /*
9378 *
9379 *
9380 * 3 2 1
9381 * 10987654321098765432109876543210
9382 * 001000 x1110000101
9383 * rt -----
9384 * rs -----
9385 * rd -----
9386 */
9387 static char *MADDF_S(uint64 instruction, Dis_info *info)
9388 {
9389 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9390 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9391 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9392
9393 const char *fd = FPR(fd_value, info);
9394 const char *fs = FPR(fs_value, info);
9395 const char *ft = FPR(ft_value, info);
9396
9397 return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
9398 }
9399
9400
9401 /*
9402 * [DSP] MADDU ac, rs, rt - Multiply two unsigned words and add to the
9403 * specified accumulator
9404 *
9405 * 3 2 1
9406 * 10987654321098765432109876543210
9407 * 001000 x1110000101
9408 * rt -----
9409 * rs -----
9410 * rd -----
9411 */
9412 static char *MADDU_DSP_(uint64 instruction, Dis_info *info)
9413 {
9414 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9415 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9416 uint64 ac_value = extract_ac_15_14(instruction);
9417
9418 const char *ac = AC(ac_value, info);
9419 const char *rs = GPR(rs_value, info);
9420 const char *rt = GPR(rt_value, info);
9421
9422 return img_format("MADDU %s, %s, %s", ac, rs, rt);
9423 }
9424
9425
9426 /*
9427 * [DSP] MAQ_S.W.PHL ac, rs, rt - Multiply the left-most single vector
9428 * fractional halfword elements with accumulation
9429 *
9430 * 3 2 1
9431 * 10987654321098765432109876543210
9432 * 001000 x1110000101
9433 * rt -----
9434 * rs -----
9435 * rd -----
9436 */
9437 static char *MAQ_S_W_PHL(uint64 instruction, Dis_info *info)
9438 {
9439 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9440 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9441 uint64 ac_value = extract_ac_15_14(instruction);
9442
9443 const char *ac = AC(ac_value, info);
9444 const char *rs = GPR(rs_value, info);
9445 const char *rt = GPR(rt_value, info);
9446
9447 return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9448 }
9449
9450
9451 /*
9452 * [DSP] MAQ_S.W.PHR ac, rs, rt - Multiply the right-most single vector
9453 * fractional halfword elements with accumulation
9454 *
9455 * 3 2 1
9456 * 10987654321098765432109876543210
9457 * 001000 x1110000101
9458 * rt -----
9459 * rs -----
9460 * rd -----
9461 */
9462 static char *MAQ_S_W_PHR(uint64 instruction, Dis_info *info)
9463 {
9464 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9465 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9466 uint64 ac_value = extract_ac_15_14(instruction);
9467
9468 const char *ac = AC(ac_value, info);
9469 const char *rs = GPR(rs_value, info);
9470 const char *rt = GPR(rt_value, info);
9471
9472 return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9473 }
9474
9475
9476 /*
9477 * [DSP] MAQ_SA.W.PHL ac, rs, rt - Multiply the left-most single vector
9478 * fractional halfword elements with saturating accumulation
9479 *
9480 * 3 2 1
9481 * 10987654321098765432109876543210
9482 * 001000 x1110000101
9483 * rt -----
9484 * rs -----
9485 * rd -----
9486 */
9487 static char *MAQ_SA_W_PHL(uint64 instruction, Dis_info *info)
9488 {
9489 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9490 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9491 uint64 ac_value = extract_ac_15_14(instruction);
9492
9493 const char *ac = AC(ac_value, info);
9494 const char *rs = GPR(rs_value, info);
9495 const char *rt = GPR(rt_value, info);
9496
9497 return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9498 }
9499
9500
9501 /*
9502 * [DSP] MAQ_SA.W.PHR ac, rs, rt - Multiply the right-most single vector
9503 * fractional halfword elements with saturating accumulation
9504 *
9505 * 3 2 1
9506 * 10987654321098765432109876543210
9507 * 001000 x1110000101
9508 * rt -----
9509 * rs -----
9510 * rd -----
9511 */
9512 static char *MAQ_SA_W_PHR(uint64 instruction, Dis_info *info)
9513 {
9514 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9515 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9516 uint64 ac_value = extract_ac_15_14(instruction);
9517
9518 const char *ac = AC(ac_value, info);
9519 const char *rs = GPR(rs_value, info);
9520 const char *rt = GPR(rt_value, info);
9521
9522 return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9523 }
9524
9525
9526 /*
9527 *
9528 *
9529 * 3 2 1
9530 * 10987654321098765432109876543210
9531 * 001000 x1110000101
9532 * rt -----
9533 * rs -----
9534 * rd -----
9535 */
9536 static char *MAX_D(uint64 instruction, Dis_info *info)
9537 {
9538 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9539 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9540 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9541
9542 const char *fd = FPR(fd_value, info);
9543 const char *fs = FPR(fs_value, info);
9544 const char *ft = FPR(ft_value, info);
9545
9546 return img_format("MAX.D %s, %s, %s", fd, fs, ft);
9547 }
9548
9549
9550 /*
9551 *
9552 *
9553 * 3 2 1
9554 * 10987654321098765432109876543210
9555 * 001000 x1110000101
9556 * rt -----
9557 * rs -----
9558 * rd -----
9559 */
9560 static char *MAX_S(uint64 instruction, Dis_info *info)
9561 {
9562 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9563 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9564 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9565
9566 const char *fd = FPR(fd_value, info);
9567 const char *fs = FPR(fs_value, info);
9568 const char *ft = FPR(ft_value, info);
9569
9570 return img_format("MAX.S %s, %s, %s", fd, fs, ft);
9571 }
9572
9573
9574 /*
9575 *
9576 *
9577 * 3 2 1
9578 * 10987654321098765432109876543210
9579 * 001000 x1110000101
9580 * rt -----
9581 * rs -----
9582 * rd -----
9583 */
9584 static char *MAXA_D(uint64 instruction, Dis_info *info)
9585 {
9586 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9587 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9588 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9589
9590 const char *fd = FPR(fd_value, info);
9591 const char *fs = FPR(fs_value, info);
9592 const char *ft = FPR(ft_value, info);
9593
9594 return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
9595 }
9596
9597
9598 /*
9599 *
9600 *
9601 * 3 2 1
9602 * 10987654321098765432109876543210
9603 * 001000 x1110000101
9604 * rt -----
9605 * rs -----
9606 * rd -----
9607 */
9608 static char *MAXA_S(uint64 instruction, Dis_info *info)
9609 {
9610 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9611 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9612 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9613
9614 const char *fd = FPR(fd_value, info);
9615 const char *fs = FPR(fs_value, info);
9616 const char *ft = FPR(ft_value, info);
9617
9618 return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
9619 }
9620
9621
9622 /*
9623 *
9624 *
9625 * 3 2 1
9626 * 10987654321098765432109876543210
9627 * 001000 x1110000101
9628 * rt -----
9629 * rs -----
9630 * rd -----
9631 */
9632 static char *MFC0(uint64 instruction, Dis_info *info)
9633 {
9634 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9635 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9636 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9637
9638 const char *rt = GPR(rt_value, info);
9639
9640 return img_format("MFC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9641 rt, c0s_value, sel_value);
9642 }
9643
9644
9645 /*
9646 *
9647 *
9648 * 3 2 1
9649 * 10987654321098765432109876543210
9650 * 001000 x1110000101
9651 * rt -----
9652 * rs -----
9653 * rd -----
9654 */
9655 static char *MFC1(uint64 instruction, Dis_info *info)
9656 {
9657 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9658 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9659
9660 const char *rt = GPR(rt_value, info);
9661 const char *fs = FPR(fs_value, info);
9662
9663 return img_format("MFC1 %s, %s", rt, fs);
9664 }
9665
9666
9667 /*
9668 *
9669 *
9670 * 3 2 1
9671 * 10987654321098765432109876543210
9672 * 001000 x1110000101
9673 * rt -----
9674 * rs -----
9675 * rd -----
9676 */
9677 static char *MFC2(uint64 instruction, Dis_info *info)
9678 {
9679 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9680 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
9681
9682 const char *rt = GPR(rt_value, info);
9683
9684 return img_format("MFC2 %s, CP%" PRIu64, rt, cs_value);
9685 }
9686
9687
9688 /*
9689 *
9690 *
9691 * 3 2 1
9692 * 10987654321098765432109876543210
9693 * 001000 x1110000101
9694 * rt -----
9695 * rs -----
9696 * rd -----
9697 */
9698 static char *MFGC0(uint64 instruction, Dis_info *info)
9699 {
9700 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9701 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9702 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9703
9704 const char *rt = GPR(rt_value, info);
9705
9706 return img_format("MFGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9707 rt, c0s_value, sel_value);
9708 }
9709
9710
9711 /*
9712 *
9713 *
9714 * 3 2 1
9715 * 10987654321098765432109876543210
9716 * 001000 x1110000101
9717 * rt -----
9718 * rs -----
9719 * rd -----
9720 */
9721 static char *MFHC0(uint64 instruction, Dis_info *info)
9722 {
9723 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9724 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9725 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9726
9727 const char *rt = GPR(rt_value, info);
9728
9729 return img_format("MFHC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9730 rt, c0s_value, sel_value);
9731 }
9732
9733
9734 /*
9735 *
9736 *
9737 * 3 2 1
9738 * 10987654321098765432109876543210
9739 * 001000 x1110000101
9740 * rt -----
9741 * rs -----
9742 * rd -----
9743 */
9744 static char *MFHC1(uint64 instruction, Dis_info *info)
9745 {
9746 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9747 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9748
9749 const char *rt = GPR(rt_value, info);
9750 const char *fs = FPR(fs_value, info);
9751
9752 return img_format("MFHC1 %s, %s", rt, fs);
9753 }
9754
9755
9756 /*
9757 *
9758 *
9759 * 3 2 1
9760 * 10987654321098765432109876543210
9761 * 001000 x1110000101
9762 * rt -----
9763 * rs -----
9764 * rd -----
9765 */
9766 static char *MFHC2(uint64 instruction, Dis_info *info)
9767 {
9768 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9769 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
9770
9771 const char *rt = GPR(rt_value, info);
9772
9773 return img_format("MFHC2 %s, CP%" PRIu64, rt, cs_value);
9774 }
9775
9776
9777 /*
9778 *
9779 *
9780 * 3 2 1
9781 * 10987654321098765432109876543210
9782 * 001000 x1110000101
9783 * rt -----
9784 * rs -----
9785 * rd -----
9786 */
9787 static char *MFHGC0(uint64 instruction, Dis_info *info)
9788 {
9789 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9790 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9791 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9792
9793 const char *rt = GPR(rt_value, info);
9794
9795 return img_format("MFHGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9796 rt, c0s_value, sel_value);
9797 }
9798
9799
9800 /*
9801 * [DSP] MFHI rs, ac - Move from HI register
9802 *
9803 * 3 2 1
9804 * 10987654321098765432109876543210
9805 * 001000 xxxxx 00000001111111
9806 * rt -----
9807 * ac --
9808 */
9809 static char *MFHI_DSP_(uint64 instruction, Dis_info *info)
9810 {
9811 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9812 uint64 ac_value = extract_ac_15_14(instruction);
9813
9814 const char *rt = GPR(rt_value, info);
9815 const char *ac = AC(ac_value, info);
9816
9817 return img_format("MFHI %s, %s", rt, ac);
9818 }
9819
9820
9821 /*
9822 *
9823 *
9824 * 3 2 1
9825 * 10987654321098765432109876543210
9826 * 001000 x1110000101
9827 * rt -----
9828 * rs -----
9829 * rd -----
9830 */
9831 static char *MFHTR(uint64 instruction, Dis_info *info)
9832 {
9833 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9834 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9835 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9836 uint64 u_value = extract_u_10(instruction);
9837
9838 const char *rt = GPR(rt_value, info);
9839
9840 return img_format("MFHTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
9841 rt, c0s_value, u_value, sel_value);
9842 }
9843
9844
9845 /*
9846 * [DSP] MFLO rs, ac - Move from HI register
9847 *
9848 * 3 2 1
9849 * 10987654321098765432109876543210
9850 * 001000 xxxxx 01000001111111
9851 * rt -----
9852 * ac --
9853 */
9854 static char *MFLO_DSP_(uint64 instruction, Dis_info *info)
9855 {
9856 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9857 uint64 ac_value = extract_ac_15_14(instruction);
9858
9859 const char *rt = GPR(rt_value, info);
9860 const char *ac = AC(ac_value, info);
9861
9862 return img_format("MFLO %s, %s", rt, ac);
9863 }
9864
9865
9866 /*
9867 *
9868 *
9869 * 3 2 1
9870 * 10987654321098765432109876543210
9871 * 001000 x1110000101
9872 * rt -----
9873 * rs -----
9874 * rd -----
9875 */
9876 static char *MFTR(uint64 instruction, Dis_info *info)
9877 {
9878 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9879 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9880 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9881 uint64 u_value = extract_u_10(instruction);
9882
9883 const char *rt = GPR(rt_value, info);
9884
9885 return img_format("MFTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
9886 rt, c0s_value, u_value, sel_value);
9887 }
9888
9889
9890 /*
9891 *
9892 *
9893 * 3 2 1
9894 * 10987654321098765432109876543210
9895 * 001000 x1110000101
9896 * rt -----
9897 * rs -----
9898 * rd -----
9899 */
9900 static char *MIN_D(uint64 instruction, Dis_info *info)
9901 {
9902 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9903 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9904 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9905
9906 const char *fd = FPR(fd_value, info);
9907 const char *fs = FPR(fs_value, info);
9908 const char *ft = FPR(ft_value, info);
9909
9910 return img_format("MIN.D %s, %s, %s", fd, fs, ft);
9911 }
9912
9913
9914 /*
9915 *
9916 *
9917 * 3 2 1
9918 * 10987654321098765432109876543210
9919 * 001000 x1110000101
9920 * rt -----
9921 * rs -----
9922 * rd -----
9923 */
9924 static char *MIN_S(uint64 instruction, Dis_info *info)
9925 {
9926 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9927 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9928 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9929
9930 const char *fd = FPR(fd_value, info);
9931 const char *fs = FPR(fs_value, info);
9932 const char *ft = FPR(ft_value, info);
9933
9934 return img_format("MIN.S %s, %s, %s", fd, fs, ft);
9935 }
9936
9937
9938 /*
9939 *
9940 *
9941 * 3 2 1
9942 * 10987654321098765432109876543210
9943 * 001000 x1110000101
9944 * rt -----
9945 * rs -----
9946 * rd -----
9947 */
9948 static char *MINA_D(uint64 instruction, Dis_info *info)
9949 {
9950 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9951 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9952 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9953
9954 const char *fd = FPR(fd_value, info);
9955 const char *fs = FPR(fs_value, info);
9956 const char *ft = FPR(ft_value, info);
9957
9958 return img_format("MINA.D %s, %s, %s", fd, fs, ft);
9959 }
9960
9961
9962 /*
9963 *
9964 *
9965 * 3 2 1
9966 * 10987654321098765432109876543210
9967 * 001000 x1110000101
9968 * rt -----
9969 * rs -----
9970 * rd -----
9971 */
9972 static char *MINA_S(uint64 instruction, Dis_info *info)
9973 {
9974 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9975 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9976 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9977
9978 const char *fd = FPR(fd_value, info);
9979 const char *fs = FPR(fs_value, info);
9980 const char *ft = FPR(ft_value, info);
9981
9982 return img_format("MINA.S %s, %s, %s", fd, fs, ft);
9983 }
9984
9985
9986 /*
9987 *
9988 *
9989 * 3 2 1
9990 * 10987654321098765432109876543210
9991 * 001000 x1110000101
9992 * rt -----
9993 * rs -----
9994 * rd -----
9995 */
9996 static char *MOD(uint64 instruction, Dis_info *info)
9997 {
9998 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9999 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10000 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10001
10002 const char *rd = GPR(rd_value, info);
10003 const char *rs = GPR(rs_value, info);
10004 const char *rt = GPR(rt_value, info);
10005
10006 return img_format("MOD %s, %s, %s", rd, rs, rt);
10007 }
10008
10009
10010 /*
10011 * [DSP] MODSUB rd, rs, rt - Modular subtraction on an index value
10012 *
10013 * 3 2 1
10014 * 10987654321098765432109876543210
10015 * 001000 x1110000101
10016 * rt -----
10017 * rs -----
10018 * rd -----
10019 */
10020 static char *MODSUB(uint64 instruction, Dis_info *info)
10021 {
10022 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10023 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10024 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10025
10026 const char *rd = GPR(rd_value, info);
10027 const char *rs = GPR(rs_value, info);
10028 const char *rt = GPR(rt_value, info);
10029
10030 return img_format("MODSUB %s, %s, %s", rd, rs, rt);
10031 }
10032
10033
10034 /*
10035 *
10036 *
10037 * 3 2 1
10038 * 10987654321098765432109876543210
10039 * 001000 x1010010101
10040 * rt -----
10041 * rs -----
10042 * rd -----
10043 */
10044 static char *MODU(uint64 instruction, Dis_info *info)
10045 {
10046 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10047 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10048 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10049
10050 const char *rd = GPR(rd_value, info);
10051 const char *rs = GPR(rs_value, info);
10052 const char *rt = GPR(rt_value, info);
10053
10054 return img_format("MODU %s, %s, %s", rd, rs, rt);
10055 }
10056
10057
10058 /*
10059 *
10060 *
10061 * 3 2 1
10062 * 10987654321098765432109876543210
10063 * 001000 x1110000101
10064 * rt -----
10065 * rs -----
10066 * rd -----
10067 */
10068 static char *MOV_D(uint64 instruction, Dis_info *info)
10069 {
10070 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10071 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10072
10073 const char *ft = FPR(ft_value, info);
10074 const char *fs = FPR(fs_value, info);
10075
10076 return img_format("MOV.D %s, %s", ft, fs);
10077 }
10078
10079
10080 /*
10081 *
10082 *
10083 * 3 2 1
10084 * 10987654321098765432109876543210
10085 * 001000 x1110000101
10086 * rt -----
10087 * rs -----
10088 * rd -----
10089 */
10090 static char *MOV_S(uint64 instruction, Dis_info *info)
10091 {
10092 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10093 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10094
10095 const char *ft = FPR(ft_value, info);
10096 const char *fs = FPR(fs_value, info);
10097
10098 return img_format("MOV.S %s, %s", ft, fs);
10099 }
10100
10101
10102 /*
10103 *
10104 *
10105 * 3 2 1
10106 * 10987654321098765432109876543210
10107 * 001000 x1110000101
10108 * rt -----
10109 * rs -----
10110 * rd -----
10111 */
10112 static char *MOVE_BALC(uint64 instruction, Dis_info *info)
10113 {
10114 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10115 uint64 rd1_value = extract_rdl_25_24(instruction);
10116 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
10117
10118 const char *rd1 = GPR(decode_gpr_gpr1(rd1_value, info), info);
10119 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
10120 g_autofree char *s = ADDRESS(s_value, 4, info);
10121
10122 return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10123 }
10124
10125
10126 /*
10127 *
10128 *
10129 * 3 2 1
10130 * 10987654321098765432109876543210
10131 * 001000 x1110000101
10132 * rt -----
10133 * rs -----
10134 * rd -----
10135 */
10136 static char *MOVEP(uint64 instruction, Dis_info *info)
10137 {
10138 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10139 uint64 rd2_value = extract_rd2_3_8(instruction);
10140 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10141
10142 const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
10143 const char *re2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
10144 /* !!!!!!!!!! - no conversion function */
10145 const char *rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value, info), info);
10146 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
10147
10148 return img_format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10149 /* hand edited */
10150 }
10151
10152
10153 /*
10154 *
10155 *
10156 * 3 2 1
10157 * 10987654321098765432109876543210
10158 * 001000 x1110000101
10159 * rt -----
10160 * rs -----
10161 * rd -----
10162 */
10163 static char *MOVEP_REV_(uint64 instruction, Dis_info *info)
10164 {
10165 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10166 uint64 rd2_value = extract_rd2_3_8(instruction);
10167 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10168
10169 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
10170 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
10171 const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
10172 const char *rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
10173 /* !!!!!!!!!! - no conversion function */
10174
10175 return img_format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10176 /* hand edited */
10177 }
10178
10179
10180 /*
10181 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10182 *
10183 * 3 2 1
10184 * 10987654321098765432109876543210
10185 * 001000 00010001101
10186 * rt -----
10187 * rs -----
10188 * rd -----
10189 */
10190 static char *MOVE(uint64 instruction, Dis_info *info)
10191 {
10192 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10193 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10194
10195 const char *rt = GPR(rt_value, info);
10196 const char *rs = GPR(rs_value, info);
10197
10198 return img_format("MOVE %s, %s", rt, rs);
10199 }
10200
10201
10202 /*
10203 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10204 *
10205 * 3 2 1
10206 * 10987654321098765432109876543210
10207 * 001000 00010001101
10208 * rt -----
10209 * rs -----
10210 * rd -----
10211 */
10212 static char *MOVN(uint64 instruction, Dis_info *info)
10213 {
10214 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10215 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10216 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10217
10218 const char *rd = GPR(rd_value, info);
10219 const char *rs = GPR(rs_value, info);
10220 const char *rt = GPR(rt_value, info);
10221
10222 return img_format("MOVN %s, %s, %s", rd, rs, rt);
10223 }
10224
10225
10226 /*
10227 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10228 *
10229 * 3 2 1
10230 * 10987654321098765432109876543210
10231 * 001000 00010001101
10232 * rt -----
10233 * rs -----
10234 * rd -----
10235 */
10236 static char *MOVZ(uint64 instruction, Dis_info *info)
10237 {
10238 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10239 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10240 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10241
10242 const char *rd = GPR(rd_value, info);
10243 const char *rs = GPR(rs_value, info);
10244 const char *rt = GPR(rt_value, info);
10245
10246 return img_format("MOVZ %s, %s, %s", rd, rs, rt);
10247 }
10248
10249
10250 /*
10251 * [DSP] MSUB ac, rs, rt - Multiply word and subtract from accumulator
10252 *
10253 * 3 2 1
10254 * 10987654321098765432109876543210
10255 * 001000 10101010111111
10256 * rt -----
10257 * rs -----
10258 * ac --
10259 */
10260 static char *MSUB_DSP_(uint64 instruction, Dis_info *info)
10261 {
10262 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10263 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10264 uint64 ac_value = extract_ac_15_14(instruction);
10265
10266 const char *ac = AC(ac_value, info);
10267 const char *rs = GPR(rs_value, info);
10268 const char *rt = GPR(rt_value, info);
10269
10270 return img_format("MSUB %s, %s, %s", ac, rs, rt);
10271 }
10272
10273
10274 /*
10275 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10276 *
10277 * 3 2 1
10278 * 10987654321098765432109876543210
10279 * 001000 00010001101
10280 * rt -----
10281 * rs -----
10282 * rd -----
10283 */
10284 static char *MSUBF_D(uint64 instruction, Dis_info *info)
10285 {
10286 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10287 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10288 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10289
10290 const char *fd = FPR(fd_value, info);
10291 const char *fs = FPR(fs_value, info);
10292 const char *ft = FPR(ft_value, info);
10293
10294 return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
10295 }
10296
10297
10298 /*
10299 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10300 *
10301 * 3 2 1
10302 * 10987654321098765432109876543210
10303 * 001000 00010001101
10304 * rt -----
10305 * rs -----
10306 * rd -----
10307 */
10308 static char *MSUBF_S(uint64 instruction, Dis_info *info)
10309 {
10310 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10311 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10312 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10313
10314 const char *fd = FPR(fd_value, info);
10315 const char *fs = FPR(fs_value, info);
10316 const char *ft = FPR(ft_value, info);
10317
10318 return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
10319 }
10320
10321
10322 /*
10323 * [DSP] MSUBU ac, rs, rt - Multiply word and add to accumulator
10324 *
10325 * 3 2 1
10326 * 10987654321098765432109876543210
10327 * 001000 11101010111111
10328 * rt -----
10329 * rs -----
10330 * ac --
10331 */
10332 static char *MSUBU_DSP_(uint64 instruction, Dis_info *info)
10333 {
10334 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10335 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10336 uint64 ac_value = extract_ac_15_14(instruction);
10337
10338 const char *ac = AC(ac_value, info);
10339 const char *rs = GPR(rs_value, info);
10340 const char *rt = GPR(rt_value, info);
10341
10342 return img_format("MSUBU %s, %s, %s", ac, rs, rt);
10343 }
10344
10345
10346 /*
10347 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10348 *
10349 * 3 2 1
10350 * 10987654321098765432109876543210
10351 * 001000 00010001101
10352 * rt -----
10353 * rs -----
10354 * rd -----
10355 */
10356 static char *MTC0(uint64 instruction, Dis_info *info)
10357 {
10358 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10359 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10360 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10361
10362 const char *rt = GPR(rt_value, info);
10363
10364 return img_format("MTC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10365 rt, c0s_value, sel_value);
10366 }
10367
10368
10369 /*
10370 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10371 *
10372 * 3 2 1
10373 * 10987654321098765432109876543210
10374 * 001000 00010001101
10375 * rt -----
10376 * rs -----
10377 * rd -----
10378 */
10379 static char *MTC1(uint64 instruction, Dis_info *info)
10380 {
10381 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10382 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10383
10384 const char *rt = GPR(rt_value, info);
10385 const char *fs = FPR(fs_value, info);
10386
10387 return img_format("MTC1 %s, %s", rt, fs);
10388 }
10389
10390
10391 /*
10392 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10393 *
10394 * 3 2 1
10395 * 10987654321098765432109876543210
10396 * 001000 00010001101
10397 * rt -----
10398 * rs -----
10399 * rd -----
10400 */
10401 static char *MTC2(uint64 instruction, Dis_info *info)
10402 {
10403 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10404 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10405
10406 const char *rt = GPR(rt_value, info);
10407
10408 return img_format("MTC2 %s, CP%" PRIu64, rt, cs_value);
10409 }
10410
10411
10412 /*
10413 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10414 *
10415 * 3 2 1
10416 * 10987654321098765432109876543210
10417 * 001000 00010001101
10418 * rt -----
10419 * rs -----
10420 * rd -----
10421 */
10422 static char *MTGC0(uint64 instruction, Dis_info *info)
10423 {
10424 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10425 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10426 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10427
10428 const char *rt = GPR(rt_value, info);
10429
10430 return img_format("MTGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10431 rt, c0s_value, sel_value);
10432 }
10433
10434
10435 /*
10436 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10437 *
10438 * 3 2 1
10439 * 10987654321098765432109876543210
10440 * 001000 00010001101
10441 * rt -----
10442 * rs -----
10443 * rd -----
10444 */
10445 static char *MTHC0(uint64 instruction, Dis_info *info)
10446 {
10447 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10448 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10449 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10450
10451 const char *rt = GPR(rt_value, info);
10452
10453 return img_format("MTHC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10454 rt, c0s_value, sel_value);
10455 }
10456
10457
10458 /*
10459 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10460 *
10461 * 3 2 1
10462 * 10987654321098765432109876543210
10463 * 001000 00010001101
10464 * rt -----
10465 * rs -----
10466 * rd -----
10467 */
10468 static char *MTHC1(uint64 instruction, Dis_info *info)
10469 {
10470 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10471 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10472
10473 const char *rt = GPR(rt_value, info);
10474 const char *fs = FPR(fs_value, info);
10475
10476 return img_format("MTHC1 %s, %s", rt, fs);
10477 }
10478
10479
10480 /*
10481 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10482 *
10483 * 3 2 1
10484 * 10987654321098765432109876543210
10485 * 001000 00010001101
10486 * rt -----
10487 * rs -----
10488 * rd -----
10489 */
10490 static char *MTHC2(uint64 instruction, Dis_info *info)
10491 {
10492 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10493 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10494
10495 const char *rt = GPR(rt_value, info);
10496
10497 return img_format("MTHC2 %s, CP%" PRIu64, rt, cs_value);
10498 }
10499
10500
10501 /*
10502 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10503 *
10504 * 3 2 1
10505 * 10987654321098765432109876543210
10506 * 001000 00010001101
10507 * rt -----
10508 * rs -----
10509 * rd -----
10510 */
10511 static char *MTHGC0(uint64 instruction, Dis_info *info)
10512 {
10513 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10514 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10515 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10516
10517 const char *rt = GPR(rt_value, info);
10518
10519 return img_format("MTHGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10520 rt, c0s_value, sel_value);
10521 }
10522
10523
10524 /*
10525 * [DSP] MTHI rs, ac - Move to HI register
10526 *
10527 * 3 2 1
10528 * 10987654321098765432109876543210
10529 * 001000xxxxx 10000001111111
10530 * rs -----
10531 * ac --
10532 */
10533 static char *MTHI_DSP_(uint64 instruction, Dis_info *info)
10534 {
10535 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10536 uint64 ac_value = extract_ac_15_14(instruction);
10537
10538 const char *rs = GPR(rs_value, info);
10539 const char *ac = AC(ac_value, info);
10540
10541 return img_format("MTHI %s, %s", rs, ac);
10542 }
10543
10544
10545 /*
10546 * [DSP] MTHLIP rs, ac - Copy LO to HI and a GPR to LO and increment pos by 32
10547 *
10548 * 3 2 1
10549 * 10987654321098765432109876543210
10550 * 001000xxxxx 00001001111111
10551 * rs -----
10552 * ac --
10553 */
10554 static char *MTHLIP(uint64 instruction, Dis_info *info)
10555 {
10556 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10557 uint64 ac_value = extract_ac_15_14(instruction);
10558
10559 const char *rs = GPR(rs_value, info);
10560 const char *ac = AC(ac_value, info);
10561
10562 return img_format("MTHLIP %s, %s", rs, ac);
10563 }
10564
10565
10566 /*
10567 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10568 *
10569 * 3 2 1
10570 * 10987654321098765432109876543210
10571 * 001000 00010001101
10572 * rt -----
10573 * rs -----
10574 * rd -----
10575 */
10576 static char *MTHTR(uint64 instruction, Dis_info *info)
10577 {
10578 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10579 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10580 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10581 uint64 u_value = extract_u_10(instruction);
10582
10583 const char *rt = GPR(rt_value, info);
10584
10585 return img_format("MTHTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
10586 rt, c0s_value, u_value, sel_value);
10587 }
10588
10589
10590 /*
10591 * [DSP] MTLO rs, ac - Move to LO register
10592 *
10593 * 3 2 1
10594 * 10987654321098765432109876543210
10595 * 001000xxxxx 11000001111111
10596 * rs -----
10597 * ac --
10598 */
10599 static char *MTLO_DSP_(uint64 instruction, Dis_info *info)
10600 {
10601 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10602 uint64 ac_value = extract_ac_15_14(instruction);
10603
10604 const char *rs = GPR(rs_value, info);
10605 const char *ac = AC(ac_value, info);
10606
10607 return img_format("MTLO %s, %s", rs, ac);
10608 }
10609
10610
10611 /*
10612 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10613 *
10614 * 3 2 1
10615 * 10987654321098765432109876543210
10616 * 001000 00010001101
10617 * rt -----
10618 * rs -----
10619 * rd -----
10620 */
10621 static char *MTTR(uint64 instruction, Dis_info *info)
10622 {
10623 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10624 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10625 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10626 uint64 u_value = extract_u_10(instruction);
10627
10628 const char *rt = GPR(rt_value, info);
10629
10630 return img_format("MTTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
10631 rt, c0s_value, u_value, sel_value);
10632 }
10633
10634
10635 /*
10636 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10637 *
10638 * 3 2 1
10639 * 10987654321098765432109876543210
10640 * 001000 00010001101
10641 * rt -----
10642 * rs -----
10643 * rd -----
10644 */
10645 static char *MUH(uint64 instruction, Dis_info *info)
10646 {
10647 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10648 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10649 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10650
10651 const char *rd = GPR(rd_value, info);
10652 const char *rs = GPR(rs_value, info);
10653 const char *rt = GPR(rt_value, info);
10654
10655 return img_format("MUH %s, %s, %s", rd, rs, rt);
10656 }
10657
10658
10659 /*
10660 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10661 *
10662 * 3 2 1
10663 * 10987654321098765432109876543210
10664 * 001000 00010001101
10665 * rt -----
10666 * rs -----
10667 * rd -----
10668 */
10669 static char *MUHU(uint64 instruction, Dis_info *info)
10670 {
10671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10672 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10673 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10674
10675 const char *rd = GPR(rd_value, info);
10676 const char *rs = GPR(rs_value, info);
10677 const char *rt = GPR(rt_value, info);
10678
10679 return img_format("MUHU %s, %s, %s", rd, rs, rt);
10680 }
10681
10682
10683 /*
10684 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10685 *
10686 * 3 2 1
10687 * 10987654321098765432109876543210
10688 * 001000 00010001101
10689 * rt -----
10690 * rs -----
10691 * rd -----
10692 */
10693 static char *MUL_32_(uint64 instruction, Dis_info *info)
10694 {
10695 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10696 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10697 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10698
10699 const char *rd = GPR(rd_value, info);
10700 const char *rs = GPR(rs_value, info);
10701 const char *rt = GPR(rt_value, info);
10702
10703 return img_format("MUL %s, %s, %s", rd, rs, rt);
10704 }
10705
10706
10707 /*
10708 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10709 *
10710 * 3 2 1
10711 * 10987654321098765432109876543210
10712 * 001000 00010001101
10713 * rt -----
10714 * rs -----
10715 * rd -----
10716 */
10717 static char *MUL_4X4_(uint64 instruction, Dis_info *info)
10718 {
10719 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10720 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10721
10722 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
10723 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
10724
10725 return img_format("MUL %s, %s", rs4, rt4);
10726 }
10727
10728
10729 /*
10730 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10731 *
10732 * 3 2 1
10733 * 10987654321098765432109876543210
10734 * 001000 00010001101
10735 * rt -----
10736 * rs -----
10737 * rd -----
10738 */
10739 static char *MUL_D(uint64 instruction, Dis_info *info)
10740 {
10741 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10742 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10743 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10744
10745 const char *fd = FPR(fd_value, info);
10746 const char *fs = FPR(fs_value, info);
10747 const char *ft = FPR(ft_value, info);
10748
10749 return img_format("MUL.D %s, %s, %s", fd, fs, ft);
10750 }
10751
10752
10753 /*
10754 * [DSP] MUL.PH rd, rs, rt - Multiply vector integer half words to same size
10755 * products
10756 *
10757 * 3 2 1
10758 * 10987654321098765432109876543210
10759 * 001000 00000101101
10760 * rt -----
10761 * rs -----
10762 * rd -----
10763 */
10764 static char *MUL_PH(uint64 instruction, Dis_info *info)
10765 {
10766 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10767 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10768 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10769
10770 const char *rd = GPR(rd_value, info);
10771 const char *rs = GPR(rs_value, info);
10772 const char *rt = GPR(rt_value, info);
10773
10774 return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
10775 }
10776
10777
10778 /*
10779 * [DSP] MUL_S.PH rd, rs, rt - Multiply vector integer half words to same size
10780 * products (saturated)
10781 *
10782 * 3 2 1
10783 * 10987654321098765432109876543210
10784 * 001000 10000101101
10785 * rt -----
10786 * rs -----
10787 * rd -----
10788 */
10789 static char *MUL_S_PH(uint64 instruction, Dis_info *info)
10790 {
10791 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10792 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10793 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10794
10795 const char *rd = GPR(rd_value, info);
10796 const char *rs = GPR(rs_value, info);
10797 const char *rt = GPR(rt_value, info);
10798
10799 return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
10800 }
10801
10802
10803 /*
10804 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10805 *
10806 * 3 2 1
10807 * 10987654321098765432109876543210
10808 * 001000 00010001101
10809 * rt -----
10810 * rs -----
10811 * rd -----
10812 */
10813 static char *MUL_S(uint64 instruction, Dis_info *info)
10814 {
10815 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10816 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10817 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10818
10819 const char *fd = FPR(fd_value, info);
10820 const char *fs = FPR(fs_value, info);
10821 const char *ft = FPR(ft_value, info);
10822
10823 return img_format("MUL.S %s, %s, %s", fd, fs, ft);
10824 }
10825
10826
10827 /*
10828 * [DSP] MULEQ_S.W.PHL rd, rs, rt - Multiply vector fractional left halfwords
10829 * to expanded width products
10830 *
10831 * 3 2 1
10832 * 10987654321098765432109876543210
10833 * 001000 x0000100101
10834 * rt -----
10835 * rs -----
10836 * rd -----
10837 */
10838 static char *MULEQ_S_W_PHL(uint64 instruction, Dis_info *info)
10839 {
10840 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10841 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10842 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10843
10844 const char *rd = GPR(rd_value, info);
10845 const char *rs = GPR(rs_value, info);
10846 const char *rt = GPR(rt_value, info);
10847
10848 return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
10849 }
10850
10851
10852 /*
10853 * [DSP] MULEQ_S.W.PHR rd, rs, rt - Multiply vector fractional right halfwords
10854 * to expanded width products
10855 *
10856 * 3 2 1
10857 * 10987654321098765432109876543210
10858 * 001000 x0001100101
10859 * rt -----
10860 * rs -----
10861 * rd -----
10862 */
10863 static char *MULEQ_S_W_PHR(uint64 instruction, Dis_info *info)
10864 {
10865 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10866 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10867 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10868
10869 const char *rd = GPR(rd_value, info);
10870 const char *rs = GPR(rs_value, info);
10871 const char *rt = GPR(rt_value, info);
10872
10873 return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
10874 }
10875
10876
10877 /*
10878 * [DSP] MULEU_S.PH.QBL rd, rs, rt - Multiply vector fractional left bytes
10879 * by halfwords to halfword products
10880 *
10881 * 3 2 1
10882 * 10987654321098765432109876543210
10883 * 001000 x0010010101
10884 * rt -----
10885 * rs -----
10886 * rd -----
10887 */
10888 static char *MULEU_S_PH_QBL(uint64 instruction, Dis_info *info)
10889 {
10890 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10891 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10892 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10893
10894 const char *rd = GPR(rd_value, info);
10895 const char *rs = GPR(rs_value, info);
10896 const char *rt = GPR(rt_value, info);
10897
10898 return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
10899 }
10900
10901
10902 /*
10903 * [DSP] MULEU_S.PH.QBR rd, rs, rt - Multiply vector fractional right bytes
10904 * by halfwords to halfword products
10905 *
10906 * 3 2 1
10907 * 10987654321098765432109876543210
10908 * 001000 x0011010101
10909 * rt -----
10910 * rs -----
10911 * rd -----
10912 */
10913 static char *MULEU_S_PH_QBR(uint64 instruction, Dis_info *info)
10914 {
10915 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10916 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10917 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10918
10919 const char *rd = GPR(rd_value, info);
10920 const char *rs = GPR(rs_value, info);
10921 const char *rt = GPR(rt_value, info);
10922
10923 return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
10924 }
10925
10926
10927 /*
10928 * [DSP] MULQ_RS.PH rd, rs, rt - Multiply vector fractional halfwords
10929 * to fractional halfword products
10930 *
10931 * 3 2 1
10932 * 10987654321098765432109876543210
10933 * 001000 x0100010101
10934 * rt -----
10935 * rs -----
10936 * rd -----
10937 */
10938 static char *MULQ_RS_PH(uint64 instruction, Dis_info *info)
10939 {
10940 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10941 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10942 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10943
10944 const char *rd = GPR(rd_value, info);
10945 const char *rs = GPR(rs_value, info);
10946 const char *rt = GPR(rt_value, info);
10947
10948 return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
10949 }
10950
10951
10952 /*
10953 * [DSP] MULQ_RS.W rd, rs, rt - Multiply fractional words to same size
10954 * product with saturation and rounding
10955 *
10956 * 3 2 1
10957 * 10987654321098765432109876543210
10958 * 001000 x0110010101
10959 * rt -----
10960 * rs -----
10961 * rd -----
10962 */
10963 static char *MULQ_RS_W(uint64 instruction, Dis_info *info)
10964 {
10965 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10966 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10967 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10968
10969 const char *rd = GPR(rd_value, info);
10970 const char *rs = GPR(rs_value, info);
10971 const char *rt = GPR(rt_value, info);
10972
10973 return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
10974 }
10975
10976
10977 /*
10978 * [DSP] MULQ_S.PH rd, rs, rt - Multiply fractional halfwords to same size
10979 * products
10980 *
10981 * 3 2 1
10982 * 10987654321098765432109876543210
10983 * 001000 x0101010101
10984 * rt -----
10985 * rs -----
10986 * rd -----
10987 */
10988 static char *MULQ_S_PH(uint64 instruction, Dis_info *info)
10989 {
10990 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10991 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10992 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10993
10994 const char *rd = GPR(rd_value, info);
10995 const char *rs = GPR(rs_value, info);
10996 const char *rt = GPR(rt_value, info);
10997
10998 return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
10999 }
11000
11001
11002 /*
11003 * [DSP] MULQ_S.W rd, rs, rt - Multiply fractional words to same size product
11004 * with saturation
11005 *
11006 * 3 2 1
11007 * 10987654321098765432109876543210
11008 * 001000 x0111010101
11009 * rt -----
11010 * rs -----
11011 * rd -----
11012 */
11013 static char *MULQ_S_W(uint64 instruction, Dis_info *info)
11014 {
11015 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11016 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11017 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11018
11019 const char *rd = GPR(rd_value, info);
11020 const char *rs = GPR(rs_value, info);
11021 const char *rt = GPR(rt_value, info);
11022
11023 return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
11024 }
11025
11026
11027 /*
11028 * [DSP] MULSA.W.PH ac, rs, rt - Multiply and subtract vector integer halfword
11029 * elements and accumulate
11030 *
11031 * 3 2 1
11032 * 10987654321098765432109876543210
11033 * 001000 10110010111111
11034 * rt -----
11035 * rs -----
11036 * ac --
11037 */
11038 static char *MULSA_W_PH(uint64 instruction, Dis_info *info)
11039 {
11040 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11041 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11042 uint64 ac_value = extract_ac_15_14(instruction);
11043
11044 const char *ac = AC(ac_value, info);
11045 const char *rs = GPR(rs_value, info);
11046 const char *rt = GPR(rt_value, info);
11047
11048 return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
11049 }
11050
11051
11052 /*
11053 * [DSP] MULSAQ_S.W.PH ac, rs, rt - Multiply and subtract vector fractional
11054 * halfwords and accumulate
11055 *
11056 * 3 2 1
11057 * 10987654321098765432109876543210
11058 * 001000 11110010111111
11059 * rt -----
11060 * rs -----
11061 * ac --
11062 */
11063 static char *MULSAQ_S_W_PH(uint64 instruction, Dis_info *info)
11064 {
11065 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11066 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11067 uint64 ac_value = extract_ac_15_14(instruction);
11068
11069 const char *ac = AC(ac_value, info);
11070 const char *rs = GPR(rs_value, info);
11071 const char *rt = GPR(rt_value, info);
11072
11073 return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
11074 }
11075
11076
11077 /*
11078 * [DSP] MULT ac, rs, rt - Multiply word
11079 *
11080 * 3 2 1
11081 * 10987654321098765432109876543210
11082 * 001000 00110010111111
11083 * rt -----
11084 * rs -----
11085 * ac --
11086 */
11087 static char *MULT_DSP_(uint64 instruction, Dis_info *info)
11088 {
11089 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11090 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11091 uint64 ac_value = extract_ac_15_14(instruction);
11092
11093 const char *ac = AC(ac_value, info);
11094 const char *rs = GPR(rs_value, info);
11095 const char *rt = GPR(rt_value, info);
11096
11097 return img_format("MULT %s, %s, %s", ac, rs, rt);
11098 }
11099
11100
11101 /*
11102 * [DSP] MULTU ac, rs, rt - Multiply unsigned word
11103 *
11104 * 3 2 1
11105 * 10987654321098765432109876543210
11106 * 001000 01110010111111
11107 * rt -----
11108 * rs -----
11109 * ac --
11110 */
11111 static char *MULTU_DSP_(uint64 instruction, Dis_info *info)
11112 {
11113 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11114 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11115 uint64 ac_value = extract_ac_15_14(instruction);
11116
11117 const char *ac = AC(ac_value, info);
11118 const char *rs = GPR(rs_value, info);
11119 const char *rt = GPR(rt_value, info);
11120
11121 return img_format("MULTU %s, %s, %s", ac, rs, rt);
11122 }
11123
11124
11125 /*
11126 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11127 *
11128 * 3 2 1
11129 * 10987654321098765432109876543210
11130 * 001000 00010001101
11131 * rt -----
11132 * rs -----
11133 * rd -----
11134 */
11135 static char *MULU(uint64 instruction, Dis_info *info)
11136 {
11137 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11138 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11139 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11140
11141 const char *rd = GPR(rd_value, info);
11142 const char *rs = GPR(rs_value, info);
11143 const char *rt = GPR(rt_value, info);
11144
11145 return img_format("MULU %s, %s, %s", rd, rs, rt);
11146 }
11147
11148
11149 /*
11150 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11151 *
11152 * 3 2 1
11153 * 10987654321098765432109876543210
11154 * 001000 00010001101
11155 * rt -----
11156 * rs -----
11157 * rd -----
11158 */
11159 static char *NEG_D(uint64 instruction, Dis_info *info)
11160 {
11161 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11162 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11163
11164 const char *ft = FPR(ft_value, info);
11165 const char *fs = FPR(fs_value, info);
11166
11167 return img_format("NEG.D %s, %s", ft, fs);
11168 }
11169
11170
11171 /*
11172 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11173 *
11174 * 3 2 1
11175 * 10987654321098765432109876543210
11176 * 001000 00010001101
11177 * rt -----
11178 * rs -----
11179 * rd -----
11180 */
11181 static char *NEG_S(uint64 instruction, Dis_info *info)
11182 {
11183 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11184 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11185
11186 const char *ft = FPR(ft_value, info);
11187 const char *fs = FPR(fs_value, info);
11188
11189 return img_format("NEG.S %s, %s", ft, fs);
11190 }
11191
11192
11193 /*
11194 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11195 *
11196 * 3 2 1
11197 * 10987654321098765432109876543210
11198 * 001000 00010001101
11199 * rt -----
11200 * rs -----
11201 * rd -----
11202 */
11203 static char *NOP_16_(uint64 instruction, Dis_info *info)
11204 {
11205 (void)instruction;
11206
11207 return g_strdup("NOP ");
11208 }
11209
11210
11211 /*
11212 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11213 *
11214 * 3 2 1
11215 * 10987654321098765432109876543210
11216 * 001000 00010001101
11217 * rt -----
11218 * rs -----
11219 * rd -----
11220 */
11221 static char *NOP_32_(uint64 instruction, Dis_info *info)
11222 {
11223 (void)instruction;
11224
11225 return g_strdup("NOP ");
11226 }
11227
11228
11229 /*
11230 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11231 *
11232 * 3 2 1
11233 * 10987654321098765432109876543210
11234 * 001000 00010001101
11235 * rt -----
11236 * rs -----
11237 * rd -----
11238 */
11239 static char *NOR(uint64 instruction, Dis_info *info)
11240 {
11241 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11242 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11243 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11244
11245 const char *rd = GPR(rd_value, info);
11246 const char *rs = GPR(rs_value, info);
11247 const char *rt = GPR(rt_value, info);
11248
11249 return img_format("NOR %s, %s, %s", rd, rs, rt);
11250 }
11251
11252
11253 /*
11254 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11255 *
11256 * 3 2 1
11257 * 10987654321098765432109876543210
11258 * 001000 00010001101
11259 * rt -----
11260 * rs -----
11261 * rd -----
11262 */
11263 static char *NOT_16_(uint64 instruction, Dis_info *info)
11264 {
11265 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11266 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11267
11268 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
11269 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
11270
11271 return img_format("NOT %s, %s", rt3, rs3);
11272 }
11273
11274
11275 /*
11276 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11277 *
11278 * 3 2 1
11279 * 10987654321098765432109876543210
11280 * 001000 00010001101
11281 * rt -----
11282 * rs -----
11283 * rd -----
11284 */
11285 static char *OR_16_(uint64 instruction, Dis_info *info)
11286 {
11287 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11288 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11289
11290 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
11291 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
11292
11293 return img_format("OR %s, %s", rs3, rt3);
11294 }
11295
11296
11297 /*
11298 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11299 *
11300 * 3 2 1
11301 * 10987654321098765432109876543210
11302 * 001000 00010001101
11303 * rt -----
11304 * rs -----
11305 * rd -----
11306 */
11307 static char *OR_32_(uint64 instruction, Dis_info *info)
11308 {
11309 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11310 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11311 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11312
11313 const char *rd = GPR(rd_value, info);
11314 const char *rs = GPR(rs_value, info);
11315 const char *rt = GPR(rt_value, info);
11316
11317 return img_format("OR %s, %s, %s", rd, rs, rt);
11318 }
11319
11320
11321 /*
11322 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11323 *
11324 * 3 2 1
11325 * 10987654321098765432109876543210
11326 * 001000 00010001101
11327 * rt -----
11328 * rs -----
11329 * rd -----
11330 */
11331 static char *ORI(uint64 instruction, Dis_info *info)
11332 {
11333 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11334 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11335 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11336
11337 const char *rt = GPR(rt_value, info);
11338 const char *rs = GPR(rs_value, info);
11339
11340 return img_format("ORI %s, %s, 0x%" PRIx64, rt, rs, u_value);
11341 }
11342
11343
11344 /*
11345 * [DSP] PACKRL.PH rd, rs, rt - Pack a word using the right halfword from one
11346 * source register and left halfword from another source register
11347 *
11348 * 3 2 1
11349 * 10987654321098765432109876543210
11350 * 001000 00010001101
11351 * rt -----
11352 * rs -----
11353 * rd -----
11354 */
11355 static char *PACKRL_PH(uint64 instruction, Dis_info *info)
11356 {
11357 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11358 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11359 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11360
11361 const char *rd = GPR(rd_value, info);
11362 const char *rs = GPR(rs_value, info);
11363 const char *rt = GPR(rt_value, info);
11364
11365 return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11366 }
11367
11368
11369 /*
11370 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11371 *
11372 * 3 2 1
11373 * 10987654321098765432109876543210
11374 * 001000 00010001101
11375 * rt -----
11376 * rs -----
11377 * rd -----
11378 */
11379 static char *PAUSE(uint64 instruction, Dis_info *info)
11380 {
11381 (void)instruction;
11382
11383 return g_strdup("PAUSE ");
11384 }
11385
11386
11387 /*
11388 * [DSP] PICK.PH rd, rs, rt - Pick a vector of halfwords based on condition
11389 * code bits
11390 *
11391 * 3 2 1
11392 * 10987654321098765432109876543210
11393 * 001000 00010001101
11394 * rt -----
11395 * rs -----
11396 * rd -----
11397 */
11398 static char *PICK_PH(uint64 instruction, Dis_info *info)
11399 {
11400 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11401 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11402 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11403
11404 const char *rd = GPR(rd_value, info);
11405 const char *rs = GPR(rs_value, info);
11406 const char *rt = GPR(rt_value, info);
11407
11408 return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
11409 }
11410
11411
11412 /*
11413 * [DSP] PICK.QB rd, rs, rt - Pick a vector of byte values based on condition
11414 * code bits
11415 *
11416 * 3 2 1
11417 * 10987654321098765432109876543210
11418 * 001000 00010001101
11419 * rt -----
11420 * rs -----
11421 * rd -----
11422 */
11423 static char *PICK_QB(uint64 instruction, Dis_info *info)
11424 {
11425 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11426 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11427 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11428
11429 const char *rd = GPR(rd_value, info);
11430 const char *rs = GPR(rs_value, info);
11431 const char *rt = GPR(rt_value, info);
11432
11433 return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
11434 }
11435
11436
11437 /*
11438 * [DSP] PRECEQ.W.PHL rt, rs - Expand the precision of the left-most element
11439 * of a paired halfword
11440 *
11441 * 3 2 1
11442 * 10987654321098765432109876543210
11443 * 001000 00010001101
11444 * rt -----
11445 * rs -----
11446 * rd -----
11447 */
11448 static char *PRECEQ_W_PHL(uint64 instruction, Dis_info *info)
11449 {
11450 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11451 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11452
11453 const char *rt = GPR(rt_value, info);
11454 const char *rs = GPR(rs_value, info);
11455
11456 return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
11457 }
11458
11459
11460 /*
11461 * [DSP] PRECEQ.W.PHR rt, rs - Expand the precision of the right-most element
11462 * of a paired halfword
11463 *
11464 * 3 2 1
11465 * 10987654321098765432109876543210
11466 * 001000 00010001101
11467 * rt -----
11468 * rs -----
11469 * rd -----
11470 */
11471 static char *PRECEQ_W_PHR(uint64 instruction, Dis_info *info)
11472 {
11473 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11474 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11475
11476 const char *rt = GPR(rt_value, info);
11477 const char *rs = GPR(rs_value, info);
11478
11479 return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
11480 }
11481
11482
11483 /*
11484 * [DSP] PRECEQU.PH.QBLA rt, rs - Expand the precision of the two
11485 * left-alternate elements of a quad byte vector
11486 *
11487 * 3 2 1
11488 * 10987654321098765432109876543210
11489 * 001000 00010001101
11490 * rt -----
11491 * rs -----
11492 * rd -----
11493 */
11494 static char *PRECEQU_PH_QBLA(uint64 instruction, Dis_info *info)
11495 {
11496 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11497 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11498
11499 const char *rt = GPR(rt_value, info);
11500 const char *rs = GPR(rs_value, info);
11501
11502 return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11503 }
11504
11505
11506 /*
11507 * [DSP] PRECEQU.PH.QBL rt, rs - Expand the precision of the two left-most
11508 * elements of a quad byte vector
11509 *
11510 * 3 2 1
11511 * 10987654321098765432109876543210
11512 * 001000 00010001101
11513 * rt -----
11514 * rs -----
11515 * rd -----
11516 */
11517 static char *PRECEQU_PH_QBL(uint64 instruction, Dis_info *info)
11518 {
11519 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11520 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11521
11522 const char *rt = GPR(rt_value, info);
11523 const char *rs = GPR(rs_value, info);
11524
11525 return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
11526 }
11527
11528
11529 /*
11530 * [DSP] PRECEQU.PH.QBRA rt, rs - Expand the precision of the two
11531 * right-alternate elements of a quad byte vector
11532 *
11533 * 3 2 1
11534 * 10987654321098765432109876543210
11535 * 001000 00010001101
11536 * rt -----
11537 * rs -----
11538 * rd -----
11539 */
11540 static char *PRECEQU_PH_QBRA(uint64 instruction, Dis_info *info)
11541 {
11542 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11543 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11544
11545 const char *rt = GPR(rt_value, info);
11546 const char *rs = GPR(rs_value, info);
11547
11548 return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11549 }
11550
11551
11552 /*
11553 * [DSP] PRECEQU.PH.QBR rt, rs - Expand the precision of the two right-most
11554 * elements of a quad byte vector
11555 *
11556 * 3 2 1
11557 * 10987654321098765432109876543210
11558 * 001000 00010001101
11559 * rt -----
11560 * rs -----
11561 * rd -----
11562 */
11563 static char *PRECEQU_PH_QBR(uint64 instruction, Dis_info *info)
11564 {
11565 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11566 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11567
11568 const char *rt = GPR(rt_value, info);
11569 const char *rs = GPR(rs_value, info);
11570
11571 return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
11572 }
11573
11574
11575 /*
11576 * [DSP] PRECEU.PH.QBLA rt, rs - Expand the precision of the two
11577 * left-alternate elements of a quad byte vector to four unsigned
11578 * halfwords
11579 *
11580 * 3 2 1
11581 * 10987654321098765432109876543210
11582 * 001000 00010001101
11583 * rt -----
11584 * rs -----
11585 * rd -----
11586 */
11587 static char *PRECEU_PH_QBLA(uint64 instruction, Dis_info *info)
11588 {
11589 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11590 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11591
11592 const char *rt = GPR(rt_value, info);
11593 const char *rs = GPR(rs_value, info);
11594
11595 return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
11596 }
11597
11598
11599 /*
11600 * [DSP] PRECEU.PH.QBL rt, rs - Expand the precision of the two left-most
11601 * elements of a quad byte vector to form unsigned halfwords
11602 *
11603 * 3 2 1
11604 * 10987654321098765432109876543210
11605 * 001000 00010001101
11606 * rt -----
11607 * rs -----
11608 * rd -----
11609 */
11610 static char *PRECEU_PH_QBL(uint64 instruction, Dis_info *info)
11611 {
11612 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11613 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11614
11615 const char *rt = GPR(rt_value, info);
11616 const char *rs = GPR(rs_value, info);
11617
11618 return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
11619 }
11620
11621
11622 /*
11623 * [DSP] PRECEU.PH.QBRA rt, rs - Expand the precision of the two
11624 * right-alternate elements of a quad byte vector to form four
11625 * unsigned halfwords
11626 *
11627 * 3 2 1
11628 * 10987654321098765432109876543210
11629 * 001000 00010001101
11630 * rt -----
11631 * rs -----
11632 * rd -----
11633 */
11634 static char *PRECEU_PH_QBRA(uint64 instruction, Dis_info *info)
11635 {
11636 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11637 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11638
11639 const char *rt = GPR(rt_value, info);
11640 const char *rs = GPR(rs_value, info);
11641
11642 return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
11643 }
11644
11645
11646 /*
11647 * [DSP] PRECEU.PH.QBR rt, rs - Expand the precision of the two right-most
11648 * elements of a quad byte vector to form unsigned halfwords
11649 *
11650 * 3 2 1
11651 * 10987654321098765432109876543210
11652 * 001000 00010001101
11653 * rt -----
11654 * rs -----
11655 * rd -----
11656 */
11657 static char *PRECEU_PH_QBR(uint64 instruction, Dis_info *info)
11658 {
11659 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11660 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11661
11662 const char *rt = GPR(rt_value, info);
11663 const char *rs = GPR(rs_value, info);
11664
11665 return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
11666 }
11667
11668
11669 /*
11670 * [DSP] PRECR.QB.PH rd, rs, rt - Reduce the precision of four integer
11671 * halfwords to four bytes
11672 *
11673 * 3 2 1
11674 * 10987654321098765432109876543210
11675 * 001000 x0001101101
11676 * rt -----
11677 * rs -----
11678 * rd -----
11679 */
11680 static char *PRECR_QB_PH(uint64 instruction, Dis_info *info)
11681 {
11682 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11683 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11684 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11685
11686 const char *rd = GPR(rd_value, info);
11687 const char *rs = GPR(rs_value, info);
11688 const char *rt = GPR(rt_value, info);
11689
11690 return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
11691 }
11692
11693
11694 /*
11695 * [DSP] PRECR_SRA.PH.W rt, rs, sa - Reduce the precision of two integer
11696 * words to halfwords after a right shift
11697 *
11698 * 3 2 1
11699 * 10987654321098765432109876543210
11700 * 001000 x1110000101
11701 * rt -----
11702 * rs -----
11703 * rd -----
11704 */
11705 static char *PRECR_SRA_PH_W(uint64 instruction, Dis_info *info)
11706 {
11707 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11708 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11709 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11710
11711 const char *rt = GPR(rt_value, info);
11712 const char *rs = GPR(rs_value, info);
11713
11714 return img_format("PRECR_SRA.PH.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11715 }
11716
11717
11718 /*
11719 * [DSP] PRECR_SRA_R.PH.W rt, rs, sa - Reduce the precision of two integer
11720 * words to halfwords after a right shift with rounding
11721 *
11722 * 3 2 1
11723 * 10987654321098765432109876543210
11724 * 001000 x1110000101
11725 * rt -----
11726 * rs -----
11727 * rd -----
11728 */
11729 static char *PRECR_SRA_R_PH_W(uint64 instruction, Dis_info *info)
11730 {
11731 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11732 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11733 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11734
11735 const char *rt = GPR(rt_value, info);
11736 const char *rs = GPR(rs_value, info);
11737
11738 return img_format("PRECR_SRA_R.PH.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11739 }
11740
11741
11742 /*
11743 * [DSP] PRECRQ.PH.W rd, rs, rt - Reduce the precision of fractional
11744 * words to fractional halfwords
11745 *
11746 * 3 2 1
11747 * 10987654321098765432109876543210
11748 * 001000 x1110000101
11749 * rt -----
11750 * rs -----
11751 * rd -----
11752 */
11753 static char *PRECRQ_PH_W(uint64 instruction, Dis_info *info)
11754 {
11755 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11756 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11757 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11758
11759 const char *rd = GPR(rd_value, info);
11760 const char *rs = GPR(rs_value, info);
11761 const char *rt = GPR(rt_value, info);
11762
11763 return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
11764 }
11765
11766
11767 /*
11768 * [DSP] PRECRQ.QB.PH rd, rs, rt - Reduce the precision of four fractional
11769 * halfwords to four bytes
11770 *
11771 * 3 2 1
11772 * 10987654321098765432109876543210
11773 * 001000 x0010101101
11774 * rt -----
11775 * rs -----
11776 * rd -----
11777 */
11778 static char *PRECRQ_QB_PH(uint64 instruction, Dis_info *info)
11779 {
11780 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11781 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11782 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11783
11784 const char *rd = GPR(rd_value, info);
11785 const char *rs = GPR(rs_value, info);
11786 const char *rt = GPR(rt_value, info);
11787
11788 return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
11789 }
11790
11791
11792 /*
11793 * [DSP] PRECRQ_RS.PH.W rd, rs, rt - Reduce the precision of fractional
11794 * words to halfwords with rounding and saturation
11795 *
11796 * 3 2 1
11797 * 10987654321098765432109876543210
11798 * 001000 x1110000101
11799 * rt -----
11800 * rs -----
11801 * rd -----
11802 */
11803 static char *PRECRQ_RS_PH_W(uint64 instruction, Dis_info *info)
11804 {
11805 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11806 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11807 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11808
11809 const char *rd = GPR(rd_value, info);
11810 const char *rs = GPR(rs_value, info);
11811 const char *rt = GPR(rt_value, info);
11812
11813 return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
11814 }
11815
11816
11817 /*
11818 * [DSP] PRECRQU_S.QB.PH rd, rs, rt - Reduce the precision of fractional
11819 * halfwords to unsigned bytes with saturation
11820 *
11821 * 3 2 1
11822 * 10987654321098765432109876543210
11823 * 001000 x1110000101
11824 * rt -----
11825 * rs -----
11826 * rd -----
11827 */
11828 static char *PRECRQU_S_QB_PH(uint64 instruction, Dis_info *info)
11829 {
11830 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11831 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11832 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11833
11834 const char *rd = GPR(rd_value, info);
11835 const char *rs = GPR(rs_value, info);
11836 const char *rt = GPR(rt_value, info);
11837
11838 return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
11839 }
11840
11841
11842 /*
11843 *
11844 *
11845 * 3 2 1
11846 * 10987654321098765432109876543210
11847 * 001000 x1110000101
11848 * rt -----
11849 * rs -----
11850 * rd -----
11851 */
11852 static char *PREF_S9_(uint64 instruction, Dis_info *info)
11853 {
11854 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11855 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11856 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
11857
11858 const char *rs = GPR(rs_value, info);
11859
11860 return img_format("PREF 0x%" PRIx64 ", %" PRId64 "(%s)",
11861 hint_value, s_value, rs);
11862 }
11863
11864
11865 /*
11866 *
11867 *
11868 * 3 2 1
11869 * 10987654321098765432109876543210
11870 * 001000 x1110000101
11871 * rt -----
11872 * rs -----
11873 * rd -----
11874 */
11875 static char *PREF_U12_(uint64 instruction, Dis_info *info)
11876 {
11877 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11878 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11879 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11880
11881 const char *rs = GPR(rs_value, info);
11882
11883 return img_format("PREF 0x%" PRIx64 ", 0x%" PRIx64 "(%s)",
11884 hint_value, u_value, rs);
11885 }
11886
11887
11888 /*
11889 *
11890 *
11891 * 3 2 1
11892 * 10987654321098765432109876543210
11893 * 001000 x1110000101
11894 * rt -----
11895 * rs -----
11896 * rd -----
11897 */
11898 static char *PREFE(uint64 instruction, Dis_info *info)
11899 {
11900 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11901 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11902 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
11903
11904 const char *rs = GPR(rs_value, info);
11905
11906 return img_format("PREFE 0x%" PRIx64 ", %" PRId64 "(%s)",
11907 hint_value, s_value, rs);
11908 }
11909
11910
11911 /*
11912 * [DSP] PREPEND rt, rs, sa - Right shift and prepend bits to the MSB
11913 *
11914 * 3 2 1
11915 * 10987654321098765432109876543210
11916 * 001000 x1110000101
11917 * rt -----
11918 * rs -----
11919 * rd -----
11920 */
11921 static char *PREPEND(uint64 instruction, Dis_info *info)
11922 {
11923 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11924 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11925 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11926
11927 const char *rt = GPR(rt_value, info);
11928 const char *rs = GPR(rs_value, info);
11929
11930 return img_format("PREPEND %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11931 }
11932
11933
11934 /*
11935 * [DSP] RADDU.W.QB rt, rs - Unsigned reduction add of vector quad bytes
11936 *
11937 * 3 2 1
11938 * 10987654321098765432109876543210
11939 * 001000 1111000100111111
11940 * rt -----
11941 * rs -----
11942 */
11943 static char *RADDU_W_QB(uint64 instruction, Dis_info *info)
11944 {
11945 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11946 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11947
11948 const char *rt = GPR(rt_value, info);
11949 const char *rs = GPR(rs_value, info);
11950
11951 return img_format("RADDU.W.QB %s, %s", rt, rs);
11952 }
11953
11954
11955 /*
11956 * [DSP] RDDSP rt, mask - Read DSPControl register fields to a GPR
11957 *
11958 * 3 2 1
11959 * 10987654321098765432109876543210
11960 * 001000 00011001111111
11961 * rt -----
11962 * mask -------
11963 */
11964 static char *RDDSP(uint64 instruction, Dis_info *info)
11965 {
11966 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11967 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
11968
11969 const char *rt = GPR(rt_value, info);
11970
11971 return img_format("RDDSP %s, 0x%" PRIx64, rt, mask_value);
11972 }
11973
11974
11975 /*
11976 *
11977 *
11978 * 3 2 1
11979 * 10987654321098765432109876543210
11980 * 001000 x1110000101
11981 * rt -----
11982 * rs -----
11983 * rd -----
11984 */
11985 static char *RDHWR(uint64 instruction, Dis_info *info)
11986 {
11987 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11988 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
11989 uint64 sel_value = extract_sel_13_12_11(instruction);
11990
11991 const char *rt = GPR(rt_value, info);
11992
11993 return img_format("RDHWR %s, CP%" PRIu64 ", 0x%" PRIx64,
11994 rt, hs_value, sel_value);
11995 }
11996
11997
11998 /*
11999 *
12000 *
12001 * 3 2 1
12002 * 10987654321098765432109876543210
12003 * 001000 x1110000101
12004 * rt -----
12005 * rs -----
12006 * rd -----
12007 */
12008 static char *RDPGPR(uint64 instruction, Dis_info *info)
12009 {
12010 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12011 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12012
12013 const char *rt = GPR(rt_value, info);
12014 const char *rs = GPR(rs_value, info);
12015
12016 return img_format("RDPGPR %s, %s", rt, rs);
12017 }
12018
12019
12020 /*
12021 *
12022 *
12023 * 3 2 1
12024 * 10987654321098765432109876543210
12025 * 001000 x1110000101
12026 * rt -----
12027 * rs -----
12028 * rd -----
12029 */
12030 static char *RECIP_D(uint64 instruction, Dis_info *info)
12031 {
12032 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12033 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12034
12035 const char *ft = FPR(ft_value, info);
12036 const char *fs = FPR(fs_value, info);
12037
12038 return img_format("RECIP.D %s, %s", ft, fs);
12039 }
12040
12041
12042 /*
12043 *
12044 *
12045 * 3 2 1
12046 * 10987654321098765432109876543210
12047 * 001000 x1110000101
12048 * rt -----
12049 * rs -----
12050 * rd -----
12051 */
12052 static char *RECIP_S(uint64 instruction, Dis_info *info)
12053 {
12054 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12055 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12056
12057 const char *ft = FPR(ft_value, info);
12058 const char *fs = FPR(fs_value, info);
12059
12060 return img_format("RECIP.S %s, %s", ft, fs);
12061 }
12062
12063
12064 /*
12065 * [DSP] REPL.PH rd, s - Replicate immediate integer into all vector element
12066 * positions
12067 *
12068 * 3 2 1
12069 * 10987654321098765432109876543210
12070 * 001000 x0000111101
12071 * rt -----
12072 * s ----------
12073 */
12074 static char *REPL_PH(uint64 instruction, Dis_info *info)
12075 {
12076 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12077 int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
12078
12079 const char *rt = GPR(rt_value, info);
12080
12081 return img_format("REPL.PH %s, %" PRId64, rt, s_value);
12082 }
12083
12084
12085 /*
12086 * [DSP] REPL.QB rd, u - Replicate immediate integer into all vector element
12087 * positions
12088 *
12089 * 3 2 1
12090 * 10987654321098765432109876543210
12091 * 001000 x010111111111
12092 * rt -----
12093 * u --------
12094 */
12095 static char *REPL_QB(uint64 instruction, Dis_info *info)
12096 {
12097 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12098 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12099
12100 const char *rt = GPR(rt_value, info);
12101
12102 return img_format("REPL.QB %s, 0x%" PRIx64, rt, u_value);
12103 }
12104
12105
12106 /*
12107 * [DSP] REPLV.PH rt, rs - Replicate a halfword into all vector element
12108 * positions
12109 *
12110 * 3 2 1
12111 * 10987654321098765432109876543210
12112 * 001000 0000001100111111
12113 * rt -----
12114 * rs -----
12115 */
12116 static char *REPLV_PH(uint64 instruction, Dis_info *info)
12117 {
12118 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12119 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12120
12121 const char *rt = GPR(rt_value, info);
12122 const char *rs = GPR(rs_value, info);
12123
12124 return img_format("REPLV.PH %s, %s", rt, rs);
12125 }
12126
12127
12128 /*
12129 * [DSP] REPLV.QB rt, rs - Replicate byte into all vector element positions
12130 *
12131 * 3 2 1
12132 * 10987654321098765432109876543210
12133 * 001000 0001001100111111
12134 * rt -----
12135 * rs -----
12136 */
12137 static char *REPLV_QB(uint64 instruction, Dis_info *info)
12138 {
12139 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12140 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12141
12142 const char *rt = GPR(rt_value, info);
12143 const char *rs = GPR(rs_value, info);
12144
12145 return img_format("REPLV.QB %s, %s", rt, rs);
12146 }
12147
12148
12149 /*
12150 *
12151 *
12152 * 3 2 1
12153 * 10987654321098765432109876543210
12154 * 001000 x1110000101
12155 * rt -----
12156 * rs -----
12157 * rd -----
12158 */
12159 static char *RESTORE_32_(uint64 instruction, Dis_info *info)
12160 {
12161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12162 uint64 count_value = extract_count_19_18_17_16(instruction);
12163 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12164 uint64 gp_value = extract_gp_2(instruction);
12165
12166 g_autofree char *save_restore_str = save_restore_list(
12167 rt_value, count_value, gp_value, info);
12168 return img_format("RESTORE 0x%" PRIx64 "%s", u_value, save_restore_str);
12169 }
12170
12171
12172 /*
12173 *
12174 *
12175 * 3 2 1
12176 * 10987654321098765432109876543210
12177 * 001000 x1110000101
12178 * rt -----
12179 * rs -----
12180 * rd -----
12181 */
12182 static char *RESTORE_JRC_16_(uint64 instruction, Dis_info *info)
12183 {
12184 uint64 rt1_value = extract_rtl_11(instruction);
12185 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12186 uint64 count_value = extract_count_3_2_1_0(instruction);
12187
12188 g_autofree char *save_restore_str = save_restore_list(
12189 encode_rt1_from_rt(rt1_value), count_value, 0, info);
12190 return img_format("RESTORE.JRC 0x%" PRIx64 "%s", u_value, save_restore_str);
12191 }
12192
12193
12194 /*
12195 *
12196 *
12197 * 3 2 1
12198 * 10987654321098765432109876543210
12199 * 001000 x1110000101
12200 * rt -----
12201 * rs -----
12202 * rd -----
12203 */
12204 static char *RESTORE_JRC_32_(uint64 instruction, Dis_info *info)
12205 {
12206 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12207 uint64 count_value = extract_count_19_18_17_16(instruction);
12208 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12209 uint64 gp_value = extract_gp_2(instruction);
12210
12211 g_autofree char *save_restore_str = save_restore_list(
12212 rt_value, count_value, gp_value, info);
12213 return img_format("RESTORE.JRC 0x%" PRIx64 "%s", u_value,
12214 save_restore_str);
12215 }
12216
12217
12218 /*
12219 *
12220 *
12221 * 3 2 1
12222 * 10987654321098765432109876543210
12223 * 001000 x1110000101
12224 * rt -----
12225 * rs -----
12226 * rd -----
12227 */
12228 static char *RESTOREF(uint64 instruction, Dis_info *info)
12229 {
12230 uint64 count_value = extract_count_19_18_17_16(instruction);
12231 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12232
12233
12234 return img_format("RESTOREF 0x%" PRIx64 ", 0x%" PRIx64,
12235 u_value, count_value);
12236 }
12237
12238
12239 /*
12240 *
12241 *
12242 * 3 2 1
12243 * 10987654321098765432109876543210
12244 * 001000 x1110000101
12245 * rt -----
12246 * rs -----
12247 * rd -----
12248 */
12249 static char *RINT_D(uint64 instruction, Dis_info *info)
12250 {
12251 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12252 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12253
12254 const char *ft = FPR(ft_value, info);
12255 const char *fs = FPR(fs_value, info);
12256
12257 return img_format("RINT.D %s, %s", ft, fs);
12258 }
12259
12260
12261 /*
12262 *
12263 *
12264 * 3 2 1
12265 * 10987654321098765432109876543210
12266 * 001000 x1110000101
12267 * rt -----
12268 * rs -----
12269 * rd -----
12270 */
12271 static char *RINT_S(uint64 instruction, Dis_info *info)
12272 {
12273 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12274 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12275
12276 const char *ft = FPR(ft_value, info);
12277 const char *fs = FPR(fs_value, info);
12278
12279 return img_format("RINT.S %s, %s", ft, fs);
12280 }
12281
12282
12283 /*
12284 *
12285 *
12286 * 3 2 1
12287 * 10987654321098765432109876543210
12288 * 001000 x1110000101
12289 * rt -----
12290 * rs -----
12291 * rd -----
12292 */
12293 static char *ROTR(uint64 instruction, Dis_info *info)
12294 {
12295 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12296 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12297 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12298
12299 const char *rt = GPR(rt_value, info);
12300 const char *rs = GPR(rs_value, info);
12301
12302 return img_format("ROTR %s, %s, 0x%" PRIx64, rt, rs, shift_value);
12303 }
12304
12305
12306 /*
12307 *
12308 *
12309 * 3 2 1
12310 * 10987654321098765432109876543210
12311 * 001000 x1110000101
12312 * rt -----
12313 * rs -----
12314 * rd -----
12315 */
12316 static char *ROTRV(uint64 instruction, Dis_info *info)
12317 {
12318 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12319 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12320 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12321
12322 const char *rd = GPR(rd_value, info);
12323 const char *rs = GPR(rs_value, info);
12324 const char *rt = GPR(rt_value, info);
12325
12326 return img_format("ROTRV %s, %s, %s", rd, rs, rt);
12327 }
12328
12329
12330 /*
12331 *
12332 *
12333 * 3 2 1
12334 * 10987654321098765432109876543210
12335 * 001000 x1110000101
12336 * rt -----
12337 * rs -----
12338 * rd -----
12339 */
12340 static char *ROTX(uint64 instruction, Dis_info *info)
12341 {
12342 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12343 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12344 uint64 shiftx_value = extract_shiftx_10_9_8_7__s1(instruction);
12345 uint64 stripe_value = extract_stripe_6(instruction);
12346 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12347
12348 const char *rt = GPR(rt_value, info);
12349 const char *rs = GPR(rs_value, info);
12350
12351 return img_format("ROTX %s, %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
12352 rt, rs, shift_value, shiftx_value, stripe_value);
12353 }
12354
12355
12356 /*
12357 *
12358 *
12359 * 3 2 1
12360 * 10987654321098765432109876543210
12361 * 001000 x1110000101
12362 * rt -----
12363 * rs -----
12364 * rd -----
12365 */
12366 static char *ROUND_L_D(uint64 instruction, Dis_info *info)
12367 {
12368 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12369 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12370
12371 const char *ft = FPR(ft_value, info);
12372 const char *fs = FPR(fs_value, info);
12373
12374 return img_format("ROUND.L.D %s, %s", ft, fs);
12375 }
12376
12377
12378 /*
12379 *
12380 *
12381 * 3 2 1
12382 * 10987654321098765432109876543210
12383 * 001000 x1110000101
12384 * rt -----
12385 * rs -----
12386 * rd -----
12387 */
12388 static char *ROUND_L_S(uint64 instruction, Dis_info *info)
12389 {
12390 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12391 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12392
12393 const char *ft = FPR(ft_value, info);
12394 const char *fs = FPR(fs_value, info);
12395
12396 return img_format("ROUND.L.S %s, %s", ft, fs);
12397 }
12398
12399
12400 /*
12401 *
12402 *
12403 * 3 2 1
12404 * 10987654321098765432109876543210
12405 * 001000 x1110000101
12406 * rt -----
12407 * rs -----
12408 * rd -----
12409 */
12410 static char *ROUND_W_D(uint64 instruction, Dis_info *info)
12411 {
12412 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12413 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12414
12415 const char *ft = FPR(ft_value, info);
12416 const char *fs = FPR(fs_value, info);
12417
12418 return img_format("ROUND.W.D %s, %s", ft, fs);
12419 }
12420
12421
12422 /*
12423 *
12424 *
12425 * 3 2 1
12426 * 10987654321098765432109876543210
12427 * 001000 x1110000101
12428 * rt -----
12429 * rs -----
12430 * rd -----
12431 */
12432 static char *ROUND_W_S(uint64 instruction, Dis_info *info)
12433 {
12434 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12435 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12436
12437 const char *ft = FPR(ft_value, info);
12438 const char *fs = FPR(fs_value, info);
12439
12440 return img_format("ROUND.W.S %s, %s", ft, fs);
12441 }
12442
12443
12444 /*
12445 *
12446 *
12447 * 3 2 1
12448 * 10987654321098765432109876543210
12449 * 001000 x1110000101
12450 * rt -----
12451 * rs -----
12452 * rd -----
12453 */
12454 static char *RSQRT_D(uint64 instruction, Dis_info *info)
12455 {
12456 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12457 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12458
12459 const char *ft = FPR(ft_value, info);
12460 const char *fs = FPR(fs_value, info);
12461
12462 return img_format("RSQRT.D %s, %s", ft, fs);
12463 }
12464
12465
12466 /*
12467 *
12468 *
12469 * 3 2 1
12470 * 10987654321098765432109876543210
12471 * 001000 x1110000101
12472 * rt -----
12473 * rs -----
12474 * rd -----
12475 */
12476 static char *RSQRT_S(uint64 instruction, Dis_info *info)
12477 {
12478 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12479 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12480
12481 const char *ft = FPR(ft_value, info);
12482 const char *fs = FPR(fs_value, info);
12483
12484 return img_format("RSQRT.S %s, %s", ft, fs);
12485 }
12486
12487
12488 /*
12489 *
12490 *
12491 * 3 2 1
12492 * 10987654321098765432109876543210
12493 * 001000 01001001101
12494 * rt -----
12495 * rs -----
12496 * rd -----
12497 */
12498 static char *SAVE_16_(uint64 instruction, Dis_info *info)
12499 {
12500 uint64 rt1_value = extract_rtl_11(instruction);
12501 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12502 uint64 count_value = extract_count_3_2_1_0(instruction);
12503
12504 g_autofree char *save_restore_str = save_restore_list(
12505 encode_rt1_from_rt(rt1_value), count_value, 0, info);
12506 return img_format("SAVE 0x%" PRIx64 "%s", u_value, save_restore_str);
12507 }
12508
12509
12510 /*
12511 *
12512 *
12513 * 3 2 1
12514 * 10987654321098765432109876543210
12515 * 001000 01001001101
12516 * rt -----
12517 * rs -----
12518 * rd -----
12519 */
12520 static char *SAVE_32_(uint64 instruction, Dis_info *info)
12521 {
12522 uint64 count_value = extract_count_19_18_17_16(instruction);
12523 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12524 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12525 uint64 gp_value = extract_gp_2(instruction);
12526
12527 g_autofree char *save_restore_str = save_restore_list(
12528 rt_value, count_value, gp_value, info);
12529 return img_format("SAVE 0x%" PRIx64 "%s", u_value, save_restore_str);
12530 }
12531
12532
12533 /*
12534 *
12535 *
12536 * 3 2 1
12537 * 10987654321098765432109876543210
12538 * 001000 01001001101
12539 * rt -----
12540 * rs -----
12541 * rd -----
12542 */
12543 static char *SAVEF(uint64 instruction, Dis_info *info)
12544 {
12545 uint64 count_value = extract_count_19_18_17_16(instruction);
12546 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12547
12548
12549 return img_format("SAVEF 0x%" PRIx64 ", 0x%" PRIx64, u_value, count_value);
12550 }
12551
12552
12553 /*
12554 *
12555 *
12556 * 3 2 1
12557 * 10987654321098765432109876543210
12558 * 001000 01001001101
12559 * rt -----
12560 * rs -----
12561 * rd -----
12562 */
12563 static char *SB_16_(uint64 instruction, Dis_info *info)
12564 {
12565 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12566 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12567 uint64 u_value = extract_u_1_0(instruction);
12568
12569 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
12570 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
12571
12572 return img_format("SB %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
12573 }
12574
12575
12576 /*
12577 *
12578 *
12579 * 3 2 1
12580 * 10987654321098765432109876543210
12581 * 001000 01001001101
12582 * rt -----
12583 * rs -----
12584 * rd -----
12585 */
12586 static char *SB_GP_(uint64 instruction, Dis_info *info)
12587 {
12588 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12589 uint64 u_value = extract_u_17_to_0(instruction);
12590
12591 const char *rt = GPR(rt_value, info);
12592
12593 return img_format("SB %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
12594 }
12595
12596
12597 /*
12598 *
12599 *
12600 * 3 2 1
12601 * 10987654321098765432109876543210
12602 * 001000 01001001101
12603 * rt -----
12604 * rs -----
12605 * rd -----
12606 */
12607 static char *SB_S9_(uint64 instruction, Dis_info *info)
12608 {
12609 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12611 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12612
12613 const char *rt = GPR(rt_value, info);
12614 const char *rs = GPR(rs_value, info);
12615
12616 return img_format("SB %s, %" PRId64 "(%s)", rt, s_value, rs);
12617 }
12618
12619
12620 /*
12621 *
12622 *
12623 * 3 2 1
12624 * 10987654321098765432109876543210
12625 * 001000 01001001101
12626 * rt -----
12627 * rs -----
12628 * rd -----
12629 */
12630 static char *SB_U12_(uint64 instruction, Dis_info *info)
12631 {
12632 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12633 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12634 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12635
12636 const char *rt = GPR(rt_value, info);
12637 const char *rs = GPR(rs_value, info);
12638
12639 return img_format("SB %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
12640 }
12641
12642
12643 /*
12644 *
12645 *
12646 * 3 2 1
12647 * 10987654321098765432109876543210
12648 * 001000 01001001101
12649 * rt -----
12650 * rs -----
12651 * rd -----
12652 */
12653 static char *SBE(uint64 instruction, Dis_info *info)
12654 {
12655 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12656 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12657 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12658
12659 const char *rt = GPR(rt_value, info);
12660 const char *rs = GPR(rs_value, info);
12661
12662 return img_format("SBE %s, %" PRId64 "(%s)", rt, s_value, rs);
12663 }
12664
12665
12666 /*
12667 *
12668 *
12669 * 3 2 1
12670 * 10987654321098765432109876543210
12671 * 001000 01001001101
12672 * rt -----
12673 * rs -----
12674 * rd -----
12675 */
12676 static char *SBX(uint64 instruction, Dis_info *info)
12677 {
12678 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12679 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12680 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12681
12682 const char *rd = GPR(rd_value, info);
12683 const char *rs = GPR(rs_value, info);
12684 const char *rt = GPR(rt_value, info);
12685
12686 return img_format("SBX %s, %s(%s)", rd, rs, rt);
12687 }
12688
12689
12690 /*
12691 *
12692 *
12693 * 3 2 1
12694 * 10987654321098765432109876543210
12695 * 001000 01001001101
12696 * rt -----
12697 * rs -----
12698 * rd -----
12699 */
12700 static char *SC(uint64 instruction, Dis_info *info)
12701 {
12702 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12703 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12704 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
12705
12706 const char *rt = GPR(rt_value, info);
12707 const char *rs = GPR(rs_value, info);
12708
12709 return img_format("SC %s, %" PRId64 "(%s)", rt, s_value, rs);
12710 }
12711
12712
12713 /*
12714 *
12715 *
12716 * 3 2 1
12717 * 10987654321098765432109876543210
12718 * 001000 01001001101
12719 * rt -----
12720 * rs -----
12721 * rd -----
12722 */
12723 static char *SCD(uint64 instruction, Dis_info *info)
12724 {
12725 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12726 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12727 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
12728
12729 const char *rt = GPR(rt_value, info);
12730 const char *rs = GPR(rs_value, info);
12731
12732 return img_format("SCD %s, %" PRId64 "(%s)", rt, s_value, rs);
12733 }
12734
12735
12736 /*
12737 *
12738 *
12739 * 3 2 1
12740 * 10987654321098765432109876543210
12741 * 001000 01001001101
12742 * rt -----
12743 * rs -----
12744 * rd -----
12745 */
12746 static char *SCDP(uint64 instruction, Dis_info *info)
12747 {
12748 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12749 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12750 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12751
12752 const char *rt = GPR(rt_value, info);
12753 const char *ru = GPR(ru_value, info);
12754 const char *rs = GPR(rs_value, info);
12755
12756 return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
12757 }
12758
12759
12760 /*
12761 *
12762 *
12763 * 3 2 1
12764 * 10987654321098765432109876543210
12765 * 001000 01001001101
12766 * rt -----
12767 * rs -----
12768 * rd -----
12769 */
12770 static char *SCE(uint64 instruction, Dis_info *info)
12771 {
12772 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12773 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12774 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
12775
12776 const char *rt = GPR(rt_value, info);
12777 const char *rs = GPR(rs_value, info);
12778
12779 return img_format("SCE %s, %" PRId64 "(%s)", rt, s_value, rs);
12780 }
12781
12782
12783 /*
12784 *
12785 *
12786 * 3 2 1
12787 * 10987654321098765432109876543210
12788 * 001000 01001001101
12789 * rt -----
12790 * rs -----
12791 * rd -----
12792 */
12793 static char *SCWP(uint64 instruction, Dis_info *info)
12794 {
12795 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12796 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12797 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12798
12799 const char *rt = GPR(rt_value, info);
12800 const char *ru = GPR(ru_value, info);
12801 const char *rs = GPR(rs_value, info);
12802
12803 return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
12804 }
12805
12806
12807 /*
12808 *
12809 *
12810 * 3 2 1
12811 * 10987654321098765432109876543210
12812 * 001000 01001001101
12813 * rt -----
12814 * rs -----
12815 * rd -----
12816 */
12817 static char *SCWPE(uint64 instruction, Dis_info *info)
12818 {
12819 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12820 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12821 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12822
12823 const char *rt = GPR(rt_value, info);
12824 const char *ru = GPR(ru_value, info);
12825 const char *rs = GPR(rs_value, info);
12826
12827 return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
12828 }
12829
12830
12831 /*
12832 *
12833 *
12834 * 3 2 1
12835 * 10987654321098765432109876543210
12836 * 001000 01001001101
12837 * rt -----
12838 * rs -----
12839 * rd -----
12840 */
12841 static char *SD_GP_(uint64 instruction, Dis_info *info)
12842 {
12843 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12844 uint64 u_value = extract_u_20_to_3__s3(instruction);
12845
12846 const char *rt = GPR(rt_value, info);
12847
12848 return img_format("SD %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
12849 }
12850
12851
12852 /*
12853 *
12854 *
12855 * 3 2 1
12856 * 10987654321098765432109876543210
12857 * 001000 01001001101
12858 * rt -----
12859 * rs -----
12860 * rd -----
12861 */
12862 static char *SD_S9_(uint64 instruction, Dis_info *info)
12863 {
12864 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12865 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12866 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12867
12868 const char *rt = GPR(rt_value, info);
12869 const char *rs = GPR(rs_value, info);
12870
12871 return img_format("SD %s, %" PRId64 "(%s)", rt, s_value, rs);
12872 }
12873
12874
12875 /*
12876 *
12877 *
12878 * 3 2 1
12879 * 10987654321098765432109876543210
12880 * 001000 01001001101
12881 * rt -----
12882 * rs -----
12883 * rd -----
12884 */
12885 static char *SD_U12_(uint64 instruction, Dis_info *info)
12886 {
12887 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12888 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12889 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12890
12891 const char *rt = GPR(rt_value, info);
12892 const char *rs = GPR(rs_value, info);
12893
12894 return img_format("SD %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
12895 }
12896
12897
12898 /*
12899 *
12900 *
12901 * 3 2 1
12902 * 10987654321098765432109876543210
12903 * 001000 01001001101
12904 * rt -----
12905 * rs -----
12906 * rd -----
12907 */
12908 static char *SDBBP_16_(uint64 instruction, Dis_info *info)
12909 {
12910 uint64 code_value = extract_code_2_1_0(instruction);
12911
12912
12913 return img_format("SDBBP 0x%" PRIx64, code_value);
12914 }
12915
12916
12917 /*
12918 *
12919 *
12920 * 3 2 1
12921 * 10987654321098765432109876543210
12922 * 001000 01001001101
12923 * rt -----
12924 * rs -----
12925 * rd -----
12926 */
12927 static char *SDBBP_32_(uint64 instruction, Dis_info *info)
12928 {
12929 uint64 code_value = extract_code_18_to_0(instruction);
12930
12931
12932 return img_format("SDBBP 0x%" PRIx64, code_value);
12933 }
12934
12935
12936 /*
12937 *
12938 *
12939 * 3 2 1
12940 * 10987654321098765432109876543210
12941 * 001000 01001001101
12942 * rt -----
12943 * rs -----
12944 * rd -----
12945 */
12946 static char *SDC1_GP_(uint64 instruction, Dis_info *info)
12947 {
12948 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12949 uint64 u_value = extract_u_17_to_2__s2(instruction);
12950
12951 const char *ft = FPR(ft_value, info);
12952
12953 return img_format("SDC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
12954 }
12955
12956
12957 /*
12958 *
12959 *
12960 * 3 2 1
12961 * 10987654321098765432109876543210
12962 * 001000 01001001101
12963 * rt -----
12964 * rs -----
12965 * rd -----
12966 */
12967 static char *SDC1_S9_(uint64 instruction, Dis_info *info)
12968 {
12969 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12970 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12971 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12972
12973 const char *ft = FPR(ft_value, info);
12974 const char *rs = GPR(rs_value, info);
12975
12976 return img_format("SDC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
12977 }
12978
12979
12980 /*
12981 *
12982 *
12983 * 3 2 1
12984 * 10987654321098765432109876543210
12985 * 001000 01001001101
12986 * rt -----
12987 * rs -----
12988 * rd -----
12989 */
12990 static char *SDC1_U12_(uint64 instruction, Dis_info *info)
12991 {
12992 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12993 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12994 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12995
12996 const char *ft = FPR(ft_value, info);
12997 const char *rs = GPR(rs_value, info);
12998
12999 return img_format("SDC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
13000 }
13001
13002
13003 /*
13004 *
13005 *
13006 * 3 2 1
13007 * 10987654321098765432109876543210
13008 * 001000 01001001101
13009 * rt -----
13010 * rs -----
13011 * rd -----
13012 */
13013 static char *SDC1X(uint64 instruction, Dis_info *info)
13014 {
13015 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13016 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13017 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13018
13019 const char *ft = FPR(ft_value, info);
13020 const char *rs = GPR(rs_value, info);
13021 const char *rt = GPR(rt_value, info);
13022
13023 return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
13024 }
13025
13026
13027 /*
13028 *
13029 *
13030 * 3 2 1
13031 * 10987654321098765432109876543210
13032 * 001000 01001001101
13033 * rt -----
13034 * rs -----
13035 * rd -----
13036 */
13037 static char *SDC1XS(uint64 instruction, Dis_info *info)
13038 {
13039 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13040 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13041 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
13042
13043 const char *ft = FPR(ft_value, info);
13044 const char *rs = GPR(rs_value, info);
13045 const char *rt = GPR(rt_value, info);
13046
13047 return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
13048 }
13049
13050
13051 /*
13052 *
13053 *
13054 * 3 2 1
13055 * 10987654321098765432109876543210
13056 * 001000 01001001101
13057 * rt -----
13058 * rs -----
13059 * rd -----
13060 */
13061 static char *SDC2(uint64 instruction, Dis_info *info)
13062 {
13063 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
13064 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13065 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13066
13067 const char *rs = GPR(rs_value, info);
13068
13069 return img_format("SDC2 CP%" PRIu64 ", %" PRId64 "(%s)",
13070 cs_value, s_value, rs);
13071 }
13072
13073
13074 /*
13075 *
13076 *
13077 * 3 2 1
13078 * 10987654321098765432109876543210
13079 * 001000 01001001101
13080 * rt -----
13081 * rs -----
13082 * rd -----
13083 */
13084 static char *SDM(uint64 instruction, Dis_info *info)
13085 {
13086 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13087 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13088 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13089 uint64 count3_value = extract_count3_14_13_12(instruction);
13090
13091 const char *rt = GPR(rt_value, info);
13092 const char *rs = GPR(rs_value, info);
13093 uint64 count3 = encode_count3_from_count(count3_value);
13094
13095 return img_format("SDM %s, %" PRId64 "(%s), 0x%" PRIx64,
13096 rt, s_value, rs, count3);
13097 }
13098
13099
13100 /*
13101 *
13102 *
13103 * 3 2 1
13104 * 10987654321098765432109876543210
13105 * 001000 01001001101
13106 * rt -----
13107 * rs -----
13108 * rd -----
13109 */
13110 static char *SDPC_48_(uint64 instruction, Dis_info *info)
13111 {
13112 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13113 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
13114
13115 const char *rt = GPR(rt_value, info);
13116 g_autofree char *s = ADDRESS(s_value, 6, info);
13117
13118 return img_format("SDPC %s, %s", rt, s);
13119 }
13120
13121
13122 /*
13123 *
13124 *
13125 * 3 2 1
13126 * 10987654321098765432109876543210
13127 * 001000 01001001101
13128 * rt -----
13129 * rs -----
13130 * rd -----
13131 */
13132 static char *SDXS(uint64 instruction, Dis_info *info)
13133 {
13134 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13135 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13136 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13137
13138 const char *rd = GPR(rd_value, info);
13139 const char *rs = GPR(rs_value, info);
13140 const char *rt = GPR(rt_value, info);
13141
13142 return img_format("SDXS %s, %s(%s)", rd, rs, rt);
13143 }
13144
13145
13146 /*
13147 *
13148 *
13149 * 3 2 1
13150 * 10987654321098765432109876543210
13151 * 001000 01001001101
13152 * rt -----
13153 * rs -----
13154 * rd -----
13155 */
13156 static char *SDX(uint64 instruction, Dis_info *info)
13157 {
13158 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13159 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13160 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13161
13162 const char *rd = GPR(rd_value, info);
13163 const char *rs = GPR(rs_value, info);
13164 const char *rt = GPR(rt_value, info);
13165
13166 return img_format("SDX %s, %s(%s)", rd, rs, rt);
13167 }
13168
13169
13170 /*
13171 *
13172 *
13173 * 3 2 1
13174 * 10987654321098765432109876543210
13175 * 001000 01001001101
13176 * rt -----
13177 * rs -----
13178 * rd -----
13179 */
13180 static char *SEB(uint64 instruction, Dis_info *info)
13181 {
13182 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13183 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13184
13185 const char *rt = GPR(rt_value, info);
13186 const char *rs = GPR(rs_value, info);
13187
13188 return img_format("SEB %s, %s", rt, rs);
13189 }
13190
13191
13192 /*
13193 *
13194 *
13195 * 3 2 1
13196 * 10987654321098765432109876543210
13197 * 001000 01001001101
13198 * rt -----
13199 * rs -----
13200 * rd -----
13201 */
13202 static char *SEH(uint64 instruction, Dis_info *info)
13203 {
13204 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13205 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13206
13207 const char *rt = GPR(rt_value, info);
13208 const char *rs = GPR(rs_value, info);
13209
13210 return img_format("SEH %s, %s", rt, rs);
13211 }
13212
13213
13214 /*
13215 *
13216 *
13217 * 3 2 1
13218 * 10987654321098765432109876543210
13219 * 001000 01001001101
13220 * rt -----
13221 * rs -----
13222 * rd -----
13223 */
13224 static char *SEL_D(uint64 instruction, Dis_info *info)
13225 {
13226 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13227 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13228 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13229
13230 const char *fd = FPR(fd_value, info);
13231 const char *fs = FPR(fs_value, info);
13232 const char *ft = FPR(ft_value, info);
13233
13234 return img_format("SEL.D %s, %s, %s", fd, fs, ft);
13235 }
13236
13237
13238 /*
13239 *
13240 *
13241 * 3 2 1
13242 * 10987654321098765432109876543210
13243 * 001000 01001001101
13244 * rt -----
13245 * rs -----
13246 * rd -----
13247 */
13248 static char *SEL_S(uint64 instruction, Dis_info *info)
13249 {
13250 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13251 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13252 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13253
13254 const char *fd = FPR(fd_value, info);
13255 const char *fs = FPR(fs_value, info);
13256 const char *ft = FPR(ft_value, info);
13257
13258 return img_format("SEL.S %s, %s, %s", fd, fs, ft);
13259 }
13260
13261
13262 /*
13263 *
13264 *
13265 * 3 2 1
13266 * 10987654321098765432109876543210
13267 * 001000 01001001101
13268 * rt -----
13269 * rs -----
13270 * rd -----
13271 */
13272 static char *SELEQZ_D(uint64 instruction, Dis_info *info)
13273 {
13274 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13275 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13276 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13277
13278 const char *fd = FPR(fd_value, info);
13279 const char *fs = FPR(fs_value, info);
13280 const char *ft = FPR(ft_value, info);
13281
13282 return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13283 }
13284
13285
13286 /*
13287 *
13288 *
13289 * 3 2 1
13290 * 10987654321098765432109876543210
13291 * 001000 01001001101
13292 * rt -----
13293 * rs -----
13294 * rd -----
13295 */
13296 static char *SELEQZ_S(uint64 instruction, Dis_info *info)
13297 {
13298 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13299 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13300 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13301
13302 const char *fd = FPR(fd_value, info);
13303 const char *fs = FPR(fs_value, info);
13304 const char *ft = FPR(ft_value, info);
13305
13306 return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13307 }
13308
13309
13310 /*
13311 *
13312 *
13313 * 3 2 1
13314 * 10987654321098765432109876543210
13315 * 001000 01001001101
13316 * rt -----
13317 * rs -----
13318 * rd -----
13319 */
13320 static char *SELNEZ_D(uint64 instruction, Dis_info *info)
13321 {
13322 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13323 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13324 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13325
13326 const char *fd = FPR(fd_value, info);
13327 const char *fs = FPR(fs_value, info);
13328 const char *ft = FPR(ft_value, info);
13329
13330 return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13331 }
13332
13333
13334 /*
13335 *
13336 *
13337 * 3 2 1
13338 * 10987654321098765432109876543210
13339 * 001000 01001001101
13340 * rt -----
13341 * rs -----
13342 * rd -----
13343 */
13344 static char *SELNEZ_S(uint64 instruction, Dis_info *info)
13345 {
13346 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13347 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13348 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13349
13350 const char *fd = FPR(fd_value, info);
13351 const char *fs = FPR(fs_value, info);
13352 const char *ft = FPR(ft_value, info);
13353
13354 return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13355 }
13356
13357
13358 /*
13359 *
13360 *
13361 * 3 2 1
13362 * 10987654321098765432109876543210
13363 * 001000 01001001101
13364 * rt -----
13365 * rs -----
13366 * rd -----
13367 */
13368 static char *SEQI(uint64 instruction, Dis_info *info)
13369 {
13370 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13371 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13372 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13373
13374 const char *rt = GPR(rt_value, info);
13375 const char *rs = GPR(rs_value, info);
13376
13377 return img_format("SEQI %s, %s, 0x%" PRIx64, rt, rs, u_value);
13378 }
13379
13380
13381 /*
13382 *
13383 *
13384 * 3 2 1
13385 * 10987654321098765432109876543210
13386 * 001000 01001001101
13387 * rt -----
13388 * rs -----
13389 * rd -----
13390 */
13391 static char *SH_16_(uint64 instruction, Dis_info *info)
13392 {
13393 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13394 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13395 uint64 u_value = extract_u_2_1__s1(instruction);
13396
13397 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
13398 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
13399
13400 return img_format("SH %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
13401 }
13402
13403
13404 /*
13405 *
13406 *
13407 * 3 2 1
13408 * 10987654321098765432109876543210
13409 * 001000 01001001101
13410 * rt -----
13411 * rs -----
13412 * rd -----
13413 */
13414 static char *SH_GP_(uint64 instruction, Dis_info *info)
13415 {
13416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13417 uint64 u_value = extract_u_17_to_1__s1(instruction);
13418
13419 const char *rt = GPR(rt_value, info);
13420
13421 return img_format("SH %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
13422 }
13423
13424
13425 /*
13426 *
13427 *
13428 * 3 2 1
13429 * 10987654321098765432109876543210
13430 * 001000 01001001101
13431 * rt -----
13432 * rs -----
13433 * rd -----
13434 */
13435 static char *SH_S9_(uint64 instruction, Dis_info *info)
13436 {
13437 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13438 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13439 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13440
13441 const char *rt = GPR(rt_value, info);
13442 const char *rs = GPR(rs_value, info);
13443
13444 return img_format("SH %s, %" PRId64 "(%s)", rt, s_value, rs);
13445 }
13446
13447
13448 /*
13449 *
13450 *
13451 * 3 2 1
13452 * 10987654321098765432109876543210
13453 * 001000 01001001101
13454 * rt -----
13455 * rs -----
13456 * rd -----
13457 */
13458 static char *SH_U12_(uint64 instruction, Dis_info *info)
13459 {
13460 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13462 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13463
13464 const char *rt = GPR(rt_value, info);
13465 const char *rs = GPR(rs_value, info);
13466
13467 return img_format("SH %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
13468 }
13469
13470
13471 /*
13472 *
13473 *
13474 * 3 2 1
13475 * 10987654321098765432109876543210
13476 * 001000 01001001101
13477 * rt -----
13478 * rs -----
13479 * rd -----
13480 */
13481 static char *SHE(uint64 instruction, Dis_info *info)
13482 {
13483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13485 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13486
13487 const char *rt = GPR(rt_value, info);
13488 const char *rs = GPR(rs_value, info);
13489
13490 return img_format("SHE %s, %" PRId64 "(%s)", rt, s_value, rs);
13491 }
13492
13493
13494 /*
13495 * [DSP] SHILO ac, shift - Shift an accumulator value leaving the result in
13496 * the same accumulator
13497 *
13498 * 3 2 1
13499 * 10987654321098765432109876543210
13500 * 001000xxxx xxxx0000011101
13501 * shift ------
13502 * ac --
13503 */
13504 static char *SHILO(uint64 instruction, Dis_info *info)
13505 {
13506 int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
13507 uint64 ac_value = extract_ac_15_14(instruction);
13508
13509 const char *ac = AC(ac_value, info);
13510
13511 return img_format("SHILO %s, 0x%" PRIx64, ac, shift_value);
13512 }
13513
13514
13515 /*
13516 * [DSP] SHILOV ac, rs - Variable shift of accumulator value leaving the result
13517 * in the same accumulator
13518 *
13519 * 3 2 1
13520 * 10987654321098765432109876543210
13521 * 001000xxxxx 01001001111111
13522 * rs -----
13523 * ac --
13524 */
13525 static char *SHILOV(uint64 instruction, Dis_info *info)
13526 {
13527 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13528 uint64 ac_value = extract_ac_15_14(instruction);
13529
13530 const char *rs = GPR(rs_value, info);
13531 const char *ac = AC(ac_value, info);
13532
13533 return img_format("SHILOV %s, %s", ac, rs);
13534 }
13535
13536
13537 /*
13538 * [DSP] SHLL.PH rt, rs, sa - Shift left logical vector pair halfwords
13539 *
13540 * 3 2 1
13541 * 10987654321098765432109876543210
13542 * 001000 001110110101
13543 * rt -----
13544 * rs -----
13545 * sa ----
13546 */
13547 static char *SHLL_PH(uint64 instruction, Dis_info *info)
13548 {
13549 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13550 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13551 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13552
13553 const char *rt = GPR(rt_value, info);
13554 const char *rs = GPR(rs_value, info);
13555
13556 return img_format("SHLL.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13557 }
13558
13559
13560 /*
13561 * [DSP] SHLL.QB rt, rs, sa - Shift left logical vector quad bytes
13562 *
13563 * 3 2 1
13564 * 10987654321098765432109876543210
13565 * 001000 0100001111111
13566 * rt -----
13567 * rs -----
13568 * sa ---
13569 */
13570 static char *SHLL_QB(uint64 instruction, Dis_info *info)
13571 {
13572 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13573 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13574 uint64 sa_value = extract_sa_15_14_13(instruction);
13575
13576 const char *rt = GPR(rt_value, info);
13577 const char *rs = GPR(rs_value, info);
13578
13579 return img_format("SHLL.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13580 }
13581
13582
13583 /*
13584 * [DSP] SHLL_S.PH rt, rs, sa - Shift left logical vector pair halfwords
13585 * with saturation
13586 *
13587 * 3 2 1
13588 * 10987654321098765432109876543210
13589 * 001000 001110110101
13590 * rt -----
13591 * rs -----
13592 * sa ----
13593 */
13594 static char *SHLL_S_PH(uint64 instruction, Dis_info *info)
13595 {
13596 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13597 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13598 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13599
13600 const char *rt = GPR(rt_value, info);
13601 const char *rs = GPR(rs_value, info);
13602
13603 return img_format("SHLL_S.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13604 }
13605
13606
13607 /*
13608 * [DSP] SHLL_S.PH rt, rs, sa - Shift left logical word with saturation
13609 *
13610 * 3 2 1
13611 * 10987654321098765432109876543210
13612 * 001000 x1111110101
13613 * rt -----
13614 * rs -----
13615 * sa -----
13616 */
13617 static char *SHLL_S_W(uint64 instruction, Dis_info *info)
13618 {
13619 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13620 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13621 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
13622
13623 const char *rt = GPR(rt_value, info);
13624 const char *rs = GPR(rs_value, info);
13625
13626 return img_format("SHLL_S.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13627 }
13628
13629
13630 /*
13631 * [DSP] SHLLV.PH rd, rt, rs - Shift left logical variable vector pair
13632 * halfwords
13633 *
13634 * 3 2 1
13635 * 10987654321098765432109876543210
13636 * 001000 01110001101
13637 * rt -----
13638 * rs -----
13639 * rd -----
13640 */
13641 static char *SHLLV_PH(uint64 instruction, Dis_info *info)
13642 {
13643 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13644 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13645 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13646
13647 const char *rd = GPR(rd_value, info);
13648 const char *rt = GPR(rt_value, info);
13649 const char *rs = GPR(rs_value, info);
13650
13651 return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
13652 }
13653
13654
13655 /*
13656 * [DSP] SHLLV_S.QB rd, rt, rs - Shift left logical variable vector quad bytes
13657 *
13658 * 3 2 1
13659 * 10987654321098765432109876543210
13660 * 001000 x1110010101
13661 * rt -----
13662 * rs -----
13663 * rd -----
13664 */
13665 static char *SHLLV_QB(uint64 instruction, Dis_info *info)
13666 {
13667 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13668 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13669 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13670
13671 const char *rd = GPR(rd_value, info);
13672 const char *rt = GPR(rt_value, info);
13673 const char *rs = GPR(rs_value, info);
13674
13675 return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
13676 }
13677
13678
13679 /*
13680 * [DSP] SHLLV.PH rd, rt, rs - Shift left logical variable vector pair
13681 * halfwords with saturation
13682 *
13683 * 3 2 1
13684 * 10987654321098765432109876543210
13685 * 001000 11110001101
13686 * rt -----
13687 * rs -----
13688 * rd -----
13689 */
13690 static char *SHLLV_S_PH(uint64 instruction, Dis_info *info)
13691 {
13692 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13693 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13694 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13695
13696 const char *rd = GPR(rd_value, info);
13697 const char *rt = GPR(rt_value, info);
13698 const char *rs = GPR(rs_value, info);
13699
13700 return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
13701 }
13702
13703
13704 /*
13705 * [DSP] SHLLV_S.W rd, rt, rs - Shift left logical variable vector word
13706 *
13707 * 3 2 1
13708 * 10987654321098765432109876543210
13709 * 001000 x1111010101
13710 * rt -----
13711 * rs -----
13712 * rd -----
13713 */
13714 static char *SHLLV_S_W(uint64 instruction, Dis_info *info)
13715 {
13716 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13717 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13718 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13719
13720 const char *rd = GPR(rd_value, info);
13721 const char *rt = GPR(rt_value, info);
13722 const char *rs = GPR(rs_value, info);
13723
13724 return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
13725 }
13726
13727
13728 /*
13729 *
13730 *
13731 * 3 2 1
13732 * 10987654321098765432109876543210
13733 * 001000 01001001101
13734 * rt -----
13735 * rs -----
13736 * rd -----
13737 */
13738 static char *SHRA_PH(uint64 instruction, Dis_info *info)
13739 {
13740 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13741 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13742 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13743
13744 const char *rt = GPR(rt_value, info);
13745 const char *rs = GPR(rs_value, info);
13746
13747 return img_format("SHRA.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13748 }
13749
13750
13751 /*
13752 *
13753 *
13754 * 3 2 1
13755 * 10987654321098765432109876543210
13756 * 001000 01001001101
13757 * rt -----
13758 * rs -----
13759 * rd -----
13760 */
13761 static char *SHRA_QB(uint64 instruction, Dis_info *info)
13762 {
13763 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13764 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13765 uint64 sa_value = extract_sa_15_14_13(instruction);
13766
13767 const char *rt = GPR(rt_value, info);
13768 const char *rs = GPR(rs_value, info);
13769
13770 return img_format("SHRA.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13771 }
13772
13773
13774 /*
13775 *
13776 *
13777 * 3 2 1
13778 * 10987654321098765432109876543210
13779 * 001000 01001001101
13780 * rt -----
13781 * rs -----
13782 * rd -----
13783 */
13784 static char *SHRA_R_PH(uint64 instruction, Dis_info *info)
13785 {
13786 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13787 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13788 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13789
13790 const char *rt = GPR(rt_value, info);
13791 const char *rs = GPR(rs_value, info);
13792
13793 return img_format("SHRA_R.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13794 }
13795
13796
13797 /*
13798 *
13799 *
13800 * 3 2 1
13801 * 10987654321098765432109876543210
13802 * 001000 01001001101
13803 * rt -----
13804 * rs -----
13805 * rd -----
13806 */
13807 static char *SHRA_R_QB(uint64 instruction, Dis_info *info)
13808 {
13809 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13810 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13811 uint64 sa_value = extract_sa_15_14_13(instruction);
13812
13813 const char *rt = GPR(rt_value, info);
13814 const char *rs = GPR(rs_value, info);
13815
13816 return img_format("SHRA_R.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13817 }
13818
13819
13820 /*
13821 *
13822 *
13823 * 3 2 1
13824 * 10987654321098765432109876543210
13825 * 001000 01001001101
13826 * rt -----
13827 * rs -----
13828 * rd -----
13829 */
13830 static char *SHRA_R_W(uint64 instruction, Dis_info *info)
13831 {
13832 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13834 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
13835
13836 const char *rt = GPR(rt_value, info);
13837 const char *rs = GPR(rs_value, info);
13838
13839 return img_format("SHRA_R.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13840 }
13841
13842
13843 /*
13844 *
13845 *
13846 * 3 2 1
13847 * 10987654321098765432109876543210
13848 * 001000 01001001101
13849 * rt -----
13850 * rs -----
13851 * rd -----
13852 */
13853 static char *SHRAV_PH(uint64 instruction, Dis_info *info)
13854 {
13855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13856 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13857 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13858
13859 const char *rd = GPR(rd_value, info);
13860 const char *rt = GPR(rt_value, info);
13861 const char *rs = GPR(rs_value, info);
13862
13863 return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
13864 }
13865
13866
13867 /*
13868 *
13869 *
13870 * 3 2 1
13871 * 10987654321098765432109876543210
13872 * 001000 01001001101
13873 * rt -----
13874 * rs -----
13875 * rd -----
13876 */
13877 static char *SHRAV_QB(uint64 instruction, Dis_info *info)
13878 {
13879 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13880 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13881 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13882
13883 const char *rd = GPR(rd_value, info);
13884 const char *rt = GPR(rt_value, info);
13885 const char *rs = GPR(rs_value, info);
13886
13887 return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
13888 }
13889
13890
13891 /*
13892 *
13893 *
13894 * 3 2 1
13895 * 10987654321098765432109876543210
13896 * 001000 01001001101
13897 * rt -----
13898 * rs -----
13899 * rd -----
13900 */
13901 static char *SHRAV_R_PH(uint64 instruction, Dis_info *info)
13902 {
13903 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13904 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13905 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13906
13907 const char *rd = GPR(rd_value, info);
13908 const char *rt = GPR(rt_value, info);
13909 const char *rs = GPR(rs_value, info);
13910
13911 return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
13912 }
13913
13914
13915 /*
13916 *
13917 *
13918 * 3 2 1
13919 * 10987654321098765432109876543210
13920 * 001000 01001001101
13921 * rt -----
13922 * rs -----
13923 * rd -----
13924 */
13925 static char *SHRAV_R_QB(uint64 instruction, Dis_info *info)
13926 {
13927 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13928 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13929 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13930
13931 const char *rd = GPR(rd_value, info);
13932 const char *rt = GPR(rt_value, info);
13933 const char *rs = GPR(rs_value, info);
13934
13935 return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
13936 }
13937
13938
13939 /*
13940 *
13941 *
13942 * 3 2 1
13943 * 10987654321098765432109876543210
13944 * 001000 01001001101
13945 * rt -----
13946 * rs -----
13947 * rd -----
13948 */
13949 static char *SHRAV_R_W(uint64 instruction, Dis_info *info)
13950 {
13951 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13952 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13953 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13954
13955 const char *rd = GPR(rd_value, info);
13956 const char *rt = GPR(rt_value, info);
13957 const char *rs = GPR(rs_value, info);
13958
13959 return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
13960 }
13961
13962
13963 /*
13964 * [DSP] SHRL.PH rt, rs, sa - Shift right logical two halfwords
13965 *
13966 * 3 2 1
13967 * 10987654321098765432109876543210
13968 * 001000 001111111111
13969 * rt -----
13970 * rs -----
13971 * sa ----
13972 */
13973 static char *SHRL_PH(uint64 instruction, Dis_info *info)
13974 {
13975 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13976 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13977 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13978
13979 const char *rt = GPR(rt_value, info);
13980 const char *rs = GPR(rs_value, info);
13981
13982 return img_format("SHRL.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13983 }
13984
13985
13986 /*
13987 * [DSP] SHRL.QB rt, rs, sa - Shift right logical vector quad bytes
13988 *
13989 * 3 2 1
13990 * 10987654321098765432109876543210
13991 * 001000 1100001111111
13992 * rt -----
13993 * rs -----
13994 * sa ---
13995 */
13996 static char *SHRL_QB(uint64 instruction, Dis_info *info)
13997 {
13998 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13999 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14000 uint64 sa_value = extract_sa_15_14_13(instruction);
14001
14002 const char *rt = GPR(rt_value, info);
14003 const char *rs = GPR(rs_value, info);
14004
14005 return img_format("SHRL.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
14006 }
14007
14008
14009 /*
14010 * [DSP] SHLLV.PH rd, rt, rs - Shift right logical variable vector pair of
14011 * halfwords
14012 *
14013 * 3 2 1
14014 * 10987654321098765432109876543210
14015 * 001000 x1100010101
14016 * rt -----
14017 * rs -----
14018 * rd -----
14019 */
14020 static char *SHRLV_PH(uint64 instruction, Dis_info *info)
14021 {
14022 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14023 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14024 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14025
14026 const char *rd = GPR(rd_value, info);
14027 const char *rt = GPR(rt_value, info);
14028 const char *rs = GPR(rs_value, info);
14029
14030 return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
14031 }
14032
14033
14034 /*
14035 * [DSP] SHLLV.QB rd, rt, rs - Shift right logical variable vector quad bytes
14036 *
14037 * 3 2 1
14038 * 10987654321098765432109876543210
14039 * 001000 x1101010101
14040 * rt -----
14041 * rs -----
14042 * rd -----
14043 */
14044 static char *SHRLV_QB(uint64 instruction, Dis_info *info)
14045 {
14046 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14047 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14048 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14049
14050 const char *rd = GPR(rd_value, info);
14051 const char *rt = GPR(rt_value, info);
14052 const char *rs = GPR(rs_value, info);
14053
14054 return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
14055 }
14056
14057
14058 /*
14059 *
14060 *
14061 * 3 2 1
14062 * 10987654321098765432109876543210
14063 * 001000 01001001101
14064 * rt -----
14065 * rs -----
14066 * rd -----
14067 */
14068 static char *SHX(uint64 instruction, Dis_info *info)
14069 {
14070 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14071 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14072 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14073
14074 const char *rd = GPR(rd_value, info);
14075 const char *rs = GPR(rs_value, info);
14076 const char *rt = GPR(rt_value, info);
14077
14078 return img_format("SHX %s, %s(%s)", rd, rs, rt);
14079 }
14080
14081
14082 /*
14083 *
14084 *
14085 * 3 2 1
14086 * 10987654321098765432109876543210
14087 * 001000 01001001101
14088 * rt -----
14089 * rs -----
14090 * rd -----
14091 */
14092 static char *SHXS(uint64 instruction, Dis_info *info)
14093 {
14094 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14095 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14096 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14097
14098 const char *rd = GPR(rd_value, info);
14099 const char *rs = GPR(rs_value, info);
14100 const char *rt = GPR(rt_value, info);
14101
14102 return img_format("SHXS %s, %s(%s)", rd, rs, rt);
14103 }
14104
14105
14106 /*
14107 *
14108 *
14109 * 3 2 1
14110 * 10987654321098765432109876543210
14111 * 001000 01001001101
14112 * rt -----
14113 * rs -----
14114 * rd -----
14115 */
14116 static char *SIGRIE(uint64 instruction, Dis_info *info)
14117 {
14118 uint64 code_value = extract_code_18_to_0(instruction);
14119
14120
14121 return img_format("SIGRIE 0x%" PRIx64, code_value);
14122 }
14123
14124
14125 /*
14126 *
14127 *
14128 * 3 2 1
14129 * 10987654321098765432109876543210
14130 * 001000 01001001101
14131 * rt -----
14132 * rs -----
14133 * rd -----
14134 */
14135 static char *SLL_16_(uint64 instruction, Dis_info *info)
14136 {
14137 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14138 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14139 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14140
14141 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14142 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14143 uint64 shift3 = encode_shift3_from_shift(shift3_value);
14144
14145 return img_format("SLL %s, %s, 0x%" PRIx64, rt3, rs3, shift3);
14146 }
14147
14148
14149 /*
14150 *
14151 *
14152 * 3 2 1
14153 * 10987654321098765432109876543210
14154 * 001000 01001001101
14155 * rt -----
14156 * rs -----
14157 * rd -----
14158 */
14159 static char *SLL_32_(uint64 instruction, Dis_info *info)
14160 {
14161 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14162 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14163 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14164
14165 const char *rt = GPR(rt_value, info);
14166 const char *rs = GPR(rs_value, info);
14167
14168 return img_format("SLL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14169 }
14170
14171
14172 /*
14173 *
14174 *
14175 * 3 2 1
14176 * 10987654321098765432109876543210
14177 * 001000 01001001101
14178 * rt -----
14179 * rs -----
14180 * rd -----
14181 */
14182 static char *SLLV(uint64 instruction, Dis_info *info)
14183 {
14184 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14185 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14186 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14187
14188 const char *rd = GPR(rd_value, info);
14189 const char *rs = GPR(rs_value, info);
14190 const char *rt = GPR(rt_value, info);
14191
14192 return img_format("SLLV %s, %s, %s", rd, rs, rt);
14193 }
14194
14195
14196 /*
14197 *
14198 *
14199 * 3 2 1
14200 * 10987654321098765432109876543210
14201 * 001000 01001001101
14202 * rt -----
14203 * rs -----
14204 * rd -----
14205 */
14206 static char *SLT(uint64 instruction, Dis_info *info)
14207 {
14208 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14209 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14210 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14211
14212 const char *rd = GPR(rd_value, info);
14213 const char *rs = GPR(rs_value, info);
14214 const char *rt = GPR(rt_value, info);
14215
14216 return img_format("SLT %s, %s, %s", rd, rs, rt);
14217 }
14218
14219
14220 /*
14221 *
14222 *
14223 * 3 2 1
14224 * 10987654321098765432109876543210
14225 * 001000 01001001101
14226 * rt -----
14227 * rs -----
14228 * rd -----
14229 */
14230 static char *SLTI(uint64 instruction, Dis_info *info)
14231 {
14232 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14233 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14234 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14235
14236 const char *rt = GPR(rt_value, info);
14237 const char *rs = GPR(rs_value, info);
14238
14239 return img_format("SLTI %s, %s, 0x%" PRIx64, rt, rs, u_value);
14240 }
14241
14242
14243 /*
14244 *
14245 *
14246 * 3 2 1
14247 * 10987654321098765432109876543210
14248 * 001000 01001001101
14249 * rt -----
14250 * rs -----
14251 * rd -----
14252 */
14253 static char *SLTIU(uint64 instruction, Dis_info *info)
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 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14258
14259 const char *rt = GPR(rt_value, info);
14260 const char *rs = GPR(rs_value, info);
14261
14262 return img_format("SLTIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
14263 }
14264
14265
14266 /*
14267 *
14268 *
14269 * 3 2 1
14270 * 10987654321098765432109876543210
14271 * 001000 01001001101
14272 * rt -----
14273 * rs -----
14274 * rd -----
14275 */
14276 static char *SLTU(uint64 instruction, Dis_info *info)
14277 {
14278 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14279 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14280 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14281
14282 const char *rd = GPR(rd_value, info);
14283 const char *rs = GPR(rs_value, info);
14284 const char *rt = GPR(rt_value, info);
14285
14286 return img_format("SLTU %s, %s, %s", rd, rs, rt);
14287 }
14288
14289
14290 /*
14291 *
14292 *
14293 * 3 2 1
14294 * 10987654321098765432109876543210
14295 * 001000 01001001101
14296 * rt -----
14297 * rs -----
14298 * rd -----
14299 */
14300 static char *SOV(uint64 instruction, Dis_info *info)
14301 {
14302 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14303 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14304 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14305
14306 const char *rd = GPR(rd_value, info);
14307 const char *rs = GPR(rs_value, info);
14308 const char *rt = GPR(rt_value, info);
14309
14310 return img_format("SOV %s, %s, %s", rd, rs, rt);
14311 }
14312
14313
14314 /*
14315 *
14316 *
14317 * 3 2 1
14318 * 10987654321098765432109876543210
14319 * 001000 01001001101
14320 * rt -----
14321 * rs -----
14322 * rd -----
14323 */
14324 static char *SPECIAL2(uint64 instruction, Dis_info *info)
14325 {
14326 uint64 op_value = extract_op_25_to_3(instruction);
14327
14328
14329 return img_format("SPECIAL2 0x%" PRIx64, op_value);
14330 }
14331
14332
14333 /*
14334 *
14335 *
14336 * 3 2 1
14337 * 10987654321098765432109876543210
14338 * 001000 01001001101
14339 * rt -----
14340 * rs -----
14341 * rd -----
14342 */
14343 static char *SQRT_D(uint64 instruction, Dis_info *info)
14344 {
14345 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14346 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14347
14348 const char *ft = FPR(ft_value, info);
14349 const char *fs = FPR(fs_value, info);
14350
14351 return img_format("SQRT.D %s, %s", ft, fs);
14352 }
14353
14354
14355 /*
14356 *
14357 *
14358 * 3 2 1
14359 * 10987654321098765432109876543210
14360 * 001000 01001001101
14361 * rt -----
14362 * rs -----
14363 * rd -----
14364 */
14365 static char *SQRT_S(uint64 instruction, Dis_info *info)
14366 {
14367 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14368 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14369
14370 const char *ft = FPR(ft_value, info);
14371 const char *fs = FPR(fs_value, info);
14372
14373 return img_format("SQRT.S %s, %s", ft, fs);
14374 }
14375
14376
14377 /*
14378 * SRA rd, rt, sa - Shift Word Right Arithmetic
14379 *
14380 * 3 2 1
14381 * 10987654321098765432109876543210
14382 * 00000000000 000011
14383 * rt -----
14384 * rd -----
14385 * sa -----
14386 */
14387 static char *SRA(uint64 instruction, Dis_info *info)
14388 {
14389 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14390 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14391 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14392
14393 const char *rt = GPR(rt_value, info);
14394 const char *rs = GPR(rs_value, info);
14395
14396 return img_format("SRA %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14397 }
14398
14399
14400 /*
14401 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14402 *
14403 * 3 2 1
14404 * 10987654321098765432109876543210
14405 * 001000 00000000111
14406 * rs -----
14407 * rt -----
14408 * rd -----
14409 */
14410 static char *SRAV(uint64 instruction, Dis_info *info)
14411 {
14412 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14413 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14414 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14415
14416 const char *rd = GPR(rd_value, info);
14417 const char *rs = GPR(rs_value, info);
14418 const char *rt = GPR(rt_value, info);
14419
14420 return img_format("SRAV %s, %s, %s", rd, rs, rt);
14421 }
14422
14423
14424 /*
14425 *
14426 *
14427 * 3 2 1
14428 * 10987654321098765432109876543210
14429 * 001000 00000000111
14430 * rs -----
14431 * rt -----
14432 * rd -----
14433 */
14434 static char *SRL_16_(uint64 instruction, Dis_info *info)
14435 {
14436 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14437 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14438 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14439
14440 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14441 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14442 uint64 shift3 = encode_shift3_from_shift(shift3_value);
14443
14444 return img_format("SRL %s, %s, 0x%" PRIx64, rt3, rs3, shift3);
14445 }
14446
14447
14448 /*
14449 *
14450 *
14451 * 3 2 1
14452 * 10987654321098765432109876543210
14453 * 001000 01001001101
14454 * rt -----
14455 * rs -----
14456 * rd -----
14457 */
14458 static char *SRL_32_(uint64 instruction, Dis_info *info)
14459 {
14460 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14461 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14462 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14463
14464 const char *rt = GPR(rt_value, info);
14465 const char *rs = GPR(rs_value, info);
14466
14467 return img_format("SRL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14468 }
14469
14470
14471 /*
14472 *
14473 *
14474 * 3 2 1
14475 * 10987654321098765432109876543210
14476 * 001000 01001001101
14477 * rt -----
14478 * rs -----
14479 * rd -----
14480 */
14481 static char *SRLV(uint64 instruction, Dis_info *info)
14482 {
14483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14485 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14486
14487 const char *rd = GPR(rd_value, info);
14488 const char *rs = GPR(rs_value, info);
14489 const char *rt = GPR(rt_value, info);
14490
14491 return img_format("SRLV %s, %s, %s", rd, rs, rt);
14492 }
14493
14494
14495 /*
14496 *
14497 *
14498 * 3 2 1
14499 * 10987654321098765432109876543210
14500 * 001000 01001001101
14501 * rt -----
14502 * rs -----
14503 * rd -----
14504 */
14505 static char *SUB(uint64 instruction, Dis_info *info)
14506 {
14507 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14508 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14509 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14510
14511 const char *rd = GPR(rd_value, info);
14512 const char *rs = GPR(rs_value, info);
14513 const char *rt = GPR(rt_value, info);
14514
14515 return img_format("SUB %s, %s, %s", rd, rs, rt);
14516 }
14517
14518
14519 /*
14520 *
14521 *
14522 * 3 2 1
14523 * 10987654321098765432109876543210
14524 * 001000 01001001101
14525 * rt -----
14526 * rs -----
14527 * rd -----
14528 */
14529 static char *SUB_D(uint64 instruction, Dis_info *info)
14530 {
14531 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14532 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14533 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14534
14535 const char *fd = FPR(fd_value, info);
14536 const char *fs = FPR(fs_value, info);
14537 const char *ft = FPR(ft_value, info);
14538
14539 return img_format("SUB.D %s, %s, %s", fd, fs, ft);
14540 }
14541
14542
14543 /*
14544 *
14545 *
14546 * 3 2 1
14547 * 10987654321098765432109876543210
14548 * 001000 01001001101
14549 * rt -----
14550 * rs -----
14551 * rd -----
14552 */
14553 static char *SUB_S(uint64 instruction, Dis_info *info)
14554 {
14555 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14556 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14557 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14558
14559 const char *fd = FPR(fd_value, info);
14560 const char *fs = FPR(fs_value, info);
14561 const char *ft = FPR(ft_value, info);
14562
14563 return img_format("SUB.S %s, %s, %s", fd, fs, ft);
14564 }
14565
14566
14567 /*
14568 *
14569 *
14570 * 3 2 1
14571 * 10987654321098765432109876543210
14572 * 001000 01001001101
14573 * rt -----
14574 * rs -----
14575 * rd -----
14576 */
14577 static char *SUBQ_PH(uint64 instruction, Dis_info *info)
14578 {
14579 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14580 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14581 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14582
14583 const char *rd = GPR(rd_value, info);
14584 const char *rs = GPR(rs_value, info);
14585 const char *rt = GPR(rt_value, info);
14586
14587 return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
14588 }
14589
14590
14591 /*
14592 * [DSP] SUBQ.S.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14593 * right to halve results
14594 *
14595 * 3 2 1
14596 * 10987654321098765432109876543210
14597 * 001000 01001001101
14598 * rt -----
14599 * rs -----
14600 * rd -----
14601 */
14602 static char *SUBQ_S_PH(uint64 instruction, Dis_info *info)
14603 {
14604 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14605 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14606 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14607
14608 const char *rd = GPR(rd_value, info);
14609 const char *rs = GPR(rs_value, info);
14610 const char *rt = GPR(rt_value, info);
14611
14612 return img_format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
14613 }
14614
14615
14616 /*
14617 * [DSP] SUBQ.S.W rd, rt, rs - Subtract fractional halfword vectors and shift
14618 * right to halve results
14619 *
14620 * 3 2 1
14621 * 10987654321098765432109876543210
14622 * 001000 01001001101
14623 * rt -----
14624 * rs -----
14625 * rd -----
14626 */
14627 static char *SUBQ_S_W(uint64 instruction, Dis_info *info)
14628 {
14629 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14630 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14631 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14632
14633 const char *rd = GPR(rd_value, info);
14634 const char *rs = GPR(rs_value, info);
14635 const char *rt = GPR(rt_value, info);
14636
14637 return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
14638 }
14639
14640
14641 /*
14642 * [DSP] SUBQH.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14643 * right to halve results
14644 *
14645 * 3 2 1
14646 * 10987654321098765432109876543210
14647 * 001000 01001001101
14648 * rt -----
14649 * rs -----
14650 * rd -----
14651 */
14652 static char *SUBQH_PH(uint64 instruction, Dis_info *info)
14653 {
14654 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14655 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14656 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14657
14658 const char *rd = GPR(rd_value, info);
14659 const char *rs = GPR(rs_value, info);
14660 const char *rt = GPR(rt_value, info);
14661
14662 return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
14663 }
14664
14665
14666 /*
14667 * [DSP] SUBQH_R.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14668 * right to halve results
14669 *
14670 * 3 2 1
14671 * 10987654321098765432109876543210
14672 * 001000 01001001101
14673 * rt -----
14674 * rs -----
14675 * rd -----
14676 */
14677 static char *SUBQH_R_PH(uint64 instruction, Dis_info *info)
14678 {
14679 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14680 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14681 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14682
14683 const char *rd = GPR(rd_value, info);
14684 const char *rs = GPR(rs_value, info);
14685 const char *rt = GPR(rt_value, info);
14686
14687 return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
14688 }
14689
14690
14691 /*
14692 * [DSP] SUBQH_R.W rd, rt, rs - Subtract fractional halfword vectors and shift
14693 * right to halve results with rounding
14694 *
14695 * 3 2 1
14696 * 10987654321098765432109876543210
14697 * 001000 11001001101
14698 * rt -----
14699 * rs -----
14700 * rd -----
14701 */
14702 static char *SUBQH_R_W(uint64 instruction, Dis_info *info)
14703 {
14704 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14705 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14706 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14707
14708 const char *rd = GPR(rd_value, info);
14709 const char *rs = GPR(rs_value, info);
14710 const char *rt = GPR(rt_value, info);
14711
14712 return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
14713 }
14714
14715
14716 /*
14717 * [DSP] SUBQH.W rd, rs, rt - Subtract fractional words and shift right to
14718 * halve results
14719 *
14720 * 3 2 1
14721 * 10987654321098765432109876543210
14722 * 001000 01010001101
14723 * rt -----
14724 * rs -----
14725 * rd -----
14726 */
14727 static char *SUBQH_W(uint64 instruction, Dis_info *info)
14728 {
14729 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14730 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14731 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14732
14733 const char *rd = GPR(rd_value, info);
14734 const char *rs = GPR(rs_value, info);
14735 const char *rt = GPR(rt_value, info);
14736
14737 return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
14738 }
14739
14740
14741 /*
14742 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14743 *
14744 * 3 2 1
14745 * 10987654321098765432109876543210
14746 * 001000 00010001101
14747 * rt -----
14748 * rs -----
14749 * rd -----
14750 */
14751 static char *SUBU_16_(uint64 instruction, Dis_info *info)
14752 {
14753 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14754 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14755 uint64 rd3_value = extract_rd3_3_2_1(instruction);
14756
14757 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
14758 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14759 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14760
14761 return img_format("SUBU %s, %s, %s", rd3, rs3, rt3);
14762 }
14763
14764
14765 /*
14766 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14767 *
14768 * 3 2 1
14769 * 10987654321098765432109876543210
14770 * 001000 00010001101
14771 * rt -----
14772 * rs -----
14773 * rd -----
14774 */
14775 static char *SUBU_32_(uint64 instruction, Dis_info *info)
14776 {
14777 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14778 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14779 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14780
14781 const char *rd = GPR(rd_value, info);
14782 const char *rs = GPR(rs_value, info);
14783 const char *rt = GPR(rt_value, info);
14784
14785 return img_format("SUBU %s, %s, %s", rd, rs, rt);
14786 }
14787
14788
14789 /*
14790 * [DSP] SUBU.PH rd, rs, rt - Subtract unsigned unsigned halfwords
14791 *
14792 * 3 2 1
14793 * 10987654321098765432109876543210
14794 * 001000 01100001101
14795 * rt -----
14796 * rs -----
14797 * rd -----
14798 */
14799 static char *SUBU_PH(uint64 instruction, Dis_info *info)
14800 {
14801 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14802 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14803 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14804
14805 const char *rd = GPR(rd_value, info);
14806 const char *rs = GPR(rs_value, info);
14807 const char *rt = GPR(rt_value, info);
14808
14809 return img_format("SUBU.PH %s, %s, %s", rd, rs, rt);
14810 }
14811
14812
14813 /*
14814 * [DSP] SUBU.QB rd, rs, rt - Subtract unsigned quad byte vectors
14815 *
14816 * 3 2 1
14817 * 10987654321098765432109876543210
14818 * 001000 01011001101
14819 * rt -----
14820 * rs -----
14821 * rd -----
14822 */
14823 static char *SUBU_QB(uint64 instruction, Dis_info *info)
14824 {
14825 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14826 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14827 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14828
14829 const char *rd = GPR(rd_value, info);
14830 const char *rs = GPR(rs_value, info);
14831 const char *rt = GPR(rt_value, info);
14832
14833 return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
14834 }
14835
14836
14837 /*
14838 * [DSP] SUBU_S.PH rd, rs, rt - Subtract unsigned unsigned halfwords with
14839 * 8-bit saturation
14840 *
14841 * 3 2 1
14842 * 10987654321098765432109876543210
14843 * 001000 11100001101
14844 * rt -----
14845 * rs -----
14846 * rd -----
14847 */
14848 static char *SUBU_S_PH(uint64 instruction, Dis_info *info)
14849 {
14850 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14851 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14852 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14853
14854 const char *rd = GPR(rd_value, info);
14855 const char *rs = GPR(rs_value, info);
14856 const char *rt = GPR(rt_value, info);
14857
14858 return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
14859 }
14860
14861
14862 /*
14863 * [DSP] SUBU_S.QB rd, rs, rt - Subtract unsigned quad byte vectors with
14864 * 8-bit saturation
14865 *
14866 * 3 2 1
14867 * 10987654321098765432109876543210
14868 * 001000 11011001101
14869 * rt -----
14870 * rs -----
14871 * rd -----
14872 */
14873 static char *SUBU_S_QB(uint64 instruction, Dis_info *info)
14874 {
14875 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14876 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14877 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14878
14879 const char *rd = GPR(rd_value, info);
14880 const char *rs = GPR(rs_value, info);
14881 const char *rt = GPR(rt_value, info);
14882
14883 return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
14884 }
14885
14886
14887 /*
14888 * [DSP] SUBUH.QB rd, rs, rt - Subtract unsigned bytes and right shift
14889 * to halve results
14890 *
14891 * 3 2 1
14892 * 10987654321098765432109876543210
14893 * 001000 01101001101
14894 * rt -----
14895 * rs -----
14896 * rd -----
14897 */
14898 static char *SUBUH_QB(uint64 instruction, Dis_info *info)
14899 {
14900 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14901 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14902 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14903
14904 const char *rd = GPR(rd_value, info);
14905 const char *rs = GPR(rs_value, info);
14906 const char *rt = GPR(rt_value, info);
14907
14908 return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
14909 }
14910
14911
14912 /*
14913 * [DSP] SUBUH_R.QB rd, rs, rt - Subtract unsigned bytes and right shift
14914 * to halve results with rounding
14915 *
14916 * 3 2 1
14917 * 10987654321098765432109876543210
14918 * 001000 11101001101
14919 * rt -----
14920 * rs -----
14921 * rd -----
14922 */
14923 static char *SUBUH_R_QB(uint64 instruction, Dis_info *info)
14924 {
14925 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14926 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14927 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14928
14929 const char *rd = GPR(rd_value, info);
14930 const char *rs = GPR(rs_value, info);
14931 const char *rt = GPR(rt_value, info);
14932
14933 return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
14934 }
14935
14936
14937 /*
14938 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14939 *
14940 * 3 2 1
14941 * 10987654321098765432109876543210
14942 * 001000 00010001101
14943 * rt -----
14944 * rs -----
14945 * rd -----
14946 */
14947 static char *SW_16_(uint64 instruction, Dis_info *info)
14948 {
14949 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
14950 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14951 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
14952
14953 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
14954 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14955
14956 return img_format("SW %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
14957 }
14958
14959
14960 /*
14961 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14962 *
14963 * 3 2 1
14964 * 10987654321098765432109876543210
14965 * 001000 00010001101
14966 * rt -----
14967 * rs -----
14968 * rd -----
14969 */
14970 static char *SW_4X4_(uint64 instruction, Dis_info *info)
14971 {
14972 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
14973 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
14974 uint64 u_value = extract_u_3_8__s2(instruction);
14975
14976 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
14977 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
14978
14979 return img_format("SW %s, 0x%" PRIx64 "(%s)", rtz4, u_value, rs4);
14980 }
14981
14982
14983 /*
14984 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14985 *
14986 * 3 2 1
14987 * 10987654321098765432109876543210
14988 * 001000 00010001101
14989 * rt -----
14990 * rs -----
14991 * rd -----
14992 */
14993 static char *SW_GP16_(uint64 instruction, Dis_info *info)
14994 {
14995 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
14996 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
14997
14998 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
14999
15000 return img_format("SW %s, 0x%" PRIx64 "($%d)", rtz3, u_value, 28);
15001 }
15002
15003
15004 /*
15005 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15006 *
15007 * 3 2 1
15008 * 10987654321098765432109876543210
15009 * 001000 00010001101
15010 * rt -----
15011 * rs -----
15012 * rd -----
15013 */
15014 static char *SW_GP_(uint64 instruction, Dis_info *info)
15015 {
15016 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15017 uint64 u_value = extract_u_20_to_2__s2(instruction);
15018
15019 const char *rt = GPR(rt_value, info);
15020
15021 return img_format("SW %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
15022 }
15023
15024
15025 /*
15026 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15027 *
15028 * 3 2 1
15029 * 10987654321098765432109876543210
15030 * 001000 00010001101
15031 * rt -----
15032 * rs -----
15033 * rd -----
15034 */
15035 static char *SW_S9_(uint64 instruction, Dis_info *info)
15036 {
15037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15038 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15039 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15040
15041 const char *rt = GPR(rt_value, info);
15042 const char *rs = GPR(rs_value, info);
15043
15044 return img_format("SW %s, %" PRId64 "(%s)", rt, s_value, rs);
15045 }
15046
15047
15048 /*
15049 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15050 *
15051 * 3 2 1
15052 * 10987654321098765432109876543210
15053 * 001000 00010001101
15054 * rt -----
15055 * rs -----
15056 * rd -----
15057 */
15058 static char *SW_SP_(uint64 instruction, Dis_info *info)
15059 {
15060 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
15061 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
15062
15063 const char *rt = GPR(rt_value, info);
15064
15065 return img_format("SW %s, 0x%" PRIx64 "($%d)", rt, u_value, 29);
15066 }
15067
15068
15069 /*
15070 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15071 *
15072 * 3 2 1
15073 * 10987654321098765432109876543210
15074 * 001000 00010001101
15075 * rt -----
15076 * rs -----
15077 * rd -----
15078 */
15079 static char *SW_U12_(uint64 instruction, Dis_info *info)
15080 {
15081 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15082 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15083 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15084
15085 const char *rt = GPR(rt_value, info);
15086 const char *rs = GPR(rs_value, info);
15087
15088 return img_format("SW %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
15089 }
15090
15091
15092 /*
15093 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15094 *
15095 * 3 2 1
15096 * 10987654321098765432109876543210
15097 * 001000 00010001101
15098 * rt -----
15099 * rs -----
15100 * rd -----
15101 */
15102 static char *SWC1_GP_(uint64 instruction, Dis_info *info)
15103 {
15104 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15105 uint64 u_value = extract_u_17_to_2__s2(instruction);
15106
15107 const char *ft = FPR(ft_value, info);
15108
15109 return img_format("SWC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
15110 }
15111
15112
15113 /*
15114 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15115 *
15116 * 3 2 1
15117 * 10987654321098765432109876543210
15118 * 001000 00010001101
15119 * rt -----
15120 * rs -----
15121 * rd -----
15122 */
15123 static char *SWC1_S9_(uint64 instruction, Dis_info *info)
15124 {
15125 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15126 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15127 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15128
15129 const char *ft = FPR(ft_value, info);
15130 const char *rs = GPR(rs_value, info);
15131
15132 return img_format("SWC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
15133 }
15134
15135
15136 /*
15137 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15138 *
15139 * 3 2 1
15140 * 10987654321098765432109876543210
15141 * 001000 00010001101
15142 * rt -----
15143 * rs -----
15144 * rd -----
15145 */
15146 static char *SWC1_U12_(uint64 instruction, Dis_info *info)
15147 {
15148 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15149 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15150 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15151
15152 const char *ft = FPR(ft_value, info);
15153 const char *rs = GPR(rs_value, info);
15154
15155 return img_format("SWC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
15156 }
15157
15158
15159 /*
15160 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15161 *
15162 * 3 2 1
15163 * 10987654321098765432109876543210
15164 * 001000 00010001101
15165 * rt -----
15166 * rs -----
15167 * rd -----
15168 */
15169 static char *SWC1X(uint64 instruction, Dis_info *info)
15170 {
15171 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15172 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15173 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15174
15175 const char *ft = FPR(ft_value, info);
15176 const char *rs = GPR(rs_value, info);
15177 const char *rt = GPR(rt_value, info);
15178
15179 return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
15180 }
15181
15182
15183 /*
15184 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15185 *
15186 * 3 2 1
15187 * 10987654321098765432109876543210
15188 * 001000 00010001101
15189 * rt -----
15190 * rs -----
15191 * rd -----
15192 */
15193 static char *SWC1XS(uint64 instruction, Dis_info *info)
15194 {
15195 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15196 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15197 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15198
15199 const char *ft = FPR(ft_value, info);
15200 const char *rs = GPR(rs_value, info);
15201 const char *rt = GPR(rt_value, info);
15202
15203 return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
15204 }
15205
15206
15207 /*
15208 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15209 *
15210 * 3 2 1
15211 * 10987654321098765432109876543210
15212 * 001000 00010001101
15213 * rt -----
15214 * rs -----
15215 * rd -----
15216 */
15217 static char *SWC2(uint64 instruction, Dis_info *info)
15218 {
15219 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15220 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15221 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15222
15223 const char *rs = GPR(rs_value, info);
15224
15225 return img_format("SWC2 CP%" PRIu64 ", %" PRId64 "(%s)",
15226 cs_value, s_value, rs);
15227 }
15228
15229
15230 /*
15231 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15232 *
15233 * 3 2 1
15234 * 10987654321098765432109876543210
15235 * 001000 00010001101
15236 * rt -----
15237 * rs -----
15238 * rd -----
15239 */
15240 static char *SWE(uint64 instruction, Dis_info *info)
15241 {
15242 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15243 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15244 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15245
15246 const char *rt = GPR(rt_value, info);
15247 const char *rs = GPR(rs_value, info);
15248
15249 return img_format("SWE %s, %" PRId64 "(%s)", rt, s_value, rs);
15250 }
15251
15252
15253 /*
15254 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15255 *
15256 * 3 2 1
15257 * 10987654321098765432109876543210
15258 * 001000 00010001101
15259 * rt -----
15260 * rs -----
15261 * rd -----
15262 */
15263 static char *SWM(uint64 instruction, Dis_info *info)
15264 {
15265 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15266 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15267 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15268 uint64 count3_value = extract_count3_14_13_12(instruction);
15269
15270 const char *rt = GPR(rt_value, info);
15271 const char *rs = GPR(rs_value, info);
15272 uint64 count3 = encode_count3_from_count(count3_value);
15273
15274 return img_format("SWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15275 rt, s_value, rs, count3);
15276 }
15277
15278
15279 /*
15280 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15281 *
15282 * 3 2 1
15283 * 10987654321098765432109876543210
15284 * 001000 00010001101
15285 * rt -----
15286 * rs -----
15287 * rd -----
15288 */
15289 static char *SWPC_48_(uint64 instruction, Dis_info *info)
15290 {
15291 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15292 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
15293
15294 const char *rt = GPR(rt_value, info);
15295 g_autofree char *s = ADDRESS(s_value, 6, info);
15296
15297 return img_format("SWPC %s, %s", rt, s);
15298 }
15299
15300
15301 /*
15302 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15303 *
15304 * 3 2 1
15305 * 10987654321098765432109876543210
15306 * 001000 00010001101
15307 * rt -----
15308 * rs -----
15309 * rd -----
15310 */
15311 static char *SWX(uint64 instruction, Dis_info *info)
15312 {
15313 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15314 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15315 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15316
15317 const char *rd = GPR(rd_value, info);
15318 const char *rs = GPR(rs_value, info);
15319 const char *rt = GPR(rt_value, info);
15320
15321 return img_format("SWX %s, %s(%s)", rd, rs, rt);
15322 }
15323
15324
15325 /*
15326 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15327 *
15328 * 3 2 1
15329 * 10987654321098765432109876543210
15330 * 001000 00010001101
15331 * rt -----
15332 * rs -----
15333 * rd -----
15334 */
15335 static char *SWXS(uint64 instruction, Dis_info *info)
15336 {
15337 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15338 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15339 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15340
15341 const char *rd = GPR(rd_value, info);
15342 const char *rs = GPR(rs_value, info);
15343 const char *rt = GPR(rt_value, info);
15344
15345 return img_format("SWXS %s, %s(%s)", rd, rs, rt);
15346 }
15347
15348
15349 /*
15350 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15351 *
15352 * 3 2 1
15353 * 10987654321098765432109876543210
15354 * 001000 00010001101
15355 * rt -----
15356 * rs -----
15357 * rd -----
15358 */
15359 static char *SYNC(uint64 instruction, Dis_info *info)
15360 {
15361 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15362
15363
15364 return img_format("SYNC 0x%" PRIx64, stype_value);
15365 }
15366
15367
15368 /*
15369 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15370 *
15371 * 3 2 1
15372 * 10987654321098765432109876543210
15373 * 001000 00010001101
15374 * rt -----
15375 * rs -----
15376 * rd -----
15377 */
15378 static char *SYNCI(uint64 instruction, Dis_info *info)
15379 {
15380 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15381 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15382
15383 const char *rs = GPR(rs_value, info);
15384
15385 return img_format("SYNCI %" PRId64 "(%s)", s_value, rs);
15386 }
15387
15388
15389 /*
15390 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15391 *
15392 * 3 2 1
15393 * 10987654321098765432109876543210
15394 * 001000 00010001101
15395 * rt -----
15396 * rs -----
15397 * rd -----
15398 */
15399 static char *SYNCIE(uint64 instruction, Dis_info *info)
15400 {
15401 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15402 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15403
15404 const char *rs = GPR(rs_value, info);
15405
15406 return img_format("SYNCIE %" PRId64 "(%s)", s_value, rs);
15407 }
15408
15409
15410 /*
15411 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15412 *
15413 * 3 2 1
15414 * 10987654321098765432109876543210
15415 * 001000 00010001101
15416 * rt -----
15417 * rs -----
15418 * rd -----
15419 */
15420 static char *SYSCALL_16_(uint64 instruction, Dis_info *info)
15421 {
15422 uint64 code_value = extract_code_1_0(instruction);
15423
15424
15425 return img_format("SYSCALL 0x%" PRIx64, code_value);
15426 }
15427
15428
15429 /*
15430 * SYSCALL code - System Call. Cause a System Call Exception
15431 *
15432 * 3 2 1
15433 * 10987654321098765432109876543210
15434 * 00000000000010
15435 * code ------------------
15436 */
15437 static char *SYSCALL_32_(uint64 instruction, Dis_info *info)
15438 {
15439 uint64 code_value = extract_code_17_to_0(instruction);
15440
15441
15442 return img_format("SYSCALL 0x%" PRIx64, code_value);
15443 }
15444
15445
15446 /*
15447 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15448 *
15449 * 3 2 1
15450 * 10987654321098765432109876543210
15451 * 001000 00010001101
15452 * rt -----
15453 * rs -----
15454 * rd -----
15455 */
15456 static char *TEQ(uint64 instruction, Dis_info *info)
15457 {
15458 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15459 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15460
15461 const char *rs = GPR(rs_value, info);
15462 const char *rt = GPR(rt_value, info);
15463
15464 return img_format("TEQ %s, %s", rs, rt);
15465 }
15466
15467
15468 /*
15469 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15470 *
15471 * 3 2 1
15472 * 10987654321098765432109876543210
15473 * 001000 00010001101
15474 * rt -----
15475 * rs -----
15476 * rd -----
15477 */
15478 static char *TLBGINV(uint64 instruction, Dis_info *info)
15479 {
15480 (void)instruction;
15481
15482 return g_strdup("TLBGINV ");
15483 }
15484
15485
15486 /*
15487 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15488 *
15489 * 3 2 1
15490 * 10987654321098765432109876543210
15491 * 001000 00010001101
15492 * rt -----
15493 * rs -----
15494 * rd -----
15495 */
15496 static char *TLBGINVF(uint64 instruction, Dis_info *info)
15497 {
15498 (void)instruction;
15499
15500 return g_strdup("TLBGINVF ");
15501 }
15502
15503
15504 /*
15505 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15506 *
15507 * 3 2 1
15508 * 10987654321098765432109876543210
15509 * 001000 00010001101
15510 * rt -----
15511 * rs -----
15512 * rd -----
15513 */
15514 static char *TLBGP(uint64 instruction, Dis_info *info)
15515 {
15516 (void)instruction;
15517
15518 return g_strdup("TLBGP ");
15519 }
15520
15521
15522 /*
15523 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15524 *
15525 * 3 2 1
15526 * 10987654321098765432109876543210
15527 * 001000 00010001101
15528 * rt -----
15529 * rs -----
15530 * rd -----
15531 */
15532 static char *TLBGR(uint64 instruction, Dis_info *info)
15533 {
15534 (void)instruction;
15535
15536 return g_strdup("TLBGR ");
15537 }
15538
15539
15540 /*
15541 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15542 *
15543 * 3 2 1
15544 * 10987654321098765432109876543210
15545 * 001000 00010001101
15546 * rt -----
15547 * rs -----
15548 * rd -----
15549 */
15550 static char *TLBGWI(uint64 instruction, Dis_info *info)
15551 {
15552 (void)instruction;
15553
15554 return g_strdup("TLBGWI ");
15555 }
15556
15557
15558 /*
15559 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15560 *
15561 * 3 2 1
15562 * 10987654321098765432109876543210
15563 * 001000 00010001101
15564 * rt -----
15565 * rs -----
15566 * rd -----
15567 */
15568 static char *TLBGWR(uint64 instruction, Dis_info *info)
15569 {
15570 (void)instruction;
15571
15572 return g_strdup("TLBGWR ");
15573 }
15574
15575
15576 /*
15577 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15578 *
15579 * 3 2 1
15580 * 10987654321098765432109876543210
15581 * 001000 00010001101
15582 * rt -----
15583 * rs -----
15584 * rd -----
15585 */
15586 static char *TLBINV(uint64 instruction, Dis_info *info)
15587 {
15588 (void)instruction;
15589
15590 return g_strdup("TLBINV ");
15591 }
15592
15593
15594 /*
15595 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15596 *
15597 * 3 2 1
15598 * 10987654321098765432109876543210
15599 * 001000 00010001101
15600 * rt -----
15601 * rs -----
15602 * rd -----
15603 */
15604 static char *TLBINVF(uint64 instruction, Dis_info *info)
15605 {
15606 (void)instruction;
15607
15608 return g_strdup("TLBINVF ");
15609 }
15610
15611
15612 /*
15613 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15614 *
15615 * 3 2 1
15616 * 10987654321098765432109876543210
15617 * 001000 00010001101
15618 * rt -----
15619 * rs -----
15620 * rd -----
15621 */
15622 static char *TLBP(uint64 instruction, Dis_info *info)
15623 {
15624 (void)instruction;
15625
15626 return g_strdup("TLBP ");
15627 }
15628
15629
15630 /*
15631 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15632 *
15633 * 3 2 1
15634 * 10987654321098765432109876543210
15635 * 001000 00010001101
15636 * rt -----
15637 * rs -----
15638 * rd -----
15639 */
15640 static char *TLBR(uint64 instruction, Dis_info *info)
15641 {
15642 (void)instruction;
15643
15644 return g_strdup("TLBR ");
15645 }
15646
15647
15648 /*
15649 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15650 *
15651 * 3 2 1
15652 * 10987654321098765432109876543210
15653 * 001000 00010001101
15654 * rt -----
15655 * rs -----
15656 * rd -----
15657 */
15658 static char *TLBWI(uint64 instruction, Dis_info *info)
15659 {
15660 (void)instruction;
15661
15662 return g_strdup("TLBWI ");
15663 }
15664
15665
15666 /*
15667 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15668 *
15669 * 3 2 1
15670 * 10987654321098765432109876543210
15671 * 001000 00010001101
15672 * rt -----
15673 * rs -----
15674 * rd -----
15675 */
15676 static char *TLBWR(uint64 instruction, Dis_info *info)
15677 {
15678 (void)instruction;
15679
15680 return g_strdup("TLBWR ");
15681 }
15682
15683
15684 /*
15685 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15686 *
15687 * 3 2 1
15688 * 10987654321098765432109876543210
15689 * 001000 00010001101
15690 * rt -----
15691 * rs -----
15692 * rd -----
15693 */
15694 static char *TNE(uint64 instruction, Dis_info *info)
15695 {
15696 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15697 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15698
15699 const char *rs = GPR(rs_value, info);
15700 const char *rt = GPR(rt_value, info);
15701
15702 return img_format("TNE %s, %s", rs, rt);
15703 }
15704
15705
15706 /*
15707 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15708 *
15709 * 3 2 1
15710 * 10987654321098765432109876543210
15711 * 001000 00010001101
15712 * rt -----
15713 * rs -----
15714 * rd -----
15715 */
15716 static char *TRUNC_L_D(uint64 instruction, Dis_info *info)
15717 {
15718 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15719 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15720
15721 const char *ft = FPR(ft_value, info);
15722 const char *fs = FPR(fs_value, info);
15723
15724 return img_format("TRUNC.L.D %s, %s", ft, fs);
15725 }
15726
15727
15728 /*
15729 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15730 *
15731 * 3 2 1
15732 * 10987654321098765432109876543210
15733 * 001000 00010001101
15734 * rt -----
15735 * rs -----
15736 * rd -----
15737 */
15738 static char *TRUNC_L_S(uint64 instruction, Dis_info *info)
15739 {
15740 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15741 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15742
15743 const char *ft = FPR(ft_value, info);
15744 const char *fs = FPR(fs_value, info);
15745
15746 return img_format("TRUNC.L.S %s, %s", ft, fs);
15747 }
15748
15749
15750 /*
15751 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15752 *
15753 * 3 2 1
15754 * 10987654321098765432109876543210
15755 * 001000 00010001101
15756 * rt -----
15757 * rs -----
15758 * rd -----
15759 */
15760 static char *TRUNC_W_D(uint64 instruction, Dis_info *info)
15761 {
15762 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15763 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15764
15765 const char *ft = FPR(ft_value, info);
15766 const char *fs = FPR(fs_value, info);
15767
15768 return img_format("TRUNC.W.D %s, %s", ft, fs);
15769 }
15770
15771
15772 /*
15773 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15774 *
15775 * 3 2 1
15776 * 10987654321098765432109876543210
15777 * 001000 00010001101
15778 * rt -----
15779 * rs -----
15780 * rd -----
15781 */
15782 static char *TRUNC_W_S(uint64 instruction, Dis_info *info)
15783 {
15784 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15785 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15786
15787 const char *ft = FPR(ft_value, info);
15788 const char *fs = FPR(fs_value, info);
15789
15790 return img_format("TRUNC.W.S %s, %s", ft, fs);
15791 }
15792
15793
15794 /*
15795 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15796 *
15797 * 3 2 1
15798 * 10987654321098765432109876543210
15799 * 001000 00010001101
15800 * rt -----
15801 * rs -----
15802 * rd -----
15803 */
15804 static char *UALDM(uint64 instruction, Dis_info *info)
15805 {
15806 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15807 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15808 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15809 uint64 count3_value = extract_count3_14_13_12(instruction);
15810
15811 const char *rt = GPR(rt_value, info);
15812 const char *rs = GPR(rs_value, info);
15813 uint64 count3 = encode_count3_from_count(count3_value);
15814
15815 return img_format("UALDM %s, %" PRId64 "(%s), 0x%" PRIx64,
15816 rt, s_value, rs, count3);
15817 }
15818
15819
15820 /*
15821 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15822 *
15823 * 3 2 1
15824 * 10987654321098765432109876543210
15825 * 001000 00010001101
15826 * rt -----
15827 * rs -----
15828 * rd -----
15829 */
15830 static char *UALH(uint64 instruction, Dis_info *info)
15831 {
15832 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15833 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15834 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15835
15836 const char *rt = GPR(rt_value, info);
15837 const char *rs = GPR(rs_value, info);
15838
15839 return img_format("UALH %s, %" PRId64 "(%s)", rt, s_value, rs);
15840 }
15841
15842
15843 /*
15844 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15845 *
15846 * 3 2 1
15847 * 10987654321098765432109876543210
15848 * 001000 00010001101
15849 * rt -----
15850 * rs -----
15851 * rd -----
15852 */
15853 static char *UALWM(uint64 instruction, Dis_info *info)
15854 {
15855 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15856 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15857 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15858 uint64 count3_value = extract_count3_14_13_12(instruction);
15859
15860 const char *rt = GPR(rt_value, info);
15861 const char *rs = GPR(rs_value, info);
15862 uint64 count3 = encode_count3_from_count(count3_value);
15863
15864 return img_format("UALWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15865 rt, s_value, rs, count3);
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 static char *UASDM(uint64 instruction, Dis_info *info)
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 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15884 uint64 count3_value = extract_count3_14_13_12(instruction);
15885
15886 const char *rt = GPR(rt_value, info);
15887 const char *rs = GPR(rs_value, info);
15888 uint64 count3 = encode_count3_from_count(count3_value);
15889
15890 return img_format("UASDM %s, %" PRId64 "(%s), 0x%" PRIx64,
15891 rt, s_value, rs, count3);
15892 }
15893
15894
15895 /*
15896 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15897 *
15898 * 3 2 1
15899 * 10987654321098765432109876543210
15900 * 001000 00010001101
15901 * rt -----
15902 * rs -----
15903 * rd -----
15904 */
15905 static char *UASH(uint64 instruction, Dis_info *info)
15906 {
15907 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15908 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15909 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15910
15911 const char *rt = GPR(rt_value, info);
15912 const char *rs = GPR(rs_value, info);
15913
15914 return img_format("UASH %s, %" PRId64 "(%s)", rt, s_value, rs);
15915 }
15916
15917
15918 /*
15919 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15920 *
15921 * 3 2 1
15922 * 10987654321098765432109876543210
15923 * 001000 00010001101
15924 * rt -----
15925 * rs -----
15926 * rd -----
15927 */
15928 static char *UASWM(uint64 instruction, Dis_info *info)
15929 {
15930 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15931 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15932 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15933 uint64 count3_value = extract_count3_14_13_12(instruction);
15934
15935 const char *rt = GPR(rt_value, info);
15936 const char *rs = GPR(rs_value, info);
15937 uint64 count3 = encode_count3_from_count(count3_value);
15938
15939 return img_format("UASWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15940 rt, s_value, rs, count3);
15941 }
15942
15943
15944 /*
15945 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15946 *
15947 * 3 2 1
15948 * 10987654321098765432109876543210
15949 * 001000 00010001101
15950 * rt -----
15951 * rs -----
15952 * rd -----
15953 */
15954 static char *UDI(uint64 instruction, Dis_info *info)
15955 {
15956 uint64 op_value = extract_op_25_to_3(instruction);
15957
15958
15959 return img_format("UDI 0x%" PRIx64, op_value);
15960 }
15961
15962
15963 /*
15964 * WAIT code - Enter Wait State
15965 *
15966 * 3 2 1
15967 * 10987654321098765432109876543210
15968 * 001000 1100001101111111
15969 * code ----------
15970 */
15971 static char *WAIT(uint64 instruction, Dis_info *info)
15972 {
15973 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
15974
15975
15976 return img_format("WAIT 0x%" PRIx64, code_value);
15977 }
15978
15979
15980 /*
15981 * [DSP] WRDSP rt, mask - Write selected fields from a GPR to the DSPControl
15982 * register
15983 *
15984 * 3 2 1
15985 * 10987654321098765432109876543210
15986 * 001000 01011001111111
15987 * rt -----
15988 * mask -------
15989 */
15990 static char *WRDSP(uint64 instruction, Dis_info *info)
15991 {
15992 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15993 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
15994
15995 const char *rt = GPR(rt_value, info);
15996
15997 return img_format("WRDSP %s, 0x%" PRIx64, rt, mask_value);
15998 }
15999
16000
16001 /*
16002 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16003 *
16004 * 3 2 1
16005 * 10987654321098765432109876543210
16006 * 001000 00010001101
16007 * rt -----
16008 * rs -----
16009 * rd -----
16010 */
16011 static char *WRPGPR(uint64 instruction, Dis_info *info)
16012 {
16013 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16014 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16015
16016 const char *rt = GPR(rt_value, info);
16017 const char *rs = GPR(rs_value, info);
16018
16019 return img_format("WRPGPR %s, %s", rt, rs);
16020 }
16021
16022
16023 /*
16024 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16025 *
16026 * 3 2 1
16027 * 10987654321098765432109876543210
16028 * 001000 00010001101
16029 * rt -----
16030 * rs -----
16031 * rd -----
16032 */
16033 static char *XOR_16_(uint64 instruction, Dis_info *info)
16034 {
16035 uint64 rt3_value = extract_rt3_9_8_7(instruction);
16036 uint64 rs3_value = extract_rs3_6_5_4(instruction);
16037
16038 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
16039 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
16040
16041 return img_format("XOR %s, %s", rs3, rt3);
16042 }
16043
16044
16045 /*
16046 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16047 *
16048 * 3 2 1
16049 * 10987654321098765432109876543210
16050 * 001000 00010001101
16051 * rt -----
16052 * rs -----
16053 * rd -----
16054 */
16055 static char *XOR_32_(uint64 instruction, Dis_info *info)
16056 {
16057 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16058 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16059 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
16060
16061 const char *rd = GPR(rd_value, info);
16062 const char *rs = GPR(rs_value, info);
16063 const char *rt = GPR(rt_value, info);
16064
16065 return img_format("XOR %s, %s, %s", rd, rs, rt);
16066 }
16067
16068
16069 /*
16070 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
16071 *
16072 * 3 2 1
16073 * 10987654321098765432109876543210
16074 * 001000 00010001101
16075 * rt -----
16076 * rs -----
16077 * rd -----
16078 */
16079 static char *XORI(uint64 instruction, Dis_info *info)
16080 {
16081 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16082 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16083 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
16084
16085 const char *rt = GPR(rt_value, info);
16086 const char *rs = GPR(rs_value, info);
16087
16088 return img_format("XORI %s, %s, 0x%" PRIx64, rt, rs, u_value);
16089 }
16090
16091
16092 /*
16093 * YIELD rt, rs -
16094 *
16095 * 3 2 1
16096 * 10987654321098765432109876543210
16097 * 001000 00010001101
16098 * rt -----
16099 * rs -----
16100 */
16101 static char *YIELD(uint64 instruction, Dis_info *info)
16102 {
16103 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16104 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16105
16106 const char *rt = GPR(rt_value, info);
16107 const char *rs = GPR(rs_value, info);
16108
16109 return img_format("YIELD %s, %s", rt, rs);
16110 }
16111
16112
16113
16114 /*
16115 * nanoMIPS instruction pool organization
16116 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
16117 *
16118 *
16119 * ┌─ P.ADDIU ─── P.RI ─── P.SYSCALL
16120 * │
16121 * │ ┌─ P.TRAP
16122 * │ │
16123 * │ ┌─ _POOL32A0_0 ─┼─ P.CMOVE
16124 * │ │ │
16125 * │ │ └─ P.SLTU
16126 * │ ┌─ _POOL32A0 ─┤
16127 * │ │ │
16128 * │ │ │
16129 * │ │ └─ _POOL32A0_1 ─── CRC32
16130 * │ │
16131 * ├─ P32A ─┤
16132 * │ │ ┌─ PP.LSX
16133 * │ │ ┌─ P.LSX ─────┤
16134 * │ │ │ └─ PP.LSXS
16135 * │ └─ _POOL32A7 ─┤
16136 * │ │ ┌─ POOL32Axf_4
16137 * │ └─ POOL32Axf ─┤
16138 * │ └─ POOL32Axf_5
16139 * │
16140 * ├─ PBAL
16141 * │
16142 * ├─ P.GP.W ┌─ PP.LSX
16143 * ┌─ P32 ─┤ │
16144 * │ ├─ P.GP.BH ─┴─ PP.LSXS
16145 * │ │
16146 * │ ├─ P.J ─────── PP.BALRSC
16147 * │ │
16148 * │ ├─ P48I
16149 * │ │ ┌─ P.SR
16150 * │ │ │
16151 * │ │ ├─ P.SHIFT
16152 * │ │ │
16153 * │ ├─ P.U12 ───┼─ P.ROTX
16154 * │ │ │
16155 * │ │ ├─ P.INS
16156 * │ │ │
16157 * │ │ └─ P.EXT
16158 * │ │
16159 * │ ├─ P.LS.U12 ── P.PREF.U12
16160 * │ │
16161 * │ ├─ P.BR1 ───── P.BR3A
16162 * │ │
16163 * │ │ ┌─ P.LS.S0 ─── P16.SYSCALL
16164 * │ │ │
16165 * │ │ │ ┌─ P.LL
16166 * │ │ ├─ P.LS.S1 ─┤
16167 * │ │ │ └─ P.SC
16168 * │ │ │
16169 * │ │ │ ┌─ P.PREFE
16170 * MAJOR ─┤ ├─ P.LS.S9 ─┤ │
16171 * │ │ ├─ P.LS.E0 ─┼─ P.LLE
16172 * │ │ │ │
16173 * │ │ │ └─ P.SCE
16174 * │ │ │
16175 * │ │ ├─ P.LS.WM
16176 * │ │ │
16177 * │ │ └─ P.LS.UAWM
16178 * │ │
16179 * │ │
16180 * │ ├─ P.BR2
16181 * │ │
16182 * │ ├─ P.BRI
16183 * │ │
16184 * │ └─ P.LUI
16185 * │
16186 * │
16187 * │ ┌─ P16.MV ──── P16.RI ─── P16.SYSCALL
16188 * │ │
16189 * │ ├─ P16.SR
16190 * │ │
16191 * │ ├─ P16.SHIFT
16192 * │ │
16193 * │ ├─ P16.4x4
16194 * │ │
16195 * │ ├─ P16C ────── POOL16C_0 ── POOL16C_00
16196 * │ │
16197 * └─ P16 ─┼─ P16.LB
16198 * │
16199 * ├─ P16.A1
16200 * │
16201 * ├─ P16.LH
16202 * │
16203 * ├─ P16.A2 ──── P.ADDIU[RS5]
16204 * │
16205 * ├─ P16.ADDU
16206 * │
16207 * └─ P16.BR ──┬─ P16.JRC
16208 * │
16209 * └─ P16.BR1
16210 *
16211 *
16212 * (FP, DPS, and some minor instruction pools are omitted from the diagram)
16213 *
16214 */
16215
16216 static const Pool P_SYSCALL[2] = {
16217 { instruction , 0 , 0 , 32,
16218 0xfffc0000, 0x00080000, &SYSCALL_32_ , 0,
16219 0x0 }, /* SYSCALL[32] */
16220 { instruction , 0 , 0 , 32,
16221 0xfffc0000, 0x000c0000, &HYPCALL , 0,
16222 CP0_ | VZ_ }, /* HYPCALL */
16223 };
16224
16225
16226 static const Pool P_RI[4] = {
16227 { instruction , 0 , 0 , 32,
16228 0xfff80000, 0x00000000, &SIGRIE , 0,
16229 0x0 }, /* SIGRIE */
16230 { pool , P_SYSCALL , 2 , 32,
16231 0xfff80000, 0x00080000, 0 , 0,
16232 0x0 }, /* P.SYSCALL */
16233 { instruction , 0 , 0 , 32,
16234 0xfff80000, 0x00100000, &BREAK_32_ , 0,
16235 0x0 }, /* BREAK[32] */
16236 { instruction , 0 , 0 , 32,
16237 0xfff80000, 0x00180000, &SDBBP_32_ , 0,
16238 EJTAG_ }, /* SDBBP[32] */
16239 };
16240
16241
16242 static const Pool P_ADDIU[2] = {
16243 { pool , P_RI , 4 , 32,
16244 0xffe00000, 0x00000000, 0 , 0,
16245 0x0 }, /* P.RI */
16246 { instruction , 0 , 0 , 32,
16247 0xfc000000, 0x00000000, &ADDIU_32_ , &ADDIU_32__cond ,
16248 0x0 }, /* ADDIU[32] */
16249 };
16250
16251
16252 static const Pool P_TRAP[2] = {
16253 { instruction , 0 , 0 , 32,
16254 0xfc0007ff, 0x20000000, &TEQ , 0,
16255 XMMS_ }, /* TEQ */
16256 { instruction , 0 , 0 , 32,
16257 0xfc0007ff, 0x20000400, &TNE , 0,
16258 XMMS_ }, /* TNE */
16259 };
16260
16261
16262 static const Pool P_CMOVE[2] = {
16263 { instruction , 0 , 0 , 32,
16264 0xfc0007ff, 0x20000210, &MOVZ , 0,
16265 0x0 }, /* MOVZ */
16266 { instruction , 0 , 0 , 32,
16267 0xfc0007ff, 0x20000610, &MOVN , 0,
16268 0x0 }, /* MOVN */
16269 };
16270
16271
16272 static const Pool P_D_MT_VPE[2] = {
16273 { instruction , 0 , 0 , 32,
16274 0xfc1f3fff, 0x20010ab0, &DMT , 0,
16275 MT_ }, /* DMT */
16276 { instruction , 0 , 0 , 32,
16277 0xfc1f3fff, 0x20000ab0, &DVPE , 0,
16278 MT_ }, /* DVPE */
16279 };
16280
16281
16282 static const Pool P_E_MT_VPE[2] = {
16283 { instruction , 0 , 0 , 32,
16284 0xfc1f3fff, 0x20010eb0, &EMT , 0,
16285 MT_ }, /* EMT */
16286 { instruction , 0 , 0 , 32,
16287 0xfc1f3fff, 0x20000eb0, &EVPE , 0,
16288 MT_ }, /* EVPE */
16289 };
16290
16291
16292 static const Pool _P_MT_VPE[2] = {
16293 { pool , P_D_MT_VPE , 2 , 32,
16294 0xfc003fff, 0x20000ab0, 0 , 0,
16295 0x0 }, /* P.D_MT_VPE */
16296 { pool , P_E_MT_VPE , 2 , 32,
16297 0xfc003fff, 0x20000eb0, 0 , 0,
16298 0x0 }, /* P.E_MT_VPE */
16299 };
16300
16301
16302 static const Pool P_MT_VPE[8] = {
16303 { reserved_block , 0 , 0 , 32,
16304 0xfc003bff, 0x200002b0, 0 , 0,
16305 0x0 }, /* P.MT_VPE~*(0) */
16306 { pool , _P_MT_VPE , 2 , 32,
16307 0xfc003bff, 0x20000ab0, 0 , 0,
16308 0x0 }, /* _P.MT_VPE */
16309 { reserved_block , 0 , 0 , 32,
16310 0xfc003bff, 0x200012b0, 0 , 0,
16311 0x0 }, /* P.MT_VPE~*(2) */
16312 { reserved_block , 0 , 0 , 32,
16313 0xfc003bff, 0x20001ab0, 0 , 0,
16314 0x0 }, /* P.MT_VPE~*(3) */
16315 { reserved_block , 0 , 0 , 32,
16316 0xfc003bff, 0x200022b0, 0 , 0,
16317 0x0 }, /* P.MT_VPE~*(4) */
16318 { reserved_block , 0 , 0 , 32,
16319 0xfc003bff, 0x20002ab0, 0 , 0,
16320 0x0 }, /* P.MT_VPE~*(5) */
16321 { reserved_block , 0 , 0 , 32,
16322 0xfc003bff, 0x200032b0, 0 , 0,
16323 0x0 }, /* P.MT_VPE~*(6) */
16324 { reserved_block , 0 , 0 , 32,
16325 0xfc003bff, 0x20003ab0, 0 , 0,
16326 0x0 }, /* P.MT_VPE~*(7) */
16327 };
16328
16329
16330 static const Pool P_DVP[2] = {
16331 { instruction , 0 , 0 , 32,
16332 0xfc00ffff, 0x20000390, &DVP , 0,
16333 0x0 }, /* DVP */
16334 { instruction , 0 , 0 , 32,
16335 0xfc00ffff, 0x20000790, &EVP , 0,
16336 0x0 }, /* EVP */
16337 };
16338
16339
16340 static const Pool P_SLTU[2] = {
16341 { pool , P_DVP , 2 , 32,
16342 0xfc00fbff, 0x20000390, 0 , 0,
16343 0x0 }, /* P.DVP */
16344 { instruction , 0 , 0 , 32,
16345 0xfc0003ff, 0x20000390, &SLTU , &SLTU_cond ,
16346 0x0 }, /* SLTU */
16347 };
16348
16349
16350 static const Pool _POOL32A0[128] = {
16351 { pool , P_TRAP , 2 , 32,
16352 0xfc0003ff, 0x20000000, 0 , 0,
16353 0x0 }, /* P.TRAP */
16354 { instruction , 0 , 0 , 32,
16355 0xfc0003ff, 0x20000008, &SEB , 0,
16356 XMMS_ }, /* SEB */
16357 { instruction , 0 , 0 , 32,
16358 0xfc0003ff, 0x20000010, &SLLV , 0,
16359 0x0 }, /* SLLV */
16360 { instruction , 0 , 0 , 32,
16361 0xfc0003ff, 0x20000018, &MUL_32_ , 0,
16362 0x0 }, /* MUL[32] */
16363 { reserved_block , 0 , 0 , 32,
16364 0xfc0003ff, 0x20000020, 0 , 0,
16365 0x0 }, /* _POOL32A0~*(4) */
16366 { reserved_block , 0 , 0 , 32,
16367 0xfc0003ff, 0x20000028, 0 , 0,
16368 0x0 }, /* _POOL32A0~*(5) */
16369 { instruction , 0 , 0 , 32,
16370 0xfc0003ff, 0x20000030, &MFC0 , 0,
16371 0x0 }, /* MFC0 */
16372 { instruction , 0 , 0 , 32,
16373 0xfc0003ff, 0x20000038, &MFHC0 , 0,
16374 CP0_ | MVH_ }, /* MFHC0 */
16375 { reserved_block , 0 , 0 , 32,
16376 0xfc0003ff, 0x20000040, 0 , 0,
16377 0x0 }, /* _POOL32A0~*(8) */
16378 { instruction , 0 , 0 , 32,
16379 0xfc0003ff, 0x20000048, &SEH , 0,
16380 0x0 }, /* SEH */
16381 { instruction , 0 , 0 , 32,
16382 0xfc0003ff, 0x20000050, &SRLV , 0,
16383 0x0 }, /* SRLV */
16384 { instruction , 0 , 0 , 32,
16385 0xfc0003ff, 0x20000058, &MUH , 0,
16386 0x0 }, /* MUH */
16387 { reserved_block , 0 , 0 , 32,
16388 0xfc0003ff, 0x20000060, 0 , 0,
16389 0x0 }, /* _POOL32A0~*(12) */
16390 { reserved_block , 0 , 0 , 32,
16391 0xfc0003ff, 0x20000068, 0 , 0,
16392 0x0 }, /* _POOL32A0~*(13) */
16393 { instruction , 0 , 0 , 32,
16394 0xfc0003ff, 0x20000070, &MTC0 , 0,
16395 CP0_ }, /* MTC0 */
16396 { instruction , 0 , 0 , 32,
16397 0xfc0003ff, 0x20000078, &MTHC0 , 0,
16398 CP0_ | MVH_ }, /* MTHC0 */
16399 { reserved_block , 0 , 0 , 32,
16400 0xfc0003ff, 0x20000080, 0 , 0,
16401 0x0 }, /* _POOL32A0~*(16) */
16402 { reserved_block , 0 , 0 , 32,
16403 0xfc0003ff, 0x20000088, 0 , 0,
16404 0x0 }, /* _POOL32A0~*(17) */
16405 { instruction , 0 , 0 , 32,
16406 0xfc0003ff, 0x20000090, &SRAV , 0,
16407 0x0 }, /* SRAV */
16408 { instruction , 0 , 0 , 32,
16409 0xfc0003ff, 0x20000098, &MULU , 0,
16410 0x0 }, /* MULU */
16411 { reserved_block , 0 , 0 , 32,
16412 0xfc0003ff, 0x200000a0, 0 , 0,
16413 0x0 }, /* _POOL32A0~*(20) */
16414 { reserved_block , 0 , 0 , 32,
16415 0xfc0003ff, 0x200000a8, 0 , 0,
16416 0x0 }, /* _POOL32A0~*(21) */
16417 { instruction , 0 , 0 , 32,
16418 0xfc0003ff, 0x200000b0, &MFGC0 , 0,
16419 CP0_ | VZ_ }, /* MFGC0 */
16420 { instruction , 0 , 0 , 32,
16421 0xfc0003ff, 0x200000b8, &MFHGC0 , 0,
16422 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16423 { reserved_block , 0 , 0 , 32,
16424 0xfc0003ff, 0x200000c0, 0 , 0,
16425 0x0 }, /* _POOL32A0~*(24) */
16426 { reserved_block , 0 , 0 , 32,
16427 0xfc0003ff, 0x200000c8, 0 , 0,
16428 0x0 }, /* _POOL32A0~*(25) */
16429 { instruction , 0 , 0 , 32,
16430 0xfc0003ff, 0x200000d0, &ROTRV , 0,
16431 0x0 }, /* ROTRV */
16432 { instruction , 0 , 0 , 32,
16433 0xfc0003ff, 0x200000d8, &MUHU , 0,
16434 0x0 }, /* MUHU */
16435 { reserved_block , 0 , 0 , 32,
16436 0xfc0003ff, 0x200000e0, 0 , 0,
16437 0x0 }, /* _POOL32A0~*(28) */
16438 { reserved_block , 0 , 0 , 32,
16439 0xfc0003ff, 0x200000e8, 0 , 0,
16440 0x0 }, /* _POOL32A0~*(29) */
16441 { instruction , 0 , 0 , 32,
16442 0xfc0003ff, 0x200000f0, &MTGC0 , 0,
16443 CP0_ | VZ_ }, /* MTGC0 */
16444 { instruction , 0 , 0 , 32,
16445 0xfc0003ff, 0x200000f8, &MTHGC0 , 0,
16446 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16447 { reserved_block , 0 , 0 , 32,
16448 0xfc0003ff, 0x20000100, 0 , 0,
16449 0x0 }, /* _POOL32A0~*(32) */
16450 { reserved_block , 0 , 0 , 32,
16451 0xfc0003ff, 0x20000108, 0 , 0,
16452 0x0 }, /* _POOL32A0~*(33) */
16453 { instruction , 0 , 0 , 32,
16454 0xfc0003ff, 0x20000110, &ADD , 0,
16455 XMMS_ }, /* ADD */
16456 { instruction , 0 , 0 , 32,
16457 0xfc0003ff, 0x20000118, &DIV , 0,
16458 0x0 }, /* DIV */
16459 { reserved_block , 0 , 0 , 32,
16460 0xfc0003ff, 0x20000120, 0 , 0,
16461 0x0 }, /* _POOL32A0~*(36) */
16462 { reserved_block , 0 , 0 , 32,
16463 0xfc0003ff, 0x20000128, 0 , 0,
16464 0x0 }, /* _POOL32A0~*(37) */
16465 { instruction , 0 , 0 , 32,
16466 0xfc0003ff, 0x20000130, &DMFC0 , 0,
16467 CP0_ | MIPS64_ }, /* DMFC0 */
16468 { reserved_block , 0 , 0 , 32,
16469 0xfc0003ff, 0x20000138, 0 , 0,
16470 0x0 }, /* _POOL32A0~*(39) */
16471 { reserved_block , 0 , 0 , 32,
16472 0xfc0003ff, 0x20000140, 0 , 0,
16473 0x0 }, /* _POOL32A0~*(40) */
16474 { reserved_block , 0 , 0 , 32,
16475 0xfc0003ff, 0x20000148, 0 , 0,
16476 0x0 }, /* _POOL32A0~*(41) */
16477 { instruction , 0 , 0 , 32,
16478 0xfc0003ff, 0x20000150, &ADDU_32_ , 0,
16479 0x0 }, /* ADDU[32] */
16480 { instruction , 0 , 0 , 32,
16481 0xfc0003ff, 0x20000158, &MOD , 0,
16482 0x0 }, /* MOD */
16483 { reserved_block , 0 , 0 , 32,
16484 0xfc0003ff, 0x20000160, 0 , 0,
16485 0x0 }, /* _POOL32A0~*(44) */
16486 { reserved_block , 0 , 0 , 32,
16487 0xfc0003ff, 0x20000168, 0 , 0,
16488 0x0 }, /* _POOL32A0~*(45) */
16489 { instruction , 0 , 0 , 32,
16490 0xfc0003ff, 0x20000170, &DMTC0 , 0,
16491 CP0_ | MIPS64_ }, /* DMTC0 */
16492 { reserved_block , 0 , 0 , 32,
16493 0xfc0003ff, 0x20000178, 0 , 0,
16494 0x0 }, /* _POOL32A0~*(47) */
16495 { reserved_block , 0 , 0 , 32,
16496 0xfc0003ff, 0x20000180, 0 , 0,
16497 0x0 }, /* _POOL32A0~*(48) */
16498 { reserved_block , 0 , 0 , 32,
16499 0xfc0003ff, 0x20000188, 0 , 0,
16500 0x0 }, /* _POOL32A0~*(49) */
16501 { instruction , 0 , 0 , 32,
16502 0xfc0003ff, 0x20000190, &SUB , 0,
16503 XMMS_ }, /* SUB */
16504 { instruction , 0 , 0 , 32,
16505 0xfc0003ff, 0x20000198, &DIVU , 0,
16506 0x0 }, /* DIVU */
16507 { reserved_block , 0 , 0 , 32,
16508 0xfc0003ff, 0x200001a0, 0 , 0,
16509 0x0 }, /* _POOL32A0~*(52) */
16510 { reserved_block , 0 , 0 , 32,
16511 0xfc0003ff, 0x200001a8, 0 , 0,
16512 0x0 }, /* _POOL32A0~*(53) */
16513 { instruction , 0 , 0 , 32,
16514 0xfc0003ff, 0x200001b0, &DMFGC0 , 0,
16515 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16516 { reserved_block , 0 , 0 , 32,
16517 0xfc0003ff, 0x200001b8, 0 , 0,
16518 0x0 }, /* _POOL32A0~*(55) */
16519 { instruction , 0 , 0 , 32,
16520 0xfc0003ff, 0x200001c0, &RDHWR , 0,
16521 XMMS_ }, /* RDHWR */
16522 { reserved_block , 0 , 0 , 32,
16523 0xfc0003ff, 0x200001c8, 0 , 0,
16524 0x0 }, /* _POOL32A0~*(57) */
16525 { instruction , 0 , 0 , 32,
16526 0xfc0003ff, 0x200001d0, &SUBU_32_ , 0,
16527 0x0 }, /* SUBU[32] */
16528 { instruction , 0 , 0 , 32,
16529 0xfc0003ff, 0x200001d8, &MODU , 0,
16530 0x0 }, /* MODU */
16531 { reserved_block , 0 , 0 , 32,
16532 0xfc0003ff, 0x200001e0, 0 , 0,
16533 0x0 }, /* _POOL32A0~*(60) */
16534 { reserved_block , 0 , 0 , 32,
16535 0xfc0003ff, 0x200001e8, 0 , 0,
16536 0x0 }, /* _POOL32A0~*(61) */
16537 { instruction , 0 , 0 , 32,
16538 0xfc0003ff, 0x200001f0, &DMTGC0 , 0,
16539 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16540 { reserved_block , 0 , 0 , 32,
16541 0xfc0003ff, 0x200001f8, 0 , 0,
16542 0x0 }, /* _POOL32A0~*(63) */
16543 { reserved_block , 0 , 0 , 32,
16544 0xfc0003ff, 0x20000200, 0 , 0,
16545 0x0 }, /* _POOL32A0~*(64) */
16546 { reserved_block , 0 , 0 , 32,
16547 0xfc0003ff, 0x20000208, 0 , 0,
16548 0x0 }, /* _POOL32A0~*(65) */
16549 { pool , P_CMOVE , 2 , 32,
16550 0xfc0003ff, 0x20000210, 0 , 0,
16551 0x0 }, /* P.CMOVE */
16552 { reserved_block , 0 , 0 , 32,
16553 0xfc0003ff, 0x20000218, 0 , 0,
16554 0x0 }, /* _POOL32A0~*(67) */
16555 { reserved_block , 0 , 0 , 32,
16556 0xfc0003ff, 0x20000220, 0 , 0,
16557 0x0 }, /* _POOL32A0~*(68) */
16558 { instruction , 0 , 0 , 32,
16559 0xfc0003ff, 0x20000228, &FORK , 0,
16560 MT_ }, /* FORK */
16561 { instruction , 0 , 0 , 32,
16562 0xfc0003ff, 0x20000230, &MFTR , 0,
16563 MT_ }, /* MFTR */
16564 { instruction , 0 , 0 , 32,
16565 0xfc0003ff, 0x20000238, &MFHTR , 0,
16566 MT_ }, /* MFHTR */
16567 { reserved_block , 0 , 0 , 32,
16568 0xfc0003ff, 0x20000240, 0 , 0,
16569 0x0 }, /* _POOL32A0~*(72) */
16570 { reserved_block , 0 , 0 , 32,
16571 0xfc0003ff, 0x20000248, 0 , 0,
16572 0x0 }, /* _POOL32A0~*(73) */
16573 { instruction , 0 , 0 , 32,
16574 0xfc0003ff, 0x20000250, &AND_32_ , 0,
16575 0x0 }, /* AND[32] */
16576 { reserved_block , 0 , 0 , 32,
16577 0xfc0003ff, 0x20000258, 0 , 0,
16578 0x0 }, /* _POOL32A0~*(75) */
16579 { reserved_block , 0 , 0 , 32,
16580 0xfc0003ff, 0x20000260, 0 , 0,
16581 0x0 }, /* _POOL32A0~*(76) */
16582 { instruction , 0 , 0 , 32,
16583 0xfc0003ff, 0x20000268, &YIELD , 0,
16584 MT_ }, /* YIELD */
16585 { instruction , 0 , 0 , 32,
16586 0xfc0003ff, 0x20000270, &MTTR , 0,
16587 MT_ }, /* MTTR */
16588 { instruction , 0 , 0 , 32,
16589 0xfc0003ff, 0x20000278, &MTHTR , 0,
16590 MT_ }, /* MTHTR */
16591 { reserved_block , 0 , 0 , 32,
16592 0xfc0003ff, 0x20000280, 0 , 0,
16593 0x0 }, /* _POOL32A0~*(80) */
16594 { reserved_block , 0 , 0 , 32,
16595 0xfc0003ff, 0x20000288, 0 , 0,
16596 0x0 }, /* _POOL32A0~*(81) */
16597 { instruction , 0 , 0 , 32,
16598 0xfc0003ff, 0x20000290, &OR_32_ , 0,
16599 0x0 }, /* OR[32] */
16600 { reserved_block , 0 , 0 , 32,
16601 0xfc0003ff, 0x20000298, 0 , 0,
16602 0x0 }, /* _POOL32A0~*(83) */
16603 { reserved_block , 0 , 0 , 32,
16604 0xfc0003ff, 0x200002a0, 0 , 0,
16605 0x0 }, /* _POOL32A0~*(84) */
16606 { reserved_block , 0 , 0 , 32,
16607 0xfc0003ff, 0x200002a8, 0 , 0,
16608 0x0 }, /* _POOL32A0~*(85) */
16609 { pool , P_MT_VPE , 8 , 32,
16610 0xfc0003ff, 0x200002b0, 0 , 0,
16611 0x0 }, /* P.MT_VPE */
16612 { reserved_block , 0 , 0 , 32,
16613 0xfc0003ff, 0x200002b8, 0 , 0,
16614 0x0 }, /* _POOL32A0~*(87) */
16615 { reserved_block , 0 , 0 , 32,
16616 0xfc0003ff, 0x200002c0, 0 , 0,
16617 0x0 }, /* _POOL32A0~*(88) */
16618 { reserved_block , 0 , 0 , 32,
16619 0xfc0003ff, 0x200002c8, 0 , 0,
16620 0x0 }, /* _POOL32A0~*(89) */
16621 { instruction , 0 , 0 , 32,
16622 0xfc0003ff, 0x200002d0, &NOR , 0,
16623 0x0 }, /* NOR */
16624 { reserved_block , 0 , 0 , 32,
16625 0xfc0003ff, 0x200002d8, 0 , 0,
16626 0x0 }, /* _POOL32A0~*(91) */
16627 { reserved_block , 0 , 0 , 32,
16628 0xfc0003ff, 0x200002e0, 0 , 0,
16629 0x0 }, /* _POOL32A0~*(92) */
16630 { reserved_block , 0 , 0 , 32,
16631 0xfc0003ff, 0x200002e8, 0 , 0,
16632 0x0 }, /* _POOL32A0~*(93) */
16633 { reserved_block , 0 , 0 , 32,
16634 0xfc0003ff, 0x200002f0, 0 , 0,
16635 0x0 }, /* _POOL32A0~*(94) */
16636 { reserved_block , 0 , 0 , 32,
16637 0xfc0003ff, 0x200002f8, 0 , 0,
16638 0x0 }, /* _POOL32A0~*(95) */
16639 { reserved_block , 0 , 0 , 32,
16640 0xfc0003ff, 0x20000300, 0 , 0,
16641 0x0 }, /* _POOL32A0~*(96) */
16642 { reserved_block , 0 , 0 , 32,
16643 0xfc0003ff, 0x20000308, 0 , 0,
16644 0x0 }, /* _POOL32A0~*(97) */
16645 { instruction , 0 , 0 , 32,
16646 0xfc0003ff, 0x20000310, &XOR_32_ , 0,
16647 0x0 }, /* XOR[32] */
16648 { reserved_block , 0 , 0 , 32,
16649 0xfc0003ff, 0x20000318, 0 , 0,
16650 0x0 }, /* _POOL32A0~*(99) */
16651 { reserved_block , 0 , 0 , 32,
16652 0xfc0003ff, 0x20000320, 0 , 0,
16653 0x0 }, /* _POOL32A0~*(100) */
16654 { reserved_block , 0 , 0 , 32,
16655 0xfc0003ff, 0x20000328, 0 , 0,
16656 0x0 }, /* _POOL32A0~*(101) */
16657 { reserved_block , 0 , 0 , 32,
16658 0xfc0003ff, 0x20000330, 0 , 0,
16659 0x0 }, /* _POOL32A0~*(102) */
16660 { reserved_block , 0 , 0 , 32,
16661 0xfc0003ff, 0x20000338, 0 , 0,
16662 0x0 }, /* _POOL32A0~*(103) */
16663 { reserved_block , 0 , 0 , 32,
16664 0xfc0003ff, 0x20000340, 0 , 0,
16665 0x0 }, /* _POOL32A0~*(104) */
16666 { reserved_block , 0 , 0 , 32,
16667 0xfc0003ff, 0x20000348, 0 , 0,
16668 0x0 }, /* _POOL32A0~*(105) */
16669 { instruction , 0 , 0 , 32,
16670 0xfc0003ff, 0x20000350, &SLT , 0,
16671 0x0 }, /* SLT */
16672 { reserved_block , 0 , 0 , 32,
16673 0xfc0003ff, 0x20000358, 0 , 0,
16674 0x0 }, /* _POOL32A0~*(107) */
16675 { reserved_block , 0 , 0 , 32,
16676 0xfc0003ff, 0x20000360, 0 , 0,
16677 0x0 }, /* _POOL32A0~*(108) */
16678 { reserved_block , 0 , 0 , 32,
16679 0xfc0003ff, 0x20000368, 0 , 0,
16680 0x0 }, /* _POOL32A0~*(109) */
16681 { reserved_block , 0 , 0 , 32,
16682 0xfc0003ff, 0x20000370, 0 , 0,
16683 0x0 }, /* _POOL32A0~*(110) */
16684 { reserved_block , 0 , 0 , 32,
16685 0xfc0003ff, 0x20000378, 0 , 0,
16686 0x0 }, /* _POOL32A0~*(111) */
16687 { reserved_block , 0 , 0 , 32,
16688 0xfc0003ff, 0x20000380, 0 , 0,
16689 0x0 }, /* _POOL32A0~*(112) */
16690 { reserved_block , 0 , 0 , 32,
16691 0xfc0003ff, 0x20000388, 0 , 0,
16692 0x0 }, /* _POOL32A0~*(113) */
16693 { pool , P_SLTU , 2 , 32,
16694 0xfc0003ff, 0x20000390, 0 , 0,
16695 0x0 }, /* P.SLTU */
16696 { reserved_block , 0 , 0 , 32,
16697 0xfc0003ff, 0x20000398, 0 , 0,
16698 0x0 }, /* _POOL32A0~*(115) */
16699 { reserved_block , 0 , 0 , 32,
16700 0xfc0003ff, 0x200003a0, 0 , 0,
16701 0x0 }, /* _POOL32A0~*(116) */
16702 { reserved_block , 0 , 0 , 32,
16703 0xfc0003ff, 0x200003a8, 0 , 0,
16704 0x0 }, /* _POOL32A0~*(117) */
16705 { reserved_block , 0 , 0 , 32,
16706 0xfc0003ff, 0x200003b0, 0 , 0,
16707 0x0 }, /* _POOL32A0~*(118) */
16708 { reserved_block , 0 , 0 , 32,
16709 0xfc0003ff, 0x200003b8, 0 , 0,
16710 0x0 }, /* _POOL32A0~*(119) */
16711 { reserved_block , 0 , 0 , 32,
16712 0xfc0003ff, 0x200003c0, 0 , 0,
16713 0x0 }, /* _POOL32A0~*(120) */
16714 { reserved_block , 0 , 0 , 32,
16715 0xfc0003ff, 0x200003c8, 0 , 0,
16716 0x0 }, /* _POOL32A0~*(121) */
16717 { instruction , 0 , 0 , 32,
16718 0xfc0003ff, 0x200003d0, &SOV , 0,
16719 0x0 }, /* SOV */
16720 { reserved_block , 0 , 0 , 32,
16721 0xfc0003ff, 0x200003d8, 0 , 0,
16722 0x0 }, /* _POOL32A0~*(123) */
16723 { reserved_block , 0 , 0 , 32,
16724 0xfc0003ff, 0x200003e0, 0 , 0,
16725 0x0 }, /* _POOL32A0~*(124) */
16726 { reserved_block , 0 , 0 , 32,
16727 0xfc0003ff, 0x200003e8, 0 , 0,
16728 0x0 }, /* _POOL32A0~*(125) */
16729 { reserved_block , 0 , 0 , 32,
16730 0xfc0003ff, 0x200003f0, 0 , 0,
16731 0x0 }, /* _POOL32A0~*(126) */
16732 { reserved_block , 0 , 0 , 32,
16733 0xfc0003ff, 0x200003f8, 0 , 0,
16734 0x0 }, /* _POOL32A0~*(127) */
16735 };
16736
16737
16738 static const Pool ADDQ__S__PH[2] = {
16739 { instruction , 0 , 0 , 32,
16740 0xfc0007ff, 0x2000000d, &ADDQ_PH , 0,
16741 DSP_ }, /* ADDQ.PH */
16742 { instruction , 0 , 0 , 32,
16743 0xfc0007ff, 0x2000040d, &ADDQ_S_PH , 0,
16744 DSP_ }, /* ADDQ_S.PH */
16745 };
16746
16747
16748 static const Pool MUL__S__PH[2] = {
16749 { instruction , 0 , 0 , 32,
16750 0xfc0007ff, 0x2000002d, &MUL_PH , 0,
16751 DSP_ }, /* MUL.PH */
16752 { instruction , 0 , 0 , 32,
16753 0xfc0007ff, 0x2000042d, &MUL_S_PH , 0,
16754 DSP_ }, /* MUL_S.PH */
16755 };
16756
16757
16758 static const Pool ADDQH__R__PH[2] = {
16759 { instruction , 0 , 0 , 32,
16760 0xfc0007ff, 0x2000004d, &ADDQH_PH , 0,
16761 DSP_ }, /* ADDQH.PH */
16762 { instruction , 0 , 0 , 32,
16763 0xfc0007ff, 0x2000044d, &ADDQH_R_PH , 0,
16764 DSP_ }, /* ADDQH_R.PH */
16765 };
16766
16767
16768 static const Pool ADDQH__R__W[2] = {
16769 { instruction , 0 , 0 , 32,
16770 0xfc0007ff, 0x2000008d, &ADDQH_W , 0,
16771 DSP_ }, /* ADDQH.W */
16772 { instruction , 0 , 0 , 32,
16773 0xfc0007ff, 0x2000048d, &ADDQH_R_W , 0,
16774 DSP_ }, /* ADDQH_R.W */
16775 };
16776
16777
16778 static const Pool ADDU__S__QB[2] = {
16779 { instruction , 0 , 0 , 32,
16780 0xfc0007ff, 0x200000cd, &ADDU_QB , 0,
16781 DSP_ }, /* ADDU.QB */
16782 { instruction , 0 , 0 , 32,
16783 0xfc0007ff, 0x200004cd, &ADDU_S_QB , 0,
16784 DSP_ }, /* ADDU_S.QB */
16785 };
16786
16787
16788 static const Pool ADDU__S__PH[2] = {
16789 { instruction , 0 , 0 , 32,
16790 0xfc0007ff, 0x2000010d, &ADDU_PH , 0,
16791 DSP_ }, /* ADDU.PH */
16792 { instruction , 0 , 0 , 32,
16793 0xfc0007ff, 0x2000050d, &ADDU_S_PH , 0,
16794 DSP_ }, /* ADDU_S.PH */
16795 };
16796
16797
16798 static const Pool ADDUH__R__QB[2] = {
16799 { instruction , 0 , 0 , 32,
16800 0xfc0007ff, 0x2000014d, &ADDUH_QB , 0,
16801 DSP_ }, /* ADDUH.QB */
16802 { instruction , 0 , 0 , 32,
16803 0xfc0007ff, 0x2000054d, &ADDUH_R_QB , 0,
16804 DSP_ }, /* ADDUH_R.QB */
16805 };
16806
16807
16808 static const Pool SHRAV__R__PH[2] = {
16809 { instruction , 0 , 0 , 32,
16810 0xfc0007ff, 0x2000018d, &SHRAV_PH , 0,
16811 DSP_ }, /* SHRAV.PH */
16812 { instruction , 0 , 0 , 32,
16813 0xfc0007ff, 0x2000058d, &SHRAV_R_PH , 0,
16814 DSP_ }, /* SHRAV_R.PH */
16815 };
16816
16817
16818 static const Pool SHRAV__R__QB[2] = {
16819 { instruction , 0 , 0 , 32,
16820 0xfc0007ff, 0x200001cd, &SHRAV_QB , 0,
16821 DSP_ }, /* SHRAV.QB */
16822 { instruction , 0 , 0 , 32,
16823 0xfc0007ff, 0x200005cd, &SHRAV_R_QB , 0,
16824 DSP_ }, /* SHRAV_R.QB */
16825 };
16826
16827
16828 static const Pool SUBQ__S__PH[2] = {
16829 { instruction , 0 , 0 , 32,
16830 0xfc0007ff, 0x2000020d, &SUBQ_PH , 0,
16831 DSP_ }, /* SUBQ.PH */
16832 { instruction , 0 , 0 , 32,
16833 0xfc0007ff, 0x2000060d, &SUBQ_S_PH , 0,
16834 DSP_ }, /* SUBQ_S.PH */
16835 };
16836
16837
16838 static const Pool SUBQH__R__PH[2] = {
16839 { instruction , 0 , 0 , 32,
16840 0xfc0007ff, 0x2000024d, &SUBQH_PH , 0,
16841 DSP_ }, /* SUBQH.PH */
16842 { instruction , 0 , 0 , 32,
16843 0xfc0007ff, 0x2000064d, &SUBQH_R_PH , 0,
16844 DSP_ }, /* SUBQH_R.PH */
16845 };
16846
16847
16848 static const Pool SUBQH__R__W[2] = {
16849 { instruction , 0 , 0 , 32,
16850 0xfc0007ff, 0x2000028d, &SUBQH_W , 0,
16851 DSP_ }, /* SUBQH.W */
16852 { instruction , 0 , 0 , 32,
16853 0xfc0007ff, 0x2000068d, &SUBQH_R_W , 0,
16854 DSP_ }, /* SUBQH_R.W */
16855 };
16856
16857
16858 static const Pool SUBU__S__QB[2] = {
16859 { instruction , 0 , 0 , 32,
16860 0xfc0007ff, 0x200002cd, &SUBU_QB , 0,
16861 DSP_ }, /* SUBU.QB */
16862 { instruction , 0 , 0 , 32,
16863 0xfc0007ff, 0x200006cd, &SUBU_S_QB , 0,
16864 DSP_ }, /* SUBU_S.QB */
16865 };
16866
16867
16868 static const Pool SUBU__S__PH[2] = {
16869 { instruction , 0 , 0 , 32,
16870 0xfc0007ff, 0x2000030d, &SUBU_PH , 0,
16871 DSP_ }, /* SUBU.PH */
16872 { instruction , 0 , 0 , 32,
16873 0xfc0007ff, 0x2000070d, &SUBU_S_PH , 0,
16874 DSP_ }, /* SUBU_S.PH */
16875 };
16876
16877
16878 static const Pool SHRA__R__PH[2] = {
16879 { instruction , 0 , 0 , 32,
16880 0xfc0007ff, 0x20000335, &SHRA_PH , 0,
16881 DSP_ }, /* SHRA.PH */
16882 { instruction , 0 , 0 , 32,
16883 0xfc0007ff, 0x20000735, &SHRA_R_PH , 0,
16884 DSP_ }, /* SHRA_R.PH */
16885 };
16886
16887
16888 static const Pool SUBUH__R__QB[2] = {
16889 { instruction , 0 , 0 , 32,
16890 0xfc0007ff, 0x2000034d, &SUBUH_QB , 0,
16891 DSP_ }, /* SUBUH.QB */
16892 { instruction , 0 , 0 , 32,
16893 0xfc0007ff, 0x2000074d, &SUBUH_R_QB , 0,
16894 DSP_ }, /* SUBUH_R.QB */
16895 };
16896
16897
16898 static const Pool SHLLV__S__PH[2] = {
16899 { instruction , 0 , 0 , 32,
16900 0xfc0007ff, 0x2000038d, &SHLLV_PH , 0,
16901 DSP_ }, /* SHLLV.PH */
16902 { instruction , 0 , 0 , 32,
16903 0xfc0007ff, 0x2000078d, &SHLLV_S_PH , 0,
16904 DSP_ }, /* SHLLV_S.PH */
16905 };
16906
16907
16908 static const Pool SHLL__S__PH[4] = {
16909 { instruction , 0 , 0 , 32,
16910 0xfc000fff, 0x200003b5, &SHLL_PH , 0,
16911 DSP_ }, /* SHLL.PH */
16912 { reserved_block , 0 , 0 , 32,
16913 0xfc000fff, 0x200007b5, 0 , 0,
16914 0x0 }, /* SHLL[_S].PH~*(1) */
16915 { instruction , 0 , 0 , 32,
16916 0xfc000fff, 0x20000bb5, &SHLL_S_PH , 0,
16917 DSP_ }, /* SHLL_S.PH */
16918 { reserved_block , 0 , 0 , 32,
16919 0xfc000fff, 0x20000fb5, 0 , 0,
16920 0x0 }, /* SHLL[_S].PH~*(3) */
16921 };
16922
16923
16924 static const Pool PRECR_SRA__R__PH_W[2] = {
16925 { instruction , 0 , 0 , 32,
16926 0xfc0007ff, 0x200003cd, &PRECR_SRA_PH_W , 0,
16927 DSP_ }, /* PRECR_SRA.PH.W */
16928 { instruction , 0 , 0 , 32,
16929 0xfc0007ff, 0x200007cd, &PRECR_SRA_R_PH_W , 0,
16930 DSP_ }, /* PRECR_SRA_R.PH.W */
16931 };
16932
16933
16934 static const Pool _POOL32A5[128] = {
16935 { instruction , 0 , 0 , 32,
16936 0xfc0003ff, 0x20000005, &CMP_EQ_PH , 0,
16937 DSP_ }, /* CMP.EQ.PH */
16938 { pool , ADDQ__S__PH , 2 , 32,
16939 0xfc0003ff, 0x2000000d, 0 , 0,
16940 0x0 }, /* ADDQ[_S].PH */
16941 { reserved_block , 0 , 0 , 32,
16942 0xfc0003ff, 0x20000015, 0 , 0,
16943 0x0 }, /* _POOL32A5~*(2) */
16944 { instruction , 0 , 0 , 32,
16945 0xfc0003ff, 0x2000001d, &SHILO , 0,
16946 DSP_ }, /* SHILO */
16947 { instruction , 0 , 0 , 32,
16948 0xfc0003ff, 0x20000025, &MULEQ_S_W_PHL , 0,
16949 DSP_ }, /* MULEQ_S.W.PHL */
16950 { pool , MUL__S__PH , 2 , 32,
16951 0xfc0003ff, 0x2000002d, 0 , 0,
16952 0x0 }, /* MUL[_S].PH */
16953 { reserved_block , 0 , 0 , 32,
16954 0xfc0003ff, 0x20000035, 0 , 0,
16955 0x0 }, /* _POOL32A5~*(6) */
16956 { instruction , 0 , 0 , 32,
16957 0xfc0003ff, 0x2000003d, &REPL_PH , 0,
16958 DSP_ }, /* REPL.PH */
16959 { instruction , 0 , 0 , 32,
16960 0xfc0003ff, 0x20000045, &CMP_LT_PH , 0,
16961 DSP_ }, /* CMP.LT.PH */
16962 { pool , ADDQH__R__PH , 2 , 32,
16963 0xfc0003ff, 0x2000004d, 0 , 0,
16964 0x0 }, /* ADDQH[_R].PH */
16965 { reserved_block , 0 , 0 , 32,
16966 0xfc0003ff, 0x20000055, 0 , 0,
16967 0x0 }, /* _POOL32A5~*(10) */
16968 { reserved_block , 0 , 0 , 32,
16969 0xfc0003ff, 0x2000005d, 0 , 0,
16970 0x0 }, /* _POOL32A5~*(11) */
16971 { instruction , 0 , 0 , 32,
16972 0xfc0003ff, 0x20000065, &MULEQ_S_W_PHR , 0,
16973 DSP_ }, /* MULEQ_S.W.PHR */
16974 { instruction , 0 , 0 , 32,
16975 0xfc0003ff, 0x2000006d, &PRECR_QB_PH , 0,
16976 DSP_ }, /* PRECR.QB.PH */
16977 { reserved_block , 0 , 0 , 32,
16978 0xfc0003ff, 0x20000075, 0 , 0,
16979 0x0 }, /* _POOL32A5~*(14) */
16980 { reserved_block , 0 , 0 , 32,
16981 0xfc0003ff, 0x2000007d, 0 , 0,
16982 0x0 }, /* _POOL32A5~*(15) */
16983 { instruction , 0 , 0 , 32,
16984 0xfc0003ff, 0x20000085, &CMP_LE_PH , 0,
16985 DSP_ }, /* CMP.LE.PH */
16986 { pool , ADDQH__R__W , 2 , 32,
16987 0xfc0003ff, 0x2000008d, 0 , 0,
16988 0x0 }, /* ADDQH[_R].W */
16989 { instruction , 0 , 0 , 32,
16990 0xfc0003ff, 0x20000095, &MULEU_S_PH_QBL , 0,
16991 DSP_ }, /* MULEU_S.PH.QBL */
16992 { reserved_block , 0 , 0 , 32,
16993 0xfc0003ff, 0x2000009d, 0 , 0,
16994 0x0 }, /* _POOL32A5~*(19) */
16995 { reserved_block , 0 , 0 , 32,
16996 0xfc0003ff, 0x200000a5, 0 , 0,
16997 0x0 }, /* _POOL32A5~*(20) */
16998 { instruction , 0 , 0 , 32,
16999 0xfc0003ff, 0x200000ad, &PRECRQ_QB_PH , 0,
17000 DSP_ }, /* PRECRQ.QB.PH */
17001 { reserved_block , 0 , 0 , 32,
17002 0xfc0003ff, 0x200000b5, 0 , 0,
17003 0x0 }, /* _POOL32A5~*(22) */
17004 { reserved_block , 0 , 0 , 32,
17005 0xfc0003ff, 0x200000bd, 0 , 0,
17006 0x0 }, /* _POOL32A5~*(23) */
17007 { instruction , 0 , 0 , 32,
17008 0xfc0003ff, 0x200000c5, &CMPGU_EQ_QB , 0,
17009 DSP_ }, /* CMPGU.EQ.QB */
17010 { pool , ADDU__S__QB , 2 , 32,
17011 0xfc0003ff, 0x200000cd, 0 , 0,
17012 0x0 }, /* ADDU[_S].QB */
17013 { instruction , 0 , 0 , 32,
17014 0xfc0003ff, 0x200000d5, &MULEU_S_PH_QBR , 0,
17015 DSP_ }, /* MULEU_S.PH.QBR */
17016 { reserved_block , 0 , 0 , 32,
17017 0xfc0003ff, 0x200000dd, 0 , 0,
17018 0x0 }, /* _POOL32A5~*(27) */
17019 { reserved_block , 0 , 0 , 32,
17020 0xfc0003ff, 0x200000e5, 0 , 0,
17021 0x0 }, /* _POOL32A5~*(28) */
17022 { instruction , 0 , 0 , 32,
17023 0xfc0003ff, 0x200000ed, &PRECRQ_PH_W , 0,
17024 DSP_ }, /* PRECRQ.PH.W */
17025 { reserved_block , 0 , 0 , 32,
17026 0xfc0003ff, 0x200000f5, 0 , 0,
17027 0x0 }, /* _POOL32A5~*(30) */
17028 { reserved_block , 0 , 0 , 32,
17029 0xfc0003ff, 0x200000fd, 0 , 0,
17030 0x0 }, /* _POOL32A5~*(31) */
17031 { instruction , 0 , 0 , 32,
17032 0xfc0003ff, 0x20000105, &CMPGU_LT_QB , 0,
17033 DSP_ }, /* CMPGU.LT.QB */
17034 { pool , ADDU__S__PH , 2 , 32,
17035 0xfc0003ff, 0x2000010d, 0 , 0,
17036 0x0 }, /* ADDU[_S].PH */
17037 { instruction , 0 , 0 , 32,
17038 0xfc0003ff, 0x20000115, &MULQ_RS_PH , 0,
17039 DSP_ }, /* MULQ_RS.PH */
17040 { reserved_block , 0 , 0 , 32,
17041 0xfc0003ff, 0x2000011d, 0 , 0,
17042 0x0 }, /* _POOL32A5~*(35) */
17043 { reserved_block , 0 , 0 , 32,
17044 0xfc0003ff, 0x20000125, 0 , 0,
17045 0x0 }, /* _POOL32A5~*(36) */
17046 { instruction , 0 , 0 , 32,
17047 0xfc0003ff, 0x2000012d, &PRECRQ_RS_PH_W , 0,
17048 DSP_ }, /* PRECRQ_RS.PH.W */
17049 { reserved_block , 0 , 0 , 32,
17050 0xfc0003ff, 0x20000135, 0 , 0,
17051 0x0 }, /* _POOL32A5~*(38) */
17052 { reserved_block , 0 , 0 , 32,
17053 0xfc0003ff, 0x2000013d, 0 , 0,
17054 0x0 }, /* _POOL32A5~*(39) */
17055 { instruction , 0 , 0 , 32,
17056 0xfc0003ff, 0x20000145, &CMPGU_LE_QB , 0,
17057 DSP_ }, /* CMPGU.LE.QB */
17058 { pool , ADDUH__R__QB , 2 , 32,
17059 0xfc0003ff, 0x2000014d, 0 , 0,
17060 0x0 }, /* ADDUH[_R].QB */
17061 { instruction , 0 , 0 , 32,
17062 0xfc0003ff, 0x20000155, &MULQ_S_PH , 0,
17063 DSP_ }, /* MULQ_S.PH */
17064 { reserved_block , 0 , 0 , 32,
17065 0xfc0003ff, 0x2000015d, 0 , 0,
17066 0x0 }, /* _POOL32A5~*(43) */
17067 { reserved_block , 0 , 0 , 32,
17068 0xfc0003ff, 0x20000165, 0 , 0,
17069 0x0 }, /* _POOL32A5~*(44) */
17070 { instruction , 0 , 0 , 32,
17071 0xfc0003ff, 0x2000016d, &PRECRQU_S_QB_PH , 0,
17072 DSP_ }, /* PRECRQU_S.QB.PH */
17073 { reserved_block , 0 , 0 , 32,
17074 0xfc0003ff, 0x20000175, 0 , 0,
17075 0x0 }, /* _POOL32A5~*(46) */
17076 { reserved_block , 0 , 0 , 32,
17077 0xfc0003ff, 0x2000017d, 0 , 0,
17078 0x0 }, /* _POOL32A5~*(47) */
17079 { instruction , 0 , 0 , 32,
17080 0xfc0003ff, 0x20000185, &CMPGDU_EQ_QB , 0,
17081 DSP_ }, /* CMPGDU.EQ.QB */
17082 { pool , SHRAV__R__PH , 2 , 32,
17083 0xfc0003ff, 0x2000018d, 0 , 0,
17084 0x0 }, /* SHRAV[_R].PH */
17085 { instruction , 0 , 0 , 32,
17086 0xfc0003ff, 0x20000195, &MULQ_RS_W , 0,
17087 DSP_ }, /* MULQ_RS.W */
17088 { reserved_block , 0 , 0 , 32,
17089 0xfc0003ff, 0x2000019d, 0 , 0,
17090 0x0 }, /* _POOL32A5~*(51) */
17091 { reserved_block , 0 , 0 , 32,
17092 0xfc0003ff, 0x200001a5, 0 , 0,
17093 0x0 }, /* _POOL32A5~*(52) */
17094 { instruction , 0 , 0 , 32,
17095 0xfc0003ff, 0x200001ad, &PACKRL_PH , 0,
17096 DSP_ }, /* PACKRL.PH */
17097 { reserved_block , 0 , 0 , 32,
17098 0xfc0003ff, 0x200001b5, 0 , 0,
17099 0x0 }, /* _POOL32A5~*(54) */
17100 { reserved_block , 0 , 0 , 32,
17101 0xfc0003ff, 0x200001bd, 0 , 0,
17102 0x0 }, /* _POOL32A5~*(55) */
17103 { instruction , 0 , 0 , 32,
17104 0xfc0003ff, 0x200001c5, &CMPGDU_LT_QB , 0,
17105 DSP_ }, /* CMPGDU.LT.QB */
17106 { pool , SHRAV__R__QB , 2 , 32,
17107 0xfc0003ff, 0x200001cd, 0 , 0,
17108 0x0 }, /* SHRAV[_R].QB */
17109 { instruction , 0 , 0 , 32,
17110 0xfc0003ff, 0x200001d5, &MULQ_S_W , 0,
17111 DSP_ }, /* MULQ_S.W */
17112 { reserved_block , 0 , 0 , 32,
17113 0xfc0003ff, 0x200001dd, 0 , 0,
17114 0x0 }, /* _POOL32A5~*(59) */
17115 { reserved_block , 0 , 0 , 32,
17116 0xfc0003ff, 0x200001e5, 0 , 0,
17117 0x0 }, /* _POOL32A5~*(60) */
17118 { instruction , 0 , 0 , 32,
17119 0xfc0003ff, 0x200001ed, &PICK_QB , 0,
17120 DSP_ }, /* PICK.QB */
17121 { reserved_block , 0 , 0 , 32,
17122 0xfc0003ff, 0x200001f5, 0 , 0,
17123 0x0 }, /* _POOL32A5~*(62) */
17124 { reserved_block , 0 , 0 , 32,
17125 0xfc0003ff, 0x200001fd, 0 , 0,
17126 0x0 }, /* _POOL32A5~*(63) */
17127 { instruction , 0 , 0 , 32,
17128 0xfc0003ff, 0x20000205, &CMPGDU_LE_QB , 0,
17129 DSP_ }, /* CMPGDU.LE.QB */
17130 { pool , SUBQ__S__PH , 2 , 32,
17131 0xfc0003ff, 0x2000020d, 0 , 0,
17132 0x0 }, /* SUBQ[_S].PH */
17133 { instruction , 0 , 0 , 32,
17134 0xfc0003ff, 0x20000215, &APPEND , 0,
17135 DSP_ }, /* APPEND */
17136 { reserved_block , 0 , 0 , 32,
17137 0xfc0003ff, 0x2000021d, 0 , 0,
17138 0x0 }, /* _POOL32A5~*(67) */
17139 { reserved_block , 0 , 0 , 32,
17140 0xfc0003ff, 0x20000225, 0 , 0,
17141 0x0 }, /* _POOL32A5~*(68) */
17142 { instruction , 0 , 0 , 32,
17143 0xfc0003ff, 0x2000022d, &PICK_PH , 0,
17144 DSP_ }, /* PICK.PH */
17145 { reserved_block , 0 , 0 , 32,
17146 0xfc0003ff, 0x20000235, 0 , 0,
17147 0x0 }, /* _POOL32A5~*(70) */
17148 { reserved_block , 0 , 0 , 32,
17149 0xfc0003ff, 0x2000023d, 0 , 0,
17150 0x0 }, /* _POOL32A5~*(71) */
17151 { instruction , 0 , 0 , 32,
17152 0xfc0003ff, 0x20000245, &CMPU_EQ_QB , 0,
17153 DSP_ }, /* CMPU.EQ.QB */
17154 { pool , SUBQH__R__PH , 2 , 32,
17155 0xfc0003ff, 0x2000024d, 0 , 0,
17156 0x0 }, /* SUBQH[_R].PH */
17157 { instruction , 0 , 0 , 32,
17158 0xfc0003ff, 0x20000255, &PREPEND , 0,
17159 DSP_ }, /* PREPEND */
17160 { reserved_block , 0 , 0 , 32,
17161 0xfc0003ff, 0x2000025d, 0 , 0,
17162 0x0 }, /* _POOL32A5~*(75) */
17163 { reserved_block , 0 , 0 , 32,
17164 0xfc0003ff, 0x20000265, 0 , 0,
17165 0x0 }, /* _POOL32A5~*(76) */
17166 { reserved_block , 0 , 0 , 32,
17167 0xfc0003ff, 0x2000026d, 0 , 0,
17168 0x0 }, /* _POOL32A5~*(77) */
17169 { reserved_block , 0 , 0 , 32,
17170 0xfc0003ff, 0x20000275, 0 , 0,
17171 0x0 }, /* _POOL32A5~*(78) */
17172 { reserved_block , 0 , 0 , 32,
17173 0xfc0003ff, 0x2000027d, 0 , 0,
17174 0x0 }, /* _POOL32A5~*(79) */
17175 { instruction , 0 , 0 , 32,
17176 0xfc0003ff, 0x20000285, &CMPU_LT_QB , 0,
17177 DSP_ }, /* CMPU.LT.QB */
17178 { pool , SUBQH__R__W , 2 , 32,
17179 0xfc0003ff, 0x2000028d, 0 , 0,
17180 0x0 }, /* SUBQH[_R].W */
17181 { instruction , 0 , 0 , 32,
17182 0xfc0003ff, 0x20000295, &MODSUB , 0,
17183 DSP_ }, /* MODSUB */
17184 { reserved_block , 0 , 0 , 32,
17185 0xfc0003ff, 0x2000029d, 0 , 0,
17186 0x0 }, /* _POOL32A5~*(83) */
17187 { reserved_block , 0 , 0 , 32,
17188 0xfc0003ff, 0x200002a5, 0 , 0,
17189 0x0 }, /* _POOL32A5~*(84) */
17190 { reserved_block , 0 , 0 , 32,
17191 0xfc0003ff, 0x200002ad, 0 , 0,
17192 0x0 }, /* _POOL32A5~*(85) */
17193 { reserved_block , 0 , 0 , 32,
17194 0xfc0003ff, 0x200002b5, 0 , 0,
17195 0x0 }, /* _POOL32A5~*(86) */
17196 { reserved_block , 0 , 0 , 32,
17197 0xfc0003ff, 0x200002bd, 0 , 0,
17198 0x0 }, /* _POOL32A5~*(87) */
17199 { instruction , 0 , 0 , 32,
17200 0xfc0003ff, 0x200002c5, &CMPU_LE_QB , 0,
17201 DSP_ }, /* CMPU.LE.QB */
17202 { pool , SUBU__S__QB , 2 , 32,
17203 0xfc0003ff, 0x200002cd, 0 , 0,
17204 0x0 }, /* SUBU[_S].QB */
17205 { instruction , 0 , 0 , 32,
17206 0xfc0003ff, 0x200002d5, &SHRAV_R_W , 0,
17207 DSP_ }, /* SHRAV_R.W */
17208 { reserved_block , 0 , 0 , 32,
17209 0xfc0003ff, 0x200002dd, 0 , 0,
17210 0x0 }, /* _POOL32A5~*(91) */
17211 { reserved_block , 0 , 0 , 32,
17212 0xfc0003ff, 0x200002e5, 0 , 0,
17213 0x0 }, /* _POOL32A5~*(92) */
17214 { reserved_block , 0 , 0 , 32,
17215 0xfc0003ff, 0x200002ed, 0 , 0,
17216 0x0 }, /* _POOL32A5~*(93) */
17217 { instruction , 0 , 0 , 32,
17218 0xfc0003ff, 0x200002f5, &SHRA_R_W , 0,
17219 DSP_ }, /* SHRA_R.W */
17220 { reserved_block , 0 , 0 , 32,
17221 0xfc0003ff, 0x200002fd, 0 , 0,
17222 0x0 }, /* _POOL32A5~*(95) */
17223 { instruction , 0 , 0 , 32,
17224 0xfc0003ff, 0x20000305, &ADDQ_S_W , 0,
17225 DSP_ }, /* ADDQ_S.W */
17226 { pool , SUBU__S__PH , 2 , 32,
17227 0xfc0003ff, 0x2000030d, 0 , 0,
17228 0x0 }, /* SUBU[_S].PH */
17229 { instruction , 0 , 0 , 32,
17230 0xfc0003ff, 0x20000315, &SHRLV_PH , 0,
17231 DSP_ }, /* SHRLV.PH */
17232 { reserved_block , 0 , 0 , 32,
17233 0xfc0003ff, 0x2000031d, 0 , 0,
17234 0x0 }, /* _POOL32A5~*(99) */
17235 { reserved_block , 0 , 0 , 32,
17236 0xfc0003ff, 0x20000325, 0 , 0,
17237 0x0 }, /* _POOL32A5~*(100) */
17238 { reserved_block , 0 , 0 , 32,
17239 0xfc0003ff, 0x2000032d, 0 , 0,
17240 0x0 }, /* _POOL32A5~*(101) */
17241 { pool , SHRA__R__PH , 2 , 32,
17242 0xfc0003ff, 0x20000335, 0 , 0,
17243 0x0 }, /* SHRA[_R].PH */
17244 { reserved_block , 0 , 0 , 32,
17245 0xfc0003ff, 0x2000033d, 0 , 0,
17246 0x0 }, /* _POOL32A5~*(103) */
17247 { instruction , 0 , 0 , 32,
17248 0xfc0003ff, 0x20000345, &SUBQ_S_W , 0,
17249 DSP_ }, /* SUBQ_S.W */
17250 { pool , SUBUH__R__QB , 2 , 32,
17251 0xfc0003ff, 0x2000034d, 0 , 0,
17252 0x0 }, /* SUBUH[_R].QB */
17253 { instruction , 0 , 0 , 32,
17254 0xfc0003ff, 0x20000355, &SHRLV_QB , 0,
17255 DSP_ }, /* SHRLV.QB */
17256 { reserved_block , 0 , 0 , 32,
17257 0xfc0003ff, 0x2000035d, 0 , 0,
17258 0x0 }, /* _POOL32A5~*(107) */
17259 { reserved_block , 0 , 0 , 32,
17260 0xfc0003ff, 0x20000365, 0 , 0,
17261 0x0 }, /* _POOL32A5~*(108) */
17262 { reserved_block , 0 , 0 , 32,
17263 0xfc0003ff, 0x2000036d, 0 , 0,
17264 0x0 }, /* _POOL32A5~*(109) */
17265 { reserved_block , 0 , 0 , 32,
17266 0xfc0003ff, 0x20000375, 0 , 0,
17267 0x0 }, /* _POOL32A5~*(110) */
17268 { reserved_block , 0 , 0 , 32,
17269 0xfc0003ff, 0x2000037d, 0 , 0,
17270 0x0 }, /* _POOL32A5~*(111) */
17271 { instruction , 0 , 0 , 32,
17272 0xfc0003ff, 0x20000385, &ADDSC , 0,
17273 DSP_ }, /* ADDSC */
17274 { pool , SHLLV__S__PH , 2 , 32,
17275 0xfc0003ff, 0x2000038d, 0 , 0,
17276 0x0 }, /* SHLLV[_S].PH */
17277 { instruction , 0 , 0 , 32,
17278 0xfc0003ff, 0x20000395, &SHLLV_QB , 0,
17279 DSP_ }, /* SHLLV.QB */
17280 { reserved_block , 0 , 0 , 32,
17281 0xfc0003ff, 0x2000039d, 0 , 0,
17282 0x0 }, /* _POOL32A5~*(115) */
17283 { reserved_block , 0 , 0 , 32,
17284 0xfc0003ff, 0x200003a5, 0 , 0,
17285 0x0 }, /* _POOL32A5~*(116) */
17286 { reserved_block , 0 , 0 , 32,
17287 0xfc0003ff, 0x200003ad, 0 , 0,
17288 0x0 }, /* _POOL32A5~*(117) */
17289 { pool , SHLL__S__PH , 4 , 32,
17290 0xfc0003ff, 0x200003b5, 0 , 0,
17291 0x0 }, /* SHLL[_S].PH */
17292 { reserved_block , 0 , 0 , 32,
17293 0xfc0003ff, 0x200003bd, 0 , 0,
17294 0x0 }, /* _POOL32A5~*(119) */
17295 { instruction , 0 , 0 , 32,
17296 0xfc0003ff, 0x200003c5, &ADDWC , 0,
17297 DSP_ }, /* ADDWC */
17298 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17299 0xfc0003ff, 0x200003cd, 0 , 0,
17300 0x0 }, /* PRECR_SRA[_R].PH.W */
17301 { instruction , 0 , 0 , 32,
17302 0xfc0003ff, 0x200003d5, &SHLLV_S_W , 0,
17303 DSP_ }, /* SHLLV_S.W */
17304 { reserved_block , 0 , 0 , 32,
17305 0xfc0003ff, 0x200003dd, 0 , 0,
17306 0x0 }, /* _POOL32A5~*(123) */
17307 { reserved_block , 0 , 0 , 32,
17308 0xfc0003ff, 0x200003e5, 0 , 0,
17309 0x0 }, /* _POOL32A5~*(124) */
17310 { reserved_block , 0 , 0 , 32,
17311 0xfc0003ff, 0x200003ed, 0 , 0,
17312 0x0 }, /* _POOL32A5~*(125) */
17313 { instruction , 0 , 0 , 32,
17314 0xfc0003ff, 0x200003f5, &SHLL_S_W , 0,
17315 DSP_ }, /* SHLL_S.W */
17316 { reserved_block , 0 , 0 , 32,
17317 0xfc0003ff, 0x200003fd, 0 , 0,
17318 0x0 }, /* _POOL32A5~*(127) */
17319 };
17320
17321
17322 static const Pool PP_LSX[16] = {
17323 { instruction , 0 , 0 , 32,
17324 0xfc0007ff, 0x20000007, &LBX , 0,
17325 0x0 }, /* LBX */
17326 { instruction , 0 , 0 , 32,
17327 0xfc0007ff, 0x20000087, &SBX , 0,
17328 XMMS_ }, /* SBX */
17329 { instruction , 0 , 0 , 32,
17330 0xfc0007ff, 0x20000107, &LBUX , 0,
17331 0x0 }, /* LBUX */
17332 { reserved_block , 0 , 0 , 32,
17333 0xfc0007ff, 0x20000187, 0 , 0,
17334 0x0 }, /* PP.LSX~*(3) */
17335 { instruction , 0 , 0 , 32,
17336 0xfc0007ff, 0x20000207, &LHX , 0,
17337 0x0 }, /* LHX */
17338 { instruction , 0 , 0 , 32,
17339 0xfc0007ff, 0x20000287, &SHX , 0,
17340 XMMS_ }, /* SHX */
17341 { instruction , 0 , 0 , 32,
17342 0xfc0007ff, 0x20000307, &LHUX , 0,
17343 0x0 }, /* LHUX */
17344 { instruction , 0 , 0 , 32,
17345 0xfc0007ff, 0x20000387, &LWUX , 0,
17346 MIPS64_ }, /* LWUX */
17347 { instruction , 0 , 0 , 32,
17348 0xfc0007ff, 0x20000407, &LWX , 0,
17349 0x0 }, /* LWX */
17350 { instruction , 0 , 0 , 32,
17351 0xfc0007ff, 0x20000487, &SWX , 0,
17352 XMMS_ }, /* SWX */
17353 { instruction , 0 , 0 , 32,
17354 0xfc0007ff, 0x20000507, &LWC1X , 0,
17355 CP1_ }, /* LWC1X */
17356 { instruction , 0 , 0 , 32,
17357 0xfc0007ff, 0x20000587, &SWC1X , 0,
17358 CP1_ }, /* SWC1X */
17359 { instruction , 0 , 0 , 32,
17360 0xfc0007ff, 0x20000607, &LDX , 0,
17361 MIPS64_ }, /* LDX */
17362 { instruction , 0 , 0 , 32,
17363 0xfc0007ff, 0x20000687, &SDX , 0,
17364 MIPS64_ }, /* SDX */
17365 { instruction , 0 , 0 , 32,
17366 0xfc0007ff, 0x20000707, &LDC1X , 0,
17367 CP1_ }, /* LDC1X */
17368 { instruction , 0 , 0 , 32,
17369 0xfc0007ff, 0x20000787, &SDC1X , 0,
17370 CP1_ }, /* SDC1X */
17371 };
17372
17373
17374 static const Pool PP_LSXS[16] = {
17375 { reserved_block , 0 , 0 , 32,
17376 0xfc0007ff, 0x20000047, 0 , 0,
17377 0x0 }, /* PP.LSXS~*(0) */
17378 { reserved_block , 0 , 0 , 32,
17379 0xfc0007ff, 0x200000c7, 0 , 0,
17380 0x0 }, /* PP.LSXS~*(1) */
17381 { reserved_block , 0 , 0 , 32,
17382 0xfc0007ff, 0x20000147, 0 , 0,
17383 0x0 }, /* PP.LSXS~*(2) */
17384 { reserved_block , 0 , 0 , 32,
17385 0xfc0007ff, 0x200001c7, 0 , 0,
17386 0x0 }, /* PP.LSXS~*(3) */
17387 { instruction , 0 , 0 , 32,
17388 0xfc0007ff, 0x20000247, &LHXS , 0,
17389 0x0 }, /* LHXS */
17390 { instruction , 0 , 0 , 32,
17391 0xfc0007ff, 0x200002c7, &SHXS , 0,
17392 XMMS_ }, /* SHXS */
17393 { instruction , 0 , 0 , 32,
17394 0xfc0007ff, 0x20000347, &LHUXS , 0,
17395 0x0 }, /* LHUXS */
17396 { instruction , 0 , 0 , 32,
17397 0xfc0007ff, 0x200003c7, &LWUXS , 0,
17398 MIPS64_ }, /* LWUXS */
17399 { instruction , 0 , 0 , 32,
17400 0xfc0007ff, 0x20000447, &LWXS_32_ , 0,
17401 0x0 }, /* LWXS[32] */
17402 { instruction , 0 , 0 , 32,
17403 0xfc0007ff, 0x200004c7, &SWXS , 0,
17404 XMMS_ }, /* SWXS */
17405 { instruction , 0 , 0 , 32,
17406 0xfc0007ff, 0x20000547, &LWC1XS , 0,
17407 CP1_ }, /* LWC1XS */
17408 { instruction , 0 , 0 , 32,
17409 0xfc0007ff, 0x200005c7, &SWC1XS , 0,
17410 CP1_ }, /* SWC1XS */
17411 { instruction , 0 , 0 , 32,
17412 0xfc0007ff, 0x20000647, &LDXS , 0,
17413 MIPS64_ }, /* LDXS */
17414 { instruction , 0 , 0 , 32,
17415 0xfc0007ff, 0x200006c7, &SDXS , 0,
17416 MIPS64_ }, /* SDXS */
17417 { instruction , 0 , 0 , 32,
17418 0xfc0007ff, 0x20000747, &LDC1XS , 0,
17419 CP1_ }, /* LDC1XS */
17420 { instruction , 0 , 0 , 32,
17421 0xfc0007ff, 0x200007c7, &SDC1XS , 0,
17422 CP1_ }, /* SDC1XS */
17423 };
17424
17425
17426 static const Pool P_LSX[2] = {
17427 { pool , PP_LSX , 16 , 32,
17428 0xfc00007f, 0x20000007, 0 , 0,
17429 0x0 }, /* PP.LSX */
17430 { pool , PP_LSXS , 16 , 32,
17431 0xfc00007f, 0x20000047, 0 , 0,
17432 0x0 }, /* PP.LSXS */
17433 };
17434
17435
17436 static const Pool POOL32Axf_1_0[4] = {
17437 { instruction , 0 , 0 , 32,
17438 0xfc003fff, 0x2000007f, &MFHI_DSP_ , 0,
17439 DSP_ }, /* MFHI[DSP] */
17440 { instruction , 0 , 0 , 32,
17441 0xfc003fff, 0x2000107f, &MFLO_DSP_ , 0,
17442 DSP_ }, /* MFLO[DSP] */
17443 { instruction , 0 , 0 , 32,
17444 0xfc003fff, 0x2000207f, &MTHI_DSP_ , 0,
17445 DSP_ }, /* MTHI[DSP] */
17446 { instruction , 0 , 0 , 32,
17447 0xfc003fff, 0x2000307f, &MTLO_DSP_ , 0,
17448 DSP_ }, /* MTLO[DSP] */
17449 };
17450
17451
17452 static const Pool POOL32Axf_1_1[4] = {
17453 { instruction , 0 , 0 , 32,
17454 0xfc003fff, 0x2000027f, &MTHLIP , 0,
17455 DSP_ }, /* MTHLIP */
17456 { instruction , 0 , 0 , 32,
17457 0xfc003fff, 0x2000127f, &SHILOV , 0,
17458 DSP_ }, /* SHILOV */
17459 { reserved_block , 0 , 0 , 32,
17460 0xfc003fff, 0x2000227f, 0 , 0,
17461 0x0 }, /* POOL32Axf_1_1~*(2) */
17462 { reserved_block , 0 , 0 , 32,
17463 0xfc003fff, 0x2000327f, 0 , 0,
17464 0x0 }, /* POOL32Axf_1_1~*(3) */
17465 };
17466
17467
17468 static const Pool POOL32Axf_1_3[4] = {
17469 { instruction , 0 , 0 , 32,
17470 0xfc003fff, 0x2000067f, &RDDSP , 0,
17471 DSP_ }, /* RDDSP */
17472 { instruction , 0 , 0 , 32,
17473 0xfc003fff, 0x2000167f, &WRDSP , 0,
17474 DSP_ }, /* WRDSP */
17475 { instruction , 0 , 0 , 32,
17476 0xfc003fff, 0x2000267f, &EXTP , 0,
17477 DSP_ }, /* EXTP */
17478 { instruction , 0 , 0 , 32,
17479 0xfc003fff, 0x2000367f, &EXTPDP , 0,
17480 DSP_ }, /* EXTPDP */
17481 };
17482
17483
17484 static const Pool POOL32Axf_1_4[2] = {
17485 { instruction , 0 , 0 , 32,
17486 0xfc001fff, 0x2000087f, &SHLL_QB , 0,
17487 DSP_ }, /* SHLL.QB */
17488 { instruction , 0 , 0 , 32,
17489 0xfc001fff, 0x2000187f, &SHRL_QB , 0,
17490 DSP_ }, /* SHRL.QB */
17491 };
17492
17493
17494 static const Pool MAQ_S_A__W_PHR[2] = {
17495 { instruction , 0 , 0 , 32,
17496 0xfc003fff, 0x20000a7f, &MAQ_S_W_PHR , 0,
17497 DSP_ }, /* MAQ_S.W.PHR */
17498 { instruction , 0 , 0 , 32,
17499 0xfc003fff, 0x20002a7f, &MAQ_SA_W_PHR , 0,
17500 DSP_ }, /* MAQ_SA.W.PHR */
17501 };
17502
17503
17504 static const Pool MAQ_S_A__W_PHL[2] = {
17505 { instruction , 0 , 0 , 32,
17506 0xfc003fff, 0x20001a7f, &MAQ_S_W_PHL , 0,
17507 DSP_ }, /* MAQ_S.W.PHL */
17508 { instruction , 0 , 0 , 32,
17509 0xfc003fff, 0x20003a7f, &MAQ_SA_W_PHL , 0,
17510 DSP_ }, /* MAQ_SA.W.PHL */
17511 };
17512
17513
17514 static const Pool POOL32Axf_1_5[2] = {
17515 { pool , MAQ_S_A__W_PHR , 2 , 32,
17516 0xfc001fff, 0x20000a7f, 0 , 0,
17517 0x0 }, /* MAQ_S[A].W.PHR */
17518 { pool , MAQ_S_A__W_PHL , 2 , 32,
17519 0xfc001fff, 0x20001a7f, 0 , 0,
17520 0x0 }, /* MAQ_S[A].W.PHL */
17521 };
17522
17523
17524 static const Pool POOL32Axf_1_7[4] = {
17525 { instruction , 0 , 0 , 32,
17526 0xfc003fff, 0x20000e7f, &EXTR_W , 0,
17527 DSP_ }, /* EXTR.W */
17528 { instruction , 0 , 0 , 32,
17529 0xfc003fff, 0x20001e7f, &EXTR_R_W , 0,
17530 DSP_ }, /* EXTR_R.W */
17531 { instruction , 0 , 0 , 32,
17532 0xfc003fff, 0x20002e7f, &EXTR_RS_W , 0,
17533 DSP_ }, /* EXTR_RS.W */
17534 { instruction , 0 , 0 , 32,
17535 0xfc003fff, 0x20003e7f, &EXTR_S_H , 0,
17536 DSP_ }, /* EXTR_S.H */
17537 };
17538
17539
17540 static const Pool POOL32Axf_1[8] = {
17541 { pool , POOL32Axf_1_0 , 4 , 32,
17542 0xfc000fff, 0x2000007f, 0 , 0,
17543 0x0 }, /* POOL32Axf_1_0 */
17544 { pool , POOL32Axf_1_1 , 4 , 32,
17545 0xfc000fff, 0x2000027f, 0 , 0,
17546 0x0 }, /* POOL32Axf_1_1 */
17547 { reserved_block , 0 , 0 , 32,
17548 0xfc000fff, 0x2000047f, 0 , 0,
17549 0x0 }, /* POOL32Axf_1~*(2) */
17550 { pool , POOL32Axf_1_3 , 4 , 32,
17551 0xfc000fff, 0x2000067f, 0 , 0,
17552 0x0 }, /* POOL32Axf_1_3 */
17553 { pool , POOL32Axf_1_4 , 2 , 32,
17554 0xfc000fff, 0x2000087f, 0 , 0,
17555 0x0 }, /* POOL32Axf_1_4 */
17556 { pool , POOL32Axf_1_5 , 2 , 32,
17557 0xfc000fff, 0x20000a7f, 0 , 0,
17558 0x0 }, /* POOL32Axf_1_5 */
17559 { reserved_block , 0 , 0 , 32,
17560 0xfc000fff, 0x20000c7f, 0 , 0,
17561 0x0 }, /* POOL32Axf_1~*(6) */
17562 { pool , POOL32Axf_1_7 , 4 , 32,
17563 0xfc000fff, 0x20000e7f, 0 , 0,
17564 0x0 }, /* POOL32Axf_1_7 */
17565 };
17566
17567
17568 static const Pool POOL32Axf_2_DSP__0_7[8] = {
17569 { instruction , 0 , 0 , 32,
17570 0xfc003fff, 0x200000bf, &DPA_W_PH , 0,
17571 DSP_ }, /* DPA.W.PH */
17572 { instruction , 0 , 0 , 32,
17573 0xfc003fff, 0x200002bf, &DPAQ_S_W_PH , 0,
17574 DSP_ }, /* DPAQ_S.W.PH */
17575 { instruction , 0 , 0 , 32,
17576 0xfc003fff, 0x200004bf, &DPS_W_PH , 0,
17577 DSP_ }, /* DPS.W.PH */
17578 { instruction , 0 , 0 , 32,
17579 0xfc003fff, 0x200006bf, &DPSQ_S_W_PH , 0,
17580 DSP_ }, /* DPSQ_S.W.PH */
17581 { reserved_block , 0 , 0 , 32,
17582 0xfc003fff, 0x200008bf, 0 , 0,
17583 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17584 { instruction , 0 , 0 , 32,
17585 0xfc003fff, 0x20000abf, &MADD_DSP_ , 0,
17586 DSP_ }, /* MADD[DSP] */
17587 { instruction , 0 , 0 , 32,
17588 0xfc003fff, 0x20000cbf, &MULT_DSP_ , 0,
17589 DSP_ }, /* MULT[DSP] */
17590 { instruction , 0 , 0 , 32,
17591 0xfc003fff, 0x20000ebf, &EXTRV_W , 0,
17592 DSP_ }, /* EXTRV.W */
17593 };
17594
17595
17596 static const Pool POOL32Axf_2_DSP__8_15[8] = {
17597 { instruction , 0 , 0 , 32,
17598 0xfc003fff, 0x200010bf, &DPAX_W_PH , 0,
17599 DSP_ }, /* DPAX.W.PH */
17600 { instruction , 0 , 0 , 32,
17601 0xfc003fff, 0x200012bf, &DPAQ_SA_L_W , 0,
17602 DSP_ }, /* DPAQ_SA.L.W */
17603 { instruction , 0 , 0 , 32,
17604 0xfc003fff, 0x200014bf, &DPSX_W_PH , 0,
17605 DSP_ }, /* DPSX.W.PH */
17606 { instruction , 0 , 0 , 32,
17607 0xfc003fff, 0x200016bf, &DPSQ_SA_L_W , 0,
17608 DSP_ }, /* DPSQ_SA.L.W */
17609 { reserved_block , 0 , 0 , 32,
17610 0xfc003fff, 0x200018bf, 0 , 0,
17611 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17612 { instruction , 0 , 0 , 32,
17613 0xfc003fff, 0x20001abf, &MADDU_DSP_ , 0,
17614 DSP_ }, /* MADDU[DSP] */
17615 { instruction , 0 , 0 , 32,
17616 0xfc003fff, 0x20001cbf, &MULTU_DSP_ , 0,
17617 DSP_ }, /* MULTU[DSP] */
17618 { instruction , 0 , 0 , 32,
17619 0xfc003fff, 0x20001ebf, &EXTRV_R_W , 0,
17620 DSP_ }, /* EXTRV_R.W */
17621 };
17622
17623
17624 static const Pool POOL32Axf_2_DSP__16_23[8] = {
17625 { instruction , 0 , 0 , 32,
17626 0xfc003fff, 0x200020bf, &DPAU_H_QBL , 0,
17627 DSP_ }, /* DPAU.H.QBL */
17628 { instruction , 0 , 0 , 32,
17629 0xfc003fff, 0x200022bf, &DPAQX_S_W_PH , 0,
17630 DSP_ }, /* DPAQX_S.W.PH */
17631 { instruction , 0 , 0 , 32,
17632 0xfc003fff, 0x200024bf, &DPSU_H_QBL , 0,
17633 DSP_ }, /* DPSU.H.QBL */
17634 { instruction , 0 , 0 , 32,
17635 0xfc003fff, 0x200026bf, &DPSQX_S_W_PH , 0,
17636 DSP_ }, /* DPSQX_S.W.PH */
17637 { instruction , 0 , 0 , 32,
17638 0xfc003fff, 0x200028bf, &EXTPV , 0,
17639 DSP_ }, /* EXTPV */
17640 { instruction , 0 , 0 , 32,
17641 0xfc003fff, 0x20002abf, &MSUB_DSP_ , 0,
17642 DSP_ }, /* MSUB[DSP] */
17643 { instruction , 0 , 0 , 32,
17644 0xfc003fff, 0x20002cbf, &MULSA_W_PH , 0,
17645 DSP_ }, /* MULSA.W.PH */
17646 { instruction , 0 , 0 , 32,
17647 0xfc003fff, 0x20002ebf, &EXTRV_RS_W , 0,
17648 DSP_ }, /* EXTRV_RS.W */
17649 };
17650
17651
17652 static const Pool POOL32Axf_2_DSP__24_31[8] = {
17653 { instruction , 0 , 0 , 32,
17654 0xfc003fff, 0x200030bf, &DPAU_H_QBR , 0,
17655 DSP_ }, /* DPAU.H.QBR */
17656 { instruction , 0 , 0 , 32,
17657 0xfc003fff, 0x200032bf, &DPAQX_SA_W_PH , 0,
17658 DSP_ }, /* DPAQX_SA.W.PH */
17659 { instruction , 0 , 0 , 32,
17660 0xfc003fff, 0x200034bf, &DPSU_H_QBR , 0,
17661 DSP_ }, /* DPSU.H.QBR */
17662 { instruction , 0 , 0 , 32,
17663 0xfc003fff, 0x200036bf, &DPSQX_SA_W_PH , 0,
17664 DSP_ }, /* DPSQX_SA.W.PH */
17665 { instruction , 0 , 0 , 32,
17666 0xfc003fff, 0x200038bf, &EXTPDPV , 0,
17667 DSP_ }, /* EXTPDPV */
17668 { instruction , 0 , 0 , 32,
17669 0xfc003fff, 0x20003abf, &MSUBU_DSP_ , 0,
17670 DSP_ }, /* MSUBU[DSP] */
17671 { instruction , 0 , 0 , 32,
17672 0xfc003fff, 0x20003cbf, &MULSAQ_S_W_PH , 0,
17673 DSP_ }, /* MULSAQ_S.W.PH */
17674 { instruction , 0 , 0 , 32,
17675 0xfc003fff, 0x20003ebf, &EXTRV_S_H , 0,
17676 DSP_ }, /* EXTRV_S.H */
17677 };
17678
17679
17680 static const Pool POOL32Axf_2[4] = {
17681 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
17682 0xfc0031ff, 0x200000bf, 0 , 0,
17683 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
17684 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
17685 0xfc0031ff, 0x200010bf, 0 , 0,
17686 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
17687 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
17688 0xfc0031ff, 0x200020bf, 0 , 0,
17689 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
17690 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
17691 0xfc0031ff, 0x200030bf, 0 , 0,
17692 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
17693 };
17694
17695
17696 static const Pool POOL32Axf_4[128] = {
17697 { instruction , 0 , 0 , 32,
17698 0xfc00ffff, 0x2000013f, &ABSQ_S_QB , 0,
17699 DSP_ }, /* ABSQ_S.QB */
17700 { instruction , 0 , 0 , 32,
17701 0xfc00ffff, 0x2000033f, &REPLV_PH , 0,
17702 DSP_ }, /* REPLV.PH */
17703 { reserved_block , 0 , 0 , 32,
17704 0xfc00ffff, 0x2000053f, 0 , 0,
17705 0x0 }, /* POOL32Axf_4~*(2) */
17706 { reserved_block , 0 , 0 , 32,
17707 0xfc00ffff, 0x2000073f, 0 , 0,
17708 0x0 }, /* POOL32Axf_4~*(3) */
17709 { reserved_block , 0 , 0 , 32,
17710 0xfc00ffff, 0x2000093f, 0 , 0,
17711 0x0 }, /* POOL32Axf_4~*(4) */
17712 { reserved_block , 0 , 0 , 32,
17713 0xfc00ffff, 0x20000b3f, 0 , 0,
17714 0x0 }, /* POOL32Axf_4~*(5) */
17715 { reserved_block , 0 , 0 , 32,
17716 0xfc00ffff, 0x20000d3f, 0 , 0,
17717 0x0 }, /* POOL32Axf_4~*(6) */
17718 { reserved_block , 0 , 0 , 32,
17719 0xfc00ffff, 0x20000f3f, 0 , 0,
17720 0x0 }, /* POOL32Axf_4~*(7) */
17721 { instruction , 0 , 0 , 32,
17722 0xfc00ffff, 0x2000113f, &ABSQ_S_PH , 0,
17723 DSP_ }, /* ABSQ_S.PH */
17724 { instruction , 0 , 0 , 32,
17725 0xfc00ffff, 0x2000133f, &REPLV_QB , 0,
17726 DSP_ }, /* REPLV.QB */
17727 { reserved_block , 0 , 0 , 32,
17728 0xfc00ffff, 0x2000153f, 0 , 0,
17729 0x0 }, /* POOL32Axf_4~*(10) */
17730 { reserved_block , 0 , 0 , 32,
17731 0xfc00ffff, 0x2000173f, 0 , 0,
17732 0x0 }, /* POOL32Axf_4~*(11) */
17733 { reserved_block , 0 , 0 , 32,
17734 0xfc00ffff, 0x2000193f, 0 , 0,
17735 0x0 }, /* POOL32Axf_4~*(12) */
17736 { reserved_block , 0 , 0 , 32,
17737 0xfc00ffff, 0x20001b3f, 0 , 0,
17738 0x0 }, /* POOL32Axf_4~*(13) */
17739 { reserved_block , 0 , 0 , 32,
17740 0xfc00ffff, 0x20001d3f, 0 , 0,
17741 0x0 }, /* POOL32Axf_4~*(14) */
17742 { reserved_block , 0 , 0 , 32,
17743 0xfc00ffff, 0x20001f3f, 0 , 0,
17744 0x0 }, /* POOL32Axf_4~*(15) */
17745 { instruction , 0 , 0 , 32,
17746 0xfc00ffff, 0x2000213f, &ABSQ_S_W , 0,
17747 DSP_ }, /* ABSQ_S.W */
17748 { reserved_block , 0 , 0 , 32,
17749 0xfc00ffff, 0x2000233f, 0 , 0,
17750 0x0 }, /* POOL32Axf_4~*(17) */
17751 { reserved_block , 0 , 0 , 32,
17752 0xfc00ffff, 0x2000253f, 0 , 0,
17753 0x0 }, /* POOL32Axf_4~*(18) */
17754 { reserved_block , 0 , 0 , 32,
17755 0xfc00ffff, 0x2000273f, 0 , 0,
17756 0x0 }, /* POOL32Axf_4~*(19) */
17757 { reserved_block , 0 , 0 , 32,
17758 0xfc00ffff, 0x2000293f, 0 , 0,
17759 0x0 }, /* POOL32Axf_4~*(20) */
17760 { reserved_block , 0 , 0 , 32,
17761 0xfc00ffff, 0x20002b3f, 0 , 0,
17762 0x0 }, /* POOL32Axf_4~*(21) */
17763 { reserved_block , 0 , 0 , 32,
17764 0xfc00ffff, 0x20002d3f, 0 , 0,
17765 0x0 }, /* POOL32Axf_4~*(22) */
17766 { reserved_block , 0 , 0 , 32,
17767 0xfc00ffff, 0x20002f3f, 0 , 0,
17768 0x0 }, /* POOL32Axf_4~*(23) */
17769 { reserved_block , 0 , 0 , 32,
17770 0xfc00ffff, 0x2000313f, 0 , 0,
17771 0x0 }, /* POOL32Axf_4~*(24) */
17772 { reserved_block , 0 , 0 , 32,
17773 0xfc00ffff, 0x2000333f, 0 , 0,
17774 0x0 }, /* POOL32Axf_4~*(25) */
17775 { reserved_block , 0 , 0 , 32,
17776 0xfc00ffff, 0x2000353f, 0 , 0,
17777 0x0 }, /* POOL32Axf_4~*(26) */
17778 { reserved_block , 0 , 0 , 32,
17779 0xfc00ffff, 0x2000373f, 0 , 0,
17780 0x0 }, /* POOL32Axf_4~*(27) */
17781 { reserved_block , 0 , 0 , 32,
17782 0xfc00ffff, 0x2000393f, 0 , 0,
17783 0x0 }, /* POOL32Axf_4~*(28) */
17784 { reserved_block , 0 , 0 , 32,
17785 0xfc00ffff, 0x20003b3f, 0 , 0,
17786 0x0 }, /* POOL32Axf_4~*(29) */
17787 { reserved_block , 0 , 0 , 32,
17788 0xfc00ffff, 0x20003d3f, 0 , 0,
17789 0x0 }, /* POOL32Axf_4~*(30) */
17790 { reserved_block , 0 , 0 , 32,
17791 0xfc00ffff, 0x20003f3f, 0 , 0,
17792 0x0 }, /* POOL32Axf_4~*(31) */
17793 { instruction , 0 , 0 , 32,
17794 0xfc00ffff, 0x2000413f, &INSV , 0,
17795 DSP_ }, /* INSV */
17796 { reserved_block , 0 , 0 , 32,
17797 0xfc00ffff, 0x2000433f, 0 , 0,
17798 0x0 }, /* POOL32Axf_4~*(33) */
17799 { reserved_block , 0 , 0 , 32,
17800 0xfc00ffff, 0x2000453f, 0 , 0,
17801 0x0 }, /* POOL32Axf_4~*(34) */
17802 { reserved_block , 0 , 0 , 32,
17803 0xfc00ffff, 0x2000473f, 0 , 0,
17804 0x0 }, /* POOL32Axf_4~*(35) */
17805 { reserved_block , 0 , 0 , 32,
17806 0xfc00ffff, 0x2000493f, 0 , 0,
17807 0x0 }, /* POOL32Axf_4~*(36) */
17808 { instruction , 0 , 0 , 32,
17809 0xfc00ffff, 0x20004b3f, &CLO , 0,
17810 XMMS_ }, /* CLO */
17811 { instruction , 0 , 0 , 32,
17812 0xfc00ffff, 0x20004d3f, &MFC2 , 0,
17813 CP2_ }, /* MFC2 */
17814 { reserved_block , 0 , 0 , 32,
17815 0xfc00ffff, 0x20004f3f, 0 , 0,
17816 0x0 }, /* POOL32Axf_4~*(39) */
17817 { instruction , 0 , 0 , 32,
17818 0xfc00ffff, 0x2000513f, &PRECEQ_W_PHL , 0,
17819 DSP_ }, /* PRECEQ.W.PHL */
17820 { reserved_block , 0 , 0 , 32,
17821 0xfc00ffff, 0x2000533f, 0 , 0,
17822 0x0 }, /* POOL32Axf_4~*(41) */
17823 { reserved_block , 0 , 0 , 32,
17824 0xfc00ffff, 0x2000553f, 0 , 0,
17825 0x0 }, /* POOL32Axf_4~*(42) */
17826 { reserved_block , 0 , 0 , 32,
17827 0xfc00ffff, 0x2000573f, 0 , 0,
17828 0x0 }, /* POOL32Axf_4~*(43) */
17829 { reserved_block , 0 , 0 , 32,
17830 0xfc00ffff, 0x2000593f, 0 , 0,
17831 0x0 }, /* POOL32Axf_4~*(44) */
17832 { instruction , 0 , 0 , 32,
17833 0xfc00ffff, 0x20005b3f, &CLZ , 0,
17834 XMMS_ }, /* CLZ */
17835 { instruction , 0 , 0 , 32,
17836 0xfc00ffff, 0x20005d3f, &MTC2 , 0,
17837 CP2_ }, /* MTC2 */
17838 { reserved_block , 0 , 0 , 32,
17839 0xfc00ffff, 0x20005f3f, 0 , 0,
17840 0x0 }, /* POOL32Axf_4~*(47) */
17841 { instruction , 0 , 0 , 32,
17842 0xfc00ffff, 0x2000613f, &PRECEQ_W_PHR , 0,
17843 DSP_ }, /* PRECEQ.W.PHR */
17844 { reserved_block , 0 , 0 , 32,
17845 0xfc00ffff, 0x2000633f, 0 , 0,
17846 0x0 }, /* POOL32Axf_4~*(49) */
17847 { reserved_block , 0 , 0 , 32,
17848 0xfc00ffff, 0x2000653f, 0 , 0,
17849 0x0 }, /* POOL32Axf_4~*(50) */
17850 { reserved_block , 0 , 0 , 32,
17851 0xfc00ffff, 0x2000673f, 0 , 0,
17852 0x0 }, /* POOL32Axf_4~*(51) */
17853 { reserved_block , 0 , 0 , 32,
17854 0xfc00ffff, 0x2000693f, 0 , 0,
17855 0x0 }, /* POOL32Axf_4~*(52) */
17856 { reserved_block , 0 , 0 , 32,
17857 0xfc00ffff, 0x20006b3f, 0 , 0,
17858 0x0 }, /* POOL32Axf_4~*(53) */
17859 { instruction , 0 , 0 , 32,
17860 0xfc00ffff, 0x20006d3f, &DMFC2 , 0,
17861 CP2_ }, /* DMFC2 */
17862 { reserved_block , 0 , 0 , 32,
17863 0xfc00ffff, 0x20006f3f, 0 , 0,
17864 0x0 }, /* POOL32Axf_4~*(55) */
17865 { instruction , 0 , 0 , 32,
17866 0xfc00ffff, 0x2000713f, &PRECEQU_PH_QBL , 0,
17867 DSP_ }, /* PRECEQU.PH.QBL */
17868 { instruction , 0 , 0 , 32,
17869 0xfc00ffff, 0x2000733f, &PRECEQU_PH_QBLA , 0,
17870 DSP_ }, /* PRECEQU.PH.QBLA */
17871 { reserved_block , 0 , 0 , 32,
17872 0xfc00ffff, 0x2000753f, 0 , 0,
17873 0x0 }, /* POOL32Axf_4~*(58) */
17874 { reserved_block , 0 , 0 , 32,
17875 0xfc00ffff, 0x2000773f, 0 , 0,
17876 0x0 }, /* POOL32Axf_4~*(59) */
17877 { reserved_block , 0 , 0 , 32,
17878 0xfc00ffff, 0x2000793f, 0 , 0,
17879 0x0 }, /* POOL32Axf_4~*(60) */
17880 { reserved_block , 0 , 0 , 32,
17881 0xfc00ffff, 0x20007b3f, 0 , 0,
17882 0x0 }, /* POOL32Axf_4~*(61) */
17883 { instruction , 0 , 0 , 32,
17884 0xfc00ffff, 0x20007d3f, &DMTC2 , 0,
17885 CP2_ }, /* DMTC2 */
17886 { reserved_block , 0 , 0 , 32,
17887 0xfc00ffff, 0x20007f3f, 0 , 0,
17888 0x0 }, /* POOL32Axf_4~*(63) */
17889 { reserved_block , 0 , 0 , 32,
17890 0xfc00ffff, 0x2000813f, 0 , 0,
17891 0x0 }, /* POOL32Axf_4~*(64) */
17892 { reserved_block , 0 , 0 , 32,
17893 0xfc00ffff, 0x2000833f, 0 , 0,
17894 0x0 }, /* POOL32Axf_4~*(65) */
17895 { reserved_block , 0 , 0 , 32,
17896 0xfc00ffff, 0x2000853f, 0 , 0,
17897 0x0 }, /* POOL32Axf_4~*(66) */
17898 { reserved_block , 0 , 0 , 32,
17899 0xfc00ffff, 0x2000873f, 0 , 0,
17900 0x0 }, /* POOL32Axf_4~*(67) */
17901 { reserved_block , 0 , 0 , 32,
17902 0xfc00ffff, 0x2000893f, 0 , 0,
17903 0x0 }, /* POOL32Axf_4~*(68) */
17904 { reserved_block , 0 , 0 , 32,
17905 0xfc00ffff, 0x20008b3f, 0 , 0,
17906 0x0 }, /* POOL32Axf_4~*(69) */
17907 { instruction , 0 , 0 , 32,
17908 0xfc00ffff, 0x20008d3f, &MFHC2 , 0,
17909 CP2_ }, /* MFHC2 */
17910 { reserved_block , 0 , 0 , 32,
17911 0xfc00ffff, 0x20008f3f, 0 , 0,
17912 0x0 }, /* POOL32Axf_4~*(71) */
17913 { instruction , 0 , 0 , 32,
17914 0xfc00ffff, 0x2000913f, &PRECEQU_PH_QBR , 0,
17915 DSP_ }, /* PRECEQU.PH.QBR */
17916 { instruction , 0 , 0 , 32,
17917 0xfc00ffff, 0x2000933f, &PRECEQU_PH_QBRA , 0,
17918 DSP_ }, /* PRECEQU.PH.QBRA */
17919 { reserved_block , 0 , 0 , 32,
17920 0xfc00ffff, 0x2000953f, 0 , 0,
17921 0x0 }, /* POOL32Axf_4~*(74) */
17922 { reserved_block , 0 , 0 , 32,
17923 0xfc00ffff, 0x2000973f, 0 , 0,
17924 0x0 }, /* POOL32Axf_4~*(75) */
17925 { reserved_block , 0 , 0 , 32,
17926 0xfc00ffff, 0x2000993f, 0 , 0,
17927 0x0 }, /* POOL32Axf_4~*(76) */
17928 { reserved_block , 0 , 0 , 32,
17929 0xfc00ffff, 0x20009b3f, 0 , 0,
17930 0x0 }, /* POOL32Axf_4~*(77) */
17931 { instruction , 0 , 0 , 32,
17932 0xfc00ffff, 0x20009d3f, &MTHC2 , 0,
17933 CP2_ }, /* MTHC2 */
17934 { reserved_block , 0 , 0 , 32,
17935 0xfc00ffff, 0x20009f3f, 0 , 0,
17936 0x0 }, /* POOL32Axf_4~*(79) */
17937 { reserved_block , 0 , 0 , 32,
17938 0xfc00ffff, 0x2000a13f, 0 , 0,
17939 0x0 }, /* POOL32Axf_4~*(80) */
17940 { reserved_block , 0 , 0 , 32,
17941 0xfc00ffff, 0x2000a33f, 0 , 0,
17942 0x0 }, /* POOL32Axf_4~*(81) */
17943 { reserved_block , 0 , 0 , 32,
17944 0xfc00ffff, 0x2000a53f, 0 , 0,
17945 0x0 }, /* POOL32Axf_4~*(82) */
17946 { reserved_block , 0 , 0 , 32,
17947 0xfc00ffff, 0x2000a73f, 0 , 0,
17948 0x0 }, /* POOL32Axf_4~*(83) */
17949 { reserved_block , 0 , 0 , 32,
17950 0xfc00ffff, 0x2000a93f, 0 , 0,
17951 0x0 }, /* POOL32Axf_4~*(84) */
17952 { reserved_block , 0 , 0 , 32,
17953 0xfc00ffff, 0x2000ab3f, 0 , 0,
17954 0x0 }, /* POOL32Axf_4~*(85) */
17955 { reserved_block , 0 , 0 , 32,
17956 0xfc00ffff, 0x2000ad3f, 0 , 0,
17957 0x0 }, /* POOL32Axf_4~*(86) */
17958 { reserved_block , 0 , 0 , 32,
17959 0xfc00ffff, 0x2000af3f, 0 , 0,
17960 0x0 }, /* POOL32Axf_4~*(87) */
17961 { instruction , 0 , 0 , 32,
17962 0xfc00ffff, 0x2000b13f, &PRECEU_PH_QBL , 0,
17963 DSP_ }, /* PRECEU.PH.QBL */
17964 { instruction , 0 , 0 , 32,
17965 0xfc00ffff, 0x2000b33f, &PRECEU_PH_QBLA , 0,
17966 DSP_ }, /* PRECEU.PH.QBLA */
17967 { reserved_block , 0 , 0 , 32,
17968 0xfc00ffff, 0x2000b53f, 0 , 0,
17969 0x0 }, /* POOL32Axf_4~*(90) */
17970 { reserved_block , 0 , 0 , 32,
17971 0xfc00ffff, 0x2000b73f, 0 , 0,
17972 0x0 }, /* POOL32Axf_4~*(91) */
17973 { reserved_block , 0 , 0 , 32,
17974 0xfc00ffff, 0x2000b93f, 0 , 0,
17975 0x0 }, /* POOL32Axf_4~*(92) */
17976 { reserved_block , 0 , 0 , 32,
17977 0xfc00ffff, 0x2000bb3f, 0 , 0,
17978 0x0 }, /* POOL32Axf_4~*(93) */
17979 { reserved_block , 0 , 0 , 32,
17980 0xfc00ffff, 0x2000bd3f, 0 , 0,
17981 0x0 }, /* POOL32Axf_4~*(94) */
17982 { reserved_block , 0 , 0 , 32,
17983 0xfc00ffff, 0x2000bf3f, 0 , 0,
17984 0x0 }, /* POOL32Axf_4~*(95) */
17985 { reserved_block , 0 , 0 , 32,
17986 0xfc00ffff, 0x2000c13f, 0 , 0,
17987 0x0 }, /* POOL32Axf_4~*(96) */
17988 { reserved_block , 0 , 0 , 32,
17989 0xfc00ffff, 0x2000c33f, 0 , 0,
17990 0x0 }, /* POOL32Axf_4~*(97) */
17991 { reserved_block , 0 , 0 , 32,
17992 0xfc00ffff, 0x2000c53f, 0 , 0,
17993 0x0 }, /* POOL32Axf_4~*(98) */
17994 { reserved_block , 0 , 0 , 32,
17995 0xfc00ffff, 0x2000c73f, 0 , 0,
17996 0x0 }, /* POOL32Axf_4~*(99) */
17997 { reserved_block , 0 , 0 , 32,
17998 0xfc00ffff, 0x2000c93f, 0 , 0,
17999 0x0 }, /* POOL32Axf_4~*(100) */
18000 { reserved_block , 0 , 0 , 32,
18001 0xfc00ffff, 0x2000cb3f, 0 , 0,
18002 0x0 }, /* POOL32Axf_4~*(101) */
18003 { instruction , 0 , 0 , 32,
18004 0xfc00ffff, 0x2000cd3f, &CFC2 , 0,
18005 CP2_ }, /* CFC2 */
18006 { reserved_block , 0 , 0 , 32,
18007 0xfc00ffff, 0x2000cf3f, 0 , 0,
18008 0x0 }, /* POOL32Axf_4~*(103) */
18009 { instruction , 0 , 0 , 32,
18010 0xfc00ffff, 0x2000d13f, &PRECEU_PH_QBR , 0,
18011 DSP_ }, /* PRECEU.PH.QBR */
18012 { instruction , 0 , 0 , 32,
18013 0xfc00ffff, 0x2000d33f, &PRECEU_PH_QBRA , 0,
18014 DSP_ }, /* PRECEU.PH.QBRA */
18015 { reserved_block , 0 , 0 , 32,
18016 0xfc00ffff, 0x2000d53f, 0 , 0,
18017 0x0 }, /* POOL32Axf_4~*(106) */
18018 { reserved_block , 0 , 0 , 32,
18019 0xfc00ffff, 0x2000d73f, 0 , 0,
18020 0x0 }, /* POOL32Axf_4~*(107) */
18021 { reserved_block , 0 , 0 , 32,
18022 0xfc00ffff, 0x2000d93f, 0 , 0,
18023 0x0 }, /* POOL32Axf_4~*(108) */
18024 { reserved_block , 0 , 0 , 32,
18025 0xfc00ffff, 0x2000db3f, 0 , 0,
18026 0x0 }, /* POOL32Axf_4~*(109) */
18027 { instruction , 0 , 0 , 32,
18028 0xfc00ffff, 0x2000dd3f, &CTC2 , 0,
18029 CP2_ }, /* CTC2 */
18030 { reserved_block , 0 , 0 , 32,
18031 0xfc00ffff, 0x2000df3f, 0 , 0,
18032 0x0 }, /* POOL32Axf_4~*(111) */
18033 { reserved_block , 0 , 0 , 32,
18034 0xfc00ffff, 0x2000e13f, 0 , 0,
18035 0x0 }, /* POOL32Axf_4~*(112) */
18036 { reserved_block , 0 , 0 , 32,
18037 0xfc00ffff, 0x2000e33f, 0 , 0,
18038 0x0 }, /* POOL32Axf_4~*(113) */
18039 { reserved_block , 0 , 0 , 32,
18040 0xfc00ffff, 0x2000e53f, 0 , 0,
18041 0x0 }, /* POOL32Axf_4~*(114) */
18042 { reserved_block , 0 , 0 , 32,
18043 0xfc00ffff, 0x2000e73f, 0 , 0,
18044 0x0 }, /* POOL32Axf_4~*(115) */
18045 { reserved_block , 0 , 0 , 32,
18046 0xfc00ffff, 0x2000e93f, 0 , 0,
18047 0x0 }, /* POOL32Axf_4~*(116) */
18048 { reserved_block , 0 , 0 , 32,
18049 0xfc00ffff, 0x2000eb3f, 0 , 0,
18050 0x0 }, /* POOL32Axf_4~*(117) */
18051 { reserved_block , 0 , 0 , 32,
18052 0xfc00ffff, 0x2000ed3f, 0 , 0,
18053 0x0 }, /* POOL32Axf_4~*(118) */
18054 { reserved_block , 0 , 0 , 32,
18055 0xfc00ffff, 0x2000ef3f, 0 , 0,
18056 0x0 }, /* POOL32Axf_4~*(119) */
18057 { instruction , 0 , 0 , 32,
18058 0xfc00ffff, 0x2000f13f, &RADDU_W_QB , 0,
18059 DSP_ }, /* RADDU.W.QB */
18060 { reserved_block , 0 , 0 , 32,
18061 0xfc00ffff, 0x2000f33f, 0 , 0,
18062 0x0 }, /* POOL32Axf_4~*(121) */
18063 { reserved_block , 0 , 0 , 32,
18064 0xfc00ffff, 0x2000f53f, 0 , 0,
18065 0x0 }, /* POOL32Axf_4~*(122) */
18066 { reserved_block , 0 , 0 , 32,
18067 0xfc00ffff, 0x2000f73f, 0 , 0,
18068 0x0 }, /* POOL32Axf_4~*(123) */
18069 { reserved_block , 0 , 0 , 32,
18070 0xfc00ffff, 0x2000f93f, 0 , 0,
18071 0x0 }, /* POOL32Axf_4~*(124) */
18072 { reserved_block , 0 , 0 , 32,
18073 0xfc00ffff, 0x2000fb3f, 0 , 0,
18074 0x0 }, /* POOL32Axf_4~*(125) */
18075 { reserved_block , 0 , 0 , 32,
18076 0xfc00ffff, 0x2000fd3f, 0 , 0,
18077 0x0 }, /* POOL32Axf_4~*(126) */
18078 { reserved_block , 0 , 0 , 32,
18079 0xfc00ffff, 0x2000ff3f, 0 , 0,
18080 0x0 }, /* POOL32Axf_4~*(127) */
18081 };
18082
18083
18084 static const Pool POOL32Axf_5_group0[32] = {
18085 { instruction , 0 , 0 , 32,
18086 0xfc00ffff, 0x2000017f, &TLBGP , 0,
18087 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18088 { instruction , 0 , 0 , 32,
18089 0xfc00ffff, 0x2000037f, &TLBP , 0,
18090 CP0_ | TLB_ }, /* TLBP */
18091 { instruction , 0 , 0 , 32,
18092 0xfc00ffff, 0x2000057f, &TLBGINV , 0,
18093 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18094 { instruction , 0 , 0 , 32,
18095 0xfc00ffff, 0x2000077f, &TLBINV , 0,
18096 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18097 { reserved_block , 0 , 0 , 32,
18098 0xfc00ffff, 0x2000097f, 0 , 0,
18099 0x0 }, /* POOL32Axf_5_group0~*(4) */
18100 { reserved_block , 0 , 0 , 32,
18101 0xfc00ffff, 0x20000b7f, 0 , 0,
18102 0x0 }, /* POOL32Axf_5_group0~*(5) */
18103 { reserved_block , 0 , 0 , 32,
18104 0xfc00ffff, 0x20000d7f, 0 , 0,
18105 0x0 }, /* POOL32Axf_5_group0~*(6) */
18106 { reserved_block , 0 , 0 , 32,
18107 0xfc00ffff, 0x20000f7f, 0 , 0,
18108 0x0 }, /* POOL32Axf_5_group0~*(7) */
18109 { instruction , 0 , 0 , 32,
18110 0xfc00ffff, 0x2000117f, &TLBGR , 0,
18111 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18112 { instruction , 0 , 0 , 32,
18113 0xfc00ffff, 0x2000137f, &TLBR , 0,
18114 CP0_ | TLB_ }, /* TLBR */
18115 { instruction , 0 , 0 , 32,
18116 0xfc00ffff, 0x2000157f, &TLBGINVF , 0,
18117 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18118 { instruction , 0 , 0 , 32,
18119 0xfc00ffff, 0x2000177f, &TLBINVF , 0,
18120 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18121 { reserved_block , 0 , 0 , 32,
18122 0xfc00ffff, 0x2000197f, 0 , 0,
18123 0x0 }, /* POOL32Axf_5_group0~*(12) */
18124 { reserved_block , 0 , 0 , 32,
18125 0xfc00ffff, 0x20001b7f, 0 , 0,
18126 0x0 }, /* POOL32Axf_5_group0~*(13) */
18127 { reserved_block , 0 , 0 , 32,
18128 0xfc00ffff, 0x20001d7f, 0 , 0,
18129 0x0 }, /* POOL32Axf_5_group0~*(14) */
18130 { reserved_block , 0 , 0 , 32,
18131 0xfc00ffff, 0x20001f7f, 0 , 0,
18132 0x0 }, /* POOL32Axf_5_group0~*(15) */
18133 { instruction , 0 , 0 , 32,
18134 0xfc00ffff, 0x2000217f, &TLBGWI , 0,
18135 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18136 { instruction , 0 , 0 , 32,
18137 0xfc00ffff, 0x2000237f, &TLBWI , 0,
18138 CP0_ | TLB_ }, /* TLBWI */
18139 { reserved_block , 0 , 0 , 32,
18140 0xfc00ffff, 0x2000257f, 0 , 0,
18141 0x0 }, /* POOL32Axf_5_group0~*(18) */
18142 { reserved_block , 0 , 0 , 32,
18143 0xfc00ffff, 0x2000277f, 0 , 0,
18144 0x0 }, /* POOL32Axf_5_group0~*(19) */
18145 { reserved_block , 0 , 0 , 32,
18146 0xfc00ffff, 0x2000297f, 0 , 0,
18147 0x0 }, /* POOL32Axf_5_group0~*(20) */
18148 { reserved_block , 0 , 0 , 32,
18149 0xfc00ffff, 0x20002b7f, 0 , 0,
18150 0x0 }, /* POOL32Axf_5_group0~*(21) */
18151 { reserved_block , 0 , 0 , 32,
18152 0xfc00ffff, 0x20002d7f, 0 , 0,
18153 0x0 }, /* POOL32Axf_5_group0~*(22) */
18154 { reserved_block , 0 , 0 , 32,
18155 0xfc00ffff, 0x20002f7f, 0 , 0,
18156 0x0 }, /* POOL32Axf_5_group0~*(23) */
18157 { instruction , 0 , 0 , 32,
18158 0xfc00ffff, 0x2000317f, &TLBGWR , 0,
18159 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18160 { instruction , 0 , 0 , 32,
18161 0xfc00ffff, 0x2000337f, &TLBWR , 0,
18162 CP0_ | TLB_ }, /* TLBWR */
18163 { reserved_block , 0 , 0 , 32,
18164 0xfc00ffff, 0x2000357f, 0 , 0,
18165 0x0 }, /* POOL32Axf_5_group0~*(26) */
18166 { reserved_block , 0 , 0 , 32,
18167 0xfc00ffff, 0x2000377f, 0 , 0,
18168 0x0 }, /* POOL32Axf_5_group0~*(27) */
18169 { reserved_block , 0 , 0 , 32,
18170 0xfc00ffff, 0x2000397f, 0 , 0,
18171 0x0 }, /* POOL32Axf_5_group0~*(28) */
18172 { reserved_block , 0 , 0 , 32,
18173 0xfc00ffff, 0x20003b7f, 0 , 0,
18174 0x0 }, /* POOL32Axf_5_group0~*(29) */
18175 { reserved_block , 0 , 0 , 32,
18176 0xfc00ffff, 0x20003d7f, 0 , 0,
18177 0x0 }, /* POOL32Axf_5_group0~*(30) */
18178 { reserved_block , 0 , 0 , 32,
18179 0xfc00ffff, 0x20003f7f, 0 , 0,
18180 0x0 }, /* POOL32Axf_5_group0~*(31) */
18181 };
18182
18183
18184 static const Pool POOL32Axf_5_group1[32] = {
18185 { reserved_block , 0 , 0 , 32,
18186 0xfc00ffff, 0x2000417f, 0 , 0,
18187 0x0 }, /* POOL32Axf_5_group1~*(0) */
18188 { reserved_block , 0 , 0 , 32,
18189 0xfc00ffff, 0x2000437f, 0 , 0,
18190 0x0 }, /* POOL32Axf_5_group1~*(1) */
18191 { reserved_block , 0 , 0 , 32,
18192 0xfc00ffff, 0x2000457f, 0 , 0,
18193 0x0 }, /* POOL32Axf_5_group1~*(2) */
18194 { instruction , 0 , 0 , 32,
18195 0xfc00ffff, 0x2000477f, &DI , 0,
18196 0x0 }, /* DI */
18197 { reserved_block , 0 , 0 , 32,
18198 0xfc00ffff, 0x2000497f, 0 , 0,
18199 0x0 }, /* POOL32Axf_5_group1~*(4) */
18200 { reserved_block , 0 , 0 , 32,
18201 0xfc00ffff, 0x20004b7f, 0 , 0,
18202 0x0 }, /* POOL32Axf_5_group1~*(5) */
18203 { reserved_block , 0 , 0 , 32,
18204 0xfc00ffff, 0x20004d7f, 0 , 0,
18205 0x0 }, /* POOL32Axf_5_group1~*(6) */
18206 { reserved_block , 0 , 0 , 32,
18207 0xfc00ffff, 0x20004f7f, 0 , 0,
18208 0x0 }, /* POOL32Axf_5_group1~*(7) */
18209 { reserved_block , 0 , 0 , 32,
18210 0xfc00ffff, 0x2000517f, 0 , 0,
18211 0x0 }, /* POOL32Axf_5_group1~*(8) */
18212 { reserved_block , 0 , 0 , 32,
18213 0xfc00ffff, 0x2000537f, 0 , 0,
18214 0x0 }, /* POOL32Axf_5_group1~*(9) */
18215 { reserved_block , 0 , 0 , 32,
18216 0xfc00ffff, 0x2000557f, 0 , 0,
18217 0x0 }, /* POOL32Axf_5_group1~*(10) */
18218 { instruction , 0 , 0 , 32,
18219 0xfc00ffff, 0x2000577f, &EI , 0,
18220 0x0 }, /* EI */
18221 { reserved_block , 0 , 0 , 32,
18222 0xfc00ffff, 0x2000597f, 0 , 0,
18223 0x0 }, /* POOL32Axf_5_group1~*(12) */
18224 { reserved_block , 0 , 0 , 32,
18225 0xfc00ffff, 0x20005b7f, 0 , 0,
18226 0x0 }, /* POOL32Axf_5_group1~*(13) */
18227 { reserved_block , 0 , 0 , 32,
18228 0xfc00ffff, 0x20005d7f, 0 , 0,
18229 0x0 }, /* POOL32Axf_5_group1~*(14) */
18230 { reserved_block , 0 , 0 , 32,
18231 0xfc00ffff, 0x20005f7f, 0 , 0,
18232 0x0 }, /* POOL32Axf_5_group1~*(15) */
18233 { reserved_block , 0 , 0 , 32,
18234 0xfc00ffff, 0x2000617f, 0 , 0,
18235 0x0 }, /* POOL32Axf_5_group1~*(16) */
18236 { reserved_block , 0 , 0 , 32,
18237 0xfc00ffff, 0x2000637f, 0 , 0,
18238 0x0 }, /* POOL32Axf_5_group1~*(17) */
18239 { reserved_block , 0 , 0 , 32,
18240 0xfc00ffff, 0x2000657f, 0 , 0,
18241 0x0 }, /* POOL32Axf_5_group1~*(18) */
18242 { reserved_block , 0 , 0 , 32,
18243 0xfc00ffff, 0x2000677f, 0 , 0,
18244 0x0 }, /* POOL32Axf_5_group1~*(19) */
18245 { reserved_block , 0 , 0 , 32,
18246 0xfc00ffff, 0x2000697f, 0 , 0,
18247 0x0 }, /* POOL32Axf_5_group1~*(20) */
18248 { reserved_block , 0 , 0 , 32,
18249 0xfc00ffff, 0x20006b7f, 0 , 0,
18250 0x0 }, /* POOL32Axf_5_group1~*(21) */
18251 { reserved_block , 0 , 0 , 32,
18252 0xfc00ffff, 0x20006d7f, 0 , 0,
18253 0x0 }, /* POOL32Axf_5_group1~*(22) */
18254 { reserved_block , 0 , 0 , 32,
18255 0xfc00ffff, 0x20006f7f, 0 , 0,
18256 0x0 }, /* POOL32Axf_5_group1~*(23) */
18257 { reserved_block , 0 , 0 , 32,
18258 0xfc00ffff, 0x2000717f, 0 , 0,
18259 0x0 }, /* POOL32Axf_5_group1~*(24) */
18260 { reserved_block , 0 , 0 , 32,
18261 0xfc00ffff, 0x2000737f, 0 , 0,
18262 0x0 }, /* POOL32Axf_5_group1~*(25) */
18263 { reserved_block , 0 , 0 , 32,
18264 0xfc00ffff, 0x2000757f, 0 , 0,
18265 0x0 }, /* POOL32Axf_5_group1~*(26) */
18266 { reserved_block , 0 , 0 , 32,
18267 0xfc00ffff, 0x2000777f, 0 , 0,
18268 0x0 }, /* POOL32Axf_5_group1~*(27) */
18269 { reserved_block , 0 , 0 , 32,
18270 0xfc00ffff, 0x2000797f, 0 , 0,
18271 0x0 }, /* POOL32Axf_5_group1~*(28) */
18272 { reserved_block , 0 , 0 , 32,
18273 0xfc00ffff, 0x20007b7f, 0 , 0,
18274 0x0 }, /* POOL32Axf_5_group1~*(29) */
18275 { reserved_block , 0 , 0 , 32,
18276 0xfc00ffff, 0x20007d7f, 0 , 0,
18277 0x0 }, /* POOL32Axf_5_group1~*(30) */
18278 { reserved_block , 0 , 0 , 32,
18279 0xfc00ffff, 0x20007f7f, 0 , 0,
18280 0x0 }, /* POOL32Axf_5_group1~*(31) */
18281 };
18282
18283
18284 static const Pool ERETx[2] = {
18285 { instruction , 0 , 0 , 32,
18286 0xfc01ffff, 0x2000f37f, &ERET , 0,
18287 0x0 }, /* ERET */
18288 { instruction , 0 , 0 , 32,
18289 0xfc01ffff, 0x2001f37f, &ERETNC , 0,
18290 0x0 }, /* ERETNC */
18291 };
18292
18293
18294 static const Pool POOL32Axf_5_group3[32] = {
18295 { reserved_block , 0 , 0 , 32,
18296 0xfc00ffff, 0x2000c17f, 0 , 0,
18297 0x0 }, /* POOL32Axf_5_group3~*(0) */
18298 { instruction , 0 , 0 , 32,
18299 0xfc00ffff, 0x2000c37f, &WAIT , 0,
18300 0x0 }, /* WAIT */
18301 { reserved_block , 0 , 0 , 32,
18302 0xfc00ffff, 0x2000c57f, 0 , 0,
18303 0x0 }, /* POOL32Axf_5_group3~*(2) */
18304 { reserved_block , 0 , 0 , 32,
18305 0xfc00ffff, 0x2000c77f, 0 , 0,
18306 0x0 }, /* POOL32Axf_5_group3~*(3) */
18307 { reserved_block , 0 , 0 , 32,
18308 0xfc00ffff, 0x2000c97f, 0 , 0,
18309 0x0 }, /* POOL32Axf_5_group3~*(4) */
18310 { reserved_block , 0 , 0 , 32,
18311 0xfc00ffff, 0x2000cb7f, 0 , 0,
18312 0x0 }, /* POOL32Axf_5_group3~*(5) */
18313 { reserved_block , 0 , 0 , 32,
18314 0xfc00ffff, 0x2000cd7f, 0 , 0,
18315 0x0 }, /* POOL32Axf_5_group3~*(6) */
18316 { reserved_block , 0 , 0 , 32,
18317 0xfc00ffff, 0x2000cf7f, 0 , 0,
18318 0x0 }, /* POOL32Axf_5_group3~*(7) */
18319 { reserved_block , 0 , 0 , 32,
18320 0xfc00ffff, 0x2000d17f, 0 , 0,
18321 0x0 }, /* POOL32Axf_5_group3~*(8) */
18322 { instruction , 0 , 0 , 32,
18323 0xfc00ffff, 0x2000d37f, &IRET , 0,
18324 MCU_ }, /* IRET */
18325 { reserved_block , 0 , 0 , 32,
18326 0xfc00ffff, 0x2000d57f, 0 , 0,
18327 0x0 }, /* POOL32Axf_5_group3~*(10) */
18328 { reserved_block , 0 , 0 , 32,
18329 0xfc00ffff, 0x2000d77f, 0 , 0,
18330 0x0 }, /* POOL32Axf_5_group3~*(11) */
18331 { reserved_block , 0 , 0 , 32,
18332 0xfc00ffff, 0x2000d97f, 0 , 0,
18333 0x0 }, /* POOL32Axf_5_group3~*(12) */
18334 { reserved_block , 0 , 0 , 32,
18335 0xfc00ffff, 0x2000db7f, 0 , 0,
18336 0x0 }, /* POOL32Axf_5_group3~*(13) */
18337 { reserved_block , 0 , 0 , 32,
18338 0xfc00ffff, 0x2000dd7f, 0 , 0,
18339 0x0 }, /* POOL32Axf_5_group3~*(14) */
18340 { reserved_block , 0 , 0 , 32,
18341 0xfc00ffff, 0x2000df7f, 0 , 0,
18342 0x0 }, /* POOL32Axf_5_group3~*(15) */
18343 { instruction , 0 , 0 , 32,
18344 0xfc00ffff, 0x2000e17f, &RDPGPR , 0,
18345 CP0_ }, /* RDPGPR */
18346 { instruction , 0 , 0 , 32,
18347 0xfc00ffff, 0x2000e37f, &DERET , 0,
18348 EJTAG_ }, /* DERET */
18349 { reserved_block , 0 , 0 , 32,
18350 0xfc00ffff, 0x2000e57f, 0 , 0,
18351 0x0 }, /* POOL32Axf_5_group3~*(18) */
18352 { reserved_block , 0 , 0 , 32,
18353 0xfc00ffff, 0x2000e77f, 0 , 0,
18354 0x0 }, /* POOL32Axf_5_group3~*(19) */
18355 { reserved_block , 0 , 0 , 32,
18356 0xfc00ffff, 0x2000e97f, 0 , 0,
18357 0x0 }, /* POOL32Axf_5_group3~*(20) */
18358 { reserved_block , 0 , 0 , 32,
18359 0xfc00ffff, 0x2000eb7f, 0 , 0,
18360 0x0 }, /* POOL32Axf_5_group3~*(21) */
18361 { reserved_block , 0 , 0 , 32,
18362 0xfc00ffff, 0x2000ed7f, 0 , 0,
18363 0x0 }, /* POOL32Axf_5_group3~*(22) */
18364 { reserved_block , 0 , 0 , 32,
18365 0xfc00ffff, 0x2000ef7f, 0 , 0,
18366 0x0 }, /* POOL32Axf_5_group3~*(23) */
18367 { instruction , 0 , 0 , 32,
18368 0xfc00ffff, 0x2000f17f, &WRPGPR , 0,
18369 CP0_ }, /* WRPGPR */
18370 { pool , ERETx , 2 , 32,
18371 0xfc00ffff, 0x2000f37f, 0 , 0,
18372 0x0 }, /* ERETx */
18373 { reserved_block , 0 , 0 , 32,
18374 0xfc00ffff, 0x2000f57f, 0 , 0,
18375 0x0 }, /* POOL32Axf_5_group3~*(26) */
18376 { reserved_block , 0 , 0 , 32,
18377 0xfc00ffff, 0x2000f77f, 0 , 0,
18378 0x0 }, /* POOL32Axf_5_group3~*(27) */
18379 { reserved_block , 0 , 0 , 32,
18380 0xfc00ffff, 0x2000f97f, 0 , 0,
18381 0x0 }, /* POOL32Axf_5_group3~*(28) */
18382 { reserved_block , 0 , 0 , 32,
18383 0xfc00ffff, 0x2000fb7f, 0 , 0,
18384 0x0 }, /* POOL32Axf_5_group3~*(29) */
18385 { reserved_block , 0 , 0 , 32,
18386 0xfc00ffff, 0x2000fd7f, 0 , 0,
18387 0x0 }, /* POOL32Axf_5_group3~*(30) */
18388 { reserved_block , 0 , 0 , 32,
18389 0xfc00ffff, 0x2000ff7f, 0 , 0,
18390 0x0 }, /* POOL32Axf_5_group3~*(31) */
18391 };
18392
18393
18394 static const Pool POOL32Axf_5[4] = {
18395 { pool , POOL32Axf_5_group0 , 32 , 32,
18396 0xfc00c1ff, 0x2000017f, 0 , 0,
18397 0x0 }, /* POOL32Axf_5_group0 */
18398 { pool , POOL32Axf_5_group1 , 32 , 32,
18399 0xfc00c1ff, 0x2000417f, 0 , 0,
18400 0x0 }, /* POOL32Axf_5_group1 */
18401 { reserved_block , 0 , 0 , 32,
18402 0xfc00c1ff, 0x2000817f, 0 , 0,
18403 0x0 }, /* POOL32Axf_5~*(2) */
18404 { pool , POOL32Axf_5_group3 , 32 , 32,
18405 0xfc00c1ff, 0x2000c17f, 0 , 0,
18406 0x0 }, /* POOL32Axf_5_group3 */
18407 };
18408
18409
18410 static const Pool SHRA__R__QB[2] = {
18411 { instruction , 0 , 0 , 32,
18412 0xfc001fff, 0x200001ff, &SHRA_QB , 0,
18413 DSP_ }, /* SHRA.QB */
18414 { instruction , 0 , 0 , 32,
18415 0xfc001fff, 0x200011ff, &SHRA_R_QB , 0,
18416 DSP_ }, /* SHRA_R.QB */
18417 };
18418
18419
18420 static const Pool POOL32Axf_7[8] = {
18421 { pool , SHRA__R__QB , 2 , 32,
18422 0xfc000fff, 0x200001ff, 0 , 0,
18423 0x0 }, /* SHRA[_R].QB */
18424 { instruction , 0 , 0 , 32,
18425 0xfc000fff, 0x200003ff, &SHRL_PH , 0,
18426 DSP_ }, /* SHRL.PH */
18427 { instruction , 0 , 0 , 32,
18428 0xfc000fff, 0x200005ff, &REPL_QB , 0,
18429 DSP_ }, /* REPL.QB */
18430 { reserved_block , 0 , 0 , 32,
18431 0xfc000fff, 0x200007ff, 0 , 0,
18432 0x0 }, /* POOL32Axf_7~*(3) */
18433 { reserved_block , 0 , 0 , 32,
18434 0xfc000fff, 0x200009ff, 0 , 0,
18435 0x0 }, /* POOL32Axf_7~*(4) */
18436 { reserved_block , 0 , 0 , 32,
18437 0xfc000fff, 0x20000bff, 0 , 0,
18438 0x0 }, /* POOL32Axf_7~*(5) */
18439 { reserved_block , 0 , 0 , 32,
18440 0xfc000fff, 0x20000dff, 0 , 0,
18441 0x0 }, /* POOL32Axf_7~*(6) */
18442 { reserved_block , 0 , 0 , 32,
18443 0xfc000fff, 0x20000fff, 0 , 0,
18444 0x0 }, /* POOL32Axf_7~*(7) */
18445 };
18446
18447
18448 static const Pool POOL32Axf[8] = {
18449 { reserved_block , 0 , 0 , 32,
18450 0xfc0001ff, 0x2000003f, 0 , 0,
18451 0x0 }, /* POOL32Axf~*(0) */
18452 { pool , POOL32Axf_1 , 8 , 32,
18453 0xfc0001ff, 0x2000007f, 0 , 0,
18454 0x0 }, /* POOL32Axf_1 */
18455 { pool , POOL32Axf_2 , 4 , 32,
18456 0xfc0001ff, 0x200000bf, 0 , 0,
18457 0x0 }, /* POOL32Axf_2 */
18458 { reserved_block , 0 , 0 , 32,
18459 0xfc0001ff, 0x200000ff, 0 , 0,
18460 0x0 }, /* POOL32Axf~*(3) */
18461 { pool , POOL32Axf_4 , 128 , 32,
18462 0xfc0001ff, 0x2000013f, 0 , 0,
18463 0x0 }, /* POOL32Axf_4 */
18464 { pool , POOL32Axf_5 , 4 , 32,
18465 0xfc0001ff, 0x2000017f, 0 , 0,
18466 0x0 }, /* POOL32Axf_5 */
18467 { reserved_block , 0 , 0 , 32,
18468 0xfc0001ff, 0x200001bf, 0 , 0,
18469 0x0 }, /* POOL32Axf~*(6) */
18470 { pool , POOL32Axf_7 , 8 , 32,
18471 0xfc0001ff, 0x200001ff, 0 , 0,
18472 0x0 }, /* POOL32Axf_7 */
18473 };
18474
18475
18476 static const Pool _POOL32A7[8] = {
18477 { pool , P_LSX , 2 , 32,
18478 0xfc00003f, 0x20000007, 0 , 0,
18479 0x0 }, /* P.LSX */
18480 { instruction , 0 , 0 , 32,
18481 0xfc00003f, 0x2000000f, &LSA , 0,
18482 0x0 }, /* LSA */
18483 { reserved_block , 0 , 0 , 32,
18484 0xfc00003f, 0x20000017, 0 , 0,
18485 0x0 }, /* _POOL32A7~*(2) */
18486 { instruction , 0 , 0 , 32,
18487 0xfc00003f, 0x2000001f, &EXTW , 0,
18488 0x0 }, /* EXTW */
18489 { reserved_block , 0 , 0 , 32,
18490 0xfc00003f, 0x20000027, 0 , 0,
18491 0x0 }, /* _POOL32A7~*(4) */
18492 { reserved_block , 0 , 0 , 32,
18493 0xfc00003f, 0x2000002f, 0 , 0,
18494 0x0 }, /* _POOL32A7~*(5) */
18495 { reserved_block , 0 , 0 , 32,
18496 0xfc00003f, 0x20000037, 0 , 0,
18497 0x0 }, /* _POOL32A7~*(6) */
18498 { pool , POOL32Axf , 8 , 32,
18499 0xfc00003f, 0x2000003f, 0 , 0,
18500 0x0 }, /* POOL32Axf */
18501 };
18502
18503
18504 static const Pool P32A[8] = {
18505 { pool , _POOL32A0 , 128 , 32,
18506 0xfc000007, 0x20000000, 0 , 0,
18507 0x0 }, /* _POOL32A0 */
18508 { instruction , 0 , 0 , 32,
18509 0xfc000007, 0x20000001, &SPECIAL2 , 0,
18510 UDI_ }, /* SPECIAL2 */
18511 { instruction , 0 , 0 , 32,
18512 0xfc000007, 0x20000002, &COP2_1 , 0,
18513 CP2_ }, /* COP2_1 */
18514 { instruction , 0 , 0 , 32,
18515 0xfc000007, 0x20000003, &UDI , 0,
18516 UDI_ }, /* UDI */
18517 { reserved_block , 0 , 0 , 32,
18518 0xfc000007, 0x20000004, 0 , 0,
18519 0x0 }, /* P32A~*(4) */
18520 { pool , _POOL32A5 , 128 , 32,
18521 0xfc000007, 0x20000005, 0 , 0,
18522 0x0 }, /* _POOL32A5 */
18523 { reserved_block , 0 , 0 , 32,
18524 0xfc000007, 0x20000006, 0 , 0,
18525 0x0 }, /* P32A~*(6) */
18526 { pool , _POOL32A7 , 8 , 32,
18527 0xfc000007, 0x20000007, 0 , 0,
18528 0x0 }, /* _POOL32A7 */
18529 };
18530
18531
18532 static const Pool P_GP_D[2] = {
18533 { instruction , 0 , 0 , 32,
18534 0xfc000007, 0x40000001, &LD_GP_ , 0,
18535 MIPS64_ }, /* LD[GP] */
18536 { instruction , 0 , 0 , 32,
18537 0xfc000007, 0x40000005, &SD_GP_ , 0,
18538 MIPS64_ }, /* SD[GP] */
18539 };
18540
18541
18542 static const Pool P_GP_W[4] = {
18543 { instruction , 0 , 0 , 32,
18544 0xfc000003, 0x40000000, &ADDIU_GP_W_ , 0,
18545 0x0 }, /* ADDIU[GP.W] */
18546 { pool , P_GP_D , 2 , 32,
18547 0xfc000003, 0x40000001, 0 , 0,
18548 0x0 }, /* P.GP.D */
18549 { instruction , 0 , 0 , 32,
18550 0xfc000003, 0x40000002, &LW_GP_ , 0,
18551 0x0 }, /* LW[GP] */
18552 { instruction , 0 , 0 , 32,
18553 0xfc000003, 0x40000003, &SW_GP_ , 0,
18554 0x0 }, /* SW[GP] */
18555 };
18556
18557
18558 static const Pool POOL48I[32] = {
18559 { instruction , 0 , 0 , 48,
18560 0xfc1f00000000ull, 0x600000000000ull, &LI_48_ , 0,
18561 XMMS_ }, /* LI[48] */
18562 { instruction , 0 , 0 , 48,
18563 0xfc1f00000000ull, 0x600100000000ull, &ADDIU_48_ , 0,
18564 XMMS_ }, /* ADDIU[48] */
18565 { instruction , 0 , 0 , 48,
18566 0xfc1f00000000ull, 0x600200000000ull, &ADDIU_GP48_ , 0,
18567 XMMS_ }, /* ADDIU[GP48] */
18568 { instruction , 0 , 0 , 48,
18569 0xfc1f00000000ull, 0x600300000000ull, &ADDIUPC_48_ , 0,
18570 XMMS_ }, /* ADDIUPC[48] */
18571 { reserved_block , 0 , 0 , 48,
18572 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18573 0x0 }, /* POOL48I~*(4) */
18574 { reserved_block , 0 , 0 , 48,
18575 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18576 0x0 }, /* POOL48I~*(5) */
18577 { reserved_block , 0 , 0 , 48,
18578 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18579 0x0 }, /* POOL48I~*(6) */
18580 { reserved_block , 0 , 0 , 48,
18581 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18582 0x0 }, /* POOL48I~*(7) */
18583 { reserved_block , 0 , 0 , 48,
18584 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18585 0x0 }, /* POOL48I~*(8) */
18586 { reserved_block , 0 , 0 , 48,
18587 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18588 0x0 }, /* POOL48I~*(9) */
18589 { reserved_block , 0 , 0 , 48,
18590 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18591 0x0 }, /* POOL48I~*(10) */
18592 { instruction , 0 , 0 , 48,
18593 0xfc1f00000000ull, 0x600b00000000ull, &LWPC_48_ , 0,
18594 XMMS_ }, /* LWPC[48] */
18595 { reserved_block , 0 , 0 , 48,
18596 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18597 0x0 }, /* POOL48I~*(12) */
18598 { reserved_block , 0 , 0 , 48,
18599 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18600 0x0 }, /* POOL48I~*(13) */
18601 { reserved_block , 0 , 0 , 48,
18602 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18603 0x0 }, /* POOL48I~*(14) */
18604 { instruction , 0 , 0 , 48,
18605 0xfc1f00000000ull, 0x600f00000000ull, &SWPC_48_ , 0,
18606 XMMS_ }, /* SWPC[48] */
18607 { reserved_block , 0 , 0 , 48,
18608 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18609 0x0 }, /* POOL48I~*(16) */
18610 { instruction , 0 , 0 , 48,
18611 0xfc1f00000000ull, 0x601100000000ull, &DADDIU_48_ , 0,
18612 MIPS64_ }, /* DADDIU[48] */
18613 { reserved_block , 0 , 0 , 48,
18614 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18615 0x0 }, /* POOL48I~*(18) */
18616 { reserved_block , 0 , 0 , 48,
18617 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18618 0x0 }, /* POOL48I~*(19) */
18619 { instruction , 0 , 0 , 48,
18620 0xfc1f00000000ull, 0x601400000000ull, &DLUI_48_ , 0,
18621 MIPS64_ }, /* DLUI[48] */
18622 { reserved_block , 0 , 0 , 48,
18623 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18624 0x0 }, /* POOL48I~*(21) */
18625 { reserved_block , 0 , 0 , 48,
18626 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18627 0x0 }, /* POOL48I~*(22) */
18628 { reserved_block , 0 , 0 , 48,
18629 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18630 0x0 }, /* POOL48I~*(23) */
18631 { reserved_block , 0 , 0 , 48,
18632 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18633 0x0 }, /* POOL48I~*(24) */
18634 { reserved_block , 0 , 0 , 48,
18635 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18636 0x0 }, /* POOL48I~*(25) */
18637 { reserved_block , 0 , 0 , 48,
18638 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18639 0x0 }, /* POOL48I~*(26) */
18640 { instruction , 0 , 0 , 48,
18641 0xfc1f00000000ull, 0x601b00000000ull, &LDPC_48_ , 0,
18642 MIPS64_ }, /* LDPC[48] */
18643 { reserved_block , 0 , 0 , 48,
18644 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18645 0x0 }, /* POOL48I~*(28) */
18646 { reserved_block , 0 , 0 , 48,
18647 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18648 0x0 }, /* POOL48I~*(29) */
18649 { reserved_block , 0 , 0 , 48,
18650 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18651 0x0 }, /* POOL48I~*(30) */
18652 { instruction , 0 , 0 , 48,
18653 0xfc1f00000000ull, 0x601f00000000ull, &SDPC_48_ , 0,
18654 MIPS64_ }, /* SDPC[48] */
18655 };
18656
18657
18658 static const Pool PP_SR[4] = {
18659 { instruction , 0 , 0 , 32,
18660 0xfc10f003, 0x80003000, &SAVE_32_ , 0,
18661 0x0 }, /* SAVE[32] */
18662 { reserved_block , 0 , 0 , 32,
18663 0xfc10f003, 0x80003001, 0 , 0,
18664 0x0 }, /* PP.SR~*(1) */
18665 { instruction , 0 , 0 , 32,
18666 0xfc10f003, 0x80003002, &RESTORE_32_ , 0,
18667 0x0 }, /* RESTORE[32] */
18668 { return_instruction , 0 , 0 , 32,
18669 0xfc10f003, 0x80003003, &RESTORE_JRC_32_ , 0,
18670 0x0 }, /* RESTORE.JRC[32] */
18671 };
18672
18673
18674 static const Pool P_SR_F[8] = {
18675 { instruction , 0 , 0 , 32,
18676 0xfc10f007, 0x80103000, &SAVEF , 0,
18677 CP1_ }, /* SAVEF */
18678 { instruction , 0 , 0 , 32,
18679 0xfc10f007, 0x80103001, &RESTOREF , 0,
18680 CP1_ }, /* RESTOREF */
18681 { reserved_block , 0 , 0 , 32,
18682 0xfc10f007, 0x80103002, 0 , 0,
18683 0x0 }, /* P.SR.F~*(2) */
18684 { reserved_block , 0 , 0 , 32,
18685 0xfc10f007, 0x80103003, 0 , 0,
18686 0x0 }, /* P.SR.F~*(3) */
18687 { reserved_block , 0 , 0 , 32,
18688 0xfc10f007, 0x80103004, 0 , 0,
18689 0x0 }, /* P.SR.F~*(4) */
18690 { reserved_block , 0 , 0 , 32,
18691 0xfc10f007, 0x80103005, 0 , 0,
18692 0x0 }, /* P.SR.F~*(5) */
18693 { reserved_block , 0 , 0 , 32,
18694 0xfc10f007, 0x80103006, 0 , 0,
18695 0x0 }, /* P.SR.F~*(6) */
18696 { reserved_block , 0 , 0 , 32,
18697 0xfc10f007, 0x80103007, 0 , 0,
18698 0x0 }, /* P.SR.F~*(7) */
18699 };
18700
18701
18702 static const Pool P_SR[2] = {
18703 { pool , PP_SR , 4 , 32,
18704 0xfc10f000, 0x80003000, 0 , 0,
18705 0x0 }, /* PP.SR */
18706 { pool , P_SR_F , 8 , 32,
18707 0xfc10f000, 0x80103000, 0 , 0,
18708 0x0 }, /* P.SR.F */
18709 };
18710
18711
18712 static const Pool P_SLL[5] = {
18713 { instruction , 0 , 0 , 32,
18714 0xffe0f1ff, 0x8000c000, &NOP_32_ , 0,
18715 0x0 }, /* NOP[32] */
18716 { instruction , 0 , 0 , 32,
18717 0xffe0f1ff, 0x8000c003, &EHB , 0,
18718 0x0 }, /* EHB */
18719 { instruction , 0 , 0 , 32,
18720 0xffe0f1ff, 0x8000c005, &PAUSE , 0,
18721 0x0 }, /* PAUSE */
18722 { instruction , 0 , 0 , 32,
18723 0xffe0f1ff, 0x8000c006, &SYNC , 0,
18724 0x0 }, /* SYNC */
18725 { instruction , 0 , 0 , 32,
18726 0xfc00f1e0, 0x8000c000, &SLL_32_ , 0,
18727 0x0 }, /* SLL[32] */
18728 };
18729
18730
18731 static const Pool P_SHIFT[16] = {
18732 { pool , P_SLL , 5 , 32,
18733 0xfc00f1e0, 0x8000c000, 0 , 0,
18734 0x0 }, /* P.SLL */
18735 { reserved_block , 0 , 0 , 32,
18736 0xfc00f1e0, 0x8000c020, 0 , 0,
18737 0x0 }, /* P.SHIFT~*(1) */
18738 { instruction , 0 , 0 , 32,
18739 0xfc00f1e0, 0x8000c040, &SRL_32_ , 0,
18740 0x0 }, /* SRL[32] */
18741 { reserved_block , 0 , 0 , 32,
18742 0xfc00f1e0, 0x8000c060, 0 , 0,
18743 0x0 }, /* P.SHIFT~*(3) */
18744 { instruction , 0 , 0 , 32,
18745 0xfc00f1e0, 0x8000c080, &SRA , 0,
18746 0x0 }, /* SRA */
18747 { reserved_block , 0 , 0 , 32,
18748 0xfc00f1e0, 0x8000c0a0, 0 , 0,
18749 0x0 }, /* P.SHIFT~*(5) */
18750 { instruction , 0 , 0 , 32,
18751 0xfc00f1e0, 0x8000c0c0, &ROTR , 0,
18752 0x0 }, /* ROTR */
18753 { reserved_block , 0 , 0 , 32,
18754 0xfc00f1e0, 0x8000c0e0, 0 , 0,
18755 0x0 }, /* P.SHIFT~*(7) */
18756 { instruction , 0 , 0 , 32,
18757 0xfc00f1e0, 0x8000c100, &DSLL , 0,
18758 MIPS64_ }, /* DSLL */
18759 { instruction , 0 , 0 , 32,
18760 0xfc00f1e0, 0x8000c120, &DSLL32 , 0,
18761 MIPS64_ }, /* DSLL32 */
18762 { instruction , 0 , 0 , 32,
18763 0xfc00f1e0, 0x8000c140, &DSRL , 0,
18764 MIPS64_ }, /* DSRL */
18765 { instruction , 0 , 0 , 32,
18766 0xfc00f1e0, 0x8000c160, &DSRL32 , 0,
18767 MIPS64_ }, /* DSRL32 */
18768 { instruction , 0 , 0 , 32,
18769 0xfc00f1e0, 0x8000c180, &DSRA , 0,
18770 MIPS64_ }, /* DSRA */
18771 { instruction , 0 , 0 , 32,
18772 0xfc00f1e0, 0x8000c1a0, &DSRA32 , 0,
18773 MIPS64_ }, /* DSRA32 */
18774 { instruction , 0 , 0 , 32,
18775 0xfc00f1e0, 0x8000c1c0, &DROTR , 0,
18776 MIPS64_ }, /* DROTR */
18777 { instruction , 0 , 0 , 32,
18778 0xfc00f1e0, 0x8000c1e0, &DROTR32 , 0,
18779 MIPS64_ }, /* DROTR32 */
18780 };
18781
18782
18783 static const Pool P_ROTX[4] = {
18784 { instruction , 0 , 0 , 32,
18785 0xfc00f820, 0x8000d000, &ROTX , 0,
18786 XMMS_ }, /* ROTX */
18787 { reserved_block , 0 , 0 , 32,
18788 0xfc00f820, 0x8000d020, 0 , 0,
18789 0x0 }, /* P.ROTX~*(1) */
18790 { reserved_block , 0 , 0 , 32,
18791 0xfc00f820, 0x8000d800, 0 , 0,
18792 0x0 }, /* P.ROTX~*(2) */
18793 { reserved_block , 0 , 0 , 32,
18794 0xfc00f820, 0x8000d820, 0 , 0,
18795 0x0 }, /* P.ROTX~*(3) */
18796 };
18797
18798
18799 static const Pool P_INS[4] = {
18800 { instruction , 0 , 0 , 32,
18801 0xfc00f820, 0x8000e000, &INS , 0,
18802 XMMS_ }, /* INS */
18803 { instruction , 0 , 0 , 32,
18804 0xfc00f820, 0x8000e020, &DINSU , 0,
18805 MIPS64_ }, /* DINSU */
18806 { instruction , 0 , 0 , 32,
18807 0xfc00f820, 0x8000e800, &DINSM , 0,
18808 MIPS64_ }, /* DINSM */
18809 { instruction , 0 , 0 , 32,
18810 0xfc00f820, 0x8000e820, &DINS , 0,
18811 MIPS64_ }, /* DINS */
18812 };
18813
18814
18815 static const Pool P_EXT[4] = {
18816 { instruction , 0 , 0 , 32,
18817 0xfc00f820, 0x8000f000, &EXT , 0,
18818 XMMS_ }, /* EXT */
18819 { instruction , 0 , 0 , 32,
18820 0xfc00f820, 0x8000f020, &DEXTU , 0,
18821 MIPS64_ }, /* DEXTU */
18822 { instruction , 0 , 0 , 32,
18823 0xfc00f820, 0x8000f800, &DEXTM , 0,
18824 MIPS64_ }, /* DEXTM */
18825 { instruction , 0 , 0 , 32,
18826 0xfc00f820, 0x8000f820, &DEXT , 0,
18827 MIPS64_ }, /* DEXT */
18828 };
18829
18830
18831 static const Pool P_U12[16] = {
18832 { instruction , 0 , 0 , 32,
18833 0xfc00f000, 0x80000000, &ORI , 0,
18834 0x0 }, /* ORI */
18835 { instruction , 0 , 0 , 32,
18836 0xfc00f000, 0x80001000, &XORI , 0,
18837 0x0 }, /* XORI */
18838 { instruction , 0 , 0 , 32,
18839 0xfc00f000, 0x80002000, &ANDI_32_ , 0,
18840 0x0 }, /* ANDI[32] */
18841 { pool , P_SR , 2 , 32,
18842 0xfc00f000, 0x80003000, 0 , 0,
18843 0x0 }, /* P.SR */
18844 { instruction , 0 , 0 , 32,
18845 0xfc00f000, 0x80004000, &SLTI , 0,
18846 0x0 }, /* SLTI */
18847 { instruction , 0 , 0 , 32,
18848 0xfc00f000, 0x80005000, &SLTIU , 0,
18849 0x0 }, /* SLTIU */
18850 { instruction , 0 , 0 , 32,
18851 0xfc00f000, 0x80006000, &SEQI , 0,
18852 0x0 }, /* SEQI */
18853 { reserved_block , 0 , 0 , 32,
18854 0xfc00f000, 0x80007000, 0 , 0,
18855 0x0 }, /* P.U12~*(7) */
18856 { instruction , 0 , 0 , 32,
18857 0xfc00f000, 0x80008000, &ADDIU_NEG_ , 0,
18858 0x0 }, /* ADDIU[NEG] */
18859 { instruction , 0 , 0 , 32,
18860 0xfc00f000, 0x80009000, &DADDIU_U12_ , 0,
18861 MIPS64_ }, /* DADDIU[U12] */
18862 { instruction , 0 , 0 , 32,
18863 0xfc00f000, 0x8000a000, &DADDIU_NEG_ , 0,
18864 MIPS64_ }, /* DADDIU[NEG] */
18865 { instruction , 0 , 0 , 32,
18866 0xfc00f000, 0x8000b000, &DROTX , 0,
18867 MIPS64_ }, /* DROTX */
18868 { pool , P_SHIFT , 16 , 32,
18869 0xfc00f000, 0x8000c000, 0 , 0,
18870 0x0 }, /* P.SHIFT */
18871 { pool , P_ROTX , 4 , 32,
18872 0xfc00f000, 0x8000d000, 0 , 0,
18873 0x0 }, /* P.ROTX */
18874 { pool , P_INS , 4 , 32,
18875 0xfc00f000, 0x8000e000, 0 , 0,
18876 0x0 }, /* P.INS */
18877 { pool , P_EXT , 4 , 32,
18878 0xfc00f000, 0x8000f000, 0 , 0,
18879 0x0 }, /* P.EXT */
18880 };
18881
18882
18883 static const Pool RINT_fmt[2] = {
18884 { instruction , 0 , 0 , 32,
18885 0xfc0003ff, 0xa0000020, &RINT_S , 0,
18886 CP1_ }, /* RINT.S */
18887 { instruction , 0 , 0 , 32,
18888 0xfc0003ff, 0xa0000220, &RINT_D , 0,
18889 CP1_ }, /* RINT.D */
18890 };
18891
18892
18893 static const Pool ADD_fmt0[2] = {
18894 { instruction , 0 , 0 , 32,
18895 0xfc0003ff, 0xa0000030, &ADD_S , 0,
18896 CP1_ }, /* ADD.S */
18897 { reserved_block , 0 , 0 , 32,
18898 0xfc0003ff, 0xa0000230, 0 , 0,
18899 CP1_ }, /* ADD.fmt0~*(1) */
18900 };
18901
18902
18903 static const Pool SELEQZ_fmt[2] = {
18904 { instruction , 0 , 0 , 32,
18905 0xfc0003ff, 0xa0000038, &SELEQZ_S , 0,
18906 CP1_ }, /* SELEQZ.S */
18907 { instruction , 0 , 0 , 32,
18908 0xfc0003ff, 0xa0000238, &SELEQZ_D , 0,
18909 CP1_ }, /* SELEQZ.D */
18910 };
18911
18912
18913 static const Pool CLASS_fmt[2] = {
18914 { instruction , 0 , 0 , 32,
18915 0xfc0003ff, 0xa0000060, &CLASS_S , 0,
18916 CP1_ }, /* CLASS.S */
18917 { instruction , 0 , 0 , 32,
18918 0xfc0003ff, 0xa0000260, &CLASS_D , 0,
18919 CP1_ }, /* CLASS.D */
18920 };
18921
18922
18923 static const Pool SUB_fmt0[2] = {
18924 { instruction , 0 , 0 , 32,
18925 0xfc0003ff, 0xa0000070, &SUB_S , 0,
18926 CP1_ }, /* SUB.S */
18927 { reserved_block , 0 , 0 , 32,
18928 0xfc0003ff, 0xa0000270, 0 , 0,
18929 CP1_ }, /* SUB.fmt0~*(1) */
18930 };
18931
18932
18933 static const Pool SELNEZ_fmt[2] = {
18934 { instruction , 0 , 0 , 32,
18935 0xfc0003ff, 0xa0000078, &SELNEZ_S , 0,
18936 CP1_ }, /* SELNEZ.S */
18937 { instruction , 0 , 0 , 32,
18938 0xfc0003ff, 0xa0000278, &SELNEZ_D , 0,
18939 CP1_ }, /* SELNEZ.D */
18940 };
18941
18942
18943 static const Pool MUL_fmt0[2] = {
18944 { instruction , 0 , 0 , 32,
18945 0xfc0003ff, 0xa00000b0, &MUL_S , 0,
18946 CP1_ }, /* MUL.S */
18947 { reserved_block , 0 , 0 , 32,
18948 0xfc0003ff, 0xa00002b0, 0 , 0,
18949 CP1_ }, /* MUL.fmt0~*(1) */
18950 };
18951
18952
18953 static const Pool SEL_fmt[2] = {
18954 { instruction , 0 , 0 , 32,
18955 0xfc0003ff, 0xa00000b8, &SEL_S , 0,
18956 CP1_ }, /* SEL.S */
18957 { instruction , 0 , 0 , 32,
18958 0xfc0003ff, 0xa00002b8, &SEL_D , 0,
18959 CP1_ }, /* SEL.D */
18960 };
18961
18962
18963 static const Pool DIV_fmt0[2] = {
18964 { instruction , 0 , 0 , 32,
18965 0xfc0003ff, 0xa00000f0, &DIV_S , 0,
18966 CP1_ }, /* DIV.S */
18967 { reserved_block , 0 , 0 , 32,
18968 0xfc0003ff, 0xa00002f0, 0 , 0,
18969 CP1_ }, /* DIV.fmt0~*(1) */
18970 };
18971
18972
18973 static const Pool ADD_fmt1[2] = {
18974 { instruction , 0 , 0 , 32,
18975 0xfc0003ff, 0xa0000130, &ADD_D , 0,
18976 CP1_ }, /* ADD.D */
18977 { reserved_block , 0 , 0 , 32,
18978 0xfc0003ff, 0xa0000330, 0 , 0,
18979 CP1_ }, /* ADD.fmt1~*(1) */
18980 };
18981
18982
18983 static const Pool SUB_fmt1[2] = {
18984 { instruction , 0 , 0 , 32,
18985 0xfc0003ff, 0xa0000170, &SUB_D , 0,
18986 CP1_ }, /* SUB.D */
18987 { reserved_block , 0 , 0 , 32,
18988 0xfc0003ff, 0xa0000370, 0 , 0,
18989 CP1_ }, /* SUB.fmt1~*(1) */
18990 };
18991
18992
18993 static const Pool MUL_fmt1[2] = {
18994 { instruction , 0 , 0 , 32,
18995 0xfc0003ff, 0xa00001b0, &MUL_D , 0,
18996 CP1_ }, /* MUL.D */
18997 { reserved_block , 0 , 0 , 32,
18998 0xfc0003ff, 0xa00003b0, 0 , 0,
18999 CP1_ }, /* MUL.fmt1~*(1) */
19000 };
19001
19002
19003 static const Pool MADDF_fmt[2] = {
19004 { instruction , 0 , 0 , 32,
19005 0xfc0003ff, 0xa00001b8, &MADDF_S , 0,
19006 CP1_ }, /* MADDF.S */
19007 { instruction , 0 , 0 , 32,
19008 0xfc0003ff, 0xa00003b8, &MADDF_D , 0,
19009 CP1_ }, /* MADDF.D */
19010 };
19011
19012
19013 static const Pool DIV_fmt1[2] = {
19014 { instruction , 0 , 0 , 32,
19015 0xfc0003ff, 0xa00001f0, &DIV_D , 0,
19016 CP1_ }, /* DIV.D */
19017 { reserved_block , 0 , 0 , 32,
19018 0xfc0003ff, 0xa00003f0, 0 , 0,
19019 CP1_ }, /* DIV.fmt1~*(1) */
19020 };
19021
19022
19023 static const Pool MSUBF_fmt[2] = {
19024 { instruction , 0 , 0 , 32,
19025 0xfc0003ff, 0xa00001f8, &MSUBF_S , 0,
19026 CP1_ }, /* MSUBF.S */
19027 { instruction , 0 , 0 , 32,
19028 0xfc0003ff, 0xa00003f8, &MSUBF_D , 0,
19029 CP1_ }, /* MSUBF.D */
19030 };
19031
19032
19033 static const Pool POOL32F_0[64] = {
19034 { reserved_block , 0 , 0 , 32,
19035 0xfc0001ff, 0xa0000000, 0 , 0,
19036 CP1_ }, /* POOL32F_0~*(0) */
19037 { reserved_block , 0 , 0 , 32,
19038 0xfc0001ff, 0xa0000008, 0 , 0,
19039 CP1_ }, /* POOL32F_0~*(1) */
19040 { reserved_block , 0 , 0 , 32,
19041 0xfc0001ff, 0xa0000010, 0 , 0,
19042 CP1_ }, /* POOL32F_0~*(2) */
19043 { reserved_block , 0 , 0 , 32,
19044 0xfc0001ff, 0xa0000018, 0 , 0,
19045 CP1_ }, /* POOL32F_0~*(3) */
19046 { pool , RINT_fmt , 2 , 32,
19047 0xfc0001ff, 0xa0000020, 0 , 0,
19048 CP1_ }, /* RINT.fmt */
19049 { reserved_block , 0 , 0 , 32,
19050 0xfc0001ff, 0xa0000028, 0 , 0,
19051 CP1_ }, /* POOL32F_0~*(5) */
19052 { pool , ADD_fmt0 , 2 , 32,
19053 0xfc0001ff, 0xa0000030, 0 , 0,
19054 CP1_ }, /* ADD.fmt0 */
19055 { pool , SELEQZ_fmt , 2 , 32,
19056 0xfc0001ff, 0xa0000038, 0 , 0,
19057 CP1_ }, /* SELEQZ.fmt */
19058 { reserved_block , 0 , 0 , 32,
19059 0xfc0001ff, 0xa0000040, 0 , 0,
19060 CP1_ }, /* POOL32F_0~*(8) */
19061 { reserved_block , 0 , 0 , 32,
19062 0xfc0001ff, 0xa0000048, 0 , 0,
19063 CP1_ }, /* POOL32F_0~*(9) */
19064 { reserved_block , 0 , 0 , 32,
19065 0xfc0001ff, 0xa0000050, 0 , 0,
19066 CP1_ }, /* POOL32F_0~*(10) */
19067 { reserved_block , 0 , 0 , 32,
19068 0xfc0001ff, 0xa0000058, 0 , 0,
19069 CP1_ }, /* POOL32F_0~*(11) */
19070 { pool , CLASS_fmt , 2 , 32,
19071 0xfc0001ff, 0xa0000060, 0 , 0,
19072 CP1_ }, /* CLASS.fmt */
19073 { reserved_block , 0 , 0 , 32,
19074 0xfc0001ff, 0xa0000068, 0 , 0,
19075 CP1_ }, /* POOL32F_0~*(13) */
19076 { pool , SUB_fmt0 , 2 , 32,
19077 0xfc0001ff, 0xa0000070, 0 , 0,
19078 CP1_ }, /* SUB.fmt0 */
19079 { pool , SELNEZ_fmt , 2 , 32,
19080 0xfc0001ff, 0xa0000078, 0 , 0,
19081 CP1_ }, /* SELNEZ.fmt */
19082 { reserved_block , 0 , 0 , 32,
19083 0xfc0001ff, 0xa0000080, 0 , 0,
19084 CP1_ }, /* POOL32F_0~*(16) */
19085 { reserved_block , 0 , 0 , 32,
19086 0xfc0001ff, 0xa0000088, 0 , 0,
19087 CP1_ }, /* POOL32F_0~*(17) */
19088 { reserved_block , 0 , 0 , 32,
19089 0xfc0001ff, 0xa0000090, 0 , 0,
19090 CP1_ }, /* POOL32F_0~*(18) */
19091 { reserved_block , 0 , 0 , 32,
19092 0xfc0001ff, 0xa0000098, 0 , 0,
19093 CP1_ }, /* POOL32F_0~*(19) */
19094 { reserved_block , 0 , 0 , 32,
19095 0xfc0001ff, 0xa00000a0, 0 , 0,
19096 CP1_ }, /* POOL32F_0~*(20) */
19097 { reserved_block , 0 , 0 , 32,
19098 0xfc0001ff, 0xa00000a8, 0 , 0,
19099 CP1_ }, /* POOL32F_0~*(21) */
19100 { pool , MUL_fmt0 , 2 , 32,
19101 0xfc0001ff, 0xa00000b0, 0 , 0,
19102 CP1_ }, /* MUL.fmt0 */
19103 { pool , SEL_fmt , 2 , 32,
19104 0xfc0001ff, 0xa00000b8, 0 , 0,
19105 CP1_ }, /* SEL.fmt */
19106 { reserved_block , 0 , 0 , 32,
19107 0xfc0001ff, 0xa00000c0, 0 , 0,
19108 CP1_ }, /* POOL32F_0~*(24) */
19109 { reserved_block , 0 , 0 , 32,
19110 0xfc0001ff, 0xa00000c8, 0 , 0,
19111 CP1_ }, /* POOL32F_0~*(25) */
19112 { reserved_block , 0 , 0 , 32,
19113 0xfc0001ff, 0xa00000d0, 0 , 0,
19114 CP1_ }, /* POOL32F_0~*(26) */
19115 { reserved_block , 0 , 0 , 32,
19116 0xfc0001ff, 0xa00000d8, 0 , 0,
19117 CP1_ }, /* POOL32F_0~*(27) */
19118 { reserved_block , 0 , 0 , 32,
19119 0xfc0001ff, 0xa00000e0, 0 , 0,
19120 CP1_ }, /* POOL32F_0~*(28) */
19121 { reserved_block , 0 , 0 , 32,
19122 0xfc0001ff, 0xa00000e8, 0 , 0,
19123 CP1_ }, /* POOL32F_0~*(29) */
19124 { pool , DIV_fmt0 , 2 , 32,
19125 0xfc0001ff, 0xa00000f0, 0 , 0,
19126 CP1_ }, /* DIV.fmt0 */
19127 { reserved_block , 0 , 0 , 32,
19128 0xfc0001ff, 0xa00000f8, 0 , 0,
19129 CP1_ }, /* POOL32F_0~*(31) */
19130 { reserved_block , 0 , 0 , 32,
19131 0xfc0001ff, 0xa0000100, 0 , 0,
19132 CP1_ }, /* POOL32F_0~*(32) */
19133 { reserved_block , 0 , 0 , 32,
19134 0xfc0001ff, 0xa0000108, 0 , 0,
19135 CP1_ }, /* POOL32F_0~*(33) */
19136 { reserved_block , 0 , 0 , 32,
19137 0xfc0001ff, 0xa0000110, 0 , 0,
19138 CP1_ }, /* POOL32F_0~*(34) */
19139 { reserved_block , 0 , 0 , 32,
19140 0xfc0001ff, 0xa0000118, 0 , 0,
19141 CP1_ }, /* POOL32F_0~*(35) */
19142 { reserved_block , 0 , 0 , 32,
19143 0xfc0001ff, 0xa0000120, 0 , 0,
19144 CP1_ }, /* POOL32F_0~*(36) */
19145 { reserved_block , 0 , 0 , 32,
19146 0xfc0001ff, 0xa0000128, 0 , 0,
19147 CP1_ }, /* POOL32F_0~*(37) */
19148 { pool , ADD_fmt1 , 2 , 32,
19149 0xfc0001ff, 0xa0000130, 0 , 0,
19150 CP1_ }, /* ADD.fmt1 */
19151 { reserved_block , 0 , 0 , 32,
19152 0xfc0001ff, 0xa0000138, 0 , 0,
19153 CP1_ }, /* POOL32F_0~*(39) */
19154 { reserved_block , 0 , 0 , 32,
19155 0xfc0001ff, 0xa0000140, 0 , 0,
19156 CP1_ }, /* POOL32F_0~*(40) */
19157 { reserved_block , 0 , 0 , 32,
19158 0xfc0001ff, 0xa0000148, 0 , 0,
19159 CP1_ }, /* POOL32F_0~*(41) */
19160 { reserved_block , 0 , 0 , 32,
19161 0xfc0001ff, 0xa0000150, 0 , 0,
19162 CP1_ }, /* POOL32F_0~*(42) */
19163 { reserved_block , 0 , 0 , 32,
19164 0xfc0001ff, 0xa0000158, 0 , 0,
19165 CP1_ }, /* POOL32F_0~*(43) */
19166 { reserved_block , 0 , 0 , 32,
19167 0xfc0001ff, 0xa0000160, 0 , 0,
19168 CP1_ }, /* POOL32F_0~*(44) */
19169 { reserved_block , 0 , 0 , 32,
19170 0xfc0001ff, 0xa0000168, 0 , 0,
19171 CP1_ }, /* POOL32F_0~*(45) */
19172 { pool , SUB_fmt1 , 2 , 32,
19173 0xfc0001ff, 0xa0000170, 0 , 0,
19174 CP1_ }, /* SUB.fmt1 */
19175 { reserved_block , 0 , 0 , 32,
19176 0xfc0001ff, 0xa0000178, 0 , 0,
19177 CP1_ }, /* POOL32F_0~*(47) */
19178 { reserved_block , 0 , 0 , 32,
19179 0xfc0001ff, 0xa0000180, 0 , 0,
19180 CP1_ }, /* POOL32F_0~*(48) */
19181 { reserved_block , 0 , 0 , 32,
19182 0xfc0001ff, 0xa0000188, 0 , 0,
19183 CP1_ }, /* POOL32F_0~*(49) */
19184 { reserved_block , 0 , 0 , 32,
19185 0xfc0001ff, 0xa0000190, 0 , 0,
19186 CP1_ }, /* POOL32F_0~*(50) */
19187 { reserved_block , 0 , 0 , 32,
19188 0xfc0001ff, 0xa0000198, 0 , 0,
19189 CP1_ }, /* POOL32F_0~*(51) */
19190 { reserved_block , 0 , 0 , 32,
19191 0xfc0001ff, 0xa00001a0, 0 , 0,
19192 CP1_ }, /* POOL32F_0~*(52) */
19193 { reserved_block , 0 , 0 , 32,
19194 0xfc0001ff, 0xa00001a8, 0 , 0,
19195 CP1_ }, /* POOL32F_0~*(53) */
19196 { pool , MUL_fmt1 , 2 , 32,
19197 0xfc0001ff, 0xa00001b0, 0 , 0,
19198 CP1_ }, /* MUL.fmt1 */
19199 { pool , MADDF_fmt , 2 , 32,
19200 0xfc0001ff, 0xa00001b8, 0 , 0,
19201 CP1_ }, /* MADDF.fmt */
19202 { reserved_block , 0 , 0 , 32,
19203 0xfc0001ff, 0xa00001c0, 0 , 0,
19204 CP1_ }, /* POOL32F_0~*(56) */
19205 { reserved_block , 0 , 0 , 32,
19206 0xfc0001ff, 0xa00001c8, 0 , 0,
19207 CP1_ }, /* POOL32F_0~*(57) */
19208 { reserved_block , 0 , 0 , 32,
19209 0xfc0001ff, 0xa00001d0, 0 , 0,
19210 CP1_ }, /* POOL32F_0~*(58) */
19211 { reserved_block , 0 , 0 , 32,
19212 0xfc0001ff, 0xa00001d8, 0 , 0,
19213 CP1_ }, /* POOL32F_0~*(59) */
19214 { reserved_block , 0 , 0 , 32,
19215 0xfc0001ff, 0xa00001e0, 0 , 0,
19216 CP1_ }, /* POOL32F_0~*(60) */
19217 { reserved_block , 0 , 0 , 32,
19218 0xfc0001ff, 0xa00001e8, 0 , 0,
19219 CP1_ }, /* POOL32F_0~*(61) */
19220 { pool , DIV_fmt1 , 2 , 32,
19221 0xfc0001ff, 0xa00001f0, 0 , 0,
19222 CP1_ }, /* DIV.fmt1 */
19223 { pool , MSUBF_fmt , 2 , 32,
19224 0xfc0001ff, 0xa00001f8, 0 , 0,
19225 CP1_ }, /* MSUBF.fmt */
19226 };
19227
19228
19229 static const Pool MIN_fmt[2] = {
19230 { instruction , 0 , 0 , 32,
19231 0xfc00023f, 0xa0000003, &MIN_S , 0,
19232 CP1_ }, /* MIN.S */
19233 { instruction , 0 , 0 , 32,
19234 0xfc00023f, 0xa0000203, &MIN_D , 0,
19235 CP1_ }, /* MIN.D */
19236 };
19237
19238
19239 static const Pool MAX_fmt[2] = {
19240 { instruction , 0 , 0 , 32,
19241 0xfc00023f, 0xa000000b, &MAX_S , 0,
19242 CP1_ }, /* MAX.S */
19243 { instruction , 0 , 0 , 32,
19244 0xfc00023f, 0xa000020b, &MAX_D , 0,
19245 CP1_ }, /* MAX.D */
19246 };
19247
19248
19249 static const Pool MINA_fmt[2] = {
19250 { instruction , 0 , 0 , 32,
19251 0xfc00023f, 0xa0000023, &MINA_S , 0,
19252 CP1_ }, /* MINA.S */
19253 { instruction , 0 , 0 , 32,
19254 0xfc00023f, 0xa0000223, &MINA_D , 0,
19255 CP1_ }, /* MINA.D */
19256 };
19257
19258
19259 static const Pool MAXA_fmt[2] = {
19260 { instruction , 0 , 0 , 32,
19261 0xfc00023f, 0xa000002b, &MAXA_S , 0,
19262 CP1_ }, /* MAXA.S */
19263 { instruction , 0 , 0 , 32,
19264 0xfc00023f, 0xa000022b, &MAXA_D , 0,
19265 CP1_ }, /* MAXA.D */
19266 };
19267
19268
19269 static const Pool CVT_L_fmt[2] = {
19270 { instruction , 0 , 0 , 32,
19271 0xfc007fff, 0xa000013b, &CVT_L_S , 0,
19272 CP1_ }, /* CVT.L.S */
19273 { instruction , 0 , 0 , 32,
19274 0xfc007fff, 0xa000413b, &CVT_L_D , 0,
19275 CP1_ }, /* CVT.L.D */
19276 };
19277
19278
19279 static const Pool RSQRT_fmt[2] = {
19280 { instruction , 0 , 0 , 32,
19281 0xfc007fff, 0xa000023b, &RSQRT_S , 0,
19282 CP1_ }, /* RSQRT.S */
19283 { instruction , 0 , 0 , 32,
19284 0xfc007fff, 0xa000423b, &RSQRT_D , 0,
19285 CP1_ }, /* RSQRT.D */
19286 };
19287
19288
19289 static const Pool FLOOR_L_fmt[2] = {
19290 { instruction , 0 , 0 , 32,
19291 0xfc007fff, 0xa000033b, &FLOOR_L_S , 0,
19292 CP1_ }, /* FLOOR.L.S */
19293 { instruction , 0 , 0 , 32,
19294 0xfc007fff, 0xa000433b, &FLOOR_L_D , 0,
19295 CP1_ }, /* FLOOR.L.D */
19296 };
19297
19298
19299 static const Pool CVT_W_fmt[2] = {
19300 { instruction , 0 , 0 , 32,
19301 0xfc007fff, 0xa000093b, &CVT_W_S , 0,
19302 CP1_ }, /* CVT.W.S */
19303 { instruction , 0 , 0 , 32,
19304 0xfc007fff, 0xa000493b, &CVT_W_D , 0,
19305 CP1_ }, /* CVT.W.D */
19306 };
19307
19308
19309 static const Pool SQRT_fmt[2] = {
19310 { instruction , 0 , 0 , 32,
19311 0xfc007fff, 0xa0000a3b, &SQRT_S , 0,
19312 CP1_ }, /* SQRT.S */
19313 { instruction , 0 , 0 , 32,
19314 0xfc007fff, 0xa0004a3b, &SQRT_D , 0,
19315 CP1_ }, /* SQRT.D */
19316 };
19317
19318
19319 static const Pool FLOOR_W_fmt[2] = {
19320 { instruction , 0 , 0 , 32,
19321 0xfc007fff, 0xa0000b3b, &FLOOR_W_S , 0,
19322 CP1_ }, /* FLOOR.W.S */
19323 { instruction , 0 , 0 , 32,
19324 0xfc007fff, 0xa0004b3b, &FLOOR_W_D , 0,
19325 CP1_ }, /* FLOOR.W.D */
19326 };
19327
19328
19329 static const Pool RECIP_fmt[2] = {
19330 { instruction , 0 , 0 , 32,
19331 0xfc007fff, 0xa000123b, &RECIP_S , 0,
19332 CP1_ }, /* RECIP.S */
19333 { instruction , 0 , 0 , 32,
19334 0xfc007fff, 0xa000523b, &RECIP_D , 0,
19335 CP1_ }, /* RECIP.D */
19336 };
19337
19338
19339 static const Pool CEIL_L_fmt[2] = {
19340 { instruction , 0 , 0 , 32,
19341 0xfc007fff, 0xa000133b, &CEIL_L_S , 0,
19342 CP1_ }, /* CEIL.L.S */
19343 { instruction , 0 , 0 , 32,
19344 0xfc007fff, 0xa000533b, &CEIL_L_D , 0,
19345 CP1_ }, /* CEIL.L.D */
19346 };
19347
19348
19349 static const Pool CEIL_W_fmt[2] = {
19350 { instruction , 0 , 0 , 32,
19351 0xfc007fff, 0xa0001b3b, &CEIL_W_S , 0,
19352 CP1_ }, /* CEIL.W.S */
19353 { instruction , 0 , 0 , 32,
19354 0xfc007fff, 0xa0005b3b, &CEIL_W_D , 0,
19355 CP1_ }, /* CEIL.W.D */
19356 };
19357
19358
19359 static const Pool TRUNC_L_fmt[2] = {
19360 { instruction , 0 , 0 , 32,
19361 0xfc007fff, 0xa000233b, &TRUNC_L_S , 0,
19362 CP1_ }, /* TRUNC.L.S */
19363 { instruction , 0 , 0 , 32,
19364 0xfc007fff, 0xa000633b, &TRUNC_L_D , 0,
19365 CP1_ }, /* TRUNC.L.D */
19366 };
19367
19368
19369 static const Pool TRUNC_W_fmt[2] = {
19370 { instruction , 0 , 0 , 32,
19371 0xfc007fff, 0xa0002b3b, &TRUNC_W_S , 0,
19372 CP1_ }, /* TRUNC.W.S */
19373 { instruction , 0 , 0 , 32,
19374 0xfc007fff, 0xa0006b3b, &TRUNC_W_D , 0,
19375 CP1_ }, /* TRUNC.W.D */
19376 };
19377
19378
19379 static const Pool ROUND_L_fmt[2] = {
19380 { instruction , 0 , 0 , 32,
19381 0xfc007fff, 0xa000333b, &ROUND_L_S , 0,
19382 CP1_ }, /* ROUND.L.S */
19383 { instruction , 0 , 0 , 32,
19384 0xfc007fff, 0xa000733b, &ROUND_L_D , 0,
19385 CP1_ }, /* ROUND.L.D */
19386 };
19387
19388
19389 static const Pool ROUND_W_fmt[2] = {
19390 { instruction , 0 , 0 , 32,
19391 0xfc007fff, 0xa0003b3b, &ROUND_W_S , 0,
19392 CP1_ }, /* ROUND.W.S */
19393 { instruction , 0 , 0 , 32,
19394 0xfc007fff, 0xa0007b3b, &ROUND_W_D , 0,
19395 CP1_ }, /* ROUND.W.D */
19396 };
19397
19398
19399 static const Pool POOL32Fxf_0[64] = {
19400 { reserved_block , 0 , 0 , 32,
19401 0xfc003fff, 0xa000003b, 0 , 0,
19402 CP1_ }, /* POOL32Fxf_0~*(0) */
19403 { pool , CVT_L_fmt , 2 , 32,
19404 0xfc003fff, 0xa000013b, 0 , 0,
19405 CP1_ }, /* CVT.L.fmt */
19406 { pool , RSQRT_fmt , 2 , 32,
19407 0xfc003fff, 0xa000023b, 0 , 0,
19408 CP1_ }, /* RSQRT.fmt */
19409 { pool , FLOOR_L_fmt , 2 , 32,
19410 0xfc003fff, 0xa000033b, 0 , 0,
19411 CP1_ }, /* FLOOR.L.fmt */
19412 { reserved_block , 0 , 0 , 32,
19413 0xfc003fff, 0xa000043b, 0 , 0,
19414 CP1_ }, /* POOL32Fxf_0~*(4) */
19415 { reserved_block , 0 , 0 , 32,
19416 0xfc003fff, 0xa000053b, 0 , 0,
19417 CP1_ }, /* POOL32Fxf_0~*(5) */
19418 { reserved_block , 0 , 0 , 32,
19419 0xfc003fff, 0xa000063b, 0 , 0,
19420 CP1_ }, /* POOL32Fxf_0~*(6) */
19421 { reserved_block , 0 , 0 , 32,
19422 0xfc003fff, 0xa000073b, 0 , 0,
19423 CP1_ }, /* POOL32Fxf_0~*(7) */
19424 { reserved_block , 0 , 0 , 32,
19425 0xfc003fff, 0xa000083b, 0 , 0,
19426 CP1_ }, /* POOL32Fxf_0~*(8) */
19427 { pool , CVT_W_fmt , 2 , 32,
19428 0xfc003fff, 0xa000093b, 0 , 0,
19429 CP1_ }, /* CVT.W.fmt */
19430 { pool , SQRT_fmt , 2 , 32,
19431 0xfc003fff, 0xa0000a3b, 0 , 0,
19432 CP1_ }, /* SQRT.fmt */
19433 { pool , FLOOR_W_fmt , 2 , 32,
19434 0xfc003fff, 0xa0000b3b, 0 , 0,
19435 CP1_ }, /* FLOOR.W.fmt */
19436 { reserved_block , 0 , 0 , 32,
19437 0xfc003fff, 0xa0000c3b, 0 , 0,
19438 CP1_ }, /* POOL32Fxf_0~*(12) */
19439 { reserved_block , 0 , 0 , 32,
19440 0xfc003fff, 0xa0000d3b, 0 , 0,
19441 CP1_ }, /* POOL32Fxf_0~*(13) */
19442 { reserved_block , 0 , 0 , 32,
19443 0xfc003fff, 0xa0000e3b, 0 , 0,
19444 CP1_ }, /* POOL32Fxf_0~*(14) */
19445 { reserved_block , 0 , 0 , 32,
19446 0xfc003fff, 0xa0000f3b, 0 , 0,
19447 CP1_ }, /* POOL32Fxf_0~*(15) */
19448 { instruction , 0 , 0 , 32,
19449 0xfc003fff, 0xa000103b, &CFC1 , 0,
19450 CP1_ }, /* CFC1 */
19451 { reserved_block , 0 , 0 , 32,
19452 0xfc003fff, 0xa000113b, 0 , 0,
19453 CP1_ }, /* POOL32Fxf_0~*(17) */
19454 { pool , RECIP_fmt , 2 , 32,
19455 0xfc003fff, 0xa000123b, 0 , 0,
19456 CP1_ }, /* RECIP.fmt */
19457 { pool , CEIL_L_fmt , 2 , 32,
19458 0xfc003fff, 0xa000133b, 0 , 0,
19459 CP1_ }, /* CEIL.L.fmt */
19460 { reserved_block , 0 , 0 , 32,
19461 0xfc003fff, 0xa000143b, 0 , 0,
19462 CP1_ }, /* POOL32Fxf_0~*(20) */
19463 { reserved_block , 0 , 0 , 32,
19464 0xfc003fff, 0xa000153b, 0 , 0,
19465 CP1_ }, /* POOL32Fxf_0~*(21) */
19466 { reserved_block , 0 , 0 , 32,
19467 0xfc003fff, 0xa000163b, 0 , 0,
19468 CP1_ }, /* POOL32Fxf_0~*(22) */
19469 { reserved_block , 0 , 0 , 32,
19470 0xfc003fff, 0xa000173b, 0 , 0,
19471 CP1_ }, /* POOL32Fxf_0~*(23) */
19472 { instruction , 0 , 0 , 32,
19473 0xfc003fff, 0xa000183b, &CTC1 , 0,
19474 CP1_ }, /* CTC1 */
19475 { reserved_block , 0 , 0 , 32,
19476 0xfc003fff, 0xa000193b, 0 , 0,
19477 CP1_ }, /* POOL32Fxf_0~*(25) */
19478 { reserved_block , 0 , 0 , 32,
19479 0xfc003fff, 0xa0001a3b, 0 , 0,
19480 CP1_ }, /* POOL32Fxf_0~*(26) */
19481 { pool , CEIL_W_fmt , 2 , 32,
19482 0xfc003fff, 0xa0001b3b, 0 , 0,
19483 CP1_ }, /* CEIL.W.fmt */
19484 { reserved_block , 0 , 0 , 32,
19485 0xfc003fff, 0xa0001c3b, 0 , 0,
19486 CP1_ }, /* POOL32Fxf_0~*(28) */
19487 { reserved_block , 0 , 0 , 32,
19488 0xfc003fff, 0xa0001d3b, 0 , 0,
19489 CP1_ }, /* POOL32Fxf_0~*(29) */
19490 { reserved_block , 0 , 0 , 32,
19491 0xfc003fff, 0xa0001e3b, 0 , 0,
19492 CP1_ }, /* POOL32Fxf_0~*(30) */
19493 { reserved_block , 0 , 0 , 32,
19494 0xfc003fff, 0xa0001f3b, 0 , 0,
19495 CP1_ }, /* POOL32Fxf_0~*(31) */
19496 { instruction , 0 , 0 , 32,
19497 0xfc003fff, 0xa000203b, &MFC1 , 0,
19498 CP1_ }, /* MFC1 */
19499 { instruction , 0 , 0 , 32,
19500 0xfc003fff, 0xa000213b, &CVT_S_PL , 0,
19501 CP1_ }, /* CVT.S.PL */
19502 { reserved_block , 0 , 0 , 32,
19503 0xfc003fff, 0xa000223b, 0 , 0,
19504 CP1_ }, /* POOL32Fxf_0~*(34) */
19505 { pool , TRUNC_L_fmt , 2 , 32,
19506 0xfc003fff, 0xa000233b, 0 , 0,
19507 CP1_ }, /* TRUNC.L.fmt */
19508 { instruction , 0 , 0 , 32,
19509 0xfc003fff, 0xa000243b, &DMFC1 , 0,
19510 CP1_ | MIPS64_ }, /* DMFC1 */
19511 { reserved_block , 0 , 0 , 32,
19512 0xfc003fff, 0xa000253b, 0 , 0,
19513 CP1_ }, /* POOL32Fxf_0~*(37) */
19514 { reserved_block , 0 , 0 , 32,
19515 0xfc003fff, 0xa000263b, 0 , 0,
19516 CP1_ }, /* POOL32Fxf_0~*(38) */
19517 { reserved_block , 0 , 0 , 32,
19518 0xfc003fff, 0xa000273b, 0 , 0,
19519 CP1_ }, /* POOL32Fxf_0~*(39) */
19520 { instruction , 0 , 0 , 32,
19521 0xfc003fff, 0xa000283b, &MTC1 , 0,
19522 CP1_ }, /* MTC1 */
19523 { instruction , 0 , 0 , 32,
19524 0xfc003fff, 0xa000293b, &CVT_S_PU , 0,
19525 CP1_ }, /* CVT.S.PU */
19526 { reserved_block , 0 , 0 , 32,
19527 0xfc003fff, 0xa0002a3b, 0 , 0,
19528 CP1_ }, /* POOL32Fxf_0~*(42) */
19529 { pool , TRUNC_W_fmt , 2 , 32,
19530 0xfc003fff, 0xa0002b3b, 0 , 0,
19531 CP1_ }, /* TRUNC.W.fmt */
19532 { instruction , 0 , 0 , 32,
19533 0xfc003fff, 0xa0002c3b, &DMTC1 , 0,
19534 CP1_ | MIPS64_ }, /* DMTC1 */
19535 { reserved_block , 0 , 0 , 32,
19536 0xfc003fff, 0xa0002d3b, 0 , 0,
19537 CP1_ }, /* POOL32Fxf_0~*(45) */
19538 { reserved_block , 0 , 0 , 32,
19539 0xfc003fff, 0xa0002e3b, 0 , 0,
19540 CP1_ }, /* POOL32Fxf_0~*(46) */
19541 { reserved_block , 0 , 0 , 32,
19542 0xfc003fff, 0xa0002f3b, 0 , 0,
19543 CP1_ }, /* POOL32Fxf_0~*(47) */
19544 { instruction , 0 , 0 , 32,
19545 0xfc003fff, 0xa000303b, &MFHC1 , 0,
19546 CP1_ }, /* MFHC1 */
19547 { reserved_block , 0 , 0 , 32,
19548 0xfc003fff, 0xa000313b, 0 , 0,
19549 CP1_ }, /* POOL32Fxf_0~*(49) */
19550 { reserved_block , 0 , 0 , 32,
19551 0xfc003fff, 0xa000323b, 0 , 0,
19552 CP1_ }, /* POOL32Fxf_0~*(50) */
19553 { pool , ROUND_L_fmt , 2 , 32,
19554 0xfc003fff, 0xa000333b, 0 , 0,
19555 CP1_ }, /* ROUND.L.fmt */
19556 { reserved_block , 0 , 0 , 32,
19557 0xfc003fff, 0xa000343b, 0 , 0,
19558 CP1_ }, /* POOL32Fxf_0~*(52) */
19559 { reserved_block , 0 , 0 , 32,
19560 0xfc003fff, 0xa000353b, 0 , 0,
19561 CP1_ }, /* POOL32Fxf_0~*(53) */
19562 { reserved_block , 0 , 0 , 32,
19563 0xfc003fff, 0xa000363b, 0 , 0,
19564 CP1_ }, /* POOL32Fxf_0~*(54) */
19565 { reserved_block , 0 , 0 , 32,
19566 0xfc003fff, 0xa000373b, 0 , 0,
19567 CP1_ }, /* POOL32Fxf_0~*(55) */
19568 { instruction , 0 , 0 , 32,
19569 0xfc003fff, 0xa000383b, &MTHC1 , 0,
19570 CP1_ }, /* MTHC1 */
19571 { reserved_block , 0 , 0 , 32,
19572 0xfc003fff, 0xa000393b, 0 , 0,
19573 CP1_ }, /* POOL32Fxf_0~*(57) */
19574 { reserved_block , 0 , 0 , 32,
19575 0xfc003fff, 0xa0003a3b, 0 , 0,
19576 CP1_ }, /* POOL32Fxf_0~*(58) */
19577 { pool , ROUND_W_fmt , 2 , 32,
19578 0xfc003fff, 0xa0003b3b, 0 , 0,
19579 CP1_ }, /* ROUND.W.fmt */
19580 { reserved_block , 0 , 0 , 32,
19581 0xfc003fff, 0xa0003c3b, 0 , 0,
19582 CP1_ }, /* POOL32Fxf_0~*(60) */
19583 { reserved_block , 0 , 0 , 32,
19584 0xfc003fff, 0xa0003d3b, 0 , 0,
19585 CP1_ }, /* POOL32Fxf_0~*(61) */
19586 { reserved_block , 0 , 0 , 32,
19587 0xfc003fff, 0xa0003e3b, 0 , 0,
19588 CP1_ }, /* POOL32Fxf_0~*(62) */
19589 { reserved_block , 0 , 0 , 32,
19590 0xfc003fff, 0xa0003f3b, 0 , 0,
19591 CP1_ }, /* POOL32Fxf_0~*(63) */
19592 };
19593
19594
19595 static const Pool MOV_fmt[4] = {
19596 { instruction , 0 , 0 , 32,
19597 0xfc007fff, 0xa000007b, &MOV_S , 0,
19598 CP1_ }, /* MOV.S */
19599 { instruction , 0 , 0 , 32,
19600 0xfc007fff, 0xa000207b, &MOV_D , 0,
19601 CP1_ }, /* MOV.D */
19602 { reserved_block , 0 , 0 , 32,
19603 0xfc007fff, 0xa000407b, 0 , 0,
19604 CP1_ }, /* MOV.fmt~*(2) */
19605 { reserved_block , 0 , 0 , 32,
19606 0xfc007fff, 0xa000607b, 0 , 0,
19607 CP1_ }, /* MOV.fmt~*(3) */
19608 };
19609
19610
19611 static const Pool ABS_fmt[4] = {
19612 { instruction , 0 , 0 , 32,
19613 0xfc007fff, 0xa000037b, &ABS_S , 0,
19614 CP1_ }, /* ABS.S */
19615 { instruction , 0 , 0 , 32,
19616 0xfc007fff, 0xa000237b, &ABS_D , 0,
19617 CP1_ }, /* ABS.D */
19618 { reserved_block , 0 , 0 , 32,
19619 0xfc007fff, 0xa000437b, 0 , 0,
19620 CP1_ }, /* ABS.fmt~*(2) */
19621 { reserved_block , 0 , 0 , 32,
19622 0xfc007fff, 0xa000637b, 0 , 0,
19623 CP1_ }, /* ABS.fmt~*(3) */
19624 };
19625
19626
19627 static const Pool NEG_fmt[4] = {
19628 { instruction , 0 , 0 , 32,
19629 0xfc007fff, 0xa0000b7b, &NEG_S , 0,
19630 CP1_ }, /* NEG.S */
19631 { instruction , 0 , 0 , 32,
19632 0xfc007fff, 0xa0002b7b, &NEG_D , 0,
19633 CP1_ }, /* NEG.D */
19634 { reserved_block , 0 , 0 , 32,
19635 0xfc007fff, 0xa0004b7b, 0 , 0,
19636 CP1_ }, /* NEG.fmt~*(2) */
19637 { reserved_block , 0 , 0 , 32,
19638 0xfc007fff, 0xa0006b7b, 0 , 0,
19639 CP1_ }, /* NEG.fmt~*(3) */
19640 };
19641
19642
19643 static const Pool CVT_D_fmt[4] = {
19644 { instruction , 0 , 0 , 32,
19645 0xfc007fff, 0xa000137b, &CVT_D_S , 0,
19646 CP1_ }, /* CVT.D.S */
19647 { instruction , 0 , 0 , 32,
19648 0xfc007fff, 0xa000337b, &CVT_D_W , 0,
19649 CP1_ }, /* CVT.D.W */
19650 { instruction , 0 , 0 , 32,
19651 0xfc007fff, 0xa000537b, &CVT_D_L , 0,
19652 CP1_ }, /* CVT.D.L */
19653 { reserved_block , 0 , 0 , 32,
19654 0xfc007fff, 0xa000737b, 0 , 0,
19655 CP1_ }, /* CVT.D.fmt~*(3) */
19656 };
19657
19658
19659 static const Pool CVT_S_fmt[4] = {
19660 { instruction , 0 , 0 , 32,
19661 0xfc007fff, 0xa0001b7b, &CVT_S_D , 0,
19662 CP1_ }, /* CVT.S.D */
19663 { instruction , 0 , 0 , 32,
19664 0xfc007fff, 0xa0003b7b, &CVT_S_W , 0,
19665 CP1_ }, /* CVT.S.W */
19666 { instruction , 0 , 0 , 32,
19667 0xfc007fff, 0xa0005b7b, &CVT_S_L , 0,
19668 CP1_ }, /* CVT.S.L */
19669 { reserved_block , 0 , 0 , 32,
19670 0xfc007fff, 0xa0007b7b, 0 , 0,
19671 CP1_ }, /* CVT.S.fmt~*(3) */
19672 };
19673
19674
19675 static const Pool POOL32Fxf_1[32] = {
19676 { pool , MOV_fmt , 4 , 32,
19677 0xfc001fff, 0xa000007b, 0 , 0,
19678 CP1_ }, /* MOV.fmt */
19679 { reserved_block , 0 , 0 , 32,
19680 0xfc001fff, 0xa000017b, 0 , 0,
19681 CP1_ }, /* POOL32Fxf_1~*(1) */
19682 { reserved_block , 0 , 0 , 32,
19683 0xfc001fff, 0xa000027b, 0 , 0,
19684 CP1_ }, /* POOL32Fxf_1~*(2) */
19685 { pool , ABS_fmt , 4 , 32,
19686 0xfc001fff, 0xa000037b, 0 , 0,
19687 CP1_ }, /* ABS.fmt */
19688 { reserved_block , 0 , 0 , 32,
19689 0xfc001fff, 0xa000047b, 0 , 0,
19690 CP1_ }, /* POOL32Fxf_1~*(4) */
19691 { reserved_block , 0 , 0 , 32,
19692 0xfc001fff, 0xa000057b, 0 , 0,
19693 CP1_ }, /* POOL32Fxf_1~*(5) */
19694 { reserved_block , 0 , 0 , 32,
19695 0xfc001fff, 0xa000067b, 0 , 0,
19696 CP1_ }, /* POOL32Fxf_1~*(6) */
19697 { reserved_block , 0 , 0 , 32,
19698 0xfc001fff, 0xa000077b, 0 , 0,
19699 CP1_ }, /* POOL32Fxf_1~*(7) */
19700 { reserved_block , 0 , 0 , 32,
19701 0xfc001fff, 0xa000087b, 0 , 0,
19702 CP1_ }, /* POOL32Fxf_1~*(8) */
19703 { reserved_block , 0 , 0 , 32,
19704 0xfc001fff, 0xa000097b, 0 , 0,
19705 CP1_ }, /* POOL32Fxf_1~*(9) */
19706 { reserved_block , 0 , 0 , 32,
19707 0xfc001fff, 0xa0000a7b, 0 , 0,
19708 CP1_ }, /* POOL32Fxf_1~*(10) */
19709 { pool , NEG_fmt , 4 , 32,
19710 0xfc001fff, 0xa0000b7b, 0 , 0,
19711 CP1_ }, /* NEG.fmt */
19712 { reserved_block , 0 , 0 , 32,
19713 0xfc001fff, 0xa0000c7b, 0 , 0,
19714 CP1_ }, /* POOL32Fxf_1~*(12) */
19715 { reserved_block , 0 , 0 , 32,
19716 0xfc001fff, 0xa0000d7b, 0 , 0,
19717 CP1_ }, /* POOL32Fxf_1~*(13) */
19718 { reserved_block , 0 , 0 , 32,
19719 0xfc001fff, 0xa0000e7b, 0 , 0,
19720 CP1_ }, /* POOL32Fxf_1~*(14) */
19721 { reserved_block , 0 , 0 , 32,
19722 0xfc001fff, 0xa0000f7b, 0 , 0,
19723 CP1_ }, /* POOL32Fxf_1~*(15) */
19724 { reserved_block , 0 , 0 , 32,
19725 0xfc001fff, 0xa000107b, 0 , 0,
19726 CP1_ }, /* POOL32Fxf_1~*(16) */
19727 { reserved_block , 0 , 0 , 32,
19728 0xfc001fff, 0xa000117b, 0 , 0,
19729 CP1_ }, /* POOL32Fxf_1~*(17) */
19730 { reserved_block , 0 , 0 , 32,
19731 0xfc001fff, 0xa000127b, 0 , 0,
19732 CP1_ }, /* POOL32Fxf_1~*(18) */
19733 { pool , CVT_D_fmt , 4 , 32,
19734 0xfc001fff, 0xa000137b, 0 , 0,
19735 CP1_ }, /* CVT.D.fmt */
19736 { reserved_block , 0 , 0 , 32,
19737 0xfc001fff, 0xa000147b, 0 , 0,
19738 CP1_ }, /* POOL32Fxf_1~*(20) */
19739 { reserved_block , 0 , 0 , 32,
19740 0xfc001fff, 0xa000157b, 0 , 0,
19741 CP1_ }, /* POOL32Fxf_1~*(21) */
19742 { reserved_block , 0 , 0 , 32,
19743 0xfc001fff, 0xa000167b, 0 , 0,
19744 CP1_ }, /* POOL32Fxf_1~*(22) */
19745 { reserved_block , 0 , 0 , 32,
19746 0xfc001fff, 0xa000177b, 0 , 0,
19747 CP1_ }, /* POOL32Fxf_1~*(23) */
19748 { reserved_block , 0 , 0 , 32,
19749 0xfc001fff, 0xa000187b, 0 , 0,
19750 CP1_ }, /* POOL32Fxf_1~*(24) */
19751 { reserved_block , 0 , 0 , 32,
19752 0xfc001fff, 0xa000197b, 0 , 0,
19753 CP1_ }, /* POOL32Fxf_1~*(25) */
19754 { reserved_block , 0 , 0 , 32,
19755 0xfc001fff, 0xa0001a7b, 0 , 0,
19756 CP1_ }, /* POOL32Fxf_1~*(26) */
19757 { pool , CVT_S_fmt , 4 , 32,
19758 0xfc001fff, 0xa0001b7b, 0 , 0,
19759 CP1_ }, /* CVT.S.fmt */
19760 { reserved_block , 0 , 0 , 32,
19761 0xfc001fff, 0xa0001c7b, 0 , 0,
19762 CP1_ }, /* POOL32Fxf_1~*(28) */
19763 { reserved_block , 0 , 0 , 32,
19764 0xfc001fff, 0xa0001d7b, 0 , 0,
19765 CP1_ }, /* POOL32Fxf_1~*(29) */
19766 { reserved_block , 0 , 0 , 32,
19767 0xfc001fff, 0xa0001e7b, 0 , 0,
19768 CP1_ }, /* POOL32Fxf_1~*(30) */
19769 { reserved_block , 0 , 0 , 32,
19770 0xfc001fff, 0xa0001f7b, 0 , 0,
19771 CP1_ }, /* POOL32Fxf_1~*(31) */
19772 };
19773
19774
19775 static const Pool POOL32Fxf[4] = {
19776 { pool , POOL32Fxf_0 , 64 , 32,
19777 0xfc0000ff, 0xa000003b, 0 , 0,
19778 CP1_ }, /* POOL32Fxf_0 */
19779 { pool , POOL32Fxf_1 , 32 , 32,
19780 0xfc0000ff, 0xa000007b, 0 , 0,
19781 CP1_ }, /* POOL32Fxf_1 */
19782 { reserved_block , 0 , 0 , 32,
19783 0xfc0000ff, 0xa00000bb, 0 , 0,
19784 CP1_ }, /* POOL32Fxf~*(2) */
19785 { reserved_block , 0 , 0 , 32,
19786 0xfc0000ff, 0xa00000fb, 0 , 0,
19787 CP1_ }, /* POOL32Fxf~*(3) */
19788 };
19789
19790
19791 static const Pool POOL32F_3[8] = {
19792 { pool , MIN_fmt , 2 , 32,
19793 0xfc00003f, 0xa0000003, 0 , 0,
19794 CP1_ }, /* MIN.fmt */
19795 { pool , MAX_fmt , 2 , 32,
19796 0xfc00003f, 0xa000000b, 0 , 0,
19797 CP1_ }, /* MAX.fmt */
19798 { reserved_block , 0 , 0 , 32,
19799 0xfc00003f, 0xa0000013, 0 , 0,
19800 CP1_ }, /* POOL32F_3~*(2) */
19801 { reserved_block , 0 , 0 , 32,
19802 0xfc00003f, 0xa000001b, 0 , 0,
19803 CP1_ }, /* POOL32F_3~*(3) */
19804 { pool , MINA_fmt , 2 , 32,
19805 0xfc00003f, 0xa0000023, 0 , 0,
19806 CP1_ }, /* MINA.fmt */
19807 { pool , MAXA_fmt , 2 , 32,
19808 0xfc00003f, 0xa000002b, 0 , 0,
19809 CP1_ }, /* MAXA.fmt */
19810 { reserved_block , 0 , 0 , 32,
19811 0xfc00003f, 0xa0000033, 0 , 0,
19812 CP1_ }, /* POOL32F_3~*(6) */
19813 { pool , POOL32Fxf , 4 , 32,
19814 0xfc00003f, 0xa000003b, 0 , 0,
19815 CP1_ }, /* POOL32Fxf */
19816 };
19817
19818
19819 static const Pool CMP_condn_S[32] = {
19820 { instruction , 0 , 0 , 32,
19821 0xfc0007ff, 0xa0000005, &CMP_AF_S , 0,
19822 CP1_ }, /* CMP.AF.S */
19823 { instruction , 0 , 0 , 32,
19824 0xfc0007ff, 0xa0000045, &CMP_UN_S , 0,
19825 CP1_ }, /* CMP.UN.S */
19826 { instruction , 0 , 0 , 32,
19827 0xfc0007ff, 0xa0000085, &CMP_EQ_S , 0,
19828 CP1_ }, /* CMP.EQ.S */
19829 { instruction , 0 , 0 , 32,
19830 0xfc0007ff, 0xa00000c5, &CMP_UEQ_S , 0,
19831 CP1_ }, /* CMP.UEQ.S */
19832 { instruction , 0 , 0 , 32,
19833 0xfc0007ff, 0xa0000105, &CMP_LT_S , 0,
19834 CP1_ }, /* CMP.LT.S */
19835 { instruction , 0 , 0 , 32,
19836 0xfc0007ff, 0xa0000145, &CMP_ULT_S , 0,
19837 CP1_ }, /* CMP.ULT.S */
19838 { instruction , 0 , 0 , 32,
19839 0xfc0007ff, 0xa0000185, &CMP_LE_S , 0,
19840 CP1_ }, /* CMP.LE.S */
19841 { instruction , 0 , 0 , 32,
19842 0xfc0007ff, 0xa00001c5, &CMP_ULE_S , 0,
19843 CP1_ }, /* CMP.ULE.S */
19844 { instruction , 0 , 0 , 32,
19845 0xfc0007ff, 0xa0000205, &CMP_SAF_S , 0,
19846 CP1_ }, /* CMP.SAF.S */
19847 { instruction , 0 , 0 , 32,
19848 0xfc0007ff, 0xa0000245, &CMP_SUN_S , 0,
19849 CP1_ }, /* CMP.SUN.S */
19850 { instruction , 0 , 0 , 32,
19851 0xfc0007ff, 0xa0000285, &CMP_SEQ_S , 0,
19852 CP1_ }, /* CMP.SEQ.S */
19853 { instruction , 0 , 0 , 32,
19854 0xfc0007ff, 0xa00002c5, &CMP_SUEQ_S , 0,
19855 CP1_ }, /* CMP.SUEQ.S */
19856 { instruction , 0 , 0 , 32,
19857 0xfc0007ff, 0xa0000305, &CMP_SLT_S , 0,
19858 CP1_ }, /* CMP.SLT.S */
19859 { instruction , 0 , 0 , 32,
19860 0xfc0007ff, 0xa0000345, &CMP_SULT_S , 0,
19861 CP1_ }, /* CMP.SULT.S */
19862 { instruction , 0 , 0 , 32,
19863 0xfc0007ff, 0xa0000385, &CMP_SLE_S , 0,
19864 CP1_ }, /* CMP.SLE.S */
19865 { instruction , 0 , 0 , 32,
19866 0xfc0007ff, 0xa00003c5, &CMP_SULE_S , 0,
19867 CP1_ }, /* CMP.SULE.S */
19868 { reserved_block , 0 , 0 , 32,
19869 0xfc0007ff, 0xa0000405, 0 , 0,
19870 CP1_ }, /* CMP.condn.S~*(16) */
19871 { instruction , 0 , 0 , 32,
19872 0xfc0007ff, 0xa0000445, &CMP_OR_S , 0,
19873 CP1_ }, /* CMP.OR.S */
19874 { instruction , 0 , 0 , 32,
19875 0xfc0007ff, 0xa0000485, &CMP_UNE_S , 0,
19876 CP1_ }, /* CMP.UNE.S */
19877 { instruction , 0 , 0 , 32,
19878 0xfc0007ff, 0xa00004c5, &CMP_NE_S , 0,
19879 CP1_ }, /* CMP.NE.S */
19880 { reserved_block , 0 , 0 , 32,
19881 0xfc0007ff, 0xa0000505, 0 , 0,
19882 CP1_ }, /* CMP.condn.S~*(20) */
19883 { reserved_block , 0 , 0 , 32,
19884 0xfc0007ff, 0xa0000545, 0 , 0,
19885 CP1_ }, /* CMP.condn.S~*(21) */
19886 { reserved_block , 0 , 0 , 32,
19887 0xfc0007ff, 0xa0000585, 0 , 0,
19888 CP1_ }, /* CMP.condn.S~*(22) */
19889 { reserved_block , 0 , 0 , 32,
19890 0xfc0007ff, 0xa00005c5, 0 , 0,
19891 CP1_ }, /* CMP.condn.S~*(23) */
19892 { reserved_block , 0 , 0 , 32,
19893 0xfc0007ff, 0xa0000605, 0 , 0,
19894 CP1_ }, /* CMP.condn.S~*(24) */
19895 { instruction , 0 , 0 , 32,
19896 0xfc0007ff, 0xa0000645, &CMP_SOR_S , 0,
19897 CP1_ }, /* CMP.SOR.S */
19898 { instruction , 0 , 0 , 32,
19899 0xfc0007ff, 0xa0000685, &CMP_SUNE_S , 0,
19900 CP1_ }, /* CMP.SUNE.S */
19901 { instruction , 0 , 0 , 32,
19902 0xfc0007ff, 0xa00006c5, &CMP_SNE_S , 0,
19903 CP1_ }, /* CMP.SNE.S */
19904 { reserved_block , 0 , 0 , 32,
19905 0xfc0007ff, 0xa0000705, 0 , 0,
19906 CP1_ }, /* CMP.condn.S~*(28) */
19907 { reserved_block , 0 , 0 , 32,
19908 0xfc0007ff, 0xa0000745, 0 , 0,
19909 CP1_ }, /* CMP.condn.S~*(29) */
19910 { reserved_block , 0 , 0 , 32,
19911 0xfc0007ff, 0xa0000785, 0 , 0,
19912 CP1_ }, /* CMP.condn.S~*(30) */
19913 { reserved_block , 0 , 0 , 32,
19914 0xfc0007ff, 0xa00007c5, 0 , 0,
19915 CP1_ }, /* CMP.condn.S~*(31) */
19916 };
19917
19918
19919 static const Pool CMP_condn_D[32] = {
19920 { instruction , 0 , 0 , 32,
19921 0xfc0007ff, 0xa0000015, &CMP_AF_D , 0,
19922 CP1_ }, /* CMP.AF.D */
19923 { instruction , 0 , 0 , 32,
19924 0xfc0007ff, 0xa0000055, &CMP_UN_D , 0,
19925 CP1_ }, /* CMP.UN.D */
19926 { instruction , 0 , 0 , 32,
19927 0xfc0007ff, 0xa0000095, &CMP_EQ_D , 0,
19928 CP1_ }, /* CMP.EQ.D */
19929 { instruction , 0 , 0 , 32,
19930 0xfc0007ff, 0xa00000d5, &CMP_UEQ_D , 0,
19931 CP1_ }, /* CMP.UEQ.D */
19932 { instruction , 0 , 0 , 32,
19933 0xfc0007ff, 0xa0000115, &CMP_LT_D , 0,
19934 CP1_ }, /* CMP.LT.D */
19935 { instruction , 0 , 0 , 32,
19936 0xfc0007ff, 0xa0000155, &CMP_ULT_D , 0,
19937 CP1_ }, /* CMP.ULT.D */
19938 { instruction , 0 , 0 , 32,
19939 0xfc0007ff, 0xa0000195, &CMP_LE_D , 0,
19940 CP1_ }, /* CMP.LE.D */
19941 { instruction , 0 , 0 , 32,
19942 0xfc0007ff, 0xa00001d5, &CMP_ULE_D , 0,
19943 CP1_ }, /* CMP.ULE.D */
19944 { instruction , 0 , 0 , 32,
19945 0xfc0007ff, 0xa0000215, &CMP_SAF_D , 0,
19946 CP1_ }, /* CMP.SAF.D */
19947 { instruction , 0 , 0 , 32,
19948 0xfc0007ff, 0xa0000255, &CMP_SUN_D , 0,
19949 CP1_ }, /* CMP.SUN.D */
19950 { instruction , 0 , 0 , 32,
19951 0xfc0007ff, 0xa0000295, &CMP_SEQ_D , 0,
19952 CP1_ }, /* CMP.SEQ.D */
19953 { instruction , 0 , 0 , 32,
19954 0xfc0007ff, 0xa00002d5, &CMP_SUEQ_D , 0,
19955 CP1_ }, /* CMP.SUEQ.D */
19956 { instruction , 0 , 0 , 32,
19957 0xfc0007ff, 0xa0000315, &CMP_SLT_D , 0,
19958 CP1_ }, /* CMP.SLT.D */
19959 { instruction , 0 , 0 , 32,
19960 0xfc0007ff, 0xa0000355, &CMP_SULT_D , 0,
19961 CP1_ }, /* CMP.SULT.D */
19962 { instruction , 0 , 0 , 32,
19963 0xfc0007ff, 0xa0000395, &CMP_SLE_D , 0,
19964 CP1_ }, /* CMP.SLE.D */
19965 { instruction , 0 , 0 , 32,
19966 0xfc0007ff, 0xa00003d5, &CMP_SULE_D , 0,
19967 CP1_ }, /* CMP.SULE.D */
19968 { reserved_block , 0 , 0 , 32,
19969 0xfc0007ff, 0xa0000415, 0 , 0,
19970 CP1_ }, /* CMP.condn.D~*(16) */
19971 { instruction , 0 , 0 , 32,
19972 0xfc0007ff, 0xa0000455, &CMP_OR_D , 0,
19973 CP1_ }, /* CMP.OR.D */
19974 { instruction , 0 , 0 , 32,
19975 0xfc0007ff, 0xa0000495, &CMP_UNE_D , 0,
19976 CP1_ }, /* CMP.UNE.D */
19977 { instruction , 0 , 0 , 32,
19978 0xfc0007ff, 0xa00004d5, &CMP_NE_D , 0,
19979 CP1_ }, /* CMP.NE.D */
19980 { reserved_block , 0 , 0 , 32,
19981 0xfc0007ff, 0xa0000515, 0 , 0,
19982 CP1_ }, /* CMP.condn.D~*(20) */
19983 { reserved_block , 0 , 0 , 32,
19984 0xfc0007ff, 0xa0000555, 0 , 0,
19985 CP1_ }, /* CMP.condn.D~*(21) */
19986 { reserved_block , 0 , 0 , 32,
19987 0xfc0007ff, 0xa0000595, 0 , 0,
19988 CP1_ }, /* CMP.condn.D~*(22) */
19989 { reserved_block , 0 , 0 , 32,
19990 0xfc0007ff, 0xa00005d5, 0 , 0,
19991 CP1_ }, /* CMP.condn.D~*(23) */
19992 { reserved_block , 0 , 0 , 32,
19993 0xfc0007ff, 0xa0000615, 0 , 0,
19994 CP1_ }, /* CMP.condn.D~*(24) */
19995 { instruction , 0 , 0 , 32,
19996 0xfc0007ff, 0xa0000655, &CMP_SOR_D , 0,
19997 CP1_ }, /* CMP.SOR.D */
19998 { instruction , 0 , 0 , 32,
19999 0xfc0007ff, 0xa0000695, &CMP_SUNE_D , 0,
20000 CP1_ }, /* CMP.SUNE.D */
20001 { instruction , 0 , 0 , 32,
20002 0xfc0007ff, 0xa00006d5, &CMP_SNE_D , 0,
20003 CP1_ }, /* CMP.SNE.D */
20004 { reserved_block , 0 , 0 , 32,
20005 0xfc0007ff, 0xa0000715, 0 , 0,
20006 CP1_ }, /* CMP.condn.D~*(28) */
20007 { reserved_block , 0 , 0 , 32,
20008 0xfc0007ff, 0xa0000755, 0 , 0,
20009 CP1_ }, /* CMP.condn.D~*(29) */
20010 { reserved_block , 0 , 0 , 32,
20011 0xfc0007ff, 0xa0000795, 0 , 0,
20012 CP1_ }, /* CMP.condn.D~*(30) */
20013 { reserved_block , 0 , 0 , 32,
20014 0xfc0007ff, 0xa00007d5, 0 , 0,
20015 CP1_ }, /* CMP.condn.D~*(31) */
20016 };
20017
20018
20019 static const Pool POOL32F_5[8] = {
20020 { pool , CMP_condn_S , 32 , 32,
20021 0xfc00003f, 0xa0000005, 0 , 0,
20022 CP1_ }, /* CMP.condn.S */
20023 { reserved_block , 0 , 0 , 32,
20024 0xfc00003f, 0xa000000d, 0 , 0,
20025 CP1_ }, /* POOL32F_5~*(1) */
20026 { pool , CMP_condn_D , 32 , 32,
20027 0xfc00003f, 0xa0000015, 0 , 0,
20028 CP1_ }, /* CMP.condn.D */
20029 { reserved_block , 0 , 0 , 32,
20030 0xfc00003f, 0xa000001d, 0 , 0,
20031 CP1_ }, /* POOL32F_5~*(3) */
20032 { reserved_block , 0 , 0 , 32,
20033 0xfc00003f, 0xa0000025, 0 , 0,
20034 CP1_ }, /* POOL32F_5~*(4) */
20035 { reserved_block , 0 , 0 , 32,
20036 0xfc00003f, 0xa000002d, 0 , 0,
20037 CP1_ }, /* POOL32F_5~*(5) */
20038 { reserved_block , 0 , 0 , 32,
20039 0xfc00003f, 0xa0000035, 0 , 0,
20040 CP1_ }, /* POOL32F_5~*(6) */
20041 { reserved_block , 0 , 0 , 32,
20042 0xfc00003f, 0xa000003d, 0 , 0,
20043 CP1_ }, /* POOL32F_5~*(7) */
20044 };
20045
20046
20047 static const Pool POOL32F[8] = {
20048 { pool , POOL32F_0 , 64 , 32,
20049 0xfc000007, 0xa0000000, 0 , 0,
20050 CP1_ }, /* POOL32F_0 */
20051 { reserved_block , 0 , 0 , 32,
20052 0xfc000007, 0xa0000001, 0 , 0,
20053 CP1_ }, /* POOL32F~*(1) */
20054 { reserved_block , 0 , 0 , 32,
20055 0xfc000007, 0xa0000002, 0 , 0,
20056 CP1_ }, /* POOL32F~*(2) */
20057 { pool , POOL32F_3 , 8 , 32,
20058 0xfc000007, 0xa0000003, 0 , 0,
20059 CP1_ }, /* POOL32F_3 */
20060 { reserved_block , 0 , 0 , 32,
20061 0xfc000007, 0xa0000004, 0 , 0,
20062 CP1_ }, /* POOL32F~*(4) */
20063 { pool , POOL32F_5 , 8 , 32,
20064 0xfc000007, 0xa0000005, 0 , 0,
20065 CP1_ }, /* POOL32F_5 */
20066 { reserved_block , 0 , 0 , 32,
20067 0xfc000007, 0xa0000006, 0 , 0,
20068 CP1_ }, /* POOL32F~*(6) */
20069 { reserved_block , 0 , 0 , 32,
20070 0xfc000007, 0xa0000007, 0 , 0,
20071 CP1_ }, /* POOL32F~*(7) */
20072 };
20073
20074
20075 static const Pool POOL32S_0[64] = {
20076 { reserved_block , 0 , 0 , 32,
20077 0xfc0001ff, 0xc0000000, 0 , 0,
20078 0x0 }, /* POOL32S_0~*(0) */
20079 { instruction , 0 , 0 , 32,
20080 0xfc0001ff, 0xc0000008, &DLSA , 0,
20081 MIPS64_ }, /* DLSA */
20082 { instruction , 0 , 0 , 32,
20083 0xfc0001ff, 0xc0000010, &DSLLV , 0,
20084 MIPS64_ }, /* DSLLV */
20085 { instruction , 0 , 0 , 32,
20086 0xfc0001ff, 0xc0000018, &DMUL , 0,
20087 MIPS64_ }, /* DMUL */
20088 { reserved_block , 0 , 0 , 32,
20089 0xfc0001ff, 0xc0000020, 0 , 0,
20090 0x0 }, /* POOL32S_0~*(4) */
20091 { reserved_block , 0 , 0 , 32,
20092 0xfc0001ff, 0xc0000028, 0 , 0,
20093 0x0 }, /* POOL32S_0~*(5) */
20094 { reserved_block , 0 , 0 , 32,
20095 0xfc0001ff, 0xc0000030, 0 , 0,
20096 0x0 }, /* POOL32S_0~*(6) */
20097 { reserved_block , 0 , 0 , 32,
20098 0xfc0001ff, 0xc0000038, 0 , 0,
20099 0x0 }, /* POOL32S_0~*(7) */
20100 { reserved_block , 0 , 0 , 32,
20101 0xfc0001ff, 0xc0000040, 0 , 0,
20102 0x0 }, /* POOL32S_0~*(8) */
20103 { reserved_block , 0 , 0 , 32,
20104 0xfc0001ff, 0xc0000048, 0 , 0,
20105 0x0 }, /* POOL32S_0~*(9) */
20106 { instruction , 0 , 0 , 32,
20107 0xfc0001ff, 0xc0000050, &DSRLV , 0,
20108 MIPS64_ }, /* DSRLV */
20109 { instruction , 0 , 0 , 32,
20110 0xfc0001ff, 0xc0000058, &DMUH , 0,
20111 MIPS64_ }, /* DMUH */
20112 { reserved_block , 0 , 0 , 32,
20113 0xfc0001ff, 0xc0000060, 0 , 0,
20114 0x0 }, /* POOL32S_0~*(12) */
20115 { reserved_block , 0 , 0 , 32,
20116 0xfc0001ff, 0xc0000068, 0 , 0,
20117 0x0 }, /* POOL32S_0~*(13) */
20118 { reserved_block , 0 , 0 , 32,
20119 0xfc0001ff, 0xc0000070, 0 , 0,
20120 0x0 }, /* POOL32S_0~*(14) */
20121 { reserved_block , 0 , 0 , 32,
20122 0xfc0001ff, 0xc0000078, 0 , 0,
20123 0x0 }, /* POOL32S_0~*(15) */
20124 { reserved_block , 0 , 0 , 32,
20125 0xfc0001ff, 0xc0000080, 0 , 0,
20126 0x0 }, /* POOL32S_0~*(16) */
20127 { reserved_block , 0 , 0 , 32,
20128 0xfc0001ff, 0xc0000088, 0 , 0,
20129 0x0 }, /* POOL32S_0~*(17) */
20130 { instruction , 0 , 0 , 32,
20131 0xfc0001ff, 0xc0000090, &DSRAV , 0,
20132 MIPS64_ }, /* DSRAV */
20133 { instruction , 0 , 0 , 32,
20134 0xfc0001ff, 0xc0000098, &DMULU , 0,
20135 MIPS64_ }, /* DMULU */
20136 { reserved_block , 0 , 0 , 32,
20137 0xfc0001ff, 0xc00000a0, 0 , 0,
20138 0x0 }, /* POOL32S_0~*(20) */
20139 { reserved_block , 0 , 0 , 32,
20140 0xfc0001ff, 0xc00000a8, 0 , 0,
20141 0x0 }, /* POOL32S_0~*(21) */
20142 { reserved_block , 0 , 0 , 32,
20143 0xfc0001ff, 0xc00000b0, 0 , 0,
20144 0x0 }, /* POOL32S_0~*(22) */
20145 { reserved_block , 0 , 0 , 32,
20146 0xfc0001ff, 0xc00000b8, 0 , 0,
20147 0x0 }, /* POOL32S_0~*(23) */
20148 { reserved_block , 0 , 0 , 32,
20149 0xfc0001ff, 0xc00000c0, 0 , 0,
20150 0x0 }, /* POOL32S_0~*(24) */
20151 { reserved_block , 0 , 0 , 32,
20152 0xfc0001ff, 0xc00000c8, 0 , 0,
20153 0x0 }, /* POOL32S_0~*(25) */
20154 { instruction , 0 , 0 , 32,
20155 0xfc0001ff, 0xc00000d0, &DROTRV , 0,
20156 MIPS64_ }, /* DROTRV */
20157 { instruction , 0 , 0 , 32,
20158 0xfc0001ff, 0xc00000d8, &DMUHU , 0,
20159 MIPS64_ }, /* DMUHU */
20160 { reserved_block , 0 , 0 , 32,
20161 0xfc0001ff, 0xc00000e0, 0 , 0,
20162 0x0 }, /* POOL32S_0~*(28) */
20163 { reserved_block , 0 , 0 , 32,
20164 0xfc0001ff, 0xc00000e8, 0 , 0,
20165 0x0 }, /* POOL32S_0~*(29) */
20166 { reserved_block , 0 , 0 , 32,
20167 0xfc0001ff, 0xc00000f0, 0 , 0,
20168 0x0 }, /* POOL32S_0~*(30) */
20169 { reserved_block , 0 , 0 , 32,
20170 0xfc0001ff, 0xc00000f8, 0 , 0,
20171 0x0 }, /* POOL32S_0~*(31) */
20172 { reserved_block , 0 , 0 , 32,
20173 0xfc0001ff, 0xc0000100, 0 , 0,
20174 0x0 }, /* POOL32S_0~*(32) */
20175 { reserved_block , 0 , 0 , 32,
20176 0xfc0001ff, 0xc0000108, 0 , 0,
20177 0x0 }, /* POOL32S_0~*(33) */
20178 { instruction , 0 , 0 , 32,
20179 0xfc0001ff, 0xc0000110, &DADD , 0,
20180 MIPS64_ }, /* DADD */
20181 { instruction , 0 , 0 , 32,
20182 0xfc0001ff, 0xc0000118, &DDIV , 0,
20183 MIPS64_ }, /* DDIV */
20184 { reserved_block , 0 , 0 , 32,
20185 0xfc0001ff, 0xc0000120, 0 , 0,
20186 0x0 }, /* POOL32S_0~*(36) */
20187 { reserved_block , 0 , 0 , 32,
20188 0xfc0001ff, 0xc0000128, 0 , 0,
20189 0x0 }, /* POOL32S_0~*(37) */
20190 { reserved_block , 0 , 0 , 32,
20191 0xfc0001ff, 0xc0000130, 0 , 0,
20192 0x0 }, /* POOL32S_0~*(38) */
20193 { reserved_block , 0 , 0 , 32,
20194 0xfc0001ff, 0xc0000138, 0 , 0,
20195 0x0 }, /* POOL32S_0~*(39) */
20196 { reserved_block , 0 , 0 , 32,
20197 0xfc0001ff, 0xc0000140, 0 , 0,
20198 0x0 }, /* POOL32S_0~*(40) */
20199 { reserved_block , 0 , 0 , 32,
20200 0xfc0001ff, 0xc0000148, 0 , 0,
20201 0x0 }, /* POOL32S_0~*(41) */
20202 { instruction , 0 , 0 , 32,
20203 0xfc0001ff, 0xc0000150, &DADDU , 0,
20204 MIPS64_ }, /* DADDU */
20205 { instruction , 0 , 0 , 32,
20206 0xfc0001ff, 0xc0000158, &DMOD , 0,
20207 MIPS64_ }, /* DMOD */
20208 { reserved_block , 0 , 0 , 32,
20209 0xfc0001ff, 0xc0000160, 0 , 0,
20210 0x0 }, /* POOL32S_0~*(44) */
20211 { reserved_block , 0 , 0 , 32,
20212 0xfc0001ff, 0xc0000168, 0 , 0,
20213 0x0 }, /* POOL32S_0~*(45) */
20214 { reserved_block , 0 , 0 , 32,
20215 0xfc0001ff, 0xc0000170, 0 , 0,
20216 0x0 }, /* POOL32S_0~*(46) */
20217 { reserved_block , 0 , 0 , 32,
20218 0xfc0001ff, 0xc0000178, 0 , 0,
20219 0x0 }, /* POOL32S_0~*(47) */
20220 { reserved_block , 0 , 0 , 32,
20221 0xfc0001ff, 0xc0000180, 0 , 0,
20222 0x0 }, /* POOL32S_0~*(48) */
20223 { reserved_block , 0 , 0 , 32,
20224 0xfc0001ff, 0xc0000188, 0 , 0,
20225 0x0 }, /* POOL32S_0~*(49) */
20226 { instruction , 0 , 0 , 32,
20227 0xfc0001ff, 0xc0000190, &DSUB , 0,
20228 MIPS64_ }, /* DSUB */
20229 { instruction , 0 , 0 , 32,
20230 0xfc0001ff, 0xc0000198, &DDIVU , 0,
20231 MIPS64_ }, /* DDIVU */
20232 { reserved_block , 0 , 0 , 32,
20233 0xfc0001ff, 0xc00001a0, 0 , 0,
20234 0x0 }, /* POOL32S_0~*(52) */
20235 { reserved_block , 0 , 0 , 32,
20236 0xfc0001ff, 0xc00001a8, 0 , 0,
20237 0x0 }, /* POOL32S_0~*(53) */
20238 { reserved_block , 0 , 0 , 32,
20239 0xfc0001ff, 0xc00001b0, 0 , 0,
20240 0x0 }, /* POOL32S_0~*(54) */
20241 { reserved_block , 0 , 0 , 32,
20242 0xfc0001ff, 0xc00001b8, 0 , 0,
20243 0x0 }, /* POOL32S_0~*(55) */
20244 { reserved_block , 0 , 0 , 32,
20245 0xfc0001ff, 0xc00001c0, 0 , 0,
20246 0x0 }, /* POOL32S_0~*(56) */
20247 { reserved_block , 0 , 0 , 32,
20248 0xfc0001ff, 0xc00001c8, 0 , 0,
20249 0x0 }, /* POOL32S_0~*(57) */
20250 { instruction , 0 , 0 , 32,
20251 0xfc0001ff, 0xc00001d0, &DSUBU , 0,
20252 MIPS64_ }, /* DSUBU */
20253 { instruction , 0 , 0 , 32,
20254 0xfc0001ff, 0xc00001d8, &DMODU , 0,
20255 MIPS64_ }, /* DMODU */
20256 { reserved_block , 0 , 0 , 32,
20257 0xfc0001ff, 0xc00001e0, 0 , 0,
20258 0x0 }, /* POOL32S_0~*(60) */
20259 { reserved_block , 0 , 0 , 32,
20260 0xfc0001ff, 0xc00001e8, 0 , 0,
20261 0x0 }, /* POOL32S_0~*(61) */
20262 { reserved_block , 0 , 0 , 32,
20263 0xfc0001ff, 0xc00001f0, 0 , 0,
20264 0x0 }, /* POOL32S_0~*(62) */
20265 { reserved_block , 0 , 0 , 32,
20266 0xfc0001ff, 0xc00001f8, 0 , 0,
20267 0x0 }, /* POOL32S_0~*(63) */
20268 };
20269
20270
20271 static const Pool POOL32Sxf_4[128] = {
20272 { reserved_block , 0 , 0 , 32,
20273 0xfc00ffff, 0xc000013c, 0 , 0,
20274 0x0 }, /* POOL32Sxf_4~*(0) */
20275 { reserved_block , 0 , 0 , 32,
20276 0xfc00ffff, 0xc000033c, 0 , 0,
20277 0x0 }, /* POOL32Sxf_4~*(1) */
20278 { reserved_block , 0 , 0 , 32,
20279 0xfc00ffff, 0xc000053c, 0 , 0,
20280 0x0 }, /* POOL32Sxf_4~*(2) */
20281 { reserved_block , 0 , 0 , 32,
20282 0xfc00ffff, 0xc000073c, 0 , 0,
20283 0x0 }, /* POOL32Sxf_4~*(3) */
20284 { reserved_block , 0 , 0 , 32,
20285 0xfc00ffff, 0xc000093c, 0 , 0,
20286 0x0 }, /* POOL32Sxf_4~*(4) */
20287 { reserved_block , 0 , 0 , 32,
20288 0xfc00ffff, 0xc0000b3c, 0 , 0,
20289 0x0 }, /* POOL32Sxf_4~*(5) */
20290 { reserved_block , 0 , 0 , 32,
20291 0xfc00ffff, 0xc0000d3c, 0 , 0,
20292 0x0 }, /* POOL32Sxf_4~*(6) */
20293 { reserved_block , 0 , 0 , 32,
20294 0xfc00ffff, 0xc0000f3c, 0 , 0,
20295 0x0 }, /* POOL32Sxf_4~*(7) */
20296 { reserved_block , 0 , 0 , 32,
20297 0xfc00ffff, 0xc000113c, 0 , 0,
20298 0x0 }, /* POOL32Sxf_4~*(8) */
20299 { reserved_block , 0 , 0 , 32,
20300 0xfc00ffff, 0xc000133c, 0 , 0,
20301 0x0 }, /* POOL32Sxf_4~*(9) */
20302 { reserved_block , 0 , 0 , 32,
20303 0xfc00ffff, 0xc000153c, 0 , 0,
20304 0x0 }, /* POOL32Sxf_4~*(10) */
20305 { reserved_block , 0 , 0 , 32,
20306 0xfc00ffff, 0xc000173c, 0 , 0,
20307 0x0 }, /* POOL32Sxf_4~*(11) */
20308 { reserved_block , 0 , 0 , 32,
20309 0xfc00ffff, 0xc000193c, 0 , 0,
20310 0x0 }, /* POOL32Sxf_4~*(12) */
20311 { reserved_block , 0 , 0 , 32,
20312 0xfc00ffff, 0xc0001b3c, 0 , 0,
20313 0x0 }, /* POOL32Sxf_4~*(13) */
20314 { reserved_block , 0 , 0 , 32,
20315 0xfc00ffff, 0xc0001d3c, 0 , 0,
20316 0x0 }, /* POOL32Sxf_4~*(14) */
20317 { reserved_block , 0 , 0 , 32,
20318 0xfc00ffff, 0xc0001f3c, 0 , 0,
20319 0x0 }, /* POOL32Sxf_4~*(15) */
20320 { reserved_block , 0 , 0 , 32,
20321 0xfc00ffff, 0xc000213c, 0 , 0,
20322 0x0 }, /* POOL32Sxf_4~*(16) */
20323 { reserved_block , 0 , 0 , 32,
20324 0xfc00ffff, 0xc000233c, 0 , 0,
20325 0x0 }, /* POOL32Sxf_4~*(17) */
20326 { reserved_block , 0 , 0 , 32,
20327 0xfc00ffff, 0xc000253c, 0 , 0,
20328 0x0 }, /* POOL32Sxf_4~*(18) */
20329 { reserved_block , 0 , 0 , 32,
20330 0xfc00ffff, 0xc000273c, 0 , 0,
20331 0x0 }, /* POOL32Sxf_4~*(19) */
20332 { reserved_block , 0 , 0 , 32,
20333 0xfc00ffff, 0xc000293c, 0 , 0,
20334 0x0 }, /* POOL32Sxf_4~*(20) */
20335 { reserved_block , 0 , 0 , 32,
20336 0xfc00ffff, 0xc0002b3c, 0 , 0,
20337 0x0 }, /* POOL32Sxf_4~*(21) */
20338 { reserved_block , 0 , 0 , 32,
20339 0xfc00ffff, 0xc0002d3c, 0 , 0,
20340 0x0 }, /* POOL32Sxf_4~*(22) */
20341 { reserved_block , 0 , 0 , 32,
20342 0xfc00ffff, 0xc0002f3c, 0 , 0,
20343 0x0 }, /* POOL32Sxf_4~*(23) */
20344 { reserved_block , 0 , 0 , 32,
20345 0xfc00ffff, 0xc000313c, 0 , 0,
20346 0x0 }, /* POOL32Sxf_4~*(24) */
20347 { reserved_block , 0 , 0 , 32,
20348 0xfc00ffff, 0xc000333c, 0 , 0,
20349 0x0 }, /* POOL32Sxf_4~*(25) */
20350 { reserved_block , 0 , 0 , 32,
20351 0xfc00ffff, 0xc000353c, 0 , 0,
20352 0x0 }, /* POOL32Sxf_4~*(26) */
20353 { reserved_block , 0 , 0 , 32,
20354 0xfc00ffff, 0xc000373c, 0 , 0,
20355 0x0 }, /* POOL32Sxf_4~*(27) */
20356 { reserved_block , 0 , 0 , 32,
20357 0xfc00ffff, 0xc000393c, 0 , 0,
20358 0x0 }, /* POOL32Sxf_4~*(28) */
20359 { reserved_block , 0 , 0 , 32,
20360 0xfc00ffff, 0xc0003b3c, 0 , 0,
20361 0x0 }, /* POOL32Sxf_4~*(29) */
20362 { reserved_block , 0 , 0 , 32,
20363 0xfc00ffff, 0xc0003d3c, 0 , 0,
20364 0x0 }, /* POOL32Sxf_4~*(30) */
20365 { reserved_block , 0 , 0 , 32,
20366 0xfc00ffff, 0xc0003f3c, 0 , 0,
20367 0x0 }, /* POOL32Sxf_4~*(31) */
20368 { reserved_block , 0 , 0 , 32,
20369 0xfc00ffff, 0xc000413c, 0 , 0,
20370 0x0 }, /* POOL32Sxf_4~*(32) */
20371 { reserved_block , 0 , 0 , 32,
20372 0xfc00ffff, 0xc000433c, 0 , 0,
20373 0x0 }, /* POOL32Sxf_4~*(33) */
20374 { reserved_block , 0 , 0 , 32,
20375 0xfc00ffff, 0xc000453c, 0 , 0,
20376 0x0 }, /* POOL32Sxf_4~*(34) */
20377 { reserved_block , 0 , 0 , 32,
20378 0xfc00ffff, 0xc000473c, 0 , 0,
20379 0x0 }, /* POOL32Sxf_4~*(35) */
20380 { reserved_block , 0 , 0 , 32,
20381 0xfc00ffff, 0xc000493c, 0 , 0,
20382 0x0 }, /* POOL32Sxf_4~*(36) */
20383 { instruction , 0 , 0 , 32,
20384 0xfc00ffff, 0xc0004b3c, &DCLO , 0,
20385 MIPS64_ }, /* DCLO */
20386 { reserved_block , 0 , 0 , 32,
20387 0xfc00ffff, 0xc0004d3c, 0 , 0,
20388 0x0 }, /* POOL32Sxf_4~*(38) */
20389 { reserved_block , 0 , 0 , 32,
20390 0xfc00ffff, 0xc0004f3c, 0 , 0,
20391 0x0 }, /* POOL32Sxf_4~*(39) */
20392 { reserved_block , 0 , 0 , 32,
20393 0xfc00ffff, 0xc000513c, 0 , 0,
20394 0x0 }, /* POOL32Sxf_4~*(40) */
20395 { reserved_block , 0 , 0 , 32,
20396 0xfc00ffff, 0xc000533c, 0 , 0,
20397 0x0 }, /* POOL32Sxf_4~*(41) */
20398 { reserved_block , 0 , 0 , 32,
20399 0xfc00ffff, 0xc000553c, 0 , 0,
20400 0x0 }, /* POOL32Sxf_4~*(42) */
20401 { reserved_block , 0 , 0 , 32,
20402 0xfc00ffff, 0xc000573c, 0 , 0,
20403 0x0 }, /* POOL32Sxf_4~*(43) */
20404 { reserved_block , 0 , 0 , 32,
20405 0xfc00ffff, 0xc000593c, 0 , 0,
20406 0x0 }, /* POOL32Sxf_4~*(44) */
20407 { instruction , 0 , 0 , 32,
20408 0xfc00ffff, 0xc0005b3c, &DCLZ , 0,
20409 MIPS64_ }, /* DCLZ */
20410 { reserved_block , 0 , 0 , 32,
20411 0xfc00ffff, 0xc0005d3c, 0 , 0,
20412 0x0 }, /* POOL32Sxf_4~*(46) */
20413 { reserved_block , 0 , 0 , 32,
20414 0xfc00ffff, 0xc0005f3c, 0 , 0,
20415 0x0 }, /* POOL32Sxf_4~*(47) */
20416 { reserved_block , 0 , 0 , 32,
20417 0xfc00ffff, 0xc000613c, 0 , 0,
20418 0x0 }, /* POOL32Sxf_4~*(48) */
20419 { reserved_block , 0 , 0 , 32,
20420 0xfc00ffff, 0xc000633c, 0 , 0,
20421 0x0 }, /* POOL32Sxf_4~*(49) */
20422 { reserved_block , 0 , 0 , 32,
20423 0xfc00ffff, 0xc000653c, 0 , 0,
20424 0x0 }, /* POOL32Sxf_4~*(50) */
20425 { reserved_block , 0 , 0 , 32,
20426 0xfc00ffff, 0xc000673c, 0 , 0,
20427 0x0 }, /* POOL32Sxf_4~*(51) */
20428 { reserved_block , 0 , 0 , 32,
20429 0xfc00ffff, 0xc000693c, 0 , 0,
20430 0x0 }, /* POOL32Sxf_4~*(52) */
20431 { reserved_block , 0 , 0 , 32,
20432 0xfc00ffff, 0xc0006b3c, 0 , 0,
20433 0x0 }, /* POOL32Sxf_4~*(53) */
20434 { reserved_block , 0 , 0 , 32,
20435 0xfc00ffff, 0xc0006d3c, 0 , 0,
20436 0x0 }, /* POOL32Sxf_4~*(54) */
20437 { reserved_block , 0 , 0 , 32,
20438 0xfc00ffff, 0xc0006f3c, 0 , 0,
20439 0x0 }, /* POOL32Sxf_4~*(55) */
20440 { reserved_block , 0 , 0 , 32,
20441 0xfc00ffff, 0xc000713c, 0 , 0,
20442 0x0 }, /* POOL32Sxf_4~*(56) */
20443 { reserved_block , 0 , 0 , 32,
20444 0xfc00ffff, 0xc000733c, 0 , 0,
20445 0x0 }, /* POOL32Sxf_4~*(57) */
20446 { reserved_block , 0 , 0 , 32,
20447 0xfc00ffff, 0xc000753c, 0 , 0,
20448 0x0 }, /* POOL32Sxf_4~*(58) */
20449 { reserved_block , 0 , 0 , 32,
20450 0xfc00ffff, 0xc000773c, 0 , 0,
20451 0x0 }, /* POOL32Sxf_4~*(59) */
20452 { reserved_block , 0 , 0 , 32,
20453 0xfc00ffff, 0xc000793c, 0 , 0,
20454 0x0 }, /* POOL32Sxf_4~*(60) */
20455 { reserved_block , 0 , 0 , 32,
20456 0xfc00ffff, 0xc0007b3c, 0 , 0,
20457 0x0 }, /* POOL32Sxf_4~*(61) */
20458 { reserved_block , 0 , 0 , 32,
20459 0xfc00ffff, 0xc0007d3c, 0 , 0,
20460 0x0 }, /* POOL32Sxf_4~*(62) */
20461 { reserved_block , 0 , 0 , 32,
20462 0xfc00ffff, 0xc0007f3c, 0 , 0,
20463 0x0 }, /* POOL32Sxf_4~*(63) */
20464 { reserved_block , 0 , 0 , 32,
20465 0xfc00ffff, 0xc000813c, 0 , 0,
20466 0x0 }, /* POOL32Sxf_4~*(64) */
20467 { reserved_block , 0 , 0 , 32,
20468 0xfc00ffff, 0xc000833c, 0 , 0,
20469 0x0 }, /* POOL32Sxf_4~*(65) */
20470 { reserved_block , 0 , 0 , 32,
20471 0xfc00ffff, 0xc000853c, 0 , 0,
20472 0x0 }, /* POOL32Sxf_4~*(66) */
20473 { reserved_block , 0 , 0 , 32,
20474 0xfc00ffff, 0xc000873c, 0 , 0,
20475 0x0 }, /* POOL32Sxf_4~*(67) */
20476 { reserved_block , 0 , 0 , 32,
20477 0xfc00ffff, 0xc000893c, 0 , 0,
20478 0x0 }, /* POOL32Sxf_4~*(68) */
20479 { reserved_block , 0 , 0 , 32,
20480 0xfc00ffff, 0xc0008b3c, 0 , 0,
20481 0x0 }, /* POOL32Sxf_4~*(69) */
20482 { reserved_block , 0 , 0 , 32,
20483 0xfc00ffff, 0xc0008d3c, 0 , 0,
20484 0x0 }, /* POOL32Sxf_4~*(70) */
20485 { reserved_block , 0 , 0 , 32,
20486 0xfc00ffff, 0xc0008f3c, 0 , 0,
20487 0x0 }, /* POOL32Sxf_4~*(71) */
20488 { reserved_block , 0 , 0 , 32,
20489 0xfc00ffff, 0xc000913c, 0 , 0,
20490 0x0 }, /* POOL32Sxf_4~*(72) */
20491 { reserved_block , 0 , 0 , 32,
20492 0xfc00ffff, 0xc000933c, 0 , 0,
20493 0x0 }, /* POOL32Sxf_4~*(73) */
20494 { reserved_block , 0 , 0 , 32,
20495 0xfc00ffff, 0xc000953c, 0 , 0,
20496 0x0 }, /* POOL32Sxf_4~*(74) */
20497 { reserved_block , 0 , 0 , 32,
20498 0xfc00ffff, 0xc000973c, 0 , 0,
20499 0x0 }, /* POOL32Sxf_4~*(75) */
20500 { reserved_block , 0 , 0 , 32,
20501 0xfc00ffff, 0xc000993c, 0 , 0,
20502 0x0 }, /* POOL32Sxf_4~*(76) */
20503 { reserved_block , 0 , 0 , 32,
20504 0xfc00ffff, 0xc0009b3c, 0 , 0,
20505 0x0 }, /* POOL32Sxf_4~*(77) */
20506 { reserved_block , 0 , 0 , 32,
20507 0xfc00ffff, 0xc0009d3c, 0 , 0,
20508 0x0 }, /* POOL32Sxf_4~*(78) */
20509 { reserved_block , 0 , 0 , 32,
20510 0xfc00ffff, 0xc0009f3c, 0 , 0,
20511 0x0 }, /* POOL32Sxf_4~*(79) */
20512 { reserved_block , 0 , 0 , 32,
20513 0xfc00ffff, 0xc000a13c, 0 , 0,
20514 0x0 }, /* POOL32Sxf_4~*(80) */
20515 { reserved_block , 0 , 0 , 32,
20516 0xfc00ffff, 0xc000a33c, 0 , 0,
20517 0x0 }, /* POOL32Sxf_4~*(81) */
20518 { reserved_block , 0 , 0 , 32,
20519 0xfc00ffff, 0xc000a53c, 0 , 0,
20520 0x0 }, /* POOL32Sxf_4~*(82) */
20521 { reserved_block , 0 , 0 , 32,
20522 0xfc00ffff, 0xc000a73c, 0 , 0,
20523 0x0 }, /* POOL32Sxf_4~*(83) */
20524 { reserved_block , 0 , 0 , 32,
20525 0xfc00ffff, 0xc000a93c, 0 , 0,
20526 0x0 }, /* POOL32Sxf_4~*(84) */
20527 { reserved_block , 0 , 0 , 32,
20528 0xfc00ffff, 0xc000ab3c, 0 , 0,
20529 0x0 }, /* POOL32Sxf_4~*(85) */
20530 { reserved_block , 0 , 0 , 32,
20531 0xfc00ffff, 0xc000ad3c, 0 , 0,
20532 0x0 }, /* POOL32Sxf_4~*(86) */
20533 { reserved_block , 0 , 0 , 32,
20534 0xfc00ffff, 0xc000af3c, 0 , 0,
20535 0x0 }, /* POOL32Sxf_4~*(87) */
20536 { reserved_block , 0 , 0 , 32,
20537 0xfc00ffff, 0xc000b13c, 0 , 0,
20538 0x0 }, /* POOL32Sxf_4~*(88) */
20539 { reserved_block , 0 , 0 , 32,
20540 0xfc00ffff, 0xc000b33c, 0 , 0,
20541 0x0 }, /* POOL32Sxf_4~*(89) */
20542 { reserved_block , 0 , 0 , 32,
20543 0xfc00ffff, 0xc000b53c, 0 , 0,
20544 0x0 }, /* POOL32Sxf_4~*(90) */
20545 { reserved_block , 0 , 0 , 32,
20546 0xfc00ffff, 0xc000b73c, 0 , 0,
20547 0x0 }, /* POOL32Sxf_4~*(91) */
20548 { reserved_block , 0 , 0 , 32,
20549 0xfc00ffff, 0xc000b93c, 0 , 0,
20550 0x0 }, /* POOL32Sxf_4~*(92) */
20551 { reserved_block , 0 , 0 , 32,
20552 0xfc00ffff, 0xc000bb3c, 0 , 0,
20553 0x0 }, /* POOL32Sxf_4~*(93) */
20554 { reserved_block , 0 , 0 , 32,
20555 0xfc00ffff, 0xc000bd3c, 0 , 0,
20556 0x0 }, /* POOL32Sxf_4~*(94) */
20557 { reserved_block , 0 , 0 , 32,
20558 0xfc00ffff, 0xc000bf3c, 0 , 0,
20559 0x0 }, /* POOL32Sxf_4~*(95) */
20560 { reserved_block , 0 , 0 , 32,
20561 0xfc00ffff, 0xc000c13c, 0 , 0,
20562 0x0 }, /* POOL32Sxf_4~*(96) */
20563 { reserved_block , 0 , 0 , 32,
20564 0xfc00ffff, 0xc000c33c, 0 , 0,
20565 0x0 }, /* POOL32Sxf_4~*(97) */
20566 { reserved_block , 0 , 0 , 32,
20567 0xfc00ffff, 0xc000c53c, 0 , 0,
20568 0x0 }, /* POOL32Sxf_4~*(98) */
20569 { reserved_block , 0 , 0 , 32,
20570 0xfc00ffff, 0xc000c73c, 0 , 0,
20571 0x0 }, /* POOL32Sxf_4~*(99) */
20572 { reserved_block , 0 , 0 , 32,
20573 0xfc00ffff, 0xc000c93c, 0 , 0,
20574 0x0 }, /* POOL32Sxf_4~*(100) */
20575 { reserved_block , 0 , 0 , 32,
20576 0xfc00ffff, 0xc000cb3c, 0 , 0,
20577 0x0 }, /* POOL32Sxf_4~*(101) */
20578 { reserved_block , 0 , 0 , 32,
20579 0xfc00ffff, 0xc000cd3c, 0 , 0,
20580 0x0 }, /* POOL32Sxf_4~*(102) */
20581 { reserved_block , 0 , 0 , 32,
20582 0xfc00ffff, 0xc000cf3c, 0 , 0,
20583 0x0 }, /* POOL32Sxf_4~*(103) */
20584 { reserved_block , 0 , 0 , 32,
20585 0xfc00ffff, 0xc000d13c, 0 , 0,
20586 0x0 }, /* POOL32Sxf_4~*(104) */
20587 { reserved_block , 0 , 0 , 32,
20588 0xfc00ffff, 0xc000d33c, 0 , 0,
20589 0x0 }, /* POOL32Sxf_4~*(105) */
20590 { reserved_block , 0 , 0 , 32,
20591 0xfc00ffff, 0xc000d53c, 0 , 0,
20592 0x0 }, /* POOL32Sxf_4~*(106) */
20593 { reserved_block , 0 , 0 , 32,
20594 0xfc00ffff, 0xc000d73c, 0 , 0,
20595 0x0 }, /* POOL32Sxf_4~*(107) */
20596 { reserved_block , 0 , 0 , 32,
20597 0xfc00ffff, 0xc000d93c, 0 , 0,
20598 0x0 }, /* POOL32Sxf_4~*(108) */
20599 { reserved_block , 0 , 0 , 32,
20600 0xfc00ffff, 0xc000db3c, 0 , 0,
20601 0x0 }, /* POOL32Sxf_4~*(109) */
20602 { reserved_block , 0 , 0 , 32,
20603 0xfc00ffff, 0xc000dd3c, 0 , 0,
20604 0x0 }, /* POOL32Sxf_4~*(110) */
20605 { reserved_block , 0 , 0 , 32,
20606 0xfc00ffff, 0xc000df3c, 0 , 0,
20607 0x0 }, /* POOL32Sxf_4~*(111) */
20608 { reserved_block , 0 , 0 , 32,
20609 0xfc00ffff, 0xc000e13c, 0 , 0,
20610 0x0 }, /* POOL32Sxf_4~*(112) */
20611 { reserved_block , 0 , 0 , 32,
20612 0xfc00ffff, 0xc000e33c, 0 , 0,
20613 0x0 }, /* POOL32Sxf_4~*(113) */
20614 { reserved_block , 0 , 0 , 32,
20615 0xfc00ffff, 0xc000e53c, 0 , 0,
20616 0x0 }, /* POOL32Sxf_4~*(114) */
20617 { reserved_block , 0 , 0 , 32,
20618 0xfc00ffff, 0xc000e73c, 0 , 0,
20619 0x0 }, /* POOL32Sxf_4~*(115) */
20620 { reserved_block , 0 , 0 , 32,
20621 0xfc00ffff, 0xc000e93c, 0 , 0,
20622 0x0 }, /* POOL32Sxf_4~*(116) */
20623 { reserved_block , 0 , 0 , 32,
20624 0xfc00ffff, 0xc000eb3c, 0 , 0,
20625 0x0 }, /* POOL32Sxf_4~*(117) */
20626 { reserved_block , 0 , 0 , 32,
20627 0xfc00ffff, 0xc000ed3c, 0 , 0,
20628 0x0 }, /* POOL32Sxf_4~*(118) */
20629 { reserved_block , 0 , 0 , 32,
20630 0xfc00ffff, 0xc000ef3c, 0 , 0,
20631 0x0 }, /* POOL32Sxf_4~*(119) */
20632 { reserved_block , 0 , 0 , 32,
20633 0xfc00ffff, 0xc000f13c, 0 , 0,
20634 0x0 }, /* POOL32Sxf_4~*(120) */
20635 { reserved_block , 0 , 0 , 32,
20636 0xfc00ffff, 0xc000f33c, 0 , 0,
20637 0x0 }, /* POOL32Sxf_4~*(121) */
20638 { reserved_block , 0 , 0 , 32,
20639 0xfc00ffff, 0xc000f53c, 0 , 0,
20640 0x0 }, /* POOL32Sxf_4~*(122) */
20641 { reserved_block , 0 , 0 , 32,
20642 0xfc00ffff, 0xc000f73c, 0 , 0,
20643 0x0 }, /* POOL32Sxf_4~*(123) */
20644 { reserved_block , 0 , 0 , 32,
20645 0xfc00ffff, 0xc000f93c, 0 , 0,
20646 0x0 }, /* POOL32Sxf_4~*(124) */
20647 { reserved_block , 0 , 0 , 32,
20648 0xfc00ffff, 0xc000fb3c, 0 , 0,
20649 0x0 }, /* POOL32Sxf_4~*(125) */
20650 { reserved_block , 0 , 0 , 32,
20651 0xfc00ffff, 0xc000fd3c, 0 , 0,
20652 0x0 }, /* POOL32Sxf_4~*(126) */
20653 { reserved_block , 0 , 0 , 32,
20654 0xfc00ffff, 0xc000ff3c, 0 , 0,
20655 0x0 }, /* POOL32Sxf_4~*(127) */
20656 };
20657
20658
20659 static const Pool POOL32Sxf[8] = {
20660 { reserved_block , 0 , 0 , 32,
20661 0xfc0001ff, 0xc000003c, 0 , 0,
20662 0x0 }, /* POOL32Sxf~*(0) */
20663 { reserved_block , 0 , 0 , 32,
20664 0xfc0001ff, 0xc000007c, 0 , 0,
20665 0x0 }, /* POOL32Sxf~*(1) */
20666 { reserved_block , 0 , 0 , 32,
20667 0xfc0001ff, 0xc00000bc, 0 , 0,
20668 0x0 }, /* POOL32Sxf~*(2) */
20669 { reserved_block , 0 , 0 , 32,
20670 0xfc0001ff, 0xc00000fc, 0 , 0,
20671 0x0 }, /* POOL32Sxf~*(3) */
20672 { pool , POOL32Sxf_4 , 128 , 32,
20673 0xfc0001ff, 0xc000013c, 0 , 0,
20674 0x0 }, /* POOL32Sxf_4 */
20675 { reserved_block , 0 , 0 , 32,
20676 0xfc0001ff, 0xc000017c, 0 , 0,
20677 0x0 }, /* POOL32Sxf~*(5) */
20678 { reserved_block , 0 , 0 , 32,
20679 0xfc0001ff, 0xc00001bc, 0 , 0,
20680 0x0 }, /* POOL32Sxf~*(6) */
20681 { reserved_block , 0 , 0 , 32,
20682 0xfc0001ff, 0xc00001fc, 0 , 0,
20683 0x0 }, /* POOL32Sxf~*(7) */
20684 };
20685
20686
20687 static const Pool POOL32S_4[8] = {
20688 { instruction , 0 , 0 , 32,
20689 0xfc00003f, 0xc0000004, &EXTD , 0,
20690 MIPS64_ }, /* EXTD */
20691 { instruction , 0 , 0 , 32,
20692 0xfc00003f, 0xc000000c, &EXTD32 , 0,
20693 MIPS64_ }, /* EXTD32 */
20694 { reserved_block , 0 , 0 , 32,
20695 0xfc00003f, 0xc0000014, 0 , 0,
20696 0x0 }, /* POOL32S_4~*(2) */
20697 { reserved_block , 0 , 0 , 32,
20698 0xfc00003f, 0xc000001c, 0 , 0,
20699 0x0 }, /* POOL32S_4~*(3) */
20700 { reserved_block , 0 , 0 , 32,
20701 0xfc00003f, 0xc0000024, 0 , 0,
20702 0x0 }, /* POOL32S_4~*(4) */
20703 { reserved_block , 0 , 0 , 32,
20704 0xfc00003f, 0xc000002c, 0 , 0,
20705 0x0 }, /* POOL32S_4~*(5) */
20706 { reserved_block , 0 , 0 , 32,
20707 0xfc00003f, 0xc0000034, 0 , 0,
20708 0x0 }, /* POOL32S_4~*(6) */
20709 { pool , POOL32Sxf , 8 , 32,
20710 0xfc00003f, 0xc000003c, 0 , 0,
20711 0x0 }, /* POOL32Sxf */
20712 };
20713
20714
20715 static const Pool POOL32S[8] = {
20716 { pool , POOL32S_0 , 64 , 32,
20717 0xfc000007, 0xc0000000, 0 , 0,
20718 0x0 }, /* POOL32S_0 */
20719 { reserved_block , 0 , 0 , 32,
20720 0xfc000007, 0xc0000001, 0 , 0,
20721 0x0 }, /* POOL32S~*(1) */
20722 { reserved_block , 0 , 0 , 32,
20723 0xfc000007, 0xc0000002, 0 , 0,
20724 0x0 }, /* POOL32S~*(2) */
20725 { reserved_block , 0 , 0 , 32,
20726 0xfc000007, 0xc0000003, 0 , 0,
20727 0x0 }, /* POOL32S~*(3) */
20728 { pool , POOL32S_4 , 8 , 32,
20729 0xfc000007, 0xc0000004, 0 , 0,
20730 0x0 }, /* POOL32S_4 */
20731 { reserved_block , 0 , 0 , 32,
20732 0xfc000007, 0xc0000005, 0 , 0,
20733 0x0 }, /* POOL32S~*(5) */
20734 { reserved_block , 0 , 0 , 32,
20735 0xfc000007, 0xc0000006, 0 , 0,
20736 0x0 }, /* POOL32S~*(6) */
20737 { reserved_block , 0 , 0 , 32,
20738 0xfc000007, 0xc0000007, 0 , 0,
20739 0x0 }, /* POOL32S~*(7) */
20740 };
20741
20742
20743 static const Pool P_LUI[2] = {
20744 { instruction , 0 , 0 , 32,
20745 0xfc000002, 0xe0000000, &LUI , 0,
20746 0x0 }, /* LUI */
20747 { instruction , 0 , 0 , 32,
20748 0xfc000002, 0xe0000002, &ALUIPC , 0,
20749 0x0 }, /* ALUIPC */
20750 };
20751
20752
20753 static const Pool P_GP_LH[2] = {
20754 { instruction , 0 , 0 , 32,
20755 0xfc1c0001, 0x44100000, &LH_GP_ , 0,
20756 0x0 }, /* LH[GP] */
20757 { instruction , 0 , 0 , 32,
20758 0xfc1c0001, 0x44100001, &LHU_GP_ , 0,
20759 0x0 }, /* LHU[GP] */
20760 };
20761
20762
20763 static const Pool P_GP_SH[2] = {
20764 { instruction , 0 , 0 , 32,
20765 0xfc1c0001, 0x44140000, &SH_GP_ , 0,
20766 0x0 }, /* SH[GP] */
20767 { reserved_block , 0 , 0 , 32,
20768 0xfc1c0001, 0x44140001, 0 , 0,
20769 0x0 }, /* P.GP.SH~*(1) */
20770 };
20771
20772
20773 static const Pool P_GP_CP1[4] = {
20774 { instruction , 0 , 0 , 32,
20775 0xfc1c0003, 0x44180000, &LWC1_GP_ , 0,
20776 CP1_ }, /* LWC1[GP] */
20777 { instruction , 0 , 0 , 32,
20778 0xfc1c0003, 0x44180001, &SWC1_GP_ , 0,
20779 CP1_ }, /* SWC1[GP] */
20780 { instruction , 0 , 0 , 32,
20781 0xfc1c0003, 0x44180002, &LDC1_GP_ , 0,
20782 CP1_ }, /* LDC1[GP] */
20783 { instruction , 0 , 0 , 32,
20784 0xfc1c0003, 0x44180003, &SDC1_GP_ , 0,
20785 CP1_ }, /* SDC1[GP] */
20786 };
20787
20788
20789 static const Pool P_GP_M64[4] = {
20790 { instruction , 0 , 0 , 32,
20791 0xfc1c0003, 0x441c0000, &LWU_GP_ , 0,
20792 MIPS64_ }, /* LWU[GP] */
20793 { reserved_block , 0 , 0 , 32,
20794 0xfc1c0003, 0x441c0001, 0 , 0,
20795 0x0 }, /* P.GP.M64~*(1) */
20796 { reserved_block , 0 , 0 , 32,
20797 0xfc1c0003, 0x441c0002, 0 , 0,
20798 0x0 }, /* P.GP.M64~*(2) */
20799 { reserved_block , 0 , 0 , 32,
20800 0xfc1c0003, 0x441c0003, 0 , 0,
20801 0x0 }, /* P.GP.M64~*(3) */
20802 };
20803
20804
20805 static const Pool P_GP_BH[8] = {
20806 { instruction , 0 , 0 , 32,
20807 0xfc1c0000, 0x44000000, &LB_GP_ , 0,
20808 0x0 }, /* LB[GP] */
20809 { instruction , 0 , 0 , 32,
20810 0xfc1c0000, 0x44040000, &SB_GP_ , 0,
20811 0x0 }, /* SB[GP] */
20812 { instruction , 0 , 0 , 32,
20813 0xfc1c0000, 0x44080000, &LBU_GP_ , 0,
20814 0x0 }, /* LBU[GP] */
20815 { instruction , 0 , 0 , 32,
20816 0xfc1c0000, 0x440c0000, &ADDIU_GP_B_ , 0,
20817 0x0 }, /* ADDIU[GP.B] */
20818 { pool , P_GP_LH , 2 , 32,
20819 0xfc1c0000, 0x44100000, 0 , 0,
20820 0x0 }, /* P.GP.LH */
20821 { pool , P_GP_SH , 2 , 32,
20822 0xfc1c0000, 0x44140000, 0 , 0,
20823 0x0 }, /* P.GP.SH */
20824 { pool , P_GP_CP1 , 4 , 32,
20825 0xfc1c0000, 0x44180000, 0 , 0,
20826 0x0 }, /* P.GP.CP1 */
20827 { pool , P_GP_M64 , 4 , 32,
20828 0xfc1c0000, 0x441c0000, 0 , 0,
20829 0x0 }, /* P.GP.M64 */
20830 };
20831
20832
20833 static const Pool P_LS_U12[16] = {
20834 { instruction , 0 , 0 , 32,
20835 0xfc00f000, 0x84000000, &LB_U12_ , 0,
20836 0x0 }, /* LB[U12] */
20837 { instruction , 0 , 0 , 32,
20838 0xfc00f000, 0x84001000, &SB_U12_ , 0,
20839 0x0 }, /* SB[U12] */
20840 { instruction , 0 , 0 , 32,
20841 0xfc00f000, 0x84002000, &LBU_U12_ , 0,
20842 0x0 }, /* LBU[U12] */
20843 { instruction , 0 , 0 , 32,
20844 0xfc00f000, 0x84003000, &PREF_U12_ , 0,
20845 0x0 }, /* PREF[U12] */
20846 { instruction , 0 , 0 , 32,
20847 0xfc00f000, 0x84004000, &LH_U12_ , 0,
20848 0x0 }, /* LH[U12] */
20849 { instruction , 0 , 0 , 32,
20850 0xfc00f000, 0x84005000, &SH_U12_ , 0,
20851 0x0 }, /* SH[U12] */
20852 { instruction , 0 , 0 , 32,
20853 0xfc00f000, 0x84006000, &LHU_U12_ , 0,
20854 0x0 }, /* LHU[U12] */
20855 { instruction , 0 , 0 , 32,
20856 0xfc00f000, 0x84007000, &LWU_U12_ , 0,
20857 MIPS64_ }, /* LWU[U12] */
20858 { instruction , 0 , 0 , 32,
20859 0xfc00f000, 0x84008000, &LW_U12_ , 0,
20860 0x0 }, /* LW[U12] */
20861 { instruction , 0 , 0 , 32,
20862 0xfc00f000, 0x84009000, &SW_U12_ , 0,
20863 0x0 }, /* SW[U12] */
20864 { instruction , 0 , 0 , 32,
20865 0xfc00f000, 0x8400a000, &LWC1_U12_ , 0,
20866 CP1_ }, /* LWC1[U12] */
20867 { instruction , 0 , 0 , 32,
20868 0xfc00f000, 0x8400b000, &SWC1_U12_ , 0,
20869 CP1_ }, /* SWC1[U12] */
20870 { instruction , 0 , 0 , 32,
20871 0xfc00f000, 0x8400c000, &LD_U12_ , 0,
20872 MIPS64_ }, /* LD[U12] */
20873 { instruction , 0 , 0 , 32,
20874 0xfc00f000, 0x8400d000, &SD_U12_ , 0,
20875 MIPS64_ }, /* SD[U12] */
20876 { instruction , 0 , 0 , 32,
20877 0xfc00f000, 0x8400e000, &LDC1_U12_ , 0,
20878 CP1_ }, /* LDC1[U12] */
20879 { instruction , 0 , 0 , 32,
20880 0xfc00f000, 0x8400f000, &SDC1_U12_ , 0,
20881 CP1_ }, /* SDC1[U12] */
20882 };
20883
20884
20885 static const Pool P_PREF_S9_[2] = {
20886 { instruction , 0 , 0 , 32,
20887 0xffe07f00, 0xa7e01800, &SYNCI , 0,
20888 0x0 }, /* SYNCI */
20889 { instruction , 0 , 0 , 32,
20890 0xfc007f00, 0xa4001800, &PREF_S9_ , &PREF_S9__cond ,
20891 0x0 }, /* PREF[S9] */
20892 };
20893
20894
20895 static const Pool P_LS_S0[16] = {
20896 { instruction , 0 , 0 , 32,
20897 0xfc007f00, 0xa4000000, &LB_S9_ , 0,
20898 0x0 }, /* LB[S9] */
20899 { instruction , 0 , 0 , 32,
20900 0xfc007f00, 0xa4000800, &SB_S9_ , 0,
20901 0x0 }, /* SB[S9] */
20902 { instruction , 0 , 0 , 32,
20903 0xfc007f00, 0xa4001000, &LBU_S9_ , 0,
20904 0x0 }, /* LBU[S9] */
20905 { pool , P_PREF_S9_ , 2 , 32,
20906 0xfc007f00, 0xa4001800, 0 , 0,
20907 0x0 }, /* P.PREF[S9] */
20908 { instruction , 0 , 0 , 32,
20909 0xfc007f00, 0xa4002000, &LH_S9_ , 0,
20910 0x0 }, /* LH[S9] */
20911 { instruction , 0 , 0 , 32,
20912 0xfc007f00, 0xa4002800, &SH_S9_ , 0,
20913 0x0 }, /* SH[S9] */
20914 { instruction , 0 , 0 , 32,
20915 0xfc007f00, 0xa4003000, &LHU_S9_ , 0,
20916 0x0 }, /* LHU[S9] */
20917 { instruction , 0 , 0 , 32,
20918 0xfc007f00, 0xa4003800, &LWU_S9_ , 0,
20919 MIPS64_ }, /* LWU[S9] */
20920 { instruction , 0 , 0 , 32,
20921 0xfc007f00, 0xa4004000, &LW_S9_ , 0,
20922 0x0 }, /* LW[S9] */
20923 { instruction , 0 , 0 , 32,
20924 0xfc007f00, 0xa4004800, &SW_S9_ , 0,
20925 0x0 }, /* SW[S9] */
20926 { instruction , 0 , 0 , 32,
20927 0xfc007f00, 0xa4005000, &LWC1_S9_ , 0,
20928 CP1_ }, /* LWC1[S9] */
20929 { instruction , 0 , 0 , 32,
20930 0xfc007f00, 0xa4005800, &SWC1_S9_ , 0,
20931 CP1_ }, /* SWC1[S9] */
20932 { instruction , 0 , 0 , 32,
20933 0xfc007f00, 0xa4006000, &LD_S9_ , 0,
20934 MIPS64_ }, /* LD[S9] */
20935 { instruction , 0 , 0 , 32,
20936 0xfc007f00, 0xa4006800, &SD_S9_ , 0,
20937 MIPS64_ }, /* SD[S9] */
20938 { instruction , 0 , 0 , 32,
20939 0xfc007f00, 0xa4007000, &LDC1_S9_ , 0,
20940 CP1_ }, /* LDC1[S9] */
20941 { instruction , 0 , 0 , 32,
20942 0xfc007f00, 0xa4007800, &SDC1_S9_ , 0,
20943 CP1_ }, /* SDC1[S9] */
20944 };
20945
20946
20947 static const Pool ASET_ACLR[2] = {
20948 { instruction , 0 , 0 , 32,
20949 0xfe007f00, 0xa4001100, &ASET , 0,
20950 MCU_ }, /* ASET */
20951 { instruction , 0 , 0 , 32,
20952 0xfe007f00, 0xa6001100, &ACLR , 0,
20953 MCU_ }, /* ACLR */
20954 };
20955
20956
20957 static const Pool P_LL[4] = {
20958 { instruction , 0 , 0 , 32,
20959 0xfc007f03, 0xa4005100, &LL , 0,
20960 0x0 }, /* LL */
20961 { instruction , 0 , 0 , 32,
20962 0xfc007f03, 0xa4005101, &LLWP , 0,
20963 XNP_ }, /* LLWP */
20964 { reserved_block , 0 , 0 , 32,
20965 0xfc007f03, 0xa4005102, 0 , 0,
20966 0x0 }, /* P.LL~*(2) */
20967 { reserved_block , 0 , 0 , 32,
20968 0xfc007f03, 0xa4005103, 0 , 0,
20969 0x0 }, /* P.LL~*(3) */
20970 };
20971
20972
20973 static const Pool P_SC[4] = {
20974 { instruction , 0 , 0 , 32,
20975 0xfc007f03, 0xa4005900, &SC , 0,
20976 0x0 }, /* SC */
20977 { instruction , 0 , 0 , 32,
20978 0xfc007f03, 0xa4005901, &SCWP , 0,
20979 XNP_ }, /* SCWP */
20980 { reserved_block , 0 , 0 , 32,
20981 0xfc007f03, 0xa4005902, 0 , 0,
20982 0x0 }, /* P.SC~*(2) */
20983 { reserved_block , 0 , 0 , 32,
20984 0xfc007f03, 0xa4005903, 0 , 0,
20985 0x0 }, /* P.SC~*(3) */
20986 };
20987
20988
20989 static const Pool P_LLD[8] = {
20990 { instruction , 0 , 0 , 32,
20991 0xfc007f07, 0xa4007100, &LLD , 0,
20992 MIPS64_ }, /* LLD */
20993 { instruction , 0 , 0 , 32,
20994 0xfc007f07, 0xa4007101, &LLDP , 0,
20995 MIPS64_ }, /* LLDP */
20996 { reserved_block , 0 , 0 , 32,
20997 0xfc007f07, 0xa4007102, 0 , 0,
20998 0x0 }, /* P.LLD~*(2) */
20999 { reserved_block , 0 , 0 , 32,
21000 0xfc007f07, 0xa4007103, 0 , 0,
21001 0x0 }, /* P.LLD~*(3) */
21002 { reserved_block , 0 , 0 , 32,
21003 0xfc007f07, 0xa4007104, 0 , 0,
21004 0x0 }, /* P.LLD~*(4) */
21005 { reserved_block , 0 , 0 , 32,
21006 0xfc007f07, 0xa4007105, 0 , 0,
21007 0x0 }, /* P.LLD~*(5) */
21008 { reserved_block , 0 , 0 , 32,
21009 0xfc007f07, 0xa4007106, 0 , 0,
21010 0x0 }, /* P.LLD~*(6) */
21011 { reserved_block , 0 , 0 , 32,
21012 0xfc007f07, 0xa4007107, 0 , 0,
21013 0x0 }, /* P.LLD~*(7) */
21014 };
21015
21016
21017 static const Pool P_SCD[8] = {
21018 { instruction , 0 , 0 , 32,
21019 0xfc007f07, 0xa4007900, &SCD , 0,
21020 MIPS64_ }, /* SCD */
21021 { instruction , 0 , 0 , 32,
21022 0xfc007f07, 0xa4007901, &SCDP , 0,
21023 MIPS64_ }, /* SCDP */
21024 { reserved_block , 0 , 0 , 32,
21025 0xfc007f07, 0xa4007902, 0 , 0,
21026 0x0 }, /* P.SCD~*(2) */
21027 { reserved_block , 0 , 0 , 32,
21028 0xfc007f07, 0xa4007903, 0 , 0,
21029 0x0 }, /* P.SCD~*(3) */
21030 { reserved_block , 0 , 0 , 32,
21031 0xfc007f07, 0xa4007904, 0 , 0,
21032 0x0 }, /* P.SCD~*(4) */
21033 { reserved_block , 0 , 0 , 32,
21034 0xfc007f07, 0xa4007905, 0 , 0,
21035 0x0 }, /* P.SCD~*(5) */
21036 { reserved_block , 0 , 0 , 32,
21037 0xfc007f07, 0xa4007906, 0 , 0,
21038 0x0 }, /* P.SCD~*(6) */
21039 { reserved_block , 0 , 0 , 32,
21040 0xfc007f07, 0xa4007907, 0 , 0,
21041 0x0 }, /* P.SCD~*(7) */
21042 };
21043
21044
21045 static const Pool P_LS_S1[16] = {
21046 { reserved_block , 0 , 0 , 32,
21047 0xfc007f00, 0xa4000100, 0 , 0,
21048 0x0 }, /* P.LS.S1~*(0) */
21049 { reserved_block , 0 , 0 , 32,
21050 0xfc007f00, 0xa4000900, 0 , 0,
21051 0x0 }, /* P.LS.S1~*(1) */
21052 { pool , ASET_ACLR , 2 , 32,
21053 0xfc007f00, 0xa4001100, 0 , 0,
21054 0x0 }, /* ASET_ACLR */
21055 { reserved_block , 0 , 0 , 32,
21056 0xfc007f00, 0xa4001900, 0 , 0,
21057 0x0 }, /* P.LS.S1~*(3) */
21058 { instruction , 0 , 0 , 32,
21059 0xfc007f00, 0xa4002100, &UALH , 0,
21060 XMMS_ }, /* UALH */
21061 { instruction , 0 , 0 , 32,
21062 0xfc007f00, 0xa4002900, &UASH , 0,
21063 XMMS_ }, /* UASH */
21064 { reserved_block , 0 , 0 , 32,
21065 0xfc007f00, 0xa4003100, 0 , 0,
21066 0x0 }, /* P.LS.S1~*(6) */
21067 { instruction , 0 , 0 , 32,
21068 0xfc007f00, 0xa4003900, &CACHE , 0,
21069 CP0_ }, /* CACHE */
21070 { instruction , 0 , 0 , 32,
21071 0xfc007f00, 0xa4004100, &LWC2 , 0,
21072 CP2_ }, /* LWC2 */
21073 { instruction , 0 , 0 , 32,
21074 0xfc007f00, 0xa4004900, &SWC2 , 0,
21075 CP2_ }, /* SWC2 */
21076 { pool , P_LL , 4 , 32,
21077 0xfc007f00, 0xa4005100, 0 , 0,
21078 0x0 }, /* P.LL */
21079 { pool , P_SC , 4 , 32,
21080 0xfc007f00, 0xa4005900, 0 , 0,
21081 0x0 }, /* P.SC */
21082 { instruction , 0 , 0 , 32,
21083 0xfc007f00, 0xa4006100, &LDC2 , 0,
21084 CP2_ }, /* LDC2 */
21085 { instruction , 0 , 0 , 32,
21086 0xfc007f00, 0xa4006900, &SDC2 , 0,
21087 CP2_ }, /* SDC2 */
21088 { pool , P_LLD , 8 , 32,
21089 0xfc007f00, 0xa4007100, 0 , 0,
21090 0x0 }, /* P.LLD */
21091 { pool , P_SCD , 8 , 32,
21092 0xfc007f00, 0xa4007900, 0 , 0,
21093 0x0 }, /* P.SCD */
21094 };
21095
21096
21097 static const Pool P_PREFE[2] = {
21098 { instruction , 0 , 0 , 32,
21099 0xffe07f00, 0xa7e01a00, &SYNCIE , 0,
21100 CP0_ | EVA_ }, /* SYNCIE */
21101 { instruction , 0 , 0 , 32,
21102 0xfc007f00, 0xa4001a00, &PREFE , &PREFE_cond ,
21103 CP0_ | EVA_ }, /* PREFE */
21104 };
21105
21106
21107 static const Pool P_LLE[4] = {
21108 { instruction , 0 , 0 , 32,
21109 0xfc007f03, 0xa4005200, &LLE , 0,
21110 CP0_ | EVA_ }, /* LLE */
21111 { instruction , 0 , 0 , 32,
21112 0xfc007f03, 0xa4005201, &LLWPE , 0,
21113 CP0_ | EVA_ }, /* LLWPE */
21114 { reserved_block , 0 , 0 , 32,
21115 0xfc007f03, 0xa4005202, 0 , 0,
21116 0x0 }, /* P.LLE~*(2) */
21117 { reserved_block , 0 , 0 , 32,
21118 0xfc007f03, 0xa4005203, 0 , 0,
21119 0x0 }, /* P.LLE~*(3) */
21120 };
21121
21122
21123 static const Pool P_SCE[4] = {
21124 { instruction , 0 , 0 , 32,
21125 0xfc007f03, 0xa4005a00, &SCE , 0,
21126 CP0_ | EVA_ }, /* SCE */
21127 { instruction , 0 , 0 , 32,
21128 0xfc007f03, 0xa4005a01, &SCWPE , 0,
21129 CP0_ | EVA_ }, /* SCWPE */
21130 { reserved_block , 0 , 0 , 32,
21131 0xfc007f03, 0xa4005a02, 0 , 0,
21132 0x0 }, /* P.SCE~*(2) */
21133 { reserved_block , 0 , 0 , 32,
21134 0xfc007f03, 0xa4005a03, 0 , 0,
21135 0x0 }, /* P.SCE~*(3) */
21136 };
21137
21138
21139 static const Pool P_LS_E0[16] = {
21140 { instruction , 0 , 0 , 32,
21141 0xfc007f00, 0xa4000200, &LBE , 0,
21142 CP0_ | EVA_ }, /* LBE */
21143 { instruction , 0 , 0 , 32,
21144 0xfc007f00, 0xa4000a00, &SBE , 0,
21145 CP0_ | EVA_ }, /* SBE */
21146 { instruction , 0 , 0 , 32,
21147 0xfc007f00, 0xa4001200, &LBUE , 0,
21148 CP0_ | EVA_ }, /* LBUE */
21149 { pool , P_PREFE , 2 , 32,
21150 0xfc007f00, 0xa4001a00, 0 , 0,
21151 0x0 }, /* P.PREFE */
21152 { instruction , 0 , 0 , 32,
21153 0xfc007f00, 0xa4002200, &LHE , 0,
21154 CP0_ | EVA_ }, /* LHE */
21155 { instruction , 0 , 0 , 32,
21156 0xfc007f00, 0xa4002a00, &SHE , 0,
21157 CP0_ | EVA_ }, /* SHE */
21158 { instruction , 0 , 0 , 32,
21159 0xfc007f00, 0xa4003200, &LHUE , 0,
21160 CP0_ | EVA_ }, /* LHUE */
21161 { instruction , 0 , 0 , 32,
21162 0xfc007f00, 0xa4003a00, &CACHEE , 0,
21163 CP0_ | EVA_ }, /* CACHEE */
21164 { instruction , 0 , 0 , 32,
21165 0xfc007f00, 0xa4004200, &LWE , 0,
21166 CP0_ | EVA_ }, /* LWE */
21167 { instruction , 0 , 0 , 32,
21168 0xfc007f00, 0xa4004a00, &SWE , 0,
21169 CP0_ | EVA_ }, /* SWE */
21170 { pool , P_LLE , 4 , 32,
21171 0xfc007f00, 0xa4005200, 0 , 0,
21172 0x0 }, /* P.LLE */
21173 { pool , P_SCE , 4 , 32,
21174 0xfc007f00, 0xa4005a00, 0 , 0,
21175 0x0 }, /* P.SCE */
21176 { reserved_block , 0 , 0 , 32,
21177 0xfc007f00, 0xa4006200, 0 , 0,
21178 0x0 }, /* P.LS.E0~*(12) */
21179 { reserved_block , 0 , 0 , 32,
21180 0xfc007f00, 0xa4006a00, 0 , 0,
21181 0x0 }, /* P.LS.E0~*(13) */
21182 { reserved_block , 0 , 0 , 32,
21183 0xfc007f00, 0xa4007200, 0 , 0,
21184 0x0 }, /* P.LS.E0~*(14) */
21185 { reserved_block , 0 , 0 , 32,
21186 0xfc007f00, 0xa4007a00, 0 , 0,
21187 0x0 }, /* P.LS.E0~*(15) */
21188 };
21189
21190
21191 static const Pool P_LS_WM[2] = {
21192 { instruction , 0 , 0 , 32,
21193 0xfc000f00, 0xa4000400, &LWM , 0,
21194 XMMS_ }, /* LWM */
21195 { instruction , 0 , 0 , 32,
21196 0xfc000f00, 0xa4000c00, &SWM , 0,
21197 XMMS_ }, /* SWM */
21198 };
21199
21200
21201 static const Pool P_LS_UAWM[2] = {
21202 { instruction , 0 , 0 , 32,
21203 0xfc000f00, 0xa4000500, &UALWM , 0,
21204 XMMS_ }, /* UALWM */
21205 { instruction , 0 , 0 , 32,
21206 0xfc000f00, 0xa4000d00, &UASWM , 0,
21207 XMMS_ }, /* UASWM */
21208 };
21209
21210
21211 static const Pool P_LS_DM[2] = {
21212 { instruction , 0 , 0 , 32,
21213 0xfc000f00, 0xa4000600, &LDM , 0,
21214 MIPS64_ }, /* LDM */
21215 { instruction , 0 , 0 , 32,
21216 0xfc000f00, 0xa4000e00, &SDM , 0,
21217 MIPS64_ }, /* SDM */
21218 };
21219
21220
21221 static const Pool P_LS_UADM[2] = {
21222 { instruction , 0 , 0 , 32,
21223 0xfc000f00, 0xa4000700, &UALDM , 0,
21224 MIPS64_ }, /* UALDM */
21225 { instruction , 0 , 0 , 32,
21226 0xfc000f00, 0xa4000f00, &UASDM , 0,
21227 MIPS64_ }, /* UASDM */
21228 };
21229
21230
21231 static const Pool P_LS_S9[8] = {
21232 { pool , P_LS_S0 , 16 , 32,
21233 0xfc000700, 0xa4000000, 0 , 0,
21234 0x0 }, /* P.LS.S0 */
21235 { pool , P_LS_S1 , 16 , 32,
21236 0xfc000700, 0xa4000100, 0 , 0,
21237 0x0 }, /* P.LS.S1 */
21238 { pool , P_LS_E0 , 16 , 32,
21239 0xfc000700, 0xa4000200, 0 , 0,
21240 0x0 }, /* P.LS.E0 */
21241 { reserved_block , 0 , 0 , 32,
21242 0xfc000700, 0xa4000300, 0 , 0,
21243 0x0 }, /* P.LS.S9~*(3) */
21244 { pool , P_LS_WM , 2 , 32,
21245 0xfc000700, 0xa4000400, 0 , 0,
21246 0x0 }, /* P.LS.WM */
21247 { pool , P_LS_UAWM , 2 , 32,
21248 0xfc000700, 0xa4000500, 0 , 0,
21249 0x0 }, /* P.LS.UAWM */
21250 { pool , P_LS_DM , 2 , 32,
21251 0xfc000700, 0xa4000600, 0 , 0,
21252 0x0 }, /* P.LS.DM */
21253 { pool , P_LS_UADM , 2 , 32,
21254 0xfc000700, 0xa4000700, 0 , 0,
21255 0x0 }, /* P.LS.UADM */
21256 };
21257
21258
21259 static const Pool P_BAL[2] = {
21260 { branch_instruction , 0 , 0 , 32,
21261 0xfe000000, 0x28000000, &BC_32_ , 0,
21262 0x0 }, /* BC[32] */
21263 { call_instruction , 0 , 0 , 32,
21264 0xfe000000, 0x2a000000, &BALC_32_ , 0,
21265 0x0 }, /* BALC[32] */
21266 };
21267
21268
21269 static const Pool P_BALRSC[2] = {
21270 { branch_instruction , 0 , 0 , 32,
21271 0xffe0f000, 0x48008000, &BRSC , 0,
21272 0x0 }, /* BRSC */
21273 { call_instruction , 0 , 0 , 32,
21274 0xfc00f000, 0x48008000, &BALRSC , &BALRSC_cond ,
21275 0x0 }, /* BALRSC */
21276 };
21277
21278
21279 static const Pool P_J[16] = {
21280 { call_instruction , 0 , 0 , 32,
21281 0xfc00f000, 0x48000000, &JALRC_32_ , 0,
21282 0x0 }, /* JALRC[32] */
21283 { call_instruction , 0 , 0 , 32,
21284 0xfc00f000, 0x48001000, &JALRC_HB , 0,
21285 0x0 }, /* JALRC.HB */
21286 { reserved_block , 0 , 0 , 32,
21287 0xfc00f000, 0x48002000, 0 , 0,
21288 0x0 }, /* P.J~*(2) */
21289 { reserved_block , 0 , 0 , 32,
21290 0xfc00f000, 0x48003000, 0 , 0,
21291 0x0 }, /* P.J~*(3) */
21292 { reserved_block , 0 , 0 , 32,
21293 0xfc00f000, 0x48004000, 0 , 0,
21294 0x0 }, /* P.J~*(4) */
21295 { reserved_block , 0 , 0 , 32,
21296 0xfc00f000, 0x48005000, 0 , 0,
21297 0x0 }, /* P.J~*(5) */
21298 { reserved_block , 0 , 0 , 32,
21299 0xfc00f000, 0x48006000, 0 , 0,
21300 0x0 }, /* P.J~*(6) */
21301 { reserved_block , 0 , 0 , 32,
21302 0xfc00f000, 0x48007000, 0 , 0,
21303 0x0 }, /* P.J~*(7) */
21304 { pool , P_BALRSC , 2 , 32,
21305 0xfc00f000, 0x48008000, 0 , 0,
21306 0x0 }, /* P.BALRSC */
21307 { reserved_block , 0 , 0 , 32,
21308 0xfc00f000, 0x48009000, 0 , 0,
21309 0x0 }, /* P.J~*(9) */
21310 { reserved_block , 0 , 0 , 32,
21311 0xfc00f000, 0x4800a000, 0 , 0,
21312 0x0 }, /* P.J~*(10) */
21313 { reserved_block , 0 , 0 , 32,
21314 0xfc00f000, 0x4800b000, 0 , 0,
21315 0x0 }, /* P.J~*(11) */
21316 { reserved_block , 0 , 0 , 32,
21317 0xfc00f000, 0x4800c000, 0 , 0,
21318 0x0 }, /* P.J~*(12) */
21319 { reserved_block , 0 , 0 , 32,
21320 0xfc00f000, 0x4800d000, 0 , 0,
21321 0x0 }, /* P.J~*(13) */
21322 { reserved_block , 0 , 0 , 32,
21323 0xfc00f000, 0x4800e000, 0 , 0,
21324 0x0 }, /* P.J~*(14) */
21325 { reserved_block , 0 , 0 , 32,
21326 0xfc00f000, 0x4800f000, 0 , 0,
21327 0x0 }, /* P.J~*(15) */
21328 };
21329
21330
21331 static const Pool P_BR3A[32] = {
21332 { branch_instruction , 0 , 0 , 32,
21333 0xfc1fc000, 0x88004000, &BC1EQZC , 0,
21334 CP1_ }, /* BC1EQZC */
21335 { branch_instruction , 0 , 0 , 32,
21336 0xfc1fc000, 0x88014000, &BC1NEZC , 0,
21337 CP1_ }, /* BC1NEZC */
21338 { branch_instruction , 0 , 0 , 32,
21339 0xfc1fc000, 0x88024000, &BC2EQZC , 0,
21340 CP2_ }, /* BC2EQZC */
21341 { branch_instruction , 0 , 0 , 32,
21342 0xfc1fc000, 0x88034000, &BC2NEZC , 0,
21343 CP2_ }, /* BC2NEZC */
21344 { branch_instruction , 0 , 0 , 32,
21345 0xfc1fc000, 0x88044000, &BPOSGE32C , 0,
21346 DSP_ }, /* BPOSGE32C */
21347 { reserved_block , 0 , 0 , 32,
21348 0xfc1fc000, 0x88054000, 0 , 0,
21349 0x0 }, /* P.BR3A~*(5) */
21350 { reserved_block , 0 , 0 , 32,
21351 0xfc1fc000, 0x88064000, 0 , 0,
21352 0x0 }, /* P.BR3A~*(6) */
21353 { reserved_block , 0 , 0 , 32,
21354 0xfc1fc000, 0x88074000, 0 , 0,
21355 0x0 }, /* P.BR3A~*(7) */
21356 { reserved_block , 0 , 0 , 32,
21357 0xfc1fc000, 0x88084000, 0 , 0,
21358 0x0 }, /* P.BR3A~*(8) */
21359 { reserved_block , 0 , 0 , 32,
21360 0xfc1fc000, 0x88094000, 0 , 0,
21361 0x0 }, /* P.BR3A~*(9) */
21362 { reserved_block , 0 , 0 , 32,
21363 0xfc1fc000, 0x880a4000, 0 , 0,
21364 0x0 }, /* P.BR3A~*(10) */
21365 { reserved_block , 0 , 0 , 32,
21366 0xfc1fc000, 0x880b4000, 0 , 0,
21367 0x0 }, /* P.BR3A~*(11) */
21368 { reserved_block , 0 , 0 , 32,
21369 0xfc1fc000, 0x880c4000, 0 , 0,
21370 0x0 }, /* P.BR3A~*(12) */
21371 { reserved_block , 0 , 0 , 32,
21372 0xfc1fc000, 0x880d4000, 0 , 0,
21373 0x0 }, /* P.BR3A~*(13) */
21374 { reserved_block , 0 , 0 , 32,
21375 0xfc1fc000, 0x880e4000, 0 , 0,
21376 0x0 }, /* P.BR3A~*(14) */
21377 { reserved_block , 0 , 0 , 32,
21378 0xfc1fc000, 0x880f4000, 0 , 0,
21379 0x0 }, /* P.BR3A~*(15) */
21380 { reserved_block , 0 , 0 , 32,
21381 0xfc1fc000, 0x88104000, 0 , 0,
21382 0x0 }, /* P.BR3A~*(16) */
21383 { reserved_block , 0 , 0 , 32,
21384 0xfc1fc000, 0x88114000, 0 , 0,
21385 0x0 }, /* P.BR3A~*(17) */
21386 { reserved_block , 0 , 0 , 32,
21387 0xfc1fc000, 0x88124000, 0 , 0,
21388 0x0 }, /* P.BR3A~*(18) */
21389 { reserved_block , 0 , 0 , 32,
21390 0xfc1fc000, 0x88134000, 0 , 0,
21391 0x0 }, /* P.BR3A~*(19) */
21392 { reserved_block , 0 , 0 , 32,
21393 0xfc1fc000, 0x88144000, 0 , 0,
21394 0x0 }, /* P.BR3A~*(20) */
21395 { reserved_block , 0 , 0 , 32,
21396 0xfc1fc000, 0x88154000, 0 , 0,
21397 0x0 }, /* P.BR3A~*(21) */
21398 { reserved_block , 0 , 0 , 32,
21399 0xfc1fc000, 0x88164000, 0 , 0,
21400 0x0 }, /* P.BR3A~*(22) */
21401 { reserved_block , 0 , 0 , 32,
21402 0xfc1fc000, 0x88174000, 0 , 0,
21403 0x0 }, /* P.BR3A~*(23) */
21404 { reserved_block , 0 , 0 , 32,
21405 0xfc1fc000, 0x88184000, 0 , 0,
21406 0x0 }, /* P.BR3A~*(24) */
21407 { reserved_block , 0 , 0 , 32,
21408 0xfc1fc000, 0x88194000, 0 , 0,
21409 0x0 }, /* P.BR3A~*(25) */
21410 { reserved_block , 0 , 0 , 32,
21411 0xfc1fc000, 0x881a4000, 0 , 0,
21412 0x0 }, /* P.BR3A~*(26) */
21413 { reserved_block , 0 , 0 , 32,
21414 0xfc1fc000, 0x881b4000, 0 , 0,
21415 0x0 }, /* P.BR3A~*(27) */
21416 { reserved_block , 0 , 0 , 32,
21417 0xfc1fc000, 0x881c4000, 0 , 0,
21418 0x0 }, /* P.BR3A~*(28) */
21419 { reserved_block , 0 , 0 , 32,
21420 0xfc1fc000, 0x881d4000, 0 , 0,
21421 0x0 }, /* P.BR3A~*(29) */
21422 { reserved_block , 0 , 0 , 32,
21423 0xfc1fc000, 0x881e4000, 0 , 0,
21424 0x0 }, /* P.BR3A~*(30) */
21425 { reserved_block , 0 , 0 , 32,
21426 0xfc1fc000, 0x881f4000, 0 , 0,
21427 0x0 }, /* P.BR3A~*(31) */
21428 };
21429
21430
21431 static const Pool P_BR1[4] = {
21432 { branch_instruction , 0 , 0 , 32,
21433 0xfc00c000, 0x88000000, &BEQC_32_ , 0,
21434 0x0 }, /* BEQC[32] */
21435 { pool , P_BR3A , 32 , 32,
21436 0xfc00c000, 0x88004000, 0 , 0,
21437 0x0 }, /* P.BR3A */
21438 { branch_instruction , 0 , 0 , 32,
21439 0xfc00c000, 0x88008000, &BGEC , 0,
21440 0x0 }, /* BGEC */
21441 { branch_instruction , 0 , 0 , 32,
21442 0xfc00c000, 0x8800c000, &BGEUC , 0,
21443 0x0 }, /* BGEUC */
21444 };
21445
21446
21447 static const Pool P_BR2[4] = {
21448 { branch_instruction , 0 , 0 , 32,
21449 0xfc00c000, 0xa8000000, &BNEC_32_ , 0,
21450 0x0 }, /* BNEC[32] */
21451 { reserved_block , 0 , 0 , 32,
21452 0xfc00c000, 0xa8004000, 0 , 0,
21453 0x0 }, /* P.BR2~*(1) */
21454 { branch_instruction , 0 , 0 , 32,
21455 0xfc00c000, 0xa8008000, &BLTC , 0,
21456 0x0 }, /* BLTC */
21457 { branch_instruction , 0 , 0 , 32,
21458 0xfc00c000, 0xa800c000, &BLTUC , 0,
21459 0x0 }, /* BLTUC */
21460 };
21461
21462
21463 static const Pool P_BRI[8] = {
21464 { branch_instruction , 0 , 0 , 32,
21465 0xfc1c0000, 0xc8000000, &BEQIC , 0,
21466 0x0 }, /* BEQIC */
21467 { branch_instruction , 0 , 0 , 32,
21468 0xfc1c0000, 0xc8040000, &BBEQZC , 0,
21469 XMMS_ }, /* BBEQZC */
21470 { branch_instruction , 0 , 0 , 32,
21471 0xfc1c0000, 0xc8080000, &BGEIC , 0,
21472 0x0 }, /* BGEIC */
21473 { branch_instruction , 0 , 0 , 32,
21474 0xfc1c0000, 0xc80c0000, &BGEIUC , 0,
21475 0x0 }, /* BGEIUC */
21476 { branch_instruction , 0 , 0 , 32,
21477 0xfc1c0000, 0xc8100000, &BNEIC , 0,
21478 0x0 }, /* BNEIC */
21479 { branch_instruction , 0 , 0 , 32,
21480 0xfc1c0000, 0xc8140000, &BBNEZC , 0,
21481 XMMS_ }, /* BBNEZC */
21482 { branch_instruction , 0 , 0 , 32,
21483 0xfc1c0000, 0xc8180000, &BLTIC , 0,
21484 0x0 }, /* BLTIC */
21485 { branch_instruction , 0 , 0 , 32,
21486 0xfc1c0000, 0xc81c0000, &BLTIUC , 0,
21487 0x0 }, /* BLTIUC */
21488 };
21489
21490
21491 static const Pool P32[32] = {
21492 { pool , P_ADDIU , 2 , 32,
21493 0xfc000000, 0x00000000, 0 , 0,
21494 0x0 }, /* P.ADDIU */
21495 { pool , P32A , 8 , 32,
21496 0xfc000000, 0x20000000, 0 , 0,
21497 0x0 }, /* P32A */
21498 { pool , P_GP_W , 4 , 32,
21499 0xfc000000, 0x40000000, 0 , 0,
21500 0x0 }, /* P.GP.W */
21501 { pool , POOL48I , 32 , 48,
21502 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21503 0x0 }, /* POOL48I */
21504 { pool , P_U12 , 16 , 32,
21505 0xfc000000, 0x80000000, 0 , 0,
21506 0x0 }, /* P.U12 */
21507 { pool , POOL32F , 8 , 32,
21508 0xfc000000, 0xa0000000, 0 , 0,
21509 CP1_ }, /* POOL32F */
21510 { pool , POOL32S , 8 , 32,
21511 0xfc000000, 0xc0000000, 0 , 0,
21512 0x0 }, /* POOL32S */
21513 { pool , P_LUI , 2 , 32,
21514 0xfc000000, 0xe0000000, 0 , 0,
21515 0x0 }, /* P.LUI */
21516 { instruction , 0 , 0 , 32,
21517 0xfc000000, 0x04000000, &ADDIUPC_32_ , 0,
21518 0x0 }, /* ADDIUPC[32] */
21519 { reserved_block , 0 , 0 , 32,
21520 0xfc000000, 0x24000000, 0 , 0,
21521 0x0 }, /* P32~*(5) */
21522 { pool , P_GP_BH , 8 , 32,
21523 0xfc000000, 0x44000000, 0 , 0,
21524 0x0 }, /* P.GP.BH */
21525 { reserved_block , 0 , 0 , 32,
21526 0xfc000000, 0x64000000, 0 , 0,
21527 0x0 }, /* P32~*(13) */
21528 { pool , P_LS_U12 , 16 , 32,
21529 0xfc000000, 0x84000000, 0 , 0,
21530 0x0 }, /* P.LS.U12 */
21531 { pool , P_LS_S9 , 8 , 32,
21532 0xfc000000, 0xa4000000, 0 , 0,
21533 0x0 }, /* P.LS.S9 */
21534 { reserved_block , 0 , 0 , 32,
21535 0xfc000000, 0xc4000000, 0 , 0,
21536 0x0 }, /* P32~*(25) */
21537 { reserved_block , 0 , 0 , 32,
21538 0xfc000000, 0xe4000000, 0 , 0,
21539 0x0 }, /* P32~*(29) */
21540 { call_instruction , 0 , 0 , 32,
21541 0xfc000000, 0x08000000, &MOVE_BALC , 0,
21542 XMMS_ }, /* MOVE.BALC */
21543 { pool , P_BAL , 2 , 32,
21544 0xfc000000, 0x28000000, 0 , 0,
21545 0x0 }, /* P.BAL */
21546 { pool , P_J , 16 , 32,
21547 0xfc000000, 0x48000000, 0 , 0,
21548 0x0 }, /* P.J */
21549 { reserved_block , 0 , 0 , 32,
21550 0xfc000000, 0x68000000, 0 , 0,
21551 0x0 }, /* P32~*(14) */
21552 { pool , P_BR1 , 4 , 32,
21553 0xfc000000, 0x88000000, 0 , 0,
21554 0x0 }, /* P.BR1 */
21555 { pool , P_BR2 , 4 , 32,
21556 0xfc000000, 0xa8000000, 0 , 0,
21557 0x0 }, /* P.BR2 */
21558 { pool , P_BRI , 8 , 32,
21559 0xfc000000, 0xc8000000, 0 , 0,
21560 0x0 }, /* P.BRI */
21561 { reserved_block , 0 , 0 , 32,
21562 0xfc000000, 0xe8000000, 0 , 0,
21563 0x0 }, /* P32~*(30) */
21564 { reserved_block , 0 , 0 , 32,
21565 0xfc000000, 0x0c000000, 0 , 0,
21566 0x0 }, /* P32~*(3) */
21567 { reserved_block , 0 , 0 , 32,
21568 0xfc000000, 0x2c000000, 0 , 0,
21569 0x0 }, /* P32~*(7) */
21570 { reserved_block , 0 , 0 , 32,
21571 0xfc000000, 0x4c000000, 0 , 0,
21572 0x0 }, /* P32~*(11) */
21573 { reserved_block , 0 , 0 , 32,
21574 0xfc000000, 0x6c000000, 0 , 0,
21575 0x0 }, /* P32~*(15) */
21576 { reserved_block , 0 , 0 , 32,
21577 0xfc000000, 0x8c000000, 0 , 0,
21578 0x0 }, /* P32~*(19) */
21579 { reserved_block , 0 , 0 , 32,
21580 0xfc000000, 0xac000000, 0 , 0,
21581 0x0 }, /* P32~*(23) */
21582 { reserved_block , 0 , 0 , 32,
21583 0xfc000000, 0xcc000000, 0 , 0,
21584 0x0 }, /* P32~*(27) */
21585 { reserved_block , 0 , 0 , 32,
21586 0xfc000000, 0xec000000, 0 , 0,
21587 0x0 }, /* P32~*(31) */
21588 };
21589
21590
21591 static const Pool P16_SYSCALL[2] = {
21592 { instruction , 0 , 0 , 16,
21593 0xfffc , 0x1008 , &SYSCALL_16_ , 0,
21594 0x0 }, /* SYSCALL[16] */
21595 { instruction , 0 , 0 , 16,
21596 0xfffc , 0x100c , &HYPCALL_16_ , 0,
21597 CP0_ | VZ_ }, /* HYPCALL[16] */
21598 };
21599
21600
21601 static const Pool P16_RI[4] = {
21602 { reserved_block , 0 , 0 , 16,
21603 0xfff8 , 0x1000 , 0 , 0,
21604 0x0 }, /* P16.RI~*(0) */
21605 { pool , P16_SYSCALL , 2 , 16,
21606 0xfff8 , 0x1008 , 0 , 0,
21607 0x0 }, /* P16.SYSCALL */
21608 { instruction , 0 , 0 , 16,
21609 0xfff8 , 0x1010 , &BREAK_16_ , 0,
21610 0x0 }, /* BREAK[16] */
21611 { instruction , 0 , 0 , 16,
21612 0xfff8 , 0x1018 , &SDBBP_16_ , 0,
21613 EJTAG_ }, /* SDBBP[16] */
21614 };
21615
21616
21617 static const Pool P16_MV[2] = {
21618 { pool , P16_RI , 4 , 16,
21619 0xffe0 , 0x1000 , 0 , 0,
21620 0x0 }, /* P16.RI */
21621 { instruction , 0 , 0 , 16,
21622 0xfc00 , 0x1000 , &MOVE , &MOVE_cond ,
21623 0x0 }, /* MOVE */
21624 };
21625
21626
21627 static const Pool P16_SHIFT[2] = {
21628 { instruction , 0 , 0 , 16,
21629 0xfc08 , 0x3000 , &SLL_16_ , 0,
21630 0x0 }, /* SLL[16] */
21631 { instruction , 0 , 0 , 16,
21632 0xfc08 , 0x3008 , &SRL_16_ , 0,
21633 0x0 }, /* SRL[16] */
21634 };
21635
21636
21637 static const Pool POOL16C_00[4] = {
21638 { instruction , 0 , 0 , 16,
21639 0xfc0f , 0x5000 , &NOT_16_ , 0,
21640 0x0 }, /* NOT[16] */
21641 { instruction , 0 , 0 , 16,
21642 0xfc0f , 0x5004 , &XOR_16_ , 0,
21643 0x0 }, /* XOR[16] */
21644 { instruction , 0 , 0 , 16,
21645 0xfc0f , 0x5008 , &AND_16_ , 0,
21646 0x0 }, /* AND[16] */
21647 { instruction , 0 , 0 , 16,
21648 0xfc0f , 0x500c , &OR_16_ , 0,
21649 0x0 }, /* OR[16] */
21650 };
21651
21652
21653 static const Pool POOL16C_0[2] = {
21654 { pool , POOL16C_00 , 4 , 16,
21655 0xfc03 , 0x5000 , 0 , 0,
21656 0x0 }, /* POOL16C_00 */
21657 { reserved_block , 0 , 0 , 16,
21658 0xfc03 , 0x5002 , 0 , 0,
21659 0x0 }, /* POOL16C_0~*(1) */
21660 };
21661
21662
21663 static const Pool P16C[2] = {
21664 { pool , POOL16C_0 , 2 , 16,
21665 0xfc01 , 0x5000 , 0 , 0,
21666 0x0 }, /* POOL16C_0 */
21667 { instruction , 0 , 0 , 16,
21668 0xfc01 , 0x5001 , &LWXS_16_ , 0,
21669 0x0 }, /* LWXS[16] */
21670 };
21671
21672
21673 static const Pool P16_A1[2] = {
21674 { reserved_block , 0 , 0 , 16,
21675 0xfc40 , 0x7000 , 0 , 0,
21676 0x0 }, /* P16.A1~*(0) */
21677 { instruction , 0 , 0 , 16,
21678 0xfc40 , 0x7040 , &ADDIU_R1_SP_ , 0,
21679 0x0 }, /* ADDIU[R1.SP] */
21680 };
21681
21682
21683 static const Pool P_ADDIU_RS5_[2] = {
21684 { instruction , 0 , 0 , 16,
21685 0xffe8 , 0x9008 , &NOP_16_ , 0,
21686 0x0 }, /* NOP[16] */
21687 { instruction , 0 , 0 , 16,
21688 0xfc08 , 0x9008 , &ADDIU_RS5_ , &ADDIU_RS5__cond ,
21689 0x0 }, /* ADDIU[RS5] */
21690 };
21691
21692
21693 static const Pool P16_A2[2] = {
21694 { instruction , 0 , 0 , 16,
21695 0xfc08 , 0x9000 , &ADDIU_R2_ , 0,
21696 0x0 }, /* ADDIU[R2] */
21697 { pool , P_ADDIU_RS5_ , 2 , 16,
21698 0xfc08 , 0x9008 , 0 , 0,
21699 0x0 }, /* P.ADDIU[RS5] */
21700 };
21701
21702
21703 static const Pool P16_ADDU[2] = {
21704 { instruction , 0 , 0 , 16,
21705 0xfc01 , 0xb000 , &ADDU_16_ , 0,
21706 0x0 }, /* ADDU[16] */
21707 { instruction , 0 , 0 , 16,
21708 0xfc01 , 0xb001 , &SUBU_16_ , 0,
21709 0x0 }, /* SUBU[16] */
21710 };
21711
21712
21713 static const Pool P16_JRC[2] = {
21714 { branch_instruction , 0 , 0 , 16,
21715 0xfc1f , 0xd800 , &JRC , 0,
21716 0x0 }, /* JRC */
21717 { call_instruction , 0 , 0 , 16,
21718 0xfc1f , 0xd810 , &JALRC_16_ , 0,
21719 0x0 }, /* JALRC[16] */
21720 };
21721
21722
21723 static const Pool P16_BR1[2] = {
21724 { branch_instruction , 0 , 0 , 16,
21725 0xfc00 , 0xd800 , &BEQC_16_ , &BEQC_16__cond ,
21726 XMMS_ }, /* BEQC[16] */
21727 { branch_instruction , 0 , 0 , 16,
21728 0xfc00 , 0xd800 , &BNEC_16_ , &BNEC_16__cond ,
21729 XMMS_ }, /* BNEC[16] */
21730 };
21731
21732
21733 static const Pool P16_BR[2] = {
21734 { pool , P16_JRC , 2 , 16,
21735 0xfc0f , 0xd800 , 0 , 0,
21736 0x0 }, /* P16.JRC */
21737 { pool , P16_BR1 , 2 , 16,
21738 0xfc00 , 0xd800 , 0 , &P16_BR1_cond ,
21739 0x0 }, /* P16.BR1 */
21740 };
21741
21742
21743 static const Pool P16_SR[2] = {
21744 { instruction , 0 , 0 , 16,
21745 0xfd00 , 0x1c00 , &SAVE_16_ , 0,
21746 0x0 }, /* SAVE[16] */
21747 { return_instruction , 0 , 0 , 16,
21748 0xfd00 , 0x1d00 , &RESTORE_JRC_16_ , 0,
21749 0x0 }, /* RESTORE.JRC[16] */
21750 };
21751
21752
21753 static const Pool P16_4X4[4] = {
21754 { instruction , 0 , 0 , 16,
21755 0xfd08 , 0x3c00 , &ADDU_4X4_ , 0,
21756 XMMS_ }, /* ADDU[4X4] */
21757 { instruction , 0 , 0 , 16,
21758 0xfd08 , 0x3c08 , &MUL_4X4_ , 0,
21759 XMMS_ }, /* MUL[4X4] */
21760 { reserved_block , 0 , 0 , 16,
21761 0xfd08 , 0x3d00 , 0 , 0,
21762 0x0 }, /* P16.4X4~*(2) */
21763 { reserved_block , 0 , 0 , 16,
21764 0xfd08 , 0x3d08 , 0 , 0,
21765 0x0 }, /* P16.4X4~*(3) */
21766 };
21767
21768
21769 static const Pool P16_LB[4] = {
21770 { instruction , 0 , 0 , 16,
21771 0xfc0c , 0x5c00 , &LB_16_ , 0,
21772 0x0 }, /* LB[16] */
21773 { instruction , 0 , 0 , 16,
21774 0xfc0c , 0x5c04 , &SB_16_ , 0,
21775 0x0 }, /* SB[16] */
21776 { instruction , 0 , 0 , 16,
21777 0xfc0c , 0x5c08 , &LBU_16_ , 0,
21778 0x0 }, /* LBU[16] */
21779 { reserved_block , 0 , 0 , 16,
21780 0xfc0c , 0x5c0c , 0 , 0,
21781 0x0 }, /* P16.LB~*(3) */
21782 };
21783
21784
21785 static const Pool P16_LH[4] = {
21786 { instruction , 0 , 0 , 16,
21787 0xfc09 , 0x7c00 , &LH_16_ , 0,
21788 0x0 }, /* LH[16] */
21789 { instruction , 0 , 0 , 16,
21790 0xfc09 , 0x7c01 , &SH_16_ , 0,
21791 0x0 }, /* SH[16] */
21792 { instruction , 0 , 0 , 16,
21793 0xfc09 , 0x7c08 , &LHU_16_ , 0,
21794 0x0 }, /* LHU[16] */
21795 { reserved_block , 0 , 0 , 16,
21796 0xfc09 , 0x7c09 , 0 , 0,
21797 0x0 }, /* P16.LH~*(3) */
21798 };
21799
21800
21801 static const Pool P16[32] = {
21802 { pool , P16_MV , 2 , 16,
21803 0xfc00 , 0x1000 , 0 , 0,
21804 0x0 }, /* P16.MV */
21805 { pool , P16_SHIFT , 2 , 16,
21806 0xfc00 , 0x3000 , 0 , 0,
21807 0x0 }, /* P16.SHIFT */
21808 { pool , P16C , 2 , 16,
21809 0xfc00 , 0x5000 , 0 , 0,
21810 0x0 }, /* P16C */
21811 { pool , P16_A1 , 2 , 16,
21812 0xfc00 , 0x7000 , 0 , 0,
21813 0x0 }, /* P16.A1 */
21814 { pool , P16_A2 , 2 , 16,
21815 0xfc00 , 0x9000 , 0 , 0,
21816 0x0 }, /* P16.A2 */
21817 { pool , P16_ADDU , 2 , 16,
21818 0xfc00 , 0xb000 , 0 , 0,
21819 0x0 }, /* P16.ADDU */
21820 { instruction , 0 , 0 , 16,
21821 0xfc00 , 0xd000 , &LI_16_ , 0,
21822 0x0 }, /* LI[16] */
21823 { instruction , 0 , 0 , 16,
21824 0xfc00 , 0xf000 , &ANDI_16_ , 0,
21825 0x0 }, /* ANDI[16] */
21826 { instruction , 0 , 0 , 16,
21827 0xfc00 , 0x1400 , &LW_16_ , 0,
21828 0x0 }, /* LW[16] */
21829 { instruction , 0 , 0 , 16,
21830 0xfc00 , 0x3400 , &LW_SP_ , 0,
21831 0x0 }, /* LW[SP] */
21832 { instruction , 0 , 0 , 16,
21833 0xfc00 , 0x5400 , &LW_GP16_ , 0,
21834 0x0 }, /* LW[GP16] */
21835 { instruction , 0 , 0 , 16,
21836 0xfc00 , 0x7400 , &LW_4X4_ , 0,
21837 XMMS_ }, /* LW[4X4] */
21838 { instruction , 0 , 0 , 16,
21839 0xfc00 , 0x9400 , &SW_16_ , 0,
21840 0x0 }, /* SW[16] */
21841 { instruction , 0 , 0 , 16,
21842 0xfc00 , 0xb400 , &SW_SP_ , 0,
21843 0x0 }, /* SW[SP] */
21844 { instruction , 0 , 0 , 16,
21845 0xfc00 , 0xd400 , &SW_GP16_ , 0,
21846 0x0 }, /* SW[GP16] */
21847 { instruction , 0 , 0 , 16,
21848 0xfc00 , 0xf400 , &SW_4X4_ , 0,
21849 XMMS_ }, /* SW[4X4] */
21850 { branch_instruction , 0 , 0 , 16,
21851 0xfc00 , 0x1800 , &BC_16_ , 0,
21852 0x0 }, /* BC[16] */
21853 { call_instruction , 0 , 0 , 16,
21854 0xfc00 , 0x3800 , &BALC_16_ , 0,
21855 0x0 }, /* BALC[16] */
21856 { reserved_block , 0 , 0 , 16,
21857 0xfc00 , 0x5800 , 0 , 0,
21858 0x0 }, /* P16~*(10) */
21859 { reserved_block , 0 , 0 , 16,
21860 0xfc00 , 0x7800 , 0 , 0,
21861 0x0 }, /* P16~*(14) */
21862 { branch_instruction , 0 , 0 , 16,
21863 0xfc00 , 0x9800 , &BEQZC_16_ , 0,
21864 0x0 }, /* BEQZC[16] */
21865 { branch_instruction , 0 , 0 , 16,
21866 0xfc00 , 0xb800 , &BNEZC_16_ , 0,
21867 0x0 }, /* BNEZC[16] */
21868 { pool , P16_BR , 2 , 16,
21869 0xfc00 , 0xd800 , 0 , 0,
21870 0x0 }, /* P16.BR */
21871 { reserved_block , 0 , 0 , 16,
21872 0xfc00 , 0xf800 , 0 , 0,
21873 0x0 }, /* P16~*(30) */
21874 { pool , P16_SR , 2 , 16,
21875 0xfc00 , 0x1c00 , 0 , 0,
21876 0x0 }, /* P16.SR */
21877 { pool , P16_4X4 , 4 , 16,
21878 0xfc00 , 0x3c00 , 0 , 0,
21879 0x0 }, /* P16.4X4 */
21880 { pool , P16_LB , 4 , 16,
21881 0xfc00 , 0x5c00 , 0 , 0,
21882 0x0 }, /* P16.LB */
21883 { pool , P16_LH , 4 , 16,
21884 0xfc00 , 0x7c00 , 0 , 0,
21885 0x0 }, /* P16.LH */
21886 { reserved_block , 0 , 0 , 16,
21887 0xfc00 , 0x9c00 , 0 , 0,
21888 0x0 }, /* P16~*(19) */
21889 { instruction , 0 , 0 , 16,
21890 0xfc00 , 0xbc00 , &MOVEP , 0,
21891 XMMS_ }, /* MOVEP */
21892 { reserved_block , 0 , 0 , 16,
21893 0xfc00 , 0xdc00 , 0 , 0,
21894 0x0 }, /* P16~*(27) */
21895 { instruction , 0 , 0 , 16,
21896 0xfc00 , 0xfc00 , &MOVEP_REV_ , 0,
21897 XMMS_ }, /* MOVEP[REV] */
21898 };
21899
21900
21901 static const Pool MAJOR[2] = {
21902 { pool , P32 , 32 , 32,
21903 0x10000000, 0x00000000, 0 , 0,
21904 0x0 }, /* P32 */
21905 { pool , P16 , 32 , 16,
21906 0x1000 , 0x1000 , 0 , 0,
21907 0x0 }, /* P16 */
21908 };
21909
21910 static bool nanomips_dis(const uint16_t *data, char **buf, Dis_info *info)
21911 {
21912 TABLE_ENTRY_TYPE type;
21913
21914 /* Handle runtime errors. */
21915 if (unlikely(sigsetjmp(info->buf, 0) != 0)) {
21916 return false;
21917 }
21918 return Disassemble(data, buf, &type, MAJOR, ARRAY_SIZE(MAJOR), info) >= 0;
21919 }
21920
21921 static bool read_u16(uint16_t *ret, bfd_vma memaddr,
21922 struct disassemble_info *info)
21923 {
21924 int status = (*info->read_memory_func)(memaddr, (bfd_byte *)ret, 2, info);
21925 if (status != 0) {
21926 (*info->memory_error_func)(status, memaddr, info);
21927 return false;
21928 }
21929
21930 if ((info->endian == BFD_ENDIAN_BIG) != HOST_BIG_ENDIAN) {
21931 bswap16s(ret);
21932 }
21933 return true;
21934 }
21935
21936 int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
21937 {
21938 int length;
21939 uint16_t words[3] = { };
21940 g_autofree char *buf = NULL;
21941
21942 info->bytes_per_chunk = 2;
21943 info->display_endian = info->endian;
21944 info->insn_info_valid = 1;
21945 info->branch_delay_insns = 0;
21946 info->data_size = 0;
21947 info->insn_type = dis_nonbranch;
21948 info->target = 0;
21949 info->target2 = 0;
21950
21951 Dis_info disassm_info;
21952 disassm_info.m_pc = memaddr;
21953 disassm_info.fprintf_func = info->fprintf_func;
21954 disassm_info.stream = info->stream;
21955
21956 if (!read_u16(&words[0], memaddr, info)) {
21957 return -1;
21958 }
21959 length = 2;
21960
21961 /* Handle 32-bit opcodes. */
21962 if ((words[0] & 0x1000) == 0) {
21963 if (!read_u16(&words[1], memaddr + 2, info)) {
21964 return -1;
21965 }
21966 length = 4;
21967
21968 /* Handle 48-bit opcodes. */
21969 if ((words[0] >> 10) == 0x18) {
21970 if (!read_u16(&words[1], memaddr + 4, info)) {
21971 return -1;
21972 }
21973 length = 6;
21974 }
21975 }
21976
21977 for (int i = 0; i < ARRAY_SIZE(words); i++) {
21978 if (i * 2 < length) {
21979 (*info->fprintf_func)(info->stream, "%04x ", words[i]);
21980 } else {
21981 (*info->fprintf_func)(info->stream, " ");
21982 }
21983 }
21984
21985 if (nanomips_dis(words, &buf, &disassm_info)) {
21986 (*info->fprintf_func) (info->stream, "%s", buf);
21987 }
21988
21989 return length;
21990 }
armbru's QEMU hackery