contrib/elftoolchain/addr2line/addr2line.c

   1 /*-
   2  * Copyright (c) 2009 Kai Wang
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/param.h>
  28
  29 #include <capsicum_helpers.h>
  30 #include <dwarf.h>
  31 #include <err.h>
  32 #include <fcntl.h>
  33 #include <gelf.h>
  34 #include <getopt.h>
  35 #include <libdwarf.h>
  36 #include <libelftc.h>
  37 #include <libgen.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #include "uthash.h"
  43 #include "_elftc.h"
  44
  45 ELFTC_VCSID("$Id: addr2line.c 3499 2016-11-25 16:06:29Z emaste $");
  46
  47 struct Func {
  48         char *name;
  49         Dwarf_Unsigned lopc;
  50         Dwarf_Unsigned hipc;
  51         Dwarf_Unsigned call_file;
  52         Dwarf_Unsigned call_line;
  53         Dwarf_Ranges *ranges;
  54         Dwarf_Signed ranges_cnt;
  55         struct Func *inlined_caller;
  56         STAILQ_ENTRY(Func) next;
  57 };
  58
  59 struct CU {
  60         Dwarf_Off off;
  61         Dwarf_Unsigned lopc;
  62         Dwarf_Unsigned hipc;
  63         char **srcfiles;
  64         Dwarf_Signed nsrcfiles;
  65         STAILQ_HEAD(, Func) funclist;
  66         UT_hash_handle hh;
  67 };
  68
  69 static struct option longopts[] = {
  70         {"addresses", no_argument, NULL, 'a'},
  71         {"target" , required_argument, NULL, 'b'},
  72         {"demangle", no_argument, NULL, 'C'},
  73         {"exe", required_argument, NULL, 'e'},
  74         {"functions", no_argument, NULL, 'f'},
  75         {"inlines", no_argument, NULL, 'i'},
  76         {"section", required_argument, NULL, 'j'},
  77         {"pretty-print", no_argument, NULL, 'p'},
  78         {"basename", no_argument, NULL, 's'},
  79         {"help", no_argument, NULL, 'H'},
  80         {"version", no_argument, NULL, 'V'},
  81         {NULL, 0, NULL, 0}
  82 };
  83 static int demangle, func, base, inlines, print_addr, pretty_print;
  84 static char unknown[] = { '?', '?', '\0' };
  85 static Dwarf_Addr section_base;
  86 static struct CU *culist;
  87
  88 #define USAGE_MESSAGE   "\
  89 Usage: %s [options] hexaddress...\n\
  90   Map program addresses to source file names and line numbers.\n\n\
  91   Options:\n\
  92   -a      | --addresses       Display address prior to line number info.\n\
  93   -b TGT  | --target=TGT      (Accepted but ignored).\n\
  94   -e EXE  | --exe=EXE         Use program \"EXE\" to translate addresses.\n\
  95   -f      | --functions       Display function names.\n\
  96   -i      | --inlines         Display caller info for inlined functions.\n\
  97   -j NAME | --section=NAME    Values are offsets into section \"NAME\".\n\
  98   -p      | --pretty-print    Display line number info and function name\n\
  99                               in human readable manner.\n\
 100   -s      | --basename        Only show the base name for each file name.\n\
 101   -C      | --demangle        Demangle C++ names.\n\
 102   -H      | --help            Print a help message.\n\
 103   -V      | --version         Print a version identifier and exit.\n"
 104
 105 static void
 106 usage(void)
 107 {
 108         (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());
 109         exit(1);
 110 }
 111
 112 static void
 113 version(void)
 114 {
 115
 116         fprintf(stderr, "%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
 117         exit(0);
 118 }
 119
 120 /*
 121  * Handle DWARF 4 'offset from' DW_AT_high_pc.  Although we don't
 122  * fully support DWARF 4, some compilers (like FreeBSD Clang 3.5.1)
 123  * generate DW_AT_high_pc as an offset from DW_AT_low_pc.
 124  *
 125  * "If the value of the DW_AT_high_pc is of class address, it is the
 126  * relocated address of the first location past the last instruction
 127  * associated with the entity; if it is of class constant, the value
 128  * is an unsigned integer offset which when added to the low PC gives
 129  * the address of the first location past the last instruction
 130  * associated with the entity."
 131  *
 132  * DWARF4 spec, section 2.17.2.
 133  */
 134 static int
 135 handle_high_pc(Dwarf_Die die, Dwarf_Unsigned lopc, Dwarf_Unsigned *hipc)
 136 {
 137         Dwarf_Error de;
 138         Dwarf_Half form;
 139         Dwarf_Attribute at;
 140         int ret;
 141
 142         ret = dwarf_attr(die, DW_AT_high_pc, &at, &de);
 143         if (ret == DW_DLV_ERROR) {
 144                 warnx("dwarf_attr failed: %s", dwarf_errmsg(de));
 145                 return (ret);
 146         }
 147         ret = dwarf_whatform(at, &form, &de);
 148         if (ret == DW_DLV_ERROR) {
 149                 warnx("dwarf_whatform failed: %s", dwarf_errmsg(de));
 150                 return (ret);
 151         }
 152         if (dwarf_get_form_class(2, 0, 0, form) == DW_FORM_CLASS_CONSTANT)
 153                 *hipc += lopc;
 154
 155         return (DW_DLV_OK);
 156 }
 157
 158 static struct Func *
 159 search_func(struct CU *cu, Dwarf_Unsigned addr)
 160 {
 161         struct Func *f, *f0;
 162         Dwarf_Unsigned lopc, hipc, addr_base;
 163         int i;
 164
 165         f0 = NULL;
 166
 167         STAILQ_FOREACH(f, &cu->funclist, next) {
 168                 if (f->ranges != NULL) {
 169                         addr_base = 0;
 170                         for (i = 0; i < f->ranges_cnt; i++) {
 171                                 if (f->ranges[i].dwr_type == DW_RANGES_END)
 172                                         break;
 173                                 if (f->ranges[i].dwr_type ==
 174                                     DW_RANGES_ADDRESS_SELECTION) {
 175                                         addr_base = f->ranges[i].dwr_addr2;
 176                                         continue;
 177                                 }
 178
 179                                 /* DW_RANGES_ENTRY */
 180                                 lopc = f->ranges[i].dwr_addr1 + addr_base;
 181                                 hipc = f->ranges[i].dwr_addr2 + addr_base;
 182                                 if (addr >= lopc && addr < hipc) {
 183                                         if (f0 == NULL ||
 184                                             (lopc >= f0->lopc &&
 185                                             hipc <= f0->hipc)) {
 186                                                 f0 = f;
 187                                                 f0->lopc = lopc;
 188                                                 f0->hipc = hipc;
 189                                                 break;
 190                                         }
 191                                 }
 192                         }
 193                 } else if (addr >= f->lopc && addr < f->hipc) {
 194                         if (f0 == NULL ||
 195                             (f->lopc >= f0->lopc && f->hipc <= f0->hipc))
 196                                 f0 = f;
 197                 }
 198         }
 199
 200         return (f0);
 201 }
 202
 203 static void
 204 collect_func(Dwarf_Debug dbg, Dwarf_Die die, struct Func *parent, struct CU *cu)
 205 {
 206         Dwarf_Die ret_die, abst_die, spec_die;
 207         Dwarf_Error de;
 208         Dwarf_Half tag;
 209         Dwarf_Unsigned lopc, hipc, ranges_off;
 210         Dwarf_Signed ranges_cnt;
 211         Dwarf_Off ref;
 212         Dwarf_Attribute abst_at, spec_at;
 213         Dwarf_Ranges *ranges;
 214         const char *funcname;
 215         struct Func *f;
 216         int found_ranges, ret;
 217
 218         f = NULL;
 219         abst_die = spec_die = NULL;
 220
 221         if (dwarf_tag(die, &tag, &de)) {
 222                 warnx("dwarf_tag: %s", dwarf_errmsg(de));
 223                 goto cont_search;
 224         }
 225         if (tag == DW_TAG_subprogram || tag == DW_TAG_entry_point ||
 226             tag == DW_TAG_inlined_subroutine) {
 227                 /*
 228                  * Function address range can be specified by either
 229                  * a DW_AT_ranges attribute which points to a range list or
 230                  * by a pair of DW_AT_low_pc and DW_AT_high_pc attributes.
 231                  */
 232                 ranges = NULL;
 233                 ranges_cnt = 0;
 234                 found_ranges = 0;
 235                 if (dwarf_attrval_unsigned(die, DW_AT_ranges, &ranges_off,
 236                     &de) == DW_DLV_OK &&
 237                     dwarf_get_ranges(dbg, (Dwarf_Off) ranges_off, &ranges,
 238                     &ranges_cnt, NULL, &de) == DW_DLV_OK) {
 239                         if (ranges != NULL && ranges_cnt > 0) {
 240                                 found_ranges = 1;
 241                                 goto get_func_name;
 242                         }
 243                 }
 244
 245                 /*
 246                  * Search for DW_AT_low_pc/DW_AT_high_pc if ranges pointer
 247                  * not found.
 248                  */
 249                 if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) ||
 250                     dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de))
 251                         goto cont_search;
 252                 if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
 253                         goto cont_search;
 254
 255         get_func_name:
 256                 /*
 257                  * Most common case the function name is stored in DW_AT_name
 258                  * attribute.
 259                  */
 260                 if (dwarf_attrval_string(die, DW_AT_name, &funcname, &de) ==
 261                     DW_DLV_OK)
 262                         goto add_func;
 263
 264                 /*
 265                  * For inlined function, the actual name is probably in the DIE
 266                  * referenced by DW_AT_abstract_origin. (if present)
 267                  */
 268                 if (dwarf_attr(die, DW_AT_abstract_origin, &abst_at, &de) ==
 269                     DW_DLV_OK &&
 270                     dwarf_global_formref(abst_at, &ref, &de) == DW_DLV_OK &&
 271                     dwarf_offdie(dbg, ref, &abst_die, &de) == DW_DLV_OK &&
 272                     dwarf_attrval_string(abst_die, DW_AT_name, &funcname,
 273                     &de) == DW_DLV_OK)
 274                         goto add_func;
 275
 276                 /*
 277                  * If DW_AT_name is not present, but DW_AT_specification is
 278                  * present, then probably the actual name is in the DIE
 279                  * referenced by DW_AT_specification.
 280                  */
 281                 if (dwarf_attr(die, DW_AT_specification, &spec_at, &de) ==
 282                     DW_DLV_OK &&
 283                     dwarf_global_formref(spec_at, &ref, &de) == DW_DLV_OK &&
 284                     dwarf_offdie(dbg, ref, &spec_die, &de) == DW_DLV_OK &&
 285                     dwarf_attrval_string(spec_die, DW_AT_name, &funcname,
 286                     &de) == DW_DLV_OK)
 287                         goto add_func;
 288
 289                 /* Skip if no name associated with this DIE. */
 290                 goto cont_search;
 291
 292         add_func:
 293                 if ((f = calloc(1, sizeof(*f))) == NULL)
 294                         err(EXIT_FAILURE, "calloc");
 295                 if ((f->name = strdup(funcname)) == NULL)
 296                         err(EXIT_FAILURE, "strdup");
 297                 if (found_ranges) {
 298                         f->ranges = ranges;
 299                         f->ranges_cnt = ranges_cnt;
 300                 } else {
 301                         f->lopc = lopc;
 302                         f->hipc = hipc;
 303                 }
 304                 if (tag == DW_TAG_inlined_subroutine) {
 305                         f->inlined_caller = parent;
 306                         dwarf_attrval_unsigned(die, DW_AT_call_file,
 307                             &f->call_file, &de);
 308                         dwarf_attrval_unsigned(die, DW_AT_call_line,
 309                             &f->call_line, &de);
 310                 }
 311                 STAILQ_INSERT_TAIL(&cu->funclist, f, next);
 312         }
 313
 314 cont_search:
 315
 316         /* Search children. */
 317         ret = dwarf_child(die, &ret_die, &de);
 318         if (ret == DW_DLV_ERROR)
 319                 warnx("dwarf_child: %s", dwarf_errmsg(de));
 320         else if (ret == DW_DLV_OK) {
 321                 if (f != NULL)
 322                         collect_func(dbg, ret_die, f, cu);
 323                 else
 324                         collect_func(dbg, ret_die, parent, cu);
 325         }
 326
 327         /* Search sibling. */
 328         ret = dwarf_siblingof(dbg, die, &ret_die, &de);
 329         if (ret == DW_DLV_ERROR)
 330                 warnx("dwarf_siblingof: %s", dwarf_errmsg(de));
 331         else if (ret == DW_DLV_OK)
 332                 collect_func(dbg, ret_die, parent, cu);
 333
 334         /* Cleanup */
 335         dwarf_dealloc(dbg, die, DW_DLA_DIE);
 336
 337         if (abst_die != NULL)
 338                 dwarf_dealloc(dbg, abst_die, DW_DLA_DIE);
 339
 340         if (spec_die != NULL)
 341                 dwarf_dealloc(dbg, spec_die, DW_DLA_DIE);
 342 }
 343
 344 static void
 345 print_inlines(struct CU *cu, struct Func *f, Dwarf_Unsigned call_file,
 346     Dwarf_Unsigned call_line)
 347 {
 348         char demangled[1024];
 349         char *file;
 350
 351         if (call_file > 0 && (Dwarf_Signed) call_file <= cu->nsrcfiles)
 352                 file = cu->srcfiles[call_file - 1];
 353         else
 354                 file = unknown;
 355
 356         if (pretty_print)
 357                 printf(" (inlined by) ");
 358
 359         if (func) {
 360                 if (demangle && !elftc_demangle(f->name, demangled,
 361                     sizeof(demangled), 0)) {
 362                         if (pretty_print)
 363                                 printf("%s at ", demangled);
 364                         else
 365                                 printf("%s\n", demangled);
 366                 } else {
 367                         if (pretty_print)
 368                                 printf("%s at ", f->name);
 369                         else
 370                                 printf("%s\n", f->name);
 371                 }
 372         }
 373         (void) printf("%s:%ju\n", base ? basename(file) : file,
 374             (uintmax_t) call_line);
 375
 376         if (f->inlined_caller != NULL)
 377                 print_inlines(cu, f->inlined_caller, f->call_file,
 378                     f->call_line);
 379 }
 380
 381 static void
 382 translate(Dwarf_Debug dbg, Elf *e, const char* addrstr)
 383 {
 384         Dwarf_Die die, ret_die;
 385         Dwarf_Line *lbuf;
 386         Dwarf_Error de;
 387         Dwarf_Half tag;
 388         Dwarf_Unsigned lopc, hipc, addr, lineno, plineno;
 389         Dwarf_Signed lcount;
 390         Dwarf_Addr lineaddr, plineaddr;
 391         Dwarf_Off off;
 392         struct CU *cu;
 393         struct Func *f;
 394         const char *funcname;
 395         char *file, *file0, *pfile;
 396         char demangled[1024];
 397         int ec, i, ret;
 398
 399         addr = strtoull(addrstr, NULL, 16);
 400         addr += section_base;
 401         lineno = 0;
 402         file = unknown;
 403         cu = NULL;
 404         die = NULL;
 405
 406         while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
 407             &de)) ==  DW_DLV_OK) {
 408                 die = NULL;
 409                 while (dwarf_siblingof(dbg, die, &ret_die, &de) == DW_DLV_OK) {
 410                         if (die != NULL)
 411                                 dwarf_dealloc(dbg, die, DW_DLA_DIE);
 412                         die = ret_die;
 413                         if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
 414                                 warnx("dwarf_tag failed: %s",
 415                                     dwarf_errmsg(de));
 416                                 goto next_cu;
 417                         }
 418
 419                         /* XXX: What about DW_TAG_partial_unit? */
 420                         if (tag == DW_TAG_compile_unit)
 421                                 break;
 422                 }
 423                 if (ret_die == NULL) {
 424                         warnx("could not find DW_TAG_compile_unit die");
 425                         goto next_cu;
 426                 }
 427                 if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) ==
 428                     DW_DLV_OK) {
 429                         if (dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc,
 430                            &de) == DW_DLV_OK) {
 431                                 /*
 432                                  * Check if the address falls into the PC
 433                                  * range of this CU.
 434                                  */
 435                                 if (handle_high_pc(die, lopc, &hipc) !=
 436                                     DW_DLV_OK)
 437                                         goto out;
 438                         } else {
 439                                 /* Assume ~0ULL if DW_AT_high_pc not present */
 440                                 hipc = ~0ULL;
 441                         }
 442
 443                         /*
 444                          * Record the CU in the hash table for faster lookup
 445                          * later.
 446                          */
 447                         if (dwarf_dieoffset(die, &off, &de) != DW_DLV_OK) {
 448                                 warnx("dwarf_dieoffset failed: %s",
 449                                     dwarf_errmsg(de));
 450                                 goto out;
 451                         }
 452                         HASH_FIND(hh, culist, &off, sizeof(off), cu);
 453                         if (cu == NULL) {
 454                                 if ((cu = calloc(1, sizeof(*cu))) == NULL)
 455                                         err(EXIT_FAILURE, "calloc");
 456                                 cu->off = off;
 457                                 cu->lopc = lopc;
 458                                 cu->hipc = hipc;
 459                                 STAILQ_INIT(&cu->funclist);
 460                                 HASH_ADD(hh, culist, off, sizeof(off), cu);
 461                         }
 462
 463                         if (addr >= lopc && addr < hipc)
 464                                 break;
 465                 }
 466
 467         next_cu:
 468                 if (die != NULL) {
 469                         dwarf_dealloc(dbg, die, DW_DLA_DIE);
 470                         die = NULL;
 471                 }
 472         }
 473
 474         if (ret != DW_DLV_OK || die == NULL)
 475                 goto out;
 476
 477         switch (dwarf_srclines(die, &lbuf, &lcount, &de)) {
 478         case DW_DLV_OK:
 479                 break;
 480         case DW_DLV_NO_ENTRY:
 481                 /* If a CU lacks debug info, just skip it. */
 482                 goto out;
 483         default:
 484                 warnx("dwarf_srclines: %s", dwarf_errmsg(de));
 485                 goto out;
 486         }
 487
 488         plineaddr = ~0ULL;
 489         plineno = 0;
 490         pfile = unknown;
 491         for (i = 0; i < lcount; i++) {
 492                 if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) {
 493                         warnx("dwarf_lineaddr: %s", dwarf_errmsg(de));
 494                         goto out;
 495                 }
 496                 if (dwarf_lineno(lbuf[i], &lineno, &de)) {
 497                         warnx("dwarf_lineno: %s", dwarf_errmsg(de));
 498                         goto out;
 499                 }
 500                 if (dwarf_linesrc(lbuf[i], &file0, &de)) {
 501                         warnx("dwarf_linesrc: %s", dwarf_errmsg(de));
 502                 } else
 503                         file = file0;
 504                 if (addr == lineaddr)
 505                         goto out;
 506                 else if (addr < lineaddr && addr > plineaddr) {
 507                         lineno = plineno;
 508                         file = pfile;
 509                         goto out;
 510                 }
 511                 plineaddr = lineaddr;
 512                 plineno = lineno;
 513                 pfile = file;
 514         }
 515
 516 out:
 517         f = NULL;
 518         funcname = NULL;
 519         if (ret == DW_DLV_OK && (func || inlines) && cu != NULL) {
 520                 if (cu->srcfiles == NULL)
 521                         if (dwarf_srcfiles(die, &cu->srcfiles, &cu->nsrcfiles,
 522                             &de))
 523                                 warnx("dwarf_srcfiles: %s", dwarf_errmsg(de));
 524                 if (STAILQ_EMPTY(&cu->funclist)) {
 525                         collect_func(dbg, die, NULL, cu);
 526                         die = NULL;
 527                 }
 528                 f = search_func(cu, addr);
 529                 if (f != NULL)
 530                         funcname = f->name;
 531         }
 532
 533         if (print_addr) {
 534                 if ((ec = gelf_getclass(e)) == ELFCLASSNONE) {
 535                         warnx("gelf_getclass failed: %s", elf_errmsg(-1));
 536                         ec = ELFCLASS64;
 537                 }
 538                 if (ec == ELFCLASS32) {
 539                         if (pretty_print)
 540                                 printf("0x%08jx: ", (uintmax_t) addr);
 541                         else
 542                                 printf("0x%08jx\n", (uintmax_t) addr);
 543                 } else {
 544                         if (pretty_print)
 545                                 printf("0x%016jx: ", (uintmax_t) addr);
 546                         else
 547                                 printf("0x%016jx\n", (uintmax_t) addr);
 548                 }
 549         }
 550
 551         if (func) {
 552                 if (funcname == NULL)
 553                         funcname = unknown;
 554                 if (demangle && !elftc_demangle(funcname, demangled,
 555                     sizeof(demangled), 0)) {
 556                         if (pretty_print)
 557                                 printf("%s at ", demangled);
 558                         else
 559                                 printf("%s\n", demangled);
 560                 } else {
 561                         if (pretty_print)
 562                                 printf("%s at ", funcname);
 563                         else
 564                                 printf("%s\n", funcname);
 565                 }
 566         }
 567
 568         (void) printf("%s:%ju\n", base ? basename(file) : file,
 569             (uintmax_t) lineno);
 570
 571         if (ret == DW_DLV_OK && inlines && cu != NULL &&
 572             cu->srcfiles != NULL && f != NULL && f->inlined_caller != NULL)
 573                 print_inlines(cu, f->inlined_caller, f->call_file,
 574                     f->call_line);
 575
 576         if (die != NULL)
 577                 dwarf_dealloc(dbg, die, DW_DLA_DIE);
 578
 579         /*
 580          * Reset internal CU pointer, so we will start from the first CU
 581          * next round.
 582          */
 583         while (ret != DW_DLV_NO_ENTRY) {
 584                 if (ret == DW_DLV_ERROR)
 585                         errx(EXIT_FAILURE, "dwarf_next_cu_header: %s",
 586                             dwarf_errmsg(de));
 587                 ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
 588                     &de);
 589         }
 590 }
 591
 592 static void
 593 find_section_base(const char *exe, Elf *e, const char *section)
 594 {
 595         Dwarf_Addr off;
 596         Elf_Scn *scn;
 597         GElf_Ehdr eh;
 598         GElf_Shdr sh;
 599         size_t shstrndx;
 600         int elferr;
 601         const char *name;
 602
 603         if (gelf_getehdr(e, &eh) != &eh) {
 604                 warnx("gelf_getehdr failed: %s", elf_errmsg(-1));
 605                 return;
 606         }
 607
 608         if (!elf_getshstrndx(e, &shstrndx)) {
 609                 warnx("elf_getshstrndx failed: %s", elf_errmsg(-1));
 610                 return;
 611         }
 612
 613         (void) elf_errno();
 614         off = 0;
 615         scn = NULL;
 616         while ((scn = elf_nextscn(e, scn)) != NULL) {
 617                 if (gelf_getshdr(scn, &sh) == NULL) {
 618                         warnx("gelf_getshdr failed: %s", elf_errmsg(-1));
 619                         continue;
 620                 }
 621                 if ((name = elf_strptr(e, shstrndx, sh.sh_name)) == NULL)
 622                         goto next;
 623                 if (!strcmp(section, name)) {
 624                         if (eh.e_type == ET_EXEC || eh.e_type == ET_DYN) {
 625                                 /*
 626                                  * For executables, section base is the virtual
 627                                  * address of the specified section.
 628                                  */
 629                                 section_base = sh.sh_addr;
 630                         } else if (eh.e_type == ET_REL) {
 631                                 /*
 632                                  * For relocatables, section base is the
 633                                  * relative offset of the specified section
 634                                  * to the start of the first section.
 635                                  */
 636                                 section_base = off;
 637                         } else
 638                                 warnx("unknown e_type %u", eh.e_type);
 639                         return;
 640                 }
 641         next:
 642                 off += sh.sh_size;
 643         }
 644         elferr = elf_errno();
 645         if (elferr != 0)
 646                 warnx("elf_nextscn failed: %s", elf_errmsg(elferr));
 647
 648         errx(EXIT_FAILURE, "%s: cannot find section %s", exe, section);
 649 }
 650
 651 int
 652 main(int argc, char **argv)
 653 {
 654         cap_rights_t rights;
 655         Elf *e;
 656         Dwarf_Debug dbg;
 657         Dwarf_Error de;
 658         const char *exe, *section;
 659         char line[1024];
 660         int fd, i, opt;
 661
 662         exe = NULL;
 663         section = NULL;
 664         while ((opt = getopt_long(argc, argv, "ab:Ce:fij:psHV", longopts,
 665             NULL)) != -1) {
 666                 switch (opt) {
 667                 case 'a':
 668                         print_addr = 1;
 669                         break;
 670                 case 'b':
 671                         /* ignored */
 672                         break;
 673                 case 'C':
 674                         demangle = 1;
 675                         break;
 676                 case 'e':
 677                         exe = optarg;
 678                         break;
 679                 case 'f':
 680                         func = 1;
 681                         break;
 682                 case 'i':
 683                         inlines = 1;
 684                         break;
 685                 case 'j':
 686                         section = optarg;
 687                         break;
 688                 case 'p':
 689                         pretty_print = 1;
 690                         break;
 691                 case 's':
 692                         base = 1;
 693                         break;
 694                 case 'H':
 695                         usage();
 696                 case 'V':
 697                         version();
 698                 default:
 699                         usage();
 700                 }
 701         }
 702
 703         argv += optind;
 704         argc -= optind;
 705
 706         if (exe == NULL)
 707                 exe = "a.out";
 708
 709         if ((fd = open(exe, O_RDONLY)) < 0)
 710                 err(EXIT_FAILURE, "%s", exe);
 711
 712         if (caph_rights_limit(fd, cap_rights_init(&rights, CAP_FSTAT,
 713             CAP_MMAP_R)) < 0)
 714                 errx(EXIT_FAILURE, "caph_rights_limit");
 715
 716         caph_cache_catpages();
 717         if (caph_limit_stdio() < 0)
 718                 errx(EXIT_FAILURE, "failed to limit stdio rights");
 719         if (caph_enter() < 0)
 720                 errx(EXIT_FAILURE, "failed to enter capability mode");
 721
 722         if (dwarf_init(fd, DW_DLC_READ, NULL, NULL, &dbg, &de))
 723                 errx(EXIT_FAILURE, "dwarf_init: %s", dwarf_errmsg(de));
 724
 725         if (dwarf_get_elf(dbg, &e, &de) != DW_DLV_OK)
 726                 errx(EXIT_FAILURE, "dwarf_get_elf: %s", dwarf_errmsg(de));
 727
 728         if (section)
 729                 find_section_base(exe, e, section);
 730         else
 731                 section_base = 0;
 732
 733         if (argc > 0)
 734                 for (i = 0; i < argc; i++)
 735                         translate(dbg, e, argv[i]);
 736         else {
 737                 setvbuf(stdout, NULL, _IOLBF, 0);
 738                 while (fgets(line, sizeof(line), stdin) != NULL)
 739                         translate(dbg, e, line);
 740         }
 741
 742         dwarf_finish(dbg, &de);
 743
 744         (void) elf_end(e);
 745
 746         exit(0);
 747 }