1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2015 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program 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.
11 This program is distributed in the hope that it will be useful,
12 but 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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "aout/stab_gnu.h"
26 #include "aout/ranlib.h"
28 #include "libiberty.h"
30 #include "elf/common.h"
31 #define DO_NOT_DEFINE_AOUTHDR
32 #define DO_NOT_DEFINE_FILHDR
33 #define DO_NOT_DEFINE_LINENO
34 #define DO_NOT_DEFINE_SCNHDR
35 #include "coff/external.h"
36 #include "coff/internal.h"
41 /* When sorting by size, we use this structure to hold the size and a
42 pointer to the minisymbol. */
50 /* When fetching relocs, we use this structure to pass information to
53 struct get_relocs_info
61 struct extended_symbol_info
65 elf_symbol_type *elfinfo;
66 coff_symbol_type *coffinfo;
67 /* FIXME: We should add more fields for Type, Line, Section. */
69 #define SYM_NAME(sym) (sym->sinfo->name)
70 #define SYM_VALUE(sym) (sym->sinfo->value)
71 #define SYM_TYPE(sym) (sym->sinfo->type)
72 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
73 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
74 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
75 #define SYM_SIZE(sym) \
76 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
78 /* The output formatting functions. */
79 static void print_object_filename_bsd (char *);
80 static void print_object_filename_sysv (char *);
81 static void print_object_filename_posix (char *);
82 static void print_archive_filename_bsd (char *);
83 static void print_archive_filename_sysv (char *);
84 static void print_archive_filename_posix (char *);
85 static void print_archive_member_bsd (char *, const char *);
86 static void print_archive_member_sysv (char *, const char *);
87 static void print_archive_member_posix (char *, const char *);
88 static void print_symbol_filename_bsd (bfd *, bfd *);
89 static void print_symbol_filename_sysv (bfd *, bfd *);
90 static void print_symbol_filename_posix (bfd *, bfd *);
91 static void print_value (bfd *, bfd_vma);
92 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
93 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
94 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
96 /* Support for different output formats. */
99 /* Print the name of an object file given on the command line. */
100 void (*print_object_filename) (char *);
102 /* Print the name of an archive file given on the command line. */
103 void (*print_archive_filename) (char *);
105 /* Print the name of an archive member file. */
106 void (*print_archive_member) (char *, const char *);
108 /* Print the name of the file (and archive, if there is one)
109 containing a symbol. */
110 void (*print_symbol_filename) (bfd *, bfd *);
112 /* Print a line of information about a symbol. */
113 void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
116 static struct output_fns formats[] =
118 {print_object_filename_bsd,
119 print_archive_filename_bsd,
120 print_archive_member_bsd,
121 print_symbol_filename_bsd,
122 print_symbol_info_bsd},
123 {print_object_filename_sysv,
124 print_archive_filename_sysv,
125 print_archive_member_sysv,
126 print_symbol_filename_sysv,
127 print_symbol_info_sysv},
128 {print_object_filename_posix,
129 print_archive_filename_posix,
130 print_archive_member_posix,
131 print_symbol_filename_posix,
132 print_symbol_info_posix}
135 /* Indices in `formats'. */
137 #define FORMAT_SYSV 1
138 #define FORMAT_POSIX 2
139 #define FORMAT_DEFAULT FORMAT_BSD
141 /* The output format to use. */
142 static struct output_fns *format = &formats[FORMAT_DEFAULT];
144 /* Command options. */
146 static int do_demangle = 0; /* Pretty print C++ symbol names. */
147 static int external_only = 0; /* Print external symbols only. */
148 static int defined_only = 0; /* Print defined symbols only. */
149 static int no_sort = 0; /* Don't sort; print syms in order found. */
150 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
151 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
152 static int print_size = 0; /* Print size of defined symbols. */
153 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
154 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
155 static int sort_by_size = 0; /* Sort by size of symbol. */
156 static int undefined_only = 0; /* Print undefined symbols only. */
157 static int dynamic = 0; /* Print dynamic symbols. */
158 static int show_version = 0; /* Show the version number. */
159 static int show_stats = 0; /* Show statistics. */
160 static int show_synthetic = 0; /* Display synthesized symbols too. */
161 static int line_numbers = 0; /* Print line numbers for symbols. */
162 static int allow_special_symbols = 0; /* Allow special symbols. */
164 /* When to print the names of files. Not mutually exclusive in SYSV format. */
165 static int filename_per_file = 0; /* Once per file, on its own line. */
166 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
168 /* Print formats for printing a symbol value. */
169 static char value_format_32bit[] = "%08lx";
170 #if BFD_HOST_64BIT_LONG
171 static char value_format_64bit[] = "%016lx";
172 #elif BFD_HOST_64BIT_LONG_LONG
174 static char value_format_64bit[] = "%016llx";
176 static char value_format_64bit[] = "%016I64x";
179 static int print_width = 0;
180 static int print_radix = 16;
181 /* Print formats for printing stab info. */
182 static char other_format[] = "%02x";
183 static char desc_format[] = "%04x";
185 static char *target = NULL;
186 #if BFD_SUPPORTS_PLUGINS
187 static const char *plugin_target = "plugin";
189 static const char *plugin_target = NULL;
192 /* Used to cache the line numbers for a BFD. */
193 static bfd *lineno_cache_bfd;
194 static bfd *lineno_cache_rel_bfd;
196 #define OPTION_TARGET 200
197 #define OPTION_PLUGIN (OPTION_TARGET + 1)
198 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
200 static struct option long_options[] =
202 {"debug-syms", no_argument, &print_debug_syms, 1},
203 {"demangle", optional_argument, 0, 'C'},
204 {"dynamic", no_argument, &dynamic, 1},
205 {"extern-only", no_argument, &external_only, 1},
206 {"format", required_argument, 0, 'f'},
207 {"help", no_argument, 0, 'h'},
208 {"line-numbers", no_argument, 0, 'l'},
209 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
210 {"no-demangle", no_argument, &do_demangle, 0},
211 {"no-sort", no_argument, 0, 'p'},
212 {"numeric-sort", no_argument, 0, 'n'},
213 {"plugin", required_argument, 0, OPTION_PLUGIN},
214 {"portability", no_argument, 0, 'P'},
215 {"print-armap", no_argument, &print_armap, 1},
216 {"print-file-name", no_argument, 0, 'o'},
217 {"print-size", no_argument, 0, 'S'},
218 {"radix", required_argument, 0, 't'},
219 {"reverse-sort", no_argument, &reverse_sort, 1},
220 {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
221 {"special-syms", no_argument, &allow_special_symbols, 1},
222 {"stats", no_argument, &show_stats, 1},
223 {"synthetic", no_argument, &show_synthetic, 1},
224 {"target", required_argument, 0, OPTION_TARGET},
225 {"defined-only", no_argument, &defined_only, 1},
226 {"undefined-only", no_argument, &undefined_only, 1},
227 {"version", no_argument, &show_version, 1},
228 {0, no_argument, 0, 0}
231 /* Some error-reporting functions. */
234 usage (FILE *stream, int status)
236 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
237 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
238 fprintf (stream, _(" The options are:\n\
239 -a, --debug-syms Display debugger-only symbols\n\
240 -A, --print-file-name Print name of the input file before every symbol\n\
241 -B Same as --format=bsd\n\
242 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
243 The STYLE, if specified, can be `auto' (the default),\n\
244 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
246 --no-demangle Do not demangle low-level symbol names\n\
247 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
248 --defined-only Display only defined symbols\n\
250 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
251 `sysv' or `posix'. The default is `bsd'\n\
252 -g, --extern-only Display only external symbols\n\
253 -l, --line-numbers Use debugging information to find a filename and\n\
254 line number for each symbol\n\
255 -n, --numeric-sort Sort symbols numerically by address\n\
257 -p, --no-sort Do not sort the symbols\n\
258 -P, --portability Same as --format=posix\n\
259 -r, --reverse-sort Reverse the sense of the sort\n"));
260 #if BFD_SUPPORTS_PLUGINS
261 fprintf (stream, _("\
262 --plugin NAME Load the specified plugin\n"));
264 fprintf (stream, _("\
265 -S, --print-size Print size of defined symbols\n\
266 -s, --print-armap Include index for symbols from archive members\n\
267 --size-sort Sort symbols by size\n\
268 --special-syms Include special symbols in the output\n\
269 --synthetic Display synthetic symbols as well\n\
270 -t, --radix=RADIX Use RADIX for printing symbol values\n\
271 --target=BFDNAME Specify the target object format as BFDNAME\n\
272 -u, --undefined-only Display only undefined symbols\n\
273 -X 32_64 (ignored)\n\
274 @FILE Read options from FILE\n\
275 -h, --help Display this information\n\
276 -V, --version Display this program's version number\n\
278 list_supported_targets (program_name, stream);
279 if (REPORT_BUGS_TO[0] && status == 0)
280 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
284 /* Set the radix for the symbol value and size according to RADIX. */
287 set_print_radix (char *radix)
299 value_format_32bit[4] = *radix;
300 #if BFD_HOST_64BIT_LONG
301 value_format_64bit[5] = *radix;
302 #elif BFD_HOST_64BIT_LONG_LONG
304 value_format_64bit[6] = *radix;
306 value_format_64bit[7] = *radix;
309 other_format[3] = desc_format[3] = *radix;
312 fatal (_("%s: invalid radix"), radix);
317 set_output_format (char *f)
336 fatal (_("%s: invalid output format"), f);
338 format = &formats[i];
342 get_elf_symbol_type (unsigned int type)
344 static char buff [32];
348 case STT_NOTYPE: return "NOTYPE";
349 case STT_OBJECT: return "OBJECT";
350 case STT_FUNC: return "FUNC";
351 case STT_SECTION: return "SECTION";
352 case STT_FILE: return "FILE";
353 case STT_COMMON: return "COMMON";
354 case STT_TLS: return "TLS";
356 if (type >= STT_LOPROC && type <= STT_HIPROC)
357 sprintf (buff, _("<processor specific>: %d"), type);
358 else if (type >= STT_LOOS && type <= STT_HIOS)
359 sprintf (buff, _("<OS specific>: %d"), type);
361 sprintf (buff, _("<unknown>: %d"), type);
367 get_coff_symbol_type (const struct internal_syment *sym)
369 static char buff [32];
371 switch (sym->n_sclass)
373 case C_BLOCK: return "Block";
374 case C_FILE: return "File";
375 case C_LINE: return "Line";
381 switch (DTYPE(sym->n_type))
383 case DT_FCN: return "Function";
384 case DT_PTR: return "Pointer";
385 case DT_ARY: return "Array";
388 sprintf (buff, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
392 /* Print symbol name NAME, read from ABFD, with printf format FORM,
393 demangling it if requested. */
396 print_symname (const char *form, const char *name, bfd *abfd)
398 if (do_demangle && *name)
400 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
414 print_symdef_entry (bfd *abfd)
416 symindex idx = BFD_NO_MORE_SYMBOLS;
418 bfd_boolean everprinted = FALSE;
420 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
421 idx != BFD_NO_MORE_SYMBOLS;
422 idx = bfd_get_next_mapent (abfd, idx, &thesym))
427 printf (_("\nArchive index:\n"));
430 elt = bfd_get_elt_at_index (abfd, idx);
432 bfd_fatal ("bfd_get_elt_at_index");
433 if (thesym->name != (char *) NULL)
435 print_symname ("%s", thesym->name, abfd);
436 printf (" in %s\n", bfd_get_filename (elt));
441 /* Choose which symbol entries to print;
442 compact them downward to get rid of the rest.
443 Return the number of symbols to be printed. */
446 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
447 long symcount, unsigned int size)
449 bfd_byte *from, *fromend, *to;
452 store = bfd_make_empty_symbol (abfd);
454 bfd_fatal (bfd_get_filename (abfd));
456 from = (bfd_byte *) minisyms;
457 fromend = from + symcount * size;
458 to = (bfd_byte *) minisyms;
460 for (; from < fromend; from += size)
467 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
469 bfd_fatal (bfd_get_filename (abfd));
471 if (strcmp (sym->name, "__gnu_lto_slim") == 0)
472 non_fatal (_("%s: plugin needed to handle lto object"),
473 bfd_get_filename (abfd));
476 keep = bfd_is_und_section (sym->section);
477 else if (external_only)
478 /* PR binutls/12753: Unique symbols are global too. */
479 keep = ((sym->flags & (BSF_GLOBAL
481 | BSF_GNU_UNIQUE)) != 0
482 || bfd_is_und_section (sym->section)
483 || bfd_is_com_section (sym->section));
488 && ! print_debug_syms
489 && (sym->flags & BSF_DEBUGGING) != 0)
494 && (bfd_is_abs_section (sym->section)
495 || bfd_is_und_section (sym->section)))
501 if (bfd_is_und_section (sym->section))
506 && bfd_is_target_special_symbol (abfd, sym)
507 && ! allow_special_symbols)
513 memcpy (to, from, size);
518 return (to - (bfd_byte *) minisyms) / size;
521 /* These globals are used to pass information into the sorting
523 static bfd *sort_bfd;
524 static bfd_boolean sort_dynamic;
525 static asymbol *sort_x;
526 static asymbol *sort_y;
528 /* Symbol-sorting predicates */
529 #define valueof(x) ((x)->section->vma + (x)->value)
531 /* Numeric sorts. Undefined symbols are always considered "less than"
532 defined symbols with zero values. Common symbols are not treated
533 specially -- i.e., their sizes are used as their "values". */
536 non_numeric_forward (const void *P_x, const void *P_y)
541 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
542 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
543 if (x == NULL || y == NULL)
544 bfd_fatal (bfd_get_filename (sort_bfd));
546 xn = bfd_asymbol_name (x);
547 yn = bfd_asymbol_name (y);
555 /* Solaris 2.5 has a bug in strcoll.
556 strcoll returns invalid values when confronted with empty strings. */
562 return strcoll (xn, yn);
564 return strcmp (xn, yn);
569 non_numeric_reverse (const void *x, const void *y)
571 return - non_numeric_forward (x, y);
575 numeric_forward (const void *P_x, const void *P_y)
580 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
581 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
582 if (x == NULL || y == NULL)
583 bfd_fatal (bfd_get_filename (sort_bfd));
585 xs = bfd_get_section (x);
586 ys = bfd_get_section (y);
588 if (bfd_is_und_section (xs))
590 if (! bfd_is_und_section (ys))
593 else if (bfd_is_und_section (ys))
595 else if (valueof (x) != valueof (y))
596 return valueof (x) < valueof (y) ? -1 : 1;
598 return non_numeric_forward (P_x, P_y);
602 numeric_reverse (const void *x, const void *y)
604 return - numeric_forward (x, y);
607 static int (*(sorters[2][2])) (const void *, const void *) =
609 { non_numeric_forward, non_numeric_reverse },
610 { numeric_forward, numeric_reverse }
613 /* This sort routine is used by sort_symbols_by_size. It is similar
614 to numeric_forward, but when symbols have the same value it sorts
615 by section VMA. This simplifies the sort_symbols_by_size code
616 which handles symbols at the end of sections. Also, this routine
617 tries to sort file names before other symbols with the same value.
618 That will make the file name have a zero size, which will make
619 sort_symbols_by_size choose the non file name symbol, leading to
620 more meaningful output. For similar reasons, this code sorts
621 gnu_compiled_* and gcc2_compiled before other symbols with the same
625 size_forward1 (const void *P_x, const void *P_y)
633 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
634 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
635 if (x == NULL || y == NULL)
636 bfd_fatal (bfd_get_filename (sort_bfd));
638 xs = bfd_get_section (x);
639 ys = bfd_get_section (y);
641 if (bfd_is_und_section (xs))
643 if (bfd_is_und_section (ys))
646 if (valueof (x) != valueof (y))
647 return valueof (x) < valueof (y) ? -1 : 1;
649 if (xs->vma != ys->vma)
650 return xs->vma < ys->vma ? -1 : 1;
652 xn = bfd_asymbol_name (x);
653 yn = bfd_asymbol_name (y);
657 /* The symbols gnu_compiled and gcc2_compiled convey even less
658 information than the file name, so sort them out first. */
660 xf = (strstr (xn, "gnu_compiled") != NULL
661 || strstr (xn, "gcc2_compiled") != NULL);
662 yf = (strstr (yn, "gnu_compiled") != NULL
663 || strstr (yn, "gcc2_compiled") != NULL);
670 /* We use a heuristic for the file name. It may not work on non
671 Unix systems, but it doesn't really matter; the only difference
672 is precisely which symbol names get printed. */
674 #define file_symbol(s, sn, snl) \
675 (((s)->flags & BSF_FILE) != 0 \
676 || ((sn)[(snl) - 2] == '.' \
677 && ((sn)[(snl) - 1] == 'o' \
678 || (sn)[(snl) - 1] == 'a')))
680 xf = file_symbol (x, xn, xnl);
681 yf = file_symbol (y, yn, ynl);
688 return non_numeric_forward (P_x, P_y);
691 /* This sort routine is used by sort_symbols_by_size. It is sorting
692 an array of size_sym structures into size order. */
695 size_forward2 (const void *P_x, const void *P_y)
697 const struct size_sym *x = (const struct size_sym *) P_x;
698 const struct size_sym *y = (const struct size_sym *) P_y;
700 if (x->size < y->size)
701 return reverse_sort ? 1 : -1;
702 else if (x->size > y->size)
703 return reverse_sort ? -1 : 1;
705 return sorters[0][reverse_sort] (x->minisym, y->minisym);
708 /* Sort the symbols by size. ELF provides a size but for other formats
709 we have to make a guess by assuming that the difference between the
710 address of a symbol and the address of the next higher symbol is the
714 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
715 long symcount, unsigned int size,
716 struct size_sym **symsizesp)
718 struct size_sym *symsizes;
719 bfd_byte *from, *fromend;
721 asymbol *store_sym, *store_next;
723 qsort (minisyms, symcount, size, size_forward1);
725 /* We are going to return a special set of symbols and sizes to
727 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
728 *symsizesp = symsizes;
730 /* Note that filter_symbols has already removed all absolute and
731 undefined symbols. Here we remove all symbols whose size winds
733 from = (bfd_byte *) minisyms;
734 fromend = from + symcount * size;
741 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
744 bfd_fatal (bfd_get_filename (abfd));
747 for (; from < fromend; from += size)
754 if (from + size < fromend)
756 next = bfd_minisymbol_to_symbol (abfd,
758 (const void *) (from + size),
761 bfd_fatal (bfd_get_filename (abfd));
766 sec = bfd_get_section (sym);
768 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
769 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
770 else if (bfd_is_com_section (sec))
774 if (from + size < fromend
775 && sec == bfd_get_section (next))
776 sz = valueof (next) - valueof (sym);
778 sz = (bfd_get_section_vma (abfd, sec)
779 + bfd_section_size (abfd, sec)
785 symsizes->minisym = (const void *) from;
793 store_sym = store_next;
797 symcount = symsizes - *symsizesp;
799 /* We must now sort again by size. */
800 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
805 /* This function is used to get the relocs for a particular section.
806 It is called via bfd_map_over_sections. */
809 get_relocs (bfd *abfd, asection *sec, void *dataarg)
811 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
815 if ((sec->flags & SEC_RELOC) == 0)
817 *data->relocs = NULL;
824 relsize = bfd_get_reloc_upper_bound (abfd, sec);
826 bfd_fatal (bfd_get_filename (abfd));
828 *data->relocs = (arelent **) xmalloc (relsize);
829 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
831 if (*data->relcount < 0)
832 bfd_fatal (bfd_get_filename (abfd));
840 /* Print a single symbol. */
843 print_symbol (bfd * abfd,
847 bfd_boolean is_synthetic)
850 struct extended_symbol_info info;
854 format->print_symbol_filename (archive_bfd, abfd);
856 bfd_get_symbol_info (abfd, sym, &syminfo);
858 info.sinfo = &syminfo;
860 /* Synthetic symbols do not have a full symbol type set of data available. */
864 info.coffinfo = NULL;
868 info.elfinfo = elf_symbol_from (abfd, sym);
869 info.coffinfo = coff_symbol_from (sym);
872 format->print_symbol_info (&info, abfd);
876 static asymbol **syms;
877 static long symcount;
878 const char *filename, *functionname;
881 /* We need to get the canonical symbols in order to call
882 bfd_find_nearest_line. This is inefficient, but, then, you
883 don't have to use --line-numbers. */
884 if (abfd != lineno_cache_bfd && syms != NULL)
893 symsize = bfd_get_symtab_upper_bound (abfd);
895 bfd_fatal (bfd_get_filename (abfd));
896 syms = (asymbol **) xmalloc (symsize);
897 symcount = bfd_canonicalize_symtab (abfd, syms);
899 bfd_fatal (bfd_get_filename (abfd));
900 lineno_cache_bfd = abfd;
903 if (bfd_is_und_section (bfd_get_section (sym)))
905 static asection **secs;
906 static arelent ***relocs;
907 static long *relcount;
908 static unsigned int seccount;
912 /* For an undefined symbol, we try to find a reloc for the
913 symbol, and print the line number of the reloc. */
914 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
916 for (i = 0; i < seccount; i++)
917 if (relocs[i] != NULL)
929 struct get_relocs_info rinfo;
931 seccount = bfd_count_sections (abfd);
933 secs = (asection **) xmalloc (seccount * sizeof *secs);
934 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
935 relcount = (long *) xmalloc (seccount * sizeof *relcount);
938 rinfo.relocs = relocs;
939 rinfo.relcount = relcount;
941 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
942 lineno_cache_rel_bfd = abfd;
945 symname = bfd_asymbol_name (sym);
946 for (i = 0; i < seccount; i++)
950 for (j = 0; j < relcount[i]; j++)
955 if (r->sym_ptr_ptr != NULL
956 && (*r->sym_ptr_ptr)->section == sym->section
957 && (*r->sym_ptr_ptr)->value == sym->value
959 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
960 && bfd_find_nearest_line (abfd, secs[i], syms,
961 r->address, &filename,
962 &functionname, &lineno)
965 /* We only print the first one we find. */
966 printf ("\t%s:%u", filename, lineno);
973 else if (bfd_get_section (sym)->owner == abfd)
975 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
976 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
977 syms, sym->value, &filename,
978 &functionname, &lineno))
981 printf ("\t%s:%u", filename, lineno);
988 /* Print the symbols when sorting by size. */
991 print_size_symbols (bfd * abfd,
992 bfd_boolean is_dynamic,
993 struct size_sym * symsizes,
999 struct size_sym *from;
1000 struct size_sym *fromend;
1001 struct size_sym *fromsynth;
1003 store = bfd_make_empty_symbol (abfd);
1005 bfd_fatal (bfd_get_filename (abfd));
1008 fromend = from + symcount;
1009 fromsynth = symsizes + (symcount - synth_count);
1011 for (; from < fromend; from++)
1015 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1017 bfd_fatal (bfd_get_filename (abfd));
1019 print_symbol (abfd, sym, from->size, archive_bfd, from >= fromsynth);
1024 /* Print the symbols of ABFD that are held in MINISYMS.
1026 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1028 SYMCOUNT is the number of symbols in MINISYMS and SYNTH_COUNT
1029 is the number of these that are synthetic. Synthetic symbols,
1030 if any are present, always come at the end of the MINISYMS.
1032 SIZE is the size of a symbol in MINISYMS. */
1035 print_symbols (bfd * abfd,
1036 bfd_boolean is_dynamic,
1046 bfd_byte *fromsynth;
1048 store = bfd_make_empty_symbol (abfd);
1050 bfd_fatal (bfd_get_filename (abfd));
1052 from = (bfd_byte *) minisyms;
1053 fromend = from + symcount * size;
1054 fromsynth = (bfd_byte *) minisyms + ((symcount - synth_count) * size);
1056 for (; from < fromend; from += size)
1060 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1062 bfd_fatal (bfd_get_filename (abfd));
1064 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd, from >= fromsynth);
1068 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1071 display_rel_file (bfd *abfd, bfd *archive_bfd)
1074 long synth_count = 0;
1077 struct size_sym *symsizes;
1081 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1083 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1088 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1091 if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1093 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1097 bfd_fatal (bfd_get_filename (abfd));
1102 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1106 if (show_synthetic && size == sizeof (asymbol *))
1109 asymbol **static_syms = NULL;
1110 asymbol **dyn_syms = NULL;
1111 long static_count = 0;
1116 dyn_count = symcount;
1117 dyn_syms = (asymbol **) minisyms;
1121 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1123 static_count = symcount;
1124 static_syms = (asymbol **) minisyms;
1128 dyn_syms = (asymbol **) xmalloc (storage);
1129 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1131 bfd_fatal (bfd_get_filename (abfd));
1135 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1136 dyn_count, dyn_syms, &synthsyms);
1137 if (synth_count > 0)
1143 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1144 symp = (asymbol **) new_mini;
1145 memcpy (symp, minisyms, symcount * sizeof (*symp));
1147 for (i = 0; i < synth_count; i++)
1148 *symp++ = synthsyms + i;
1150 minisyms = new_mini;
1151 symcount += synth_count;
1155 /* Discard the symbols we don't want to print.
1156 It's OK to do this in place; we'll free the storage anyway
1157 (after printing). */
1159 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1165 sort_dynamic = dynamic;
1166 sort_x = bfd_make_empty_symbol (abfd);
1167 sort_y = bfd_make_empty_symbol (abfd);
1168 if (sort_x == NULL || sort_y == NULL)
1169 bfd_fatal (bfd_get_filename (abfd));
1172 qsort (minisyms, symcount, size,
1173 sorters[sort_numerically][reverse_sort]);
1175 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1180 print_symbols (abfd, dynamic, minisyms, symcount, synth_count, size, archive_bfd);
1182 print_size_symbols (abfd, dynamic, symsizes, symcount, synth_count, archive_bfd);
1189 set_print_width (bfd *file)
1191 print_width = bfd_get_arch_size (file);
1193 if (print_width == -1)
1196 Guess the target's bitsize based on its name.
1197 We assume here than any 64-bit format will include
1198 "64" somewhere in its name. The only known exception
1199 is the MMO object file format. */
1200 if (strstr (bfd_get_target (file), "64") != NULL
1201 || strcmp (bfd_get_target (file), "mmo") == 0)
1209 display_archive (bfd *file)
1212 bfd *last_arfile = NULL;
1215 format->print_archive_filename (bfd_get_filename (file));
1218 print_symdef_entry (file);
1224 arfile = bfd_openr_next_archived_file (file, arfile);
1228 if (bfd_get_error () != bfd_error_no_more_archived_files)
1229 bfd_fatal (bfd_get_filename (file));
1233 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1235 set_print_width (arfile);
1236 format->print_archive_member (bfd_get_filename (file),
1237 bfd_get_filename (arfile));
1238 display_rel_file (arfile, file);
1242 bfd_nonfatal (bfd_get_filename (arfile));
1243 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1245 list_matching_formats (matching);
1250 if (last_arfile != NULL)
1252 bfd_close (last_arfile);
1253 lineno_cache_bfd = NULL;
1254 lineno_cache_rel_bfd = NULL;
1255 if (arfile == last_arfile)
1258 last_arfile = arfile;
1261 if (last_arfile != NULL)
1263 bfd_close (last_arfile);
1264 lineno_cache_bfd = NULL;
1265 lineno_cache_rel_bfd = NULL;
1270 display_file (char *filename)
1272 bfd_boolean retval = TRUE;
1276 if (get_file_size (filename) < 1)
1279 file = bfd_openr (filename, target ? target : plugin_target);
1282 bfd_nonfatal (filename);
1286 /* If printing line numbers, decompress the debug sections. */
1288 file->flags |= BFD_DECOMPRESS;
1290 if (bfd_check_format (file, bfd_archive))
1292 display_archive (file);
1294 else if (bfd_check_format_matches (file, bfd_object, &matching))
1296 set_print_width (file);
1297 format->print_object_filename (filename);
1298 display_rel_file (file, NULL);
1302 bfd_nonfatal (filename);
1303 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1305 list_matching_formats (matching);
1311 if (!bfd_close (file))
1312 bfd_fatal (filename);
1314 lineno_cache_bfd = NULL;
1315 lineno_cache_rel_bfd = NULL;
1320 /* The following 3 groups of functions are called unconditionally,
1321 once at the start of processing each file of the appropriate type.
1322 They should check `filename_per_file' and `filename_per_symbol',
1323 as appropriate for their output format, to determine whether to
1326 /* Print the name of an object file given on the command line. */
1329 print_object_filename_bsd (char *filename)
1331 if (filename_per_file && !filename_per_symbol)
1332 printf ("\n%s:\n", filename);
1336 print_object_filename_sysv (char *filename)
1339 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1341 printf (_("\n\nSymbols from %s:\n\n"), filename);
1342 if (print_width == 32)
1344 Name Value Class Type Size Line Section\n\n"));
1347 Name Value Class Type Size Line Section\n\n"));
1351 print_object_filename_posix (char *filename)
1353 if (filename_per_file && !filename_per_symbol)
1354 printf ("%s:\n", filename);
1357 /* Print the name of an archive file given on the command line. */
1360 print_archive_filename_bsd (char *filename)
1362 if (filename_per_file)
1363 printf ("\n%s:\n", filename);
1367 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1372 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1376 /* Print the name of an archive member file. */
1379 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1380 const char *filename)
1382 if (!filename_per_symbol)
1383 printf ("\n%s:\n", filename);
1387 print_archive_member_sysv (char *archive, const char *filename)
1390 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1392 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1393 if (print_width == 32)
1395 Name Value Class Type Size Line Section\n\n"));
1398 Name Value Class Type Size Line Section\n\n"));
1402 print_archive_member_posix (char *archive, const char *filename)
1404 if (!filename_per_symbol)
1405 printf ("%s[%s]:\n", archive, filename);
1408 /* Print the name of the file (and archive, if there is one)
1409 containing a symbol. */
1412 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1414 if (filename_per_symbol)
1417 printf ("%s:", bfd_get_filename (archive_bfd));
1418 printf ("%s:", bfd_get_filename (abfd));
1423 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1425 if (filename_per_symbol)
1428 printf ("%s:", bfd_get_filename (archive_bfd));
1429 printf ("%s:", bfd_get_filename (abfd));
1434 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1436 if (filename_per_symbol)
1439 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1440 bfd_get_filename (abfd));
1442 printf ("%s: ", bfd_get_filename (abfd));
1446 /* Print a symbol value. */
1449 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1451 switch (print_width)
1454 printf (value_format_32bit, (unsigned long) val);
1458 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1459 printf (value_format_64bit, val);
1461 /* We have a 64 bit value to print, but the host is only 32 bit. */
1462 if (print_radix == 16)
1463 bfd_fprintf_vma (abfd, stdout, val);
1469 s = buf + sizeof buf;
1473 *--s = (val % print_radix) + '0';
1476 while ((buf + sizeof buf - 1) - s < 16)
1484 fatal (_("Print width has not been initialized (%d)"), print_width);
1489 /* Print a line of information about a symbol. */
1492 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1494 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1496 if (print_width == 64)
1502 /* Normally we print the value of the symbol. If we are printing the
1503 size or sorting by size then we print its size, except for the
1504 (weird) special case where both flags are defined, in which case we
1505 print both values. This conforms to documented behaviour. */
1506 if (sort_by_size && !print_size)
1507 print_value (abfd, SYM_SIZE (info));
1509 print_value (abfd, SYM_VALUE (info));
1510 if (print_size && SYM_SIZE (info))
1513 print_value (abfd, SYM_SIZE (info));
1517 printf (" %c", SYM_TYPE (info));
1519 if (SYM_TYPE (info) == '-')
1523 printf (other_format, SYM_STAB_OTHER (info));
1525 printf (desc_format, SYM_STAB_DESC (info));
1526 printf (" %5s", SYM_STAB_NAME (info));
1528 print_symname (" %s", SYM_NAME (info), abfd);
1532 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1534 print_symname ("%-20s|", SYM_NAME (info), abfd);
1536 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1538 if (print_width == 32)
1544 print_value (abfd, SYM_VALUE (info));
1546 printf ("| %c |", SYM_TYPE (info));
1548 if (SYM_TYPE (info) == '-')
1551 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1552 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1553 printf ("| |"); /* Line, Section. */
1557 /* Type, Size, Line, Section */
1560 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1561 else if (info->coffinfo)
1563 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1567 if (SYM_SIZE (info))
1568 print_value (abfd, SYM_SIZE (info));
1571 if (print_width == 32)
1578 printf("| |%s", info->elfinfo->symbol.section->name);
1579 else if (info->coffinfo)
1580 printf("| |%s", info->coffinfo->symbol.section->name);
1587 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1589 print_symname ("%s ", SYM_NAME (info), abfd);
1590 printf ("%c ", SYM_TYPE (info));
1592 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1596 print_value (abfd, SYM_VALUE (info));
1598 if (SYM_SIZE (info))
1599 print_value (abfd, SYM_SIZE (info));
1604 main (int argc, char **argv)
1609 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1610 setlocale (LC_MESSAGES, "");
1612 #if defined (HAVE_SETLOCALE)
1613 setlocale (LC_CTYPE, "");
1614 setlocale (LC_COLLATE, "");
1616 bindtextdomain (PACKAGE, LOCALEDIR);
1617 textdomain (PACKAGE);
1619 program_name = *argv;
1620 xmalloc_set_program_name (program_name);
1621 bfd_set_error_program_name (program_name);
1622 #if BFD_SUPPORTS_PLUGINS
1623 bfd_plugin_set_program_name (program_name);
1626 START_PROGRESS (program_name, 0);
1628 expandargv (&argc, &argv);
1631 set_default_bfd_target ();
1633 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1634 long_options, (int *) 0)) != EOF)
1639 print_debug_syms = 1;
1643 filename_per_symbol = 1;
1645 case 'B': /* For MIPS compatibility. */
1646 set_output_format ("bsd");
1652 enum demangling_styles style;
1654 style = cplus_demangle_name_to_style (optarg);
1655 if (style == unknown_demangling)
1656 fatal (_("unknown demangling style `%s'"),
1659 cplus_demangle_set_style (style);
1666 /* Ignored for HP/UX compatibility. */
1669 set_output_format (optarg);
1683 sort_numerically = 1;
1688 sort_numerically = 0;
1691 case OPTION_SIZE_SORT:
1693 sort_numerically = 0;
1697 set_output_format ("posix");
1709 set_print_radix (optarg);
1718 /* Ignored for (partial) AIX compatibility. On AIX, the
1719 argument has values 32, 64, or 32_64, and specifies that
1720 only 32-bit, only 64-bit, or both kinds of objects should
1721 be examined. The default is 32. So plain AIX nm on a
1722 library archive with both kinds of objects will ignore
1723 the 64-bit ones. For GNU nm, the default is and always
1724 has been -X 32_64, and other options are not supported. */
1725 if (strcmp (optarg, "32_64") != 0)
1726 fatal (_("Only -X 32_64 is supported"));
1729 case OPTION_TARGET: /* --target */
1733 case OPTION_PLUGIN: /* --plugin */
1734 #if BFD_SUPPORTS_PLUGINS
1735 bfd_plugin_set_plugin (optarg);
1737 fatal (_("sorry - this program has been built without plugin support\n"));
1741 case 0: /* A long option that just sets a flag. */
1750 print_version ("nm");
1752 if (sort_by_size && undefined_only)
1754 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1755 non_fatal (_("will produce no output, since undefined symbols have no size."));
1759 /* OK, all options now parsed. If no filename specified, do a.out. */
1761 return !display_file ("a.out");
1765 if (argc - optind > 1)
1766 filename_per_file = 1;
1768 /* We were given several filenames to do. */
1769 while (optind < argc)
1772 if (!display_file (argv[optind++]))
1776 END_PROGRESS (program_name);
1781 char *lim = (char *) sbrk (0);
1783 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));