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 #include <sys/tree.h>
  29
  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 <stdbool.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  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 range {
  60         RB_ENTRY(range) entry;
  61         Dwarf_Off off;
  62         Dwarf_Unsigned lopc;
  63         Dwarf_Unsigned hipc;
  64         char **srcfiles;
  65         Dwarf_Signed nsrcfiles;
  66         STAILQ_HEAD(, Func) funclist;
  67         Dwarf_Die die;
  68         Dwarf_Debug dbg;
  69 };
  70
  71 static struct option longopts[] = {
  72         {"addresses", no_argument, NULL, 'a'},
  73         {"target" , required_argument, NULL, 'b'},
  74         {"demangle", no_argument, NULL, 'C'},
  75         {"exe", required_argument, NULL, 'e'},
  76         {"functions", no_argument, NULL, 'f'},
  77         {"inlines", no_argument, NULL, 'i'},
  78         {"section", required_argument, NULL, 'j'},
  79         {"pretty-print", no_argument, NULL, 'p'},
  80         {"basename", no_argument, NULL, 's'},
  81         {"help", no_argument, NULL, 'H'},
  82         {"version", no_argument, NULL, 'V'},
  83         {NULL, 0, NULL, 0}
  84 };
  85
  86 static int demangle, func, base, inlines, print_addr, pretty_print;
  87 static char unknown[] = { '?', '?', '\0' };
  88 static Dwarf_Addr section_base;
  89 /* Need a new curlopc that stores last lopc value. */
  90 static Dwarf_Unsigned curlopc = ~0ULL;
  91 static RB_HEAD(cutree, range) cuhead = RB_INITIALIZER(&cuhead);
  92
  93 static int
  94 lopccmp(struct range *e1, struct range *e2)
  95 {
  96         return (e1->lopc < e2->lopc ? -1 : e1->lopc > e2->lopc);
  97 }
  98
  99 RB_PROTOTYPE(cutree, range, entry, lopccmp);
 100 RB_GENERATE(cutree, range, entry, lopccmp)
 101
 102 #define USAGE_MESSAGE   "\
 103 Usage: %s [options] hexaddress...\n\
 104   Map program addresses to source file names and line numbers.\n\n\
 105   Options:\n\
 106   -a      | --addresses       Display address prior to line number info.\n\
 107   -b TGT  | --target=TGT      (Accepted but ignored).\n\
 108   -e EXE  | --exe=EXE         Use program \"EXE\" to translate addresses.\n\
 109   -f      | --functions       Display function names.\n\
 110   -i      | --inlines         Display caller info for inlined functions.\n\
 111   -j NAME | --section=NAME    Values are offsets into section \"NAME\".\n\
 112   -p      | --pretty-print    Display line number info and function name\n\
 113                               in human readable manner.\n\
 114   -s      | --basename        Only show the base name for each file name.\n\
 115   -C      | --demangle        Demangle C++ names.\n\
 116   -H      | --help            Print a help message.\n\
 117   -V      | --version         Print a version identifier and exit.\n"
 118
 119 static void
 120 usage(void)
 121 {
 122         (void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());
 123         exit(1);
 124 }
 125
 126 static void
 127 version(void)
 128 {
 129
 130         fprintf(stderr, "%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
 131         exit(0);
 132 }
 133
 134 /*
 135  * Handle DWARF 4 'offset from' DW_AT_high_pc.  Although we don't
 136  * fully support DWARF 4, some compilers (like FreeBSD Clang 3.5.1)
 137  * generate DW_AT_high_pc as an offset from DW_AT_low_pc.
 138  *
 139  * "If the value of the DW_AT_high_pc is of class address, it is the
 140  * relocated address of the first location past the last instruction
 141  * associated with the entity; if it is of class constant, the value
 142  * is an unsigned integer offset which when added to the low PC gives
 143  * the address of the first location past the last instruction
 144  * associated with the entity."
 145  *
 146  * DWARF4 spec, section 2.17.2.
 147  */
 148 static int
 149 handle_high_pc(Dwarf_Die die, Dwarf_Unsigned lopc, Dwarf_Unsigned *hipc)
 150 {
 151         Dwarf_Error de;
 152         Dwarf_Half form;
 153         Dwarf_Attribute at;
 154         int ret;
 155
 156         ret = dwarf_attr(die, DW_AT_high_pc, &at, &de);
 157         if (ret == DW_DLV_ERROR) {
 158                 warnx("dwarf_attr failed: %s", dwarf_errmsg(de));
 159                 return (ret);
 160         }
 161         ret = dwarf_whatform(at, &form, &de);
 162         if (ret == DW_DLV_ERROR) {
 163                 warnx("dwarf_whatform failed: %s", dwarf_errmsg(de));
 164                 return (ret);
 165         }
 166         if (dwarf_get_form_class(2, 0, 0, form) == DW_FORM_CLASS_CONSTANT)
 167                 *hipc += lopc;
 168
 169         return (DW_DLV_OK);
 170 }
 171
 172 static struct Func *
 173 search_func(struct range *range, Dwarf_Unsigned addr)
 174 {
 175         struct Func *f, *f0;
 176         Dwarf_Unsigned lopc, hipc, addr_base;
 177         int i;
 178
 179         f0 = NULL;
 180
 181         STAILQ_FOREACH(f, &range->funclist, next) {
 182                 if (f->ranges != NULL) {
 183                         addr_base = 0;
 184                         for (i = 0; i < f->ranges_cnt; i++) {
 185                                 if (f->ranges[i].dwr_type == DW_RANGES_END)
 186                                         break;
 187                                 if (f->ranges[i].dwr_type ==
 188                                     DW_RANGES_ADDRESS_SELECTION) {
 189                                         addr_base = f->ranges[i].dwr_addr2;
 190                                         continue;
 191                                 }
 192
 193                                 /* DW_RANGES_ENTRY */
 194                                 lopc = f->ranges[i].dwr_addr1 + addr_base;
 195                                 hipc = f->ranges[i].dwr_addr2 + addr_base;
 196                                 if (addr >= lopc && addr < hipc) {
 197                                         if (f0 == NULL ||
 198                                             (lopc >= f0->lopc &&
 199                                             hipc <= f0->hipc)) {
 200                                                 f0 = f;
 201                                                 f0->lopc = lopc;
 202                                                 f0->hipc = hipc;
 203                                                 break;
 204                                         }
 205                                 }
 206                         }
 207                 } else if (addr >= f->lopc && addr < f->hipc) {
 208                         if (f0 == NULL ||
 209                             (f->lopc >= f0->lopc && f->hipc <= f0->hipc))
 210                                 f0 = f;
 211                 }
 212         }
 213
 214         return (f0);
 215 }
 216
 217 static void
 218 collect_func(Dwarf_Debug dbg, Dwarf_Die die, struct Func *parent,
 219     struct range *range)
 220 {
 221         Dwarf_Die ret_die, abst_die, spec_die;
 222         Dwarf_Error de;
 223         Dwarf_Half tag;
 224         Dwarf_Unsigned lopc, hipc, ranges_off;
 225         Dwarf_Signed ranges_cnt;
 226         Dwarf_Off ref;
 227         Dwarf_Attribute abst_at, spec_at;
 228         Dwarf_Ranges *ranges;
 229         const char *funcname;
 230         struct Func *f;
 231         int found_ranges, ret;
 232
 233         f = NULL;
 234         abst_die = spec_die = NULL;
 235
 236         if (dwarf_tag(die, &tag, &de)) {
 237                 warnx("dwarf_tag: %s", dwarf_errmsg(de));
 238                 goto cont_search;
 239         }
 240         if (tag == DW_TAG_subprogram || tag == DW_TAG_entry_point ||
 241             tag == DW_TAG_inlined_subroutine || tag == DW_TAG_label) {
 242                 /*
 243                  * Function address range can be specified by either
 244                  * a DW_AT_ranges attribute which points to a range list or
 245                  * by a pair of DW_AT_low_pc and DW_AT_high_pc attributes.
 246                  */
 247                 ranges = NULL;
 248                 ranges_cnt = 0;
 249                 found_ranges = 0;
 250                 if (dwarf_attrval_unsigned(die, DW_AT_ranges, &ranges_off,
 251                     &de) == DW_DLV_OK &&
 252                     dwarf_get_ranges(dbg, (Dwarf_Off) ranges_off, &ranges,
 253                     &ranges_cnt, NULL, &de) == DW_DLV_OK) {
 254                         if (ranges != NULL && ranges_cnt > 0) {
 255                                 found_ranges = 1;
 256                                 goto get_func_name;
 257                         }
 258                 }
 259
 260                 /*
 261                  * Ranges pointer not found.  Search for DW_AT_low_pc, and
 262                  * DW_AT_high_pc iff die is not a label.  Labels doesn't have
 263                  * hipc attr. */
 264                 if (tag == DW_TAG_label) {
 265                         if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc,
 266                             &de) != DW_DLV_OK)
 267                                 goto cont_search;
 268                 } else {
 269                         if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc,
 270                             &de) || dwarf_attrval_unsigned(die, DW_AT_high_pc,
 271                             &hipc, &de))
 272                                 goto cont_search;
 273                         if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
 274                                 goto cont_search;
 275                 }
 276
 277         get_func_name:
 278                 /*
 279                  * Most common case the function name is stored in DW_AT_name
 280                  * attribute.
 281                  */
 282                 if (dwarf_attrval_string(die, DW_AT_name, &funcname, &de) ==
 283                     DW_DLV_OK)
 284                         goto add_func;
 285
 286                 /*
 287                  * For inlined function, the actual name is probably in the DIE
 288                  * referenced by DW_AT_abstract_origin. (if present)
 289                  */
 290                 if (dwarf_attr(die, DW_AT_abstract_origin, &abst_at, &de) ==
 291                     DW_DLV_OK &&
 292                     dwarf_global_formref(abst_at, &ref, &de) == DW_DLV_OK &&
 293                     dwarf_offdie(dbg, ref, &abst_die, &de) == DW_DLV_OK &&
 294                     dwarf_attrval_string(abst_die, DW_AT_name, &funcname,
 295                     &de) == DW_DLV_OK)
 296                         goto add_func;
 297
 298                 /*
 299                  * If DW_AT_name is not present, but DW_AT_specification is
 300                  * present, then probably the actual name is in the DIE
 301                  * referenced by DW_AT_specification.
 302                  */
 303                 if (dwarf_attr(die, DW_AT_specification, &spec_at, &de) ==
 304                     DW_DLV_OK &&
 305                     dwarf_global_formref(spec_at, &ref, &de) == DW_DLV_OK &&
 306                     dwarf_offdie(dbg, ref, &spec_die, &de) == DW_DLV_OK &&
 307                     dwarf_attrval_string(spec_die, DW_AT_name, &funcname,
 308                     &de) == DW_DLV_OK)
 309                         goto add_func;
 310
 311                 /* Skip if no name associated with this DIE. */
 312                 goto cont_search;
 313
 314         add_func:
 315                 if ((f = calloc(1, sizeof(*f))) == NULL)
 316                         err(EXIT_FAILURE, "calloc");
 317                 if ((f->name = strdup(funcname)) == NULL)
 318                         err(EXIT_FAILURE, "strdup");
 319                 if (found_ranges) {
 320                         f->ranges = ranges;
 321                         f->ranges_cnt = ranges_cnt;
 322                 } else {
 323                         f->lopc = lopc;
 324                         f->hipc = hipc;
 325                 }
 326                 if (tag == DW_TAG_inlined_subroutine) {
 327                         f->inlined_caller = parent;
 328                         dwarf_attrval_unsigned(die, DW_AT_call_file,
 329                             &f->call_file, &de);
 330                         dwarf_attrval_unsigned(die, DW_AT_call_line,
 331                             &f->call_line, &de);
 332                 }
 333                 STAILQ_INSERT_TAIL(&range->funclist, f, next);
 334         }
 335
 336 cont_search:
 337
 338         /* Search children. */
 339         ret = dwarf_child(die, &ret_die, &de);
 340         if (ret == DW_DLV_ERROR)
 341                 warnx("dwarf_child: %s", dwarf_errmsg(de));
 342         else if (ret == DW_DLV_OK) {
 343                 if (f != NULL)
 344                         collect_func(dbg, ret_die, f, range);
 345                 else
 346                         collect_func(dbg, ret_die, parent, range);
 347         }
 348
 349         /* Search sibling. */
 350         ret = dwarf_siblingof(dbg, die, &ret_die, &de);
 351         if (ret == DW_DLV_ERROR)
 352                 warnx("dwarf_siblingof: %s", dwarf_errmsg(de));
 353         else if (ret == DW_DLV_OK)
 354                 collect_func(dbg, ret_die, parent, range);
 355
 356         /* Cleanup */
 357         if (die != range->die)
 358                 dwarf_dealloc(dbg, die, DW_DLA_DIE);
 359
 360         if (abst_die != NULL)
 361                 dwarf_dealloc(dbg, abst_die, DW_DLA_DIE);
 362
 363         if (spec_die != NULL)
 364                 dwarf_dealloc(dbg, spec_die, DW_DLA_DIE);
 365 }
 366
 367 static void
 368 print_inlines(struct range *range, struct Func *f, Dwarf_Unsigned call_file,
 369     Dwarf_Unsigned call_line)
 370 {
 371         char demangled[1024];
 372         char *file;
 373
 374         if (call_file > 0 && (Dwarf_Signed) call_file <= range->nsrcfiles)
 375                 file = range->srcfiles[call_file - 1];
 376         else
 377                 file = unknown;
 378
 379         if (pretty_print)
 380                 printf(" (inlined by) ");
 381
 382         if (func) {
 383                 if (demangle && !elftc_demangle(f->name, demangled,
 384                     sizeof(demangled), 0)) {
 385                         if (pretty_print)
 386                                 printf("%s at ", demangled);
 387                         else
 388                                 printf("%s\n", demangled);
 389                 } else {
 390                         if (pretty_print)
 391                                 printf("%s at ", f->name);
 392                         else
 393                                 printf("%s\n", f->name);
 394                 }
 395         }
 396         (void) printf("%s:%ju\n", base ? basename(file) : file,
 397             (uintmax_t) call_line);
 398
 399         if (f->inlined_caller != NULL)
 400                 print_inlines(range, f->inlined_caller, f->call_file,
 401                     f->call_line);
 402 }
 403
 404 static struct range *
 405 culookup(Dwarf_Unsigned addr)
 406 {
 407         struct range find, *res;
 408
 409         find.lopc = addr;
 410         res = RB_NFIND(cutree, &cuhead, &find);
 411         if (res != NULL) {
 412                 if (res->lopc != addr)
 413                         res = RB_PREV(cutree, &cuhead, res);
 414                 if (res != NULL && addr >= res->lopc && addr < res->hipc)
 415                         return (res);
 416         } else {
 417                 res = RB_MAX(cutree, &cuhead);
 418                 if (res != NULL && addr >= res->lopc && addr < res->hipc)
 419                         return (res);
 420         }
 421         return (NULL);
 422 }
 423
 424 /*
 425  * When DW_AT_ranges, DW_AT_low_pc/DW_AT_high_pc are all absent, we check the
 426  * children of cu die for labels.  If the address falls into one of the labels
 427  * ranges(aranges), return the label DIE.
 428  */
 429 static int
 430 check_labels(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Unsigned addr,
 431     struct range **range) {
 432         Dwarf_Addr start;
 433         Dwarf_Arange *aranges;
 434         Dwarf_Die prev_die, ret_die;
 435         Dwarf_Error de;
 436         Dwarf_Half tag;
 437         Dwarf_Off die_off;
 438         Dwarf_Unsigned lopc, length;
 439         Dwarf_Signed arcnt;
 440         struct range *labelp, **labels;
 441         int i, j, label_cnt, ret;
 442
 443         prev_die = ret_die = NULL;
 444         labels = NULL;
 445         i = label_cnt = 0;
 446
 447         /* Find aranges. */
 448         ret = dwarf_get_aranges(dbg, &aranges, &arcnt, &de);
 449         if (ret != DW_DLV_OK && ret != DW_DLV_NO_ENTRY)
 450                 warnx("dwarf_get_aranges failed: %s", dwarf_errmsg(de));
 451
 452         /* Child of current CU. */
 453         ret = dwarf_child(die, &prev_die, &de);
 454         if (ret == DW_DLV_ERROR)
 455                 warnx("dwarf_child: %s", dwarf_errmsg(de));
 456
 457         /* Count labels. */
 458         while (1) {
 459                 if (dwarf_tag(prev_die, &tag, &de) != DW_DLV_OK) {
 460                         warnx("dwarf_tag failed: %s",
 461                                 dwarf_errmsg(de));
 462                         return DW_DLV_ERROR;
 463                 }
 464                 if (tag == DW_TAG_label) {
 465                         if (dwarf_attrval_unsigned(prev_die, DW_AT_low_pc,
 466                             &lopc, &de) == DW_DLV_OK)
 467                                 label_cnt++;
 468                 }
 469
 470                 if (dwarf_siblingof(dbg, prev_die, &ret_die, &de) != DW_DLV_OK)
 471                         break;
 472
 473                 if (prev_die != NULL)
 474                         dwarf_dealloc(dbg, prev_die, DW_DLA_DIE);
 475                 prev_die = ret_die;
 476         }
 477
 478         if (label_cnt == 0)
 479                 return (DW_DLV_NO_ENTRY);
 480
 481         /* Allocate space for labels. */
 482         if ((labels = calloc(label_cnt, sizeof(struct range *))) == NULL)
 483                 err(EXIT_FAILURE, "calloc");
 484
 485         /* Add labels to list. */
 486         ret = dwarf_child(die, &prev_die, &de);
 487         if (ret == DW_DLV_ERROR)
 488                 warnx("dwarf_child: %s", dwarf_errmsg(de));
 489         while (1) {
 490                 if (dwarf_tag(prev_die, &tag, &de) != DW_DLV_OK) {
 491                         warnx("dwarf_tag failed: %s",
 492                                 dwarf_errmsg(de));
 493                         free(labels);
 494                         return DW_DLV_ERROR;
 495                 }
 496                 if (tag == DW_TAG_label) {
 497                         if (dwarf_attrval_unsigned(prev_die, DW_AT_low_pc,
 498                             &lopc, &de) == DW_DLV_OK) {
 499                                 if (curlopc == lopc) {
 500                                         for (i = 0; i < label_cnt - 1; i++) {
 501                                                 if (labels[i] != *range)
 502                                                         free(labels[i]);
 503                                         }
 504                                         free(labels);
 505                                         return DW_DLV_ERROR;
 506                                 }
 507                                 labelp = calloc(1, sizeof(struct range));
 508                                 if (labelp == NULL)
 509                                         err(EXIT_FAILURE, "calloc");
 510                                 labelp->lopc = lopc;
 511                                 labelp->die = prev_die;
 512                                 labelp->dbg = dbg;
 513                                 STAILQ_INIT(&labelp->funclist);
 514                                 labels[i++] = labelp;
 515                         }
 516                 }
 517                 if (dwarf_siblingof(dbg, prev_die, &ret_die, &de) != DW_DLV_OK)
 518                         break;
 519                 if (prev_die != NULL && tag != DW_TAG_label)
 520                         dwarf_dealloc(dbg, prev_die, DW_DLA_DIE);
 521                 prev_die = ret_die;
 522         }
 523
 524         /* Set hipc for each label using aranges */
 525         for (i = 0; i < label_cnt; i++) {
 526                 for (j = 0; j < arcnt; j++) {
 527                         if (dwarf_get_arange_info(aranges[j], &start, &length,
 528                             &die_off, &de) != DW_DLV_OK) {
 529                                 warnx("dwarf_get_arange_info failed: %s",
 530                                         dwarf_errmsg(de));
 531                                 continue;
 532                         }
 533                         if (labels[i]->lopc == (Dwarf_Unsigned)start) {
 534                                 labels[i]->hipc = start + length;
 535                                 break;
 536                         }
 537                 }
 538         }
 539
 540         /* If addr in label's range, we have found the range for this label. */
 541         for (i = 0; i < label_cnt; i++) {
 542                 if (addr >= labels[i]->lopc && addr < labels[i]->hipc) {
 543                         *range = labels[i];
 544                         RB_INSERT(cutree, &cuhead, (*range));
 545                         curlopc = (*range)->lopc;
 546                         break;
 547                 }
 548         }
 549
 550         for (i = 0; i < label_cnt - 1; i++) {
 551                 if (labels[i] != *range)
 552                         free(labels[i]);
 553         }
 554         free(labels);
 555
 556         if (*range != NULL)
 557                 return (DW_DLV_OK);
 558         else
 559                 return (DW_DLV_NO_ENTRY);
 560 }
 561
 562 /*
 563  * Check whether addr falls into range(s) of current CU.
 564  * If so, save current CU to lookup tree.
 565  */
 566 static int
 567 check_range(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Unsigned addr,
 568     struct range **range)
 569 {
 570         Dwarf_Error de;
 571         Dwarf_Unsigned addr_base, lopc, hipc;
 572         Dwarf_Off ranges_off;
 573         Dwarf_Signed ranges_cnt;
 574         Dwarf_Ranges *ranges;
 575         int i, ret;
 576         bool in_cu;
 577
 578         addr_base = 0;
 579         ranges = NULL;
 580         ranges_cnt = 0;
 581         in_cu = false;
 582
 583         if (dwarf_attrval_unsigned(die, DW_AT_ranges, &ranges_off, &de) ==
 584             DW_DLV_OK) {
 585                 ret = dwarf_get_ranges(dbg, ranges_off, &ranges,
 586                         &ranges_cnt, NULL, &de);
 587                 if (ret != DW_DLV_OK)
 588                         return (ret);
 589
 590                 if (!ranges || ranges_cnt <= 0)
 591                         return (DW_DLV_ERROR);
 592
 593                 for (i = 0; i < ranges_cnt; i++) {
 594                         if (ranges[i].dwr_type == DW_RANGES_END)
 595                                 return (DW_DLV_NO_ENTRY);
 596
 597                         if (ranges[i].dwr_type ==
 598                                 DW_RANGES_ADDRESS_SELECTION) {
 599                                 addr_base = ranges[i].dwr_addr2;
 600                                 continue;
 601                         }
 602
 603                         /* DW_RANGES_ENTRY */
 604                         lopc = ranges[i].dwr_addr1 + addr_base;
 605                         hipc = ranges[i].dwr_addr2 + addr_base;
 606
 607                         if (lopc == curlopc)
 608                                 return (DW_DLV_ERROR);
 609
 610                         if (addr >= lopc && addr < hipc){
 611                                 in_cu = true;
 612                                 break;
 613                         }
 614                 }
 615         } else if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) ==
 616             DW_DLV_OK) {
 617                 if (lopc == curlopc)
 618                         return (DW_DLV_ERROR);
 619                 if (dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de) ==
 620                     DW_DLV_OK) {
 621                         /*
 622                          * Check if the address falls into the PC
 623                          * range of this CU.
 624                          */
 625                         if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
 626                                 return (DW_DLV_ERROR);
 627                 } else {
 628                         /* Assume ~0ULL if DW_AT_high_pc not present. */
 629                         hipc = ~0ULL;
 630                 }
 631
 632                 if (addr >= lopc && addr < hipc) {
 633                         in_cu = true;
 634                 }
 635         } else {
 636                 /* Addr not found above, try labels. */
 637                 ret = check_labels(dbg, die, addr, range);
 638                 return ret;
 639         }
 640
 641         if (in_cu) {
 642                 if ((*range = calloc(1, sizeof(struct range))) == NULL)
 643                         err(EXIT_FAILURE, "calloc");
 644                 (*range)->lopc = lopc;
 645                 (*range)->hipc = hipc;
 646                 (*range)->die = die;
 647                 (*range)->dbg = dbg;
 648                 STAILQ_INIT(&(*range)->funclist);
 649                 RB_INSERT(cutree, &cuhead, *range);
 650                 curlopc = lopc;
 651                 return (DW_DLV_OK);
 652         } else {
 653                 return (DW_DLV_NO_ENTRY);
 654         }
 655 }
 656
 657 static void
 658 translate(Dwarf_Debug dbg, Elf *e, const char* addrstr)
 659 {
 660         Dwarf_Die die, ret_die;
 661         Dwarf_Line *lbuf;
 662         Dwarf_Error de;
 663         Dwarf_Half tag;
 664         Dwarf_Unsigned addr, lineno, plineno;
 665         Dwarf_Signed lcount;
 666         Dwarf_Addr lineaddr, plineaddr;
 667         struct range *range;
 668         struct Func *f;
 669         const char *funcname;
 670         char *file, *file0, *pfile;
 671         char demangled[1024];
 672         int ec, i, ret;
 673
 674         addr = strtoull(addrstr, NULL, 16);
 675         addr += section_base;
 676         lineno = 0;
 677         file = unknown;
 678         die = NULL;
 679         ret = DW_DLV_OK;
 680
 681         range = culookup(addr);
 682         if (range != NULL) {
 683                 die = range->die;
 684                 dbg = range->dbg;
 685                 goto status_ok;
 686         }
 687
 688         while (true) {
 689                 /*
 690                  * We resume the CU scan from the last place we found a match.
 691                  * Because when we have 2 sequential addresses, and the second
 692                  * one is of the next CU, it is faster to just go to the next CU
 693                  * instead of starting from the beginning.
 694                  */
 695                 ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
 696                     &de);
 697                 if (ret == DW_DLV_NO_ENTRY) {
 698                         if (curlopc == ~0ULL)
 699                                 goto out;
 700                         ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL,
 701                             NULL, &de);
 702                 }
 703                 die = NULL;
 704                 while (dwarf_siblingof(dbg, die, &ret_die, &de) == DW_DLV_OK) {
 705                         if (die != NULL)
 706                                 dwarf_dealloc(dbg, die, DW_DLA_DIE);
 707                         die = ret_die;
 708                         if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
 709                                 warnx("dwarf_tag failed: %s",
 710                                     dwarf_errmsg(de));
 711                                 goto next_cu;
 712                         }
 713
 714                         /* XXX: What about DW_TAG_partial_unit? */
 715                         if (tag == DW_TAG_compile_unit)
 716                                 break;
 717                 }
 718
 719                 if (ret_die == NULL) {
 720                         warnx("could not find DW_TAG_compile_unit die");
 721                         goto next_cu;
 722                 }
 723                 ret = check_range(dbg, die, addr, &range);
 724                 if (ret == DW_DLV_OK)
 725                         break;
 726                 if (ret == DW_DLV_ERROR)
 727                         goto out;
 728 next_cu:
 729                 if (die != NULL) {
 730                         dwarf_dealloc(dbg, die, DW_DLA_DIE);
 731                         die = NULL;
 732                 }
 733         }
 734
 735         if (ret != DW_DLV_OK || die == NULL)
 736                 goto out;
 737
 738 status_ok:
 739         switch (dwarf_srclines(die, &lbuf, &lcount, &de)) {
 740         case DW_DLV_OK:
 741                 break;
 742         case DW_DLV_NO_ENTRY:
 743                 /* If a CU lacks debug info, just skip it. */
 744                 goto out;
 745         default:
 746                 warnx("dwarf_srclines: %s", dwarf_errmsg(de));
 747                 goto out;
 748         }
 749
 750         plineaddr = ~0ULL;
 751         plineno = 0;
 752         pfile = unknown;
 753         for (i = 0; i < lcount; i++) {
 754                 if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) {
 755                         warnx("dwarf_lineaddr: %s", dwarf_errmsg(de));
 756                         goto out;
 757                 }
 758                 if (dwarf_lineno(lbuf[i], &lineno, &de)) {
 759                         warnx("dwarf_lineno: %s", dwarf_errmsg(de));
 760                         goto out;
 761                 }
 762                 if (dwarf_linesrc(lbuf[i], &file0, &de)) {
 763                         warnx("dwarf_linesrc: %s", dwarf_errmsg(de));
 764                 } else
 765                         file = file0;
 766                 if (addr == lineaddr)
 767                         goto out;
 768                 else if (addr < lineaddr && addr > plineaddr) {
 769                         lineno = plineno;
 770                         file = pfile;
 771                         goto out;
 772                 }
 773                 plineaddr = lineaddr;
 774                 plineno = lineno;
 775                 pfile = file;
 776         }
 777
 778 out:
 779         f = NULL;
 780         funcname = NULL;
 781         if (ret == DW_DLV_OK && (func || inlines) && range != NULL) {
 782                 if (range->srcfiles == NULL)
 783                         if (dwarf_srcfiles(die, &range->srcfiles,
 784                             &range->nsrcfiles, &de))
 785                                 warnx("dwarf_srcfiles: %s", dwarf_errmsg(de));
 786                 if (STAILQ_EMPTY(&range->funclist)) {
 787                         collect_func(dbg, range->die, NULL, range);
 788                         die = NULL;
 789                 }
 790                 f = search_func(range, addr);
 791                 if (f != NULL)
 792                         funcname = f->name;
 793         }
 794
 795         if (print_addr) {
 796                 if ((ec = gelf_getclass(e)) == ELFCLASSNONE) {
 797                         warnx("gelf_getclass failed: %s", elf_errmsg(-1));
 798                         ec = ELFCLASS64;
 799                 }
 800                 if (ec == ELFCLASS32) {
 801                         if (pretty_print)
 802                                 printf("0x%08jx: ", (uintmax_t) addr);
 803                         else
 804                                 printf("0x%08jx\n", (uintmax_t) addr);
 805                 } else {
 806                         if (pretty_print)
 807                                 printf("0x%016jx: ", (uintmax_t) addr);
 808                         else
 809                                 printf("0x%016jx\n", (uintmax_t) addr);
 810                 }
 811         }
 812
 813         if (func) {
 814                 if (funcname == NULL)
 815                         funcname = unknown;
 816                 if (demangle && !elftc_demangle(funcname, demangled,
 817                     sizeof(demangled), 0)) {
 818                         if (pretty_print)
 819                                 printf("%s at ", demangled);
 820                         else
 821                                 printf("%s\n", demangled);
 822                 } else {
 823                         if (pretty_print)
 824                                 printf("%s at ", funcname);
 825                         else
 826                                 printf("%s\n", funcname);
 827                 }
 828         }
 829
 830         (void) printf("%s:%ju\n", base ? basename(file) : file,
 831             (uintmax_t) lineno);
 832
 833         if (ret == DW_DLV_OK && inlines && range != NULL &&
 834             range->srcfiles != NULL && f != NULL && f->inlined_caller != NULL)
 835                 print_inlines(range, f->inlined_caller, f->call_file,
 836                     f->call_line);
 837 }
 838
 839 static void
 840 find_section_base(const char *exe, Elf *e, const char *section)
 841 {
 842         Dwarf_Addr off;
 843         Elf_Scn *scn;
 844         GElf_Ehdr eh;
 845         GElf_Shdr sh;
 846         size_t shstrndx;
 847         int elferr;
 848         const char *name;
 849
 850         if (gelf_getehdr(e, &eh) != &eh) {
 851                 warnx("gelf_getehdr failed: %s", elf_errmsg(-1));
 852                 return;
 853         }
 854
 855         if (!elf_getshstrndx(e, &shstrndx)) {
 856                 warnx("elf_getshstrndx failed: %s", elf_errmsg(-1));
 857                 return;
 858         }
 859
 860         (void) elf_errno();
 861         off = 0;
 862         scn = NULL;
 863         while ((scn = elf_nextscn(e, scn)) != NULL) {
 864                 if (gelf_getshdr(scn, &sh) == NULL) {
 865                         warnx("gelf_getshdr failed: %s", elf_errmsg(-1));
 866                         continue;
 867                 }
 868                 if ((name = elf_strptr(e, shstrndx, sh.sh_name)) == NULL)
 869                         goto next;
 870                 if (!strcmp(section, name)) {
 871                         if (eh.e_type == ET_EXEC || eh.e_type == ET_DYN) {
 872                                 /*
 873                                  * For executables, section base is the virtual
 874                                  * address of the specified section.
 875                                  */
 876                                 section_base = sh.sh_addr;
 877                         } else if (eh.e_type == ET_REL) {
 878                                 /*
 879                                  * For relocatables, section base is the
 880                                  * relative offset of the specified section
 881                                  * to the start of the first section.
 882                                  */
 883                                 section_base = off;
 884                         } else
 885                                 warnx("unknown e_type %u", eh.e_type);
 886                         return;
 887                 }
 888         next:
 889                 off += sh.sh_size;
 890         }
 891         elferr = elf_errno();
 892         if (elferr != 0)
 893                 warnx("elf_nextscn failed: %s", elf_errmsg(elferr));
 894
 895         errx(EXIT_FAILURE, "%s: cannot find section %s", exe, section);
 896 }
 897
 898 int
 899 main(int argc, char **argv)
 900 {
 901         Elf *e;
 902         Dwarf_Debug dbg;
 903         Dwarf_Error de;
 904         const char *exe, *section;
 905         char line[1024];
 906         int fd, i, opt;
 907
 908         exe = NULL;
 909         section = NULL;
 910         while ((opt = getopt_long(argc, argv, "ab:Ce:fij:psHV", longopts,
 911             NULL)) != -1) {
 912                 switch (opt) {
 913                 case 'a':
 914                         print_addr = 1;
 915                         break;
 916                 case 'b':
 917                         /* ignored */
 918                         break;
 919                 case 'C':
 920                         demangle = 1;
 921                         break;
 922                 case 'e':
 923                         exe = optarg;
 924                         break;
 925                 case 'f':
 926                         func = 1;
 927                         break;
 928                 case 'i':
 929                         inlines = 1;
 930                         break;
 931                 case 'j':
 932                         section = optarg;
 933                         break;
 934                 case 'p':
 935                         pretty_print = 1;
 936                         break;
 937                 case 's':
 938                         base = 1;
 939                         break;
 940                 case 'H':
 941                         usage();
 942                 case 'V':
 943                         version();
 944                 default:
 945                         usage();
 946                 }
 947         }
 948
 949         argv += optind;
 950         argc -= optind;
 951
 952         if (exe == NULL)
 953                 exe = "a.out";
 954
 955         if ((fd = open(exe, O_RDONLY)) < 0)
 956                 err(EXIT_FAILURE, "%s", exe);
 957
 958         if (dwarf_init(fd, DW_DLC_READ, NULL, NULL, &dbg, &de))
 959                 errx(EXIT_FAILURE, "dwarf_init: %s", dwarf_errmsg(de));
 960
 961         if (dwarf_get_elf(dbg, &e, &de) != DW_DLV_OK)
 962                 errx(EXIT_FAILURE, "dwarf_get_elf: %s", dwarf_errmsg(de));
 963
 964         if (section)
 965                 find_section_base(exe, e, section);
 966         else
 967                 section_base = 0;
 968
 969         if (argc > 0)
 970                 for (i = 0; i < argc; i++)
 971                         translate(dbg, e, argv[i]);
 972         else {
 973                 setvbuf(stdout, NULL, _IOLBF, 0);
 974                 while (fgets(line, sizeof(line), stdin) != NULL)
 975                         translate(dbg, e, line);
 976         }
 977
 978         dwarf_finish(dbg, &de);
 979
 980         (void) elf_end(e);
 981
 982         exit(0);
 983 }