addr2line.c revision 282918 
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 <dwarf.h>
29#include <err.h>
30#include <fcntl.h>
31#include <gelf.h>
32#include <getopt.h>
33#include <libdwarf.h>
34#include <libelftc.h>
35#include <libgen.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39
40#include "_elftc.h"
41
42ELFTC_VCSID("$Id: addr2line.c 3197 2015-05-12 21:01:31Z emaste $");
43
44static struct option longopts[] = {
45	{"target" , required_argument, NULL, 'b'},
46	{"demangle", no_argument, NULL, 'C'},
47	{"exe", required_argument, NULL, 'e'},
48	{"functions", no_argument, NULL, 'f'},
49	{"section", required_argument, NULL, 'j'},
50	{"basename", no_argument, NULL, 's'},
51	{"help", no_argument, NULL, 'H'},
52	{"version", no_argument, NULL, 'V'},
53	{NULL, 0, NULL, 0}
54};
55static int demangle, func, base;
56static char unknown[] = { '?', '?', '\0' };
57static Dwarf_Addr section_base;
58
59#define	USAGE_MESSAGE	"\
60Usage: %s [options] hexaddress...\n\
61  Map program addresses to source file names and line numbers.\n\n\
62  Options:\n\
63  -b TGT  | --target=TGT      (Accepted but ignored).\n\
64  -e EXE  | --exec=EXE        Use program \"EXE\" to translate addresses.\n\
65  -f      | --functions       Display function names.\n\
66  -j NAME | --section=NAME    Values are offsets into section \"NAME\".\n\
67  -s      | --basename        Only show the base name for each file name.\n\
68  -C      | --demangle        Demangle C++ names.\n\
69  -H      | --help            Print a help message.\n\
70  -V      | --version         Print a version identifier and exit.\n"
71
72static void
73usage(void)
74{
75	(void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());
76	exit(1);
77}
78
79static void
80version(void)
81{
82
83	fprintf(stderr, "%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
84	exit(0);
85}
86
87/*
88 * Handle DWARF 4 'offset from' DW_AT_high_pc.  Although we don't
89 * fully support DWARF 4, some compilers (like FreeBSD Clang 3.5.1)
90 * generate DW_AT_high_pc as an offset from DW_AT_low_pc.
91 *
92 * "If the value of the DW_AT_high_pc is of class address, it is the
93 * relocated address of the first location past the last instruction
94 * associated with the entity; if it is of class constant, the value
95 * is an unsigned integer offset which when added to the low PC gives
96 * the address of the first location past the last instruction
97 * associated with the entity."
98 *
99 * DWARF4 spec, section 2.17.2.
100 */
101static int
102handle_high_pc(Dwarf_Die die, Dwarf_Unsigned lopc, Dwarf_Unsigned *hipc)
103{
104	Dwarf_Error de;
105	Dwarf_Half form;
106	Dwarf_Attribute at;
107	int ret;
108
109	ret = dwarf_attr(die, DW_AT_high_pc, &at, &de);
110	if (ret == DW_DLV_ERROR) {
111		warnx("dwarf_attr failed: %s", dwarf_errmsg(de));
112		return (ret);
113	}
114	ret = dwarf_whatform(at, &form, &de);
115	if (ret == DW_DLV_ERROR) {
116		warnx("dwarf_whatform failed: %s", dwarf_errmsg(de));
117		return (ret);
118	}
119	if (dwarf_get_form_class(2, 0, 0, form) == DW_FORM_CLASS_CONSTANT)
120		*hipc += lopc;
121
122	return (DW_DLV_OK);
123}
124
125static void
126search_func(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Addr addr,
127    const char **rlt_func)
128{
129	Dwarf_Die ret_die, spec_die;
130	Dwarf_Error de;
131	Dwarf_Half tag;
132	Dwarf_Unsigned lopc, hipc;
133	Dwarf_Off ref;
134	Dwarf_Attribute sub_at, spec_at;
135	char *func0;
136	int ret;
137
138	if (*rlt_func != NULL)
139		return;
140
141	if (dwarf_tag(die, &tag, &de)) {
142		warnx("dwarf_tag: %s", dwarf_errmsg(de));
143		goto cont_search;
144	}
145	if (tag == DW_TAG_subprogram) {
146		if (dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) ||
147		    dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de))
148			goto cont_search;
149		if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
150			goto cont_search;
151		if (addr < lopc || addr >= hipc)
152			goto cont_search;
153
154		/* Found it! */
155
156		*rlt_func = unknown;
157		ret = dwarf_attr(die, DW_AT_name, &sub_at, &de);
158		if (ret == DW_DLV_ERROR)
159			return;
160		if (ret == DW_DLV_OK) {
161			if (dwarf_formstring(sub_at, &func0, &de))
162				*rlt_func = unknown;
163			else
164				*rlt_func = func0;
165			return;
166		}
167
168		/*
169		 * If DW_AT_name is not present, but DW_AT_specification is
170		 * present, then probably the actual name is in the DIE
171		 * referenced by DW_AT_specification.
172		 */
173		if (dwarf_attr(die, DW_AT_specification, &spec_at, &de))
174			return;
175		if (dwarf_global_formref(spec_at, &ref, &de))
176			return;
177		if (dwarf_offdie(dbg, ref, &spec_die, &de))
178			return;
179		if (dwarf_attrval_string(spec_die, DW_AT_name, rlt_func, &de))
180			*rlt_func = unknown;
181
182		return;
183	}
184
185cont_search:
186
187	/* Search children. */
188	ret = dwarf_child(die, &ret_die, &de);
189	if (ret == DW_DLV_ERROR)
190		errx(EXIT_FAILURE, "dwarf_child: %s", dwarf_errmsg(de));
191	else if (ret == DW_DLV_OK)
192		search_func(dbg, ret_die, addr, rlt_func);
193
194	/* Search sibling. */
195	ret = dwarf_siblingof(dbg, die, &ret_die, &de);
196	if (ret == DW_DLV_ERROR)
197		errx(EXIT_FAILURE, "dwarf_siblingof: %s", dwarf_errmsg(de));
198	else if (ret == DW_DLV_OK)
199		search_func(dbg, ret_die, addr, rlt_func);
200}
201
202static void
203translate(Dwarf_Debug dbg, const char* addrstr)
204{
205	Dwarf_Die die;
206	Dwarf_Line *lbuf;
207	Dwarf_Error de;
208	Dwarf_Half tag;
209	Dwarf_Unsigned lopc, hipc, addr, lineno, plineno;
210	Dwarf_Signed lcount;
211	Dwarf_Addr lineaddr, plineaddr;
212	const char *funcname;
213	char *file, *file0, *pfile;
214	char demangled[1024];
215	int i, ret;
216
217	addr = strtoull(addrstr, NULL, 16);
218	addr += section_base;
219	lineno = 0;
220	file = unknown;
221
222	while ((ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
223	    &de)) ==  DW_DLV_OK) {
224		die = NULL;
225		while (dwarf_siblingof(dbg, die, &die, &de) == DW_DLV_OK) {
226			if (dwarf_tag(die, &tag, &de) != DW_DLV_OK) {
227				warnx("dwarf_tag failed: %s",
228				    dwarf_errmsg(de));
229				goto out;
230			}
231			/* XXX: What about DW_TAG_partial_unit? */
232			if (tag == DW_TAG_compile_unit)
233				break;
234		}
235		if (die == NULL) {
236			warnx("could not find DW_TAG_compile_unit die");
237			goto out;
238		}
239		if (!dwarf_attrval_unsigned(die, DW_AT_low_pc, &lopc, &de) &&
240		    !dwarf_attrval_unsigned(die, DW_AT_high_pc, &hipc, &de)) {
241			/*
242			 * Check if the address falls into the PC range of
243			 * this CU.
244			 */
245			if (handle_high_pc(die, lopc, &hipc) != DW_DLV_OK)
246				continue;
247			if (addr < lopc || addr >= hipc)
248				continue;
249		}
250
251		if (dwarf_srclines(die, &lbuf, &lcount, &de) != DW_DLV_OK) {
252			warnx("dwarf_srclines: %s", dwarf_errmsg(de));
253			goto out;
254		}
255
256		plineaddr = ~0ULL;
257		plineno = 0;
258		pfile = unknown;
259		for (i = 0; i < lcount; i++) {
260			if (dwarf_lineaddr(lbuf[i], &lineaddr, &de)) {
261				warnx("dwarf_lineaddr: %s",
262				    dwarf_errmsg(de));
263				goto out;
264			}
265			if (dwarf_lineno(lbuf[i], &lineno, &de)) {
266				warnx("dwarf_lineno: %s",
267				    dwarf_errmsg(de));
268				goto out;
269			}
270			if (dwarf_linesrc(lbuf[i], &file0, &de)) {
271				warnx("dwarf_linesrc: %s",
272				    dwarf_errmsg(de));
273			} else
274				file = file0;
275			if (addr == lineaddr)
276				goto out;
277			else if (addr < lineaddr && addr > plineaddr) {
278				lineno = plineno;
279				file = pfile;
280				goto out;
281			}
282			plineaddr = lineaddr;
283			plineno = lineno;
284			pfile = file;
285		}
286	}
287
288out:
289	funcname = NULL;
290	if (ret == DW_DLV_OK && func)
291		search_func(dbg, die, addr, &funcname);
292
293	if (func) {
294		if (funcname == NULL)
295			funcname = unknown;
296		if (demangle &&
297		    !elftc_demangle(funcname, demangled, sizeof(demangled), 0))
298			printf("%s\n", demangled);
299		else
300			printf("%s\n", funcname);
301	}
302
303	(void) printf("%s:%ju\n", base ? basename(file) : file, lineno);
304
305	/*
306	 * Reset internal CU pointer, so we will start from the first CU
307	 * next round.
308	 */
309	while (ret != DW_DLV_NO_ENTRY) {
310		if (ret == DW_DLV_ERROR)
311			errx(EXIT_FAILURE, "dwarf_next_cu_header: %s",
312			    dwarf_errmsg(de));
313		ret = dwarf_next_cu_header(dbg, NULL, NULL, NULL, NULL, NULL,
314		    &de);
315	}
316}
317
318static void
319find_section_base(const char *exe, Elf *e, const char *section)
320{
321	Dwarf_Addr off;
322	Elf_Scn *scn;
323	GElf_Ehdr eh;
324	GElf_Shdr sh;
325	size_t shstrndx;
326	int elferr;
327	const char *name;
328
329	if (gelf_getehdr(e, &eh) != &eh) {
330		warnx("gelf_getehdr failed: %s", elf_errmsg(-1));
331		return;
332	}
333
334	if (!elf_getshstrndx(e, &shstrndx)) {
335		warnx("elf_getshstrndx failed: %s", elf_errmsg(-1));
336		return;
337	}
338
339	(void) elf_errno();
340	off = 0;
341	scn = NULL;
342	while ((scn = elf_nextscn(e, scn)) != NULL) {
343		if (gelf_getshdr(scn, &sh) == NULL) {
344			warnx("gelf_getshdr failed: %s", elf_errmsg(-1));
345			continue;
346		}
347		if ((name = elf_strptr(e, shstrndx, sh.sh_name)) == NULL)
348			goto next;
349		if (!strcmp(section, name)) {
350			if (eh.e_type == ET_EXEC || eh.e_type == ET_DYN) {
351				/*
352				 * For executables, section base is the virtual
353				 * address of the specified section.
354				 */
355				section_base = sh.sh_addr;
356			} else if (eh.e_type == ET_REL) {
357				/*
358				 * For relocatables, section base is the
359				 * relative offset of the specified section
360				 * to the start of the first section.
361				 */
362				section_base = off;
363			} else
364				warnx("unknown e_type %u", eh.e_type);
365			return;
366		}
367	next:
368		off += sh.sh_size;
369	}
370	elferr = elf_errno();
371	if (elferr != 0)
372		warnx("elf_nextscn failed: %s", elf_errmsg(elferr));
373
374	errx(EXIT_FAILURE, "%s: cannot find section %s", exe, section);
375}
376
377int
378main(int argc, char **argv)
379{
380	Elf *e;
381	Dwarf_Debug dbg;
382	Dwarf_Error de;
383	const char *exe, *section;
384	char line[1024];
385	int fd, i, opt;
386
387	exe = NULL;
388	section = NULL;
389	while ((opt = getopt_long(argc, argv, "b:Ce:fj:sHV", longopts, NULL)) !=
390	    -1) {
391		switch (opt) {
392		case 'b':
393			/* ignored */
394			break;
395		case 'C':
396			demangle = 1;
397			break;
398		case 'e':
399			exe = optarg;
400			break;
401		case 'f':
402			func = 1;
403			break;
404		case 'j':
405			section = optarg;
406			break;
407		case 's':
408			base = 1;
409			break;
410		case 'H':
411			usage();
412		case 'V':
413			version();
414		default:
415			usage();
416		}
417	}
418
419	argv += optind;
420	argc -= optind;
421
422	if (exe == NULL)
423		exe = "a.out";
424
425	if ((fd = open(exe, O_RDONLY)) < 0)
426		err(EXIT_FAILURE, "%s", exe);
427
428	if (dwarf_init(fd, DW_DLC_READ, NULL, NULL, &dbg, &de))
429		errx(EXIT_FAILURE, "dwarf_init: %s", dwarf_errmsg(de));
430
431	if (dwarf_get_elf(dbg, &e, &de) != DW_DLV_OK)
432		errx(EXIT_FAILURE, "dwarf_get_elf: %s", dwarf_errmsg(de));
433
434	if (section)
435		find_section_base(exe, e, section);
436	else
437		section_base = 0;
438
439	if (argc > 0)
440		for (i = 0; i < argc; i++)
441			translate(dbg, argv[i]);
442	else
443		while (fgets(line, sizeof(line), stdin) != NULL) {
444			translate(dbg, line);
445			fflush(stdout);
446		}
447
448	dwarf_finish(dbg, &de);
449
450	(void) elf_end(e);
451
452	exit(0);
453}
454