kit

addr2line.c (5198B)

---

 #include <kit/core.h>
 #include <kit/dwarf.h>
 #include <kit/object.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "driver.h"
 #include "dwarfsym.h"
 
 #define A2L_TOOL "addr2line"
 
 typedef struct A2lOpts {
   const char* exe_path;
   int functions; /* -f */
   int pretty;    /* -p */
   int basenames; /* --basenames */
   int show_addr; /* -a */
 } A2lOpts;
 
 static void a2l_strip_basename(const char** path_ptr) {
   const char* s = *path_ptr;
   const char* slash = NULL;
   const char* p;
   if (!s) return;
   for (p = s; *p; ++p)
     if (*p == '/') slash = p;
   if (slash) *path_ptr = slash + 1;
 }
 
 static void a2l_translate(DriverDwarfSym* sym, uint64_t addr,
                           const A2lOpts* opts) {
   DriverSymLoc loc;
 
   /* Share the DWARF open + func/line queries with `kit symbolize`; the two
    * tools differ only in how they format the result. */
   driver_dwarfsym_lookup(sym, addr, opts->functions, &loc);
 
   if (opts->show_addr) driver_printf("0x%llx", (unsigned long long)addr);
 
   if (opts->pretty) {
     if (opts->show_addr) driver_printf(": ");
     if (loc.have_func)
       driver_printf("%.*s at ", (int)loc.func.len, loc.func.s);
     else if (opts->functions)
       driver_printf("?? at ");
     if (loc.have_line) {
       const char* f = loc.file.s;
       if (opts->basenames) a2l_strip_basename(&f);
       driver_printf("%s:%u", f, loc.line);
       if (loc.col) driver_printf(":%u", loc.col);
     } else {
       driver_printf("??:0");
     }
     driver_printf("\n");
     return;
   }
 
   /* default or -f, -a modes */
   if (opts->show_addr) driver_printf(": ");
 
   if (opts->functions) {
     if (loc.have_func)
       driver_printf("%.*s\n", (int)loc.func.len, loc.func.s);
     else
       driver_printf("??\n");
   }
 
   if (loc.have_line) {
     const char* f = loc.file.s;
     if (opts->basenames) a2l_strip_basename(&f);
     driver_printf("%s:%u", f, loc.line);
     if (loc.col) driver_printf(":%u", loc.col);
   } else {
     driver_printf("??:0");
   }
   driver_printf("\n");
 }
 
 void driver_help_addr2line(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit addr2line — translate addresses to file:line using debug "
           "info\n"
           "\n"
           "USAGE\n"
           "  kit addr2line [OPTIONS] -e FILE [ADDR...]\n"
           "\n"
           "OPTIONS\n"
           "  -e FILE              object file with debug info (required)\n"
           "  -a, --addresses      print the address before each line\n"
           "  -f, --functions      print function names\n"
           "  -p, --pretty-print   compact single-line output\n"
           "  --basenames          strip directory from file paths\n"
           "  -h, --help           show this help\n"
           "\n"
           "If no addresses are given on the command line, addresses are read\n"
           "from standard input, one per line (hex).\n")));
 }
 
 int driver_addr2line(int argc, char** argv) {
   DriverEnv env;
   A2lOpts opts;
   DriverDwarfSym sym;
   int i, rc = 1, opened = 0;
   int stdin_addr_count = 0;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_addr2line();
     return 0;
   }
 
   memset(&opts, 0, sizeof opts);
   driver_env_init(&env);
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (driver_streq(a, "-e")) {
       if (i + 1 >= argc) {
         driver_errf(A2L_TOOL, "-e requires a path");
         rc = 2;
         goto done;
       }
       opts.exe_path = argv[++i];
       continue;
     }
     if (driver_streq(a, "-a") || driver_streq(a, "--addresses")) {
       opts.show_addr = 1;
       continue;
     }
     if (driver_streq(a, "-f") || driver_streq(a, "--functions")) {
       opts.functions = 1;
       continue;
     }
     if (driver_streq(a, "-p") || driver_streq(a, "--pretty-print")) {
       opts.pretty = 1;
       continue;
     }
     if (driver_streq(a, "--basenames")) {
       opts.basenames = 1;
       continue;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(A2L_TOOL, "unknown option: %s", a);
       rc = 2;
       goto done;
     }
   }
 
   if (!opts.exe_path) {
     driver_errf(A2L_TOOL, "no object file specified (-e FILE)");
     rc = 2;
     goto done;
   }
 
   /* open() memsets `sym` before any fallible step, so once we are past this
    * point driver_dwarfsym_close is always safe — even on a partial failure. */
   opened = 1;
   if (driver_dwarfsym_open(&sym, &env, A2L_TOOL, opts.exe_path) != 0) {
     rc = 1;
     goto done;
   }
 
   /* scan for positional addresses */
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (a[0] == '-' && a[1] != '\0') {
       if (driver_streq(a, "-e")) {
         ++i;
         continue;
       }
       continue;
     }
     {
       uint64_t addr = (uint64_t)strtoull(a, NULL, 16);
       a2l_translate(&sym, addr, &opts);
       stdin_addr_count++;
     }
   }
 
   if (stdin_addr_count == 0) {
     char line[256];
     for (;;) {
       int n = driver_read_line(line, sizeof line);
       if (n <= 0) break;
       {
         uint64_t addr = (uint64_t)strtoull(line, NULL, 16);
         a2l_translate(&sym, addr, &opts);
       }
     }
   }
 
   rc = 0;
 
 done:
   if (opened) driver_dwarfsym_close(&sym);
   driver_env_fini(&env);
   return rc;
 }