Branch data Line data Source code
1 : : /* Print symbol information from ELF file in human-readable form.
2 : : Copyright (C) 2000-2008, 2009, 2011, 2012 Red Hat, Inc.
3 : : This file is part of elfutils.
4 : : Written by Ulrich Drepper <drepper@redhat.com>, 2000.
5 : :
6 : : This file is free software; you can redistribute it and/or modify
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3 of the License, or
9 : : (at your option) any later version.
10 : :
11 : : elfutils is distributed in the hope that it will be useful, but
12 : : WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 : :
19 : : #ifdef HAVE_CONFIG_H
20 : : # include <config.h>
21 : : #endif
22 : :
23 : : #include <ar.h>
24 : : #include <argp.h>
25 : : #include <assert.h>
26 : : #include <ctype.h>
27 : : #include <dwarf.h>
28 : : #include <errno.h>
29 : : #include <error.h>
30 : : #include <fcntl.h>
31 : : #include <gelf.h>
32 : : #include <inttypes.h>
33 : : #include <libdw.h>
34 : : #include <libintl.h>
35 : : #include <locale.h>
36 : : #include <mcheck.h>
37 : : #include <obstack.h>
38 : : #include <search.h>
39 : : #include <stdbool.h>
40 : : #include <stdio.h>
41 : : #include <stdio_ext.h>
42 : : #include <stdlib.h>
43 : : #include <string.h>
44 : : #include <unistd.h>
45 : : #include <sys/param.h>
46 : :
47 : : #include <system.h>
48 : : #include "../libebl/libeblP.h"
49 : :
50 : :
51 : : /* Name and version of program. */
52 : : static void print_version (FILE *stream, struct argp_state *state);
53 : : ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
54 : :
55 : : /* Bug report address. */
56 : : ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
57 : :
58 : :
59 : : /* Values for the parameters which have no short form. */
60 : : #define OPT_DEFINED 0x100
61 : : #define OPT_MARK_SPECIAL 0x101
62 : :
63 : : /* Definitions of arguments for argp functions. */
64 : : static const struct argp_option options[] =
65 : : {
66 : : { NULL, 0, NULL, 0, N_("Output selection:"), 0 },
67 : : { "debug-syms", 'a', NULL, 0, N_("Display debugger-only symbols"), 0 },
68 : : { "defined-only", OPT_DEFINED, NULL, 0, N_("Display only defined symbols"),
69 : : 0 },
70 : : { "dynamic", 'D', NULL, 0,
71 : : N_("Display dynamic symbols instead of normal symbols"), 0 },
72 : : { "extern-only", 'g', NULL, 0, N_("Display only external symbols"), 0 },
73 : : { "undefined-only", 'u', NULL, 0, N_("Display only undefined symbols"), 0 },
74 : : { "print-armap", 's', NULL, 0,
75 : : N_("Include index for symbols from archive members"), 0 },
76 : :
77 : : { NULL, 0, NULL, 0, N_("Output format:"), 0 },
78 : : { "print-file-name", 'A', NULL, 0,
79 : : N_("Print name of the input file before every symbol"), 0 },
80 : : { NULL, 'o', NULL, OPTION_HIDDEN, "Same as -A", 0 },
81 : : { "format", 'f', "FORMAT", 0,
82 : : N_("Use the output format FORMAT. FORMAT can be `bsd', `sysv' or `posix'. The default is `sysv'"),
83 : : 0 },
84 : : { NULL, 'B', NULL, 0, N_("Same as --format=bsd"), 0 },
85 : : { "portability", 'P', NULL, 0, N_("Same as --format=posix"), 0 },
86 : : { "radix", 't', "RADIX", 0, N_("Use RADIX for printing symbol values"), 0 },
87 : : { "mark-special", OPT_MARK_SPECIAL, NULL, 0, N_("Mark special symbols"), 0 },
88 : : { "mark-weak", OPT_MARK_SPECIAL, NULL, OPTION_HIDDEN, "", 0 },
89 : : { "print-size", 'S', NULL, 0, N_("Print size of defined symbols"), 0 },
90 : :
91 : : { NULL, 0, NULL, 0, N_("Output options:"), 0 },
92 : : { "numeric-sort", 'n', NULL, 0, N_("Sort symbols numerically by address"),
93 : : 0 },
94 : : { "no-sort", 'p', NULL, 0, N_("Do not sort the symbols"), 0 },
95 : : { "reverse-sort", 'r', NULL, 0, N_("Reverse the sense of the sort"), 0 },
96 : : #ifdef USE_DEMANGLE
97 : : { "demangle", 'C', NULL, 0,
98 : : N_("Decode low-level symbol names into source code names"), 0 },
99 : : #endif
100 : : { NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 },
101 : : { NULL, 0, NULL, 0, NULL, 0 }
102 : : };
103 : :
104 : : /* Short description of program. */
105 : : static const char doc[] = N_("List symbols from FILEs (a.out by default).");
106 : :
107 : : /* Strings for arguments in help texts. */
108 : : static const char args_doc[] = N_("[FILE...]");
109 : :
110 : : /* Prototype for option handler. */
111 : : static error_t parse_opt (int key, char *arg, struct argp_state *state);
112 : :
113 : : /* Parser children. */
114 : : static struct argp_child argp_children[] =
115 : : {
116 : : { &color_argp, 0, N_("Output formatting"), 2 },
117 : : { NULL, 0, NULL, 0}
118 : : };
119 : :
120 : : /* Data structure to communicate with argp functions. */
121 : : static struct argp argp =
122 : : {
123 : : options, parse_opt, args_doc, doc, argp_children, NULL, NULL
124 : : };
125 : :
126 : :
127 : : /* Print symbols in file named FNAME. */
128 : : static int process_file (const char *fname, bool more_than_one);
129 : :
130 : : /* Handle content of archive. */
131 : : static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
132 : : const char *suffix);
133 : :
134 : : /* Handle ELF file. */
135 : : static int handle_elf (Elf *elf, const char *prefix, const char *fname,
136 : : const char *suffix);
137 : :
138 : :
139 : : #define INTERNAL_ERROR(fname) \
140 : : error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s-%s): %s"), \
141 : : fname, __LINE__, PACKAGE_VERSION, __DATE__, elf_errmsg (-1))
142 : :
143 : :
144 : : /* Internal representation of symbols. */
145 : : typedef struct GElf_SymX
146 : : {
147 : : GElf_Sym sym;
148 : : Elf32_Word xndx;
149 : : char *where;
150 : : } GElf_SymX;
151 : :
152 : :
153 : : /* User-selectable options. */
154 : :
155 : : /* The selected output format. */
156 : : static enum
157 : : {
158 : : format_sysv = 0,
159 : : format_bsd,
160 : : format_posix
161 : : } format;
162 : :
163 : : /* Print defined, undefined, or both? */
164 : : static bool hide_undefined;
165 : : static bool hide_defined;
166 : :
167 : : /* Print local symbols also? */
168 : : static bool hide_local;
169 : :
170 : : /* Nonzero if full filename should precede every symbol. */
171 : : static bool print_file_name;
172 : :
173 : : /* If true print size of defined symbols in BSD format. */
174 : : static bool print_size;
175 : :
176 : : /* If true print archive index. */
177 : : static bool print_armap;
178 : :
179 : : /* If true reverse sorting. */
180 : : static bool reverse_sort;
181 : :
182 : : #ifdef USE_DEMANGLE
183 : : /* If true demangle symbols. */
184 : : static bool demangle;
185 : : #endif
186 : :
187 : : /* Type of the section we are printing. */
188 : : static GElf_Word symsec_type = SHT_SYMTAB;
189 : :
190 : : /* Sorting selection. */
191 : : static enum
192 : : {
193 : : sort_name = 0,
194 : : sort_numeric,
195 : : sort_nosort
196 : : } sort;
197 : :
198 : : /* Radix for printed numbers. */
199 : : static enum
200 : : {
201 : : radix_hex = 0,
202 : : radix_decimal,
203 : : radix_octal
204 : : } radix;
205 : :
206 : : /* If nonzero mark special symbols:
207 : : - weak symbols are distinguished from global symbols by adding
208 : : a `*' after the identifying letter for the symbol class and type.
209 : : - TLS symbols are distinguished from normal symbols by adding
210 : : a '@' after the identifying letter for the symbol class and type. */
211 : : static bool mark_special;
212 : :
213 : :
214 : : int
215 : 864 : main (int argc, char *argv[])
216 : : {
217 : : int remaining;
218 : 864 : int result = 0;
219 : :
220 : : /* Make memory leak detection possible. */
221 : 864 : mtrace ();
222 : :
223 : : /* We use no threads here which can interfere with handling a stream. */
224 : 864 : (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER);
225 : 864 : (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
226 : 864 : (void) __fsetlocking (stderr, FSETLOCKING_BYCALLER);
227 : :
228 : : /* Set locale. */
229 : 864 : (void) setlocale (LC_ALL, "");
230 : :
231 : : /* Make sure the message catalog can be found. */
232 : 864 : (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
233 : :
234 : : /* Initialize the message catalog. */
235 : 864 : (void) textdomain (PACKAGE_TARNAME);
236 : :
237 : : /* Parse and process arguments. */
238 : 864 : (void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);
239 : :
240 : : /* Tell the library which version we are expecting. */
241 : 864 : (void) elf_version (EV_CURRENT);
242 : :
243 [ - + ]: 864 : if (remaining == argc)
244 : : /* The user didn't specify a name so we use a.out. */
245 : 0 : result = process_file ("a.out", false);
246 : : else
247 : : {
248 : : /* Process all the remaining files. */
249 : 864 : const bool more_than_one = remaining + 1 < argc;
250 : :
251 : : do
252 : 864 : result |= process_file (argv[remaining], more_than_one);
253 [ - + ]: 864 : while (++remaining < argc);
254 : : }
255 : :
256 : : return result;
257 : : }
258 : :
259 : :
260 : : /* Print the version information. */
261 : : static void
262 : 0 : print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
263 : : {
264 : 0 : fprintf (stream, "nm (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
265 : 0 : fprintf (stream, gettext ("\
266 : : Copyright (C) %s Red Hat, Inc.\n\
267 : : This is free software; see the source for copying conditions. There is NO\n\
268 : : warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
269 : : "), "2012");
270 : 0 : fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
271 : 0 : }
272 : :
273 : :
274 : : /* Handle program arguments. */
275 : : static error_t
276 : 6912 : parse_opt (int key, char *arg,
277 : : struct argp_state *state __attribute__ ((unused)))
278 : : {
279 [ + - + + : 6912 : switch (key)
+ + - - -
- + - + -
- - + + ]
280 : : {
281 : : case 'a':
282 : : /* XXX */
283 : : break;
284 : :
285 : : #ifdef USE_DEMANGLE
286 : : case 'C':
287 : 0 : demangle = true;
288 : 0 : break;
289 : : #endif
290 : :
291 : : case 'f':
292 [ + + ][ + - ]: 864 : if (strcmp (arg, "bsd") == 0)
[ + - ][ + + ]
293 : 288 : format = format_bsd;
294 [ + + ]: 576 : else if (strcmp (arg, "posix") == 0)
295 : 288 : format = format_posix;
296 : : else
297 : : /* Be bug compatible. The BFD implementation also defaulted to
298 : : using the SysV format if nothing else matches. */
299 : 288 : format = format_sysv;
300 : : break;
301 : :
302 : : case 'g':
303 : 216 : hide_local = true;
304 : 216 : break;
305 : :
306 : : case 'n':
307 : 288 : sort = sort_numeric;
308 : 288 : break;
309 : :
310 : : case 'p':
311 : 288 : sort = sort_nosort;
312 : 288 : break;
313 : :
314 : : case 't':
315 [ # # ][ # # ]: 0 : if (strcmp (arg, "10") == 0 || strcmp (arg, "d") == 0)
[ # # ][ # # ]
[ # # ]
316 : 0 : radix = radix_decimal;
317 [ # # ][ # # ]: 0 : else if (strcmp (arg, "8") == 0 || strcmp (arg, "o") == 0)
[ # # ][ # # ]
318 : 0 : radix = radix_octal;
319 : : else
320 : 0 : radix = radix_hex;
321 : : break;
322 : :
323 : : case 'u':
324 : 0 : hide_undefined = false;
325 : 0 : hide_defined = true;
326 : 0 : break;
327 : :
328 : : case 'A':
329 : : case 'o':
330 : 0 : print_file_name = true;
331 : 0 : break;
332 : :
333 : : case 'B':
334 : 0 : format = format_bsd;
335 : 0 : break;
336 : :
337 : : case 'D':
338 : 216 : symsec_type = SHT_DYNSYM;
339 : 216 : break;
340 : :
341 : : case 'P':
342 : 0 : format = format_posix;
343 : 0 : break;
344 : :
345 : : case OPT_DEFINED:
346 : 216 : hide_undefined = true;
347 : 216 : hide_defined = false;
348 : 216 : break;
349 : :
350 : : case OPT_MARK_SPECIAL:
351 : 0 : mark_special = true;
352 : 0 : break;
353 : :
354 : : case 'S':
355 : 0 : print_size = true;
356 : 0 : break;
357 : :
358 : : case 's':
359 : 0 : print_armap = true;
360 : 0 : break;
361 : :
362 : : case 'r':
363 : 288 : reverse_sort = true;
364 : 6912 : break;
365 : :
366 : : default:
367 : : return ARGP_ERR_UNKNOWN;
368 : : }
369 : : return 0;
370 : : }
371 : :
372 : :
373 : : /* Open the file and determine the type. */
374 : : static int
375 : 864 : process_file (const char *fname, bool more_than_one)
376 : : {
377 : : /* Open the file. */
378 : 864 : int fd = open (fname, O_RDONLY);
379 [ - + ]: 864 : if (fd == -1)
380 : : {
381 : 0 : error (0, errno, gettext ("cannot open '%s'"), fname);
382 : 0 : return 1;
383 : : }
384 : :
385 : : /* Now get the ELF descriptor. */
386 : 864 : Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
387 [ + - ]: 864 : if (elf != NULL)
388 : : {
389 [ + - ]: 864 : if (elf_kind (elf) == ELF_K_ELF)
390 : : {
391 [ + - ]: 864 : int result = handle_elf (elf, more_than_one ? "" : NULL,
392 : : fname, NULL);
393 : :
394 [ - + ]: 864 : if (elf_end (elf) != 0)
395 : 0 : INTERNAL_ERROR (fname);
396 : :
397 [ - + ]: 864 : if (close (fd) != 0)
398 : 0 : error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
399 : :
400 : : return result;
401 : : }
402 [ # # ]: 0 : else if (elf_kind (elf) == ELF_K_AR)
403 : : {
404 : 0 : int result = handle_ar (fd, elf, NULL, fname, NULL);
405 : :
406 [ # # ]: 0 : if (elf_end (elf) != 0)
407 : 0 : INTERNAL_ERROR (fname);
408 : :
409 [ # # ]: 0 : if (close (fd) != 0)
410 : 0 : error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
411 : :
412 : : return result;
413 : : }
414 : :
415 : : /* We cannot handle this type. Close the descriptor anyway. */
416 [ # # ]: 0 : if (elf_end (elf) != 0)
417 : 0 : INTERNAL_ERROR (fname);
418 : : }
419 : :
420 : 0 : error (0, 0, gettext ("%s: File format not recognized"), fname);
421 : :
422 : 864 : return 1;
423 : : }
424 : :
425 : :
426 : : static int
427 : 0 : handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
428 : : const char *suffix)
429 : : {
430 : 0 : size_t fname_len = strlen (fname) + 1;
431 [ # # ]: 0 : size_t prefix_len = prefix != NULL ? strlen (prefix) : 0;
432 : 0 : char new_prefix[prefix_len + fname_len + 2];
433 [ # # ]: 0 : size_t suffix_len = suffix != NULL ? strlen (suffix) : 0;
434 : 0 : char new_suffix[suffix_len + 2];
435 : : Elf *subelf;
436 : 0 : Elf_Cmd cmd = ELF_C_READ_MMAP;
437 : 0 : int result = 0;
438 : :
439 : 0 : char *cp = new_prefix;
440 [ # # ]: 0 : if (prefix != NULL)
441 : 0 : cp = stpcpy (cp, prefix);
442 : 0 : cp = stpcpy (cp, fname);
443 : 0 : stpcpy (cp, "[");
444 : :
445 : 0 : cp = new_suffix;
446 [ # # ]: 0 : if (suffix != NULL)
447 : 0 : cp = stpcpy (cp, suffix);
448 : 0 : stpcpy (cp, "]");
449 : :
450 : : /* First print the archive index if this is wanted. */
451 [ # # ]: 0 : if (print_armap)
452 : : {
453 : 0 : Elf_Arsym *arsym = elf_getarsym (elf, NULL);
454 : :
455 [ # # ]: 0 : if (arsym != NULL)
456 : : {
457 : 0 : Elf_Arhdr *arhdr = NULL;
458 : 0 : size_t arhdr_off = 0; /* Note: 0 is no valid offset. */
459 : :
460 : 0 : fputs_unlocked (gettext("\nArchive index:\n"), stdout);
461 : :
462 [ # # ]: 0 : while (arsym->as_off != 0)
463 : : {
464 [ # # ]: 0 : if (arhdr_off != arsym->as_off
465 [ # # ]: 0 : && (elf_rand (elf, arsym->as_off) != arsym->as_off
466 [ # # ]: 0 : || (subelf = elf_begin (fd, cmd, elf)) == NULL
467 [ # # ]: 0 : || (arhdr = elf_getarhdr (subelf)) == NULL))
468 : : {
469 : 0 : error (0, 0, gettext ("invalid offset %zu for symbol %s"),
470 : : arsym->as_off, arsym->as_name);
471 : 0 : continue;
472 : : }
473 : :
474 : 0 : printf (gettext ("%s in %s\n"), arsym->as_name, arhdr->ar_name);
475 : :
476 : 0 : ++arsym;
477 : : }
478 : :
479 [ # # ]: 0 : if (elf_rand (elf, SARMAG) != SARMAG)
480 : : {
481 : : error (0, 0,
482 : 0 : gettext ("cannot reset archive offset to beginning"));
483 : : return 1;
484 : : }
485 : : }
486 : : }
487 : :
488 : : /* Process all the files contained in the archive. */
489 [ # # ]: 0 : while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
490 : : {
491 : : /* The the header for this element. */
492 : 0 : Elf_Arhdr *arhdr = elf_getarhdr (subelf);
493 : :
494 : : /* Skip over the index entries. */
495 [ # # ][ # # ]: 0 : if (strcmp (arhdr->ar_name, "/") != 0
496 [ # # ][ # # ]: 0 : && strcmp (arhdr->ar_name, "//") != 0)
[ # # ]
497 : : {
498 [ # # ]: 0 : if (elf_kind (subelf) == ELF_K_ELF)
499 : 0 : result |= handle_elf (subelf, new_prefix, arhdr->ar_name,
500 : : new_suffix);
501 [ # # ]: 0 : else if (elf_kind (subelf) == ELF_K_AR)
502 : 0 : result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name,
503 : : new_suffix);
504 : : else
505 : : {
506 : 0 : error (0, 0, gettext ("%s%s%s: file format not recognized"),
507 : : new_prefix, arhdr->ar_name, new_suffix);
508 : 0 : result = 1;
509 : : }
510 : : }
511 : :
512 : : /* Get next archive element. */
513 : 0 : cmd = elf_next (subelf);
514 [ # # ]: 0 : if (elf_end (subelf) != 0)
515 : 0 : INTERNAL_ERROR (fname);
516 : : }
517 : :
518 : : return result;
519 : : }
520 : :
521 : :
522 : : /* Mapping of radix and binary class to length. */
523 : : static const int length_map[2][3] =
524 : : {
525 : : [ELFCLASS32 - 1] =
526 : : {
527 : : [radix_hex] = 8,
528 : : [radix_decimal] = 10,
529 : : [radix_octal] = 11
530 : : },
531 : : [ELFCLASS64 - 1] =
532 : : {
533 : : [radix_hex] = 16,
534 : : [radix_decimal] = 20,
535 : : [radix_octal] = 22
536 : : }
537 : : };
538 : :
539 : :
540 : : static int
541 : 0 : global_compare (const void *p1, const void *p2)
542 : : {
543 : 0 : const Dwarf_Global *g1 = (const Dwarf_Global *) p1;
544 : 0 : const Dwarf_Global *g2 = (const Dwarf_Global *) p2;
545 : :
546 : 0 : return strcmp (g1->name, g2->name);
547 : : }
548 : :
549 : :
550 : : static void *global_root;
551 : :
552 : :
553 : : static int
554 : 0 : get_global (Dwarf *dbg __attribute__ ((unused)), Dwarf_Global *global,
555 : : void *arg __attribute__ ((unused)))
556 : : {
557 : 0 : tsearch (memcpy (xmalloc (sizeof (Dwarf_Global)), global,
558 : : sizeof (Dwarf_Global)),
559 : : &global_root, global_compare);
560 : :
561 : 0 : return DWARF_CB_OK;
562 : : }
563 : :
564 : :
565 : : struct local_name
566 : : {
567 : : const char *name;
568 : : const char *file;
569 : : Dwarf_Word lineno;
570 : : Dwarf_Addr lowpc;
571 : : Dwarf_Addr highpc;
572 : : };
573 : :
574 : :
575 : : static int
576 : 1154052 : local_compare (const void *p1, const void *p2)
577 : : {
578 : 1154052 : struct local_name *g1 = (struct local_name *) p1;
579 : 1154052 : struct local_name *g2 = (struct local_name *) p2;
580 : : int result;
581 : :
582 : 1154052 : result = strcmp (g1->name, g2->name);
583 [ + + ]: 1154052 : if (result == 0)
584 : : {
585 [ + + ][ + + ]: 29097 : if (g1->lowpc <= g2->lowpc && g1->highpc >= g2->highpc)
586 : : {
587 : : /* g2 is contained in g1. Update the data. */
588 : 3768 : g2->lowpc = g1->lowpc;
589 : 3768 : g2->highpc = g1->highpc;
590 : 3768 : result = 0;
591 : : }
592 [ + + ][ + + ]: 25329 : else if (g2->lowpc <= g1->lowpc && g2->highpc >= g1->highpc)
593 : : {
594 : : /* g1 is contained in g2. Update the data. */
595 : 24012 : g1->lowpc = g2->lowpc;
596 : 24012 : g1->highpc = g2->highpc;
597 : 24012 : result = 0;
598 : : }
599 : : else
600 [ + + ]: 1317 : result = g1->lowpc < g2->lowpc ? -1 : 1;
601 : : }
602 : :
603 : 1154052 : return result;
604 : : }
605 : :
606 : :
607 : : static int
608 : 30372 : get_var_range (Dwarf_Die *die, Dwarf_Word *lowpc, Dwarf_Word *highpc)
609 : : {
610 : : Dwarf_Attribute locattr_mem;
611 : 30372 : Dwarf_Attribute *locattr = dwarf_attr (die, DW_AT_location, &locattr_mem);
612 [ + + ]: 30372 : if (locattr == NULL)
613 : : return 1;
614 : :
615 : : Dwarf_Op *loc;
616 : : size_t nloc;
617 [ + - ]: 7308 : if (dwarf_getlocation (locattr, &loc, &nloc) != 0)
618 : : return 1;
619 : :
620 : : /* Interpret the location expressions. */
621 : : // XXX For now just the simple one:
622 [ + + ][ + - ]: 7308 : if (nloc == 1 && loc[0].atom == DW_OP_addr)
623 : : {
624 : 30372 : *lowpc = *highpc = loc[0].number;
625 : : return 0;
626 : : }
627 : :
628 : : return 1;
629 : : }
630 : :
631 : :
632 : :
633 : : static void *local_root;
634 : :
635 : :
636 : : static void
637 : 288 : get_local_names (Dwarf *dbg)
638 : : {
639 : 288 : Dwarf_Off offset = 0;
640 : : Dwarf_Off old_offset;
641 : : size_t hsize;
642 : :
643 [ + + ]: 14352 : while (dwarf_nextcu (dbg, old_offset = offset, &offset, &hsize, NULL, NULL,
644 : : NULL) == 0)
645 : : {
646 : : Dwarf_Die cudie_mem;
647 : 14064 : Dwarf_Die *cudie = dwarf_offdie (dbg, old_offset + hsize, &cudie_mem);
648 : :
649 : : /* If we cannot get the CU DIE there is no need to go on with
650 : : this CU. */
651 [ - + ]: 14064 : if (cudie == NULL)
652 : 0 : continue;
653 : : /* This better be a CU DIE. */
654 [ - + ]: 14064 : if (dwarf_tag (cudie) != DW_TAG_compile_unit)
655 : 0 : continue;
656 : :
657 : : /* Get the line information. */
658 : : Dwarf_Files *files;
659 : : size_t nfiles;
660 [ - + ]: 14064 : if (dwarf_getsrcfiles (cudie, &files, &nfiles) != 0)
661 : 0 : continue;
662 : :
663 : : Dwarf_Die die_mem;
664 : 14064 : Dwarf_Die *die = &die_mem;
665 [ + - ]: 14064 : if (dwarf_child (cudie, die) == 0)
666 : : /* Iterate over all immediate children of the CU DIE. */
667 : : do
668 : : {
669 : 1924164 : int tag = dwarf_tag (die);
670 [ + + ]: 1924164 : if (tag != DW_TAG_subprogram && tag != DW_TAG_variable)
671 : 1756872 : continue;
672 : :
673 : : /* We are interested in five attributes: name, decl_file,
674 : : decl_line, low_pc, and high_pc. */
675 : : Dwarf_Attribute attr_mem;
676 : 167292 : Dwarf_Attribute *attr = dwarf_attr (die, DW_AT_name, &attr_mem);
677 : 167292 : const char *name = dwarf_formstring (attr);
678 [ + + ]: 167292 : if (name == NULL)
679 : 1776 : continue;
680 : :
681 : : Dwarf_Word fileidx;
682 : 165516 : attr = dwarf_attr (die, DW_AT_decl_file, &attr_mem);
683 [ + + ][ - + ]: 165516 : if (dwarf_formudata (attr, &fileidx) != 0 || fileidx >= nfiles)
684 : 10668 : continue;
685 : :
686 : : Dwarf_Word lineno;
687 : 154848 : attr = dwarf_attr (die, DW_AT_decl_line, &attr_mem);
688 [ + - ][ + + ]: 154848 : if (dwarf_formudata (attr, &lineno) != 0 || lineno == 0)
689 : 10944 : continue;
690 : :
691 : : Dwarf_Addr lowpc;
692 : : Dwarf_Addr highpc;
693 [ + + ]: 143904 : if (tag == DW_TAG_subprogram)
694 : : {
695 [ + + ]: 113532 : if (dwarf_lowpc (die, &lowpc) != 0
696 [ - + ]: 36648 : || dwarf_highpc (die, &highpc) != 0)
697 : 76884 : continue;
698 : : }
699 : : else
700 : : {
701 [ + + ]: 30372 : if (get_var_range (die, &lowpc, &highpc) != 0)
702 : 23316 : continue;
703 : : }
704 : :
705 : : /* We have all the information. Create a record. */
706 : 43704 : struct local_name *newp
707 : : = (struct local_name *) xmalloc (sizeof (*newp));
708 : 43704 : newp->name = name;
709 : 43704 : newp->file = dwarf_filesrc (files, fileidx, NULL, NULL);
710 : 43704 : newp->lineno = lineno;
711 : 43704 : newp->lowpc = lowpc;
712 : 43704 : newp->highpc = highpc;
713 : :
714 : : /* Since we cannot deallocate individual memory we do not test
715 : : for duplicates in the tree. This should not happen anyway. */
716 [ - + ]: 43704 : if (tsearch (newp, &local_root, local_compare) == NULL)
717 : 0 : error (EXIT_FAILURE, errno,
718 : 0 : gettext ("cannot create search tree"));
719 : : }
720 [ + + ]: 1924164 : while (dwarf_siblingof (die, die) == 0);
721 : : }
722 : 288 : }
723 : :
724 : : /* Do elf_strptr, but return a backup string and never NULL. */
725 : : static const char *
726 : 314922 : sym_name (Elf *elf, GElf_Word strndx, GElf_Word st_name, char buf[], size_t n)
727 : : {
728 : 314922 : const char *symstr = elf_strptr (elf, strndx, st_name);
729 [ - + ]: 314922 : if (symstr == NULL)
730 : : {
731 : 0 : snprintf (buf, n, "[invalid st_name %#" PRIx32 "]", st_name);
732 : 0 : symstr = buf;
733 : : }
734 : 314922 : return symstr;
735 : : }
736 : :
737 : : /* Show symbols in SysV format. */
738 : : static void
739 : 288 : show_symbols_sysv (Ebl *ebl, GElf_Word strndx, const char *fullname,
740 : : GElf_SymX *syms, size_t nsyms, int longest_name,
741 : : int longest_where)
742 : : {
743 : : size_t shnum;
744 [ - + ]: 288 : if (elf_getshdrnum (ebl->elf, &shnum) < 0)
745 : 0 : INTERNAL_ERROR (fullname);
746 : :
747 : 288 : bool scnnames_malloced = shnum * sizeof (const char *) > 128 * 1024;
748 : : const char **scnnames;
749 [ - + ]: 288 : if (scnnames_malloced)
750 : 0 : scnnames = (const char **) xmalloc (sizeof (const char *) * shnum);
751 : : else
752 : 288 : scnnames = (const char **) alloca (sizeof (const char *) * shnum);
753 : : /* Get the section header string table index. */
754 : : size_t shstrndx;
755 [ + - ]: 288 : if (elf_getshdrstrndx (ebl->elf, &shstrndx) < 0)
756 : : error (EXIT_FAILURE, 0,
757 : 0 : gettext ("cannot get section header string table index"));
758 : :
759 : : /* Cache the section names. */
760 : : Elf_Scn *scn = NULL;
761 : : size_t cnt = 1;
762 [ + + ]: 10824 : while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
763 : : {
764 : : GElf_Shdr shdr_mem;
765 : :
766 [ - + ]: 10536 : assert (elf_ndxscn (scn) == cnt++);
767 : :
768 : 10536 : char *name = elf_strptr (ebl->elf, shstrndx,
769 : 10536 : gelf_getshdr (scn, &shdr_mem)->sh_name);
770 [ - + ]: 10536 : if (unlikely (name == NULL))
771 : : {
772 : 0 : const size_t bufsz = sizeof "[invalid sh_name 0x12345678]";
773 : 0 : name = alloca (bufsz);
774 : 0 : snprintf (name, bufsz, "[invalid sh_name %#" PRIx32 "]",
775 : 0 : gelf_getshdr (scn, &shdr_mem)->sh_name);
776 : : }
777 : 10536 : scnnames[elf_ndxscn (scn)] = name;
778 : : }
779 : :
780 : 288 : int digits = length_map[gelf_getclass (ebl->elf) - 1][radix];
781 : :
782 : : /* We always print this prolog. */
783 : 288 : printf (gettext ("\n\nSymbols from %s:\n\n"), fullname);
784 : :
785 : : /* The header line. */
786 [ - + ]: 288 : printf (gettext ("%*s%-*s %-*s Class Type %-*s %*s Section\n\n"),
787 : 0 : print_file_name ? (int) strlen (fullname) + 1: 0, "",
788 [ + - ]: 288 : longest_name, sgettext ("sysv|Name"),
789 : : /* TRANS: the "sysv|" parts makes the string unique. */
790 [ + - ]: 288 : digits, sgettext ("sysv|Value"),
791 : : /* TRANS: the "sysv|" parts makes the string unique. */
792 [ + - ]: 288 : digits, sgettext ("sysv|Size"),
793 : : /* TRANS: the "sysv|" parts makes the string unique. */
794 [ + - ]: 288 : longest_where, sgettext ("sysv|Line"));
795 : :
796 : : /* Which format string to use (different radix for numbers). */
797 : : const char *number_fmtstr;
798 [ - + ]: 288 : if (radix == radix_hex)
799 : : number_fmtstr = "%0*" PRIx64;
800 [ # # ]: 0 : else if (radix == radix_decimal)
801 : : number_fmtstr = "%0*" PRId64;
802 : : else
803 : 0 : number_fmtstr = "%0*" PRIo64;
804 : :
805 : : #ifdef USE_DEMANGLE
806 : 288 : size_t demangle_buffer_len = 0;
807 : 288 : char *demangle_buffer = NULL;
808 : : #endif
809 : :
810 : : /* Iterate over all symbols. */
811 [ + + ]: 106683 : for (cnt = 1; cnt < nsyms; ++cnt)
812 : : {
813 : : /* In this format SECTION entries are not printed. */
814 [ + + ]: 106395 : if (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_SECTION)
815 : 4839 : continue;
816 : :
817 : : char symstrbuf[50];
818 : 101556 : const char *symstr = sym_name (ebl->elf, strndx, syms[cnt].sym.st_name,
819 : : symstrbuf, sizeof symstrbuf);
820 : :
821 : : #ifdef USE_DEMANGLE
822 : : /* Demangle if necessary. */
823 [ - + ]: 101556 : if (demangle)
824 : : {
825 : 0 : int status = -1;
826 : 0 : char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
827 : : &demangle_buffer_len, &status);
828 : :
829 [ # # ]: 0 : if (status == 0)
830 : 0 : symstr = dmsymstr;
831 : : }
832 : : #endif
833 : :
834 : : char symbindbuf[50];
835 : : char symtypebuf[50];
836 : : char secnamebuf[1024];
837 : : char addressbuf[(64 + 2) / 3 + 1];
838 : : char sizebuf[(64 + 2) / 3 + 1];
839 : :
840 : : /* If we have to precede the line with the file name. */
841 [ - + ]: 101556 : if (print_file_name)
842 : : {
843 : 0 : fputs_unlocked (fullname, stdout);
844 : 0 : putchar_unlocked (':');
845 : : }
846 : :
847 : : /* Covert the address. */
848 [ + + ]: 101556 : if (syms[cnt].sym.st_shndx == SHN_UNDEF)
849 : 11509 : addressbuf[0] = sizebuf[0] = '\0';
850 : : else
851 : : {
852 : 90047 : snprintf (addressbuf, sizeof (addressbuf), number_fmtstr,
853 : : digits, syms[cnt].sym.st_value);
854 : 90047 : snprintf (sizebuf, sizeof (sizebuf), number_fmtstr,
855 : : digits, syms[cnt].sym.st_size);
856 : : }
857 : :
858 : : /* Print the actual string. */
859 : 101556 : printf ("%-*s|%s|%-6s|%-8s|%s|%*s|%s\n",
860 : : longest_name, symstr, addressbuf,
861 : : ebl_symbol_binding_name (ebl,
862 : 101556 : GELF_ST_BIND (syms[cnt].sym.st_info),
863 : : symbindbuf, sizeof (symbindbuf)),
864 : 101556 : ebl_symbol_type_name (ebl, GELF_ST_TYPE (syms[cnt].sym.st_info),
865 : : symtypebuf, sizeof (symtypebuf)),
866 : : sizebuf, longest_where, syms[cnt].where,
867 : 203112 : ebl_section_name (ebl, syms[cnt].sym.st_shndx, syms[cnt].xndx,
868 : : secnamebuf, sizeof (secnamebuf), scnnames,
869 : : shnum));
870 : : }
871 : :
872 : : #ifdef USE_DEMANGLE
873 : : free (demangle_buffer);
874 : : #endif
875 : :
876 [ - + ]: 288 : if (scnnames_malloced)
877 : 0 : free (scnnames);
878 : 288 : }
879 : :
880 : :
881 : : static char
882 : 184083 : class_type_char (Elf *elf, const GElf_Ehdr *ehdr, GElf_Sym *sym)
883 : : {
884 : 184083 : int local_p = GELF_ST_BIND (sym->st_info) == STB_LOCAL;
885 : :
886 : : /* XXX Add support for architecture specific types and classes. */
887 [ + + ]: 184083 : if (sym->st_shndx == SHN_ABS)
888 [ + + ]: 8196 : return local_p ? 'a' : 'A';
889 : :
890 [ + + ]: 175887 : if (sym->st_shndx == SHN_UNDEF)
891 : : /* Undefined symbols must be global. */
892 : : return 'U';
893 : :
894 : 164358 : char result = "NDTSFBD "[GELF_ST_TYPE (sym->st_info)];
895 : :
896 [ + + ]: 164358 : if (result == 'D')
897 : : {
898 : : /* Special handling: unique data symbols. */
899 [ - + ]: 93594 : if (ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX
900 [ # # ]: 0 : && GELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
901 : : result = 'u';
902 : : else
903 : : {
904 : : GElf_Shdr shdr_mem;
905 : 93594 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (elf, sym->st_shndx),
906 : : &shdr_mem);
907 [ + - ]: 93594 : if (shdr != NULL)
908 : : {
909 [ + + ]: 93594 : if ((shdr->sh_flags & SHF_WRITE) == 0)
910 : : result = 'R';
911 [ + + ]: 83622 : else if (shdr->sh_type == SHT_NOBITS)
912 : 93594 : result = 'B';
913 : : }
914 : : }
915 : : }
916 : :
917 [ + + ]: 184083 : return local_p ? tolower (result) : result;
918 : : }
919 : :
920 : :
921 : : static void
922 : 288 : show_symbols_bsd (Elf *elf, const GElf_Ehdr *ehdr, GElf_Word strndx,
923 : : const char *prefix, const char *fname, const char *fullname,
924 : : GElf_SymX *syms, size_t nsyms)
925 : : {
926 : 288 : int digits = length_map[gelf_getclass (elf) - 1][radix];
927 : :
928 [ - + ][ # # ]: 288 : if (prefix != NULL && ! print_file_name)
929 : 0 : printf ("\n%s:\n", fname);
930 : :
931 : : static const char *const fmtstrs[] =
932 : : {
933 : : [radix_hex] = "%6$s%2$0*1$" PRIx64 "%8$s %7$s%3$c%4$s %5$s",
934 : : [radix_decimal] = "%6$s%*" PRId64 "%8$s %7$s%3$c%4$s %5$s",
935 : : [radix_octal] = "%6$s%2$0*1$" PRIo64 "%8$s %7$s%3$c%4$s %5$s"
936 : : };
937 : : static const char *const sfmtstrs[] =
938 : : {
939 : : [radix_hex] = "%6$s%2$0*1$" PRIx64 "%8$s %10$0*9$" PRIx64 " %7$s%3$c%4$s %5$s",
940 : : [radix_decimal] = "%6$s%2$*1$" PRId64 "%8$s %10$*9$" PRId64 " %7$s%3$c%4$s %5$s",
941 : : [radix_octal] = "%6$s%2$0*1$" PRIo64 "%8$s %10$0*9$" PRIo64 " %7$s%3$c%4$s %5$s"
942 : : };
943 : :
944 : : #ifdef USE_DEMANGLE
945 : 288 : size_t demangle_buffer_len = 0;
946 : 288 : char *demangle_buffer = NULL;
947 : : #endif
948 : :
949 : : /* Iterate over all symbols. */
950 [ + + ]: 106971 : for (size_t cnt = 0; cnt < nsyms; ++cnt)
951 : : {
952 : : char symstrbuf[50];
953 : 106683 : const char *symstr = sym_name (elf, strndx, syms[cnt].sym.st_name,
954 : : symstrbuf, sizeof symstrbuf);
955 : :
956 : : /* Printing entries with a zero-length name makes the output
957 : : not very well parseable. Since these entries don't carry
958 : : much information we leave them out. */
959 [ + + ]: 106683 : if (symstr[0] == '\0')
960 : 5175 : continue;
961 : :
962 : : /* We do not print the entries for files. */
963 [ + + ]: 101508 : if (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_FILE)
964 : 7404 : continue;
965 : :
966 : : #ifdef USE_DEMANGLE
967 : : /* Demangle if necessary. */
968 [ - + ]: 94104 : if (demangle)
969 : : {
970 : 0 : int status = -1;
971 : 0 : char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
972 : : &demangle_buffer_len, &status);
973 : :
974 [ # # ]: 0 : if (status == 0)
975 : 0 : symstr = dmsymstr;
976 : : }
977 : : #endif
978 : :
979 : : /* If we have to precede the line with the file name. */
980 [ - + ]: 94104 : if (print_file_name)
981 : : {
982 : 0 : fputs_unlocked (fullname, stdout);
983 : 0 : putchar_unlocked (':');
984 : : }
985 : :
986 : 94104 : bool is_tls = GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_TLS;
987 : 94104 : bool is_weak = GELF_ST_BIND (syms[cnt].sym.st_info) == STB_WEAK;
988 : 94104 : const char *marker = (mark_special
989 [ - + ][ # # ]: 94104 : ? (is_tls ? "@" : (is_weak ? "*" : " ")) : "");
[ # # ]
990 : :
991 [ + + ]: 94104 : if (syms[cnt].sym.st_shndx == SHN_UNDEF)
992 : : {
993 : 11529 : const char *color = "";
994 [ - + ]: 11529 : if (color_mode)
995 : : {
996 [ # # ]: 0 : if (is_tls)
997 : 0 : color = color_undef_tls;
998 [ # # ]: 0 : else if (is_weak)
999 : 0 : color = color_undef_weak;
1000 : : else
1001 : 0 : color = color_undef;
1002 : : }
1003 : :
1004 : 11529 : printf ("%*s %sU%s %s", digits, "", color, marker, symstr);
1005 : : }
1006 : : else
1007 : : {
1008 : 82575 : const char *color = "";
1009 [ - + ]: 82575 : if (color_mode)
1010 : : {
1011 [ # # ]: 0 : if (is_tls)
1012 : 0 : color = color_tls;
1013 [ # # ]: 0 : else if (is_weak)
1014 : 0 : color = color_weak;
1015 : : else
1016 : 0 : color = color_symbol;
1017 : : }
1018 : :
1019 [ + - ][ - + ]: 165150 : printf (print_size && syms[cnt].sym.st_size != 0
[ - + ][ # # ]
1020 : 82575 : ? sfmtstrs[radix] : fmtstrs[radix],
1021 : : digits, syms[cnt].sym.st_value,
1022 : 82575 : class_type_char (elf, ehdr, &syms[cnt].sym), marker,
1023 : : symstr,
1024 : : color_mode ? color_address : "",
1025 : : color,
1026 : : color_mode ? color_off : "",
1027 : : digits, (uint64_t) syms[cnt].sym.st_size);
1028 : : }
1029 : :
1030 [ - + ]: 94104 : if (color_mode)
1031 : 0 : fputs_unlocked (color_off, stdout);
1032 : 106683 : putchar_unlocked ('\n');
1033 : : }
1034 : :
1035 : : #ifdef USE_DEMANGLE
1036 : : free (demangle_buffer);
1037 : : #endif
1038 : 288 : }
1039 : :
1040 : :
1041 : : static void
1042 : 288 : show_symbols_posix (Elf *elf, const GElf_Ehdr *ehdr, GElf_Word strndx,
1043 : : const char *prefix, const char *fullname, GElf_SymX *syms,
1044 : : size_t nsyms)
1045 : : {
1046 [ - + ][ # # ]: 288 : if (prefix != NULL && ! print_file_name)
1047 : 0 : printf ("%s:\n", fullname);
1048 : :
1049 : : const char *fmtstr;
1050 [ - + ]: 288 : if (radix == radix_hex)
1051 : : fmtstr = "%s %c%s %0*" PRIx64 " %0*" PRIx64 "\n";
1052 [ # # ]: 0 : else if (radix == radix_decimal)
1053 : : fmtstr = "%s %c%s %*" PRId64 " %*" PRId64 "\n";
1054 : : else
1055 : 0 : fmtstr = "%s %c%s %0*" PRIo64 " %0*" PRIo64 "\n";
1056 : :
1057 : 288 : int digits = length_map[gelf_getclass (elf) - 1][radix];
1058 : :
1059 : : #ifdef USE_DEMANGLE
1060 : 288 : size_t demangle_buffer_len = 0;
1061 : 288 : char *demangle_buffer = NULL;
1062 : : #endif
1063 : :
1064 : : /* Iterate over all symbols. */
1065 [ + + ]: 106971 : for (size_t cnt = 0; cnt < nsyms; ++cnt)
1066 : : {
1067 : : char symstrbuf[50];
1068 : 106683 : const char *symstr = sym_name (elf, strndx, syms[cnt].sym.st_name,
1069 : : symstrbuf, sizeof symstrbuf);
1070 : :
1071 : : /* Printing entries with a zero-length name makes the output
1072 : : not very well parseable. Since these entries don't carry
1073 : : much information we leave them out. */
1074 [ + + ]: 106683 : if (symstr[0] == '\0')
1075 : 5175 : continue;
1076 : :
1077 : : #ifdef USE_DEMANGLE
1078 : : /* Demangle if necessary. */
1079 [ - + ]: 101508 : if (demangle)
1080 : : {
1081 : 0 : int status = -1;
1082 : 0 : char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
1083 : : &demangle_buffer_len, &status);
1084 : :
1085 [ # # ]: 0 : if (status == 0)
1086 : 0 : symstr = dmsymstr;
1087 : : }
1088 : : #endif
1089 : :
1090 : : /* If we have to precede the line with the file name. */
1091 [ - + ]: 101508 : if (print_file_name)
1092 : : {
1093 : 0 : fputs_unlocked (fullname, stdout);
1094 : 0 : putchar_unlocked (':');
1095 : 0 : putchar_unlocked (' ');
1096 : : }
1097 : :
1098 [ - + ]: 203016 : printf (fmtstr,
1099 : : symstr,
1100 : 101508 : class_type_char (elf, ehdr, &syms[cnt].sym),
1101 : : mark_special
1102 : 0 : ? (GELF_ST_TYPE (syms[cnt].sym.st_info) == STT_TLS
1103 : : ? "@"
1104 [ # # ]: 0 : : (GELF_ST_BIND (syms[cnt].sym.st_info) == STB_WEAK
1105 [ # # ]: 0 : ? "*" : " "))
1106 : : : "",
1107 : : digits, syms[cnt].sym.st_value,
1108 : : digits, syms[cnt].sym.st_size);
1109 : : }
1110 : :
1111 : : #ifdef USE_DEMANGLE
1112 : : free (demangle_buffer);
1113 : : #endif
1114 : 288 : }
1115 : :
1116 : :
1117 : : /* Maximum size of memory we allocate on the stack. */
1118 : : #define MAX_STACK_ALLOC 65536
1119 : :
1120 : : static int
1121 : 819927 : sort_by_address (const void *p1, const void *p2)
1122 : : {
1123 : 819927 : GElf_SymX *s1 = (GElf_SymX *) p1;
1124 : 819927 : GElf_SymX *s2 = (GElf_SymX *) p2;
1125 : :
1126 : 1639854 : int result = (s1->sym.st_value < s2->sym.st_value
1127 [ + + ]: 819927 : ? -1 : (s1->sym.st_value == s2->sym.st_value ? 0 : 1));
1128 : :
1129 [ - + ]: 819927 : return reverse_sort ? -result : result;
1130 : : }
1131 : :
1132 : : static Elf_Data *sort_by_name_strtab;
1133 : :
1134 : : static int
1135 : 859011 : sort_by_name (const void *p1, const void *p2)
1136 : : {
1137 : 859011 : GElf_SymX *s1 = (GElf_SymX *) p1;
1138 : 859011 : GElf_SymX *s2 = (GElf_SymX *) p2;
1139 : :
1140 : 859011 : const char *n1 = sort_by_name_strtab->d_buf + s1->sym.st_name;
1141 : 859011 : const char *n2 = sort_by_name_strtab->d_buf + s2->sym.st_name;
1142 : :
1143 : 859011 : int result = strcmp (n1, n2);
1144 : :
1145 [ + - ]: 859011 : return reverse_sort ? -result : result;
1146 : : }
1147 : :
1148 : : static void
1149 : 864 : show_symbols (Ebl *ebl, GElf_Ehdr *ehdr, Elf_Scn *scn, Elf_Scn *xndxscn,
1150 : : GElf_Shdr *shdr, const char *prefix, const char *fname,
1151 : : const char *fullname)
1152 : : {
1153 : : /* Get the section header string table index. */
1154 : : size_t shstrndx;
1155 [ - + ]: 864 : if (elf_getshdrstrndx (ebl->elf, &shstrndx) < 0)
1156 : : error (EXIT_FAILURE, 0,
1157 : 0 : gettext ("cannot get section header string table index"));
1158 : :
1159 : : /* The section is that large. */
1160 : 864 : size_t size = shdr->sh_size;
1161 : : /* One entry is this large. */
1162 : 864 : size_t entsize = shdr->sh_entsize;
1163 : :
1164 : : /* Consistency checks. */
1165 [ - + ]: 864 : if (entsize != gelf_fsize (ebl->elf, ELF_T_SYM, 1, ehdr->e_version))
1166 : 0 : error (0, 0,
1167 : 0 : gettext ("%s: entry size in section `%s' is not what we expect"),
1168 : 0 : fullname, elf_strptr (ebl->elf, shstrndx, shdr->sh_name));
1169 [ - + ]: 864 : else if (size % entsize != 0)
1170 : 0 : error (0, 0,
1171 : 0 : gettext ("%s: size of section `%s' is not multiple of entry size"),
1172 : 0 : fullname, elf_strptr (ebl->elf, shstrndx, shdr->sh_name));
1173 : :
1174 : : /* Compute number of entries. Handle buggy entsize values. */
1175 [ + - ]: 864 : size_t nentries = size / (entsize ?: 1);
1176 : :
1177 : :
1178 : : #define obstack_chunk_alloc xmalloc
1179 : : #define obstack_chunk_free free
1180 : : struct obstack whereob;
1181 : 864 : obstack_init (&whereob);
1182 : :
1183 : : /* Get a DWARF debugging descriptor. It's no problem if this isn't
1184 : : possible. We just won't print any line number information. */
1185 : 864 : Dwarf *dbg = NULL;
1186 [ + + ]: 864 : if (format == format_sysv)
1187 : : {
1188 : 288 : dbg = dwarf_begin_elf (ebl->elf, DWARF_C_READ, NULL);
1189 [ + - ]: 288 : if (dbg != NULL)
1190 : : {
1191 : 288 : (void) dwarf_getpubnames (dbg, get_global, NULL, 0);
1192 : :
1193 : 288 : get_local_names (dbg);
1194 : : }
1195 : : }
1196 : :
1197 : : /* Allocate the memory.
1198 : :
1199 : : XXX We can use a dirty trick here. Since GElf_Sym == Elf64_Sym we
1200 : : can use the data memory instead of copying again if what we read
1201 : : is a 64 bit file. */
1202 : : GElf_SymX *sym_mem;
1203 [ + + ]: 864 : if (nentries * sizeof (GElf_SymX) < MAX_STACK_ALLOC)
1204 : 783 : sym_mem = (GElf_SymX *) alloca (nentries * sizeof (GElf_SymX));
1205 : : else
1206 : 81 : sym_mem = (GElf_SymX *) xmalloc (nentries * sizeof (GElf_SymX));
1207 : :
1208 : : /* Get the data of the section. */
1209 : 864 : Elf_Data *data = elf_getdata (scn, NULL);
1210 : 864 : Elf_Data *xndxdata = elf_getdata (xndxscn, NULL);
1211 [ + - ][ - + ]: 864 : if (data == NULL || (xndxscn != NULL && xndxdata == NULL))
1212 : 0 : INTERNAL_ERROR (fullname);
1213 : :
1214 : : /* Iterate over all symbols. */
1215 : : #ifdef USE_DEMANGLE
1216 : 864 : size_t demangle_buffer_len = 0;
1217 : 864 : char *demangle_buffer = NULL;
1218 : : #endif
1219 : 864 : int longest_name = 4;
1220 : 864 : int longest_where = 4;
1221 : 864 : size_t nentries_used = 0;
1222 [ + + ]: 446787 : for (size_t cnt = 0; cnt < nentries; ++cnt)
1223 : : {
1224 : 445923 : GElf_Sym *sym = gelf_getsymshndx (data, xndxdata, cnt,
1225 : : &sym_mem[nentries_used].sym,
1226 : 445923 : &sym_mem[nentries_used].xndx);
1227 [ - + ]: 445923 : if (sym == NULL)
1228 : 0 : INTERNAL_ERROR (fullname);
1229 : :
1230 : : /* Filter out administrative symbols without a name and those
1231 : : deselected by the user with command line options. */
1232 [ + + ][ + + ]: 445923 : if ((hide_undefined && sym->st_shndx == SHN_UNDEF)
1233 [ - + ][ # # ]: 434169 : || (hide_defined && sym->st_shndx != SHN_UNDEF)
1234 [ + + ][ + + ]: 434169 : || (hide_local && GELF_ST_BIND (sym->st_info) == STB_LOCAL))
1235 : 125874 : continue;
1236 : :
1237 : 320049 : sym_mem[nentries_used].where = "";
1238 [ + + ]: 320049 : if (format == format_sysv)
1239 : : {
1240 : 106683 : const char *symstr = elf_strptr (ebl->elf, shdr->sh_link,
1241 : 106683 : sym->st_name);
1242 [ - + ]: 106683 : if (symstr == NULL)
1243 : 0 : continue;
1244 : :
1245 : : #ifdef USE_DEMANGLE
1246 : : /* Demangle if necessary. */
1247 [ - + ]: 106683 : if (demangle)
1248 : : {
1249 : 0 : int status = -1;
1250 : 0 : char *dmsymstr = __cxa_demangle (symstr, demangle_buffer,
1251 : : &demangle_buffer_len, &status);
1252 : :
1253 [ # # ]: 0 : if (status == 0)
1254 : 0 : symstr = dmsymstr;
1255 : : }
1256 : : #endif
1257 : :
1258 [ + + ]: 106683 : longest_name = MAX ((size_t) longest_name, strlen (symstr));
1259 : :
1260 [ + + ]: 106683 : if (sym->st_shndx != SHN_UNDEF
1261 [ + + ]: 95010 : && GELF_ST_BIND (sym->st_info) != STB_LOCAL
1262 [ - + ]: 19023 : && global_root != NULL)
1263 : : {
1264 : 0 : Dwarf_Global fake = { .name = symstr };
1265 : 0 : Dwarf_Global **found = tfind (&fake, &global_root,
1266 : : global_compare);
1267 [ # # ]: 0 : if (found != NULL)
1268 : : {
1269 : : Dwarf_Die die_mem;
1270 : 0 : Dwarf_Die *die = dwarf_offdie (dbg, (*found)->die_offset,
1271 : : &die_mem);
1272 : :
1273 : : Dwarf_Die cudie_mem;
1274 : 0 : Dwarf_Die *cudie = NULL;
1275 : :
1276 : : Dwarf_Addr lowpc;
1277 : : Dwarf_Addr highpc;
1278 [ # # ]: 0 : if (die != NULL
1279 [ # # ]: 0 : && dwarf_lowpc (die, &lowpc) == 0
1280 [ # # ]: 0 : && lowpc <= sym->st_value
1281 [ # # ]: 0 : && dwarf_highpc (die, &highpc) == 0
1282 [ # # ]: 0 : && highpc > sym->st_value)
1283 : 0 : cudie = dwarf_offdie (dbg, (*found)->cu_offset,
1284 : : &cudie_mem);
1285 [ # # ]: 0 : if (cudie != NULL)
1286 : : {
1287 : 0 : Dwarf_Line *line = dwarf_getsrc_die (cudie,
1288 : : sym->st_value);
1289 [ # # ]: 0 : if (line != NULL)
1290 : : {
1291 : : /* We found the line. */
1292 : : int lineno;
1293 : 0 : (void) dwarf_lineno (line, &lineno);
1294 : : int n;
1295 : 0 : n = obstack_printf (&whereob, "%s:%d%c",
1296 : : basename (dwarf_linesrc (line,
1297 : : NULL,
1298 : : NULL)),
1299 : : lineno, '\0');
1300 : : sym_mem[nentries_used].where
1301 [ # # ][ # # ]: 0 : = obstack_finish (&whereob);
1302 : :
1303 : : /* The return value of obstack_print included the
1304 : : NUL byte, so subtract one. */
1305 [ # # ]: 0 : if (--n > (int) longest_where)
1306 : 0 : longest_where = (size_t) n;
1307 : : }
1308 : : }
1309 : : }
1310 : : }
1311 : :
1312 : : /* Try to find the symbol among the local symbols. */
1313 [ + - ]: 106683 : if (sym_mem[nentries_used].where[0] == '\0')
1314 : : {
1315 : 213366 : struct local_name fake =
1316 : : {
1317 : : .name = symstr,
1318 : 106683 : .lowpc = sym->st_value,
1319 : : .highpc = sym->st_value,
1320 : : };
1321 : 106683 : struct local_name **found = tfind (&fake, &local_root,
1322 : : local_compare);
1323 [ + + ]: 106683 : if (found != NULL)
1324 : : {
1325 : : /* We found the line. */
1326 : 27780 : int n = obstack_printf (&whereob, "%s:%" PRIu64 "%c",
1327 : : basename ((*found)->file),
1328 : 27780 : (*found)->lineno,
1329 : : '\0');
1330 [ - + ][ - + ]: 27780 : sym_mem[nentries_used].where = obstack_finish (&whereob);
1331 : :
1332 : : /* The return value of obstack_print included the
1333 : : NUL byte, so subtract one. */
1334 [ + + ]: 27780 : if (--n > (int) longest_where)
1335 : 106683 : longest_where = (size_t) n;
1336 : : }
1337 : : }
1338 : : }
1339 : :
1340 : : /* We use this entry. */
1341 : 320049 : ++nentries_used;
1342 : : }
1343 : : #ifdef USE_DEMANGLE
1344 : : free (demangle_buffer);
1345 : : #endif
1346 : : /* Now we know the exact number. */
1347 : 864 : nentries = nentries_used;
1348 : :
1349 : : /* Sort the entries according to the users wishes. */
1350 [ + + ]: 864 : if (sort == sort_name)
1351 : : {
1352 : 288 : sort_by_name_strtab = elf_getdata (elf_getscn (ebl->elf, shdr->sh_link),
1353 : : NULL);
1354 : 288 : qsort (sym_mem, nentries, sizeof (GElf_SymX), sort_by_name);
1355 : : }
1356 [ + + ]: 576 : else if (sort == sort_numeric)
1357 : 288 : qsort (sym_mem, nentries, sizeof (GElf_SymX), sort_by_address);
1358 : :
1359 : : /* Finally print according to the users selection. */
1360 [ + + + ]: 864 : switch (format)
1361 : : {
1362 : : case format_sysv:
1363 : 288 : show_symbols_sysv (ebl, shdr->sh_link, fullname, sym_mem, nentries,
1364 : : longest_name, longest_where);
1365 : 288 : break;
1366 : :
1367 : : case format_bsd:
1368 : 288 : show_symbols_bsd (ebl->elf, ehdr, shdr->sh_link, prefix, fname, fullname,
1369 : : sym_mem, nentries);
1370 : 288 : break;
1371 : :
1372 : : case format_posix:
1373 : : default:
1374 [ - + ]: 288 : assert (format == format_posix);
1375 : 288 : show_symbols_posix (ebl->elf, ehdr, shdr->sh_link, prefix, fullname,
1376 : : sym_mem, nentries);
1377 : 288 : break;
1378 : : }
1379 : :
1380 : : /* Free all memory. */
1381 [ - + ]: 864 : if (nentries * sizeof (GElf_Sym) >= MAX_STACK_ALLOC)
1382 : 0 : free (sym_mem);
1383 : :
1384 : 864 : obstack_free (&whereob, NULL);
1385 : :
1386 [ + + ]: 864 : if (dbg != NULL)
1387 : : {
1388 : 288 : tdestroy (global_root, free);
1389 : 288 : global_root = NULL;
1390 : :
1391 : 288 : tdestroy (local_root, free);
1392 : 288 : local_root = NULL;
1393 : :
1394 : 288 : (void) dwarf_end (dbg);
1395 : : }
1396 : 864 : }
1397 : :
1398 : :
1399 : : static int
1400 : 864 : handle_elf (Elf *elf, const char *prefix, const char *fname,
1401 : : const char *suffix)
1402 : : {
1403 [ - + ]: 864 : size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
1404 [ - + ]: 864 : size_t suffix_len = suffix == NULL ? 0 : strlen (suffix);
1405 : 864 : size_t fname_len = strlen (fname) + 1;
1406 : 864 : char fullname[prefix_len + 1 + fname_len + suffix_len];
1407 : 864 : char *cp = fullname;
1408 : 864 : Elf_Scn *scn = NULL;
1409 : 864 : int any = 0;
1410 : 864 : int result = 0;
1411 : : GElf_Ehdr ehdr_mem;
1412 : : GElf_Ehdr *ehdr;
1413 : : Ebl *ebl;
1414 : :
1415 : : /* Get the backend for this object file type. */
1416 : 864 : ebl = ebl_openbackend (elf);
1417 : :
1418 : : /* We need the ELF header in a few places. */
1419 : 864 : ehdr = gelf_getehdr (elf, &ehdr_mem);
1420 [ - + ]: 864 : if (ehdr == NULL)
1421 : 0 : INTERNAL_ERROR (fullname);
1422 : :
1423 : : /* If we are asked to print the dynamic symbol table and this is
1424 : : executable or dynamic executable, fail. */
1425 [ + + ]: 864 : if (symsec_type == SHT_DYNSYM
1426 [ + + ][ - + ]: 216 : && ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
1427 : : {
1428 : : /* XXX Add machine specific object file types. */
1429 [ # # ][ # # ]: 0 : error (0, 0, gettext ("%s%s%s%s: Invalid operation"),
[ # # ]
1430 : : prefix ?: "", prefix ? "(" : "", fname, prefix ? ")" : "");
1431 : 0 : result = 1;
1432 : 0 : goto out;
1433 : : }
1434 : :
1435 : : /* Create the full name of the file. */
1436 [ - + ]: 864 : if (prefix != NULL)
1437 : 0 : cp = mempcpy (cp, prefix, prefix_len);
1438 : 864 : cp = mempcpy (cp, fname, fname_len);
1439 [ - + ]: 864 : if (suffix != NULL)
1440 : 864 : memcpy (cp - 1, suffix, suffix_len + 1);
1441 : :
1442 : : /* Find the symbol table.
1443 : :
1444 : : XXX Can there be more than one? Do we print all? Currently we do. */
1445 [ + + ]: 32472 : while ((scn = elf_nextscn (elf, scn)) != NULL)
1446 : : {
1447 : : GElf_Shdr shdr_mem;
1448 : 31608 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1449 : :
1450 [ - + ]: 31608 : if (shdr == NULL)
1451 : 0 : INTERNAL_ERROR (fullname);
1452 : :
1453 [ + + ]: 31608 : if (shdr->sh_type == symsec_type)
1454 : : {
1455 : 864 : Elf_Scn *xndxscn = NULL;
1456 : :
1457 : : /* We have a symbol table. First make sure we remember this. */
1458 : 864 : any = 1;
1459 : :
1460 : : /* Look for an extended section index table for this section. */
1461 [ + + ]: 864 : if (symsec_type == SHT_SYMTAB)
1462 : : {
1463 : 648 : size_t scnndx = elf_ndxscn (scn);
1464 : :
1465 [ + + ]: 24354 : while ((xndxscn = elf_nextscn (elf, xndxscn)) != NULL)
1466 : : {
1467 : : GElf_Shdr xndxshdr_mem;
1468 : 23706 : GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);
1469 : :
1470 [ - + ]: 23706 : if (xndxshdr == NULL)
1471 : 0 : INTERNAL_ERROR (fullname);
1472 : :
1473 [ - + ]: 23706 : if (xndxshdr->sh_type == SHT_SYMTAB_SHNDX
1474 [ # # ]: 23706 : && xndxshdr->sh_link == scnndx)
1475 : : break;
1476 : : }
1477 : : }
1478 : :
1479 : 31608 : show_symbols (ebl, ehdr, scn, xndxscn, shdr, prefix, fname,
1480 : : fullname);
1481 : : }
1482 : : }
1483 : :
1484 [ - + ]: 864 : if (! any)
1485 : : {
1486 [ # # ][ # # ]: 0 : error (0, 0, gettext ("%s%s%s: no symbols"),
1487 : : prefix ?: "", prefix ? ":" : "", fname);
1488 : 0 : result = 1;
1489 : : }
1490 : :
1491 : : out:
1492 : : /* Close the ELF backend library descriptor. */
1493 : 864 : ebl_closebackend (ebl);
1494 : :
1495 : 864 : return result;
1496 : : }
1497 : :
1498 : :
1499 : 387099 : #include "debugpred.h"
|
