]>
Commit | Line | Data |
---|---|---|
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 |