Commit | Line | Data |
---|---|---|
16216333 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
ae06e374 ME |
2 | /* Disassemble SPU instructions |
3 | ||
4 | Copyright 2006 Free Software Foundation, Inc. | |
5 | ||
6 | This file is part of GDB, GAS, and the GNU binutils. | |
7 | ||
16216333 | 8 | */ |
ae06e374 ME |
9 | |
10 | #include <linux/string.h> | |
11 | #include "nonstdio.h" | |
12 | #include "ansidecl.h" | |
13 | #include "spu.h" | |
e0426047 | 14 | #include "dis-asm.h" |
ae06e374 ME |
15 | |
16 | /* This file provides a disassembler function which uses | |
17 | the disassembler interface defined in dis-asm.h. */ | |
18 | ||
19 | extern const struct spu_opcode spu_opcodes[]; | |
20 | extern const int spu_num_opcodes; | |
21 | ||
22 | #define SPU_DISASM_TBL_SIZE (1 << 11) | |
23 | static const struct spu_opcode *spu_disassemble_table[SPU_DISASM_TBL_SIZE]; | |
24 | ||
25 | static void | |
26 | init_spu_disassemble (void) | |
27 | { | |
28 | int i; | |
29 | ||
30 | /* If two instructions have the same opcode then we prefer the first | |
31 | * one. In most cases it is just an alternate mnemonic. */ | |
32 | for (i = 0; i < spu_num_opcodes; i++) | |
33 | { | |
34 | int o = spu_opcodes[i].opcode; | |
35 | if (o >= SPU_DISASM_TBL_SIZE) | |
36 | continue; /* abort (); */ | |
37 | if (spu_disassemble_table[o] == 0) | |
38 | spu_disassemble_table[o] = &spu_opcodes[i]; | |
39 | } | |
40 | } | |
41 | ||
42 | /* Determine the instruction from the 10 least significant bits. */ | |
43 | static const struct spu_opcode * | |
44 | get_index_for_opcode (unsigned int insn) | |
45 | { | |
46 | const struct spu_opcode *index; | |
47 | unsigned int opcode = insn >> (32-11); | |
48 | ||
49 | /* Init the table. This assumes that element 0/opcode 0 (currently | |
50 | * NOP) is always used */ | |
51 | if (spu_disassemble_table[0] == 0) | |
52 | init_spu_disassemble (); | |
53 | ||
54 | if ((index = spu_disassemble_table[opcode & 0x780]) != 0 | |
55 | && index->insn_type == RRR) | |
56 | return index; | |
57 | ||
58 | if ((index = spu_disassemble_table[opcode & 0x7f0]) != 0 | |
59 | && (index->insn_type == RI18 || index->insn_type == LBT)) | |
60 | return index; | |
61 | ||
62 | if ((index = spu_disassemble_table[opcode & 0x7f8]) != 0 | |
63 | && index->insn_type == RI10) | |
64 | return index; | |
65 | ||
66 | if ((index = spu_disassemble_table[opcode & 0x7fc]) != 0 | |
67 | && (index->insn_type == RI16)) | |
68 | return index; | |
69 | ||
70 | if ((index = spu_disassemble_table[opcode & 0x7fe]) != 0 | |
71 | && (index->insn_type == RI8)) | |
72 | return index; | |
73 | ||
74 | if ((index = spu_disassemble_table[opcode & 0x7ff]) != 0) | |
75 | return index; | |
76 | ||
9340b0d3 | 77 | return NULL; |
ae06e374 ME |
78 | } |
79 | ||
80 | /* Print a Spu instruction. */ | |
81 | ||
82 | int | |
83 | print_insn_spu (unsigned long insn, unsigned long memaddr) | |
84 | { | |
85 | int value; | |
86 | int hex_value; | |
87 | const struct spu_opcode *index; | |
88 | enum spu_insns tag; | |
89 | ||
90 | index = get_index_for_opcode (insn); | |
91 | ||
92 | if (index == 0) | |
93 | { | |
e70d8f55 | 94 | printf(".long 0x%lx", insn); |
ae06e374 ME |
95 | } |
96 | else | |
97 | { | |
98 | int i; | |
99 | int paren = 0; | |
100 | tag = (enum spu_insns)(index - spu_opcodes); | |
101 | printf("%s", index->mnemonic); | |
102 | if (tag == M_BI || tag == M_BISL || tag == M_IRET || tag == M_BISLED | |
103 | || tag == M_BIHNZ || tag == M_BIHZ || tag == M_BINZ || tag == M_BIZ | |
104 | || tag == M_SYNC || tag == M_HBR) | |
105 | { | |
106 | int fb = (insn >> (32-18)) & 0x7f; | |
107 | if (fb & 0x40) | |
108 | printf(tag == M_SYNC ? "c" : "p"); | |
109 | if (fb & 0x20) | |
110 | printf("d"); | |
111 | if (fb & 0x10) | |
112 | printf("e"); | |
113 | } | |
114 | if (index->arg[0] != 0) | |
115 | printf("\t"); | |
116 | hex_value = 0; | |
117 | for (i = 1; i <= index->arg[0]; i++) | |
118 | { | |
119 | int arg = index->arg[i]; | |
120 | if (arg != A_P && !paren && i > 1) | |
121 | printf(","); | |
122 | ||
123 | switch (arg) | |
124 | { | |
125 | case A_T: | |
e70d8f55 | 126 | printf("$%lu", |
ae06e374 ME |
127 | DECODE_INSN_RT (insn)); |
128 | break; | |
129 | case A_A: | |
e70d8f55 | 130 | printf("$%lu", |
ae06e374 ME |
131 | DECODE_INSN_RA (insn)); |
132 | break; | |
133 | case A_B: | |
e70d8f55 | 134 | printf("$%lu", |
ae06e374 ME |
135 | DECODE_INSN_RB (insn)); |
136 | break; | |
137 | case A_C: | |
e70d8f55 | 138 | printf("$%lu", |
ae06e374 ME |
139 | DECODE_INSN_RC (insn)); |
140 | break; | |
141 | case A_S: | |
e70d8f55 | 142 | printf("$sp%lu", |
ae06e374 ME |
143 | DECODE_INSN_RA (insn)); |
144 | break; | |
145 | case A_H: | |
e70d8f55 | 146 | printf("$ch%lu", |
ae06e374 ME |
147 | DECODE_INSN_RA (insn)); |
148 | break; | |
149 | case A_P: | |
150 | paren++; | |
151 | printf("("); | |
152 | break; | |
153 | case A_U7A: | |
e70d8f55 | 154 | printf("%lu", |
ae06e374 ME |
155 | 173 - DECODE_INSN_U8 (insn)); |
156 | break; | |
157 | case A_U7B: | |
e70d8f55 | 158 | printf("%lu", |
ae06e374 ME |
159 | 155 - DECODE_INSN_U8 (insn)); |
160 | break; | |
161 | case A_S3: | |
162 | case A_S6: | |
163 | case A_S7: | |
164 | case A_S7N: | |
165 | case A_U3: | |
166 | case A_U5: | |
167 | case A_U6: | |
168 | case A_U7: | |
169 | hex_value = DECODE_INSN_I7 (insn); | |
170 | printf("%d", hex_value); | |
171 | break; | |
172 | case A_S11: | |
173 | print_address(memaddr + DECODE_INSN_I9a (insn) * 4); | |
174 | break; | |
175 | case A_S11I: | |
176 | print_address(memaddr + DECODE_INSN_I9b (insn) * 4); | |
177 | break; | |
178 | case A_S10: | |
179 | case A_S10B: | |
180 | hex_value = DECODE_INSN_I10 (insn); | |
181 | printf("%d", hex_value); | |
182 | break; | |
183 | case A_S14: | |
184 | hex_value = DECODE_INSN_I10 (insn) * 16; | |
185 | printf("%d", hex_value); | |
186 | break; | |
187 | case A_S16: | |
188 | hex_value = DECODE_INSN_I16 (insn); | |
189 | printf("%d", hex_value); | |
190 | break; | |
191 | case A_X16: | |
192 | hex_value = DECODE_INSN_U16 (insn); | |
193 | printf("%u", hex_value); | |
194 | break; | |
195 | case A_R18: | |
196 | value = DECODE_INSN_I16 (insn) * 4; | |
197 | if (value == 0) | |
198 | printf("%d", value); | |
199 | else | |
200 | { | |
201 | hex_value = memaddr + value; | |
202 | print_address(hex_value & 0x3ffff); | |
203 | } | |
204 | break; | |
205 | case A_S18: | |
206 | value = DECODE_INSN_U16 (insn) * 4; | |
207 | if (value == 0) | |
208 | printf("%d", value); | |
209 | else | |
210 | print_address(value); | |
211 | break; | |
212 | case A_U18: | |
213 | value = DECODE_INSN_U18 (insn); | |
214 | if (value == 0 || 1) | |
215 | { | |
216 | hex_value = value; | |
217 | printf("%u", value); | |
218 | } | |
219 | else | |
220 | print_address(value); | |
221 | break; | |
222 | case A_U14: | |
223 | hex_value = DECODE_INSN_U14 (insn); | |
224 | printf("%u", hex_value); | |
225 | break; | |
226 | } | |
227 | if (arg != A_P && paren) | |
228 | { | |
229 | printf(")"); | |
230 | paren--; | |
231 | } | |
232 | } | |
233 | if (hex_value > 16) | |
234 | printf("\t# %x", hex_value); | |
235 | } | |
236 | return 4; | |
237 | } |