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 \
688 || ((sn)[(snl) - 2] == '.' \
689 && ((sn)[(snl) - 1] == 'o' \
690 || (sn)[(snl) - 1] == 'a')))
692 xf = file_symbol (x, xn, xnl);
693 yf = file_symbol (y, yn, ynl);
700 return non_numeric_forward (P_x, P_y);
703 /* This sort routine is used by sort_symbols_by_size. It is sorting
704 an array of size_sym structures into size order. */
707 size_forward2 (const void *P_x, const void *P_y)
709 const struct size_sym *x = (const struct size_sym *) P_x;
710 const struct size_sym *y = (const struct size_sym *) P_y;
712 if (x->size < y->size)
713 return reverse_sort ? 1 : -1;
714 else if (x->size > y->size)
715 return reverse_sort ? -1 : 1;
717 return sorters[0][reverse_sort] (x->minisym, y->minisym);
720 /* Sort the symbols by size. ELF provides a size but for other formats
721 we have to make a guess by assuming that the difference between the
722 address of a symbol and the address of the next higher symbol is the
726 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
727 long symcount, unsigned int size,
728 struct size_sym **symsizesp)
730 struct size_sym *symsizes;
731 bfd_byte *from, *fromend;
733 asymbol *store_sym, *store_next;
735 qsort (minisyms, symcount, size, size_forward1);
737 /* We are going to return a special set of symbols and sizes to
739 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
740 *symsizesp = symsizes;
742 /* Note that filter_symbols has already removed all absolute and
743 undefined symbols. Here we remove all symbols whose size winds
745 from = (bfd_byte *) minisyms;
746 fromend = from + symcount * size;
753 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
756 bfd_fatal (bfd_get_filename (abfd));
759 for (; from < fromend; from += size)
765 int synthetic = (sym->flags & BSF_SYNTHETIC);
767 if (from + size < fromend)
769 next = bfd_minisymbol_to_symbol (abfd,
771 (const void *) (from + size),
774 bfd_fatal (bfd_get_filename (abfd));
779 sec = bfd_get_section (sym);
781 /* Synthetic symbols don't have a full type set of data available, thus
782 we can't rely on that information for the symbol size. */
783 if (!synthetic && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
784 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
785 else if (!synthetic && bfd_is_com_section (sec))
789 if (from + size < fromend
790 && sec == bfd_get_section (next))
791 sz = valueof (next) - valueof (sym);
793 sz = (bfd_get_section_vma (abfd, sec)
794 + bfd_section_size (abfd, sec)
800 symsizes->minisym = (const void *) from;
808 store_sym = store_next;
812 symcount = symsizes - *symsizesp;
814 /* We must now sort again by size. */
815 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
820 /* This function is used to get the relocs for a particular section.
821 It is called via bfd_map_over_sections. */
824 get_relocs (bfd *abfd, asection *sec, void *dataarg)
826 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
830 if ((sec->flags & SEC_RELOC) == 0)
832 *data->relocs = NULL;
839 relsize = bfd_get_reloc_upper_bound (abfd, sec);
841 bfd_fatal (bfd_get_filename (abfd));
843 *data->relocs = (arelent **) xmalloc (relsize);
844 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
846 if (*data->relcount < 0)
847 bfd_fatal (bfd_get_filename (abfd));
855 /* Print a single symbol. */
858 print_symbol (bfd * abfd,
864 struct extended_symbol_info info;
868 format->print_symbol_filename (archive_bfd, abfd);
870 bfd_get_symbol_info (abfd, sym, &syminfo);
872 info.sinfo = &syminfo;
874 /* Synthetic symbols do not have a full symbol type set of data available. */
875 if ((sym->flags & BSF_SYNTHETIC) != 0)
878 info.coffinfo = NULL;
882 info.elfinfo = elf_symbol_from (abfd, sym);
883 info.coffinfo = coff_symbol_from (sym);
886 format->print_symbol_info (&info, abfd);
888 if (with_symbol_versions)
890 const char * version_string = NULL;
891 bfd_boolean hidden = FALSE;
893 if ((sym->flags & BSF_SYNTHETIC) == 0)
894 version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
896 if (bfd_is_und_section (bfd_get_section (sym)))
899 if (version_string && *version_string != '\0')
900 printf (hidden ? "@%s" : "@@%s", version_string);
905 static asymbol **syms;
906 static long symcount;
907 const char *filename, *functionname;
910 /* We need to get the canonical symbols in order to call
911 bfd_find_nearest_line. This is inefficient, but, then, you
912 don't have to use --line-numbers. */
913 if (abfd != lineno_cache_bfd && syms != NULL)
922 symsize = bfd_get_symtab_upper_bound (abfd);
924 bfd_fatal (bfd_get_filename (abfd));
925 syms = (asymbol **) xmalloc (symsize);
926 symcount = bfd_canonicalize_symtab (abfd, syms);
928 bfd_fatal (bfd_get_filename (abfd));
929 lineno_cache_bfd = abfd;
932 if (bfd_is_und_section (bfd_get_section (sym)))
934 static asection **secs;
935 static arelent ***relocs;
936 static long *relcount;
937 static unsigned int seccount;
941 /* For an undefined symbol, we try to find a reloc for the
942 symbol, and print the line number of the reloc. */
943 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
945 for (i = 0; i < seccount; i++)
946 if (relocs[i] != NULL)
958 struct get_relocs_info rinfo;
960 seccount = bfd_count_sections (abfd);
962 secs = (asection **) xmalloc (seccount * sizeof *secs);
963 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
964 relcount = (long *) xmalloc (seccount * sizeof *relcount);
967 rinfo.relocs = relocs;
968 rinfo.relcount = relcount;
970 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
971 lineno_cache_rel_bfd = abfd;
974 symname = bfd_asymbol_name (sym);
975 for (i = 0; i < seccount; i++)
979 for (j = 0; j < relcount[i]; j++)
984 if (r->sym_ptr_ptr != NULL
985 && (*r->sym_ptr_ptr)->section == sym->section
986 && (*r->sym_ptr_ptr)->value == sym->value
988 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
989 && bfd_find_nearest_line (abfd, secs[i], syms,
990 r->address, &filename,
991 &functionname, &lineno)
994 /* We only print the first one we find. */
995 printf ("\t%s:%u", filename, lineno);
1002 else if (bfd_get_section (sym)->owner == abfd)
1004 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
1005 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
1006 syms, sym->value, &filename,
1007 &functionname, &lineno))
1010 printf ("\t%s:%u", filename, lineno);
1017 /* Print the symbols when sorting by size. */
1020 print_size_symbols (bfd * abfd,
1021 bfd_boolean is_dynamic,
1022 struct size_sym * symsizes,
1027 struct size_sym *from;
1028 struct size_sym *fromend;
1030 store = bfd_make_empty_symbol (abfd);
1032 bfd_fatal (bfd_get_filename (abfd));
1035 fromend = from + symcount;
1037 for (; from < fromend; from++)
1041 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1043 bfd_fatal (bfd_get_filename (abfd));
1045 print_symbol (abfd, sym, from->size, archive_bfd);
1050 /* Print the symbols of ABFD that are held in MINISYMS.
1052 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1054 SYMCOUNT is the number of symbols in MINISYMS.
1056 SIZE is the size of a symbol in MINISYMS. */
1059 print_symbols (bfd * abfd,
1060 bfd_boolean is_dynamic,
1070 store = bfd_make_empty_symbol (abfd);
1072 bfd_fatal (bfd_get_filename (abfd));
1074 from = (bfd_byte *) minisyms;
1075 fromend = from + symcount * size;
1077 for (; from < fromend; from += size)
1081 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1083 bfd_fatal (bfd_get_filename (abfd));
1085 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1089 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1092 display_rel_file (bfd *abfd, bfd *archive_bfd)
1097 struct size_sym *symsizes;
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 *))
1129 asymbol **static_syms = NULL;
1130 asymbol **dyn_syms = NULL;
1131 long static_count = 0;
1137 dyn_count = symcount;
1138 dyn_syms = (asymbol **) minisyms;
1142 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1144 static_count = symcount;
1145 static_syms = (asymbol **) minisyms;
1149 dyn_syms = (asymbol **) xmalloc (storage);
1150 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1152 bfd_fatal (bfd_get_filename (abfd));
1156 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1157 dyn_count, dyn_syms, &synthsyms);
1158 if (synth_count > 0)
1164 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1165 symp = (asymbol **) new_mini;
1166 memcpy (symp, minisyms, symcount * sizeof (*symp));
1168 for (i = 0; i < synth_count; i++)
1169 *symp++ = synthsyms + i;
1171 minisyms = new_mini;
1172 symcount += synth_count;
1176 /* Discard the symbols we don't want to print.
1177 It's OK to do this in place; we'll free the storage anyway
1178 (after printing). */
1180 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1186 sort_dynamic = dynamic;
1187 sort_x = bfd_make_empty_symbol (abfd);
1188 sort_y = bfd_make_empty_symbol (abfd);
1189 if (sort_x == NULL || sort_y == NULL)
1190 bfd_fatal (bfd_get_filename (abfd));
1193 qsort (minisyms, symcount, size,
1194 sorters[sort_numerically][reverse_sort]);
1196 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1201 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1203 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1210 set_print_width (bfd *file)
1212 print_width = bfd_get_arch_size (file);
1214 if (print_width == -1)
1217 Guess the target's bitsize based on its name.
1218 We assume here than any 64-bit format will include
1219 "64" somewhere in its name. The only known exception
1220 is the MMO object file format. */
1221 if (strstr (bfd_get_target (file), "64") != NULL
1222 || strcmp (bfd_get_target (file), "mmo") == 0)
1230 display_archive (bfd *file)
1233 bfd *last_arfile = NULL;
1236 format->print_archive_filename (bfd_get_filename (file));
1239 print_symdef_entry (file);
1245 arfile = bfd_openr_next_archived_file (file, arfile);
1249 if (bfd_get_error () != bfd_error_no_more_archived_files)
1250 bfd_fatal (bfd_get_filename (file));
1254 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1256 set_print_width (arfile);
1257 format->print_archive_member (bfd_get_filename (file),
1258 bfd_get_filename (arfile));
1259 display_rel_file (arfile, file);
1263 bfd_nonfatal (bfd_get_filename (arfile));
1264 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1266 list_matching_formats (matching);
1271 if (last_arfile != NULL)
1273 bfd_close (last_arfile);
1274 lineno_cache_bfd = NULL;
1275 lineno_cache_rel_bfd = NULL;
1276 if (arfile == last_arfile)
1279 last_arfile = arfile;
1282 if (last_arfile != NULL)
1284 bfd_close (last_arfile);
1285 lineno_cache_bfd = NULL;
1286 lineno_cache_rel_bfd = NULL;
1291 display_file (char *filename)
1293 bfd_boolean retval = TRUE;
1297 if (get_file_size (filename) < 1)
1300 file = bfd_openr (filename, target ? target : plugin_target);
1303 bfd_nonfatal (filename);
1307 /* If printing line numbers, decompress the debug sections. */
1309 file->flags |= BFD_DECOMPRESS;
1311 if (bfd_check_format (file, bfd_archive))
1313 display_archive (file);
1315 else if (bfd_check_format_matches (file, bfd_object, &matching))
1317 set_print_width (file);
1318 format->print_object_filename (filename);
1319 display_rel_file (file, NULL);
1323 bfd_nonfatal (filename);
1324 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1326 list_matching_formats (matching);
1332 if (!bfd_close (file))
1333 bfd_fatal (filename);
1335 lineno_cache_bfd = NULL;
1336 lineno_cache_rel_bfd = NULL;
1341 /* The following 3 groups of functions are called unconditionally,
1342 once at the start of processing each file of the appropriate type.
1343 They should check `filename_per_file' and `filename_per_symbol',
1344 as appropriate for their output format, to determine whether to
1347 /* Print the name of an object file given on the command line. */
1350 print_object_filename_bsd (char *filename)
1352 if (filename_per_file && !filename_per_symbol)
1353 printf ("\n%s:\n", filename);
1357 print_object_filename_sysv (char *filename)
1360 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1362 printf (_("\n\nSymbols from %s:\n\n"), filename);
1363 if (print_width == 32)
1365 Name Value Class Type Size Line Section\n\n"));
1368 Name Value Class Type Size Line Section\n\n"));
1372 print_object_filename_posix (char *filename)
1374 if (filename_per_file && !filename_per_symbol)
1375 printf ("%s:\n", filename);
1378 /* Print the name of an archive file given on the command line. */
1381 print_archive_filename_bsd (char *filename)
1383 if (filename_per_file)
1384 printf ("\n%s:\n", filename);
1388 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1393 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1397 /* Print the name of an archive member file. */
1400 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1401 const char *filename)
1403 if (!filename_per_symbol)
1404 printf ("\n%s:\n", filename);
1408 print_archive_member_sysv (char *archive, const char *filename)
1411 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1413 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1414 if (print_width == 32)
1416 Name Value Class Type Size Line Section\n\n"));
1419 Name Value Class Type Size Line Section\n\n"));
1423 print_archive_member_posix (char *archive, const char *filename)
1425 if (!filename_per_symbol)
1426 printf ("%s[%s]:\n", archive, filename);
1429 /* Print the name of the file (and archive, if there is one)
1430 containing a symbol. */
1433 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1435 if (filename_per_symbol)
1438 printf ("%s:", bfd_get_filename (archive_bfd));
1439 printf ("%s:", bfd_get_filename (abfd));
1444 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1446 if (filename_per_symbol)
1449 printf ("%s:", bfd_get_filename (archive_bfd));
1450 printf ("%s:", bfd_get_filename (abfd));
1455 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1457 if (filename_per_symbol)
1460 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1461 bfd_get_filename (abfd));
1463 printf ("%s: ", bfd_get_filename (abfd));
1467 /* Print a symbol value. */
1470 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1472 switch (print_width)
1475 printf (value_format_32bit, (unsigned long) val);
1479 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1480 printf (value_format_64bit, val);
1482 /* We have a 64 bit value to print, but the host is only 32 bit. */
1483 if (print_radix == 16)
1484 bfd_fprintf_vma (abfd, stdout, val);
1490 s = buf + sizeof buf;
1494 *--s = (val % print_radix) + '0';
1497 while ((buf + sizeof buf - 1) - s < 16)
1505 fatal (_("Print width has not been initialized (%d)"), print_width);
1510 /* Print a line of information about a symbol. */
1513 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1515 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1517 if (print_width == 64)
1523 /* Normally we print the value of the symbol. If we are printing the
1524 size or sorting by size then we print its size, except for the
1525 (weird) special case where both flags are defined, in which case we
1526 print both values. This conforms to documented behaviour. */
1527 if (sort_by_size && !print_size)
1528 print_value (abfd, SYM_SIZE (info));
1530 print_value (abfd, SYM_VALUE (info));
1531 if (print_size && SYM_SIZE (info))
1534 print_value (abfd, SYM_SIZE (info));
1538 printf (" %c", SYM_TYPE (info));
1540 if (SYM_TYPE (info) == '-')
1544 printf (other_format, SYM_STAB_OTHER (info));
1546 printf (desc_format, SYM_STAB_DESC (info));
1547 printf (" %5s", SYM_STAB_NAME (info));
1549 print_symname (" %s", SYM_NAME (info), abfd);
1553 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1555 print_symname ("%-20s|", SYM_NAME (info), abfd);
1557 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1559 if (print_width == 32)
1565 print_value (abfd, SYM_VALUE (info));
1567 printf ("| %c |", SYM_TYPE (info));
1569 if (SYM_TYPE (info) == '-')
1572 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1573 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1574 printf ("| |"); /* Line, Section. */
1578 /* Type, Size, Line, Section */
1581 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1582 else if (info->coffinfo)
1584 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1588 if (SYM_SIZE (info))
1589 print_value (abfd, SYM_SIZE (info));
1592 if (print_width == 32)
1599 printf("| |%s", info->elfinfo->symbol.section->name);
1600 else if (info->coffinfo)
1601 printf("| |%s", info->coffinfo->symbol.section->name);
1608 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1610 print_symname ("%s ", SYM_NAME (info), abfd);
1611 printf ("%c ", SYM_TYPE (info));
1613 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1617 print_value (abfd, SYM_VALUE (info));
1619 if (SYM_SIZE (info))
1620 print_value (abfd, SYM_SIZE (info));
1625 main (int argc, char **argv)
1630 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1631 setlocale (LC_MESSAGES, "");
1633 #if defined (HAVE_SETLOCALE)
1634 setlocale (LC_CTYPE, "");
1635 setlocale (LC_COLLATE, "");
1637 bindtextdomain (PACKAGE, LOCALEDIR);
1638 textdomain (PACKAGE);
1640 program_name = *argv;
1641 xmalloc_set_program_name (program_name);
1642 bfd_set_error_program_name (program_name);
1643 #if BFD_SUPPORTS_PLUGINS
1644 bfd_plugin_set_program_name (program_name);
1647 START_PROGRESS (program_name, 0);
1649 expandargv (&argc, &argv);
1652 set_default_bfd_target ();
1654 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1655 long_options, (int *) 0)) != EOF)
1660 print_debug_syms = 1;
1664 filename_per_symbol = 1;
1666 case 'B': /* For MIPS compatibility. */
1667 set_output_format ("bsd");
1673 enum demangling_styles style;
1675 style = cplus_demangle_name_to_style (optarg);
1676 if (style == unknown_demangling)
1677 fatal (_("unknown demangling style `%s'"),
1680 cplus_demangle_set_style (style);
1687 /* Ignored for HP/UX compatibility. */
1690 set_output_format (optarg);
1704 sort_numerically = 1;
1709 sort_numerically = 0;
1712 case OPTION_SIZE_SORT:
1714 sort_numerically = 0;
1718 set_output_format ("posix");
1730 set_print_radix (optarg);
1739 /* Ignored for (partial) AIX compatibility. On AIX, the
1740 argument has values 32, 64, or 32_64, and specifies that
1741 only 32-bit, only 64-bit, or both kinds of objects should
1742 be examined. The default is 32. So plain AIX nm on a
1743 library archive with both kinds of objects will ignore
1744 the 64-bit ones. For GNU nm, the default is and always
1745 has been -X 32_64, and other options are not supported. */
1746 if (strcmp (optarg, "32_64") != 0)
1747 fatal (_("Only -X 32_64 is supported"));
1750 case OPTION_TARGET: /* --target */
1754 case OPTION_PLUGIN: /* --plugin */
1755 #if BFD_SUPPORTS_PLUGINS
1756 bfd_plugin_set_plugin (optarg);
1758 fatal (_("sorry - this program has been built without plugin support\n"));
1762 case 0: /* A long option that just sets a flag. */
1771 print_version ("nm");
1773 if (sort_by_size && undefined_only)
1775 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1776 non_fatal (_("will produce no output, since undefined symbols have no size."));
1780 /* OK, all options now parsed. If no filename specified, do a.out. */
1782 return !display_file ("a.out");
1786 if (argc - optind > 1)
1787 filename_per_file = 1;
1789 /* We were given several filenames to do. */
1790 while (optind < argc)
1793 if (!display_file (argv[optind++]))
1797 END_PROGRESS (program_name);
1802 char *lim = (char *) sbrk (0);
1804 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));