/src/binutils-gdb/opcodes/ia64-dis.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* ia64-dis.c -- Disassemble ia64 instructions |
2 | | Copyright (C) 1998-2024 Free Software Foundation, Inc. |
3 | | Contributed by David Mosberger-Tang <davidm@hpl.hp.com> |
4 | | |
5 | | This file is part of the GNU opcodes library. |
6 | | |
7 | | This library is free software; you can redistribute it and/or modify |
8 | | it under the terms of the GNU General Public License as published by |
9 | | the Free Software Foundation; either version 3, or (at your option) |
10 | | any later version. |
11 | | |
12 | | It is distributed in the hope that it will be useful, but WITHOUT |
13 | | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
14 | | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public |
15 | | License for more details. |
16 | | |
17 | | You should have received a copy of the GNU General Public License |
18 | | along with this file; see the file COPYING. If not, write to the |
19 | | Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA |
20 | | 02110-1301, USA. */ |
21 | | |
22 | | #include "sysdep.h" |
23 | | #include <assert.h> |
24 | | |
25 | | #include "disassemble.h" |
26 | | #include "opcode/ia64.h" |
27 | | |
28 | 385k | #define NELEMS(a) ((int) (sizeof (a) / sizeof (a[0]))) |
29 | | |
30 | | /* Disassemble ia64 instruction. */ |
31 | | |
32 | | /* Return the instruction type for OPCODE found in unit UNIT. */ |
33 | | |
34 | | static enum ia64_insn_type |
35 | | unit_to_type (ia64_insn opcode, enum ia64_unit unit) |
36 | 109k | { |
37 | 109k | enum ia64_insn_type type; |
38 | 109k | int op; |
39 | | |
40 | 109k | op = IA64_OP (opcode); |
41 | | |
42 | 109k | if (op >= 8 && (unit == IA64_UNIT_I || unit == IA64_UNIT_M)) |
43 | 24.8k | { |
44 | 24.8k | type = IA64_TYPE_A; |
45 | 24.8k | } |
46 | 85.0k | else |
47 | 85.0k | { |
48 | 85.0k | switch (unit) |
49 | 85.0k | { |
50 | 38.0k | case IA64_UNIT_I: |
51 | 38.0k | type = IA64_TYPE_I; break; |
52 | 29.1k | case IA64_UNIT_M: |
53 | 29.1k | type = IA64_TYPE_M; break; |
54 | 11.0k | case IA64_UNIT_B: |
55 | 11.0k | type = IA64_TYPE_B; break; |
56 | 4.76k | case IA64_UNIT_F: |
57 | 4.76k | type = IA64_TYPE_F; break; |
58 | 2.12k | case IA64_UNIT_L: |
59 | 2.12k | case IA64_UNIT_X: |
60 | 2.12k | type = IA64_TYPE_X; break; |
61 | 0 | default: |
62 | 0 | type = -1; |
63 | 85.0k | } |
64 | 85.0k | } |
65 | 109k | return type; |
66 | 109k | } |
67 | | |
68 | | int |
69 | | print_insn_ia64 (bfd_vma memaddr, struct disassemble_info *info) |
70 | 133k | { |
71 | 133k | ia64_insn t0, t1, slot[3], template_val, s_bit, insn; |
72 | 133k | int slotnum, j, status, need_comma, retval, slot_multiplier; |
73 | 133k | const struct ia64_operand *odesc; |
74 | 133k | const struct ia64_opcode *idesc; |
75 | 133k | const char *err, *str, *tname; |
76 | 133k | uint64_t value; |
77 | 133k | bfd_byte bundle[16]; |
78 | 133k | enum ia64_unit unit; |
79 | 133k | char regname[16]; |
80 | | |
81 | 133k | if (info->bytes_per_line == 0) |
82 | 133k | info->bytes_per_line = 6; |
83 | 133k | info->display_endian = info->endian; |
84 | | |
85 | 133k | slot_multiplier = info->bytes_per_line; |
86 | 133k | retval = slot_multiplier; |
87 | | |
88 | 133k | slotnum = (((long) memaddr) & 0xf) / slot_multiplier; |
89 | 133k | if (slotnum > 2) |
90 | 0 | return -1; |
91 | | |
92 | 133k | memaddr -= (memaddr & 0xf); |
93 | 133k | status = (*info->read_memory_func) (memaddr, bundle, sizeof (bundle), info); |
94 | 133k | if (status != 0) |
95 | 231 | { |
96 | 231 | (*info->memory_error_func) (status, memaddr, info); |
97 | 231 | return -1; |
98 | 231 | } |
99 | | /* bundles are always in little-endian byte order */ |
100 | 133k | t0 = bfd_getl64 (bundle); |
101 | 133k | t1 = bfd_getl64 (bundle + 8); |
102 | 133k | s_bit = t0 & 1; |
103 | 133k | template_val = (t0 >> 1) & 0xf; |
104 | 133k | slot[0] = (t0 >> 5) & 0x1ffffffffffLL; |
105 | 133k | slot[1] = ((t0 >> 46) & 0x3ffff) | ((t1 & 0x7fffff) << 18); |
106 | 133k | slot[2] = (t1 >> 23) & 0x1ffffffffffLL; |
107 | | |
108 | 133k | tname = ia64_templ_desc[template_val].name; |
109 | 133k | if (slotnum == 0) |
110 | 45.2k | (*info->fprintf_func) (info->stream, "[%s] ", tname); |
111 | 87.9k | else |
112 | 87.9k | (*info->fprintf_func) (info->stream, " "); |
113 | | |
114 | 133k | unit = ia64_templ_desc[template_val].exec_unit[slotnum]; |
115 | | |
116 | 133k | if (template_val == 2 && slotnum == 1) |
117 | 2.12k | { |
118 | | /* skip L slot in MLI template: */ |
119 | 2.12k | slotnum = 2; |
120 | 2.12k | retval += slot_multiplier; |
121 | 2.12k | } |
122 | | |
123 | 133k | insn = slot[slotnum]; |
124 | | |
125 | 133k | if (unit == IA64_UNIT_NIL) |
126 | 23.2k | goto decoding_failed; |
127 | | |
128 | 109k | idesc = ia64_dis_opcode (insn, unit_to_type (insn, unit)); |
129 | 109k | if (idesc == NULL) |
130 | 45.0k | goto decoding_failed; |
131 | | |
132 | | /* print predicate, if any: */ |
133 | | |
134 | 64.8k | if ((idesc->flags & IA64_OPCODE_NO_PRED) |
135 | 64.8k | || (insn & 0x3f) == 0) |
136 | 33.5k | (*info->fprintf_func) (info->stream, " "); |
137 | 31.3k | else |
138 | 31.3k | (*info->fprintf_func) (info->stream, "(p%02d) ", (int)(insn & 0x3f)); |
139 | | |
140 | | /* now the actual instruction: */ |
141 | | |
142 | 64.8k | (*info->fprintf_func) (info->stream, "%s", idesc->name); |
143 | 64.8k | if (idesc->operands[0]) |
144 | 64.2k | (*info->fprintf_func) (info->stream, " "); |
145 | | |
146 | 64.8k | need_comma = 0; |
147 | 192k | for (j = 0; j < NELEMS (idesc->operands) && idesc->operands[j]; ++j) |
148 | 127k | { |
149 | 127k | odesc = elf64_ia64_operands + idesc->operands[j]; |
150 | | |
151 | 127k | if (need_comma) |
152 | 38.8k | (*info->fprintf_func) (info->stream, ","); |
153 | | |
154 | 127k | if (odesc - elf64_ia64_operands == IA64_OPND_IMMU64) |
155 | 73 | { |
156 | | /* special case of 64 bit immediate load: */ |
157 | 73 | value = ((insn >> 13) & 0x7f) | (((insn >> 27) & 0x1ff) << 7) |
158 | 73 | | (((insn >> 22) & 0x1f) << 16) | (((insn >> 21) & 0x1) << 21) |
159 | 73 | | (slot[1] << 22) | (((insn >> 36) & 0x1) << 63); |
160 | 73 | } |
161 | 127k | else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62) |
162 | 314 | { |
163 | | /* 62-bit immediate for nop.x/break.x */ |
164 | 314 | value = ((slot[1] & 0x1ffffffffffLL) << 21) |
165 | 314 | | (((insn >> 36) & 0x1) << 20) |
166 | 314 | | ((insn >> 6) & 0xfffff); |
167 | 314 | } |
168 | 127k | else if (odesc - elf64_ia64_operands == IA64_OPND_TGT64) |
169 | 106 | { |
170 | | /* 60-bit immediate for long branches. */ |
171 | 106 | value = (((insn >> 13) & 0xfffff) |
172 | 106 | | (((insn >> 36) & 1) << 59) |
173 | 106 | | (((slot[1] >> 2) & 0x7fffffffffLL) << 20)) << 4; |
174 | 106 | } |
175 | 127k | else |
176 | 127k | { |
177 | 127k | err = (*odesc->extract) (odesc, insn, &value); |
178 | 127k | if (err) |
179 | 0 | { |
180 | 0 | (*info->fprintf_func) (info->stream, "%s", err); |
181 | 0 | goto done; |
182 | 0 | } |
183 | 127k | } |
184 | | |
185 | 127k | switch (odesc->op_class) |
186 | 127k | { |
187 | 4.75k | case IA64_OPND_CLASS_CST: |
188 | 4.75k | (*info->fprintf_func) (info->stream, "%s", odesc->str); |
189 | 4.75k | break; |
190 | | |
191 | 63.7k | case IA64_OPND_CLASS_REG: |
192 | 63.7k | if (odesc->str[0] == 'a' && odesc->str[1] == 'r') |
193 | 186 | { |
194 | 186 | switch (value) |
195 | 186 | { |
196 | 63 | case 0: case 1: case 2: case 3: |
197 | 64 | case 4: case 5: case 6: case 7: |
198 | 64 | sprintf (regname, "ar.k%u", (unsigned int) value); |
199 | 64 | break; |
200 | 1 | case 16: strcpy (regname, "ar.rsc"); break; |
201 | 1 | case 17: strcpy (regname, "ar.bsp"); break; |
202 | 0 | case 18: strcpy (regname, "ar.bspstore"); break; |
203 | 0 | case 19: strcpy (regname, "ar.rnat"); break; |
204 | 1 | case 21: strcpy (regname, "ar.fcr"); break; |
205 | 0 | case 24: strcpy (regname, "ar.eflag"); break; |
206 | 0 | case 25: strcpy (regname, "ar.csd"); break; |
207 | 0 | case 26: strcpy (regname, "ar.ssd"); break; |
208 | 0 | case 27: strcpy (regname, "ar.cflg"); break; |
209 | 0 | case 28: strcpy (regname, "ar.fsr"); break; |
210 | 4 | case 29: strcpy (regname, "ar.fir"); break; |
211 | 0 | case 30: strcpy (regname, "ar.fdr"); break; |
212 | 7 | case 32: strcpy (regname, "ar.ccv"); break; |
213 | 0 | case 36: strcpy (regname, "ar.unat"); break; |
214 | 0 | case 40: strcpy (regname, "ar.fpsr"); break; |
215 | 1 | case 44: strcpy (regname, "ar.itc"); break; |
216 | 1 | case 45: strcpy (regname, "ar.ruc"); break; |
217 | 46 | case 64: strcpy (regname, "ar.pfs"); break; |
218 | 3 | case 65: strcpy (regname, "ar.lc"); break; |
219 | 0 | case 66: strcpy (regname, "ar.ec"); break; |
220 | 57 | default: |
221 | 57 | sprintf (regname, "ar%u", (unsigned int) value); |
222 | 57 | break; |
223 | 186 | } |
224 | 186 | (*info->fprintf_func) (info->stream, "%s", regname); |
225 | 186 | } |
226 | 63.6k | else if (odesc->str[0] == 'c' && odesc->str[1] == 'r') |
227 | 50 | { |
228 | 50 | switch (value) |
229 | 50 | { |
230 | 3 | case 0: strcpy (regname, "cr.dcr"); break; |
231 | 0 | case 1: strcpy (regname, "cr.itm"); break; |
232 | 1 | case 2: strcpy (regname, "cr.iva"); break; |
233 | 3 | case 8: strcpy (regname, "cr.pta"); break; |
234 | 1 | case 16: strcpy (regname, "cr.ipsr"); break; |
235 | 0 | case 17: strcpy (regname, "cr.isr"); break; |
236 | 1 | case 19: strcpy (regname, "cr.iip"); break; |
237 | 3 | case 20: strcpy (regname, "cr.ifa"); break; |
238 | 0 | case 21: strcpy (regname, "cr.itir"); break; |
239 | 1 | case 22: strcpy (regname, "cr.iipa"); break; |
240 | 1 | case 23: strcpy (regname, "cr.ifs"); break; |
241 | 2 | case 24: strcpy (regname, "cr.iim"); break; |
242 | 0 | case 25: strcpy (regname, "cr.iha"); break; |
243 | 1 | case 26: strcpy (regname, "cr.iib0"); break; |
244 | 1 | case 27: strcpy (regname, "cr.iib1"); break; |
245 | 1 | case 64: strcpy (regname, "cr.lid"); break; |
246 | 0 | case 65: strcpy (regname, "cr.ivr"); break; |
247 | 1 | case 66: strcpy (regname, "cr.tpr"); break; |
248 | 0 | case 67: strcpy (regname, "cr.eoi"); break; |
249 | 1 | case 68: strcpy (regname, "cr.irr0"); break; |
250 | 0 | case 69: strcpy (regname, "cr.irr1"); break; |
251 | 1 | case 70: strcpy (regname, "cr.irr2"); break; |
252 | 1 | case 71: strcpy (regname, "cr.irr3"); break; |
253 | 1 | case 72: strcpy (regname, "cr.itv"); break; |
254 | 0 | case 73: strcpy (regname, "cr.pmv"); break; |
255 | 0 | case 74: strcpy (regname, "cr.cmcv"); break; |
256 | 1 | case 80: strcpy (regname, "cr.lrr0"); break; |
257 | 0 | case 81: strcpy (regname, "cr.lrr1"); break; |
258 | 25 | default: |
259 | 25 | sprintf (regname, "cr%u", (unsigned int) value); |
260 | 25 | break; |
261 | 50 | } |
262 | 50 | (*info->fprintf_func) (info->stream, "%s", regname); |
263 | 50 | } |
264 | 63.5k | else |
265 | 63.5k | (*info->fprintf_func) (info->stream, "%s%d", odesc->str, (int)value); |
266 | 63.7k | break; |
267 | | |
268 | 63.7k | case IA64_OPND_CLASS_IND: |
269 | 2.74k | (*info->fprintf_func) (info->stream, "%s[r%d]", odesc->str, (int)value); |
270 | 2.74k | break; |
271 | | |
272 | 50.7k | case IA64_OPND_CLASS_ABS: |
273 | 50.7k | str = 0; |
274 | 50.7k | if (odesc - elf64_ia64_operands == IA64_OPND_MBTYPE4) |
275 | 0 | switch (value) |
276 | 0 | { |
277 | 0 | case 0x0: str = "@brcst"; break; |
278 | 0 | case 0x8: str = "@mix"; break; |
279 | 0 | case 0x9: str = "@shuf"; break; |
280 | 0 | case 0xa: str = "@alt"; break; |
281 | 0 | case 0xb: str = "@rev"; break; |
282 | 0 | } |
283 | | |
284 | 50.7k | if (str) |
285 | 0 | (*info->fprintf_func) (info->stream, "%s", str); |
286 | 50.7k | else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_SIGNED) |
287 | 8.73k | (*info->fprintf_func) (info->stream, "%lld", (long long) value); |
288 | 42.0k | else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_UNSIGNED) |
289 | 5.22k | (*info->fprintf_func) (info->stream, "%llu", (long long) value); |
290 | 36.8k | else |
291 | 36.8k | (*info->fprintf_func) (info->stream, "0x%llx", (long long) value); |
292 | 50.7k | break; |
293 | | |
294 | 5.82k | case IA64_OPND_CLASS_REL: |
295 | 5.82k | (*info->print_address_func) (memaddr + value, info); |
296 | 5.82k | break; |
297 | 127k | } |
298 | | |
299 | 127k | need_comma = 1; |
300 | 127k | if (j + 1 == idesc->num_outputs) |
301 | 24.8k | { |
302 | 24.8k | (*info->fprintf_func) (info->stream, "="); |
303 | 24.8k | need_comma = 0; |
304 | 24.8k | } |
305 | 127k | } |
306 | 64.8k | if (slotnum + 1 == ia64_templ_desc[template_val].group_boundary |
307 | 64.8k | || ((slotnum == 2) && s_bit)) |
308 | 6.16k | (*info->fprintf_func) (info->stream, ";;"); |
309 | | |
310 | 64.8k | done: |
311 | 64.8k | ia64_free_opcode ((struct ia64_opcode *)idesc); |
312 | 133k | failed: |
313 | 133k | if (slotnum == 2) |
314 | 44.8k | retval += 16 - 3*slot_multiplier; |
315 | 133k | return retval; |
316 | | |
317 | 68.2k | decoding_failed: |
318 | 68.2k | (*info->fprintf_func) (info->stream, " data8 %#011llx", (long long) insn); |
319 | 68.2k | goto failed; |
320 | 64.8k | } |