1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
27 #include "aout/stab_gnu.h"
28 #include "aout/ranlib.h"
30 #include "libiberty.h"
32 #include "elf/common.h"
36 /* When sorting by size, we use this structure to hold the size and a
37 pointer to the minisymbol. */
45 /* When fetching relocs, we use this structure to pass information to
48 struct get_relocs_info
56 struct extended_symbol_info
60 elf_symbol_type *elfinfo;
61 /* FIXME: We should add more fields for Type, Line, Section. */
63 #define SYM_NAME(sym) (sym->sinfo->name)
64 #define SYM_VALUE(sym) (sym->sinfo->value)
65 #define SYM_TYPE(sym) (sym->sinfo->type)
66 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
67 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
68 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
69 #define SYM_SIZE(sym) \
70 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
72 /* The output formatting functions. */
73 static void print_object_filename_bsd (char *);
74 static void print_object_filename_sysv (char *);
75 static void print_object_filename_posix (char *);
76 static void print_archive_filename_bsd (char *);
77 static void print_archive_filename_sysv (char *);
78 static void print_archive_filename_posix (char *);
79 static void print_archive_member_bsd (char *, const char *);
80 static void print_archive_member_sysv (char *, const char *);
81 static void print_archive_member_posix (char *, const char *);
82 static void print_symbol_filename_bsd (bfd *, bfd *);
83 static void print_symbol_filename_sysv (bfd *, bfd *);
84 static void print_symbol_filename_posix (bfd *, bfd *);
85 static void print_value (bfd *, bfd_vma);
86 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
87 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
88 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
90 /* Support for different output formats. */
93 /* Print the name of an object file given on the command line. */
94 void (*print_object_filename) (char *);
96 /* Print the name of an archive file given on the command line. */
97 void (*print_archive_filename) (char *);
99 /* Print the name of an archive member file. */
100 void (*print_archive_member) (char *, const char *);
102 /* Print the name of the file (and archive, if there is one)
103 containing a symbol. */
104 void (*print_symbol_filename) (bfd *, bfd *);
106 /* Print a line of information about a symbol. */
107 void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
110 static struct output_fns formats[] =
112 {print_object_filename_bsd,
113 print_archive_filename_bsd,
114 print_archive_member_bsd,
115 print_symbol_filename_bsd,
116 print_symbol_info_bsd},
117 {print_object_filename_sysv,
118 print_archive_filename_sysv,
119 print_archive_member_sysv,
120 print_symbol_filename_sysv,
121 print_symbol_info_sysv},
122 {print_object_filename_posix,
123 print_archive_filename_posix,
124 print_archive_member_posix,
125 print_symbol_filename_posix,
126 print_symbol_info_posix}
129 /* Indices in `formats'. */
131 #define FORMAT_SYSV 1
132 #define FORMAT_POSIX 2
133 #define FORMAT_DEFAULT FORMAT_BSD
135 /* The output format to use. */
136 static struct output_fns *format = &formats[FORMAT_DEFAULT];
138 /* Command options. */
140 static int do_demangle = 0; /* Pretty print C++ symbol names. */
141 static int external_only = 0; /* Print external symbols only. */
142 static int defined_only = 0; /* Print defined symbols only. */
143 static int no_sort = 0; /* Don't sort; print syms in order found. */
144 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
145 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
146 static int print_size = 0; /* Print size of defined symbols. */
147 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
148 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
149 static int sort_by_size = 0; /* Sort by size of symbol. */
150 static int undefined_only = 0; /* Print undefined symbols only. */
151 static int dynamic = 0; /* Print dynamic symbols. */
152 static int show_version = 0; /* Show the version number. */
153 static int show_stats = 0; /* Show statistics. */
154 static int show_synthetic = 0; /* Display synthesized symbols too. */
155 static int line_numbers = 0; /* Print line numbers for symbols. */
156 static int allow_special_symbols = 0; /* Allow special symbols. */
158 /* When to print the names of files. Not mutually exclusive in SYSV format. */
159 static int filename_per_file = 0; /* Once per file, on its own line. */
160 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
162 /* Print formats for printing a symbol value. */
163 static char value_format_32bit[] = "%08lx";
164 #if BFD_HOST_64BIT_LONG
165 static char value_format_64bit[] = "%016lx";
166 #elif BFD_HOST_64BIT_LONG_LONG
168 static char value_format_64bit[] = "%016llx";
170 static char value_format_64bit[] = "%016I64x";
173 static int print_width = 0;
174 static int print_radix = 16;
175 /* Print formats for printing stab info. */
176 static char other_format[] = "%02x";
177 static char desc_format[] = "%04x";
179 static char *target = NULL;
180 static char *plugin_target = NULL;
182 /* Used to cache the line numbers for a BFD. */
183 static bfd *lineno_cache_bfd;
184 static bfd *lineno_cache_rel_bfd;
186 #define OPTION_TARGET 200
187 #define OPTION_PLUGIN 201
189 static struct option long_options[] =
191 {"debug-syms", no_argument, &print_debug_syms, 1},
192 {"demangle", optional_argument, 0, 'C'},
193 {"dynamic", no_argument, &dynamic, 1},
194 {"extern-only", no_argument, &external_only, 1},
195 {"format", required_argument, 0, 'f'},
196 {"help", no_argument, 0, 'h'},
197 {"line-numbers", no_argument, 0, 'l'},
198 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
199 {"no-demangle", no_argument, &do_demangle, 0},
200 {"no-sort", no_argument, &no_sort, 1},
201 {"numeric-sort", no_argument, &sort_numerically, 1},
202 {"plugin", required_argument, 0, OPTION_PLUGIN},
203 {"portability", no_argument, 0, 'P'},
204 {"print-armap", no_argument, &print_armap, 1},
205 {"print-file-name", no_argument, 0, 'o'},
206 {"print-size", no_argument, 0, 'S'},
207 {"radix", required_argument, 0, 't'},
208 {"reverse-sort", no_argument, &reverse_sort, 1},
209 {"size-sort", no_argument, &sort_by_size, 1},
210 {"special-syms", no_argument, &allow_special_symbols, 1},
211 {"stats", no_argument, &show_stats, 1},
212 {"synthetic", no_argument, &show_synthetic, 1},
213 {"target", required_argument, 0, OPTION_TARGET},
214 {"defined-only", no_argument, &defined_only, 1},
215 {"undefined-only", no_argument, &undefined_only, 1},
216 {"version", no_argument, &show_version, 1},
217 {0, no_argument, 0, 0}
220 /* Some error-reporting functions. */
223 usage (FILE *stream, int status)
225 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
226 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
227 fprintf (stream, _(" The options are:\n\
228 -a, --debug-syms Display debugger-only symbols\n\
229 -A, --print-file-name Print name of the input file before every symbol\n\
230 -B Same as --format=bsd\n\
231 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
232 The STYLE, if specified, can be `auto' (the default),\n\
233 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
235 --no-demangle Do not demangle low-level symbol names\n\
236 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
237 --defined-only Display only defined symbols\n\
239 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
240 `sysv' or `posix'. The default is `bsd'\n\
241 -g, --extern-only Display only external symbols\n\
242 -l, --line-numbers Use debugging information to find a filename and\n\
243 line number for each symbol\n\
244 -n, --numeric-sort Sort symbols numerically by address\n\
246 -p, --no-sort Do not sort the symbols\n\
247 -P, --portability Same as --format=posix\n\
248 -r, --reverse-sort Reverse the sense of the sort\n"));
249 #if BFD_SUPPORTS_PLUGINS
250 fprintf (stream, _("\
251 --plugin NAME Load the specified plugin\n"));
253 fprintf (stream, _("\
254 -S, --print-size Print size of defined symbols\n\
255 -s, --print-armap Include index for symbols from archive members\n\
256 --size-sort Sort symbols by size\n\
257 --special-syms Include special symbols in the output\n\
258 --synthetic Display synthetic symbols as well\n\
259 -t, --radix=RADIX Use RADIX for printing symbol values\n\
260 --target=BFDNAME Specify the target object format as BFDNAME\n\
261 -u, --undefined-only Display only undefined symbols\n\
262 -X 32_64 (ignored)\n\
263 @FILE Read options from FILE\n\
264 -h, --help Display this information\n\
265 -V, --version Display this program's version number\n\
267 list_supported_targets (program_name, stream);
268 if (REPORT_BUGS_TO[0] && status == 0)
269 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
273 /* Set the radix for the symbol value and size according to RADIX. */
276 set_print_radix (char *radix)
288 value_format_32bit[4] = *radix;
289 #if BFD_HOST_64BIT_LONG
290 value_format_64bit[5] = *radix;
291 #elif BFD_HOST_64BIT_LONG_LONG
293 value_format_64bit[6] = *radix;
295 value_format_64bit[7] = *radix;
298 other_format[3] = desc_format[3] = *radix;
301 fatal (_("%s: invalid radix"), radix);
306 set_output_format (char *f)
325 fatal (_("%s: invalid output format"), f);
327 format = &formats[i];
331 get_symbol_type (unsigned int type)
333 static char buff [32];
337 case STT_NOTYPE: return "NOTYPE";
338 case STT_OBJECT: return "OBJECT";
339 case STT_FUNC: return "FUNC";
340 case STT_SECTION: return "SECTION";
341 case STT_FILE: return "FILE";
342 case STT_COMMON: return "COMMON";
343 case STT_TLS: return "TLS";
345 if (type >= STT_LOPROC && type <= STT_HIPROC)
346 sprintf (buff, _("<processor specific>: %d"), type);
347 else if (type >= STT_LOOS && type <= STT_HIOS)
348 sprintf (buff, _("<OS specific>: %d"), type);
350 sprintf (buff, _("<unknown>: %d"), type);
355 /* Print symbol name NAME, read from ABFD, with printf format FORM,
356 demangling it if requested. */
359 print_symname (const char *form, const char *name, bfd *abfd)
361 if (do_demangle && *name)
363 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
377 print_symdef_entry (bfd *abfd)
379 symindex idx = BFD_NO_MORE_SYMBOLS;
381 bfd_boolean everprinted = FALSE;
383 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
384 idx != BFD_NO_MORE_SYMBOLS;
385 idx = bfd_get_next_mapent (abfd, idx, &thesym))
390 printf (_("\nArchive index:\n"));
393 elt = bfd_get_elt_at_index (abfd, idx);
395 bfd_fatal ("bfd_get_elt_at_index");
396 if (thesym->name != (char *) NULL)
398 print_symname ("%s", thesym->name, abfd);
399 printf (" in %s\n", bfd_get_filename (elt));
404 /* Choose which symbol entries to print;
405 compact them downward to get rid of the rest.
406 Return the number of symbols to be printed. */
409 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
410 long symcount, unsigned int size)
412 bfd_byte *from, *fromend, *to;
415 store = bfd_make_empty_symbol (abfd);
417 bfd_fatal (bfd_get_filename (abfd));
419 from = (bfd_byte *) minisyms;
420 fromend = from + symcount * size;
421 to = (bfd_byte *) minisyms;
423 for (; from < fromend; from += size)
430 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
432 bfd_fatal (bfd_get_filename (abfd));
435 keep = bfd_is_und_section (sym->section);
436 else if (external_only)
437 keep = ((sym->flags & BSF_GLOBAL) != 0
438 || (sym->flags & BSF_WEAK) != 0
439 /* PR binutls/12753: Unique symbols are global too. */
440 || (sym->flags & BSF_GNU_UNIQUE) != 0
441 || bfd_is_und_section (sym->section)
442 || bfd_is_com_section (sym->section));
447 && ! print_debug_syms
448 && (sym->flags & BSF_DEBUGGING) != 0)
453 && (bfd_is_abs_section (sym->section)
454 || bfd_is_und_section (sym->section)))
460 if (bfd_is_und_section (sym->section))
465 && bfd_is_target_special_symbol (abfd, sym)
466 && ! allow_special_symbols)
472 memcpy (to, from, size);
477 return (to - (bfd_byte *) minisyms) / size;
480 /* These globals are used to pass information into the sorting
482 static bfd *sort_bfd;
483 static bfd_boolean sort_dynamic;
484 static asymbol *sort_x;
485 static asymbol *sort_y;
487 /* Symbol-sorting predicates */
488 #define valueof(x) ((x)->section->vma + (x)->value)
490 /* Numeric sorts. Undefined symbols are always considered "less than"
491 defined symbols with zero values. Common symbols are not treated
492 specially -- i.e., their sizes are used as their "values". */
495 non_numeric_forward (const void *P_x, const void *P_y)
500 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
501 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
502 if (x == NULL || y == NULL)
503 bfd_fatal (bfd_get_filename (sort_bfd));
505 xn = bfd_asymbol_name (x);
506 yn = bfd_asymbol_name (y);
514 /* Solaris 2.5 has a bug in strcoll.
515 strcoll returns invalid values when confronted with empty strings. */
521 return strcoll (xn, yn);
523 return strcmp (xn, yn);
528 non_numeric_reverse (const void *x, const void *y)
530 return - non_numeric_forward (x, y);
534 numeric_forward (const void *P_x, const void *P_y)
539 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
540 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
541 if (x == NULL || y == NULL)
542 bfd_fatal (bfd_get_filename (sort_bfd));
544 xs = bfd_get_section (x);
545 ys = bfd_get_section (y);
547 if (bfd_is_und_section (xs))
549 if (! bfd_is_und_section (ys))
552 else if (bfd_is_und_section (ys))
554 else if (valueof (x) != valueof (y))
555 return valueof (x) < valueof (y) ? -1 : 1;
557 return non_numeric_forward (P_x, P_y);
561 numeric_reverse (const void *x, const void *y)
563 return - numeric_forward (x, y);
566 static int (*(sorters[2][2])) (const void *, const void *) =
568 { non_numeric_forward, non_numeric_reverse },
569 { numeric_forward, numeric_reverse }
572 /* This sort routine is used by sort_symbols_by_size. It is similar
573 to numeric_forward, but when symbols have the same value it sorts
574 by section VMA. This simplifies the sort_symbols_by_size code
575 which handles symbols at the end of sections. Also, this routine
576 tries to sort file names before other symbols with the same value.
577 That will make the file name have a zero size, which will make
578 sort_symbols_by_size choose the non file name symbol, leading to
579 more meaningful output. For similar reasons, this code sorts
580 gnu_compiled_* and gcc2_compiled before other symbols with the same
584 size_forward1 (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 if (valueof (x) != valueof (y))
606 return valueof (x) < valueof (y) ? -1 : 1;
608 if (xs->vma != ys->vma)
609 return xs->vma < ys->vma ? -1 : 1;
611 xn = bfd_asymbol_name (x);
612 yn = bfd_asymbol_name (y);
616 /* The symbols gnu_compiled and gcc2_compiled convey even less
617 information than the file name, so sort them out first. */
619 xf = (strstr (xn, "gnu_compiled") != NULL
620 || strstr (xn, "gcc2_compiled") != NULL);
621 yf = (strstr (yn, "gnu_compiled") != NULL
622 || strstr (yn, "gcc2_compiled") != NULL);
629 /* We use a heuristic for the file name. It may not work on non
630 Unix systems, but it doesn't really matter; the only difference
631 is precisely which symbol names get printed. */
633 #define file_symbol(s, sn, snl) \
634 (((s)->flags & BSF_FILE) != 0 \
635 || ((sn)[(snl) - 2] == '.' \
636 && ((sn)[(snl) - 1] == 'o' \
637 || (sn)[(snl) - 1] == 'a')))
639 xf = file_symbol (x, xn, xnl);
640 yf = file_symbol (y, yn, ynl);
647 return non_numeric_forward (P_x, P_y);
650 /* This sort routine is used by sort_symbols_by_size. It is sorting
651 an array of size_sym structures into size order. */
654 size_forward2 (const void *P_x, const void *P_y)
656 const struct size_sym *x = (const struct size_sym *) P_x;
657 const struct size_sym *y = (const struct size_sym *) P_y;
659 if (x->size < y->size)
660 return reverse_sort ? 1 : -1;
661 else if (x->size > y->size)
662 return reverse_sort ? -1 : 1;
664 return sorters[0][reverse_sort] (x->minisym, y->minisym);
667 /* Sort the symbols by size. ELF provides a size but for other formats
668 we have to make a guess by assuming that the difference between the
669 address of a symbol and the address of the next higher symbol is the
673 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
674 long symcount, unsigned int size,
675 struct size_sym **symsizesp)
677 struct size_sym *symsizes;
678 bfd_byte *from, *fromend;
680 asymbol *store_sym, *store_next;
682 qsort (minisyms, symcount, size, size_forward1);
684 /* We are going to return a special set of symbols and sizes to
686 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
687 *symsizesp = symsizes;
689 /* Note that filter_symbols has already removed all absolute and
690 undefined symbols. Here we remove all symbols whose size winds
692 from = (bfd_byte *) minisyms;
693 fromend = from + symcount * size;
700 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
703 bfd_fatal (bfd_get_filename (abfd));
706 for (; from < fromend; from += size)
713 if (from + size < fromend)
715 next = bfd_minisymbol_to_symbol (abfd,
717 (const void *) (from + size),
720 bfd_fatal (bfd_get_filename (abfd));
725 sec = bfd_get_section (sym);
727 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
728 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
729 else if (bfd_is_com_section (sec))
733 if (from + size < fromend
734 && sec == bfd_get_section (next))
735 sz = valueof (next) - valueof (sym);
737 sz = (bfd_get_section_vma (abfd, sec)
738 + bfd_section_size (abfd, sec)
744 symsizes->minisym = (const void *) from;
752 store_sym = store_next;
756 symcount = symsizes - *symsizesp;
758 /* We must now sort again by size. */
759 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
764 /* This function is used to get the relocs for a particular section.
765 It is called via bfd_map_over_sections. */
768 get_relocs (bfd *abfd, asection *sec, void *dataarg)
770 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
774 if ((sec->flags & SEC_RELOC) == 0)
776 *data->relocs = NULL;
783 relsize = bfd_get_reloc_upper_bound (abfd, sec);
785 bfd_fatal (bfd_get_filename (abfd));
787 *data->relocs = (arelent **) xmalloc (relsize);
788 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
790 if (*data->relcount < 0)
791 bfd_fatal (bfd_get_filename (abfd));
799 /* Print a single symbol. */
802 print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
805 struct extended_symbol_info info;
809 format->print_symbol_filename (archive_bfd, abfd);
811 bfd_get_symbol_info (abfd, sym, &syminfo);
812 info.sinfo = &syminfo;
814 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
815 info.elfinfo = (elf_symbol_type *) sym;
818 format->print_symbol_info (&info, abfd);
822 static asymbol **syms;
823 static long symcount;
824 const char *filename, *functionname;
827 /* We need to get the canonical symbols in order to call
828 bfd_find_nearest_line. This is inefficient, but, then, you
829 don't have to use --line-numbers. */
830 if (abfd != lineno_cache_bfd && syms != NULL)
839 symsize = bfd_get_symtab_upper_bound (abfd);
841 bfd_fatal (bfd_get_filename (abfd));
842 syms = (asymbol **) xmalloc (symsize);
843 symcount = bfd_canonicalize_symtab (abfd, syms);
845 bfd_fatal (bfd_get_filename (abfd));
846 lineno_cache_bfd = abfd;
849 if (bfd_is_und_section (bfd_get_section (sym)))
851 static asection **secs;
852 static arelent ***relocs;
853 static long *relcount;
854 static unsigned int seccount;
858 /* For an undefined symbol, we try to find a reloc for the
859 symbol, and print the line number of the reloc. */
860 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
862 for (i = 0; i < seccount; i++)
863 if (relocs[i] != NULL)
875 struct get_relocs_info rinfo;
877 seccount = bfd_count_sections (abfd);
879 secs = (asection **) xmalloc (seccount * sizeof *secs);
880 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
881 relcount = (long *) xmalloc (seccount * sizeof *relcount);
884 rinfo.relocs = relocs;
885 rinfo.relcount = relcount;
887 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
888 lineno_cache_rel_bfd = abfd;
891 symname = bfd_asymbol_name (sym);
892 for (i = 0; i < seccount; i++)
896 for (j = 0; j < relcount[i]; j++)
901 if (r->sym_ptr_ptr != NULL
902 && (*r->sym_ptr_ptr)->section == sym->section
903 && (*r->sym_ptr_ptr)->value == sym->value
905 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
906 && bfd_find_nearest_line (abfd, secs[i], syms,
907 r->address, &filename,
908 &functionname, &lineno)
911 /* We only print the first one we find. */
912 printf ("\t%s:%u", filename, lineno);
919 else if (bfd_get_section (sym)->owner == abfd)
921 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
922 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
923 syms, sym->value, &filename,
924 &functionname, &lineno))
927 printf ("\t%s:%u", filename, lineno);
934 /* Print the symbols when sorting by size. */
937 print_size_symbols (bfd *abfd, bfd_boolean is_dynamic,
938 struct size_sym *symsizes, long symcount,
942 struct size_sym *from, *fromend;
944 store = bfd_make_empty_symbol (abfd);
946 bfd_fatal (bfd_get_filename (abfd));
949 fromend = from + symcount;
950 for (; from < fromend; from++)
955 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
957 bfd_fatal (bfd_get_filename (abfd));
959 /* For elf we have already computed the correct symbol size. */
960 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
963 ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
965 print_symbol (abfd, sym, ssize, archive_bfd);
970 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
974 print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
975 unsigned int size, bfd *archive_bfd)
978 bfd_byte *from, *fromend;
980 store = bfd_make_empty_symbol (abfd);
982 bfd_fatal (bfd_get_filename (abfd));
984 from = (bfd_byte *) minisyms;
985 fromend = from + symcount * size;
986 for (; from < fromend; from += size)
990 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
992 bfd_fatal (bfd_get_filename (abfd));
994 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
998 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1001 display_rel_file (bfd *abfd, bfd *archive_bfd)
1006 struct size_sym *symsizes;
1010 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1012 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1017 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1019 bfd_fatal (bfd_get_filename (abfd));
1023 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1027 if (show_synthetic && size == sizeof (asymbol *))
1031 asymbol **static_syms = NULL;
1032 asymbol **dyn_syms = NULL;
1033 long static_count = 0;
1038 dyn_count = symcount;
1039 dyn_syms = (asymbol **) minisyms;
1043 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1045 static_count = symcount;
1046 static_syms = (asymbol **) minisyms;
1050 dyn_syms = (asymbol **) xmalloc (storage);
1051 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1053 bfd_fatal (bfd_get_filename (abfd));
1056 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1057 dyn_count, dyn_syms, &synthsyms);
1058 if (synth_count > 0)
1064 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1065 symp = (asymbol **) new_mini;
1066 memcpy (symp, minisyms, symcount * sizeof (*symp));
1068 for (i = 0; i < synth_count; i++)
1069 *symp++ = synthsyms + i;
1071 minisyms = new_mini;
1072 symcount += synth_count;
1076 /* Discard the symbols we don't want to print.
1077 It's OK to do this in place; we'll free the storage anyway
1078 (after printing). */
1080 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1086 sort_dynamic = dynamic;
1087 sort_x = bfd_make_empty_symbol (abfd);
1088 sort_y = bfd_make_empty_symbol (abfd);
1089 if (sort_x == NULL || sort_y == NULL)
1090 bfd_fatal (bfd_get_filename (abfd));
1093 qsort (minisyms, symcount, size,
1094 sorters[sort_numerically][reverse_sort]);
1096 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1101 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1103 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1109 set_print_width (bfd *file)
1111 print_width = bfd_get_arch_size (file);
1113 if (print_width == -1)
1116 Guess the target's bitsize based on its name.
1117 We assume here than any 64-bit format will include
1118 "64" somewhere in its name. The only known exception
1119 is the MMO object file format. */
1120 if (strstr (bfd_get_target (file), "64") != NULL
1121 || strcmp (bfd_get_target (file), "mmo") == 0)
1129 display_archive (bfd *file)
1132 bfd *last_arfile = NULL;
1135 format->print_archive_filename (bfd_get_filename (file));
1138 print_symdef_entry (file);
1144 arfile = bfd_openr_next_archived_file (file, arfile);
1148 if (bfd_get_error () != bfd_error_no_more_archived_files)
1149 bfd_fatal (bfd_get_filename (file));
1153 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1155 set_print_width (arfile);
1156 format->print_archive_member (bfd_get_filename (file),
1157 bfd_get_filename (arfile));
1158 display_rel_file (arfile, file);
1162 bfd_nonfatal (bfd_get_filename (arfile));
1163 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1165 list_matching_formats (matching);
1170 if (last_arfile != NULL)
1172 bfd_close (last_arfile);
1173 lineno_cache_bfd = NULL;
1174 lineno_cache_rel_bfd = NULL;
1176 last_arfile = arfile;
1179 if (last_arfile != NULL)
1181 bfd_close (last_arfile);
1182 lineno_cache_bfd = NULL;
1183 lineno_cache_rel_bfd = NULL;
1188 display_file (char *filename)
1190 bfd_boolean retval = TRUE;
1194 if (get_file_size (filename) < 1)
1197 file = bfd_openr (filename, target ? target : plugin_target);
1200 bfd_nonfatal (filename);
1204 if (bfd_check_format (file, bfd_archive))
1206 display_archive (file);
1208 else if (bfd_check_format_matches (file, bfd_object, &matching))
1210 set_print_width (file);
1211 format->print_object_filename (filename);
1212 display_rel_file (file, NULL);
1216 bfd_nonfatal (filename);
1217 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1219 list_matching_formats (matching);
1225 if (!bfd_close (file))
1226 bfd_fatal (filename);
1228 lineno_cache_bfd = NULL;
1229 lineno_cache_rel_bfd = NULL;
1234 /* The following 3 groups of functions are called unconditionally,
1235 once at the start of processing each file of the appropriate type.
1236 They should check `filename_per_file' and `filename_per_symbol',
1237 as appropriate for their output format, to determine whether to
1240 /* Print the name of an object file given on the command line. */
1243 print_object_filename_bsd (char *filename)
1245 if (filename_per_file && !filename_per_symbol)
1246 printf ("\n%s:\n", filename);
1250 print_object_filename_sysv (char *filename)
1253 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1255 printf (_("\n\nSymbols from %s:\n\n"), filename);
1256 if (print_width == 32)
1258 Name Value Class Type Size Line Section\n\n"));
1261 Name Value Class Type Size Line Section\n\n"));
1265 print_object_filename_posix (char *filename)
1267 if (filename_per_file && !filename_per_symbol)
1268 printf ("%s:\n", filename);
1271 /* Print the name of an archive file given on the command line. */
1274 print_archive_filename_bsd (char *filename)
1276 if (filename_per_file)
1277 printf ("\n%s:\n", filename);
1281 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1286 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1290 /* Print the name of an archive member file. */
1293 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1294 const char *filename)
1296 if (!filename_per_symbol)
1297 printf ("\n%s:\n", filename);
1301 print_archive_member_sysv (char *archive, const char *filename)
1304 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1306 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1307 if (print_width == 32)
1309 Name Value Class Type Size Line Section\n\n"));
1312 Name Value Class Type Size Line Section\n\n"));
1316 print_archive_member_posix (char *archive, const char *filename)
1318 if (!filename_per_symbol)
1319 printf ("%s[%s]:\n", archive, filename);
1322 /* Print the name of the file (and archive, if there is one)
1323 containing a symbol. */
1326 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1328 if (filename_per_symbol)
1331 printf ("%s:", bfd_get_filename (archive_bfd));
1332 printf ("%s:", bfd_get_filename (abfd));
1337 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1339 if (filename_per_symbol)
1342 printf ("%s:", bfd_get_filename (archive_bfd));
1343 printf ("%s:", bfd_get_filename (abfd));
1348 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1350 if (filename_per_symbol)
1353 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1354 bfd_get_filename (abfd));
1356 printf ("%s: ", bfd_get_filename (abfd));
1360 /* Print a symbol value. */
1363 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1365 switch (print_width)
1368 printf (value_format_32bit, (unsigned long) val);
1372 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1373 printf (value_format_64bit, val);
1375 /* We have a 64 bit value to print, but the host is only 32 bit. */
1376 if (print_radix == 16)
1377 bfd_fprintf_vma (abfd, stdout, val);
1383 s = buf + sizeof buf;
1387 *--s = (val % print_radix) + '0';
1390 while ((buf + sizeof buf - 1) - s < 16)
1398 fatal (_("Print width has not been initialized (%d)"), print_width);
1403 /* Print a line of information about a symbol. */
1406 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1408 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1410 if (print_width == 64)
1416 /* Normally we print the value of the symbol. If we are printing the
1417 size or sorting by size then we print its size, except for the
1418 (weird) special case where both flags are defined, in which case we
1419 print both values. This conforms to documented behaviour. */
1420 if (sort_by_size && !print_size)
1421 print_value (abfd, SYM_SIZE (info));
1423 print_value (abfd, SYM_VALUE (info));
1425 if (print_size && SYM_SIZE (info))
1428 print_value (abfd, SYM_SIZE (info));
1432 printf (" %c", SYM_TYPE (info));
1434 if (SYM_TYPE (info) == '-')
1438 printf (other_format, SYM_STAB_OTHER (info));
1440 printf (desc_format, SYM_STAB_DESC (info));
1441 printf (" %5s", SYM_STAB_NAME (info));
1443 print_symname (" %s", SYM_NAME (info), abfd);
1447 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1449 print_symname ("%-20s|", SYM_NAME (info), abfd);
1451 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1453 if (print_width == 32)
1459 print_value (abfd, SYM_VALUE (info));
1461 printf ("| %c |", SYM_TYPE (info));
1463 if (SYM_TYPE (info) == '-')
1466 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1467 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1468 printf ("| |"); /* Line, Section. */
1472 /* Type, Size, Line, Section */
1475 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1479 if (SYM_SIZE (info))
1480 print_value (abfd, SYM_SIZE (info));
1483 if (print_width == 32)
1490 printf("| |%s", info->elfinfo->symbol.section->name);
1497 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1499 print_symname ("%s ", SYM_NAME (info), abfd);
1500 printf ("%c ", SYM_TYPE (info));
1502 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1506 print_value (abfd, SYM_VALUE (info));
1508 if (SYM_SIZE (info))
1509 print_value (abfd, SYM_SIZE (info));
1514 main (int argc, char **argv)
1519 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1520 setlocale (LC_MESSAGES, "");
1522 #if defined (HAVE_SETLOCALE)
1523 setlocale (LC_CTYPE, "");
1524 setlocale (LC_COLLATE, "");
1526 bindtextdomain (PACKAGE, LOCALEDIR);
1527 textdomain (PACKAGE);
1529 program_name = *argv;
1530 xmalloc_set_program_name (program_name);
1531 #if BFD_SUPPORTS_PLUGINS
1532 bfd_plugin_set_program_name (program_name);
1535 START_PROGRESS (program_name, 0);
1537 expandargv (&argc, &argv);
1540 set_default_bfd_target ();
1542 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1543 long_options, (int *) 0)) != EOF)
1548 print_debug_syms = 1;
1552 filename_per_symbol = 1;
1554 case 'B': /* For MIPS compatibility. */
1555 set_output_format ("bsd");
1561 enum demangling_styles style;
1563 style = cplus_demangle_name_to_style (optarg);
1564 if (style == unknown_demangling)
1565 fatal (_("unknown demangling style `%s'"),
1568 cplus_demangle_set_style (style);
1575 /* Ignored for HP/UX compatibility. */
1578 set_output_format (optarg);
1591 sort_numerically = 1;
1597 set_output_format ("posix");
1609 set_print_radix (optarg);
1618 /* Ignored for (partial) AIX compatibility. On AIX, the
1619 argument has values 32, 64, or 32_64, and specifies that
1620 only 32-bit, only 64-bit, or both kinds of objects should
1621 be examined. The default is 32. So plain AIX nm on a
1622 library archive with both kinds of objects will ignore
1623 the 64-bit ones. For GNU nm, the default is and always
1624 has been -X 32_64, and other options are not supported. */
1625 if (strcmp (optarg, "32_64") != 0)
1626 fatal (_("Only -X 32_64 is supported"));
1629 case OPTION_TARGET: /* --target */
1633 case OPTION_PLUGIN: /* --plugin */
1634 #if BFD_SUPPORTS_PLUGINS
1635 plugin_target = "plugin";
1636 bfd_plugin_set_plugin (optarg);
1638 fatal (_("sorry - this program has been built without plugin support\n"));
1642 case 0: /* A long option that just sets a flag. */
1651 print_version ("nm");
1653 if (sort_by_size && undefined_only)
1655 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1656 non_fatal (_("will produce no output, since undefined symbols have no size."));
1660 /* OK, all options now parsed. If no filename specified, do a.out. */
1662 return !display_file ("a.out");
1666 if (argc - optind > 1)
1667 filename_per_file = 1;
1669 /* We were given several filenames to do. */
1670 while (optind < argc)
1673 if (!display_file (argv[optind++]))
1677 END_PROGRESS (program_name);
1682 char *lim = (char *) sbrk (0);
1684 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));