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