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 "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 #ifdef CONFIG_CAPSTONE
 113 /* Temporary storage for the capstone library.  This will be alloced via
 114    malloc with a size private to the library; thus there's no reason not
 115    to share this across calls and across host vs target disassembly.  */
 116 static __thread cs_insn *cap_insn;
 117
 118 /* Initialize the Capstone library.  */
 119 /* ??? It would be nice to cache this.  We would need one handle for the
 120    host and one for the target.  For most targets we can reset specific
 121    parameters via cs_option(CS_OPT_MODE, new_mode), but we cannot change
 122    CS_ARCH_* in this way.  Thus we would need to be able to close and
 123    re-open the target handle with a different arch for the target in order
 124    to handle AArch64 vs AArch32 mode switching.  */
 125 static cs_err cap_disas_start(disassemble_info *info, csh *handle)
 126 {
 127     cs_mode cap_mode = info->cap_mode;
 128     cs_err err;
 129
 130     cap_mode += (info->endian == BFD_ENDIAN_BIG ? CS_MODE_BIG_ENDIAN
 131                  : CS_MODE_LITTLE_ENDIAN);
 132
 133     err = cs_open(info->cap_arch, cap_mode, handle);
 134     if (err != CS_ERR_OK) {
 135         return err;
 136     }
 137
 138     /* ??? There probably ought to be a better place to put this.  */
 139     if (info->cap_arch == CS_ARCH_X86) {
 140         /* We don't care about errors (if for some reason the library
 141            is compiled without AT&T syntax); the user will just have
 142            to deal with the Intel syntax.  */
 143         cs_option(*handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT);
 144     }
 145
 146     /* "Disassemble" unknown insns as ".byte W,X,Y,Z".  */
 147     cs_option(*handle, CS_OPT_SKIPDATA, CS_OPT_ON);
 148
 149     /* Allocate temp space for cs_disasm_iter.  */
 150     if (cap_insn == NULL) {
 151         cap_insn = cs_malloc(*handle);
 152         if (cap_insn == NULL) {
 153             cs_close(handle);
 154             return CS_ERR_MEM;
 155         }
 156     }
 157     return CS_ERR_OK;
 158 }
 159
 160 static void cap_dump_insn_units(disassemble_info *info, cs_insn *insn,
 161                                 int i, int n)
 162 {
 163     fprintf_function print = info->fprintf_func;
 164     FILE *stream = info->stream;
 165
 166     switch (info->cap_insn_unit) {
 167     case 4:
 168         if (info->endian == BFD_ENDIAN_BIG) {
 169             for (; i < n; i += 4) {
 170                 print(stream, " %08x", ldl_be_p(insn->bytes + i));
 171
 172             }
 173         } else {
 174             for (; i < n; i += 4) {
 175                 print(stream, " %08x", ldl_le_p(insn->bytes + i));
 176             }
 177         }
 178         break;
 179
 180     case 2:
 181         if (info->endian == BFD_ENDIAN_BIG) {
 182             for (; i < n; i += 2) {
 183                 print(stream, " %04x", lduw_be_p(insn->bytes + i));
 184             }
 185         } else {
 186             for (; i < n; i += 2) {
 187                 print(stream, " %04x", lduw_le_p(insn->bytes + i));
 188             }
 189         }
 190         break;
 191
 192     default:
 193         for (; i < n; i++) {
 194             print(stream, " %02x", insn->bytes[i]);
 195         }
 196         break;
 197     }
 198 }
 199
 200 static void cap_dump_insn(disassemble_info *info, cs_insn *insn)
 201 {
 202     fprintf_function print = info->fprintf_func;
 203     int i, n, split;
 204
 205     print(info->stream, "0x%08" PRIx64 ": ", insn->address);
 206
 207     n = insn->size;
 208     split = info->cap_insn_split;
 209
 210     /* Dump the first SPLIT bytes of the instruction.  */
 211     cap_dump_insn_units(info, insn, 0, MIN(n, split));
 212
 213     /* Add padding up to SPLIT so that mnemonics line up.  */
 214     if (n < split) {
 215         int width = (split - n) / info->cap_insn_unit;
 216         width *= (2 * info->cap_insn_unit + 1);
 217         print(info->stream, "%*s", width, "");
 218     }
 219
 220     /* Print the actual instruction.  */
 221     print(info->stream, "  %-8s %s\n", insn->mnemonic, insn->op_str);
 222
 223     /* Dump any remaining part of the insn on subsequent lines.  */
 224     for (i = split; i < n; i += split) {
 225         print(info->stream, "0x%08" PRIx64 ": ", insn->address + i);
 226         cap_dump_insn_units(info, insn, i, MIN(n, i + split));
 227         print(info->stream, "\n");
 228     }
 229 }
 230
 231 /* Disassemble SIZE bytes at PC for the target.  */
 232 static bool cap_disas_target(disassemble_info *info, uint64_t pc, size_t size)
 233 {
 234     uint8_t cap_buf[1024];
 235     csh handle;
 236     cs_insn *insn;
 237     size_t csize = 0;
 238
 239     if (cap_disas_start(info, &handle) != CS_ERR_OK) {
 240         return false;
 241     }
 242     insn = cap_insn;
 243
 244     while (1) {
 245         size_t tsize = MIN(sizeof(cap_buf) - csize, size);
 246         const uint8_t *cbuf = cap_buf;
 247
 248         target_read_memory(pc + csize, cap_buf + csize, tsize, info);
 249         csize += tsize;
 250         size -= tsize;
 251
 252         while (cs_disasm_iter(handle, &cbuf, &csize, &pc, insn)) {
 253             cap_dump_insn(info, insn);
 254         }
 255
 256         /* If the target memory is not consumed, go back for more... */
 257         if (size != 0) {
 258             /* ... taking care to move any remaining fractional insn
 259                to the beginning of the buffer.  */
 260             if (csize != 0) {
 261                 memmove(cap_buf, cbuf, csize);
 262             }
 263             continue;
 264         }
 265
 266         /* Since the target memory is consumed, we should not have
 267            a remaining fractional insn.  */
 268         if (csize != 0) {
 269             (*info->fprintf_func)(info->stream,
 270                 "Disassembler disagrees with translator "
 271                 "over instruction decoding\n"
 272                 "Please report this to qemu-devel@nongnu.org\n");
 273         }
 274         break;
 275     }
 276
 277     cs_close(&handle);
 278     return true;
 279 }
 280
 281 /* Disassemble SIZE bytes at CODE for the host.  */
 282 static bool cap_disas_host(disassemble_info *info, void *code, size_t size)
 283 {
 284     csh handle;
 285     const uint8_t *cbuf;
 286     cs_insn *insn;
 287     uint64_t pc;
 288
 289     if (cap_disas_start(info, &handle) != CS_ERR_OK) {
 290         return false;
 291     }
 292     insn = cap_insn;
 293
 294     cbuf = code;
 295     pc = (uintptr_t)code;
 296
 297     while (cs_disasm_iter(handle, &cbuf, &size, &pc, insn)) {
 298         cap_dump_insn(info, insn);
 299     }
 300     if (size != 0) {
 301         (*info->fprintf_func)(info->stream,
 302             "Disassembler disagrees with TCG over instruction encoding\n"
 303             "Please report this to qemu-devel@nongnu.org\n");
 304     }
 305
 306     cs_close(&handle);
 307     return true;
 308 }
 309
 310 #if !defined(CONFIG_USER_ONLY)
 311 /* Disassemble COUNT insns at PC for the target.  */
 312 static bool cap_disas_monitor(disassemble_info *info, uint64_t pc, int count)
 313 {
 314     uint8_t cap_buf[32];
 315     csh handle;
 316     cs_insn *insn;
 317     size_t csize = 0;
 318
 319     if (cap_disas_start(info, &handle) != CS_ERR_OK) {
 320         return false;
 321     }
 322     insn = cap_insn;
 323
 324     while (1) {
 325         /* We want to read memory for one insn, but generically we do not
 326            know how much memory that is.  We have a small buffer which is
 327            known to be sufficient for all supported targets.  Try to not
 328            read beyond the page, Just In Case.  For even more simplicity,
 329            ignore the actual target page size and use a 1k boundary.  If
 330            that turns out to be insufficient, we'll come back around the
 331            loop and read more.  */
 332         uint64_t epc = QEMU_ALIGN_UP(pc + csize + 1, 1024);
 333         size_t tsize = MIN(sizeof(cap_buf) - csize, epc - pc);
 334         const uint8_t *cbuf = cap_buf;
 335
 336         /* Make certain that we can make progress.  */
 337         assert(tsize != 0);
 338         info->read_memory_func(pc, cap_buf + csize, tsize, info);
 339         csize += tsize;
 340
 341         if (cs_disasm_iter(handle, &cbuf, &csize, &pc, insn)) {
 342             cap_dump_insn(info, insn);
 343             if (--count <= 0) {
 344                 break;
 345             }
 346         }
 347         memmove(cap_buf, cbuf, csize);
 348     }
 349
 350     cs_close(&handle);
 351     return true;
 352 }
 353 #endif /* !CONFIG_USER_ONLY */
 354 #else
 355 # define cap_disas_target(i, p, s)  false
 356 # define cap_disas_host(i, p, s)  false
 357 # define cap_disas_monitor(i, p, c)  false
 358 # define cap_disas_plugin(i, p, c) false
 359 #endif /* CONFIG_CAPSTONE */
 360
 361 static void initialize_debug(CPUDebug *s)
 362 {
 363     memset(s, 0, sizeof(*s));
 364     s->info.arch = bfd_arch_unknown;
 365     s->info.cap_arch = -1;
 366     s->info.cap_insn_unit = 4;
 367     s->info.cap_insn_split = 4;
 368     s->info.memory_error_func = perror_memory;
 369     s->info.symbol_at_address_func = symbol_at_address;
 370 }
 371
 372 static void initialize_debug_target(CPUDebug *s, CPUState *cpu)
 373 {
 374     initialize_debug(s);
 375
 376     s->cpu = cpu;
 377     s->info.read_memory_func = target_read_memory;
 378     s->info.print_address_func = print_address;
 379 #ifdef TARGET_WORDS_BIGENDIAN
 380     s->info.endian = BFD_ENDIAN_BIG;
 381 #else
 382     s->info.endian = BFD_ENDIAN_LITTLE;
 383 #endif
 384
 385     CPUClass *cc = CPU_GET_CLASS(cpu);
 386     if (cc->disas_set_info) {
 387         cc->disas_set_info(cpu, &s->info);
 388     }
 389 }
 390
 391 static void initialize_debug_host(CPUDebug *s)
 392 {
 393     initialize_debug(s);
 394
 395     s->info.read_memory_func = host_read_memory;
 396     s->info.print_address_func = host_print_address;
 397 #ifdef HOST_WORDS_BIGENDIAN
 398     s->info.endian = BFD_ENDIAN_BIG;
 399 #else
 400     s->info.endian = BFD_ENDIAN_LITTLE;
 401 #endif
 402 #if defined(CONFIG_TCG_INTERPRETER)
 403     s->info.print_insn = print_insn_tci;
 404 #elif defined(__i386__)
 405     s->info.mach = bfd_mach_i386_i386;
 406     s->info.print_insn = print_insn_i386;
 407     s->info.cap_arch = CS_ARCH_X86;
 408     s->info.cap_mode = CS_MODE_32;
 409     s->info.cap_insn_unit = 1;
 410     s->info.cap_insn_split = 8;
 411 #elif defined(__x86_64__)
 412     s->info.mach = bfd_mach_x86_64;
 413     s->info.print_insn = print_insn_i386;
 414     s->info.cap_arch = CS_ARCH_X86;
 415     s->info.cap_mode = CS_MODE_64;
 416     s->info.cap_insn_unit = 1;
 417     s->info.cap_insn_split = 8;
 418 #elif defined(_ARCH_PPC)
 419     s->info.disassembler_options = (char *)"any";
 420     s->info.print_insn = print_insn_ppc;
 421     s->info.cap_arch = CS_ARCH_PPC;
 422 # ifdef _ARCH_PPC64
 423     s->info.cap_mode = CS_MODE_64;
 424 # endif
 425 #elif defined(__riscv) && defined(CONFIG_RISCV_DIS)
 426 #if defined(_ILP32) || (__riscv_xlen == 32)
 427     s->info.print_insn = print_insn_riscv32;
 428 #elif defined(_LP64)
 429     s->info.print_insn = print_insn_riscv64;
 430 #else
 431 #error unsupported RISC-V ABI
 432 #endif
 433 #elif defined(__aarch64__) && defined(CONFIG_ARM_A64_DIS)
 434     s->info.print_insn = print_insn_arm_a64;
 435     s->info.cap_arch = CS_ARCH_ARM64;
 436 #elif defined(__alpha__)
 437     s->info.print_insn = print_insn_alpha;
 438 #elif defined(__sparc__)
 439     s->info.print_insn = print_insn_sparc;
 440     s->info.mach = bfd_mach_sparc_v9b;
 441 #elif defined(__arm__)
 442     /* TCG only generates code for arm mode.  */
 443     s->info.print_insn = print_insn_arm;
 444     s->info.cap_arch = CS_ARCH_ARM;
 445 #elif defined(__MIPSEB__)
 446     s->info.print_insn = print_insn_big_mips;
 447 #elif defined(__MIPSEL__)
 448     s->info.print_insn = print_insn_little_mips;
 449 #elif defined(__m68k__)
 450     s->info.print_insn = print_insn_m68k;
 451 #elif defined(__s390__)
 452     s->info.print_insn = print_insn_s390;
 453 #elif defined(__hppa__)
 454     s->info.print_insn = print_insn_hppa;
 455 #endif
 456 }
 457
 458 /* Disassemble this for me please... (debugging).  */
 459 void target_disas(FILE *out, CPUState *cpu, target_ulong code,
 460                   target_ulong size)
 461 {
 462     target_ulong pc;
 463     int count;
 464     CPUDebug s;
 465
 466     initialize_debug_target(&s, cpu);
 467     s.info.fprintf_func = fprintf;
 468     s.info.stream = out;
 469     s.info.buffer_vma = code;
 470     s.info.buffer_length = size;
 471
 472     if (s.info.cap_arch >= 0 && cap_disas_target(&s.info, code, size)) {
 473         return;
 474     }
 475
 476     if (s.info.print_insn == NULL) {
 477         s.info.print_insn = print_insn_od_target;
 478     }
 479
 480     for (pc = code; size > 0; pc += count, size -= count) {
 481         fprintf(out, "0x" TARGET_FMT_lx ":  ", pc);
 482         count = s.info.print_insn(pc, &s.info);
 483         fprintf(out, "\n");
 484         if (count < 0)
 485             break;
 486         if (size < count) {
 487             fprintf(out,
 488                     "Disassembler disagrees with translator over instruction "
 489                     "decoding\n"
 490                     "Please report this to qemu-devel@nongnu.org\n");
 491             break;
 492         }
 493     }
 494 }
 495
 496 static int plugin_printf(FILE *stream, const char *fmt, ...)
 497 {
 498     /* We abuse the FILE parameter to pass a GString. */
 499     GString *s = (GString *)stream;
 500     int initial_len = s->len;
 501     va_list va;
 502
 503     va_start(va, fmt);
 504     g_string_append_vprintf(s, fmt, va);
 505     va_end(va);
 506
 507     return s->len - initial_len;
 508 }
 509
 510 static void plugin_print_address(bfd_vma addr, struct disassemble_info *info)
 511 {
 512     /* does nothing */
 513 }
 514
 515
 516 #ifdef CONFIG_CAPSTONE
 517 /* Disassemble a single instruction directly into plugin output */
 518 static
 519 bool cap_disas_plugin(disassemble_info *info, uint64_t pc, size_t size)
 520 {
 521     uint8_t cap_buf[64];
 522     const uint8_t *cbuf = cap_buf;
 523     csh handle;
 524
 525     if (cap_disas_start(info, &handle) != CS_ERR_OK) {
 526         return false;
 527     }
 528
 529     assert(size < sizeof(cap_buf));
 530     target_read_memory(pc, cap_buf, size, info);
 531
 532     if (cs_disasm_iter(handle, &cbuf, &size, &pc, cap_insn)) {
 533         GString *s = (GString *)info->stream;
 534         g_string_printf(s, "%s %s", cap_insn->mnemonic, cap_insn->op_str);
 535     }
 536
 537     cs_close(&handle);
 538     return true;
 539 }
 540 #endif
 541
 542 /*
 543  * We should only be dissembling one instruction at a time here. If
 544  * there is left over it usually indicates the front end has read more
 545  * bytes than it needed.
 546  */
 547 char *plugin_disas(CPUState *cpu, uint64_t addr, size_t size)
 548 {
 549     CPUDebug s;
 550     GString *ds = g_string_new(NULL);
 551
 552     initialize_debug_target(&s, cpu);
 553     s.info.fprintf_func = plugin_printf;
 554     s.info.stream = (FILE *)ds;  /* abuse this slot */
 555     s.info.buffer_vma = addr;
 556     s.info.buffer_length = size;
 557     s.info.print_address_func = plugin_print_address;
 558
 559     if (s.info.cap_arch >= 0 && cap_disas_plugin(&s.info, addr, size)) {
 560         ; /* done */
 561     } else if (s.info.print_insn) {
 562         s.info.print_insn(addr, &s.info);
 563     } else {
 564         ; /* cannot disassemble -- return empty string */
 565     }
 566
 567     /* Return the buffer, freeing the GString container.  */
 568     return g_string_free(ds, false);
 569 }
 570
 571 /* Disassemble this for me please... (debugging). */
 572 void disas(FILE *out, void *code, unsigned long size)
 573 {
 574     uintptr_t pc;
 575     int count;
 576     CPUDebug s;
 577
 578     initialize_debug_host(&s);
 579     s.info.fprintf_func = fprintf;
 580     s.info.stream = out;
 581     s.info.buffer = code;
 582     s.info.buffer_vma = (uintptr_t)code;
 583     s.info.buffer_length = size;
 584
 585     if (s.info.cap_arch >= 0 && cap_disas_host(&s.info, code, size)) {
 586         return;
 587     }
 588
 589     if (s.info.print_insn == NULL) {
 590         s.info.print_insn = print_insn_od_host;
 591     }
 592     for (pc = (uintptr_t)code; size > 0; pc += count, size -= count) {
 593         fprintf(out, "0x%08" PRIxPTR ":  ", pc);
 594         count = s.info.print_insn(pc, &s.info);
 595         fprintf(out, "\n");
 596         if (count < 0) {
 597             break;
 598         }
 599     }
 600
 601 }
 602
 603 /* Look up symbol for debugging purpose.  Returns "" if unknown. */
 604 const char *lookup_symbol(target_ulong orig_addr)
 605 {
 606     const char *symbol = "";
 607     struct syminfo *s;
 608
 609     for (s = syminfos; s; s = s->next) {
 610         symbol = s->lookup_symbol(s, orig_addr);
 611         if (symbol[0] != '\0') {
 612             break;
 613         }
 614     }
 615
 616     return symbol;
 617 }
 618
 619 #if !defined(CONFIG_USER_ONLY)
 620
 621 #include "monitor/monitor.h"
 622
 623 static int
 624 physical_read_memory(bfd_vma memaddr, bfd_byte *myaddr, int length,
 625                      struct disassemble_info *info)
 626 {
 627     CPUDebug *s = container_of(info, CPUDebug, info);
 628     MemTxResult res;
 629
 630     res = address_space_read(s->cpu->as, memaddr, MEMTXATTRS_UNSPECIFIED,
 631                              myaddr, length);
 632     return res == MEMTX_OK ? 0 : EIO;
 633 }
 634
 635 /* Disassembler for the monitor.  */
 636 void monitor_disas(Monitor *mon, CPUState *cpu,
 637                    target_ulong pc, int nb_insn, int is_physical)
 638 {
 639     int count, i;
 640     CPUDebug s;
 641
 642     initialize_debug_target(&s, cpu);
 643     s.info.fprintf_func = qemu_fprintf;
 644     if (is_physical) {
 645         s.info.read_memory_func = physical_read_memory;
 646     }
 647     s.info.buffer_vma = pc;
 648
 649     if (s.info.cap_arch >= 0 && cap_disas_monitor(&s.info, pc, nb_insn)) {
 650         return;
 651     }
 652
 653     if (!s.info.print_insn) {
 654         monitor_printf(mon, "0x" TARGET_FMT_lx
 655                        ": Asm output not supported on this arch\n", pc);
 656         return;
 657     }
 658
 659     for(i = 0; i < nb_insn; i++) {
 660         monitor_printf(mon, "0x" TARGET_FMT_lx ":  ", pc);
 661         count = s.info.print_insn(pc, &s.info);
 662         monitor_printf(mon, "\n");
 663         if (count < 0)
 664             break;
 665         pc += count;
 666     }
 667 }
 668 #endif