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