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 s.info.show_opcodes = true; 215 216 if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) { 217 return; 218 } 219 220 if (s.info.print_insn == NULL) { 221 s.info.print_insn = print_insn_od_target; 222 } 223 224 for (pc = code; size > 0; pc += count, size -= count) { 225 fprintf(out, "0x%08" PRIx64 ": ", pc); 226 count = s.info.print_insn(pc, &s.info); 227 fprintf(out, "\n"); 228 if (count < 0) { 229 break; 230 } 231 if (size < count) { 232 fprintf(out, 233 "Disassembler disagrees with translator over instruction " 234 "decoding\n" 235 "Please report this to qemu-devel@nongnu.org\n"); 236 break; 237 } 238 } 239 } 240 241 int disas_gstring_printf(FILE *stream, const char *fmt, ...) 242 { 243 /* We abuse the FILE parameter to pass a GString. */ 244 GString *s = (GString *)stream; 245 int initial_len = s->len; 246 va_list va; 247 248 va_start(va, fmt); 249 g_string_append_vprintf(s, fmt, va); 250 va_end(va); 251 252 return s->len - initial_len; 253 } 254 255 static void plugin_print_address(bfd_vma addr, struct disassemble_info *info) 256 { 257 /* does nothing */ 258 } 259 260 261 /* 262 * We should only be dissembling one instruction at a time here. If 263 * there is left over it usually indicates the front end has read more 264 * bytes than it needed. 265 */ 266 char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size) 267 { 268 CPUDebug s; 269 GString *ds = g_string_new(NULL); 270 271 disas_initialize_debug_target(&s, cpu); 272 s.info.fprintf_func = disas_gstring_printf; 273 s.info.stream = (FILE *)ds; /* abuse this slot */ 274 s.info.buffer_vma = addr; 275 s.info.buffer_length = size; 276 s.info.print_address_func = plugin_print_address; 277 278 if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) { 279 ; /* done */ 280 } else if (s.info.print_insn) { 281 s.info.print_insn(addr, &s.info); 282 } else { 283 ; /* cannot disassemble -- return empty string */ 284 } 285 286 /* Return the buffer, freeing the GString container. */ 287 return g_string_free(ds, false); 288 } 289 290 /* Disassemble this for me please... (debugging). */ 291 void disas(FILE *out, const void *code, size_t size) 292 { 293 uintptr_t pc; 294 int count; 295 CPUDebug s; 296 297 initialize_debug_host(&s); 298 s.info.fprintf_func = fprintf; 299 s.info.stream = out; 300 s.info.buffer = code; 301 s.info.buffer_vma = (uintptr_t)code; 302 s.info.buffer_length = size; 303 s.info.show_opcodes = true; 304 305 if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) { 306 return; 307 } 308 309 if (s.info.print_insn == NULL) { 310 s.info.print_insn = print_insn_od_host; 311 } 312 for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) { 313 fprintf(out, "0x%08" PRIxPTR ": ", pc); 314 count = s.info.print_insn(pc, &s.info); 315 fprintf(out, "\n"); 316 if (count < 0) { 317 break; 318 } 319 } 320 321 } 322 323 /* Look up symbol for debugging purpose. Returns "" if unknown. */ 324 const char *lookup_symbol(uint64_t orig_addr) 325 { 326 const char *symbol = ""; 327 struct syminfo *s; 328 329 for (s = syminfos; s; s = s->next) { 330 symbol = s->lookup_symbol(s, orig_addr); 331 if (symbol[0] != '\0') { 332 break; 333 } 334 } 335 336 return symbol; 337 } 338