1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2017 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"
39 #include "plugin-api.h"
42 /* When sorting by size, we use this structure to hold the size and a
43 pointer to the minisymbol. */
51 /* When fetching relocs, we use this structure to pass information to
54 struct get_relocs_info
62 struct extended_symbol_info
66 elf_symbol_type *elfinfo;
67 coff_symbol_type *coffinfo;
68 /* FIXME: We should add more fields for Type, Line, Section. */
70 #define SYM_NAME(sym) (sym->sinfo->name)
71 #define SYM_VALUE(sym) (sym->sinfo->value)
72 #define SYM_TYPE(sym) (sym->sinfo->type)
73 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
74 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
75 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
76 #define SYM_SIZE(sym) \
77 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
79 /* The output formatting functions. */
80 static void print_object_filename_bsd (char *);
81 static void print_object_filename_sysv (char *);
82 static void print_object_filename_posix (char *);
83 static void print_archive_filename_bsd (char *);
84 static void print_archive_filename_sysv (char *);
85 static void print_archive_filename_posix (char *);
86 static void print_archive_member_bsd (char *, const char *);
87 static void print_archive_member_sysv (char *, const char *);
88 static void print_archive_member_posix (char *, const char *);
89 static void print_symbol_filename_bsd (bfd *, bfd *);
90 static void print_symbol_filename_sysv (bfd *, bfd *);
91 static void print_symbol_filename_posix (bfd *, bfd *);
92 static void print_value (bfd *, bfd_vma);
93 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
94 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
95 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
97 /* Support for different output formats. */
100 /* Print the name of an object file given on the command line. */
101 void (*print_object_filename) (char *);
103 /* Print the name of an archive file given on the command line. */
104 void (*print_archive_filename) (char *);
106 /* Print the name of an archive member file. */
107 void (*print_archive_member) (char *, const char *);
109 /* Print the name of the file (and archive, if there is one)
110 containing a symbol. */
111 void (*print_symbol_filename) (bfd *, bfd *);
113 /* Print a line of information about a symbol. */
114 void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
117 static struct output_fns formats[] =
119 {print_object_filename_bsd,
120 print_archive_filename_bsd,
121 print_archive_member_bsd,
122 print_symbol_filename_bsd,
123 print_symbol_info_bsd},
124 {print_object_filename_sysv,
125 print_archive_filename_sysv,
126 print_archive_member_sysv,
127 print_symbol_filename_sysv,
128 print_symbol_info_sysv},
129 {print_object_filename_posix,
130 print_archive_filename_posix,
131 print_archive_member_posix,
132 print_symbol_filename_posix,
133 print_symbol_info_posix}
136 /* Indices in `formats'. */
138 #define FORMAT_SYSV 1
139 #define FORMAT_POSIX 2
140 #define FORMAT_DEFAULT FORMAT_BSD
142 /* The output format to use. */
143 static struct output_fns *format = &formats[FORMAT_DEFAULT];
145 /* Command options. */
147 static int do_demangle = 0; /* Pretty print C++ symbol names. */
148 static int external_only = 0; /* Print external symbols only. */
149 static int defined_only = 0; /* Print defined symbols only. */
150 static int no_sort = 0; /* Don't sort; print syms in order found. */
151 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
152 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
153 static int print_size = 0; /* Print size of defined symbols. */
154 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
155 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
156 static int sort_by_size = 0; /* Sort by size of symbol. */
157 static int undefined_only = 0; /* Print undefined symbols only. */
158 static int dynamic = 0; /* Print dynamic symbols. */
159 static int show_version = 0; /* Show the version number. */
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. */
163 static int with_symbol_versions = 0; /* Include symbol version information in the output. */
165 /* When to print the names of files. Not mutually exclusive in SYSV format. */
166 static int filename_per_file = 0; /* Once per file, on its own line. */
167 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
169 /* Print formats for printing a symbol value. */
170 static char value_format_32bit[] = "%08lx";
171 #if BFD_HOST_64BIT_LONG
172 static char value_format_64bit[] = "%016lx";
173 #elif BFD_HOST_64BIT_LONG_LONG
175 static char value_format_64bit[] = "%016llx";
177 static char value_format_64bit[] = "%016I64x";
180 static int print_width = 0;
181 static int print_radix = 16;
182 /* Print formats for printing stab info. */
183 static char other_format[] = "%02x";
184 static char desc_format[] = "%04x";
186 static char *target = NULL;
187 #if BFD_SUPPORTS_PLUGINS
188 static const char *plugin_target = "plugin";
190 static const char *plugin_target = NULL;
193 /* Used to cache the line numbers for a BFD. */
194 static bfd *lineno_cache_bfd;
195 static bfd *lineno_cache_rel_bfd;
197 #define OPTION_TARGET 200
198 #define OPTION_PLUGIN (OPTION_TARGET + 1)
199 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
201 static struct option long_options[] =
203 {"debug-syms", no_argument, &print_debug_syms, 1},
204 {"demangle", optional_argument, 0, 'C'},
205 {"dynamic", no_argument, &dynamic, 1},
206 {"extern-only", no_argument, &external_only, 1},
207 {"format", required_argument, 0, 'f'},
208 {"help", no_argument, 0, 'h'},
209 {"line-numbers", no_argument, 0, 'l'},
210 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
211 {"no-demangle", no_argument, &do_demangle, 0},
212 {"no-sort", no_argument, 0, 'p'},
213 {"numeric-sort", no_argument, 0, 'n'},
214 {"plugin", required_argument, 0, OPTION_PLUGIN},
215 {"portability", no_argument, 0, 'P'},
216 {"print-armap", no_argument, &print_armap, 1},
217 {"print-file-name", no_argument, 0, 'o'},
218 {"print-size", no_argument, 0, 'S'},
219 {"radix", required_argument, 0, 't'},
220 {"reverse-sort", no_argument, &reverse_sort, 1},
221 {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
222 {"special-syms", no_argument, &allow_special_symbols, 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 {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
229 {0, no_argument, 0, 0}
232 /* Some error-reporting functions. */
234 ATTRIBUTE_NORETURN static void
235 usage (FILE *stream, int status)
237 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
238 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
239 fprintf (stream, _(" The options are:\n\
240 -a, --debug-syms Display debugger-only symbols\n\
241 -A, --print-file-name Print name of the input file before every symbol\n\
242 -B Same as --format=bsd\n\
243 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
244 The STYLE, if specified, can be `auto' (the default),\n\
245 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
247 --no-demangle Do not demangle low-level symbol names\n\
248 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
249 --defined-only Display only defined symbols\n\
251 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
252 `sysv' or `posix'. The default is `bsd'\n\
253 -g, --extern-only Display only external symbols\n\
254 -l, --line-numbers Use debugging information to find a filename and\n\
255 line number for each symbol\n\
256 -n, --numeric-sort Sort symbols numerically by address\n\
258 -p, --no-sort Do not sort the symbols\n\
259 -P, --portability Same as --format=posix\n\
260 -r, --reverse-sort Reverse the sense of the sort\n"));
261 #if BFD_SUPPORTS_PLUGINS
262 fprintf (stream, _("\
263 --plugin NAME Load the specified plugin\n"));
265 fprintf (stream, _("\
266 -S, --print-size Print size of defined symbols\n\
267 -s, --print-armap Include index for symbols from archive members\n\
268 --size-sort Sort symbols by size\n\
269 --special-syms Include special symbols in the output\n\
270 --synthetic Display synthetic symbols as well\n\
271 -t, --radix=RADIX Use RADIX for printing symbol values\n\
272 --target=BFDNAME Specify the target object format as BFDNAME\n\
273 -u, --undefined-only Display only undefined symbols\n\
274 --with-symbol-versions Display version strings after symbol names\n\
275 -X 32_64 (ignored)\n\
276 @FILE Read options from FILE\n\
277 -h, --help Display this information\n\
278 -V, --version Display this program's version number\n\
280 list_supported_targets (program_name, stream);
281 if (REPORT_BUGS_TO[0] && status == 0)
282 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
286 /* Set the radix for the symbol value and size according to RADIX. */
289 set_print_radix (char *radix)
301 value_format_32bit[4] = *radix;
302 #if BFD_HOST_64BIT_LONG
303 value_format_64bit[5] = *radix;
304 #elif BFD_HOST_64BIT_LONG_LONG
306 value_format_64bit[6] = *radix;
308 value_format_64bit[7] = *radix;
311 other_format[3] = desc_format[3] = *radix;
314 fatal (_("%s: invalid radix"), radix);
319 set_output_format (char *f)
338 fatal (_("%s: invalid output format"), f);
340 format = &formats[i];
344 get_elf_symbol_type (unsigned int type)
351 case STT_NOTYPE: return "NOTYPE";
352 case STT_OBJECT: return "OBJECT";
353 case STT_FUNC: return "FUNC";
354 case STT_SECTION: return "SECTION";
355 case STT_FILE: return "FILE";
356 case STT_COMMON: return "COMMON";
357 case STT_TLS: return "TLS";
361 if (type >= STT_LOPROC && type <= STT_HIPROC)
362 n = asprintf (&bufp, _("<processor specific>: %d"), type);
363 else if (type >= STT_LOOS && type <= STT_HIOS)
364 n = asprintf (&bufp, _("<OS specific>: %d"), type);
366 n = asprintf (&bufp, _("<unknown>: %d"), type);
368 fatal ("%s", xstrerror (errno));
373 get_coff_symbol_type (const struct internal_syment *sym)
378 switch (sym->n_sclass)
380 case C_BLOCK: return "Block";
381 case C_FILE: return "File";
382 case C_LINE: return "Line";
388 switch (DTYPE(sym->n_type))
390 case DT_FCN: return "Function";
391 case DT_PTR: return "Pointer";
392 case DT_ARY: return "Array";
396 n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
398 fatal ("%s", xstrerror (errno));
402 /* Print symbol name NAME, read from ABFD, with printf format FORM,
403 demangling it if requested. */
406 print_symname (const char *form, const char *name, bfd *abfd)
408 if (do_demangle && *name)
410 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
424 print_symdef_entry (bfd *abfd)
426 symindex idx = BFD_NO_MORE_SYMBOLS;
428 bfd_boolean everprinted = FALSE;
430 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
431 idx != BFD_NO_MORE_SYMBOLS;
432 idx = bfd_get_next_mapent (abfd, idx, &thesym))
437 printf (_("\nArchive index:\n"));
440 elt = bfd_get_elt_at_index (abfd, idx);
442 bfd_fatal ("bfd_get_elt_at_index");
443 if (thesym->name != (char *) NULL)
445 print_symname ("%s", thesym->name, abfd);
446 printf (" in %s\n", bfd_get_filename (elt));
451 /* Choose which symbol entries to print;
452 compact them downward to get rid of the rest.
453 Return the number of symbols to be printed. */
456 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
457 long symcount, unsigned int size)
459 bfd_byte *from, *fromend, *to;
462 store = bfd_make_empty_symbol (abfd);
464 bfd_fatal (bfd_get_filename (abfd));
466 from = (bfd_byte *) minisyms;
467 fromend = from + symcount * size;
468 to = (bfd_byte *) minisyms;
470 for (; from < fromend; from += size)
477 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
479 bfd_fatal (bfd_get_filename (abfd));
481 if (strcmp (sym->name, "__gnu_lto_slim") == 0)
482 non_fatal (_("%s: plugin needed to handle lto object"),
483 bfd_get_filename (abfd));
486 keep = bfd_is_und_section (sym->section);
487 else if (external_only)
488 /* PR binutls/12753: Unique symbols are global too. */
489 keep = ((sym->flags & (BSF_GLOBAL
491 | BSF_GNU_UNIQUE)) != 0
492 || bfd_is_und_section (sym->section)
493 || bfd_is_com_section (sym->section));
498 && ! print_debug_syms
499 && (sym->flags & BSF_DEBUGGING) != 0)
504 && (bfd_is_abs_section (sym->section)
505 || bfd_is_und_section (sym->section)))
511 if (bfd_is_und_section (sym->section))
516 && bfd_is_target_special_symbol (abfd, sym)
517 && ! allow_special_symbols)
523 memcpy (to, from, size);
528 return (to - (bfd_byte *) minisyms) / size;
531 /* These globals are used to pass information into the sorting
533 static bfd *sort_bfd;
534 static bfd_boolean sort_dynamic;
535 static asymbol *sort_x;
536 static asymbol *sort_y;
538 /* Symbol-sorting predicates */
539 #define valueof(x) ((x)->section->vma + (x)->value)
541 /* Numeric sorts. Undefined symbols are always considered "less than"
542 defined symbols with zero values. Common symbols are not treated
543 specially -- i.e., their sizes are used as their "values". */
546 non_numeric_forward (const void *P_x, const void *P_y)
551 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
552 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
553 if (x == NULL || y == NULL)
554 bfd_fatal (bfd_get_filename (sort_bfd));
556 xn = bfd_asymbol_name (x);
557 yn = bfd_asymbol_name (y);
565 /* Solaris 2.5 has a bug in strcoll.
566 strcoll returns invalid values when confronted with empty strings. */
572 return strcoll (xn, yn);
574 return strcmp (xn, yn);
579 non_numeric_reverse (const void *x, const void *y)
581 return - non_numeric_forward (x, y);
585 numeric_forward (const void *P_x, const void *P_y)
590 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
591 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
592 if (x == NULL || y == NULL)
593 bfd_fatal (bfd_get_filename (sort_bfd));
595 xs = bfd_get_section (x);
596 ys = bfd_get_section (y);
598 if (bfd_is_und_section (xs))
600 if (! bfd_is_und_section (ys))
603 else if (bfd_is_und_section (ys))
605 else if (valueof (x) != valueof (y))
606 return valueof (x) < valueof (y) ? -1 : 1;
608 return non_numeric_forward (P_x, P_y);
612 numeric_reverse (const void *x, const void *y)
614 return - numeric_forward (x, y);
617 static int (*(sorters[2][2])) (const void *, const void *) =
619 { non_numeric_forward, non_numeric_reverse },
620 { numeric_forward, numeric_reverse }
623 /* This sort routine is used by sort_symbols_by_size. It is similar
624 to numeric_forward, but when symbols have the same value it sorts
625 by section VMA. This simplifies the sort_symbols_by_size code
626 which handles symbols at the end of sections. Also, this routine
627 tries to sort file names before other symbols with the same value.
628 That will make the file name have a zero size, which will make
629 sort_symbols_by_size choose the non file name symbol, leading to
630 more meaningful output. For similar reasons, this code sorts
631 gnu_compiled_* and gcc2_compiled before other symbols with the same
635 size_forward1 (const void *P_x, const void *P_y)
643 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
644 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
645 if (x == NULL || y == NULL)
646 bfd_fatal (bfd_get_filename (sort_bfd));
648 xs = bfd_get_section (x);
649 ys = bfd_get_section (y);
651 if (bfd_is_und_section (xs))
653 if (bfd_is_und_section (ys))
656 if (valueof (x) != valueof (y))
657 return valueof (x) < valueof (y) ? -1 : 1;
659 if (xs->vma != ys->vma)
660 return xs->vma < ys->vma ? -1 : 1;
662 xn = bfd_asymbol_name (x);
663 yn = bfd_asymbol_name (y);
667 /* The symbols gnu_compiled and gcc2_compiled convey even less
668 information than the file name, so sort them out first. */
670 xf = (strstr (xn, "gnu_compiled") != NULL
671 || strstr (xn, "gcc2_compiled") != NULL);
672 yf = (strstr (yn, "gnu_compiled") != NULL
673 || strstr (yn, "gcc2_compiled") != NULL);
680 /* We use a heuristic for the file name. It may not work on non
681 Unix systems, but it doesn't really matter; the only difference
682 is precisely which symbol names get printed. */
684 #define file_symbol(s, sn, snl) \
685 (((s)->flags & BSF_FILE) != 0 \
687 && (sn)[(snl) - 2] == '.' \
688 && ((sn)[(snl) - 1] == 'o' \
689 || (sn)[(snl) - 1] == 'a')))
691 xf = file_symbol (x, xn, xnl);
692 yf = file_symbol (y, yn, ynl);
699 return non_numeric_forward (P_x, P_y);
702 /* This sort routine is used by sort_symbols_by_size. It is sorting
703 an array of size_sym structures into size order. */
706 size_forward2 (const void *P_x, const void *P_y)
708 const struct size_sym *x = (const struct size_sym *) P_x;
709 const struct size_sym *y = (const struct size_sym *) P_y;
711 if (x->size < y->size)
712 return reverse_sort ? 1 : -1;
713 else if (x->size > y->size)
714 return reverse_sort ? -1 : 1;
716 return sorters[0][reverse_sort] (x->minisym, y->minisym);
719 /* Sort the symbols by size. ELF provides a size but for other formats
720 we have to make a guess by assuming that the difference between the
721 address of a symbol and the address of the next higher symbol is the
725 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
726 long symcount, unsigned int size,
727 struct size_sym **symsizesp)
729 struct size_sym *symsizes;
730 bfd_byte *from, *fromend;
732 asymbol *store_sym, *store_next;
734 qsort (minisyms, symcount, size, size_forward1);
736 /* We are going to return a special set of symbols and sizes to
738 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
739 *symsizesp = symsizes;
741 /* Note that filter_symbols has already removed all absolute and
742 undefined symbols. Here we remove all symbols whose size winds
744 from = (bfd_byte *) minisyms;
745 fromend = from + symcount * size;
752 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
755 bfd_fatal (bfd_get_filename (abfd));
758 for (; from < fromend; from += size)
764 int synthetic = (sym->flags & BSF_SYNTHETIC);
766 if (from + size < fromend)
768 next = bfd_minisymbol_to_symbol (abfd,
770 (const void *) (from + size),
773 bfd_fatal (bfd_get_filename (abfd));
778 sec = bfd_get_section (sym);
780 /* Synthetic symbols don't have a full type set of data available, thus
781 we can't rely on that information for the symbol size. */
782 if (!synthetic && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
783 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
784 else if (!synthetic && bfd_is_com_section (sec))
788 if (from + size < fromend
789 && sec == bfd_get_section (next))
790 sz = valueof (next) - valueof (sym);
792 sz = (bfd_get_section_vma (abfd, sec)
793 + bfd_section_size (abfd, sec)
799 symsizes->minisym = (const void *) from;
807 store_sym = store_next;
811 symcount = symsizes - *symsizesp;
813 /* We must now sort again by size. */
814 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
819 /* This function is used to get the relocs for a particular section.
820 It is called via bfd_map_over_sections. */
823 get_relocs (bfd *abfd, asection *sec, void *dataarg)
825 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
829 if ((sec->flags & SEC_RELOC) == 0)
831 *data->relocs = NULL;
838 relsize = bfd_get_reloc_upper_bound (abfd, sec);
840 bfd_fatal (bfd_get_filename (abfd));
842 *data->relocs = (arelent **) xmalloc (relsize);
843 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
845 if (*data->relcount < 0)
846 bfd_fatal (bfd_get_filename (abfd));
854 /* Print a single symbol. */
857 print_symbol (bfd * abfd,
863 struct extended_symbol_info info;
867 format->print_symbol_filename (archive_bfd, abfd);
869 bfd_get_symbol_info (abfd, sym, &syminfo);
871 info.sinfo = &syminfo;
873 /* Synthetic symbols do not have a full symbol type set of data available. */
874 if ((sym->flags & BSF_SYNTHETIC) != 0)
877 info.coffinfo = NULL;
881 info.elfinfo = elf_symbol_from (abfd, sym);
882 info.coffinfo = coff_symbol_from (sym);
885 format->print_symbol_info (&info, abfd);
887 if (with_symbol_versions)
889 const char * version_string = NULL;
890 bfd_boolean hidden = FALSE;
892 if ((sym->flags & BSF_SYNTHETIC) == 0)
893 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
895 if (bfd_is_und_section (bfd_get_section (sym)))
898 if (version_string && *version_string != '\0')
899 printf (hidden ? "@%s" : "@@%s", version_string);
904 static asymbol **syms;
905 static long symcount;
906 const char *filename, *functionname;
909 /* We need to get the canonical symbols in order to call
910 bfd_find_nearest_line. This is inefficient, but, then, you
911 don't have to use --line-numbers. */
912 if (abfd != lineno_cache_bfd && syms != NULL)
921 symsize = bfd_get_symtab_upper_bound (abfd);
923 bfd_fatal (bfd_get_filename (abfd));
924 syms = (asymbol **) xmalloc (symsize);
925 symcount = bfd_canonicalize_symtab (abfd, syms);
927 bfd_fatal (bfd_get_filename (abfd));
928 lineno_cache_bfd = abfd;
931 if (bfd_is_und_section (bfd_get_section (sym)))
933 static asection **secs;
934 static arelent ***relocs;
935 static long *relcount;
936 static unsigned int seccount;
940 /* For an undefined symbol, we try to find a reloc for the
941 symbol, and print the line number of the reloc. */
942 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
944 for (i = 0; i < seccount; i++)
945 if (relocs[i] != NULL)
957 struct get_relocs_info rinfo;
959 seccount = bfd_count_sections (abfd);
961 secs = (asection **) xmalloc (seccount * sizeof *secs);
962 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
963 relcount = (long *) xmalloc (seccount * sizeof *relcount);
966 rinfo.relocs = relocs;
967 rinfo.relcount = relcount;
969 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
970 lineno_cache_rel_bfd = abfd;
973 symname = bfd_asymbol_name (sym);
974 for (i = 0; i < seccount; i++)
978 for (j = 0; j < relcount[i]; j++)
983 if (r->sym_ptr_ptr != NULL
984 && (*r->sym_ptr_ptr)->section == sym->section
985 && (*r->sym_ptr_ptr)->value == sym->value
987 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
988 && bfd_find_nearest_line (abfd, secs[i], syms,
989 r->address, &filename,
990 &functionname, &lineno)
993 /* We only print the first one we find. */
994 printf ("\t%s:%u", filename, lineno);
1001 else if (bfd_get_section (sym)->owner == abfd)
1003 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
1004 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
1005 syms, sym->value, &filename,
1006 &functionname, &lineno))
1009 printf ("\t%s:%u", filename, lineno);
1016 /* Print the symbols when sorting by size. */
1019 print_size_symbols (bfd * abfd,
1020 bfd_boolean is_dynamic,
1021 struct size_sym * symsizes,
1026 struct size_sym *from;
1027 struct size_sym *fromend;
1029 store = bfd_make_empty_symbol (abfd);
1031 bfd_fatal (bfd_get_filename (abfd));
1034 fromend = from + symcount;
1036 for (; from < fromend; from++)
1040 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1042 bfd_fatal (bfd_get_filename (abfd));
1044 print_symbol (abfd, sym, from->size, archive_bfd);
1049 /* Print the symbols of ABFD that are held in MINISYMS.
1051 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1053 SYMCOUNT is the number of symbols in MINISYMS.
1055 SIZE is the size of a symbol in MINISYMS. */
1058 print_symbols (bfd * abfd,
1059 bfd_boolean is_dynamic,
1069 store = bfd_make_empty_symbol (abfd);
1071 bfd_fatal (bfd_get_filename (abfd));
1073 from = (bfd_byte *) minisyms;
1074 fromend = from + symcount * size;
1076 for (; from < fromend; from += size)
1080 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1082 bfd_fatal (bfd_get_filename (abfd));
1084 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1088 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1091 display_rel_file (bfd *abfd, bfd *archive_bfd)
1096 struct size_sym *symsizes;
1097 asymbol *synthsyms = NULL;
1101 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1103 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1108 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1111 if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1113 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1117 bfd_fatal (bfd_get_filename (abfd));
1122 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1126 if (show_synthetic && size == sizeof (asymbol *))
1128 asymbol **static_syms = NULL;
1129 asymbol **dyn_syms = NULL;
1130 long static_count = 0;
1136 dyn_count = symcount;
1137 dyn_syms = (asymbol **) minisyms;
1141 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1143 static_count = symcount;
1144 static_syms = (asymbol **) minisyms;
1148 dyn_syms = (asymbol **) xmalloc (storage);
1149 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1151 bfd_fatal (bfd_get_filename (abfd));
1155 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1156 dyn_count, dyn_syms, &synthsyms);
1157 if (synth_count > 0)
1163 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1164 symp = (asymbol **) new_mini;
1165 memcpy (symp, minisyms, symcount * sizeof (*symp));
1167 for (i = 0; i < synth_count; i++)
1168 *symp++ = synthsyms + i;
1170 minisyms = new_mini;
1171 symcount += synth_count;
1175 /* Discard the symbols we don't want to print.
1176 It's OK to do this in place; we'll free the storage anyway
1177 (after printing). */
1179 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1185 sort_dynamic = dynamic;
1186 sort_x = bfd_make_empty_symbol (abfd);
1187 sort_y = bfd_make_empty_symbol (abfd);
1188 if (sort_x == NULL || sort_y == NULL)
1189 bfd_fatal (bfd_get_filename (abfd));
1192 qsort (minisyms, symcount, size,
1193 sorters[sort_numerically][reverse_sort]);
1195 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1200 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1202 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1211 set_print_width (bfd *file)
1213 print_width = bfd_get_arch_size (file);
1215 if (print_width == -1)
1218 Guess the target's bitsize based on its name.
1219 We assume here than any 64-bit format will include
1220 "64" somewhere in its name. The only known exception
1221 is the MMO object file format. */
1222 if (strstr (bfd_get_target (file), "64") != NULL
1223 || strcmp (bfd_get_target (file), "mmo") == 0)
1231 display_archive (bfd *file)
1234 bfd *last_arfile = NULL;
1237 format->print_archive_filename (bfd_get_filename (file));
1240 print_symdef_entry (file);
1246 arfile = bfd_openr_next_archived_file (file, arfile);
1250 if (bfd_get_error () != bfd_error_no_more_archived_files)
1251 bfd_fatal (bfd_get_filename (file));
1255 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1257 set_print_width (arfile);
1258 format->print_archive_member (bfd_get_filename (file),
1259 bfd_get_filename (arfile));
1260 display_rel_file (arfile, file);
1264 bfd_nonfatal (bfd_get_filename (arfile));
1265 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1267 list_matching_formats (matching);
1272 if (last_arfile != NULL)
1274 bfd_close (last_arfile);
1275 lineno_cache_bfd = NULL;
1276 lineno_cache_rel_bfd = NULL;
1277 if (arfile == last_arfile)
1280 last_arfile = arfile;
1283 if (last_arfile != NULL)
1285 bfd_close (last_arfile);
1286 lineno_cache_bfd = NULL;
1287 lineno_cache_rel_bfd = NULL;
1292 display_file (char *filename)
1294 bfd_boolean retval = TRUE;
1298 if (get_file_size (filename) < 1)
1301 file = bfd_openr (filename, target ? target : plugin_target);
1304 bfd_nonfatal (filename);
1308 /* If printing line numbers, decompress the debug sections. */
1310 file->flags |= BFD_DECOMPRESS;
1312 if (bfd_check_format (file, bfd_archive))
1314 display_archive (file);
1316 else if (bfd_check_format_matches (file, bfd_object, &matching))
1318 set_print_width (file);
1319 format->print_object_filename (filename);
1320 display_rel_file (file, NULL);
1324 bfd_nonfatal (filename);
1325 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1327 list_matching_formats (matching);
1333 if (!bfd_close (file))
1334 bfd_fatal (filename);
1336 lineno_cache_bfd = NULL;
1337 lineno_cache_rel_bfd = NULL;
1342 /* The following 3 groups of functions are called unconditionally,
1343 once at the start of processing each file of the appropriate type.
1344 They should check `filename_per_file' and `filename_per_symbol',
1345 as appropriate for their output format, to determine whether to
1348 /* Print the name of an object file given on the command line. */
1351 print_object_filename_bsd (char *filename)
1353 if (filename_per_file && !filename_per_symbol)
1354 printf ("\n%s:\n", filename);
1358 print_object_filename_sysv (char *filename)
1361 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1363 printf (_("\n\nSymbols from %s:\n\n"), filename);
1364 if (print_width == 32)
1366 Name Value Class Type Size Line Section\n\n"));
1369 Name Value Class Type Size Line Section\n\n"));
1373 print_object_filename_posix (char *filename)
1375 if (filename_per_file && !filename_per_symbol)
1376 printf ("%s:\n", filename);
1379 /* Print the name of an archive file given on the command line. */
1382 print_archive_filename_bsd (char *filename)
1384 if (filename_per_file)
1385 printf ("\n%s:\n", filename);
1389 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1394 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1398 /* Print the name of an archive member file. */
1401 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1402 const char *filename)
1404 if (!filename_per_symbol)
1405 printf ("\n%s:\n", filename);
1409 print_archive_member_sysv (char *archive, const char *filename)
1412 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1414 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1415 if (print_width == 32)
1417 Name Value Class Type Size Line Section\n\n"));
1420 Name Value Class Type Size Line Section\n\n"));
1424 print_archive_member_posix (char *archive, const char *filename)
1426 if (!filename_per_symbol)
1427 printf ("%s[%s]:\n", archive, filename);
1430 /* Print the name of the file (and archive, if there is one)
1431 containing a symbol. */
1434 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1436 if (filename_per_symbol)
1439 printf ("%s:", bfd_get_filename (archive_bfd));
1440 printf ("%s:", bfd_get_filename (abfd));
1445 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1447 if (filename_per_symbol)
1450 printf ("%s:", bfd_get_filename (archive_bfd));
1451 printf ("%s:", bfd_get_filename (abfd));
1456 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1458 if (filename_per_symbol)
1461 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1462 bfd_get_filename (abfd));
1464 printf ("%s: ", bfd_get_filename (abfd));
1468 /* Print a symbol value. */
1471 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1473 switch (print_width)
1476 printf (value_format_32bit, (unsigned long) val);
1480 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1481 printf (value_format_64bit, val);
1483 /* We have a 64 bit value to print, but the host is only 32 bit. */
1484 if (print_radix == 16)
1485 bfd_fprintf_vma (abfd, stdout, val);
1491 s = buf + sizeof buf;
1495 *--s = (val % print_radix) + '0';
1498 while ((buf + sizeof buf - 1) - s < 16)
1506 fatal (_("Print width has not been initialized (%d)"), print_width);
1511 /* Print a line of information about a symbol. */
1514 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1516 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1518 if (print_width == 64)
1524 /* Normally we print the value of the symbol. If we are printing the
1525 size or sorting by size then we print its size, except for the
1526 (weird) special case where both flags are defined, in which case we
1527 print both values. This conforms to documented behaviour. */
1528 if (sort_by_size && !print_size)
1529 print_value (abfd, SYM_SIZE (info));
1531 print_value (abfd, SYM_VALUE (info));
1532 if (print_size && SYM_SIZE (info))
1535 print_value (abfd, SYM_SIZE (info));
1539 printf (" %c", SYM_TYPE (info));
1541 if (SYM_TYPE (info) == '-')
1545 printf (other_format, SYM_STAB_OTHER (info));
1547 printf (desc_format, SYM_STAB_DESC (info));
1548 printf (" %5s", SYM_STAB_NAME (info));
1550 print_symname (" %s", SYM_NAME (info), abfd);
1554 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1556 print_symname ("%-20s|", SYM_NAME (info), abfd);
1558 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1560 if (print_width == 32)
1566 print_value (abfd, SYM_VALUE (info));
1568 printf ("| %c |", SYM_TYPE (info));
1570 if (SYM_TYPE (info) == '-')
1573 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1574 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1575 printf ("| |"); /* Line, Section. */
1579 /* Type, Size, Line, Section */
1582 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1583 else if (info->coffinfo)
1585 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1589 if (SYM_SIZE (info))
1590 print_value (abfd, SYM_SIZE (info));
1593 if (print_width == 32)
1600 printf("| |%s", info->elfinfo->symbol.section->name);
1601 else if (info->coffinfo)
1602 printf("| |%s", info->coffinfo->symbol.section->name);
1609 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1611 print_symname ("%s ", SYM_NAME (info), abfd);
1612 printf ("%c ", SYM_TYPE (info));
1614 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1618 print_value (abfd, SYM_VALUE (info));
1620 if (SYM_SIZE (info))
1621 print_value (abfd, SYM_SIZE (info));
1626 main (int argc, char **argv)
1631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1632 setlocale (LC_MESSAGES, "");
1634 #if defined (HAVE_SETLOCALE)
1635 setlocale (LC_CTYPE, "");
1636 setlocale (LC_COLLATE, "");
1638 bindtextdomain (PACKAGE, LOCALEDIR);
1639 textdomain (PACKAGE);
1641 program_name = *argv;
1642 xmalloc_set_program_name (program_name);
1643 bfd_set_error_program_name (program_name);
1644 #if BFD_SUPPORTS_PLUGINS
1645 bfd_plugin_set_program_name (program_name);
1648 START_PROGRESS (program_name, 0);
1650 expandargv (&argc, &argv);
1653 set_default_bfd_target ();
1655 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1656 long_options, (int *) 0)) != EOF)
1661 print_debug_syms = 1;
1665 filename_per_symbol = 1;
1667 case 'B': /* For MIPS compatibility. */
1668 set_output_format ("bsd");
1674 enum demangling_styles style;
1676 style = cplus_demangle_name_to_style (optarg);
1677 if (style == unknown_demangling)
1678 fatal (_("unknown demangling style `%s'"),
1681 cplus_demangle_set_style (style);
1688 /* Ignored for HP/UX compatibility. */
1691 set_output_format (optarg);
1705 sort_numerically = 1;
1710 sort_numerically = 0;
1713 case OPTION_SIZE_SORT:
1715 sort_numerically = 0;
1719 set_output_format ("posix");
1731 set_print_radix (optarg);
1740 /* Ignored for (partial) AIX compatibility. On AIX, the
1741 argument has values 32, 64, or 32_64, and specifies that
1742 only 32-bit, only 64-bit, or both kinds of objects should
1743 be examined. The default is 32. So plain AIX nm on a
1744 library archive with both kinds of objects will ignore
1745 the 64-bit ones. For GNU nm, the default is and always
1746 has been -X 32_64, and other options are not supported. */
1747 if (strcmp (optarg, "32_64") != 0)
1748 fatal (_("Only -X 32_64 is supported"));
1751 case OPTION_TARGET: /* --target */
1755 case OPTION_PLUGIN: /* --plugin */
1756 #if BFD_SUPPORTS_PLUGINS
1757 bfd_plugin_set_plugin (optarg);
1759 fatal (_("sorry - this program has been built without plugin support\n"));
1763 case 0: /* A long option that just sets a flag. */
1772 print_version ("nm");
1774 if (sort_by_size && undefined_only)
1776 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1777 non_fatal (_("will produce no output, since undefined symbols have no size."));
1781 /* OK, all options now parsed. If no filename specified, do a.out. */
1783 return !display_file ("a.out");
1787 if (argc - optind > 1)
1788 filename_per_file = 1;
1790 /* We were given several filenames to do. */
1791 while (optind < argc)
1794 if (!display_file (argv[optind++]))
1798 END_PROGRESS (program_name);