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