]> git.proxmox.com Git - mirror_qemu.git/blob - disas/nanomips.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'pull-maintainer-may24-160524-2' of https://gitlab.com/stsquad/qemu into...
[mirror_qemu.git] / disas / nanomips.c
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 struct Dis_info {
40 img_address m_pc;
41 fprintf_function fprintf_func;
42 FILE *stream;
43 sigjmp_buf buf;
44 } Dis_info;
45
46 #define IMGASSERTONCE(test)
47
48
49 static char * G_GNUC_PRINTF(1, 2) img_format(const char *format, ...)
50 {
51 char *buffer;
52 va_list args;
53 va_start(args, format);
54 buffer = g_strdup_vprintf(format, args);
55 va_end(args);
56 return buffer;
57 }
58
59
60 static char *to_string(img_address a)
61 {
62 return g_strdup_printf("0x%" PRIx64, a);
63 }
64
65
66 static uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
67 {
68 return (data << (64 - (bit_size + bit_offset))) >> (64 - bit_size);
69 }
70
71
72 static int64 sign_extend(int64 data, int msb)
73 {
74 uint64 shift = 63 - msb;
75 return (data << shift) >> shift;
76 }
77
78
79 static uint64 renumber_registers(uint64 index, uint64 *register_list,
80 size_t register_list_size, Dis_info *info)
81 {
82 if (index < register_list_size) {
83 return register_list[index];
84 }
85
86 info->fprintf_func(info->stream, "Invalid register mapping index %" PRIu64
87 ", size of list = %zu", index, register_list_size);
88 siglongjmp(info->buf, 1);
89 }
90
91
92 /*
93 * decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
94 *
95 * Map a 4-bit code to the 5-bit register space according to this pattern:
96 *
97 * 1 0
98 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
99 * | | | | | | | | | | | | | | | |
100 * | | | | | | | | | | | | | | | |
101 * | | | | | | | | | | | └---------------┐
102 * | | | | | | | | | | └---------------┐ |
103 * | | | | | | | | | └---------------┐ | |
104 * | | | | | | | | └---------------┐ | | |
105 * | | | | | | | | | | | | | | | |
106 * | | | | | | | | | | | | | | | |
107 * 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
108 * 3 2 1 0
109 *
110 * Used in handling following instructions:
111 *
112 * - ADDU[4X4]
113 * - LW[4X4]
114 * - MOVEP[REV]
115 * - MUL[4X4]
116 * - SW[4X4]
117 */
118 static uint64 decode_gpr_gpr4(uint64 d, Dis_info *info)
119 {
120 static uint64 register_list[] = { 8, 9, 10, 11, 4, 5, 6, 7,
121 16, 17, 18, 19, 20, 21, 22, 23 };
122 return renumber_registers(d, register_list,
123 sizeof(register_list) / sizeof(register_list[0]), info);
124 }
125
126
127 /*
128 * decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
129 *
130 * Map a 4-bit code to the 5-bit register space according to this pattern:
131 *
132 * 1 0
133 * 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
134 * | | | | | | | | | | | | | | | |
135 * | | | | | | | | | | | | └---------------------┐
136 * | | | | | | | | | | | └---------------┐ |
137 * | | | | | | | | | | └---------------┐ | |
138 * | | | | | | | | | └---------------┐ | | |
139 * | | | | | | | | └---------------┐ | | | |
140 * | | | | | | | | | | | | | | | |
141 * | | | | | | | | | | | | | | | |
142 * 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
143 * 3 2 1 0
144 *
145 * This pattern is the same one used for 'gpr4' gpr encoding type, except for
146 * the input value 3, that is mapped to the output value 0 instead of 11.
147 *
148 * Used in handling following instructions:
149 *
150 * - MOVE.BALC
151 * - MOVEP
152 * - SW[4X4]
153 */
154 static uint64 decode_gpr_gpr4_zero(uint64 d, Dis_info *info)
155 {
156 static uint64 register_list[] = { 8, 9, 10, 0, 4, 5, 6, 7,
157 16, 17, 18, 19, 20, 21, 22, 23 };
158 return renumber_registers(d, register_list,
159 sizeof(register_list) / sizeof(register_list[0]), info);
160 }
161
162
163 /*
164 * decode_gpr_gpr3() - decoder for 'gpr3' gpr encoding type
165 *
166 * Map a 3-bit code to the 5-bit register space according to this pattern:
167 *
168 * 7 6 5 4 3 2 1 0
169 * | | | | | | | |
170 * | | | | | | | |
171 * | | | └-----------------------┐
172 * | | └-----------------------┐ |
173 * | └-----------------------┐ | |
174 * └-----------------------┐ | | |
175 * | | | | | | | |
176 * ┌-------┘ | | | | | | |
177 * | ┌-------┘ | | | | | |
178 * | | ┌-------┘ | | | | |
179 * | | | ┌-------┘ | | | |
180 * | | | | | | | |
181 * 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
182 * 3 2 1 0
183 *
184 * Used in handling following instructions:
185 *
186 * - ADDIU[R1.SP]
187 * - ADDIU[R2]
188 * - ADDU[16]
189 * - AND[16]
190 * - ANDI[16]
191 * - BEQC[16]
192 * - BEQZC[16]
193 * - BNEC[16]
194 * - BNEZC[16]
195 * - LB[16]
196 * - LBU[16]
197 * - LH[16]
198 * - LHU[16]
199 * - LI[16]
200 * - LW[16]
201 * - LW[GP16]
202 * - LWXS[16]
203 * - NOT[16]
204 * - OR[16]
205 * - SB[16]
206 * - SH[16]
207 * - SLL[16]
208 * - SRL[16]
209 * - SUBU[16]
210 * - SW[16]
211 * - XOR[16]
212 */
213 static uint64 decode_gpr_gpr3(uint64 d, Dis_info *info)
214 {
215 static uint64 register_list[] = { 16, 17, 18, 19, 4, 5, 6, 7 };
216 return renumber_registers(d, register_list,
217 sizeof(register_list) / sizeof(register_list[0]), info);
218 }
219
220
221 /*
222 * decode_gpr_gpr3_src_store() - decoder for 'gpr3.src.store' gpr encoding
223 * type
224 *
225 * Map a 3-bit code to the 5-bit register space according to this pattern:
226 *
227 * 7 6 5 4 3 2 1 0
228 * | | | | | | | |
229 * | | | | | | | └-----------------------┐
230 * | | | └-----------------------┐ |
231 * | | └-----------------------┐ | |
232 * | └-----------------------┐ | | |
233 * └-----------------------┐ | | | |
234 * | | | | | | | |
235 * ┌-------┘ | | | | | | |
236 * | ┌-------┘ | | | | | |
237 * | | ┌-------┘ | | | | |
238 * | | | | | | | |
239 * | | | | | | | |
240 * 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
241 * 3 2 1 0
242 *
243 * This pattern is the same one used for 'gpr3' gpr encoding type, except for
244 * the input value 0, that is mapped to the output value 0 instead of 16.
245 *
246 * Used in handling following instructions:
247 *
248 * - SB[16]
249 * - SH[16]
250 * - SW[16]
251 * - SW[GP16]
252 */
253 static uint64 decode_gpr_gpr3_src_store(uint64 d, Dis_info *info)
254 {
255 static uint64 register_list[] = { 0, 17, 18, 19, 4, 5, 6, 7 };
256 return renumber_registers(d, register_list,
257 sizeof(register_list) / sizeof(register_list[0]), info);
258 }
259
260
261 /*
262 * decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
263 *
264 * Map a 2-bit code to the 5-bit register space according to this pattern:
265 *
266 * 3 2 1 0
267 * | | | |
268 * | | | |
269 * | | | └-------------------┐
270 * | | └-------------------┐ |
271 * | └-------------------┐ | |
272 * └-------------------┐ | | |
273 * | | | |
274 * | | | |
275 * 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
276 * 3 2 1 0
277 *
278 * Used in handling following instructions:
279 *
280 * - MOVEP
281 * - MOVEP[REV]
282 */
283 static uint64 decode_gpr_gpr2_reg1(uint64 d, Dis_info *info)
284 {
285 static uint64 register_list[] = { 4, 5, 6, 7 };
286 return renumber_registers(d, register_list,
287 sizeof(register_list) / sizeof(register_list[0]), info);
288 }
289
290
291 /*
292 * decode_gpr_gpr2_reg2() - decoder for 'gpr2.reg2' gpr encoding type
293 *
294 * Map a 2-bit code to the 5-bit register space according to this pattern:
295 *
296 * 3 2 1 0
297 * | | | |
298 * | | | |
299 * | | | └-----------------┐
300 * | | └-----------------┐ |
301 * | └-----------------┐ | |
302 * └-----------------┐ | | |
303 * | | | |
304 * | | | |
305 * 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
306 * 3 2 1 0
307 *
308 * Used in handling following instructions:
309 *
310 * - MOVEP
311 * - MOVEP[REV]
312 */
313 static uint64 decode_gpr_gpr2_reg2(uint64 d, Dis_info *info)
314 {
315 static uint64 register_list[] = { 5, 6, 7, 8 };
316 return renumber_registers(d, register_list,
317 sizeof(register_list) / sizeof(register_list[0]), info);
318 }
319
320
321 /*
322 * decode_gpr_gpr1() - decoder for 'gpr1' gpr encoding type
323 *
324 * Map a 1-bit code to the 5-bit register space according to this pattern:
325 *
326 * 1 0
327 * | |
328 * | |
329 * | └---------------------┐
330 * └---------------------┐ |
331 * | |
332 * | |
333 * | |
334 * | |
335 * 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
336 * 3 2 1 0
337 *
338 * Used in handling following instruction:
339 *
340 * - MOVE.BALC
341 */
342 static uint64 decode_gpr_gpr1(uint64 d, Dis_info *info)
343 {
344 static uint64 register_list[] = { 4, 5 };
345 return renumber_registers(d, register_list,
346 sizeof(register_list) / sizeof(register_list[0]), info);
347 }
348
349
350 static int64 neg_copy(uint64 d)
351 {
352 return 0ll - d;
353 }
354
355
356 static uint64 encode_count3_from_count(uint64 d)
357 {
358 IMGASSERTONCE(d < 8);
359 return d == 0ull ? 8ull : d;
360 }
361
362
363 static uint64 encode_shift3_from_shift(uint64 d)
364 {
365 IMGASSERTONCE(d < 8);
366 return d == 0ull ? 8ull : d;
367 }
368
369
370 /* special value for load literal */
371 static int64 encode_eu_from_s_li16(uint64 d)
372 {
373 IMGASSERTONCE(d < 128);
374 return d == 127 ? -1 : (int64)d;
375 }
376
377
378 static uint64 encode_msbd_from_size(uint64 d)
379 {
380 IMGASSERTONCE(d < 32);
381 return d + 1;
382 }
383
384
385 static uint64 encode_eu_from_u_andi16(uint64 d)
386 {
387 IMGASSERTONCE(d < 16);
388 if (d == 12) {
389 return 0x00ffull;
390 }
391 if (d == 13) {
392 return 0xffffull;
393 }
394 return d;
395 }
396
397
398 /* save16 / restore16 ???? */
399 static uint64 encode_rt1_from_rt(uint64 d)
400 {
401 return d ? 31 : 30;
402 }
403
404
405 static const char *GPR(uint64 reg, Dis_info *info)
406 {
407 static const char *gpr_reg[32] = {
408 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
409 "a4", "a5", "a6", "a7", "r12", "r13", "r14", "r15",
410 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
411 "r24", "r25", "k0", "k1", "gp", "sp", "fp", "ra"
412 };
413
414 if (reg < 32) {
415 return gpr_reg[reg];
416 }
417
418 info->fprintf_func(info->stream, "Invalid GPR register index %" PRIu64,
419 reg);
420 siglongjmp(info->buf, 1);
421 }
422
423
424 static char *save_restore_list(uint64 rt, uint64 count, uint64 gp,
425 Dis_info *info)
426 {
427 char *reg_list[34];
428 reg_list[0] = (char *)"";
429
430 assert(count <= 32);
431 for (uint64 counter = 0; counter != count; counter++) {
432 bool use_gp = gp && (counter == count - 1);
433 uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
434 /* glib usage below requires casting away const */
435 reg_list[counter + 1] = (char *)GPR(this_rt, info);
436 }
437 reg_list[count + 1] = NULL;
438
439 return g_strjoinv(",", reg_list);
440 }
441
442
443 static const char *FPR(uint64 reg, Dis_info *info)
444 {
445 static const char *fpr_reg[32] = {
446 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
447 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
448 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
449 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
450 };
451
452 if (reg < 32) {
453 return fpr_reg[reg];
454 }
455
456 info->fprintf_func(info->stream, "Invalid FPR register index %" PRIu64,
457 reg);
458 siglongjmp(info->buf, 1);
459 }
460
461
462 static const char *AC(uint64 reg, Dis_info *info)
463 {
464 static const char *ac_reg[4] = {
465 "ac0", "ac1", "ac2", "ac3"
466 };
467
468 if (reg < 4) {
469 return ac_reg[reg];
470 }
471
472 info->fprintf_func(info->stream, "Invalid AC register index %" PRIu64,
473 reg);
474 siglongjmp(info->buf, 1);
475 }
476
477
478 static char *ADDRESS(uint64 value, int instruction_size, Dis_info *info)
479 {
480 /* token for string replace */
481 img_address address = info->m_pc + value + instruction_size;
482 /* symbol replacement */
483 return to_string(address);
484 }
485
486
487 static uint64 extract_op_code_value(const uint16 *data, int size)
488 {
489 switch (size) {
490 case 16:
491 return data[0];
492 case 32:
493 return ((uint64)data[0] << 16) | data[1];
494 case 48:
495 return ((uint64)data[0] << 32) | ((uint64)data[1] << 16) | data[2];
496 default:
497 return data[0];
498 }
499 }
500
501
502 static uint64 extract_code_18_to_0(uint64 instruction)
503 {
504 uint64 value = 0;
505 value |= extract_bits(instruction, 0, 19);
506 return value;
507 }
508
509
510 static uint64 extract_shift3_2_1_0(uint64 instruction)
511 {
512 uint64 value = 0;
513 value |= extract_bits(instruction, 0, 3);
514 return value;
515 }
516
517
518 static uint64 extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
519 {
520 uint64 value = 0;
521 value |= extract_bits(instruction, 3, 9) << 3;
522 return value;
523 }
524
525
526 static uint64 extract_count_3_2_1_0(uint64 instruction)
527 {
528 uint64 value = 0;
529 value |= extract_bits(instruction, 0, 4);
530 return value;
531 }
532
533
534 static uint64 extract_rtz3_9_8_7(uint64 instruction)
535 {
536 uint64 value = 0;
537 value |= extract_bits(instruction, 7, 3);
538 return value;
539 }
540
541
542 static uint64 extract_u_17_to_1__s1(uint64 instruction)
543 {
544 uint64 value = 0;
545 value |= extract_bits(instruction, 1, 17) << 1;
546 return value;
547 }
548
549
550 static int64 extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
551 {
552 int64 value = 0;
553 value |= extract_bits(instruction, 11, 10);
554 value = sign_extend(value, 9);
555 return value;
556 }
557
558
559 static int64 extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
560 {
561 int64 value = 0;
562 value |= extract_bits(instruction, 0, 1) << 11;
563 value |= extract_bits(instruction, 1, 10) << 1;
564 value = sign_extend(value, 11);
565 return value;
566 }
567
568
569 static uint64 extract_u_10(uint64 instruction)
570 {
571 uint64 value = 0;
572 value |= extract_bits(instruction, 10, 1);
573 return value;
574 }
575
576
577 static uint64 extract_rtz4_27_26_25_23_22_21(uint64 instruction)
578 {
579 uint64 value = 0;
580 value |= extract_bits(instruction, 21, 3);
581 value |= extract_bits(instruction, 25, 1) << 3;
582 return value;
583 }
584
585
586 static uint64 extract_sa_15_14_13_12_11(uint64 instruction)
587 {
588 uint64 value = 0;
589 value |= extract_bits(instruction, 11, 5);
590 return value;
591 }
592
593
594 static uint64 extract_shift_4_3_2_1_0(uint64 instruction)
595 {
596 uint64 value = 0;
597 value |= extract_bits(instruction, 0, 5);
598 return value;
599 }
600
601
602 static uint64 extract_shiftx_10_9_8_7__s1(uint64 instruction)
603 {
604 uint64 value = 0;
605 value |= extract_bits(instruction, 7, 4) << 1;
606 return value;
607 }
608
609
610 static uint64 extract_hint_25_24_23_22_21(uint64 instruction)
611 {
612 uint64 value = 0;
613 value |= extract_bits(instruction, 21, 5);
614 return value;
615 }
616
617
618 static uint64 extract_count3_14_13_12(uint64 instruction)
619 {
620 uint64 value = 0;
621 value |= extract_bits(instruction, 12, 3);
622 return value;
623 }
624
625
626 static int64 extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
627 {
628 int64 value = 0;
629 value |= extract_bits(instruction, 0, 1) << 31;
630 value |= extract_bits(instruction, 2, 10) << 21;
631 value |= extract_bits(instruction, 12, 9) << 12;
632 value = sign_extend(value, 31);
633 return value;
634 }
635
636
637 static int64 extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
638 {
639 int64 value = 0;
640 value |= extract_bits(instruction, 0, 1) << 7;
641 value |= extract_bits(instruction, 1, 6) << 1;
642 value = sign_extend(value, 7);
643 return value;
644 }
645
646
647 static uint64 extract_u2_10_9(uint64 instruction)
648 {
649 uint64 value = 0;
650 value |= extract_bits(instruction, 9, 2);
651 return value;
652 }
653
654
655 static uint64 extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
656 {
657 uint64 value = 0;
658 value |= extract_bits(instruction, 16, 10);
659 return value;
660 }
661
662
663 static uint64 extract_rs_20_19_18_17_16(uint64 instruction)
664 {
665 uint64 value = 0;
666 value |= extract_bits(instruction, 16, 5);
667 return value;
668 }
669
670
671 static uint64 extract_u_2_1__s1(uint64 instruction)
672 {
673 uint64 value = 0;
674 value |= extract_bits(instruction, 1, 2) << 1;
675 return value;
676 }
677
678
679 static uint64 extract_stripe_6(uint64 instruction)
680 {
681 uint64 value = 0;
682 value |= extract_bits(instruction, 6, 1);
683 return value;
684 }
685
686
687 static uint64 extract_ac_15_14(uint64 instruction)
688 {
689 uint64 value = 0;
690 value |= extract_bits(instruction, 14, 2);
691 return value;
692 }
693
694
695 static uint64 extract_shift_20_19_18_17_16(uint64 instruction)
696 {
697 uint64 value = 0;
698 value |= extract_bits(instruction, 16, 5);
699 return value;
700 }
701
702
703 static uint64 extract_rdl_25_24(uint64 instruction)
704 {
705 uint64 value = 0;
706 value |= extract_bits(instruction, 24, 1);
707 return value;
708 }
709
710
711 static int64 extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
712 {
713 int64 value = 0;
714 value |= extract_bits(instruction, 0, 1) << 10;
715 value |= extract_bits(instruction, 1, 9) << 1;
716 value = sign_extend(value, 10);
717 return value;
718 }
719
720
721 static uint64 extract_eu_6_5_4_3_2_1_0(uint64 instruction)
722 {
723 uint64 value = 0;
724 value |= extract_bits(instruction, 0, 7);
725 return value;
726 }
727
728
729 static uint64 extract_shift_5_4_3_2_1_0(uint64 instruction)
730 {
731 uint64 value = 0;
732 value |= extract_bits(instruction, 0, 6);
733 return value;
734 }
735
736
737 static uint64 extract_count_19_18_17_16(uint64 instruction)
738 {
739 uint64 value = 0;
740 value |= extract_bits(instruction, 16, 4);
741 return value;
742 }
743
744
745 static uint64 extract_code_2_1_0(uint64 instruction)
746 {
747 uint64 value = 0;
748 value |= extract_bits(instruction, 0, 3);
749 return value;
750 }
751
752
753 static uint64 extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
754 {
755 uint64 value = 0;
756 value |= extract_bits(instruction, 0, 12);
757 return value;
758 }
759
760
761 static uint64 extract_rs_4_3_2_1_0(uint64 instruction)
762 {
763 uint64 value = 0;
764 value |= extract_bits(instruction, 0, 5);
765 return value;
766 }
767
768
769 static uint64 extract_u_20_to_3__s3(uint64 instruction)
770 {
771 uint64 value = 0;
772 value |= extract_bits(instruction, 3, 18) << 3;
773 return value;
774 }
775
776
777 static uint64 extract_u_3_2_1_0__s2(uint64 instruction)
778 {
779 uint64 value = 0;
780 value |= extract_bits(instruction, 0, 4) << 2;
781 return value;
782 }
783
784
785 static uint64 extract_cofun_25_24_23(uint64 instruction)
786 {
787 uint64 value = 0;
788 value |= extract_bits(instruction, 3, 23);
789 return value;
790 }
791
792
793 static uint64 extract_u_2_1_0__s2(uint64 instruction)
794 {
795 uint64 value = 0;
796 value |= extract_bits(instruction, 0, 3) << 2;
797 return value;
798 }
799
800
801 static uint64 extract_rd3_3_2_1(uint64 instruction)
802 {
803 uint64 value = 0;
804 value |= extract_bits(instruction, 1, 3);
805 return value;
806 }
807
808
809 static uint64 extract_sa_15_14_13_12(uint64 instruction)
810 {
811 uint64 value = 0;
812 value |= extract_bits(instruction, 12, 4);
813 return value;
814 }
815
816
817 static uint64 extract_rt_25_24_23_22_21(uint64 instruction)
818 {
819 uint64 value = 0;
820 value |= extract_bits(instruction, 21, 5);
821 return value;
822 }
823
824
825 static uint64 extract_ru_7_6_5_4_3(uint64 instruction)
826 {
827 uint64 value = 0;
828 value |= extract_bits(instruction, 3, 5);
829 return value;
830 }
831
832
833 static uint64 extract_u_17_to_0(uint64 instruction)
834 {
835 uint64 value = 0;
836 value |= extract_bits(instruction, 0, 18);
837 return value;
838 }
839
840
841 static uint64 extract_rsz4_4_2_1_0(uint64 instruction)
842 {
843 uint64 value = 0;
844 value |= extract_bits(instruction, 0, 3);
845 value |= extract_bits(instruction, 4, 1) << 3;
846 return value;
847 }
848
849
850 static int64 extract_s__se21_0_20_to_1_s1(uint64 instruction)
851 {
852 int64 value = 0;
853 value |= extract_bits(instruction, 0, 1) << 21;
854 value |= extract_bits(instruction, 1, 20) << 1;
855 value = sign_extend(value, 21);
856 return value;
857 }
858
859
860 static uint64 extract_op_25_to_3(uint64 instruction)
861 {
862 uint64 value = 0;
863 value |= extract_bits(instruction, 3, 23);
864 return value;
865 }
866
867
868 static uint64 extract_rs4_4_2_1_0(uint64 instruction)
869 {
870 uint64 value = 0;
871 value |= extract_bits(instruction, 0, 3);
872 value |= extract_bits(instruction, 4, 1) << 3;
873 return value;
874 }
875
876
877 static uint64 extract_bit_23_22_21(uint64 instruction)
878 {
879 uint64 value = 0;
880 value |= extract_bits(instruction, 21, 3);
881 return value;
882 }
883
884
885 static uint64 extract_rt_41_40_39_38_37(uint64 instruction)
886 {
887 uint64 value = 0;
888 value |= extract_bits(instruction, 37, 5);
889 return value;
890 }
891
892
893 static int64 extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
894 {
895 int64 value = 0;
896 value |= extract_bits(instruction, 16, 6);
897 value = sign_extend(value, 5);
898 return value;
899 }
900
901
902 static uint64 extract_rd2_3_8(uint64 instruction)
903 {
904 uint64 value = 0;
905 value |= extract_bits(instruction, 3, 1) << 1;
906 value |= extract_bits(instruction, 8, 1);
907 return value;
908 }
909
910
911 static uint64 extract_code_17_to_0(uint64 instruction)
912 {
913 uint64 value = 0;
914 value |= extract_bits(instruction, 0, 18);
915 return value;
916 }
917
918
919 static uint64 extract_size_20_19_18_17_16(uint64 instruction)
920 {
921 uint64 value = 0;
922 value |= extract_bits(instruction, 16, 5);
923 return value;
924 }
925
926
927 static int64 extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
928 {
929 int64 value = 0;
930 value |= extract_bits(instruction, 2, 6) << 2;
931 value |= extract_bits(instruction, 15, 1) << 8;
932 value = sign_extend(value, 8);
933 return value;
934 }
935
936
937 static uint64 extract_u_15_to_0(uint64 instruction)
938 {
939 uint64 value = 0;
940 value |= extract_bits(instruction, 0, 16);
941 return value;
942 }
943
944
945 static uint64 extract_fs_20_19_18_17_16(uint64 instruction)
946 {
947 uint64 value = 0;
948 value |= extract_bits(instruction, 16, 5);
949 return value;
950 }
951
952
953 static int64 extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
954 {
955 int64 value = 0;
956 value |= extract_bits(instruction, 0, 8);
957 value |= extract_bits(instruction, 15, 1) << 8;
958 value = sign_extend(value, 8);
959 return value;
960 }
961
962
963 static uint64 extract_stype_20_19_18_17_16(uint64 instruction)
964 {
965 uint64 value = 0;
966 value |= extract_bits(instruction, 16, 5);
967 return value;
968 }
969
970
971 static uint64 extract_rtl_11(uint64 instruction)
972 {
973 uint64 value = 0;
974 value |= extract_bits(instruction, 9, 1);
975 return value;
976 }
977
978
979 static uint64 extract_hs_20_19_18_17_16(uint64 instruction)
980 {
981 uint64 value = 0;
982 value |= extract_bits(instruction, 16, 5);
983 return value;
984 }
985
986
987 static uint64 extract_sel_13_12_11(uint64 instruction)
988 {
989 uint64 value = 0;
990 value |= extract_bits(instruction, 11, 3);
991 return value;
992 }
993
994
995 static uint64 extract_lsb_4_3_2_1_0(uint64 instruction)
996 {
997 uint64 value = 0;
998 value |= extract_bits(instruction, 0, 5);
999 return value;
1000 }
1001
1002
1003 static uint64 extract_gp_2(uint64 instruction)
1004 {
1005 uint64 value = 0;
1006 value |= extract_bits(instruction, 2, 1);
1007 return value;
1008 }
1009
1010
1011 static uint64 extract_rt3_9_8_7(uint64 instruction)
1012 {
1013 uint64 value = 0;
1014 value |= extract_bits(instruction, 7, 3);
1015 return value;
1016 }
1017
1018
1019 static uint64 extract_ft_25_24_23_22_21(uint64 instruction)
1020 {
1021 uint64 value = 0;
1022 value |= extract_bits(instruction, 21, 5);
1023 return value;
1024 }
1025
1026
1027 static uint64 extract_u_17_16_15_14_13_12_11(uint64 instruction)
1028 {
1029 uint64 value = 0;
1030 value |= extract_bits(instruction, 11, 7);
1031 return value;
1032 }
1033
1034
1035 static uint64 extract_cs_20_19_18_17_16(uint64 instruction)
1036 {
1037 uint64 value = 0;
1038 value |= extract_bits(instruction, 16, 5);
1039 return value;
1040 }
1041
1042
1043 static uint64 extract_rt4_9_7_6_5(uint64 instruction)
1044 {
1045 uint64 value = 0;
1046 value |= extract_bits(instruction, 5, 3);
1047 value |= extract_bits(instruction, 9, 1) << 3;
1048 return value;
1049 }
1050
1051
1052 static uint64 extract_msbt_10_9_8_7_6(uint64 instruction)
1053 {
1054 uint64 value = 0;
1055 value |= extract_bits(instruction, 6, 5);
1056 return value;
1057 }
1058
1059
1060 static uint64 extract_u_5_4_3_2_1_0__s2(uint64 instruction)
1061 {
1062 uint64 value = 0;
1063 value |= extract_bits(instruction, 0, 6) << 2;
1064 return value;
1065 }
1066
1067
1068 static uint64 extract_sa_15_14_13(uint64 instruction)
1069 {
1070 uint64 value = 0;
1071 value |= extract_bits(instruction, 13, 3);
1072 return value;
1073 }
1074
1075
1076 static int64 extract_s__se14_0_13_to_1_s1(uint64 instruction)
1077 {
1078 int64 value = 0;
1079 value |= extract_bits(instruction, 0, 1) << 14;
1080 value |= extract_bits(instruction, 1, 13) << 1;
1081 value = sign_extend(value, 14);
1082 return value;
1083 }
1084
1085
1086 static uint64 extract_rs3_6_5_4(uint64 instruction)
1087 {
1088 uint64 value = 0;
1089 value |= extract_bits(instruction, 4, 3);
1090 return value;
1091 }
1092
1093
1094 static uint64 extract_u_31_to_0__s32(uint64 instruction)
1095 {
1096 uint64 value = 0;
1097 value |= extract_bits(instruction, 0, 32) << 32;
1098 return value;
1099 }
1100
1101
1102 static uint64 extract_shift_10_9_8_7_6(uint64 instruction)
1103 {
1104 uint64 value = 0;
1105 value |= extract_bits(instruction, 6, 5);
1106 return value;
1107 }
1108
1109
1110 static uint64 extract_cs_25_24_23_22_21(uint64 instruction)
1111 {
1112 uint64 value = 0;
1113 value |= extract_bits(instruction, 21, 5);
1114 return value;
1115 }
1116
1117
1118 static uint64 extract_shiftx_11_10_9_8_7_6(uint64 instruction)
1119 {
1120 uint64 value = 0;
1121 value |= extract_bits(instruction, 6, 6);
1122 return value;
1123 }
1124
1125
1126 static uint64 extract_rt_9_8_7_6_5(uint64 instruction)
1127 {
1128 uint64 value = 0;
1129 value |= extract_bits(instruction, 5, 5);
1130 return value;
1131 }
1132
1133
1134 static uint64 extract_op_25_24_23_22_21(uint64 instruction)
1135 {
1136 uint64 value = 0;
1137 value |= extract_bits(instruction, 21, 5);
1138 return value;
1139 }
1140
1141
1142 static uint64 extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
1143 {
1144 uint64 value = 0;
1145 value |= extract_bits(instruction, 0, 7) << 2;
1146 return value;
1147 }
1148
1149
1150 static uint64 extract_bit_16_15_14_13_12_11(uint64 instruction)
1151 {
1152 uint64 value = 0;
1153 value |= extract_bits(instruction, 11, 6);
1154 return value;
1155 }
1156
1157
1158 static uint64 extract_mask_20_19_18_17_16_15_14(uint64 instruction)
1159 {
1160 uint64 value = 0;
1161 value |= extract_bits(instruction, 14, 7);
1162 return value;
1163 }
1164
1165
1166 static uint64 extract_eu_3_2_1_0(uint64 instruction)
1167 {
1168 uint64 value = 0;
1169 value |= extract_bits(instruction, 0, 4);
1170 return value;
1171 }
1172
1173
1174 static uint64 extract_u_7_6_5_4__s4(uint64 instruction)
1175 {
1176 uint64 value = 0;
1177 value |= extract_bits(instruction, 4, 4) << 4;
1178 return value;
1179 }
1180
1181
1182 static int64 extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
1183 {
1184 int64 value = 0;
1185 value |= extract_bits(instruction, 3, 5) << 3;
1186 value |= extract_bits(instruction, 15, 1) << 8;
1187 value = sign_extend(value, 8);
1188 return value;
1189 }
1190
1191
1192 static uint64 extract_ft_15_14_13_12_11(uint64 instruction)
1193 {
1194 uint64 value = 0;
1195 value |= extract_bits(instruction, 11, 5);
1196 return value;
1197 }
1198
1199
1200 static int64 extract_s__se31_15_to_0_31_to_16(uint64 instruction)
1201 {
1202 int64 value = 0;
1203 value |= extract_bits(instruction, 0, 16) << 16;
1204 value |= extract_bits(instruction, 16, 16);
1205 value = sign_extend(value, 31);
1206 return value;
1207 }
1208
1209
1210 static uint64 extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
1211 {
1212 uint64 value = 0;
1213 value |= extract_bits(instruction, 13, 8);
1214 return value;
1215 }
1216
1217
1218 static uint64 extract_u_17_to_2__s2(uint64 instruction)
1219 {
1220 uint64 value = 0;
1221 value |= extract_bits(instruction, 2, 16) << 2;
1222 return value;
1223 }
1224
1225
1226 static uint64 extract_rd_15_14_13_12_11(uint64 instruction)
1227 {
1228 uint64 value = 0;
1229 value |= extract_bits(instruction, 11, 5);
1230 return value;
1231 }
1232
1233
1234 static uint64 extract_c0s_20_19_18_17_16(uint64 instruction)
1235 {
1236 uint64 value = 0;
1237 value |= extract_bits(instruction, 16, 5);
1238 return value;
1239 }
1240
1241
1242 static uint64 extract_code_1_0(uint64 instruction)
1243 {
1244 uint64 value = 0;
1245 value |= extract_bits(instruction, 0, 2);
1246 return value;
1247 }
1248
1249
1250 static int64 extract_s__se25_0_24_to_1_s1(uint64 instruction)
1251 {
1252 int64 value = 0;
1253 value |= extract_bits(instruction, 0, 1) << 25;
1254 value |= extract_bits(instruction, 1, 24) << 1;
1255 value = sign_extend(value, 25);
1256 return value;
1257 }
1258
1259
1260 static uint64 extract_u_1_0(uint64 instruction)
1261 {
1262 uint64 value = 0;
1263 value |= extract_bits(instruction, 0, 2);
1264 return value;
1265 }
1266
1267
1268 static uint64 extract_u_3_8__s2(uint64 instruction)
1269 {
1270 uint64 value = 0;
1271 value |= extract_bits(instruction, 3, 1) << 3;
1272 value |= extract_bits(instruction, 8, 1) << 2;
1273 return value;
1274 }
1275
1276
1277 static uint64 extract_fd_15_14_13_12_11(uint64 instruction)
1278 {
1279 uint64 value = 0;
1280 value |= extract_bits(instruction, 11, 5);
1281 return value;
1282 }
1283
1284
1285 static uint64 extract_u_4_3_2_1_0__s2(uint64 instruction)
1286 {
1287 uint64 value = 0;
1288 value |= extract_bits(instruction, 0, 5) << 2;
1289 return value;
1290 }
1291
1292
1293 static uint64 extract_rtz4_9_7_6_5(uint64 instruction)
1294 {
1295 uint64 value = 0;
1296 value |= extract_bits(instruction, 5, 3);
1297 value |= extract_bits(instruction, 9, 1) << 3;
1298 return value;
1299 }
1300
1301
1302 static uint64 extract_sel_15_14_13_12_11(uint64 instruction)
1303 {
1304 uint64 value = 0;
1305 value |= extract_bits(instruction, 11, 5);
1306 return value;
1307 }
1308
1309
1310 static uint64 extract_ct_25_24_23_22_21(uint64 instruction)
1311 {
1312 uint64 value = 0;
1313 value |= extract_bits(instruction, 21, 5);
1314 return value;
1315 }
1316
1317
1318 static uint64 extract_u_20_to_2__s2(uint64 instruction)
1319 {
1320 uint64 value = 0;
1321 value |= extract_bits(instruction, 2, 19) << 2;
1322 return value;
1323 }
1324
1325
1326 static int64 extract_s__se3_4_2_1_0(uint64 instruction)
1327 {
1328 int64 value = 0;
1329 value |= extract_bits(instruction, 0, 3);
1330 value |= extract_bits(instruction, 4, 1) << 3;
1331 value = sign_extend(value, 3);
1332 return value;
1333 }
1334
1335
1336 static uint64 extract_u_3_2_1_0__s1(uint64 instruction)
1337 {
1338 uint64 value = 0;
1339 value |= extract_bits(instruction, 0, 4) << 1;
1340 return value;
1341 }
1342
1343
1344
1345 static bool ADDIU_32__cond(uint64 instruction)
1346 {
1347 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1348 return rt != 0;
1349 }
1350
1351
1352 static bool ADDIU_RS5__cond(uint64 instruction)
1353 {
1354 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1355 return rt != 0;
1356 }
1357
1358
1359 static bool BALRSC_cond(uint64 instruction)
1360 {
1361 uint64 rt = extract_rt_25_24_23_22_21(instruction);
1362 return rt != 0;
1363 }
1364
1365
1366 static bool BEQC_16__cond(uint64 instruction)
1367 {
1368 uint64 rs3 = extract_rs3_6_5_4(instruction);
1369 uint64 rt3 = extract_rt3_9_8_7(instruction);
1370 uint64 u = extract_u_3_2_1_0__s1(instruction);
1371 return rs3 < rt3 && u != 0;
1372 }
1373
1374
1375 static bool BNEC_16__cond(uint64 instruction)
1376 {
1377 uint64 rs3 = extract_rs3_6_5_4(instruction);
1378 uint64 rt3 = extract_rt3_9_8_7(instruction);
1379 uint64 u = extract_u_3_2_1_0__s1(instruction);
1380 return rs3 >= rt3 && u != 0;
1381 }
1382
1383
1384 static bool MOVE_cond(uint64 instruction)
1385 {
1386 uint64 rt = extract_rt_9_8_7_6_5(instruction);
1387 return rt != 0;
1388 }
1389
1390
1391 static bool P16_BR1_cond(uint64 instruction)
1392 {
1393 uint64 u = extract_u_3_2_1_0__s1(instruction);
1394 return u != 0;
1395 }
1396
1397
1398 static bool PREF_S9__cond(uint64 instruction)
1399 {
1400 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1401 return hint != 31;
1402 }
1403
1404
1405 static bool PREFE_cond(uint64 instruction)
1406 {
1407 uint64 hint = extract_hint_25_24_23_22_21(instruction);
1408 return hint != 31;
1409 }
1410
1411
1412 static bool SLTU_cond(uint64 instruction)
1413 {
1414 uint64 rd = extract_rd_15_14_13_12_11(instruction);
1415 return rd != 0;
1416 }
1417
1418
1419
1420 /*
1421 * ABS.D fd, fs - Floating Point Absolute Value
1422 *
1423 * 3 2 1
1424 * 10987654321098765432109876543210
1425 * 010001 00000 000101
1426 * fmt -----
1427 * fs -----
1428 * fd -----
1429 */
1430 static char *ABS_D(uint64 instruction, Dis_info *info)
1431 {
1432 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1433 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1434
1435 const char *fs = FPR(fs_value, info);
1436 const char *fd = FPR(fd_value, info);
1437
1438 return img_format("ABS.D %s, %s", fd, fs);
1439 }
1440
1441
1442 /*
1443 * ABS.S fd, fs - Floating Point Absolute Value
1444 *
1445 * 3 2 1
1446 * 10987654321098765432109876543210
1447 * 010001 00000 000101
1448 * fmt -----
1449 * fd -----
1450 * fs -----
1451 */
1452 static char *ABS_S(uint64 instruction, Dis_info *info)
1453 {
1454 uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
1455 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1456
1457 const char *fs = FPR(fs_value, info);
1458 const char *fd = FPR(fd_value, info);
1459
1460 return img_format("ABS.S %s, %s", fd, fs);
1461 }
1462
1463
1464 /*
1465 * [DSP] ABSQ_S.PH rt, rs - Find absolute value of two fractional halfwords
1466 * with 16-bit saturation
1467 *
1468 * 3 2 1
1469 * 10987654321098765432109876543210
1470 * 001000 0001000100111111
1471 * rt -----
1472 * rs -----
1473 */
1474 static char *ABSQ_S_PH(uint64 instruction, Dis_info *info)
1475 {
1476 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1477 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1478
1479 const char *rt = GPR(rt_value, info);
1480 const char *rs = GPR(rs_value, info);
1481
1482 return img_format("ABSQ_S.PH %s, %s", rt, rs);
1483 }
1484
1485
1486 /*
1487 * [DSP] ABSQ_S.QB rt, rs - Find absolute value of four fractional byte values
1488 * with 8-bit saturation
1489 *
1490 * 3 2 1
1491 * 10987654321098765432109876543210
1492 * 001000 0000000100111111
1493 * rt -----
1494 * rs -----
1495 */
1496 static char *ABSQ_S_QB(uint64 instruction, Dis_info *info)
1497 {
1498 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1499 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1500
1501 const char *rt = GPR(rt_value, info);
1502 const char *rs = GPR(rs_value, info);
1503
1504 return img_format("ABSQ_S.QB %s, %s", rt, rs);
1505 }
1506
1507
1508 /*
1509 * [DSP] ABSQ_S.W rt, rs - Find absolute value of fractional word with 32-bit
1510 * saturation
1511 *
1512 * 3 2 1
1513 * 10987654321098765432109876543210
1514 * 001000 0010000100111111
1515 * rt -----
1516 * rs -----
1517 */
1518 static char *ABSQ_S_W(uint64 instruction, Dis_info *info)
1519 {
1520 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1521 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1522
1523 const char *rt = GPR(rt_value, info);
1524 const char *rs = GPR(rs_value, info);
1525
1526 return img_format("ABSQ_S.W %s, %s", rt, rs);
1527 }
1528
1529
1530 /*
1531 *
1532 *
1533 * 3 2 1
1534 * 10987654321098765432109876543210
1535 * 001000 0010000100111111
1536 * rt -----
1537 * rs -----
1538 */
1539 static char *ACLR(uint64 instruction, Dis_info *info)
1540 {
1541 uint64 bit_value = extract_bit_23_22_21(instruction);
1542 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1543 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
1544
1545 const char *rs = GPR(rs_value, info);
1546
1547 return img_format("ACLR 0x%" PRIx64 ", %" PRId64 "(%s)",
1548 bit_value, s_value, rs);
1549 }
1550
1551
1552 /*
1553 *
1554 *
1555 * 3 2 1
1556 * 10987654321098765432109876543210
1557 * 001000 0010000100111111
1558 * rt -----
1559 * rs -----
1560 */
1561 static char *ADD(uint64 instruction, Dis_info *info)
1562 {
1563 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1564 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1565 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1566
1567 const char *rd = GPR(rd_value, info);
1568 const char *rs = GPR(rs_value, info);
1569 const char *rt = GPR(rt_value, info);
1570
1571 return img_format("ADD %s, %s, %s", rd, rs, rt);
1572 }
1573
1574
1575 /*
1576 * ADD.D fd, fs, ft - Floating Point Add
1577 *
1578 * 3 2 1
1579 * 10987654321098765432109876543210
1580 * 010001 000101
1581 * fmt -----
1582 * ft -----
1583 * fs -----
1584 * fd -----
1585 */
1586 static char *ADD_D(uint64 instruction, Dis_info *info)
1587 {
1588 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1589 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1590 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1591
1592 const char *ft = FPR(ft_value, info);
1593 const char *fs = FPR(fs_value, info);
1594 const char *fd = FPR(fd_value, info);
1595
1596 return img_format("ADD.D %s, %s, %s", fd, fs, ft);
1597 }
1598
1599
1600 /*
1601 * ADD.S fd, fs, ft - Floating Point Add
1602 *
1603 * 3 2 1
1604 * 10987654321098765432109876543210
1605 * 010001 000101
1606 * fmt -----
1607 * ft -----
1608 * fs -----
1609 * fd -----
1610 */
1611 static char *ADD_S(uint64 instruction, Dis_info *info)
1612 {
1613 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
1614 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
1615 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
1616
1617 const char *ft = FPR(ft_value, info);
1618 const char *fs = FPR(fs_value, info);
1619 const char *fd = FPR(fd_value, info);
1620
1621 return img_format("ADD.S %s, %s, %s", fd, fs, ft);
1622 }
1623
1624
1625 /*
1626 *
1627 *
1628 * 3 2 1
1629 * 10987654321098765432109876543210
1630 * 001000 0010000100111111
1631 * rt -----
1632 * rs -----
1633 */
1634 static char *ADDIU_32_(uint64 instruction, Dis_info *info)
1635 {
1636 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1637 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1638 uint64 u_value = extract_u_15_to_0(instruction);
1639
1640 const char *rt = GPR(rt_value, info);
1641 const char *rs = GPR(rs_value, info);
1642
1643 return img_format("ADDIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
1644 }
1645
1646
1647 /*
1648 *
1649 *
1650 * 3 2 1
1651 * 10987654321098765432109876543210
1652 * 001000 0010000100111111
1653 * rt -----
1654 * rs -----
1655 */
1656 static char *ADDIU_48_(uint64 instruction, Dis_info *info)
1657 {
1658 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1659 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1660
1661 const char *rt = GPR(rt_value, info);
1662
1663 return img_format("ADDIU %s, %" PRId64, rt, s_value);
1664 }
1665
1666
1667 /*
1668 *
1669 *
1670 * 3 2 1
1671 * 10987654321098765432109876543210
1672 * 001000 0010000100111111
1673 * rt -----
1674 * rs -----
1675 */
1676 static char *ADDIU_GP48_(uint64 instruction, Dis_info *info)
1677 {
1678 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1679 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1680
1681 const char *rt = GPR(rt_value, info);
1682
1683 return img_format("ADDIU %s, $%d, %" PRId64, rt, 28, s_value);
1684 }
1685
1686
1687 /*
1688 *
1689 *
1690 * 3 2 1
1691 * 10987654321098765432109876543210
1692 * 001000 0010000100111111
1693 * rt -----
1694 * rs -----
1695 */
1696 static char *ADDIU_GP_B_(uint64 instruction, Dis_info *info)
1697 {
1698 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1699 uint64 u_value = extract_u_17_to_0(instruction);
1700
1701 const char *rt = GPR(rt_value, info);
1702
1703 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt, 28, u_value);
1704 }
1705
1706
1707 /*
1708 *
1709 *
1710 * 3 2 1
1711 * 10987654321098765432109876543210
1712 * 001000 0010000100111111
1713 * rt -----
1714 * rs -----
1715 */
1716 static char *ADDIU_GP_W_(uint64 instruction, Dis_info *info)
1717 {
1718 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1719 uint64 u_value = extract_u_20_to_2__s2(instruction);
1720
1721 const char *rt = GPR(rt_value, info);
1722
1723 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt, 28, u_value);
1724 }
1725
1726
1727 /*
1728 *
1729 *
1730 * 3 2 1
1731 * 10987654321098765432109876543210
1732 * 001000 0010000100111111
1733 * rt -----
1734 * rs -----
1735 */
1736 static char *ADDIU_NEG_(uint64 instruction, Dis_info *info)
1737 {
1738 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1739 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1740 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
1741
1742 const char *rt = GPR(rt_value, info);
1743 const char *rs = GPR(rs_value, info);
1744 int64 u = neg_copy(u_value);
1745
1746 return img_format("ADDIU %s, %s, %" PRId64, rt, rs, u);
1747 }
1748
1749
1750 /*
1751 *
1752 *
1753 * 3 2 1
1754 * 10987654321098765432109876543210
1755 * 001000 0010000100111111
1756 * rt -----
1757 * rs -----
1758 */
1759 static char *ADDIU_R1_SP_(uint64 instruction, Dis_info *info)
1760 {
1761 uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
1762 uint64 rt3_value = extract_rt3_9_8_7(instruction);
1763
1764 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
1765
1766 return img_format("ADDIU %s, $%d, 0x%" PRIx64, rt3, 29, u_value);
1767 }
1768
1769
1770 /*
1771 *
1772 *
1773 * 3 2 1
1774 * 10987654321098765432109876543210
1775 * 001000 0010000100111111
1776 * rt -----
1777 * rs -----
1778 */
1779 static char *ADDIU_R2_(uint64 instruction, Dis_info *info)
1780 {
1781 uint64 rt3_value = extract_rt3_9_8_7(instruction);
1782 uint64 rs3_value = extract_rs3_6_5_4(instruction);
1783 uint64 u_value = extract_u_2_1_0__s2(instruction);
1784
1785 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
1786 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
1787
1788 return img_format("ADDIU %s, %s, 0x%" PRIx64, rt3, rs3, u_value);
1789 }
1790
1791
1792 /*
1793 * ADDIU[RS5] rt, s5 - Add Signed Word and Set Carry Bit
1794 *
1795 * 5432109876543210
1796 * 100100 1
1797 * rt -----
1798 * s - ---
1799 */
1800 static char *ADDIU_RS5_(uint64 instruction, Dis_info *info)
1801 {
1802 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
1803 int64 s_value = extract_s__se3_4_2_1_0(instruction);
1804
1805 const char *rt = GPR(rt_value, info);
1806
1807 return img_format("ADDIU %s, %" PRId64, rt, s_value);
1808 }
1809
1810
1811 /*
1812 *
1813 *
1814 * 3 2 1
1815 * 10987654321098765432109876543210
1816 * 001000 x1110000101
1817 * rt -----
1818 * rs -----
1819 * rd -----
1820 */
1821 static char *ADDIUPC_32_(uint64 instruction, Dis_info *info)
1822 {
1823 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1824 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
1825
1826 const char *rt = GPR(rt_value, info);
1827 g_autofree char *s = ADDRESS(s_value, 4, info);
1828
1829 return img_format("ADDIUPC %s, %s", rt, s);
1830 }
1831
1832
1833 /*
1834 *
1835 *
1836 * 3 2 1
1837 * 10987654321098765432109876543210
1838 * 001000 x1110000101
1839 * rt -----
1840 * rs -----
1841 * rd -----
1842 */
1843 static char *ADDIUPC_48_(uint64 instruction, Dis_info *info)
1844 {
1845 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
1846 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
1847
1848 const char *rt = GPR(rt_value, info);
1849 g_autofree char *s = ADDRESS(s_value, 6, info);
1850
1851 return img_format("ADDIUPC %s, %s", rt, s);
1852 }
1853
1854
1855 /*
1856 * [DSP] ADDQ.PH rd, rt, rs - Add fractional halfword vectors
1857 *
1858 * 3 2 1
1859 * 10987654321098765432109876543210
1860 * 001000 00000001101
1861 * rt -----
1862 * rs -----
1863 * rd -----
1864 */
1865 static char *ADDQ_PH(uint64 instruction, Dis_info *info)
1866 {
1867 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1868 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1869 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1870
1871 const char *rd = GPR(rd_value, info);
1872 const char *rs = GPR(rs_value, info);
1873 const char *rt = GPR(rt_value, info);
1874
1875 return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
1876 }
1877
1878
1879 /*
1880 * [DSP] ADDQ_S.PH rd, rt, rs - Add fractional halfword vectors with 16-bit
1881 * saturation
1882 *
1883 * 3 2 1
1884 * 10987654321098765432109876543210
1885 * 001000 10000001101
1886 * rt -----
1887 * rs -----
1888 * rd -----
1889 */
1890 static char *ADDQ_S_PH(uint64 instruction, Dis_info *info)
1891 {
1892 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1893 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1894 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1895
1896 const char *rd = GPR(rd_value, info);
1897 const char *rs = GPR(rs_value, info);
1898 const char *rt = GPR(rt_value, info);
1899
1900 return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
1901 }
1902
1903
1904 /*
1905 * [DSP] ADDQ_S.W rd, rt, rs - Add fractional words with 32-bit saturation
1906 *
1907 * 3 2 1
1908 * 10987654321098765432109876543210
1909 * 001000 x1100000101
1910 * rt -----
1911 * rs -----
1912 * rd -----
1913 */
1914 static char *ADDQ_S_W(uint64 instruction, Dis_info *info)
1915 {
1916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1917 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1918 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1919
1920 const char *rd = GPR(rd_value, info);
1921 const char *rs = GPR(rs_value, info);
1922 const char *rt = GPR(rt_value, info);
1923
1924 return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
1925 }
1926
1927
1928 /*
1929 * [DSP] ADDQH.PH rd, rt, rs - Add fractional halfword vectors and shift
1930 * right to halve results
1931 *
1932 * 3 2 1
1933 * 10987654321098765432109876543210
1934 * 001000 00001001101
1935 * rt -----
1936 * rs -----
1937 * rd -----
1938 */
1939 static char *ADDQH_PH(uint64 instruction, Dis_info *info)
1940 {
1941 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1942 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1943 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1944
1945 const char *rd = GPR(rd_value, info);
1946 const char *rs = GPR(rs_value, info);
1947 const char *rt = GPR(rt_value, info);
1948
1949 return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
1950 }
1951
1952
1953 /*
1954 * [DSP] ADDQH_R.PH rd, rt, rs - Add fractional halfword vectors and shift
1955 * right to halve results with rounding
1956 *
1957 * 3 2 1
1958 * 10987654321098765432109876543210
1959 * 001000 10001001101
1960 * rt -----
1961 * rs -----
1962 * rd -----
1963 */
1964 static char *ADDQH_R_PH(uint64 instruction, Dis_info *info)
1965 {
1966 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1967 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1968 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1969
1970 const char *rd = GPR(rd_value, info);
1971 const char *rs = GPR(rs_value, info);
1972 const char *rt = GPR(rt_value, info);
1973
1974 return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
1975 }
1976
1977
1978 /*
1979 * [DSP] ADDQH_R.W rd, rt, rs - Add fractional words and shift right to halve
1980 * results with rounding
1981 *
1982 * 3 2 1
1983 * 10987654321098765432109876543210
1984 * 001000 00010001101
1985 * rt -----
1986 * rs -----
1987 * rd -----
1988 */
1989 static char *ADDQH_R_W(uint64 instruction, Dis_info *info)
1990 {
1991 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
1992 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
1993 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
1994
1995 const char *rd = GPR(rd_value, info);
1996 const char *rs = GPR(rs_value, info);
1997 const char *rt = GPR(rt_value, info);
1998
1999 return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
2000 }
2001
2002
2003 /*
2004 * [DSP] ADDQH.W rd, rt, rs - Add fractional words and shift right to halve
2005 * results
2006 *
2007 * 3 2 1
2008 * 10987654321098765432109876543210
2009 * 001000 10010001101
2010 * rt -----
2011 * rs -----
2012 * rd -----
2013 */
2014 static char *ADDQH_W(uint64 instruction, Dis_info *info)
2015 {
2016 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2017 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2018 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2019
2020 const char *rd = GPR(rd_value, info);
2021 const char *rs = GPR(rs_value, info);
2022 const char *rt = GPR(rt_value, info);
2023
2024 return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
2025 }
2026
2027
2028 /*
2029 * [DSP] ADDSC rd, rt, rs - Add two signed words and set carry bit
2030 *
2031 * 3 2 1
2032 * 10987654321098765432109876543210
2033 * 001000 x1110000101
2034 * rt -----
2035 * rs -----
2036 * rd -----
2037 */
2038 static char *ADDSC(uint64 instruction, Dis_info *info)
2039 {
2040 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2041 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2042 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2043
2044 const char *rd = GPR(rd_value, info);
2045 const char *rs = GPR(rs_value, info);
2046 const char *rt = GPR(rt_value, info);
2047
2048 return img_format("ADDSC %s, %s, %s", rd, rs, rt);
2049 }
2050
2051
2052 /*
2053 * ADDU[16] rd3, rs3, rt3 -
2054 *
2055 * 5432109876543210
2056 * 101100 0
2057 * rt3 ---
2058 * rs3 ---
2059 * rd3 ---
2060 */
2061 static char *ADDU_16_(uint64 instruction, Dis_info *info)
2062 {
2063 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2064 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2065 uint64 rd3_value = extract_rd3_3_2_1(instruction);
2066
2067 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2068 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2069 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
2070
2071 return img_format("ADDU %s, %s, %s", rd3, rs3, rt3);
2072 }
2073
2074
2075 /*
2076 *
2077 *
2078 * 3 2 1
2079 * 10987654321098765432109876543210
2080 * 001000 x1110000101
2081 * rt -----
2082 * rs -----
2083 * rd -----
2084 */
2085 static char *ADDU_32_(uint64 instruction, Dis_info *info)
2086 {
2087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2089 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2090
2091 const char *rd = GPR(rd_value, info);
2092 const char *rs = GPR(rs_value, info);
2093 const char *rt = GPR(rt_value, info);
2094
2095 return img_format("ADDU %s, %s, %s", rd, rs, rt);
2096 }
2097
2098
2099 /*
2100 *
2101 *
2102 * 3 2 1
2103 * 10987654321098765432109876543210
2104 * 001000 x1110000101
2105 * rt -----
2106 * rs -----
2107 * rd -----
2108 */
2109 static char *ADDU_4X4_(uint64 instruction, Dis_info *info)
2110 {
2111 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
2112 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
2113
2114 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
2115 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
2116
2117 return img_format("ADDU %s, %s", rs4, rt4);
2118 }
2119
2120
2121 /*
2122 * [DSP] ADDU.PH rd, rt, rs - Add two pairs of unsigned halfwords
2123 *
2124 * 3 2 1
2125 * 10987654321098765432109876543210
2126 * 001000 00100001101
2127 * rt -----
2128 * rs -----
2129 * rd -----
2130 */
2131 static char *ADDU_PH(uint64 instruction, Dis_info *info)
2132 {
2133 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2134 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2135 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2136
2137 const char *rd = GPR(rd_value, info);
2138 const char *rs = GPR(rs_value, info);
2139 const char *rt = GPR(rt_value, info);
2140
2141 return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
2142 }
2143
2144
2145 /*
2146 * ADDU.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2147 *
2148 * 3 2 1
2149 * 10987654321098765432109876543210
2150 * 001000 00011001101
2151 * rt -----
2152 * rs -----
2153 * rd -----
2154 */
2155 static char *ADDU_QB(uint64 instruction, Dis_info *info)
2156 {
2157 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2158 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2159 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2160
2161 const char *rd = GPR(rd_value, info);
2162 const char *rs = GPR(rs_value, info);
2163 const char *rt = GPR(rt_value, info);
2164
2165 return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
2166 }
2167
2168
2169 /*
2170 * [DSP] ADDU_S.PH rd, rt, rs - Add two pairs of unsigned halfwords with 16-bit
2171 * saturation
2172 *
2173 * 3 2 1
2174 * 10987654321098765432109876543210
2175 * 001000 10100001101
2176 * rt -----
2177 * rs -----
2178 * rd -----
2179 */
2180 static char *ADDU_S_PH(uint64 instruction, Dis_info *info)
2181 {
2182 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2183 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2184 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2185
2186 const char *rd = GPR(rd_value, info);
2187 const char *rs = GPR(rs_value, info);
2188 const char *rt = GPR(rt_value, info);
2189
2190 return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
2191 }
2192
2193
2194 /*
2195 * ADDU_S.QB rd, rt, rs - Unsigned Add Quad Byte Vectors
2196 *
2197 * 3 2 1
2198 * 10987654321098765432109876543210
2199 * 001000 10011001101
2200 * rt -----
2201 * rs -----
2202 * rd -----
2203 */
2204 static char *ADDU_S_QB(uint64 instruction, Dis_info *info)
2205 {
2206 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2207 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2208 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2209
2210 const char *rd = GPR(rd_value, info);
2211 const char *rs = GPR(rs_value, info);
2212 const char *rt = GPR(rt_value, info);
2213
2214 return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
2215 }
2216
2217
2218 /*
2219 * ADDUH.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2220 * to Halve Results
2221 *
2222 * 3 2 1
2223 * 10987654321098765432109876543210
2224 * 001000 00101001101
2225 * rt -----
2226 * rs -----
2227 * rd -----
2228 */
2229 static char *ADDUH_QB(uint64 instruction, Dis_info *info)
2230 {
2231 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2232 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2233 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2234
2235 const char *rd = GPR(rd_value, info);
2236 const char *rs = GPR(rs_value, info);
2237 const char *rt = GPR(rt_value, info);
2238
2239 return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
2240 }
2241
2242
2243 /*
2244 * ADDUH_R.QB rd, rt, rs - Unsigned Add Vector Quad-Bytes And Right Shift
2245 * to Halve Results
2246 *
2247 * 3 2 1
2248 * 10987654321098765432109876543210
2249 * 001000 10101001101
2250 * rt -----
2251 * rs -----
2252 * rd -----
2253 */
2254 static char *ADDUH_R_QB(uint64 instruction, Dis_info *info)
2255 {
2256 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2257 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2258 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2259
2260 const char *rd = GPR(rd_value, info);
2261 const char *rs = GPR(rs_value, info);
2262 const char *rt = GPR(rt_value, info);
2263
2264 return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
2265 }
2266
2267 /*
2268 * ADDWC rd, rt, rs - Add Word with Carry Bit
2269 *
2270 * 3 2 1
2271 * 10987654321098765432109876543210
2272 * 001000 x1111000101
2273 * rt -----
2274 * rs -----
2275 * rd -----
2276 */
2277 static char *ADDWC(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("ADDWC %s, %s, %s", rd, rs, rt);
2288 }
2289
2290
2291 /*
2292 *
2293 *
2294 * 3 2 1
2295 * 10987654321098765432109876543210
2296 * 001000 x1110000101
2297 * rt -----
2298 * rs -----
2299 * rd -----
2300 */
2301 static char *ALUIPC(uint64 instruction, Dis_info *info)
2302 {
2303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2304 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
2305
2306 const char *rt = GPR(rt_value, info);
2307 g_autofree char *s = ADDRESS(s_value, 4, info);
2308
2309 return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
2310 }
2311
2312
2313 /*
2314 * AND[16] rt3, rs3 -
2315 *
2316 * 5432109876543210
2317 * 101100
2318 * rt3 ---
2319 * rs3 ---
2320 * eu ----
2321 */
2322 static char *AND_16_(uint64 instruction, Dis_info *info)
2323 {
2324 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2325 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2326
2327 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2328 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2329
2330 return img_format("AND %s, %s", rs3, rt3);
2331 }
2332
2333
2334 /*
2335 *
2336 *
2337 * 3 2 1
2338 * 10987654321098765432109876543210
2339 * 001000 x1110000101
2340 * rt -----
2341 * rs -----
2342 * rd -----
2343 */
2344 static char *AND_32_(uint64 instruction, Dis_info *info)
2345 {
2346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2347 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2348 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
2349
2350 const char *rd = GPR(rd_value, info);
2351 const char *rs = GPR(rs_value, info);
2352 const char *rt = GPR(rt_value, info);
2353
2354 return img_format("AND %s, %s, %s", rd, rs, rt);
2355 }
2356
2357
2358 /*
2359 * ANDI rt, rs, u -
2360 *
2361 * 5432109876543210
2362 * 101100
2363 * rt3 ---
2364 * rs3 ---
2365 * eu ----
2366 */
2367 static char *ANDI_16_(uint64 instruction, Dis_info *info)
2368 {
2369 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2370 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2371 uint64 eu_value = extract_eu_3_2_1_0(instruction);
2372
2373 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2374 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2375 uint64 eu = encode_eu_from_u_andi16(eu_value);
2376
2377 return img_format("ANDI %s, %s, 0x%" PRIx64, rt3, rs3, eu);
2378 }
2379
2380
2381 /*
2382 *
2383 *
2384 * 3 2 1
2385 * 10987654321098765432109876543210
2386 * 001000 x1110000101
2387 * rt -----
2388 * rs -----
2389 * rd -----
2390 */
2391 static char *ANDI_32_(uint64 instruction, Dis_info *info)
2392 {
2393 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2394 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2395 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
2396
2397 const char *rt = GPR(rt_value, info);
2398 const char *rs = GPR(rs_value, info);
2399
2400 return img_format("ANDI %s, %s, 0x%" PRIx64, rt, rs, u_value);
2401 }
2402
2403
2404 /*
2405 *
2406 *
2407 * 3 2 1
2408 * 10987654321098765432109876543210
2409 * 001000 x1110000101
2410 * rt -----
2411 * rs -----
2412 * rd -----
2413 */
2414 static char *APPEND(uint64 instruction, Dis_info *info)
2415 {
2416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2417 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2418 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
2419
2420 const char *rt = GPR(rt_value, info);
2421 const char *rs = GPR(rs_value, info);
2422
2423 return img_format("APPEND %s, %s, 0x%" PRIx64, rt, rs, sa_value);
2424 }
2425
2426
2427 /*
2428 *
2429 *
2430 * 3 2 1
2431 * 10987654321098765432109876543210
2432 * 001000 x1110000101
2433 * rt -----
2434 * rs -----
2435 * rd -----
2436 */
2437 static char *ASET(uint64 instruction, Dis_info *info)
2438 {
2439 uint64 bit_value = extract_bit_23_22_21(instruction);
2440 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2441 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
2442
2443 const char *rs = GPR(rs_value, info);
2444
2445 return img_format("ASET 0x%" PRIx64 ", %" PRId64 "(%s)",
2446 bit_value, s_value, rs);
2447 }
2448
2449
2450 /*
2451 *
2452 *
2453 * 3 2 1
2454 * 10987654321098765432109876543210
2455 * 001000 x1110000101
2456 * rt -----
2457 * rs -----
2458 * rd -----
2459 */
2460 static char *BALC_16_(uint64 instruction, Dis_info *info)
2461 {
2462 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2463
2464 g_autofree char *s = ADDRESS(s_value, 2, info);
2465
2466 return img_format("BALC %s", s);
2467 }
2468
2469
2470 /*
2471 *
2472 *
2473 * 3 2 1
2474 * 10987654321098765432109876543210
2475 * 001000 x1110000101
2476 * rt -----
2477 * rs -----
2478 * rd -----
2479 */
2480 static char *BALC_32_(uint64 instruction, Dis_info *info)
2481 {
2482 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2483
2484 g_autofree char *s = ADDRESS(s_value, 4, info);
2485
2486 return img_format("BALC %s", s);
2487 }
2488
2489
2490 /*
2491 *
2492 *
2493 * 3 2 1
2494 * 10987654321098765432109876543210
2495 * 001000 x1110000101
2496 * rt -----
2497 * rs -----
2498 * rd -----
2499 */
2500 static char *BALRSC(uint64 instruction, Dis_info *info)
2501 {
2502 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2503 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2504
2505 const char *rt = GPR(rt_value, info);
2506 const char *rs = GPR(rs_value, info);
2507
2508 return img_format("BALRSC %s, %s", rt, rs);
2509 }
2510
2511
2512 /*
2513 *
2514 *
2515 * 3 2 1
2516 * 10987654321098765432109876543210
2517 * 001000 x1110000101
2518 * rt -----
2519 * rs -----
2520 * rd -----
2521 */
2522 static char *BBEQZC(uint64 instruction, Dis_info *info)
2523 {
2524 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2525 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2526 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2527
2528 const char *rt = GPR(rt_value, info);
2529 g_autofree char *s = ADDRESS(s_value, 4, info);
2530
2531 return img_format("BBEQZC %s, 0x%" PRIx64 ", %s", rt, bit_value, s);
2532 }
2533
2534
2535 /*
2536 *
2537 *
2538 * 3 2 1
2539 * 10987654321098765432109876543210
2540 * 001000 x1110000101
2541 * rt -----
2542 * rs -----
2543 * rd -----
2544 */
2545 static char *BBNEZC(uint64 instruction, Dis_info *info)
2546 {
2547 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2548 uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
2549 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2550
2551 const char *rt = GPR(rt_value, info);
2552 g_autofree char *s = ADDRESS(s_value, 4, info);
2553
2554 return img_format("BBNEZC %s, 0x%" PRIx64 ", %s", rt, bit_value, s);
2555 }
2556
2557
2558 /*
2559 *
2560 *
2561 * 3 2 1
2562 * 10987654321098765432109876543210
2563 * 001000 x1110000101
2564 * rt -----
2565 * rs -----
2566 * rd -----
2567 */
2568 static char *BC_16_(uint64 instruction, Dis_info *info)
2569 {
2570 int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
2571
2572 g_autofree char *s = ADDRESS(s_value, 2, info);
2573
2574 return img_format("BC %s", s);
2575 }
2576
2577
2578 /*
2579 *
2580 *
2581 * 3 2 1
2582 * 10987654321098765432109876543210
2583 * 001000 x1110000101
2584 * rt -----
2585 * rs -----
2586 * rd -----
2587 */
2588 static char *BC_32_(uint64 instruction, Dis_info *info)
2589 {
2590 int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
2591
2592 g_autofree char *s = ADDRESS(s_value, 4, info);
2593
2594 return img_format("BC %s", s);
2595 }
2596
2597
2598 /*
2599 *
2600 *
2601 * 3 2 1
2602 * 10987654321098765432109876543210
2603 * 001000 x1110000101
2604 * rt -----
2605 * rs -----
2606 * rd -----
2607 */
2608 static char *BC1EQZC(uint64 instruction, Dis_info *info)
2609 {
2610 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2611 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2612
2613 const char *ft = FPR(ft_value, info);
2614 g_autofree char *s = ADDRESS(s_value, 4, info);
2615
2616 return img_format("BC1EQZC %s, %s", ft, s);
2617 }
2618
2619
2620 /*
2621 *
2622 *
2623 * 3 2 1
2624 * 10987654321098765432109876543210
2625 * 001000 x1110000101
2626 * rt -----
2627 * rs -----
2628 * rd -----
2629 */
2630 static char *BC1NEZC(uint64 instruction, Dis_info *info)
2631 {
2632 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
2633 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2634
2635 const char *ft = FPR(ft_value, info);
2636 g_autofree char *s = ADDRESS(s_value, 4, info);
2637
2638 return img_format("BC1NEZC %s, %s", ft, s);
2639 }
2640
2641
2642 /*
2643 *
2644 *
2645 * 3 2 1
2646 * 10987654321098765432109876543210
2647 * 001000 x1110000101
2648 * rt -----
2649 * rs -----
2650 * rd -----
2651 */
2652 static char *BC2EQZC(uint64 instruction, Dis_info *info)
2653 {
2654 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
2655 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2656
2657 g_autofree char *s = ADDRESS(s_value, 4, info);
2658
2659 return img_format("BC2EQZC CP%" PRIu64 ", %s", ct_value, s);
2660 }
2661
2662
2663 /*
2664 *
2665 *
2666 * 3 2 1
2667 * 10987654321098765432109876543210
2668 * 001000 x1110000101
2669 * rt -----
2670 * rs -----
2671 * rd -----
2672 */
2673 static char *BC2NEZC(uint64 instruction, Dis_info *info)
2674 {
2675 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
2676 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2677
2678 g_autofree char *s = ADDRESS(s_value, 4, info);
2679
2680 return img_format("BC2NEZC CP%" PRIu64 ", %s", ct_value, s);
2681 }
2682
2683
2684 /*
2685 *
2686 *
2687 * 3 2 1
2688 * 10987654321098765432109876543210
2689 * 001000 x1110000101
2690 * rt -----
2691 * rs -----
2692 * rd -----
2693 */
2694 static char *BEQC_16_(uint64 instruction, Dis_info *info)
2695 {
2696 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2697 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2698 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
2699
2700 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2701 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2702 g_autofree char *u = ADDRESS(u_value, 2, info);
2703
2704 return img_format("BEQC %s, %s, %s", rs3, rt3, u);
2705 }
2706
2707
2708 /*
2709 *
2710 *
2711 * 3 2 1
2712 * 10987654321098765432109876543210
2713 * 001000 x1110000101
2714 * rt -----
2715 * rs -----
2716 * rd -----
2717 */
2718 static char *BEQC_32_(uint64 instruction, Dis_info *info)
2719 {
2720 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2721 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2722 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2723
2724 const char *rs = GPR(rs_value, info);
2725 const char *rt = GPR(rt_value, info);
2726 g_autofree char *s = ADDRESS(s_value, 4, info);
2727
2728 return img_format("BEQC %s, %s, %s", rs, rt, s);
2729 }
2730
2731
2732 /*
2733 *
2734 *
2735 * 3 2 1
2736 * 10987654321098765432109876543210
2737 * 001000 x1110000101
2738 * rt -----
2739 * rs -----
2740 * rd -----
2741 */
2742 static char *BEQIC(uint64 instruction, Dis_info *info)
2743 {
2744 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2745 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2746 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2747
2748 const char *rt = GPR(rt_value, info);
2749 g_autofree char *s = ADDRESS(s_value, 4, info);
2750
2751 return img_format("BEQIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2752 }
2753
2754
2755 /*
2756 *
2757 *
2758 * 3 2 1
2759 * 10987654321098765432109876543210
2760 * 001000 x1110000101
2761 * rt -----
2762 * rs -----
2763 * rd -----
2764 */
2765 static char *BEQZC_16_(uint64 instruction, Dis_info *info)
2766 {
2767 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2768 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
2769
2770 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2771 g_autofree char *s = ADDRESS(s_value, 2, info);
2772
2773 return img_format("BEQZC %s, %s", rt3, s);
2774 }
2775
2776
2777 /*
2778 *
2779 *
2780 * 3 2 1
2781 * 10987654321098765432109876543210
2782 * 001000 x1110000101
2783 * rt -----
2784 * rs -----
2785 * rd -----
2786 */
2787 static char *BGEC(uint64 instruction, Dis_info *info)
2788 {
2789 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2790 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2791 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2792
2793 const char *rs = GPR(rs_value, info);
2794 const char *rt = GPR(rt_value, info);
2795 g_autofree char *s = ADDRESS(s_value, 4, info);
2796
2797 return img_format("BGEC %s, %s, %s", rs, rt, s);
2798 }
2799
2800
2801 /*
2802 *
2803 *
2804 * 3 2 1
2805 * 10987654321098765432109876543210
2806 * 001000 x1110000101
2807 * rt -----
2808 * rs -----
2809 * rd -----
2810 */
2811 static char *BGEIC(uint64 instruction, Dis_info *info)
2812 {
2813 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2814 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2815 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2816
2817 const char *rt = GPR(rt_value, info);
2818 g_autofree char *s = ADDRESS(s_value, 4, info);
2819
2820 return img_format("BGEIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2821 }
2822
2823
2824 /*
2825 *
2826 *
2827 * 3 2 1
2828 * 10987654321098765432109876543210
2829 * 001000 x1110000101
2830 * rt -----
2831 * rs -----
2832 * rd -----
2833 */
2834 static char *BGEIUC(uint64 instruction, Dis_info *info)
2835 {
2836 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2837 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2838 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2839
2840 const char *rt = GPR(rt_value, info);
2841 g_autofree char *s = ADDRESS(s_value, 4, info);
2842
2843 return img_format("BGEIUC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2844 }
2845
2846
2847 /*
2848 *
2849 *
2850 * 3 2 1
2851 * 10987654321098765432109876543210
2852 * 001000 x1110000101
2853 * rt -----
2854 * rs -----
2855 * rd -----
2856 */
2857 static char *BGEUC(uint64 instruction, Dis_info *info)
2858 {
2859 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2860 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2861 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2862
2863 const char *rs = GPR(rs_value, info);
2864 const char *rt = GPR(rt_value, info);
2865 g_autofree char *s = ADDRESS(s_value, 4, info);
2866
2867 return img_format("BGEUC %s, %s, %s", rs, rt, s);
2868 }
2869
2870
2871 /*
2872 *
2873 *
2874 * 3 2 1
2875 * 10987654321098765432109876543210
2876 * 001000 x1110000101
2877 * rt -----
2878 * rs -----
2879 * rd -----
2880 */
2881 static char *BLTC(uint64 instruction, Dis_info *info)
2882 {
2883 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2884 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2885 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2886
2887 const char *rs = GPR(rs_value, info);
2888 const char *rt = GPR(rt_value, info);
2889 g_autofree char *s = ADDRESS(s_value, 4, info);
2890
2891 return img_format("BLTC %s, %s, %s", rs, rt, s);
2892 }
2893
2894
2895 /*
2896 *
2897 *
2898 * 3 2 1
2899 * 10987654321098765432109876543210
2900 * 001000 x1110000101
2901 * rt -----
2902 * rs -----
2903 * rd -----
2904 */
2905 static char *BLTIC(uint64 instruction, Dis_info *info)
2906 {
2907 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2908 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2909 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2910
2911 const char *rt = GPR(rt_value, info);
2912 g_autofree char *s = ADDRESS(s_value, 4, info);
2913
2914 return img_format("BLTIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2915 }
2916
2917
2918 /*
2919 *
2920 *
2921 * 3 2 1
2922 * 10987654321098765432109876543210
2923 * 001000 x1110000101
2924 * rt -----
2925 * rs -----
2926 * rd -----
2927 */
2928 static char *BLTIUC(uint64 instruction, Dis_info *info)
2929 {
2930 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2931 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
2932 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
2933
2934 const char *rt = GPR(rt_value, info);
2935 g_autofree char *s = ADDRESS(s_value, 4, info);
2936
2937 return img_format("BLTIUC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
2938 }
2939
2940
2941 /*
2942 *
2943 *
2944 * 3 2 1
2945 * 10987654321098765432109876543210
2946 * 001000 x1110000101
2947 * rt -----
2948 * rs -----
2949 * rd -----
2950 */
2951 static char *BLTUC(uint64 instruction, Dis_info *info)
2952 {
2953 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
2954 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
2955 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
2956
2957 const char *rs = GPR(rs_value, info);
2958 const char *rt = GPR(rt_value, info);
2959 g_autofree char *s = ADDRESS(s_value, 4, info);
2960
2961 return img_format("BLTUC %s, %s, %s", rs, rt, s);
2962 }
2963
2964
2965 /*
2966 *
2967 *
2968 * 3 2 1
2969 * 10987654321098765432109876543210
2970 * 001000 x1110000101
2971 * rt -----
2972 * rs -----
2973 * rd -----
2974 */
2975 static char *BNEC_16_(uint64 instruction, Dis_info *info)
2976 {
2977 uint64 rt3_value = extract_rt3_9_8_7(instruction);
2978 uint64 rs3_value = extract_rs3_6_5_4(instruction);
2979 uint64 u_value = extract_u_3_2_1_0__s1(instruction);
2980
2981 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
2982 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
2983 g_autofree char *u = ADDRESS(u_value, 2, info);
2984
2985 return img_format("BNEC %s, %s, %s", rs3, rt3, u);
2986 }
2987
2988
2989 /*
2990 *
2991 *
2992 * 3 2 1
2993 * 10987654321098765432109876543210
2994 * 001000 x1110000101
2995 * rt -----
2996 * rs -----
2997 * rd -----
2998 */
2999 static char *BNEC_32_(uint64 instruction, Dis_info *info)
3000 {
3001 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3002 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3003 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3004
3005 const char *rs = GPR(rs_value, info);
3006 const char *rt = GPR(rt_value, info);
3007 g_autofree char *s = ADDRESS(s_value, 4, info);
3008
3009 return img_format("BNEC %s, %s, %s", rs, rt, s);
3010 }
3011
3012
3013 /*
3014 *
3015 *
3016 * 3 2 1
3017 * 10987654321098765432109876543210
3018 * 001000 x1110000101
3019 * rt -----
3020 * rs -----
3021 * rd -----
3022 */
3023 static char *BNEIC(uint64 instruction, Dis_info *info)
3024 {
3025 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3026 uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
3027 int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
3028
3029 const char *rt = GPR(rt_value, info);
3030 g_autofree char *s = ADDRESS(s_value, 4, info);
3031
3032 return img_format("BNEIC %s, 0x%" PRIx64 ", %s", rt, u_value, s);
3033 }
3034
3035
3036 /*
3037 *
3038 *
3039 * 3 2 1
3040 * 10987654321098765432109876543210
3041 * 001000 x1110000101
3042 * rt -----
3043 * rs -----
3044 * rd -----
3045 */
3046 static char *BNEZC_16_(uint64 instruction, Dis_info *info)
3047 {
3048 uint64 rt3_value = extract_rt3_9_8_7(instruction);
3049 int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
3050
3051 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
3052 g_autofree char *s = ADDRESS(s_value, 2, info);
3053
3054 return img_format("BNEZC %s, %s", rt3, s);
3055 }
3056
3057
3058 /*
3059 * [DSP] BPOSGE32C offset - Branch on greater than or equal to value 32 in
3060 * DSPControl Pos field
3061 *
3062 * 3 2 1
3063 * 10987654321098765432109876543210
3064 * 100010xxxxx0010001
3065 * s[13:1] -------------
3066 * s[14] -
3067 */
3068 static char *BPOSGE32C(uint64 instruction, Dis_info *info)
3069 {
3070 int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
3071
3072 g_autofree char *s = ADDRESS(s_value, 4, info);
3073
3074 return img_format("BPOSGE32C %s", s);
3075 }
3076
3077
3078 /*
3079 *
3080 *
3081 * 3 2 1
3082 * 10987654321098765432109876543210
3083 * 001000 x1110000101
3084 * rt -----
3085 * rs -----
3086 * rd -----
3087 */
3088 static char *BREAK_16_(uint64 instruction, Dis_info *info)
3089 {
3090 uint64 code_value = extract_code_2_1_0(instruction);
3091
3092
3093 return img_format("BREAK 0x%" PRIx64, code_value);
3094 }
3095
3096
3097 /*
3098 * BREAK code - Break. Cause a Breakpoint exception
3099 *
3100 * 3 2 1
3101 * 10987654321098765432109876543210
3102 * 001000 x1110000101
3103 * rt -----
3104 * rs -----
3105 * rd -----
3106 */
3107 static char *BREAK_32_(uint64 instruction, Dis_info *info)
3108 {
3109 uint64 code_value = extract_code_18_to_0(instruction);
3110
3111
3112 return img_format("BREAK 0x%" PRIx64, code_value);
3113 }
3114
3115
3116 /*
3117 *
3118 *
3119 * 3 2 1
3120 * 10987654321098765432109876543210
3121 * 001000 x1110000101
3122 * rt -----
3123 * rs -----
3124 * rd -----
3125 */
3126 static char *BRSC(uint64 instruction, Dis_info *info)
3127 {
3128 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3129
3130 const char *rs = GPR(rs_value, info);
3131
3132 return img_format("BRSC %s", rs);
3133 }
3134
3135
3136 /*
3137 *
3138 *
3139 * 3 2 1
3140 * 10987654321098765432109876543210
3141 * 001000 x1110000101
3142 * rt -----
3143 * rs -----
3144 * rd -----
3145 */
3146 static char *CACHE(uint64 instruction, Dis_info *info)
3147 {
3148 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3149 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3150 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3151
3152 const char *rs = GPR(rs_value, info);
3153
3154 return img_format("CACHE 0x%" PRIx64 ", %" PRId64 "(%s)",
3155 op_value, s_value, rs);
3156 }
3157
3158
3159 /*
3160 *
3161 *
3162 * 3 2 1
3163 * 10987654321098765432109876543210
3164 * 001000 x1110000101
3165 * rt -----
3166 * rs -----
3167 * rd -----
3168 */
3169 static char *CACHEE(uint64 instruction, Dis_info *info)
3170 {
3171 uint64 op_value = extract_op_25_24_23_22_21(instruction);
3172 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3173 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
3174
3175 const char *rs = GPR(rs_value, info);
3176
3177 return img_format("CACHEE 0x%" PRIx64 ", %" PRId64 "(%s)",
3178 op_value, s_value, rs);
3179 }
3180
3181
3182 /*
3183 *
3184 *
3185 * 3 2 1
3186 * 10987654321098765432109876543210
3187 * 001000 x1110000101
3188 * rt -----
3189 * rs -----
3190 * rd -----
3191 */
3192 static char *CEIL_L_D(uint64 instruction, Dis_info *info)
3193 {
3194 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3195 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3196
3197 const char *ft = FPR(ft_value, info);
3198 const char *fs = FPR(fs_value, info);
3199
3200 return img_format("CEIL.L.D %s, %s", ft, fs);
3201 }
3202
3203
3204 /*
3205 *
3206 *
3207 * 3 2 1
3208 * 10987654321098765432109876543210
3209 * 001000 x1110000101
3210 * rt -----
3211 * rs -----
3212 * rd -----
3213 */
3214 static char *CEIL_L_S(uint64 instruction, Dis_info *info)
3215 {
3216 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3217 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3218
3219 const char *ft = FPR(ft_value, info);
3220 const char *fs = FPR(fs_value, info);
3221
3222 return img_format("CEIL.L.S %s, %s", ft, fs);
3223 }
3224
3225
3226 /*
3227 *
3228 *
3229 * 3 2 1
3230 * 10987654321098765432109876543210
3231 * 001000 x1110000101
3232 * rt -----
3233 * rs -----
3234 * rd -----
3235 */
3236 static char *CEIL_W_D(uint64 instruction, Dis_info *info)
3237 {
3238 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3239 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3240
3241 const char *ft = FPR(ft_value, info);
3242 const char *fs = FPR(fs_value, info);
3243
3244 return img_format("CEIL.W.D %s, %s", ft, fs);
3245 }
3246
3247
3248 /*
3249 *
3250 *
3251 * 3 2 1
3252 * 10987654321098765432109876543210
3253 * 001000 x1110000101
3254 * rt -----
3255 * rs -----
3256 * rd -----
3257 */
3258 static char *CEIL_W_S(uint64 instruction, Dis_info *info)
3259 {
3260 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3261 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3262
3263 const char *ft = FPR(ft_value, info);
3264 const char *fs = FPR(fs_value, info);
3265
3266 return img_format("CEIL.W.S %s, %s", ft, fs);
3267 }
3268
3269
3270 /*
3271 *
3272 *
3273 * 3 2 1
3274 * 10987654321098765432109876543210
3275 * 001000 x1110000101
3276 * rt -----
3277 * rs -----
3278 * rd -----
3279 */
3280 static char *CFC1(uint64 instruction, Dis_info *info)
3281 {
3282 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3283 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3284
3285 const char *rt = GPR(rt_value, info);
3286
3287 return img_format("CFC1 %s, CP%" PRIu64, rt, cs_value);
3288 }
3289
3290
3291 /*
3292 *
3293 *
3294 * 3 2 1
3295 * 10987654321098765432109876543210
3296 * 001000 x1110000101
3297 * rt -----
3298 * rs -----
3299 * rd -----
3300 */
3301 static char *CFC2(uint64 instruction, Dis_info *info)
3302 {
3303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3304 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
3305
3306 const char *rt = GPR(rt_value, info);
3307
3308 return img_format("CFC2 %s, CP%" PRIu64, rt, cs_value);
3309 }
3310
3311
3312 /*
3313 *
3314 *
3315 * 3 2 1
3316 * 10987654321098765432109876543210
3317 * 001000 x1110000101
3318 * rt -----
3319 * rs -----
3320 * rd -----
3321 */
3322 static char *CLASS_D(uint64 instruction, Dis_info *info)
3323 {
3324 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3325 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3326
3327 const char *ft = FPR(ft_value, info);
3328 const char *fs = FPR(fs_value, info);
3329
3330 return img_format("CLASS.D %s, %s", ft, fs);
3331 }
3332
3333
3334 /*
3335 *
3336 *
3337 * 3 2 1
3338 * 10987654321098765432109876543210
3339 * 001000 x1110000101
3340 * rt -----
3341 * rs -----
3342 * rd -----
3343 */
3344 static char *CLASS_S(uint64 instruction, Dis_info *info)
3345 {
3346 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3347 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3348
3349 const char *ft = FPR(ft_value, info);
3350 const char *fs = FPR(fs_value, info);
3351
3352 return img_format("CLASS.S %s, %s", ft, fs);
3353 }
3354
3355
3356 /*
3357 *
3358 *
3359 * 3 2 1
3360 * 10987654321098765432109876543210
3361 * 001000 x1110000101
3362 * rt -----
3363 * rs -----
3364 * rd -----
3365 */
3366 static char *CLO(uint64 instruction, Dis_info *info)
3367 {
3368 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3369 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3370
3371 const char *rt = GPR(rt_value, info);
3372 const char *rs = GPR(rs_value, info);
3373
3374 return img_format("CLO %s, %s", rt, rs);
3375 }
3376
3377
3378 /*
3379 *
3380 *
3381 * 3 2 1
3382 * 10987654321098765432109876543210
3383 * 001000 x1110000101
3384 * rt -----
3385 * rs -----
3386 * rd -----
3387 */
3388 static char *CLZ(uint64 instruction, Dis_info *info)
3389 {
3390 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3391 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3392
3393 const char *rt = GPR(rt_value, info);
3394 const char *rs = GPR(rs_value, info);
3395
3396 return img_format("CLZ %s, %s", rt, rs);
3397 }
3398
3399
3400 /*
3401 *
3402 *
3403 * 3 2 1
3404 * 10987654321098765432109876543210
3405 * 001000 x1110000101
3406 * rt -----
3407 * rs -----
3408 * rd -----
3409 */
3410 static char *CMP_AF_D(uint64 instruction, Dis_info *info)
3411 {
3412 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3413 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3414 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3415
3416 const char *fd = FPR(fd_value, info);
3417 const char *fs = FPR(fs_value, info);
3418 const char *ft = FPR(ft_value, info);
3419
3420 return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
3421 }
3422
3423
3424 /*
3425 *
3426 *
3427 * 3 2 1
3428 * 10987654321098765432109876543210
3429 * 001000 x1110000101
3430 * rt -----
3431 * rs -----
3432 * rd -----
3433 */
3434 static char *CMP_AF_S(uint64 instruction, Dis_info *info)
3435 {
3436 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3437 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3438 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3439
3440 const char *fd = FPR(fd_value, info);
3441 const char *fs = FPR(fs_value, info);
3442 const char *ft = FPR(ft_value, info);
3443
3444 return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
3445 }
3446
3447
3448 /*
3449 *
3450 *
3451 * 3 2 1
3452 * 10987654321098765432109876543210
3453 * 001000 x1110000101
3454 * rt -----
3455 * rs -----
3456 * rd -----
3457 */
3458 static char *CMP_EQ_D(uint64 instruction, Dis_info *info)
3459 {
3460 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3461 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3462 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3463
3464 const char *fd = FPR(fd_value, info);
3465 const char *fs = FPR(fs_value, info);
3466 const char *ft = FPR(ft_value, info);
3467
3468 return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
3469 }
3470
3471
3472 /*
3473 * [DSP] CMP.EQ.PH rs, rt - Compare vectors of signed integer halfword values
3474 *
3475 * 3 2 1
3476 * 10987654321098765432109876543210
3477 * 001000 xxxxxx0000000101
3478 * rt -----
3479 * rs -----
3480 */
3481 static char *CMP_EQ_PH(uint64 instruction, Dis_info *info)
3482 {
3483 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3484 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3485
3486 const char *rs = GPR(rs_value, info);
3487 const char *rt = GPR(rt_value, info);
3488
3489 return img_format("CMP.EQ.PH %s, %s", rs, rt);
3490 }
3491
3492
3493 /*
3494 *
3495 *
3496 * 3 2 1
3497 * 10987654321098765432109876543210
3498 * 001000 x1110000101
3499 * rt -----
3500 * rs -----
3501 * rd -----
3502 */
3503 static char *CMP_EQ_S(uint64 instruction, Dis_info *info)
3504 {
3505 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3506 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3507 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3508
3509 const char *fd = FPR(fd_value, info);
3510 const char *fs = FPR(fs_value, info);
3511 const char *ft = FPR(ft_value, info);
3512
3513 return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
3514 }
3515
3516
3517 /*
3518 *
3519 *
3520 * 3 2 1
3521 * 10987654321098765432109876543210
3522 * 001000 x1110000101
3523 * rt -----
3524 * rs -----
3525 * rd -----
3526 */
3527 static char *CMP_LE_D(uint64 instruction, Dis_info *info)
3528 {
3529 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3530 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3531 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3532
3533 const char *fd = FPR(fd_value, info);
3534 const char *fs = FPR(fs_value, info);
3535 const char *ft = FPR(ft_value, info);
3536
3537 return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
3538 }
3539
3540
3541 /*
3542 * [DSP] CMP.LE.PH rs, rt - Compare vectors of signed integer halfword values
3543 *
3544 * 3 2 1
3545 * 10987654321098765432109876543210
3546 * 001000 xxxxxx0010000101
3547 * rt -----
3548 * rs -----
3549 */
3550 static char *CMP_LE_PH(uint64 instruction, Dis_info *info)
3551 {
3552 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3553 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3554
3555 const char *rs = GPR(rs_value, info);
3556 const char *rt = GPR(rt_value, info);
3557
3558 return img_format("CMP.LE.PH %s, %s", rs, rt);
3559 }
3560
3561
3562 /*
3563 *
3564 *
3565 * 3 2 1
3566 * 10987654321098765432109876543210
3567 * 001000 x1110000101
3568 * rt -----
3569 * rs -----
3570 * rd -----
3571 */
3572 static char *CMP_LE_S(uint64 instruction, Dis_info *info)
3573 {
3574 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3575 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3576 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3577
3578 const char *fd = FPR(fd_value, info);
3579 const char *fs = FPR(fs_value, info);
3580 const char *ft = FPR(ft_value, info);
3581
3582 return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
3583 }
3584
3585
3586 /*
3587 *
3588 *
3589 * 3 2 1
3590 * 10987654321098765432109876543210
3591 * 001000 x1110000101
3592 * rt -----
3593 * rs -----
3594 * rd -----
3595 */
3596 static char *CMP_LT_D(uint64 instruction, Dis_info *info)
3597 {
3598 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3599 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3600 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3601
3602 const char *fd = FPR(fd_value, info);
3603 const char *fs = FPR(fs_value, info);
3604 const char *ft = FPR(ft_value, info);
3605
3606 return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
3607 }
3608
3609
3610 /*
3611 * [DSP] CMP.LT.PH rs, rt - Compare vectors of signed integer halfword values
3612 *
3613 * 3 2 1
3614 * 10987654321098765432109876543210
3615 * 001000 xxxxxx0001000101
3616 * rt -----
3617 * rs -----
3618 */
3619 static char *CMP_LT_PH(uint64 instruction, Dis_info *info)
3620 {
3621 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
3622 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
3623
3624 const char *rs = GPR(rs_value, info);
3625 const char *rt = GPR(rt_value, info);
3626
3627 return img_format("CMP.LT.PH %s, %s", rs, rt);
3628 }
3629
3630
3631 /*
3632 *
3633 *
3634 * 3 2 1
3635 * 10987654321098765432109876543210
3636 * 001000 x1110000101
3637 * rt -----
3638 * rs -----
3639 * rd -----
3640 */
3641 static char *CMP_LT_S(uint64 instruction, Dis_info *info)
3642 {
3643 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3644 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3645 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3646
3647 const char *fd = FPR(fd_value, info);
3648 const char *fs = FPR(fs_value, info);
3649 const char *ft = FPR(ft_value, info);
3650
3651 return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
3652 }
3653
3654
3655 /*
3656 *
3657 *
3658 * 3 2 1
3659 * 10987654321098765432109876543210
3660 * 001000 x1110000101
3661 * rt -----
3662 * rs -----
3663 * rd -----
3664 */
3665 static char *CMP_NE_D(uint64 instruction, Dis_info *info)
3666 {
3667 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3668 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3669 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3670
3671 const char *fd = FPR(fd_value, info);
3672 const char *fs = FPR(fs_value, info);
3673 const char *ft = FPR(ft_value, info);
3674
3675 return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
3676 }
3677
3678
3679 /*
3680 *
3681 *
3682 * 3 2 1
3683 * 10987654321098765432109876543210
3684 * 001000 x1110000101
3685 * rt -----
3686 * rs -----
3687 * rd -----
3688 */
3689 static char *CMP_NE_S(uint64 instruction, Dis_info *info)
3690 {
3691 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3692 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3693 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3694
3695 const char *fd = FPR(fd_value, info);
3696 const char *fs = FPR(fs_value, info);
3697 const char *ft = FPR(ft_value, info);
3698
3699 return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
3700 }
3701
3702
3703 /*
3704 *
3705 *
3706 * 3 2 1
3707 * 10987654321098765432109876543210
3708 * 001000 x1110000101
3709 * rt -----
3710 * rs -----
3711 * rd -----
3712 */
3713 static char *CMP_OR_D(uint64 instruction, Dis_info *info)
3714 {
3715 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3716 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3717 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3718
3719 const char *fd = FPR(fd_value, info);
3720 const char *fs = FPR(fs_value, info);
3721 const char *ft = FPR(ft_value, info);
3722
3723 return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
3724 }
3725
3726
3727 /*
3728 *
3729 *
3730 * 3 2 1
3731 * 10987654321098765432109876543210
3732 * 001000 x1110000101
3733 * rt -----
3734 * rs -----
3735 * rd -----
3736 */
3737 static char *CMP_OR_S(uint64 instruction, Dis_info *info)
3738 {
3739 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3740 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3741 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3742
3743 const char *fd = FPR(fd_value, info);
3744 const char *fs = FPR(fs_value, info);
3745 const char *ft = FPR(ft_value, info);
3746
3747 return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
3748 }
3749
3750
3751 /*
3752 *
3753 *
3754 * 3 2 1
3755 * 10987654321098765432109876543210
3756 * 001000 x1110000101
3757 * rt -----
3758 * rs -----
3759 * rd -----
3760 */
3761 static char *CMP_SAF_D(uint64 instruction, Dis_info *info)
3762 {
3763 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3764 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3765 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3766
3767 const char *fd = FPR(fd_value, info);
3768 const char *fs = FPR(fs_value, info);
3769 const char *ft = FPR(ft_value, info);
3770
3771 return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
3772 }
3773
3774
3775 /*
3776 *
3777 *
3778 * 3 2 1
3779 * 10987654321098765432109876543210
3780 * 001000 x1110000101
3781 * rt -----
3782 * rs -----
3783 * rd -----
3784 */
3785 static char *CMP_SAF_S(uint64 instruction, Dis_info *info)
3786 {
3787 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3788 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3789 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3790
3791 const char *fd = FPR(fd_value, info);
3792 const char *fs = FPR(fs_value, info);
3793 const char *ft = FPR(ft_value, info);
3794
3795 return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
3796 }
3797
3798
3799 /*
3800 *
3801 *
3802 * 3 2 1
3803 * 10987654321098765432109876543210
3804 * 001000 x1110000101
3805 * rt -----
3806 * rs -----
3807 * rd -----
3808 */
3809 static char *CMP_SEQ_D(uint64 instruction, Dis_info *info)
3810 {
3811 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3812 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3813 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3814
3815 const char *fd = FPR(fd_value, info);
3816 const char *fs = FPR(fs_value, info);
3817 const char *ft = FPR(ft_value, info);
3818
3819 return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
3820 }
3821
3822
3823 /*
3824 *
3825 *
3826 * 3 2 1
3827 * 10987654321098765432109876543210
3828 * 001000 x1110000101
3829 * rt -----
3830 * rs -----
3831 * rd -----
3832 */
3833 static char *CMP_SEQ_S(uint64 instruction, Dis_info *info)
3834 {
3835 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3836 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3837 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3838
3839 const char *fd = FPR(fd_value, info);
3840 const char *fs = FPR(fs_value, info);
3841 const char *ft = FPR(ft_value, info);
3842
3843 return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
3844 }
3845
3846
3847 /*
3848 *
3849 *
3850 * 3 2 1
3851 * 10987654321098765432109876543210
3852 * 001000 x1110000101
3853 * rt -----
3854 * rs -----
3855 * rd -----
3856 */
3857 static char *CMP_SLE_D(uint64 instruction, Dis_info *info)
3858 {
3859 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3860 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3861 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3862
3863 const char *fd = FPR(fd_value, info);
3864 const char *fs = FPR(fs_value, info);
3865 const char *ft = FPR(ft_value, info);
3866
3867 return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
3868 }
3869
3870
3871 /*
3872 *
3873 *
3874 * 3 2 1
3875 * 10987654321098765432109876543210
3876 * 001000 x1110000101
3877 * rt -----
3878 * rs -----
3879 * rd -----
3880 */
3881 static char *CMP_SLE_S(uint64 instruction, Dis_info *info)
3882 {
3883 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3884 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3885 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3886
3887 const char *fd = FPR(fd_value, info);
3888 const char *fs = FPR(fs_value, info);
3889 const char *ft = FPR(ft_value, info);
3890
3891 return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
3892 }
3893
3894
3895 /*
3896 *
3897 *
3898 * 3 2 1
3899 * 10987654321098765432109876543210
3900 * 001000 x1110000101
3901 * rt -----
3902 * rs -----
3903 * rd -----
3904 */
3905 static char *CMP_SLT_D(uint64 instruction, Dis_info *info)
3906 {
3907 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3908 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3909 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3910
3911 const char *fd = FPR(fd_value, info);
3912 const char *fs = FPR(fs_value, info);
3913 const char *ft = FPR(ft_value, info);
3914
3915 return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
3916 }
3917
3918
3919 /*
3920 *
3921 *
3922 * 3 2 1
3923 * 10987654321098765432109876543210
3924 * 001000 x1110000101
3925 * rt -----
3926 * rs -----
3927 * rd -----
3928 */
3929 static char *CMP_SLT_S(uint64 instruction, Dis_info *info)
3930 {
3931 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3932 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3933 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3934
3935 const char *fd = FPR(fd_value, info);
3936 const char *fs = FPR(fs_value, info);
3937 const char *ft = FPR(ft_value, info);
3938
3939 return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
3940 }
3941
3942
3943 /*
3944 *
3945 *
3946 * 3 2 1
3947 * 10987654321098765432109876543210
3948 * 001000 x1110000101
3949 * rt -----
3950 * rs -----
3951 * rd -----
3952 */
3953 static char *CMP_SNE_D(uint64 instruction, Dis_info *info)
3954 {
3955 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3956 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3957 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3958
3959 const char *fd = FPR(fd_value, info);
3960 const char *fs = FPR(fs_value, info);
3961 const char *ft = FPR(ft_value, info);
3962
3963 return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
3964 }
3965
3966
3967 /*
3968 *
3969 *
3970 * 3 2 1
3971 * 10987654321098765432109876543210
3972 * 001000 x1110000101
3973 * rt -----
3974 * rs -----
3975 * rd -----
3976 */
3977 static char *CMP_SNE_S(uint64 instruction, Dis_info *info)
3978 {
3979 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
3980 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
3981 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
3982
3983 const char *fd = FPR(fd_value, info);
3984 const char *fs = FPR(fs_value, info);
3985 const char *ft = FPR(ft_value, info);
3986
3987 return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
3988 }
3989
3990
3991 /*
3992 *
3993 *
3994 * 3 2 1
3995 * 10987654321098765432109876543210
3996 * 001000 x1110000101
3997 * rt -----
3998 * rs -----
3999 * rd -----
4000 */
4001 static char *CMP_SOR_D(uint64 instruction, Dis_info *info)
4002 {
4003 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4004 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4005 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4006
4007 const char *fd = FPR(fd_value, info);
4008 const char *fs = FPR(fs_value, info);
4009 const char *ft = FPR(ft_value, info);
4010
4011 return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
4012 }
4013
4014
4015 /*
4016 *
4017 *
4018 * 3 2 1
4019 * 10987654321098765432109876543210
4020 * 001000 x1110000101
4021 * rt -----
4022 * rs -----
4023 * rd -----
4024 */
4025 static char *CMP_SOR_S(uint64 instruction, Dis_info *info)
4026 {
4027 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4028 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4029 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4030
4031 const char *fd = FPR(fd_value, info);
4032 const char *fs = FPR(fs_value, info);
4033 const char *ft = FPR(ft_value, info);
4034
4035 return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
4036 }
4037
4038
4039 /*
4040 *
4041 *
4042 * 3 2 1
4043 * 10987654321098765432109876543210
4044 * 001000 x1110000101
4045 * rt -----
4046 * rs -----
4047 * rd -----
4048 */
4049 static char *CMP_SUEQ_D(uint64 instruction, Dis_info *info)
4050 {
4051 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4052 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4053 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4054
4055 const char *fd = FPR(fd_value, info);
4056 const char *fs = FPR(fs_value, info);
4057 const char *ft = FPR(ft_value, info);
4058
4059 return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
4060 }
4061
4062
4063 /*
4064 *
4065 *
4066 * 3 2 1
4067 * 10987654321098765432109876543210
4068 * 001000 x1110000101
4069 * rt -----
4070 * rs -----
4071 * rd -----
4072 */
4073 static char *CMP_SUEQ_S(uint64 instruction, Dis_info *info)
4074 {
4075 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4076 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4077 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4078
4079 const char *fd = FPR(fd_value, info);
4080 const char *fs = FPR(fs_value, info);
4081 const char *ft = FPR(ft_value, info);
4082
4083 return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
4084 }
4085
4086
4087 /*
4088 *
4089 *
4090 * 3 2 1
4091 * 10987654321098765432109876543210
4092 * 001000 x1110000101
4093 * rt -----
4094 * rs -----
4095 * rd -----
4096 */
4097 static char *CMP_SULE_D(uint64 instruction, Dis_info *info)
4098 {
4099 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4100 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4101 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4102
4103 const char *fd = FPR(fd_value, info);
4104 const char *fs = FPR(fs_value, info);
4105 const char *ft = FPR(ft_value, info);
4106
4107 return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
4108 }
4109
4110
4111 /*
4112 *
4113 *
4114 * 3 2 1
4115 * 10987654321098765432109876543210
4116 * 001000 x1110000101
4117 * rt -----
4118 * rs -----
4119 * rd -----
4120 */
4121 static char *CMP_SULE_S(uint64 instruction, Dis_info *info)
4122 {
4123 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4124 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4125 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4126
4127 const char *fd = FPR(fd_value, info);
4128 const char *fs = FPR(fs_value, info);
4129 const char *ft = FPR(ft_value, info);
4130
4131 return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
4132 }
4133
4134
4135 /*
4136 *
4137 *
4138 * 3 2 1
4139 * 10987654321098765432109876543210
4140 * 001000 x1110000101
4141 * rt -----
4142 * rs -----
4143 * rd -----
4144 */
4145 static char *CMP_SULT_D(uint64 instruction, Dis_info *info)
4146 {
4147 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4148 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4149 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4150
4151 const char *fd = FPR(fd_value, info);
4152 const char *fs = FPR(fs_value, info);
4153 const char *ft = FPR(ft_value, info);
4154
4155 return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
4156 }
4157
4158
4159 /*
4160 *
4161 *
4162 * 3 2 1
4163 * 10987654321098765432109876543210
4164 * 001000 x1110000101
4165 * rt -----
4166 * rs -----
4167 * rd -----
4168 */
4169 static char *CMP_SULT_S(uint64 instruction, Dis_info *info)
4170 {
4171 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4172 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4173 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4174
4175 const char *fd = FPR(fd_value, info);
4176 const char *fs = FPR(fs_value, info);
4177 const char *ft = FPR(ft_value, info);
4178
4179 return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
4180 }
4181
4182
4183 /*
4184 *
4185 *
4186 * 3 2 1
4187 * 10987654321098765432109876543210
4188 * 001000 x1110000101
4189 * rt -----
4190 * rs -----
4191 * rd -----
4192 */
4193 static char *CMP_SUN_D(uint64 instruction, Dis_info *info)
4194 {
4195 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4196 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4197 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4198
4199 const char *fd = FPR(fd_value, info);
4200 const char *fs = FPR(fs_value, info);
4201 const char *ft = FPR(ft_value, info);
4202
4203 return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
4204 }
4205
4206
4207 /*
4208 *
4209 *
4210 * 3 2 1
4211 * 10987654321098765432109876543210
4212 * 001000 x1110000101
4213 * rt -----
4214 * rs -----
4215 * rd -----
4216 */
4217 static char *CMP_SUNE_D(uint64 instruction, Dis_info *info)
4218 {
4219 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4220 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4221 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4222
4223 const char *fd = FPR(fd_value, info);
4224 const char *fs = FPR(fs_value, info);
4225 const char *ft = FPR(ft_value, info);
4226
4227 return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
4228 }
4229
4230
4231 /*
4232 *
4233 *
4234 * 3 2 1
4235 * 10987654321098765432109876543210
4236 * 001000 x1110000101
4237 * rt -----
4238 * rs -----
4239 * rd -----
4240 */
4241 static char *CMP_SUNE_S(uint64 instruction, Dis_info *info)
4242 {
4243 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4244 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4245 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4246
4247 const char *fd = FPR(fd_value, info);
4248 const char *fs = FPR(fs_value, info);
4249 const char *ft = FPR(ft_value, info);
4250
4251 return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
4252 }
4253
4254
4255 /*
4256 *
4257 *
4258 * 3 2 1
4259 * 10987654321098765432109876543210
4260 * 001000 x1110000101
4261 * rt -----
4262 * rs -----
4263 * rd -----
4264 */
4265 static char *CMP_SUN_S(uint64 instruction, Dis_info *info)
4266 {
4267 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4268 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4269 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4270
4271 const char *fd = FPR(fd_value, info);
4272 const char *fs = FPR(fs_value, info);
4273 const char *ft = FPR(ft_value, info);
4274
4275 return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
4276 }
4277
4278
4279 /*
4280 *
4281 *
4282 * 3 2 1
4283 * 10987654321098765432109876543210
4284 * 001000 x1110000101
4285 * rt -----
4286 * rs -----
4287 * rd -----
4288 */
4289 static char *CMP_UEQ_D(uint64 instruction, Dis_info *info)
4290 {
4291 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4292 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4293 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4294
4295 const char *fd = FPR(fd_value, info);
4296 const char *fs = FPR(fs_value, info);
4297 const char *ft = FPR(ft_value, info);
4298
4299 return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
4300 }
4301
4302
4303 /*
4304 *
4305 *
4306 * 3 2 1
4307 * 10987654321098765432109876543210
4308 * 001000 x1110000101
4309 * rt -----
4310 * rs -----
4311 * rd -----
4312 */
4313 static char *CMP_UEQ_S(uint64 instruction, Dis_info *info)
4314 {
4315 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4316 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4317 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4318
4319 const char *fd = FPR(fd_value, info);
4320 const char *fs = FPR(fs_value, info);
4321 const char *ft = FPR(ft_value, info);
4322
4323 return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
4324 }
4325
4326
4327 /*
4328 *
4329 *
4330 * 3 2 1
4331 * 10987654321098765432109876543210
4332 * 001000 x1110000101
4333 * rt -----
4334 * rs -----
4335 * rd -----
4336 */
4337 static char *CMP_ULE_D(uint64 instruction, Dis_info *info)
4338 {
4339 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4340 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4341 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4342
4343 const char *fd = FPR(fd_value, info);
4344 const char *fs = FPR(fs_value, info);
4345 const char *ft = FPR(ft_value, info);
4346
4347 return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
4348 }
4349
4350
4351 /*
4352 *
4353 *
4354 * 3 2 1
4355 * 10987654321098765432109876543210
4356 * 001000 x1110000101
4357 * rt -----
4358 * rs -----
4359 * rd -----
4360 */
4361 static char *CMP_ULE_S(uint64 instruction, Dis_info *info)
4362 {
4363 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4364 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4365 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4366
4367 const char *fd = FPR(fd_value, info);
4368 const char *fs = FPR(fs_value, info);
4369 const char *ft = FPR(ft_value, info);
4370
4371 return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
4372 }
4373
4374
4375 /*
4376 *
4377 *
4378 * 3 2 1
4379 * 10987654321098765432109876543210
4380 * 001000 x1110000101
4381 * rt -----
4382 * rs -----
4383 * rd -----
4384 */
4385 static char *CMP_ULT_D(uint64 instruction, Dis_info *info)
4386 {
4387 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4388 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4389 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4390
4391 const char *fd = FPR(fd_value, info);
4392 const char *fs = FPR(fs_value, info);
4393 const char *ft = FPR(ft_value, info);
4394
4395 return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
4396 }
4397
4398
4399 /*
4400 *
4401 *
4402 * 3 2 1
4403 * 10987654321098765432109876543210
4404 * 001000 x1110000101
4405 * rt -----
4406 * rs -----
4407 * rd -----
4408 */
4409 static char *CMP_ULT_S(uint64 instruction, Dis_info *info)
4410 {
4411 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4412 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4413 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4414
4415 const char *fd = FPR(fd_value, info);
4416 const char *fs = FPR(fs_value, info);
4417 const char *ft = FPR(ft_value, info);
4418
4419 return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
4420 }
4421
4422
4423 /*
4424 *
4425 *
4426 * 3 2 1
4427 * 10987654321098765432109876543210
4428 * 001000 x1110000101
4429 * rt -----
4430 * rs -----
4431 * rd -----
4432 */
4433 static char *CMP_UN_D(uint64 instruction, Dis_info *info)
4434 {
4435 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4436 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4437 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4438
4439 const char *fd = FPR(fd_value, info);
4440 const char *fs = FPR(fs_value, info);
4441 const char *ft = FPR(ft_value, info);
4442
4443 return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
4444 }
4445
4446
4447 /*
4448 *
4449 *
4450 * 3 2 1
4451 * 10987654321098765432109876543210
4452 * 001000 x1110000101
4453 * rt -----
4454 * rs -----
4455 * rd -----
4456 */
4457 static char *CMP_UNE_D(uint64 instruction, Dis_info *info)
4458 {
4459 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4460 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4461 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4462
4463 const char *fd = FPR(fd_value, info);
4464 const char *fs = FPR(fs_value, info);
4465 const char *ft = FPR(ft_value, info);
4466
4467 return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
4468 }
4469
4470
4471 /*
4472 *
4473 *
4474 * 3 2 1
4475 * 10987654321098765432109876543210
4476 * 001000 x1110000101
4477 * rt -----
4478 * rs -----
4479 * rd -----
4480 */
4481 static char *CMP_UNE_S(uint64 instruction, Dis_info *info)
4482 {
4483 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4484 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4485 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4486
4487 const char *fd = FPR(fd_value, info);
4488 const char *fs = FPR(fs_value, info);
4489 const char *ft = FPR(ft_value, info);
4490
4491 return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
4492 }
4493
4494
4495 /*
4496 *
4497 *
4498 * 3 2 1
4499 * 10987654321098765432109876543210
4500 * 001000 x1110000101
4501 * rt -----
4502 * rs -----
4503 * rd -----
4504 */
4505 static char *CMP_UN_S(uint64 instruction, Dis_info *info)
4506 {
4507 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4508 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4509 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
4510
4511 const char *fd = FPR(fd_value, info);
4512 const char *fs = FPR(fs_value, info);
4513 const char *ft = FPR(ft_value, info);
4514
4515 return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
4516 }
4517
4518
4519 /*
4520 * [DSP] CMPGDU.EQ.QB rd, rs, rt - Compare unsigned vector of
4521 * four bytes and write result to GPR and DSPControl
4522 *
4523 * 3 2 1
4524 * 10987654321098765432109876543210
4525 * 001000 x0110000101
4526 * rt -----
4527 * rs -----
4528 * rd -----
4529 */
4530 static char *CMPGDU_EQ_QB(uint64 instruction, Dis_info *info)
4531 {
4532 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4533 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4534 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4535
4536 const char *rd = GPR(rd_value, info);
4537 const char *rs = GPR(rs_value, info);
4538 const char *rt = GPR(rt_value, info);
4539
4540 return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
4541 }
4542
4543
4544 /*
4545 * [DSP] CMPGDU.LE.QB rd, rs, rt - Compare unsigned vector of
4546 * four bytes and write result to GPR and DSPControl
4547 *
4548 * 3 2 1
4549 * 10987654321098765432109876543210
4550 * 001000 x1000000101
4551 * rt -----
4552 * rs -----
4553 * rd -----
4554 */
4555 static char *CMPGDU_LE_QB(uint64 instruction, Dis_info *info)
4556 {
4557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4559 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4560
4561 const char *rd = GPR(rd_value, info);
4562 const char *rs = GPR(rs_value, info);
4563 const char *rt = GPR(rt_value, info);
4564
4565 return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
4566 }
4567
4568
4569 /*
4570 * [DSP] CMPGDU.EQ.QB rd, rs, rt - Compare unsigned vector of
4571 * four bytes and write result to GPR and DSPControl
4572 *
4573 * 3 2 1
4574 * 10987654321098765432109876543210
4575 * 001000 x0111000101
4576 * rt -----
4577 * rs -----
4578 * rd -----
4579 */
4580 static char *CMPGDU_LT_QB(uint64 instruction, Dis_info *info)
4581 {
4582 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4583 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4584 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4585
4586 const char *rd = GPR(rd_value, info);
4587 const char *rs = GPR(rs_value, info);
4588 const char *rt = GPR(rt_value, info);
4589
4590 return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
4591 }
4592
4593
4594 /*
4595 * [DSP] CMPGU.EQ.QB rd, rs, rt - Compare vectors of unsigned
4596 * byte values and write result to a GPR
4597 *
4598 * 3 2 1
4599 * 10987654321098765432109876543210
4600 * 001000 x0011000101
4601 * rt -----
4602 * rs -----
4603 * rd -----
4604 */
4605 static char *CMPGU_EQ_QB(uint64 instruction, Dis_info *info)
4606 {
4607 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4608 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4609 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4610
4611 const char *rd = GPR(rd_value, info);
4612 const char *rs = GPR(rs_value, info);
4613 const char *rt = GPR(rt_value, info);
4614
4615 return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
4616 }
4617
4618
4619 /*
4620 * [DSP] CMPGU.LE.QB rd, rs, rt - Compare vectors of unsigned
4621 * byte values and write result to a GPR
4622 *
4623 * 3 2 1
4624 * 10987654321098765432109876543210
4625 * 001000 x0101000101
4626 * rt -----
4627 * rs -----
4628 * rd -----
4629 */
4630 static char *CMPGU_LE_QB(uint64 instruction, Dis_info *info)
4631 {
4632 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4633 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4634 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4635
4636 const char *rd = GPR(rd_value, info);
4637 const char *rs = GPR(rs_value, info);
4638 const char *rt = GPR(rt_value, info);
4639
4640 return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
4641 }
4642
4643
4644 /*
4645 * [DSP] CMPGU.LT.QB rd, rs, rt - Compare vectors of unsigned
4646 * byte values and write result to a GPR
4647 *
4648 * 3 2 1
4649 * 10987654321098765432109876543210
4650 * 001000 x0100000101
4651 * rt -----
4652 * rs -----
4653 * rd -----
4654 */
4655 static char *CMPGU_LT_QB(uint64 instruction, Dis_info *info)
4656 {
4657 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4658 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4659 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
4660
4661 const char *rd = GPR(rd_value, info);
4662 const char *rs = GPR(rs_value, info);
4663 const char *rt = GPR(rt_value, info);
4664
4665 return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
4666 }
4667
4668
4669 /*
4670 * [DSP] CMPU.EQ.QB rd, rs, rt - Compare vectors of unsigned
4671 * byte values
4672 *
4673 * 3 2 1
4674 * 10987654321098765432109876543210
4675 * 001000 xxxxxx1001000101
4676 * rt -----
4677 * rs -----
4678 */
4679 static char *CMPU_EQ_QB(uint64 instruction, Dis_info *info)
4680 {
4681 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4682 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4683
4684 const char *rs = GPR(rs_value, info);
4685 const char *rt = GPR(rt_value, info);
4686
4687 return img_format("CMPU.EQ.QB %s, %s", rs, rt);
4688 }
4689
4690
4691 /*
4692 * [DSP] CMPU.LE.QB rd, rs, rt - Compare vectors of unsigned
4693 * byte values
4694 *
4695 * 3 2 1
4696 * 10987654321098765432109876543210
4697 * 001000 xxxxxx1011000101
4698 * rt -----
4699 * rs -----
4700 */
4701 static char *CMPU_LE_QB(uint64 instruction, Dis_info *info)
4702 {
4703 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4704 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4705
4706 const char *rs = GPR(rs_value, info);
4707 const char *rt = GPR(rt_value, info);
4708
4709 return img_format("CMPU.LE.QB %s, %s", rs, rt);
4710 }
4711
4712
4713 /*
4714 * [DSP] CMPU.LT.QB rd, rs, rt - Compare vectors of unsigned
4715 * byte values
4716 *
4717 * 3 2 1
4718 * 10987654321098765432109876543210
4719 * 001000 xxxxxx1010000101
4720 * rt -----
4721 * rs -----
4722 */
4723 static char *CMPU_LT_QB(uint64 instruction, Dis_info *info)
4724 {
4725 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4726 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
4727
4728 const char *rs = GPR(rs_value, info);
4729 const char *rt = GPR(rt_value, info);
4730
4731 return img_format("CMPU.LT.QB %s, %s", rs, rt);
4732 }
4733
4734
4735 /*
4736 *
4737 *
4738 * 3 2 1
4739 * 10987654321098765432109876543210
4740 * 001000 x1110000101
4741 * rt -----
4742 * rs -----
4743 * rd -----
4744 */
4745 static char *COP2_1(uint64 instruction, Dis_info *info)
4746 {
4747 uint64 cofun_value = extract_cofun_25_24_23(instruction);
4748
4749
4750 return img_format("COP2_1 0x%" PRIx64, cofun_value);
4751 }
4752
4753
4754 /*
4755 *
4756 *
4757 * 3 2 1
4758 * 10987654321098765432109876543210
4759 * 001000 x1110000101
4760 * rt -----
4761 * rs -----
4762 * rd -----
4763 */
4764 static char *CTC1(uint64 instruction, Dis_info *info)
4765 {
4766 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4767 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
4768
4769 const char *rt = GPR(rt_value, info);
4770
4771 return img_format("CTC1 %s, CP%" PRIu64, rt, cs_value);
4772 }
4773
4774
4775 /*
4776 *
4777 *
4778 * 3 2 1
4779 * 10987654321098765432109876543210
4780 * 001000 x1110000101
4781 * rt -----
4782 * rs -----
4783 * rd -----
4784 */
4785 static char *CTC2(uint64 instruction, Dis_info *info)
4786 {
4787 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
4788 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
4789
4790 const char *rt = GPR(rt_value, info);
4791
4792 return img_format("CTC2 %s, CP%" PRIu64, rt, cs_value);
4793 }
4794
4795
4796 /*
4797 *
4798 *
4799 * 3 2 1
4800 * 10987654321098765432109876543210
4801 * 001000 x1110000101
4802 * rt -----
4803 * rs -----
4804 * rd -----
4805 */
4806 static char *CVT_D_L(uint64 instruction, Dis_info *info)
4807 {
4808 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4809 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4810
4811 const char *ft = FPR(ft_value, info);
4812 const char *fs = FPR(fs_value, info);
4813
4814 return img_format("CVT.D.L %s, %s", ft, fs);
4815 }
4816
4817
4818 /*
4819 *
4820 *
4821 * 3 2 1
4822 * 10987654321098765432109876543210
4823 * 001000 x1110000101
4824 * rt -----
4825 * rs -----
4826 * rd -----
4827 */
4828 static char *CVT_D_S(uint64 instruction, Dis_info *info)
4829 {
4830 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4831 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4832
4833 const char *ft = FPR(ft_value, info);
4834 const char *fs = FPR(fs_value, info);
4835
4836 return img_format("CVT.D.S %s, %s", ft, fs);
4837 }
4838
4839
4840 /*
4841 *
4842 *
4843 * 3 2 1
4844 * 10987654321098765432109876543210
4845 * 001000 x1110000101
4846 * rt -----
4847 * rs -----
4848 * rd -----
4849 */
4850 static char *CVT_D_W(uint64 instruction, Dis_info *info)
4851 {
4852 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4853 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4854
4855 const char *ft = FPR(ft_value, info);
4856 const char *fs = FPR(fs_value, info);
4857
4858 return img_format("CVT.D.W %s, %s", ft, fs);
4859 }
4860
4861
4862 /*
4863 *
4864 *
4865 * 3 2 1
4866 * 10987654321098765432109876543210
4867 * 001000 x1110000101
4868 * rt -----
4869 * rs -----
4870 * rd -----
4871 */
4872 static char *CVT_L_D(uint64 instruction, Dis_info *info)
4873 {
4874 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4875 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4876
4877 const char *ft = FPR(ft_value, info);
4878 const char *fs = FPR(fs_value, info);
4879
4880 return img_format("CVT.L.D %s, %s", ft, fs);
4881 }
4882
4883
4884 /*
4885 *
4886 *
4887 * 3 2 1
4888 * 10987654321098765432109876543210
4889 * 001000 x1110000101
4890 * rt -----
4891 * rs -----
4892 * rd -----
4893 */
4894 static char *CVT_L_S(uint64 instruction, Dis_info *info)
4895 {
4896 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4897 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4898
4899 const char *ft = FPR(ft_value, info);
4900 const char *fs = FPR(fs_value, info);
4901
4902 return img_format("CVT.L.S %s, %s", ft, fs);
4903 }
4904
4905
4906 /*
4907 *
4908 *
4909 * 3 2 1
4910 * 10987654321098765432109876543210
4911 * 001000 x1110000101
4912 * rt -----
4913 * rs -----
4914 * rd -----
4915 */
4916 static char *CVT_S_D(uint64 instruction, Dis_info *info)
4917 {
4918 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4919 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4920
4921 const char *ft = FPR(ft_value, info);
4922 const char *fs = FPR(fs_value, info);
4923
4924 return img_format("CVT.S.D %s, %s", ft, fs);
4925 }
4926
4927
4928 /*
4929 *
4930 *
4931 * 3 2 1
4932 * 10987654321098765432109876543210
4933 * 001000 x1110000101
4934 * rt -----
4935 * rs -----
4936 * rd -----
4937 */
4938 static char *CVT_S_L(uint64 instruction, Dis_info *info)
4939 {
4940 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4941 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4942
4943 const char *ft = FPR(ft_value, info);
4944 const char *fs = FPR(fs_value, info);
4945
4946 return img_format("CVT.S.L %s, %s", ft, fs);
4947 }
4948
4949
4950 /*
4951 *
4952 *
4953 * 3 2 1
4954 * 10987654321098765432109876543210
4955 * 001000 x1110000101
4956 * rt -----
4957 * rs -----
4958 * rd -----
4959 */
4960 static char *CVT_S_PL(uint64 instruction, Dis_info *info)
4961 {
4962 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4963 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4964
4965 const char *ft = FPR(ft_value, info);
4966 const char *fs = FPR(fs_value, info);
4967
4968 return img_format("CVT.S.PL %s, %s", ft, fs);
4969 }
4970
4971
4972 /*
4973 *
4974 *
4975 * 3 2 1
4976 * 10987654321098765432109876543210
4977 * 001000 x1110000101
4978 * rt -----
4979 * rs -----
4980 * rd -----
4981 */
4982 static char *CVT_S_PU(uint64 instruction, Dis_info *info)
4983 {
4984 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
4985 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
4986
4987 const char *ft = FPR(ft_value, info);
4988 const char *fs = FPR(fs_value, info);
4989
4990 return img_format("CVT.S.PU %s, %s", ft, fs);
4991 }
4992
4993
4994 /*
4995 *
4996 *
4997 * 3 2 1
4998 * 10987654321098765432109876543210
4999 * 001000 x1110000101
5000 * rt -----
5001 * rs -----
5002 * rd -----
5003 */
5004 static char *CVT_S_W(uint64 instruction, Dis_info *info)
5005 {
5006 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5007 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5008
5009 const char *ft = FPR(ft_value, info);
5010 const char *fs = FPR(fs_value, info);
5011
5012 return img_format("CVT.S.W %s, %s", ft, fs);
5013 }
5014
5015
5016 /*
5017 *
5018 *
5019 * 3 2 1
5020 * 10987654321098765432109876543210
5021 * 001000 x1110000101
5022 * rt -----
5023 * rs -----
5024 * rd -----
5025 */
5026 static char *CVT_W_D(uint64 instruction, Dis_info *info)
5027 {
5028 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5029 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5030
5031 const char *ft = FPR(ft_value, info);
5032 const char *fs = FPR(fs_value, info);
5033
5034 return img_format("CVT.W.D %s, %s", ft, fs);
5035 }
5036
5037
5038 /*
5039 *
5040 *
5041 * 3 2 1
5042 * 10987654321098765432109876543210
5043 * 001000 x1110000101
5044 * rt -----
5045 * rs -----
5046 * rd -----
5047 */
5048 static char *CVT_W_S(uint64 instruction, Dis_info *info)
5049 {
5050 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5051 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5052
5053 const char *ft = FPR(ft_value, info);
5054 const char *fs = FPR(fs_value, info);
5055
5056 return img_format("CVT.W.S %s, %s", ft, fs);
5057 }
5058
5059
5060 /*
5061 *
5062 *
5063 * 3 2 1
5064 * 10987654321098765432109876543210
5065 * 001000 x1110000101
5066 * rt -----
5067 * rs -----
5068 * rd -----
5069 */
5070 static char *DADDIU_48_(uint64 instruction, Dis_info *info)
5071 {
5072 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5073 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
5074
5075 const char *rt = GPR(rt_value, info);
5076
5077 return img_format("DADDIU %s, %" PRId64, rt, s_value);
5078 }
5079
5080
5081 /*
5082 *
5083 *
5084 * 3 2 1
5085 * 10987654321098765432109876543210
5086 * 001000 x1110000101
5087 * rt -----
5088 * rs -----
5089 * rd -----
5090 */
5091 static char *DADDIU_NEG_(uint64 instruction, Dis_info *info)
5092 {
5093 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5094 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5095 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5096
5097 const char *rt = GPR(rt_value, info);
5098 const char *rs = GPR(rs_value, info);
5099 int64 u = neg_copy(u_value);
5100
5101 return img_format("DADDIU %s, %s, %" PRId64, rt, rs, u);
5102 }
5103
5104
5105 /*
5106 *
5107 *
5108 * 3 2 1
5109 * 10987654321098765432109876543210
5110 * 001000 x1110000101
5111 * rt -----
5112 * rs -----
5113 * rd -----
5114 */
5115 static char *DADDIU_U12_(uint64 instruction, Dis_info *info)
5116 {
5117 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5118 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5119 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
5120
5121 const char *rt = GPR(rt_value, info);
5122 const char *rs = GPR(rs_value, info);
5123
5124 return img_format("DADDIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
5125 }
5126
5127
5128 /*
5129 *
5130 *
5131 * 3 2 1
5132 * 10987654321098765432109876543210
5133 * 001000 x1110000101
5134 * rt -----
5135 * rs -----
5136 * rd -----
5137 */
5138 static char *DADD(uint64 instruction, Dis_info *info)
5139 {
5140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5141 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5142 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5143
5144 const char *rd = GPR(rd_value, info);
5145 const char *rs = GPR(rs_value, info);
5146 const char *rt = GPR(rt_value, info);
5147
5148 return img_format("DADD %s, %s, %s", rd, rs, rt);
5149 }
5150
5151
5152 /*
5153 *
5154 *
5155 * 3 2 1
5156 * 10987654321098765432109876543210
5157 * 001000 x1110000101
5158 * rt -----
5159 * rs -----
5160 * rd -----
5161 */
5162 static char *DADDU(uint64 instruction, Dis_info *info)
5163 {
5164 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5165 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5166 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5167
5168 const char *rd = GPR(rd_value, info);
5169 const char *rs = GPR(rs_value, info);
5170 const char *rt = GPR(rt_value, info);
5171
5172 return img_format("DADDU %s, %s, %s", rd, rs, rt);
5173 }
5174
5175
5176 /*
5177 *
5178 *
5179 * 3 2 1
5180 * 10987654321098765432109876543210
5181 * 001000 x1110000101
5182 * rt -----
5183 * rs -----
5184 * rd -----
5185 */
5186 static char *DCLO(uint64 instruction, Dis_info *info)
5187 {
5188 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5189 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5190
5191 const char *rt = GPR(rt_value, info);
5192 const char *rs = GPR(rs_value, info);
5193
5194 return img_format("DCLO %s, %s", rt, rs);
5195 }
5196
5197
5198 /*
5199 *
5200 *
5201 * 3 2 1
5202 * 10987654321098765432109876543210
5203 * 001000 x1110000101
5204 * rt -----
5205 * rs -----
5206 * rd -----
5207 */
5208 static char *DCLZ(uint64 instruction, Dis_info *info)
5209 {
5210 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5211 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5212
5213 const char *rt = GPR(rt_value, info);
5214 const char *rs = GPR(rs_value, info);
5215
5216 return img_format("DCLZ %s, %s", rt, rs);
5217 }
5218
5219
5220 /*
5221 *
5222 *
5223 * 3 2 1
5224 * 10987654321098765432109876543210
5225 * 001000 x1110000101
5226 * rt -----
5227 * rs -----
5228 * rd -----
5229 */
5230 static char *DDIV(uint64 instruction, Dis_info *info)
5231 {
5232 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5233 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5234 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5235
5236 const char *rd = GPR(rd_value, info);
5237 const char *rs = GPR(rs_value, info);
5238 const char *rt = GPR(rt_value, info);
5239
5240 return img_format("DDIV %s, %s, %s", rd, rs, rt);
5241 }
5242
5243
5244 /*
5245 *
5246 *
5247 * 3 2 1
5248 * 10987654321098765432109876543210
5249 * 001000 x1110000101
5250 * rt -----
5251 * rs -----
5252 * rd -----
5253 */
5254 static char *DDIVU(uint64 instruction, Dis_info *info)
5255 {
5256 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5257 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5258 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5259
5260 const char *rd = GPR(rd_value, info);
5261 const char *rs = GPR(rs_value, info);
5262 const char *rt = GPR(rt_value, info);
5263
5264 return img_format("DDIVU %s, %s, %s", rd, rs, rt);
5265 }
5266
5267
5268 /*
5269 *
5270 *
5271 * 3 2 1
5272 * 10987654321098765432109876543210
5273 * 001000 x1110000101
5274 * rt -----
5275 * rs -----
5276 * rd -----
5277 */
5278 static char *DERET(uint64 instruction, Dis_info *info)
5279 {
5280 (void)instruction;
5281
5282 return g_strdup("DERET ");
5283 }
5284
5285
5286 /*
5287 *
5288 *
5289 * 3 2 1
5290 * 10987654321098765432109876543210
5291 * 001000 x1110000101
5292 * rt -----
5293 * rs -----
5294 * rd -----
5295 */
5296 static char *DEXTM(uint64 instruction, Dis_info *info)
5297 {
5298 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5299 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5300 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5301 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5302
5303 const char *rt = GPR(rt_value, info);
5304 const char *rs = GPR(rs_value, info);
5305 uint64 msbd = encode_msbd_from_size(msbd_value);
5306
5307 return img_format("DEXTM %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5308 rt, rs, lsb_value, msbd);
5309 }
5310
5311
5312 /*
5313 *
5314 *
5315 * 3 2 1
5316 * 10987654321098765432109876543210
5317 * 001000 x1110000101
5318 * rt -----
5319 * rs -----
5320 * rd -----
5321 */
5322 static char *DEXT(uint64 instruction, Dis_info *info)
5323 {
5324 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5325 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5326 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5327 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5328
5329 const char *rt = GPR(rt_value, info);
5330 const char *rs = GPR(rs_value, info);
5331 uint64 msbd = encode_msbd_from_size(msbd_value);
5332
5333 return img_format("DEXT %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5334 rt, rs, lsb_value, msbd);
5335 }
5336
5337
5338 /*
5339 *
5340 *
5341 * 3 2 1
5342 * 10987654321098765432109876543210
5343 * 001000 x1110000101
5344 * rt -----
5345 * rs -----
5346 * rd -----
5347 */
5348 static char *DEXTU(uint64 instruction, Dis_info *info)
5349 {
5350 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5351 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5352 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5353 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5354
5355 const char *rt = GPR(rt_value, info);
5356 const char *rs = GPR(rs_value, info);
5357 uint64 msbd = encode_msbd_from_size(msbd_value);
5358
5359 return img_format("DEXTU %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5360 rt, rs, lsb_value, msbd);
5361 }
5362
5363
5364 /*
5365 *
5366 *
5367 * 3 2 1
5368 * 10987654321098765432109876543210
5369 * 001000 x1110000101
5370 * rt -----
5371 * rs -----
5372 * rd -----
5373 */
5374 static char *DINSM(uint64 instruction, Dis_info *info)
5375 {
5376 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5377 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5378 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5379 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5380
5381 const char *rt = GPR(rt_value, info);
5382 const char *rs = GPR(rs_value, info);
5383 /* !!!!!!!!!! - no conversion function */
5384
5385 return img_format("DINSM %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5386 rt, rs, lsb_value, msbd_value);
5387 /* hand edited */
5388 }
5389
5390
5391 /*
5392 *
5393 *
5394 * 3 2 1
5395 * 10987654321098765432109876543210
5396 * 001000 x1110000101
5397 * rt -----
5398 * rs -----
5399 * rd -----
5400 */
5401 static char *DINS(uint64 instruction, Dis_info *info)
5402 {
5403 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5404 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5405 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5406 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5407
5408 const char *rt = GPR(rt_value, info);
5409 const char *rs = GPR(rs_value, info);
5410 /* !!!!!!!!!! - no conversion function */
5411
5412 return img_format("DINS %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5413 rt, rs, lsb_value, msbd_value);
5414 /* hand edited */
5415 }
5416
5417
5418 /*
5419 *
5420 *
5421 * 3 2 1
5422 * 10987654321098765432109876543210
5423 * 001000 x1110000101
5424 * rt -----
5425 * rs -----
5426 * rd -----
5427 */
5428 static char *DINSU(uint64 instruction, Dis_info *info)
5429 {
5430 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5431 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5432 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
5433 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
5434
5435 const char *rt = GPR(rt_value, info);
5436 const char *rs = GPR(rs_value, info);
5437 /* !!!!!!!!!! - no conversion function */
5438
5439 return img_format("DINSU %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
5440 rt, rs, lsb_value, msbd_value);
5441 /* hand edited */
5442 }
5443
5444
5445 /*
5446 *
5447 *
5448 * 3 2 1
5449 * 10987654321098765432109876543210
5450 * 001000 x1110000101
5451 * rt -----
5452 * rs -----
5453 * rd -----
5454 */
5455 static char *DI(uint64 instruction, Dis_info *info)
5456 {
5457 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5458
5459 const char *rt = GPR(rt_value, info);
5460
5461 return img_format("DI %s", rt);
5462 }
5463
5464
5465 /*
5466 *
5467 *
5468 * 3 2 1
5469 * 10987654321098765432109876543210
5470 * 001000 x1110000101
5471 * rt -----
5472 * rs -----
5473 * rd -----
5474 */
5475 static char *DIV(uint64 instruction, Dis_info *info)
5476 {
5477 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5478 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5479 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5480
5481 const char *rd = GPR(rd_value, info);
5482 const char *rs = GPR(rs_value, info);
5483 const char *rt = GPR(rt_value, info);
5484
5485 return img_format("DIV %s, %s, %s", rd, rs, rt);
5486 }
5487
5488
5489 /*
5490 *
5491 *
5492 * 3 2 1
5493 * 10987654321098765432109876543210
5494 * 001000 x1110000101
5495 * rt -----
5496 * rs -----
5497 * rd -----
5498 */
5499 static char *DIV_D(uint64 instruction, Dis_info *info)
5500 {
5501 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5502 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5503 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5504
5505 const char *fd = FPR(fd_value, info);
5506 const char *fs = FPR(fs_value, info);
5507 const char *ft = FPR(ft_value, info);
5508
5509 return img_format("DIV.D %s, %s, %s", fd, fs, ft);
5510 }
5511
5512
5513 /*
5514 *
5515 *
5516 * 3 2 1
5517 * 10987654321098765432109876543210
5518 * 001000 x1110000101
5519 * rt -----
5520 * rs -----
5521 * rd -----
5522 */
5523 static char *DIV_S(uint64 instruction, Dis_info *info)
5524 {
5525 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
5526 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5527 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
5528
5529 const char *fd = FPR(fd_value, info);
5530 const char *fs = FPR(fs_value, info);
5531 const char *ft = FPR(ft_value, info);
5532
5533 return img_format("DIV.S %s, %s, %s", fd, fs, ft);
5534 }
5535
5536
5537 /*
5538 *
5539 *
5540 * 3 2 1
5541 * 10987654321098765432109876543210
5542 * 001000 x1110000101
5543 * rt -----
5544 * rs -----
5545 * rd -----
5546 */
5547 static char *DIVU(uint64 instruction, Dis_info *info)
5548 {
5549 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5550 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5551 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5552
5553 const char *rd = GPR(rd_value, info);
5554 const char *rs = GPR(rs_value, info);
5555 const char *rt = GPR(rt_value, info);
5556
5557 return img_format("DIVU %s, %s, %s", rd, rs, rt);
5558 }
5559
5560
5561 /*
5562 *
5563 *
5564 * 3 2 1
5565 * 10987654321098765432109876543210
5566 * 001000 x1110000101
5567 * rt -----
5568 * rs -----
5569 * rd -----
5570 */
5571 static char *DLSA(uint64 instruction, Dis_info *info)
5572 {
5573 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5574 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5575 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5576 uint64 u2_value = extract_u2_10_9(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("DLSA %s, %s, %s, 0x%" PRIx64, rd, rs, rt, u2_value);
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 *DLUI_48_(uint64 instruction, Dis_info *info)
5597 {
5598 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
5599 uint64 u_value = extract_u_31_to_0__s32(instruction);
5600
5601 const char *rt = GPR(rt_value, info);
5602
5603 return img_format("DLUI %s, 0x%" PRIx64, rt, u_value);
5604 }
5605
5606
5607 /*
5608 *
5609 *
5610 * 3 2 1
5611 * 10987654321098765432109876543210
5612 * 001000 x1110000101
5613 * rt -----
5614 * rs -----
5615 * rd -----
5616 */
5617 static char *DMFC0(uint64 instruction, Dis_info *info)
5618 {
5619 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5620 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5621 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5622
5623 const char *rt = GPR(rt_value, info);
5624
5625 return img_format("DMFC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5626 rt, c0s_value, sel_value);
5627 }
5628
5629
5630 /*
5631 *
5632 *
5633 * 3 2 1
5634 * 10987654321098765432109876543210
5635 * 001000 x1110000101
5636 * rt -----
5637 * rs -----
5638 * rd -----
5639 */
5640 static char *DMFC1(uint64 instruction, Dis_info *info)
5641 {
5642 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5643 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5644
5645 const char *rt = GPR(rt_value, info);
5646 const char *fs = FPR(fs_value, info);
5647
5648 return img_format("DMFC1 %s, %s", rt, fs);
5649 }
5650
5651
5652 /*
5653 *
5654 *
5655 * 3 2 1
5656 * 10987654321098765432109876543210
5657 * 001000 x1110000101
5658 * rt -----
5659 * rs -----
5660 * rd -----
5661 */
5662 static char *DMFC2(uint64 instruction, Dis_info *info)
5663 {
5664 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5665 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5666
5667 const char *rt = GPR(rt_value, info);
5668
5669 return img_format("DMFC2 %s, CP%" PRIu64, rt, cs_value);
5670 }
5671
5672
5673 /*
5674 *
5675 *
5676 * 3 2 1
5677 * 10987654321098765432109876543210
5678 * 001000 x1110000101
5679 * rt -----
5680 * rs -----
5681 * rd -----
5682 */
5683 static char *DMFGC0(uint64 instruction, Dis_info *info)
5684 {
5685 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5686 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5687 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5688
5689 const char *rt = GPR(rt_value, info);
5690
5691 return img_format("DMFGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5692 rt, c0s_value, sel_value);
5693 }
5694
5695
5696 /*
5697 *
5698 *
5699 * 3 2 1
5700 * 10987654321098765432109876543210
5701 * 001000 x1110000101
5702 * rt -----
5703 * rs -----
5704 * rd -----
5705 */
5706 static char *DMOD(uint64 instruction, Dis_info *info)
5707 {
5708 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5709 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5710 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5711
5712 const char *rd = GPR(rd_value, info);
5713 const char *rs = GPR(rs_value, info);
5714 const char *rt = GPR(rt_value, info);
5715
5716 return img_format("DMOD %s, %s, %s", rd, rs, rt);
5717 }
5718
5719
5720 /*
5721 *
5722 *
5723 * 3 2 1
5724 * 10987654321098765432109876543210
5725 * 001000 x1110000101
5726 * rt -----
5727 * rs -----
5728 * rd -----
5729 */
5730 static char *DMODU(uint64 instruction, Dis_info *info)
5731 {
5732 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5733 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5734 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5735
5736 const char *rd = GPR(rd_value, info);
5737 const char *rs = GPR(rs_value, info);
5738 const char *rt = GPR(rt_value, info);
5739
5740 return img_format("DMODU %s, %s, %s", rd, rs, rt);
5741 }
5742
5743
5744 /*
5745 *
5746 *
5747 * 3 2 1
5748 * 10987654321098765432109876543210
5749 * 001000 x1110000101
5750 * rt -----
5751 * rs -----
5752 * rd -----
5753 */
5754 static char *DMTC0(uint64 instruction, Dis_info *info)
5755 {
5756 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5757 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5758 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5759
5760 const char *rt = GPR(rt_value, info);
5761
5762 return img_format("DMTC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5763 rt, c0s_value, sel_value);
5764 }
5765
5766
5767 /*
5768 *
5769 *
5770 * 3 2 1
5771 * 10987654321098765432109876543210
5772 * 001000 x1110000101
5773 * rt -----
5774 * rs -----
5775 * rd -----
5776 */
5777 static char *DMTC1(uint64 instruction, Dis_info *info)
5778 {
5779 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5780 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
5781
5782 const char *rt = GPR(rt_value, info);
5783 const char *fs = FPR(fs_value, info);
5784
5785 return img_format("DMTC1 %s, %s", rt, fs);
5786 }
5787
5788
5789 /*
5790 *
5791 *
5792 * 3 2 1
5793 * 10987654321098765432109876543210
5794 * 001000 x1110000101
5795 * rt -----
5796 * rs -----
5797 * rd -----
5798 */
5799 static char *DMTC2(uint64 instruction, Dis_info *info)
5800 {
5801 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5802 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
5803
5804 const char *rt = GPR(rt_value, info);
5805
5806 return img_format("DMTC2 %s, CP%" PRIu64, rt, cs_value);
5807 }
5808
5809
5810 /*
5811 *
5812 *
5813 * 3 2 1
5814 * 10987654321098765432109876543210
5815 * 001000 x1110000101
5816 * rt -----
5817 * rs -----
5818 * rd -----
5819 */
5820 static char *DMTGC0(uint64 instruction, Dis_info *info)
5821 {
5822 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5823 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
5824 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
5825
5826 const char *rt = GPR(rt_value, info);
5827
5828 return img_format("DMTGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
5829 rt, c0s_value, sel_value);
5830 }
5831
5832
5833 /*
5834 *
5835 *
5836 * 3 2 1
5837 * 10987654321098765432109876543210
5838 * 001000 x1110000101
5839 * rt -----
5840 * rs -----
5841 * rd -----
5842 */
5843 static char *DMT(uint64 instruction, Dis_info *info)
5844 {
5845 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5846
5847 const char *rt = GPR(rt_value, info);
5848
5849 return img_format("DMT %s", rt);
5850 }
5851
5852
5853 /*
5854 *
5855 *
5856 * 3 2 1
5857 * 10987654321098765432109876543210
5858 * 001000 x1110000101
5859 * rt -----
5860 * rs -----
5861 * rd -----
5862 */
5863 static char *DMUH(uint64 instruction, Dis_info *info)
5864 {
5865 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5866 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5867 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5868
5869 const char *rd = GPR(rd_value, info);
5870 const char *rs = GPR(rs_value, info);
5871 const char *rt = GPR(rt_value, info);
5872
5873 return img_format("DMUH %s, %s, %s", rd, rs, rt);
5874 }
5875
5876
5877 /*
5878 *
5879 *
5880 * 3 2 1
5881 * 10987654321098765432109876543210
5882 * 001000 x1110000101
5883 * rt -----
5884 * rs -----
5885 * rd -----
5886 */
5887 static char *DMUHU(uint64 instruction, Dis_info *info)
5888 {
5889 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5890 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5891 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5892
5893 const char *rd = GPR(rd_value, info);
5894 const char *rs = GPR(rs_value, info);
5895 const char *rt = GPR(rt_value, info);
5896
5897 return img_format("DMUHU %s, %s, %s", rd, rs, rt);
5898 }
5899
5900
5901 /*
5902 *
5903 *
5904 * 3 2 1
5905 * 10987654321098765432109876543210
5906 * 001000 x1110000101
5907 * rt -----
5908 * rs -----
5909 * rd -----
5910 */
5911 static char *DMUL(uint64 instruction, Dis_info *info)
5912 {
5913 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5914 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5915 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5916
5917 const char *rd = GPR(rd_value, info);
5918 const char *rs = GPR(rs_value, info);
5919 const char *rt = GPR(rt_value, info);
5920
5921 return img_format("DMUL %s, %s, %s", rd, rs, rt);
5922 }
5923
5924
5925 /*
5926 *
5927 *
5928 * 3 2 1
5929 * 10987654321098765432109876543210
5930 * 001000 x1110000101
5931 * rt -----
5932 * rs -----
5933 * rd -----
5934 */
5935 static char *DMULU(uint64 instruction, Dis_info *info)
5936 {
5937 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
5938 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
5939 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
5940
5941 const char *rd = GPR(rd_value, info);
5942 const char *rs = GPR(rs_value, info);
5943 const char *rt = GPR(rt_value, info);
5944
5945 return img_format("DMULU %s, %s, %s", rd, rs, rt);
5946 }
5947
5948
5949 /*
5950 * [DSP] DPA.W.PH ac, rs, rt - Dot product with accumulate on
5951 * vector integer halfword elements
5952 *
5953 * 3 2 1
5954 * 10987654321098765432109876543210
5955 * 001000 00000010111111
5956 * rt -----
5957 * rs -----
5958 * ac --
5959 */
5960 static char *DPA_W_PH(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 ac_value = extract_ac_15_14(instruction);
5965
5966 const char *ac = AC(ac_value, info);
5967 const char *rs = GPR(rs_value, info);
5968 const char *rt = GPR(rt_value, info);
5969
5970 return img_format("DPA.W.PH %s, %s, %s", ac, 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 *DPAQ_SA_L_W(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 ac_value = extract_ac_15_14(instruction);
5989
5990 const char *ac = AC(ac_value, info);
5991 const char *rs = GPR(rs_value, info);
5992 const char *rt = GPR(rt_value, info);
5993
5994 return img_format("DPAQ_SA.L.W %s, %s, %s", ac, 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 *DPAQ_S_W_PH(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 ac_value = extract_ac_15_14(instruction);
6013
6014 const char *ac = AC(ac_value, info);
6015 const char *rs = GPR(rs_value, info);
6016 const char *rt = GPR(rt_value, info);
6017
6018 return img_format("DPAQ_S.W.PH %s, %s, %s", ac, 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 *DPAQX_SA_W_PH(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 ac_value = extract_ac_15_14(instruction);
6037
6038 const char *ac = AC(ac_value, info);
6039 const char *rs = GPR(rs_value, info);
6040 const char *rt = GPR(rt_value, info);
6041
6042 return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6043 }
6044
6045
6046 /*
6047 *
6048 *
6049 * 3 2 1
6050 * 10987654321098765432109876543210
6051 * 001000 x1110000101
6052 * rt -----
6053 * rs -----
6054 * rd -----
6055 */
6056 static char *DPAQX_S_W_PH(uint64 instruction, Dis_info *info)
6057 {
6058 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6059 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6060 uint64 ac_value = extract_ac_15_14(instruction);
6061
6062 const char *ac = AC(ac_value, info);
6063 const char *rs = GPR(rs_value, info);
6064 const char *rt = GPR(rt_value, info);
6065
6066 return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
6067 }
6068
6069
6070 /*
6071 *
6072 *
6073 * 3 2 1
6074 * 10987654321098765432109876543210
6075 * 001000 x1110000101
6076 * rt -----
6077 * rs -----
6078 * rd -----
6079 */
6080 static char *DPAU_H_QBL(uint64 instruction, Dis_info *info)
6081 {
6082 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6083 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6084 uint64 ac_value = extract_ac_15_14(instruction);
6085
6086 const char *ac = AC(ac_value, info);
6087 const char *rs = GPR(rs_value, info);
6088 const char *rt = GPR(rt_value, info);
6089
6090 return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
6091 }
6092
6093
6094 /*
6095 *
6096 *
6097 * 3 2 1
6098 * 10987654321098765432109876543210
6099 * 001000 x1110000101
6100 * rt -----
6101 * rs -----
6102 * rd -----
6103 */
6104 static char *DPAU_H_QBR(uint64 instruction, Dis_info *info)
6105 {
6106 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6107 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6108 uint64 ac_value = extract_ac_15_14(instruction);
6109
6110 const char *ac = AC(ac_value, info);
6111 const char *rs = GPR(rs_value, info);
6112 const char *rt = GPR(rt_value, info);
6113
6114 return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
6115 }
6116
6117
6118 /*
6119 *
6120 *
6121 * 3 2 1
6122 * 10987654321098765432109876543210
6123 * 001000 x1110000101
6124 * rt -----
6125 * rs -----
6126 * rd -----
6127 */
6128 static char *DPAX_W_PH(uint64 instruction, Dis_info *info)
6129 {
6130 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6131 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6132 uint64 ac_value = extract_ac_15_14(instruction);
6133
6134 const char *ac = AC(ac_value, info);
6135 const char *rs = GPR(rs_value, info);
6136 const char *rt = GPR(rt_value, info);
6137
6138 return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
6139 }
6140
6141
6142 /*
6143 *
6144 *
6145 * 3 2 1
6146 * 10987654321098765432109876543210
6147 * 001000 x1110000101
6148 * rt -----
6149 * rs -----
6150 * rd -----
6151 */
6152 static char *DPS_W_PH(uint64 instruction, Dis_info *info)
6153 {
6154 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6155 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6156 uint64 ac_value = extract_ac_15_14(instruction);
6157
6158 const char *ac = AC(ac_value, info);
6159 const char *rs = GPR(rs_value, info);
6160 const char *rt = GPR(rt_value, info);
6161
6162 return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
6163 }
6164
6165
6166 /*
6167 *
6168 *
6169 * 3 2 1
6170 * 10987654321098765432109876543210
6171 * 001000 x1110000101
6172 * rt -----
6173 * rs -----
6174 * rd -----
6175 */
6176 static char *DPSQ_SA_L_W(uint64 instruction, Dis_info *info)
6177 {
6178 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6179 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6180 uint64 ac_value = extract_ac_15_14(instruction);
6181
6182 const char *ac = AC(ac_value, info);
6183 const char *rs = GPR(rs_value, info);
6184 const char *rt = GPR(rt_value, info);
6185
6186 return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
6187 }
6188
6189
6190 /*
6191 *
6192 *
6193 * 3 2 1
6194 * 10987654321098765432109876543210
6195 * 001000 x1110000101
6196 * rt -----
6197 * rs -----
6198 * rd -----
6199 */
6200 static char *DPSQ_S_W_PH(uint64 instruction, Dis_info *info)
6201 {
6202 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6203 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6204 uint64 ac_value = extract_ac_15_14(instruction);
6205
6206 const char *ac = AC(ac_value, info);
6207 const char *rs = GPR(rs_value, info);
6208 const char *rt = GPR(rt_value, info);
6209
6210 return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
6211 }
6212
6213
6214 /*
6215 *
6216 *
6217 * 3 2 1
6218 * 10987654321098765432109876543210
6219 * 001000 x1110000101
6220 * rt -----
6221 * rs -----
6222 * rd -----
6223 */
6224 static char *DPSQX_SA_W_PH(uint64 instruction, Dis_info *info)
6225 {
6226 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6227 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6228 uint64 ac_value = extract_ac_15_14(instruction);
6229
6230 const char *ac = AC(ac_value, info);
6231 const char *rs = GPR(rs_value, info);
6232 const char *rt = GPR(rt_value, info);
6233
6234 return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
6235 }
6236
6237
6238 /*
6239 *
6240 *
6241 * 3 2 1
6242 * 10987654321098765432109876543210
6243 * 001000 x1110000101
6244 * rt -----
6245 * rs -----
6246 * rd -----
6247 */
6248 static char *DPSQX_S_W_PH(uint64 instruction, Dis_info *info)
6249 {
6250 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6251 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6252 uint64 ac_value = extract_ac_15_14(instruction);
6253
6254 const char *ac = AC(ac_value, info);
6255 const char *rs = GPR(rs_value, info);
6256 const char *rt = GPR(rt_value, info);
6257
6258 return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
6259 }
6260
6261
6262 /*
6263 *
6264 *
6265 * 3 2 1
6266 * 10987654321098765432109876543210
6267 * 001000 x1110000101
6268 * rt -----
6269 * rs -----
6270 * rd -----
6271 */
6272 static char *DPSU_H_QBL(uint64 instruction, Dis_info *info)
6273 {
6274 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6275 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6276 uint64 ac_value = extract_ac_15_14(instruction);
6277
6278 const char *ac = AC(ac_value, info);
6279 const char *rs = GPR(rs_value, info);
6280 const char *rt = GPR(rt_value, info);
6281
6282 return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
6283 }
6284
6285
6286 /*
6287 *
6288 *
6289 * 3 2 1
6290 * 10987654321098765432109876543210
6291 * 001000 x1110000101
6292 * rt -----
6293 * rs -----
6294 * rd -----
6295 */
6296 static char *DPSU_H_QBR(uint64 instruction, Dis_info *info)
6297 {
6298 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6299 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6300 uint64 ac_value = extract_ac_15_14(instruction);
6301
6302 const char *ac = AC(ac_value, info);
6303 const char *rs = GPR(rs_value, info);
6304 const char *rt = GPR(rt_value, info);
6305
6306 return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
6307 }
6308
6309
6310 /*
6311 *
6312 *
6313 * 3 2 1
6314 * 10987654321098765432109876543210
6315 * 001000 x1110000101
6316 * rt -----
6317 * rs -----
6318 * rd -----
6319 */
6320 static char *DPSX_W_PH(uint64 instruction, Dis_info *info)
6321 {
6322 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6323 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6324 uint64 ac_value = extract_ac_15_14(instruction);
6325
6326 const char *ac = AC(ac_value, info);
6327 const char *rs = GPR(rs_value, info);
6328 const char *rt = GPR(rt_value, info);
6329
6330 return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
6331 }
6332
6333
6334 /*
6335 * DROTR -
6336 *
6337 * 3 2 1
6338 * 10987654321098765432109876543210
6339 * 001000 x1110000101
6340 * rt -----
6341 * rs -----
6342 * rd -----
6343 */
6344 static char *DROTR(uint64 instruction, Dis_info *info)
6345 {
6346 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6347 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6348 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6349
6350 const char *rt = GPR(rt_value, info);
6351 const char *rs = GPR(rs_value, info);
6352
6353 return img_format("DROTR %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6354 }
6355
6356
6357 /*
6358 * DROTR[32] -
6359 *
6360 * 3 2 1
6361 * 10987654321098765432109876543210
6362 * 10o000 1100xxx0110
6363 * rt -----
6364 * rs -----
6365 * shift -----
6366 */
6367 static char *DROTR32(uint64 instruction, Dis_info *info)
6368 {
6369 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6370 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6371 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6372
6373 const char *rt = GPR(rt_value, info);
6374 const char *rs = GPR(rs_value, info);
6375
6376 return img_format("DROTR32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6377 }
6378
6379
6380 /*
6381 *
6382 *
6383 * 3 2 1
6384 * 10987654321098765432109876543210
6385 * 001000 x1110000101
6386 * rt -----
6387 * rs -----
6388 * rd -----
6389 */
6390 static char *DROTRV(uint64 instruction, Dis_info *info)
6391 {
6392 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6393 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6394 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6395
6396 const char *rd = GPR(rd_value, info);
6397 const char *rs = GPR(rs_value, info);
6398 const char *rt = GPR(rt_value, info);
6399
6400 return img_format("DROTRV %s, %s, %s", rd, rs, rt);
6401 }
6402
6403
6404 /*
6405 *
6406 *
6407 * 3 2 1
6408 * 10987654321098765432109876543210
6409 * 001000 x1110000101
6410 * rt -----
6411 * rs -----
6412 * rd -----
6413 */
6414 static char *DROTX(uint64 instruction, Dis_info *info)
6415 {
6416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6417 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6418 uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
6419 uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
6420
6421 const char *rt = GPR(rt_value, info);
6422 const char *rs = GPR(rs_value, info);
6423
6424 return img_format("DROTX %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
6425 rt, rs, shift_value, shiftx_value);
6426 }
6427
6428
6429 /*
6430 * DSLL -
6431 *
6432 * 3 2 1
6433 * 10987654321098765432109876543210
6434 * 10o000 1100xxx0000
6435 * rt -----
6436 * rs -----
6437 * shift -----
6438 */
6439 static char *DSLL(uint64 instruction, Dis_info *info)
6440 {
6441 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6442 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6443 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6444
6445 const char *rt = GPR(rt_value, info);
6446 const char *rs = GPR(rs_value, info);
6447
6448 return img_format("DSLL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6449 }
6450
6451
6452 /*
6453 * DSLL[32] -
6454 *
6455 * 3 2 1
6456 * 10987654321098765432109876543210
6457 * 10o000 1100xxx0000
6458 * rt -----
6459 * rs -----
6460 * shift -----
6461 */
6462 static char *DSLL32(uint64 instruction, Dis_info *info)
6463 {
6464 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6465 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6466 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6467
6468 const char *rt = GPR(rt_value, info);
6469 const char *rs = GPR(rs_value, info);
6470
6471 return img_format("DSLL32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6472 }
6473
6474
6475 /*
6476 *
6477 *
6478 * 3 2 1
6479 * 10987654321098765432109876543210
6480 * 001000 x1110000101
6481 * rt -----
6482 * rs -----
6483 * rd -----
6484 */
6485 static char *DSLLV(uint64 instruction, Dis_info *info)
6486 {
6487 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6488 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6489 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6490
6491 const char *rd = GPR(rd_value, info);
6492 const char *rs = GPR(rs_value, info);
6493 const char *rt = GPR(rt_value, info);
6494
6495 return img_format("DSLLV %s, %s, %s", rd, rs, rt);
6496 }
6497
6498
6499 /*
6500 * DSRA -
6501 *
6502 * 3 2 1
6503 * 10987654321098765432109876543210
6504 * 10o000 1100xxx0100
6505 * rt -----
6506 * rs -----
6507 * shift -----
6508 */
6509 static char *DSRA(uint64 instruction, Dis_info *info)
6510 {
6511 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6512 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6513 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6514
6515 const char *rt = GPR(rt_value, info);
6516 const char *rs = GPR(rs_value, info);
6517
6518 return img_format("DSRA %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6519 }
6520
6521
6522 /*
6523 * DSRA[32] -
6524 *
6525 * 3 2 1
6526 * 10987654321098765432109876543210
6527 * 10o000 1100xxx0100
6528 * rt -----
6529 * rs -----
6530 * shift -----
6531 */
6532 static char *DSRA32(uint64 instruction, Dis_info *info)
6533 {
6534 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6535 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6536 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6537
6538 const char *rt = GPR(rt_value, info);
6539 const char *rs = GPR(rs_value, info);
6540
6541 return img_format("DSRA32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6542 }
6543
6544
6545 /*
6546 *
6547 *
6548 * 3 2 1
6549 * 10987654321098765432109876543210
6550 * 001000 x1110000101
6551 * rt -----
6552 * rs -----
6553 * rd -----
6554 */
6555 static char *DSRAV(uint64 instruction, Dis_info *info)
6556 {
6557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6559 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6560
6561 const char *rd = GPR(rd_value, info);
6562 const char *rs = GPR(rs_value, info);
6563 const char *rt = GPR(rt_value, info);
6564
6565 return img_format("DSRAV %s, %s, %s", rd, rs, rt);
6566 }
6567
6568
6569 /*
6570 * DSRL -
6571 *
6572 * 3 2 1
6573 * 10987654321098765432109876543210
6574 * 10o000 1100xxx0100
6575 * rt -----
6576 * rs -----
6577 * shift -----
6578 */
6579 static char *DSRL(uint64 instruction, Dis_info *info)
6580 {
6581 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6582 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6583 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6584
6585 const char *rt = GPR(rt_value, info);
6586 const char *rs = GPR(rs_value, info);
6587
6588 return img_format("DSRL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6589 }
6590
6591
6592 /*
6593 * DSRL[32] -
6594 *
6595 * 3 2 1
6596 * 10987654321098765432109876543210
6597 * 10o000 1100xxx0010
6598 * rt -----
6599 * rs -----
6600 * shift -----
6601 */
6602 static char *DSRL32(uint64 instruction, Dis_info *info)
6603 {
6604 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6605 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6606 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
6607
6608 const char *rt = GPR(rt_value, info);
6609 const char *rs = GPR(rs_value, info);
6610
6611 return img_format("DSRL32 %s, %s, 0x%" PRIx64, rt, rs, shift_value);
6612 }
6613
6614
6615 /*
6616 *
6617 *
6618 * 3 2 1
6619 * 10987654321098765432109876543210
6620 * 001000 x1110000101
6621 * rt -----
6622 * rs -----
6623 * rd -----
6624 */
6625 static char *DSRLV(uint64 instruction, Dis_info *info)
6626 {
6627 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6628 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6629 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6630
6631 const char *rd = GPR(rd_value, info);
6632 const char *rs = GPR(rs_value, info);
6633 const char *rt = GPR(rt_value, info);
6634
6635 return img_format("DSRLV %s, %s, %s", rd, rs, rt);
6636 }
6637
6638
6639 /*
6640 *
6641 *
6642 * 3 2 1
6643 * 10987654321098765432109876543210
6644 * 001000 x1110000101
6645 * rt -----
6646 * rs -----
6647 * rd -----
6648 */
6649 static char *DSUB(uint64 instruction, Dis_info *info)
6650 {
6651 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6652 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6653 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6654
6655 const char *rd = GPR(rd_value, info);
6656 const char *rs = GPR(rs_value, info);
6657 const char *rt = GPR(rt_value, info);
6658
6659 return img_format("DSUB %s, %s, %s", rd, rs, rt);
6660 }
6661
6662
6663 /*
6664 *
6665 *
6666 * 3 2 1
6667 * 10987654321098765432109876543210
6668 * 001000 x1110000101
6669 * rt -----
6670 * rs -----
6671 * rd -----
6672 */
6673 static char *DSUBU(uint64 instruction, Dis_info *info)
6674 {
6675 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6676 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6677 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6678
6679 const char *rd = GPR(rd_value, info);
6680 const char *rs = GPR(rs_value, info);
6681 const char *rt = GPR(rt_value, info);
6682
6683 return img_format("DSUBU %s, %s, %s", rd, rs, rt);
6684 }
6685
6686
6687 /*
6688 *
6689 *
6690 * 3 2 1
6691 * 10987654321098765432109876543210
6692 * 001000 x1110000101
6693 * rt -----
6694 * rs -----
6695 * rd -----
6696 */
6697 static char *DVPE(uint64 instruction, Dis_info *info)
6698 {
6699 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6700
6701 const char *rt = GPR(rt_value, info);
6702
6703 return img_format("DVPE %s", rt);
6704 }
6705
6706
6707 /*
6708 *
6709 *
6710 * 3 2 1
6711 * 10987654321098765432109876543210
6712 * 001000 x1110000101
6713 * rt -----
6714 * rs -----
6715 * rd -----
6716 */
6717 static char *DVP(uint64 instruction, Dis_info *info)
6718 {
6719 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6720
6721 const char *rt = GPR(rt_value, info);
6722
6723 return img_format("DVP %s", rt);
6724 }
6725
6726
6727 /*
6728 *
6729 *
6730 * 3 2 1
6731 * 10987654321098765432109876543210
6732 * 001000 x1110000101
6733 * rt -----
6734 * rs -----
6735 * rd -----
6736 */
6737 static char *EHB(uint64 instruction, Dis_info *info)
6738 {
6739 (void)instruction;
6740
6741 return g_strdup("EHB ");
6742 }
6743
6744
6745 /*
6746 *
6747 *
6748 * 3 2 1
6749 * 10987654321098765432109876543210
6750 * 001000 x1110000101
6751 * rt -----
6752 * rs -----
6753 * rd -----
6754 */
6755 static char *EI(uint64 instruction, Dis_info *info)
6756 {
6757 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6758
6759 const char *rt = GPR(rt_value, info);
6760
6761 return img_format("EI %s", rt);
6762 }
6763
6764
6765 /*
6766 *
6767 *
6768 * 3 2 1
6769 * 10987654321098765432109876543210
6770 * 001000 x1110000101
6771 * rt -----
6772 * rs -----
6773 * rd -----
6774 */
6775 static char *EMT(uint64 instruction, Dis_info *info)
6776 {
6777 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6778
6779 const char *rt = GPR(rt_value, info);
6780
6781 return img_format("EMT %s", rt);
6782 }
6783
6784
6785 /*
6786 *
6787 *
6788 * 3 2 1
6789 * 10987654321098765432109876543210
6790 * 001000 x1110000101
6791 * rt -----
6792 * rs -----
6793 * rd -----
6794 */
6795 static char *ERET(uint64 instruction, Dis_info *info)
6796 {
6797 (void)instruction;
6798
6799 return g_strdup("ERET ");
6800 }
6801
6802
6803 /*
6804 *
6805 *
6806 * 3 2 1
6807 * 10987654321098765432109876543210
6808 * 001000 x1110000101
6809 * rt -----
6810 * rs -----
6811 * rd -----
6812 */
6813 static char *ERETNC(uint64 instruction, Dis_info *info)
6814 {
6815 (void)instruction;
6816
6817 return g_strdup("ERETNC ");
6818 }
6819
6820
6821 /*
6822 *
6823 *
6824 * 3 2 1
6825 * 10987654321098765432109876543210
6826 * 001000 x1110000101
6827 * rt -----
6828 * rs -----
6829 * rd -----
6830 */
6831 static char *EVP(uint64 instruction, Dis_info *info)
6832 {
6833 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6834
6835 const char *rt = GPR(rt_value, info);
6836
6837 return img_format("EVP %s", rt);
6838 }
6839
6840
6841 /*
6842 *
6843 *
6844 * 3 2 1
6845 * 10987654321098765432109876543210
6846 * 001000 x1110000101
6847 * rt -----
6848 * rs -----
6849 * rd -----
6850 */
6851 static char *EVPE(uint64 instruction, Dis_info *info)
6852 {
6853 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6854
6855 const char *rt = GPR(rt_value, info);
6856
6857 return img_format("EVPE %s", rt);
6858 }
6859
6860
6861 /*
6862 *
6863 *
6864 * 3 2 1
6865 * 10987654321098765432109876543210
6866 * 001000 x1110000101
6867 * rt -----
6868 * rs -----
6869 * rd -----
6870 */
6871 static char *EXT(uint64 instruction, Dis_info *info)
6872 {
6873 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6874 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6875 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
6876 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
6877
6878 const char *rt = GPR(rt_value, info);
6879 const char *rs = GPR(rs_value, info);
6880 uint64 msbd = encode_msbd_from_size(msbd_value);
6881
6882 return img_format("EXT %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
6883 rt, rs, lsb_value, msbd);
6884 }
6885
6886
6887 /*
6888 *
6889 *
6890 * 3 2 1
6891 * 10987654321098765432109876543210
6892 * 001000 x1110000101
6893 * rt -----
6894 * rs -----
6895 * rd -----
6896 */
6897 static char *EXTD(uint64 instruction, Dis_info *info)
6898 {
6899 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6900 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6901 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6902 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
6903
6904 const char *rd = GPR(rd_value, info);
6905 const char *rs = GPR(rs_value, info);
6906 const char *rt = GPR(rt_value, info);
6907
6908 return img_format("EXTD %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
6909 }
6910
6911
6912 /*
6913 *
6914 *
6915 * 3 2 1
6916 * 10987654321098765432109876543210
6917 * 001000 x1110000101
6918 * rt -----
6919 * rs -----
6920 * rd -----
6921 */
6922 static char *EXTD32(uint64 instruction, Dis_info *info)
6923 {
6924 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6925 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6926 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
6927 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
6928
6929 const char *rd = GPR(rd_value, info);
6930 const char *rs = GPR(rs_value, info);
6931 const char *rt = GPR(rt_value, info);
6932
6933 return img_format("EXTD32 %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
6934 }
6935
6936
6937 /*
6938 *
6939 *
6940 * 3 2 1
6941 * 10987654321098765432109876543210
6942 * 001000 x1110000101
6943 * rt -----
6944 * rs -----
6945 * rd -----
6946 */
6947 static char *EXTPDP(uint64 instruction, Dis_info *info)
6948 {
6949 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6950 uint64 size_value = extract_size_20_19_18_17_16(instruction);
6951 uint64 ac_value = extract_ac_15_14(instruction);
6952
6953 const char *rt = GPR(rt_value, info);
6954 const char *ac = AC(ac_value, info);
6955
6956 return img_format("EXTPDP %s, %s, 0x%" PRIx64, rt, ac, size_value);
6957 }
6958
6959
6960 /*
6961 *
6962 *
6963 * 3 2 1
6964 * 10987654321098765432109876543210
6965 * 001000 x1110000101
6966 * rt -----
6967 * rs -----
6968 * rd -----
6969 */
6970 static char *EXTPDPV(uint64 instruction, Dis_info *info)
6971 {
6972 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6973 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
6974 uint64 ac_value = extract_ac_15_14(instruction);
6975
6976 const char *rt = GPR(rt_value, info);
6977 const char *ac = AC(ac_value, info);
6978 const char *rs = GPR(rs_value, info);
6979
6980 return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
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 *EXTP(uint64 instruction, Dis_info *info)
6995 {
6996 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
6997 uint64 size_value = extract_size_20_19_18_17_16(instruction);
6998 uint64 ac_value = extract_ac_15_14(instruction);
6999
7000 const char *rt = GPR(rt_value, info);
7001 const char *ac = AC(ac_value, info);
7002
7003 return img_format("EXTP %s, %s, 0x%" PRIx64, rt, ac, size_value);
7004 }
7005
7006
7007 /*
7008 *
7009 *
7010 * 3 2 1
7011 * 10987654321098765432109876543210
7012 * 001000 x1110000101
7013 * rt -----
7014 * rs -----
7015 * rd -----
7016 */
7017 static char *EXTPV(uint64 instruction, Dis_info *info)
7018 {
7019 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7020 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7021 uint64 ac_value = extract_ac_15_14(instruction);
7022
7023 const char *rt = GPR(rt_value, info);
7024 const char *ac = AC(ac_value, info);
7025 const char *rs = GPR(rs_value, info);
7026
7027 return img_format("EXTPV %s, %s, %s", rt, ac, rs);
7028 }
7029
7030
7031 /*
7032 * [DSP] EXTR_RS.W rt, ac, shift - Extract word value from accumulator to GPR
7033 * with right shift
7034 *
7035 * 3 2 1
7036 * 10987654321098765432109876543210
7037 * 001000 10111001111111
7038 * rt -----
7039 * shift -----
7040 * ac --
7041 */
7042 static char *EXTR_RS_W(uint64 instruction, Dis_info *info)
7043 {
7044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7045 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7046 uint64 ac_value = extract_ac_15_14(instruction);
7047
7048 const char *rt = GPR(rt_value, info);
7049 const char *ac = AC(ac_value, info);
7050
7051 return img_format("EXTR_RS.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7052 }
7053
7054
7055 /*
7056 * [DSP] EXTR_R.W rt, ac, shift - Extract word value from accumulator to GPR
7057 * with right shift
7058 *
7059 * 3 2 1
7060 * 10987654321098765432109876543210
7061 * 001000 01111001111111
7062 * rt -----
7063 * shift -----
7064 * ac --
7065 */
7066 static char *EXTR_R_W(uint64 instruction, Dis_info *info)
7067 {
7068 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7069 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7070 uint64 ac_value = extract_ac_15_14(instruction);
7071
7072 const char *rt = GPR(rt_value, info);
7073 const char *ac = AC(ac_value, info);
7074
7075 return img_format("EXTR_R.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7076 }
7077
7078
7079 /*
7080 * [DSP] EXTR_S.H rt, ac, shift - Extract halfword value from accumulator
7081 * to GPR with right shift and saturate
7082 *
7083 * 3 2 1
7084 * 10987654321098765432109876543210
7085 * 001000 11111001111111
7086 * rt -----
7087 * shift -----
7088 * ac --
7089 */
7090 static char *EXTR_S_H(uint64 instruction, Dis_info *info)
7091 {
7092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7093 uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
7094 uint64 ac_value = extract_ac_15_14(instruction);
7095
7096 const char *rt = GPR(rt_value, info);
7097 const char *ac = AC(ac_value, info);
7098
7099 return img_format("EXTR_S.H %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7100 }
7101
7102
7103 /*
7104 * [DSP] EXTR.W rt, ac, shift - Extract word value from accumulator to GPR
7105 * with right shift
7106 *
7107 * 3 2 1
7108 * 10987654321098765432109876543210
7109 * 001000 00111001111111
7110 * rt -----
7111 * shift -----
7112 * ac --
7113 */
7114 static char *EXTR_W(uint64 instruction, Dis_info *info)
7115 {
7116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7117 uint64 shift_value = extract_shift_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
7123 return img_format("EXTR.W %s, %s, 0x%" PRIx64, rt, ac, shift_value);
7124 }
7125
7126
7127 /*
7128 * [DSP] EXTRV_RS.W rt, ac, rs - Extract word value with variable
7129 * right shift from accumulator to GPR
7130 *
7131 * 3 2 1
7132 * 10987654321098765432109876543210
7133 * 001000 10111010111111
7134 * rt -----
7135 * rs -----
7136 * ac --
7137 */
7138 static char *EXTRV_RS_W(uint64 instruction, Dis_info *info)
7139 {
7140 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7141 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7142 uint64 ac_value = extract_ac_15_14(instruction);
7143
7144 const char *rt = GPR(rt_value, info);
7145 const char *ac = AC(ac_value, info);
7146 const char *rs = GPR(rs_value, info);
7147
7148 return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
7149 }
7150
7151
7152 /*
7153 * [DSP] EXTRV_R.W rt, ac, rs - Extract word value with variable
7154 * right shift from accumulator to GPR
7155 *
7156 * 3 2 1
7157 * 10987654321098765432109876543210
7158 * 001000 01111010111111
7159 * rt -----
7160 * rs -----
7161 * ac --
7162 */
7163 static char *EXTRV_R_W(uint64 instruction, Dis_info *info)
7164 {
7165 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7166 uint64 rs_value = extract_rs_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 const char *rs = GPR(rs_value, info);
7172
7173 return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
7174 }
7175
7176
7177 /*
7178 * [DSP] EXTRV_S.H rt, ac, rs - Extract halfword value variable from
7179 * accumulator to GPR with right shift and saturate
7180 *
7181 * 3 2 1
7182 * 10987654321098765432109876543210
7183 * 001000 11111010111111
7184 * rt -----
7185 * rs -----
7186 * ac --
7187 */
7188 static char *EXTRV_S_H(uint64 instruction, Dis_info *info)
7189 {
7190 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7191 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7192 uint64 ac_value = extract_ac_15_14(instruction);
7193
7194 const char *rt = GPR(rt_value, info);
7195 const char *ac = AC(ac_value, info);
7196 const char *rs = GPR(rs_value, info);
7197
7198 return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
7199 }
7200
7201
7202 /*
7203 * [DSP] EXTRV.W rt, ac, rs - Extract word value with variable
7204 * right shift from accumulator to GPR
7205 *
7206 * 3 2 1
7207 * 10987654321098765432109876543210
7208 * 001000 00111010111111
7209 * rt -----
7210 * rs -----
7211 * ac --
7212 */
7213 static char *EXTRV_W(uint64 instruction, Dis_info *info)
7214 {
7215 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7216 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7217 uint64 ac_value = extract_ac_15_14(instruction);
7218
7219 const char *rt = GPR(rt_value, info);
7220 const char *ac = AC(ac_value, info);
7221 const char *rs = GPR(rs_value, info);
7222
7223 return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
7224 }
7225
7226
7227 /*
7228 * EXTW - Extract Word
7229 *
7230 * 3 2 1
7231 * 10987654321098765432109876543210
7232 * 001000 011111
7233 * rt -----
7234 * rs -----
7235 * rd -----
7236 * shift -----
7237 */
7238 static char *EXTW(uint64 instruction, Dis_info *info)
7239 {
7240 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7242 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7243 uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
7244
7245 const char *rd = GPR(rd_value, info);
7246 const char *rs = GPR(rs_value, info);
7247 const char *rt = GPR(rt_value, info);
7248
7249 return img_format("EXTW %s, %s, %s, 0x%" PRIx64, rd, rs, rt, shift_value);
7250 }
7251
7252
7253 /*
7254 *
7255 *
7256 * 3 2 1
7257 * 10987654321098765432109876543210
7258 * 001000 x1110000101
7259 * rt -----
7260 * rs -----
7261 * rd -----
7262 */
7263 static char *FLOOR_L_D(uint64 instruction, Dis_info *info)
7264 {
7265 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7266 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7267
7268 const char *ft = FPR(ft_value, info);
7269 const char *fs = FPR(fs_value, info);
7270
7271 return img_format("FLOOR.L.D %s, %s", ft, fs);
7272 }
7273
7274
7275 /*
7276 *
7277 *
7278 * 3 2 1
7279 * 10987654321098765432109876543210
7280 * 001000 x1110000101
7281 * rt -----
7282 * rs -----
7283 * rd -----
7284 */
7285 static char *FLOOR_L_S(uint64 instruction, Dis_info *info)
7286 {
7287 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7288 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7289
7290 const char *ft = FPR(ft_value, info);
7291 const char *fs = FPR(fs_value, info);
7292
7293 return img_format("FLOOR.L.S %s, %s", ft, fs);
7294 }
7295
7296
7297 /*
7298 *
7299 *
7300 * 3 2 1
7301 * 10987654321098765432109876543210
7302 * 001000 x1110000101
7303 * rt -----
7304 * rs -----
7305 * rd -----
7306 */
7307 static char *FLOOR_W_D(uint64 instruction, Dis_info *info)
7308 {
7309 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7310 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7311
7312 const char *ft = FPR(ft_value, info);
7313 const char *fs = FPR(fs_value, info);
7314
7315 return img_format("FLOOR.W.D %s, %s", ft, fs);
7316 }
7317
7318
7319 /*
7320 *
7321 *
7322 * 3 2 1
7323 * 10987654321098765432109876543210
7324 * 001000 x1110000101
7325 * rt -----
7326 * rs -----
7327 * rd -----
7328 */
7329 static char *FLOOR_W_S(uint64 instruction, Dis_info *info)
7330 {
7331 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7332 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
7333
7334 const char *ft = FPR(ft_value, info);
7335 const char *fs = FPR(fs_value, info);
7336
7337 return img_format("FLOOR.W.S %s, %s", ft, fs);
7338 }
7339
7340
7341 /*
7342 *
7343 *
7344 * 3 2 1
7345 * 10987654321098765432109876543210
7346 * 001000 x1110000101
7347 * rt -----
7348 * rs -----
7349 * rd -----
7350 */
7351 static char *FORK(uint64 instruction, Dis_info *info)
7352 {
7353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7355 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7356
7357 const char *rd = GPR(rd_value, info);
7358 const char *rs = GPR(rs_value, info);
7359 const char *rt = GPR(rt_value, info);
7360
7361 return img_format("FORK %s, %s, %s", rd, rs, rt);
7362 }
7363
7364
7365 /*
7366 *
7367 *
7368 * 3 2 1
7369 * 10987654321098765432109876543210
7370 * 001000 x1110000101
7371 * rt -----
7372 * rs -----
7373 * rd -----
7374 */
7375 static char *HYPCALL(uint64 instruction, Dis_info *info)
7376 {
7377 uint64 code_value = extract_code_17_to_0(instruction);
7378
7379
7380 return img_format("HYPCALL 0x%" PRIx64, code_value);
7381 }
7382
7383
7384 /*
7385 *
7386 *
7387 * 3 2 1
7388 * 10987654321098765432109876543210
7389 * 001000 x1110000101
7390 * rt -----
7391 * rs -----
7392 * rd -----
7393 */
7394 static char *HYPCALL_16_(uint64 instruction, Dis_info *info)
7395 {
7396 uint64 code_value = extract_code_1_0(instruction);
7397
7398
7399 return img_format("HYPCALL 0x%" PRIx64, code_value);
7400 }
7401
7402
7403 /*
7404 *
7405 *
7406 * 3 2 1
7407 * 10987654321098765432109876543210
7408 * 001000 x1110000101
7409 * rt -----
7410 * rs -----
7411 * rd -----
7412 */
7413 static char *INS(uint64 instruction, Dis_info *info)
7414 {
7415 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7416 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7417 uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
7418 uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
7419
7420 const char *rt = GPR(rt_value, info);
7421 const char *rs = GPR(rs_value, info);
7422 /* !!!!!!!!!! - no conversion function */
7423
7424 return img_format("INS %s, %s, 0x%" PRIx64 ", 0x%" PRIx64,
7425 rt, rs, lsb_value, msbd_value);
7426 /* hand edited */
7427 }
7428
7429
7430 /*
7431 * [DSP] INSV rt, rs - Insert bit field variable
7432 *
7433 * 3 2 1
7434 * 10987654321098765432109876543210
7435 * 001000 0100000100111111
7436 * rt -----
7437 * rs -----
7438 */
7439 static char *INSV(uint64 instruction, Dis_info *info)
7440 {
7441 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7442 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7443
7444 const char *rt = GPR(rt_value, info);
7445 const char *rs = GPR(rs_value, info);
7446
7447 return img_format("INSV %s, %s", rt, rs);
7448 }
7449
7450
7451 /*
7452 *
7453 *
7454 * 3 2 1
7455 * 10987654321098765432109876543210
7456 * 001000 x1110000101
7457 * rt -----
7458 * rs -----
7459 * rd -----
7460 */
7461 static char *IRET(uint64 instruction, Dis_info *info)
7462 {
7463 (void)instruction;
7464
7465 return g_strdup("IRET ");
7466 }
7467
7468
7469 /*
7470 *
7471 *
7472 * 3 2 1
7473 * 10987654321098765432109876543210
7474 * 001000 x1110000101
7475 * rt -----
7476 * rs -----
7477 * rd -----
7478 */
7479 static char *JALRC_16_(uint64 instruction, Dis_info *info)
7480 {
7481 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7482
7483 const char *rt = GPR(rt_value, info);
7484
7485 return img_format("JALRC $%d, %s", 31, rt);
7486 }
7487
7488
7489 /*
7490 *
7491 *
7492 * 3 2 1
7493 * 10987654321098765432109876543210
7494 * 001000 x1110000101
7495 * rt -----
7496 * rs -----
7497 * rd -----
7498 */
7499 static char *JALRC_32_(uint64 instruction, Dis_info *info)
7500 {
7501 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7502 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7503
7504 const char *rt = GPR(rt_value, info);
7505 const char *rs = GPR(rs_value, info);
7506
7507 return img_format("JALRC %s, %s", rt, rs);
7508 }
7509
7510
7511 /*
7512 *
7513 *
7514 * 3 2 1
7515 * 10987654321098765432109876543210
7516 * 001000 x1110000101
7517 * rt -----
7518 * rs -----
7519 * rd -----
7520 */
7521 static char *JALRC_HB(uint64 instruction, Dis_info *info)
7522 {
7523 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7524 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7525
7526 const char *rt = GPR(rt_value, info);
7527 const char *rs = GPR(rs_value, info);
7528
7529 return img_format("JALRC.HB %s, %s", rt, rs);
7530 }
7531
7532
7533 /*
7534 *
7535 *
7536 * 3 2 1
7537 * 10987654321098765432109876543210
7538 * 001000 x1110000101
7539 * rt -----
7540 * rs -----
7541 * rd -----
7542 */
7543 static char *JRC(uint64 instruction, Dis_info *info)
7544 {
7545 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
7546
7547 const char *rt = GPR(rt_value, info);
7548
7549 return img_format("JRC %s", rt);
7550 }
7551
7552
7553 /*
7554 *
7555 *
7556 * 3 2 1
7557 * 10987654321098765432109876543210
7558 * 001000 x1110000101
7559 * rt -----
7560 * rs -----
7561 * rd -----
7562 */
7563 static char *LB_16_(uint64 instruction, Dis_info *info)
7564 {
7565 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7566 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7567 uint64 u_value = extract_u_1_0(instruction);
7568
7569 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
7570 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
7571
7572 return img_format("LB %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
7573 }
7574
7575
7576 /*
7577 *
7578 *
7579 * 3 2 1
7580 * 10987654321098765432109876543210
7581 * 001000 x1110000101
7582 * rt -----
7583 * rs -----
7584 * rd -----
7585 */
7586 static char *LB_GP_(uint64 instruction, Dis_info *info)
7587 {
7588 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7589 uint64 u_value = extract_u_17_to_0(instruction);
7590
7591 const char *rt = GPR(rt_value, info);
7592
7593 return img_format("LB %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7594 }
7595
7596
7597 /*
7598 *
7599 *
7600 * 3 2 1
7601 * 10987654321098765432109876543210
7602 * 001000 x1110000101
7603 * rt -----
7604 * rs -----
7605 * rd -----
7606 */
7607 static char *LB_S9_(uint64 instruction, Dis_info *info)
7608 {
7609 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7610 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7611 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7612
7613 const char *rt = GPR(rt_value, info);
7614 const char *rs = GPR(rs_value, info);
7615
7616 return img_format("LB %s, %" PRId64 "(%s)", rt, s_value, rs);
7617 }
7618
7619
7620 /*
7621 *
7622 *
7623 * 3 2 1
7624 * 10987654321098765432109876543210
7625 * 001000 x1110000101
7626 * rt -----
7627 * rs -----
7628 * rd -----
7629 */
7630 static char *LB_U12_(uint64 instruction, Dis_info *info)
7631 {
7632 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7633 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7634 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7635
7636 const char *rt = GPR(rt_value, info);
7637 const char *rs = GPR(rs_value, info);
7638
7639 return img_format("LB %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7640 }
7641
7642
7643 /*
7644 *
7645 *
7646 * 3 2 1
7647 * 10987654321098765432109876543210
7648 * 001000 x1110000101
7649 * rt -----
7650 * rs -----
7651 * rd -----
7652 */
7653 static char *LBE(uint64 instruction, Dis_info *info)
7654 {
7655 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7656 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7657 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7658
7659 const char *rt = GPR(rt_value, info);
7660 const char *rs = GPR(rs_value, info);
7661
7662 return img_format("LBE %s, %" PRId64 "(%s)", rt, s_value, rs);
7663 }
7664
7665
7666 /*
7667 *
7668 *
7669 * 3 2 1
7670 * 10987654321098765432109876543210
7671 * 001000 x1110000101
7672 * rt -----
7673 * rs -----
7674 * rd -----
7675 */
7676 static char *LBU_16_(uint64 instruction, Dis_info *info)
7677 {
7678 uint64 rt3_value = extract_rt3_9_8_7(instruction);
7679 uint64 rs3_value = extract_rs3_6_5_4(instruction);
7680 uint64 u_value = extract_u_1_0(instruction);
7681
7682 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
7683 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
7684
7685 return img_format("LBU %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
7686 }
7687
7688
7689 /*
7690 *
7691 *
7692 * 3 2 1
7693 * 10987654321098765432109876543210
7694 * 001000 x1110000101
7695 * rt -----
7696 * rs -----
7697 * rd -----
7698 */
7699 static char *LBU_GP_(uint64 instruction, Dis_info *info)
7700 {
7701 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7702 uint64 u_value = extract_u_17_to_0(instruction);
7703
7704 const char *rt = GPR(rt_value, info);
7705
7706 return img_format("LBU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7707 }
7708
7709
7710 /*
7711 *
7712 *
7713 * 3 2 1
7714 * 10987654321098765432109876543210
7715 * 001000 x1110000101
7716 * rt -----
7717 * rs -----
7718 * rd -----
7719 */
7720 static char *LBU_S9_(uint64 instruction, Dis_info *info)
7721 {
7722 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7723 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7724 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7725
7726 const char *rt = GPR(rt_value, info);
7727 const char *rs = GPR(rs_value, info);
7728
7729 return img_format("LBU %s, %" PRId64 "(%s)", rt, s_value, rs);
7730 }
7731
7732
7733 /*
7734 *
7735 *
7736 * 3 2 1
7737 * 10987654321098765432109876543210
7738 * 001000 x1110000101
7739 * rt -----
7740 * rs -----
7741 * rd -----
7742 */
7743 static char *LBU_U12_(uint64 instruction, Dis_info *info)
7744 {
7745 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7746 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7747 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7748
7749 const char *rt = GPR(rt_value, info);
7750 const char *rs = GPR(rs_value, info);
7751
7752 return img_format("LBU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7753 }
7754
7755
7756 /*
7757 *
7758 *
7759 * 3 2 1
7760 * 10987654321098765432109876543210
7761 * 001000 x1110000101
7762 * rt -----
7763 * rs -----
7764 * rd -----
7765 */
7766 static char *LBUE(uint64 instruction, Dis_info *info)
7767 {
7768 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7769 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7770 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7771
7772 const char *rt = GPR(rt_value, info);
7773 const char *rs = GPR(rs_value, info);
7774
7775 return img_format("LBUE %s, %" PRId64 "(%s)", rt, s_value, rs);
7776 }
7777
7778
7779 /*
7780 *
7781 *
7782 * 3 2 1
7783 * 10987654321098765432109876543210
7784 * 001000 x1110000101
7785 * rt -----
7786 * rs -----
7787 * rd -----
7788 */
7789 static char *LBUX(uint64 instruction, Dis_info *info)
7790 {
7791 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7792 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7793 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7794
7795 const char *rd = GPR(rd_value, info);
7796 const char *rs = GPR(rs_value, info);
7797 const char *rt = GPR(rt_value, info);
7798
7799 return img_format("LBUX %s, %s(%s)", rd, rs, rt);
7800 }
7801
7802
7803 /*
7804 *
7805 *
7806 * 3 2 1
7807 * 10987654321098765432109876543210
7808 * 001000 x1110000101
7809 * rt -----
7810 * rs -----
7811 * rd -----
7812 */
7813 static char *LBX(uint64 instruction, Dis_info *info)
7814 {
7815 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7816 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7817 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
7818
7819 const char *rd = GPR(rd_value, info);
7820 const char *rs = GPR(rs_value, info);
7821 const char *rt = GPR(rt_value, info);
7822
7823 return img_format("LBX %s, %s(%s)", rd, rs, rt);
7824 }
7825
7826
7827 /*
7828 *
7829 *
7830 * 3 2 1
7831 * 10987654321098765432109876543210
7832 * 001000 x1110000101
7833 * rt -----
7834 * rs -----
7835 * rd -----
7836 */
7837 static char *LD_GP_(uint64 instruction, Dis_info *info)
7838 {
7839 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7840 uint64 u_value = extract_u_20_to_3__s3(instruction);
7841
7842 const char *rt = GPR(rt_value, info);
7843
7844 return img_format("LD %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
7845 }
7846
7847
7848 /*
7849 *
7850 *
7851 * 3 2 1
7852 * 10987654321098765432109876543210
7853 * 001000 x1110000101
7854 * rt -----
7855 * rs -----
7856 * rd -----
7857 */
7858 static char *LD_S9_(uint64 instruction, Dis_info *info)
7859 {
7860 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7861 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7862 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7863
7864 const char *rt = GPR(rt_value, info);
7865 const char *rs = GPR(rs_value, info);
7866
7867 return img_format("LD %s, %" PRId64 "(%s)", rt, s_value, rs);
7868 }
7869
7870
7871 /*
7872 *
7873 *
7874 * 3 2 1
7875 * 10987654321098765432109876543210
7876 * 001000 x1110000101
7877 * rt -----
7878 * rs -----
7879 * rd -----
7880 */
7881 static char *LD_U12_(uint64 instruction, Dis_info *info)
7882 {
7883 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7884 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7885 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7886
7887 const char *rt = GPR(rt_value, info);
7888 const char *rs = GPR(rs_value, info);
7889
7890 return img_format("LD %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
7891 }
7892
7893
7894 /*
7895 *
7896 *
7897 * 3 2 1
7898 * 10987654321098765432109876543210
7899 * 001000 x1110000101
7900 * rt -----
7901 * rs -----
7902 * rd -----
7903 */
7904 static char *LDC1_GP_(uint64 instruction, Dis_info *info)
7905 {
7906 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7907 uint64 u_value = extract_u_17_to_2__s2(instruction);
7908
7909 const char *ft = FPR(ft_value, info);
7910
7911 return img_format("LDC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
7912 }
7913
7914
7915 /*
7916 *
7917 *
7918 * 3 2 1
7919 * 10987654321098765432109876543210
7920 * 001000 x1110000101
7921 * rt -----
7922 * rs -----
7923 * rd -----
7924 */
7925 static char *LDC1_S9_(uint64 instruction, Dis_info *info)
7926 {
7927 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7928 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7929 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
7930
7931 const char *ft = FPR(ft_value, info);
7932 const char *rs = GPR(rs_value, info);
7933
7934 return img_format("LDC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
7935 }
7936
7937
7938 /*
7939 *
7940 *
7941 * 3 2 1
7942 * 10987654321098765432109876543210
7943 * 001000 x1110000101
7944 * rt -----
7945 * rs -----
7946 * rd -----
7947 */
7948 static char *LDC1_U12_(uint64 instruction, Dis_info *info)
7949 {
7950 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
7951 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7952 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
7953
7954 const char *ft = FPR(ft_value, info);
7955 const char *rs = GPR(rs_value, info);
7956
7957 return img_format("LDC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
7958 }
7959
7960
7961 /*
7962 *
7963 *
7964 * 3 2 1
7965 * 10987654321098765432109876543210
7966 * 001000 x1110000101
7967 * rt -----
7968 * rs -----
7969 * rd -----
7970 */
7971 static char *LDC1XS(uint64 instruction, Dis_info *info)
7972 {
7973 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7974 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7975 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
7976
7977 const char *ft = FPR(ft_value, info);
7978 const char *rs = GPR(rs_value, info);
7979 const char *rt = GPR(rt_value, info);
7980
7981 return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
7982 }
7983
7984
7985 /*
7986 *
7987 *
7988 * 3 2 1
7989 * 10987654321098765432109876543210
7990 * 001000 x1110000101
7991 * rt -----
7992 * rs -----
7993 * rd -----
7994 */
7995 static char *LDC1X(uint64 instruction, Dis_info *info)
7996 {
7997 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
7998 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
7999 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8000
8001 const char *ft = FPR(ft_value, info);
8002 const char *rs = GPR(rs_value, info);
8003 const char *rt = GPR(rt_value, info);
8004
8005 return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
8006 }
8007
8008
8009 /*
8010 *
8011 *
8012 * 3 2 1
8013 * 10987654321098765432109876543210
8014 * 001000 x1110000101
8015 * rt -----
8016 * rs -----
8017 * rd -----
8018 */
8019 static char *LDC2(uint64 instruction, Dis_info *info)
8020 {
8021 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8022 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8023 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8024
8025 const char *rs = GPR(rs_value, info);
8026
8027 return img_format("LDC2 CP%" PRIu64 ", %" PRId64 "(%s)",
8028 ct_value, s_value, rs);
8029 }
8030
8031
8032 /*
8033 *
8034 *
8035 * 3 2 1
8036 * 10987654321098765432109876543210
8037 * 001000 x1110000101
8038 * rt -----
8039 * rs -----
8040 * rd -----
8041 */
8042 static char *LDM(uint64 instruction, Dis_info *info)
8043 {
8044 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8045 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8046 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8047 uint64 count3_value = extract_count3_14_13_12(instruction);
8048
8049 const char *rt = GPR(rt_value, info);
8050 const char *rs = GPR(rs_value, info);
8051 uint64 count3 = encode_count3_from_count(count3_value);
8052
8053 return img_format("LDM %s, %" PRId64 "(%s), 0x%" PRIx64,
8054 rt, s_value, rs, count3);
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 *LDPC_48_(uint64 instruction, Dis_info *info)
8069 {
8070 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8071 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8072
8073 const char *rt = GPR(rt_value, info);
8074 g_autofree char *s = ADDRESS(s_value, 6, info);
8075
8076 return img_format("LDPC %s, %s", rt, s);
8077 }
8078
8079
8080 /*
8081 *
8082 *
8083 * 3 2 1
8084 * 10987654321098765432109876543210
8085 * 001000 x1110000101
8086 * rt -----
8087 * rs -----
8088 * rd -----
8089 */
8090 static char *LDX(uint64 instruction, Dis_info *info)
8091 {
8092 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8093 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8094 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8095
8096 const char *rd = GPR(rd_value, info);
8097 const char *rs = GPR(rs_value, info);
8098 const char *rt = GPR(rt_value, info);
8099
8100 return img_format("LDX %s, %s(%s)", rd, rs, rt);
8101 }
8102
8103
8104 /*
8105 *
8106 *
8107 * 3 2 1
8108 * 10987654321098765432109876543210
8109 * 001000 x1110000101
8110 * rt -----
8111 * rs -----
8112 * rd -----
8113 */
8114 static char *LDXS(uint64 instruction, Dis_info *info)
8115 {
8116 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8117 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8118 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8119
8120 const char *rd = GPR(rd_value, info);
8121 const char *rs = GPR(rs_value, info);
8122 const char *rt = GPR(rt_value, info);
8123
8124 return img_format("LDXS %s, %s(%s)", rd, rs, rt);
8125 }
8126
8127
8128 /*
8129 *
8130 *
8131 * 3 2 1
8132 * 10987654321098765432109876543210
8133 * 001000 x1110000101
8134 * rt -----
8135 * rs -----
8136 * rd -----
8137 */
8138 static char *LH_16_(uint64 instruction, Dis_info *info)
8139 {
8140 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8141 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8142 uint64 u_value = extract_u_2_1__s1(instruction);
8143
8144 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8145 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8146
8147 return img_format("LH %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8148 }
8149
8150
8151 /*
8152 *
8153 *
8154 * 3 2 1
8155 * 10987654321098765432109876543210
8156 * 001000 x1110000101
8157 * rt -----
8158 * rs -----
8159 * rd -----
8160 */
8161 static char *LH_GP_(uint64 instruction, Dis_info *info)
8162 {
8163 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8164 uint64 u_value = extract_u_17_to_1__s1(instruction);
8165
8166 const char *rt = GPR(rt_value, info);
8167
8168 return img_format("LH %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8169 }
8170
8171
8172 /*
8173 *
8174 *
8175 * 3 2 1
8176 * 10987654321098765432109876543210
8177 * 001000 x1110000101
8178 * rt -----
8179 * rs -----
8180 * rd -----
8181 */
8182 static char *LH_S9_(uint64 instruction, Dis_info *info)
8183 {
8184 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8185 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8186 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8187
8188 const char *rt = GPR(rt_value, info);
8189 const char *rs = GPR(rs_value, info);
8190
8191 return img_format("LH %s, %" PRId64 "(%s)", rt, s_value, rs);
8192 }
8193
8194
8195 /*
8196 *
8197 *
8198 * 3 2 1
8199 * 10987654321098765432109876543210
8200 * 001000 x1110000101
8201 * rt -----
8202 * rs -----
8203 * rd -----
8204 */
8205 static char *LH_U12_(uint64 instruction, Dis_info *info)
8206 {
8207 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8208 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8209 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8210
8211 const char *rt = GPR(rt_value, info);
8212 const char *rs = GPR(rs_value, info);
8213
8214 return img_format("LH %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8215 }
8216
8217
8218 /*
8219 *
8220 *
8221 * 3 2 1
8222 * 10987654321098765432109876543210
8223 * 001000 x1110000101
8224 * rt -----
8225 * rs -----
8226 * rd -----
8227 */
8228 static char *LHE(uint64 instruction, Dis_info *info)
8229 {
8230 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8231 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8232 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8233
8234 const char *rt = GPR(rt_value, info);
8235 const char *rs = GPR(rs_value, info);
8236
8237 return img_format("LHE %s, %" PRId64 "(%s)", rt, s_value, rs);
8238 }
8239
8240
8241 /*
8242 *
8243 *
8244 * 3 2 1
8245 * 10987654321098765432109876543210
8246 * 001000 x1110000101
8247 * rt -----
8248 * rs -----
8249 * rd -----
8250 */
8251 static char *LHU_16_(uint64 instruction, Dis_info *info)
8252 {
8253 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8254 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8255 uint64 u_value = extract_u_2_1__s1(instruction);
8256
8257 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8258 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8259
8260 return img_format("LHU %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8261 }
8262
8263
8264 /*
8265 *
8266 *
8267 * 3 2 1
8268 * 10987654321098765432109876543210
8269 * 001000 x1110000101
8270 * rt -----
8271 * rs -----
8272 * rd -----
8273 */
8274 static char *LHU_GP_(uint64 instruction, Dis_info *info)
8275 {
8276 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8277 uint64 u_value = extract_u_17_to_1__s1(instruction);
8278
8279 const char *rt = GPR(rt_value, info);
8280
8281 return img_format("LHU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8282 }
8283
8284
8285 /*
8286 *
8287 *
8288 * 3 2 1
8289 * 10987654321098765432109876543210
8290 * 001000 x1110000101
8291 * rt -----
8292 * rs -----
8293 * rd -----
8294 */
8295 static char *LHU_S9_(uint64 instruction, Dis_info *info)
8296 {
8297 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8298 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8299 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8300
8301 const char *rt = GPR(rt_value, info);
8302 const char *rs = GPR(rs_value, info);
8303
8304 return img_format("LHU %s, %" PRId64 "(%s)", rt, s_value, rs);
8305 }
8306
8307
8308 /*
8309 *
8310 *
8311 * 3 2 1
8312 * 10987654321098765432109876543210
8313 * 001000 x1110000101
8314 * rt -----
8315 * rs -----
8316 * rd -----
8317 */
8318 static char *LHU_U12_(uint64 instruction, Dis_info *info)
8319 {
8320 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8321 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8322 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8323
8324 const char *rt = GPR(rt_value, info);
8325 const char *rs = GPR(rs_value, info);
8326
8327 return img_format("LHU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8328 }
8329
8330
8331 /*
8332 *
8333 *
8334 * 3 2 1
8335 * 10987654321098765432109876543210
8336 * 001000 x1110000101
8337 * rt -----
8338 * rs -----
8339 * rd -----
8340 */
8341 static char *LHUE(uint64 instruction, Dis_info *info)
8342 {
8343 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8344 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8345 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8346
8347 const char *rt = GPR(rt_value, info);
8348 const char *rs = GPR(rs_value, info);
8349
8350 return img_format("LHUE %s, %" PRId64 "(%s)", rt, s_value, rs);
8351 }
8352
8353
8354 /*
8355 *
8356 *
8357 * 3 2 1
8358 * 10987654321098765432109876543210
8359 * 001000 x1110000101
8360 * rt -----
8361 * rs -----
8362 * rd -----
8363 */
8364 static char *LHUX(uint64 instruction, Dis_info *info)
8365 {
8366 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8367 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8368 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8369
8370 const char *rd = GPR(rd_value, info);
8371 const char *rs = GPR(rs_value, info);
8372 const char *rt = GPR(rt_value, info);
8373
8374 return img_format("LHUX %s, %s(%s)", rd, rs, rt);
8375 }
8376
8377
8378 /*
8379 *
8380 *
8381 * 3 2 1
8382 * 10987654321098765432109876543210
8383 * 001000 x1110000101
8384 * rt -----
8385 * rs -----
8386 * rd -----
8387 */
8388 static char *LHUXS(uint64 instruction, Dis_info *info)
8389 {
8390 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8391 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8392 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8393
8394 const char *rd = GPR(rd_value, info);
8395 const char *rs = GPR(rs_value, info);
8396 const char *rt = GPR(rt_value, info);
8397
8398 return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
8399 }
8400
8401
8402 /*
8403 *
8404 *
8405 * 3 2 1
8406 * 10987654321098765432109876543210
8407 * 001000 x1110000101
8408 * rt -----
8409 * rs -----
8410 * rd -----
8411 */
8412 static char *LHXS(uint64 instruction, Dis_info *info)
8413 {
8414 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8415 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8416 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8417
8418 const char *rd = GPR(rd_value, info);
8419 const char *rs = GPR(rs_value, info);
8420 const char *rt = GPR(rt_value, info);
8421
8422 return img_format("LHXS %s, %s(%s)", rd, rs, rt);
8423 }
8424
8425
8426 /*
8427 *
8428 *
8429 * 3 2 1
8430 * 10987654321098765432109876543210
8431 * 001000 x1110000101
8432 * rt -----
8433 * rs -----
8434 * rd -----
8435 */
8436 static char *LHX(uint64 instruction, Dis_info *info)
8437 {
8438 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8439 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8440 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8441
8442 const char *rd = GPR(rd_value, info);
8443 const char *rs = GPR(rs_value, info);
8444 const char *rt = GPR(rt_value, info);
8445
8446 return img_format("LHX %s, %s(%s)", rd, rs, rt);
8447 }
8448
8449
8450 /*
8451 *
8452 *
8453 * 3 2 1
8454 * 10987654321098765432109876543210
8455 * 001000 x1110000101
8456 * rt -----
8457 * rs -----
8458 * rd -----
8459 */
8460 static char *LI_16_(uint64 instruction, Dis_info *info)
8461 {
8462 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8463 uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
8464
8465 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8466 int64 eu = encode_eu_from_s_li16(eu_value);
8467
8468 return img_format("LI %s, %" PRId64, rt3, eu);
8469 }
8470
8471
8472 /*
8473 *
8474 *
8475 * 3 2 1
8476 * 10987654321098765432109876543210
8477 * 001000 x1110000101
8478 * rt -----
8479 * rs -----
8480 * rd -----
8481 */
8482 static char *LI_48_(uint64 instruction, Dis_info *info)
8483 {
8484 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
8485 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
8486
8487 const char *rt = GPR(rt_value, info);
8488
8489 return img_format("LI %s, %" PRId64, rt, s_value);
8490 }
8491
8492
8493 /*
8494 *
8495 *
8496 * 3 2 1
8497 * 10987654321098765432109876543210
8498 * 001000 x1110000101
8499 * rt -----
8500 * rs -----
8501 * rd -----
8502 */
8503 static char *LL(uint64 instruction, Dis_info *info)
8504 {
8505 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8506 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8507 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8508
8509 const char *rt = GPR(rt_value, info);
8510 const char *rs = GPR(rs_value, info);
8511
8512 return img_format("LL %s, %" PRId64 "(%s)", rt, s_value, rs);
8513 }
8514
8515
8516 /*
8517 *
8518 *
8519 * 3 2 1
8520 * 10987654321098765432109876543210
8521 * 001000 x1110000101
8522 * rt -----
8523 * rs -----
8524 * rd -----
8525 */
8526 static char *LLD(uint64 instruction, Dis_info *info)
8527 {
8528 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8529 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8530 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
8531
8532 const char *rt = GPR(rt_value, info);
8533 const char *rs = GPR(rs_value, info);
8534
8535 return img_format("LLD %s, %" PRId64 "(%s)", rt, s_value, rs);
8536 }
8537
8538
8539 /*
8540 *
8541 *
8542 * 3 2 1
8543 * 10987654321098765432109876543210
8544 * 001000 x1110000101
8545 * rt -----
8546 * rs -----
8547 * rd -----
8548 */
8549 static char *LLDP(uint64 instruction, Dis_info *info)
8550 {
8551 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8552 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8553 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8554
8555 const char *rt = GPR(rt_value, info);
8556 const char *ru = GPR(ru_value, info);
8557 const char *rs = GPR(rs_value, info);
8558
8559 return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
8560 }
8561
8562
8563 /*
8564 *
8565 *
8566 * 3 2 1
8567 * 10987654321098765432109876543210
8568 * 001000 x1110000101
8569 * rt -----
8570 * rs -----
8571 * rd -----
8572 */
8573 static char *LLE(uint64 instruction, Dis_info *info)
8574 {
8575 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8576 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8577 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
8578
8579 const char *rt = GPR(rt_value, info);
8580 const char *rs = GPR(rs_value, info);
8581
8582 return img_format("LLE %s, %" PRId64 "(%s)", rt, s_value, rs);
8583 }
8584
8585
8586 /*
8587 *
8588 *
8589 * 3 2 1
8590 * 10987654321098765432109876543210
8591 * 001000 x1110000101
8592 * rt -----
8593 * rs -----
8594 * rd -----
8595 */
8596 static char *LLWP(uint64 instruction, Dis_info *info)
8597 {
8598 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8600 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8601
8602 const char *rt = GPR(rt_value, info);
8603 const char *ru = GPR(ru_value, info);
8604 const char *rs = GPR(rs_value, info);
8605
8606 return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
8607 }
8608
8609
8610 /*
8611 *
8612 *
8613 * 3 2 1
8614 * 10987654321098765432109876543210
8615 * 001000 x1110000101
8616 * rt -----
8617 * rs -----
8618 * rd -----
8619 */
8620 static char *LLWPE(uint64 instruction, Dis_info *info)
8621 {
8622 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8623 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8624 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
8625
8626 const char *rt = GPR(rt_value, info);
8627 const char *ru = GPR(ru_value, info);
8628 const char *rs = GPR(rs_value, info);
8629
8630 return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
8631 }
8632
8633
8634 /*
8635 *
8636 *
8637 * 3 2 1
8638 * 10987654321098765432109876543210
8639 * 001000 x1110000101
8640 * rt -----
8641 * rs -----
8642 * rd -----
8643 */
8644 static char *LSA(uint64 instruction, Dis_info *info)
8645 {
8646 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8647 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8648 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
8649 uint64 u2_value = extract_u2_10_9(instruction);
8650
8651 const char *rd = GPR(rd_value, info);
8652 const char *rs = GPR(rs_value, info);
8653 const char *rt = GPR(rt_value, info);
8654
8655 return img_format("LSA %s, %s, %s, 0x%" PRIx64, rd, rs, rt, u2_value);
8656 }
8657
8658
8659 /*
8660 *
8661 *
8662 * 3 2 1
8663 * 10987654321098765432109876543210
8664 * 001000 x1110000101
8665 * rt -----
8666 * rs -----
8667 * rd -----
8668 */
8669 static char *LUI(uint64 instruction, Dis_info *info)
8670 {
8671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8672 int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
8673
8674 const char *rt = GPR(rt_value, info);
8675
8676 return img_format("LUI %s, %%hi(%" PRId64 ")", rt, s_value);
8677 }
8678
8679
8680 /*
8681 *
8682 *
8683 * 3 2 1
8684 * 10987654321098765432109876543210
8685 * 001000 x1110000101
8686 * rt -----
8687 * rs -----
8688 * rd -----
8689 */
8690 static char *LW_16_(uint64 instruction, Dis_info *info)
8691 {
8692 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8693 uint64 rs3_value = extract_rs3_6_5_4(instruction);
8694 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
8695
8696 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8697 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
8698
8699 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt3, u_value, rs3);
8700 }
8701
8702
8703 /*
8704 *
8705 *
8706 * 3 2 1
8707 * 10987654321098765432109876543210
8708 * 001000 x1110000101
8709 * rt -----
8710 * rs -----
8711 * rd -----
8712 */
8713 static char *LW_4X4_(uint64 instruction, Dis_info *info)
8714 {
8715 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
8716 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
8717 uint64 u_value = extract_u_3_8__s2(instruction);
8718
8719 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
8720 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
8721
8722 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt4, u_value, rs4);
8723 }
8724
8725
8726 /*
8727 *
8728 *
8729 * 3 2 1
8730 * 10987654321098765432109876543210
8731 * 001000 x1110000101
8732 * rt -----
8733 * rs -----
8734 * rd -----
8735 */
8736 static char *LW_GP_(uint64 instruction, Dis_info *info)
8737 {
8738 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8739 uint64 u_value = extract_u_20_to_2__s2(instruction);
8740
8741 const char *rt = GPR(rt_value, info);
8742
8743 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
8744 }
8745
8746
8747 /*
8748 *
8749 *
8750 * 3 2 1
8751 * 10987654321098765432109876543210
8752 * 001000 x1110000101
8753 * rt -----
8754 * rs -----
8755 * rd -----
8756 */
8757 static char *LW_GP16_(uint64 instruction, Dis_info *info)
8758 {
8759 uint64 rt3_value = extract_rt3_9_8_7(instruction);
8760 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
8761
8762 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
8763
8764 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt3, u_value, 28);
8765 }
8766
8767
8768 /*
8769 *
8770 *
8771 * 3 2 1
8772 * 10987654321098765432109876543210
8773 * 001000 x1110000101
8774 * rt -----
8775 * rs -----
8776 * rd -----
8777 */
8778 static char *LW_S9_(uint64 instruction, Dis_info *info)
8779 {
8780 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8781 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8782 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8783
8784 const char *rt = GPR(rt_value, info);
8785 const char *rs = GPR(rs_value, info);
8786
8787 return img_format("LW %s, %" PRId64 "(%s)", rt, s_value, rs);
8788 }
8789
8790
8791 /*
8792 *
8793 *
8794 * 3 2 1
8795 * 10987654321098765432109876543210
8796 * 001000 x1110000101
8797 * rt -----
8798 * rs -----
8799 * rd -----
8800 */
8801 static char *LW_SP_(uint64 instruction, Dis_info *info)
8802 {
8803 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
8804 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
8805
8806 const char *rt = GPR(rt_value, info);
8807
8808 return img_format("LW %s, 0x%" PRIx64 "($%d)", rt, u_value, 29);
8809 }
8810
8811
8812 /*
8813 *
8814 *
8815 * 3 2 1
8816 * 10987654321098765432109876543210
8817 * 001000 x1110000101
8818 * rt -----
8819 * rs -----
8820 * rd -----
8821 */
8822 static char *LW_U12_(uint64 instruction, Dis_info *info)
8823 {
8824 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8825 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8826 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8827
8828 const char *rt = GPR(rt_value, info);
8829 const char *rs = GPR(rs_value, info);
8830
8831 return img_format("LW %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
8832 }
8833
8834
8835 /*
8836 *
8837 *
8838 * 3 2 1
8839 * 10987654321098765432109876543210
8840 * 001000 x1110000101
8841 * rt -----
8842 * rs -----
8843 * rd -----
8844 */
8845 static char *LWC1_GP_(uint64 instruction, Dis_info *info)
8846 {
8847 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8848 uint64 u_value = extract_u_17_to_2__s2(instruction);
8849
8850 const char *ft = FPR(ft_value, info);
8851
8852 return img_format("LWC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
8853 }
8854
8855
8856 /*
8857 *
8858 *
8859 * 3 2 1
8860 * 10987654321098765432109876543210
8861 * 001000 x1110000101
8862 * rt -----
8863 * rs -----
8864 * rd -----
8865 */
8866 static char *LWC1_S9_(uint64 instruction, Dis_info *info)
8867 {
8868 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8869 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8870 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8871
8872 const char *ft = FPR(ft_value, info);
8873 const char *rs = GPR(rs_value, info);
8874
8875 return img_format("LWC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
8876 }
8877
8878
8879 /*
8880 *
8881 *
8882 * 3 2 1
8883 * 10987654321098765432109876543210
8884 * 001000 x1110000101
8885 * rt -----
8886 * rs -----
8887 * rd -----
8888 */
8889 static char *LWC1_U12_(uint64 instruction, Dis_info *info)
8890 {
8891 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
8892 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8893 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
8894
8895 const char *ft = FPR(ft_value, info);
8896 const char *rs = GPR(rs_value, info);
8897
8898 return img_format("LWC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
8899 }
8900
8901
8902 /*
8903 *
8904 *
8905 * 3 2 1
8906 * 10987654321098765432109876543210
8907 * 001000 x1110000101
8908 * rt -----
8909 * rs -----
8910 * rd -----
8911 */
8912 static char *LWC1X(uint64 instruction, Dis_info *info)
8913 {
8914 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8915 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8916 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8917
8918 const char *ft = FPR(ft_value, info);
8919 const char *rs = GPR(rs_value, info);
8920 const char *rt = GPR(rt_value, info);
8921
8922 return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
8923 }
8924
8925
8926 /*
8927 *
8928 *
8929 * 3 2 1
8930 * 10987654321098765432109876543210
8931 * 001000 x1110000101
8932 * rt -----
8933 * rs -----
8934 * rd -----
8935 */
8936 static char *LWC1XS(uint64 instruction, Dis_info *info)
8937 {
8938 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8939 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8940 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
8941
8942 const char *ft = FPR(ft_value, info);
8943 const char *rs = GPR(rs_value, info);
8944 const char *rt = GPR(rt_value, info);
8945
8946 return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
8947 }
8948
8949
8950 /*
8951 *
8952 *
8953 * 3 2 1
8954 * 10987654321098765432109876543210
8955 * 001000 x1110000101
8956 * rt -----
8957 * rs -----
8958 * rd -----
8959 */
8960 static char *LWC2(uint64 instruction, Dis_info *info)
8961 {
8962 uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
8963 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8964 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8965
8966 const char *rs = GPR(rs_value, info);
8967
8968 return img_format("LWC2 CP%" PRIu64 ", %" PRId64 "(%s)",
8969 ct_value, s_value, rs);
8970 }
8971
8972
8973 /*
8974 *
8975 *
8976 * 3 2 1
8977 * 10987654321098765432109876543210
8978 * 001000 x1110000101
8979 * rt -----
8980 * rs -----
8981 * rd -----
8982 */
8983 static char *LWE(uint64 instruction, Dis_info *info)
8984 {
8985 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
8986 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
8987 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
8988
8989 const char *rt = GPR(rt_value, info);
8990 const char *rs = GPR(rs_value, info);
8991
8992 return img_format("LWE %s, %" PRId64 "(%s)", rt, s_value, rs);
8993 }
8994
8995
8996 /*
8997 *
8998 *
8999 * 3 2 1
9000 * 10987654321098765432109876543210
9001 * 001000 x1110000101
9002 * rt -----
9003 * rs -----
9004 * rd -----
9005 */
9006 static char *LWM(uint64 instruction, Dis_info *info)
9007 {
9008 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9009 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9010 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9011 uint64 count3_value = extract_count3_14_13_12(instruction);
9012
9013 const char *rt = GPR(rt_value, info);
9014 const char *rs = GPR(rs_value, info);
9015 uint64 count3 = encode_count3_from_count(count3_value);
9016
9017 return img_format("LWM %s, %" PRId64 "(%s), 0x%" PRIx64,
9018 rt, s_value, rs, count3);
9019 }
9020
9021
9022 /*
9023 *
9024 *
9025 * 3 2 1
9026 * 10987654321098765432109876543210
9027 * 001000 x1110000101
9028 * rt -----
9029 * rs -----
9030 * rd -----
9031 */
9032 static char *LWPC_48_(uint64 instruction, Dis_info *info)
9033 {
9034 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
9035 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
9036
9037 const char *rt = GPR(rt_value, info);
9038 g_autofree char *s = ADDRESS(s_value, 6, info);
9039
9040 return img_format("LWPC %s, %s", rt, s);
9041 }
9042
9043
9044 /*
9045 *
9046 *
9047 * 3 2 1
9048 * 10987654321098765432109876543210
9049 * 001000 x1110000101
9050 * rt -----
9051 * rs -----
9052 * rd -----
9053 */
9054 static char *LWU_GP_(uint64 instruction, Dis_info *info)
9055 {
9056 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9057 uint64 u_value = extract_u_17_to_2__s2(instruction);
9058
9059 const char *rt = GPR(rt_value, info);
9060
9061 return img_format("LWU %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
9062 }
9063
9064
9065 /*
9066 *
9067 *
9068 * 3 2 1
9069 * 10987654321098765432109876543210
9070 * 001000 x1110000101
9071 * rt -----
9072 * rs -----
9073 * rd -----
9074 */
9075 static char *LWU_S9_(uint64 instruction, Dis_info *info)
9076 {
9077 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9078 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9079 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
9080
9081 const char *rt = GPR(rt_value, info);
9082 const char *rs = GPR(rs_value, info);
9083
9084 return img_format("LWU %s, %" PRId64 "(%s)", rt, s_value, rs);
9085 }
9086
9087
9088 /*
9089 *
9090 *
9091 * 3 2 1
9092 * 10987654321098765432109876543210
9093 * 001000 x1110000101
9094 * rt -----
9095 * rs -----
9096 * rd -----
9097 */
9098 static char *LWU_U12_(uint64 instruction, Dis_info *info)
9099 {
9100 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9101 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9102 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
9103
9104 const char *rt = GPR(rt_value, info);
9105 const char *rs = GPR(rs_value, info);
9106
9107 return img_format("LWU %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
9108 }
9109
9110
9111 /*
9112 *
9113 *
9114 * 3 2 1
9115 * 10987654321098765432109876543210
9116 * 001000 x1110000101
9117 * rt -----
9118 * rs -----
9119 * rd -----
9120 */
9121 static char *LWUX(uint64 instruction, Dis_info *info)
9122 {
9123 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9124 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9125 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9126
9127 const char *rd = GPR(rd_value, info);
9128 const char *rs = GPR(rs_value, info);
9129 const char *rt = GPR(rt_value, info);
9130
9131 return img_format("LWUX %s, %s(%s)", rd, rs, rt);
9132 }
9133
9134
9135 /*
9136 *
9137 *
9138 * 3 2 1
9139 * 10987654321098765432109876543210
9140 * 001000 x1110000101
9141 * rt -----
9142 * rs -----
9143 * rd -----
9144 */
9145 static char *LWUXS(uint64 instruction, Dis_info *info)
9146 {
9147 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9148 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9149 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9150
9151 const char *rd = GPR(rd_value, info);
9152 const char *rs = GPR(rs_value, info);
9153 const char *rt = GPR(rt_value, info);
9154
9155 return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
9156 }
9157
9158
9159 /*
9160 *
9161 *
9162 * 3 2 1
9163 * 10987654321098765432109876543210
9164 * 001000 x1110000101
9165 * rt -----
9166 * rs -----
9167 * rd -----
9168 */
9169 static char *LWX(uint64 instruction, Dis_info *info)
9170 {
9171 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9172 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9173 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9174
9175 const char *rd = GPR(rd_value, info);
9176 const char *rs = GPR(rs_value, info);
9177 const char *rt = GPR(rt_value, info);
9178
9179 return img_format("LWX %s, %s(%s)", rd, rs, rt);
9180 }
9181
9182
9183 /*
9184 *
9185 *
9186 * 3 2 1
9187 * 10987654321098765432109876543210
9188 * 001000 x1110000101
9189 * rt -----
9190 * rs -----
9191 * rd -----
9192 */
9193 static char *LWXS_16_(uint64 instruction, Dis_info *info)
9194 {
9195 uint64 rt3_value = extract_rt3_9_8_7(instruction);
9196 uint64 rs3_value = extract_rs3_6_5_4(instruction);
9197 uint64 rd3_value = extract_rd3_3_2_1(instruction);
9198
9199 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
9200 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
9201 uint64 rt3 = decode_gpr_gpr3(rt3_value, info);
9202
9203 return img_format("LWXS %s, %s(0x%" PRIx64 ")", rd3, rs3, rt3);
9204 }
9205
9206
9207 /*
9208 *
9209 *
9210 * 3 2 1
9211 * 10987654321098765432109876543210
9212 * 001000 x1110000101
9213 * rt -----
9214 * rs -----
9215 * rd -----
9216 */
9217 static char *LWXS_32_(uint64 instruction, Dis_info *info)
9218 {
9219 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9220 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9221 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9222
9223 const char *rd = GPR(rd_value, info);
9224 const char *rs = GPR(rs_value, info);
9225 const char *rt = GPR(rt_value, info);
9226
9227 return img_format("LWXS %s, %s(%s)", rd, rs, rt);
9228 }
9229
9230
9231 /*
9232 * [DSP] MADD ac, rs, rt - Multiply two words and add to the specified
9233 * accumulator
9234 *
9235 * 3 2 1
9236 * 10987654321098765432109876543210
9237 * 001000 x1110000101
9238 * rt -----
9239 * rs -----
9240 * rd -----
9241 */
9242 static char *MADD_DSP_(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 ac_value = extract_ac_15_14(instruction);
9247
9248 const char *ac = AC(ac_value, info);
9249 const char *rs = GPR(rs_value, info);
9250 const char *rt = GPR(rt_value, info);
9251
9252 return img_format("MADD %s, %s, %s", ac, 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 *MADDF_D(uint64 instruction, Dis_info *info)
9267 {
9268 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9269 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9270 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9271
9272 const char *fd = FPR(fd_value, info);
9273 const char *fs = FPR(fs_value, info);
9274 const char *ft = FPR(ft_value, info);
9275
9276 return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
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 *MADDF_S(uint64 instruction, Dis_info *info)
9291 {
9292 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9293 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9294 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9295
9296 const char *fd = FPR(fd_value, info);
9297 const char *fs = FPR(fs_value, info);
9298 const char *ft = FPR(ft_value, info);
9299
9300 return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
9301 }
9302
9303
9304 /*
9305 * [DSP] MADDU ac, rs, rt - Multiply two unsigned words and add to the
9306 * specified accumulator
9307 *
9308 * 3 2 1
9309 * 10987654321098765432109876543210
9310 * 001000 x1110000101
9311 * rt -----
9312 * rs -----
9313 * rd -----
9314 */
9315 static char *MADDU_DSP_(uint64 instruction, Dis_info *info)
9316 {
9317 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9318 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9319 uint64 ac_value = extract_ac_15_14(instruction);
9320
9321 const char *ac = AC(ac_value, info);
9322 const char *rs = GPR(rs_value, info);
9323 const char *rt = GPR(rt_value, info);
9324
9325 return img_format("MADDU %s, %s, %s", ac, rs, rt);
9326 }
9327
9328
9329 /*
9330 * [DSP] MAQ_S.W.PHL ac, rs, rt - Multiply the left-most single vector
9331 * fractional halfword elements with accumulation
9332 *
9333 * 3 2 1
9334 * 10987654321098765432109876543210
9335 * 001000 x1110000101
9336 * rt -----
9337 * rs -----
9338 * rd -----
9339 */
9340 static char *MAQ_S_W_PHL(uint64 instruction, Dis_info *info)
9341 {
9342 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9343 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9344 uint64 ac_value = extract_ac_15_14(instruction);
9345
9346 const char *ac = AC(ac_value, info);
9347 const char *rs = GPR(rs_value, info);
9348 const char *rt = GPR(rt_value, info);
9349
9350 return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
9351 }
9352
9353
9354 /*
9355 * [DSP] MAQ_S.W.PHR ac, rs, rt - Multiply the right-most single vector
9356 * fractional halfword elements with accumulation
9357 *
9358 * 3 2 1
9359 * 10987654321098765432109876543210
9360 * 001000 x1110000101
9361 * rt -----
9362 * rs -----
9363 * rd -----
9364 */
9365 static char *MAQ_S_W_PHR(uint64 instruction, Dis_info *info)
9366 {
9367 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9368 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9369 uint64 ac_value = extract_ac_15_14(instruction);
9370
9371 const char *ac = AC(ac_value, info);
9372 const char *rs = GPR(rs_value, info);
9373 const char *rt = GPR(rt_value, info);
9374
9375 return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
9376 }
9377
9378
9379 /*
9380 * [DSP] MAQ_SA.W.PHL ac, rs, rt - Multiply the left-most single vector
9381 * fractional halfword elements with saturating accumulation
9382 *
9383 * 3 2 1
9384 * 10987654321098765432109876543210
9385 * 001000 x1110000101
9386 * rt -----
9387 * rs -----
9388 * rd -----
9389 */
9390 static char *MAQ_SA_W_PHL(uint64 instruction, Dis_info *info)
9391 {
9392 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9393 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9394 uint64 ac_value = extract_ac_15_14(instruction);
9395
9396 const char *ac = AC(ac_value, info);
9397 const char *rs = GPR(rs_value, info);
9398 const char *rt = GPR(rt_value, info);
9399
9400 return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
9401 }
9402
9403
9404 /*
9405 * [DSP] MAQ_SA.W.PHR ac, rs, rt - Multiply the right-most single vector
9406 * fractional halfword elements with saturating accumulation
9407 *
9408 * 3 2 1
9409 * 10987654321098765432109876543210
9410 * 001000 x1110000101
9411 * rt -----
9412 * rs -----
9413 * rd -----
9414 */
9415 static char *MAQ_SA_W_PHR(uint64 instruction, Dis_info *info)
9416 {
9417 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9418 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9419 uint64 ac_value = extract_ac_15_14(instruction);
9420
9421 const char *ac = AC(ac_value, info);
9422 const char *rs = GPR(rs_value, info);
9423 const char *rt = GPR(rt_value, info);
9424
9425 return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
9426 }
9427
9428
9429 /*
9430 *
9431 *
9432 * 3 2 1
9433 * 10987654321098765432109876543210
9434 * 001000 x1110000101
9435 * rt -----
9436 * rs -----
9437 * rd -----
9438 */
9439 static char *MAX_D(uint64 instruction, Dis_info *info)
9440 {
9441 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9442 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9443 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9444
9445 const char *fd = FPR(fd_value, info);
9446 const char *fs = FPR(fs_value, info);
9447 const char *ft = FPR(ft_value, info);
9448
9449 return img_format("MAX.D %s, %s, %s", fd, fs, ft);
9450 }
9451
9452
9453 /*
9454 *
9455 *
9456 * 3 2 1
9457 * 10987654321098765432109876543210
9458 * 001000 x1110000101
9459 * rt -----
9460 * rs -----
9461 * rd -----
9462 */
9463 static char *MAX_S(uint64 instruction, Dis_info *info)
9464 {
9465 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9466 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9467 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9468
9469 const char *fd = FPR(fd_value, info);
9470 const char *fs = FPR(fs_value, info);
9471 const char *ft = FPR(ft_value, info);
9472
9473 return img_format("MAX.S %s, %s, %s", fd, fs, ft);
9474 }
9475
9476
9477 /*
9478 *
9479 *
9480 * 3 2 1
9481 * 10987654321098765432109876543210
9482 * 001000 x1110000101
9483 * rt -----
9484 * rs -----
9485 * rd -----
9486 */
9487 static char *MAXA_D(uint64 instruction, Dis_info *info)
9488 {
9489 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9490 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9491 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9492
9493 const char *fd = FPR(fd_value, info);
9494 const char *fs = FPR(fs_value, info);
9495 const char *ft = FPR(ft_value, info);
9496
9497 return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
9498 }
9499
9500
9501 /*
9502 *
9503 *
9504 * 3 2 1
9505 * 10987654321098765432109876543210
9506 * 001000 x1110000101
9507 * rt -----
9508 * rs -----
9509 * rd -----
9510 */
9511 static char *MAXA_S(uint64 instruction, Dis_info *info)
9512 {
9513 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9514 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9515 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9516
9517 const char *fd = FPR(fd_value, info);
9518 const char *fs = FPR(fs_value, info);
9519 const char *ft = FPR(ft_value, info);
9520
9521 return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
9522 }
9523
9524
9525 /*
9526 *
9527 *
9528 * 3 2 1
9529 * 10987654321098765432109876543210
9530 * 001000 x1110000101
9531 * rt -----
9532 * rs -----
9533 * rd -----
9534 */
9535 static char *MFC0(uint64 instruction, Dis_info *info)
9536 {
9537 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9538 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9539 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9540
9541 const char *rt = GPR(rt_value, info);
9542
9543 return img_format("MFC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9544 rt, c0s_value, sel_value);
9545 }
9546
9547
9548 /*
9549 *
9550 *
9551 * 3 2 1
9552 * 10987654321098765432109876543210
9553 * 001000 x1110000101
9554 * rt -----
9555 * rs -----
9556 * rd -----
9557 */
9558 static char *MFC1(uint64 instruction, Dis_info *info)
9559 {
9560 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9561 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9562
9563 const char *rt = GPR(rt_value, info);
9564 const char *fs = FPR(fs_value, info);
9565
9566 return img_format("MFC1 %s, %s", rt, fs);
9567 }
9568
9569
9570 /*
9571 *
9572 *
9573 * 3 2 1
9574 * 10987654321098765432109876543210
9575 * 001000 x1110000101
9576 * rt -----
9577 * rs -----
9578 * rd -----
9579 */
9580 static char *MFC2(uint64 instruction, Dis_info *info)
9581 {
9582 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9583 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
9584
9585 const char *rt = GPR(rt_value, info);
9586
9587 return img_format("MFC2 %s, CP%" PRIu64, rt, cs_value);
9588 }
9589
9590
9591 /*
9592 *
9593 *
9594 * 3 2 1
9595 * 10987654321098765432109876543210
9596 * 001000 x1110000101
9597 * rt -----
9598 * rs -----
9599 * rd -----
9600 */
9601 static char *MFGC0(uint64 instruction, Dis_info *info)
9602 {
9603 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9604 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9605 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9606
9607 const char *rt = GPR(rt_value, info);
9608
9609 return img_format("MFGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9610 rt, c0s_value, sel_value);
9611 }
9612
9613
9614 /*
9615 *
9616 *
9617 * 3 2 1
9618 * 10987654321098765432109876543210
9619 * 001000 x1110000101
9620 * rt -----
9621 * rs -----
9622 * rd -----
9623 */
9624 static char *MFHC0(uint64 instruction, Dis_info *info)
9625 {
9626 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9627 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9628 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9629
9630 const char *rt = GPR(rt_value, info);
9631
9632 return img_format("MFHC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9633 rt, c0s_value, sel_value);
9634 }
9635
9636
9637 /*
9638 *
9639 *
9640 * 3 2 1
9641 * 10987654321098765432109876543210
9642 * 001000 x1110000101
9643 * rt -----
9644 * rs -----
9645 * rd -----
9646 */
9647 static char *MFHC1(uint64 instruction, Dis_info *info)
9648 {
9649 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9650 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9651
9652 const char *rt = GPR(rt_value, info);
9653 const char *fs = FPR(fs_value, info);
9654
9655 return img_format("MFHC1 %s, %s", rt, fs);
9656 }
9657
9658
9659 /*
9660 *
9661 *
9662 * 3 2 1
9663 * 10987654321098765432109876543210
9664 * 001000 x1110000101
9665 * rt -----
9666 * rs -----
9667 * rd -----
9668 */
9669 static char *MFHC2(uint64 instruction, Dis_info *info)
9670 {
9671 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9672 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
9673
9674 const char *rt = GPR(rt_value, info);
9675
9676 return img_format("MFHC2 %s, CP%" PRIu64, rt, cs_value);
9677 }
9678
9679
9680 /*
9681 *
9682 *
9683 * 3 2 1
9684 * 10987654321098765432109876543210
9685 * 001000 x1110000101
9686 * rt -----
9687 * rs -----
9688 * rd -----
9689 */
9690 static char *MFHGC0(uint64 instruction, Dis_info *info)
9691 {
9692 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9693 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9694 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9695
9696 const char *rt = GPR(rt_value, info);
9697
9698 return img_format("MFHGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
9699 rt, c0s_value, sel_value);
9700 }
9701
9702
9703 /*
9704 * [DSP] MFHI rs, ac - Move from HI register
9705 *
9706 * 3 2 1
9707 * 10987654321098765432109876543210
9708 * 001000 xxxxx 00000001111111
9709 * rt -----
9710 * ac --
9711 */
9712 static char *MFHI_DSP_(uint64 instruction, Dis_info *info)
9713 {
9714 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9715 uint64 ac_value = extract_ac_15_14(instruction);
9716
9717 const char *rt = GPR(rt_value, info);
9718 const char *ac = AC(ac_value, info);
9719
9720 return img_format("MFHI %s, %s", rt, ac);
9721 }
9722
9723
9724 /*
9725 *
9726 *
9727 * 3 2 1
9728 * 10987654321098765432109876543210
9729 * 001000 x1110000101
9730 * rt -----
9731 * rs -----
9732 * rd -----
9733 */
9734 static char *MFHTR(uint64 instruction, Dis_info *info)
9735 {
9736 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9737 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9738 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9739 uint64 u_value = extract_u_10(instruction);
9740
9741 const char *rt = GPR(rt_value, info);
9742
9743 return img_format("MFHTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
9744 rt, c0s_value, u_value, sel_value);
9745 }
9746
9747
9748 /*
9749 * [DSP] MFLO rs, ac - Move from HI register
9750 *
9751 * 3 2 1
9752 * 10987654321098765432109876543210
9753 * 001000 xxxxx 01000001111111
9754 * rt -----
9755 * ac --
9756 */
9757 static char *MFLO_DSP_(uint64 instruction, Dis_info *info)
9758 {
9759 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9760 uint64 ac_value = extract_ac_15_14(instruction);
9761
9762 const char *rt = GPR(rt_value, info);
9763 const char *ac = AC(ac_value, info);
9764
9765 return img_format("MFLO %s, %s", rt, ac);
9766 }
9767
9768
9769 /*
9770 *
9771 *
9772 * 3 2 1
9773 * 10987654321098765432109876543210
9774 * 001000 x1110000101
9775 * rt -----
9776 * rs -----
9777 * rd -----
9778 */
9779 static char *MFTR(uint64 instruction, Dis_info *info)
9780 {
9781 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9782 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
9783 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
9784 uint64 u_value = extract_u_10(instruction);
9785
9786 const char *rt = GPR(rt_value, info);
9787
9788 return img_format("MFTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
9789 rt, c0s_value, u_value, sel_value);
9790 }
9791
9792
9793 /*
9794 *
9795 *
9796 * 3 2 1
9797 * 10987654321098765432109876543210
9798 * 001000 x1110000101
9799 * rt -----
9800 * rs -----
9801 * rd -----
9802 */
9803 static char *MIN_D(uint64 instruction, Dis_info *info)
9804 {
9805 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9806 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9807 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9808
9809 const char *fd = FPR(fd_value, info);
9810 const char *fs = FPR(fs_value, info);
9811 const char *ft = FPR(ft_value, info);
9812
9813 return img_format("MIN.D %s, %s, %s", fd, fs, ft);
9814 }
9815
9816
9817 /*
9818 *
9819 *
9820 * 3 2 1
9821 * 10987654321098765432109876543210
9822 * 001000 x1110000101
9823 * rt -----
9824 * rs -----
9825 * rd -----
9826 */
9827 static char *MIN_S(uint64 instruction, Dis_info *info)
9828 {
9829 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9830 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9831 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9832
9833 const char *fd = FPR(fd_value, info);
9834 const char *fs = FPR(fs_value, info);
9835 const char *ft = FPR(ft_value, info);
9836
9837 return img_format("MIN.S %s, %s, %s", fd, fs, ft);
9838 }
9839
9840
9841 /*
9842 *
9843 *
9844 * 3 2 1
9845 * 10987654321098765432109876543210
9846 * 001000 x1110000101
9847 * rt -----
9848 * rs -----
9849 * rd -----
9850 */
9851 static char *MINA_D(uint64 instruction, Dis_info *info)
9852 {
9853 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9854 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9855 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9856
9857 const char *fd = FPR(fd_value, info);
9858 const char *fs = FPR(fs_value, info);
9859 const char *ft = FPR(ft_value, info);
9860
9861 return img_format("MINA.D %s, %s, %s", fd, fs, ft);
9862 }
9863
9864
9865 /*
9866 *
9867 *
9868 * 3 2 1
9869 * 10987654321098765432109876543210
9870 * 001000 x1110000101
9871 * rt -----
9872 * rs -----
9873 * rd -----
9874 */
9875 static char *MINA_S(uint64 instruction, Dis_info *info)
9876 {
9877 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9878 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9879 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
9880
9881 const char *fd = FPR(fd_value, info);
9882 const char *fs = FPR(fs_value, info);
9883 const char *ft = FPR(ft_value, info);
9884
9885 return img_format("MINA.S %s, %s, %s", fd, fs, ft);
9886 }
9887
9888
9889 /*
9890 *
9891 *
9892 * 3 2 1
9893 * 10987654321098765432109876543210
9894 * 001000 x1110000101
9895 * rt -----
9896 * rs -----
9897 * rd -----
9898 */
9899 static char *MOD(uint64 instruction, Dis_info *info)
9900 {
9901 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9902 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9903 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9904
9905 const char *rd = GPR(rd_value, info);
9906 const char *rs = GPR(rs_value, info);
9907 const char *rt = GPR(rt_value, info);
9908
9909 return img_format("MOD %s, %s, %s", rd, rs, rt);
9910 }
9911
9912
9913 /*
9914 * [DSP] MODSUB rd, rs, rt - Modular subtraction on an index value
9915 *
9916 * 3 2 1
9917 * 10987654321098765432109876543210
9918 * 001000 x1110000101
9919 * rt -----
9920 * rs -----
9921 * rd -----
9922 */
9923 static char *MODSUB(uint64 instruction, Dis_info *info)
9924 {
9925 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9926 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9927 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9928
9929 const char *rd = GPR(rd_value, info);
9930 const char *rs = GPR(rs_value, info);
9931 const char *rt = GPR(rt_value, info);
9932
9933 return img_format("MODSUB %s, %s, %s", rd, rs, rt);
9934 }
9935
9936
9937 /*
9938 *
9939 *
9940 * 3 2 1
9941 * 10987654321098765432109876543210
9942 * 001000 x1010010101
9943 * rt -----
9944 * rs -----
9945 * rd -----
9946 */
9947 static char *MODU(uint64 instruction, Dis_info *info)
9948 {
9949 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
9950 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
9951 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
9952
9953 const char *rd = GPR(rd_value, info);
9954 const char *rs = GPR(rs_value, info);
9955 const char *rt = GPR(rt_value, info);
9956
9957 return img_format("MODU %s, %s, %s", rd, rs, rt);
9958 }
9959
9960
9961 /*
9962 *
9963 *
9964 * 3 2 1
9965 * 10987654321098765432109876543210
9966 * 001000 x1110000101
9967 * rt -----
9968 * rs -----
9969 * rd -----
9970 */
9971 static char *MOV_D(uint64 instruction, Dis_info *info)
9972 {
9973 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9974 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9975
9976 const char *ft = FPR(ft_value, info);
9977 const char *fs = FPR(fs_value, info);
9978
9979 return img_format("MOV.D %s, %s", ft, fs);
9980 }
9981
9982
9983 /*
9984 *
9985 *
9986 * 3 2 1
9987 * 10987654321098765432109876543210
9988 * 001000 x1110000101
9989 * rt -----
9990 * rs -----
9991 * rd -----
9992 */
9993 static char *MOV_S(uint64 instruction, Dis_info *info)
9994 {
9995 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
9996 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
9997
9998 const char *ft = FPR(ft_value, info);
9999 const char *fs = FPR(fs_value, info);
10000
10001 return img_format("MOV.S %s, %s", ft, fs);
10002 }
10003
10004
10005 /*
10006 *
10007 *
10008 * 3 2 1
10009 * 10987654321098765432109876543210
10010 * 001000 x1110000101
10011 * rt -----
10012 * rs -----
10013 * rd -----
10014 */
10015 static char *MOVE_BALC(uint64 instruction, Dis_info *info)
10016 {
10017 uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
10018 uint64 rd1_value = extract_rdl_25_24(instruction);
10019 int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
10020
10021 const char *rd1 = GPR(decode_gpr_gpr1(rd1_value, info), info);
10022 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
10023 g_autofree char *s = ADDRESS(s_value, 4, info);
10024
10025 return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
10026 }
10027
10028
10029 /*
10030 *
10031 *
10032 * 3 2 1
10033 * 10987654321098765432109876543210
10034 * 001000 x1110000101
10035 * rt -----
10036 * rs -----
10037 * rd -----
10038 */
10039 static char *MOVEP(uint64 instruction, Dis_info *info)
10040 {
10041 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
10042 uint64 rd2_value = extract_rd2_3_8(instruction);
10043 uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
10044
10045 const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
10046 const char *re2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
10047 /* !!!!!!!!!! - no conversion function */
10048 const char *rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value, info), info);
10049 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
10050
10051 return img_format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
10052 /* hand edited */
10053 }
10054
10055
10056 /*
10057 *
10058 *
10059 * 3 2 1
10060 * 10987654321098765432109876543210
10061 * 001000 x1110000101
10062 * rt -----
10063 * rs -----
10064 * rd -----
10065 */
10066 static char *MOVEP_REV_(uint64 instruction, Dis_info *info)
10067 {
10068 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10069 uint64 rd2_value = extract_rd2_3_8(instruction);
10070 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10071
10072 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
10073 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
10074 const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
10075 const char *rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
10076 /* !!!!!!!!!! - no conversion function */
10077
10078 return img_format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
10079 /* hand edited */
10080 }
10081
10082
10083 /*
10084 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10085 *
10086 * 3 2 1
10087 * 10987654321098765432109876543210
10088 * 001000 00010001101
10089 * rt -----
10090 * rs -----
10091 * rd -----
10092 */
10093 static char *MOVE(uint64 instruction, Dis_info *info)
10094 {
10095 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
10096 uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
10097
10098 const char *rt = GPR(rt_value, info);
10099 const char *rs = GPR(rs_value, info);
10100
10101 return img_format("MOVE %s, %s", rt, rs);
10102 }
10103
10104
10105 /*
10106 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10107 *
10108 * 3 2 1
10109 * 10987654321098765432109876543210
10110 * 001000 00010001101
10111 * rt -----
10112 * rs -----
10113 * rd -----
10114 */
10115 static char *MOVN(uint64 instruction, Dis_info *info)
10116 {
10117 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10118 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10119 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10120
10121 const char *rd = GPR(rd_value, info);
10122 const char *rs = GPR(rs_value, info);
10123 const char *rt = GPR(rt_value, info);
10124
10125 return img_format("MOVN %s, %s, %s", rd, rs, rt);
10126 }
10127
10128
10129 /*
10130 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10131 *
10132 * 3 2 1
10133 * 10987654321098765432109876543210
10134 * 001000 00010001101
10135 * rt -----
10136 * rs -----
10137 * rd -----
10138 */
10139 static char *MOVZ(uint64 instruction, Dis_info *info)
10140 {
10141 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10142 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10143 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10144
10145 const char *rd = GPR(rd_value, info);
10146 const char *rs = GPR(rs_value, info);
10147 const char *rt = GPR(rt_value, info);
10148
10149 return img_format("MOVZ %s, %s, %s", rd, rs, rt);
10150 }
10151
10152
10153 /*
10154 * [DSP] MSUB ac, rs, rt - Multiply word and subtract from accumulator
10155 *
10156 * 3 2 1
10157 * 10987654321098765432109876543210
10158 * 001000 10101010111111
10159 * rt -----
10160 * rs -----
10161 * ac --
10162 */
10163 static char *MSUB_DSP_(uint64 instruction, Dis_info *info)
10164 {
10165 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10166 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10167 uint64 ac_value = extract_ac_15_14(instruction);
10168
10169 const char *ac = AC(ac_value, info);
10170 const char *rs = GPR(rs_value, info);
10171 const char *rt = GPR(rt_value, info);
10172
10173 return img_format("MSUB %s, %s, %s", ac, rs, rt);
10174 }
10175
10176
10177 /*
10178 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10179 *
10180 * 3 2 1
10181 * 10987654321098765432109876543210
10182 * 001000 00010001101
10183 * rt -----
10184 * rs -----
10185 * rd -----
10186 */
10187 static char *MSUBF_D(uint64 instruction, Dis_info *info)
10188 {
10189 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10190 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10191 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10192
10193 const char *fd = FPR(fd_value, info);
10194 const char *fs = FPR(fs_value, info);
10195 const char *ft = FPR(ft_value, info);
10196
10197 return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
10198 }
10199
10200
10201 /*
10202 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10203 *
10204 * 3 2 1
10205 * 10987654321098765432109876543210
10206 * 001000 00010001101
10207 * rt -----
10208 * rs -----
10209 * rd -----
10210 */
10211 static char *MSUBF_S(uint64 instruction, Dis_info *info)
10212 {
10213 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10214 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10215 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10216
10217 const char *fd = FPR(fd_value, info);
10218 const char *fs = FPR(fs_value, info);
10219 const char *ft = FPR(ft_value, info);
10220
10221 return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
10222 }
10223
10224
10225 /*
10226 * [DSP] MSUBU ac, rs, rt - Multiply word and add to accumulator
10227 *
10228 * 3 2 1
10229 * 10987654321098765432109876543210
10230 * 001000 11101010111111
10231 * rt -----
10232 * rs -----
10233 * ac --
10234 */
10235 static char *MSUBU_DSP_(uint64 instruction, Dis_info *info)
10236 {
10237 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10238 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10239 uint64 ac_value = extract_ac_15_14(instruction);
10240
10241 const char *ac = AC(ac_value, info);
10242 const char *rs = GPR(rs_value, info);
10243 const char *rt = GPR(rt_value, info);
10244
10245 return img_format("MSUBU %s, %s, %s", ac, rs, rt);
10246 }
10247
10248
10249 /*
10250 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10251 *
10252 * 3 2 1
10253 * 10987654321098765432109876543210
10254 * 001000 00010001101
10255 * rt -----
10256 * rs -----
10257 * rd -----
10258 */
10259 static char *MTC0(uint64 instruction, Dis_info *info)
10260 {
10261 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10262 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10263 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10264
10265 const char *rt = GPR(rt_value, info);
10266
10267 return img_format("MTC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10268 rt, c0s_value, sel_value);
10269 }
10270
10271
10272 /*
10273 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10274 *
10275 * 3 2 1
10276 * 10987654321098765432109876543210
10277 * 001000 00010001101
10278 * rt -----
10279 * rs -----
10280 * rd -----
10281 */
10282 static char *MTC1(uint64 instruction, Dis_info *info)
10283 {
10284 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10285 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10286
10287 const char *rt = GPR(rt_value, info);
10288 const char *fs = FPR(fs_value, info);
10289
10290 return img_format("MTC1 %s, %s", rt, fs);
10291 }
10292
10293
10294 /*
10295 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10296 *
10297 * 3 2 1
10298 * 10987654321098765432109876543210
10299 * 001000 00010001101
10300 * rt -----
10301 * rs -----
10302 * rd -----
10303 */
10304 static char *MTC2(uint64 instruction, Dis_info *info)
10305 {
10306 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10307 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10308
10309 const char *rt = GPR(rt_value, info);
10310
10311 return img_format("MTC2 %s, CP%" PRIu64, rt, cs_value);
10312 }
10313
10314
10315 /*
10316 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10317 *
10318 * 3 2 1
10319 * 10987654321098765432109876543210
10320 * 001000 00010001101
10321 * rt -----
10322 * rs -----
10323 * rd -----
10324 */
10325 static char *MTGC0(uint64 instruction, Dis_info *info)
10326 {
10327 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10328 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10329 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10330
10331 const char *rt = GPR(rt_value, info);
10332
10333 return img_format("MTGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10334 rt, c0s_value, sel_value);
10335 }
10336
10337
10338 /*
10339 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10340 *
10341 * 3 2 1
10342 * 10987654321098765432109876543210
10343 * 001000 00010001101
10344 * rt -----
10345 * rs -----
10346 * rd -----
10347 */
10348 static char *MTHC0(uint64 instruction, Dis_info *info)
10349 {
10350 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10351 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10352 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10353
10354 const char *rt = GPR(rt_value, info);
10355
10356 return img_format("MTHC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10357 rt, c0s_value, sel_value);
10358 }
10359
10360
10361 /*
10362 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10363 *
10364 * 3 2 1
10365 * 10987654321098765432109876543210
10366 * 001000 00010001101
10367 * rt -----
10368 * rs -----
10369 * rd -----
10370 */
10371 static char *MTHC1(uint64 instruction, Dis_info *info)
10372 {
10373 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10374 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10375
10376 const char *rt = GPR(rt_value, info);
10377 const char *fs = FPR(fs_value, info);
10378
10379 return img_format("MTHC1 %s, %s", rt, fs);
10380 }
10381
10382
10383 /*
10384 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10385 *
10386 * 3 2 1
10387 * 10987654321098765432109876543210
10388 * 001000 00010001101
10389 * rt -----
10390 * rs -----
10391 * rd -----
10392 */
10393 static char *MTHC2(uint64 instruction, Dis_info *info)
10394 {
10395 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10396 uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
10397
10398 const char *rt = GPR(rt_value, info);
10399
10400 return img_format("MTHC2 %s, CP%" PRIu64, rt, cs_value);
10401 }
10402
10403
10404 /*
10405 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10406 *
10407 * 3 2 1
10408 * 10987654321098765432109876543210
10409 * 001000 00010001101
10410 * rt -----
10411 * rs -----
10412 * rd -----
10413 */
10414 static char *MTHGC0(uint64 instruction, Dis_info *info)
10415 {
10416 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10417 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10418 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10419
10420 const char *rt = GPR(rt_value, info);
10421
10422 return img_format("MTHGC0 %s, CP%" PRIu64 ", 0x%" PRIx64,
10423 rt, c0s_value, sel_value);
10424 }
10425
10426
10427 /*
10428 * [DSP] MTHI rs, ac - Move to HI register
10429 *
10430 * 3 2 1
10431 * 10987654321098765432109876543210
10432 * 001000xxxxx 10000001111111
10433 * rs -----
10434 * ac --
10435 */
10436 static char *MTHI_DSP_(uint64 instruction, Dis_info *info)
10437 {
10438 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10439 uint64 ac_value = extract_ac_15_14(instruction);
10440
10441 const char *rs = GPR(rs_value, info);
10442 const char *ac = AC(ac_value, info);
10443
10444 return img_format("MTHI %s, %s", rs, ac);
10445 }
10446
10447
10448 /*
10449 * [DSP] MTHLIP rs, ac - Copy LO to HI and a GPR to LO and increment pos by 32
10450 *
10451 * 3 2 1
10452 * 10987654321098765432109876543210
10453 * 001000xxxxx 00001001111111
10454 * rs -----
10455 * ac --
10456 */
10457 static char *MTHLIP(uint64 instruction, Dis_info *info)
10458 {
10459 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10460 uint64 ac_value = extract_ac_15_14(instruction);
10461
10462 const char *rs = GPR(rs_value, info);
10463 const char *ac = AC(ac_value, info);
10464
10465 return img_format("MTHLIP %s, %s", rs, ac);
10466 }
10467
10468
10469 /*
10470 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10471 *
10472 * 3 2 1
10473 * 10987654321098765432109876543210
10474 * 001000 00010001101
10475 * rt -----
10476 * rs -----
10477 * rd -----
10478 */
10479 static char *MTHTR(uint64 instruction, Dis_info *info)
10480 {
10481 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10482 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10483 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10484 uint64 u_value = extract_u_10(instruction);
10485
10486 const char *rt = GPR(rt_value, info);
10487
10488 return img_format("MTHTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
10489 rt, c0s_value, u_value, sel_value);
10490 }
10491
10492
10493 /*
10494 * [DSP] MTLO rs, ac - Move to LO register
10495 *
10496 * 3 2 1
10497 * 10987654321098765432109876543210
10498 * 001000xxxxx 11000001111111
10499 * rs -----
10500 * ac --
10501 */
10502 static char *MTLO_DSP_(uint64 instruction, Dis_info *info)
10503 {
10504 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10505 uint64 ac_value = extract_ac_15_14(instruction);
10506
10507 const char *rs = GPR(rs_value, info);
10508 const char *ac = AC(ac_value, info);
10509
10510 return img_format("MTLO %s, %s", rs, ac);
10511 }
10512
10513
10514 /*
10515 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10516 *
10517 * 3 2 1
10518 * 10987654321098765432109876543210
10519 * 001000 00010001101
10520 * rt -----
10521 * rs -----
10522 * rd -----
10523 */
10524 static char *MTTR(uint64 instruction, Dis_info *info)
10525 {
10526 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10527 uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
10528 uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
10529 uint64 u_value = extract_u_10(instruction);
10530
10531 const char *rt = GPR(rt_value, info);
10532
10533 return img_format("MTTR %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
10534 rt, c0s_value, u_value, sel_value);
10535 }
10536
10537
10538 /*
10539 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10540 *
10541 * 3 2 1
10542 * 10987654321098765432109876543210
10543 * 001000 00010001101
10544 * rt -----
10545 * rs -----
10546 * rd -----
10547 */
10548 static char *MUH(uint64 instruction, Dis_info *info)
10549 {
10550 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10551 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10552 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10553
10554 const char *rd = GPR(rd_value, info);
10555 const char *rs = GPR(rs_value, info);
10556 const char *rt = GPR(rt_value, info);
10557
10558 return img_format("MUH %s, %s, %s", rd, rs, rt);
10559 }
10560
10561
10562 /*
10563 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10564 *
10565 * 3 2 1
10566 * 10987654321098765432109876543210
10567 * 001000 00010001101
10568 * rt -----
10569 * rs -----
10570 * rd -----
10571 */
10572 static char *MUHU(uint64 instruction, Dis_info *info)
10573 {
10574 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10575 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10576 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10577
10578 const char *rd = GPR(rd_value, info);
10579 const char *rs = GPR(rs_value, info);
10580 const char *rt = GPR(rt_value, info);
10581
10582 return img_format("MUHU %s, %s, %s", rd, rs, rt);
10583 }
10584
10585
10586 /*
10587 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10588 *
10589 * 3 2 1
10590 * 10987654321098765432109876543210
10591 * 001000 00010001101
10592 * rt -----
10593 * rs -----
10594 * rd -----
10595 */
10596 static char *MUL_32_(uint64 instruction, Dis_info *info)
10597 {
10598 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10599 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10600 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10601
10602 const char *rd = GPR(rd_value, info);
10603 const char *rs = GPR(rs_value, info);
10604 const char *rt = GPR(rt_value, info);
10605
10606 return img_format("MUL %s, %s, %s", rd, rs, rt);
10607 }
10608
10609
10610 /*
10611 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10612 *
10613 * 3 2 1
10614 * 10987654321098765432109876543210
10615 * 001000 00010001101
10616 * rt -----
10617 * rs -----
10618 * rd -----
10619 */
10620 static char *MUL_4X4_(uint64 instruction, Dis_info *info)
10621 {
10622 uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
10623 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
10624
10625 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
10626 const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
10627
10628 return img_format("MUL %s, %s", rs4, rt4);
10629 }
10630
10631
10632 /*
10633 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10634 *
10635 * 3 2 1
10636 * 10987654321098765432109876543210
10637 * 001000 00010001101
10638 * rt -----
10639 * rs -----
10640 * rd -----
10641 */
10642 static char *MUL_D(uint64 instruction, Dis_info *info)
10643 {
10644 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10645 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10646 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10647
10648 const char *fd = FPR(fd_value, info);
10649 const char *fs = FPR(fs_value, info);
10650 const char *ft = FPR(ft_value, info);
10651
10652 return img_format("MUL.D %s, %s, %s", fd, fs, ft);
10653 }
10654
10655
10656 /*
10657 * [DSP] MUL.PH rd, rs, rt - Multiply vector integer half words to same size
10658 * products
10659 *
10660 * 3 2 1
10661 * 10987654321098765432109876543210
10662 * 001000 00000101101
10663 * rt -----
10664 * rs -----
10665 * rd -----
10666 */
10667 static char *MUL_PH(uint64 instruction, Dis_info *info)
10668 {
10669 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10670 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10671 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10672
10673 const char *rd = GPR(rd_value, info);
10674 const char *rs = GPR(rs_value, info);
10675 const char *rt = GPR(rt_value, info);
10676
10677 return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
10678 }
10679
10680
10681 /*
10682 * [DSP] MUL_S.PH rd, rs, rt - Multiply vector integer half words to same size
10683 * products (saturated)
10684 *
10685 * 3 2 1
10686 * 10987654321098765432109876543210
10687 * 001000 10000101101
10688 * rt -----
10689 * rs -----
10690 * rd -----
10691 */
10692 static char *MUL_S_PH(uint64 instruction, Dis_info *info)
10693 {
10694 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10695 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10696 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10697
10698 const char *rd = GPR(rd_value, info);
10699 const char *rs = GPR(rs_value, info);
10700 const char *rt = GPR(rt_value, info);
10701
10702 return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
10703 }
10704
10705
10706 /*
10707 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
10708 *
10709 * 3 2 1
10710 * 10987654321098765432109876543210
10711 * 001000 00010001101
10712 * rt -----
10713 * rs -----
10714 * rd -----
10715 */
10716 static char *MUL_S(uint64 instruction, Dis_info *info)
10717 {
10718 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
10719 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
10720 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
10721
10722 const char *fd = FPR(fd_value, info);
10723 const char *fs = FPR(fs_value, info);
10724 const char *ft = FPR(ft_value, info);
10725
10726 return img_format("MUL.S %s, %s, %s", fd, fs, ft);
10727 }
10728
10729
10730 /*
10731 * [DSP] MULEQ_S.W.PHL rd, rs, rt - Multiply vector fractional left halfwords
10732 * to expanded width products
10733 *
10734 * 3 2 1
10735 * 10987654321098765432109876543210
10736 * 001000 x0000100101
10737 * rt -----
10738 * rs -----
10739 * rd -----
10740 */
10741 static char *MULEQ_S_W_PHL(uint64 instruction, Dis_info *info)
10742 {
10743 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10744 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10745 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10746
10747 const char *rd = GPR(rd_value, info);
10748 const char *rs = GPR(rs_value, info);
10749 const char *rt = GPR(rt_value, info);
10750
10751 return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
10752 }
10753
10754
10755 /*
10756 * [DSP] MULEQ_S.W.PHR rd, rs, rt - Multiply vector fractional right halfwords
10757 * to expanded width products
10758 *
10759 * 3 2 1
10760 * 10987654321098765432109876543210
10761 * 001000 x0001100101
10762 * rt -----
10763 * rs -----
10764 * rd -----
10765 */
10766 static char *MULEQ_S_W_PHR(uint64 instruction, Dis_info *info)
10767 {
10768 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10769 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10770 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10771
10772 const char *rd = GPR(rd_value, info);
10773 const char *rs = GPR(rs_value, info);
10774 const char *rt = GPR(rt_value, info);
10775
10776 return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
10777 }
10778
10779
10780 /*
10781 * [DSP] MULEU_S.PH.QBL rd, rs, rt - Multiply vector fractional left bytes
10782 * by halfwords to halfword products
10783 *
10784 * 3 2 1
10785 * 10987654321098765432109876543210
10786 * 001000 x0010010101
10787 * rt -----
10788 * rs -----
10789 * rd -----
10790 */
10791 static char *MULEU_S_PH_QBL(uint64 instruction, Dis_info *info)
10792 {
10793 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10794 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10795 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10796
10797 const char *rd = GPR(rd_value, info);
10798 const char *rs = GPR(rs_value, info);
10799 const char *rt = GPR(rt_value, info);
10800
10801 return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
10802 }
10803
10804
10805 /*
10806 * [DSP] MULEU_S.PH.QBR rd, rs, rt - Multiply vector fractional right bytes
10807 * by halfwords to halfword products
10808 *
10809 * 3 2 1
10810 * 10987654321098765432109876543210
10811 * 001000 x0011010101
10812 * rt -----
10813 * rs -----
10814 * rd -----
10815 */
10816 static char *MULEU_S_PH_QBR(uint64 instruction, Dis_info *info)
10817 {
10818 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10819 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10820 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10821
10822 const char *rd = GPR(rd_value, info);
10823 const char *rs = GPR(rs_value, info);
10824 const char *rt = GPR(rt_value, info);
10825
10826 return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
10827 }
10828
10829
10830 /*
10831 * [DSP] MULQ_RS.PH rd, rs, rt - Multiply vector fractional halfwords
10832 * to fractional halfword products
10833 *
10834 * 3 2 1
10835 * 10987654321098765432109876543210
10836 * 001000 x0100010101
10837 * rt -----
10838 * rs -----
10839 * rd -----
10840 */
10841 static char *MULQ_RS_PH(uint64 instruction, Dis_info *info)
10842 {
10843 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10844 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10845 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10846
10847 const char *rd = GPR(rd_value, info);
10848 const char *rs = GPR(rs_value, info);
10849 const char *rt = GPR(rt_value, info);
10850
10851 return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
10852 }
10853
10854
10855 /*
10856 * [DSP] MULQ_RS.W rd, rs, rt - Multiply fractional words to same size
10857 * product with saturation and rounding
10858 *
10859 * 3 2 1
10860 * 10987654321098765432109876543210
10861 * 001000 x0110010101
10862 * rt -----
10863 * rs -----
10864 * rd -----
10865 */
10866 static char *MULQ_RS_W(uint64 instruction, Dis_info *info)
10867 {
10868 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10869 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10870 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10871
10872 const char *rd = GPR(rd_value, info);
10873 const char *rs = GPR(rs_value, info);
10874 const char *rt = GPR(rt_value, info);
10875
10876 return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
10877 }
10878
10879
10880 /*
10881 * [DSP] MULQ_S.PH rd, rs, rt - Multiply fractional halfwords to same size
10882 * products
10883 *
10884 * 3 2 1
10885 * 10987654321098765432109876543210
10886 * 001000 x0101010101
10887 * rt -----
10888 * rs -----
10889 * rd -----
10890 */
10891 static char *MULQ_S_PH(uint64 instruction, Dis_info *info)
10892 {
10893 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10894 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10895 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10896
10897 const char *rd = GPR(rd_value, info);
10898 const char *rs = GPR(rs_value, info);
10899 const char *rt = GPR(rt_value, info);
10900
10901 return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
10902 }
10903
10904
10905 /*
10906 * [DSP] MULQ_S.W rd, rs, rt - Multiply fractional words to same size product
10907 * with saturation
10908 *
10909 * 3 2 1
10910 * 10987654321098765432109876543210
10911 * 001000 x0111010101
10912 * rt -----
10913 * rs -----
10914 * rd -----
10915 */
10916 static char *MULQ_S_W(uint64 instruction, Dis_info *info)
10917 {
10918 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10919 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10920 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
10921
10922 const char *rd = GPR(rd_value, info);
10923 const char *rs = GPR(rs_value, info);
10924 const char *rt = GPR(rt_value, info);
10925
10926 return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
10927 }
10928
10929
10930 /*
10931 * [DSP] MULSA.W.PH ac, rs, rt - Multiply and subtract vector integer halfword
10932 * elements and accumulate
10933 *
10934 * 3 2 1
10935 * 10987654321098765432109876543210
10936 * 001000 10110010111111
10937 * rt -----
10938 * rs -----
10939 * ac --
10940 */
10941 static char *MULSA_W_PH(uint64 instruction, Dis_info *info)
10942 {
10943 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10944 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10945 uint64 ac_value = extract_ac_15_14(instruction);
10946
10947 const char *ac = AC(ac_value, info);
10948 const char *rs = GPR(rs_value, info);
10949 const char *rt = GPR(rt_value, info);
10950
10951 return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
10952 }
10953
10954
10955 /*
10956 * [DSP] MULSAQ_S.W.PH ac, rs, rt - Multiply and subtract vector fractional
10957 * halfwords and accumulate
10958 *
10959 * 3 2 1
10960 * 10987654321098765432109876543210
10961 * 001000 11110010111111
10962 * rt -----
10963 * rs -----
10964 * ac --
10965 */
10966 static char *MULSAQ_S_W_PH(uint64 instruction, Dis_info *info)
10967 {
10968 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10969 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10970 uint64 ac_value = extract_ac_15_14(instruction);
10971
10972 const char *ac = AC(ac_value, info);
10973 const char *rs = GPR(rs_value, info);
10974 const char *rt = GPR(rt_value, info);
10975
10976 return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
10977 }
10978
10979
10980 /*
10981 * [DSP] MULT ac, rs, rt - Multiply word
10982 *
10983 * 3 2 1
10984 * 10987654321098765432109876543210
10985 * 001000 00110010111111
10986 * rt -----
10987 * rs -----
10988 * ac --
10989 */
10990 static char *MULT_DSP_(uint64 instruction, Dis_info *info)
10991 {
10992 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
10993 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
10994 uint64 ac_value = extract_ac_15_14(instruction);
10995
10996 const char *ac = AC(ac_value, info);
10997 const char *rs = GPR(rs_value, info);
10998 const char *rt = GPR(rt_value, info);
10999
11000 return img_format("MULT %s, %s, %s", ac, rs, rt);
11001 }
11002
11003
11004 /*
11005 * [DSP] MULTU ac, rs, rt - Multiply unsigned word
11006 *
11007 * 3 2 1
11008 * 10987654321098765432109876543210
11009 * 001000 01110010111111
11010 * rt -----
11011 * rs -----
11012 * ac --
11013 */
11014 static char *MULTU_DSP_(uint64 instruction, Dis_info *info)
11015 {
11016 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11017 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11018 uint64 ac_value = extract_ac_15_14(instruction);
11019
11020 const char *ac = AC(ac_value, info);
11021 const char *rs = GPR(rs_value, info);
11022 const char *rt = GPR(rt_value, info);
11023
11024 return img_format("MULTU %s, %s, %s", ac, rs, rt);
11025 }
11026
11027
11028 /*
11029 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11030 *
11031 * 3 2 1
11032 * 10987654321098765432109876543210
11033 * 001000 00010001101
11034 * rt -----
11035 * rs -----
11036 * rd -----
11037 */
11038 static char *MULU(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 rd_value = extract_rd_15_14_13_12_11(instruction);
11043
11044 const char *rd = GPR(rd_value, info);
11045 const char *rs = GPR(rs_value, info);
11046 const char *rt = GPR(rt_value, info);
11047
11048 return img_format("MULU %s, %s, %s", rd, rs, rt);
11049 }
11050
11051
11052 /*
11053 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11054 *
11055 * 3 2 1
11056 * 10987654321098765432109876543210
11057 * 001000 00010001101
11058 * rt -----
11059 * rs -----
11060 * rd -----
11061 */
11062 static char *NEG_D(uint64 instruction, Dis_info *info)
11063 {
11064 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11065 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11066
11067 const char *ft = FPR(ft_value, info);
11068 const char *fs = FPR(fs_value, info);
11069
11070 return img_format("NEG.D %s, %s", ft, fs);
11071 }
11072
11073
11074 /*
11075 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11076 *
11077 * 3 2 1
11078 * 10987654321098765432109876543210
11079 * 001000 00010001101
11080 * rt -----
11081 * rs -----
11082 * rd -----
11083 */
11084 static char *NEG_S(uint64 instruction, Dis_info *info)
11085 {
11086 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11087 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11088
11089 const char *ft = FPR(ft_value, info);
11090 const char *fs = FPR(fs_value, info);
11091
11092 return img_format("NEG.S %s, %s", ft, fs);
11093 }
11094
11095
11096 /*
11097 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11098 *
11099 * 3 2 1
11100 * 10987654321098765432109876543210
11101 * 001000 00010001101
11102 * rt -----
11103 * rs -----
11104 * rd -----
11105 */
11106 static char *NOP_16_(uint64 instruction, Dis_info *info)
11107 {
11108 (void)instruction;
11109
11110 return g_strdup("NOP ");
11111 }
11112
11113
11114 /*
11115 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11116 *
11117 * 3 2 1
11118 * 10987654321098765432109876543210
11119 * 001000 00010001101
11120 * rt -----
11121 * rs -----
11122 * rd -----
11123 */
11124 static char *NOP_32_(uint64 instruction, Dis_info *info)
11125 {
11126 (void)instruction;
11127
11128 return g_strdup("NOP ");
11129 }
11130
11131
11132 /*
11133 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11134 *
11135 * 3 2 1
11136 * 10987654321098765432109876543210
11137 * 001000 00010001101
11138 * rt -----
11139 * rs -----
11140 * rd -----
11141 */
11142 static char *NOR(uint64 instruction, Dis_info *info)
11143 {
11144 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11145 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11146 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11147
11148 const char *rd = GPR(rd_value, info);
11149 const char *rs = GPR(rs_value, info);
11150 const char *rt = GPR(rt_value, info);
11151
11152 return img_format("NOR %s, %s, %s", rd, rs, rt);
11153 }
11154
11155
11156 /*
11157 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11158 *
11159 * 3 2 1
11160 * 10987654321098765432109876543210
11161 * 001000 00010001101
11162 * rt -----
11163 * rs -----
11164 * rd -----
11165 */
11166 static char *NOT_16_(uint64 instruction, Dis_info *info)
11167 {
11168 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11169 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11170
11171 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
11172 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
11173
11174 return img_format("NOT %s, %s", rt3, rs3);
11175 }
11176
11177
11178 /*
11179 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11180 *
11181 * 3 2 1
11182 * 10987654321098765432109876543210
11183 * 001000 00010001101
11184 * rt -----
11185 * rs -----
11186 * rd -----
11187 */
11188 static char *OR_16_(uint64 instruction, Dis_info *info)
11189 {
11190 uint64 rt3_value = extract_rt3_9_8_7(instruction);
11191 uint64 rs3_value = extract_rs3_6_5_4(instruction);
11192
11193 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
11194 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
11195
11196 return img_format("OR %s, %s", rs3, rt3);
11197 }
11198
11199
11200 /*
11201 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11202 *
11203 * 3 2 1
11204 * 10987654321098765432109876543210
11205 * 001000 00010001101
11206 * rt -----
11207 * rs -----
11208 * rd -----
11209 */
11210 static char *OR_32_(uint64 instruction, Dis_info *info)
11211 {
11212 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11213 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11214 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11215
11216 const char *rd = GPR(rd_value, info);
11217 const char *rs = GPR(rs_value, info);
11218 const char *rt = GPR(rt_value, info);
11219
11220 return img_format("OR %s, %s, %s", rd, rs, rt);
11221 }
11222
11223
11224 /*
11225 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11226 *
11227 * 3 2 1
11228 * 10987654321098765432109876543210
11229 * 001000 00010001101
11230 * rt -----
11231 * rs -----
11232 * rd -----
11233 */
11234 static char *ORI(uint64 instruction, Dis_info *info)
11235 {
11236 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11237 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11238 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11239
11240 const char *rt = GPR(rt_value, info);
11241 const char *rs = GPR(rs_value, info);
11242
11243 return img_format("ORI %s, %s, 0x%" PRIx64, rt, rs, u_value);
11244 }
11245
11246
11247 /*
11248 * [DSP] PACKRL.PH rd, rs, rt - Pack a word using the right halfword from one
11249 * source register and left halfword from another source register
11250 *
11251 * 3 2 1
11252 * 10987654321098765432109876543210
11253 * 001000 00010001101
11254 * rt -----
11255 * rs -----
11256 * rd -----
11257 */
11258 static char *PACKRL_PH(uint64 instruction, Dis_info *info)
11259 {
11260 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11261 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11262 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11263
11264 const char *rd = GPR(rd_value, info);
11265 const char *rs = GPR(rs_value, info);
11266 const char *rt = GPR(rt_value, info);
11267
11268 return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
11269 }
11270
11271
11272 /*
11273 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
11274 *
11275 * 3 2 1
11276 * 10987654321098765432109876543210
11277 * 001000 00010001101
11278 * rt -----
11279 * rs -----
11280 * rd -----
11281 */
11282 static char *PAUSE(uint64 instruction, Dis_info *info)
11283 {
11284 (void)instruction;
11285
11286 return g_strdup("PAUSE ");
11287 }
11288
11289
11290 /*
11291 * [DSP] PICK.PH rd, rs, rt - Pick a vector of halfwords based on condition
11292 * code bits
11293 *
11294 * 3 2 1
11295 * 10987654321098765432109876543210
11296 * 001000 00010001101
11297 * rt -----
11298 * rs -----
11299 * rd -----
11300 */
11301 static char *PICK_PH(uint64 instruction, Dis_info *info)
11302 {
11303 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11305 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11306
11307 const char *rd = GPR(rd_value, info);
11308 const char *rs = GPR(rs_value, info);
11309 const char *rt = GPR(rt_value, info);
11310
11311 return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
11312 }
11313
11314
11315 /*
11316 * [DSP] PICK.QB rd, rs, rt - Pick a vector of byte values based on condition
11317 * code bits
11318 *
11319 * 3 2 1
11320 * 10987654321098765432109876543210
11321 * 001000 00010001101
11322 * rt -----
11323 * rs -----
11324 * rd -----
11325 */
11326 static char *PICK_QB(uint64 instruction, Dis_info *info)
11327 {
11328 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11329 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11330 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11331
11332 const char *rd = GPR(rd_value, info);
11333 const char *rs = GPR(rs_value, info);
11334 const char *rt = GPR(rt_value, info);
11335
11336 return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
11337 }
11338
11339
11340 /*
11341 * [DSP] PRECEQ.W.PHL rt, rs - Expand the precision of the left-most element
11342 * of a paired halfword
11343 *
11344 * 3 2 1
11345 * 10987654321098765432109876543210
11346 * 001000 00010001101
11347 * rt -----
11348 * rs -----
11349 * rd -----
11350 */
11351 static char *PRECEQ_W_PHL(uint64 instruction, Dis_info *info)
11352 {
11353 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11354 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11355
11356 const char *rt = GPR(rt_value, info);
11357 const char *rs = GPR(rs_value, info);
11358
11359 return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
11360 }
11361
11362
11363 /*
11364 * [DSP] PRECEQ.W.PHR rt, rs - Expand the precision of the right-most element
11365 * of a paired halfword
11366 *
11367 * 3 2 1
11368 * 10987654321098765432109876543210
11369 * 001000 00010001101
11370 * rt -----
11371 * rs -----
11372 * rd -----
11373 */
11374 static char *PRECEQ_W_PHR(uint64 instruction, Dis_info *info)
11375 {
11376 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11377 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11378
11379 const char *rt = GPR(rt_value, info);
11380 const char *rs = GPR(rs_value, info);
11381
11382 return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
11383 }
11384
11385
11386 /*
11387 * [DSP] PRECEQU.PH.QBLA rt, rs - Expand the precision of the two
11388 * left-alternate elements of a quad byte vector
11389 *
11390 * 3 2 1
11391 * 10987654321098765432109876543210
11392 * 001000 00010001101
11393 * rt -----
11394 * rs -----
11395 * rd -----
11396 */
11397 static char *PRECEQU_PH_QBLA(uint64 instruction, Dis_info *info)
11398 {
11399 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11400 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11401
11402 const char *rt = GPR(rt_value, info);
11403 const char *rs = GPR(rs_value, info);
11404
11405 return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
11406 }
11407
11408
11409 /*
11410 * [DSP] PRECEQU.PH.QBL rt, rs - Expand the precision of the two left-most
11411 * elements of a quad byte vector
11412 *
11413 * 3 2 1
11414 * 10987654321098765432109876543210
11415 * 001000 00010001101
11416 * rt -----
11417 * rs -----
11418 * rd -----
11419 */
11420 static char *PRECEQU_PH_QBL(uint64 instruction, Dis_info *info)
11421 {
11422 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11423 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11424
11425 const char *rt = GPR(rt_value, info);
11426 const char *rs = GPR(rs_value, info);
11427
11428 return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
11429 }
11430
11431
11432 /*
11433 * [DSP] PRECEQU.PH.QBRA rt, rs - Expand the precision of the two
11434 * right-alternate elements of a quad byte vector
11435 *
11436 * 3 2 1
11437 * 10987654321098765432109876543210
11438 * 001000 00010001101
11439 * rt -----
11440 * rs -----
11441 * rd -----
11442 */
11443 static char *PRECEQU_PH_QBRA(uint64 instruction, Dis_info *info)
11444 {
11445 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11446 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11447
11448 const char *rt = GPR(rt_value, info);
11449 const char *rs = GPR(rs_value, info);
11450
11451 return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
11452 }
11453
11454
11455 /*
11456 * [DSP] PRECEQU.PH.QBR rt, rs - Expand the precision of the two right-most
11457 * elements of a quad byte vector
11458 *
11459 * 3 2 1
11460 * 10987654321098765432109876543210
11461 * 001000 00010001101
11462 * rt -----
11463 * rs -----
11464 * rd -----
11465 */
11466 static char *PRECEQU_PH_QBR(uint64 instruction, Dis_info *info)
11467 {
11468 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11469 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11470
11471 const char *rt = GPR(rt_value, info);
11472 const char *rs = GPR(rs_value, info);
11473
11474 return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
11475 }
11476
11477
11478 /*
11479 * [DSP] PRECEU.PH.QBLA rt, rs - Expand the precision of the two
11480 * left-alternate elements of a quad byte vector to four unsigned
11481 * halfwords
11482 *
11483 * 3 2 1
11484 * 10987654321098765432109876543210
11485 * 001000 00010001101
11486 * rt -----
11487 * rs -----
11488 * rd -----
11489 */
11490 static char *PRECEU_PH_QBLA(uint64 instruction, Dis_info *info)
11491 {
11492 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11493 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11494
11495 const char *rt = GPR(rt_value, info);
11496 const char *rs = GPR(rs_value, info);
11497
11498 return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
11499 }
11500
11501
11502 /*
11503 * [DSP] PRECEU.PH.QBL rt, rs - Expand the precision of the two left-most
11504 * elements of a quad byte vector to form unsigned halfwords
11505 *
11506 * 3 2 1
11507 * 10987654321098765432109876543210
11508 * 001000 00010001101
11509 * rt -----
11510 * rs -----
11511 * rd -----
11512 */
11513 static char *PRECEU_PH_QBL(uint64 instruction, Dis_info *info)
11514 {
11515 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11516 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11517
11518 const char *rt = GPR(rt_value, info);
11519 const char *rs = GPR(rs_value, info);
11520
11521 return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
11522 }
11523
11524
11525 /*
11526 * [DSP] PRECEU.PH.QBRA rt, rs - Expand the precision of the two
11527 * right-alternate elements of a quad byte vector to form four
11528 * unsigned halfwords
11529 *
11530 * 3 2 1
11531 * 10987654321098765432109876543210
11532 * 001000 00010001101
11533 * rt -----
11534 * rs -----
11535 * rd -----
11536 */
11537 static char *PRECEU_PH_QBRA(uint64 instruction, Dis_info *info)
11538 {
11539 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11540 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11541
11542 const char *rt = GPR(rt_value, info);
11543 const char *rs = GPR(rs_value, info);
11544
11545 return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
11546 }
11547
11548
11549 /*
11550 * [DSP] PRECEU.PH.QBR rt, rs - Expand the precision of the two right-most
11551 * elements of a quad byte vector to form unsigned halfwords
11552 *
11553 * 3 2 1
11554 * 10987654321098765432109876543210
11555 * 001000 00010001101
11556 * rt -----
11557 * rs -----
11558 * rd -----
11559 */
11560 static char *PRECEU_PH_QBR(uint64 instruction, Dis_info *info)
11561 {
11562 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11563 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11564
11565 const char *rt = GPR(rt_value, info);
11566 const char *rs = GPR(rs_value, info);
11567
11568 return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
11569 }
11570
11571
11572 /*
11573 * [DSP] PRECR.QB.PH rd, rs, rt - Reduce the precision of four integer
11574 * halfwords to four bytes
11575 *
11576 * 3 2 1
11577 * 10987654321098765432109876543210
11578 * 001000 x0001101101
11579 * rt -----
11580 * rs -----
11581 * rd -----
11582 */
11583 static char *PRECR_QB_PH(uint64 instruction, Dis_info *info)
11584 {
11585 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11586 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11587 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11588
11589 const char *rd = GPR(rd_value, info);
11590 const char *rs = GPR(rs_value, info);
11591 const char *rt = GPR(rt_value, info);
11592
11593 return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
11594 }
11595
11596
11597 /*
11598 * [DSP] PRECR_SRA.PH.W rt, rs, sa - Reduce the precision of two integer
11599 * words to halfwords after a right shift
11600 *
11601 * 3 2 1
11602 * 10987654321098765432109876543210
11603 * 001000 x1110000101
11604 * rt -----
11605 * rs -----
11606 * rd -----
11607 */
11608 static char *PRECR_SRA_PH_W(uint64 instruction, Dis_info *info)
11609 {
11610 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11611 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11612 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11613
11614 const char *rt = GPR(rt_value, info);
11615 const char *rs = GPR(rs_value, info);
11616
11617 return img_format("PRECR_SRA.PH.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11618 }
11619
11620
11621 /*
11622 * [DSP] PRECR_SRA_R.PH.W rt, rs, sa - Reduce the precision of two integer
11623 * words to halfwords after a right shift with rounding
11624 *
11625 * 3 2 1
11626 * 10987654321098765432109876543210
11627 * 001000 x1110000101
11628 * rt -----
11629 * rs -----
11630 * rd -----
11631 */
11632 static char *PRECR_SRA_R_PH_W(uint64 instruction, Dis_info *info)
11633 {
11634 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11635 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11636 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11637
11638 const char *rt = GPR(rt_value, info);
11639 const char *rs = GPR(rs_value, info);
11640
11641 return img_format("PRECR_SRA_R.PH.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11642 }
11643
11644
11645 /*
11646 * [DSP] PRECRQ.PH.W rd, rs, rt - Reduce the precision of fractional
11647 * words to fractional halfwords
11648 *
11649 * 3 2 1
11650 * 10987654321098765432109876543210
11651 * 001000 x1110000101
11652 * rt -----
11653 * rs -----
11654 * rd -----
11655 */
11656 static char *PRECRQ_PH_W(uint64 instruction, Dis_info *info)
11657 {
11658 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11659 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11660 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11661
11662 const char *rd = GPR(rd_value, info);
11663 const char *rs = GPR(rs_value, info);
11664 const char *rt = GPR(rt_value, info);
11665
11666 return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
11667 }
11668
11669
11670 /*
11671 * [DSP] PRECRQ.QB.PH rd, rs, rt - Reduce the precision of four fractional
11672 * halfwords to four bytes
11673 *
11674 * 3 2 1
11675 * 10987654321098765432109876543210
11676 * 001000 x0010101101
11677 * rt -----
11678 * rs -----
11679 * rd -----
11680 */
11681 static char *PRECRQ_QB_PH(uint64 instruction, Dis_info *info)
11682 {
11683 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11684 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11685 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11686
11687 const char *rd = GPR(rd_value, info);
11688 const char *rs = GPR(rs_value, info);
11689 const char *rt = GPR(rt_value, info);
11690
11691 return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
11692 }
11693
11694
11695 /*
11696 * [DSP] PRECRQ_RS.PH.W rd, rs, rt - Reduce the precision of fractional
11697 * words to halfwords with rounding and saturation
11698 *
11699 * 3 2 1
11700 * 10987654321098765432109876543210
11701 * 001000 x1110000101
11702 * rt -----
11703 * rs -----
11704 * rd -----
11705 */
11706 static char *PRECRQ_RS_PH_W(uint64 instruction, Dis_info *info)
11707 {
11708 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11709 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11710 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11711
11712 const char *rd = GPR(rd_value, info);
11713 const char *rs = GPR(rs_value, info);
11714 const char *rt = GPR(rt_value, info);
11715
11716 return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
11717 }
11718
11719
11720 /*
11721 * [DSP] PRECRQU_S.QB.PH rd, rs, rt - Reduce the precision of fractional
11722 * halfwords to unsigned bytes with saturation
11723 *
11724 * 3 2 1
11725 * 10987654321098765432109876543210
11726 * 001000 x1110000101
11727 * rt -----
11728 * rs -----
11729 * rd -----
11730 */
11731 static char *PRECRQU_S_QB_PH(uint64 instruction, Dis_info *info)
11732 {
11733 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11734 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11735 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
11736
11737 const char *rd = GPR(rd_value, info);
11738 const char *rs = GPR(rs_value, info);
11739 const char *rt = GPR(rt_value, info);
11740
11741 return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
11742 }
11743
11744
11745 /*
11746 *
11747 *
11748 * 3 2 1
11749 * 10987654321098765432109876543210
11750 * 001000 x1110000101
11751 * rt -----
11752 * rs -----
11753 * rd -----
11754 */
11755 static char *PREF_S9_(uint64 instruction, Dis_info *info)
11756 {
11757 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11758 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11759 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
11760
11761 const char *rs = GPR(rs_value, info);
11762
11763 return img_format("PREF 0x%" PRIx64 ", %" PRId64 "(%s)",
11764 hint_value, s_value, rs);
11765 }
11766
11767
11768 /*
11769 *
11770 *
11771 * 3 2 1
11772 * 10987654321098765432109876543210
11773 * 001000 x1110000101
11774 * rt -----
11775 * rs -----
11776 * rd -----
11777 */
11778 static char *PREF_U12_(uint64 instruction, Dis_info *info)
11779 {
11780 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11781 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11782 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
11783
11784 const char *rs = GPR(rs_value, info);
11785
11786 return img_format("PREF 0x%" PRIx64 ", 0x%" PRIx64 "(%s)",
11787 hint_value, u_value, rs);
11788 }
11789
11790
11791 /*
11792 *
11793 *
11794 * 3 2 1
11795 * 10987654321098765432109876543210
11796 * 001000 x1110000101
11797 * rt -----
11798 * rs -----
11799 * rd -----
11800 */
11801 static char *PREFE(uint64 instruction, Dis_info *info)
11802 {
11803 uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
11804 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11805 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
11806
11807 const char *rs = GPR(rs_value, info);
11808
11809 return img_format("PREFE 0x%" PRIx64 ", %" PRId64 "(%s)",
11810 hint_value, s_value, rs);
11811 }
11812
11813
11814 /*
11815 * [DSP] PREPEND rt, rs, sa - Right shift and prepend bits to the MSB
11816 *
11817 * 3 2 1
11818 * 10987654321098765432109876543210
11819 * 001000 x1110000101
11820 * rt -----
11821 * rs -----
11822 * rd -----
11823 */
11824 static char *PREPEND(uint64 instruction, Dis_info *info)
11825 {
11826 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11827 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11828 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
11829
11830 const char *rt = GPR(rt_value, info);
11831 const char *rs = GPR(rs_value, info);
11832
11833 return img_format("PREPEND %s, %s, 0x%" PRIx64, rt, rs, sa_value);
11834 }
11835
11836
11837 /*
11838 * [DSP] RADDU.W.QB rt, rs - Unsigned reduction add of vector quad bytes
11839 *
11840 * 3 2 1
11841 * 10987654321098765432109876543210
11842 * 001000 1111000100111111
11843 * rt -----
11844 * rs -----
11845 */
11846 static char *RADDU_W_QB(uint64 instruction, Dis_info *info)
11847 {
11848 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11849 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11850
11851 const char *rt = GPR(rt_value, info);
11852 const char *rs = GPR(rs_value, info);
11853
11854 return img_format("RADDU.W.QB %s, %s", rt, rs);
11855 }
11856
11857
11858 /*
11859 * [DSP] RDDSP rt, mask - Read DSPControl register fields to a GPR
11860 *
11861 * 3 2 1
11862 * 10987654321098765432109876543210
11863 * 001000 00011001111111
11864 * rt -----
11865 * mask -------
11866 */
11867 static char *RDDSP(uint64 instruction, Dis_info *info)
11868 {
11869 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11870 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
11871
11872 const char *rt = GPR(rt_value, info);
11873
11874 return img_format("RDDSP %s, 0x%" PRIx64, rt, mask_value);
11875 }
11876
11877
11878 /*
11879 *
11880 *
11881 * 3 2 1
11882 * 10987654321098765432109876543210
11883 * 001000 x1110000101
11884 * rt -----
11885 * rs -----
11886 * rd -----
11887 */
11888 static char *RDHWR(uint64 instruction, Dis_info *info)
11889 {
11890 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11891 uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
11892 uint64 sel_value = extract_sel_13_12_11(instruction);
11893
11894 const char *rt = GPR(rt_value, info);
11895
11896 return img_format("RDHWR %s, CP%" PRIu64 ", 0x%" PRIx64,
11897 rt, hs_value, sel_value);
11898 }
11899
11900
11901 /*
11902 *
11903 *
11904 * 3 2 1
11905 * 10987654321098765432109876543210
11906 * 001000 x1110000101
11907 * rt -----
11908 * rs -----
11909 * rd -----
11910 */
11911 static char *RDPGPR(uint64 instruction, Dis_info *info)
11912 {
11913 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11914 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
11915
11916 const char *rt = GPR(rt_value, info);
11917 const char *rs = GPR(rs_value, info);
11918
11919 return img_format("RDPGPR %s, %s", rt, rs);
11920 }
11921
11922
11923 /*
11924 *
11925 *
11926 * 3 2 1
11927 * 10987654321098765432109876543210
11928 * 001000 x1110000101
11929 * rt -----
11930 * rs -----
11931 * rd -----
11932 */
11933 static char *RECIP_D(uint64 instruction, Dis_info *info)
11934 {
11935 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11936 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11937
11938 const char *ft = FPR(ft_value, info);
11939 const char *fs = FPR(fs_value, info);
11940
11941 return img_format("RECIP.D %s, %s", ft, fs);
11942 }
11943
11944
11945 /*
11946 *
11947 *
11948 * 3 2 1
11949 * 10987654321098765432109876543210
11950 * 001000 x1110000101
11951 * rt -----
11952 * rs -----
11953 * rd -----
11954 */
11955 static char *RECIP_S(uint64 instruction, Dis_info *info)
11956 {
11957 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
11958 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
11959
11960 const char *ft = FPR(ft_value, info);
11961 const char *fs = FPR(fs_value, info);
11962
11963 return img_format("RECIP.S %s, %s", ft, fs);
11964 }
11965
11966
11967 /*
11968 * [DSP] REPL.PH rd, s - Replicate immediate integer into all vector element
11969 * positions
11970 *
11971 * 3 2 1
11972 * 10987654321098765432109876543210
11973 * 001000 x0000111101
11974 * rt -----
11975 * s ----------
11976 */
11977 static char *REPL_PH(uint64 instruction, Dis_info *info)
11978 {
11979 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
11980 int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
11981
11982 const char *rt = GPR(rt_value, info);
11983
11984 return img_format("REPL.PH %s, %" PRId64, rt, s_value);
11985 }
11986
11987
11988 /*
11989 * [DSP] REPL.QB rd, u - Replicate immediate integer into all vector element
11990 * positions
11991 *
11992 * 3 2 1
11993 * 10987654321098765432109876543210
11994 * 001000 x010111111111
11995 * rt -----
11996 * u --------
11997 */
11998 static char *REPL_QB(uint64 instruction, Dis_info *info)
11999 {
12000 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12001 uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
12002
12003 const char *rt = GPR(rt_value, info);
12004
12005 return img_format("REPL.QB %s, 0x%" PRIx64, rt, u_value);
12006 }
12007
12008
12009 /*
12010 * [DSP] REPLV.PH rt, rs - Replicate a halfword into all vector element
12011 * positions
12012 *
12013 * 3 2 1
12014 * 10987654321098765432109876543210
12015 * 001000 0000001100111111
12016 * rt -----
12017 * rs -----
12018 */
12019 static char *REPLV_PH(uint64 instruction, Dis_info *info)
12020 {
12021 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12022 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12023
12024 const char *rt = GPR(rt_value, info);
12025 const char *rs = GPR(rs_value, info);
12026
12027 return img_format("REPLV.PH %s, %s", rt, rs);
12028 }
12029
12030
12031 /*
12032 * [DSP] REPLV.QB rt, rs - Replicate byte into all vector element positions
12033 *
12034 * 3 2 1
12035 * 10987654321098765432109876543210
12036 * 001000 0001001100111111
12037 * rt -----
12038 * rs -----
12039 */
12040 static char *REPLV_QB(uint64 instruction, Dis_info *info)
12041 {
12042 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12043 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12044
12045 const char *rt = GPR(rt_value, info);
12046 const char *rs = GPR(rs_value, info);
12047
12048 return img_format("REPLV.QB %s, %s", rt, rs);
12049 }
12050
12051
12052 /*
12053 *
12054 *
12055 * 3 2 1
12056 * 10987654321098765432109876543210
12057 * 001000 x1110000101
12058 * rt -----
12059 * rs -----
12060 * rd -----
12061 */
12062 static char *RESTORE_32_(uint64 instruction, Dis_info *info)
12063 {
12064 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12065 uint64 count_value = extract_count_19_18_17_16(instruction);
12066 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12067 uint64 gp_value = extract_gp_2(instruction);
12068
12069 g_autofree char *save_restore_str = save_restore_list(
12070 rt_value, count_value, gp_value, info);
12071 return img_format("RESTORE 0x%" PRIx64 "%s", u_value, save_restore_str);
12072 }
12073
12074
12075 /*
12076 *
12077 *
12078 * 3 2 1
12079 * 10987654321098765432109876543210
12080 * 001000 x1110000101
12081 * rt -----
12082 * rs -----
12083 * rd -----
12084 */
12085 static char *RESTORE_JRC_16_(uint64 instruction, Dis_info *info)
12086 {
12087 uint64 rt1_value = extract_rtl_11(instruction);
12088 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12089 uint64 count_value = extract_count_3_2_1_0(instruction);
12090
12091 g_autofree char *save_restore_str = save_restore_list(
12092 encode_rt1_from_rt(rt1_value), count_value, 0, info);
12093 return img_format("RESTORE.JRC 0x%" PRIx64 "%s", u_value, save_restore_str);
12094 }
12095
12096
12097 /*
12098 *
12099 *
12100 * 3 2 1
12101 * 10987654321098765432109876543210
12102 * 001000 x1110000101
12103 * rt -----
12104 * rs -----
12105 * rd -----
12106 */
12107 static char *RESTORE_JRC_32_(uint64 instruction, Dis_info *info)
12108 {
12109 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12110 uint64 count_value = extract_count_19_18_17_16(instruction);
12111 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12112 uint64 gp_value = extract_gp_2(instruction);
12113
12114 g_autofree char *save_restore_str = save_restore_list(
12115 rt_value, count_value, gp_value, info);
12116 return img_format("RESTORE.JRC 0x%" PRIx64 "%s", u_value,
12117 save_restore_str);
12118 }
12119
12120
12121 /*
12122 *
12123 *
12124 * 3 2 1
12125 * 10987654321098765432109876543210
12126 * 001000 x1110000101
12127 * rt -----
12128 * rs -----
12129 * rd -----
12130 */
12131 static char *RESTOREF(uint64 instruction, Dis_info *info)
12132 {
12133 uint64 count_value = extract_count_19_18_17_16(instruction);
12134 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12135
12136
12137 return img_format("RESTOREF 0x%" PRIx64 ", 0x%" PRIx64,
12138 u_value, count_value);
12139 }
12140
12141
12142 /*
12143 *
12144 *
12145 * 3 2 1
12146 * 10987654321098765432109876543210
12147 * 001000 x1110000101
12148 * rt -----
12149 * rs -----
12150 * rd -----
12151 */
12152 static char *RINT_D(uint64 instruction, Dis_info *info)
12153 {
12154 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12155 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12156
12157 const char *ft = FPR(ft_value, info);
12158 const char *fs = FPR(fs_value, info);
12159
12160 return img_format("RINT.D %s, %s", ft, fs);
12161 }
12162
12163
12164 /*
12165 *
12166 *
12167 * 3 2 1
12168 * 10987654321098765432109876543210
12169 * 001000 x1110000101
12170 * rt -----
12171 * rs -----
12172 * rd -----
12173 */
12174 static char *RINT_S(uint64 instruction, Dis_info *info)
12175 {
12176 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12177 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12178
12179 const char *ft = FPR(ft_value, info);
12180 const char *fs = FPR(fs_value, info);
12181
12182 return img_format("RINT.S %s, %s", ft, fs);
12183 }
12184
12185
12186 /*
12187 *
12188 *
12189 * 3 2 1
12190 * 10987654321098765432109876543210
12191 * 001000 x1110000101
12192 * rt -----
12193 * rs -----
12194 * rd -----
12195 */
12196 static char *ROTR(uint64 instruction, Dis_info *info)
12197 {
12198 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12199 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12200 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12201
12202 const char *rt = GPR(rt_value, info);
12203 const char *rs = GPR(rs_value, info);
12204
12205 return img_format("ROTR %s, %s, 0x%" PRIx64, rt, rs, shift_value);
12206 }
12207
12208
12209 /*
12210 *
12211 *
12212 * 3 2 1
12213 * 10987654321098765432109876543210
12214 * 001000 x1110000101
12215 * rt -----
12216 * rs -----
12217 * rd -----
12218 */
12219 static char *ROTRV(uint64 instruction, Dis_info *info)
12220 {
12221 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12222 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12223 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12224
12225 const char *rd = GPR(rd_value, info);
12226 const char *rs = GPR(rs_value, info);
12227 const char *rt = GPR(rt_value, info);
12228
12229 return img_format("ROTRV %s, %s, %s", rd, rs, rt);
12230 }
12231
12232
12233 /*
12234 *
12235 *
12236 * 3 2 1
12237 * 10987654321098765432109876543210
12238 * 001000 x1110000101
12239 * rt -----
12240 * rs -----
12241 * rd -----
12242 */
12243 static char *ROTX(uint64 instruction, Dis_info *info)
12244 {
12245 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12246 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12247 uint64 shiftx_value = extract_shiftx_10_9_8_7__s1(instruction);
12248 uint64 stripe_value = extract_stripe_6(instruction);
12249 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
12250
12251 const char *rt = GPR(rt_value, info);
12252 const char *rs = GPR(rs_value, info);
12253
12254 return img_format("ROTX %s, %s, 0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRIx64,
12255 rt, rs, shift_value, shiftx_value, stripe_value);
12256 }
12257
12258
12259 /*
12260 *
12261 *
12262 * 3 2 1
12263 * 10987654321098765432109876543210
12264 * 001000 x1110000101
12265 * rt -----
12266 * rs -----
12267 * rd -----
12268 */
12269 static char *ROUND_L_D(uint64 instruction, Dis_info *info)
12270 {
12271 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12272 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12273
12274 const char *ft = FPR(ft_value, info);
12275 const char *fs = FPR(fs_value, info);
12276
12277 return img_format("ROUND.L.D %s, %s", ft, fs);
12278 }
12279
12280
12281 /*
12282 *
12283 *
12284 * 3 2 1
12285 * 10987654321098765432109876543210
12286 * 001000 x1110000101
12287 * rt -----
12288 * rs -----
12289 * rd -----
12290 */
12291 static char *ROUND_L_S(uint64 instruction, Dis_info *info)
12292 {
12293 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12294 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12295
12296 const char *ft = FPR(ft_value, info);
12297 const char *fs = FPR(fs_value, info);
12298
12299 return img_format("ROUND.L.S %s, %s", ft, fs);
12300 }
12301
12302
12303 /*
12304 *
12305 *
12306 * 3 2 1
12307 * 10987654321098765432109876543210
12308 * 001000 x1110000101
12309 * rt -----
12310 * rs -----
12311 * rd -----
12312 */
12313 static char *ROUND_W_D(uint64 instruction, Dis_info *info)
12314 {
12315 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12316 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12317
12318 const char *ft = FPR(ft_value, info);
12319 const char *fs = FPR(fs_value, info);
12320
12321 return img_format("ROUND.W.D %s, %s", ft, fs);
12322 }
12323
12324
12325 /*
12326 *
12327 *
12328 * 3 2 1
12329 * 10987654321098765432109876543210
12330 * 001000 x1110000101
12331 * rt -----
12332 * rs -----
12333 * rd -----
12334 */
12335 static char *ROUND_W_S(uint64 instruction, Dis_info *info)
12336 {
12337 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12338 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12339
12340 const char *ft = FPR(ft_value, info);
12341 const char *fs = FPR(fs_value, info);
12342
12343 return img_format("ROUND.W.S %s, %s", ft, fs);
12344 }
12345
12346
12347 /*
12348 *
12349 *
12350 * 3 2 1
12351 * 10987654321098765432109876543210
12352 * 001000 x1110000101
12353 * rt -----
12354 * rs -----
12355 * rd -----
12356 */
12357 static char *RSQRT_D(uint64 instruction, Dis_info *info)
12358 {
12359 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12360 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12361
12362 const char *ft = FPR(ft_value, info);
12363 const char *fs = FPR(fs_value, info);
12364
12365 return img_format("RSQRT.D %s, %s", ft, fs);
12366 }
12367
12368
12369 /*
12370 *
12371 *
12372 * 3 2 1
12373 * 10987654321098765432109876543210
12374 * 001000 x1110000101
12375 * rt -----
12376 * rs -----
12377 * rd -----
12378 */
12379 static char *RSQRT_S(uint64 instruction, Dis_info *info)
12380 {
12381 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12382 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
12383
12384 const char *ft = FPR(ft_value, info);
12385 const char *fs = FPR(fs_value, info);
12386
12387 return img_format("RSQRT.S %s, %s", ft, fs);
12388 }
12389
12390
12391 /*
12392 *
12393 *
12394 * 3 2 1
12395 * 10987654321098765432109876543210
12396 * 001000 01001001101
12397 * rt -----
12398 * rs -----
12399 * rd -----
12400 */
12401 static char *SAVE_16_(uint64 instruction, Dis_info *info)
12402 {
12403 uint64 rt1_value = extract_rtl_11(instruction);
12404 uint64 u_value = extract_u_7_6_5_4__s4(instruction);
12405 uint64 count_value = extract_count_3_2_1_0(instruction);
12406
12407 g_autofree char *save_restore_str = save_restore_list(
12408 encode_rt1_from_rt(rt1_value), count_value, 0, info);
12409 return img_format("SAVE 0x%" PRIx64 "%s", u_value, save_restore_str);
12410 }
12411
12412
12413 /*
12414 *
12415 *
12416 * 3 2 1
12417 * 10987654321098765432109876543210
12418 * 001000 01001001101
12419 * rt -----
12420 * rs -----
12421 * rd -----
12422 */
12423 static char *SAVE_32_(uint64 instruction, Dis_info *info)
12424 {
12425 uint64 count_value = extract_count_19_18_17_16(instruction);
12426 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12427 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12428 uint64 gp_value = extract_gp_2(instruction);
12429
12430 g_autofree char *save_restore_str = save_restore_list(
12431 rt_value, count_value, gp_value, info);
12432 return img_format("SAVE 0x%" PRIx64 "%s", u_value, save_restore_str);
12433 }
12434
12435
12436 /*
12437 *
12438 *
12439 * 3 2 1
12440 * 10987654321098765432109876543210
12441 * 001000 01001001101
12442 * rt -----
12443 * rs -----
12444 * rd -----
12445 */
12446 static char *SAVEF(uint64 instruction, Dis_info *info)
12447 {
12448 uint64 count_value = extract_count_19_18_17_16(instruction);
12449 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
12450
12451
12452 return img_format("SAVEF 0x%" PRIx64 ", 0x%" PRIx64, u_value, count_value);
12453 }
12454
12455
12456 /*
12457 *
12458 *
12459 * 3 2 1
12460 * 10987654321098765432109876543210
12461 * 001000 01001001101
12462 * rt -----
12463 * rs -----
12464 * rd -----
12465 */
12466 static char *SB_16_(uint64 instruction, Dis_info *info)
12467 {
12468 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
12469 uint64 rs3_value = extract_rs3_6_5_4(instruction);
12470 uint64 u_value = extract_u_1_0(instruction);
12471
12472 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
12473 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
12474
12475 return img_format("SB %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
12476 }
12477
12478
12479 /*
12480 *
12481 *
12482 * 3 2 1
12483 * 10987654321098765432109876543210
12484 * 001000 01001001101
12485 * rt -----
12486 * rs -----
12487 * rd -----
12488 */
12489 static char *SB_GP_(uint64 instruction, Dis_info *info)
12490 {
12491 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12492 uint64 u_value = extract_u_17_to_0(instruction);
12493
12494 const char *rt = GPR(rt_value, info);
12495
12496 return img_format("SB %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
12497 }
12498
12499
12500 /*
12501 *
12502 *
12503 * 3 2 1
12504 * 10987654321098765432109876543210
12505 * 001000 01001001101
12506 * rt -----
12507 * rs -----
12508 * rd -----
12509 */
12510 static char *SB_S9_(uint64 instruction, Dis_info *info)
12511 {
12512 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12513 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12514 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12515
12516 const char *rt = GPR(rt_value, info);
12517 const char *rs = GPR(rs_value, info);
12518
12519 return img_format("SB %s, %" PRId64 "(%s)", rt, s_value, rs);
12520 }
12521
12522
12523 /*
12524 *
12525 *
12526 * 3 2 1
12527 * 10987654321098765432109876543210
12528 * 001000 01001001101
12529 * rt -----
12530 * rs -----
12531 * rd -----
12532 */
12533 static char *SB_U12_(uint64 instruction, Dis_info *info)
12534 {
12535 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12536 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12537 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12538
12539 const char *rt = GPR(rt_value, info);
12540 const char *rs = GPR(rs_value, info);
12541
12542 return img_format("SB %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
12543 }
12544
12545
12546 /*
12547 *
12548 *
12549 * 3 2 1
12550 * 10987654321098765432109876543210
12551 * 001000 01001001101
12552 * rt -----
12553 * rs -----
12554 * rd -----
12555 */
12556 static char *SBE(uint64 instruction, Dis_info *info)
12557 {
12558 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12559 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12560 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12561
12562 const char *rt = GPR(rt_value, info);
12563 const char *rs = GPR(rs_value, info);
12564
12565 return img_format("SBE %s, %" PRId64 "(%s)", rt, s_value, rs);
12566 }
12567
12568
12569 /*
12570 *
12571 *
12572 * 3 2 1
12573 * 10987654321098765432109876543210
12574 * 001000 01001001101
12575 * rt -----
12576 * rs -----
12577 * rd -----
12578 */
12579 static char *SBX(uint64 instruction, Dis_info *info)
12580 {
12581 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12582 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12583 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
12584
12585 const char *rd = GPR(rd_value, info);
12586 const char *rs = GPR(rs_value, info);
12587 const char *rt = GPR(rt_value, info);
12588
12589 return img_format("SBX %s, %s(%s)", rd, rs, rt);
12590 }
12591
12592
12593 /*
12594 *
12595 *
12596 * 3 2 1
12597 * 10987654321098765432109876543210
12598 * 001000 01001001101
12599 * rt -----
12600 * rs -----
12601 * rd -----
12602 */
12603 static char *SC(uint64 instruction, Dis_info *info)
12604 {
12605 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12606 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12607 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
12608
12609 const char *rt = GPR(rt_value, info);
12610 const char *rs = GPR(rs_value, info);
12611
12612 return img_format("SC %s, %" PRId64 "(%s)", rt, s_value, rs);
12613 }
12614
12615
12616 /*
12617 *
12618 *
12619 * 3 2 1
12620 * 10987654321098765432109876543210
12621 * 001000 01001001101
12622 * rt -----
12623 * rs -----
12624 * rd -----
12625 */
12626 static char *SCD(uint64 instruction, Dis_info *info)
12627 {
12628 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12629 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12630 int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
12631
12632 const char *rt = GPR(rt_value, info);
12633 const char *rs = GPR(rs_value, info);
12634
12635 return img_format("SCD %s, %" PRId64 "(%s)", rt, s_value, rs);
12636 }
12637
12638
12639 /*
12640 *
12641 *
12642 * 3 2 1
12643 * 10987654321098765432109876543210
12644 * 001000 01001001101
12645 * rt -----
12646 * rs -----
12647 * rd -----
12648 */
12649 static char *SCDP(uint64 instruction, Dis_info *info)
12650 {
12651 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12652 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12653 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12654
12655 const char *rt = GPR(rt_value, info);
12656 const char *ru = GPR(ru_value, info);
12657 const char *rs = GPR(rs_value, info);
12658
12659 return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
12660 }
12661
12662
12663 /*
12664 *
12665 *
12666 * 3 2 1
12667 * 10987654321098765432109876543210
12668 * 001000 01001001101
12669 * rt -----
12670 * rs -----
12671 * rd -----
12672 */
12673 static char *SCE(uint64 instruction, Dis_info *info)
12674 {
12675 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12676 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12677 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
12678
12679 const char *rt = GPR(rt_value, info);
12680 const char *rs = GPR(rs_value, info);
12681
12682 return img_format("SCE %s, %" PRId64 "(%s)", rt, s_value, rs);
12683 }
12684
12685
12686 /*
12687 *
12688 *
12689 * 3 2 1
12690 * 10987654321098765432109876543210
12691 * 001000 01001001101
12692 * rt -----
12693 * rs -----
12694 * rd -----
12695 */
12696 static char *SCWP(uint64 instruction, Dis_info *info)
12697 {
12698 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12699 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12700 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12701
12702 const char *rt = GPR(rt_value, info);
12703 const char *ru = GPR(ru_value, info);
12704 const char *rs = GPR(rs_value, info);
12705
12706 return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
12707 }
12708
12709
12710 /*
12711 *
12712 *
12713 * 3 2 1
12714 * 10987654321098765432109876543210
12715 * 001000 01001001101
12716 * rt -----
12717 * rs -----
12718 * rd -----
12719 */
12720 static char *SCWPE(uint64 instruction, Dis_info *info)
12721 {
12722 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12723 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12724 uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
12725
12726 const char *rt = GPR(rt_value, info);
12727 const char *ru = GPR(ru_value, info);
12728 const char *rs = GPR(rs_value, info);
12729
12730 return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
12731 }
12732
12733
12734 /*
12735 *
12736 *
12737 * 3 2 1
12738 * 10987654321098765432109876543210
12739 * 001000 01001001101
12740 * rt -----
12741 * rs -----
12742 * rd -----
12743 */
12744 static char *SD_GP_(uint64 instruction, Dis_info *info)
12745 {
12746 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12747 uint64 u_value = extract_u_20_to_3__s3(instruction);
12748
12749 const char *rt = GPR(rt_value, info);
12750
12751 return img_format("SD %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
12752 }
12753
12754
12755 /*
12756 *
12757 *
12758 * 3 2 1
12759 * 10987654321098765432109876543210
12760 * 001000 01001001101
12761 * rt -----
12762 * rs -----
12763 * rd -----
12764 */
12765 static char *SD_S9_(uint64 instruction, Dis_info *info)
12766 {
12767 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12768 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12769 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12770
12771 const char *rt = GPR(rt_value, info);
12772 const char *rs = GPR(rs_value, info);
12773
12774 return img_format("SD %s, %" PRId64 "(%s)", rt, s_value, rs);
12775 }
12776
12777
12778 /*
12779 *
12780 *
12781 * 3 2 1
12782 * 10987654321098765432109876543210
12783 * 001000 01001001101
12784 * rt -----
12785 * rs -----
12786 * rd -----
12787 */
12788 static char *SD_U12_(uint64 instruction, Dis_info *info)
12789 {
12790 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12791 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12792 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12793
12794 const char *rt = GPR(rt_value, info);
12795 const char *rs = GPR(rs_value, info);
12796
12797 return img_format("SD %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
12798 }
12799
12800
12801 /*
12802 *
12803 *
12804 * 3 2 1
12805 * 10987654321098765432109876543210
12806 * 001000 01001001101
12807 * rt -----
12808 * rs -----
12809 * rd -----
12810 */
12811 static char *SDBBP_16_(uint64 instruction, Dis_info *info)
12812 {
12813 uint64 code_value = extract_code_2_1_0(instruction);
12814
12815
12816 return img_format("SDBBP 0x%" PRIx64, code_value);
12817 }
12818
12819
12820 /*
12821 *
12822 *
12823 * 3 2 1
12824 * 10987654321098765432109876543210
12825 * 001000 01001001101
12826 * rt -----
12827 * rs -----
12828 * rd -----
12829 */
12830 static char *SDBBP_32_(uint64 instruction, Dis_info *info)
12831 {
12832 uint64 code_value = extract_code_18_to_0(instruction);
12833
12834
12835 return img_format("SDBBP 0x%" PRIx64, code_value);
12836 }
12837
12838
12839 /*
12840 *
12841 *
12842 * 3 2 1
12843 * 10987654321098765432109876543210
12844 * 001000 01001001101
12845 * rt -----
12846 * rs -----
12847 * rd -----
12848 */
12849 static char *SDC1_GP_(uint64 instruction, Dis_info *info)
12850 {
12851 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12852 uint64 u_value = extract_u_17_to_2__s2(instruction);
12853
12854 const char *ft = FPR(ft_value, info);
12855
12856 return img_format("SDC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
12857 }
12858
12859
12860 /*
12861 *
12862 *
12863 * 3 2 1
12864 * 10987654321098765432109876543210
12865 * 001000 01001001101
12866 * rt -----
12867 * rs -----
12868 * rd -----
12869 */
12870 static char *SDC1_S9_(uint64 instruction, Dis_info *info)
12871 {
12872 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12873 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12874 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12875
12876 const char *ft = FPR(ft_value, info);
12877 const char *rs = GPR(rs_value, info);
12878
12879 return img_format("SDC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
12880 }
12881
12882
12883 /*
12884 *
12885 *
12886 * 3 2 1
12887 * 10987654321098765432109876543210
12888 * 001000 01001001101
12889 * rt -----
12890 * rs -----
12891 * rd -----
12892 */
12893 static char *SDC1_U12_(uint64 instruction, Dis_info *info)
12894 {
12895 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
12896 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12897 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
12898
12899 const char *ft = FPR(ft_value, info);
12900 const char *rs = GPR(rs_value, info);
12901
12902 return img_format("SDC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
12903 }
12904
12905
12906 /*
12907 *
12908 *
12909 * 3 2 1
12910 * 10987654321098765432109876543210
12911 * 001000 01001001101
12912 * rt -----
12913 * rs -----
12914 * rd -----
12915 */
12916 static char *SDC1X(uint64 instruction, Dis_info *info)
12917 {
12918 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12919 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12920 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
12921
12922 const char *ft = FPR(ft_value, info);
12923 const char *rs = GPR(rs_value, info);
12924 const char *rt = GPR(rt_value, info);
12925
12926 return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
12927 }
12928
12929
12930 /*
12931 *
12932 *
12933 * 3 2 1
12934 * 10987654321098765432109876543210
12935 * 001000 01001001101
12936 * rt -----
12937 * rs -----
12938 * rd -----
12939 */
12940 static char *SDC1XS(uint64 instruction, Dis_info *info)
12941 {
12942 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12943 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12944 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
12945
12946 const char *ft = FPR(ft_value, info);
12947 const char *rs = GPR(rs_value, info);
12948 const char *rt = GPR(rt_value, info);
12949
12950 return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
12951 }
12952
12953
12954 /*
12955 *
12956 *
12957 * 3 2 1
12958 * 10987654321098765432109876543210
12959 * 001000 01001001101
12960 * rt -----
12961 * rs -----
12962 * rd -----
12963 */
12964 static char *SDC2(uint64 instruction, Dis_info *info)
12965 {
12966 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
12967 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12968 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12969
12970 const char *rs = GPR(rs_value, info);
12971
12972 return img_format("SDC2 CP%" PRIu64 ", %" PRId64 "(%s)",
12973 cs_value, s_value, rs);
12974 }
12975
12976
12977 /*
12978 *
12979 *
12980 * 3 2 1
12981 * 10987654321098765432109876543210
12982 * 001000 01001001101
12983 * rt -----
12984 * rs -----
12985 * rd -----
12986 */
12987 static char *SDM(uint64 instruction, Dis_info *info)
12988 {
12989 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
12990 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
12991 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
12992 uint64 count3_value = extract_count3_14_13_12(instruction);
12993
12994 const char *rt = GPR(rt_value, info);
12995 const char *rs = GPR(rs_value, info);
12996 uint64 count3 = encode_count3_from_count(count3_value);
12997
12998 return img_format("SDM %s, %" PRId64 "(%s), 0x%" PRIx64,
12999 rt, s_value, rs, count3);
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 *SDPC_48_(uint64 instruction, Dis_info *info)
13014 {
13015 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
13016 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
13017
13018 const char *rt = GPR(rt_value, info);
13019 g_autofree char *s = ADDRESS(s_value, 6, info);
13020
13021 return img_format("SDPC %s, %s", rt, s);
13022 }
13023
13024
13025 /*
13026 *
13027 *
13028 * 3 2 1
13029 * 10987654321098765432109876543210
13030 * 001000 01001001101
13031 * rt -----
13032 * rs -----
13033 * rd -----
13034 */
13035 static char *SDXS(uint64 instruction, Dis_info *info)
13036 {
13037 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13038 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13039 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13040
13041 const char *rd = GPR(rd_value, info);
13042 const char *rs = GPR(rs_value, info);
13043 const char *rt = GPR(rt_value, info);
13044
13045 return img_format("SDXS %s, %s(%s)", rd, rs, rt);
13046 }
13047
13048
13049 /*
13050 *
13051 *
13052 * 3 2 1
13053 * 10987654321098765432109876543210
13054 * 001000 01001001101
13055 * rt -----
13056 * rs -----
13057 * rd -----
13058 */
13059 static char *SDX(uint64 instruction, Dis_info *info)
13060 {
13061 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13062 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13063 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13064
13065 const char *rd = GPR(rd_value, info);
13066 const char *rs = GPR(rs_value, info);
13067 const char *rt = GPR(rt_value, info);
13068
13069 return img_format("SDX %s, %s(%s)", rd, rs, rt);
13070 }
13071
13072
13073 /*
13074 *
13075 *
13076 * 3 2 1
13077 * 10987654321098765432109876543210
13078 * 001000 01001001101
13079 * rt -----
13080 * rs -----
13081 * rd -----
13082 */
13083 static char *SEB(uint64 instruction, Dis_info *info)
13084 {
13085 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13086 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13087
13088 const char *rt = GPR(rt_value, info);
13089 const char *rs = GPR(rs_value, info);
13090
13091 return img_format("SEB %s, %s", rt, rs);
13092 }
13093
13094
13095 /*
13096 *
13097 *
13098 * 3 2 1
13099 * 10987654321098765432109876543210
13100 * 001000 01001001101
13101 * rt -----
13102 * rs -----
13103 * rd -----
13104 */
13105 static char *SEH(uint64 instruction, Dis_info *info)
13106 {
13107 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13108 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13109
13110 const char *rt = GPR(rt_value, info);
13111 const char *rs = GPR(rs_value, info);
13112
13113 return img_format("SEH %s, %s", rt, rs);
13114 }
13115
13116
13117 /*
13118 *
13119 *
13120 * 3 2 1
13121 * 10987654321098765432109876543210
13122 * 001000 01001001101
13123 * rt -----
13124 * rs -----
13125 * rd -----
13126 */
13127 static char *SEL_D(uint64 instruction, Dis_info *info)
13128 {
13129 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13130 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13131 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13132
13133 const char *fd = FPR(fd_value, info);
13134 const char *fs = FPR(fs_value, info);
13135 const char *ft = FPR(ft_value, info);
13136
13137 return img_format("SEL.D %s, %s, %s", fd, fs, ft);
13138 }
13139
13140
13141 /*
13142 *
13143 *
13144 * 3 2 1
13145 * 10987654321098765432109876543210
13146 * 001000 01001001101
13147 * rt -----
13148 * rs -----
13149 * rd -----
13150 */
13151 static char *SEL_S(uint64 instruction, Dis_info *info)
13152 {
13153 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13154 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13155 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13156
13157 const char *fd = FPR(fd_value, info);
13158 const char *fs = FPR(fs_value, info);
13159 const char *ft = FPR(ft_value, info);
13160
13161 return img_format("SEL.S %s, %s, %s", fd, fs, ft);
13162 }
13163
13164
13165 /*
13166 *
13167 *
13168 * 3 2 1
13169 * 10987654321098765432109876543210
13170 * 001000 01001001101
13171 * rt -----
13172 * rs -----
13173 * rd -----
13174 */
13175 static char *SELEQZ_D(uint64 instruction, Dis_info *info)
13176 {
13177 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13178 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13179 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13180
13181 const char *fd = FPR(fd_value, info);
13182 const char *fs = FPR(fs_value, info);
13183 const char *ft = FPR(ft_value, info);
13184
13185 return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
13186 }
13187
13188
13189 /*
13190 *
13191 *
13192 * 3 2 1
13193 * 10987654321098765432109876543210
13194 * 001000 01001001101
13195 * rt -----
13196 * rs -----
13197 * rd -----
13198 */
13199 static char *SELEQZ_S(uint64 instruction, Dis_info *info)
13200 {
13201 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13202 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13203 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13204
13205 const char *fd = FPR(fd_value, info);
13206 const char *fs = FPR(fs_value, info);
13207 const char *ft = FPR(ft_value, info);
13208
13209 return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
13210 }
13211
13212
13213 /*
13214 *
13215 *
13216 * 3 2 1
13217 * 10987654321098765432109876543210
13218 * 001000 01001001101
13219 * rt -----
13220 * rs -----
13221 * rd -----
13222 */
13223 static char *SELNEZ_D(uint64 instruction, Dis_info *info)
13224 {
13225 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13226 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13227 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13228
13229 const char *fd = FPR(fd_value, info);
13230 const char *fs = FPR(fs_value, info);
13231 const char *ft = FPR(ft_value, info);
13232
13233 return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
13234 }
13235
13236
13237 /*
13238 *
13239 *
13240 * 3 2 1
13241 * 10987654321098765432109876543210
13242 * 001000 01001001101
13243 * rt -----
13244 * rs -----
13245 * rd -----
13246 */
13247 static char *SELNEZ_S(uint64 instruction, Dis_info *info)
13248 {
13249 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
13250 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
13251 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
13252
13253 const char *fd = FPR(fd_value, info);
13254 const char *fs = FPR(fs_value, info);
13255 const char *ft = FPR(ft_value, info);
13256
13257 return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
13258 }
13259
13260
13261 /*
13262 *
13263 *
13264 * 3 2 1
13265 * 10987654321098765432109876543210
13266 * 001000 01001001101
13267 * rt -----
13268 * rs -----
13269 * rd -----
13270 */
13271 static char *SEQI(uint64 instruction, Dis_info *info)
13272 {
13273 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13274 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13275 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13276
13277 const char *rt = GPR(rt_value, info);
13278 const char *rs = GPR(rs_value, info);
13279
13280 return img_format("SEQI %s, %s, 0x%" PRIx64, rt, rs, u_value);
13281 }
13282
13283
13284 /*
13285 *
13286 *
13287 * 3 2 1
13288 * 10987654321098765432109876543210
13289 * 001000 01001001101
13290 * rt -----
13291 * rs -----
13292 * rd -----
13293 */
13294 static char *SH_16_(uint64 instruction, Dis_info *info)
13295 {
13296 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
13297 uint64 rs3_value = extract_rs3_6_5_4(instruction);
13298 uint64 u_value = extract_u_2_1__s1(instruction);
13299
13300 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
13301 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
13302
13303 return img_format("SH %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
13304 }
13305
13306
13307 /*
13308 *
13309 *
13310 * 3 2 1
13311 * 10987654321098765432109876543210
13312 * 001000 01001001101
13313 * rt -----
13314 * rs -----
13315 * rd -----
13316 */
13317 static char *SH_GP_(uint64 instruction, Dis_info *info)
13318 {
13319 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13320 uint64 u_value = extract_u_17_to_1__s1(instruction);
13321
13322 const char *rt = GPR(rt_value, info);
13323
13324 return img_format("SH %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
13325 }
13326
13327
13328 /*
13329 *
13330 *
13331 * 3 2 1
13332 * 10987654321098765432109876543210
13333 * 001000 01001001101
13334 * rt -----
13335 * rs -----
13336 * rd -----
13337 */
13338 static char *SH_S9_(uint64 instruction, Dis_info *info)
13339 {
13340 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13341 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13342 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13343
13344 const char *rt = GPR(rt_value, info);
13345 const char *rs = GPR(rs_value, info);
13346
13347 return img_format("SH %s, %" PRId64 "(%s)", rt, s_value, rs);
13348 }
13349
13350
13351 /*
13352 *
13353 *
13354 * 3 2 1
13355 * 10987654321098765432109876543210
13356 * 001000 01001001101
13357 * rt -----
13358 * rs -----
13359 * rd -----
13360 */
13361 static char *SH_U12_(uint64 instruction, Dis_info *info)
13362 {
13363 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13364 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13365 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
13366
13367 const char *rt = GPR(rt_value, info);
13368 const char *rs = GPR(rs_value, info);
13369
13370 return img_format("SH %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
13371 }
13372
13373
13374 /*
13375 *
13376 *
13377 * 3 2 1
13378 * 10987654321098765432109876543210
13379 * 001000 01001001101
13380 * rt -----
13381 * rs -----
13382 * rd -----
13383 */
13384 static char *SHE(uint64 instruction, Dis_info *info)
13385 {
13386 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13387 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13388 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
13389
13390 const char *rt = GPR(rt_value, info);
13391 const char *rs = GPR(rs_value, info);
13392
13393 return img_format("SHE %s, %" PRId64 "(%s)", rt, s_value, rs);
13394 }
13395
13396
13397 /*
13398 * [DSP] SHILO ac, shift - Shift an accumulator value leaving the result in
13399 * the same accumulator
13400 *
13401 * 3 2 1
13402 * 10987654321098765432109876543210
13403 * 001000xxxx xxxx0000011101
13404 * shift ------
13405 * ac --
13406 */
13407 static char *SHILO(uint64 instruction, Dis_info *info)
13408 {
13409 int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
13410 uint64 ac_value = extract_ac_15_14(instruction);
13411
13412 const char *ac = AC(ac_value, info);
13413
13414 return img_format("SHILO %s, 0x%" PRIx64, ac, shift_value);
13415 }
13416
13417
13418 /*
13419 * [DSP] SHILOV ac, rs - Variable shift of accumulator value leaving the result
13420 * in the same accumulator
13421 *
13422 * 3 2 1
13423 * 10987654321098765432109876543210
13424 * 001000xxxxx 01001001111111
13425 * rs -----
13426 * ac --
13427 */
13428 static char *SHILOV(uint64 instruction, Dis_info *info)
13429 {
13430 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13431 uint64 ac_value = extract_ac_15_14(instruction);
13432
13433 const char *rs = GPR(rs_value, info);
13434 const char *ac = AC(ac_value, info);
13435
13436 return img_format("SHILOV %s, %s", ac, rs);
13437 }
13438
13439
13440 /*
13441 * [DSP] SHLL.PH rt, rs, sa - Shift left logical vector pair halfwords
13442 *
13443 * 3 2 1
13444 * 10987654321098765432109876543210
13445 * 001000 001110110101
13446 * rt -----
13447 * rs -----
13448 * sa ----
13449 */
13450 static char *SHLL_PH(uint64 instruction, Dis_info *info)
13451 {
13452 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13453 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13454 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13455
13456 const char *rt = GPR(rt_value, info);
13457 const char *rs = GPR(rs_value, info);
13458
13459 return img_format("SHLL.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13460 }
13461
13462
13463 /*
13464 * [DSP] SHLL.QB rt, rs, sa - Shift left logical vector quad bytes
13465 *
13466 * 3 2 1
13467 * 10987654321098765432109876543210
13468 * 001000 0100001111111
13469 * rt -----
13470 * rs -----
13471 * sa ---
13472 */
13473 static char *SHLL_QB(uint64 instruction, Dis_info *info)
13474 {
13475 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13476 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13477 uint64 sa_value = extract_sa_15_14_13(instruction);
13478
13479 const char *rt = GPR(rt_value, info);
13480 const char *rs = GPR(rs_value, info);
13481
13482 return img_format("SHLL.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13483 }
13484
13485
13486 /*
13487 * [DSP] SHLL_S.PH rt, rs, sa - Shift left logical vector pair halfwords
13488 * with saturation
13489 *
13490 * 3 2 1
13491 * 10987654321098765432109876543210
13492 * 001000 001110110101
13493 * rt -----
13494 * rs -----
13495 * sa ----
13496 */
13497 static char *SHLL_S_PH(uint64 instruction, Dis_info *info)
13498 {
13499 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13500 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13501 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13502
13503 const char *rt = GPR(rt_value, info);
13504 const char *rs = GPR(rs_value, info);
13505
13506 return img_format("SHLL_S.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13507 }
13508
13509
13510 /*
13511 * [DSP] SHLL_S.PH rt, rs, sa - Shift left logical word with saturation
13512 *
13513 * 3 2 1
13514 * 10987654321098765432109876543210
13515 * 001000 x1111110101
13516 * rt -----
13517 * rs -----
13518 * sa -----
13519 */
13520 static char *SHLL_S_W(uint64 instruction, Dis_info *info)
13521 {
13522 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13523 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13524 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
13525
13526 const char *rt = GPR(rt_value, info);
13527 const char *rs = GPR(rs_value, info);
13528
13529 return img_format("SHLL_S.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13530 }
13531
13532
13533 /*
13534 * [DSP] SHLLV.PH rd, rt, rs - Shift left logical variable vector pair
13535 * halfwords
13536 *
13537 * 3 2 1
13538 * 10987654321098765432109876543210
13539 * 001000 01110001101
13540 * rt -----
13541 * rs -----
13542 * rd -----
13543 */
13544 static char *SHLLV_PH(uint64 instruction, Dis_info *info)
13545 {
13546 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13547 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13548 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13549
13550 const char *rd = GPR(rd_value, info);
13551 const char *rt = GPR(rt_value, info);
13552 const char *rs = GPR(rs_value, info);
13553
13554 return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
13555 }
13556
13557
13558 /*
13559 * [DSP] SHLLV_S.QB rd, rt, rs - Shift left logical variable vector quad bytes
13560 *
13561 * 3 2 1
13562 * 10987654321098765432109876543210
13563 * 001000 x1110010101
13564 * rt -----
13565 * rs -----
13566 * rd -----
13567 */
13568 static char *SHLLV_QB(uint64 instruction, Dis_info *info)
13569 {
13570 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13571 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13572 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13573
13574 const char *rd = GPR(rd_value, info);
13575 const char *rt = GPR(rt_value, info);
13576 const char *rs = GPR(rs_value, info);
13577
13578 return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
13579 }
13580
13581
13582 /*
13583 * [DSP] SHLLV.PH rd, rt, rs - Shift left logical variable vector pair
13584 * halfwords with saturation
13585 *
13586 * 3 2 1
13587 * 10987654321098765432109876543210
13588 * 001000 11110001101
13589 * rt -----
13590 * rs -----
13591 * rd -----
13592 */
13593 static char *SHLLV_S_PH(uint64 instruction, Dis_info *info)
13594 {
13595 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13596 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13597 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13598
13599 const char *rd = GPR(rd_value, info);
13600 const char *rt = GPR(rt_value, info);
13601 const char *rs = GPR(rs_value, info);
13602
13603 return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
13604 }
13605
13606
13607 /*
13608 * [DSP] SHLLV_S.W rd, rt, rs - Shift left logical variable vector word
13609 *
13610 * 3 2 1
13611 * 10987654321098765432109876543210
13612 * 001000 x1111010101
13613 * rt -----
13614 * rs -----
13615 * rd -----
13616 */
13617 static char *SHLLV_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 rd_value = extract_rd_15_14_13_12_11(instruction);
13622
13623 const char *rd = GPR(rd_value, info);
13624 const char *rt = GPR(rt_value, info);
13625 const char *rs = GPR(rs_value, info);
13626
13627 return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
13628 }
13629
13630
13631 /*
13632 *
13633 *
13634 * 3 2 1
13635 * 10987654321098765432109876543210
13636 * 001000 01001001101
13637 * rt -----
13638 * rs -----
13639 * rd -----
13640 */
13641 static char *SHRA_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 sa_value = extract_sa_15_14_13_12(instruction);
13646
13647 const char *rt = GPR(rt_value, info);
13648 const char *rs = GPR(rs_value, info);
13649
13650 return img_format("SHRA.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13651 }
13652
13653
13654 /*
13655 *
13656 *
13657 * 3 2 1
13658 * 10987654321098765432109876543210
13659 * 001000 01001001101
13660 * rt -----
13661 * rs -----
13662 * rd -----
13663 */
13664 static char *SHRA_QB(uint64 instruction, Dis_info *info)
13665 {
13666 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13667 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13668 uint64 sa_value = extract_sa_15_14_13(instruction);
13669
13670 const char *rt = GPR(rt_value, info);
13671 const char *rs = GPR(rs_value, info);
13672
13673 return img_format("SHRA.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13674 }
13675
13676
13677 /*
13678 *
13679 *
13680 * 3 2 1
13681 * 10987654321098765432109876543210
13682 * 001000 01001001101
13683 * rt -----
13684 * rs -----
13685 * rd -----
13686 */
13687 static char *SHRA_R_PH(uint64 instruction, Dis_info *info)
13688 {
13689 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13690 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13691 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13692
13693 const char *rt = GPR(rt_value, info);
13694 const char *rs = GPR(rs_value, info);
13695
13696 return img_format("SHRA_R.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13697 }
13698
13699
13700 /*
13701 *
13702 *
13703 * 3 2 1
13704 * 10987654321098765432109876543210
13705 * 001000 01001001101
13706 * rt -----
13707 * rs -----
13708 * rd -----
13709 */
13710 static char *SHRA_R_QB(uint64 instruction, Dis_info *info)
13711 {
13712 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13713 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13714 uint64 sa_value = extract_sa_15_14_13(instruction);
13715
13716 const char *rt = GPR(rt_value, info);
13717 const char *rs = GPR(rs_value, info);
13718
13719 return img_format("SHRA_R.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13720 }
13721
13722
13723 /*
13724 *
13725 *
13726 * 3 2 1
13727 * 10987654321098765432109876543210
13728 * 001000 01001001101
13729 * rt -----
13730 * rs -----
13731 * rd -----
13732 */
13733 static char *SHRA_R_W(uint64 instruction, Dis_info *info)
13734 {
13735 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13737 uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
13738
13739 const char *rt = GPR(rt_value, info);
13740 const char *rs = GPR(rs_value, info);
13741
13742 return img_format("SHRA_R.W %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13743 }
13744
13745
13746 /*
13747 *
13748 *
13749 * 3 2 1
13750 * 10987654321098765432109876543210
13751 * 001000 01001001101
13752 * rt -----
13753 * rs -----
13754 * rd -----
13755 */
13756 static char *SHRAV_PH(uint64 instruction, Dis_info *info)
13757 {
13758 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13759 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13760 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13761
13762 const char *rd = GPR(rd_value, info);
13763 const char *rt = GPR(rt_value, info);
13764 const char *rs = GPR(rs_value, info);
13765
13766 return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
13767 }
13768
13769
13770 /*
13771 *
13772 *
13773 * 3 2 1
13774 * 10987654321098765432109876543210
13775 * 001000 01001001101
13776 * rt -----
13777 * rs -----
13778 * rd -----
13779 */
13780 static char *SHRAV_QB(uint64 instruction, Dis_info *info)
13781 {
13782 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13783 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13784 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13785
13786 const char *rd = GPR(rd_value, info);
13787 const char *rt = GPR(rt_value, info);
13788 const char *rs = GPR(rs_value, info);
13789
13790 return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
13791 }
13792
13793
13794 /*
13795 *
13796 *
13797 * 3 2 1
13798 * 10987654321098765432109876543210
13799 * 001000 01001001101
13800 * rt -----
13801 * rs -----
13802 * rd -----
13803 */
13804 static char *SHRAV_R_PH(uint64 instruction, Dis_info *info)
13805 {
13806 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13807 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13808 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13809
13810 const char *rd = GPR(rd_value, info);
13811 const char *rt = GPR(rt_value, info);
13812 const char *rs = GPR(rs_value, info);
13813
13814 return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
13815 }
13816
13817
13818 /*
13819 *
13820 *
13821 * 3 2 1
13822 * 10987654321098765432109876543210
13823 * 001000 01001001101
13824 * rt -----
13825 * rs -----
13826 * rd -----
13827 */
13828 static char *SHRAV_R_QB(uint64 instruction, Dis_info *info)
13829 {
13830 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13831 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13832 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13833
13834 const char *rd = GPR(rd_value, info);
13835 const char *rt = GPR(rt_value, info);
13836 const char *rs = GPR(rs_value, info);
13837
13838 return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
13839 }
13840
13841
13842 /*
13843 *
13844 *
13845 * 3 2 1
13846 * 10987654321098765432109876543210
13847 * 001000 01001001101
13848 * rt -----
13849 * rs -----
13850 * rd -----
13851 */
13852 static char *SHRAV_R_W(uint64 instruction, Dis_info *info)
13853 {
13854 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13855 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13856 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13857
13858 const char *rd = GPR(rd_value, info);
13859 const char *rt = GPR(rt_value, info);
13860 const char *rs = GPR(rs_value, info);
13861
13862 return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
13863 }
13864
13865
13866 /*
13867 * [DSP] SHRL.PH rt, rs, sa - Shift right logical two halfwords
13868 *
13869 * 3 2 1
13870 * 10987654321098765432109876543210
13871 * 001000 001111111111
13872 * rt -----
13873 * rs -----
13874 * sa ----
13875 */
13876 static char *SHRL_PH(uint64 instruction, Dis_info *info)
13877 {
13878 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13879 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13880 uint64 sa_value = extract_sa_15_14_13_12(instruction);
13881
13882 const char *rt = GPR(rt_value, info);
13883 const char *rs = GPR(rs_value, info);
13884
13885 return img_format("SHRL.PH %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13886 }
13887
13888
13889 /*
13890 * [DSP] SHRL.QB rt, rs, sa - Shift right logical vector quad bytes
13891 *
13892 * 3 2 1
13893 * 10987654321098765432109876543210
13894 * 001000 1100001111111
13895 * rt -----
13896 * rs -----
13897 * sa ---
13898 */
13899 static char *SHRL_QB(uint64 instruction, Dis_info *info)
13900 {
13901 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13902 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13903 uint64 sa_value = extract_sa_15_14_13(instruction);
13904
13905 const char *rt = GPR(rt_value, info);
13906 const char *rs = GPR(rs_value, info);
13907
13908 return img_format("SHRL.QB %s, %s, 0x%" PRIx64, rt, rs, sa_value);
13909 }
13910
13911
13912 /*
13913 * [DSP] SHLLV.PH rd, rt, rs - Shift right logical variable vector pair of
13914 * halfwords
13915 *
13916 * 3 2 1
13917 * 10987654321098765432109876543210
13918 * 001000 x1100010101
13919 * rt -----
13920 * rs -----
13921 * rd -----
13922 */
13923 static char *SHRLV_PH(uint64 instruction, Dis_info *info)
13924 {
13925 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13926 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13927 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13928
13929 const char *rd = GPR(rd_value, info);
13930 const char *rt = GPR(rt_value, info);
13931 const char *rs = GPR(rs_value, info);
13932
13933 return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
13934 }
13935
13936
13937 /*
13938 * [DSP] SHLLV.QB rd, rt, rs - Shift right logical variable vector quad bytes
13939 *
13940 * 3 2 1
13941 * 10987654321098765432109876543210
13942 * 001000 x1101010101
13943 * rt -----
13944 * rs -----
13945 * rd -----
13946 */
13947 static char *SHRLV_QB(uint64 instruction, Dis_info *info)
13948 {
13949 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13950 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13951 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13952
13953 const char *rd = GPR(rd_value, info);
13954 const char *rt = GPR(rt_value, info);
13955 const char *rs = GPR(rs_value, info);
13956
13957 return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
13958 }
13959
13960
13961 /*
13962 *
13963 *
13964 * 3 2 1
13965 * 10987654321098765432109876543210
13966 * 001000 01001001101
13967 * rt -----
13968 * rs -----
13969 * rd -----
13970 */
13971 static char *SHX(uint64 instruction, Dis_info *info)
13972 {
13973 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13974 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13975 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
13976
13977 const char *rd = GPR(rd_value, info);
13978 const char *rs = GPR(rs_value, info);
13979 const char *rt = GPR(rt_value, info);
13980
13981 return img_format("SHX %s, %s(%s)", rd, rs, rt);
13982 }
13983
13984
13985 /*
13986 *
13987 *
13988 * 3 2 1
13989 * 10987654321098765432109876543210
13990 * 001000 01001001101
13991 * rt -----
13992 * rs -----
13993 * rd -----
13994 */
13995 static char *SHXS(uint64 instruction, Dis_info *info)
13996 {
13997 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
13998 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
13999 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14000
14001 const char *rd = GPR(rd_value, info);
14002 const char *rs = GPR(rs_value, info);
14003 const char *rt = GPR(rt_value, info);
14004
14005 return img_format("SHXS %s, %s(%s)", rd, rs, rt);
14006 }
14007
14008
14009 /*
14010 *
14011 *
14012 * 3 2 1
14013 * 10987654321098765432109876543210
14014 * 001000 01001001101
14015 * rt -----
14016 * rs -----
14017 * rd -----
14018 */
14019 static char *SIGRIE(uint64 instruction, Dis_info *info)
14020 {
14021 uint64 code_value = extract_code_18_to_0(instruction);
14022
14023
14024 return img_format("SIGRIE 0x%" PRIx64, code_value);
14025 }
14026
14027
14028 /*
14029 *
14030 *
14031 * 3 2 1
14032 * 10987654321098765432109876543210
14033 * 001000 01001001101
14034 * rt -----
14035 * rs -----
14036 * rd -----
14037 */
14038 static char *SLL_16_(uint64 instruction, Dis_info *info)
14039 {
14040 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14041 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14042 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14043
14044 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14045 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14046 uint64 shift3 = encode_shift3_from_shift(shift3_value);
14047
14048 return img_format("SLL %s, %s, 0x%" PRIx64, rt3, rs3, shift3);
14049 }
14050
14051
14052 /*
14053 *
14054 *
14055 * 3 2 1
14056 * 10987654321098765432109876543210
14057 * 001000 01001001101
14058 * rt -----
14059 * rs -----
14060 * rd -----
14061 */
14062 static char *SLL_32_(uint64 instruction, Dis_info *info)
14063 {
14064 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14065 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14066 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14067
14068 const char *rt = GPR(rt_value, info);
14069 const char *rs = GPR(rs_value, info);
14070
14071 return img_format("SLL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14072 }
14073
14074
14075 /*
14076 *
14077 *
14078 * 3 2 1
14079 * 10987654321098765432109876543210
14080 * 001000 01001001101
14081 * rt -----
14082 * rs -----
14083 * rd -----
14084 */
14085 static char *SLLV(uint64 instruction, Dis_info *info)
14086 {
14087 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14088 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14089 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14090
14091 const char *rd = GPR(rd_value, info);
14092 const char *rs = GPR(rs_value, info);
14093 const char *rt = GPR(rt_value, info);
14094
14095 return img_format("SLLV %s, %s, %s", rd, rs, rt);
14096 }
14097
14098
14099 /*
14100 *
14101 *
14102 * 3 2 1
14103 * 10987654321098765432109876543210
14104 * 001000 01001001101
14105 * rt -----
14106 * rs -----
14107 * rd -----
14108 */
14109 static char *SLT(uint64 instruction, Dis_info *info)
14110 {
14111 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14112 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14113 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14114
14115 const char *rd = GPR(rd_value, info);
14116 const char *rs = GPR(rs_value, info);
14117 const char *rt = GPR(rt_value, info);
14118
14119 return img_format("SLT %s, %s, %s", rd, rs, rt);
14120 }
14121
14122
14123 /*
14124 *
14125 *
14126 * 3 2 1
14127 * 10987654321098765432109876543210
14128 * 001000 01001001101
14129 * rt -----
14130 * rs -----
14131 * rd -----
14132 */
14133 static char *SLTI(uint64 instruction, Dis_info *info)
14134 {
14135 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14136 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14137 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14138
14139 const char *rt = GPR(rt_value, info);
14140 const char *rs = GPR(rs_value, info);
14141
14142 return img_format("SLTI %s, %s, 0x%" PRIx64, rt, rs, u_value);
14143 }
14144
14145
14146 /*
14147 *
14148 *
14149 * 3 2 1
14150 * 10987654321098765432109876543210
14151 * 001000 01001001101
14152 * rt -----
14153 * rs -----
14154 * rd -----
14155 */
14156 static char *SLTIU(uint64 instruction, Dis_info *info)
14157 {
14158 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14159 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14160 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14161
14162 const char *rt = GPR(rt_value, info);
14163 const char *rs = GPR(rs_value, info);
14164
14165 return img_format("SLTIU %s, %s, 0x%" PRIx64, rt, rs, u_value);
14166 }
14167
14168
14169 /*
14170 *
14171 *
14172 * 3 2 1
14173 * 10987654321098765432109876543210
14174 * 001000 01001001101
14175 * rt -----
14176 * rs -----
14177 * rd -----
14178 */
14179 static char *SLTU(uint64 instruction, Dis_info *info)
14180 {
14181 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14182 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14183 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14184
14185 const char *rd = GPR(rd_value, info);
14186 const char *rs = GPR(rs_value, info);
14187 const char *rt = GPR(rt_value, info);
14188
14189 return img_format("SLTU %s, %s, %s", rd, rs, rt);
14190 }
14191
14192
14193 /*
14194 *
14195 *
14196 * 3 2 1
14197 * 10987654321098765432109876543210
14198 * 001000 01001001101
14199 * rt -----
14200 * rs -----
14201 * rd -----
14202 */
14203 static char *SOV(uint64 instruction, Dis_info *info)
14204 {
14205 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14206 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14207 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14208
14209 const char *rd = GPR(rd_value, info);
14210 const char *rs = GPR(rs_value, info);
14211 const char *rt = GPR(rt_value, info);
14212
14213 return img_format("SOV %s, %s, %s", rd, rs, rt);
14214 }
14215
14216
14217 /*
14218 *
14219 *
14220 * 3 2 1
14221 * 10987654321098765432109876543210
14222 * 001000 01001001101
14223 * rt -----
14224 * rs -----
14225 * rd -----
14226 */
14227 static char *SPECIAL2(uint64 instruction, Dis_info *info)
14228 {
14229 uint64 op_value = extract_op_25_to_3(instruction);
14230
14231
14232 return img_format("SPECIAL2 0x%" PRIx64, op_value);
14233 }
14234
14235
14236 /*
14237 *
14238 *
14239 * 3 2 1
14240 * 10987654321098765432109876543210
14241 * 001000 01001001101
14242 * rt -----
14243 * rs -----
14244 * rd -----
14245 */
14246 static char *SQRT_D(uint64 instruction, Dis_info *info)
14247 {
14248 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14249 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14250
14251 const char *ft = FPR(ft_value, info);
14252 const char *fs = FPR(fs_value, info);
14253
14254 return img_format("SQRT.D %s, %s", ft, fs);
14255 }
14256
14257
14258 /*
14259 *
14260 *
14261 * 3 2 1
14262 * 10987654321098765432109876543210
14263 * 001000 01001001101
14264 * rt -----
14265 * rs -----
14266 * rd -----
14267 */
14268 static char *SQRT_S(uint64 instruction, Dis_info *info)
14269 {
14270 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14271 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14272
14273 const char *ft = FPR(ft_value, info);
14274 const char *fs = FPR(fs_value, info);
14275
14276 return img_format("SQRT.S %s, %s", ft, fs);
14277 }
14278
14279
14280 /*
14281 * SRA rd, rt, sa - Shift Word Right Arithmetic
14282 *
14283 * 3 2 1
14284 * 10987654321098765432109876543210
14285 * 00000000000 000011
14286 * rt -----
14287 * rd -----
14288 * sa -----
14289 */
14290 static char *SRA(uint64 instruction, Dis_info *info)
14291 {
14292 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14293 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14294 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14295
14296 const char *rt = GPR(rt_value, info);
14297 const char *rs = GPR(rs_value, info);
14298
14299 return img_format("SRA %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14300 }
14301
14302
14303 /*
14304 * SRAV rd, rt, rs - Shift Word Right Arithmetic Variable
14305 *
14306 * 3 2 1
14307 * 10987654321098765432109876543210
14308 * 001000 00000000111
14309 * rs -----
14310 * rt -----
14311 * rd -----
14312 */
14313 static char *SRAV(uint64 instruction, Dis_info *info)
14314 {
14315 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14316 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14317 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14318
14319 const char *rd = GPR(rd_value, info);
14320 const char *rs = GPR(rs_value, info);
14321 const char *rt = GPR(rt_value, info);
14322
14323 return img_format("SRAV %s, %s, %s", rd, rs, rt);
14324 }
14325
14326
14327 /*
14328 *
14329 *
14330 * 3 2 1
14331 * 10987654321098765432109876543210
14332 * 001000 00000000111
14333 * rs -----
14334 * rt -----
14335 * rd -----
14336 */
14337 static char *SRL_16_(uint64 instruction, Dis_info *info)
14338 {
14339 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14340 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14341 uint64 shift3_value = extract_shift3_2_1_0(instruction);
14342
14343 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14344 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14345 uint64 shift3 = encode_shift3_from_shift(shift3_value);
14346
14347 return img_format("SRL %s, %s, 0x%" PRIx64, rt3, rs3, shift3);
14348 }
14349
14350
14351 /*
14352 *
14353 *
14354 * 3 2 1
14355 * 10987654321098765432109876543210
14356 * 001000 01001001101
14357 * rt -----
14358 * rs -----
14359 * rd -----
14360 */
14361 static char *SRL_32_(uint64 instruction, Dis_info *info)
14362 {
14363 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14364 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14365 uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
14366
14367 const char *rt = GPR(rt_value, info);
14368 const char *rs = GPR(rs_value, info);
14369
14370 return img_format("SRL %s, %s, 0x%" PRIx64, rt, rs, shift_value);
14371 }
14372
14373
14374 /*
14375 *
14376 *
14377 * 3 2 1
14378 * 10987654321098765432109876543210
14379 * 001000 01001001101
14380 * rt -----
14381 * rs -----
14382 * rd -----
14383 */
14384 static char *SRLV(uint64 instruction, Dis_info *info)
14385 {
14386 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14387 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14388 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14389
14390 const char *rd = GPR(rd_value, info);
14391 const char *rs = GPR(rs_value, info);
14392 const char *rt = GPR(rt_value, info);
14393
14394 return img_format("SRLV %s, %s, %s", rd, rs, rt);
14395 }
14396
14397
14398 /*
14399 *
14400 *
14401 * 3 2 1
14402 * 10987654321098765432109876543210
14403 * 001000 01001001101
14404 * rt -----
14405 * rs -----
14406 * rd -----
14407 */
14408 static char *SUB(uint64 instruction, Dis_info *info)
14409 {
14410 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14411 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14412 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14413
14414 const char *rd = GPR(rd_value, info);
14415 const char *rs = GPR(rs_value, info);
14416 const char *rt = GPR(rt_value, info);
14417
14418 return img_format("SUB %s, %s, %s", rd, rs, rt);
14419 }
14420
14421
14422 /*
14423 *
14424 *
14425 * 3 2 1
14426 * 10987654321098765432109876543210
14427 * 001000 01001001101
14428 * rt -----
14429 * rs -----
14430 * rd -----
14431 */
14432 static char *SUB_D(uint64 instruction, Dis_info *info)
14433 {
14434 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14435 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14436 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14437
14438 const char *fd = FPR(fd_value, info);
14439 const char *fs = FPR(fs_value, info);
14440 const char *ft = FPR(ft_value, info);
14441
14442 return img_format("SUB.D %s, %s, %s", fd, fs, ft);
14443 }
14444
14445
14446 /*
14447 *
14448 *
14449 * 3 2 1
14450 * 10987654321098765432109876543210
14451 * 001000 01001001101
14452 * rt -----
14453 * rs -----
14454 * rd -----
14455 */
14456 static char *SUB_S(uint64 instruction, Dis_info *info)
14457 {
14458 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
14459 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
14460 uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
14461
14462 const char *fd = FPR(fd_value, info);
14463 const char *fs = FPR(fs_value, info);
14464 const char *ft = FPR(ft_value, info);
14465
14466 return img_format("SUB.S %s, %s, %s", fd, fs, ft);
14467 }
14468
14469
14470 /*
14471 *
14472 *
14473 * 3 2 1
14474 * 10987654321098765432109876543210
14475 * 001000 01001001101
14476 * rt -----
14477 * rs -----
14478 * rd -----
14479 */
14480 static char *SUBQ_PH(uint64 instruction, Dis_info *info)
14481 {
14482 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14483 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14484 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14485
14486 const char *rd = GPR(rd_value, info);
14487 const char *rs = GPR(rs_value, info);
14488 const char *rt = GPR(rt_value, info);
14489
14490 return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
14491 }
14492
14493
14494 /*
14495 * [DSP] SUBQ.S.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14496 * right to halve results
14497 *
14498 * 3 2 1
14499 * 10987654321098765432109876543210
14500 * 001000 01001001101
14501 * rt -----
14502 * rs -----
14503 * rd -----
14504 */
14505 static char *SUBQ_S_PH(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("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
14516 }
14517
14518
14519 /*
14520 * [DSP] SUBQ.S.W rd, rt, rs - Subtract fractional halfword vectors and shift
14521 * right to halve results
14522 *
14523 * 3 2 1
14524 * 10987654321098765432109876543210
14525 * 001000 01001001101
14526 * rt -----
14527 * rs -----
14528 * rd -----
14529 */
14530 static char *SUBQ_S_W(uint64 instruction, Dis_info *info)
14531 {
14532 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14533 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14534 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14535
14536 const char *rd = GPR(rd_value, info);
14537 const char *rs = GPR(rs_value, info);
14538 const char *rt = GPR(rt_value, info);
14539
14540 return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
14541 }
14542
14543
14544 /*
14545 * [DSP] SUBQH.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14546 * right to halve results
14547 *
14548 * 3 2 1
14549 * 10987654321098765432109876543210
14550 * 001000 01001001101
14551 * rt -----
14552 * rs -----
14553 * rd -----
14554 */
14555 static char *SUBQH_PH(uint64 instruction, Dis_info *info)
14556 {
14557 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14558 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14559 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14560
14561 const char *rd = GPR(rd_value, info);
14562 const char *rs = GPR(rs_value, info);
14563 const char *rt = GPR(rt_value, info);
14564
14565 return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
14566 }
14567
14568
14569 /*
14570 * [DSP] SUBQH_R.PH rd, rt, rs - Subtract fractional halfword vectors and shift
14571 * right to halve results
14572 *
14573 * 3 2 1
14574 * 10987654321098765432109876543210
14575 * 001000 01001001101
14576 * rt -----
14577 * rs -----
14578 * rd -----
14579 */
14580 static char *SUBQH_R_PH(uint64 instruction, Dis_info *info)
14581 {
14582 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14583 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14584 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14585
14586 const char *rd = GPR(rd_value, info);
14587 const char *rs = GPR(rs_value, info);
14588 const char *rt = GPR(rt_value, info);
14589
14590 return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
14591 }
14592
14593
14594 /*
14595 * [DSP] SUBQH_R.W rd, rt, rs - Subtract fractional halfword vectors and shift
14596 * right to halve results with rounding
14597 *
14598 * 3 2 1
14599 * 10987654321098765432109876543210
14600 * 001000 11001001101
14601 * rt -----
14602 * rs -----
14603 * rd -----
14604 */
14605 static char *SUBQH_R_W(uint64 instruction, Dis_info *info)
14606 {
14607 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14608 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14609 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14610
14611 const char *rd = GPR(rd_value, info);
14612 const char *rs = GPR(rs_value, info);
14613 const char *rt = GPR(rt_value, info);
14614
14615 return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
14616 }
14617
14618
14619 /*
14620 * [DSP] SUBQH.W rd, rs, rt - Subtract fractional words and shift right to
14621 * halve results
14622 *
14623 * 3 2 1
14624 * 10987654321098765432109876543210
14625 * 001000 01010001101
14626 * rt -----
14627 * rs -----
14628 * rd -----
14629 */
14630 static char *SUBQH_W(uint64 instruction, Dis_info *info)
14631 {
14632 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14633 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14634 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14635
14636 const char *rd = GPR(rd_value, info);
14637 const char *rs = GPR(rs_value, info);
14638 const char *rt = GPR(rt_value, info);
14639
14640 return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
14641 }
14642
14643
14644 /*
14645 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14646 *
14647 * 3 2 1
14648 * 10987654321098765432109876543210
14649 * 001000 00010001101
14650 * rt -----
14651 * rs -----
14652 * rd -----
14653 */
14654 static char *SUBU_16_(uint64 instruction, Dis_info *info)
14655 {
14656 uint64 rt3_value = extract_rt3_9_8_7(instruction);
14657 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14658 uint64 rd3_value = extract_rd3_3_2_1(instruction);
14659
14660 const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
14661 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14662 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
14663
14664 return img_format("SUBU %s, %s, %s", rd3, rs3, rt3);
14665 }
14666
14667
14668 /*
14669 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14670 *
14671 * 3 2 1
14672 * 10987654321098765432109876543210
14673 * 001000 00010001101
14674 * rt -----
14675 * rs -----
14676 * rd -----
14677 */
14678 static char *SUBU_32_(uint64 instruction, Dis_info *info)
14679 {
14680 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14681 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14682 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14683
14684 const char *rd = GPR(rd_value, info);
14685 const char *rs = GPR(rs_value, info);
14686 const char *rt = GPR(rt_value, info);
14687
14688 return img_format("SUBU %s, %s, %s", rd, rs, rt);
14689 }
14690
14691
14692 /*
14693 * [DSP] SUBU.PH rd, rs, rt - Subtract unsigned unsigned halfwords
14694 *
14695 * 3 2 1
14696 * 10987654321098765432109876543210
14697 * 001000 01100001101
14698 * rt -----
14699 * rs -----
14700 * rd -----
14701 */
14702 static char *SUBU_PH(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("SUBU.PH %s, %s, %s", rd, rs, rt);
14713 }
14714
14715
14716 /*
14717 * [DSP] SUBU.QB rd, rs, rt - Subtract unsigned quad byte vectors
14718 *
14719 * 3 2 1
14720 * 10987654321098765432109876543210
14721 * 001000 01011001101
14722 * rt -----
14723 * rs -----
14724 * rd -----
14725 */
14726 static char *SUBU_QB(uint64 instruction, Dis_info *info)
14727 {
14728 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14729 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14730 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14731
14732 const char *rd = GPR(rd_value, info);
14733 const char *rs = GPR(rs_value, info);
14734 const char *rt = GPR(rt_value, info);
14735
14736 return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
14737 }
14738
14739
14740 /*
14741 * [DSP] SUBU_S.PH rd, rs, rt - Subtract unsigned unsigned halfwords with
14742 * 8-bit saturation
14743 *
14744 * 3 2 1
14745 * 10987654321098765432109876543210
14746 * 001000 11100001101
14747 * rt -----
14748 * rs -----
14749 * rd -----
14750 */
14751 static char *SUBU_S_PH(uint64 instruction, Dis_info *info)
14752 {
14753 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14754 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14755 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14756
14757 const char *rd = GPR(rd_value, info);
14758 const char *rs = GPR(rs_value, info);
14759 const char *rt = GPR(rt_value, info);
14760
14761 return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
14762 }
14763
14764
14765 /*
14766 * [DSP] SUBU_S.QB rd, rs, rt - Subtract unsigned quad byte vectors with
14767 * 8-bit saturation
14768 *
14769 * 3 2 1
14770 * 10987654321098765432109876543210
14771 * 001000 11011001101
14772 * rt -----
14773 * rs -----
14774 * rd -----
14775 */
14776 static char *SUBU_S_QB(uint64 instruction, Dis_info *info)
14777 {
14778 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14779 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14780 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14781
14782 const char *rd = GPR(rd_value, info);
14783 const char *rs = GPR(rs_value, info);
14784 const char *rt = GPR(rt_value, info);
14785
14786 return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
14787 }
14788
14789
14790 /*
14791 * [DSP] SUBUH.QB rd, rs, rt - Subtract unsigned bytes and right shift
14792 * to halve results
14793 *
14794 * 3 2 1
14795 * 10987654321098765432109876543210
14796 * 001000 01101001101
14797 * rt -----
14798 * rs -----
14799 * rd -----
14800 */
14801 static char *SUBUH_QB(uint64 instruction, Dis_info *info)
14802 {
14803 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14804 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14805 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14806
14807 const char *rd = GPR(rd_value, info);
14808 const char *rs = GPR(rs_value, info);
14809 const char *rt = GPR(rt_value, info);
14810
14811 return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
14812 }
14813
14814
14815 /*
14816 * [DSP] SUBUH_R.QB rd, rs, rt - Subtract unsigned bytes and right shift
14817 * to halve results with rounding
14818 *
14819 * 3 2 1
14820 * 10987654321098765432109876543210
14821 * 001000 11101001101
14822 * rt -----
14823 * rs -----
14824 * rd -----
14825 */
14826 static char *SUBUH_R_QB(uint64 instruction, Dis_info *info)
14827 {
14828 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14829 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14830 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
14831
14832 const char *rd = GPR(rd_value, info);
14833 const char *rs = GPR(rs_value, info);
14834 const char *rt = GPR(rt_value, info);
14835
14836 return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
14837 }
14838
14839
14840 /*
14841 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14842 *
14843 * 3 2 1
14844 * 10987654321098765432109876543210
14845 * 001000 00010001101
14846 * rt -----
14847 * rs -----
14848 * rd -----
14849 */
14850 static char *SW_16_(uint64 instruction, Dis_info *info)
14851 {
14852 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
14853 uint64 rs3_value = extract_rs3_6_5_4(instruction);
14854 uint64 u_value = extract_u_3_2_1_0__s2(instruction);
14855
14856 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
14857 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
14858
14859 return img_format("SW %s, 0x%" PRIx64 "(%s)", rtz3, u_value, rs3);
14860 }
14861
14862
14863 /*
14864 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14865 *
14866 * 3 2 1
14867 * 10987654321098765432109876543210
14868 * 001000 00010001101
14869 * rt -----
14870 * rs -----
14871 * rd -----
14872 */
14873 static char *SW_4X4_(uint64 instruction, Dis_info *info)
14874 {
14875 uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
14876 uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
14877 uint64 u_value = extract_u_3_8__s2(instruction);
14878
14879 const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
14880 const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
14881
14882 return img_format("SW %s, 0x%" PRIx64 "(%s)", rtz4, u_value, rs4);
14883 }
14884
14885
14886 /*
14887 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14888 *
14889 * 3 2 1
14890 * 10987654321098765432109876543210
14891 * 001000 00010001101
14892 * rt -----
14893 * rs -----
14894 * rd -----
14895 */
14896 static char *SW_GP16_(uint64 instruction, Dis_info *info)
14897 {
14898 uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
14899 uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
14900
14901 const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
14902
14903 return img_format("SW %s, 0x%" PRIx64 "($%d)", rtz3, u_value, 28);
14904 }
14905
14906
14907 /*
14908 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14909 *
14910 * 3 2 1
14911 * 10987654321098765432109876543210
14912 * 001000 00010001101
14913 * rt -----
14914 * rs -----
14915 * rd -----
14916 */
14917 static char *SW_GP_(uint64 instruction, Dis_info *info)
14918 {
14919 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14920 uint64 u_value = extract_u_20_to_2__s2(instruction);
14921
14922 const char *rt = GPR(rt_value, info);
14923
14924 return img_format("SW %s, 0x%" PRIx64 "($%d)", rt, u_value, 28);
14925 }
14926
14927
14928 /*
14929 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14930 *
14931 * 3 2 1
14932 * 10987654321098765432109876543210
14933 * 001000 00010001101
14934 * rt -----
14935 * rs -----
14936 * rd -----
14937 */
14938 static char *SW_S9_(uint64 instruction, Dis_info *info)
14939 {
14940 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14941 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
14942 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14943
14944 const char *rt = GPR(rt_value, info);
14945 const char *rs = GPR(rs_value, info);
14946
14947 return img_format("SW %s, %" PRId64 "(%s)", rt, s_value, rs);
14948 }
14949
14950
14951 /*
14952 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14953 *
14954 * 3 2 1
14955 * 10987654321098765432109876543210
14956 * 001000 00010001101
14957 * rt -----
14958 * rs -----
14959 * rd -----
14960 */
14961 static char *SW_SP_(uint64 instruction, Dis_info *info)
14962 {
14963 uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
14964 uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
14965
14966 const char *rt = GPR(rt_value, info);
14967
14968 return img_format("SW %s, 0x%" PRIx64 "($%d)", rt, u_value, 29);
14969 }
14970
14971
14972 /*
14973 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14974 *
14975 * 3 2 1
14976 * 10987654321098765432109876543210
14977 * 001000 00010001101
14978 * rt -----
14979 * rs -----
14980 * rd -----
14981 */
14982 static char *SW_U12_(uint64 instruction, Dis_info *info)
14983 {
14984 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
14985 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
14986 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
14987
14988 const char *rt = GPR(rt_value, info);
14989 const char *rs = GPR(rs_value, info);
14990
14991 return img_format("SW %s, 0x%" PRIx64 "(%s)", rt, u_value, rs);
14992 }
14993
14994
14995 /*
14996 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
14997 *
14998 * 3 2 1
14999 * 10987654321098765432109876543210
15000 * 001000 00010001101
15001 * rt -----
15002 * rs -----
15003 * rd -----
15004 */
15005 static char *SWC1_GP_(uint64 instruction, Dis_info *info)
15006 {
15007 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15008 uint64 u_value = extract_u_17_to_2__s2(instruction);
15009
15010 const char *ft = FPR(ft_value, info);
15011
15012 return img_format("SWC1 %s, 0x%" PRIx64 "($%d)", ft, u_value, 28);
15013 }
15014
15015
15016 /*
15017 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15018 *
15019 * 3 2 1
15020 * 10987654321098765432109876543210
15021 * 001000 00010001101
15022 * rt -----
15023 * rs -----
15024 * rd -----
15025 */
15026 static char *SWC1_S9_(uint64 instruction, Dis_info *info)
15027 {
15028 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15029 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15030 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15031
15032 const char *ft = FPR(ft_value, info);
15033 const char *rs = GPR(rs_value, info);
15034
15035 return img_format("SWC1 %s, %" PRId64 "(%s)", ft, s_value, rs);
15036 }
15037
15038
15039 /*
15040 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15041 *
15042 * 3 2 1
15043 * 10987654321098765432109876543210
15044 * 001000 00010001101
15045 * rt -----
15046 * rs -----
15047 * rd -----
15048 */
15049 static char *SWC1_U12_(uint64 instruction, Dis_info *info)
15050 {
15051 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15052 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15053 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15054
15055 const char *ft = FPR(ft_value, info);
15056 const char *rs = GPR(rs_value, info);
15057
15058 return img_format("SWC1 %s, 0x%" PRIx64 "(%s)", ft, u_value, rs);
15059 }
15060
15061
15062 /*
15063 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15064 *
15065 * 3 2 1
15066 * 10987654321098765432109876543210
15067 * 001000 00010001101
15068 * rt -----
15069 * rs -----
15070 * rd -----
15071 */
15072 static char *SWC1X(uint64 instruction, Dis_info *info)
15073 {
15074 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15075 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15076 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15077
15078 const char *ft = FPR(ft_value, info);
15079 const char *rs = GPR(rs_value, info);
15080 const char *rt = GPR(rt_value, info);
15081
15082 return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
15083 }
15084
15085
15086 /*
15087 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15088 *
15089 * 3 2 1
15090 * 10987654321098765432109876543210
15091 * 001000 00010001101
15092 * rt -----
15093 * rs -----
15094 * rd -----
15095 */
15096 static char *SWC1XS(uint64 instruction, Dis_info *info)
15097 {
15098 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15099 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15100 uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
15101
15102 const char *ft = FPR(ft_value, info);
15103 const char *rs = GPR(rs_value, info);
15104 const char *rt = GPR(rt_value, info);
15105
15106 return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
15107 }
15108
15109
15110 /*
15111 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15112 *
15113 * 3 2 1
15114 * 10987654321098765432109876543210
15115 * 001000 00010001101
15116 * rt -----
15117 * rs -----
15118 * rd -----
15119 */
15120 static char *SWC2(uint64 instruction, Dis_info *info)
15121 {
15122 uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
15123 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15124 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15125
15126 const char *rs = GPR(rs_value, info);
15127
15128 return img_format("SWC2 CP%" PRIu64 ", %" PRId64 "(%s)",
15129 cs_value, s_value, rs);
15130 }
15131
15132
15133 /*
15134 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15135 *
15136 * 3 2 1
15137 * 10987654321098765432109876543210
15138 * 001000 00010001101
15139 * rt -----
15140 * rs -----
15141 * rd -----
15142 */
15143 static char *SWE(uint64 instruction, Dis_info *info)
15144 {
15145 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15146 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15147 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15148
15149 const char *rt = GPR(rt_value, info);
15150 const char *rs = GPR(rs_value, info);
15151
15152 return img_format("SWE %s, %" PRId64 "(%s)", rt, s_value, rs);
15153 }
15154
15155
15156 /*
15157 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15158 *
15159 * 3 2 1
15160 * 10987654321098765432109876543210
15161 * 001000 00010001101
15162 * rt -----
15163 * rs -----
15164 * rd -----
15165 */
15166 static char *SWM(uint64 instruction, Dis_info *info)
15167 {
15168 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15169 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15170 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15171 uint64 count3_value = extract_count3_14_13_12(instruction);
15172
15173 const char *rt = GPR(rt_value, info);
15174 const char *rs = GPR(rs_value, info);
15175 uint64 count3 = encode_count3_from_count(count3_value);
15176
15177 return img_format("SWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15178 rt, s_value, rs, count3);
15179 }
15180
15181
15182 /*
15183 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15184 *
15185 * 3 2 1
15186 * 10987654321098765432109876543210
15187 * 001000 00010001101
15188 * rt -----
15189 * rs -----
15190 * rd -----
15191 */
15192 static char *SWPC_48_(uint64 instruction, Dis_info *info)
15193 {
15194 uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
15195 int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
15196
15197 const char *rt = GPR(rt_value, info);
15198 g_autofree char *s = ADDRESS(s_value, 6, info);
15199
15200 return img_format("SWPC %s, %s", rt, s);
15201 }
15202
15203
15204 /*
15205 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15206 *
15207 * 3 2 1
15208 * 10987654321098765432109876543210
15209 * 001000 00010001101
15210 * rt -----
15211 * rs -----
15212 * rd -----
15213 */
15214 static char *SWX(uint64 instruction, Dis_info *info)
15215 {
15216 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15217 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15218 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15219
15220 const char *rd = GPR(rd_value, info);
15221 const char *rs = GPR(rs_value, info);
15222 const char *rt = GPR(rt_value, info);
15223
15224 return img_format("SWX %s, %s(%s)", rd, rs, rt);
15225 }
15226
15227
15228 /*
15229 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15230 *
15231 * 3 2 1
15232 * 10987654321098765432109876543210
15233 * 001000 00010001101
15234 * rt -----
15235 * rs -----
15236 * rd -----
15237 */
15238 static char *SWXS(uint64 instruction, Dis_info *info)
15239 {
15240 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15241 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15242 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15243
15244 const char *rd = GPR(rd_value, info);
15245 const char *rs = GPR(rs_value, info);
15246 const char *rt = GPR(rt_value, info);
15247
15248 return img_format("SWXS %s, %s(%s)", rd, rs, rt);
15249 }
15250
15251
15252 /*
15253 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15254 *
15255 * 3 2 1
15256 * 10987654321098765432109876543210
15257 * 001000 00010001101
15258 * rt -----
15259 * rs -----
15260 * rd -----
15261 */
15262 static char *SYNC(uint64 instruction, Dis_info *info)
15263 {
15264 uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
15265
15266
15267 return img_format("SYNC 0x%" PRIx64, stype_value);
15268 }
15269
15270
15271 /*
15272 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15273 *
15274 * 3 2 1
15275 * 10987654321098765432109876543210
15276 * 001000 00010001101
15277 * rt -----
15278 * rs -----
15279 * rd -----
15280 */
15281 static char *SYNCI(uint64 instruction, Dis_info *info)
15282 {
15283 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15284 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15285
15286 const char *rs = GPR(rs_value, info);
15287
15288 return img_format("SYNCI %" PRId64 "(%s)", s_value, rs);
15289 }
15290
15291
15292 /*
15293 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15294 *
15295 * 3 2 1
15296 * 10987654321098765432109876543210
15297 * 001000 00010001101
15298 * rt -----
15299 * rs -----
15300 * rd -----
15301 */
15302 static char *SYNCIE(uint64 instruction, Dis_info *info)
15303 {
15304 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15305 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15306
15307 const char *rs = GPR(rs_value, info);
15308
15309 return img_format("SYNCIE %" PRId64 "(%s)", s_value, rs);
15310 }
15311
15312
15313 /*
15314 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15315 *
15316 * 3 2 1
15317 * 10987654321098765432109876543210
15318 * 001000 00010001101
15319 * rt -----
15320 * rs -----
15321 * rd -----
15322 */
15323 static char *SYSCALL_16_(uint64 instruction, Dis_info *info)
15324 {
15325 uint64 code_value = extract_code_1_0(instruction);
15326
15327
15328 return img_format("SYSCALL 0x%" PRIx64, code_value);
15329 }
15330
15331
15332 /*
15333 * SYSCALL code - System Call. Cause a System Call Exception
15334 *
15335 * 3 2 1
15336 * 10987654321098765432109876543210
15337 * 00000000000010
15338 * code ------------------
15339 */
15340 static char *SYSCALL_32_(uint64 instruction, Dis_info *info)
15341 {
15342 uint64 code_value = extract_code_17_to_0(instruction);
15343
15344
15345 return img_format("SYSCALL 0x%" PRIx64, code_value);
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 *TEQ(uint64 instruction, Dis_info *info)
15360 {
15361 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15362 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15363
15364 const char *rs = GPR(rs_value, info);
15365 const char *rt = GPR(rt_value, info);
15366
15367 return img_format("TEQ %s, %s", rs, rt);
15368 }
15369
15370
15371 /*
15372 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15373 *
15374 * 3 2 1
15375 * 10987654321098765432109876543210
15376 * 001000 00010001101
15377 * rt -----
15378 * rs -----
15379 * rd -----
15380 */
15381 static char *TLBGINV(uint64 instruction, Dis_info *info)
15382 {
15383 (void)instruction;
15384
15385 return g_strdup("TLBGINV ");
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 *TLBGINVF(uint64 instruction, Dis_info *info)
15400 {
15401 (void)instruction;
15402
15403 return g_strdup("TLBGINVF ");
15404 }
15405
15406
15407 /*
15408 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15409 *
15410 * 3 2 1
15411 * 10987654321098765432109876543210
15412 * 001000 00010001101
15413 * rt -----
15414 * rs -----
15415 * rd -----
15416 */
15417 static char *TLBGP(uint64 instruction, Dis_info *info)
15418 {
15419 (void)instruction;
15420
15421 return g_strdup("TLBGP ");
15422 }
15423
15424
15425 /*
15426 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15427 *
15428 * 3 2 1
15429 * 10987654321098765432109876543210
15430 * 001000 00010001101
15431 * rt -----
15432 * rs -----
15433 * rd -----
15434 */
15435 static char *TLBGR(uint64 instruction, Dis_info *info)
15436 {
15437 (void)instruction;
15438
15439 return g_strdup("TLBGR ");
15440 }
15441
15442
15443 /*
15444 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15445 *
15446 * 3 2 1
15447 * 10987654321098765432109876543210
15448 * 001000 00010001101
15449 * rt -----
15450 * rs -----
15451 * rd -----
15452 */
15453 static char *TLBGWI(uint64 instruction, Dis_info *info)
15454 {
15455 (void)instruction;
15456
15457 return g_strdup("TLBGWI ");
15458 }
15459
15460
15461 /*
15462 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15463 *
15464 * 3 2 1
15465 * 10987654321098765432109876543210
15466 * 001000 00010001101
15467 * rt -----
15468 * rs -----
15469 * rd -----
15470 */
15471 static char *TLBGWR(uint64 instruction, Dis_info *info)
15472 {
15473 (void)instruction;
15474
15475 return g_strdup("TLBGWR ");
15476 }
15477
15478
15479 /*
15480 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15481 *
15482 * 3 2 1
15483 * 10987654321098765432109876543210
15484 * 001000 00010001101
15485 * rt -----
15486 * rs -----
15487 * rd -----
15488 */
15489 static char *TLBINV(uint64 instruction, Dis_info *info)
15490 {
15491 (void)instruction;
15492
15493 return g_strdup("TLBINV ");
15494 }
15495
15496
15497 /*
15498 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15499 *
15500 * 3 2 1
15501 * 10987654321098765432109876543210
15502 * 001000 00010001101
15503 * rt -----
15504 * rs -----
15505 * rd -----
15506 */
15507 static char *TLBINVF(uint64 instruction, Dis_info *info)
15508 {
15509 (void)instruction;
15510
15511 return g_strdup("TLBINVF ");
15512 }
15513
15514
15515 /*
15516 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15517 *
15518 * 3 2 1
15519 * 10987654321098765432109876543210
15520 * 001000 00010001101
15521 * rt -----
15522 * rs -----
15523 * rd -----
15524 */
15525 static char *TLBP(uint64 instruction, Dis_info *info)
15526 {
15527 (void)instruction;
15528
15529 return g_strdup("TLBP ");
15530 }
15531
15532
15533 /*
15534 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15535 *
15536 * 3 2 1
15537 * 10987654321098765432109876543210
15538 * 001000 00010001101
15539 * rt -----
15540 * rs -----
15541 * rd -----
15542 */
15543 static char *TLBR(uint64 instruction, Dis_info *info)
15544 {
15545 (void)instruction;
15546
15547 return g_strdup("TLBR ");
15548 }
15549
15550
15551 /*
15552 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15553 *
15554 * 3 2 1
15555 * 10987654321098765432109876543210
15556 * 001000 00010001101
15557 * rt -----
15558 * rs -----
15559 * rd -----
15560 */
15561 static char *TLBWI(uint64 instruction, Dis_info *info)
15562 {
15563 (void)instruction;
15564
15565 return g_strdup("TLBWI ");
15566 }
15567
15568
15569 /*
15570 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15571 *
15572 * 3 2 1
15573 * 10987654321098765432109876543210
15574 * 001000 00010001101
15575 * rt -----
15576 * rs -----
15577 * rd -----
15578 */
15579 static char *TLBWR(uint64 instruction, Dis_info *info)
15580 {
15581 (void)instruction;
15582
15583 return g_strdup("TLBWR ");
15584 }
15585
15586
15587 /*
15588 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15589 *
15590 * 3 2 1
15591 * 10987654321098765432109876543210
15592 * 001000 00010001101
15593 * rt -----
15594 * rs -----
15595 * rd -----
15596 */
15597 static char *TNE(uint64 instruction, Dis_info *info)
15598 {
15599 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15600 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15601
15602 const char *rs = GPR(rs_value, info);
15603 const char *rt = GPR(rt_value, info);
15604
15605 return img_format("TNE %s, %s", rs, rt);
15606 }
15607
15608
15609 /*
15610 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15611 *
15612 * 3 2 1
15613 * 10987654321098765432109876543210
15614 * 001000 00010001101
15615 * rt -----
15616 * rs -----
15617 * rd -----
15618 */
15619 static char *TRUNC_L_D(uint64 instruction, Dis_info *info)
15620 {
15621 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15622 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15623
15624 const char *ft = FPR(ft_value, info);
15625 const char *fs = FPR(fs_value, info);
15626
15627 return img_format("TRUNC.L.D %s, %s", ft, fs);
15628 }
15629
15630
15631 /*
15632 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15633 *
15634 * 3 2 1
15635 * 10987654321098765432109876543210
15636 * 001000 00010001101
15637 * rt -----
15638 * rs -----
15639 * rd -----
15640 */
15641 static char *TRUNC_L_S(uint64 instruction, Dis_info *info)
15642 {
15643 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15644 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15645
15646 const char *ft = FPR(ft_value, info);
15647 const char *fs = FPR(fs_value, info);
15648
15649 return img_format("TRUNC.L.S %s, %s", ft, fs);
15650 }
15651
15652
15653 /*
15654 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15655 *
15656 * 3 2 1
15657 * 10987654321098765432109876543210
15658 * 001000 00010001101
15659 * rt -----
15660 * rs -----
15661 * rd -----
15662 */
15663 static char *TRUNC_W_D(uint64 instruction, Dis_info *info)
15664 {
15665 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15666 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15667
15668 const char *ft = FPR(ft_value, info);
15669 const char *fs = FPR(fs_value, info);
15670
15671 return img_format("TRUNC.W.D %s, %s", ft, fs);
15672 }
15673
15674
15675 /*
15676 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15677 *
15678 * 3 2 1
15679 * 10987654321098765432109876543210
15680 * 001000 00010001101
15681 * rt -----
15682 * rs -----
15683 * rd -----
15684 */
15685 static char *TRUNC_W_S(uint64 instruction, Dis_info *info)
15686 {
15687 uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
15688 uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
15689
15690 const char *ft = FPR(ft_value, info);
15691 const char *fs = FPR(fs_value, info);
15692
15693 return img_format("TRUNC.W.S %s, %s", ft, fs);
15694 }
15695
15696
15697 /*
15698 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15699 *
15700 * 3 2 1
15701 * 10987654321098765432109876543210
15702 * 001000 00010001101
15703 * rt -----
15704 * rs -----
15705 * rd -----
15706 */
15707 static char *UALDM(uint64 instruction, Dis_info *info)
15708 {
15709 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15710 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15711 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15712 uint64 count3_value = extract_count3_14_13_12(instruction);
15713
15714 const char *rt = GPR(rt_value, info);
15715 const char *rs = GPR(rs_value, info);
15716 uint64 count3 = encode_count3_from_count(count3_value);
15717
15718 return img_format("UALDM %s, %" PRId64 "(%s), 0x%" PRIx64,
15719 rt, s_value, rs, count3);
15720 }
15721
15722
15723 /*
15724 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15725 *
15726 * 3 2 1
15727 * 10987654321098765432109876543210
15728 * 001000 00010001101
15729 * rt -----
15730 * rs -----
15731 * rd -----
15732 */
15733 static char *UALH(uint64 instruction, Dis_info *info)
15734 {
15735 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15736 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15737 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15738
15739 const char *rt = GPR(rt_value, info);
15740 const char *rs = GPR(rs_value, info);
15741
15742 return img_format("UALH %s, %" PRId64 "(%s)", rt, s_value, rs);
15743 }
15744
15745
15746 /*
15747 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15748 *
15749 * 3 2 1
15750 * 10987654321098765432109876543210
15751 * 001000 00010001101
15752 * rt -----
15753 * rs -----
15754 * rd -----
15755 */
15756 static char *UALWM(uint64 instruction, Dis_info *info)
15757 {
15758 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15759 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15760 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15761 uint64 count3_value = extract_count3_14_13_12(instruction);
15762
15763 const char *rt = GPR(rt_value, info);
15764 const char *rs = GPR(rs_value, info);
15765 uint64 count3 = encode_count3_from_count(count3_value);
15766
15767 return img_format("UALWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15768 rt, s_value, rs, count3);
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 *UASDM(uint64 instruction, Dis_info *info)
15783 {
15784 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15785 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15786 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15787 uint64 count3_value = extract_count3_14_13_12(instruction);
15788
15789 const char *rt = GPR(rt_value, info);
15790 const char *rs = GPR(rs_value, info);
15791 uint64 count3 = encode_count3_from_count(count3_value);
15792
15793 return img_format("UASDM %s, %" PRId64 "(%s), 0x%" PRIx64,
15794 rt, s_value, rs, count3);
15795 }
15796
15797
15798 /*
15799 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15800 *
15801 * 3 2 1
15802 * 10987654321098765432109876543210
15803 * 001000 00010001101
15804 * rt -----
15805 * rs -----
15806 * rd -----
15807 */
15808 static char *UASH(uint64 instruction, Dis_info *info)
15809 {
15810 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15811 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15812 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15813
15814 const char *rt = GPR(rt_value, info);
15815 const char *rs = GPR(rs_value, info);
15816
15817 return img_format("UASH %s, %" PRId64 "(%s)", rt, s_value, rs);
15818 }
15819
15820
15821 /*
15822 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15823 *
15824 * 3 2 1
15825 * 10987654321098765432109876543210
15826 * 001000 00010001101
15827 * rt -----
15828 * rs -----
15829 * rd -----
15830 */
15831 static char *UASWM(uint64 instruction, Dis_info *info)
15832 {
15833 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15834 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15835 int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
15836 uint64 count3_value = extract_count3_14_13_12(instruction);
15837
15838 const char *rt = GPR(rt_value, info);
15839 const char *rs = GPR(rs_value, info);
15840 uint64 count3 = encode_count3_from_count(count3_value);
15841
15842 return img_format("UASWM %s, %" PRId64 "(%s), 0x%" PRIx64,
15843 rt, s_value, rs, count3);
15844 }
15845
15846
15847 /*
15848 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15849 *
15850 * 3 2 1
15851 * 10987654321098765432109876543210
15852 * 001000 00010001101
15853 * rt -----
15854 * rs -----
15855 * rd -----
15856 */
15857 static char *UDI(uint64 instruction, Dis_info *info)
15858 {
15859 uint64 op_value = extract_op_25_to_3(instruction);
15860
15861
15862 return img_format("UDI 0x%" PRIx64, op_value);
15863 }
15864
15865
15866 /*
15867 * WAIT code - Enter Wait State
15868 *
15869 * 3 2 1
15870 * 10987654321098765432109876543210
15871 * 001000 1100001101111111
15872 * code ----------
15873 */
15874 static char *WAIT(uint64 instruction, Dis_info *info)
15875 {
15876 uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
15877
15878
15879 return img_format("WAIT 0x%" PRIx64, code_value);
15880 }
15881
15882
15883 /*
15884 * [DSP] WRDSP rt, mask - Write selected fields from a GPR to the DSPControl
15885 * register
15886 *
15887 * 3 2 1
15888 * 10987654321098765432109876543210
15889 * 001000 01011001111111
15890 * rt -----
15891 * mask -------
15892 */
15893 static char *WRDSP(uint64 instruction, Dis_info *info)
15894 {
15895 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15896 uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
15897
15898 const char *rt = GPR(rt_value, info);
15899
15900 return img_format("WRDSP %s, 0x%" PRIx64, rt, mask_value);
15901 }
15902
15903
15904 /*
15905 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15906 *
15907 * 3 2 1
15908 * 10987654321098765432109876543210
15909 * 001000 00010001101
15910 * rt -----
15911 * rs -----
15912 * rd -----
15913 */
15914 static char *WRPGPR(uint64 instruction, Dis_info *info)
15915 {
15916 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15917 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15918
15919 const char *rt = GPR(rt_value, info);
15920 const char *rs = GPR(rs_value, info);
15921
15922 return img_format("WRPGPR %s, %s", rt, rs);
15923 }
15924
15925
15926 /*
15927 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15928 *
15929 * 3 2 1
15930 * 10987654321098765432109876543210
15931 * 001000 00010001101
15932 * rt -----
15933 * rs -----
15934 * rd -----
15935 */
15936 static char *XOR_16_(uint64 instruction, Dis_info *info)
15937 {
15938 uint64 rt3_value = extract_rt3_9_8_7(instruction);
15939 uint64 rs3_value = extract_rs3_6_5_4(instruction);
15940
15941 const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
15942 const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
15943
15944 return img_format("XOR %s, %s", rs3, rt3);
15945 }
15946
15947
15948 /*
15949 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15950 *
15951 * 3 2 1
15952 * 10987654321098765432109876543210
15953 * 001000 00010001101
15954 * rt -----
15955 * rs -----
15956 * rd -----
15957 */
15958 static char *XOR_32_(uint64 instruction, Dis_info *info)
15959 {
15960 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15961 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15962 uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
15963
15964 const char *rd = GPR(rd_value, info);
15965 const char *rs = GPR(rs_value, info);
15966 const char *rt = GPR(rt_value, info);
15967
15968 return img_format("XOR %s, %s, %s", rd, rs, rt);
15969 }
15970
15971
15972 /*
15973 * ADDQH_R.W rd, rt, rs - Add Fractional Words And Shift Right to Halve Results
15974 *
15975 * 3 2 1
15976 * 10987654321098765432109876543210
15977 * 001000 00010001101
15978 * rt -----
15979 * rs -----
15980 * rd -----
15981 */
15982 static char *XORI(uint64 instruction, Dis_info *info)
15983 {
15984 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
15985 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
15986 uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
15987
15988 const char *rt = GPR(rt_value, info);
15989 const char *rs = GPR(rs_value, info);
15990
15991 return img_format("XORI %s, %s, 0x%" PRIx64, rt, rs, u_value);
15992 }
15993
15994
15995 /*
15996 * YIELD rt, rs -
15997 *
15998 * 3 2 1
15999 * 10987654321098765432109876543210
16000 * 001000 00010001101
16001 * rt -----
16002 * rs -----
16003 */
16004 static char *YIELD(uint64 instruction, Dis_info *info)
16005 {
16006 uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
16007 uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
16008
16009 const char *rt = GPR(rt_value, info);
16010 const char *rs = GPR(rs_value, info);
16011
16012 return img_format("YIELD %s, %s", rt, rs);
16013 }
16014
16015
16016
16017 /*
16018 * nanoMIPS instruction pool organization
16019 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
16020 *
16021 *
16022 * ┌─ P.ADDIU ─── P.RI ─── P.SYSCALL
16023 * │
16024 * │ ┌─ P.TRAP
16025 * │ │
16026 * │ ┌─ _POOL32A0_0 ─┼─ P.CMOVE
16027 * │ │ │
16028 * │ │ └─ P.SLTU
16029 * │ ┌─ _POOL32A0 ─┤
16030 * │ │ │
16031 * │ │ │
16032 * │ │ └─ _POOL32A0_1 ─── CRC32
16033 * │ │
16034 * ├─ P32A ─┤
16035 * │ │ ┌─ PP.LSX
16036 * │ │ ┌─ P.LSX ─────┤
16037 * │ │ │ └─ PP.LSXS
16038 * │ └─ _POOL32A7 ─┤
16039 * │ │ ┌─ POOL32Axf_4
16040 * │ └─ POOL32Axf ─┤
16041 * │ └─ POOL32Axf_5
16042 * │
16043 * ├─ PBAL
16044 * │
16045 * ├─ P.GP.W ┌─ PP.LSX
16046 * ┌─ P32 ─┤ │
16047 * │ ├─ P.GP.BH ─┴─ PP.LSXS
16048 * │ │
16049 * │ ├─ P.J ─────── PP.BALRSC
16050 * │ │
16051 * │ ├─ P48I
16052 * │ │ ┌─ P.SR
16053 * │ │ │
16054 * │ │ ├─ P.SHIFT
16055 * │ │ │
16056 * │ ├─ P.U12 ───┼─ P.ROTX
16057 * │ │ │
16058 * │ │ ├─ P.INS
16059 * │ │ │
16060 * │ │ └─ P.EXT
16061 * │ │
16062 * │ ├─ P.LS.U12 ── P.PREF.U12
16063 * │ │
16064 * │ ├─ P.BR1 ───── P.BR3A
16065 * │ │
16066 * │ │ ┌─ P.LS.S0 ─── P16.SYSCALL
16067 * │ │ │
16068 * │ │ │ ┌─ P.LL
16069 * │ │ ├─ P.LS.S1 ─┤
16070 * │ │ │ └─ P.SC
16071 * │ │ │
16072 * │ │ │ ┌─ P.PREFE
16073 * MAJOR ─┤ ├─ P.LS.S9 ─┤ │
16074 * │ │ ├─ P.LS.E0 ─┼─ P.LLE
16075 * │ │ │ │
16076 * │ │ │ └─ P.SCE
16077 * │ │ │
16078 * │ │ ├─ P.LS.WM
16079 * │ │ │
16080 * │ │ └─ P.LS.UAWM
16081 * │ │
16082 * │ │
16083 * │ ├─ P.BR2
16084 * │ │
16085 * │ ├─ P.BRI
16086 * │ │
16087 * │ └─ P.LUI
16088 * │
16089 * │
16090 * │ ┌─ P16.MV ──── P16.RI ─── P16.SYSCALL
16091 * │ │
16092 * │ ├─ P16.SR
16093 * │ │
16094 * │ ├─ P16.SHIFT
16095 * │ │
16096 * │ ├─ P16.4x4
16097 * │ │
16098 * │ ├─ P16C ────── POOL16C_0 ── POOL16C_00
16099 * │ │
16100 * └─ P16 ─┼─ P16.LB
16101 * │
16102 * ├─ P16.A1
16103 * │
16104 * ├─ P16.LH
16105 * │
16106 * ├─ P16.A2 ──── P.ADDIU[RS5]
16107 * │
16108 * ├─ P16.ADDU
16109 * │
16110 * └─ P16.BR ──┬─ P16.JRC
16111 * │
16112 * └─ P16.BR1
16113 *
16114 *
16115 * (FP, DPS, and some minor instruction pools are omitted from the diagram)
16116 *
16117 */
16118
16119 typedef enum {
16120 instruction,
16121 call_instruction,
16122 branch_instruction,
16123 return_instruction,
16124 reserved_block,
16125 pool,
16126 } TABLE_ENTRY_TYPE;
16127
16128 typedef enum {
16129 MIPS64_ = 0x00000001,
16130 XNP_ = 0x00000002,
16131 XMMS_ = 0x00000004,
16132 EVA_ = 0x00000008,
16133 DSP_ = 0x00000010,
16134 MT_ = 0x00000020,
16135 EJTAG_ = 0x00000040,
16136 TLBINV_ = 0x00000080,
16137 CP0_ = 0x00000100,
16138 CP1_ = 0x00000200,
16139 CP2_ = 0x00000400,
16140 UDI_ = 0x00000800,
16141 MCU_ = 0x00001000,
16142 VZ_ = 0x00002000,
16143 TLB_ = 0x00004000,
16144 MVH_ = 0x00008000,
16145 ALL_ATTRIBUTES = 0xffffffffull,
16146 } TABLE_ATTRIBUTE_TYPE;
16147
16148 typedef bool (*conditional_function)(uint64 instruction);
16149 typedef char * (*disassembly_function)(uint64 instruction,
16150 Dis_info *info);
16151
16152 typedef struct Pool {
16153 TABLE_ENTRY_TYPE type;
16154 const struct Pool *next_table;
16155 int next_table_size;
16156 int instructions_size;
16157 uint64 mask;
16158 uint64 value;
16159 disassembly_function disassembly;
16160 conditional_function condition;
16161 uint64 attributes;
16162 } Pool;
16163
16164 static const Pool P_SYSCALL[2] = {
16165 { instruction , 0 , 0 , 32,
16166 0xfffc0000, 0x00080000, &SYSCALL_32_ , 0,
16167 0x0 }, /* SYSCALL[32] */
16168 { instruction , 0 , 0 , 32,
16169 0xfffc0000, 0x000c0000, &HYPCALL , 0,
16170 CP0_ | VZ_ }, /* HYPCALL */
16171 };
16172
16173
16174 static const Pool P_RI[4] = {
16175 { instruction , 0 , 0 , 32,
16176 0xfff80000, 0x00000000, &SIGRIE , 0,
16177 0x0 }, /* SIGRIE */
16178 { pool , P_SYSCALL , 2 , 32,
16179 0xfff80000, 0x00080000, 0 , 0,
16180 0x0 }, /* P.SYSCALL */
16181 { instruction , 0 , 0 , 32,
16182 0xfff80000, 0x00100000, &BREAK_32_ , 0,
16183 0x0 }, /* BREAK[32] */
16184 { instruction , 0 , 0 , 32,
16185 0xfff80000, 0x00180000, &SDBBP_32_ , 0,
16186 EJTAG_ }, /* SDBBP[32] */
16187 };
16188
16189
16190 static const Pool P_ADDIU[2] = {
16191 { pool , P_RI , 4 , 32,
16192 0xffe00000, 0x00000000, 0 , 0,
16193 0x0 }, /* P.RI */
16194 { instruction , 0 , 0 , 32,
16195 0xfc000000, 0x00000000, &ADDIU_32_ , &ADDIU_32__cond ,
16196 0x0 }, /* ADDIU[32] */
16197 };
16198
16199
16200 static const Pool P_TRAP[2] = {
16201 { instruction , 0 , 0 , 32,
16202 0xfc0007ff, 0x20000000, &TEQ , 0,
16203 XMMS_ }, /* TEQ */
16204 { instruction , 0 , 0 , 32,
16205 0xfc0007ff, 0x20000400, &TNE , 0,
16206 XMMS_ }, /* TNE */
16207 };
16208
16209
16210 static const Pool P_CMOVE[2] = {
16211 { instruction , 0 , 0 , 32,
16212 0xfc0007ff, 0x20000210, &MOVZ , 0,
16213 0x0 }, /* MOVZ */
16214 { instruction , 0 , 0 , 32,
16215 0xfc0007ff, 0x20000610, &MOVN , 0,
16216 0x0 }, /* MOVN */
16217 };
16218
16219
16220 static const Pool P_D_MT_VPE[2] = {
16221 { instruction , 0 , 0 , 32,
16222 0xfc1f3fff, 0x20010ab0, &DMT , 0,
16223 MT_ }, /* DMT */
16224 { instruction , 0 , 0 , 32,
16225 0xfc1f3fff, 0x20000ab0, &DVPE , 0,
16226 MT_ }, /* DVPE */
16227 };
16228
16229
16230 static const Pool P_E_MT_VPE[2] = {
16231 { instruction , 0 , 0 , 32,
16232 0xfc1f3fff, 0x20010eb0, &EMT , 0,
16233 MT_ }, /* EMT */
16234 { instruction , 0 , 0 , 32,
16235 0xfc1f3fff, 0x20000eb0, &EVPE , 0,
16236 MT_ }, /* EVPE */
16237 };
16238
16239
16240 static const Pool _P_MT_VPE[2] = {
16241 { pool , P_D_MT_VPE , 2 , 32,
16242 0xfc003fff, 0x20000ab0, 0 , 0,
16243 0x0 }, /* P.D_MT_VPE */
16244 { pool , P_E_MT_VPE , 2 , 32,
16245 0xfc003fff, 0x20000eb0, 0 , 0,
16246 0x0 }, /* P.E_MT_VPE */
16247 };
16248
16249
16250 static const Pool P_MT_VPE[8] = {
16251 { reserved_block , 0 , 0 , 32,
16252 0xfc003bff, 0x200002b0, 0 , 0,
16253 0x0 }, /* P.MT_VPE~*(0) */
16254 { pool , _P_MT_VPE , 2 , 32,
16255 0xfc003bff, 0x20000ab0, 0 , 0,
16256 0x0 }, /* _P.MT_VPE */
16257 { reserved_block , 0 , 0 , 32,
16258 0xfc003bff, 0x200012b0, 0 , 0,
16259 0x0 }, /* P.MT_VPE~*(2) */
16260 { reserved_block , 0 , 0 , 32,
16261 0xfc003bff, 0x20001ab0, 0 , 0,
16262 0x0 }, /* P.MT_VPE~*(3) */
16263 { reserved_block , 0 , 0 , 32,
16264 0xfc003bff, 0x200022b0, 0 , 0,
16265 0x0 }, /* P.MT_VPE~*(4) */
16266 { reserved_block , 0 , 0 , 32,
16267 0xfc003bff, 0x20002ab0, 0 , 0,
16268 0x0 }, /* P.MT_VPE~*(5) */
16269 { reserved_block , 0 , 0 , 32,
16270 0xfc003bff, 0x200032b0, 0 , 0,
16271 0x0 }, /* P.MT_VPE~*(6) */
16272 { reserved_block , 0 , 0 , 32,
16273 0xfc003bff, 0x20003ab0, 0 , 0,
16274 0x0 }, /* P.MT_VPE~*(7) */
16275 };
16276
16277
16278 static const Pool P_DVP[2] = {
16279 { instruction , 0 , 0 , 32,
16280 0xfc00ffff, 0x20000390, &DVP , 0,
16281 0x0 }, /* DVP */
16282 { instruction , 0 , 0 , 32,
16283 0xfc00ffff, 0x20000790, &EVP , 0,
16284 0x0 }, /* EVP */
16285 };
16286
16287
16288 static const Pool P_SLTU[2] = {
16289 { pool , P_DVP , 2 , 32,
16290 0xfc00fbff, 0x20000390, 0 , 0,
16291 0x0 }, /* P.DVP */
16292 { instruction , 0 , 0 , 32,
16293 0xfc0003ff, 0x20000390, &SLTU , &SLTU_cond ,
16294 0x0 }, /* SLTU */
16295 };
16296
16297
16298 static const Pool _POOL32A0[128] = {
16299 { pool , P_TRAP , 2 , 32,
16300 0xfc0003ff, 0x20000000, 0 , 0,
16301 0x0 }, /* P.TRAP */
16302 { instruction , 0 , 0 , 32,
16303 0xfc0003ff, 0x20000008, &SEB , 0,
16304 XMMS_ }, /* SEB */
16305 { instruction , 0 , 0 , 32,
16306 0xfc0003ff, 0x20000010, &SLLV , 0,
16307 0x0 }, /* SLLV */
16308 { instruction , 0 , 0 , 32,
16309 0xfc0003ff, 0x20000018, &MUL_32_ , 0,
16310 0x0 }, /* MUL[32] */
16311 { reserved_block , 0 , 0 , 32,
16312 0xfc0003ff, 0x20000020, 0 , 0,
16313 0x0 }, /* _POOL32A0~*(4) */
16314 { reserved_block , 0 , 0 , 32,
16315 0xfc0003ff, 0x20000028, 0 , 0,
16316 0x0 }, /* _POOL32A0~*(5) */
16317 { instruction , 0 , 0 , 32,
16318 0xfc0003ff, 0x20000030, &MFC0 , 0,
16319 0x0 }, /* MFC0 */
16320 { instruction , 0 , 0 , 32,
16321 0xfc0003ff, 0x20000038, &MFHC0 , 0,
16322 CP0_ | MVH_ }, /* MFHC0 */
16323 { reserved_block , 0 , 0 , 32,
16324 0xfc0003ff, 0x20000040, 0 , 0,
16325 0x0 }, /* _POOL32A0~*(8) */
16326 { instruction , 0 , 0 , 32,
16327 0xfc0003ff, 0x20000048, &SEH , 0,
16328 0x0 }, /* SEH */
16329 { instruction , 0 , 0 , 32,
16330 0xfc0003ff, 0x20000050, &SRLV , 0,
16331 0x0 }, /* SRLV */
16332 { instruction , 0 , 0 , 32,
16333 0xfc0003ff, 0x20000058, &MUH , 0,
16334 0x0 }, /* MUH */
16335 { reserved_block , 0 , 0 , 32,
16336 0xfc0003ff, 0x20000060, 0 , 0,
16337 0x0 }, /* _POOL32A0~*(12) */
16338 { reserved_block , 0 , 0 , 32,
16339 0xfc0003ff, 0x20000068, 0 , 0,
16340 0x0 }, /* _POOL32A0~*(13) */
16341 { instruction , 0 , 0 , 32,
16342 0xfc0003ff, 0x20000070, &MTC0 , 0,
16343 CP0_ }, /* MTC0 */
16344 { instruction , 0 , 0 , 32,
16345 0xfc0003ff, 0x20000078, &MTHC0 , 0,
16346 CP0_ | MVH_ }, /* MTHC0 */
16347 { reserved_block , 0 , 0 , 32,
16348 0xfc0003ff, 0x20000080, 0 , 0,
16349 0x0 }, /* _POOL32A0~*(16) */
16350 { reserved_block , 0 , 0 , 32,
16351 0xfc0003ff, 0x20000088, 0 , 0,
16352 0x0 }, /* _POOL32A0~*(17) */
16353 { instruction , 0 , 0 , 32,
16354 0xfc0003ff, 0x20000090, &SRAV , 0,
16355 0x0 }, /* SRAV */
16356 { instruction , 0 , 0 , 32,
16357 0xfc0003ff, 0x20000098, &MULU , 0,
16358 0x0 }, /* MULU */
16359 { reserved_block , 0 , 0 , 32,
16360 0xfc0003ff, 0x200000a0, 0 , 0,
16361 0x0 }, /* _POOL32A0~*(20) */
16362 { reserved_block , 0 , 0 , 32,
16363 0xfc0003ff, 0x200000a8, 0 , 0,
16364 0x0 }, /* _POOL32A0~*(21) */
16365 { instruction , 0 , 0 , 32,
16366 0xfc0003ff, 0x200000b0, &MFGC0 , 0,
16367 CP0_ | VZ_ }, /* MFGC0 */
16368 { instruction , 0 , 0 , 32,
16369 0xfc0003ff, 0x200000b8, &MFHGC0 , 0,
16370 CP0_ | VZ_ | MVH_ }, /* MFHGC0 */
16371 { reserved_block , 0 , 0 , 32,
16372 0xfc0003ff, 0x200000c0, 0 , 0,
16373 0x0 }, /* _POOL32A0~*(24) */
16374 { reserved_block , 0 , 0 , 32,
16375 0xfc0003ff, 0x200000c8, 0 , 0,
16376 0x0 }, /* _POOL32A0~*(25) */
16377 { instruction , 0 , 0 , 32,
16378 0xfc0003ff, 0x200000d0, &ROTRV , 0,
16379 0x0 }, /* ROTRV */
16380 { instruction , 0 , 0 , 32,
16381 0xfc0003ff, 0x200000d8, &MUHU , 0,
16382 0x0 }, /* MUHU */
16383 { reserved_block , 0 , 0 , 32,
16384 0xfc0003ff, 0x200000e0, 0 , 0,
16385 0x0 }, /* _POOL32A0~*(28) */
16386 { reserved_block , 0 , 0 , 32,
16387 0xfc0003ff, 0x200000e8, 0 , 0,
16388 0x0 }, /* _POOL32A0~*(29) */
16389 { instruction , 0 , 0 , 32,
16390 0xfc0003ff, 0x200000f0, &MTGC0 , 0,
16391 CP0_ | VZ_ }, /* MTGC0 */
16392 { instruction , 0 , 0 , 32,
16393 0xfc0003ff, 0x200000f8, &MTHGC0 , 0,
16394 CP0_ | VZ_ | MVH_ }, /* MTHGC0 */
16395 { reserved_block , 0 , 0 , 32,
16396 0xfc0003ff, 0x20000100, 0 , 0,
16397 0x0 }, /* _POOL32A0~*(32) */
16398 { reserved_block , 0 , 0 , 32,
16399 0xfc0003ff, 0x20000108, 0 , 0,
16400 0x0 }, /* _POOL32A0~*(33) */
16401 { instruction , 0 , 0 , 32,
16402 0xfc0003ff, 0x20000110, &ADD , 0,
16403 XMMS_ }, /* ADD */
16404 { instruction , 0 , 0 , 32,
16405 0xfc0003ff, 0x20000118, &DIV , 0,
16406 0x0 }, /* DIV */
16407 { reserved_block , 0 , 0 , 32,
16408 0xfc0003ff, 0x20000120, 0 , 0,
16409 0x0 }, /* _POOL32A0~*(36) */
16410 { reserved_block , 0 , 0 , 32,
16411 0xfc0003ff, 0x20000128, 0 , 0,
16412 0x0 }, /* _POOL32A0~*(37) */
16413 { instruction , 0 , 0 , 32,
16414 0xfc0003ff, 0x20000130, &DMFC0 , 0,
16415 CP0_ | MIPS64_ }, /* DMFC0 */
16416 { reserved_block , 0 , 0 , 32,
16417 0xfc0003ff, 0x20000138, 0 , 0,
16418 0x0 }, /* _POOL32A0~*(39) */
16419 { reserved_block , 0 , 0 , 32,
16420 0xfc0003ff, 0x20000140, 0 , 0,
16421 0x0 }, /* _POOL32A0~*(40) */
16422 { reserved_block , 0 , 0 , 32,
16423 0xfc0003ff, 0x20000148, 0 , 0,
16424 0x0 }, /* _POOL32A0~*(41) */
16425 { instruction , 0 , 0 , 32,
16426 0xfc0003ff, 0x20000150, &ADDU_32_ , 0,
16427 0x0 }, /* ADDU[32] */
16428 { instruction , 0 , 0 , 32,
16429 0xfc0003ff, 0x20000158, &MOD , 0,
16430 0x0 }, /* MOD */
16431 { reserved_block , 0 , 0 , 32,
16432 0xfc0003ff, 0x20000160, 0 , 0,
16433 0x0 }, /* _POOL32A0~*(44) */
16434 { reserved_block , 0 , 0 , 32,
16435 0xfc0003ff, 0x20000168, 0 , 0,
16436 0x0 }, /* _POOL32A0~*(45) */
16437 { instruction , 0 , 0 , 32,
16438 0xfc0003ff, 0x20000170, &DMTC0 , 0,
16439 CP0_ | MIPS64_ }, /* DMTC0 */
16440 { reserved_block , 0 , 0 , 32,
16441 0xfc0003ff, 0x20000178, 0 , 0,
16442 0x0 }, /* _POOL32A0~*(47) */
16443 { reserved_block , 0 , 0 , 32,
16444 0xfc0003ff, 0x20000180, 0 , 0,
16445 0x0 }, /* _POOL32A0~*(48) */
16446 { reserved_block , 0 , 0 , 32,
16447 0xfc0003ff, 0x20000188, 0 , 0,
16448 0x0 }, /* _POOL32A0~*(49) */
16449 { instruction , 0 , 0 , 32,
16450 0xfc0003ff, 0x20000190, &SUB , 0,
16451 XMMS_ }, /* SUB */
16452 { instruction , 0 , 0 , 32,
16453 0xfc0003ff, 0x20000198, &DIVU , 0,
16454 0x0 }, /* DIVU */
16455 { reserved_block , 0 , 0 , 32,
16456 0xfc0003ff, 0x200001a0, 0 , 0,
16457 0x0 }, /* _POOL32A0~*(52) */
16458 { reserved_block , 0 , 0 , 32,
16459 0xfc0003ff, 0x200001a8, 0 , 0,
16460 0x0 }, /* _POOL32A0~*(53) */
16461 { instruction , 0 , 0 , 32,
16462 0xfc0003ff, 0x200001b0, &DMFGC0 , 0,
16463 CP0_ | MIPS64_ | VZ_}, /* DMFGC0 */
16464 { reserved_block , 0 , 0 , 32,
16465 0xfc0003ff, 0x200001b8, 0 , 0,
16466 0x0 }, /* _POOL32A0~*(55) */
16467 { instruction , 0 , 0 , 32,
16468 0xfc0003ff, 0x200001c0, &RDHWR , 0,
16469 XMMS_ }, /* RDHWR */
16470 { reserved_block , 0 , 0 , 32,
16471 0xfc0003ff, 0x200001c8, 0 , 0,
16472 0x0 }, /* _POOL32A0~*(57) */
16473 { instruction , 0 , 0 , 32,
16474 0xfc0003ff, 0x200001d0, &SUBU_32_ , 0,
16475 0x0 }, /* SUBU[32] */
16476 { instruction , 0 , 0 , 32,
16477 0xfc0003ff, 0x200001d8, &MODU , 0,
16478 0x0 }, /* MODU */
16479 { reserved_block , 0 , 0 , 32,
16480 0xfc0003ff, 0x200001e0, 0 , 0,
16481 0x0 }, /* _POOL32A0~*(60) */
16482 { reserved_block , 0 , 0 , 32,
16483 0xfc0003ff, 0x200001e8, 0 , 0,
16484 0x0 }, /* _POOL32A0~*(61) */
16485 { instruction , 0 , 0 , 32,
16486 0xfc0003ff, 0x200001f0, &DMTGC0 , 0,
16487 CP0_ | MIPS64_ | VZ_}, /* DMTGC0 */
16488 { reserved_block , 0 , 0 , 32,
16489 0xfc0003ff, 0x200001f8, 0 , 0,
16490 0x0 }, /* _POOL32A0~*(63) */
16491 { reserved_block , 0 , 0 , 32,
16492 0xfc0003ff, 0x20000200, 0 , 0,
16493 0x0 }, /* _POOL32A0~*(64) */
16494 { reserved_block , 0 , 0 , 32,
16495 0xfc0003ff, 0x20000208, 0 , 0,
16496 0x0 }, /* _POOL32A0~*(65) */
16497 { pool , P_CMOVE , 2 , 32,
16498 0xfc0003ff, 0x20000210, 0 , 0,
16499 0x0 }, /* P.CMOVE */
16500 { reserved_block , 0 , 0 , 32,
16501 0xfc0003ff, 0x20000218, 0 , 0,
16502 0x0 }, /* _POOL32A0~*(67) */
16503 { reserved_block , 0 , 0 , 32,
16504 0xfc0003ff, 0x20000220, 0 , 0,
16505 0x0 }, /* _POOL32A0~*(68) */
16506 { instruction , 0 , 0 , 32,
16507 0xfc0003ff, 0x20000228, &FORK , 0,
16508 MT_ }, /* FORK */
16509 { instruction , 0 , 0 , 32,
16510 0xfc0003ff, 0x20000230, &MFTR , 0,
16511 MT_ }, /* MFTR */
16512 { instruction , 0 , 0 , 32,
16513 0xfc0003ff, 0x20000238, &MFHTR , 0,
16514 MT_ }, /* MFHTR */
16515 { reserved_block , 0 , 0 , 32,
16516 0xfc0003ff, 0x20000240, 0 , 0,
16517 0x0 }, /* _POOL32A0~*(72) */
16518 { reserved_block , 0 , 0 , 32,
16519 0xfc0003ff, 0x20000248, 0 , 0,
16520 0x0 }, /* _POOL32A0~*(73) */
16521 { instruction , 0 , 0 , 32,
16522 0xfc0003ff, 0x20000250, &AND_32_ , 0,
16523 0x0 }, /* AND[32] */
16524 { reserved_block , 0 , 0 , 32,
16525 0xfc0003ff, 0x20000258, 0 , 0,
16526 0x0 }, /* _POOL32A0~*(75) */
16527 { reserved_block , 0 , 0 , 32,
16528 0xfc0003ff, 0x20000260, 0 , 0,
16529 0x0 }, /* _POOL32A0~*(76) */
16530 { instruction , 0 , 0 , 32,
16531 0xfc0003ff, 0x20000268, &YIELD , 0,
16532 MT_ }, /* YIELD */
16533 { instruction , 0 , 0 , 32,
16534 0xfc0003ff, 0x20000270, &MTTR , 0,
16535 MT_ }, /* MTTR */
16536 { instruction , 0 , 0 , 32,
16537 0xfc0003ff, 0x20000278, &MTHTR , 0,
16538 MT_ }, /* MTHTR */
16539 { reserved_block , 0 , 0 , 32,
16540 0xfc0003ff, 0x20000280, 0 , 0,
16541 0x0 }, /* _POOL32A0~*(80) */
16542 { reserved_block , 0 , 0 , 32,
16543 0xfc0003ff, 0x20000288, 0 , 0,
16544 0x0 }, /* _POOL32A0~*(81) */
16545 { instruction , 0 , 0 , 32,
16546 0xfc0003ff, 0x20000290, &OR_32_ , 0,
16547 0x0 }, /* OR[32] */
16548 { reserved_block , 0 , 0 , 32,
16549 0xfc0003ff, 0x20000298, 0 , 0,
16550 0x0 }, /* _POOL32A0~*(83) */
16551 { reserved_block , 0 , 0 , 32,
16552 0xfc0003ff, 0x200002a0, 0 , 0,
16553 0x0 }, /* _POOL32A0~*(84) */
16554 { reserved_block , 0 , 0 , 32,
16555 0xfc0003ff, 0x200002a8, 0 , 0,
16556 0x0 }, /* _POOL32A0~*(85) */
16557 { pool , P_MT_VPE , 8 , 32,
16558 0xfc0003ff, 0x200002b0, 0 , 0,
16559 0x0 }, /* P.MT_VPE */
16560 { reserved_block , 0 , 0 , 32,
16561 0xfc0003ff, 0x200002b8, 0 , 0,
16562 0x0 }, /* _POOL32A0~*(87) */
16563 { reserved_block , 0 , 0 , 32,
16564 0xfc0003ff, 0x200002c0, 0 , 0,
16565 0x0 }, /* _POOL32A0~*(88) */
16566 { reserved_block , 0 , 0 , 32,
16567 0xfc0003ff, 0x200002c8, 0 , 0,
16568 0x0 }, /* _POOL32A0~*(89) */
16569 { instruction , 0 , 0 , 32,
16570 0xfc0003ff, 0x200002d0, &NOR , 0,
16571 0x0 }, /* NOR */
16572 { reserved_block , 0 , 0 , 32,
16573 0xfc0003ff, 0x200002d8, 0 , 0,
16574 0x0 }, /* _POOL32A0~*(91) */
16575 { reserved_block , 0 , 0 , 32,
16576 0xfc0003ff, 0x200002e0, 0 , 0,
16577 0x0 }, /* _POOL32A0~*(92) */
16578 { reserved_block , 0 , 0 , 32,
16579 0xfc0003ff, 0x200002e8, 0 , 0,
16580 0x0 }, /* _POOL32A0~*(93) */
16581 { reserved_block , 0 , 0 , 32,
16582 0xfc0003ff, 0x200002f0, 0 , 0,
16583 0x0 }, /* _POOL32A0~*(94) */
16584 { reserved_block , 0 , 0 , 32,
16585 0xfc0003ff, 0x200002f8, 0 , 0,
16586 0x0 }, /* _POOL32A0~*(95) */
16587 { reserved_block , 0 , 0 , 32,
16588 0xfc0003ff, 0x20000300, 0 , 0,
16589 0x0 }, /* _POOL32A0~*(96) */
16590 { reserved_block , 0 , 0 , 32,
16591 0xfc0003ff, 0x20000308, 0 , 0,
16592 0x0 }, /* _POOL32A0~*(97) */
16593 { instruction , 0 , 0 , 32,
16594 0xfc0003ff, 0x20000310, &XOR_32_ , 0,
16595 0x0 }, /* XOR[32] */
16596 { reserved_block , 0 , 0 , 32,
16597 0xfc0003ff, 0x20000318, 0 , 0,
16598 0x0 }, /* _POOL32A0~*(99) */
16599 { reserved_block , 0 , 0 , 32,
16600 0xfc0003ff, 0x20000320, 0 , 0,
16601 0x0 }, /* _POOL32A0~*(100) */
16602 { reserved_block , 0 , 0 , 32,
16603 0xfc0003ff, 0x20000328, 0 , 0,
16604 0x0 }, /* _POOL32A0~*(101) */
16605 { reserved_block , 0 , 0 , 32,
16606 0xfc0003ff, 0x20000330, 0 , 0,
16607 0x0 }, /* _POOL32A0~*(102) */
16608 { reserved_block , 0 , 0 , 32,
16609 0xfc0003ff, 0x20000338, 0 , 0,
16610 0x0 }, /* _POOL32A0~*(103) */
16611 { reserved_block , 0 , 0 , 32,
16612 0xfc0003ff, 0x20000340, 0 , 0,
16613 0x0 }, /* _POOL32A0~*(104) */
16614 { reserved_block , 0 , 0 , 32,
16615 0xfc0003ff, 0x20000348, 0 , 0,
16616 0x0 }, /* _POOL32A0~*(105) */
16617 { instruction , 0 , 0 , 32,
16618 0xfc0003ff, 0x20000350, &SLT , 0,
16619 0x0 }, /* SLT */
16620 { reserved_block , 0 , 0 , 32,
16621 0xfc0003ff, 0x20000358, 0 , 0,
16622 0x0 }, /* _POOL32A0~*(107) */
16623 { reserved_block , 0 , 0 , 32,
16624 0xfc0003ff, 0x20000360, 0 , 0,
16625 0x0 }, /* _POOL32A0~*(108) */
16626 { reserved_block , 0 , 0 , 32,
16627 0xfc0003ff, 0x20000368, 0 , 0,
16628 0x0 }, /* _POOL32A0~*(109) */
16629 { reserved_block , 0 , 0 , 32,
16630 0xfc0003ff, 0x20000370, 0 , 0,
16631 0x0 }, /* _POOL32A0~*(110) */
16632 { reserved_block , 0 , 0 , 32,
16633 0xfc0003ff, 0x20000378, 0 , 0,
16634 0x0 }, /* _POOL32A0~*(111) */
16635 { reserved_block , 0 , 0 , 32,
16636 0xfc0003ff, 0x20000380, 0 , 0,
16637 0x0 }, /* _POOL32A0~*(112) */
16638 { reserved_block , 0 , 0 , 32,
16639 0xfc0003ff, 0x20000388, 0 , 0,
16640 0x0 }, /* _POOL32A0~*(113) */
16641 { pool , P_SLTU , 2 , 32,
16642 0xfc0003ff, 0x20000390, 0 , 0,
16643 0x0 }, /* P.SLTU */
16644 { reserved_block , 0 , 0 , 32,
16645 0xfc0003ff, 0x20000398, 0 , 0,
16646 0x0 }, /* _POOL32A0~*(115) */
16647 { reserved_block , 0 , 0 , 32,
16648 0xfc0003ff, 0x200003a0, 0 , 0,
16649 0x0 }, /* _POOL32A0~*(116) */
16650 { reserved_block , 0 , 0 , 32,
16651 0xfc0003ff, 0x200003a8, 0 , 0,
16652 0x0 }, /* _POOL32A0~*(117) */
16653 { reserved_block , 0 , 0 , 32,
16654 0xfc0003ff, 0x200003b0, 0 , 0,
16655 0x0 }, /* _POOL32A0~*(118) */
16656 { reserved_block , 0 , 0 , 32,
16657 0xfc0003ff, 0x200003b8, 0 , 0,
16658 0x0 }, /* _POOL32A0~*(119) */
16659 { reserved_block , 0 , 0 , 32,
16660 0xfc0003ff, 0x200003c0, 0 , 0,
16661 0x0 }, /* _POOL32A0~*(120) */
16662 { reserved_block , 0 , 0 , 32,
16663 0xfc0003ff, 0x200003c8, 0 , 0,
16664 0x0 }, /* _POOL32A0~*(121) */
16665 { instruction , 0 , 0 , 32,
16666 0xfc0003ff, 0x200003d0, &SOV , 0,
16667 0x0 }, /* SOV */
16668 { reserved_block , 0 , 0 , 32,
16669 0xfc0003ff, 0x200003d8, 0 , 0,
16670 0x0 }, /* _POOL32A0~*(123) */
16671 { reserved_block , 0 , 0 , 32,
16672 0xfc0003ff, 0x200003e0, 0 , 0,
16673 0x0 }, /* _POOL32A0~*(124) */
16674 { reserved_block , 0 , 0 , 32,
16675 0xfc0003ff, 0x200003e8, 0 , 0,
16676 0x0 }, /* _POOL32A0~*(125) */
16677 { reserved_block , 0 , 0 , 32,
16678 0xfc0003ff, 0x200003f0, 0 , 0,
16679 0x0 }, /* _POOL32A0~*(126) */
16680 { reserved_block , 0 , 0 , 32,
16681 0xfc0003ff, 0x200003f8, 0 , 0,
16682 0x0 }, /* _POOL32A0~*(127) */
16683 };
16684
16685
16686 static const Pool ADDQ__S__PH[2] = {
16687 { instruction , 0 , 0 , 32,
16688 0xfc0007ff, 0x2000000d, &ADDQ_PH , 0,
16689 DSP_ }, /* ADDQ.PH */
16690 { instruction , 0 , 0 , 32,
16691 0xfc0007ff, 0x2000040d, &ADDQ_S_PH , 0,
16692 DSP_ }, /* ADDQ_S.PH */
16693 };
16694
16695
16696 static const Pool MUL__S__PH[2] = {
16697 { instruction , 0 , 0 , 32,
16698 0xfc0007ff, 0x2000002d, &MUL_PH , 0,
16699 DSP_ }, /* MUL.PH */
16700 { instruction , 0 , 0 , 32,
16701 0xfc0007ff, 0x2000042d, &MUL_S_PH , 0,
16702 DSP_ }, /* MUL_S.PH */
16703 };
16704
16705
16706 static const Pool ADDQH__R__PH[2] = {
16707 { instruction , 0 , 0 , 32,
16708 0xfc0007ff, 0x2000004d, &ADDQH_PH , 0,
16709 DSP_ }, /* ADDQH.PH */
16710 { instruction , 0 , 0 , 32,
16711 0xfc0007ff, 0x2000044d, &ADDQH_R_PH , 0,
16712 DSP_ }, /* ADDQH_R.PH */
16713 };
16714
16715
16716 static const Pool ADDQH__R__W[2] = {
16717 { instruction , 0 , 0 , 32,
16718 0xfc0007ff, 0x2000008d, &ADDQH_W , 0,
16719 DSP_ }, /* ADDQH.W */
16720 { instruction , 0 , 0 , 32,
16721 0xfc0007ff, 0x2000048d, &ADDQH_R_W , 0,
16722 DSP_ }, /* ADDQH_R.W */
16723 };
16724
16725
16726 static const Pool ADDU__S__QB[2] = {
16727 { instruction , 0 , 0 , 32,
16728 0xfc0007ff, 0x200000cd, &ADDU_QB , 0,
16729 DSP_ }, /* ADDU.QB */
16730 { instruction , 0 , 0 , 32,
16731 0xfc0007ff, 0x200004cd, &ADDU_S_QB , 0,
16732 DSP_ }, /* ADDU_S.QB */
16733 };
16734
16735
16736 static const Pool ADDU__S__PH[2] = {
16737 { instruction , 0 , 0 , 32,
16738 0xfc0007ff, 0x2000010d, &ADDU_PH , 0,
16739 DSP_ }, /* ADDU.PH */
16740 { instruction , 0 , 0 , 32,
16741 0xfc0007ff, 0x2000050d, &ADDU_S_PH , 0,
16742 DSP_ }, /* ADDU_S.PH */
16743 };
16744
16745
16746 static const Pool ADDUH__R__QB[2] = {
16747 { instruction , 0 , 0 , 32,
16748 0xfc0007ff, 0x2000014d, &ADDUH_QB , 0,
16749 DSP_ }, /* ADDUH.QB */
16750 { instruction , 0 , 0 , 32,
16751 0xfc0007ff, 0x2000054d, &ADDUH_R_QB , 0,
16752 DSP_ }, /* ADDUH_R.QB */
16753 };
16754
16755
16756 static const Pool SHRAV__R__PH[2] = {
16757 { instruction , 0 , 0 , 32,
16758 0xfc0007ff, 0x2000018d, &SHRAV_PH , 0,
16759 DSP_ }, /* SHRAV.PH */
16760 { instruction , 0 , 0 , 32,
16761 0xfc0007ff, 0x2000058d, &SHRAV_R_PH , 0,
16762 DSP_ }, /* SHRAV_R.PH */
16763 };
16764
16765
16766 static const Pool SHRAV__R__QB[2] = {
16767 { instruction , 0 , 0 , 32,
16768 0xfc0007ff, 0x200001cd, &SHRAV_QB , 0,
16769 DSP_ }, /* SHRAV.QB */
16770 { instruction , 0 , 0 , 32,
16771 0xfc0007ff, 0x200005cd, &SHRAV_R_QB , 0,
16772 DSP_ }, /* SHRAV_R.QB */
16773 };
16774
16775
16776 static const Pool SUBQ__S__PH[2] = {
16777 { instruction , 0 , 0 , 32,
16778 0xfc0007ff, 0x2000020d, &SUBQ_PH , 0,
16779 DSP_ }, /* SUBQ.PH */
16780 { instruction , 0 , 0 , 32,
16781 0xfc0007ff, 0x2000060d, &SUBQ_S_PH , 0,
16782 DSP_ }, /* SUBQ_S.PH */
16783 };
16784
16785
16786 static const Pool SUBQH__R__PH[2] = {
16787 { instruction , 0 , 0 , 32,
16788 0xfc0007ff, 0x2000024d, &SUBQH_PH , 0,
16789 DSP_ }, /* SUBQH.PH */
16790 { instruction , 0 , 0 , 32,
16791 0xfc0007ff, 0x2000064d, &SUBQH_R_PH , 0,
16792 DSP_ }, /* SUBQH_R.PH */
16793 };
16794
16795
16796 static const Pool SUBQH__R__W[2] = {
16797 { instruction , 0 , 0 , 32,
16798 0xfc0007ff, 0x2000028d, &SUBQH_W , 0,
16799 DSP_ }, /* SUBQH.W */
16800 { instruction , 0 , 0 , 32,
16801 0xfc0007ff, 0x2000068d, &SUBQH_R_W , 0,
16802 DSP_ }, /* SUBQH_R.W */
16803 };
16804
16805
16806 static const Pool SUBU__S__QB[2] = {
16807 { instruction , 0 , 0 , 32,
16808 0xfc0007ff, 0x200002cd, &SUBU_QB , 0,
16809 DSP_ }, /* SUBU.QB */
16810 { instruction , 0 , 0 , 32,
16811 0xfc0007ff, 0x200006cd, &SUBU_S_QB , 0,
16812 DSP_ }, /* SUBU_S.QB */
16813 };
16814
16815
16816 static const Pool SUBU__S__PH[2] = {
16817 { instruction , 0 , 0 , 32,
16818 0xfc0007ff, 0x2000030d, &SUBU_PH , 0,
16819 DSP_ }, /* SUBU.PH */
16820 { instruction , 0 , 0 , 32,
16821 0xfc0007ff, 0x2000070d, &SUBU_S_PH , 0,
16822 DSP_ }, /* SUBU_S.PH */
16823 };
16824
16825
16826 static const Pool SHRA__R__PH[2] = {
16827 { instruction , 0 , 0 , 32,
16828 0xfc0007ff, 0x20000335, &SHRA_PH , 0,
16829 DSP_ }, /* SHRA.PH */
16830 { instruction , 0 , 0 , 32,
16831 0xfc0007ff, 0x20000735, &SHRA_R_PH , 0,
16832 DSP_ }, /* SHRA_R.PH */
16833 };
16834
16835
16836 static const Pool SUBUH__R__QB[2] = {
16837 { instruction , 0 , 0 , 32,
16838 0xfc0007ff, 0x2000034d, &SUBUH_QB , 0,
16839 DSP_ }, /* SUBUH.QB */
16840 { instruction , 0 , 0 , 32,
16841 0xfc0007ff, 0x2000074d, &SUBUH_R_QB , 0,
16842 DSP_ }, /* SUBUH_R.QB */
16843 };
16844
16845
16846 static const Pool SHLLV__S__PH[2] = {
16847 { instruction , 0 , 0 , 32,
16848 0xfc0007ff, 0x2000038d, &SHLLV_PH , 0,
16849 DSP_ }, /* SHLLV.PH */
16850 { instruction , 0 , 0 , 32,
16851 0xfc0007ff, 0x2000078d, &SHLLV_S_PH , 0,
16852 DSP_ }, /* SHLLV_S.PH */
16853 };
16854
16855
16856 static const Pool SHLL__S__PH[4] = {
16857 { instruction , 0 , 0 , 32,
16858 0xfc000fff, 0x200003b5, &SHLL_PH , 0,
16859 DSP_ }, /* SHLL.PH */
16860 { reserved_block , 0 , 0 , 32,
16861 0xfc000fff, 0x200007b5, 0 , 0,
16862 0x0 }, /* SHLL[_S].PH~*(1) */
16863 { instruction , 0 , 0 , 32,
16864 0xfc000fff, 0x20000bb5, &SHLL_S_PH , 0,
16865 DSP_ }, /* SHLL_S.PH */
16866 { reserved_block , 0 , 0 , 32,
16867 0xfc000fff, 0x20000fb5, 0 , 0,
16868 0x0 }, /* SHLL[_S].PH~*(3) */
16869 };
16870
16871
16872 static const Pool PRECR_SRA__R__PH_W[2] = {
16873 { instruction , 0 , 0 , 32,
16874 0xfc0007ff, 0x200003cd, &PRECR_SRA_PH_W , 0,
16875 DSP_ }, /* PRECR_SRA.PH.W */
16876 { instruction , 0 , 0 , 32,
16877 0xfc0007ff, 0x200007cd, &PRECR_SRA_R_PH_W , 0,
16878 DSP_ }, /* PRECR_SRA_R.PH.W */
16879 };
16880
16881
16882 static const Pool _POOL32A5[128] = {
16883 { instruction , 0 , 0 , 32,
16884 0xfc0003ff, 0x20000005, &CMP_EQ_PH , 0,
16885 DSP_ }, /* CMP.EQ.PH */
16886 { pool , ADDQ__S__PH , 2 , 32,
16887 0xfc0003ff, 0x2000000d, 0 , 0,
16888 0x0 }, /* ADDQ[_S].PH */
16889 { reserved_block , 0 , 0 , 32,
16890 0xfc0003ff, 0x20000015, 0 , 0,
16891 0x0 }, /* _POOL32A5~*(2) */
16892 { instruction , 0 , 0 , 32,
16893 0xfc0003ff, 0x2000001d, &SHILO , 0,
16894 DSP_ }, /* SHILO */
16895 { instruction , 0 , 0 , 32,
16896 0xfc0003ff, 0x20000025, &MULEQ_S_W_PHL , 0,
16897 DSP_ }, /* MULEQ_S.W.PHL */
16898 { pool , MUL__S__PH , 2 , 32,
16899 0xfc0003ff, 0x2000002d, 0 , 0,
16900 0x0 }, /* MUL[_S].PH */
16901 { reserved_block , 0 , 0 , 32,
16902 0xfc0003ff, 0x20000035, 0 , 0,
16903 0x0 }, /* _POOL32A5~*(6) */
16904 { instruction , 0 , 0 , 32,
16905 0xfc0003ff, 0x2000003d, &REPL_PH , 0,
16906 DSP_ }, /* REPL.PH */
16907 { instruction , 0 , 0 , 32,
16908 0xfc0003ff, 0x20000045, &CMP_LT_PH , 0,
16909 DSP_ }, /* CMP.LT.PH */
16910 { pool , ADDQH__R__PH , 2 , 32,
16911 0xfc0003ff, 0x2000004d, 0 , 0,
16912 0x0 }, /* ADDQH[_R].PH */
16913 { reserved_block , 0 , 0 , 32,
16914 0xfc0003ff, 0x20000055, 0 , 0,
16915 0x0 }, /* _POOL32A5~*(10) */
16916 { reserved_block , 0 , 0 , 32,
16917 0xfc0003ff, 0x2000005d, 0 , 0,
16918 0x0 }, /* _POOL32A5~*(11) */
16919 { instruction , 0 , 0 , 32,
16920 0xfc0003ff, 0x20000065, &MULEQ_S_W_PHR , 0,
16921 DSP_ }, /* MULEQ_S.W.PHR */
16922 { instruction , 0 , 0 , 32,
16923 0xfc0003ff, 0x2000006d, &PRECR_QB_PH , 0,
16924 DSP_ }, /* PRECR.QB.PH */
16925 { reserved_block , 0 , 0 , 32,
16926 0xfc0003ff, 0x20000075, 0 , 0,
16927 0x0 }, /* _POOL32A5~*(14) */
16928 { reserved_block , 0 , 0 , 32,
16929 0xfc0003ff, 0x2000007d, 0 , 0,
16930 0x0 }, /* _POOL32A5~*(15) */
16931 { instruction , 0 , 0 , 32,
16932 0xfc0003ff, 0x20000085, &CMP_LE_PH , 0,
16933 DSP_ }, /* CMP.LE.PH */
16934 { pool , ADDQH__R__W , 2 , 32,
16935 0xfc0003ff, 0x2000008d, 0 , 0,
16936 0x0 }, /* ADDQH[_R].W */
16937 { instruction , 0 , 0 , 32,
16938 0xfc0003ff, 0x20000095, &MULEU_S_PH_QBL , 0,
16939 DSP_ }, /* MULEU_S.PH.QBL */
16940 { reserved_block , 0 , 0 , 32,
16941 0xfc0003ff, 0x2000009d, 0 , 0,
16942 0x0 }, /* _POOL32A5~*(19) */
16943 { reserved_block , 0 , 0 , 32,
16944 0xfc0003ff, 0x200000a5, 0 , 0,
16945 0x0 }, /* _POOL32A5~*(20) */
16946 { instruction , 0 , 0 , 32,
16947 0xfc0003ff, 0x200000ad, &PRECRQ_QB_PH , 0,
16948 DSP_ }, /* PRECRQ.QB.PH */
16949 { reserved_block , 0 , 0 , 32,
16950 0xfc0003ff, 0x200000b5, 0 , 0,
16951 0x0 }, /* _POOL32A5~*(22) */
16952 { reserved_block , 0 , 0 , 32,
16953 0xfc0003ff, 0x200000bd, 0 , 0,
16954 0x0 }, /* _POOL32A5~*(23) */
16955 { instruction , 0 , 0 , 32,
16956 0xfc0003ff, 0x200000c5, &CMPGU_EQ_QB , 0,
16957 DSP_ }, /* CMPGU.EQ.QB */
16958 { pool , ADDU__S__QB , 2 , 32,
16959 0xfc0003ff, 0x200000cd, 0 , 0,
16960 0x0 }, /* ADDU[_S].QB */
16961 { instruction , 0 , 0 , 32,
16962 0xfc0003ff, 0x200000d5, &MULEU_S_PH_QBR , 0,
16963 DSP_ }, /* MULEU_S.PH.QBR */
16964 { reserved_block , 0 , 0 , 32,
16965 0xfc0003ff, 0x200000dd, 0 , 0,
16966 0x0 }, /* _POOL32A5~*(27) */
16967 { reserved_block , 0 , 0 , 32,
16968 0xfc0003ff, 0x200000e5, 0 , 0,
16969 0x0 }, /* _POOL32A5~*(28) */
16970 { instruction , 0 , 0 , 32,
16971 0xfc0003ff, 0x200000ed, &PRECRQ_PH_W , 0,
16972 DSP_ }, /* PRECRQ.PH.W */
16973 { reserved_block , 0 , 0 , 32,
16974 0xfc0003ff, 0x200000f5, 0 , 0,
16975 0x0 }, /* _POOL32A5~*(30) */
16976 { reserved_block , 0 , 0 , 32,
16977 0xfc0003ff, 0x200000fd, 0 , 0,
16978 0x0 }, /* _POOL32A5~*(31) */
16979 { instruction , 0 , 0 , 32,
16980 0xfc0003ff, 0x20000105, &CMPGU_LT_QB , 0,
16981 DSP_ }, /* CMPGU.LT.QB */
16982 { pool , ADDU__S__PH , 2 , 32,
16983 0xfc0003ff, 0x2000010d, 0 , 0,
16984 0x0 }, /* ADDU[_S].PH */
16985 { instruction , 0 , 0 , 32,
16986 0xfc0003ff, 0x20000115, &MULQ_RS_PH , 0,
16987 DSP_ }, /* MULQ_RS.PH */
16988 { reserved_block , 0 , 0 , 32,
16989 0xfc0003ff, 0x2000011d, 0 , 0,
16990 0x0 }, /* _POOL32A5~*(35) */
16991 { reserved_block , 0 , 0 , 32,
16992 0xfc0003ff, 0x20000125, 0 , 0,
16993 0x0 }, /* _POOL32A5~*(36) */
16994 { instruction , 0 , 0 , 32,
16995 0xfc0003ff, 0x2000012d, &PRECRQ_RS_PH_W , 0,
16996 DSP_ }, /* PRECRQ_RS.PH.W */
16997 { reserved_block , 0 , 0 , 32,
16998 0xfc0003ff, 0x20000135, 0 , 0,
16999 0x0 }, /* _POOL32A5~*(38) */
17000 { reserved_block , 0 , 0 , 32,
17001 0xfc0003ff, 0x2000013d, 0 , 0,
17002 0x0 }, /* _POOL32A5~*(39) */
17003 { instruction , 0 , 0 , 32,
17004 0xfc0003ff, 0x20000145, &CMPGU_LE_QB , 0,
17005 DSP_ }, /* CMPGU.LE.QB */
17006 { pool , ADDUH__R__QB , 2 , 32,
17007 0xfc0003ff, 0x2000014d, 0 , 0,
17008 0x0 }, /* ADDUH[_R].QB */
17009 { instruction , 0 , 0 , 32,
17010 0xfc0003ff, 0x20000155, &MULQ_S_PH , 0,
17011 DSP_ }, /* MULQ_S.PH */
17012 { reserved_block , 0 , 0 , 32,
17013 0xfc0003ff, 0x2000015d, 0 , 0,
17014 0x0 }, /* _POOL32A5~*(43) */
17015 { reserved_block , 0 , 0 , 32,
17016 0xfc0003ff, 0x20000165, 0 , 0,
17017 0x0 }, /* _POOL32A5~*(44) */
17018 { instruction , 0 , 0 , 32,
17019 0xfc0003ff, 0x2000016d, &PRECRQU_S_QB_PH , 0,
17020 DSP_ }, /* PRECRQU_S.QB.PH */
17021 { reserved_block , 0 , 0 , 32,
17022 0xfc0003ff, 0x20000175, 0 , 0,
17023 0x0 }, /* _POOL32A5~*(46) */
17024 { reserved_block , 0 , 0 , 32,
17025 0xfc0003ff, 0x2000017d, 0 , 0,
17026 0x0 }, /* _POOL32A5~*(47) */
17027 { instruction , 0 , 0 , 32,
17028 0xfc0003ff, 0x20000185, &CMPGDU_EQ_QB , 0,
17029 DSP_ }, /* CMPGDU.EQ.QB */
17030 { pool , SHRAV__R__PH , 2 , 32,
17031 0xfc0003ff, 0x2000018d, 0 , 0,
17032 0x0 }, /* SHRAV[_R].PH */
17033 { instruction , 0 , 0 , 32,
17034 0xfc0003ff, 0x20000195, &MULQ_RS_W , 0,
17035 DSP_ }, /* MULQ_RS.W */
17036 { reserved_block , 0 , 0 , 32,
17037 0xfc0003ff, 0x2000019d, 0 , 0,
17038 0x0 }, /* _POOL32A5~*(51) */
17039 { reserved_block , 0 , 0 , 32,
17040 0xfc0003ff, 0x200001a5, 0 , 0,
17041 0x0 }, /* _POOL32A5~*(52) */
17042 { instruction , 0 , 0 , 32,
17043 0xfc0003ff, 0x200001ad, &PACKRL_PH , 0,
17044 DSP_ }, /* PACKRL.PH */
17045 { reserved_block , 0 , 0 , 32,
17046 0xfc0003ff, 0x200001b5, 0 , 0,
17047 0x0 }, /* _POOL32A5~*(54) */
17048 { reserved_block , 0 , 0 , 32,
17049 0xfc0003ff, 0x200001bd, 0 , 0,
17050 0x0 }, /* _POOL32A5~*(55) */
17051 { instruction , 0 , 0 , 32,
17052 0xfc0003ff, 0x200001c5, &CMPGDU_LT_QB , 0,
17053 DSP_ }, /* CMPGDU.LT.QB */
17054 { pool , SHRAV__R__QB , 2 , 32,
17055 0xfc0003ff, 0x200001cd, 0 , 0,
17056 0x0 }, /* SHRAV[_R].QB */
17057 { instruction , 0 , 0 , 32,
17058 0xfc0003ff, 0x200001d5, &MULQ_S_W , 0,
17059 DSP_ }, /* MULQ_S.W */
17060 { reserved_block , 0 , 0 , 32,
17061 0xfc0003ff, 0x200001dd, 0 , 0,
17062 0x0 }, /* _POOL32A5~*(59) */
17063 { reserved_block , 0 , 0 , 32,
17064 0xfc0003ff, 0x200001e5, 0 , 0,
17065 0x0 }, /* _POOL32A5~*(60) */
17066 { instruction , 0 , 0 , 32,
17067 0xfc0003ff, 0x200001ed, &PICK_QB , 0,
17068 DSP_ }, /* PICK.QB */
17069 { reserved_block , 0 , 0 , 32,
17070 0xfc0003ff, 0x200001f5, 0 , 0,
17071 0x0 }, /* _POOL32A5~*(62) */
17072 { reserved_block , 0 , 0 , 32,
17073 0xfc0003ff, 0x200001fd, 0 , 0,
17074 0x0 }, /* _POOL32A5~*(63) */
17075 { instruction , 0 , 0 , 32,
17076 0xfc0003ff, 0x20000205, &CMPGDU_LE_QB , 0,
17077 DSP_ }, /* CMPGDU.LE.QB */
17078 { pool , SUBQ__S__PH , 2 , 32,
17079 0xfc0003ff, 0x2000020d, 0 , 0,
17080 0x0 }, /* SUBQ[_S].PH */
17081 { instruction , 0 , 0 , 32,
17082 0xfc0003ff, 0x20000215, &APPEND , 0,
17083 DSP_ }, /* APPEND */
17084 { reserved_block , 0 , 0 , 32,
17085 0xfc0003ff, 0x2000021d, 0 , 0,
17086 0x0 }, /* _POOL32A5~*(67) */
17087 { reserved_block , 0 , 0 , 32,
17088 0xfc0003ff, 0x20000225, 0 , 0,
17089 0x0 }, /* _POOL32A5~*(68) */
17090 { instruction , 0 , 0 , 32,
17091 0xfc0003ff, 0x2000022d, &PICK_PH , 0,
17092 DSP_ }, /* PICK.PH */
17093 { reserved_block , 0 , 0 , 32,
17094 0xfc0003ff, 0x20000235, 0 , 0,
17095 0x0 }, /* _POOL32A5~*(70) */
17096 { reserved_block , 0 , 0 , 32,
17097 0xfc0003ff, 0x2000023d, 0 , 0,
17098 0x0 }, /* _POOL32A5~*(71) */
17099 { instruction , 0 , 0 , 32,
17100 0xfc0003ff, 0x20000245, &CMPU_EQ_QB , 0,
17101 DSP_ }, /* CMPU.EQ.QB */
17102 { pool , SUBQH__R__PH , 2 , 32,
17103 0xfc0003ff, 0x2000024d, 0 , 0,
17104 0x0 }, /* SUBQH[_R].PH */
17105 { instruction , 0 , 0 , 32,
17106 0xfc0003ff, 0x20000255, &PREPEND , 0,
17107 DSP_ }, /* PREPEND */
17108 { reserved_block , 0 , 0 , 32,
17109 0xfc0003ff, 0x2000025d, 0 , 0,
17110 0x0 }, /* _POOL32A5~*(75) */
17111 { reserved_block , 0 , 0 , 32,
17112 0xfc0003ff, 0x20000265, 0 , 0,
17113 0x0 }, /* _POOL32A5~*(76) */
17114 { reserved_block , 0 , 0 , 32,
17115 0xfc0003ff, 0x2000026d, 0 , 0,
17116 0x0 }, /* _POOL32A5~*(77) */
17117 { reserved_block , 0 , 0 , 32,
17118 0xfc0003ff, 0x20000275, 0 , 0,
17119 0x0 }, /* _POOL32A5~*(78) */
17120 { reserved_block , 0 , 0 , 32,
17121 0xfc0003ff, 0x2000027d, 0 , 0,
17122 0x0 }, /* _POOL32A5~*(79) */
17123 { instruction , 0 , 0 , 32,
17124 0xfc0003ff, 0x20000285, &CMPU_LT_QB , 0,
17125 DSP_ }, /* CMPU.LT.QB */
17126 { pool , SUBQH__R__W , 2 , 32,
17127 0xfc0003ff, 0x2000028d, 0 , 0,
17128 0x0 }, /* SUBQH[_R].W */
17129 { instruction , 0 , 0 , 32,
17130 0xfc0003ff, 0x20000295, &MODSUB , 0,
17131 DSP_ }, /* MODSUB */
17132 { reserved_block , 0 , 0 , 32,
17133 0xfc0003ff, 0x2000029d, 0 , 0,
17134 0x0 }, /* _POOL32A5~*(83) */
17135 { reserved_block , 0 , 0 , 32,
17136 0xfc0003ff, 0x200002a5, 0 , 0,
17137 0x0 }, /* _POOL32A5~*(84) */
17138 { reserved_block , 0 , 0 , 32,
17139 0xfc0003ff, 0x200002ad, 0 , 0,
17140 0x0 }, /* _POOL32A5~*(85) */
17141 { reserved_block , 0 , 0 , 32,
17142 0xfc0003ff, 0x200002b5, 0 , 0,
17143 0x0 }, /* _POOL32A5~*(86) */
17144 { reserved_block , 0 , 0 , 32,
17145 0xfc0003ff, 0x200002bd, 0 , 0,
17146 0x0 }, /* _POOL32A5~*(87) */
17147 { instruction , 0 , 0 , 32,
17148 0xfc0003ff, 0x200002c5, &CMPU_LE_QB , 0,
17149 DSP_ }, /* CMPU.LE.QB */
17150 { pool , SUBU__S__QB , 2 , 32,
17151 0xfc0003ff, 0x200002cd, 0 , 0,
17152 0x0 }, /* SUBU[_S].QB */
17153 { instruction , 0 , 0 , 32,
17154 0xfc0003ff, 0x200002d5, &SHRAV_R_W , 0,
17155 DSP_ }, /* SHRAV_R.W */
17156 { reserved_block , 0 , 0 , 32,
17157 0xfc0003ff, 0x200002dd, 0 , 0,
17158 0x0 }, /* _POOL32A5~*(91) */
17159 { reserved_block , 0 , 0 , 32,
17160 0xfc0003ff, 0x200002e5, 0 , 0,
17161 0x0 }, /* _POOL32A5~*(92) */
17162 { reserved_block , 0 , 0 , 32,
17163 0xfc0003ff, 0x200002ed, 0 , 0,
17164 0x0 }, /* _POOL32A5~*(93) */
17165 { instruction , 0 , 0 , 32,
17166 0xfc0003ff, 0x200002f5, &SHRA_R_W , 0,
17167 DSP_ }, /* SHRA_R.W */
17168 { reserved_block , 0 , 0 , 32,
17169 0xfc0003ff, 0x200002fd, 0 , 0,
17170 0x0 }, /* _POOL32A5~*(95) */
17171 { instruction , 0 , 0 , 32,
17172 0xfc0003ff, 0x20000305, &ADDQ_S_W , 0,
17173 DSP_ }, /* ADDQ_S.W */
17174 { pool , SUBU__S__PH , 2 , 32,
17175 0xfc0003ff, 0x2000030d, 0 , 0,
17176 0x0 }, /* SUBU[_S].PH */
17177 { instruction , 0 , 0 , 32,
17178 0xfc0003ff, 0x20000315, &SHRLV_PH , 0,
17179 DSP_ }, /* SHRLV.PH */
17180 { reserved_block , 0 , 0 , 32,
17181 0xfc0003ff, 0x2000031d, 0 , 0,
17182 0x0 }, /* _POOL32A5~*(99) */
17183 { reserved_block , 0 , 0 , 32,
17184 0xfc0003ff, 0x20000325, 0 , 0,
17185 0x0 }, /* _POOL32A5~*(100) */
17186 { reserved_block , 0 , 0 , 32,
17187 0xfc0003ff, 0x2000032d, 0 , 0,
17188 0x0 }, /* _POOL32A5~*(101) */
17189 { pool , SHRA__R__PH , 2 , 32,
17190 0xfc0003ff, 0x20000335, 0 , 0,
17191 0x0 }, /* SHRA[_R].PH */
17192 { reserved_block , 0 , 0 , 32,
17193 0xfc0003ff, 0x2000033d, 0 , 0,
17194 0x0 }, /* _POOL32A5~*(103) */
17195 { instruction , 0 , 0 , 32,
17196 0xfc0003ff, 0x20000345, &SUBQ_S_W , 0,
17197 DSP_ }, /* SUBQ_S.W */
17198 { pool , SUBUH__R__QB , 2 , 32,
17199 0xfc0003ff, 0x2000034d, 0 , 0,
17200 0x0 }, /* SUBUH[_R].QB */
17201 { instruction , 0 , 0 , 32,
17202 0xfc0003ff, 0x20000355, &SHRLV_QB , 0,
17203 DSP_ }, /* SHRLV.QB */
17204 { reserved_block , 0 , 0 , 32,
17205 0xfc0003ff, 0x2000035d, 0 , 0,
17206 0x0 }, /* _POOL32A5~*(107) */
17207 { reserved_block , 0 , 0 , 32,
17208 0xfc0003ff, 0x20000365, 0 , 0,
17209 0x0 }, /* _POOL32A5~*(108) */
17210 { reserved_block , 0 , 0 , 32,
17211 0xfc0003ff, 0x2000036d, 0 , 0,
17212 0x0 }, /* _POOL32A5~*(109) */
17213 { reserved_block , 0 , 0 , 32,
17214 0xfc0003ff, 0x20000375, 0 , 0,
17215 0x0 }, /* _POOL32A5~*(110) */
17216 { reserved_block , 0 , 0 , 32,
17217 0xfc0003ff, 0x2000037d, 0 , 0,
17218 0x0 }, /* _POOL32A5~*(111) */
17219 { instruction , 0 , 0 , 32,
17220 0xfc0003ff, 0x20000385, &ADDSC , 0,
17221 DSP_ }, /* ADDSC */
17222 { pool , SHLLV__S__PH , 2 , 32,
17223 0xfc0003ff, 0x2000038d, 0 , 0,
17224 0x0 }, /* SHLLV[_S].PH */
17225 { instruction , 0 , 0 , 32,
17226 0xfc0003ff, 0x20000395, &SHLLV_QB , 0,
17227 DSP_ }, /* SHLLV.QB */
17228 { reserved_block , 0 , 0 , 32,
17229 0xfc0003ff, 0x2000039d, 0 , 0,
17230 0x0 }, /* _POOL32A5~*(115) */
17231 { reserved_block , 0 , 0 , 32,
17232 0xfc0003ff, 0x200003a5, 0 , 0,
17233 0x0 }, /* _POOL32A5~*(116) */
17234 { reserved_block , 0 , 0 , 32,
17235 0xfc0003ff, 0x200003ad, 0 , 0,
17236 0x0 }, /* _POOL32A5~*(117) */
17237 { pool , SHLL__S__PH , 4 , 32,
17238 0xfc0003ff, 0x200003b5, 0 , 0,
17239 0x0 }, /* SHLL[_S].PH */
17240 { reserved_block , 0 , 0 , 32,
17241 0xfc0003ff, 0x200003bd, 0 , 0,
17242 0x0 }, /* _POOL32A5~*(119) */
17243 { instruction , 0 , 0 , 32,
17244 0xfc0003ff, 0x200003c5, &ADDWC , 0,
17245 DSP_ }, /* ADDWC */
17246 { pool , PRECR_SRA__R__PH_W , 2 , 32,
17247 0xfc0003ff, 0x200003cd, 0 , 0,
17248 0x0 }, /* PRECR_SRA[_R].PH.W */
17249 { instruction , 0 , 0 , 32,
17250 0xfc0003ff, 0x200003d5, &SHLLV_S_W , 0,
17251 DSP_ }, /* SHLLV_S.W */
17252 { reserved_block , 0 , 0 , 32,
17253 0xfc0003ff, 0x200003dd, 0 , 0,
17254 0x0 }, /* _POOL32A5~*(123) */
17255 { reserved_block , 0 , 0 , 32,
17256 0xfc0003ff, 0x200003e5, 0 , 0,
17257 0x0 }, /* _POOL32A5~*(124) */
17258 { reserved_block , 0 , 0 , 32,
17259 0xfc0003ff, 0x200003ed, 0 , 0,
17260 0x0 }, /* _POOL32A5~*(125) */
17261 { instruction , 0 , 0 , 32,
17262 0xfc0003ff, 0x200003f5, &SHLL_S_W , 0,
17263 DSP_ }, /* SHLL_S.W */
17264 { reserved_block , 0 , 0 , 32,
17265 0xfc0003ff, 0x200003fd, 0 , 0,
17266 0x0 }, /* _POOL32A5~*(127) */
17267 };
17268
17269
17270 static const Pool PP_LSX[16] = {
17271 { instruction , 0 , 0 , 32,
17272 0xfc0007ff, 0x20000007, &LBX , 0,
17273 0x0 }, /* LBX */
17274 { instruction , 0 , 0 , 32,
17275 0xfc0007ff, 0x20000087, &SBX , 0,
17276 XMMS_ }, /* SBX */
17277 { instruction , 0 , 0 , 32,
17278 0xfc0007ff, 0x20000107, &LBUX , 0,
17279 0x0 }, /* LBUX */
17280 { reserved_block , 0 , 0 , 32,
17281 0xfc0007ff, 0x20000187, 0 , 0,
17282 0x0 }, /* PP.LSX~*(3) */
17283 { instruction , 0 , 0 , 32,
17284 0xfc0007ff, 0x20000207, &LHX , 0,
17285 0x0 }, /* LHX */
17286 { instruction , 0 , 0 , 32,
17287 0xfc0007ff, 0x20000287, &SHX , 0,
17288 XMMS_ }, /* SHX */
17289 { instruction , 0 , 0 , 32,
17290 0xfc0007ff, 0x20000307, &LHUX , 0,
17291 0x0 }, /* LHUX */
17292 { instruction , 0 , 0 , 32,
17293 0xfc0007ff, 0x20000387, &LWUX , 0,
17294 MIPS64_ }, /* LWUX */
17295 { instruction , 0 , 0 , 32,
17296 0xfc0007ff, 0x20000407, &LWX , 0,
17297 0x0 }, /* LWX */
17298 { instruction , 0 , 0 , 32,
17299 0xfc0007ff, 0x20000487, &SWX , 0,
17300 XMMS_ }, /* SWX */
17301 { instruction , 0 , 0 , 32,
17302 0xfc0007ff, 0x20000507, &LWC1X , 0,
17303 CP1_ }, /* LWC1X */
17304 { instruction , 0 , 0 , 32,
17305 0xfc0007ff, 0x20000587, &SWC1X , 0,
17306 CP1_ }, /* SWC1X */
17307 { instruction , 0 , 0 , 32,
17308 0xfc0007ff, 0x20000607, &LDX , 0,
17309 MIPS64_ }, /* LDX */
17310 { instruction , 0 , 0 , 32,
17311 0xfc0007ff, 0x20000687, &SDX , 0,
17312 MIPS64_ }, /* SDX */
17313 { instruction , 0 , 0 , 32,
17314 0xfc0007ff, 0x20000707, &LDC1X , 0,
17315 CP1_ }, /* LDC1X */
17316 { instruction , 0 , 0 , 32,
17317 0xfc0007ff, 0x20000787, &SDC1X , 0,
17318 CP1_ }, /* SDC1X */
17319 };
17320
17321
17322 static const Pool PP_LSXS[16] = {
17323 { reserved_block , 0 , 0 , 32,
17324 0xfc0007ff, 0x20000047, 0 , 0,
17325 0x0 }, /* PP.LSXS~*(0) */
17326 { reserved_block , 0 , 0 , 32,
17327 0xfc0007ff, 0x200000c7, 0 , 0,
17328 0x0 }, /* PP.LSXS~*(1) */
17329 { reserved_block , 0 , 0 , 32,
17330 0xfc0007ff, 0x20000147, 0 , 0,
17331 0x0 }, /* PP.LSXS~*(2) */
17332 { reserved_block , 0 , 0 , 32,
17333 0xfc0007ff, 0x200001c7, 0 , 0,
17334 0x0 }, /* PP.LSXS~*(3) */
17335 { instruction , 0 , 0 , 32,
17336 0xfc0007ff, 0x20000247, &LHXS , 0,
17337 0x0 }, /* LHXS */
17338 { instruction , 0 , 0 , 32,
17339 0xfc0007ff, 0x200002c7, &SHXS , 0,
17340 XMMS_ }, /* SHXS */
17341 { instruction , 0 , 0 , 32,
17342 0xfc0007ff, 0x20000347, &LHUXS , 0,
17343 0x0 }, /* LHUXS */
17344 { instruction , 0 , 0 , 32,
17345 0xfc0007ff, 0x200003c7, &LWUXS , 0,
17346 MIPS64_ }, /* LWUXS */
17347 { instruction , 0 , 0 , 32,
17348 0xfc0007ff, 0x20000447, &LWXS_32_ , 0,
17349 0x0 }, /* LWXS[32] */
17350 { instruction , 0 , 0 , 32,
17351 0xfc0007ff, 0x200004c7, &SWXS , 0,
17352 XMMS_ }, /* SWXS */
17353 { instruction , 0 , 0 , 32,
17354 0xfc0007ff, 0x20000547, &LWC1XS , 0,
17355 CP1_ }, /* LWC1XS */
17356 { instruction , 0 , 0 , 32,
17357 0xfc0007ff, 0x200005c7, &SWC1XS , 0,
17358 CP1_ }, /* SWC1XS */
17359 { instruction , 0 , 0 , 32,
17360 0xfc0007ff, 0x20000647, &LDXS , 0,
17361 MIPS64_ }, /* LDXS */
17362 { instruction , 0 , 0 , 32,
17363 0xfc0007ff, 0x200006c7, &SDXS , 0,
17364 MIPS64_ }, /* SDXS */
17365 { instruction , 0 , 0 , 32,
17366 0xfc0007ff, 0x20000747, &LDC1XS , 0,
17367 CP1_ }, /* LDC1XS */
17368 { instruction , 0 , 0 , 32,
17369 0xfc0007ff, 0x200007c7, &SDC1XS , 0,
17370 CP1_ }, /* SDC1XS */
17371 };
17372
17373
17374 static const Pool P_LSX[2] = {
17375 { pool , PP_LSX , 16 , 32,
17376 0xfc00007f, 0x20000007, 0 , 0,
17377 0x0 }, /* PP.LSX */
17378 { pool , PP_LSXS , 16 , 32,
17379 0xfc00007f, 0x20000047, 0 , 0,
17380 0x0 }, /* PP.LSXS */
17381 };
17382
17383
17384 static const Pool POOL32Axf_1_0[4] = {
17385 { instruction , 0 , 0 , 32,
17386 0xfc003fff, 0x2000007f, &MFHI_DSP_ , 0,
17387 DSP_ }, /* MFHI[DSP] */
17388 { instruction , 0 , 0 , 32,
17389 0xfc003fff, 0x2000107f, &MFLO_DSP_ , 0,
17390 DSP_ }, /* MFLO[DSP] */
17391 { instruction , 0 , 0 , 32,
17392 0xfc003fff, 0x2000207f, &MTHI_DSP_ , 0,
17393 DSP_ }, /* MTHI[DSP] */
17394 { instruction , 0 , 0 , 32,
17395 0xfc003fff, 0x2000307f, &MTLO_DSP_ , 0,
17396 DSP_ }, /* MTLO[DSP] */
17397 };
17398
17399
17400 static const Pool POOL32Axf_1_1[4] = {
17401 { instruction , 0 , 0 , 32,
17402 0xfc003fff, 0x2000027f, &MTHLIP , 0,
17403 DSP_ }, /* MTHLIP */
17404 { instruction , 0 , 0 , 32,
17405 0xfc003fff, 0x2000127f, &SHILOV , 0,
17406 DSP_ }, /* SHILOV */
17407 { reserved_block , 0 , 0 , 32,
17408 0xfc003fff, 0x2000227f, 0 , 0,
17409 0x0 }, /* POOL32Axf_1_1~*(2) */
17410 { reserved_block , 0 , 0 , 32,
17411 0xfc003fff, 0x2000327f, 0 , 0,
17412 0x0 }, /* POOL32Axf_1_1~*(3) */
17413 };
17414
17415
17416 static const Pool POOL32Axf_1_3[4] = {
17417 { instruction , 0 , 0 , 32,
17418 0xfc003fff, 0x2000067f, &RDDSP , 0,
17419 DSP_ }, /* RDDSP */
17420 { instruction , 0 , 0 , 32,
17421 0xfc003fff, 0x2000167f, &WRDSP , 0,
17422 DSP_ }, /* WRDSP */
17423 { instruction , 0 , 0 , 32,
17424 0xfc003fff, 0x2000267f, &EXTP , 0,
17425 DSP_ }, /* EXTP */
17426 { instruction , 0 , 0 , 32,
17427 0xfc003fff, 0x2000367f, &EXTPDP , 0,
17428 DSP_ }, /* EXTPDP */
17429 };
17430
17431
17432 static const Pool POOL32Axf_1_4[2] = {
17433 { instruction , 0 , 0 , 32,
17434 0xfc001fff, 0x2000087f, &SHLL_QB , 0,
17435 DSP_ }, /* SHLL.QB */
17436 { instruction , 0 , 0 , 32,
17437 0xfc001fff, 0x2000187f, &SHRL_QB , 0,
17438 DSP_ }, /* SHRL.QB */
17439 };
17440
17441
17442 static const Pool MAQ_S_A__W_PHR[2] = {
17443 { instruction , 0 , 0 , 32,
17444 0xfc003fff, 0x20000a7f, &MAQ_S_W_PHR , 0,
17445 DSP_ }, /* MAQ_S.W.PHR */
17446 { instruction , 0 , 0 , 32,
17447 0xfc003fff, 0x20002a7f, &MAQ_SA_W_PHR , 0,
17448 DSP_ }, /* MAQ_SA.W.PHR */
17449 };
17450
17451
17452 static const Pool MAQ_S_A__W_PHL[2] = {
17453 { instruction , 0 , 0 , 32,
17454 0xfc003fff, 0x20001a7f, &MAQ_S_W_PHL , 0,
17455 DSP_ }, /* MAQ_S.W.PHL */
17456 { instruction , 0 , 0 , 32,
17457 0xfc003fff, 0x20003a7f, &MAQ_SA_W_PHL , 0,
17458 DSP_ }, /* MAQ_SA.W.PHL */
17459 };
17460
17461
17462 static const Pool POOL32Axf_1_5[2] = {
17463 { pool , MAQ_S_A__W_PHR , 2 , 32,
17464 0xfc001fff, 0x20000a7f, 0 , 0,
17465 0x0 }, /* MAQ_S[A].W.PHR */
17466 { pool , MAQ_S_A__W_PHL , 2 , 32,
17467 0xfc001fff, 0x20001a7f, 0 , 0,
17468 0x0 }, /* MAQ_S[A].W.PHL */
17469 };
17470
17471
17472 static const Pool POOL32Axf_1_7[4] = {
17473 { instruction , 0 , 0 , 32,
17474 0xfc003fff, 0x20000e7f, &EXTR_W , 0,
17475 DSP_ }, /* EXTR.W */
17476 { instruction , 0 , 0 , 32,
17477 0xfc003fff, 0x20001e7f, &EXTR_R_W , 0,
17478 DSP_ }, /* EXTR_R.W */
17479 { instruction , 0 , 0 , 32,
17480 0xfc003fff, 0x20002e7f, &EXTR_RS_W , 0,
17481 DSP_ }, /* EXTR_RS.W */
17482 { instruction , 0 , 0 , 32,
17483 0xfc003fff, 0x20003e7f, &EXTR_S_H , 0,
17484 DSP_ }, /* EXTR_S.H */
17485 };
17486
17487
17488 static const Pool POOL32Axf_1[8] = {
17489 { pool , POOL32Axf_1_0 , 4 , 32,
17490 0xfc000fff, 0x2000007f, 0 , 0,
17491 0x0 }, /* POOL32Axf_1_0 */
17492 { pool , POOL32Axf_1_1 , 4 , 32,
17493 0xfc000fff, 0x2000027f, 0 , 0,
17494 0x0 }, /* POOL32Axf_1_1 */
17495 { reserved_block , 0 , 0 , 32,
17496 0xfc000fff, 0x2000047f, 0 , 0,
17497 0x0 }, /* POOL32Axf_1~*(2) */
17498 { pool , POOL32Axf_1_3 , 4 , 32,
17499 0xfc000fff, 0x2000067f, 0 , 0,
17500 0x0 }, /* POOL32Axf_1_3 */
17501 { pool , POOL32Axf_1_4 , 2 , 32,
17502 0xfc000fff, 0x2000087f, 0 , 0,
17503 0x0 }, /* POOL32Axf_1_4 */
17504 { pool , POOL32Axf_1_5 , 2 , 32,
17505 0xfc000fff, 0x20000a7f, 0 , 0,
17506 0x0 }, /* POOL32Axf_1_5 */
17507 { reserved_block , 0 , 0 , 32,
17508 0xfc000fff, 0x20000c7f, 0 , 0,
17509 0x0 }, /* POOL32Axf_1~*(6) */
17510 { pool , POOL32Axf_1_7 , 4 , 32,
17511 0xfc000fff, 0x20000e7f, 0 , 0,
17512 0x0 }, /* POOL32Axf_1_7 */
17513 };
17514
17515
17516 static const Pool POOL32Axf_2_DSP__0_7[8] = {
17517 { instruction , 0 , 0 , 32,
17518 0xfc003fff, 0x200000bf, &DPA_W_PH , 0,
17519 DSP_ }, /* DPA.W.PH */
17520 { instruction , 0 , 0 , 32,
17521 0xfc003fff, 0x200002bf, &DPAQ_S_W_PH , 0,
17522 DSP_ }, /* DPAQ_S.W.PH */
17523 { instruction , 0 , 0 , 32,
17524 0xfc003fff, 0x200004bf, &DPS_W_PH , 0,
17525 DSP_ }, /* DPS.W.PH */
17526 { instruction , 0 , 0 , 32,
17527 0xfc003fff, 0x200006bf, &DPSQ_S_W_PH , 0,
17528 DSP_ }, /* DPSQ_S.W.PH */
17529 { reserved_block , 0 , 0 , 32,
17530 0xfc003fff, 0x200008bf, 0 , 0,
17531 0x0 }, /* POOL32Axf_2(DSP)_0_7~*(4) */
17532 { instruction , 0 , 0 , 32,
17533 0xfc003fff, 0x20000abf, &MADD_DSP_ , 0,
17534 DSP_ }, /* MADD[DSP] */
17535 { instruction , 0 , 0 , 32,
17536 0xfc003fff, 0x20000cbf, &MULT_DSP_ , 0,
17537 DSP_ }, /* MULT[DSP] */
17538 { instruction , 0 , 0 , 32,
17539 0xfc003fff, 0x20000ebf, &EXTRV_W , 0,
17540 DSP_ }, /* EXTRV.W */
17541 };
17542
17543
17544 static const Pool POOL32Axf_2_DSP__8_15[8] = {
17545 { instruction , 0 , 0 , 32,
17546 0xfc003fff, 0x200010bf, &DPAX_W_PH , 0,
17547 DSP_ }, /* DPAX.W.PH */
17548 { instruction , 0 , 0 , 32,
17549 0xfc003fff, 0x200012bf, &DPAQ_SA_L_W , 0,
17550 DSP_ }, /* DPAQ_SA.L.W */
17551 { instruction , 0 , 0 , 32,
17552 0xfc003fff, 0x200014bf, &DPSX_W_PH , 0,
17553 DSP_ }, /* DPSX.W.PH */
17554 { instruction , 0 , 0 , 32,
17555 0xfc003fff, 0x200016bf, &DPSQ_SA_L_W , 0,
17556 DSP_ }, /* DPSQ_SA.L.W */
17557 { reserved_block , 0 , 0 , 32,
17558 0xfc003fff, 0x200018bf, 0 , 0,
17559 0x0 }, /* POOL32Axf_2(DSP)_8_15~*(4) */
17560 { instruction , 0 , 0 , 32,
17561 0xfc003fff, 0x20001abf, &MADDU_DSP_ , 0,
17562 DSP_ }, /* MADDU[DSP] */
17563 { instruction , 0 , 0 , 32,
17564 0xfc003fff, 0x20001cbf, &MULTU_DSP_ , 0,
17565 DSP_ }, /* MULTU[DSP] */
17566 { instruction , 0 , 0 , 32,
17567 0xfc003fff, 0x20001ebf, &EXTRV_R_W , 0,
17568 DSP_ }, /* EXTRV_R.W */
17569 };
17570
17571
17572 static const Pool POOL32Axf_2_DSP__16_23[8] = {
17573 { instruction , 0 , 0 , 32,
17574 0xfc003fff, 0x200020bf, &DPAU_H_QBL , 0,
17575 DSP_ }, /* DPAU.H.QBL */
17576 { instruction , 0 , 0 , 32,
17577 0xfc003fff, 0x200022bf, &DPAQX_S_W_PH , 0,
17578 DSP_ }, /* DPAQX_S.W.PH */
17579 { instruction , 0 , 0 , 32,
17580 0xfc003fff, 0x200024bf, &DPSU_H_QBL , 0,
17581 DSP_ }, /* DPSU.H.QBL */
17582 { instruction , 0 , 0 , 32,
17583 0xfc003fff, 0x200026bf, &DPSQX_S_W_PH , 0,
17584 DSP_ }, /* DPSQX_S.W.PH */
17585 { instruction , 0 , 0 , 32,
17586 0xfc003fff, 0x200028bf, &EXTPV , 0,
17587 DSP_ }, /* EXTPV */
17588 { instruction , 0 , 0 , 32,
17589 0xfc003fff, 0x20002abf, &MSUB_DSP_ , 0,
17590 DSP_ }, /* MSUB[DSP] */
17591 { instruction , 0 , 0 , 32,
17592 0xfc003fff, 0x20002cbf, &MULSA_W_PH , 0,
17593 DSP_ }, /* MULSA.W.PH */
17594 { instruction , 0 , 0 , 32,
17595 0xfc003fff, 0x20002ebf, &EXTRV_RS_W , 0,
17596 DSP_ }, /* EXTRV_RS.W */
17597 };
17598
17599
17600 static const Pool POOL32Axf_2_DSP__24_31[8] = {
17601 { instruction , 0 , 0 , 32,
17602 0xfc003fff, 0x200030bf, &DPAU_H_QBR , 0,
17603 DSP_ }, /* DPAU.H.QBR */
17604 { instruction , 0 , 0 , 32,
17605 0xfc003fff, 0x200032bf, &DPAQX_SA_W_PH , 0,
17606 DSP_ }, /* DPAQX_SA.W.PH */
17607 { instruction , 0 , 0 , 32,
17608 0xfc003fff, 0x200034bf, &DPSU_H_QBR , 0,
17609 DSP_ }, /* DPSU.H.QBR */
17610 { instruction , 0 , 0 , 32,
17611 0xfc003fff, 0x200036bf, &DPSQX_SA_W_PH , 0,
17612 DSP_ }, /* DPSQX_SA.W.PH */
17613 { instruction , 0 , 0 , 32,
17614 0xfc003fff, 0x200038bf, &EXTPDPV , 0,
17615 DSP_ }, /* EXTPDPV */
17616 { instruction , 0 , 0 , 32,
17617 0xfc003fff, 0x20003abf, &MSUBU_DSP_ , 0,
17618 DSP_ }, /* MSUBU[DSP] */
17619 { instruction , 0 , 0 , 32,
17620 0xfc003fff, 0x20003cbf, &MULSAQ_S_W_PH , 0,
17621 DSP_ }, /* MULSAQ_S.W.PH */
17622 { instruction , 0 , 0 , 32,
17623 0xfc003fff, 0x20003ebf, &EXTRV_S_H , 0,
17624 DSP_ }, /* EXTRV_S.H */
17625 };
17626
17627
17628 static const Pool POOL32Axf_2[4] = {
17629 { pool , POOL32Axf_2_DSP__0_7, 8 , 32,
17630 0xfc0031ff, 0x200000bf, 0 , 0,
17631 0x0 }, /* POOL32Axf_2(DSP)_0_7 */
17632 { pool , POOL32Axf_2_DSP__8_15, 8 , 32,
17633 0xfc0031ff, 0x200010bf, 0 , 0,
17634 0x0 }, /* POOL32Axf_2(DSP)_8_15 */
17635 { pool , POOL32Axf_2_DSP__16_23, 8 , 32,
17636 0xfc0031ff, 0x200020bf, 0 , 0,
17637 0x0 }, /* POOL32Axf_2(DSP)_16_23 */
17638 { pool , POOL32Axf_2_DSP__24_31, 8 , 32,
17639 0xfc0031ff, 0x200030bf, 0 , 0,
17640 0x0 }, /* POOL32Axf_2(DSP)_24_31 */
17641 };
17642
17643
17644 static const Pool POOL32Axf_4[128] = {
17645 { instruction , 0 , 0 , 32,
17646 0xfc00ffff, 0x2000013f, &ABSQ_S_QB , 0,
17647 DSP_ }, /* ABSQ_S.QB */
17648 { instruction , 0 , 0 , 32,
17649 0xfc00ffff, 0x2000033f, &REPLV_PH , 0,
17650 DSP_ }, /* REPLV.PH */
17651 { reserved_block , 0 , 0 , 32,
17652 0xfc00ffff, 0x2000053f, 0 , 0,
17653 0x0 }, /* POOL32Axf_4~*(2) */
17654 { reserved_block , 0 , 0 , 32,
17655 0xfc00ffff, 0x2000073f, 0 , 0,
17656 0x0 }, /* POOL32Axf_4~*(3) */
17657 { reserved_block , 0 , 0 , 32,
17658 0xfc00ffff, 0x2000093f, 0 , 0,
17659 0x0 }, /* POOL32Axf_4~*(4) */
17660 { reserved_block , 0 , 0 , 32,
17661 0xfc00ffff, 0x20000b3f, 0 , 0,
17662 0x0 }, /* POOL32Axf_4~*(5) */
17663 { reserved_block , 0 , 0 , 32,
17664 0xfc00ffff, 0x20000d3f, 0 , 0,
17665 0x0 }, /* POOL32Axf_4~*(6) */
17666 { reserved_block , 0 , 0 , 32,
17667 0xfc00ffff, 0x20000f3f, 0 , 0,
17668 0x0 }, /* POOL32Axf_4~*(7) */
17669 { instruction , 0 , 0 , 32,
17670 0xfc00ffff, 0x2000113f, &ABSQ_S_PH , 0,
17671 DSP_ }, /* ABSQ_S.PH */
17672 { instruction , 0 , 0 , 32,
17673 0xfc00ffff, 0x2000133f, &REPLV_QB , 0,
17674 DSP_ }, /* REPLV.QB */
17675 { reserved_block , 0 , 0 , 32,
17676 0xfc00ffff, 0x2000153f, 0 , 0,
17677 0x0 }, /* POOL32Axf_4~*(10) */
17678 { reserved_block , 0 , 0 , 32,
17679 0xfc00ffff, 0x2000173f, 0 , 0,
17680 0x0 }, /* POOL32Axf_4~*(11) */
17681 { reserved_block , 0 , 0 , 32,
17682 0xfc00ffff, 0x2000193f, 0 , 0,
17683 0x0 }, /* POOL32Axf_4~*(12) */
17684 { reserved_block , 0 , 0 , 32,
17685 0xfc00ffff, 0x20001b3f, 0 , 0,
17686 0x0 }, /* POOL32Axf_4~*(13) */
17687 { reserved_block , 0 , 0 , 32,
17688 0xfc00ffff, 0x20001d3f, 0 , 0,
17689 0x0 }, /* POOL32Axf_4~*(14) */
17690 { reserved_block , 0 , 0 , 32,
17691 0xfc00ffff, 0x20001f3f, 0 , 0,
17692 0x0 }, /* POOL32Axf_4~*(15) */
17693 { instruction , 0 , 0 , 32,
17694 0xfc00ffff, 0x2000213f, &ABSQ_S_W , 0,
17695 DSP_ }, /* ABSQ_S.W */
17696 { reserved_block , 0 , 0 , 32,
17697 0xfc00ffff, 0x2000233f, 0 , 0,
17698 0x0 }, /* POOL32Axf_4~*(17) */
17699 { reserved_block , 0 , 0 , 32,
17700 0xfc00ffff, 0x2000253f, 0 , 0,
17701 0x0 }, /* POOL32Axf_4~*(18) */
17702 { reserved_block , 0 , 0 , 32,
17703 0xfc00ffff, 0x2000273f, 0 , 0,
17704 0x0 }, /* POOL32Axf_4~*(19) */
17705 { reserved_block , 0 , 0 , 32,
17706 0xfc00ffff, 0x2000293f, 0 , 0,
17707 0x0 }, /* POOL32Axf_4~*(20) */
17708 { reserved_block , 0 , 0 , 32,
17709 0xfc00ffff, 0x20002b3f, 0 , 0,
17710 0x0 }, /* POOL32Axf_4~*(21) */
17711 { reserved_block , 0 , 0 , 32,
17712 0xfc00ffff, 0x20002d3f, 0 , 0,
17713 0x0 }, /* POOL32Axf_4~*(22) */
17714 { reserved_block , 0 , 0 , 32,
17715 0xfc00ffff, 0x20002f3f, 0 , 0,
17716 0x0 }, /* POOL32Axf_4~*(23) */
17717 { reserved_block , 0 , 0 , 32,
17718 0xfc00ffff, 0x2000313f, 0 , 0,
17719 0x0 }, /* POOL32Axf_4~*(24) */
17720 { reserved_block , 0 , 0 , 32,
17721 0xfc00ffff, 0x2000333f, 0 , 0,
17722 0x0 }, /* POOL32Axf_4~*(25) */
17723 { reserved_block , 0 , 0 , 32,
17724 0xfc00ffff, 0x2000353f, 0 , 0,
17725 0x0 }, /* POOL32Axf_4~*(26) */
17726 { reserved_block , 0 , 0 , 32,
17727 0xfc00ffff, 0x2000373f, 0 , 0,
17728 0x0 }, /* POOL32Axf_4~*(27) */
17729 { reserved_block , 0 , 0 , 32,
17730 0xfc00ffff, 0x2000393f, 0 , 0,
17731 0x0 }, /* POOL32Axf_4~*(28) */
17732 { reserved_block , 0 , 0 , 32,
17733 0xfc00ffff, 0x20003b3f, 0 , 0,
17734 0x0 }, /* POOL32Axf_4~*(29) */
17735 { reserved_block , 0 , 0 , 32,
17736 0xfc00ffff, 0x20003d3f, 0 , 0,
17737 0x0 }, /* POOL32Axf_4~*(30) */
17738 { reserved_block , 0 , 0 , 32,
17739 0xfc00ffff, 0x20003f3f, 0 , 0,
17740 0x0 }, /* POOL32Axf_4~*(31) */
17741 { instruction , 0 , 0 , 32,
17742 0xfc00ffff, 0x2000413f, &INSV , 0,
17743 DSP_ }, /* INSV */
17744 { reserved_block , 0 , 0 , 32,
17745 0xfc00ffff, 0x2000433f, 0 , 0,
17746 0x0 }, /* POOL32Axf_4~*(33) */
17747 { reserved_block , 0 , 0 , 32,
17748 0xfc00ffff, 0x2000453f, 0 , 0,
17749 0x0 }, /* POOL32Axf_4~*(34) */
17750 { reserved_block , 0 , 0 , 32,
17751 0xfc00ffff, 0x2000473f, 0 , 0,
17752 0x0 }, /* POOL32Axf_4~*(35) */
17753 { reserved_block , 0 , 0 , 32,
17754 0xfc00ffff, 0x2000493f, 0 , 0,
17755 0x0 }, /* POOL32Axf_4~*(36) */
17756 { instruction , 0 , 0 , 32,
17757 0xfc00ffff, 0x20004b3f, &CLO , 0,
17758 XMMS_ }, /* CLO */
17759 { instruction , 0 , 0 , 32,
17760 0xfc00ffff, 0x20004d3f, &MFC2 , 0,
17761 CP2_ }, /* MFC2 */
17762 { reserved_block , 0 , 0 , 32,
17763 0xfc00ffff, 0x20004f3f, 0 , 0,
17764 0x0 }, /* POOL32Axf_4~*(39) */
17765 { instruction , 0 , 0 , 32,
17766 0xfc00ffff, 0x2000513f, &PRECEQ_W_PHL , 0,
17767 DSP_ }, /* PRECEQ.W.PHL */
17768 { reserved_block , 0 , 0 , 32,
17769 0xfc00ffff, 0x2000533f, 0 , 0,
17770 0x0 }, /* POOL32Axf_4~*(41) */
17771 { reserved_block , 0 , 0 , 32,
17772 0xfc00ffff, 0x2000553f, 0 , 0,
17773 0x0 }, /* POOL32Axf_4~*(42) */
17774 { reserved_block , 0 , 0 , 32,
17775 0xfc00ffff, 0x2000573f, 0 , 0,
17776 0x0 }, /* POOL32Axf_4~*(43) */
17777 { reserved_block , 0 , 0 , 32,
17778 0xfc00ffff, 0x2000593f, 0 , 0,
17779 0x0 }, /* POOL32Axf_4~*(44) */
17780 { instruction , 0 , 0 , 32,
17781 0xfc00ffff, 0x20005b3f, &CLZ , 0,
17782 XMMS_ }, /* CLZ */
17783 { instruction , 0 , 0 , 32,
17784 0xfc00ffff, 0x20005d3f, &MTC2 , 0,
17785 CP2_ }, /* MTC2 */
17786 { reserved_block , 0 , 0 , 32,
17787 0xfc00ffff, 0x20005f3f, 0 , 0,
17788 0x0 }, /* POOL32Axf_4~*(47) */
17789 { instruction , 0 , 0 , 32,
17790 0xfc00ffff, 0x2000613f, &PRECEQ_W_PHR , 0,
17791 DSP_ }, /* PRECEQ.W.PHR */
17792 { reserved_block , 0 , 0 , 32,
17793 0xfc00ffff, 0x2000633f, 0 , 0,
17794 0x0 }, /* POOL32Axf_4~*(49) */
17795 { reserved_block , 0 , 0 , 32,
17796 0xfc00ffff, 0x2000653f, 0 , 0,
17797 0x0 }, /* POOL32Axf_4~*(50) */
17798 { reserved_block , 0 , 0 , 32,
17799 0xfc00ffff, 0x2000673f, 0 , 0,
17800 0x0 }, /* POOL32Axf_4~*(51) */
17801 { reserved_block , 0 , 0 , 32,
17802 0xfc00ffff, 0x2000693f, 0 , 0,
17803 0x0 }, /* POOL32Axf_4~*(52) */
17804 { reserved_block , 0 , 0 , 32,
17805 0xfc00ffff, 0x20006b3f, 0 , 0,
17806 0x0 }, /* POOL32Axf_4~*(53) */
17807 { instruction , 0 , 0 , 32,
17808 0xfc00ffff, 0x20006d3f, &DMFC2 , 0,
17809 CP2_ }, /* DMFC2 */
17810 { reserved_block , 0 , 0 , 32,
17811 0xfc00ffff, 0x20006f3f, 0 , 0,
17812 0x0 }, /* POOL32Axf_4~*(55) */
17813 { instruction , 0 , 0 , 32,
17814 0xfc00ffff, 0x2000713f, &PRECEQU_PH_QBL , 0,
17815 DSP_ }, /* PRECEQU.PH.QBL */
17816 { instruction , 0 , 0 , 32,
17817 0xfc00ffff, 0x2000733f, &PRECEQU_PH_QBLA , 0,
17818 DSP_ }, /* PRECEQU.PH.QBLA */
17819 { reserved_block , 0 , 0 , 32,
17820 0xfc00ffff, 0x2000753f, 0 , 0,
17821 0x0 }, /* POOL32Axf_4~*(58) */
17822 { reserved_block , 0 , 0 , 32,
17823 0xfc00ffff, 0x2000773f, 0 , 0,
17824 0x0 }, /* POOL32Axf_4~*(59) */
17825 { reserved_block , 0 , 0 , 32,
17826 0xfc00ffff, 0x2000793f, 0 , 0,
17827 0x0 }, /* POOL32Axf_4~*(60) */
17828 { reserved_block , 0 , 0 , 32,
17829 0xfc00ffff, 0x20007b3f, 0 , 0,
17830 0x0 }, /* POOL32Axf_4~*(61) */
17831 { instruction , 0 , 0 , 32,
17832 0xfc00ffff, 0x20007d3f, &DMTC2 , 0,
17833 CP2_ }, /* DMTC2 */
17834 { reserved_block , 0 , 0 , 32,
17835 0xfc00ffff, 0x20007f3f, 0 , 0,
17836 0x0 }, /* POOL32Axf_4~*(63) */
17837 { reserved_block , 0 , 0 , 32,
17838 0xfc00ffff, 0x2000813f, 0 , 0,
17839 0x0 }, /* POOL32Axf_4~*(64) */
17840 { reserved_block , 0 , 0 , 32,
17841 0xfc00ffff, 0x2000833f, 0 , 0,
17842 0x0 }, /* POOL32Axf_4~*(65) */
17843 { reserved_block , 0 , 0 , 32,
17844 0xfc00ffff, 0x2000853f, 0 , 0,
17845 0x0 }, /* POOL32Axf_4~*(66) */
17846 { reserved_block , 0 , 0 , 32,
17847 0xfc00ffff, 0x2000873f, 0 , 0,
17848 0x0 }, /* POOL32Axf_4~*(67) */
17849 { reserved_block , 0 , 0 , 32,
17850 0xfc00ffff, 0x2000893f, 0 , 0,
17851 0x0 }, /* POOL32Axf_4~*(68) */
17852 { reserved_block , 0 , 0 , 32,
17853 0xfc00ffff, 0x20008b3f, 0 , 0,
17854 0x0 }, /* POOL32Axf_4~*(69) */
17855 { instruction , 0 , 0 , 32,
17856 0xfc00ffff, 0x20008d3f, &MFHC2 , 0,
17857 CP2_ }, /* MFHC2 */
17858 { reserved_block , 0 , 0 , 32,
17859 0xfc00ffff, 0x20008f3f, 0 , 0,
17860 0x0 }, /* POOL32Axf_4~*(71) */
17861 { instruction , 0 , 0 , 32,
17862 0xfc00ffff, 0x2000913f, &PRECEQU_PH_QBR , 0,
17863 DSP_ }, /* PRECEQU.PH.QBR */
17864 { instruction , 0 , 0 , 32,
17865 0xfc00ffff, 0x2000933f, &PRECEQU_PH_QBRA , 0,
17866 DSP_ }, /* PRECEQU.PH.QBRA */
17867 { reserved_block , 0 , 0 , 32,
17868 0xfc00ffff, 0x2000953f, 0 , 0,
17869 0x0 }, /* POOL32Axf_4~*(74) */
17870 { reserved_block , 0 , 0 , 32,
17871 0xfc00ffff, 0x2000973f, 0 , 0,
17872 0x0 }, /* POOL32Axf_4~*(75) */
17873 { reserved_block , 0 , 0 , 32,
17874 0xfc00ffff, 0x2000993f, 0 , 0,
17875 0x0 }, /* POOL32Axf_4~*(76) */
17876 { reserved_block , 0 , 0 , 32,
17877 0xfc00ffff, 0x20009b3f, 0 , 0,
17878 0x0 }, /* POOL32Axf_4~*(77) */
17879 { instruction , 0 , 0 , 32,
17880 0xfc00ffff, 0x20009d3f, &MTHC2 , 0,
17881 CP2_ }, /* MTHC2 */
17882 { reserved_block , 0 , 0 , 32,
17883 0xfc00ffff, 0x20009f3f, 0 , 0,
17884 0x0 }, /* POOL32Axf_4~*(79) */
17885 { reserved_block , 0 , 0 , 32,
17886 0xfc00ffff, 0x2000a13f, 0 , 0,
17887 0x0 }, /* POOL32Axf_4~*(80) */
17888 { reserved_block , 0 , 0 , 32,
17889 0xfc00ffff, 0x2000a33f, 0 , 0,
17890 0x0 }, /* POOL32Axf_4~*(81) */
17891 { reserved_block , 0 , 0 , 32,
17892 0xfc00ffff, 0x2000a53f, 0 , 0,
17893 0x0 }, /* POOL32Axf_4~*(82) */
17894 { reserved_block , 0 , 0 , 32,
17895 0xfc00ffff, 0x2000a73f, 0 , 0,
17896 0x0 }, /* POOL32Axf_4~*(83) */
17897 { reserved_block , 0 , 0 , 32,
17898 0xfc00ffff, 0x2000a93f, 0 , 0,
17899 0x0 }, /* POOL32Axf_4~*(84) */
17900 { reserved_block , 0 , 0 , 32,
17901 0xfc00ffff, 0x2000ab3f, 0 , 0,
17902 0x0 }, /* POOL32Axf_4~*(85) */
17903 { reserved_block , 0 , 0 , 32,
17904 0xfc00ffff, 0x2000ad3f, 0 , 0,
17905 0x0 }, /* POOL32Axf_4~*(86) */
17906 { reserved_block , 0 , 0 , 32,
17907 0xfc00ffff, 0x2000af3f, 0 , 0,
17908 0x0 }, /* POOL32Axf_4~*(87) */
17909 { instruction , 0 , 0 , 32,
17910 0xfc00ffff, 0x2000b13f, &PRECEU_PH_QBL , 0,
17911 DSP_ }, /* PRECEU.PH.QBL */
17912 { instruction , 0 , 0 , 32,
17913 0xfc00ffff, 0x2000b33f, &PRECEU_PH_QBLA , 0,
17914 DSP_ }, /* PRECEU.PH.QBLA */
17915 { reserved_block , 0 , 0 , 32,
17916 0xfc00ffff, 0x2000b53f, 0 , 0,
17917 0x0 }, /* POOL32Axf_4~*(90) */
17918 { reserved_block , 0 , 0 , 32,
17919 0xfc00ffff, 0x2000b73f, 0 , 0,
17920 0x0 }, /* POOL32Axf_4~*(91) */
17921 { reserved_block , 0 , 0 , 32,
17922 0xfc00ffff, 0x2000b93f, 0 , 0,
17923 0x0 }, /* POOL32Axf_4~*(92) */
17924 { reserved_block , 0 , 0 , 32,
17925 0xfc00ffff, 0x2000bb3f, 0 , 0,
17926 0x0 }, /* POOL32Axf_4~*(93) */
17927 { reserved_block , 0 , 0 , 32,
17928 0xfc00ffff, 0x2000bd3f, 0 , 0,
17929 0x0 }, /* POOL32Axf_4~*(94) */
17930 { reserved_block , 0 , 0 , 32,
17931 0xfc00ffff, 0x2000bf3f, 0 , 0,
17932 0x0 }, /* POOL32Axf_4~*(95) */
17933 { reserved_block , 0 , 0 , 32,
17934 0xfc00ffff, 0x2000c13f, 0 , 0,
17935 0x0 }, /* POOL32Axf_4~*(96) */
17936 { reserved_block , 0 , 0 , 32,
17937 0xfc00ffff, 0x2000c33f, 0 , 0,
17938 0x0 }, /* POOL32Axf_4~*(97) */
17939 { reserved_block , 0 , 0 , 32,
17940 0xfc00ffff, 0x2000c53f, 0 , 0,
17941 0x0 }, /* POOL32Axf_4~*(98) */
17942 { reserved_block , 0 , 0 , 32,
17943 0xfc00ffff, 0x2000c73f, 0 , 0,
17944 0x0 }, /* POOL32Axf_4~*(99) */
17945 { reserved_block , 0 , 0 , 32,
17946 0xfc00ffff, 0x2000c93f, 0 , 0,
17947 0x0 }, /* POOL32Axf_4~*(100) */
17948 { reserved_block , 0 , 0 , 32,
17949 0xfc00ffff, 0x2000cb3f, 0 , 0,
17950 0x0 }, /* POOL32Axf_4~*(101) */
17951 { instruction , 0 , 0 , 32,
17952 0xfc00ffff, 0x2000cd3f, &CFC2 , 0,
17953 CP2_ }, /* CFC2 */
17954 { reserved_block , 0 , 0 , 32,
17955 0xfc00ffff, 0x2000cf3f, 0 , 0,
17956 0x0 }, /* POOL32Axf_4~*(103) */
17957 { instruction , 0 , 0 , 32,
17958 0xfc00ffff, 0x2000d13f, &PRECEU_PH_QBR , 0,
17959 DSP_ }, /* PRECEU.PH.QBR */
17960 { instruction , 0 , 0 , 32,
17961 0xfc00ffff, 0x2000d33f, &PRECEU_PH_QBRA , 0,
17962 DSP_ }, /* PRECEU.PH.QBRA */
17963 { reserved_block , 0 , 0 , 32,
17964 0xfc00ffff, 0x2000d53f, 0 , 0,
17965 0x0 }, /* POOL32Axf_4~*(106) */
17966 { reserved_block , 0 , 0 , 32,
17967 0xfc00ffff, 0x2000d73f, 0 , 0,
17968 0x0 }, /* POOL32Axf_4~*(107) */
17969 { reserved_block , 0 , 0 , 32,
17970 0xfc00ffff, 0x2000d93f, 0 , 0,
17971 0x0 }, /* POOL32Axf_4~*(108) */
17972 { reserved_block , 0 , 0 , 32,
17973 0xfc00ffff, 0x2000db3f, 0 , 0,
17974 0x0 }, /* POOL32Axf_4~*(109) */
17975 { instruction , 0 , 0 , 32,
17976 0xfc00ffff, 0x2000dd3f, &CTC2 , 0,
17977 CP2_ }, /* CTC2 */
17978 { reserved_block , 0 , 0 , 32,
17979 0xfc00ffff, 0x2000df3f, 0 , 0,
17980 0x0 }, /* POOL32Axf_4~*(111) */
17981 { reserved_block , 0 , 0 , 32,
17982 0xfc00ffff, 0x2000e13f, 0 , 0,
17983 0x0 }, /* POOL32Axf_4~*(112) */
17984 { reserved_block , 0 , 0 , 32,
17985 0xfc00ffff, 0x2000e33f, 0 , 0,
17986 0x0 }, /* POOL32Axf_4~*(113) */
17987 { reserved_block , 0 , 0 , 32,
17988 0xfc00ffff, 0x2000e53f, 0 , 0,
17989 0x0 }, /* POOL32Axf_4~*(114) */
17990 { reserved_block , 0 , 0 , 32,
17991 0xfc00ffff, 0x2000e73f, 0 , 0,
17992 0x0 }, /* POOL32Axf_4~*(115) */
17993 { reserved_block , 0 , 0 , 32,
17994 0xfc00ffff, 0x2000e93f, 0 , 0,
17995 0x0 }, /* POOL32Axf_4~*(116) */
17996 { reserved_block , 0 , 0 , 32,
17997 0xfc00ffff, 0x2000eb3f, 0 , 0,
17998 0x0 }, /* POOL32Axf_4~*(117) */
17999 { reserved_block , 0 , 0 , 32,
18000 0xfc00ffff, 0x2000ed3f, 0 , 0,
18001 0x0 }, /* POOL32Axf_4~*(118) */
18002 { reserved_block , 0 , 0 , 32,
18003 0xfc00ffff, 0x2000ef3f, 0 , 0,
18004 0x0 }, /* POOL32Axf_4~*(119) */
18005 { instruction , 0 , 0 , 32,
18006 0xfc00ffff, 0x2000f13f, &RADDU_W_QB , 0,
18007 DSP_ }, /* RADDU.W.QB */
18008 { reserved_block , 0 , 0 , 32,
18009 0xfc00ffff, 0x2000f33f, 0 , 0,
18010 0x0 }, /* POOL32Axf_4~*(121) */
18011 { reserved_block , 0 , 0 , 32,
18012 0xfc00ffff, 0x2000f53f, 0 , 0,
18013 0x0 }, /* POOL32Axf_4~*(122) */
18014 { reserved_block , 0 , 0 , 32,
18015 0xfc00ffff, 0x2000f73f, 0 , 0,
18016 0x0 }, /* POOL32Axf_4~*(123) */
18017 { reserved_block , 0 , 0 , 32,
18018 0xfc00ffff, 0x2000f93f, 0 , 0,
18019 0x0 }, /* POOL32Axf_4~*(124) */
18020 { reserved_block , 0 , 0 , 32,
18021 0xfc00ffff, 0x2000fb3f, 0 , 0,
18022 0x0 }, /* POOL32Axf_4~*(125) */
18023 { reserved_block , 0 , 0 , 32,
18024 0xfc00ffff, 0x2000fd3f, 0 , 0,
18025 0x0 }, /* POOL32Axf_4~*(126) */
18026 { reserved_block , 0 , 0 , 32,
18027 0xfc00ffff, 0x2000ff3f, 0 , 0,
18028 0x0 }, /* POOL32Axf_4~*(127) */
18029 };
18030
18031
18032 static const Pool POOL32Axf_5_group0[32] = {
18033 { instruction , 0 , 0 , 32,
18034 0xfc00ffff, 0x2000017f, &TLBGP , 0,
18035 CP0_ | VZ_ | TLB_ }, /* TLBGP */
18036 { instruction , 0 , 0 , 32,
18037 0xfc00ffff, 0x2000037f, &TLBP , 0,
18038 CP0_ | TLB_ }, /* TLBP */
18039 { instruction , 0 , 0 , 32,
18040 0xfc00ffff, 0x2000057f, &TLBGINV , 0,
18041 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINV */
18042 { instruction , 0 , 0 , 32,
18043 0xfc00ffff, 0x2000077f, &TLBINV , 0,
18044 CP0_ | TLB_ | TLBINV_}, /* TLBINV */
18045 { reserved_block , 0 , 0 , 32,
18046 0xfc00ffff, 0x2000097f, 0 , 0,
18047 0x0 }, /* POOL32Axf_5_group0~*(4) */
18048 { reserved_block , 0 , 0 , 32,
18049 0xfc00ffff, 0x20000b7f, 0 , 0,
18050 0x0 }, /* POOL32Axf_5_group0~*(5) */
18051 { reserved_block , 0 , 0 , 32,
18052 0xfc00ffff, 0x20000d7f, 0 , 0,
18053 0x0 }, /* POOL32Axf_5_group0~*(6) */
18054 { reserved_block , 0 , 0 , 32,
18055 0xfc00ffff, 0x20000f7f, 0 , 0,
18056 0x0 }, /* POOL32Axf_5_group0~*(7) */
18057 { instruction , 0 , 0 , 32,
18058 0xfc00ffff, 0x2000117f, &TLBGR , 0,
18059 CP0_ | VZ_ | TLB_ }, /* TLBGR */
18060 { instruction , 0 , 0 , 32,
18061 0xfc00ffff, 0x2000137f, &TLBR , 0,
18062 CP0_ | TLB_ }, /* TLBR */
18063 { instruction , 0 , 0 , 32,
18064 0xfc00ffff, 0x2000157f, &TLBGINVF , 0,
18065 CP0_ | VZ_ | TLB_ | TLBINV_}, /* TLBGINVF */
18066 { instruction , 0 , 0 , 32,
18067 0xfc00ffff, 0x2000177f, &TLBINVF , 0,
18068 CP0_ | TLB_ | TLBINV_}, /* TLBINVF */
18069 { reserved_block , 0 , 0 , 32,
18070 0xfc00ffff, 0x2000197f, 0 , 0,
18071 0x0 }, /* POOL32Axf_5_group0~*(12) */
18072 { reserved_block , 0 , 0 , 32,
18073 0xfc00ffff, 0x20001b7f, 0 , 0,
18074 0x0 }, /* POOL32Axf_5_group0~*(13) */
18075 { reserved_block , 0 , 0 , 32,
18076 0xfc00ffff, 0x20001d7f, 0 , 0,
18077 0x0 }, /* POOL32Axf_5_group0~*(14) */
18078 { reserved_block , 0 , 0 , 32,
18079 0xfc00ffff, 0x20001f7f, 0 , 0,
18080 0x0 }, /* POOL32Axf_5_group0~*(15) */
18081 { instruction , 0 , 0 , 32,
18082 0xfc00ffff, 0x2000217f, &TLBGWI , 0,
18083 CP0_ | VZ_ | TLB_ }, /* TLBGWI */
18084 { instruction , 0 , 0 , 32,
18085 0xfc00ffff, 0x2000237f, &TLBWI , 0,
18086 CP0_ | TLB_ }, /* TLBWI */
18087 { reserved_block , 0 , 0 , 32,
18088 0xfc00ffff, 0x2000257f, 0 , 0,
18089 0x0 }, /* POOL32Axf_5_group0~*(18) */
18090 { reserved_block , 0 , 0 , 32,
18091 0xfc00ffff, 0x2000277f, 0 , 0,
18092 0x0 }, /* POOL32Axf_5_group0~*(19) */
18093 { reserved_block , 0 , 0 , 32,
18094 0xfc00ffff, 0x2000297f, 0 , 0,
18095 0x0 }, /* POOL32Axf_5_group0~*(20) */
18096 { reserved_block , 0 , 0 , 32,
18097 0xfc00ffff, 0x20002b7f, 0 , 0,
18098 0x0 }, /* POOL32Axf_5_group0~*(21) */
18099 { reserved_block , 0 , 0 , 32,
18100 0xfc00ffff, 0x20002d7f, 0 , 0,
18101 0x0 }, /* POOL32Axf_5_group0~*(22) */
18102 { reserved_block , 0 , 0 , 32,
18103 0xfc00ffff, 0x20002f7f, 0 , 0,
18104 0x0 }, /* POOL32Axf_5_group0~*(23) */
18105 { instruction , 0 , 0 , 32,
18106 0xfc00ffff, 0x2000317f, &TLBGWR , 0,
18107 CP0_ | VZ_ | TLB_ }, /* TLBGWR */
18108 { instruction , 0 , 0 , 32,
18109 0xfc00ffff, 0x2000337f, &TLBWR , 0,
18110 CP0_ | TLB_ }, /* TLBWR */
18111 { reserved_block , 0 , 0 , 32,
18112 0xfc00ffff, 0x2000357f, 0 , 0,
18113 0x0 }, /* POOL32Axf_5_group0~*(26) */
18114 { reserved_block , 0 , 0 , 32,
18115 0xfc00ffff, 0x2000377f, 0 , 0,
18116 0x0 }, /* POOL32Axf_5_group0~*(27) */
18117 { reserved_block , 0 , 0 , 32,
18118 0xfc00ffff, 0x2000397f, 0 , 0,
18119 0x0 }, /* POOL32Axf_5_group0~*(28) */
18120 { reserved_block , 0 , 0 , 32,
18121 0xfc00ffff, 0x20003b7f, 0 , 0,
18122 0x0 }, /* POOL32Axf_5_group0~*(29) */
18123 { reserved_block , 0 , 0 , 32,
18124 0xfc00ffff, 0x20003d7f, 0 , 0,
18125 0x0 }, /* POOL32Axf_5_group0~*(30) */
18126 { reserved_block , 0 , 0 , 32,
18127 0xfc00ffff, 0x20003f7f, 0 , 0,
18128 0x0 }, /* POOL32Axf_5_group0~*(31) */
18129 };
18130
18131
18132 static const Pool POOL32Axf_5_group1[32] = {
18133 { reserved_block , 0 , 0 , 32,
18134 0xfc00ffff, 0x2000417f, 0 , 0,
18135 0x0 }, /* POOL32Axf_5_group1~*(0) */
18136 { reserved_block , 0 , 0 , 32,
18137 0xfc00ffff, 0x2000437f, 0 , 0,
18138 0x0 }, /* POOL32Axf_5_group1~*(1) */
18139 { reserved_block , 0 , 0 , 32,
18140 0xfc00ffff, 0x2000457f, 0 , 0,
18141 0x0 }, /* POOL32Axf_5_group1~*(2) */
18142 { instruction , 0 , 0 , 32,
18143 0xfc00ffff, 0x2000477f, &DI , 0,
18144 0x0 }, /* DI */
18145 { reserved_block , 0 , 0 , 32,
18146 0xfc00ffff, 0x2000497f, 0 , 0,
18147 0x0 }, /* POOL32Axf_5_group1~*(4) */
18148 { reserved_block , 0 , 0 , 32,
18149 0xfc00ffff, 0x20004b7f, 0 , 0,
18150 0x0 }, /* POOL32Axf_5_group1~*(5) */
18151 { reserved_block , 0 , 0 , 32,
18152 0xfc00ffff, 0x20004d7f, 0 , 0,
18153 0x0 }, /* POOL32Axf_5_group1~*(6) */
18154 { reserved_block , 0 , 0 , 32,
18155 0xfc00ffff, 0x20004f7f, 0 , 0,
18156 0x0 }, /* POOL32Axf_5_group1~*(7) */
18157 { reserved_block , 0 , 0 , 32,
18158 0xfc00ffff, 0x2000517f, 0 , 0,
18159 0x0 }, /* POOL32Axf_5_group1~*(8) */
18160 { reserved_block , 0 , 0 , 32,
18161 0xfc00ffff, 0x2000537f, 0 , 0,
18162 0x0 }, /* POOL32Axf_5_group1~*(9) */
18163 { reserved_block , 0 , 0 , 32,
18164 0xfc00ffff, 0x2000557f, 0 , 0,
18165 0x0 }, /* POOL32Axf_5_group1~*(10) */
18166 { instruction , 0 , 0 , 32,
18167 0xfc00ffff, 0x2000577f, &EI , 0,
18168 0x0 }, /* EI */
18169 { reserved_block , 0 , 0 , 32,
18170 0xfc00ffff, 0x2000597f, 0 , 0,
18171 0x0 }, /* POOL32Axf_5_group1~*(12) */
18172 { reserved_block , 0 , 0 , 32,
18173 0xfc00ffff, 0x20005b7f, 0 , 0,
18174 0x0 }, /* POOL32Axf_5_group1~*(13) */
18175 { reserved_block , 0 , 0 , 32,
18176 0xfc00ffff, 0x20005d7f, 0 , 0,
18177 0x0 }, /* POOL32Axf_5_group1~*(14) */
18178 { reserved_block , 0 , 0 , 32,
18179 0xfc00ffff, 0x20005f7f, 0 , 0,
18180 0x0 }, /* POOL32Axf_5_group1~*(15) */
18181 { reserved_block , 0 , 0 , 32,
18182 0xfc00ffff, 0x2000617f, 0 , 0,
18183 0x0 }, /* POOL32Axf_5_group1~*(16) */
18184 { reserved_block , 0 , 0 , 32,
18185 0xfc00ffff, 0x2000637f, 0 , 0,
18186 0x0 }, /* POOL32Axf_5_group1~*(17) */
18187 { reserved_block , 0 , 0 , 32,
18188 0xfc00ffff, 0x2000657f, 0 , 0,
18189 0x0 }, /* POOL32Axf_5_group1~*(18) */
18190 { reserved_block , 0 , 0 , 32,
18191 0xfc00ffff, 0x2000677f, 0 , 0,
18192 0x0 }, /* POOL32Axf_5_group1~*(19) */
18193 { reserved_block , 0 , 0 , 32,
18194 0xfc00ffff, 0x2000697f, 0 , 0,
18195 0x0 }, /* POOL32Axf_5_group1~*(20) */
18196 { reserved_block , 0 , 0 , 32,
18197 0xfc00ffff, 0x20006b7f, 0 , 0,
18198 0x0 }, /* POOL32Axf_5_group1~*(21) */
18199 { reserved_block , 0 , 0 , 32,
18200 0xfc00ffff, 0x20006d7f, 0 , 0,
18201 0x0 }, /* POOL32Axf_5_group1~*(22) */
18202 { reserved_block , 0 , 0 , 32,
18203 0xfc00ffff, 0x20006f7f, 0 , 0,
18204 0x0 }, /* POOL32Axf_5_group1~*(23) */
18205 { reserved_block , 0 , 0 , 32,
18206 0xfc00ffff, 0x2000717f, 0 , 0,
18207 0x0 }, /* POOL32Axf_5_group1~*(24) */
18208 { reserved_block , 0 , 0 , 32,
18209 0xfc00ffff, 0x2000737f, 0 , 0,
18210 0x0 }, /* POOL32Axf_5_group1~*(25) */
18211 { reserved_block , 0 , 0 , 32,
18212 0xfc00ffff, 0x2000757f, 0 , 0,
18213 0x0 }, /* POOL32Axf_5_group1~*(26) */
18214 { reserved_block , 0 , 0 , 32,
18215 0xfc00ffff, 0x2000777f, 0 , 0,
18216 0x0 }, /* POOL32Axf_5_group1~*(27) */
18217 { reserved_block , 0 , 0 , 32,
18218 0xfc00ffff, 0x2000797f, 0 , 0,
18219 0x0 }, /* POOL32Axf_5_group1~*(28) */
18220 { reserved_block , 0 , 0 , 32,
18221 0xfc00ffff, 0x20007b7f, 0 , 0,
18222 0x0 }, /* POOL32Axf_5_group1~*(29) */
18223 { reserved_block , 0 , 0 , 32,
18224 0xfc00ffff, 0x20007d7f, 0 , 0,
18225 0x0 }, /* POOL32Axf_5_group1~*(30) */
18226 { reserved_block , 0 , 0 , 32,
18227 0xfc00ffff, 0x20007f7f, 0 , 0,
18228 0x0 }, /* POOL32Axf_5_group1~*(31) */
18229 };
18230
18231
18232 static const Pool ERETx[2] = {
18233 { instruction , 0 , 0 , 32,
18234 0xfc01ffff, 0x2000f37f, &ERET , 0,
18235 0x0 }, /* ERET */
18236 { instruction , 0 , 0 , 32,
18237 0xfc01ffff, 0x2001f37f, &ERETNC , 0,
18238 0x0 }, /* ERETNC */
18239 };
18240
18241
18242 static const Pool POOL32Axf_5_group3[32] = {
18243 { reserved_block , 0 , 0 , 32,
18244 0xfc00ffff, 0x2000c17f, 0 , 0,
18245 0x0 }, /* POOL32Axf_5_group3~*(0) */
18246 { instruction , 0 , 0 , 32,
18247 0xfc00ffff, 0x2000c37f, &WAIT , 0,
18248 0x0 }, /* WAIT */
18249 { reserved_block , 0 , 0 , 32,
18250 0xfc00ffff, 0x2000c57f, 0 , 0,
18251 0x0 }, /* POOL32Axf_5_group3~*(2) */
18252 { reserved_block , 0 , 0 , 32,
18253 0xfc00ffff, 0x2000c77f, 0 , 0,
18254 0x0 }, /* POOL32Axf_5_group3~*(3) */
18255 { reserved_block , 0 , 0 , 32,
18256 0xfc00ffff, 0x2000c97f, 0 , 0,
18257 0x0 }, /* POOL32Axf_5_group3~*(4) */
18258 { reserved_block , 0 , 0 , 32,
18259 0xfc00ffff, 0x2000cb7f, 0 , 0,
18260 0x0 }, /* POOL32Axf_5_group3~*(5) */
18261 { reserved_block , 0 , 0 , 32,
18262 0xfc00ffff, 0x2000cd7f, 0 , 0,
18263 0x0 }, /* POOL32Axf_5_group3~*(6) */
18264 { reserved_block , 0 , 0 , 32,
18265 0xfc00ffff, 0x2000cf7f, 0 , 0,
18266 0x0 }, /* POOL32Axf_5_group3~*(7) */
18267 { reserved_block , 0 , 0 , 32,
18268 0xfc00ffff, 0x2000d17f, 0 , 0,
18269 0x0 }, /* POOL32Axf_5_group3~*(8) */
18270 { instruction , 0 , 0 , 32,
18271 0xfc00ffff, 0x2000d37f, &IRET , 0,
18272 MCU_ }, /* IRET */
18273 { reserved_block , 0 , 0 , 32,
18274 0xfc00ffff, 0x2000d57f, 0 , 0,
18275 0x0 }, /* POOL32Axf_5_group3~*(10) */
18276 { reserved_block , 0 , 0 , 32,
18277 0xfc00ffff, 0x2000d77f, 0 , 0,
18278 0x0 }, /* POOL32Axf_5_group3~*(11) */
18279 { reserved_block , 0 , 0 , 32,
18280 0xfc00ffff, 0x2000d97f, 0 , 0,
18281 0x0 }, /* POOL32Axf_5_group3~*(12) */
18282 { reserved_block , 0 , 0 , 32,
18283 0xfc00ffff, 0x2000db7f, 0 , 0,
18284 0x0 }, /* POOL32Axf_5_group3~*(13) */
18285 { reserved_block , 0 , 0 , 32,
18286 0xfc00ffff, 0x2000dd7f, 0 , 0,
18287 0x0 }, /* POOL32Axf_5_group3~*(14) */
18288 { reserved_block , 0 , 0 , 32,
18289 0xfc00ffff, 0x2000df7f, 0 , 0,
18290 0x0 }, /* POOL32Axf_5_group3~*(15) */
18291 { instruction , 0 , 0 , 32,
18292 0xfc00ffff, 0x2000e17f, &RDPGPR , 0,
18293 CP0_ }, /* RDPGPR */
18294 { instruction , 0 , 0 , 32,
18295 0xfc00ffff, 0x2000e37f, &DERET , 0,
18296 EJTAG_ }, /* DERET */
18297 { reserved_block , 0 , 0 , 32,
18298 0xfc00ffff, 0x2000e57f, 0 , 0,
18299 0x0 }, /* POOL32Axf_5_group3~*(18) */
18300 { reserved_block , 0 , 0 , 32,
18301 0xfc00ffff, 0x2000e77f, 0 , 0,
18302 0x0 }, /* POOL32Axf_5_group3~*(19) */
18303 { reserved_block , 0 , 0 , 32,
18304 0xfc00ffff, 0x2000e97f, 0 , 0,
18305 0x0 }, /* POOL32Axf_5_group3~*(20) */
18306 { reserved_block , 0 , 0 , 32,
18307 0xfc00ffff, 0x2000eb7f, 0 , 0,
18308 0x0 }, /* POOL32Axf_5_group3~*(21) */
18309 { reserved_block , 0 , 0 , 32,
18310 0xfc00ffff, 0x2000ed7f, 0 , 0,
18311 0x0 }, /* POOL32Axf_5_group3~*(22) */
18312 { reserved_block , 0 , 0 , 32,
18313 0xfc00ffff, 0x2000ef7f, 0 , 0,
18314 0x0 }, /* POOL32Axf_5_group3~*(23) */
18315 { instruction , 0 , 0 , 32,
18316 0xfc00ffff, 0x2000f17f, &WRPGPR , 0,
18317 CP0_ }, /* WRPGPR */
18318 { pool , ERETx , 2 , 32,
18319 0xfc00ffff, 0x2000f37f, 0 , 0,
18320 0x0 }, /* ERETx */
18321 { reserved_block , 0 , 0 , 32,
18322 0xfc00ffff, 0x2000f57f, 0 , 0,
18323 0x0 }, /* POOL32Axf_5_group3~*(26) */
18324 { reserved_block , 0 , 0 , 32,
18325 0xfc00ffff, 0x2000f77f, 0 , 0,
18326 0x0 }, /* POOL32Axf_5_group3~*(27) */
18327 { reserved_block , 0 , 0 , 32,
18328 0xfc00ffff, 0x2000f97f, 0 , 0,
18329 0x0 }, /* POOL32Axf_5_group3~*(28) */
18330 { reserved_block , 0 , 0 , 32,
18331 0xfc00ffff, 0x2000fb7f, 0 , 0,
18332 0x0 }, /* POOL32Axf_5_group3~*(29) */
18333 { reserved_block , 0 , 0 , 32,
18334 0xfc00ffff, 0x2000fd7f, 0 , 0,
18335 0x0 }, /* POOL32Axf_5_group3~*(30) */
18336 { reserved_block , 0 , 0 , 32,
18337 0xfc00ffff, 0x2000ff7f, 0 , 0,
18338 0x0 }, /* POOL32Axf_5_group3~*(31) */
18339 };
18340
18341
18342 static const Pool POOL32Axf_5[4] = {
18343 { pool , POOL32Axf_5_group0 , 32 , 32,
18344 0xfc00c1ff, 0x2000017f, 0 , 0,
18345 0x0 }, /* POOL32Axf_5_group0 */
18346 { pool , POOL32Axf_5_group1 , 32 , 32,
18347 0xfc00c1ff, 0x2000417f, 0 , 0,
18348 0x0 }, /* POOL32Axf_5_group1 */
18349 { reserved_block , 0 , 0 , 32,
18350 0xfc00c1ff, 0x2000817f, 0 , 0,
18351 0x0 }, /* POOL32Axf_5~*(2) */
18352 { pool , POOL32Axf_5_group3 , 32 , 32,
18353 0xfc00c1ff, 0x2000c17f, 0 , 0,
18354 0x0 }, /* POOL32Axf_5_group3 */
18355 };
18356
18357
18358 static const Pool SHRA__R__QB[2] = {
18359 { instruction , 0 , 0 , 32,
18360 0xfc001fff, 0x200001ff, &SHRA_QB , 0,
18361 DSP_ }, /* SHRA.QB */
18362 { instruction , 0 , 0 , 32,
18363 0xfc001fff, 0x200011ff, &SHRA_R_QB , 0,
18364 DSP_ }, /* SHRA_R.QB */
18365 };
18366
18367
18368 static const Pool POOL32Axf_7[8] = {
18369 { pool , SHRA__R__QB , 2 , 32,
18370 0xfc000fff, 0x200001ff, 0 , 0,
18371 0x0 }, /* SHRA[_R].QB */
18372 { instruction , 0 , 0 , 32,
18373 0xfc000fff, 0x200003ff, &SHRL_PH , 0,
18374 DSP_ }, /* SHRL.PH */
18375 { instruction , 0 , 0 , 32,
18376 0xfc000fff, 0x200005ff, &REPL_QB , 0,
18377 DSP_ }, /* REPL.QB */
18378 { reserved_block , 0 , 0 , 32,
18379 0xfc000fff, 0x200007ff, 0 , 0,
18380 0x0 }, /* POOL32Axf_7~*(3) */
18381 { reserved_block , 0 , 0 , 32,
18382 0xfc000fff, 0x200009ff, 0 , 0,
18383 0x0 }, /* POOL32Axf_7~*(4) */
18384 { reserved_block , 0 , 0 , 32,
18385 0xfc000fff, 0x20000bff, 0 , 0,
18386 0x0 }, /* POOL32Axf_7~*(5) */
18387 { reserved_block , 0 , 0 , 32,
18388 0xfc000fff, 0x20000dff, 0 , 0,
18389 0x0 }, /* POOL32Axf_7~*(6) */
18390 { reserved_block , 0 , 0 , 32,
18391 0xfc000fff, 0x20000fff, 0 , 0,
18392 0x0 }, /* POOL32Axf_7~*(7) */
18393 };
18394
18395
18396 static const Pool POOL32Axf[8] = {
18397 { reserved_block , 0 , 0 , 32,
18398 0xfc0001ff, 0x2000003f, 0 , 0,
18399 0x0 }, /* POOL32Axf~*(0) */
18400 { pool , POOL32Axf_1 , 8 , 32,
18401 0xfc0001ff, 0x2000007f, 0 , 0,
18402 0x0 }, /* POOL32Axf_1 */
18403 { pool , POOL32Axf_2 , 4 , 32,
18404 0xfc0001ff, 0x200000bf, 0 , 0,
18405 0x0 }, /* POOL32Axf_2 */
18406 { reserved_block , 0 , 0 , 32,
18407 0xfc0001ff, 0x200000ff, 0 , 0,
18408 0x0 }, /* POOL32Axf~*(3) */
18409 { pool , POOL32Axf_4 , 128 , 32,
18410 0xfc0001ff, 0x2000013f, 0 , 0,
18411 0x0 }, /* POOL32Axf_4 */
18412 { pool , POOL32Axf_5 , 4 , 32,
18413 0xfc0001ff, 0x2000017f, 0 , 0,
18414 0x0 }, /* POOL32Axf_5 */
18415 { reserved_block , 0 , 0 , 32,
18416 0xfc0001ff, 0x200001bf, 0 , 0,
18417 0x0 }, /* POOL32Axf~*(6) */
18418 { pool , POOL32Axf_7 , 8 , 32,
18419 0xfc0001ff, 0x200001ff, 0 , 0,
18420 0x0 }, /* POOL32Axf_7 */
18421 };
18422
18423
18424 static const Pool _POOL32A7[8] = {
18425 { pool , P_LSX , 2 , 32,
18426 0xfc00003f, 0x20000007, 0 , 0,
18427 0x0 }, /* P.LSX */
18428 { instruction , 0 , 0 , 32,
18429 0xfc00003f, 0x2000000f, &LSA , 0,
18430 0x0 }, /* LSA */
18431 { reserved_block , 0 , 0 , 32,
18432 0xfc00003f, 0x20000017, 0 , 0,
18433 0x0 }, /* _POOL32A7~*(2) */
18434 { instruction , 0 , 0 , 32,
18435 0xfc00003f, 0x2000001f, &EXTW , 0,
18436 0x0 }, /* EXTW */
18437 { reserved_block , 0 , 0 , 32,
18438 0xfc00003f, 0x20000027, 0 , 0,
18439 0x0 }, /* _POOL32A7~*(4) */
18440 { reserved_block , 0 , 0 , 32,
18441 0xfc00003f, 0x2000002f, 0 , 0,
18442 0x0 }, /* _POOL32A7~*(5) */
18443 { reserved_block , 0 , 0 , 32,
18444 0xfc00003f, 0x20000037, 0 , 0,
18445 0x0 }, /* _POOL32A7~*(6) */
18446 { pool , POOL32Axf , 8 , 32,
18447 0xfc00003f, 0x2000003f, 0 , 0,
18448 0x0 }, /* POOL32Axf */
18449 };
18450
18451
18452 static const Pool P32A[8] = {
18453 { pool , _POOL32A0 , 128 , 32,
18454 0xfc000007, 0x20000000, 0 , 0,
18455 0x0 }, /* _POOL32A0 */
18456 { instruction , 0 , 0 , 32,
18457 0xfc000007, 0x20000001, &SPECIAL2 , 0,
18458 UDI_ }, /* SPECIAL2 */
18459 { instruction , 0 , 0 , 32,
18460 0xfc000007, 0x20000002, &COP2_1 , 0,
18461 CP2_ }, /* COP2_1 */
18462 { instruction , 0 , 0 , 32,
18463 0xfc000007, 0x20000003, &UDI , 0,
18464 UDI_ }, /* UDI */
18465 { reserved_block , 0 , 0 , 32,
18466 0xfc000007, 0x20000004, 0 , 0,
18467 0x0 }, /* P32A~*(4) */
18468 { pool , _POOL32A5 , 128 , 32,
18469 0xfc000007, 0x20000005, 0 , 0,
18470 0x0 }, /* _POOL32A5 */
18471 { reserved_block , 0 , 0 , 32,
18472 0xfc000007, 0x20000006, 0 , 0,
18473 0x0 }, /* P32A~*(6) */
18474 { pool , _POOL32A7 , 8 , 32,
18475 0xfc000007, 0x20000007, 0 , 0,
18476 0x0 }, /* _POOL32A7 */
18477 };
18478
18479
18480 static const Pool P_GP_D[2] = {
18481 { instruction , 0 , 0 , 32,
18482 0xfc000007, 0x40000001, &LD_GP_ , 0,
18483 MIPS64_ }, /* LD[GP] */
18484 { instruction , 0 , 0 , 32,
18485 0xfc000007, 0x40000005, &SD_GP_ , 0,
18486 MIPS64_ }, /* SD[GP] */
18487 };
18488
18489
18490 static const Pool P_GP_W[4] = {
18491 { instruction , 0 , 0 , 32,
18492 0xfc000003, 0x40000000, &ADDIU_GP_W_ , 0,
18493 0x0 }, /* ADDIU[GP.W] */
18494 { pool , P_GP_D , 2 , 32,
18495 0xfc000003, 0x40000001, 0 , 0,
18496 0x0 }, /* P.GP.D */
18497 { instruction , 0 , 0 , 32,
18498 0xfc000003, 0x40000002, &LW_GP_ , 0,
18499 0x0 }, /* LW[GP] */
18500 { instruction , 0 , 0 , 32,
18501 0xfc000003, 0x40000003, &SW_GP_ , 0,
18502 0x0 }, /* SW[GP] */
18503 };
18504
18505
18506 static const Pool POOL48I[32] = {
18507 { instruction , 0 , 0 , 48,
18508 0xfc1f00000000ull, 0x600000000000ull, &LI_48_ , 0,
18509 XMMS_ }, /* LI[48] */
18510 { instruction , 0 , 0 , 48,
18511 0xfc1f00000000ull, 0x600100000000ull, &ADDIU_48_ , 0,
18512 XMMS_ }, /* ADDIU[48] */
18513 { instruction , 0 , 0 , 48,
18514 0xfc1f00000000ull, 0x600200000000ull, &ADDIU_GP48_ , 0,
18515 XMMS_ }, /* ADDIU[GP48] */
18516 { instruction , 0 , 0 , 48,
18517 0xfc1f00000000ull, 0x600300000000ull, &ADDIUPC_48_ , 0,
18518 XMMS_ }, /* ADDIUPC[48] */
18519 { reserved_block , 0 , 0 , 48,
18520 0xfc1f00000000ull, 0x600400000000ull, 0 , 0,
18521 0x0 }, /* POOL48I~*(4) */
18522 { reserved_block , 0 , 0 , 48,
18523 0xfc1f00000000ull, 0x600500000000ull, 0 , 0,
18524 0x0 }, /* POOL48I~*(5) */
18525 { reserved_block , 0 , 0 , 48,
18526 0xfc1f00000000ull, 0x600600000000ull, 0 , 0,
18527 0x0 }, /* POOL48I~*(6) */
18528 { reserved_block , 0 , 0 , 48,
18529 0xfc1f00000000ull, 0x600700000000ull, 0 , 0,
18530 0x0 }, /* POOL48I~*(7) */
18531 { reserved_block , 0 , 0 , 48,
18532 0xfc1f00000000ull, 0x600800000000ull, 0 , 0,
18533 0x0 }, /* POOL48I~*(8) */
18534 { reserved_block , 0 , 0 , 48,
18535 0xfc1f00000000ull, 0x600900000000ull, 0 , 0,
18536 0x0 }, /* POOL48I~*(9) */
18537 { reserved_block , 0 , 0 , 48,
18538 0xfc1f00000000ull, 0x600a00000000ull, 0 , 0,
18539 0x0 }, /* POOL48I~*(10) */
18540 { instruction , 0 , 0 , 48,
18541 0xfc1f00000000ull, 0x600b00000000ull, &LWPC_48_ , 0,
18542 XMMS_ }, /* LWPC[48] */
18543 { reserved_block , 0 , 0 , 48,
18544 0xfc1f00000000ull, 0x600c00000000ull, 0 , 0,
18545 0x0 }, /* POOL48I~*(12) */
18546 { reserved_block , 0 , 0 , 48,
18547 0xfc1f00000000ull, 0x600d00000000ull, 0 , 0,
18548 0x0 }, /* POOL48I~*(13) */
18549 { reserved_block , 0 , 0 , 48,
18550 0xfc1f00000000ull, 0x600e00000000ull, 0 , 0,
18551 0x0 }, /* POOL48I~*(14) */
18552 { instruction , 0 , 0 , 48,
18553 0xfc1f00000000ull, 0x600f00000000ull, &SWPC_48_ , 0,
18554 XMMS_ }, /* SWPC[48] */
18555 { reserved_block , 0 , 0 , 48,
18556 0xfc1f00000000ull, 0x601000000000ull, 0 , 0,
18557 0x0 }, /* POOL48I~*(16) */
18558 { instruction , 0 , 0 , 48,
18559 0xfc1f00000000ull, 0x601100000000ull, &DADDIU_48_ , 0,
18560 MIPS64_ }, /* DADDIU[48] */
18561 { reserved_block , 0 , 0 , 48,
18562 0xfc1f00000000ull, 0x601200000000ull, 0 , 0,
18563 0x0 }, /* POOL48I~*(18) */
18564 { reserved_block , 0 , 0 , 48,
18565 0xfc1f00000000ull, 0x601300000000ull, 0 , 0,
18566 0x0 }, /* POOL48I~*(19) */
18567 { instruction , 0 , 0 , 48,
18568 0xfc1f00000000ull, 0x601400000000ull, &DLUI_48_ , 0,
18569 MIPS64_ }, /* DLUI[48] */
18570 { reserved_block , 0 , 0 , 48,
18571 0xfc1f00000000ull, 0x601500000000ull, 0 , 0,
18572 0x0 }, /* POOL48I~*(21) */
18573 { reserved_block , 0 , 0 , 48,
18574 0xfc1f00000000ull, 0x601600000000ull, 0 , 0,
18575 0x0 }, /* POOL48I~*(22) */
18576 { reserved_block , 0 , 0 , 48,
18577 0xfc1f00000000ull, 0x601700000000ull, 0 , 0,
18578 0x0 }, /* POOL48I~*(23) */
18579 { reserved_block , 0 , 0 , 48,
18580 0xfc1f00000000ull, 0x601800000000ull, 0 , 0,
18581 0x0 }, /* POOL48I~*(24) */
18582 { reserved_block , 0 , 0 , 48,
18583 0xfc1f00000000ull, 0x601900000000ull, 0 , 0,
18584 0x0 }, /* POOL48I~*(25) */
18585 { reserved_block , 0 , 0 , 48,
18586 0xfc1f00000000ull, 0x601a00000000ull, 0 , 0,
18587 0x0 }, /* POOL48I~*(26) */
18588 { instruction , 0 , 0 , 48,
18589 0xfc1f00000000ull, 0x601b00000000ull, &LDPC_48_ , 0,
18590 MIPS64_ }, /* LDPC[48] */
18591 { reserved_block , 0 , 0 , 48,
18592 0xfc1f00000000ull, 0x601c00000000ull, 0 , 0,
18593 0x0 }, /* POOL48I~*(28) */
18594 { reserved_block , 0 , 0 , 48,
18595 0xfc1f00000000ull, 0x601d00000000ull, 0 , 0,
18596 0x0 }, /* POOL48I~*(29) */
18597 { reserved_block , 0 , 0 , 48,
18598 0xfc1f00000000ull, 0x601e00000000ull, 0 , 0,
18599 0x0 }, /* POOL48I~*(30) */
18600 { instruction , 0 , 0 , 48,
18601 0xfc1f00000000ull, 0x601f00000000ull, &SDPC_48_ , 0,
18602 MIPS64_ }, /* SDPC[48] */
18603 };
18604
18605
18606 static const Pool PP_SR[4] = {
18607 { instruction , 0 , 0 , 32,
18608 0xfc10f003, 0x80003000, &SAVE_32_ , 0,
18609 0x0 }, /* SAVE[32] */
18610 { reserved_block , 0 , 0 , 32,
18611 0xfc10f003, 0x80003001, 0 , 0,
18612 0x0 }, /* PP.SR~*(1) */
18613 { instruction , 0 , 0 , 32,
18614 0xfc10f003, 0x80003002, &RESTORE_32_ , 0,
18615 0x0 }, /* RESTORE[32] */
18616 { return_instruction , 0 , 0 , 32,
18617 0xfc10f003, 0x80003003, &RESTORE_JRC_32_ , 0,
18618 0x0 }, /* RESTORE.JRC[32] */
18619 };
18620
18621
18622 static const Pool P_SR_F[8] = {
18623 { instruction , 0 , 0 , 32,
18624 0xfc10f007, 0x80103000, &SAVEF , 0,
18625 CP1_ }, /* SAVEF */
18626 { instruction , 0 , 0 , 32,
18627 0xfc10f007, 0x80103001, &RESTOREF , 0,
18628 CP1_ }, /* RESTOREF */
18629 { reserved_block , 0 , 0 , 32,
18630 0xfc10f007, 0x80103002, 0 , 0,
18631 0x0 }, /* P.SR.F~*(2) */
18632 { reserved_block , 0 , 0 , 32,
18633 0xfc10f007, 0x80103003, 0 , 0,
18634 0x0 }, /* P.SR.F~*(3) */
18635 { reserved_block , 0 , 0 , 32,
18636 0xfc10f007, 0x80103004, 0 , 0,
18637 0x0 }, /* P.SR.F~*(4) */
18638 { reserved_block , 0 , 0 , 32,
18639 0xfc10f007, 0x80103005, 0 , 0,
18640 0x0 }, /* P.SR.F~*(5) */
18641 { reserved_block , 0 , 0 , 32,
18642 0xfc10f007, 0x80103006, 0 , 0,
18643 0x0 }, /* P.SR.F~*(6) */
18644 { reserved_block , 0 , 0 , 32,
18645 0xfc10f007, 0x80103007, 0 , 0,
18646 0x0 }, /* P.SR.F~*(7) */
18647 };
18648
18649
18650 static const Pool P_SR[2] = {
18651 { pool , PP_SR , 4 , 32,
18652 0xfc10f000, 0x80003000, 0 , 0,
18653 0x0 }, /* PP.SR */
18654 { pool , P_SR_F , 8 , 32,
18655 0xfc10f000, 0x80103000, 0 , 0,
18656 0x0 }, /* P.SR.F */
18657 };
18658
18659
18660 static const Pool P_SLL[5] = {
18661 { instruction , 0 , 0 , 32,
18662 0xffe0f1ff, 0x8000c000, &NOP_32_ , 0,
18663 0x0 }, /* NOP[32] */
18664 { instruction , 0 , 0 , 32,
18665 0xffe0f1ff, 0x8000c003, &EHB , 0,
18666 0x0 }, /* EHB */
18667 { instruction , 0 , 0 , 32,
18668 0xffe0f1ff, 0x8000c005, &PAUSE , 0,
18669 0x0 }, /* PAUSE */
18670 { instruction , 0 , 0 , 32,
18671 0xffe0f1ff, 0x8000c006, &SYNC , 0,
18672 0x0 }, /* SYNC */
18673 { instruction , 0 , 0 , 32,
18674 0xfc00f1e0, 0x8000c000, &SLL_32_ , 0,
18675 0x0 }, /* SLL[32] */
18676 };
18677
18678
18679 static const Pool P_SHIFT[16] = {
18680 { pool , P_SLL , 5 , 32,
18681 0xfc00f1e0, 0x8000c000, 0 , 0,
18682 0x0 }, /* P.SLL */
18683 { reserved_block , 0 , 0 , 32,
18684 0xfc00f1e0, 0x8000c020, 0 , 0,
18685 0x0 }, /* P.SHIFT~*(1) */
18686 { instruction , 0 , 0 , 32,
18687 0xfc00f1e0, 0x8000c040, &SRL_32_ , 0,
18688 0x0 }, /* SRL[32] */
18689 { reserved_block , 0 , 0 , 32,
18690 0xfc00f1e0, 0x8000c060, 0 , 0,
18691 0x0 }, /* P.SHIFT~*(3) */
18692 { instruction , 0 , 0 , 32,
18693 0xfc00f1e0, 0x8000c080, &SRA , 0,
18694 0x0 }, /* SRA */
18695 { reserved_block , 0 , 0 , 32,
18696 0xfc00f1e0, 0x8000c0a0, 0 , 0,
18697 0x0 }, /* P.SHIFT~*(5) */
18698 { instruction , 0 , 0 , 32,
18699 0xfc00f1e0, 0x8000c0c0, &ROTR , 0,
18700 0x0 }, /* ROTR */
18701 { reserved_block , 0 , 0 , 32,
18702 0xfc00f1e0, 0x8000c0e0, 0 , 0,
18703 0x0 }, /* P.SHIFT~*(7) */
18704 { instruction , 0 , 0 , 32,
18705 0xfc00f1e0, 0x8000c100, &DSLL , 0,
18706 MIPS64_ }, /* DSLL */
18707 { instruction , 0 , 0 , 32,
18708 0xfc00f1e0, 0x8000c120, &DSLL32 , 0,
18709 MIPS64_ }, /* DSLL32 */
18710 { instruction , 0 , 0 , 32,
18711 0xfc00f1e0, 0x8000c140, &DSRL , 0,
18712 MIPS64_ }, /* DSRL */
18713 { instruction , 0 , 0 , 32,
18714 0xfc00f1e0, 0x8000c160, &DSRL32 , 0,
18715 MIPS64_ }, /* DSRL32 */
18716 { instruction , 0 , 0 , 32,
18717 0xfc00f1e0, 0x8000c180, &DSRA , 0,
18718 MIPS64_ }, /* DSRA */
18719 { instruction , 0 , 0 , 32,
18720 0xfc00f1e0, 0x8000c1a0, &DSRA32 , 0,
18721 MIPS64_ }, /* DSRA32 */
18722 { instruction , 0 , 0 , 32,
18723 0xfc00f1e0, 0x8000c1c0, &DROTR , 0,
18724 MIPS64_ }, /* DROTR */
18725 { instruction , 0 , 0 , 32,
18726 0xfc00f1e0, 0x8000c1e0, &DROTR32 , 0,
18727 MIPS64_ }, /* DROTR32 */
18728 };
18729
18730
18731 static const Pool P_ROTX[4] = {
18732 { instruction , 0 , 0 , 32,
18733 0xfc00f820, 0x8000d000, &ROTX , 0,
18734 XMMS_ }, /* ROTX */
18735 { reserved_block , 0 , 0 , 32,
18736 0xfc00f820, 0x8000d020, 0 , 0,
18737 0x0 }, /* P.ROTX~*(1) */
18738 { reserved_block , 0 , 0 , 32,
18739 0xfc00f820, 0x8000d800, 0 , 0,
18740 0x0 }, /* P.ROTX~*(2) */
18741 { reserved_block , 0 , 0 , 32,
18742 0xfc00f820, 0x8000d820, 0 , 0,
18743 0x0 }, /* P.ROTX~*(3) */
18744 };
18745
18746
18747 static const Pool P_INS[4] = {
18748 { instruction , 0 , 0 , 32,
18749 0xfc00f820, 0x8000e000, &INS , 0,
18750 XMMS_ }, /* INS */
18751 { instruction , 0 , 0 , 32,
18752 0xfc00f820, 0x8000e020, &DINSU , 0,
18753 MIPS64_ }, /* DINSU */
18754 { instruction , 0 , 0 , 32,
18755 0xfc00f820, 0x8000e800, &DINSM , 0,
18756 MIPS64_ }, /* DINSM */
18757 { instruction , 0 , 0 , 32,
18758 0xfc00f820, 0x8000e820, &DINS , 0,
18759 MIPS64_ }, /* DINS */
18760 };
18761
18762
18763 static const Pool P_EXT[4] = {
18764 { instruction , 0 , 0 , 32,
18765 0xfc00f820, 0x8000f000, &EXT , 0,
18766 XMMS_ }, /* EXT */
18767 { instruction , 0 , 0 , 32,
18768 0xfc00f820, 0x8000f020, &DEXTU , 0,
18769 MIPS64_ }, /* DEXTU */
18770 { instruction , 0 , 0 , 32,
18771 0xfc00f820, 0x8000f800, &DEXTM , 0,
18772 MIPS64_ }, /* DEXTM */
18773 { instruction , 0 , 0 , 32,
18774 0xfc00f820, 0x8000f820, &DEXT , 0,
18775 MIPS64_ }, /* DEXT */
18776 };
18777
18778
18779 static const Pool P_U12[16] = {
18780 { instruction , 0 , 0 , 32,
18781 0xfc00f000, 0x80000000, &ORI , 0,
18782 0x0 }, /* ORI */
18783 { instruction , 0 , 0 , 32,
18784 0xfc00f000, 0x80001000, &XORI , 0,
18785 0x0 }, /* XORI */
18786 { instruction , 0 , 0 , 32,
18787 0xfc00f000, 0x80002000, &ANDI_32_ , 0,
18788 0x0 }, /* ANDI[32] */
18789 { pool , P_SR , 2 , 32,
18790 0xfc00f000, 0x80003000, 0 , 0,
18791 0x0 }, /* P.SR */
18792 { instruction , 0 , 0 , 32,
18793 0xfc00f000, 0x80004000, &SLTI , 0,
18794 0x0 }, /* SLTI */
18795 { instruction , 0 , 0 , 32,
18796 0xfc00f000, 0x80005000, &SLTIU , 0,
18797 0x0 }, /* SLTIU */
18798 { instruction , 0 , 0 , 32,
18799 0xfc00f000, 0x80006000, &SEQI , 0,
18800 0x0 }, /* SEQI */
18801 { reserved_block , 0 , 0 , 32,
18802 0xfc00f000, 0x80007000, 0 , 0,
18803 0x0 }, /* P.U12~*(7) */
18804 { instruction , 0 , 0 , 32,
18805 0xfc00f000, 0x80008000, &ADDIU_NEG_ , 0,
18806 0x0 }, /* ADDIU[NEG] */
18807 { instruction , 0 , 0 , 32,
18808 0xfc00f000, 0x80009000, &DADDIU_U12_ , 0,
18809 MIPS64_ }, /* DADDIU[U12] */
18810 { instruction , 0 , 0 , 32,
18811 0xfc00f000, 0x8000a000, &DADDIU_NEG_ , 0,
18812 MIPS64_ }, /* DADDIU[NEG] */
18813 { instruction , 0 , 0 , 32,
18814 0xfc00f000, 0x8000b000, &DROTX , 0,
18815 MIPS64_ }, /* DROTX */
18816 { pool , P_SHIFT , 16 , 32,
18817 0xfc00f000, 0x8000c000, 0 , 0,
18818 0x0 }, /* P.SHIFT */
18819 { pool , P_ROTX , 4 , 32,
18820 0xfc00f000, 0x8000d000, 0 , 0,
18821 0x0 }, /* P.ROTX */
18822 { pool , P_INS , 4 , 32,
18823 0xfc00f000, 0x8000e000, 0 , 0,
18824 0x0 }, /* P.INS */
18825 { pool , P_EXT , 4 , 32,
18826 0xfc00f000, 0x8000f000, 0 , 0,
18827 0x0 }, /* P.EXT */
18828 };
18829
18830
18831 static const Pool RINT_fmt[2] = {
18832 { instruction , 0 , 0 , 32,
18833 0xfc0003ff, 0xa0000020, &RINT_S , 0,
18834 CP1_ }, /* RINT.S */
18835 { instruction , 0 , 0 , 32,
18836 0xfc0003ff, 0xa0000220, &RINT_D , 0,
18837 CP1_ }, /* RINT.D */
18838 };
18839
18840
18841 static const Pool ADD_fmt0[2] = {
18842 { instruction , 0 , 0 , 32,
18843 0xfc0003ff, 0xa0000030, &ADD_S , 0,
18844 CP1_ }, /* ADD.S */
18845 { reserved_block , 0 , 0 , 32,
18846 0xfc0003ff, 0xa0000230, 0 , 0,
18847 CP1_ }, /* ADD.fmt0~*(1) */
18848 };
18849
18850
18851 static const Pool SELEQZ_fmt[2] = {
18852 { instruction , 0 , 0 , 32,
18853 0xfc0003ff, 0xa0000038, &SELEQZ_S , 0,
18854 CP1_ }, /* SELEQZ.S */
18855 { instruction , 0 , 0 , 32,
18856 0xfc0003ff, 0xa0000238, &SELEQZ_D , 0,
18857 CP1_ }, /* SELEQZ.D */
18858 };
18859
18860
18861 static const Pool CLASS_fmt[2] = {
18862 { instruction , 0 , 0 , 32,
18863 0xfc0003ff, 0xa0000060, &CLASS_S , 0,
18864 CP1_ }, /* CLASS.S */
18865 { instruction , 0 , 0 , 32,
18866 0xfc0003ff, 0xa0000260, &CLASS_D , 0,
18867 CP1_ }, /* CLASS.D */
18868 };
18869
18870
18871 static const Pool SUB_fmt0[2] = {
18872 { instruction , 0 , 0 , 32,
18873 0xfc0003ff, 0xa0000070, &SUB_S , 0,
18874 CP1_ }, /* SUB.S */
18875 { reserved_block , 0 , 0 , 32,
18876 0xfc0003ff, 0xa0000270, 0 , 0,
18877 CP1_ }, /* SUB.fmt0~*(1) */
18878 };
18879
18880
18881 static const Pool SELNEZ_fmt[2] = {
18882 { instruction , 0 , 0 , 32,
18883 0xfc0003ff, 0xa0000078, &SELNEZ_S , 0,
18884 CP1_ }, /* SELNEZ.S */
18885 { instruction , 0 , 0 , 32,
18886 0xfc0003ff, 0xa0000278, &SELNEZ_D , 0,
18887 CP1_ }, /* SELNEZ.D */
18888 };
18889
18890
18891 static const Pool MUL_fmt0[2] = {
18892 { instruction , 0 , 0 , 32,
18893 0xfc0003ff, 0xa00000b0, &MUL_S , 0,
18894 CP1_ }, /* MUL.S */
18895 { reserved_block , 0 , 0 , 32,
18896 0xfc0003ff, 0xa00002b0, 0 , 0,
18897 CP1_ }, /* MUL.fmt0~*(1) */
18898 };
18899
18900
18901 static const Pool SEL_fmt[2] = {
18902 { instruction , 0 , 0 , 32,
18903 0xfc0003ff, 0xa00000b8, &SEL_S , 0,
18904 CP1_ }, /* SEL.S */
18905 { instruction , 0 , 0 , 32,
18906 0xfc0003ff, 0xa00002b8, &SEL_D , 0,
18907 CP1_ }, /* SEL.D */
18908 };
18909
18910
18911 static const Pool DIV_fmt0[2] = {
18912 { instruction , 0 , 0 , 32,
18913 0xfc0003ff, 0xa00000f0, &DIV_S , 0,
18914 CP1_ }, /* DIV.S */
18915 { reserved_block , 0 , 0 , 32,
18916 0xfc0003ff, 0xa00002f0, 0 , 0,
18917 CP1_ }, /* DIV.fmt0~*(1) */
18918 };
18919
18920
18921 static const Pool ADD_fmt1[2] = {
18922 { instruction , 0 , 0 , 32,
18923 0xfc0003ff, 0xa0000130, &ADD_D , 0,
18924 CP1_ }, /* ADD.D */
18925 { reserved_block , 0 , 0 , 32,
18926 0xfc0003ff, 0xa0000330, 0 , 0,
18927 CP1_ }, /* ADD.fmt1~*(1) */
18928 };
18929
18930
18931 static const Pool SUB_fmt1[2] = {
18932 { instruction , 0 , 0 , 32,
18933 0xfc0003ff, 0xa0000170, &SUB_D , 0,
18934 CP1_ }, /* SUB.D */
18935 { reserved_block , 0 , 0 , 32,
18936 0xfc0003ff, 0xa0000370, 0 , 0,
18937 CP1_ }, /* SUB.fmt1~*(1) */
18938 };
18939
18940
18941 static const Pool MUL_fmt1[2] = {
18942 { instruction , 0 , 0 , 32,
18943 0xfc0003ff, 0xa00001b0, &MUL_D , 0,
18944 CP1_ }, /* MUL.D */
18945 { reserved_block , 0 , 0 , 32,
18946 0xfc0003ff, 0xa00003b0, 0 , 0,
18947 CP1_ }, /* MUL.fmt1~*(1) */
18948 };
18949
18950
18951 static const Pool MADDF_fmt[2] = {
18952 { instruction , 0 , 0 , 32,
18953 0xfc0003ff, 0xa00001b8, &MADDF_S , 0,
18954 CP1_ }, /* MADDF.S */
18955 { instruction , 0 , 0 , 32,
18956 0xfc0003ff, 0xa00003b8, &MADDF_D , 0,
18957 CP1_ }, /* MADDF.D */
18958 };
18959
18960
18961 static const Pool DIV_fmt1[2] = {
18962 { instruction , 0 , 0 , 32,
18963 0xfc0003ff, 0xa00001f0, &DIV_D , 0,
18964 CP1_ }, /* DIV.D */
18965 { reserved_block , 0 , 0 , 32,
18966 0xfc0003ff, 0xa00003f0, 0 , 0,
18967 CP1_ }, /* DIV.fmt1~*(1) */
18968 };
18969
18970
18971 static const Pool MSUBF_fmt[2] = {
18972 { instruction , 0 , 0 , 32,
18973 0xfc0003ff, 0xa00001f8, &MSUBF_S , 0,
18974 CP1_ }, /* MSUBF.S */
18975 { instruction , 0 , 0 , 32,
18976 0xfc0003ff, 0xa00003f8, &MSUBF_D , 0,
18977 CP1_ }, /* MSUBF.D */
18978 };
18979
18980
18981 static const Pool POOL32F_0[64] = {
18982 { reserved_block , 0 , 0 , 32,
18983 0xfc0001ff, 0xa0000000, 0 , 0,
18984 CP1_ }, /* POOL32F_0~*(0) */
18985 { reserved_block , 0 , 0 , 32,
18986 0xfc0001ff, 0xa0000008, 0 , 0,
18987 CP1_ }, /* POOL32F_0~*(1) */
18988 { reserved_block , 0 , 0 , 32,
18989 0xfc0001ff, 0xa0000010, 0 , 0,
18990 CP1_ }, /* POOL32F_0~*(2) */
18991 { reserved_block , 0 , 0 , 32,
18992 0xfc0001ff, 0xa0000018, 0 , 0,
18993 CP1_ }, /* POOL32F_0~*(3) */
18994 { pool , RINT_fmt , 2 , 32,
18995 0xfc0001ff, 0xa0000020, 0 , 0,
18996 CP1_ }, /* RINT.fmt */
18997 { reserved_block , 0 , 0 , 32,
18998 0xfc0001ff, 0xa0000028, 0 , 0,
18999 CP1_ }, /* POOL32F_0~*(5) */
19000 { pool , ADD_fmt0 , 2 , 32,
19001 0xfc0001ff, 0xa0000030, 0 , 0,
19002 CP1_ }, /* ADD.fmt0 */
19003 { pool , SELEQZ_fmt , 2 , 32,
19004 0xfc0001ff, 0xa0000038, 0 , 0,
19005 CP1_ }, /* SELEQZ.fmt */
19006 { reserved_block , 0 , 0 , 32,
19007 0xfc0001ff, 0xa0000040, 0 , 0,
19008 CP1_ }, /* POOL32F_0~*(8) */
19009 { reserved_block , 0 , 0 , 32,
19010 0xfc0001ff, 0xa0000048, 0 , 0,
19011 CP1_ }, /* POOL32F_0~*(9) */
19012 { reserved_block , 0 , 0 , 32,
19013 0xfc0001ff, 0xa0000050, 0 , 0,
19014 CP1_ }, /* POOL32F_0~*(10) */
19015 { reserved_block , 0 , 0 , 32,
19016 0xfc0001ff, 0xa0000058, 0 , 0,
19017 CP1_ }, /* POOL32F_0~*(11) */
19018 { pool , CLASS_fmt , 2 , 32,
19019 0xfc0001ff, 0xa0000060, 0 , 0,
19020 CP1_ }, /* CLASS.fmt */
19021 { reserved_block , 0 , 0 , 32,
19022 0xfc0001ff, 0xa0000068, 0 , 0,
19023 CP1_ }, /* POOL32F_0~*(13) */
19024 { pool , SUB_fmt0 , 2 , 32,
19025 0xfc0001ff, 0xa0000070, 0 , 0,
19026 CP1_ }, /* SUB.fmt0 */
19027 { pool , SELNEZ_fmt , 2 , 32,
19028 0xfc0001ff, 0xa0000078, 0 , 0,
19029 CP1_ }, /* SELNEZ.fmt */
19030 { reserved_block , 0 , 0 , 32,
19031 0xfc0001ff, 0xa0000080, 0 , 0,
19032 CP1_ }, /* POOL32F_0~*(16) */
19033 { reserved_block , 0 , 0 , 32,
19034 0xfc0001ff, 0xa0000088, 0 , 0,
19035 CP1_ }, /* POOL32F_0~*(17) */
19036 { reserved_block , 0 , 0 , 32,
19037 0xfc0001ff, 0xa0000090, 0 , 0,
19038 CP1_ }, /* POOL32F_0~*(18) */
19039 { reserved_block , 0 , 0 , 32,
19040 0xfc0001ff, 0xa0000098, 0 , 0,
19041 CP1_ }, /* POOL32F_0~*(19) */
19042 { reserved_block , 0 , 0 , 32,
19043 0xfc0001ff, 0xa00000a0, 0 , 0,
19044 CP1_ }, /* POOL32F_0~*(20) */
19045 { reserved_block , 0 , 0 , 32,
19046 0xfc0001ff, 0xa00000a8, 0 , 0,
19047 CP1_ }, /* POOL32F_0~*(21) */
19048 { pool , MUL_fmt0 , 2 , 32,
19049 0xfc0001ff, 0xa00000b0, 0 , 0,
19050 CP1_ }, /* MUL.fmt0 */
19051 { pool , SEL_fmt , 2 , 32,
19052 0xfc0001ff, 0xa00000b8, 0 , 0,
19053 CP1_ }, /* SEL.fmt */
19054 { reserved_block , 0 , 0 , 32,
19055 0xfc0001ff, 0xa00000c0, 0 , 0,
19056 CP1_ }, /* POOL32F_0~*(24) */
19057 { reserved_block , 0 , 0 , 32,
19058 0xfc0001ff, 0xa00000c8, 0 , 0,
19059 CP1_ }, /* POOL32F_0~*(25) */
19060 { reserved_block , 0 , 0 , 32,
19061 0xfc0001ff, 0xa00000d0, 0 , 0,
19062 CP1_ }, /* POOL32F_0~*(26) */
19063 { reserved_block , 0 , 0 , 32,
19064 0xfc0001ff, 0xa00000d8, 0 , 0,
19065 CP1_ }, /* POOL32F_0~*(27) */
19066 { reserved_block , 0 , 0 , 32,
19067 0xfc0001ff, 0xa00000e0, 0 , 0,
19068 CP1_ }, /* POOL32F_0~*(28) */
19069 { reserved_block , 0 , 0 , 32,
19070 0xfc0001ff, 0xa00000e8, 0 , 0,
19071 CP1_ }, /* POOL32F_0~*(29) */
19072 { pool , DIV_fmt0 , 2 , 32,
19073 0xfc0001ff, 0xa00000f0, 0 , 0,
19074 CP1_ }, /* DIV.fmt0 */
19075 { reserved_block , 0 , 0 , 32,
19076 0xfc0001ff, 0xa00000f8, 0 , 0,
19077 CP1_ }, /* POOL32F_0~*(31) */
19078 { reserved_block , 0 , 0 , 32,
19079 0xfc0001ff, 0xa0000100, 0 , 0,
19080 CP1_ }, /* POOL32F_0~*(32) */
19081 { reserved_block , 0 , 0 , 32,
19082 0xfc0001ff, 0xa0000108, 0 , 0,
19083 CP1_ }, /* POOL32F_0~*(33) */
19084 { reserved_block , 0 , 0 , 32,
19085 0xfc0001ff, 0xa0000110, 0 , 0,
19086 CP1_ }, /* POOL32F_0~*(34) */
19087 { reserved_block , 0 , 0 , 32,
19088 0xfc0001ff, 0xa0000118, 0 , 0,
19089 CP1_ }, /* POOL32F_0~*(35) */
19090 { reserved_block , 0 , 0 , 32,
19091 0xfc0001ff, 0xa0000120, 0 , 0,
19092 CP1_ }, /* POOL32F_0~*(36) */
19093 { reserved_block , 0 , 0 , 32,
19094 0xfc0001ff, 0xa0000128, 0 , 0,
19095 CP1_ }, /* POOL32F_0~*(37) */
19096 { pool , ADD_fmt1 , 2 , 32,
19097 0xfc0001ff, 0xa0000130, 0 , 0,
19098 CP1_ }, /* ADD.fmt1 */
19099 { reserved_block , 0 , 0 , 32,
19100 0xfc0001ff, 0xa0000138, 0 , 0,
19101 CP1_ }, /* POOL32F_0~*(39) */
19102 { reserved_block , 0 , 0 , 32,
19103 0xfc0001ff, 0xa0000140, 0 , 0,
19104 CP1_ }, /* POOL32F_0~*(40) */
19105 { reserved_block , 0 , 0 , 32,
19106 0xfc0001ff, 0xa0000148, 0 , 0,
19107 CP1_ }, /* POOL32F_0~*(41) */
19108 { reserved_block , 0 , 0 , 32,
19109 0xfc0001ff, 0xa0000150, 0 , 0,
19110 CP1_ }, /* POOL32F_0~*(42) */
19111 { reserved_block , 0 , 0 , 32,
19112 0xfc0001ff, 0xa0000158, 0 , 0,
19113 CP1_ }, /* POOL32F_0~*(43) */
19114 { reserved_block , 0 , 0 , 32,
19115 0xfc0001ff, 0xa0000160, 0 , 0,
19116 CP1_ }, /* POOL32F_0~*(44) */
19117 { reserved_block , 0 , 0 , 32,
19118 0xfc0001ff, 0xa0000168, 0 , 0,
19119 CP1_ }, /* POOL32F_0~*(45) */
19120 { pool , SUB_fmt1 , 2 , 32,
19121 0xfc0001ff, 0xa0000170, 0 , 0,
19122 CP1_ }, /* SUB.fmt1 */
19123 { reserved_block , 0 , 0 , 32,
19124 0xfc0001ff, 0xa0000178, 0 , 0,
19125 CP1_ }, /* POOL32F_0~*(47) */
19126 { reserved_block , 0 , 0 , 32,
19127 0xfc0001ff, 0xa0000180, 0 , 0,
19128 CP1_ }, /* POOL32F_0~*(48) */
19129 { reserved_block , 0 , 0 , 32,
19130 0xfc0001ff, 0xa0000188, 0 , 0,
19131 CP1_ }, /* POOL32F_0~*(49) */
19132 { reserved_block , 0 , 0 , 32,
19133 0xfc0001ff, 0xa0000190, 0 , 0,
19134 CP1_ }, /* POOL32F_0~*(50) */
19135 { reserved_block , 0 , 0 , 32,
19136 0xfc0001ff, 0xa0000198, 0 , 0,
19137 CP1_ }, /* POOL32F_0~*(51) */
19138 { reserved_block , 0 , 0 , 32,
19139 0xfc0001ff, 0xa00001a0, 0 , 0,
19140 CP1_ }, /* POOL32F_0~*(52) */
19141 { reserved_block , 0 , 0 , 32,
19142 0xfc0001ff, 0xa00001a8, 0 , 0,
19143 CP1_ }, /* POOL32F_0~*(53) */
19144 { pool , MUL_fmt1 , 2 , 32,
19145 0xfc0001ff, 0xa00001b0, 0 , 0,
19146 CP1_ }, /* MUL.fmt1 */
19147 { pool , MADDF_fmt , 2 , 32,
19148 0xfc0001ff, 0xa00001b8, 0 , 0,
19149 CP1_ }, /* MADDF.fmt */
19150 { reserved_block , 0 , 0 , 32,
19151 0xfc0001ff, 0xa00001c0, 0 , 0,
19152 CP1_ }, /* POOL32F_0~*(56) */
19153 { reserved_block , 0 , 0 , 32,
19154 0xfc0001ff, 0xa00001c8, 0 , 0,
19155 CP1_ }, /* POOL32F_0~*(57) */
19156 { reserved_block , 0 , 0 , 32,
19157 0xfc0001ff, 0xa00001d0, 0 , 0,
19158 CP1_ }, /* POOL32F_0~*(58) */
19159 { reserved_block , 0 , 0 , 32,
19160 0xfc0001ff, 0xa00001d8, 0 , 0,
19161 CP1_ }, /* POOL32F_0~*(59) */
19162 { reserved_block , 0 , 0 , 32,
19163 0xfc0001ff, 0xa00001e0, 0 , 0,
19164 CP1_ }, /* POOL32F_0~*(60) */
19165 { reserved_block , 0 , 0 , 32,
19166 0xfc0001ff, 0xa00001e8, 0 , 0,
19167 CP1_ }, /* POOL32F_0~*(61) */
19168 { pool , DIV_fmt1 , 2 , 32,
19169 0xfc0001ff, 0xa00001f0, 0 , 0,
19170 CP1_ }, /* DIV.fmt1 */
19171 { pool , MSUBF_fmt , 2 , 32,
19172 0xfc0001ff, 0xa00001f8, 0 , 0,
19173 CP1_ }, /* MSUBF.fmt */
19174 };
19175
19176
19177 static const Pool MIN_fmt[2] = {
19178 { instruction , 0 , 0 , 32,
19179 0xfc00023f, 0xa0000003, &MIN_S , 0,
19180 CP1_ }, /* MIN.S */
19181 { instruction , 0 , 0 , 32,
19182 0xfc00023f, 0xa0000203, &MIN_D , 0,
19183 CP1_ }, /* MIN.D */
19184 };
19185
19186
19187 static const Pool MAX_fmt[2] = {
19188 { instruction , 0 , 0 , 32,
19189 0xfc00023f, 0xa000000b, &MAX_S , 0,
19190 CP1_ }, /* MAX.S */
19191 { instruction , 0 , 0 , 32,
19192 0xfc00023f, 0xa000020b, &MAX_D , 0,
19193 CP1_ }, /* MAX.D */
19194 };
19195
19196
19197 static const Pool MINA_fmt[2] = {
19198 { instruction , 0 , 0 , 32,
19199 0xfc00023f, 0xa0000023, &MINA_S , 0,
19200 CP1_ }, /* MINA.S */
19201 { instruction , 0 , 0 , 32,
19202 0xfc00023f, 0xa0000223, &MINA_D , 0,
19203 CP1_ }, /* MINA.D */
19204 };
19205
19206
19207 static const Pool MAXA_fmt[2] = {
19208 { instruction , 0 , 0 , 32,
19209 0xfc00023f, 0xa000002b, &MAXA_S , 0,
19210 CP1_ }, /* MAXA.S */
19211 { instruction , 0 , 0 , 32,
19212 0xfc00023f, 0xa000022b, &MAXA_D , 0,
19213 CP1_ }, /* MAXA.D */
19214 };
19215
19216
19217 static const Pool CVT_L_fmt[2] = {
19218 { instruction , 0 , 0 , 32,
19219 0xfc007fff, 0xa000013b, &CVT_L_S , 0,
19220 CP1_ }, /* CVT.L.S */
19221 { instruction , 0 , 0 , 32,
19222 0xfc007fff, 0xa000413b, &CVT_L_D , 0,
19223 CP1_ }, /* CVT.L.D */
19224 };
19225
19226
19227 static const Pool RSQRT_fmt[2] = {
19228 { instruction , 0 , 0 , 32,
19229 0xfc007fff, 0xa000023b, &RSQRT_S , 0,
19230 CP1_ }, /* RSQRT.S */
19231 { instruction , 0 , 0 , 32,
19232 0xfc007fff, 0xa000423b, &RSQRT_D , 0,
19233 CP1_ }, /* RSQRT.D */
19234 };
19235
19236
19237 static const Pool FLOOR_L_fmt[2] = {
19238 { instruction , 0 , 0 , 32,
19239 0xfc007fff, 0xa000033b, &FLOOR_L_S , 0,
19240 CP1_ }, /* FLOOR.L.S */
19241 { instruction , 0 , 0 , 32,
19242 0xfc007fff, 0xa000433b, &FLOOR_L_D , 0,
19243 CP1_ }, /* FLOOR.L.D */
19244 };
19245
19246
19247 static const Pool CVT_W_fmt[2] = {
19248 { instruction , 0 , 0 , 32,
19249 0xfc007fff, 0xa000093b, &CVT_W_S , 0,
19250 CP1_ }, /* CVT.W.S */
19251 { instruction , 0 , 0 , 32,
19252 0xfc007fff, 0xa000493b, &CVT_W_D , 0,
19253 CP1_ }, /* CVT.W.D */
19254 };
19255
19256
19257 static const Pool SQRT_fmt[2] = {
19258 { instruction , 0 , 0 , 32,
19259 0xfc007fff, 0xa0000a3b, &SQRT_S , 0,
19260 CP1_ }, /* SQRT.S */
19261 { instruction , 0 , 0 , 32,
19262 0xfc007fff, 0xa0004a3b, &SQRT_D , 0,
19263 CP1_ }, /* SQRT.D */
19264 };
19265
19266
19267 static const Pool FLOOR_W_fmt[2] = {
19268 { instruction , 0 , 0 , 32,
19269 0xfc007fff, 0xa0000b3b, &FLOOR_W_S , 0,
19270 CP1_ }, /* FLOOR.W.S */
19271 { instruction , 0 , 0 , 32,
19272 0xfc007fff, 0xa0004b3b, &FLOOR_W_D , 0,
19273 CP1_ }, /* FLOOR.W.D */
19274 };
19275
19276
19277 static const Pool RECIP_fmt[2] = {
19278 { instruction , 0 , 0 , 32,
19279 0xfc007fff, 0xa000123b, &RECIP_S , 0,
19280 CP1_ }, /* RECIP.S */
19281 { instruction , 0 , 0 , 32,
19282 0xfc007fff, 0xa000523b, &RECIP_D , 0,
19283 CP1_ }, /* RECIP.D */
19284 };
19285
19286
19287 static const Pool CEIL_L_fmt[2] = {
19288 { instruction , 0 , 0 , 32,
19289 0xfc007fff, 0xa000133b, &CEIL_L_S , 0,
19290 CP1_ }, /* CEIL.L.S */
19291 { instruction , 0 , 0 , 32,
19292 0xfc007fff, 0xa000533b, &CEIL_L_D , 0,
19293 CP1_ }, /* CEIL.L.D */
19294 };
19295
19296
19297 static const Pool CEIL_W_fmt[2] = {
19298 { instruction , 0 , 0 , 32,
19299 0xfc007fff, 0xa0001b3b, &CEIL_W_S , 0,
19300 CP1_ }, /* CEIL.W.S */
19301 { instruction , 0 , 0 , 32,
19302 0xfc007fff, 0xa0005b3b, &CEIL_W_D , 0,
19303 CP1_ }, /* CEIL.W.D */
19304 };
19305
19306
19307 static const Pool TRUNC_L_fmt[2] = {
19308 { instruction , 0 , 0 , 32,
19309 0xfc007fff, 0xa000233b, &TRUNC_L_S , 0,
19310 CP1_ }, /* TRUNC.L.S */
19311 { instruction , 0 , 0 , 32,
19312 0xfc007fff, 0xa000633b, &TRUNC_L_D , 0,
19313 CP1_ }, /* TRUNC.L.D */
19314 };
19315
19316
19317 static const Pool TRUNC_W_fmt[2] = {
19318 { instruction , 0 , 0 , 32,
19319 0xfc007fff, 0xa0002b3b, &TRUNC_W_S , 0,
19320 CP1_ }, /* TRUNC.W.S */
19321 { instruction , 0 , 0 , 32,
19322 0xfc007fff, 0xa0006b3b, &TRUNC_W_D , 0,
19323 CP1_ }, /* TRUNC.W.D */
19324 };
19325
19326
19327 static const Pool ROUND_L_fmt[2] = {
19328 { instruction , 0 , 0 , 32,
19329 0xfc007fff, 0xa000333b, &ROUND_L_S , 0,
19330 CP1_ }, /* ROUND.L.S */
19331 { instruction , 0 , 0 , 32,
19332 0xfc007fff, 0xa000733b, &ROUND_L_D , 0,
19333 CP1_ }, /* ROUND.L.D */
19334 };
19335
19336
19337 static const Pool ROUND_W_fmt[2] = {
19338 { instruction , 0 , 0 , 32,
19339 0xfc007fff, 0xa0003b3b, &ROUND_W_S , 0,
19340 CP1_ }, /* ROUND.W.S */
19341 { instruction , 0 , 0 , 32,
19342 0xfc007fff, 0xa0007b3b, &ROUND_W_D , 0,
19343 CP1_ }, /* ROUND.W.D */
19344 };
19345
19346
19347 static const Pool POOL32Fxf_0[64] = {
19348 { reserved_block , 0 , 0 , 32,
19349 0xfc003fff, 0xa000003b, 0 , 0,
19350 CP1_ }, /* POOL32Fxf_0~*(0) */
19351 { pool , CVT_L_fmt , 2 , 32,
19352 0xfc003fff, 0xa000013b, 0 , 0,
19353 CP1_ }, /* CVT.L.fmt */
19354 { pool , RSQRT_fmt , 2 , 32,
19355 0xfc003fff, 0xa000023b, 0 , 0,
19356 CP1_ }, /* RSQRT.fmt */
19357 { pool , FLOOR_L_fmt , 2 , 32,
19358 0xfc003fff, 0xa000033b, 0 , 0,
19359 CP1_ }, /* FLOOR.L.fmt */
19360 { reserved_block , 0 , 0 , 32,
19361 0xfc003fff, 0xa000043b, 0 , 0,
19362 CP1_ }, /* POOL32Fxf_0~*(4) */
19363 { reserved_block , 0 , 0 , 32,
19364 0xfc003fff, 0xa000053b, 0 , 0,
19365 CP1_ }, /* POOL32Fxf_0~*(5) */
19366 { reserved_block , 0 , 0 , 32,
19367 0xfc003fff, 0xa000063b, 0 , 0,
19368 CP1_ }, /* POOL32Fxf_0~*(6) */
19369 { reserved_block , 0 , 0 , 32,
19370 0xfc003fff, 0xa000073b, 0 , 0,
19371 CP1_ }, /* POOL32Fxf_0~*(7) */
19372 { reserved_block , 0 , 0 , 32,
19373 0xfc003fff, 0xa000083b, 0 , 0,
19374 CP1_ }, /* POOL32Fxf_0~*(8) */
19375 { pool , CVT_W_fmt , 2 , 32,
19376 0xfc003fff, 0xa000093b, 0 , 0,
19377 CP1_ }, /* CVT.W.fmt */
19378 { pool , SQRT_fmt , 2 , 32,
19379 0xfc003fff, 0xa0000a3b, 0 , 0,
19380 CP1_ }, /* SQRT.fmt */
19381 { pool , FLOOR_W_fmt , 2 , 32,
19382 0xfc003fff, 0xa0000b3b, 0 , 0,
19383 CP1_ }, /* FLOOR.W.fmt */
19384 { reserved_block , 0 , 0 , 32,
19385 0xfc003fff, 0xa0000c3b, 0 , 0,
19386 CP1_ }, /* POOL32Fxf_0~*(12) */
19387 { reserved_block , 0 , 0 , 32,
19388 0xfc003fff, 0xa0000d3b, 0 , 0,
19389 CP1_ }, /* POOL32Fxf_0~*(13) */
19390 { reserved_block , 0 , 0 , 32,
19391 0xfc003fff, 0xa0000e3b, 0 , 0,
19392 CP1_ }, /* POOL32Fxf_0~*(14) */
19393 { reserved_block , 0 , 0 , 32,
19394 0xfc003fff, 0xa0000f3b, 0 , 0,
19395 CP1_ }, /* POOL32Fxf_0~*(15) */
19396 { instruction , 0 , 0 , 32,
19397 0xfc003fff, 0xa000103b, &CFC1 , 0,
19398 CP1_ }, /* CFC1 */
19399 { reserved_block , 0 , 0 , 32,
19400 0xfc003fff, 0xa000113b, 0 , 0,
19401 CP1_ }, /* POOL32Fxf_0~*(17) */
19402 { pool , RECIP_fmt , 2 , 32,
19403 0xfc003fff, 0xa000123b, 0 , 0,
19404 CP1_ }, /* RECIP.fmt */
19405 { pool , CEIL_L_fmt , 2 , 32,
19406 0xfc003fff, 0xa000133b, 0 , 0,
19407 CP1_ }, /* CEIL.L.fmt */
19408 { reserved_block , 0 , 0 , 32,
19409 0xfc003fff, 0xa000143b, 0 , 0,
19410 CP1_ }, /* POOL32Fxf_0~*(20) */
19411 { reserved_block , 0 , 0 , 32,
19412 0xfc003fff, 0xa000153b, 0 , 0,
19413 CP1_ }, /* POOL32Fxf_0~*(21) */
19414 { reserved_block , 0 , 0 , 32,
19415 0xfc003fff, 0xa000163b, 0 , 0,
19416 CP1_ }, /* POOL32Fxf_0~*(22) */
19417 { reserved_block , 0 , 0 , 32,
19418 0xfc003fff, 0xa000173b, 0 , 0,
19419 CP1_ }, /* POOL32Fxf_0~*(23) */
19420 { instruction , 0 , 0 , 32,
19421 0xfc003fff, 0xa000183b, &CTC1 , 0,
19422 CP1_ }, /* CTC1 */
19423 { reserved_block , 0 , 0 , 32,
19424 0xfc003fff, 0xa000193b, 0 , 0,
19425 CP1_ }, /* POOL32Fxf_0~*(25) */
19426 { reserved_block , 0 , 0 , 32,
19427 0xfc003fff, 0xa0001a3b, 0 , 0,
19428 CP1_ }, /* POOL32Fxf_0~*(26) */
19429 { pool , CEIL_W_fmt , 2 , 32,
19430 0xfc003fff, 0xa0001b3b, 0 , 0,
19431 CP1_ }, /* CEIL.W.fmt */
19432 { reserved_block , 0 , 0 , 32,
19433 0xfc003fff, 0xa0001c3b, 0 , 0,
19434 CP1_ }, /* POOL32Fxf_0~*(28) */
19435 { reserved_block , 0 , 0 , 32,
19436 0xfc003fff, 0xa0001d3b, 0 , 0,
19437 CP1_ }, /* POOL32Fxf_0~*(29) */
19438 { reserved_block , 0 , 0 , 32,
19439 0xfc003fff, 0xa0001e3b, 0 , 0,
19440 CP1_ }, /* POOL32Fxf_0~*(30) */
19441 { reserved_block , 0 , 0 , 32,
19442 0xfc003fff, 0xa0001f3b, 0 , 0,
19443 CP1_ }, /* POOL32Fxf_0~*(31) */
19444 { instruction , 0 , 0 , 32,
19445 0xfc003fff, 0xa000203b, &MFC1 , 0,
19446 CP1_ }, /* MFC1 */
19447 { instruction , 0 , 0 , 32,
19448 0xfc003fff, 0xa000213b, &CVT_S_PL , 0,
19449 CP1_ }, /* CVT.S.PL */
19450 { reserved_block , 0 , 0 , 32,
19451 0xfc003fff, 0xa000223b, 0 , 0,
19452 CP1_ }, /* POOL32Fxf_0~*(34) */
19453 { pool , TRUNC_L_fmt , 2 , 32,
19454 0xfc003fff, 0xa000233b, 0 , 0,
19455 CP1_ }, /* TRUNC.L.fmt */
19456 { instruction , 0 , 0 , 32,
19457 0xfc003fff, 0xa000243b, &DMFC1 , 0,
19458 CP1_ | MIPS64_ }, /* DMFC1 */
19459 { reserved_block , 0 , 0 , 32,
19460 0xfc003fff, 0xa000253b, 0 , 0,
19461 CP1_ }, /* POOL32Fxf_0~*(37) */
19462 { reserved_block , 0 , 0 , 32,
19463 0xfc003fff, 0xa000263b, 0 , 0,
19464 CP1_ }, /* POOL32Fxf_0~*(38) */
19465 { reserved_block , 0 , 0 , 32,
19466 0xfc003fff, 0xa000273b, 0 , 0,
19467 CP1_ }, /* POOL32Fxf_0~*(39) */
19468 { instruction , 0 , 0 , 32,
19469 0xfc003fff, 0xa000283b, &MTC1 , 0,
19470 CP1_ }, /* MTC1 */
19471 { instruction , 0 , 0 , 32,
19472 0xfc003fff, 0xa000293b, &CVT_S_PU , 0,
19473 CP1_ }, /* CVT.S.PU */
19474 { reserved_block , 0 , 0 , 32,
19475 0xfc003fff, 0xa0002a3b, 0 , 0,
19476 CP1_ }, /* POOL32Fxf_0~*(42) */
19477 { pool , TRUNC_W_fmt , 2 , 32,
19478 0xfc003fff, 0xa0002b3b, 0 , 0,
19479 CP1_ }, /* TRUNC.W.fmt */
19480 { instruction , 0 , 0 , 32,
19481 0xfc003fff, 0xa0002c3b, &DMTC1 , 0,
19482 CP1_ | MIPS64_ }, /* DMTC1 */
19483 { reserved_block , 0 , 0 , 32,
19484 0xfc003fff, 0xa0002d3b, 0 , 0,
19485 CP1_ }, /* POOL32Fxf_0~*(45) */
19486 { reserved_block , 0 , 0 , 32,
19487 0xfc003fff, 0xa0002e3b, 0 , 0,
19488 CP1_ }, /* POOL32Fxf_0~*(46) */
19489 { reserved_block , 0 , 0 , 32,
19490 0xfc003fff, 0xa0002f3b, 0 , 0,
19491 CP1_ }, /* POOL32Fxf_0~*(47) */
19492 { instruction , 0 , 0 , 32,
19493 0xfc003fff, 0xa000303b, &MFHC1 , 0,
19494 CP1_ }, /* MFHC1 */
19495 { reserved_block , 0 , 0 , 32,
19496 0xfc003fff, 0xa000313b, 0 , 0,
19497 CP1_ }, /* POOL32Fxf_0~*(49) */
19498 { reserved_block , 0 , 0 , 32,
19499 0xfc003fff, 0xa000323b, 0 , 0,
19500 CP1_ }, /* POOL32Fxf_0~*(50) */
19501 { pool , ROUND_L_fmt , 2 , 32,
19502 0xfc003fff, 0xa000333b, 0 , 0,
19503 CP1_ }, /* ROUND.L.fmt */
19504 { reserved_block , 0 , 0 , 32,
19505 0xfc003fff, 0xa000343b, 0 , 0,
19506 CP1_ }, /* POOL32Fxf_0~*(52) */
19507 { reserved_block , 0 , 0 , 32,
19508 0xfc003fff, 0xa000353b, 0 , 0,
19509 CP1_ }, /* POOL32Fxf_0~*(53) */
19510 { reserved_block , 0 , 0 , 32,
19511 0xfc003fff, 0xa000363b, 0 , 0,
19512 CP1_ }, /* POOL32Fxf_0~*(54) */
19513 { reserved_block , 0 , 0 , 32,
19514 0xfc003fff, 0xa000373b, 0 , 0,
19515 CP1_ }, /* POOL32Fxf_0~*(55) */
19516 { instruction , 0 , 0 , 32,
19517 0xfc003fff, 0xa000383b, &MTHC1 , 0,
19518 CP1_ }, /* MTHC1 */
19519 { reserved_block , 0 , 0 , 32,
19520 0xfc003fff, 0xa000393b, 0 , 0,
19521 CP1_ }, /* POOL32Fxf_0~*(57) */
19522 { reserved_block , 0 , 0 , 32,
19523 0xfc003fff, 0xa0003a3b, 0 , 0,
19524 CP1_ }, /* POOL32Fxf_0~*(58) */
19525 { pool , ROUND_W_fmt , 2 , 32,
19526 0xfc003fff, 0xa0003b3b, 0 , 0,
19527 CP1_ }, /* ROUND.W.fmt */
19528 { reserved_block , 0 , 0 , 32,
19529 0xfc003fff, 0xa0003c3b, 0 , 0,
19530 CP1_ }, /* POOL32Fxf_0~*(60) */
19531 { reserved_block , 0 , 0 , 32,
19532 0xfc003fff, 0xa0003d3b, 0 , 0,
19533 CP1_ }, /* POOL32Fxf_0~*(61) */
19534 { reserved_block , 0 , 0 , 32,
19535 0xfc003fff, 0xa0003e3b, 0 , 0,
19536 CP1_ }, /* POOL32Fxf_0~*(62) */
19537 { reserved_block , 0 , 0 , 32,
19538 0xfc003fff, 0xa0003f3b, 0 , 0,
19539 CP1_ }, /* POOL32Fxf_0~*(63) */
19540 };
19541
19542
19543 static const Pool MOV_fmt[4] = {
19544 { instruction , 0 , 0 , 32,
19545 0xfc007fff, 0xa000007b, &MOV_S , 0,
19546 CP1_ }, /* MOV.S */
19547 { instruction , 0 , 0 , 32,
19548 0xfc007fff, 0xa000207b, &MOV_D , 0,
19549 CP1_ }, /* MOV.D */
19550 { reserved_block , 0 , 0 , 32,
19551 0xfc007fff, 0xa000407b, 0 , 0,
19552 CP1_ }, /* MOV.fmt~*(2) */
19553 { reserved_block , 0 , 0 , 32,
19554 0xfc007fff, 0xa000607b, 0 , 0,
19555 CP1_ }, /* MOV.fmt~*(3) */
19556 };
19557
19558
19559 static const Pool ABS_fmt[4] = {
19560 { instruction , 0 , 0 , 32,
19561 0xfc007fff, 0xa000037b, &ABS_S , 0,
19562 CP1_ }, /* ABS.S */
19563 { instruction , 0 , 0 , 32,
19564 0xfc007fff, 0xa000237b, &ABS_D , 0,
19565 CP1_ }, /* ABS.D */
19566 { reserved_block , 0 , 0 , 32,
19567 0xfc007fff, 0xa000437b, 0 , 0,
19568 CP1_ }, /* ABS.fmt~*(2) */
19569 { reserved_block , 0 , 0 , 32,
19570 0xfc007fff, 0xa000637b, 0 , 0,
19571 CP1_ }, /* ABS.fmt~*(3) */
19572 };
19573
19574
19575 static const Pool NEG_fmt[4] = {
19576 { instruction , 0 , 0 , 32,
19577 0xfc007fff, 0xa0000b7b, &NEG_S , 0,
19578 CP1_ }, /* NEG.S */
19579 { instruction , 0 , 0 , 32,
19580 0xfc007fff, 0xa0002b7b, &NEG_D , 0,
19581 CP1_ }, /* NEG.D */
19582 { reserved_block , 0 , 0 , 32,
19583 0xfc007fff, 0xa0004b7b, 0 , 0,
19584 CP1_ }, /* NEG.fmt~*(2) */
19585 { reserved_block , 0 , 0 , 32,
19586 0xfc007fff, 0xa0006b7b, 0 , 0,
19587 CP1_ }, /* NEG.fmt~*(3) */
19588 };
19589
19590
19591 static const Pool CVT_D_fmt[4] = {
19592 { instruction , 0 , 0 , 32,
19593 0xfc007fff, 0xa000137b, &CVT_D_S , 0,
19594 CP1_ }, /* CVT.D.S */
19595 { instruction , 0 , 0 , 32,
19596 0xfc007fff, 0xa000337b, &CVT_D_W , 0,
19597 CP1_ }, /* CVT.D.W */
19598 { instruction , 0 , 0 , 32,
19599 0xfc007fff, 0xa000537b, &CVT_D_L , 0,
19600 CP1_ }, /* CVT.D.L */
19601 { reserved_block , 0 , 0 , 32,
19602 0xfc007fff, 0xa000737b, 0 , 0,
19603 CP1_ }, /* CVT.D.fmt~*(3) */
19604 };
19605
19606
19607 static const Pool CVT_S_fmt[4] = {
19608 { instruction , 0 , 0 , 32,
19609 0xfc007fff, 0xa0001b7b, &CVT_S_D , 0,
19610 CP1_ }, /* CVT.S.D */
19611 { instruction , 0 , 0 , 32,
19612 0xfc007fff, 0xa0003b7b, &CVT_S_W , 0,
19613 CP1_ }, /* CVT.S.W */
19614 { instruction , 0 , 0 , 32,
19615 0xfc007fff, 0xa0005b7b, &CVT_S_L , 0,
19616 CP1_ }, /* CVT.S.L */
19617 { reserved_block , 0 , 0 , 32,
19618 0xfc007fff, 0xa0007b7b, 0 , 0,
19619 CP1_ }, /* CVT.S.fmt~*(3) */
19620 };
19621
19622
19623 static const Pool POOL32Fxf_1[32] = {
19624 { pool , MOV_fmt , 4 , 32,
19625 0xfc001fff, 0xa000007b, 0 , 0,
19626 CP1_ }, /* MOV.fmt */
19627 { reserved_block , 0 , 0 , 32,
19628 0xfc001fff, 0xa000017b, 0 , 0,
19629 CP1_ }, /* POOL32Fxf_1~*(1) */
19630 { reserved_block , 0 , 0 , 32,
19631 0xfc001fff, 0xa000027b, 0 , 0,
19632 CP1_ }, /* POOL32Fxf_1~*(2) */
19633 { pool , ABS_fmt , 4 , 32,
19634 0xfc001fff, 0xa000037b, 0 , 0,
19635 CP1_ }, /* ABS.fmt */
19636 { reserved_block , 0 , 0 , 32,
19637 0xfc001fff, 0xa000047b, 0 , 0,
19638 CP1_ }, /* POOL32Fxf_1~*(4) */
19639 { reserved_block , 0 , 0 , 32,
19640 0xfc001fff, 0xa000057b, 0 , 0,
19641 CP1_ }, /* POOL32Fxf_1~*(5) */
19642 { reserved_block , 0 , 0 , 32,
19643 0xfc001fff, 0xa000067b, 0 , 0,
19644 CP1_ }, /* POOL32Fxf_1~*(6) */
19645 { reserved_block , 0 , 0 , 32,
19646 0xfc001fff, 0xa000077b, 0 , 0,
19647 CP1_ }, /* POOL32Fxf_1~*(7) */
19648 { reserved_block , 0 , 0 , 32,
19649 0xfc001fff, 0xa000087b, 0 , 0,
19650 CP1_ }, /* POOL32Fxf_1~*(8) */
19651 { reserved_block , 0 , 0 , 32,
19652 0xfc001fff, 0xa000097b, 0 , 0,
19653 CP1_ }, /* POOL32Fxf_1~*(9) */
19654 { reserved_block , 0 , 0 , 32,
19655 0xfc001fff, 0xa0000a7b, 0 , 0,
19656 CP1_ }, /* POOL32Fxf_1~*(10) */
19657 { pool , NEG_fmt , 4 , 32,
19658 0xfc001fff, 0xa0000b7b, 0 , 0,
19659 CP1_ }, /* NEG.fmt */
19660 { reserved_block , 0 , 0 , 32,
19661 0xfc001fff, 0xa0000c7b, 0 , 0,
19662 CP1_ }, /* POOL32Fxf_1~*(12) */
19663 { reserved_block , 0 , 0 , 32,
19664 0xfc001fff, 0xa0000d7b, 0 , 0,
19665 CP1_ }, /* POOL32Fxf_1~*(13) */
19666 { reserved_block , 0 , 0 , 32,
19667 0xfc001fff, 0xa0000e7b, 0 , 0,
19668 CP1_ }, /* POOL32Fxf_1~*(14) */
19669 { reserved_block , 0 , 0 , 32,
19670 0xfc001fff, 0xa0000f7b, 0 , 0,
19671 CP1_ }, /* POOL32Fxf_1~*(15) */
19672 { reserved_block , 0 , 0 , 32,
19673 0xfc001fff, 0xa000107b, 0 , 0,
19674 CP1_ }, /* POOL32Fxf_1~*(16) */
19675 { reserved_block , 0 , 0 , 32,
19676 0xfc001fff, 0xa000117b, 0 , 0,
19677 CP1_ }, /* POOL32Fxf_1~*(17) */
19678 { reserved_block , 0 , 0 , 32,
19679 0xfc001fff, 0xa000127b, 0 , 0,
19680 CP1_ }, /* POOL32Fxf_1~*(18) */
19681 { pool , CVT_D_fmt , 4 , 32,
19682 0xfc001fff, 0xa000137b, 0 , 0,
19683 CP1_ }, /* CVT.D.fmt */
19684 { reserved_block , 0 , 0 , 32,
19685 0xfc001fff, 0xa000147b, 0 , 0,
19686 CP1_ }, /* POOL32Fxf_1~*(20) */
19687 { reserved_block , 0 , 0 , 32,
19688 0xfc001fff, 0xa000157b, 0 , 0,
19689 CP1_ }, /* POOL32Fxf_1~*(21) */
19690 { reserved_block , 0 , 0 , 32,
19691 0xfc001fff, 0xa000167b, 0 , 0,
19692 CP1_ }, /* POOL32Fxf_1~*(22) */
19693 { reserved_block , 0 , 0 , 32,
19694 0xfc001fff, 0xa000177b, 0 , 0,
19695 CP1_ }, /* POOL32Fxf_1~*(23) */
19696 { reserved_block , 0 , 0 , 32,
19697 0xfc001fff, 0xa000187b, 0 , 0,
19698 CP1_ }, /* POOL32Fxf_1~*(24) */
19699 { reserved_block , 0 , 0 , 32,
19700 0xfc001fff, 0xa000197b, 0 , 0,
19701 CP1_ }, /* POOL32Fxf_1~*(25) */
19702 { reserved_block , 0 , 0 , 32,
19703 0xfc001fff, 0xa0001a7b, 0 , 0,
19704 CP1_ }, /* POOL32Fxf_1~*(26) */
19705 { pool , CVT_S_fmt , 4 , 32,
19706 0xfc001fff, 0xa0001b7b, 0 , 0,
19707 CP1_ }, /* CVT.S.fmt */
19708 { reserved_block , 0 , 0 , 32,
19709 0xfc001fff, 0xa0001c7b, 0 , 0,
19710 CP1_ }, /* POOL32Fxf_1~*(28) */
19711 { reserved_block , 0 , 0 , 32,
19712 0xfc001fff, 0xa0001d7b, 0 , 0,
19713 CP1_ }, /* POOL32Fxf_1~*(29) */
19714 { reserved_block , 0 , 0 , 32,
19715 0xfc001fff, 0xa0001e7b, 0 , 0,
19716 CP1_ }, /* POOL32Fxf_1~*(30) */
19717 { reserved_block , 0 , 0 , 32,
19718 0xfc001fff, 0xa0001f7b, 0 , 0,
19719 CP1_ }, /* POOL32Fxf_1~*(31) */
19720 };
19721
19722
19723 static const Pool POOL32Fxf[4] = {
19724 { pool , POOL32Fxf_0 , 64 , 32,
19725 0xfc0000ff, 0xa000003b, 0 , 0,
19726 CP1_ }, /* POOL32Fxf_0 */
19727 { pool , POOL32Fxf_1 , 32 , 32,
19728 0xfc0000ff, 0xa000007b, 0 , 0,
19729 CP1_ }, /* POOL32Fxf_1 */
19730 { reserved_block , 0 , 0 , 32,
19731 0xfc0000ff, 0xa00000bb, 0 , 0,
19732 CP1_ }, /* POOL32Fxf~*(2) */
19733 { reserved_block , 0 , 0 , 32,
19734 0xfc0000ff, 0xa00000fb, 0 , 0,
19735 CP1_ }, /* POOL32Fxf~*(3) */
19736 };
19737
19738
19739 static const Pool POOL32F_3[8] = {
19740 { pool , MIN_fmt , 2 , 32,
19741 0xfc00003f, 0xa0000003, 0 , 0,
19742 CP1_ }, /* MIN.fmt */
19743 { pool , MAX_fmt , 2 , 32,
19744 0xfc00003f, 0xa000000b, 0 , 0,
19745 CP1_ }, /* MAX.fmt */
19746 { reserved_block , 0 , 0 , 32,
19747 0xfc00003f, 0xa0000013, 0 , 0,
19748 CP1_ }, /* POOL32F_3~*(2) */
19749 { reserved_block , 0 , 0 , 32,
19750 0xfc00003f, 0xa000001b, 0 , 0,
19751 CP1_ }, /* POOL32F_3~*(3) */
19752 { pool , MINA_fmt , 2 , 32,
19753 0xfc00003f, 0xa0000023, 0 , 0,
19754 CP1_ }, /* MINA.fmt */
19755 { pool , MAXA_fmt , 2 , 32,
19756 0xfc00003f, 0xa000002b, 0 , 0,
19757 CP1_ }, /* MAXA.fmt */
19758 { reserved_block , 0 , 0 , 32,
19759 0xfc00003f, 0xa0000033, 0 , 0,
19760 CP1_ }, /* POOL32F_3~*(6) */
19761 { pool , POOL32Fxf , 4 , 32,
19762 0xfc00003f, 0xa000003b, 0 , 0,
19763 CP1_ }, /* POOL32Fxf */
19764 };
19765
19766
19767 static const Pool CMP_condn_S[32] = {
19768 { instruction , 0 , 0 , 32,
19769 0xfc0007ff, 0xa0000005, &CMP_AF_S , 0,
19770 CP1_ }, /* CMP.AF.S */
19771 { instruction , 0 , 0 , 32,
19772 0xfc0007ff, 0xa0000045, &CMP_UN_S , 0,
19773 CP1_ }, /* CMP.UN.S */
19774 { instruction , 0 , 0 , 32,
19775 0xfc0007ff, 0xa0000085, &CMP_EQ_S , 0,
19776 CP1_ }, /* CMP.EQ.S */
19777 { instruction , 0 , 0 , 32,
19778 0xfc0007ff, 0xa00000c5, &CMP_UEQ_S , 0,
19779 CP1_ }, /* CMP.UEQ.S */
19780 { instruction , 0 , 0 , 32,
19781 0xfc0007ff, 0xa0000105, &CMP_LT_S , 0,
19782 CP1_ }, /* CMP.LT.S */
19783 { instruction , 0 , 0 , 32,
19784 0xfc0007ff, 0xa0000145, &CMP_ULT_S , 0,
19785 CP1_ }, /* CMP.ULT.S */
19786 { instruction , 0 , 0 , 32,
19787 0xfc0007ff, 0xa0000185, &CMP_LE_S , 0,
19788 CP1_ }, /* CMP.LE.S */
19789 { instruction , 0 , 0 , 32,
19790 0xfc0007ff, 0xa00001c5, &CMP_ULE_S , 0,
19791 CP1_ }, /* CMP.ULE.S */
19792 { instruction , 0 , 0 , 32,
19793 0xfc0007ff, 0xa0000205, &CMP_SAF_S , 0,
19794 CP1_ }, /* CMP.SAF.S */
19795 { instruction , 0 , 0 , 32,
19796 0xfc0007ff, 0xa0000245, &CMP_SUN_S , 0,
19797 CP1_ }, /* CMP.SUN.S */
19798 { instruction , 0 , 0 , 32,
19799 0xfc0007ff, 0xa0000285, &CMP_SEQ_S , 0,
19800 CP1_ }, /* CMP.SEQ.S */
19801 { instruction , 0 , 0 , 32,
19802 0xfc0007ff, 0xa00002c5, &CMP_SUEQ_S , 0,
19803 CP1_ }, /* CMP.SUEQ.S */
19804 { instruction , 0 , 0 , 32,
19805 0xfc0007ff, 0xa0000305, &CMP_SLT_S , 0,
19806 CP1_ }, /* CMP.SLT.S */
19807 { instruction , 0 , 0 , 32,
19808 0xfc0007ff, 0xa0000345, &CMP_SULT_S , 0,
19809 CP1_ }, /* CMP.SULT.S */
19810 { instruction , 0 , 0 , 32,
19811 0xfc0007ff, 0xa0000385, &CMP_SLE_S , 0,
19812 CP1_ }, /* CMP.SLE.S */
19813 { instruction , 0 , 0 , 32,
19814 0xfc0007ff, 0xa00003c5, &CMP_SULE_S , 0,
19815 CP1_ }, /* CMP.SULE.S */
19816 { reserved_block , 0 , 0 , 32,
19817 0xfc0007ff, 0xa0000405, 0 , 0,
19818 CP1_ }, /* CMP.condn.S~*(16) */
19819 { instruction , 0 , 0 , 32,
19820 0xfc0007ff, 0xa0000445, &CMP_OR_S , 0,
19821 CP1_ }, /* CMP.OR.S */
19822 { instruction , 0 , 0 , 32,
19823 0xfc0007ff, 0xa0000485, &CMP_UNE_S , 0,
19824 CP1_ }, /* CMP.UNE.S */
19825 { instruction , 0 , 0 , 32,
19826 0xfc0007ff, 0xa00004c5, &CMP_NE_S , 0,
19827 CP1_ }, /* CMP.NE.S */
19828 { reserved_block , 0 , 0 , 32,
19829 0xfc0007ff, 0xa0000505, 0 , 0,
19830 CP1_ }, /* CMP.condn.S~*(20) */
19831 { reserved_block , 0 , 0 , 32,
19832 0xfc0007ff, 0xa0000545, 0 , 0,
19833 CP1_ }, /* CMP.condn.S~*(21) */
19834 { reserved_block , 0 , 0 , 32,
19835 0xfc0007ff, 0xa0000585, 0 , 0,
19836 CP1_ }, /* CMP.condn.S~*(22) */
19837 { reserved_block , 0 , 0 , 32,
19838 0xfc0007ff, 0xa00005c5, 0 , 0,
19839 CP1_ }, /* CMP.condn.S~*(23) */
19840 { reserved_block , 0 , 0 , 32,
19841 0xfc0007ff, 0xa0000605, 0 , 0,
19842 CP1_ }, /* CMP.condn.S~*(24) */
19843 { instruction , 0 , 0 , 32,
19844 0xfc0007ff, 0xa0000645, &CMP_SOR_S , 0,
19845 CP1_ }, /* CMP.SOR.S */
19846 { instruction , 0 , 0 , 32,
19847 0xfc0007ff, 0xa0000685, &CMP_SUNE_S , 0,
19848 CP1_ }, /* CMP.SUNE.S */
19849 { instruction , 0 , 0 , 32,
19850 0xfc0007ff, 0xa00006c5, &CMP_SNE_S , 0,
19851 CP1_ }, /* CMP.SNE.S */
19852 { reserved_block , 0 , 0 , 32,
19853 0xfc0007ff, 0xa0000705, 0 , 0,
19854 CP1_ }, /* CMP.condn.S~*(28) */
19855 { reserved_block , 0 , 0 , 32,
19856 0xfc0007ff, 0xa0000745, 0 , 0,
19857 CP1_ }, /* CMP.condn.S~*(29) */
19858 { reserved_block , 0 , 0 , 32,
19859 0xfc0007ff, 0xa0000785, 0 , 0,
19860 CP1_ }, /* CMP.condn.S~*(30) */
19861 { reserved_block , 0 , 0 , 32,
19862 0xfc0007ff, 0xa00007c5, 0 , 0,
19863 CP1_ }, /* CMP.condn.S~*(31) */
19864 };
19865
19866
19867 static const Pool CMP_condn_D[32] = {
19868 { instruction , 0 , 0 , 32,
19869 0xfc0007ff, 0xa0000015, &CMP_AF_D , 0,
19870 CP1_ }, /* CMP.AF.D */
19871 { instruction , 0 , 0 , 32,
19872 0xfc0007ff, 0xa0000055, &CMP_UN_D , 0,
19873 CP1_ }, /* CMP.UN.D */
19874 { instruction , 0 , 0 , 32,
19875 0xfc0007ff, 0xa0000095, &CMP_EQ_D , 0,
19876 CP1_ }, /* CMP.EQ.D */
19877 { instruction , 0 , 0 , 32,
19878 0xfc0007ff, 0xa00000d5, &CMP_UEQ_D , 0,
19879 CP1_ }, /* CMP.UEQ.D */
19880 { instruction , 0 , 0 , 32,
19881 0xfc0007ff, 0xa0000115, &CMP_LT_D , 0,
19882 CP1_ }, /* CMP.LT.D */
19883 { instruction , 0 , 0 , 32,
19884 0xfc0007ff, 0xa0000155, &CMP_ULT_D , 0,
19885 CP1_ }, /* CMP.ULT.D */
19886 { instruction , 0 , 0 , 32,
19887 0xfc0007ff, 0xa0000195, &CMP_LE_D , 0,
19888 CP1_ }, /* CMP.LE.D */
19889 { instruction , 0 , 0 , 32,
19890 0xfc0007ff, 0xa00001d5, &CMP_ULE_D , 0,
19891 CP1_ }, /* CMP.ULE.D */
19892 { instruction , 0 , 0 , 32,
19893 0xfc0007ff, 0xa0000215, &CMP_SAF_D , 0,
19894 CP1_ }, /* CMP.SAF.D */
19895 { instruction , 0 , 0 , 32,
19896 0xfc0007ff, 0xa0000255, &CMP_SUN_D , 0,
19897 CP1_ }, /* CMP.SUN.D */
19898 { instruction , 0 , 0 , 32,
19899 0xfc0007ff, 0xa0000295, &CMP_SEQ_D , 0,
19900 CP1_ }, /* CMP.SEQ.D */
19901 { instruction , 0 , 0 , 32,
19902 0xfc0007ff, 0xa00002d5, &CMP_SUEQ_D , 0,
19903 CP1_ }, /* CMP.SUEQ.D */
19904 { instruction , 0 , 0 , 32,
19905 0xfc0007ff, 0xa0000315, &CMP_SLT_D , 0,
19906 CP1_ }, /* CMP.SLT.D */
19907 { instruction , 0 , 0 , 32,
19908 0xfc0007ff, 0xa0000355, &CMP_SULT_D , 0,
19909 CP1_ }, /* CMP.SULT.D */
19910 { instruction , 0 , 0 , 32,
19911 0xfc0007ff, 0xa0000395, &CMP_SLE_D , 0,
19912 CP1_ }, /* CMP.SLE.D */
19913 { instruction , 0 , 0 , 32,
19914 0xfc0007ff, 0xa00003d5, &CMP_SULE_D , 0,
19915 CP1_ }, /* CMP.SULE.D */
19916 { reserved_block , 0 , 0 , 32,
19917 0xfc0007ff, 0xa0000415, 0 , 0,
19918 CP1_ }, /* CMP.condn.D~*(16) */
19919 { instruction , 0 , 0 , 32,
19920 0xfc0007ff, 0xa0000455, &CMP_OR_D , 0,
19921 CP1_ }, /* CMP.OR.D */
19922 { instruction , 0 , 0 , 32,
19923 0xfc0007ff, 0xa0000495, &CMP_UNE_D , 0,
19924 CP1_ }, /* CMP.UNE.D */
19925 { instruction , 0 , 0 , 32,
19926 0xfc0007ff, 0xa00004d5, &CMP_NE_D , 0,
19927 CP1_ }, /* CMP.NE.D */
19928 { reserved_block , 0 , 0 , 32,
19929 0xfc0007ff, 0xa0000515, 0 , 0,
19930 CP1_ }, /* CMP.condn.D~*(20) */
19931 { reserved_block , 0 , 0 , 32,
19932 0xfc0007ff, 0xa0000555, 0 , 0,
19933 CP1_ }, /* CMP.condn.D~*(21) */
19934 { reserved_block , 0 , 0 , 32,
19935 0xfc0007ff, 0xa0000595, 0 , 0,
19936 CP1_ }, /* CMP.condn.D~*(22) */
19937 { reserved_block , 0 , 0 , 32,
19938 0xfc0007ff, 0xa00005d5, 0 , 0,
19939 CP1_ }, /* CMP.condn.D~*(23) */
19940 { reserved_block , 0 , 0 , 32,
19941 0xfc0007ff, 0xa0000615, 0 , 0,
19942 CP1_ }, /* CMP.condn.D~*(24) */
19943 { instruction , 0 , 0 , 32,
19944 0xfc0007ff, 0xa0000655, &CMP_SOR_D , 0,
19945 CP1_ }, /* CMP.SOR.D */
19946 { instruction , 0 , 0 , 32,
19947 0xfc0007ff, 0xa0000695, &CMP_SUNE_D , 0,
19948 CP1_ }, /* CMP.SUNE.D */
19949 { instruction , 0 , 0 , 32,
19950 0xfc0007ff, 0xa00006d5, &CMP_SNE_D , 0,
19951 CP1_ }, /* CMP.SNE.D */
19952 { reserved_block , 0 , 0 , 32,
19953 0xfc0007ff, 0xa0000715, 0 , 0,
19954 CP1_ }, /* CMP.condn.D~*(28) */
19955 { reserved_block , 0 , 0 , 32,
19956 0xfc0007ff, 0xa0000755, 0 , 0,
19957 CP1_ }, /* CMP.condn.D~*(29) */
19958 { reserved_block , 0 , 0 , 32,
19959 0xfc0007ff, 0xa0000795, 0 , 0,
19960 CP1_ }, /* CMP.condn.D~*(30) */
19961 { reserved_block , 0 , 0 , 32,
19962 0xfc0007ff, 0xa00007d5, 0 , 0,
19963 CP1_ }, /* CMP.condn.D~*(31) */
19964 };
19965
19966
19967 static const Pool POOL32F_5[8] = {
19968 { pool , CMP_condn_S , 32 , 32,
19969 0xfc00003f, 0xa0000005, 0 , 0,
19970 CP1_ }, /* CMP.condn.S */
19971 { reserved_block , 0 , 0 , 32,
19972 0xfc00003f, 0xa000000d, 0 , 0,
19973 CP1_ }, /* POOL32F_5~*(1) */
19974 { pool , CMP_condn_D , 32 , 32,
19975 0xfc00003f, 0xa0000015, 0 , 0,
19976 CP1_ }, /* CMP.condn.D */
19977 { reserved_block , 0 , 0 , 32,
19978 0xfc00003f, 0xa000001d, 0 , 0,
19979 CP1_ }, /* POOL32F_5~*(3) */
19980 { reserved_block , 0 , 0 , 32,
19981 0xfc00003f, 0xa0000025, 0 , 0,
19982 CP1_ }, /* POOL32F_5~*(4) */
19983 { reserved_block , 0 , 0 , 32,
19984 0xfc00003f, 0xa000002d, 0 , 0,
19985 CP1_ }, /* POOL32F_5~*(5) */
19986 { reserved_block , 0 , 0 , 32,
19987 0xfc00003f, 0xa0000035, 0 , 0,
19988 CP1_ }, /* POOL32F_5~*(6) */
19989 { reserved_block , 0 , 0 , 32,
19990 0xfc00003f, 0xa000003d, 0 , 0,
19991 CP1_ }, /* POOL32F_5~*(7) */
19992 };
19993
19994
19995 static const Pool POOL32F[8] = {
19996 { pool , POOL32F_0 , 64 , 32,
19997 0xfc000007, 0xa0000000, 0 , 0,
19998 CP1_ }, /* POOL32F_0 */
19999 { reserved_block , 0 , 0 , 32,
20000 0xfc000007, 0xa0000001, 0 , 0,
20001 CP1_ }, /* POOL32F~*(1) */
20002 { reserved_block , 0 , 0 , 32,
20003 0xfc000007, 0xa0000002, 0 , 0,
20004 CP1_ }, /* POOL32F~*(2) */
20005 { pool , POOL32F_3 , 8 , 32,
20006 0xfc000007, 0xa0000003, 0 , 0,
20007 CP1_ }, /* POOL32F_3 */
20008 { reserved_block , 0 , 0 , 32,
20009 0xfc000007, 0xa0000004, 0 , 0,
20010 CP1_ }, /* POOL32F~*(4) */
20011 { pool , POOL32F_5 , 8 , 32,
20012 0xfc000007, 0xa0000005, 0 , 0,
20013 CP1_ }, /* POOL32F_5 */
20014 { reserved_block , 0 , 0 , 32,
20015 0xfc000007, 0xa0000006, 0 , 0,
20016 CP1_ }, /* POOL32F~*(6) */
20017 { reserved_block , 0 , 0 , 32,
20018 0xfc000007, 0xa0000007, 0 , 0,
20019 CP1_ }, /* POOL32F~*(7) */
20020 };
20021
20022
20023 static const Pool POOL32S_0[64] = {
20024 { reserved_block , 0 , 0 , 32,
20025 0xfc0001ff, 0xc0000000, 0 , 0,
20026 0x0 }, /* POOL32S_0~*(0) */
20027 { instruction , 0 , 0 , 32,
20028 0xfc0001ff, 0xc0000008, &DLSA , 0,
20029 MIPS64_ }, /* DLSA */
20030 { instruction , 0 , 0 , 32,
20031 0xfc0001ff, 0xc0000010, &DSLLV , 0,
20032 MIPS64_ }, /* DSLLV */
20033 { instruction , 0 , 0 , 32,
20034 0xfc0001ff, 0xc0000018, &DMUL , 0,
20035 MIPS64_ }, /* DMUL */
20036 { reserved_block , 0 , 0 , 32,
20037 0xfc0001ff, 0xc0000020, 0 , 0,
20038 0x0 }, /* POOL32S_0~*(4) */
20039 { reserved_block , 0 , 0 , 32,
20040 0xfc0001ff, 0xc0000028, 0 , 0,
20041 0x0 }, /* POOL32S_0~*(5) */
20042 { reserved_block , 0 , 0 , 32,
20043 0xfc0001ff, 0xc0000030, 0 , 0,
20044 0x0 }, /* POOL32S_0~*(6) */
20045 { reserved_block , 0 , 0 , 32,
20046 0xfc0001ff, 0xc0000038, 0 , 0,
20047 0x0 }, /* POOL32S_0~*(7) */
20048 { reserved_block , 0 , 0 , 32,
20049 0xfc0001ff, 0xc0000040, 0 , 0,
20050 0x0 }, /* POOL32S_0~*(8) */
20051 { reserved_block , 0 , 0 , 32,
20052 0xfc0001ff, 0xc0000048, 0 , 0,
20053 0x0 }, /* POOL32S_0~*(9) */
20054 { instruction , 0 , 0 , 32,
20055 0xfc0001ff, 0xc0000050, &DSRLV , 0,
20056 MIPS64_ }, /* DSRLV */
20057 { instruction , 0 , 0 , 32,
20058 0xfc0001ff, 0xc0000058, &DMUH , 0,
20059 MIPS64_ }, /* DMUH */
20060 { reserved_block , 0 , 0 , 32,
20061 0xfc0001ff, 0xc0000060, 0 , 0,
20062 0x0 }, /* POOL32S_0~*(12) */
20063 { reserved_block , 0 , 0 , 32,
20064 0xfc0001ff, 0xc0000068, 0 , 0,
20065 0x0 }, /* POOL32S_0~*(13) */
20066 { reserved_block , 0 , 0 , 32,
20067 0xfc0001ff, 0xc0000070, 0 , 0,
20068 0x0 }, /* POOL32S_0~*(14) */
20069 { reserved_block , 0 , 0 , 32,
20070 0xfc0001ff, 0xc0000078, 0 , 0,
20071 0x0 }, /* POOL32S_0~*(15) */
20072 { reserved_block , 0 , 0 , 32,
20073 0xfc0001ff, 0xc0000080, 0 , 0,
20074 0x0 }, /* POOL32S_0~*(16) */
20075 { reserved_block , 0 , 0 , 32,
20076 0xfc0001ff, 0xc0000088, 0 , 0,
20077 0x0 }, /* POOL32S_0~*(17) */
20078 { instruction , 0 , 0 , 32,
20079 0xfc0001ff, 0xc0000090, &DSRAV , 0,
20080 MIPS64_ }, /* DSRAV */
20081 { instruction , 0 , 0 , 32,
20082 0xfc0001ff, 0xc0000098, &DMULU , 0,
20083 MIPS64_ }, /* DMULU */
20084 { reserved_block , 0 , 0 , 32,
20085 0xfc0001ff, 0xc00000a0, 0 , 0,
20086 0x0 }, /* POOL32S_0~*(20) */
20087 { reserved_block , 0 , 0 , 32,
20088 0xfc0001ff, 0xc00000a8, 0 , 0,
20089 0x0 }, /* POOL32S_0~*(21) */
20090 { reserved_block , 0 , 0 , 32,
20091 0xfc0001ff, 0xc00000b0, 0 , 0,
20092 0x0 }, /* POOL32S_0~*(22) */
20093 { reserved_block , 0 , 0 , 32,
20094 0xfc0001ff, 0xc00000b8, 0 , 0,
20095 0x0 }, /* POOL32S_0~*(23) */
20096 { reserved_block , 0 , 0 , 32,
20097 0xfc0001ff, 0xc00000c0, 0 , 0,
20098 0x0 }, /* POOL32S_0~*(24) */
20099 { reserved_block , 0 , 0 , 32,
20100 0xfc0001ff, 0xc00000c8, 0 , 0,
20101 0x0 }, /* POOL32S_0~*(25) */
20102 { instruction , 0 , 0 , 32,
20103 0xfc0001ff, 0xc00000d0, &DROTRV , 0,
20104 MIPS64_ }, /* DROTRV */
20105 { instruction , 0 , 0 , 32,
20106 0xfc0001ff, 0xc00000d8, &DMUHU , 0,
20107 MIPS64_ }, /* DMUHU */
20108 { reserved_block , 0 , 0 , 32,
20109 0xfc0001ff, 0xc00000e0, 0 , 0,
20110 0x0 }, /* POOL32S_0~*(28) */
20111 { reserved_block , 0 , 0 , 32,
20112 0xfc0001ff, 0xc00000e8, 0 , 0,
20113 0x0 }, /* POOL32S_0~*(29) */
20114 { reserved_block , 0 , 0 , 32,
20115 0xfc0001ff, 0xc00000f0, 0 , 0,
20116 0x0 }, /* POOL32S_0~*(30) */
20117 { reserved_block , 0 , 0 , 32,
20118 0xfc0001ff, 0xc00000f8, 0 , 0,
20119 0x0 }, /* POOL32S_0~*(31) */
20120 { reserved_block , 0 , 0 , 32,
20121 0xfc0001ff, 0xc0000100, 0 , 0,
20122 0x0 }, /* POOL32S_0~*(32) */
20123 { reserved_block , 0 , 0 , 32,
20124 0xfc0001ff, 0xc0000108, 0 , 0,
20125 0x0 }, /* POOL32S_0~*(33) */
20126 { instruction , 0 , 0 , 32,
20127 0xfc0001ff, 0xc0000110, &DADD , 0,
20128 MIPS64_ }, /* DADD */
20129 { instruction , 0 , 0 , 32,
20130 0xfc0001ff, 0xc0000118, &DDIV , 0,
20131 MIPS64_ }, /* DDIV */
20132 { reserved_block , 0 , 0 , 32,
20133 0xfc0001ff, 0xc0000120, 0 , 0,
20134 0x0 }, /* POOL32S_0~*(36) */
20135 { reserved_block , 0 , 0 , 32,
20136 0xfc0001ff, 0xc0000128, 0 , 0,
20137 0x0 }, /* POOL32S_0~*(37) */
20138 { reserved_block , 0 , 0 , 32,
20139 0xfc0001ff, 0xc0000130, 0 , 0,
20140 0x0 }, /* POOL32S_0~*(38) */
20141 { reserved_block , 0 , 0 , 32,
20142 0xfc0001ff, 0xc0000138, 0 , 0,
20143 0x0 }, /* POOL32S_0~*(39) */
20144 { reserved_block , 0 , 0 , 32,
20145 0xfc0001ff, 0xc0000140, 0 , 0,
20146 0x0 }, /* POOL32S_0~*(40) */
20147 { reserved_block , 0 , 0 , 32,
20148 0xfc0001ff, 0xc0000148, 0 , 0,
20149 0x0 }, /* POOL32S_0~*(41) */
20150 { instruction , 0 , 0 , 32,
20151 0xfc0001ff, 0xc0000150, &DADDU , 0,
20152 MIPS64_ }, /* DADDU */
20153 { instruction , 0 , 0 , 32,
20154 0xfc0001ff, 0xc0000158, &DMOD , 0,
20155 MIPS64_ }, /* DMOD */
20156 { reserved_block , 0 , 0 , 32,
20157 0xfc0001ff, 0xc0000160, 0 , 0,
20158 0x0 }, /* POOL32S_0~*(44) */
20159 { reserved_block , 0 , 0 , 32,
20160 0xfc0001ff, 0xc0000168, 0 , 0,
20161 0x0 }, /* POOL32S_0~*(45) */
20162 { reserved_block , 0 , 0 , 32,
20163 0xfc0001ff, 0xc0000170, 0 , 0,
20164 0x0 }, /* POOL32S_0~*(46) */
20165 { reserved_block , 0 , 0 , 32,
20166 0xfc0001ff, 0xc0000178, 0 , 0,
20167 0x0 }, /* POOL32S_0~*(47) */
20168 { reserved_block , 0 , 0 , 32,
20169 0xfc0001ff, 0xc0000180, 0 , 0,
20170 0x0 }, /* POOL32S_0~*(48) */
20171 { reserved_block , 0 , 0 , 32,
20172 0xfc0001ff, 0xc0000188, 0 , 0,
20173 0x0 }, /* POOL32S_0~*(49) */
20174 { instruction , 0 , 0 , 32,
20175 0xfc0001ff, 0xc0000190, &DSUB , 0,
20176 MIPS64_ }, /* DSUB */
20177 { instruction , 0 , 0 , 32,
20178 0xfc0001ff, 0xc0000198, &DDIVU , 0,
20179 MIPS64_ }, /* DDIVU */
20180 { reserved_block , 0 , 0 , 32,
20181 0xfc0001ff, 0xc00001a0, 0 , 0,
20182 0x0 }, /* POOL32S_0~*(52) */
20183 { reserved_block , 0 , 0 , 32,
20184 0xfc0001ff, 0xc00001a8, 0 , 0,
20185 0x0 }, /* POOL32S_0~*(53) */
20186 { reserved_block , 0 , 0 , 32,
20187 0xfc0001ff, 0xc00001b0, 0 , 0,
20188 0x0 }, /* POOL32S_0~*(54) */
20189 { reserved_block , 0 , 0 , 32,
20190 0xfc0001ff, 0xc00001b8, 0 , 0,
20191 0x0 }, /* POOL32S_0~*(55) */
20192 { reserved_block , 0 , 0 , 32,
20193 0xfc0001ff, 0xc00001c0, 0 , 0,
20194 0x0 }, /* POOL32S_0~*(56) */
20195 { reserved_block , 0 , 0 , 32,
20196 0xfc0001ff, 0xc00001c8, 0 , 0,
20197 0x0 }, /* POOL32S_0~*(57) */
20198 { instruction , 0 , 0 , 32,
20199 0xfc0001ff, 0xc00001d0, &DSUBU , 0,
20200 MIPS64_ }, /* DSUBU */
20201 { instruction , 0 , 0 , 32,
20202 0xfc0001ff, 0xc00001d8, &DMODU , 0,
20203 MIPS64_ }, /* DMODU */
20204 { reserved_block , 0 , 0 , 32,
20205 0xfc0001ff, 0xc00001e0, 0 , 0,
20206 0x0 }, /* POOL32S_0~*(60) */
20207 { reserved_block , 0 , 0 , 32,
20208 0xfc0001ff, 0xc00001e8, 0 , 0,
20209 0x0 }, /* POOL32S_0~*(61) */
20210 { reserved_block , 0 , 0 , 32,
20211 0xfc0001ff, 0xc00001f0, 0 , 0,
20212 0x0 }, /* POOL32S_0~*(62) */
20213 { reserved_block , 0 , 0 , 32,
20214 0xfc0001ff, 0xc00001f8, 0 , 0,
20215 0x0 }, /* POOL32S_0~*(63) */
20216 };
20217
20218
20219 static const Pool POOL32Sxf_4[128] = {
20220 { reserved_block , 0 , 0 , 32,
20221 0xfc00ffff, 0xc000013c, 0 , 0,
20222 0x0 }, /* POOL32Sxf_4~*(0) */
20223 { reserved_block , 0 , 0 , 32,
20224 0xfc00ffff, 0xc000033c, 0 , 0,
20225 0x0 }, /* POOL32Sxf_4~*(1) */
20226 { reserved_block , 0 , 0 , 32,
20227 0xfc00ffff, 0xc000053c, 0 , 0,
20228 0x0 }, /* POOL32Sxf_4~*(2) */
20229 { reserved_block , 0 , 0 , 32,
20230 0xfc00ffff, 0xc000073c, 0 , 0,
20231 0x0 }, /* POOL32Sxf_4~*(3) */
20232 { reserved_block , 0 , 0 , 32,
20233 0xfc00ffff, 0xc000093c, 0 , 0,
20234 0x0 }, /* POOL32Sxf_4~*(4) */
20235 { reserved_block , 0 , 0 , 32,
20236 0xfc00ffff, 0xc0000b3c, 0 , 0,
20237 0x0 }, /* POOL32Sxf_4~*(5) */
20238 { reserved_block , 0 , 0 , 32,
20239 0xfc00ffff, 0xc0000d3c, 0 , 0,
20240 0x0 }, /* POOL32Sxf_4~*(6) */
20241 { reserved_block , 0 , 0 , 32,
20242 0xfc00ffff, 0xc0000f3c, 0 , 0,
20243 0x0 }, /* POOL32Sxf_4~*(7) */
20244 { reserved_block , 0 , 0 , 32,
20245 0xfc00ffff, 0xc000113c, 0 , 0,
20246 0x0 }, /* POOL32Sxf_4~*(8) */
20247 { reserved_block , 0 , 0 , 32,
20248 0xfc00ffff, 0xc000133c, 0 , 0,
20249 0x0 }, /* POOL32Sxf_4~*(9) */
20250 { reserved_block , 0 , 0 , 32,
20251 0xfc00ffff, 0xc000153c, 0 , 0,
20252 0x0 }, /* POOL32Sxf_4~*(10) */
20253 { reserved_block , 0 , 0 , 32,
20254 0xfc00ffff, 0xc000173c, 0 , 0,
20255 0x0 }, /* POOL32Sxf_4~*(11) */
20256 { reserved_block , 0 , 0 , 32,
20257 0xfc00ffff, 0xc000193c, 0 , 0,
20258 0x0 }, /* POOL32Sxf_4~*(12) */
20259 { reserved_block , 0 , 0 , 32,
20260 0xfc00ffff, 0xc0001b3c, 0 , 0,
20261 0x0 }, /* POOL32Sxf_4~*(13) */
20262 { reserved_block , 0 , 0 , 32,
20263 0xfc00ffff, 0xc0001d3c, 0 , 0,
20264 0x0 }, /* POOL32Sxf_4~*(14) */
20265 { reserved_block , 0 , 0 , 32,
20266 0xfc00ffff, 0xc0001f3c, 0 , 0,
20267 0x0 }, /* POOL32Sxf_4~*(15) */
20268 { reserved_block , 0 , 0 , 32,
20269 0xfc00ffff, 0xc000213c, 0 , 0,
20270 0x0 }, /* POOL32Sxf_4~*(16) */
20271 { reserved_block , 0 , 0 , 32,
20272 0xfc00ffff, 0xc000233c, 0 , 0,
20273 0x0 }, /* POOL32Sxf_4~*(17) */
20274 { reserved_block , 0 , 0 , 32,
20275 0xfc00ffff, 0xc000253c, 0 , 0,
20276 0x0 }, /* POOL32Sxf_4~*(18) */
20277 { reserved_block , 0 , 0 , 32,
20278 0xfc00ffff, 0xc000273c, 0 , 0,
20279 0x0 }, /* POOL32Sxf_4~*(19) */
20280 { reserved_block , 0 , 0 , 32,
20281 0xfc00ffff, 0xc000293c, 0 , 0,
20282 0x0 }, /* POOL32Sxf_4~*(20) */
20283 { reserved_block , 0 , 0 , 32,
20284 0xfc00ffff, 0xc0002b3c, 0 , 0,
20285 0x0 }, /* POOL32Sxf_4~*(21) */
20286 { reserved_block , 0 , 0 , 32,
20287 0xfc00ffff, 0xc0002d3c, 0 , 0,
20288 0x0 }, /* POOL32Sxf_4~*(22) */
20289 { reserved_block , 0 , 0 , 32,
20290 0xfc00ffff, 0xc0002f3c, 0 , 0,
20291 0x0 }, /* POOL32Sxf_4~*(23) */
20292 { reserved_block , 0 , 0 , 32,
20293 0xfc00ffff, 0xc000313c, 0 , 0,
20294 0x0 }, /* POOL32Sxf_4~*(24) */
20295 { reserved_block , 0 , 0 , 32,
20296 0xfc00ffff, 0xc000333c, 0 , 0,
20297 0x0 }, /* POOL32Sxf_4~*(25) */
20298 { reserved_block , 0 , 0 , 32,
20299 0xfc00ffff, 0xc000353c, 0 , 0,
20300 0x0 }, /* POOL32Sxf_4~*(26) */
20301 { reserved_block , 0 , 0 , 32,
20302 0xfc00ffff, 0xc000373c, 0 , 0,
20303 0x0 }, /* POOL32Sxf_4~*(27) */
20304 { reserved_block , 0 , 0 , 32,
20305 0xfc00ffff, 0xc000393c, 0 , 0,
20306 0x0 }, /* POOL32Sxf_4~*(28) */
20307 { reserved_block , 0 , 0 , 32,
20308 0xfc00ffff, 0xc0003b3c, 0 , 0,
20309 0x0 }, /* POOL32Sxf_4~*(29) */
20310 { reserved_block , 0 , 0 , 32,
20311 0xfc00ffff, 0xc0003d3c, 0 , 0,
20312 0x0 }, /* POOL32Sxf_4~*(30) */
20313 { reserved_block , 0 , 0 , 32,
20314 0xfc00ffff, 0xc0003f3c, 0 , 0,
20315 0x0 }, /* POOL32Sxf_4~*(31) */
20316 { reserved_block , 0 , 0 , 32,
20317 0xfc00ffff, 0xc000413c, 0 , 0,
20318 0x0 }, /* POOL32Sxf_4~*(32) */
20319 { reserved_block , 0 , 0 , 32,
20320 0xfc00ffff, 0xc000433c, 0 , 0,
20321 0x0 }, /* POOL32Sxf_4~*(33) */
20322 { reserved_block , 0 , 0 , 32,
20323 0xfc00ffff, 0xc000453c, 0 , 0,
20324 0x0 }, /* POOL32Sxf_4~*(34) */
20325 { reserved_block , 0 , 0 , 32,
20326 0xfc00ffff, 0xc000473c, 0 , 0,
20327 0x0 }, /* POOL32Sxf_4~*(35) */
20328 { reserved_block , 0 , 0 , 32,
20329 0xfc00ffff, 0xc000493c, 0 , 0,
20330 0x0 }, /* POOL32Sxf_4~*(36) */
20331 { instruction , 0 , 0 , 32,
20332 0xfc00ffff, 0xc0004b3c, &DCLO , 0,
20333 MIPS64_ }, /* DCLO */
20334 { reserved_block , 0 , 0 , 32,
20335 0xfc00ffff, 0xc0004d3c, 0 , 0,
20336 0x0 }, /* POOL32Sxf_4~*(38) */
20337 { reserved_block , 0 , 0 , 32,
20338 0xfc00ffff, 0xc0004f3c, 0 , 0,
20339 0x0 }, /* POOL32Sxf_4~*(39) */
20340 { reserved_block , 0 , 0 , 32,
20341 0xfc00ffff, 0xc000513c, 0 , 0,
20342 0x0 }, /* POOL32Sxf_4~*(40) */
20343 { reserved_block , 0 , 0 , 32,
20344 0xfc00ffff, 0xc000533c, 0 , 0,
20345 0x0 }, /* POOL32Sxf_4~*(41) */
20346 { reserved_block , 0 , 0 , 32,
20347 0xfc00ffff, 0xc000553c, 0 , 0,
20348 0x0 }, /* POOL32Sxf_4~*(42) */
20349 { reserved_block , 0 , 0 , 32,
20350 0xfc00ffff, 0xc000573c, 0 , 0,
20351 0x0 }, /* POOL32Sxf_4~*(43) */
20352 { reserved_block , 0 , 0 , 32,
20353 0xfc00ffff, 0xc000593c, 0 , 0,
20354 0x0 }, /* POOL32Sxf_4~*(44) */
20355 { instruction , 0 , 0 , 32,
20356 0xfc00ffff, 0xc0005b3c, &DCLZ , 0,
20357 MIPS64_ }, /* DCLZ */
20358 { reserved_block , 0 , 0 , 32,
20359 0xfc00ffff, 0xc0005d3c, 0 , 0,
20360 0x0 }, /* POOL32Sxf_4~*(46) */
20361 { reserved_block , 0 , 0 , 32,
20362 0xfc00ffff, 0xc0005f3c, 0 , 0,
20363 0x0 }, /* POOL32Sxf_4~*(47) */
20364 { reserved_block , 0 , 0 , 32,
20365 0xfc00ffff, 0xc000613c, 0 , 0,
20366 0x0 }, /* POOL32Sxf_4~*(48) */
20367 { reserved_block , 0 , 0 , 32,
20368 0xfc00ffff, 0xc000633c, 0 , 0,
20369 0x0 }, /* POOL32Sxf_4~*(49) */
20370 { reserved_block , 0 , 0 , 32,
20371 0xfc00ffff, 0xc000653c, 0 , 0,
20372 0x0 }, /* POOL32Sxf_4~*(50) */
20373 { reserved_block , 0 , 0 , 32,
20374 0xfc00ffff, 0xc000673c, 0 , 0,
20375 0x0 }, /* POOL32Sxf_4~*(51) */
20376 { reserved_block , 0 , 0 , 32,
20377 0xfc00ffff, 0xc000693c, 0 , 0,
20378 0x0 }, /* POOL32Sxf_4~*(52) */
20379 { reserved_block , 0 , 0 , 32,
20380 0xfc00ffff, 0xc0006b3c, 0 , 0,
20381 0x0 }, /* POOL32Sxf_4~*(53) */
20382 { reserved_block , 0 , 0 , 32,
20383 0xfc00ffff, 0xc0006d3c, 0 , 0,
20384 0x0 }, /* POOL32Sxf_4~*(54) */
20385 { reserved_block , 0 , 0 , 32,
20386 0xfc00ffff, 0xc0006f3c, 0 , 0,
20387 0x0 }, /* POOL32Sxf_4~*(55) */
20388 { reserved_block , 0 , 0 , 32,
20389 0xfc00ffff, 0xc000713c, 0 , 0,
20390 0x0 }, /* POOL32Sxf_4~*(56) */
20391 { reserved_block , 0 , 0 , 32,
20392 0xfc00ffff, 0xc000733c, 0 , 0,
20393 0x0 }, /* POOL32Sxf_4~*(57) */
20394 { reserved_block , 0 , 0 , 32,
20395 0xfc00ffff, 0xc000753c, 0 , 0,
20396 0x0 }, /* POOL32Sxf_4~*(58) */
20397 { reserved_block , 0 , 0 , 32,
20398 0xfc00ffff, 0xc000773c, 0 , 0,
20399 0x0 }, /* POOL32Sxf_4~*(59) */
20400 { reserved_block , 0 , 0 , 32,
20401 0xfc00ffff, 0xc000793c, 0 , 0,
20402 0x0 }, /* POOL32Sxf_4~*(60) */
20403 { reserved_block , 0 , 0 , 32,
20404 0xfc00ffff, 0xc0007b3c, 0 , 0,
20405 0x0 }, /* POOL32Sxf_4~*(61) */
20406 { reserved_block , 0 , 0 , 32,
20407 0xfc00ffff, 0xc0007d3c, 0 , 0,
20408 0x0 }, /* POOL32Sxf_4~*(62) */
20409 { reserved_block , 0 , 0 , 32,
20410 0xfc00ffff, 0xc0007f3c, 0 , 0,
20411 0x0 }, /* POOL32Sxf_4~*(63) */
20412 { reserved_block , 0 , 0 , 32,
20413 0xfc00ffff, 0xc000813c, 0 , 0,
20414 0x0 }, /* POOL32Sxf_4~*(64) */
20415 { reserved_block , 0 , 0 , 32,
20416 0xfc00ffff, 0xc000833c, 0 , 0,
20417 0x0 }, /* POOL32Sxf_4~*(65) */
20418 { reserved_block , 0 , 0 , 32,
20419 0xfc00ffff, 0xc000853c, 0 , 0,
20420 0x0 }, /* POOL32Sxf_4~*(66) */
20421 { reserved_block , 0 , 0 , 32,
20422 0xfc00ffff, 0xc000873c, 0 , 0,
20423 0x0 }, /* POOL32Sxf_4~*(67) */
20424 { reserved_block , 0 , 0 , 32,
20425 0xfc00ffff, 0xc000893c, 0 , 0,
20426 0x0 }, /* POOL32Sxf_4~*(68) */
20427 { reserved_block , 0 , 0 , 32,
20428 0xfc00ffff, 0xc0008b3c, 0 , 0,
20429 0x0 }, /* POOL32Sxf_4~*(69) */
20430 { reserved_block , 0 , 0 , 32,
20431 0xfc00ffff, 0xc0008d3c, 0 , 0,
20432 0x0 }, /* POOL32Sxf_4~*(70) */
20433 { reserved_block , 0 , 0 , 32,
20434 0xfc00ffff, 0xc0008f3c, 0 , 0,
20435 0x0 }, /* POOL32Sxf_4~*(71) */
20436 { reserved_block , 0 , 0 , 32,
20437 0xfc00ffff, 0xc000913c, 0 , 0,
20438 0x0 }, /* POOL32Sxf_4~*(72) */
20439 { reserved_block , 0 , 0 , 32,
20440 0xfc00ffff, 0xc000933c, 0 , 0,
20441 0x0 }, /* POOL32Sxf_4~*(73) */
20442 { reserved_block , 0 , 0 , 32,
20443 0xfc00ffff, 0xc000953c, 0 , 0,
20444 0x0 }, /* POOL32Sxf_4~*(74) */
20445 { reserved_block , 0 , 0 , 32,
20446 0xfc00ffff, 0xc000973c, 0 , 0,
20447 0x0 }, /* POOL32Sxf_4~*(75) */
20448 { reserved_block , 0 , 0 , 32,
20449 0xfc00ffff, 0xc000993c, 0 , 0,
20450 0x0 }, /* POOL32Sxf_4~*(76) */
20451 { reserved_block , 0 , 0 , 32,
20452 0xfc00ffff, 0xc0009b3c, 0 , 0,
20453 0x0 }, /* POOL32Sxf_4~*(77) */
20454 { reserved_block , 0 , 0 , 32,
20455 0xfc00ffff, 0xc0009d3c, 0 , 0,
20456 0x0 }, /* POOL32Sxf_4~*(78) */
20457 { reserved_block , 0 , 0 , 32,
20458 0xfc00ffff, 0xc0009f3c, 0 , 0,
20459 0x0 }, /* POOL32Sxf_4~*(79) */
20460 { reserved_block , 0 , 0 , 32,
20461 0xfc00ffff, 0xc000a13c, 0 , 0,
20462 0x0 }, /* POOL32Sxf_4~*(80) */
20463 { reserved_block , 0 , 0 , 32,
20464 0xfc00ffff, 0xc000a33c, 0 , 0,
20465 0x0 }, /* POOL32Sxf_4~*(81) */
20466 { reserved_block , 0 , 0 , 32,
20467 0xfc00ffff, 0xc000a53c, 0 , 0,
20468 0x0 }, /* POOL32Sxf_4~*(82) */
20469 { reserved_block , 0 , 0 , 32,
20470 0xfc00ffff, 0xc000a73c, 0 , 0,
20471 0x0 }, /* POOL32Sxf_4~*(83) */
20472 { reserved_block , 0 , 0 , 32,
20473 0xfc00ffff, 0xc000a93c, 0 , 0,
20474 0x0 }, /* POOL32Sxf_4~*(84) */
20475 { reserved_block , 0 , 0 , 32,
20476 0xfc00ffff, 0xc000ab3c, 0 , 0,
20477 0x0 }, /* POOL32Sxf_4~*(85) */
20478 { reserved_block , 0 , 0 , 32,
20479 0xfc00ffff, 0xc000ad3c, 0 , 0,
20480 0x0 }, /* POOL32Sxf_4~*(86) */
20481 { reserved_block , 0 , 0 , 32,
20482 0xfc00ffff, 0xc000af3c, 0 , 0,
20483 0x0 }, /* POOL32Sxf_4~*(87) */
20484 { reserved_block , 0 , 0 , 32,
20485 0xfc00ffff, 0xc000b13c, 0 , 0,
20486 0x0 }, /* POOL32Sxf_4~*(88) */
20487 { reserved_block , 0 , 0 , 32,
20488 0xfc00ffff, 0xc000b33c, 0 , 0,
20489 0x0 }, /* POOL32Sxf_4~*(89) */
20490 { reserved_block , 0 , 0 , 32,
20491 0xfc00ffff, 0xc000b53c, 0 , 0,
20492 0x0 }, /* POOL32Sxf_4~*(90) */
20493 { reserved_block , 0 , 0 , 32,
20494 0xfc00ffff, 0xc000b73c, 0 , 0,
20495 0x0 }, /* POOL32Sxf_4~*(91) */
20496 { reserved_block , 0 , 0 , 32,
20497 0xfc00ffff, 0xc000b93c, 0 , 0,
20498 0x0 }, /* POOL32Sxf_4~*(92) */
20499 { reserved_block , 0 , 0 , 32,
20500 0xfc00ffff, 0xc000bb3c, 0 , 0,
20501 0x0 }, /* POOL32Sxf_4~*(93) */
20502 { reserved_block , 0 , 0 , 32,
20503 0xfc00ffff, 0xc000bd3c, 0 , 0,
20504 0x0 }, /* POOL32Sxf_4~*(94) */
20505 { reserved_block , 0 , 0 , 32,
20506 0xfc00ffff, 0xc000bf3c, 0 , 0,
20507 0x0 }, /* POOL32Sxf_4~*(95) */
20508 { reserved_block , 0 , 0 , 32,
20509 0xfc00ffff, 0xc000c13c, 0 , 0,
20510 0x0 }, /* POOL32Sxf_4~*(96) */
20511 { reserved_block , 0 , 0 , 32,
20512 0xfc00ffff, 0xc000c33c, 0 , 0,
20513 0x0 }, /* POOL32Sxf_4~*(97) */
20514 { reserved_block , 0 , 0 , 32,
20515 0xfc00ffff, 0xc000c53c, 0 , 0,
20516 0x0 }, /* POOL32Sxf_4~*(98) */
20517 { reserved_block , 0 , 0 , 32,
20518 0xfc00ffff, 0xc000c73c, 0 , 0,
20519 0x0 }, /* POOL32Sxf_4~*(99) */
20520 { reserved_block , 0 , 0 , 32,
20521 0xfc00ffff, 0xc000c93c, 0 , 0,
20522 0x0 }, /* POOL32Sxf_4~*(100) */
20523 { reserved_block , 0 , 0 , 32,
20524 0xfc00ffff, 0xc000cb3c, 0 , 0,
20525 0x0 }, /* POOL32Sxf_4~*(101) */
20526 { reserved_block , 0 , 0 , 32,
20527 0xfc00ffff, 0xc000cd3c, 0 , 0,
20528 0x0 }, /* POOL32Sxf_4~*(102) */
20529 { reserved_block , 0 , 0 , 32,
20530 0xfc00ffff, 0xc000cf3c, 0 , 0,
20531 0x0 }, /* POOL32Sxf_4~*(103) */
20532 { reserved_block , 0 , 0 , 32,
20533 0xfc00ffff, 0xc000d13c, 0 , 0,
20534 0x0 }, /* POOL32Sxf_4~*(104) */
20535 { reserved_block , 0 , 0 , 32,
20536 0xfc00ffff, 0xc000d33c, 0 , 0,
20537 0x0 }, /* POOL32Sxf_4~*(105) */
20538 { reserved_block , 0 , 0 , 32,
20539 0xfc00ffff, 0xc000d53c, 0 , 0,
20540 0x0 }, /* POOL32Sxf_4~*(106) */
20541 { reserved_block , 0 , 0 , 32,
20542 0xfc00ffff, 0xc000d73c, 0 , 0,
20543 0x0 }, /* POOL32Sxf_4~*(107) */
20544 { reserved_block , 0 , 0 , 32,
20545 0xfc00ffff, 0xc000d93c, 0 , 0,
20546 0x0 }, /* POOL32Sxf_4~*(108) */
20547 { reserved_block , 0 , 0 , 32,
20548 0xfc00ffff, 0xc000db3c, 0 , 0,
20549 0x0 }, /* POOL32Sxf_4~*(109) */
20550 { reserved_block , 0 , 0 , 32,
20551 0xfc00ffff, 0xc000dd3c, 0 , 0,
20552 0x0 }, /* POOL32Sxf_4~*(110) */
20553 { reserved_block , 0 , 0 , 32,
20554 0xfc00ffff, 0xc000df3c, 0 , 0,
20555 0x0 }, /* POOL32Sxf_4~*(111) */
20556 { reserved_block , 0 , 0 , 32,
20557 0xfc00ffff, 0xc000e13c, 0 , 0,
20558 0x0 }, /* POOL32Sxf_4~*(112) */
20559 { reserved_block , 0 , 0 , 32,
20560 0xfc00ffff, 0xc000e33c, 0 , 0,
20561 0x0 }, /* POOL32Sxf_4~*(113) */
20562 { reserved_block , 0 , 0 , 32,
20563 0xfc00ffff, 0xc000e53c, 0 , 0,
20564 0x0 }, /* POOL32Sxf_4~*(114) */
20565 { reserved_block , 0 , 0 , 32,
20566 0xfc00ffff, 0xc000e73c, 0 , 0,
20567 0x0 }, /* POOL32Sxf_4~*(115) */
20568 { reserved_block , 0 , 0 , 32,
20569 0xfc00ffff, 0xc000e93c, 0 , 0,
20570 0x0 }, /* POOL32Sxf_4~*(116) */
20571 { reserved_block , 0 , 0 , 32,
20572 0xfc00ffff, 0xc000eb3c, 0 , 0,
20573 0x0 }, /* POOL32Sxf_4~*(117) */
20574 { reserved_block , 0 , 0 , 32,
20575 0xfc00ffff, 0xc000ed3c, 0 , 0,
20576 0x0 }, /* POOL32Sxf_4~*(118) */
20577 { reserved_block , 0 , 0 , 32,
20578 0xfc00ffff, 0xc000ef3c, 0 , 0,
20579 0x0 }, /* POOL32Sxf_4~*(119) */
20580 { reserved_block , 0 , 0 , 32,
20581 0xfc00ffff, 0xc000f13c, 0 , 0,
20582 0x0 }, /* POOL32Sxf_4~*(120) */
20583 { reserved_block , 0 , 0 , 32,
20584 0xfc00ffff, 0xc000f33c, 0 , 0,
20585 0x0 }, /* POOL32Sxf_4~*(121) */
20586 { reserved_block , 0 , 0 , 32,
20587 0xfc00ffff, 0xc000f53c, 0 , 0,
20588 0x0 }, /* POOL32Sxf_4~*(122) */
20589 { reserved_block , 0 , 0 , 32,
20590 0xfc00ffff, 0xc000f73c, 0 , 0,
20591 0x0 }, /* POOL32Sxf_4~*(123) */
20592 { reserved_block , 0 , 0 , 32,
20593 0xfc00ffff, 0xc000f93c, 0 , 0,
20594 0x0 }, /* POOL32Sxf_4~*(124) */
20595 { reserved_block , 0 , 0 , 32,
20596 0xfc00ffff, 0xc000fb3c, 0 , 0,
20597 0x0 }, /* POOL32Sxf_4~*(125) */
20598 { reserved_block , 0 , 0 , 32,
20599 0xfc00ffff, 0xc000fd3c, 0 , 0,
20600 0x0 }, /* POOL32Sxf_4~*(126) */
20601 { reserved_block , 0 , 0 , 32,
20602 0xfc00ffff, 0xc000ff3c, 0 , 0,
20603 0x0 }, /* POOL32Sxf_4~*(127) */
20604 };
20605
20606
20607 static const Pool POOL32Sxf[8] = {
20608 { reserved_block , 0 , 0 , 32,
20609 0xfc0001ff, 0xc000003c, 0 , 0,
20610 0x0 }, /* POOL32Sxf~*(0) */
20611 { reserved_block , 0 , 0 , 32,
20612 0xfc0001ff, 0xc000007c, 0 , 0,
20613 0x0 }, /* POOL32Sxf~*(1) */
20614 { reserved_block , 0 , 0 , 32,
20615 0xfc0001ff, 0xc00000bc, 0 , 0,
20616 0x0 }, /* POOL32Sxf~*(2) */
20617 { reserved_block , 0 , 0 , 32,
20618 0xfc0001ff, 0xc00000fc, 0 , 0,
20619 0x0 }, /* POOL32Sxf~*(3) */
20620 { pool , POOL32Sxf_4 , 128 , 32,
20621 0xfc0001ff, 0xc000013c, 0 , 0,
20622 0x0 }, /* POOL32Sxf_4 */
20623 { reserved_block , 0 , 0 , 32,
20624 0xfc0001ff, 0xc000017c, 0 , 0,
20625 0x0 }, /* POOL32Sxf~*(5) */
20626 { reserved_block , 0 , 0 , 32,
20627 0xfc0001ff, 0xc00001bc, 0 , 0,
20628 0x0 }, /* POOL32Sxf~*(6) */
20629 { reserved_block , 0 , 0 , 32,
20630 0xfc0001ff, 0xc00001fc, 0 , 0,
20631 0x0 }, /* POOL32Sxf~*(7) */
20632 };
20633
20634
20635 static const Pool POOL32S_4[8] = {
20636 { instruction , 0 , 0 , 32,
20637 0xfc00003f, 0xc0000004, &EXTD , 0,
20638 MIPS64_ }, /* EXTD */
20639 { instruction , 0 , 0 , 32,
20640 0xfc00003f, 0xc000000c, &EXTD32 , 0,
20641 MIPS64_ }, /* EXTD32 */
20642 { reserved_block , 0 , 0 , 32,
20643 0xfc00003f, 0xc0000014, 0 , 0,
20644 0x0 }, /* POOL32S_4~*(2) */
20645 { reserved_block , 0 , 0 , 32,
20646 0xfc00003f, 0xc000001c, 0 , 0,
20647 0x0 }, /* POOL32S_4~*(3) */
20648 { reserved_block , 0 , 0 , 32,
20649 0xfc00003f, 0xc0000024, 0 , 0,
20650 0x0 }, /* POOL32S_4~*(4) */
20651 { reserved_block , 0 , 0 , 32,
20652 0xfc00003f, 0xc000002c, 0 , 0,
20653 0x0 }, /* POOL32S_4~*(5) */
20654 { reserved_block , 0 , 0 , 32,
20655 0xfc00003f, 0xc0000034, 0 , 0,
20656 0x0 }, /* POOL32S_4~*(6) */
20657 { pool , POOL32Sxf , 8 , 32,
20658 0xfc00003f, 0xc000003c, 0 , 0,
20659 0x0 }, /* POOL32Sxf */
20660 };
20661
20662
20663 static const Pool POOL32S[8] = {
20664 { pool , POOL32S_0 , 64 , 32,
20665 0xfc000007, 0xc0000000, 0 , 0,
20666 0x0 }, /* POOL32S_0 */
20667 { reserved_block , 0 , 0 , 32,
20668 0xfc000007, 0xc0000001, 0 , 0,
20669 0x0 }, /* POOL32S~*(1) */
20670 { reserved_block , 0 , 0 , 32,
20671 0xfc000007, 0xc0000002, 0 , 0,
20672 0x0 }, /* POOL32S~*(2) */
20673 { reserved_block , 0 , 0 , 32,
20674 0xfc000007, 0xc0000003, 0 , 0,
20675 0x0 }, /* POOL32S~*(3) */
20676 { pool , POOL32S_4 , 8 , 32,
20677 0xfc000007, 0xc0000004, 0 , 0,
20678 0x0 }, /* POOL32S_4 */
20679 { reserved_block , 0 , 0 , 32,
20680 0xfc000007, 0xc0000005, 0 , 0,
20681 0x0 }, /* POOL32S~*(5) */
20682 { reserved_block , 0 , 0 , 32,
20683 0xfc000007, 0xc0000006, 0 , 0,
20684 0x0 }, /* POOL32S~*(6) */
20685 { reserved_block , 0 , 0 , 32,
20686 0xfc000007, 0xc0000007, 0 , 0,
20687 0x0 }, /* POOL32S~*(7) */
20688 };
20689
20690
20691 static const Pool P_LUI[2] = {
20692 { instruction , 0 , 0 , 32,
20693 0xfc000002, 0xe0000000, &LUI , 0,
20694 0x0 }, /* LUI */
20695 { instruction , 0 , 0 , 32,
20696 0xfc000002, 0xe0000002, &ALUIPC , 0,
20697 0x0 }, /* ALUIPC */
20698 };
20699
20700
20701 static const Pool P_GP_LH[2] = {
20702 { instruction , 0 , 0 , 32,
20703 0xfc1c0001, 0x44100000, &LH_GP_ , 0,
20704 0x0 }, /* LH[GP] */
20705 { instruction , 0 , 0 , 32,
20706 0xfc1c0001, 0x44100001, &LHU_GP_ , 0,
20707 0x0 }, /* LHU[GP] */
20708 };
20709
20710
20711 static const Pool P_GP_SH[2] = {
20712 { instruction , 0 , 0 , 32,
20713 0xfc1c0001, 0x44140000, &SH_GP_ , 0,
20714 0x0 }, /* SH[GP] */
20715 { reserved_block , 0 , 0 , 32,
20716 0xfc1c0001, 0x44140001, 0 , 0,
20717 0x0 }, /* P.GP.SH~*(1) */
20718 };
20719
20720
20721 static const Pool P_GP_CP1[4] = {
20722 { instruction , 0 , 0 , 32,
20723 0xfc1c0003, 0x44180000, &LWC1_GP_ , 0,
20724 CP1_ }, /* LWC1[GP] */
20725 { instruction , 0 , 0 , 32,
20726 0xfc1c0003, 0x44180001, &SWC1_GP_ , 0,
20727 CP1_ }, /* SWC1[GP] */
20728 { instruction , 0 , 0 , 32,
20729 0xfc1c0003, 0x44180002, &LDC1_GP_ , 0,
20730 CP1_ }, /* LDC1[GP] */
20731 { instruction , 0 , 0 , 32,
20732 0xfc1c0003, 0x44180003, &SDC1_GP_ , 0,
20733 CP1_ }, /* SDC1[GP] */
20734 };
20735
20736
20737 static const Pool P_GP_M64[4] = {
20738 { instruction , 0 , 0 , 32,
20739 0xfc1c0003, 0x441c0000, &LWU_GP_ , 0,
20740 MIPS64_ }, /* LWU[GP] */
20741 { reserved_block , 0 , 0 , 32,
20742 0xfc1c0003, 0x441c0001, 0 , 0,
20743 0x0 }, /* P.GP.M64~*(1) */
20744 { reserved_block , 0 , 0 , 32,
20745 0xfc1c0003, 0x441c0002, 0 , 0,
20746 0x0 }, /* P.GP.M64~*(2) */
20747 { reserved_block , 0 , 0 , 32,
20748 0xfc1c0003, 0x441c0003, 0 , 0,
20749 0x0 }, /* P.GP.M64~*(3) */
20750 };
20751
20752
20753 static const Pool P_GP_BH[8] = {
20754 { instruction , 0 , 0 , 32,
20755 0xfc1c0000, 0x44000000, &LB_GP_ , 0,
20756 0x0 }, /* LB[GP] */
20757 { instruction , 0 , 0 , 32,
20758 0xfc1c0000, 0x44040000, &SB_GP_ , 0,
20759 0x0 }, /* SB[GP] */
20760 { instruction , 0 , 0 , 32,
20761 0xfc1c0000, 0x44080000, &LBU_GP_ , 0,
20762 0x0 }, /* LBU[GP] */
20763 { instruction , 0 , 0 , 32,
20764 0xfc1c0000, 0x440c0000, &ADDIU_GP_B_ , 0,
20765 0x0 }, /* ADDIU[GP.B] */
20766 { pool , P_GP_LH , 2 , 32,
20767 0xfc1c0000, 0x44100000, 0 , 0,
20768 0x0 }, /* P.GP.LH */
20769 { pool , P_GP_SH , 2 , 32,
20770 0xfc1c0000, 0x44140000, 0 , 0,
20771 0x0 }, /* P.GP.SH */
20772 { pool , P_GP_CP1 , 4 , 32,
20773 0xfc1c0000, 0x44180000, 0 , 0,
20774 0x0 }, /* P.GP.CP1 */
20775 { pool , P_GP_M64 , 4 , 32,
20776 0xfc1c0000, 0x441c0000, 0 , 0,
20777 0x0 }, /* P.GP.M64 */
20778 };
20779
20780
20781 static const Pool P_LS_U12[16] = {
20782 { instruction , 0 , 0 , 32,
20783 0xfc00f000, 0x84000000, &LB_U12_ , 0,
20784 0x0 }, /* LB[U12] */
20785 { instruction , 0 , 0 , 32,
20786 0xfc00f000, 0x84001000, &SB_U12_ , 0,
20787 0x0 }, /* SB[U12] */
20788 { instruction , 0 , 0 , 32,
20789 0xfc00f000, 0x84002000, &LBU_U12_ , 0,
20790 0x0 }, /* LBU[U12] */
20791 { instruction , 0 , 0 , 32,
20792 0xfc00f000, 0x84003000, &PREF_U12_ , 0,
20793 0x0 }, /* PREF[U12] */
20794 { instruction , 0 , 0 , 32,
20795 0xfc00f000, 0x84004000, &LH_U12_ , 0,
20796 0x0 }, /* LH[U12] */
20797 { instruction , 0 , 0 , 32,
20798 0xfc00f000, 0x84005000, &SH_U12_ , 0,
20799 0x0 }, /* SH[U12] */
20800 { instruction , 0 , 0 , 32,
20801 0xfc00f000, 0x84006000, &LHU_U12_ , 0,
20802 0x0 }, /* LHU[U12] */
20803 { instruction , 0 , 0 , 32,
20804 0xfc00f000, 0x84007000, &LWU_U12_ , 0,
20805 MIPS64_ }, /* LWU[U12] */
20806 { instruction , 0 , 0 , 32,
20807 0xfc00f000, 0x84008000, &LW_U12_ , 0,
20808 0x0 }, /* LW[U12] */
20809 { instruction , 0 , 0 , 32,
20810 0xfc00f000, 0x84009000, &SW_U12_ , 0,
20811 0x0 }, /* SW[U12] */
20812 { instruction , 0 , 0 , 32,
20813 0xfc00f000, 0x8400a000, &LWC1_U12_ , 0,
20814 CP1_ }, /* LWC1[U12] */
20815 { instruction , 0 , 0 , 32,
20816 0xfc00f000, 0x8400b000, &SWC1_U12_ , 0,
20817 CP1_ }, /* SWC1[U12] */
20818 { instruction , 0 , 0 , 32,
20819 0xfc00f000, 0x8400c000, &LD_U12_ , 0,
20820 MIPS64_ }, /* LD[U12] */
20821 { instruction , 0 , 0 , 32,
20822 0xfc00f000, 0x8400d000, &SD_U12_ , 0,
20823 MIPS64_ }, /* SD[U12] */
20824 { instruction , 0 , 0 , 32,
20825 0xfc00f000, 0x8400e000, &LDC1_U12_ , 0,
20826 CP1_ }, /* LDC1[U12] */
20827 { instruction , 0 , 0 , 32,
20828 0xfc00f000, 0x8400f000, &SDC1_U12_ , 0,
20829 CP1_ }, /* SDC1[U12] */
20830 };
20831
20832
20833 static const Pool P_PREF_S9_[2] = {
20834 { instruction , 0 , 0 , 32,
20835 0xffe07f00, 0xa7e01800, &SYNCI , 0,
20836 0x0 }, /* SYNCI */
20837 { instruction , 0 , 0 , 32,
20838 0xfc007f00, 0xa4001800, &PREF_S9_ , &PREF_S9__cond ,
20839 0x0 }, /* PREF[S9] */
20840 };
20841
20842
20843 static const Pool P_LS_S0[16] = {
20844 { instruction , 0 , 0 , 32,
20845 0xfc007f00, 0xa4000000, &LB_S9_ , 0,
20846 0x0 }, /* LB[S9] */
20847 { instruction , 0 , 0 , 32,
20848 0xfc007f00, 0xa4000800, &SB_S9_ , 0,
20849 0x0 }, /* SB[S9] */
20850 { instruction , 0 , 0 , 32,
20851 0xfc007f00, 0xa4001000, &LBU_S9_ , 0,
20852 0x0 }, /* LBU[S9] */
20853 { pool , P_PREF_S9_ , 2 , 32,
20854 0xfc007f00, 0xa4001800, 0 , 0,
20855 0x0 }, /* P.PREF[S9] */
20856 { instruction , 0 , 0 , 32,
20857 0xfc007f00, 0xa4002000, &LH_S9_ , 0,
20858 0x0 }, /* LH[S9] */
20859 { instruction , 0 , 0 , 32,
20860 0xfc007f00, 0xa4002800, &SH_S9_ , 0,
20861 0x0 }, /* SH[S9] */
20862 { instruction , 0 , 0 , 32,
20863 0xfc007f00, 0xa4003000, &LHU_S9_ , 0,
20864 0x0 }, /* LHU[S9] */
20865 { instruction , 0 , 0 , 32,
20866 0xfc007f00, 0xa4003800, &LWU_S9_ , 0,
20867 MIPS64_ }, /* LWU[S9] */
20868 { instruction , 0 , 0 , 32,
20869 0xfc007f00, 0xa4004000, &LW_S9_ , 0,
20870 0x0 }, /* LW[S9] */
20871 { instruction , 0 , 0 , 32,
20872 0xfc007f00, 0xa4004800, &SW_S9_ , 0,
20873 0x0 }, /* SW[S9] */
20874 { instruction , 0 , 0 , 32,
20875 0xfc007f00, 0xa4005000, &LWC1_S9_ , 0,
20876 CP1_ }, /* LWC1[S9] */
20877 { instruction , 0 , 0 , 32,
20878 0xfc007f00, 0xa4005800, &SWC1_S9_ , 0,
20879 CP1_ }, /* SWC1[S9] */
20880 { instruction , 0 , 0 , 32,
20881 0xfc007f00, 0xa4006000, &LD_S9_ , 0,
20882 MIPS64_ }, /* LD[S9] */
20883 { instruction , 0 , 0 , 32,
20884 0xfc007f00, 0xa4006800, &SD_S9_ , 0,
20885 MIPS64_ }, /* SD[S9] */
20886 { instruction , 0 , 0 , 32,
20887 0xfc007f00, 0xa4007000, &LDC1_S9_ , 0,
20888 CP1_ }, /* LDC1[S9] */
20889 { instruction , 0 , 0 , 32,
20890 0xfc007f00, 0xa4007800, &SDC1_S9_ , 0,
20891 CP1_ }, /* SDC1[S9] */
20892 };
20893
20894
20895 static const Pool ASET_ACLR[2] = {
20896 { instruction , 0 , 0 , 32,
20897 0xfe007f00, 0xa4001100, &ASET , 0,
20898 MCU_ }, /* ASET */
20899 { instruction , 0 , 0 , 32,
20900 0xfe007f00, 0xa6001100, &ACLR , 0,
20901 MCU_ }, /* ACLR */
20902 };
20903
20904
20905 static const Pool P_LL[4] = {
20906 { instruction , 0 , 0 , 32,
20907 0xfc007f03, 0xa4005100, &LL , 0,
20908 0x0 }, /* LL */
20909 { instruction , 0 , 0 , 32,
20910 0xfc007f03, 0xa4005101, &LLWP , 0,
20911 XNP_ }, /* LLWP */
20912 { reserved_block , 0 , 0 , 32,
20913 0xfc007f03, 0xa4005102, 0 , 0,
20914 0x0 }, /* P.LL~*(2) */
20915 { reserved_block , 0 , 0 , 32,
20916 0xfc007f03, 0xa4005103, 0 , 0,
20917 0x0 }, /* P.LL~*(3) */
20918 };
20919
20920
20921 static const Pool P_SC[4] = {
20922 { instruction , 0 , 0 , 32,
20923 0xfc007f03, 0xa4005900, &SC , 0,
20924 0x0 }, /* SC */
20925 { instruction , 0 , 0 , 32,
20926 0xfc007f03, 0xa4005901, &SCWP , 0,
20927 XNP_ }, /* SCWP */
20928 { reserved_block , 0 , 0 , 32,
20929 0xfc007f03, 0xa4005902, 0 , 0,
20930 0x0 }, /* P.SC~*(2) */
20931 { reserved_block , 0 , 0 , 32,
20932 0xfc007f03, 0xa4005903, 0 , 0,
20933 0x0 }, /* P.SC~*(3) */
20934 };
20935
20936
20937 static const Pool P_LLD[8] = {
20938 { instruction , 0 , 0 , 32,
20939 0xfc007f07, 0xa4007100, &LLD , 0,
20940 MIPS64_ }, /* LLD */
20941 { instruction , 0 , 0 , 32,
20942 0xfc007f07, 0xa4007101, &LLDP , 0,
20943 MIPS64_ }, /* LLDP */
20944 { reserved_block , 0 , 0 , 32,
20945 0xfc007f07, 0xa4007102, 0 , 0,
20946 0x0 }, /* P.LLD~*(2) */
20947 { reserved_block , 0 , 0 , 32,
20948 0xfc007f07, 0xa4007103, 0 , 0,
20949 0x0 }, /* P.LLD~*(3) */
20950 { reserved_block , 0 , 0 , 32,
20951 0xfc007f07, 0xa4007104, 0 , 0,
20952 0x0 }, /* P.LLD~*(4) */
20953 { reserved_block , 0 , 0 , 32,
20954 0xfc007f07, 0xa4007105, 0 , 0,
20955 0x0 }, /* P.LLD~*(5) */
20956 { reserved_block , 0 , 0 , 32,
20957 0xfc007f07, 0xa4007106, 0 , 0,
20958 0x0 }, /* P.LLD~*(6) */
20959 { reserved_block , 0 , 0 , 32,
20960 0xfc007f07, 0xa4007107, 0 , 0,
20961 0x0 }, /* P.LLD~*(7) */
20962 };
20963
20964
20965 static const Pool P_SCD[8] = {
20966 { instruction , 0 , 0 , 32,
20967 0xfc007f07, 0xa4007900, &SCD , 0,
20968 MIPS64_ }, /* SCD */
20969 { instruction , 0 , 0 , 32,
20970 0xfc007f07, 0xa4007901, &SCDP , 0,
20971 MIPS64_ }, /* SCDP */
20972 { reserved_block , 0 , 0 , 32,
20973 0xfc007f07, 0xa4007902, 0 , 0,
20974 0x0 }, /* P.SCD~*(2) */
20975 { reserved_block , 0 , 0 , 32,
20976 0xfc007f07, 0xa4007903, 0 , 0,
20977 0x0 }, /* P.SCD~*(3) */
20978 { reserved_block , 0 , 0 , 32,
20979 0xfc007f07, 0xa4007904, 0 , 0,
20980 0x0 }, /* P.SCD~*(4) */
20981 { reserved_block , 0 , 0 , 32,
20982 0xfc007f07, 0xa4007905, 0 , 0,
20983 0x0 }, /* P.SCD~*(5) */
20984 { reserved_block , 0 , 0 , 32,
20985 0xfc007f07, 0xa4007906, 0 , 0,
20986 0x0 }, /* P.SCD~*(6) */
20987 { reserved_block , 0 , 0 , 32,
20988 0xfc007f07, 0xa4007907, 0 , 0,
20989 0x0 }, /* P.SCD~*(7) */
20990 };
20991
20992
20993 static const Pool P_LS_S1[16] = {
20994 { reserved_block , 0 , 0 , 32,
20995 0xfc007f00, 0xa4000100, 0 , 0,
20996 0x0 }, /* P.LS.S1~*(0) */
20997 { reserved_block , 0 , 0 , 32,
20998 0xfc007f00, 0xa4000900, 0 , 0,
20999 0x0 }, /* P.LS.S1~*(1) */
21000 { pool , ASET_ACLR , 2 , 32,
21001 0xfc007f00, 0xa4001100, 0 , 0,
21002 0x0 }, /* ASET_ACLR */
21003 { reserved_block , 0 , 0 , 32,
21004 0xfc007f00, 0xa4001900, 0 , 0,
21005 0x0 }, /* P.LS.S1~*(3) */
21006 { instruction , 0 , 0 , 32,
21007 0xfc007f00, 0xa4002100, &UALH , 0,
21008 XMMS_ }, /* UALH */
21009 { instruction , 0 , 0 , 32,
21010 0xfc007f00, 0xa4002900, &UASH , 0,
21011 XMMS_ }, /* UASH */
21012 { reserved_block , 0 , 0 , 32,
21013 0xfc007f00, 0xa4003100, 0 , 0,
21014 0x0 }, /* P.LS.S1~*(6) */
21015 { instruction , 0 , 0 , 32,
21016 0xfc007f00, 0xa4003900, &CACHE , 0,
21017 CP0_ }, /* CACHE */
21018 { instruction , 0 , 0 , 32,
21019 0xfc007f00, 0xa4004100, &LWC2 , 0,
21020 CP2_ }, /* LWC2 */
21021 { instruction , 0 , 0 , 32,
21022 0xfc007f00, 0xa4004900, &SWC2 , 0,
21023 CP2_ }, /* SWC2 */
21024 { pool , P_LL , 4 , 32,
21025 0xfc007f00, 0xa4005100, 0 , 0,
21026 0x0 }, /* P.LL */
21027 { pool , P_SC , 4 , 32,
21028 0xfc007f00, 0xa4005900, 0 , 0,
21029 0x0 }, /* P.SC */
21030 { instruction , 0 , 0 , 32,
21031 0xfc007f00, 0xa4006100, &LDC2 , 0,
21032 CP2_ }, /* LDC2 */
21033 { instruction , 0 , 0 , 32,
21034 0xfc007f00, 0xa4006900, &SDC2 , 0,
21035 CP2_ }, /* SDC2 */
21036 { pool , P_LLD , 8 , 32,
21037 0xfc007f00, 0xa4007100, 0 , 0,
21038 0x0 }, /* P.LLD */
21039 { pool , P_SCD , 8 , 32,
21040 0xfc007f00, 0xa4007900, 0 , 0,
21041 0x0 }, /* P.SCD */
21042 };
21043
21044
21045 static const Pool P_PREFE[2] = {
21046 { instruction , 0 , 0 , 32,
21047 0xffe07f00, 0xa7e01a00, &SYNCIE , 0,
21048 CP0_ | EVA_ }, /* SYNCIE */
21049 { instruction , 0 , 0 , 32,
21050 0xfc007f00, 0xa4001a00, &PREFE , &PREFE_cond ,
21051 CP0_ | EVA_ }, /* PREFE */
21052 };
21053
21054
21055 static const Pool P_LLE[4] = {
21056 { instruction , 0 , 0 , 32,
21057 0xfc007f03, 0xa4005200, &LLE , 0,
21058 CP0_ | EVA_ }, /* LLE */
21059 { instruction , 0 , 0 , 32,
21060 0xfc007f03, 0xa4005201, &LLWPE , 0,
21061 CP0_ | EVA_ }, /* LLWPE */
21062 { reserved_block , 0 , 0 , 32,
21063 0xfc007f03, 0xa4005202, 0 , 0,
21064 0x0 }, /* P.LLE~*(2) */
21065 { reserved_block , 0 , 0 , 32,
21066 0xfc007f03, 0xa4005203, 0 , 0,
21067 0x0 }, /* P.LLE~*(3) */
21068 };
21069
21070
21071 static const Pool P_SCE[4] = {
21072 { instruction , 0 , 0 , 32,
21073 0xfc007f03, 0xa4005a00, &SCE , 0,
21074 CP0_ | EVA_ }, /* SCE */
21075 { instruction , 0 , 0 , 32,
21076 0xfc007f03, 0xa4005a01, &SCWPE , 0,
21077 CP0_ | EVA_ }, /* SCWPE */
21078 { reserved_block , 0 , 0 , 32,
21079 0xfc007f03, 0xa4005a02, 0 , 0,
21080 0x0 }, /* P.SCE~*(2) */
21081 { reserved_block , 0 , 0 , 32,
21082 0xfc007f03, 0xa4005a03, 0 , 0,
21083 0x0 }, /* P.SCE~*(3) */
21084 };
21085
21086
21087 static const Pool P_LS_E0[16] = {
21088 { instruction , 0 , 0 , 32,
21089 0xfc007f00, 0xa4000200, &LBE , 0,
21090 CP0_ | EVA_ }, /* LBE */
21091 { instruction , 0 , 0 , 32,
21092 0xfc007f00, 0xa4000a00, &SBE , 0,
21093 CP0_ | EVA_ }, /* SBE */
21094 { instruction , 0 , 0 , 32,
21095 0xfc007f00, 0xa4001200, &LBUE , 0,
21096 CP0_ | EVA_ }, /* LBUE */
21097 { pool , P_PREFE , 2 , 32,
21098 0xfc007f00, 0xa4001a00, 0 , 0,
21099 0x0 }, /* P.PREFE */
21100 { instruction , 0 , 0 , 32,
21101 0xfc007f00, 0xa4002200, &LHE , 0,
21102 CP0_ | EVA_ }, /* LHE */
21103 { instruction , 0 , 0 , 32,
21104 0xfc007f00, 0xa4002a00, &SHE , 0,
21105 CP0_ | EVA_ }, /* SHE */
21106 { instruction , 0 , 0 , 32,
21107 0xfc007f00, 0xa4003200, &LHUE , 0,
21108 CP0_ | EVA_ }, /* LHUE */
21109 { instruction , 0 , 0 , 32,
21110 0xfc007f00, 0xa4003a00, &CACHEE , 0,
21111 CP0_ | EVA_ }, /* CACHEE */
21112 { instruction , 0 , 0 , 32,
21113 0xfc007f00, 0xa4004200, &LWE , 0,
21114 CP0_ | EVA_ }, /* LWE */
21115 { instruction , 0 , 0 , 32,
21116 0xfc007f00, 0xa4004a00, &SWE , 0,
21117 CP0_ | EVA_ }, /* SWE */
21118 { pool , P_LLE , 4 , 32,
21119 0xfc007f00, 0xa4005200, 0 , 0,
21120 0x0 }, /* P.LLE */
21121 { pool , P_SCE , 4 , 32,
21122 0xfc007f00, 0xa4005a00, 0 , 0,
21123 0x0 }, /* P.SCE */
21124 { reserved_block , 0 , 0 , 32,
21125 0xfc007f00, 0xa4006200, 0 , 0,
21126 0x0 }, /* P.LS.E0~*(12) */
21127 { reserved_block , 0 , 0 , 32,
21128 0xfc007f00, 0xa4006a00, 0 , 0,
21129 0x0 }, /* P.LS.E0~*(13) */
21130 { reserved_block , 0 , 0 , 32,
21131 0xfc007f00, 0xa4007200, 0 , 0,
21132 0x0 }, /* P.LS.E0~*(14) */
21133 { reserved_block , 0 , 0 , 32,
21134 0xfc007f00, 0xa4007a00, 0 , 0,
21135 0x0 }, /* P.LS.E0~*(15) */
21136 };
21137
21138
21139 static const Pool P_LS_WM[2] = {
21140 { instruction , 0 , 0 , 32,
21141 0xfc000f00, 0xa4000400, &LWM , 0,
21142 XMMS_ }, /* LWM */
21143 { instruction , 0 , 0 , 32,
21144 0xfc000f00, 0xa4000c00, &SWM , 0,
21145 XMMS_ }, /* SWM */
21146 };
21147
21148
21149 static const Pool P_LS_UAWM[2] = {
21150 { instruction , 0 , 0 , 32,
21151 0xfc000f00, 0xa4000500, &UALWM , 0,
21152 XMMS_ }, /* UALWM */
21153 { instruction , 0 , 0 , 32,
21154 0xfc000f00, 0xa4000d00, &UASWM , 0,
21155 XMMS_ }, /* UASWM */
21156 };
21157
21158
21159 static const Pool P_LS_DM[2] = {
21160 { instruction , 0 , 0 , 32,
21161 0xfc000f00, 0xa4000600, &LDM , 0,
21162 MIPS64_ }, /* LDM */
21163 { instruction , 0 , 0 , 32,
21164 0xfc000f00, 0xa4000e00, &SDM , 0,
21165 MIPS64_ }, /* SDM */
21166 };
21167
21168
21169 static const Pool P_LS_UADM[2] = {
21170 { instruction , 0 , 0 , 32,
21171 0xfc000f00, 0xa4000700, &UALDM , 0,
21172 MIPS64_ }, /* UALDM */
21173 { instruction , 0 , 0 , 32,
21174 0xfc000f00, 0xa4000f00, &UASDM , 0,
21175 MIPS64_ }, /* UASDM */
21176 };
21177
21178
21179 static const Pool P_LS_S9[8] = {
21180 { pool , P_LS_S0 , 16 , 32,
21181 0xfc000700, 0xa4000000, 0 , 0,
21182 0x0 }, /* P.LS.S0 */
21183 { pool , P_LS_S1 , 16 , 32,
21184 0xfc000700, 0xa4000100, 0 , 0,
21185 0x0 }, /* P.LS.S1 */
21186 { pool , P_LS_E0 , 16 , 32,
21187 0xfc000700, 0xa4000200, 0 , 0,
21188 0x0 }, /* P.LS.E0 */
21189 { reserved_block , 0 , 0 , 32,
21190 0xfc000700, 0xa4000300, 0 , 0,
21191 0x0 }, /* P.LS.S9~*(3) */
21192 { pool , P_LS_WM , 2 , 32,
21193 0xfc000700, 0xa4000400, 0 , 0,
21194 0x0 }, /* P.LS.WM */
21195 { pool , P_LS_UAWM , 2 , 32,
21196 0xfc000700, 0xa4000500, 0 , 0,
21197 0x0 }, /* P.LS.UAWM */
21198 { pool , P_LS_DM , 2 , 32,
21199 0xfc000700, 0xa4000600, 0 , 0,
21200 0x0 }, /* P.LS.DM */
21201 { pool , P_LS_UADM , 2 , 32,
21202 0xfc000700, 0xa4000700, 0 , 0,
21203 0x0 }, /* P.LS.UADM */
21204 };
21205
21206
21207 static const Pool P_BAL[2] = {
21208 { branch_instruction , 0 , 0 , 32,
21209 0xfe000000, 0x28000000, &BC_32_ , 0,
21210 0x0 }, /* BC[32] */
21211 { call_instruction , 0 , 0 , 32,
21212 0xfe000000, 0x2a000000, &BALC_32_ , 0,
21213 0x0 }, /* BALC[32] */
21214 };
21215
21216
21217 static const Pool P_BALRSC[2] = {
21218 { branch_instruction , 0 , 0 , 32,
21219 0xffe0f000, 0x48008000, &BRSC , 0,
21220 0x0 }, /* BRSC */
21221 { call_instruction , 0 , 0 , 32,
21222 0xfc00f000, 0x48008000, &BALRSC , &BALRSC_cond ,
21223 0x0 }, /* BALRSC */
21224 };
21225
21226
21227 static const Pool P_J[16] = {
21228 { call_instruction , 0 , 0 , 32,
21229 0xfc00f000, 0x48000000, &JALRC_32_ , 0,
21230 0x0 }, /* JALRC[32] */
21231 { call_instruction , 0 , 0 , 32,
21232 0xfc00f000, 0x48001000, &JALRC_HB , 0,
21233 0x0 }, /* JALRC.HB */
21234 { reserved_block , 0 , 0 , 32,
21235 0xfc00f000, 0x48002000, 0 , 0,
21236 0x0 }, /* P.J~*(2) */
21237 { reserved_block , 0 , 0 , 32,
21238 0xfc00f000, 0x48003000, 0 , 0,
21239 0x0 }, /* P.J~*(3) */
21240 { reserved_block , 0 , 0 , 32,
21241 0xfc00f000, 0x48004000, 0 , 0,
21242 0x0 }, /* P.J~*(4) */
21243 { reserved_block , 0 , 0 , 32,
21244 0xfc00f000, 0x48005000, 0 , 0,
21245 0x0 }, /* P.J~*(5) */
21246 { reserved_block , 0 , 0 , 32,
21247 0xfc00f000, 0x48006000, 0 , 0,
21248 0x0 }, /* P.J~*(6) */
21249 { reserved_block , 0 , 0 , 32,
21250 0xfc00f000, 0x48007000, 0 , 0,
21251 0x0 }, /* P.J~*(7) */
21252 { pool , P_BALRSC , 2 , 32,
21253 0xfc00f000, 0x48008000, 0 , 0,
21254 0x0 }, /* P.BALRSC */
21255 { reserved_block , 0 , 0 , 32,
21256 0xfc00f000, 0x48009000, 0 , 0,
21257 0x0 }, /* P.J~*(9) */
21258 { reserved_block , 0 , 0 , 32,
21259 0xfc00f000, 0x4800a000, 0 , 0,
21260 0x0 }, /* P.J~*(10) */
21261 { reserved_block , 0 , 0 , 32,
21262 0xfc00f000, 0x4800b000, 0 , 0,
21263 0x0 }, /* P.J~*(11) */
21264 { reserved_block , 0 , 0 , 32,
21265 0xfc00f000, 0x4800c000, 0 , 0,
21266 0x0 }, /* P.J~*(12) */
21267 { reserved_block , 0 , 0 , 32,
21268 0xfc00f000, 0x4800d000, 0 , 0,
21269 0x0 }, /* P.J~*(13) */
21270 { reserved_block , 0 , 0 , 32,
21271 0xfc00f000, 0x4800e000, 0 , 0,
21272 0x0 }, /* P.J~*(14) */
21273 { reserved_block , 0 , 0 , 32,
21274 0xfc00f000, 0x4800f000, 0 , 0,
21275 0x0 }, /* P.J~*(15) */
21276 };
21277
21278
21279 static const Pool P_BR3A[32] = {
21280 { branch_instruction , 0 , 0 , 32,
21281 0xfc1fc000, 0x88004000, &BC1EQZC , 0,
21282 CP1_ }, /* BC1EQZC */
21283 { branch_instruction , 0 , 0 , 32,
21284 0xfc1fc000, 0x88014000, &BC1NEZC , 0,
21285 CP1_ }, /* BC1NEZC */
21286 { branch_instruction , 0 , 0 , 32,
21287 0xfc1fc000, 0x88024000, &BC2EQZC , 0,
21288 CP2_ }, /* BC2EQZC */
21289 { branch_instruction , 0 , 0 , 32,
21290 0xfc1fc000, 0x88034000, &BC2NEZC , 0,
21291 CP2_ }, /* BC2NEZC */
21292 { branch_instruction , 0 , 0 , 32,
21293 0xfc1fc000, 0x88044000, &BPOSGE32C , 0,
21294 DSP_ }, /* BPOSGE32C */
21295 { reserved_block , 0 , 0 , 32,
21296 0xfc1fc000, 0x88054000, 0 , 0,
21297 0x0 }, /* P.BR3A~*(5) */
21298 { reserved_block , 0 , 0 , 32,
21299 0xfc1fc000, 0x88064000, 0 , 0,
21300 0x0 }, /* P.BR3A~*(6) */
21301 { reserved_block , 0 , 0 , 32,
21302 0xfc1fc000, 0x88074000, 0 , 0,
21303 0x0 }, /* P.BR3A~*(7) */
21304 { reserved_block , 0 , 0 , 32,
21305 0xfc1fc000, 0x88084000, 0 , 0,
21306 0x0 }, /* P.BR3A~*(8) */
21307 { reserved_block , 0 , 0 , 32,
21308 0xfc1fc000, 0x88094000, 0 , 0,
21309 0x0 }, /* P.BR3A~*(9) */
21310 { reserved_block , 0 , 0 , 32,
21311 0xfc1fc000, 0x880a4000, 0 , 0,
21312 0x0 }, /* P.BR3A~*(10) */
21313 { reserved_block , 0 , 0 , 32,
21314 0xfc1fc000, 0x880b4000, 0 , 0,
21315 0x0 }, /* P.BR3A~*(11) */
21316 { reserved_block , 0 , 0 , 32,
21317 0xfc1fc000, 0x880c4000, 0 , 0,
21318 0x0 }, /* P.BR3A~*(12) */
21319 { reserved_block , 0 , 0 , 32,
21320 0xfc1fc000, 0x880d4000, 0 , 0,
21321 0x0 }, /* P.BR3A~*(13) */
21322 { reserved_block , 0 , 0 , 32,
21323 0xfc1fc000, 0x880e4000, 0 , 0,
21324 0x0 }, /* P.BR3A~*(14) */
21325 { reserved_block , 0 , 0 , 32,
21326 0xfc1fc000, 0x880f4000, 0 , 0,
21327 0x0 }, /* P.BR3A~*(15) */
21328 { reserved_block , 0 , 0 , 32,
21329 0xfc1fc000, 0x88104000, 0 , 0,
21330 0x0 }, /* P.BR3A~*(16) */
21331 { reserved_block , 0 , 0 , 32,
21332 0xfc1fc000, 0x88114000, 0 , 0,
21333 0x0 }, /* P.BR3A~*(17) */
21334 { reserved_block , 0 , 0 , 32,
21335 0xfc1fc000, 0x88124000, 0 , 0,
21336 0x0 }, /* P.BR3A~*(18) */
21337 { reserved_block , 0 , 0 , 32,
21338 0xfc1fc000, 0x88134000, 0 , 0,
21339 0x0 }, /* P.BR3A~*(19) */
21340 { reserved_block , 0 , 0 , 32,
21341 0xfc1fc000, 0x88144000, 0 , 0,
21342 0x0 }, /* P.BR3A~*(20) */
21343 { reserved_block , 0 , 0 , 32,
21344 0xfc1fc000, 0x88154000, 0 , 0,
21345 0x0 }, /* P.BR3A~*(21) */
21346 { reserved_block , 0 , 0 , 32,
21347 0xfc1fc000, 0x88164000, 0 , 0,
21348 0x0 }, /* P.BR3A~*(22) */
21349 { reserved_block , 0 , 0 , 32,
21350 0xfc1fc000, 0x88174000, 0 , 0,
21351 0x0 }, /* P.BR3A~*(23) */
21352 { reserved_block , 0 , 0 , 32,
21353 0xfc1fc000, 0x88184000, 0 , 0,
21354 0x0 }, /* P.BR3A~*(24) */
21355 { reserved_block , 0 , 0 , 32,
21356 0xfc1fc000, 0x88194000, 0 , 0,
21357 0x0 }, /* P.BR3A~*(25) */
21358 { reserved_block , 0 , 0 , 32,
21359 0xfc1fc000, 0x881a4000, 0 , 0,
21360 0x0 }, /* P.BR3A~*(26) */
21361 { reserved_block , 0 , 0 , 32,
21362 0xfc1fc000, 0x881b4000, 0 , 0,
21363 0x0 }, /* P.BR3A~*(27) */
21364 { reserved_block , 0 , 0 , 32,
21365 0xfc1fc000, 0x881c4000, 0 , 0,
21366 0x0 }, /* P.BR3A~*(28) */
21367 { reserved_block , 0 , 0 , 32,
21368 0xfc1fc000, 0x881d4000, 0 , 0,
21369 0x0 }, /* P.BR3A~*(29) */
21370 { reserved_block , 0 , 0 , 32,
21371 0xfc1fc000, 0x881e4000, 0 , 0,
21372 0x0 }, /* P.BR3A~*(30) */
21373 { reserved_block , 0 , 0 , 32,
21374 0xfc1fc000, 0x881f4000, 0 , 0,
21375 0x0 }, /* P.BR3A~*(31) */
21376 };
21377
21378
21379 static const Pool P_BR1[4] = {
21380 { branch_instruction , 0 , 0 , 32,
21381 0xfc00c000, 0x88000000, &BEQC_32_ , 0,
21382 0x0 }, /* BEQC[32] */
21383 { pool , P_BR3A , 32 , 32,
21384 0xfc00c000, 0x88004000, 0 , 0,
21385 0x0 }, /* P.BR3A */
21386 { branch_instruction , 0 , 0 , 32,
21387 0xfc00c000, 0x88008000, &BGEC , 0,
21388 0x0 }, /* BGEC */
21389 { branch_instruction , 0 , 0 , 32,
21390 0xfc00c000, 0x8800c000, &BGEUC , 0,
21391 0x0 }, /* BGEUC */
21392 };
21393
21394
21395 static const Pool P_BR2[4] = {
21396 { branch_instruction , 0 , 0 , 32,
21397 0xfc00c000, 0xa8000000, &BNEC_32_ , 0,
21398 0x0 }, /* BNEC[32] */
21399 { reserved_block , 0 , 0 , 32,
21400 0xfc00c000, 0xa8004000, 0 , 0,
21401 0x0 }, /* P.BR2~*(1) */
21402 { branch_instruction , 0 , 0 , 32,
21403 0xfc00c000, 0xa8008000, &BLTC , 0,
21404 0x0 }, /* BLTC */
21405 { branch_instruction , 0 , 0 , 32,
21406 0xfc00c000, 0xa800c000, &BLTUC , 0,
21407 0x0 }, /* BLTUC */
21408 };
21409
21410
21411 static const Pool P_BRI[8] = {
21412 { branch_instruction , 0 , 0 , 32,
21413 0xfc1c0000, 0xc8000000, &BEQIC , 0,
21414 0x0 }, /* BEQIC */
21415 { branch_instruction , 0 , 0 , 32,
21416 0xfc1c0000, 0xc8040000, &BBEQZC , 0,
21417 XMMS_ }, /* BBEQZC */
21418 { branch_instruction , 0 , 0 , 32,
21419 0xfc1c0000, 0xc8080000, &BGEIC , 0,
21420 0x0 }, /* BGEIC */
21421 { branch_instruction , 0 , 0 , 32,
21422 0xfc1c0000, 0xc80c0000, &BGEIUC , 0,
21423 0x0 }, /* BGEIUC */
21424 { branch_instruction , 0 , 0 , 32,
21425 0xfc1c0000, 0xc8100000, &BNEIC , 0,
21426 0x0 }, /* BNEIC */
21427 { branch_instruction , 0 , 0 , 32,
21428 0xfc1c0000, 0xc8140000, &BBNEZC , 0,
21429 XMMS_ }, /* BBNEZC */
21430 { branch_instruction , 0 , 0 , 32,
21431 0xfc1c0000, 0xc8180000, &BLTIC , 0,
21432 0x0 }, /* BLTIC */
21433 { branch_instruction , 0 , 0 , 32,
21434 0xfc1c0000, 0xc81c0000, &BLTIUC , 0,
21435 0x0 }, /* BLTIUC */
21436 };
21437
21438
21439 static const Pool P32[32] = {
21440 { pool , P_ADDIU , 2 , 32,
21441 0xfc000000, 0x00000000, 0 , 0,
21442 0x0 }, /* P.ADDIU */
21443 { pool , P32A , 8 , 32,
21444 0xfc000000, 0x20000000, 0 , 0,
21445 0x0 }, /* P32A */
21446 { pool , P_GP_W , 4 , 32,
21447 0xfc000000, 0x40000000, 0 , 0,
21448 0x0 }, /* P.GP.W */
21449 { pool , POOL48I , 32 , 48,
21450 0xfc0000000000ull, 0x600000000000ull, 0 , 0,
21451 0x0 }, /* POOL48I */
21452 { pool , P_U12 , 16 , 32,
21453 0xfc000000, 0x80000000, 0 , 0,
21454 0x0 }, /* P.U12 */
21455 { pool , POOL32F , 8 , 32,
21456 0xfc000000, 0xa0000000, 0 , 0,
21457 CP1_ }, /* POOL32F */
21458 { pool , POOL32S , 8 , 32,
21459 0xfc000000, 0xc0000000, 0 , 0,
21460 0x0 }, /* POOL32S */
21461 { pool , P_LUI , 2 , 32,
21462 0xfc000000, 0xe0000000, 0 , 0,
21463 0x0 }, /* P.LUI */
21464 { instruction , 0 , 0 , 32,
21465 0xfc000000, 0x04000000, &ADDIUPC_32_ , 0,
21466 0x0 }, /* ADDIUPC[32] */
21467 { reserved_block , 0 , 0 , 32,
21468 0xfc000000, 0x24000000, 0 , 0,
21469 0x0 }, /* P32~*(5) */
21470 { pool , P_GP_BH , 8 , 32,
21471 0xfc000000, 0x44000000, 0 , 0,
21472 0x0 }, /* P.GP.BH */
21473 { reserved_block , 0 , 0 , 32,
21474 0xfc000000, 0x64000000, 0 , 0,
21475 0x0 }, /* P32~*(13) */
21476 { pool , P_LS_U12 , 16 , 32,
21477 0xfc000000, 0x84000000, 0 , 0,
21478 0x0 }, /* P.LS.U12 */
21479 { pool , P_LS_S9 , 8 , 32,
21480 0xfc000000, 0xa4000000, 0 , 0,
21481 0x0 }, /* P.LS.S9 */
21482 { reserved_block , 0 , 0 , 32,
21483 0xfc000000, 0xc4000000, 0 , 0,
21484 0x0 }, /* P32~*(25) */
21485 { reserved_block , 0 , 0 , 32,
21486 0xfc000000, 0xe4000000, 0 , 0,
21487 0x0 }, /* P32~*(29) */
21488 { call_instruction , 0 , 0 , 32,
21489 0xfc000000, 0x08000000, &MOVE_BALC , 0,
21490 XMMS_ }, /* MOVE.BALC */
21491 { pool , P_BAL , 2 , 32,
21492 0xfc000000, 0x28000000, 0 , 0,
21493 0x0 }, /* P.BAL */
21494 { pool , P_J , 16 , 32,
21495 0xfc000000, 0x48000000, 0 , 0,
21496 0x0 }, /* P.J */
21497 { reserved_block , 0 , 0 , 32,
21498 0xfc000000, 0x68000000, 0 , 0,
21499 0x0 }, /* P32~*(14) */
21500 { pool , P_BR1 , 4 , 32,
21501 0xfc000000, 0x88000000, 0 , 0,
21502 0x0 }, /* P.BR1 */
21503 { pool , P_BR2 , 4 , 32,
21504 0xfc000000, 0xa8000000, 0 , 0,
21505 0x0 }, /* P.BR2 */
21506 { pool , P_BRI , 8 , 32,
21507 0xfc000000, 0xc8000000, 0 , 0,
21508 0x0 }, /* P.BRI */
21509 { reserved_block , 0 , 0 , 32,
21510 0xfc000000, 0xe8000000, 0 , 0,
21511 0x0 }, /* P32~*(30) */
21512 { reserved_block , 0 , 0 , 32,
21513 0xfc000000, 0x0c000000, 0 , 0,
21514 0x0 }, /* P32~*(3) */
21515 { reserved_block , 0 , 0 , 32,
21516 0xfc000000, 0x2c000000, 0 , 0,
21517 0x0 }, /* P32~*(7) */
21518 { reserved_block , 0 , 0 , 32,
21519 0xfc000000, 0x4c000000, 0 , 0,
21520 0x0 }, /* P32~*(11) */
21521 { reserved_block , 0 , 0 , 32,
21522 0xfc000000, 0x6c000000, 0 , 0,
21523 0x0 }, /* P32~*(15) */
21524 { reserved_block , 0 , 0 , 32,
21525 0xfc000000, 0x8c000000, 0 , 0,
21526 0x0 }, /* P32~*(19) */
21527 { reserved_block , 0 , 0 , 32,
21528 0xfc000000, 0xac000000, 0 , 0,
21529 0x0 }, /* P32~*(23) */
21530 { reserved_block , 0 , 0 , 32,
21531 0xfc000000, 0xcc000000, 0 , 0,
21532 0x0 }, /* P32~*(27) */
21533 { reserved_block , 0 , 0 , 32,
21534 0xfc000000, 0xec000000, 0 , 0,
21535 0x0 }, /* P32~*(31) */
21536 };
21537
21538
21539 static const Pool P16_SYSCALL[2] = {
21540 { instruction , 0 , 0 , 16,
21541 0xfffc , 0x1008 , &SYSCALL_16_ , 0,
21542 0x0 }, /* SYSCALL[16] */
21543 { instruction , 0 , 0 , 16,
21544 0xfffc , 0x100c , &HYPCALL_16_ , 0,
21545 CP0_ | VZ_ }, /* HYPCALL[16] */
21546 };
21547
21548
21549 static const Pool P16_RI[4] = {
21550 { reserved_block , 0 , 0 , 16,
21551 0xfff8 , 0x1000 , 0 , 0,
21552 0x0 }, /* P16.RI~*(0) */
21553 { pool , P16_SYSCALL , 2 , 16,
21554 0xfff8 , 0x1008 , 0 , 0,
21555 0x0 }, /* P16.SYSCALL */
21556 { instruction , 0 , 0 , 16,
21557 0xfff8 , 0x1010 , &BREAK_16_ , 0,
21558 0x0 }, /* BREAK[16] */
21559 { instruction , 0 , 0 , 16,
21560 0xfff8 , 0x1018 , &SDBBP_16_ , 0,
21561 EJTAG_ }, /* SDBBP[16] */
21562 };
21563
21564
21565 static const Pool P16_MV[2] = {
21566 { pool , P16_RI , 4 , 16,
21567 0xffe0 , 0x1000 , 0 , 0,
21568 0x0 }, /* P16.RI */
21569 { instruction , 0 , 0 , 16,
21570 0xfc00 , 0x1000 , &MOVE , &MOVE_cond ,
21571 0x0 }, /* MOVE */
21572 };
21573
21574
21575 static const Pool P16_SHIFT[2] = {
21576 { instruction , 0 , 0 , 16,
21577 0xfc08 , 0x3000 , &SLL_16_ , 0,
21578 0x0 }, /* SLL[16] */
21579 { instruction , 0 , 0 , 16,
21580 0xfc08 , 0x3008 , &SRL_16_ , 0,
21581 0x0 }, /* SRL[16] */
21582 };
21583
21584
21585 static const Pool POOL16C_00[4] = {
21586 { instruction , 0 , 0 , 16,
21587 0xfc0f , 0x5000 , &NOT_16_ , 0,
21588 0x0 }, /* NOT[16] */
21589 { instruction , 0 , 0 , 16,
21590 0xfc0f , 0x5004 , &XOR_16_ , 0,
21591 0x0 }, /* XOR[16] */
21592 { instruction , 0 , 0 , 16,
21593 0xfc0f , 0x5008 , &AND_16_ , 0,
21594 0x0 }, /* AND[16] */
21595 { instruction , 0 , 0 , 16,
21596 0xfc0f , 0x500c , &OR_16_ , 0,
21597 0x0 }, /* OR[16] */
21598 };
21599
21600
21601 static const Pool POOL16C_0[2] = {
21602 { pool , POOL16C_00 , 4 , 16,
21603 0xfc03 , 0x5000 , 0 , 0,
21604 0x0 }, /* POOL16C_00 */
21605 { reserved_block , 0 , 0 , 16,
21606 0xfc03 , 0x5002 , 0 , 0,
21607 0x0 }, /* POOL16C_0~*(1) */
21608 };
21609
21610
21611 static const Pool P16C[2] = {
21612 { pool , POOL16C_0 , 2 , 16,
21613 0xfc01 , 0x5000 , 0 , 0,
21614 0x0 }, /* POOL16C_0 */
21615 { instruction , 0 , 0 , 16,
21616 0xfc01 , 0x5001 , &LWXS_16_ , 0,
21617 0x0 }, /* LWXS[16] */
21618 };
21619
21620
21621 static const Pool P16_A1[2] = {
21622 { reserved_block , 0 , 0 , 16,
21623 0xfc40 , 0x7000 , 0 , 0,
21624 0x0 }, /* P16.A1~*(0) */
21625 { instruction , 0 , 0 , 16,
21626 0xfc40 , 0x7040 , &ADDIU_R1_SP_ , 0,
21627 0x0 }, /* ADDIU[R1.SP] */
21628 };
21629
21630
21631 static const Pool P_ADDIU_RS5_[2] = {
21632 { instruction , 0 , 0 , 16,
21633 0xffe8 , 0x9008 , &NOP_16_ , 0,
21634 0x0 }, /* NOP[16] */
21635 { instruction , 0 , 0 , 16,
21636 0xfc08 , 0x9008 , &ADDIU_RS5_ , &ADDIU_RS5__cond ,
21637 0x0 }, /* ADDIU[RS5] */
21638 };
21639
21640
21641 static const Pool P16_A2[2] = {
21642 { instruction , 0 , 0 , 16,
21643 0xfc08 , 0x9000 , &ADDIU_R2_ , 0,
21644 0x0 }, /* ADDIU[R2] */
21645 { pool , P_ADDIU_RS5_ , 2 , 16,
21646 0xfc08 , 0x9008 , 0 , 0,
21647 0x0 }, /* P.ADDIU[RS5] */
21648 };
21649
21650
21651 static const Pool P16_ADDU[2] = {
21652 { instruction , 0 , 0 , 16,
21653 0xfc01 , 0xb000 , &ADDU_16_ , 0,
21654 0x0 }, /* ADDU[16] */
21655 { instruction , 0 , 0 , 16,
21656 0xfc01 , 0xb001 , &SUBU_16_ , 0,
21657 0x0 }, /* SUBU[16] */
21658 };
21659
21660
21661 static const Pool P16_JRC[2] = {
21662 { branch_instruction , 0 , 0 , 16,
21663 0xfc1f , 0xd800 , &JRC , 0,
21664 0x0 }, /* JRC */
21665 { call_instruction , 0 , 0 , 16,
21666 0xfc1f , 0xd810 , &JALRC_16_ , 0,
21667 0x0 }, /* JALRC[16] */
21668 };
21669
21670
21671 static const Pool P16_BR1[2] = {
21672 { branch_instruction , 0 , 0 , 16,
21673 0xfc00 , 0xd800 , &BEQC_16_ , &BEQC_16__cond ,
21674 XMMS_ }, /* BEQC[16] */
21675 { branch_instruction , 0 , 0 , 16,
21676 0xfc00 , 0xd800 , &BNEC_16_ , &BNEC_16__cond ,
21677 XMMS_ }, /* BNEC[16] */
21678 };
21679
21680
21681 static const Pool P16_BR[2] = {
21682 { pool , P16_JRC , 2 , 16,
21683 0xfc0f , 0xd800 , 0 , 0,
21684 0x0 }, /* P16.JRC */
21685 { pool , P16_BR1 , 2 , 16,
21686 0xfc00 , 0xd800 , 0 , &P16_BR1_cond ,
21687 0x0 }, /* P16.BR1 */
21688 };
21689
21690
21691 static const Pool P16_SR[2] = {
21692 { instruction , 0 , 0 , 16,
21693 0xfd00 , 0x1c00 , &SAVE_16_ , 0,
21694 0x0 }, /* SAVE[16] */
21695 { return_instruction , 0 , 0 , 16,
21696 0xfd00 , 0x1d00 , &RESTORE_JRC_16_ , 0,
21697 0x0 }, /* RESTORE.JRC[16] */
21698 };
21699
21700
21701 static const Pool P16_4X4[4] = {
21702 { instruction , 0 , 0 , 16,
21703 0xfd08 , 0x3c00 , &ADDU_4X4_ , 0,
21704 XMMS_ }, /* ADDU[4X4] */
21705 { instruction , 0 , 0 , 16,
21706 0xfd08 , 0x3c08 , &MUL_4X4_ , 0,
21707 XMMS_ }, /* MUL[4X4] */
21708 { reserved_block , 0 , 0 , 16,
21709 0xfd08 , 0x3d00 , 0 , 0,
21710 0x0 }, /* P16.4X4~*(2) */
21711 { reserved_block , 0 , 0 , 16,
21712 0xfd08 , 0x3d08 , 0 , 0,
21713 0x0 }, /* P16.4X4~*(3) */
21714 };
21715
21716
21717 static const Pool P16_LB[4] = {
21718 { instruction , 0 , 0 , 16,
21719 0xfc0c , 0x5c00 , &LB_16_ , 0,
21720 0x0 }, /* LB[16] */
21721 { instruction , 0 , 0 , 16,
21722 0xfc0c , 0x5c04 , &SB_16_ , 0,
21723 0x0 }, /* SB[16] */
21724 { instruction , 0 , 0 , 16,
21725 0xfc0c , 0x5c08 , &LBU_16_ , 0,
21726 0x0 }, /* LBU[16] */
21727 { reserved_block , 0 , 0 , 16,
21728 0xfc0c , 0x5c0c , 0 , 0,
21729 0x0 }, /* P16.LB~*(3) */
21730 };
21731
21732
21733 static const Pool P16_LH[4] = {
21734 { instruction , 0 , 0 , 16,
21735 0xfc09 , 0x7c00 , &LH_16_ , 0,
21736 0x0 }, /* LH[16] */
21737 { instruction , 0 , 0 , 16,
21738 0xfc09 , 0x7c01 , &SH_16_ , 0,
21739 0x0 }, /* SH[16] */
21740 { instruction , 0 , 0 , 16,
21741 0xfc09 , 0x7c08 , &LHU_16_ , 0,
21742 0x0 }, /* LHU[16] */
21743 { reserved_block , 0 , 0 , 16,
21744 0xfc09 , 0x7c09 , 0 , 0,
21745 0x0 }, /* P16.LH~*(3) */
21746 };
21747
21748
21749 static const Pool P16[32] = {
21750 { pool , P16_MV , 2 , 16,
21751 0xfc00 , 0x1000 , 0 , 0,
21752 0x0 }, /* P16.MV */
21753 { pool , P16_SHIFT , 2 , 16,
21754 0xfc00 , 0x3000 , 0 , 0,
21755 0x0 }, /* P16.SHIFT */
21756 { pool , P16C , 2 , 16,
21757 0xfc00 , 0x5000 , 0 , 0,
21758 0x0 }, /* P16C */
21759 { pool , P16_A1 , 2 , 16,
21760 0xfc00 , 0x7000 , 0 , 0,
21761 0x0 }, /* P16.A1 */
21762 { pool , P16_A2 , 2 , 16,
21763 0xfc00 , 0x9000 , 0 , 0,
21764 0x0 }, /* P16.A2 */
21765 { pool , P16_ADDU , 2 , 16,
21766 0xfc00 , 0xb000 , 0 , 0,
21767 0x0 }, /* P16.ADDU */
21768 { instruction , 0 , 0 , 16,
21769 0xfc00 , 0xd000 , &LI_16_ , 0,
21770 0x0 }, /* LI[16] */
21771 { instruction , 0 , 0 , 16,
21772 0xfc00 , 0xf000 , &ANDI_16_ , 0,
21773 0x0 }, /* ANDI[16] */
21774 { instruction , 0 , 0 , 16,
21775 0xfc00 , 0x1400 , &LW_16_ , 0,
21776 0x0 }, /* LW[16] */
21777 { instruction , 0 , 0 , 16,
21778 0xfc00 , 0x3400 , &LW_SP_ , 0,
21779 0x0 }, /* LW[SP] */
21780 { instruction , 0 , 0 , 16,
21781 0xfc00 , 0x5400 , &LW_GP16_ , 0,
21782 0x0 }, /* LW[GP16] */
21783 { instruction , 0 , 0 , 16,
21784 0xfc00 , 0x7400 , &LW_4X4_ , 0,
21785 XMMS_ }, /* LW[4X4] */
21786 { instruction , 0 , 0 , 16,
21787 0xfc00 , 0x9400 , &SW_16_ , 0,
21788 0x0 }, /* SW[16] */
21789 { instruction , 0 , 0 , 16,
21790 0xfc00 , 0xb400 , &SW_SP_ , 0,
21791 0x0 }, /* SW[SP] */
21792 { instruction , 0 , 0 , 16,
21793 0xfc00 , 0xd400 , &SW_GP16_ , 0,
21794 0x0 }, /* SW[GP16] */
21795 { instruction , 0 , 0 , 16,
21796 0xfc00 , 0xf400 , &SW_4X4_ , 0,
21797 XMMS_ }, /* SW[4X4] */
21798 { branch_instruction , 0 , 0 , 16,
21799 0xfc00 , 0x1800 , &BC_16_ , 0,
21800 0x0 }, /* BC[16] */
21801 { call_instruction , 0 , 0 , 16,
21802 0xfc00 , 0x3800 , &BALC_16_ , 0,
21803 0x0 }, /* BALC[16] */
21804 { reserved_block , 0 , 0 , 16,
21805 0xfc00 , 0x5800 , 0 , 0,
21806 0x0 }, /* P16~*(10) */
21807 { reserved_block , 0 , 0 , 16,
21808 0xfc00 , 0x7800 , 0 , 0,
21809 0x0 }, /* P16~*(14) */
21810 { branch_instruction , 0 , 0 , 16,
21811 0xfc00 , 0x9800 , &BEQZC_16_ , 0,
21812 0x0 }, /* BEQZC[16] */
21813 { branch_instruction , 0 , 0 , 16,
21814 0xfc00 , 0xb800 , &BNEZC_16_ , 0,
21815 0x0 }, /* BNEZC[16] */
21816 { pool , P16_BR , 2 , 16,
21817 0xfc00 , 0xd800 , 0 , 0,
21818 0x0 }, /* P16.BR */
21819 { reserved_block , 0 , 0 , 16,
21820 0xfc00 , 0xf800 , 0 , 0,
21821 0x0 }, /* P16~*(30) */
21822 { pool , P16_SR , 2 , 16,
21823 0xfc00 , 0x1c00 , 0 , 0,
21824 0x0 }, /* P16.SR */
21825 { pool , P16_4X4 , 4 , 16,
21826 0xfc00 , 0x3c00 , 0 , 0,
21827 0x0 }, /* P16.4X4 */
21828 { pool , P16_LB , 4 , 16,
21829 0xfc00 , 0x5c00 , 0 , 0,
21830 0x0 }, /* P16.LB */
21831 { pool , P16_LH , 4 , 16,
21832 0xfc00 , 0x7c00 , 0 , 0,
21833 0x0 }, /* P16.LH */
21834 { reserved_block , 0 , 0 , 16,
21835 0xfc00 , 0x9c00 , 0 , 0,
21836 0x0 }, /* P16~*(19) */
21837 { instruction , 0 , 0 , 16,
21838 0xfc00 , 0xbc00 , &MOVEP , 0,
21839 XMMS_ }, /* MOVEP */
21840 { reserved_block , 0 , 0 , 16,
21841 0xfc00 , 0xdc00 , 0 , 0,
21842 0x0 }, /* P16~*(27) */
21843 { instruction , 0 , 0 , 16,
21844 0xfc00 , 0xfc00 , &MOVEP_REV_ , 0,
21845 XMMS_ }, /* MOVEP[REV] */
21846 };
21847
21848
21849 static const Pool MAJOR[2] = {
21850 { pool , P32 , 32 , 32,
21851 0x10000000, 0x00000000, 0 , 0,
21852 0x0 }, /* P32 */
21853 { pool , P16 , 32 , 16,
21854 0x1000 , 0x1000 , 0 , 0,
21855 0x0 }, /* P16 */
21856 };
21857
21858 /*
21859 * Recurse through tables until the instruction is found then return
21860 * the string and size
21861 *
21862 * inputs:
21863 * pointer to a word stream,
21864 * disassember table and size
21865 * returns:
21866 * instruction size - negative is error
21867 * disassembly string - on error will constain error string
21868 */
21869 static int Disassemble(const uint16 *data, char **dis,
21870 TABLE_ENTRY_TYPE *type, const Pool *table,
21871 int table_size, Dis_info *info)
21872 {
21873 for (int i = 0; i < table_size; i++) {
21874 uint64 op_code = extract_op_code_value(data,
21875 table[i].instructions_size);
21876 if ((op_code & table[i].mask) == table[i].value) {
21877 /* possible match */
21878 conditional_function cond = table[i].condition;
21879 if ((cond == NULL) || cond(op_code)) {
21880 if (table[i].type == pool) {
21881 return Disassemble(data, dis, type,
21882 table[i].next_table,
21883 table[i].next_table_size,
21884 info);
21885 } else if ((table[i].type == instruction) ||
21886 (table[i].type == call_instruction) ||
21887 (table[i].type == branch_instruction) ||
21888 (table[i].type == return_instruction)) {
21889 disassembly_function dis_fn = table[i].disassembly;
21890 if (dis_fn == 0) {
21891 *dis = g_strdup(
21892 "disassembler failure - bad table entry");
21893 return -6;
21894 }
21895 *type = table[i].type;
21896 *dis = dis_fn(op_code, info);
21897 return table[i].instructions_size;
21898 } else {
21899 *dis = g_strdup("reserved instruction");
21900 return -2;
21901 }
21902 }
21903 }
21904 }
21905 *dis = g_strdup("failed to disassemble");
21906 return -1; /* failed to disassemble */
21907 }
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 }
QEMU mirror