Merge tag 'for-upstream' of https://repo.or.cz/qemu/kevin into staging
[qemu.git] / disas.c
1 /* General "disassemble this chunk" code. Used for debugging. */
2 #include "qemu/osdep.h"
3 #include "disas/dis-asm.h"
4 #include "elf.h"
5 #include "qemu/qemu-print.h"
6
7 #include "disas/disas.h"
8 #include "disas/capstone.h"
9
10 typedef struct CPUDebug {
11 struct disassemble_info info;
12 CPUState *cpu;
13 } CPUDebug;
14
15 /* Filled in by elfload.c. Simplistic, but will do for now. */
16 struct syminfo *syminfos = NULL;
17
18 /*
19 * Get LENGTH bytes from info's buffer, at host address memaddr.
20 * Transfer them to myaddr.
21 */
22 static int host_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
23 struct disassemble_info *info)
24 {
25 if (memaddr < info->buffer_vma
26 || memaddr + length > info->buffer_vma + info->buffer_length) {
27 /* Out of bounds. Use EIO because GDB uses it. */
28 return EIO;
29 }
30 memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
31 return 0;
32 }
33
34 /*
35 * Get LENGTH bytes from info's buffer, at target address memaddr.
36 * Transfer them to myaddr.
37 */
38 static int target_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
39 struct disassemble_info *info)
40 {
41 CPUDebug *s = container_of(info, CPUDebug, info);
42 int r = cpu_memory_rw_debug(s->cpu, memaddr, myaddr, length, 0);
43 return r ? EIO : 0;
44 }
45
46 /*
47 * Print an error message. We can assume that this is in response to
48 * an error return from {host,target}_read_memory.
49 */
50 static void perror_memory(int status, bfd_vma memaddr,
51 struct disassemble_info *info)
52 {
53 if (status != EIO) {
54 /* Can't happen. */
55 info->fprintf_func(info->stream, "Unknown error %d\n", status);
56 } else {
57 /* Address between memaddr and memaddr + len was out of bounds. */
58 info->fprintf_func(info->stream,
59 "Address 0x%" PRIx64 " is out of bounds.\n",
60 memaddr);
61 }
62 }
63
64 /* Print address in hex. */
65 static void print_address(bfd_vma addr, struct disassemble_info *info)
66 {
67 info->fprintf_func(info->stream, "0x%" PRIx64, addr);
68 }
69
70 /* Print address in hex, truncated to the width of a host virtual address. */
71 static void host_print_address(bfd_vma addr, struct disassemble_info *info)
72 {
73 print_address((uintptr_t)addr, info);
74 }
75
76 /* Stub prevents some fruitless earching in optabs disassemblers. */
77 static int symbol_at_address(bfd_vma addr, struct disassemble_info *info)
78 {
79 return 1;
80 }
81
82 static int print_insn_objdump(bfd_vma pc, disassemble_info *info,
83 const char *prefix)
84 {
85 int i, n = info->buffer_length;
86 g_autofree uint8_t *buf = g_malloc(n);
87
88 if (info->read_memory_func(pc, buf, n, info) == 0) {
89 for (i = 0; i < n; ++i) {
90 if (i % 32 == 0) {
91 info->fprintf_func(info->stream, "\n%s: ", prefix);
92 }
93 info->fprintf_func(info->stream, "%02x", buf[i]);
94 }
95 } else {
96 info->fprintf_func(info->stream, "unable to read memory");
97 }
98 return n;
99 }
100
101 static int print_insn_od_host(bfd_vma pc, disassemble_info *info)
102 {
103 return print_insn_objdump(pc, info, "OBJD-H");
104 }
105
106 static int print_insn_od_target(bfd_vma pc, disassemble_info *info)
107 {
108 return print_insn_objdump(pc, info, "OBJD-T");
109 }
110
111 static void initialize_debug(CPUDebug *s)
112 {
113 memset(s, 0, sizeof(*s));
114 s->info.arch = bfd_arch_unknown;
115 s->info.cap_arch = -1;
116 s->info.cap_insn_unit = 4;
117 s->info.cap_insn_split = 4;
118 s->info.memory_error_func = perror_memory;
119 s->info.symbol_at_address_func = symbol_at_address;
120 }
121
122 static void initialize_debug_target(CPUDebug *s, CPUState *cpu)
123 {
124 initialize_debug(s);
125
126 s->cpu = cpu;
127 s->info.read_memory_func = target_read_memory;
128 s->info.print_address_func = print_address;
129 #if TARGET_BIG_ENDIAN
130 s->info.endian = BFD_ENDIAN_BIG;
131 #else
132 s->info.endian = BFD_ENDIAN_LITTLE;
133 #endif
134
135 CPUClass *cc = CPU_GET_CLASS(cpu);
136 if (cc->disas_set_info) {
137 cc->disas_set_info(cpu, &s->info);
138 }
139 }
140
141 static void initialize_debug_host(CPUDebug *s)
142 {
143 initialize_debug(s);
144
145 s->info.read_memory_func = host_read_memory;
146 s->info.print_address_func = host_print_address;
147 #if HOST_BIG_ENDIAN
148 s->info.endian = BFD_ENDIAN_BIG;
149 #else
150 s->info.endian = BFD_ENDIAN_LITTLE;
151 #endif
152 #if defined(CONFIG_TCG_INTERPRETER)
153 s->info.print_insn = print_insn_tci;
154 #elif defined(__i386__)
155 s->info.mach = bfd_mach_i386_i386;
156 s->info.cap_arch = CS_ARCH_X86;
157 s->info.cap_mode = CS_MODE_32;
158 s->info.cap_insn_unit = 1;
159 s->info.cap_insn_split = 8;
160 #elif defined(__x86_64__)
161 s->info.mach = bfd_mach_x86_64;
162 s->info.cap_arch = CS_ARCH_X86;
163 s->info.cap_mode = CS_MODE_64;
164 s->info.cap_insn_unit = 1;
165 s->info.cap_insn_split = 8;
166 #elif defined(_ARCH_PPC)
167 s->info.cap_arch = CS_ARCH_PPC;
168 # ifdef _ARCH_PPC64
169 s->info.cap_mode = CS_MODE_64;
170 # endif
171 #elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
172 #if defined(_ILP32) || (__riscv_xlen == 32)
173 s->info.print_insn = print_insn_riscv32;
174 #elif defined(_LP64)
175 s->info.print_insn = print_insn_riscv64;
176 #else
177 #error unsupported RISC-V ABI
178 #endif
179 #elif defined(__aarch64__)
180 s->info.cap_arch = CS_ARCH_ARM64;
181 #elif defined(__alpha__)
182 s->info.print_insn = print_insn_alpha;
183 #elif defined(__sparc__)
184 s->info.print_insn = print_insn_sparc;
185 s->info.mach = bfd_mach_sparc_v9b;
186 #elif defined(__arm__)
187 /* TCG only generates code for arm mode. */
188 s->info.cap_arch = CS_ARCH_ARM;
189 #elif defined(__MIPSEB__)
190 s->info.print_insn = print_insn_big_mips;
191 #elif defined(__MIPSEL__)
192 s->info.print_insn = print_insn_little_mips;
193 #elif defined(__m68k__)
194 s->info.print_insn = print_insn_m68k;
195 #elif defined(__s390__)
196 s->info.cap_arch = CS_ARCH_SYSZ;
197 s->info.cap_insn_unit = 2;
198 s->info.cap_insn_split = 6;
199 #elif defined(__hppa__)
200 s->info.print_insn = print_insn_hppa;
201 #elif defined(__loongarch__)
202 s->info.print_insn = print_insn_loongarch;
203 #endif
204 }
205
206 /* Disassemble this for me please... (debugging). */
207 void target_disas(FILE *out, CPUState *cpu, target_ulong code,
208 target_ulong size)
209 {
210 target_ulong pc;
211 int count;
212 CPUDebug s;
213
214 initialize_debug_target(&s, cpu);
215 s.info.fprintf_func = fprintf;
216 s.info.stream = out;
217 s.info.buffer_vma = code;
218 s.info.buffer_length = size;
219
220 if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
221 return;
222 }
223
224 if (s.info.print_insn == NULL) {
225 s.info.print_insn = print_insn_od_target;
226 }
227
228 for (pc = code; size > 0; pc += count, size -= count) {
229 fprintf(out, "0x" TARGET_FMT_lx ": ", pc);
230 count = s.info.print_insn(pc, &s.info);
231 fprintf(out, "\n");
232 if (count < 0)
233 break;
234 if (size < count) {
235 fprintf(out,
236 "Disassembler disagrees with translator over instruction "
237 "decoding\n"
238 "Please report this to qemu-devel@nongnu.org\n");
239 break;
240 }
241 }
242 }
243
244 static int G_GNUC_PRINTF(2, 3)
245 gstring_printf(FILE *stream, const char *fmt, ...)
246 {
247 /* We abuse the FILE parameter to pass a GString. */
248 GString *s = (GString *)stream;
249 int initial_len = s->len;
250 va_list va;
251
252 va_start(va, fmt);
253 g_string_append_vprintf(s, fmt, va);
254 va_end(va);
255
256 return s->len - initial_len;
257 }
258
259 static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
260 {
261 /* does nothing */
262 }
263
264
265 /*
266 * We should only be dissembling one instruction at a time here. If
267 * there is left over it usually indicates the front end has read more
268 * bytes than it needed.
269 */
270 char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size)
271 {
272 CPUDebug s;
273 GString *ds = g_string_new(NULL);
274
275 initialize_debug_target(&s, cpu);
276 s.info.fprintf_func = gstring_printf;
277 s.info.stream = (FILE *)ds; /* abuse this slot */
278 s.info.buffer_vma = addr;
279 s.info.buffer_length = size;
280 s.info.print_address_func = plugin_print_address;
281
282 if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
283 ; /* done */
284 } else if (s.info.print_insn) {
285 s.info.print_insn(addr, &s.info);
286 } else {
287 ; /* cannot disassemble -- return empty string */
288 }
289
290 /* Return the buffer, freeing the GString container. */
291 return g_string_free(ds, false);
292 }
293
294 /* Disassemble this for me please... (debugging). */
295 void disas(FILE *out, const void *code, unsigned long size)
296 {
297 uintptr_t pc;
298 int count;
299 CPUDebug s;
300
301 initialize_debug_host(&s);
302 s.info.fprintf_func = fprintf;
303 s.info.stream = out;
304 s.info.buffer = code;
305 s.info.buffer_vma = (uintptr_t)code;
306 s.info.buffer_length = size;
307
308 if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) {
309 return;
310 }
311
312 if (s.info.print_insn == NULL) {
313 s.info.print_insn = print_insn_od_host;
314 }
315 for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
316 fprintf(out, "0x%08" PRIxPTR ": ", pc);
317 count = s.info.print_insn(pc, &s.info);
318 fprintf(out, "\n");
319 if (count < 0) {
320 break;
321 }
322 }
323
324 }
325
326 /* Look up symbol for debugging purpose. Returns "" if unknown. */
327 const char *lookup_symbol(target_ulong orig_addr)
328 {
329 const char *symbol = "";
330 struct syminfo *s;
331
332 for (s = syminfos; s; s = s->next) {
333 symbol = s->lookup_symbol(s, orig_addr);
334 if (symbol[0] != '\0') {
335 break;
336 }
337 }
338
339 return symbol;
340 }
341
342 #if !defined(CONFIG_USER_ONLY)
343
344 #include "monitor/monitor.h"
345
346 static int
347 physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
348 struct disassemble_info *info)
349 {
350 CPUDebug *s = container_of(info, CPUDebug, info);
351 MemTxResult res;
352
353 res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
354 myaddr, length);
355 return res == MEMTX_OK ? 0 : EIO;
356 }
357
358 /* Disassembler for the monitor. */
359 void monitor_disas(Monitor *mon, CPUState *cpu,
360 target_ulong pc, int nb_insn, int is_physical)
361 {
362 int count, i;
363 CPUDebug s;
364 g_autoptr(GString) ds = g_string_new("");
365
366 initialize_debug_target(&s, cpu);
367 s.info.fprintf_func = gstring_printf;
368 s.info.stream = (FILE *)ds; /* abuse this slot */
369
370 if (is_physical) {
371 s.info.read_memory_func = physical_read_memory;
372 }
373 s.info.buffer_vma = pc;
374
375 if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
376 monitor_puts(mon, ds->str);
377 return;
378 }
379
380 if (!s.info.print_insn) {
381 monitor_printf(mon, "0x" TARGET_FMT_lx
382 ": Asm output not supported on this arch\n", pc);
383 return;
384 }
385
386 for (i = 0; i < nb_insn; i++) {
387 g_string_append_printf(ds, "0x" TARGET_FMT_lx ": ", pc);
388 count = s.info.print_insn(pc, &s.info);
389 g_string_append_c(ds, '\n');
390 if (count < 0) {
391 break;
392 }
393 pc += count;
394 }
395
396 monitor_puts(mon, ds->str);
397 }
398 #endif