Commit | Line | Data |
---|---|---|
9d04d618 TT |
1 | /* addr2line.c -- convert addresses to line number and function name |
2 | Copyright 1997, 1998 Free Software Foundation, Inc. | |
3 | Contributed by Ulrich Lauther <Ulrich.Lauther@zfe.siemens.de> | |
4 | ||
5 | This file is part of GNU Binutils. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2, or (at your option) | |
10 | any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | /* Derived from objdump.c and nm.c by Ulrich.Lauther@zfe.siemens.de | |
22 | ||
23 | Usage: | |
24 | addr2line [options] addr addr ... | |
25 | or | |
26 | addr2line [options] | |
27 | ||
28 | both forms write results to stdout, the second form reads addresses | |
29 | to be converted from stdin. */ | |
30 | ||
31 | #include <ctype.h> | |
32 | #include <string.h> | |
33 | ||
34 | #include "bfd.h" | |
35 | #include "getopt.h" | |
36 | #include "libiberty.h" | |
37 | #include "demangle.h" | |
38 | #include "bucomm.h" | |
39 | ||
40 | extern char *program_version; | |
41 | ||
42 | static boolean with_functions; /* -f, show function names. */ | |
43 | static boolean do_demangle; /* -C, demangle names. */ | |
44 | static boolean base_names; /* -s, strip directory names. */ | |
45 | ||
46 | static int naddr; /* Number of addresses to process. */ | |
47 | static char **addr; /* Hex addresses to process. */ | |
48 | ||
49 | static asymbol **syms; /* Symbol table. */ | |
50 | ||
51 | static struct option long_options[] = | |
52 | { | |
53 | {"basenames", no_argument, NULL, 's'}, | |
54 | {"demangle", no_argument, NULL, 'C'}, | |
55 | {"exe", required_argument, NULL, 'e'}, | |
56 | {"functions", no_argument, NULL, 'f'}, | |
57 | {"target", required_argument, NULL, 'b'}, | |
58 | {"help", no_argument, NULL, 'H'}, | |
59 | {"version", no_argument, NULL, 'V'}, | |
60 | {0, no_argument, 0, 0} | |
61 | }; | |
62 | ||
63 | static void usage PARAMS ((FILE *, int)); | |
64 | static void slurp_symtab PARAMS ((bfd *)); | |
65 | static void find_address_in_section PARAMS ((bfd *, asection *, PTR)); | |
66 | static void translate_addresses PARAMS ((bfd *)); | |
67 | static void process_file PARAMS ((const char *, const char *)); | |
68 | \f | |
69 | /* Print a usage message to STREAM and exit with STATUS. */ | |
70 | ||
71 | static void | |
72 | usage (stream, status) | |
73 | FILE *stream; | |
74 | int status; | |
75 | { | |
76 | fprintf (stream, _("\ | |
77 | Usage: %s [-CfsHV] [-b bfdname] [--target=bfdname]\n\ | |
78 | [-e executable] [--exe=executable] [--demangle]\n\ | |
79 | [--basenames] [--functions] [addr addr ...]\n"), | |
80 | program_name); | |
81 | list_supported_targets (program_name, stream); | |
82 | if (status == 0) | |
83 | fprintf (stream, _("Report bugs to bug-gnu-utils@gnu.org\n")); | |
84 | exit (status); | |
85 | } | |
86 | \f | |
87 | /* Read in the symbol table. */ | |
88 | ||
89 | static void | |
90 | slurp_symtab (abfd) | |
91 | bfd *abfd; | |
92 | { | |
93 | long storage; | |
94 | long symcount; | |
95 | ||
96 | if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0) | |
97 | return; | |
98 | ||
99 | storage = bfd_get_symtab_upper_bound (abfd); | |
100 | if (storage < 0) | |
101 | bfd_fatal (bfd_get_filename (abfd)); | |
102 | ||
103 | syms = (asymbol **) xmalloc (storage); | |
104 | ||
105 | symcount = bfd_canonicalize_symtab (abfd, syms); | |
106 | if (symcount < 0) | |
107 | bfd_fatal (bfd_get_filename (abfd)); | |
108 | } | |
109 | \f | |
110 | /* These global variables are used to pass information between | |
111 | translate_addresses and find_address_in_section. */ | |
112 | ||
113 | static bfd_vma pc; | |
114 | static const char *filename; | |
115 | static const char *functionname; | |
116 | static unsigned int line; | |
117 | static boolean found; | |
118 | ||
119 | /* Look for an address in a section. This is called via | |
120 | bfd_map_over_sections. */ | |
121 | ||
122 | static void | |
123 | find_address_in_section (abfd, section, data) | |
124 | bfd *abfd; | |
125 | asection *section; | |
126 | PTR data; | |
127 | { | |
128 | bfd_vma vma; | |
129 | ||
130 | if (found) | |
131 | return; | |
132 | ||
133 | if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0) | |
134 | return; | |
135 | ||
136 | vma = bfd_get_section_vma (abfd, section); | |
137 | if (pc < vma) | |
138 | return; | |
139 | ||
140 | found = bfd_find_nearest_line (abfd, section, syms, pc - vma, | |
141 | &filename, &functionname, &line); | |
142 | } | |
143 | ||
144 | /* Read hexadecimal addresses from stdin, translate into | |
145 | file_name:line_number and optionally function name. */ | |
146 | ||
147 | static void | |
148 | translate_addresses (abfd) | |
149 | bfd *abfd; | |
150 | { | |
151 | int read_stdin = (naddr == 0); | |
152 | ||
153 | for (;;) | |
154 | { | |
155 | if (read_stdin) | |
156 | { | |
157 | char addr_hex[100]; | |
158 | ||
159 | if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL) | |
160 | break; | |
161 | pc = bfd_scan_vma (addr_hex, NULL, 16); | |
162 | } | |
163 | else | |
164 | { | |
165 | if (naddr <= 0) | |
166 | break; | |
167 | --naddr; | |
168 | pc = bfd_scan_vma (*addr++, NULL, 16); | |
169 | } | |
170 | ||
171 | found = false; | |
172 | bfd_map_over_sections (abfd, find_address_in_section, (PTR) NULL); | |
173 | ||
174 | if (! found) | |
175 | { | |
176 | if (with_functions) | |
177 | printf ("??\n"); | |
178 | printf ("??:0\n"); | |
179 | } | |
180 | else | |
181 | { | |
182 | if (with_functions) | |
183 | { | |
184 | if (*functionname == '\0') | |
185 | printf ("??\n"); | |
186 | else if (! do_demangle) | |
187 | printf ("%s\n", functionname); | |
188 | else | |
189 | { | |
190 | char *res; | |
191 | ||
192 | res = cplus_demangle (functionname, DMGL_ANSI | DMGL_PARAMS); | |
193 | if (res == NULL) | |
194 | printf ("%s\n", functionname); | |
195 | else | |
196 | { | |
197 | printf ("%s\n", res); | |
198 | free (res); | |
199 | } | |
200 | } | |
201 | } | |
202 | ||
203 | if (base_names) | |
204 | { | |
205 | char *h; | |
206 | ||
207 | h = strrchr (filename, '/'); | |
208 | if (h != NULL) | |
209 | filename = h + 1; | |
210 | } | |
211 | ||
212 | printf ("%s:%u\n", filename, line); | |
213 | } | |
214 | ||
215 | /* fflush() is essential for using this command as a server | |
216 | child process that reads addresses from a pipe and responds | |
217 | with line number information, processing one address at a | |
218 | time. */ | |
219 | fflush (stdout); | |
220 | } | |
221 | } | |
222 | ||
223 | /* Process a file. */ | |
224 | ||
225 | static void | |
226 | process_file (filename, target) | |
227 | const char *filename; | |
228 | const char *target; | |
229 | { | |
230 | bfd *abfd; | |
231 | char **matching; | |
232 | ||
233 | abfd = bfd_openr (filename, target); | |
234 | if (abfd == NULL) | |
235 | bfd_fatal (filename); | |
236 | ||
237 | if (bfd_check_format (abfd, bfd_archive)) | |
238 | fatal (_("%s: can not get addresses from archive"), filename); | |
239 | ||
240 | if (! bfd_check_format_matches (abfd, bfd_object, &matching)) | |
241 | { | |
242 | bfd_nonfatal (bfd_get_filename (abfd)); | |
243 | if (bfd_get_error () == bfd_error_file_ambiguously_recognized) | |
244 | { | |
245 | list_matching_formats (matching); | |
246 | free (matching); | |
247 | } | |
248 | xexit (1); | |
249 | } | |
250 | ||
251 | slurp_symtab (abfd); | |
252 | ||
253 | translate_addresses (abfd); | |
254 | ||
255 | if (syms != NULL) | |
256 | { | |
257 | free (syms); | |
258 | syms = NULL; | |
259 | } | |
260 | ||
261 | bfd_close (abfd); | |
262 | } | |
263 | \f | |
264 | int | |
265 | main (argc, argv) | |
266 | int argc; | |
267 | char **argv; | |
268 | { | |
269 | char *filename; | |
270 | char *target; | |
271 | int c; | |
272 | ||
19ac4b08 TT |
273 | setlocale (LC_MESSAGES, ""); |
274 | bindtextdomain (PACKAGE, LOCALEDIR); | |
275 | textdomain (PACKAGE); | |
276 | ||
9d04d618 TT |
277 | program_name = *argv; |
278 | xmalloc_set_program_name (program_name); | |
279 | ||
280 | bfd_init (); | |
281 | set_default_bfd_target (); | |
282 | ||
283 | filename = NULL; | |
284 | target = NULL; | |
285 | while ((c = getopt_long (argc, argv, "b:Ce:sfHV", long_options, (int *) 0)) | |
286 | != EOF) | |
287 | { | |
288 | switch (c) | |
289 | { | |
290 | case 0: | |
291 | break; /* we've been given a long option */ | |
292 | case 'b': | |
293 | target = optarg; | |
294 | break; | |
295 | case 'C': | |
296 | do_demangle = true; | |
297 | break; | |
298 | case 'e': | |
299 | filename = optarg; | |
300 | break; | |
301 | case 's': | |
302 | base_names = true; | |
303 | break; | |
304 | case 'f': | |
305 | with_functions = true; | |
306 | break; | |
307 | case 'V': | |
308 | print_version ("addr2line"); | |
309 | break; | |
310 | case 'H': | |
311 | usage (stdout, 0); | |
312 | break; | |
313 | default: | |
314 | usage (stderr, 1); | |
315 | break; | |
316 | } | |
317 | } | |
318 | ||
319 | if (filename == NULL) | |
320 | filename = "a.out"; | |
321 | ||
322 | addr = argv + optind; | |
323 | naddr = argc - optind; | |
324 | ||
325 | process_file (filename, target); | |
326 | ||
327 | return 0; | |
328 | } |