blob: 3dab4482d1a1eeef0393f3c3efb4b54637270136 [file] [log] [blame]
bellardb9adb4a2003-04-29 20:41:16 +00001/* General "disassemble this chunk" code. Used for debugging. */
Peter Maydelld38ea872016-01-29 17:50:05 +00002#include "qemu/osdep.h"
Markus Armbruster3979fca2019-04-17 21:18:04 +02003#include "disas/dis-asm.h"
bellardb9adb4a2003-04-29 20:41:16 +00004#include "elf.h"
Markus Armbruster30cc9832019-04-17 21:18:03 +02005#include "qemu/qemu-print.h"
bellardb9adb4a2003-04-29 20:41:16 +00006
Paolo Bonzini76cad712012-10-24 11:12:21 +02007#include "disas/disas.h"
Richard Henderson8ca80762017-09-14 09:41:12 -07008#include "disas/capstone.h"
bellardc6105c02003-10-27 21:13:58 +00009
Blue Swirlf4359b92012-09-08 12:40:00 +000010typedef struct CPUDebug {
11 struct disassemble_info info;
Peter Crosthwaited49190c2015-05-24 14:20:41 -070012 CPUState *cpu;
Blue Swirlf4359b92012-09-08 12:40:00 +000013} CPUDebug;
14
bellardb9adb4a2003-04-29 20:41:16 +000015/* Filled in by elfload.c. Simplistic, but will do for now. */
bellarde80cfcf2004-12-19 23:18:01 +000016struct syminfo *syminfos = NULL;
bellardb9adb4a2003-04-29 20:41:16 +000017
Richard Henderson12b6e9b2020-09-10 14:40:54 -070018/*
19 * Get LENGTH bytes from info's buffer, at host address memaddr.
20 * Transfer them to myaddr.
21 */
22static int host_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
23 struct disassemble_info *info)
bellardaa0aa4f2003-06-09 15:23:31 +000024{
bellardc6105c02003-10-27 21:13:58 +000025 if (memaddr < info->buffer_vma
Richard Henderson12b6e9b2020-09-10 14:40:54 -070026 || memaddr + length > info->buffer_vma + info->buffer_length) {
bellardc6105c02003-10-27 21:13:58 +000027 /* Out of bounds. Use EIO because GDB uses it. */
28 return EIO;
Richard Henderson12b6e9b2020-09-10 14:40:54 -070029 }
bellardc6105c02003-10-27 21:13:58 +000030 memcpy (myaddr, info->buffer + (memaddr - info->buffer_vma), length);
31 return 0;
bellardaa0aa4f2003-06-09 15:23:31 +000032}
33
Richard Henderson12b6e9b2020-09-10 14:40:54 -070034/*
35 * Get LENGTH bytes from info's buffer, at target address memaddr.
36 * Transfer them to myaddr.
37 */
38static int target_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
39 struct disassemble_info *info)
bellardc6105c02003-10-27 21:13:58 +000040{
Blue Swirlf4359b92012-09-08 12:40:00 +000041 CPUDebug *s = container_of(info, CPUDebug, info);
Richard Henderson12b6e9b2020-09-10 14:40:54 -070042 int r = cpu_memory_rw_debug(s->cpu, memaddr, myaddr, length, 0);
Philippe Mathieu-Daudé6766ba52020-05-18 17:53:04 +020043 return r ? EIO : 0;
bellardc6105c02003-10-27 21:13:58 +000044}
bellardc6105c02003-10-27 21:13:58 +000045
Richard Henderson12b6e9b2020-09-10 14:40:54 -070046/*
47 * Print an error message. We can assume that this is in response to
48 * an error return from {host,target}_read_memory.
49 */
50static void perror_memory(int status, bfd_vma memaddr,
51 struct disassemble_info *info)
bellardaa0aa4f2003-06-09 15:23:31 +000052{
Richard Henderson12b6e9b2020-09-10 14:40:54 -070053 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 }
bellardaa0aa4f2003-06-09 15:23:31 +000062}
63
Richard Henderson12b6e9b2020-09-10 14:40:54 -070064/* Print address in hex. */
65static void print_address(bfd_vma addr, struct disassemble_info *info)
bellardaa0aa4f2003-06-09 15:23:31 +000066{
Richard Henderson12b6e9b2020-09-10 14:40:54 -070067 info->fprintf_func(info->stream, "0x%" PRIx64, addr);
bellardaa0aa4f2003-06-09 15:23:31 +000068}
69
Peter Maydell636bd282012-06-25 04:55:55 +000070/* Print address in hex, truncated to the width of a host virtual address. */
Richard Henderson12b6e9b2020-09-10 14:40:54 -070071static void host_print_address(bfd_vma addr, struct disassemble_info *info)
Peter Maydell636bd282012-06-25 04:55:55 +000072{
Richard Henderson12b6e9b2020-09-10 14:40:54 -070073 print_address((uintptr_t)addr, info);
Peter Maydell636bd282012-06-25 04:55:55 +000074}
75
Richard Henderson12b6e9b2020-09-10 14:40:54 -070076/* Stub prevents some fruitless earching in optabs disassemblers. */
77static int symbol_at_address(bfd_vma addr, struct disassemble_info *info)
bellardaa0aa4f2003-06-09 15:23:31 +000078{
Richard Henderson12b6e9b2020-09-10 14:40:54 -070079 return 1;
bellardaa0aa4f2003-06-09 15:23:31 +000080}
81
Richard Hendersonc46ffd52013-08-16 23:29:45 -070082static int print_insn_objdump(bfd_vma pc, disassemble_info *info,
83 const char *prefix)
84{
85 int i, n = info->buffer_length;
86 uint8_t *buf = g_malloc(n);
87
88 info->read_memory_func(pc, buf, n, info);
89
90 for (i = 0; i < n; ++i) {
91 if (i % 32 == 0) {
92 info->fprintf_func(info->stream, "\n%s: ", prefix);
93 }
94 info->fprintf_func(info->stream, "%02x", buf[i]);
95 }
96
97 g_free(buf);
98 return n;
99}
100
101static int print_insn_od_host(bfd_vma pc, disassemble_info *info)
102{
103 return print_insn_objdump(pc, info, "OBJD-H");
104}
105
106static int print_insn_od_target(bfd_vma pc, disassemble_info *info)
107{
108 return print_insn_objdump(pc, info, "OBJD-T");
109}
110
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700111static 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
122static 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#ifdef TARGET_WORDS_BIGENDIAN
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
141static 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#ifdef HOST_WORDS_BIGENDIAN
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.print_insn = print_insn_i386;
157 s->info.cap_arch = CS_ARCH_X86;
158 s->info.cap_mode = CS_MODE_32;
159 s->info.cap_insn_unit = 1;
160 s->info.cap_insn_split = 8;
161#elif defined(__x86_64__)
162 s->info.mach = bfd_mach_x86_64;
163 s->info.print_insn = print_insn_i386;
164 s->info.cap_arch = CS_ARCH_X86;
165 s->info.cap_mode = CS_MODE_64;
166 s->info.cap_insn_unit = 1;
167 s->info.cap_insn_split = 8;
168#elif defined(_ARCH_PPC)
169 s->info.disassembler_options = (char *)"any";
170 s->info.print_insn = print_insn_ppc;
171 s->info.cap_arch = CS_ARCH_PPC;
172# ifdef _ARCH_PPC64
173 s->info.cap_mode = CS_MODE_64;
174# endif
175#elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
176#if defined(_ILP32) || (__riscv_xlen == 32)
177 s->info.print_insn = print_insn_riscv32;
178#elif defined(_LP64)
179 s->info.print_insn = print_insn_riscv64;
180#else
181#error unsupported RISC-V ABI
182#endif
Richard Hendersona4038a02020-09-11 17:59:01 -0700183#elif defined(__aarch64__)
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700184 s->info.cap_arch = CS_ARCH_ARM64;
Richard Hendersona4038a02020-09-11 17:59:01 -0700185# ifdef CONFIG_ARM_A64_DIS
186 s->info.print_insn = print_insn_arm_a64;
187# endif
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700188#elif defined(__alpha__)
189 s->info.print_insn = print_insn_alpha;
190#elif defined(__sparc__)
191 s->info.print_insn = print_insn_sparc;
192 s->info.mach = bfd_mach_sparc_v9b;
193#elif defined(__arm__)
194 /* TCG only generates code for arm mode. */
195 s->info.print_insn = print_insn_arm;
196 s->info.cap_arch = CS_ARCH_ARM;
197#elif defined(__MIPSEB__)
198 s->info.print_insn = print_insn_big_mips;
199#elif defined(__MIPSEL__)
200 s->info.print_insn = print_insn_little_mips;
201#elif defined(__m68k__)
202 s->info.print_insn = print_insn_m68k;
203#elif defined(__s390__)
204 s->info.print_insn = print_insn_s390;
Richard Henderson3d562842020-01-04 07:24:59 +1000205 s->info.cap_arch = CS_ARCH_SYSZ;
206 s->info.cap_insn_unit = 2;
207 s->info.cap_insn_split = 6;
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700208#elif defined(__hppa__)
209 s->info.print_insn = print_insn_hppa;
210#endif
211}
212
Richard Henderson1d484742017-09-14 08:38:35 -0700213/* Disassemble this for me please... (debugging). */
Peter Crosthwaited49190c2015-05-24 14:20:41 -0700214void target_disas(FILE *out, CPUState *cpu, target_ulong code,
Richard Henderson1d484742017-09-14 08:38:35 -0700215 target_ulong size)
bellardb9adb4a2003-04-29 20:41:16 +0000216{
bellardc27004e2005-01-03 23:35:10 +0000217 target_ulong pc;
bellardb9adb4a2003-04-29 20:41:16 +0000218 int count;
Blue Swirlf4359b92012-09-08 12:40:00 +0000219 CPUDebug s;
bellardb9adb4a2003-04-29 20:41:16 +0000220
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700221 initialize_debug_target(&s, cpu);
222 s.info.fprintf_func = fprintf;
223 s.info.stream = out;
Blue Swirlf4359b92012-09-08 12:40:00 +0000224 s.info.buffer_vma = code;
225 s.info.buffer_length = size;
Peter Crosthwaite37b9de42015-06-23 20:57:33 -0700226
Richard Henderson8ca80762017-09-14 09:41:12 -0700227 if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
228 return;
229 }
230
Peter Crosthwaite2de295c2015-06-23 20:57:32 -0700231 if (s.info.print_insn == NULL) {
232 s.info.print_insn = print_insn_od_target;
Richard Hendersonc46ffd52013-08-16 23:29:45 -0700233 }
bellardc27004e2005-01-03 23:35:10 +0000234
blueswir17e000c22009-02-13 21:44:41 +0000235 for (pc = code; size > 0; pc += count, size -= count) {
bellardfa15e032005-01-31 23:32:31 +0000236 fprintf(out, "0x" TARGET_FMT_lx ": ", pc);
Peter Crosthwaite2de295c2015-06-23 20:57:32 -0700237 count = s.info.print_insn(pc, &s.info);
bellardc27004e2005-01-03 23:35:10 +0000238 fprintf(out, "\n");
239 if (count < 0)
240 break;
malc754d00a2009-04-21 22:26:22 +0000241 if (size < count) {
242 fprintf(out,
243 "Disassembler disagrees with translator over instruction "
244 "decoding\n"
245 "Please report this to qemu-devel@nongnu.org\n");
246 break;
247 }
bellardc27004e2005-01-03 23:35:10 +0000248 }
249}
250
Alex Bennéecbafa232019-05-22 10:27:14 +0100251static int plugin_printf(FILE *stream, const char *fmt, ...)
252{
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700253 /* We abuse the FILE parameter to pass a GString. */
254 GString *s = (GString *)stream;
Alex Bennéecbafa232019-05-22 10:27:14 +0100255 int initial_len = s->len;
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700256 va_list va;
Alex Bennéecbafa232019-05-22 10:27:14 +0100257
258 va_start(va, fmt);
259 g_string_append_vprintf(s, fmt, va);
260 va_end(va);
261
262 return s->len - initial_len;
263}
264
265static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
266{
267 /* does nothing */
268}
269
270
Alex Bennéecbafa232019-05-22 10:27:14 +0100271/*
272 * We should only be dissembling one instruction at a time here. If
273 * there is left over it usually indicates the front end has read more
274 * bytes than it needed.
275 */
276char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size)
277{
Alex Bennéecbafa232019-05-22 10:27:14 +0100278 CPUDebug s;
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700279 GString *ds = g_string_new(NULL);
Alex Bennéecbafa232019-05-22 10:27:14 +0100280
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700281 initialize_debug_target(&s, cpu);
282 s.info.fprintf_func = plugin_printf;
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700283 s.info.stream = (FILE *)ds; /* abuse this slot */
Alex Bennéecbafa232019-05-22 10:27:14 +0100284 s.info.buffer_vma = addr;
285 s.info.buffer_length = size;
286 s.info.print_address_func = plugin_print_address;
Alex Bennéecbafa232019-05-22 10:27:14 +0100287
288 if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700289 ; /* done */
290 } else if (s.info.print_insn) {
291 s.info.print_insn(addr, &s.info);
292 } else {
293 ; /* cannot disassemble -- return empty string */
Alex Bennéecbafa232019-05-22 10:27:14 +0100294 }
295
Richard Hendersonb71f3a62020-09-10 15:13:38 -0700296 /* Return the buffer, freeing the GString container. */
297 return g_string_free(ds, false);
Alex Bennéecbafa232019-05-22 10:27:14 +0100298}
299
bellardc27004e2005-01-03 23:35:10 +0000300/* Disassemble this for me please... (debugging). */
Richard Hendersonf06176b2020-10-30 20:59:01 -0700301void disas(FILE *out, const void *code, unsigned long size)
bellardc27004e2005-01-03 23:35:10 +0000302{
Stefan Weilb0b0f1c2012-04-12 15:44:35 +0200303 uintptr_t pc;
bellardc27004e2005-01-03 23:35:10 +0000304 int count;
Blue Swirlf4359b92012-09-08 12:40:00 +0000305 CPUDebug s;
bellardc27004e2005-01-03 23:35:10 +0000306
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700307 initialize_debug_host(&s);
308 s.info.fprintf_func = fprintf;
309 s.info.stream = out;
Blue Swirlf4359b92012-09-08 12:40:00 +0000310 s.info.buffer = code;
311 s.info.buffer_vma = (uintptr_t)code;
312 s.info.buffer_length = size;
Richard Henderson8ca80762017-09-14 09:41:12 -0700313
Richard Henderson4c389f62020-09-10 12:15:04 -0700314 if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) {
Richard Henderson8ca80762017-09-14 09:41:12 -0700315 return;
316 }
317
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700318 if (s.info.print_insn == NULL) {
319 s.info.print_insn = print_insn_od_host;
Richard Hendersonc46ffd52013-08-16 23:29:45 -0700320 }
Stefan Weilb0b0f1c2012-04-12 15:44:35 +0200321 for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
322 fprintf(out, "0x%08" PRIxPTR ": ", pc);
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700323 count = s.info.print_insn(pc, &s.info);
Alex Bennéee5ef4ec2020-05-13 18:51:32 +0100324 fprintf(out, "\n");
325 if (count < 0) {
326 break;
327 }
bellardb9adb4a2003-04-29 20:41:16 +0000328 }
Alex Bennéee5ef4ec2020-05-13 18:51:32 +0100329
bellardb9adb4a2003-04-29 20:41:16 +0000330}
331
332/* Look up symbol for debugging purpose. Returns "" if unknown. */
bellardc27004e2005-01-03 23:35:10 +0000333const char *lookup_symbol(target_ulong orig_addr)
bellardb9adb4a2003-04-29 20:41:16 +0000334{
pbrook49918a72008-10-22 15:11:31 +0000335 const char *symbol = "";
bellarde80cfcf2004-12-19 23:18:01 +0000336 struct syminfo *s;
ths3b46e622007-09-17 08:09:54 +0000337
bellarde80cfcf2004-12-19 23:18:01 +0000338 for (s = syminfos; s; s = s->next) {
pbrook49918a72008-10-22 15:11:31 +0000339 symbol = s->lookup_symbol(s, orig_addr);
340 if (symbol[0] != '\0') {
341 break;
342 }
bellardb9adb4a2003-04-29 20:41:16 +0000343 }
pbrook49918a72008-10-22 15:11:31 +0000344
345 return symbol;
bellardb9adb4a2003-04-29 20:41:16 +0000346}
bellard9307c4c2004-04-04 12:57:25 +0000347
348#if !defined(CONFIG_USER_ONLY)
349
Paolo Bonzini83c90892012-12-17 18:19:49 +0100350#include "monitor/monitor.h"
bellard3d2cfdf2004-08-01 21:49:07 +0000351
bellard9307c4c2004-04-04 12:57:25 +0000352static int
Richard Hendersonb8d87202017-09-19 09:40:40 -0500353physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
blueswir1a5f1b962008-08-17 20:21:51 +0000354 struct disassemble_info *info)
bellard9307c4c2004-04-04 12:57:25 +0000355{
Peter Maydellf2c6abc2018-12-14 13:30:49 +0000356 CPUDebug *s = container_of(info, CPUDebug, info);
Philippe Mathieu-Daudé6766ba52020-05-18 17:53:04 +0200357 MemTxResult res;
Peter Maydellf2c6abc2018-12-14 13:30:49 +0000358
Philippe Mathieu-Daudé6766ba52020-05-18 17:53:04 +0200359 res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
360 myaddr, length);
361 return res == MEMTX_OK ? 0 : EIO;
bellard9307c4c2004-04-04 12:57:25 +0000362}
363
Richard Henderson1d484742017-09-14 08:38:35 -0700364/* Disassembler for the monitor. */
Peter Crosthwaited49190c2015-05-24 14:20:41 -0700365void monitor_disas(Monitor *mon, CPUState *cpu,
Richard Henderson1d484742017-09-14 08:38:35 -0700366 target_ulong pc, int nb_insn, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +0000367{
bellard9307c4c2004-04-04 12:57:25 +0000368 int count, i;
Blue Swirlf4359b92012-09-08 12:40:00 +0000369 CPUDebug s;
bellard9307c4c2004-04-04 12:57:25 +0000370
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700371 initialize_debug_target(&s, cpu);
372 s.info.fprintf_func = qemu_fprintf;
373 if (is_physical) {
374 s.info.read_memory_func = physical_read_memory;
Peter Crosthwaite37b9de42015-06-23 20:57:33 -0700375 }
Richard Henderson12b6e9b2020-09-10 14:40:54 -0700376 s.info.buffer_vma = pc;
Peter Crosthwaite37b9de42015-06-23 20:57:33 -0700377
Richard Henderson8ca80762017-09-14 09:41:12 -0700378 if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
379 return;
380 }
381
Peter Crosthwaite37b9de42015-06-23 20:57:33 -0700382 if (!s.info.print_insn) {
383 monitor_printf(mon, "0x" TARGET_FMT_lx
384 ": Asm output not supported on this arch\n", pc);
385 return;
386 }
bellard9307c4c2004-04-04 12:57:25 +0000387
388 for(i = 0; i < nb_insn; i++) {
aliguori376253e2009-03-05 23:01:23 +0000389 monitor_printf(mon, "0x" TARGET_FMT_lx ": ", pc);
Peter Crosthwaite2de295c2015-06-23 20:57:32 -0700390 count = s.info.print_insn(pc, &s.info);
aliguori376253e2009-03-05 23:01:23 +0000391 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +0000392 if (count < 0)
393 break;
394 pc += count;
395 }
396}
397#endif