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_stats = 0; /* Show statistics. */
161 static int show_synthetic = 0; /* Display synthesized symbols too. */
162 static int line_numbers = 0; /* Print line numbers for symbols. */
163 static int allow_special_symbols = 0; /* Allow special symbols. */
164 static int with_symbol_versions = 0; /* Include symbol version information in the output. */
166 /* When to print the names of files. Not mutually exclusive in SYSV format. */
167 static int filename_per_file = 0; /* Once per file, on its own line. */
168 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
170 /* Print formats for printing a symbol value. */
171 static char value_format_32bit[] = "%08lx";
172 #if BFD_HOST_64BIT_LONG
173 static char value_format_64bit[] = "%016lx";
174 #elif BFD_HOST_64BIT_LONG_LONG
176 static char value_format_64bit[] = "%016llx";
178 static char value_format_64bit[] = "%016I64x";
181 static int print_width = 0;
182 static int print_radix = 16;
183 /* Print formats for printing stab info. */
184 static char other_format[] = "%02x";
185 static char desc_format[] = "%04x";
187 static char *target = NULL;
188 #if BFD_SUPPORTS_PLUGINS
189 static const char *plugin_target = "plugin";
191 static const char *plugin_target = NULL;
194 /* Used to cache the line numbers for a BFD. */
195 static bfd *lineno_cache_bfd;
196 static bfd *lineno_cache_rel_bfd;
198 #define OPTION_TARGET 200
199 #define OPTION_PLUGIN (OPTION_TARGET + 1)
200 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
202 static struct option long_options[] =
204 {"debug-syms", no_argument, &print_debug_syms, 1},
205 {"demangle", optional_argument, 0, 'C'},
206 {"dynamic", no_argument, &dynamic, 1},
207 {"extern-only", no_argument, &external_only, 1},
208 {"format", required_argument, 0, 'f'},
209 {"help", no_argument, 0, 'h'},
210 {"line-numbers", no_argument, 0, 'l'},
211 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
212 {"no-demangle", no_argument, &do_demangle, 0},
213 {"no-sort", no_argument, 0, 'p'},
214 {"numeric-sort", no_argument, 0, 'n'},
215 {"plugin", required_argument, 0, OPTION_PLUGIN},
216 {"portability", no_argument, 0, 'P'},
217 {"print-armap", no_argument, &print_armap, 1},
218 {"print-file-name", no_argument, 0, 'o'},
219 {"print-size", no_argument, 0, 'S'},
220 {"radix", required_argument, 0, 't'},
221 {"reverse-sort", no_argument, &reverse_sort, 1},
222 {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
223 {"special-syms", no_argument, &allow_special_symbols, 1},
224 {"stats", no_argument, &show_stats, 1},
225 {"synthetic", no_argument, &show_synthetic, 1},
226 {"target", required_argument, 0, OPTION_TARGET},
227 {"defined-only", no_argument, &defined_only, 1},
228 {"undefined-only", no_argument, &undefined_only, 1},
229 {"version", no_argument, &show_version, 1},
230 {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
231 {0, no_argument, 0, 0}
234 /* Some error-reporting functions. */
236 ATTRIBUTE_NORETURN static void
237 usage (FILE *stream, int status)
239 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
240 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
241 fprintf (stream, _(" The options are:\n\
242 -a, --debug-syms Display debugger-only symbols\n\
243 -A, --print-file-name Print name of the input file before every symbol\n\
244 -B Same as --format=bsd\n\
245 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
246 The STYLE, if specified, can be `auto' (the default),\n\
247 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
249 --no-demangle Do not demangle low-level symbol names\n\
250 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
251 --defined-only Display only defined symbols\n\
253 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
254 `sysv' or `posix'. The default is `bsd'\n\
255 -g, --extern-only Display only external symbols\n\
256 -l, --line-numbers Use debugging information to find a filename and\n\
257 line number for each symbol\n\
258 -n, --numeric-sort Sort symbols numerically by address\n\
260 -p, --no-sort Do not sort the symbols\n\
261 -P, --portability Same as --format=posix\n\
262 -r, --reverse-sort Reverse the sense of the sort\n"));
263 #if BFD_SUPPORTS_PLUGINS
264 fprintf (stream, _("\
265 --plugin NAME Load the specified plugin\n"));
267 fprintf (stream, _("\
268 -S, --print-size Print size of defined symbols\n\
269 -s, --print-armap Include index for symbols from archive members\n\
270 --size-sort Sort symbols by size\n\
271 --special-syms Include special symbols in the output\n\
272 --synthetic Display synthetic symbols as well\n\
273 -t, --radix=RADIX Use RADIX for printing symbol values\n\
274 --target=BFDNAME Specify the target object format as BFDNAME\n\
275 -u, --undefined-only Display only undefined symbols\n\
276 --with-symbol-versions Display version strings after symbol names\n\
277 -X 32_64 (ignored)\n\
278 @FILE Read options from FILE\n\
279 -h, --help Display this information\n\
280 -V, --version Display this program's version number\n\
282 list_supported_targets (program_name, stream);
283 if (REPORT_BUGS_TO[0] && status == 0)
284 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
288 /* Set the radix for the symbol value and size according to RADIX. */
291 set_print_radix (char *radix)
303 value_format_32bit[4] = *radix;
304 #if BFD_HOST_64BIT_LONG
305 value_format_64bit[5] = *radix;
306 #elif BFD_HOST_64BIT_LONG_LONG
308 value_format_64bit[6] = *radix;
310 value_format_64bit[7] = *radix;
313 other_format[3] = desc_format[3] = *radix;
316 fatal (_("%s: invalid radix"), radix);
321 set_output_format (char *f)
340 fatal (_("%s: invalid output format"), f);
342 format = &formats[i];
346 get_elf_symbol_type (unsigned int type)
353 case STT_NOTYPE: return "NOTYPE";
354 case STT_OBJECT: return "OBJECT";
355 case STT_FUNC: return "FUNC";
356 case STT_SECTION: return "SECTION";
357 case STT_FILE: return "FILE";
358 case STT_COMMON: return "COMMON";
359 case STT_TLS: return "TLS";
363 if (type >= STT_LOPROC && type <= STT_HIPROC)
364 n = asprintf (&bufp, _("<processor specific>: %d"), type);
365 else if (type >= STT_LOOS && type <= STT_HIOS)
366 n = asprintf (&bufp, _("<OS specific>: %d"), type);
368 n = asprintf (&bufp, _("<unknown>: %d"), type);
370 fatal ("%s", xstrerror (errno));
375 get_coff_symbol_type (const struct internal_syment *sym)
380 switch (sym->n_sclass)
382 case C_BLOCK: return "Block";
383 case C_FILE: return "File";
384 case C_LINE: return "Line";
390 switch (DTYPE(sym->n_type))
392 case DT_FCN: return "Function";
393 case DT_PTR: return "Pointer";
394 case DT_ARY: return "Array";
398 n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
400 fatal ("%s", xstrerror (errno));
404 /* Print symbol name NAME, read from ABFD, with printf format FORM,
405 demangling it if requested. */
408 print_symname (const char *form, const char *name, bfd *abfd)
410 if (do_demangle && *name)
412 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
426 print_symdef_entry (bfd *abfd)
428 symindex idx = BFD_NO_MORE_SYMBOLS;
430 bfd_boolean everprinted = FALSE;
432 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
433 idx != BFD_NO_MORE_SYMBOLS;
434 idx = bfd_get_next_mapent (abfd, idx, &thesym))
439 printf (_("\nArchive index:\n"));
442 elt = bfd_get_elt_at_index (abfd, idx);
444 bfd_fatal ("bfd_get_elt_at_index");
445 if (thesym->name != (char *) NULL)
447 print_symname ("%s", thesym->name, abfd);
448 printf (" in %s\n", bfd_get_filename (elt));
453 /* Choose which symbol entries to print;
454 compact them downward to get rid of the rest.
455 Return the number of symbols to be printed. */
458 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
459 long symcount, unsigned int size)
461 bfd_byte *from, *fromend, *to;
464 store = bfd_make_empty_symbol (abfd);
466 bfd_fatal (bfd_get_filename (abfd));
468 from = (bfd_byte *) minisyms;
469 fromend = from + symcount * size;
470 to = (bfd_byte *) minisyms;
472 for (; from < fromend; from += size)
479 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
481 bfd_fatal (bfd_get_filename (abfd));
483 if (strcmp (sym->name, "__gnu_lto_slim") == 0)
484 non_fatal (_("%s: plugin needed to handle lto object"),
485 bfd_get_filename (abfd));
488 keep = bfd_is_und_section (sym->section);
489 else if (external_only)
490 /* PR binutls/12753: Unique symbols are global too. */
491 keep = ((sym->flags & (BSF_GLOBAL
493 | BSF_GNU_UNIQUE)) != 0
494 || bfd_is_und_section (sym->section)
495 || bfd_is_com_section (sym->section));
500 && ! print_debug_syms
501 && (sym->flags & BSF_DEBUGGING) != 0)
506 && (bfd_is_abs_section (sym->section)
507 || bfd_is_und_section (sym->section)))
513 if (bfd_is_und_section (sym->section))
518 && bfd_is_target_special_symbol (abfd, sym)
519 && ! allow_special_symbols)
525 memcpy (to, from, size);
530 return (to - (bfd_byte *) minisyms) / size;
533 /* These globals are used to pass information into the sorting
535 static bfd *sort_bfd;
536 static bfd_boolean sort_dynamic;
537 static asymbol *sort_x;
538 static asymbol *sort_y;
540 /* Symbol-sorting predicates */
541 #define valueof(x) ((x)->section->vma + (x)->value)
543 /* Numeric sorts. Undefined symbols are always considered "less than"
544 defined symbols with zero values. Common symbols are not treated
545 specially -- i.e., their sizes are used as their "values". */
548 non_numeric_forward (const void *P_x, const void *P_y)
553 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
554 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
555 if (x == NULL || y == NULL)
556 bfd_fatal (bfd_get_filename (sort_bfd));
558 xn = bfd_asymbol_name (x);
559 yn = bfd_asymbol_name (y);
567 /* Solaris 2.5 has a bug in strcoll.
568 strcoll returns invalid values when confronted with empty strings. */
574 return strcoll (xn, yn);
576 return strcmp (xn, yn);
581 non_numeric_reverse (const void *x, const void *y)
583 return - non_numeric_forward (x, y);
587 numeric_forward (const void *P_x, const void *P_y)
592 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
593 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
594 if (x == NULL || y == NULL)
595 bfd_fatal (bfd_get_filename (sort_bfd));
597 xs = bfd_get_section (x);
598 ys = bfd_get_section (y);
600 if (bfd_is_und_section (xs))
602 if (! bfd_is_und_section (ys))
605 else if (bfd_is_und_section (ys))
607 else if (valueof (x) != valueof (y))
608 return valueof (x) < valueof (y) ? -1 : 1;
610 return non_numeric_forward (P_x, P_y);
614 numeric_reverse (const void *x, const void *y)
616 return - numeric_forward (x, y);
619 static int (*(sorters[2][2])) (const void *, const void *) =
621 { non_numeric_forward, non_numeric_reverse },
622 { numeric_forward, numeric_reverse }
625 /* This sort routine is used by sort_symbols_by_size. It is similar
626 to numeric_forward, but when symbols have the same value it sorts
627 by section VMA. This simplifies the sort_symbols_by_size code
628 which handles symbols at the end of sections. Also, this routine
629 tries to sort file names before other symbols with the same value.
630 That will make the file name have a zero size, which will make
631 sort_symbols_by_size choose the non file name symbol, leading to
632 more meaningful output. For similar reasons, this code sorts
633 gnu_compiled_* and gcc2_compiled before other symbols with the same
637 size_forward1 (const void *P_x, const void *P_y)
645 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
646 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
647 if (x == NULL || y == NULL)
648 bfd_fatal (bfd_get_filename (sort_bfd));
650 xs = bfd_get_section (x);
651 ys = bfd_get_section (y);
653 if (bfd_is_und_section (xs))
655 if (bfd_is_und_section (ys))
658 if (valueof (x) != valueof (y))
659 return valueof (x) < valueof (y) ? -1 : 1;
661 if (xs->vma != ys->vma)
662 return xs->vma < ys->vma ? -1 : 1;
664 xn = bfd_asymbol_name (x);
665 yn = bfd_asymbol_name (y);
669 /* The symbols gnu_compiled and gcc2_compiled convey even less
670 information than the file name, so sort them out first. */
672 xf = (strstr (xn, "gnu_compiled") != NULL
673 || strstr (xn, "gcc2_compiled") != NULL);
674 yf = (strstr (yn, "gnu_compiled") != NULL
675 || strstr (yn, "gcc2_compiled") != NULL);
682 /* We use a heuristic for the file name. It may not work on non
683 Unix systems, but it doesn't really matter; the only difference
684 is precisely which symbol names get printed. */
686 #define file_symbol(s, sn, snl) \
687 (((s)->flags & BSF_FILE) != 0 \
689 && (sn)[(snl) - 2] == '.' \
690 && ((sn)[(snl) - 1] == 'o' \
691 || (sn)[(snl) - 1] == 'a')))
693 xf = file_symbol (x, xn, xnl);
694 yf = file_symbol (y, yn, ynl);
701 return non_numeric_forward (P_x, P_y);
704 /* This sort routine is used by sort_symbols_by_size. It is sorting
705 an array of size_sym structures into size order. */
708 size_forward2 (const void *P_x, const void *P_y)
710 const struct size_sym *x = (const struct size_sym *) P_x;
711 const struct size_sym *y = (const struct size_sym *) P_y;
713 if (x->size < y->size)
714 return reverse_sort ? 1 : -1;
715 else if (x->size > y->size)
716 return reverse_sort ? -1 : 1;
718 return sorters[0][reverse_sort] (x->minisym, y->minisym);
721 /* Sort the symbols by size. ELF provides a size but for other formats
722 we have to make a guess by assuming that the difference between the
723 address of a symbol and the address of the next higher symbol is the
727 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
728 long symcount, unsigned int size,
729 struct size_sym **symsizesp)
731 struct size_sym *symsizes;
732 bfd_byte *from, *fromend;
734 asymbol *store_sym, *store_next;
736 qsort (minisyms, symcount, size, size_forward1);
738 /* We are going to return a special set of symbols and sizes to
740 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
741 *symsizesp = symsizes;
743 /* Note that filter_symbols has already removed all absolute and
744 undefined symbols. Here we remove all symbols whose size winds
746 from = (bfd_byte *) minisyms;
747 fromend = from + symcount * size;
754 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
757 bfd_fatal (bfd_get_filename (abfd));
760 for (; from < fromend; from += size)
766 int synthetic = (sym->flags & BSF_SYNTHETIC);
768 if (from + size < fromend)
770 next = bfd_minisymbol_to_symbol (abfd,
772 (const void *) (from + size),
775 bfd_fatal (bfd_get_filename (abfd));
780 sec = bfd_get_section (sym);
782 /* Synthetic symbols don't have a full type set of data available, thus
783 we can't rely on that information for the symbol size. */
784 if (!synthetic && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
785 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
786 else if (!synthetic && bfd_is_com_section (sec))
790 if (from + size < fromend
791 && sec == bfd_get_section (next))
792 sz = valueof (next) - valueof (sym);
794 sz = (bfd_get_section_vma (abfd, sec)
795 + bfd_section_size (abfd, sec)
801 symsizes->minisym = (const void *) from;
809 store_sym = store_next;
813 symcount = symsizes - *symsizesp;
815 /* We must now sort again by size. */
816 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
821 /* This function is used to get the relocs for a particular section.
822 It is called via bfd_map_over_sections. */
825 get_relocs (bfd *abfd, asection *sec, void *dataarg)
827 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
831 if ((sec->flags & SEC_RELOC) == 0)
833 *data->relocs = NULL;
840 relsize = bfd_get_reloc_upper_bound (abfd, sec);
842 bfd_fatal (bfd_get_filename (abfd));
844 *data->relocs = (arelent **) xmalloc (relsize);
845 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
847 if (*data->relcount < 0)
848 bfd_fatal (bfd_get_filename (abfd));
856 /* Print a single symbol. */
859 print_symbol (bfd * abfd,
865 struct extended_symbol_info info;
869 format->print_symbol_filename (archive_bfd, abfd);
871 bfd_get_symbol_info (abfd, sym, &syminfo);
873 info.sinfo = &syminfo;
875 /* Synthetic symbols do not have a full symbol type set of data available. */
876 if ((sym->flags & BSF_SYNTHETIC) != 0)
879 info.coffinfo = NULL;
883 info.elfinfo = elf_symbol_from (abfd, sym);
884 info.coffinfo = coff_symbol_from (sym);
887 format->print_symbol_info (&info, abfd);
889 if (with_symbol_versions)
891 const char * version_string = NULL;
892 bfd_boolean hidden = FALSE;
894 if ((sym->flags & BSF_SYNTHETIC) == 0)
895 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
897 if (bfd_is_und_section (bfd_get_section (sym)))
900 if (version_string && *version_string != '\0')
901 printf (hidden ? "@%s" : "@@%s", version_string);
906 static asymbol **syms;
907 static long symcount;
908 const char *filename, *functionname;
911 /* We need to get the canonical symbols in order to call
912 bfd_find_nearest_line. This is inefficient, but, then, you
913 don't have to use --line-numbers. */
914 if (abfd != lineno_cache_bfd && syms != NULL)
923 symsize = bfd_get_symtab_upper_bound (abfd);
925 bfd_fatal (bfd_get_filename (abfd));
926 syms = (asymbol **) xmalloc (symsize);
927 symcount = bfd_canonicalize_symtab (abfd, syms);
929 bfd_fatal (bfd_get_filename (abfd));
930 lineno_cache_bfd = abfd;
933 if (bfd_is_und_section (bfd_get_section (sym)))
935 static asection **secs;
936 static arelent ***relocs;
937 static long *relcount;
938 static unsigned int seccount;
942 /* For an undefined symbol, we try to find a reloc for the
943 symbol, and print the line number of the reloc. */
944 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
946 for (i = 0; i < seccount; i++)
947 if (relocs[i] != NULL)
959 struct get_relocs_info rinfo;
961 seccount = bfd_count_sections (abfd);
963 secs = (asection **) xmalloc (seccount * sizeof *secs);
964 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
965 relcount = (long *) xmalloc (seccount * sizeof *relcount);
968 rinfo.relocs = relocs;
969 rinfo.relcount = relcount;
971 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
972 lineno_cache_rel_bfd = abfd;
975 symname = bfd_asymbol_name (sym);
976 for (i = 0; i < seccount; i++)
980 for (j = 0; j < relcount[i]; j++)
985 if (r->sym_ptr_ptr != NULL
986 && (*r->sym_ptr_ptr)->section == sym->section
987 && (*r->sym_ptr_ptr)->value == sym->value
989 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
990 && bfd_find_nearest_line (abfd, secs[i], syms,
991 r->address, &filename,
992 &functionname, &lineno)
995 /* We only print the first one we find. */
996 printf ("\t%s:%u", filename, lineno);
1003 else if (bfd_get_section (sym)->owner == abfd)
1005 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
1006 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
1007 syms, sym->value, &filename,
1008 &functionname, &lineno))
1011 printf ("\t%s:%u", filename, lineno);
1018 /* Print the symbols when sorting by size. */
1021 print_size_symbols (bfd * abfd,
1022 bfd_boolean is_dynamic,
1023 struct size_sym * symsizes,
1028 struct size_sym *from;
1029 struct size_sym *fromend;
1031 store = bfd_make_empty_symbol (abfd);
1033 bfd_fatal (bfd_get_filename (abfd));
1036 fromend = from + symcount;
1038 for (; from < fromend; from++)
1042 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1044 bfd_fatal (bfd_get_filename (abfd));
1046 print_symbol (abfd, sym, from->size, archive_bfd);
1051 /* Print the symbols of ABFD that are held in MINISYMS.
1053 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1055 SYMCOUNT is the number of symbols in MINISYMS.
1057 SIZE is the size of a symbol in MINISYMS. */
1060 print_symbols (bfd * abfd,
1061 bfd_boolean is_dynamic,
1071 store = bfd_make_empty_symbol (abfd);
1073 bfd_fatal (bfd_get_filename (abfd));
1075 from = (bfd_byte *) minisyms;
1076 fromend = from + symcount * size;
1078 for (; from < fromend; from += size)
1082 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1084 bfd_fatal (bfd_get_filename (abfd));
1086 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1090 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1093 display_rel_file (bfd *abfd, bfd *archive_bfd)
1098 struct size_sym *symsizes;
1102 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1104 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1109 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1112 if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1114 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1118 bfd_fatal (bfd_get_filename (abfd));
1123 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1127 if (show_synthetic && size == sizeof (asymbol *))
1130 asymbol **static_syms = NULL;
1131 asymbol **dyn_syms = NULL;
1132 long static_count = 0;
1138 dyn_count = symcount;
1139 dyn_syms = (asymbol **) minisyms;
1143 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1145 static_count = symcount;
1146 static_syms = (asymbol **) minisyms;
1150 dyn_syms = (asymbol **) xmalloc (storage);
1151 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1153 bfd_fatal (bfd_get_filename (abfd));
1157 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1158 dyn_count, dyn_syms, &synthsyms);
1159 if (synth_count > 0)
1165 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1166 symp = (asymbol **) new_mini;
1167 memcpy (symp, minisyms, symcount * sizeof (*symp));
1169 for (i = 0; i < synth_count; i++)
1170 *symp++ = synthsyms + i;
1172 minisyms = new_mini;
1173 symcount += synth_count;
1177 /* Discard the symbols we don't want to print.
1178 It's OK to do this in place; we'll free the storage anyway
1179 (after printing). */
1181 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1187 sort_dynamic = dynamic;
1188 sort_x = bfd_make_empty_symbol (abfd);
1189 sort_y = bfd_make_empty_symbol (abfd);
1190 if (sort_x == NULL || sort_y == NULL)
1191 bfd_fatal (bfd_get_filename (abfd));
1194 qsort (minisyms, symcount, size,
1195 sorters[sort_numerically][reverse_sort]);
1197 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1202 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1204 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);
1803 char *lim = (char *) sbrk (0);
1805 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));