1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2016 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. */
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 {"stats", no_argument, &show_stats, 1},
224 {"synthetic", no_argument, &show_synthetic, 1},
225 {"target", required_argument, 0, OPTION_TARGET},
226 {"defined-only", no_argument, &defined_only, 1},
227 {"undefined-only", no_argument, &undefined_only, 1},
228 {"version", no_argument, &show_version, 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 -X 32_64 (ignored)\n\
275 @FILE Read options from FILE\n\
276 -h, --help Display this information\n\
277 -V, --version Display this program's version number\n\
279 list_supported_targets (program_name, stream);
280 if (REPORT_BUGS_TO[0] && status == 0)
281 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
285 /* Set the radix for the symbol value and size according to RADIX. */
288 set_print_radix (char *radix)
300 value_format_32bit[4] = *radix;
301 #if BFD_HOST_64BIT_LONG
302 value_format_64bit[5] = *radix;
303 #elif BFD_HOST_64BIT_LONG_LONG
305 value_format_64bit[6] = *radix;
307 value_format_64bit[7] = *radix;
310 other_format[3] = desc_format[3] = *radix;
313 fatal (_("%s: invalid radix"), radix);
318 set_output_format (char *f)
337 fatal (_("%s: invalid output format"), f);
339 format = &formats[i];
343 get_elf_symbol_type (unsigned int type)
350 case STT_NOTYPE: return "NOTYPE";
351 case STT_OBJECT: return "OBJECT";
352 case STT_FUNC: return "FUNC";
353 case STT_SECTION: return "SECTION";
354 case STT_FILE: return "FILE";
355 case STT_COMMON: return "COMMON";
356 case STT_TLS: return "TLS";
360 if (type >= STT_LOPROC && type <= STT_HIPROC)
361 n = asprintf (&bufp, _("<processor specific>: %d"), type);
362 else if (type >= STT_LOOS && type <= STT_HIOS)
363 n = asprintf (&bufp, _("<OS specific>: %d"), type);
365 n = asprintf (&bufp, _("<unknown>: %d"), type);
367 fatal ("%s", xstrerror (errno));
372 get_coff_symbol_type (const struct internal_syment *sym)
377 switch (sym->n_sclass)
379 case C_BLOCK: return "Block";
380 case C_FILE: return "File";
381 case C_LINE: return "Line";
387 switch (DTYPE(sym->n_type))
389 case DT_FCN: return "Function";
390 case DT_PTR: return "Pointer";
391 case DT_ARY: return "Array";
395 n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
397 fatal ("%s", xstrerror (errno));
401 /* Print symbol name NAME, read from ABFD, with printf format FORM,
402 demangling it if requested. */
405 print_symname (const char *form, const char *name, bfd *abfd)
407 if (do_demangle && *name)
409 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
423 print_symdef_entry (bfd *abfd)
425 symindex idx = BFD_NO_MORE_SYMBOLS;
427 bfd_boolean everprinted = FALSE;
429 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
430 idx != BFD_NO_MORE_SYMBOLS;
431 idx = bfd_get_next_mapent (abfd, idx, &thesym))
436 printf (_("\nArchive index:\n"));
439 elt = bfd_get_elt_at_index (abfd, idx);
441 bfd_fatal ("bfd_get_elt_at_index");
442 if (thesym->name != (char *) NULL)
444 print_symname ("%s", thesym->name, abfd);
445 printf (" in %s\n", bfd_get_filename (elt));
450 /* Choose which symbol entries to print;
451 compact them downward to get rid of the rest.
452 Return the number of symbols to be printed. */
455 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
456 long symcount, unsigned int size)
458 bfd_byte *from, *fromend, *to;
461 store = bfd_make_empty_symbol (abfd);
463 bfd_fatal (bfd_get_filename (abfd));
465 from = (bfd_byte *) minisyms;
466 fromend = from + symcount * size;
467 to = (bfd_byte *) minisyms;
469 for (; from < fromend; from += size)
476 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
478 bfd_fatal (bfd_get_filename (abfd));
480 if (strcmp (sym->name, "__gnu_lto_slim") == 0)
481 non_fatal (_("%s: plugin needed to handle lto object"),
482 bfd_get_filename (abfd));
485 keep = bfd_is_und_section (sym->section);
486 else if (external_only)
487 /* PR binutls/12753: Unique symbols are global too. */
488 keep = ((sym->flags & (BSF_GLOBAL
490 | BSF_GNU_UNIQUE)) != 0
491 || bfd_is_und_section (sym->section)
492 || bfd_is_com_section (sym->section));
497 && ! print_debug_syms
498 && (sym->flags & BSF_DEBUGGING) != 0)
503 && (bfd_is_abs_section (sym->section)
504 || bfd_is_und_section (sym->section)))
510 if (bfd_is_und_section (sym->section))
515 && bfd_is_target_special_symbol (abfd, sym)
516 && ! allow_special_symbols)
522 memcpy (to, from, size);
527 return (to - (bfd_byte *) minisyms) / size;
530 /* These globals are used to pass information into the sorting
532 static bfd *sort_bfd;
533 static bfd_boolean sort_dynamic;
534 static asymbol *sort_x;
535 static asymbol *sort_y;
537 /* Symbol-sorting predicates */
538 #define valueof(x) ((x)->section->vma + (x)->value)
540 /* Numeric sorts. Undefined symbols are always considered "less than"
541 defined symbols with zero values. Common symbols are not treated
542 specially -- i.e., their sizes are used as their "values". */
545 non_numeric_forward (const void *P_x, const void *P_y)
550 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
551 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
552 if (x == NULL || y == NULL)
553 bfd_fatal (bfd_get_filename (sort_bfd));
555 xn = bfd_asymbol_name (x);
556 yn = bfd_asymbol_name (y);
564 /* Solaris 2.5 has a bug in strcoll.
565 strcoll returns invalid values when confronted with empty strings. */
571 return strcoll (xn, yn);
573 return strcmp (xn, yn);
578 non_numeric_reverse (const void *x, const void *y)
580 return - non_numeric_forward (x, y);
584 numeric_forward (const void *P_x, const void *P_y)
589 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
590 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
591 if (x == NULL || y == NULL)
592 bfd_fatal (bfd_get_filename (sort_bfd));
594 xs = bfd_get_section (x);
595 ys = bfd_get_section (y);
597 if (bfd_is_und_section (xs))
599 if (! bfd_is_und_section (ys))
602 else if (bfd_is_und_section (ys))
604 else if (valueof (x) != valueof (y))
605 return valueof (x) < valueof (y) ? -1 : 1;
607 return non_numeric_forward (P_x, P_y);
611 numeric_reverse (const void *x, const void *y)
613 return - numeric_forward (x, y);
616 static int (*(sorters[2][2])) (const void *, const void *) =
618 { non_numeric_forward, non_numeric_reverse },
619 { numeric_forward, numeric_reverse }
622 /* This sort routine is used by sort_symbols_by_size. It is similar
623 to numeric_forward, but when symbols have the same value it sorts
624 by section VMA. This simplifies the sort_symbols_by_size code
625 which handles symbols at the end of sections. Also, this routine
626 tries to sort file names before other symbols with the same value.
627 That will make the file name have a zero size, which will make
628 sort_symbols_by_size choose the non file name symbol, leading to
629 more meaningful output. For similar reasons, this code sorts
630 gnu_compiled_* and gcc2_compiled before other symbols with the same
634 size_forward1 (const void *P_x, const void *P_y)
642 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
643 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
644 if (x == NULL || y == NULL)
645 bfd_fatal (bfd_get_filename (sort_bfd));
647 xs = bfd_get_section (x);
648 ys = bfd_get_section (y);
650 if (bfd_is_und_section (xs))
652 if (bfd_is_und_section (ys))
655 if (valueof (x) != valueof (y))
656 return valueof (x) < valueof (y) ? -1 : 1;
658 if (xs->vma != ys->vma)
659 return xs->vma < ys->vma ? -1 : 1;
661 xn = bfd_asymbol_name (x);
662 yn = bfd_asymbol_name (y);
666 /* The symbols gnu_compiled and gcc2_compiled convey even less
667 information than the file name, so sort them out first. */
669 xf = (strstr (xn, "gnu_compiled") != NULL
670 || strstr (xn, "gcc2_compiled") != NULL);
671 yf = (strstr (yn, "gnu_compiled") != NULL
672 || strstr (yn, "gcc2_compiled") != NULL);
679 /* We use a heuristic for the file name. It may not work on non
680 Unix systems, but it doesn't really matter; the only difference
681 is precisely which symbol names get printed. */
683 #define file_symbol(s, sn, snl) \
684 (((s)->flags & BSF_FILE) != 0 \
685 || ((sn)[(snl) - 2] == '.' \
686 && ((sn)[(snl) - 1] == 'o' \
687 || (sn)[(snl) - 1] == 'a')))
689 xf = file_symbol (x, xn, xnl);
690 yf = file_symbol (y, yn, ynl);
697 return non_numeric_forward (P_x, P_y);
700 /* This sort routine is used by sort_symbols_by_size. It is sorting
701 an array of size_sym structures into size order. */
704 size_forward2 (const void *P_x, const void *P_y)
706 const struct size_sym *x = (const struct size_sym *) P_x;
707 const struct size_sym *y = (const struct size_sym *) P_y;
709 if (x->size < y->size)
710 return reverse_sort ? 1 : -1;
711 else if (x->size > y->size)
712 return reverse_sort ? -1 : 1;
714 return sorters[0][reverse_sort] (x->minisym, y->minisym);
717 /* Sort the symbols by size. ELF provides a size but for other formats
718 we have to make a guess by assuming that the difference between the
719 address of a symbol and the address of the next higher symbol is the
723 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
724 long symcount, unsigned int size,
725 struct size_sym **symsizesp)
727 struct size_sym *symsizes;
728 bfd_byte *from, *fromend;
730 asymbol *store_sym, *store_next;
732 qsort (minisyms, symcount, size, size_forward1);
734 /* We are going to return a special set of symbols and sizes to
736 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
737 *symsizesp = symsizes;
739 /* Note that filter_symbols has already removed all absolute and
740 undefined symbols. Here we remove all symbols whose size winds
742 from = (bfd_byte *) minisyms;
743 fromend = from + symcount * size;
750 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
753 bfd_fatal (bfd_get_filename (abfd));
756 for (; from < fromend; from += size)
763 if (from + size < fromend)
765 next = bfd_minisymbol_to_symbol (abfd,
767 (const void *) (from + size),
770 bfd_fatal (bfd_get_filename (abfd));
775 sec = bfd_get_section (sym);
777 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
778 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
779 else if (bfd_is_com_section (sec))
783 if (from + size < fromend
784 && sec == bfd_get_section (next))
785 sz = valueof (next) - valueof (sym);
787 sz = (bfd_get_section_vma (abfd, sec)
788 + bfd_section_size (abfd, sec)
794 symsizes->minisym = (const void *) from;
802 store_sym = store_next;
806 symcount = symsizes - *symsizesp;
808 /* We must now sort again by size. */
809 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
814 /* This function is used to get the relocs for a particular section.
815 It is called via bfd_map_over_sections. */
818 get_relocs (bfd *abfd, asection *sec, void *dataarg)
820 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
824 if ((sec->flags & SEC_RELOC) == 0)
826 *data->relocs = NULL;
833 relsize = bfd_get_reloc_upper_bound (abfd, sec);
835 bfd_fatal (bfd_get_filename (abfd));
837 *data->relocs = (arelent **) xmalloc (relsize);
838 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
840 if (*data->relcount < 0)
841 bfd_fatal (bfd_get_filename (abfd));
849 /* Print a single symbol. */
852 print_symbol (bfd * abfd,
858 struct extended_symbol_info info;
862 format->print_symbol_filename (archive_bfd, abfd);
864 bfd_get_symbol_info (abfd, sym, &syminfo);
866 info.sinfo = &syminfo;
868 /* Synthetic symbols do not have a full symbol type set of data available. */
869 if ((sym->flags & BSF_SYNTHETIC) != 0)
872 info.coffinfo = NULL;
876 info.elfinfo = elf_symbol_from (abfd, sym);
877 info.coffinfo = coff_symbol_from (sym);
880 format->print_symbol_info (&info, abfd);
884 static asymbol **syms;
885 static long symcount;
886 const char *filename, *functionname;
889 /* We need to get the canonical symbols in order to call
890 bfd_find_nearest_line. This is inefficient, but, then, you
891 don't have to use --line-numbers. */
892 if (abfd != lineno_cache_bfd && syms != NULL)
901 symsize = bfd_get_symtab_upper_bound (abfd);
903 bfd_fatal (bfd_get_filename (abfd));
904 syms = (asymbol **) xmalloc (symsize);
905 symcount = bfd_canonicalize_symtab (abfd, syms);
907 bfd_fatal (bfd_get_filename (abfd));
908 lineno_cache_bfd = abfd;
911 if (bfd_is_und_section (bfd_get_section (sym)))
913 static asection **secs;
914 static arelent ***relocs;
915 static long *relcount;
916 static unsigned int seccount;
920 /* For an undefined symbol, we try to find a reloc for the
921 symbol, and print the line number of the reloc. */
922 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
924 for (i = 0; i < seccount; i++)
925 if (relocs[i] != NULL)
937 struct get_relocs_info rinfo;
939 seccount = bfd_count_sections (abfd);
941 secs = (asection **) xmalloc (seccount * sizeof *secs);
942 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
943 relcount = (long *) xmalloc (seccount * sizeof *relcount);
946 rinfo.relocs = relocs;
947 rinfo.relcount = relcount;
949 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
950 lineno_cache_rel_bfd = abfd;
953 symname = bfd_asymbol_name (sym);
954 for (i = 0; i < seccount; i++)
958 for (j = 0; j < relcount[i]; j++)
963 if (r->sym_ptr_ptr != NULL
964 && (*r->sym_ptr_ptr)->section == sym->section
965 && (*r->sym_ptr_ptr)->value == sym->value
967 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
968 && bfd_find_nearest_line (abfd, secs[i], syms,
969 r->address, &filename,
970 &functionname, &lineno)
973 /* We only print the first one we find. */
974 printf ("\t%s:%u", filename, lineno);
981 else if (bfd_get_section (sym)->owner == abfd)
983 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
984 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
985 syms, sym->value, &filename,
986 &functionname, &lineno))
989 printf ("\t%s:%u", filename, lineno);
996 /* Print the symbols when sorting by size. */
999 print_size_symbols (bfd * abfd,
1000 bfd_boolean is_dynamic,
1001 struct size_sym * symsizes,
1006 struct size_sym *from;
1007 struct size_sym *fromend;
1009 store = bfd_make_empty_symbol (abfd);
1011 bfd_fatal (bfd_get_filename (abfd));
1014 fromend = from + symcount;
1016 for (; from < fromend; from++)
1020 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
1022 bfd_fatal (bfd_get_filename (abfd));
1024 print_symbol (abfd, sym, from->size, archive_bfd);
1029 /* Print the symbols of ABFD that are held in MINISYMS.
1031 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1033 SYMCOUNT is the number of symbols in MINISYMS.
1035 SIZE is the size of a symbol in MINISYMS. */
1038 print_symbols (bfd * abfd,
1039 bfd_boolean is_dynamic,
1049 store = bfd_make_empty_symbol (abfd);
1051 bfd_fatal (bfd_get_filename (abfd));
1053 from = (bfd_byte *) minisyms;
1054 fromend = from + symcount * size;
1056 for (; from < fromend; from += size)
1060 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
1062 bfd_fatal (bfd_get_filename (abfd));
1064 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1068 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1071 display_rel_file (bfd *abfd, bfd *archive_bfd)
1076 struct size_sym *symsizes;
1080 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1082 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1087 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1090 if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1092 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1096 bfd_fatal (bfd_get_filename (abfd));
1101 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1105 if (show_synthetic && size == sizeof (asymbol *))
1108 asymbol **static_syms = NULL;
1109 asymbol **dyn_syms = NULL;
1110 long static_count = 0;
1116 dyn_count = symcount;
1117 dyn_syms = (asymbol **) minisyms;
1121 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1123 static_count = symcount;
1124 static_syms = (asymbol **) minisyms;
1128 dyn_syms = (asymbol **) xmalloc (storage);
1129 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1131 bfd_fatal (bfd_get_filename (abfd));
1135 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1136 dyn_count, dyn_syms, &synthsyms);
1137 if (synth_count > 0)
1143 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1144 symp = (asymbol **) new_mini;
1145 memcpy (symp, minisyms, symcount * sizeof (*symp));
1147 for (i = 0; i < synth_count; i++)
1148 *symp++ = synthsyms + i;
1150 minisyms = new_mini;
1151 symcount += synth_count;
1155 /* Discard the symbols we don't want to print.
1156 It's OK to do this in place; we'll free the storage anyway
1157 (after printing). */
1159 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1165 sort_dynamic = dynamic;
1166 sort_x = bfd_make_empty_symbol (abfd);
1167 sort_y = bfd_make_empty_symbol (abfd);
1168 if (sort_x == NULL || sort_y == NULL)
1169 bfd_fatal (bfd_get_filename (abfd));
1172 qsort (minisyms, symcount, size,
1173 sorters[sort_numerically][reverse_sort]);
1175 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1180 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1182 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1189 set_print_width (bfd *file)
1191 print_width = bfd_get_arch_size (file);
1193 if (print_width == -1)
1196 Guess the target's bitsize based on its name.
1197 We assume here than any 64-bit format will include
1198 "64" somewhere in its name. The only known exception
1199 is the MMO object file format. */
1200 if (strstr (bfd_get_target (file), "64") != NULL
1201 || strcmp (bfd_get_target (file), "mmo") == 0)
1209 display_archive (bfd *file)
1212 bfd *last_arfile = NULL;
1215 format->print_archive_filename (bfd_get_filename (file));
1218 print_symdef_entry (file);
1224 arfile = bfd_openr_next_archived_file (file, arfile);
1228 if (bfd_get_error () != bfd_error_no_more_archived_files)
1229 bfd_fatal (bfd_get_filename (file));
1233 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1235 set_print_width (arfile);
1236 format->print_archive_member (bfd_get_filename (file),
1237 bfd_get_filename (arfile));
1238 display_rel_file (arfile, file);
1242 bfd_nonfatal (bfd_get_filename (arfile));
1243 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1245 list_matching_formats (matching);
1250 if (last_arfile != NULL)
1252 bfd_close (last_arfile);
1253 lineno_cache_bfd = NULL;
1254 lineno_cache_rel_bfd = NULL;
1255 if (arfile == last_arfile)
1258 last_arfile = arfile;
1261 if (last_arfile != NULL)
1263 bfd_close (last_arfile);
1264 lineno_cache_bfd = NULL;
1265 lineno_cache_rel_bfd = NULL;
1270 display_file (char *filename)
1272 bfd_boolean retval = TRUE;
1276 if (get_file_size (filename) < 1)
1279 file = bfd_openr (filename, target ? target : plugin_target);
1282 bfd_nonfatal (filename);
1286 /* If printing line numbers, decompress the debug sections. */
1288 file->flags |= BFD_DECOMPRESS;
1290 if (bfd_check_format (file, bfd_archive))
1292 display_archive (file);
1294 else if (bfd_check_format_matches (file, bfd_object, &matching))
1296 set_print_width (file);
1297 format->print_object_filename (filename);
1298 display_rel_file (file, NULL);
1302 bfd_nonfatal (filename);
1303 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1305 list_matching_formats (matching);
1311 if (!bfd_close (file))
1312 bfd_fatal (filename);
1314 lineno_cache_bfd = NULL;
1315 lineno_cache_rel_bfd = NULL;
1320 /* The following 3 groups of functions are called unconditionally,
1321 once at the start of processing each file of the appropriate type.
1322 They should check `filename_per_file' and `filename_per_symbol',
1323 as appropriate for their output format, to determine whether to
1326 /* Print the name of an object file given on the command line. */
1329 print_object_filename_bsd (char *filename)
1331 if (filename_per_file && !filename_per_symbol)
1332 printf ("\n%s:\n", filename);
1336 print_object_filename_sysv (char *filename)
1339 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1341 printf (_("\n\nSymbols from %s:\n\n"), filename);
1342 if (print_width == 32)
1344 Name Value Class Type Size Line Section\n\n"));
1347 Name Value Class Type Size Line Section\n\n"));
1351 print_object_filename_posix (char *filename)
1353 if (filename_per_file && !filename_per_symbol)
1354 printf ("%s:\n", filename);
1357 /* Print the name of an archive file given on the command line. */
1360 print_archive_filename_bsd (char *filename)
1362 if (filename_per_file)
1363 printf ("\n%s:\n", filename);
1367 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1372 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1376 /* Print the name of an archive member file. */
1379 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1380 const char *filename)
1382 if (!filename_per_symbol)
1383 printf ("\n%s:\n", filename);
1387 print_archive_member_sysv (char *archive, const char *filename)
1390 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1392 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1393 if (print_width == 32)
1395 Name Value Class Type Size Line Section\n\n"));
1398 Name Value Class Type Size Line Section\n\n"));
1402 print_archive_member_posix (char *archive, const char *filename)
1404 if (!filename_per_symbol)
1405 printf ("%s[%s]:\n", archive, filename);
1408 /* Print the name of the file (and archive, if there is one)
1409 containing a symbol. */
1412 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1414 if (filename_per_symbol)
1417 printf ("%s:", bfd_get_filename (archive_bfd));
1418 printf ("%s:", bfd_get_filename (abfd));
1423 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1425 if (filename_per_symbol)
1428 printf ("%s:", bfd_get_filename (archive_bfd));
1429 printf ("%s:", bfd_get_filename (abfd));
1434 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1436 if (filename_per_symbol)
1439 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1440 bfd_get_filename (abfd));
1442 printf ("%s: ", bfd_get_filename (abfd));
1446 /* Print a symbol value. */
1449 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1451 switch (print_width)
1454 printf (value_format_32bit, (unsigned long) val);
1458 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1459 printf (value_format_64bit, val);
1461 /* We have a 64 bit value to print, but the host is only 32 bit. */
1462 if (print_radix == 16)
1463 bfd_fprintf_vma (abfd, stdout, val);
1469 s = buf + sizeof buf;
1473 *--s = (val % print_radix) + '0';
1476 while ((buf + sizeof buf - 1) - s < 16)
1484 fatal (_("Print width has not been initialized (%d)"), print_width);
1489 /* Print a line of information about a symbol. */
1492 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1494 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1496 if (print_width == 64)
1502 /* Normally we print the value of the symbol. If we are printing the
1503 size or sorting by size then we print its size, except for the
1504 (weird) special case where both flags are defined, in which case we
1505 print both values. This conforms to documented behaviour. */
1506 if (sort_by_size && !print_size)
1507 print_value (abfd, SYM_SIZE (info));
1509 print_value (abfd, SYM_VALUE (info));
1510 if (print_size && SYM_SIZE (info))
1513 print_value (abfd, SYM_SIZE (info));
1517 printf (" %c", SYM_TYPE (info));
1519 if (SYM_TYPE (info) == '-')
1523 printf (other_format, SYM_STAB_OTHER (info));
1525 printf (desc_format, SYM_STAB_DESC (info));
1526 printf (" %5s", SYM_STAB_NAME (info));
1528 print_symname (" %s", SYM_NAME (info), abfd);
1532 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1534 print_symname ("%-20s|", SYM_NAME (info), abfd);
1536 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1538 if (print_width == 32)
1544 print_value (abfd, SYM_VALUE (info));
1546 printf ("| %c |", SYM_TYPE (info));
1548 if (SYM_TYPE (info) == '-')
1551 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1552 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1553 printf ("| |"); /* Line, Section. */
1557 /* Type, Size, Line, Section */
1560 get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1561 else if (info->coffinfo)
1563 get_coff_symbol_type (&info->coffinfo->native->u.syment));
1567 if (SYM_SIZE (info))
1568 print_value (abfd, SYM_SIZE (info));
1571 if (print_width == 32)
1578 printf("| |%s", info->elfinfo->symbol.section->name);
1579 else if (info->coffinfo)
1580 printf("| |%s", info->coffinfo->symbol.section->name);
1587 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1589 print_symname ("%s ", SYM_NAME (info), abfd);
1590 printf ("%c ", SYM_TYPE (info));
1592 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1596 print_value (abfd, SYM_VALUE (info));
1598 if (SYM_SIZE (info))
1599 print_value (abfd, SYM_SIZE (info));
1604 main (int argc, char **argv)
1609 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1610 setlocale (LC_MESSAGES, "");
1612 #if defined (HAVE_SETLOCALE)
1613 setlocale (LC_CTYPE, "");
1614 setlocale (LC_COLLATE, "");
1616 bindtextdomain (PACKAGE, LOCALEDIR);
1617 textdomain (PACKAGE);
1619 program_name = *argv;
1620 xmalloc_set_program_name (program_name);
1621 bfd_set_error_program_name (program_name);
1622 #if BFD_SUPPORTS_PLUGINS
1623 bfd_plugin_set_program_name (program_name);
1626 START_PROGRESS (program_name, 0);
1628 expandargv (&argc, &argv);
1631 set_default_bfd_target ();
1633 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1634 long_options, (int *) 0)) != EOF)
1639 print_debug_syms = 1;
1643 filename_per_symbol = 1;
1645 case 'B': /* For MIPS compatibility. */
1646 set_output_format ("bsd");
1652 enum demangling_styles style;
1654 style = cplus_demangle_name_to_style (optarg);
1655 if (style == unknown_demangling)
1656 fatal (_("unknown demangling style `%s'"),
1659 cplus_demangle_set_style (style);
1666 /* Ignored for HP/UX compatibility. */
1669 set_output_format (optarg);
1683 sort_numerically = 1;
1688 sort_numerically = 0;
1691 case OPTION_SIZE_SORT:
1693 sort_numerically = 0;
1697 set_output_format ("posix");
1709 set_print_radix (optarg);
1718 /* Ignored for (partial) AIX compatibility. On AIX, the
1719 argument has values 32, 64, or 32_64, and specifies that
1720 only 32-bit, only 64-bit, or both kinds of objects should
1721 be examined. The default is 32. So plain AIX nm on a
1722 library archive with both kinds of objects will ignore
1723 the 64-bit ones. For GNU nm, the default is and always
1724 has been -X 32_64, and other options are not supported. */
1725 if (strcmp (optarg, "32_64") != 0)
1726 fatal (_("Only -X 32_64 is supported"));
1729 case OPTION_TARGET: /* --target */
1733 case OPTION_PLUGIN: /* --plugin */
1734 #if BFD_SUPPORTS_PLUGINS
1735 bfd_plugin_set_plugin (optarg);
1737 fatal (_("sorry - this program has been built without plugin support\n"));
1741 case 0: /* A long option that just sets a flag. */
1750 print_version ("nm");
1752 if (sort_by_size && undefined_only)
1754 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1755 non_fatal (_("will produce no output, since undefined symbols have no size."));
1759 /* OK, all options now parsed. If no filename specified, do a.out. */
1761 return !display_file ("a.out");
1765 if (argc - optind > 1)
1766 filename_per_file = 1;
1768 /* We were given several filenames to do. */
1769 while (optind < argc)
1772 if (!display_file (argv[optind++]))
1776 END_PROGRESS (program_name);
1781 char *lim = (char *) sbrk (0);
1783 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));