1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2014 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"
34 /* When sorting by size, we use this structure to hold the size and a
35 pointer to the minisymbol. */
43 /* When fetching relocs, we use this structure to pass information to
46 struct get_relocs_info
54 struct extended_symbol_info
58 elf_symbol_type *elfinfo;
59 /* FIXME: We should add more fields for Type, Line, Section. */
61 #define SYM_NAME(sym) (sym->sinfo->name)
62 #define SYM_VALUE(sym) (sym->sinfo->value)
63 #define SYM_TYPE(sym) (sym->sinfo->type)
64 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
65 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
66 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
67 #define SYM_SIZE(sym) \
68 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
70 /* The output formatting functions. */
71 static void print_object_filename_bsd (char *);
72 static void print_object_filename_sysv (char *);
73 static void print_object_filename_posix (char *);
74 static void print_archive_filename_bsd (char *);
75 static void print_archive_filename_sysv (char *);
76 static void print_archive_filename_posix (char *);
77 static void print_archive_member_bsd (char *, const char *);
78 static void print_archive_member_sysv (char *, const char *);
79 static void print_archive_member_posix (char *, const char *);
80 static void print_symbol_filename_bsd (bfd *, bfd *);
81 static void print_symbol_filename_sysv (bfd *, bfd *);
82 static void print_symbol_filename_posix (bfd *, bfd *);
83 static void print_value (bfd *, bfd_vma);
84 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
85 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
86 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
88 /* Support for different output formats. */
91 /* Print the name of an object file given on the command line. */
92 void (*print_object_filename) (char *);
94 /* Print the name of an archive file given on the command line. */
95 void (*print_archive_filename) (char *);
97 /* Print the name of an archive member file. */
98 void (*print_archive_member) (char *, const char *);
100 /* Print the name of the file (and archive, if there is one)
101 containing a symbol. */
102 void (*print_symbol_filename) (bfd *, bfd *);
104 /* Print a line of information about a symbol. */
105 void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
108 static struct output_fns formats[] =
110 {print_object_filename_bsd,
111 print_archive_filename_bsd,
112 print_archive_member_bsd,
113 print_symbol_filename_bsd,
114 print_symbol_info_bsd},
115 {print_object_filename_sysv,
116 print_archive_filename_sysv,
117 print_archive_member_sysv,
118 print_symbol_filename_sysv,
119 print_symbol_info_sysv},
120 {print_object_filename_posix,
121 print_archive_filename_posix,
122 print_archive_member_posix,
123 print_symbol_filename_posix,
124 print_symbol_info_posix}
127 /* Indices in `formats'. */
129 #define FORMAT_SYSV 1
130 #define FORMAT_POSIX 2
131 #define FORMAT_DEFAULT FORMAT_BSD
133 /* The output format to use. */
134 static struct output_fns *format = &formats[FORMAT_DEFAULT];
136 /* Command options. */
138 static int do_demangle = 0; /* Pretty print C++ symbol names. */
139 static int external_only = 0; /* Print external symbols only. */
140 static int defined_only = 0; /* Print defined symbols only. */
141 static int no_sort = 0; /* Don't sort; print syms in order found. */
142 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
143 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
144 static int print_size = 0; /* Print size of defined symbols. */
145 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
146 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
147 static int sort_by_size = 0; /* Sort by size of symbol. */
148 static int undefined_only = 0; /* Print undefined symbols only. */
149 static int dynamic = 0; /* Print dynamic symbols. */
150 static int show_version = 0; /* Show the version number. */
151 static int show_stats = 0; /* Show statistics. */
152 static int show_synthetic = 0; /* Display synthesized symbols too. */
153 static int line_numbers = 0; /* Print line numbers for symbols. */
154 static int allow_special_symbols = 0; /* Allow special symbols. */
156 /* When to print the names of files. Not mutually exclusive in SYSV format. */
157 static int filename_per_file = 0; /* Once per file, on its own line. */
158 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
160 /* Print formats for printing a symbol value. */
161 static char value_format_32bit[] = "%08lx";
162 #if BFD_HOST_64BIT_LONG
163 static char value_format_64bit[] = "%016lx";
164 #elif BFD_HOST_64BIT_LONG_LONG
166 static char value_format_64bit[] = "%016llx";
168 static char value_format_64bit[] = "%016I64x";
171 static int print_width = 0;
172 static int print_radix = 16;
173 /* Print formats for printing stab info. */
174 static char other_format[] = "%02x";
175 static char desc_format[] = "%04x";
177 static char *target = NULL;
178 static char *plugin_target = NULL;
180 /* Used to cache the line numbers for a BFD. */
181 static bfd *lineno_cache_bfd;
182 static bfd *lineno_cache_rel_bfd;
184 #define OPTION_TARGET 200
185 #define OPTION_PLUGIN (OPTION_TARGET + 1)
186 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
188 static struct option long_options[] =
190 {"debug-syms", no_argument, &print_debug_syms, 1},
191 {"demangle", optional_argument, 0, 'C'},
192 {"dynamic", no_argument, &dynamic, 1},
193 {"extern-only", no_argument, &external_only, 1},
194 {"format", required_argument, 0, 'f'},
195 {"help", no_argument, 0, 'h'},
196 {"line-numbers", no_argument, 0, 'l'},
197 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
198 {"no-demangle", no_argument, &do_demangle, 0},
199 {"no-sort", no_argument, 0, 'p'},
200 {"numeric-sort", no_argument, 0, 'n'},
201 {"plugin", required_argument, 0, OPTION_PLUGIN},
202 {"portability", no_argument, 0, 'P'},
203 {"print-armap", no_argument, &print_armap, 1},
204 {"print-file-name", no_argument, 0, 'o'},
205 {"print-size", no_argument, 0, 'S'},
206 {"radix", required_argument, 0, 't'},
207 {"reverse-sort", no_argument, &reverse_sort, 1},
208 {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
209 {"special-syms", no_argument, &allow_special_symbols, 1},
210 {"stats", no_argument, &show_stats, 1},
211 {"synthetic", no_argument, &show_synthetic, 1},
212 {"target", required_argument, 0, OPTION_TARGET},
213 {"defined-only", no_argument, &defined_only, 1},
214 {"undefined-only", no_argument, &undefined_only, 1},
215 {"version", no_argument, &show_version, 1},
216 {0, no_argument, 0, 0}
219 /* Some error-reporting functions. */
222 usage (FILE *stream, int status)
224 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
225 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
226 fprintf (stream, _(" The options are:\n\
227 -a, --debug-syms Display debugger-only symbols\n\
228 -A, --print-file-name Print name of the input file before every symbol\n\
229 -B Same as --format=bsd\n\
230 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
231 The STYLE, if specified, can be `auto' (the default),\n\
232 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
234 --no-demangle Do not demangle low-level symbol names\n\
235 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
236 --defined-only Display only defined symbols\n\
238 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
239 `sysv' or `posix'. The default is `bsd'\n\
240 -g, --extern-only Display only external symbols\n\
241 -l, --line-numbers Use debugging information to find a filename and\n\
242 line number for each symbol\n\
243 -n, --numeric-sort Sort symbols numerically by address\n\
245 -p, --no-sort Do not sort the symbols\n\
246 -P, --portability Same as --format=posix\n\
247 -r, --reverse-sort Reverse the sense of the sort\n"));
248 #if BFD_SUPPORTS_PLUGINS
249 fprintf (stream, _("\
250 --plugin NAME Load the specified plugin\n"));
252 fprintf (stream, _("\
253 -S, --print-size Print size of defined symbols\n\
254 -s, --print-armap Include index for symbols from archive members\n\
255 --size-sort Sort symbols by size\n\
256 --special-syms Include special symbols in the output\n\
257 --synthetic Display synthetic symbols as well\n\
258 -t, --radix=RADIX Use RADIX for printing symbol values\n\
259 --target=BFDNAME Specify the target object format as BFDNAME\n\
260 -u, --undefined-only Display only undefined symbols\n\
261 -X 32_64 (ignored)\n\
262 @FILE Read options from FILE\n\
263 -h, --help Display this information\n\
264 -V, --version Display this program's version number\n\
266 list_supported_targets (program_name, stream);
267 if (REPORT_BUGS_TO[0] && status == 0)
268 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
272 /* Set the radix for the symbol value and size according to RADIX. */
275 set_print_radix (char *radix)
287 value_format_32bit[4] = *radix;
288 #if BFD_HOST_64BIT_LONG
289 value_format_64bit[5] = *radix;
290 #elif BFD_HOST_64BIT_LONG_LONG
292 value_format_64bit[6] = *radix;
294 value_format_64bit[7] = *radix;
297 other_format[3] = desc_format[3] = *radix;
300 fatal (_("%s: invalid radix"), radix);
305 set_output_format (char *f)
324 fatal (_("%s: invalid output format"), f);
326 format = &formats[i];
330 get_symbol_type (unsigned int type)
332 static char buff [32];
336 case STT_NOTYPE: return "NOTYPE";
337 case STT_OBJECT: return "OBJECT";
338 case STT_FUNC: return "FUNC";
339 case STT_SECTION: return "SECTION";
340 case STT_FILE: return "FILE";
341 case STT_COMMON: return "COMMON";
342 case STT_TLS: return "TLS";
344 if (type >= STT_LOPROC && type <= STT_HIPROC)
345 sprintf (buff, _("<processor specific>: %d"), type);
346 else if (type >= STT_LOOS && type <= STT_HIOS)
347 sprintf (buff, _("<OS specific>: %d"), type);
349 sprintf (buff, _("<unknown>: %d"), type);
354 /* Print symbol name NAME, read from ABFD, with printf format FORM,
355 demangling it if requested. */
358 print_symname (const char *form, const char *name, bfd *abfd)
360 if (do_demangle && *name)
362 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
376 print_symdef_entry (bfd *abfd)
378 symindex idx = BFD_NO_MORE_SYMBOLS;
380 bfd_boolean everprinted = FALSE;
382 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
383 idx != BFD_NO_MORE_SYMBOLS;
384 idx = bfd_get_next_mapent (abfd, idx, &thesym))
389 printf (_("\nArchive index:\n"));
392 elt = bfd_get_elt_at_index (abfd, idx);
394 bfd_fatal ("bfd_get_elt_at_index");
395 if (thesym->name != (char *) NULL)
397 print_symname ("%s", thesym->name, abfd);
398 printf (" in %s\n", bfd_get_filename (elt));
403 /* Choose which symbol entries to print;
404 compact them downward to get rid of the rest.
405 Return the number of symbols to be printed. */
408 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
409 long symcount, unsigned int size)
411 bfd_byte *from, *fromend, *to;
414 store = bfd_make_empty_symbol (abfd);
416 bfd_fatal (bfd_get_filename (abfd));
418 from = (bfd_byte *) minisyms;
419 fromend = from + symcount * size;
420 to = (bfd_byte *) minisyms;
422 for (; from < fromend; from += size)
429 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
431 bfd_fatal (bfd_get_filename (abfd));
434 keep = bfd_is_und_section (sym->section);
435 else if (external_only)
436 /* PR binutls/12753: Unique symbols are global too. */
437 keep = ((sym->flags & (BSF_GLOBAL
439 | BSF_GNU_UNIQUE)) != 0
440 || bfd_is_und_section (sym->section)
441 || bfd_is_com_section (sym->section));
446 && ! print_debug_syms
447 && (sym->flags & BSF_DEBUGGING) != 0)
452 && (bfd_is_abs_section (sym->section)
453 || bfd_is_und_section (sym->section)))
459 if (bfd_is_und_section (sym->section))
464 && bfd_is_target_special_symbol (abfd, sym)
465 && ! allow_special_symbols)
471 memcpy (to, from, size);
476 return (to - (bfd_byte *) minisyms) / size;
479 /* These globals are used to pass information into the sorting
481 static bfd *sort_bfd;
482 static bfd_boolean sort_dynamic;
483 static asymbol *sort_x;
484 static asymbol *sort_y;
486 /* Symbol-sorting predicates */
487 #define valueof(x) ((x)->section->vma + (x)->value)
489 /* Numeric sorts. Undefined symbols are always considered "less than"
490 defined symbols with zero values. Common symbols are not treated
491 specially -- i.e., their sizes are used as their "values". */
494 non_numeric_forward (const void *P_x, const void *P_y)
499 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
500 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
501 if (x == NULL || y == NULL)
502 bfd_fatal (bfd_get_filename (sort_bfd));
504 xn = bfd_asymbol_name (x);
505 yn = bfd_asymbol_name (y);
513 /* Solaris 2.5 has a bug in strcoll.
514 strcoll returns invalid values when confronted with empty strings. */
520 return strcoll (xn, yn);
522 return strcmp (xn, yn);
527 non_numeric_reverse (const void *x, const void *y)
529 return - non_numeric_forward (x, y);
533 numeric_forward (const void *P_x, const void *P_y)
538 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
539 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
540 if (x == NULL || y == NULL)
541 bfd_fatal (bfd_get_filename (sort_bfd));
543 xs = bfd_get_section (x);
544 ys = bfd_get_section (y);
546 if (bfd_is_und_section (xs))
548 if (! bfd_is_und_section (ys))
551 else if (bfd_is_und_section (ys))
553 else if (valueof (x) != valueof (y))
554 return valueof (x) < valueof (y) ? -1 : 1;
556 return non_numeric_forward (P_x, P_y);
560 numeric_reverse (const void *x, const void *y)
562 return - numeric_forward (x, y);
565 static int (*(sorters[2][2])) (const void *, const void *) =
567 { non_numeric_forward, non_numeric_reverse },
568 { numeric_forward, numeric_reverse }
571 /* This sort routine is used by sort_symbols_by_size. It is similar
572 to numeric_forward, but when symbols have the same value it sorts
573 by section VMA. This simplifies the sort_symbols_by_size code
574 which handles symbols at the end of sections. Also, this routine
575 tries to sort file names before other symbols with the same value.
576 That will make the file name have a zero size, which will make
577 sort_symbols_by_size choose the non file name symbol, leading to
578 more meaningful output. For similar reasons, this code sorts
579 gnu_compiled_* and gcc2_compiled before other symbols with the same
583 size_forward1 (const void *P_x, const void *P_y)
591 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
592 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
593 if (x == NULL || y == NULL)
594 bfd_fatal (bfd_get_filename (sort_bfd));
596 xs = bfd_get_section (x);
597 ys = bfd_get_section (y);
599 if (bfd_is_und_section (xs))
601 if (bfd_is_und_section (ys))
604 if (valueof (x) != valueof (y))
605 return valueof (x) < valueof (y) ? -1 : 1;
607 if (xs->vma != ys->vma)
608 return xs->vma < ys->vma ? -1 : 1;
610 xn = bfd_asymbol_name (x);
611 yn = bfd_asymbol_name (y);
615 /* The symbols gnu_compiled and gcc2_compiled convey even less
616 information than the file name, so sort them out first. */
618 xf = (strstr (xn, "gnu_compiled") != NULL
619 || strstr (xn, "gcc2_compiled") != NULL);
620 yf = (strstr (yn, "gnu_compiled") != NULL
621 || strstr (yn, "gcc2_compiled") != NULL);
628 /* We use a heuristic for the file name. It may not work on non
629 Unix systems, but it doesn't really matter; the only difference
630 is precisely which symbol names get printed. */
632 #define file_symbol(s, sn, snl) \
633 (((s)->flags & BSF_FILE) != 0 \
634 || ((sn)[(snl) - 2] == '.' \
635 && ((sn)[(snl) - 1] == 'o' \
636 || (sn)[(snl) - 1] == 'a')))
638 xf = file_symbol (x, xn, xnl);
639 yf = file_symbol (y, yn, ynl);
646 return non_numeric_forward (P_x, P_y);
649 /* This sort routine is used by sort_symbols_by_size. It is sorting
650 an array of size_sym structures into size order. */
653 size_forward2 (const void *P_x, const void *P_y)
655 const struct size_sym *x = (const struct size_sym *) P_x;
656 const struct size_sym *y = (const struct size_sym *) P_y;
658 if (x->size < y->size)
659 return reverse_sort ? 1 : -1;
660 else if (x->size > y->size)
661 return reverse_sort ? -1 : 1;
663 return sorters[0][reverse_sort] (x->minisym, y->minisym);
666 /* Sort the symbols by size. ELF provides a size but for other formats
667 we have to make a guess by assuming that the difference between the
668 address of a symbol and the address of the next higher symbol is the
672 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
673 long symcount, unsigned int size,
674 struct size_sym **symsizesp)
676 struct size_sym *symsizes;
677 bfd_byte *from, *fromend;
679 asymbol *store_sym, *store_next;
681 qsort (minisyms, symcount, size, size_forward1);
683 /* We are going to return a special set of symbols and sizes to
685 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
686 *symsizesp = symsizes;
688 /* Note that filter_symbols has already removed all absolute and
689 undefined symbols. Here we remove all symbols whose size winds
691 from = (bfd_byte *) minisyms;
692 fromend = from + symcount * size;
699 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
702 bfd_fatal (bfd_get_filename (abfd));
705 for (; from < fromend; from += size)
712 if (from + size < fromend)
714 next = bfd_minisymbol_to_symbol (abfd,
716 (const void *) (from + size),
719 bfd_fatal (bfd_get_filename (abfd));
724 sec = bfd_get_section (sym);
726 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
727 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
728 else if (bfd_is_com_section (sec))
732 if (from + size < fromend
733 && sec == bfd_get_section (next))
734 sz = valueof (next) - valueof (sym);
736 sz = (bfd_get_section_vma (abfd, sec)
737 + bfd_section_size (abfd, sec)
743 symsizes->minisym = (const void *) from;
751 store_sym = store_next;
755 symcount = symsizes - *symsizesp;
757 /* We must now sort again by size. */
758 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
763 /* This function is used to get the relocs for a particular section.
764 It is called via bfd_map_over_sections. */
767 get_relocs (bfd *abfd, asection *sec, void *dataarg)
769 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
773 if ((sec->flags & SEC_RELOC) == 0)
775 *data->relocs = NULL;
782 relsize = bfd_get_reloc_upper_bound (abfd, sec);
784 bfd_fatal (bfd_get_filename (abfd));
786 *data->relocs = (arelent **) xmalloc (relsize);
787 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
789 if (*data->relcount < 0)
790 bfd_fatal (bfd_get_filename (abfd));
798 /* Print a single symbol. */
801 print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
804 struct extended_symbol_info info;
808 format->print_symbol_filename (archive_bfd, abfd);
810 bfd_get_symbol_info (abfd, sym, &syminfo);
811 info.sinfo = &syminfo;
813 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
814 info.elfinfo = (elf_symbol_type *) sym;
817 format->print_symbol_info (&info, abfd);
821 static asymbol **syms;
822 static long symcount;
823 const char *filename, *functionname;
826 /* We need to get the canonical symbols in order to call
827 bfd_find_nearest_line. This is inefficient, but, then, you
828 don't have to use --line-numbers. */
829 if (abfd != lineno_cache_bfd && syms != NULL)
838 symsize = bfd_get_symtab_upper_bound (abfd);
840 bfd_fatal (bfd_get_filename (abfd));
841 syms = (asymbol **) xmalloc (symsize);
842 symcount = bfd_canonicalize_symtab (abfd, syms);
844 bfd_fatal (bfd_get_filename (abfd));
845 lineno_cache_bfd = abfd;
848 if (bfd_is_und_section (bfd_get_section (sym)))
850 static asection **secs;
851 static arelent ***relocs;
852 static long *relcount;
853 static unsigned int seccount;
857 /* For an undefined symbol, we try to find a reloc for the
858 symbol, and print the line number of the reloc. */
859 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
861 for (i = 0; i < seccount; i++)
862 if (relocs[i] != NULL)
874 struct get_relocs_info rinfo;
876 seccount = bfd_count_sections (abfd);
878 secs = (asection **) xmalloc (seccount * sizeof *secs);
879 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
880 relcount = (long *) xmalloc (seccount * sizeof *relcount);
883 rinfo.relocs = relocs;
884 rinfo.relcount = relcount;
886 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
887 lineno_cache_rel_bfd = abfd;
890 symname = bfd_asymbol_name (sym);
891 for (i = 0; i < seccount; i++)
895 for (j = 0; j < relcount[i]; j++)
900 if (r->sym_ptr_ptr != NULL
901 && (*r->sym_ptr_ptr)->section == sym->section
902 && (*r->sym_ptr_ptr)->value == sym->value
904 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
905 && bfd_find_nearest_line (abfd, secs[i], syms,
906 r->address, &filename,
907 &functionname, &lineno)
910 /* We only print the first one we find. */
911 printf ("\t%s:%u", filename, lineno);
918 else if (bfd_get_section (sym)->owner == abfd)
920 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
921 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
922 syms, sym->value, &filename,
923 &functionname, &lineno))
926 printf ("\t%s:%u", filename, lineno);
933 /* Print the symbols when sorting by size. */
936 print_size_symbols (bfd *abfd, bfd_boolean is_dynamic,
937 struct size_sym *symsizes, long symcount,
941 struct size_sym *from, *fromend;
943 store = bfd_make_empty_symbol (abfd);
945 bfd_fatal (bfd_get_filename (abfd));
948 fromend = from + symcount;
949 for (; from < fromend; from++)
953 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
955 bfd_fatal (bfd_get_filename (abfd));
957 print_symbol (abfd, sym, from->size, archive_bfd);
962 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
966 print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
967 unsigned int size, bfd *archive_bfd)
970 bfd_byte *from, *fromend;
972 store = bfd_make_empty_symbol (abfd);
974 bfd_fatal (bfd_get_filename (abfd));
976 from = (bfd_byte *) minisyms;
977 fromend = from + symcount * size;
978 for (; from < fromend; from += size)
982 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
984 bfd_fatal (bfd_get_filename (abfd));
986 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
990 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
993 display_rel_file (bfd *abfd, bfd *archive_bfd)
998 struct size_sym *symsizes;
1002 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1004 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1009 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1012 if (dynamic && bfd_get_error () == bfd_error_no_symbols)
1014 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1018 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);
1110 set_print_width (bfd *file)
1112 print_width = bfd_get_arch_size (file);
1114 if (print_width == -1)
1117 Guess the target's bitsize based on its name.
1118 We assume here than any 64-bit format will include
1119 "64" somewhere in its name. The only known exception
1120 is the MMO object file format. */
1121 if (strstr (bfd_get_target (file), "64") != NULL
1122 || strcmp (bfd_get_target (file), "mmo") == 0)
1130 display_archive (bfd *file)
1133 bfd *last_arfile = NULL;
1136 format->print_archive_filename (bfd_get_filename (file));
1139 print_symdef_entry (file);
1145 arfile = bfd_openr_next_archived_file (file, arfile);
1149 if (bfd_get_error () != bfd_error_no_more_archived_files)
1150 bfd_fatal (bfd_get_filename (file));
1154 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1156 set_print_width (arfile);
1157 format->print_archive_member (bfd_get_filename (file),
1158 bfd_get_filename (arfile));
1159 display_rel_file (arfile, file);
1163 bfd_nonfatal (bfd_get_filename (arfile));
1164 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1166 list_matching_formats (matching);
1171 if (last_arfile != NULL)
1173 bfd_close (last_arfile);
1174 lineno_cache_bfd = NULL;
1175 lineno_cache_rel_bfd = NULL;
1177 last_arfile = arfile;
1180 if (last_arfile != NULL)
1182 bfd_close (last_arfile);
1183 lineno_cache_bfd = NULL;
1184 lineno_cache_rel_bfd = NULL;
1189 display_file (char *filename)
1191 bfd_boolean retval = TRUE;
1195 if (get_file_size (filename) < 1)
1198 file = bfd_openr (filename, target ? target : plugin_target);
1201 bfd_nonfatal (filename);
1205 /* If printing line numbers, decompress the debug sections. */
1207 file->flags |= BFD_DECOMPRESS;
1209 if (bfd_check_format (file, bfd_archive))
1211 display_archive (file);
1213 else if (bfd_check_format_matches (file, bfd_object, &matching))
1215 set_print_width (file);
1216 format->print_object_filename (filename);
1217 display_rel_file (file, NULL);
1221 bfd_nonfatal (filename);
1222 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1224 list_matching_formats (matching);
1230 if (!bfd_close (file))
1231 bfd_fatal (filename);
1233 lineno_cache_bfd = NULL;
1234 lineno_cache_rel_bfd = NULL;
1239 /* The following 3 groups of functions are called unconditionally,
1240 once at the start of processing each file of the appropriate type.
1241 They should check `filename_per_file' and `filename_per_symbol',
1242 as appropriate for their output format, to determine whether to
1245 /* Print the name of an object file given on the command line. */
1248 print_object_filename_bsd (char *filename)
1250 if (filename_per_file && !filename_per_symbol)
1251 printf ("\n%s:\n", filename);
1255 print_object_filename_sysv (char *filename)
1258 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1260 printf (_("\n\nSymbols from %s:\n\n"), filename);
1261 if (print_width == 32)
1263 Name Value Class Type Size Line Section\n\n"));
1266 Name Value Class Type Size Line Section\n\n"));
1270 print_object_filename_posix (char *filename)
1272 if (filename_per_file && !filename_per_symbol)
1273 printf ("%s:\n", filename);
1276 /* Print the name of an archive file given on the command line. */
1279 print_archive_filename_bsd (char *filename)
1281 if (filename_per_file)
1282 printf ("\n%s:\n", filename);
1286 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1291 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1295 /* Print the name of an archive member file. */
1298 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1299 const char *filename)
1301 if (!filename_per_symbol)
1302 printf ("\n%s:\n", filename);
1306 print_archive_member_sysv (char *archive, const char *filename)
1309 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1311 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1312 if (print_width == 32)
1314 Name Value Class Type Size Line Section\n\n"));
1317 Name Value Class Type Size Line Section\n\n"));
1321 print_archive_member_posix (char *archive, const char *filename)
1323 if (!filename_per_symbol)
1324 printf ("%s[%s]:\n", archive, filename);
1327 /* Print the name of the file (and archive, if there is one)
1328 containing a symbol. */
1331 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1333 if (filename_per_symbol)
1336 printf ("%s:", bfd_get_filename (archive_bfd));
1337 printf ("%s:", bfd_get_filename (abfd));
1342 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1344 if (filename_per_symbol)
1347 printf ("%s:", bfd_get_filename (archive_bfd));
1348 printf ("%s:", bfd_get_filename (abfd));
1353 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1355 if (filename_per_symbol)
1358 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1359 bfd_get_filename (abfd));
1361 printf ("%s: ", bfd_get_filename (abfd));
1365 /* Print a symbol value. */
1368 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1370 switch (print_width)
1373 printf (value_format_32bit, (unsigned long) val);
1377 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1378 printf (value_format_64bit, val);
1380 /* We have a 64 bit value to print, but the host is only 32 bit. */
1381 if (print_radix == 16)
1382 bfd_fprintf_vma (abfd, stdout, val);
1388 s = buf + sizeof buf;
1392 *--s = (val % print_radix) + '0';
1395 while ((buf + sizeof buf - 1) - s < 16)
1403 fatal (_("Print width has not been initialized (%d)"), print_width);
1408 /* Print a line of information about a symbol. */
1411 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1413 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1415 if (print_width == 64)
1421 /* Normally we print the value of the symbol. If we are printing the
1422 size or sorting by size then we print its size, except for the
1423 (weird) special case where both flags are defined, in which case we
1424 print both values. This conforms to documented behaviour. */
1425 if (sort_by_size && !print_size)
1426 print_value (abfd, SYM_SIZE (info));
1428 print_value (abfd, SYM_VALUE (info));
1430 if (print_size && SYM_SIZE (info))
1433 print_value (abfd, SYM_SIZE (info));
1437 printf (" %c", SYM_TYPE (info));
1439 if (SYM_TYPE (info) == '-')
1443 printf (other_format, SYM_STAB_OTHER (info));
1445 printf (desc_format, SYM_STAB_DESC (info));
1446 printf (" %5s", SYM_STAB_NAME (info));
1448 print_symname (" %s", SYM_NAME (info), abfd);
1452 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1454 print_symname ("%-20s|", SYM_NAME (info), abfd);
1456 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1458 if (print_width == 32)
1464 print_value (abfd, SYM_VALUE (info));
1466 printf ("| %c |", SYM_TYPE (info));
1468 if (SYM_TYPE (info) == '-')
1471 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1472 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1473 printf ("| |"); /* Line, Section. */
1477 /* Type, Size, Line, Section */
1480 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1484 if (SYM_SIZE (info))
1485 print_value (abfd, SYM_SIZE (info));
1488 if (print_width == 32)
1495 printf("| |%s", info->elfinfo->symbol.section->name);
1502 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1504 print_symname ("%s ", SYM_NAME (info), abfd);
1505 printf ("%c ", SYM_TYPE (info));
1507 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1511 print_value (abfd, SYM_VALUE (info));
1513 if (SYM_SIZE (info))
1514 print_value (abfd, SYM_SIZE (info));
1519 main (int argc, char **argv)
1524 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1525 setlocale (LC_MESSAGES, "");
1527 #if defined (HAVE_SETLOCALE)
1528 setlocale (LC_CTYPE, "");
1529 setlocale (LC_COLLATE, "");
1531 bindtextdomain (PACKAGE, LOCALEDIR);
1532 textdomain (PACKAGE);
1534 program_name = *argv;
1535 xmalloc_set_program_name (program_name);
1536 #if BFD_SUPPORTS_PLUGINS
1537 bfd_plugin_set_program_name (program_name);
1540 START_PROGRESS (program_name, 0);
1542 expandargv (&argc, &argv);
1545 set_default_bfd_target ();
1547 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1548 long_options, (int *) 0)) != EOF)
1553 print_debug_syms = 1;
1557 filename_per_symbol = 1;
1559 case 'B': /* For MIPS compatibility. */
1560 set_output_format ("bsd");
1566 enum demangling_styles style;
1568 style = cplus_demangle_name_to_style (optarg);
1569 if (style == unknown_demangling)
1570 fatal (_("unknown demangling style `%s'"),
1573 cplus_demangle_set_style (style);
1580 /* Ignored for HP/UX compatibility. */
1583 set_output_format (optarg);
1597 sort_numerically = 1;
1602 sort_numerically = 0;
1605 case OPTION_SIZE_SORT:
1607 sort_numerically = 0;
1611 set_output_format ("posix");
1623 set_print_radix (optarg);
1632 /* Ignored for (partial) AIX compatibility. On AIX, the
1633 argument has values 32, 64, or 32_64, and specifies that
1634 only 32-bit, only 64-bit, or both kinds of objects should
1635 be examined. The default is 32. So plain AIX nm on a
1636 library archive with both kinds of objects will ignore
1637 the 64-bit ones. For GNU nm, the default is and always
1638 has been -X 32_64, and other options are not supported. */
1639 if (strcmp (optarg, "32_64") != 0)
1640 fatal (_("Only -X 32_64 is supported"));
1643 case OPTION_TARGET: /* --target */
1647 case OPTION_PLUGIN: /* --plugin */
1648 #if BFD_SUPPORTS_PLUGINS
1649 plugin_target = "plugin";
1650 bfd_plugin_set_plugin (optarg);
1652 fatal (_("sorry - this program has been built without plugin support\n"));
1656 case 0: /* A long option that just sets a flag. */
1665 print_version ("nm");
1667 if (sort_by_size && undefined_only)
1669 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1670 non_fatal (_("will produce no output, since undefined symbols have no size."));
1674 /* OK, all options now parsed. If no filename specified, do a.out. */
1676 return !display_file ("a.out");
1680 if (argc - optind > 1)
1681 filename_per_file = 1;
1683 /* We were given several filenames to do. */
1684 while (optind < argc)
1687 if (!display_file (argv[optind++]))
1691 END_PROGRESS (program_name);
1696 char *lim = (char *) sbrk (0);
1698 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));