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