disas/disas.c

   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 }