1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
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 2 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., 59 Temple Place - Suite 330, Boston, MA
28 #include "aout/stab_gnu.h"
29 #include "aout/ranlib.h"
31 #include "libiberty.h"
33 #include "elf/common.h"
35 /* When sorting by size, we use this structure to hold the size and a
36 pointer to the minisymbol. */
44 /* When fetching relocs, we use this structure to pass information to
47 struct get_relocs_info
55 struct extended_symbol_info
59 elf_symbol_type *elfinfo;
60 /* FIXME: We should add more fields for Type, Line, Section. */
62 #define SYM_NAME(sym) (sym->sinfo->name)
63 #define SYM_VALUE(sym) (sym->sinfo->value)
64 #define SYM_TYPE(sym) (sym->sinfo->type)
65 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
66 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
67 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
68 #define SYM_SIZE(sym) \
69 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
72 PARAMS ((FILE *, int));
73 static void set_print_radix
75 static void set_output_format
77 static void display_archive
79 static bfd_boolean display_file
81 static void display_rel_file
82 PARAMS ((bfd *, bfd *));
83 static long filter_symbols
84 PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int));
85 static long sort_symbols_by_size
86 PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int, struct size_sym **));
87 static void print_symbols
88 PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int, bfd *));
89 static void print_size_symbols
90 PARAMS ((bfd *, bfd_boolean, struct size_sym *, long, bfd *));
91 static void print_symname
92 PARAMS ((const char *, const char *, bfd *));
93 static void print_symbol
94 PARAMS ((bfd *, asymbol *, bfd_vma ssize, bfd *));
95 static void print_symdef_entry
98 /* The sorting functions. */
99 static int numeric_forward
100 PARAMS ((const PTR, const PTR));
101 static int numeric_reverse
102 PARAMS ((const PTR, const PTR));
103 static int non_numeric_forward
104 PARAMS ((const PTR, const PTR));
105 static int non_numeric_reverse
106 PARAMS ((const PTR, const PTR));
107 static int size_forward1
108 PARAMS ((const PTR, const PTR));
109 static int size_forward2
110 PARAMS ((const PTR, const PTR));
112 /* The output formatting functions. */
113 static void print_object_filename_bsd
115 static void print_object_filename_sysv
117 static void print_object_filename_posix
119 static void print_archive_filename_bsd
121 static void print_archive_filename_sysv
123 static void print_archive_filename_posix
125 static void print_archive_member_bsd
126 PARAMS ((char *, const char *));
127 static void print_archive_member_sysv
128 PARAMS ((char *, const char *));
129 static void print_archive_member_posix
130 PARAMS ((char *, const char *));
131 static void print_symbol_filename_bsd
132 PARAMS ((bfd *, bfd *));
133 static void print_symbol_filename_sysv
134 PARAMS ((bfd *, bfd *));
135 static void print_symbol_filename_posix
136 PARAMS ((bfd *, bfd *));
137 static void print_value
138 PARAMS ((bfd *, bfd_vma));
139 static void print_symbol_info_bsd
140 PARAMS ((struct extended_symbol_info *, bfd *));
141 static void print_symbol_info_sysv
142 PARAMS ((struct extended_symbol_info *, bfd *));
143 static void print_symbol_info_posix
144 PARAMS ((struct extended_symbol_info *, bfd *));
145 static void get_relocs
146 PARAMS ((bfd *, asection *, PTR));
147 static const char * get_symbol_type
148 PARAMS ((unsigned int));
150 /* Support for different output formats. */
153 /* Print the name of an object file given on the command line. */
154 void (*print_object_filename) PARAMS ((char *));
156 /* Print the name of an archive file given on the command line. */
157 void (*print_archive_filename) PARAMS ((char *));
159 /* Print the name of an archive member file. */
160 void (*print_archive_member) PARAMS ((char *, const char *));
162 /* Print the name of the file (and archive, if there is one)
163 containing a symbol. */
164 void (*print_symbol_filename) PARAMS ((bfd *, bfd *));
166 /* Print a line of information about a symbol. */
167 void (*print_symbol_info) PARAMS ((struct extended_symbol_info *, bfd *));
170 static struct output_fns formats[] =
172 {print_object_filename_bsd,
173 print_archive_filename_bsd,
174 print_archive_member_bsd,
175 print_symbol_filename_bsd,
176 print_symbol_info_bsd},
177 {print_object_filename_sysv,
178 print_archive_filename_sysv,
179 print_archive_member_sysv,
180 print_symbol_filename_sysv,
181 print_symbol_info_sysv},
182 {print_object_filename_posix,
183 print_archive_filename_posix,
184 print_archive_member_posix,
185 print_symbol_filename_posix,
186 print_symbol_info_posix}
189 /* Indices in `formats'. */
191 #define FORMAT_SYSV 1
192 #define FORMAT_POSIX 2
193 #define FORMAT_DEFAULT FORMAT_BSD
195 /* The output format to use. */
196 static struct output_fns *format = &formats[FORMAT_DEFAULT];
198 /* Command options. */
200 static int do_demangle = 0; /* Pretty print C++ symbol names. */
201 static int external_only = 0; /* Print external symbols only. */
202 static int defined_only = 0; /* Print defined symbols only. */
203 static int no_sort = 0; /* Don't sort; print syms in order found. */
204 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
205 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
206 static int print_size = 0; /* Print size of defined symbols. */
207 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
208 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
209 static int sort_by_size = 0; /* Sort by size of symbol. */
210 static int undefined_only = 0; /* Print undefined symbols only. */
211 static int dynamic = 0; /* Print dynamic symbols. */
212 static int show_version = 0; /* Show the version number. */
213 static int show_stats = 0; /* Show statistics. */
214 static int line_numbers = 0; /* Print line numbers for symbols. */
216 /* When to print the names of files. Not mutually exclusive in SYSV format. */
217 static int filename_per_file = 0; /* Once per file, on its own line. */
218 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
220 /* Print formats for printing a symbol value. */
222 static char value_format[] = "%08lx";
224 #if BFD_HOST_64BIT_LONG
225 static char value_format[] = "%016lx";
227 /* We don't use value_format for this case. */
231 static int print_width = 16;
233 static int print_width = 8;
235 static int print_radix = 16;
236 /* Print formats for printing stab info. */
237 static char other_format[] = "%02x";
238 static char desc_format[] = "%04x";
240 static char *target = NULL;
242 /* Used to cache the line numbers for a BFD. */
243 static bfd *lineno_cache_bfd;
244 static bfd *lineno_cache_rel_bfd;
246 #define OPTION_TARGET 200
248 static struct option long_options[] =
250 {"debug-syms", no_argument, &print_debug_syms, 1},
251 {"demangle", optional_argument, 0, 'C'},
252 {"dynamic", no_argument, &dynamic, 1},
253 {"extern-only", no_argument, &external_only, 1},
254 {"format", required_argument, 0, 'f'},
255 {"help", no_argument, 0, 'h'},
256 {"line-numbers", no_argument, 0, 'l'},
257 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
258 {"no-demangle", no_argument, &do_demangle, 0},
259 {"no-sort", no_argument, &no_sort, 1},
260 {"numeric-sort", no_argument, &sort_numerically, 1},
261 {"portability", no_argument, 0, 'P'},
262 {"print-armap", no_argument, &print_armap, 1},
263 {"print-file-name", no_argument, 0, 'o'},
264 {"print-size", no_argument, 0, 'S'},
265 {"radix", required_argument, 0, 't'},
266 {"reverse-sort", no_argument, &reverse_sort, 1},
267 {"size-sort", no_argument, &sort_by_size, 1},
268 {"stats", no_argument, &show_stats, 1},
269 {"target", required_argument, 0, OPTION_TARGET},
270 {"defined-only", no_argument, &defined_only, 1},
271 {"undefined-only", no_argument, &undefined_only, 1},
272 {"version", no_argument, &show_version, 1},
273 {0, no_argument, 0, 0}
276 /* Some error-reporting functions. */
279 usage (stream, status)
283 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
284 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
285 fprintf (stream, _(" The options are:\n\
286 -a, --debug-syms Display debugger-only symbols\n\
287 -A, --print-file-name Print name of the input file before every symbol\n\
288 -B Same as --format=bsd\n\
289 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
290 The STYLE, if specified, can be `auto' (the default),\n\
291 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
293 --no-demangle Do not demangle low-level symbol names\n\
294 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
295 --defined-only Display only defined symbols\n\
297 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
298 `sysv' or `posix'. The default is `bsd'\n\
299 -g, --extern-only Display only external symbols\n\
300 -l, --line-numbers Use debugging information to find a filename and\n\
301 line number for each symbol\n\
302 -n, --numeric-sort Sort symbols numerically by address\n\
304 -p, --no-sort Do not sort the symbols\n\
305 -P, --portability Same as --format=posix\n\
306 -r, --reverse-sort Reverse the sense of the sort\n\
307 -S, --print-size Print size of defined symbols\n\
308 -s, --print-armap Include index for symbols from archive members\n\
309 --size-sort Sort symbols by size\n\
310 -t, --radix=RADIX Use RADIX for printing symbol values\n\
311 --target=BFDNAME Specify the target object format as BFDNAME\n\
312 -u, --undefined-only Display only undefined symbols\n\
313 -X 32_64 (ignored)\n\
314 -h, --help Display this information\n\
315 -V, --version Display this program's version number\n\
317 list_supported_targets (program_name, stream);
319 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
323 /* Set the radix for the symbol value and size according to RADIX. */
326 set_print_radix (radix)
340 value_format[4] = *radix;
342 #if BFD_HOST_64BIT_LONG
343 value_format[5] = *radix;
345 /* This case requires special handling for octal and decimal
349 other_format[3] = desc_format[3] = *radix;
352 fatal (_("%s: invalid radix"), radix);
357 set_output_format (f)
377 fatal (_("%s: invalid output format"), f);
379 format = &formats[i];
382 int main PARAMS ((int, char **));
392 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
393 setlocale (LC_MESSAGES, "");
395 #if defined (HAVE_SETLOCALE)
396 setlocale (LC_CTYPE, "");
397 setlocale (LC_COLLATE, "");
399 bindtextdomain (PACKAGE, LOCALEDIR);
400 textdomain (PACKAGE);
402 program_name = *argv;
403 xmalloc_set_program_name (program_name);
405 START_PROGRESS (program_name, 0);
408 set_default_bfd_target ();
410 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
411 long_options, (int *) 0)) != EOF)
416 print_debug_syms = 1;
420 filename_per_symbol = 1;
422 case 'B': /* For MIPS compatibility. */
423 set_output_format ("bsd");
429 enum demangling_styles style;
431 style = cplus_demangle_name_to_style (optarg);
432 if (style == unknown_demangling)
433 fatal (_("unknown demangling style `%s'"),
436 cplus_demangle_set_style (style);
443 /* Ignored for HP/UX compatibility. */
446 set_output_format (optarg);
459 sort_numerically = 1;
465 set_output_format ("posix");
477 set_print_radix (optarg);
486 /* Ignored for (partial) AIX compatibility. On AIX, the
487 argument has values 32, 64, or 32_64, and specfies that
488 only 32-bit, only 64-bit, or both kinds of objects should
489 be examined. The default is 32. So plain AIX nm on a
490 library archive with both kinds of objects will ignore
491 the 64-bit ones. For GNU nm, the default is and always
492 has been -X 32_64, and other options are not supported. */
493 if (strcmp (optarg, "32_64") != 0)
494 fatal (_("Only -X 32_64 is supported"));
497 case OPTION_TARGET: /* --target */
501 case 0: /* A long option that just sets a flag. */
510 print_version ("nm");
512 /* OK, all options now parsed. If no filename specified, do a.out. */
514 return !display_file ("a.out");
518 if (argc - optind > 1)
519 filename_per_file = 1;
521 /* We were given several filenames to do. */
522 while (optind < argc)
525 if (!display_file (argv[optind++]))
529 END_PROGRESS (program_name);
534 char *lim = (char *) sbrk (0);
536 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
545 get_symbol_type (type)
548 static char buff [32];
552 case STT_NOTYPE: return "NOTYPE";
553 case STT_OBJECT: return "OBJECT";
554 case STT_FUNC: return "FUNC";
555 case STT_SECTION: return "SECTION";
556 case STT_FILE: return "FILE";
557 case STT_COMMON: return "COMMON";
558 case STT_TLS: return "TLS";
560 if (type >= STT_LOPROC && type <= STT_HIPROC)
561 sprintf (buff, _("<processor specific>: %d"), type);
562 else if (type >= STT_LOOS && type <= STT_HIOS)
563 sprintf (buff, _("<OS specific>: %d"), type);
565 sprintf (buff, _("<unknown>: %d"), type);
571 display_archive (file)
575 bfd *last_arfile = NULL;
578 (*format->print_archive_filename) (bfd_get_filename (file));
581 print_symdef_entry (file);
587 arfile = bfd_openr_next_archived_file (file, arfile);
591 if (bfd_get_error () != bfd_error_no_more_archived_files)
592 bfd_fatal (bfd_get_filename (file));
596 if (bfd_check_format_matches (arfile, bfd_object, &matching))
600 bfd_sprintf_vma (arfile, buf, (bfd_vma) -1);
601 print_width = strlen (buf);
602 (*format->print_archive_member) (bfd_get_filename (file),
603 bfd_get_filename (arfile));
604 display_rel_file (arfile, file);
608 bfd_nonfatal (bfd_get_filename (arfile));
609 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
611 list_matching_formats (matching);
616 if (last_arfile != NULL)
618 bfd_close (last_arfile);
619 lineno_cache_bfd = NULL;
620 lineno_cache_rel_bfd = NULL;
622 last_arfile = arfile;
625 if (last_arfile != NULL)
627 bfd_close (last_arfile);
628 lineno_cache_bfd = NULL;
629 lineno_cache_rel_bfd = NULL;
634 display_file (filename)
637 bfd_boolean retval = TRUE;
641 file = bfd_openr (filename, target);
644 bfd_nonfatal (filename);
648 if (bfd_check_format (file, bfd_archive))
650 display_archive (file);
652 else if (bfd_check_format_matches (file, bfd_object, &matching))
656 bfd_sprintf_vma (file, buf, (bfd_vma) -1);
657 print_width = strlen (buf);
658 (*format->print_object_filename) (filename);
659 display_rel_file (file, NULL);
663 bfd_nonfatal (filename);
664 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
666 list_matching_formats (matching);
672 if (!bfd_close (file))
673 bfd_fatal (filename);
675 lineno_cache_bfd = NULL;
676 lineno_cache_rel_bfd = NULL;
681 /* These globals are used to pass information into the sorting
683 static bfd *sort_bfd;
684 static bfd_boolean sort_dynamic;
685 static asymbol *sort_x;
686 static asymbol *sort_y;
688 /* Symbol-sorting predicates */
689 #define valueof(x) ((x)->section->vma + (x)->value)
691 /* Numeric sorts. Undefined symbols are always considered "less than"
692 defined symbols with zero values. Common symbols are not treated
693 specially -- i.e., their sizes are used as their "values". */
696 numeric_forward (P_x, P_y)
703 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
704 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
705 if (x == NULL || y == NULL)
706 bfd_fatal (bfd_get_filename (sort_bfd));
708 xs = bfd_get_section (x);
709 ys = bfd_get_section (y);
711 if (bfd_is_und_section (xs))
713 if (! bfd_is_und_section (ys))
716 else if (bfd_is_und_section (ys))
718 else if (valueof (x) != valueof (y))
719 return valueof (x) < valueof (y) ? -1 : 1;
721 return non_numeric_forward (P_x, P_y);
725 numeric_reverse (x, y)
729 return - numeric_forward (x, y);
733 non_numeric_forward (P_x, P_y)
740 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
741 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
742 if (x == NULL || y == NULL)
743 bfd_fatal (bfd_get_filename (sort_bfd));
745 xn = bfd_asymbol_name (x);
746 yn = bfd_asymbol_name (y);
754 /* Solaris 2.5 has a bug in strcoll.
755 strcoll returns invalid values when confronted with empty strings. */
761 return strcoll (xn, yn);
763 return strcmp (xn, yn);
768 non_numeric_reverse (x, y)
772 return - non_numeric_forward (x, y);
775 static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
777 { non_numeric_forward, non_numeric_reverse },
778 { numeric_forward, numeric_reverse }
781 /* This sort routine is used by sort_symbols_by_size. It is similar
782 to numeric_forward, but when symbols have the same value it sorts
783 by section VMA. This simplifies the sort_symbols_by_size code
784 which handles symbols at the end of sections. Also, this routine
785 tries to sort file names before other symbols with the same value.
786 That will make the file name have a zero size, which will make
787 sort_symbols_by_size choose the non file name symbol, leading to
788 more meaningful output. For similar reasons, this code sorts
789 gnu_compiled_* and gcc2_compiled before other symbols with the same
793 size_forward1 (P_x, P_y)
803 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
804 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
805 if (x == NULL || y == NULL)
806 bfd_fatal (bfd_get_filename (sort_bfd));
808 xs = bfd_get_section (x);
809 ys = bfd_get_section (y);
811 if (bfd_is_und_section (xs))
813 if (bfd_is_und_section (ys))
816 if (valueof (x) != valueof (y))
817 return valueof (x) < valueof (y) ? -1 : 1;
819 if (xs->vma != ys->vma)
820 return xs->vma < ys->vma ? -1 : 1;
822 xn = bfd_asymbol_name (x);
823 yn = bfd_asymbol_name (y);
827 /* The symbols gnu_compiled and gcc2_compiled convey even less
828 information than the file name, so sort them out first. */
830 xf = (strstr (xn, "gnu_compiled") != NULL
831 || strstr (xn, "gcc2_compiled") != NULL);
832 yf = (strstr (yn, "gnu_compiled") != NULL
833 || strstr (yn, "gcc2_compiled") != NULL);
840 /* We use a heuristic for the file name. It may not work on non
841 Unix systems, but it doesn't really matter; the only difference
842 is precisely which symbol names get printed. */
844 #define file_symbol(s, sn, snl) \
845 (((s)->flags & BSF_FILE) != 0 \
846 || ((sn)[(snl) - 2] == '.' \
847 && ((sn)[(snl) - 1] == 'o' \
848 || (sn)[(snl) - 1] == 'a')))
850 xf = file_symbol (x, xn, xnl);
851 yf = file_symbol (y, yn, ynl);
858 return non_numeric_forward (P_x, P_y);
861 /* This sort routine is used by sort_symbols_by_size. It is sorting
862 an array of size_sym structures into size order. */
865 size_forward2 (P_x, P_y)
869 const struct size_sym *x = (const struct size_sym *) P_x;
870 const struct size_sym *y = (const struct size_sym *) P_y;
872 if (x->size < y->size)
873 return reverse_sort ? 1 : -1;
874 else if (x->size > y->size)
875 return reverse_sort ? -1 : 1;
877 return sorters[0][reverse_sort] (x->minisym, y->minisym);
880 /* Sort the symbols by size. ELF provides a size but for other formats
881 we have to make a guess by assuming that the difference between the
882 address of a symbol and the address of the next higher symbol is the
886 sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
892 struct size_sym **symsizesp;
894 struct size_sym *symsizes;
895 bfd_byte *from, *fromend;
897 asymbol *store_sym, *store_next;
899 qsort (minisyms, symcount, size, size_forward1);
901 /* We are going to return a special set of symbols and sizes to
903 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
904 *symsizesp = symsizes;
906 /* Note that filter_symbols has already removed all absolute and
907 undefined symbols. Here we remove all symbols whose size winds
909 from = (bfd_byte *) minisyms;
910 fromend = from + symcount * size;
917 sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from,
920 bfd_fatal (bfd_get_filename (abfd));
923 for (; from < fromend; from += size)
930 if (from + size < fromend)
932 next = bfd_minisymbol_to_symbol (abfd,
934 (const PTR) (from + size),
937 bfd_fatal (bfd_get_filename (abfd));
942 sec = bfd_get_section (sym);
944 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
945 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
946 else if (bfd_is_com_section (sec))
950 if (from + size < fromend
951 && sec == bfd_get_section (next))
952 sz = valueof (next) - valueof (sym);
954 sz = (bfd_get_section_vma (abfd, sec)
955 + bfd_section_size (abfd, sec)
961 symsizes->minisym = (const PTR) from;
969 store_sym = store_next;
973 symcount = symsizes - *symsizesp;
975 /* We must now sort again by size. */
976 qsort ((PTR) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
981 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
984 display_rel_file (abfd, archive_bfd)
991 struct size_sym *symsizes;
995 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
997 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1002 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1004 bfd_fatal (bfd_get_filename (abfd));
1008 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1012 /* Discard the symbols we don't want to print.
1013 It's OK to do this in place; we'll free the storage anyway
1014 (after printing). */
1016 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1022 sort_dynamic = dynamic;
1023 sort_x = bfd_make_empty_symbol (abfd);
1024 sort_y = bfd_make_empty_symbol (abfd);
1025 if (sort_x == NULL || sort_y == NULL)
1026 bfd_fatal (bfd_get_filename (abfd));
1029 qsort (minisyms, symcount, size,
1030 sorters[sort_numerically][reverse_sort]);
1032 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1037 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1039 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1044 /* Choose which symbol entries to print;
1045 compact them downward to get rid of the rest.
1046 Return the number of symbols to be printed. */
1049 filter_symbols (abfd, dynamic, minisyms, symcount, size)
1051 bfd_boolean dynamic;
1056 bfd_byte *from, *fromend, *to;
1059 store = bfd_make_empty_symbol (abfd);
1061 bfd_fatal (bfd_get_filename (abfd));
1063 from = (bfd_byte *) minisyms;
1064 fromend = from + symcount * size;
1065 to = (bfd_byte *) minisyms;
1067 for (; from < fromend; from += size)
1074 sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from, store);
1076 bfd_fatal (bfd_get_filename (abfd));
1079 keep = bfd_is_und_section (sym->section);
1080 else if (external_only)
1081 keep = ((sym->flags & BSF_GLOBAL) != 0
1082 || (sym->flags & BSF_WEAK) != 0
1083 || bfd_is_und_section (sym->section)
1084 || bfd_is_com_section (sym->section));
1089 && ! print_debug_syms
1090 && (sym->flags & BSF_DEBUGGING) != 0)
1095 && (bfd_is_abs_section (sym->section)
1096 || bfd_is_und_section (sym->section)))
1102 if (bfd_is_und_section (sym->section))
1108 memcpy (to, from, size);
1113 return (to - (bfd_byte *) minisyms) / size;
1116 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
1117 demangling it if requested. */
1120 print_symname (format, name, abfd)
1125 if (do_demangle && *name)
1127 char *res = demangle (abfd, name);
1129 printf (format, res);
1134 printf (format, name);
1137 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
1141 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd)
1143 bfd_boolean dynamic;
1150 bfd_byte *from, *fromend;
1152 store = bfd_make_empty_symbol (abfd);
1154 bfd_fatal (bfd_get_filename (abfd));
1156 from = (bfd_byte *) minisyms;
1157 fromend = from + symcount * size;
1158 for (; from < fromend; from += size)
1162 sym = bfd_minisymbol_to_symbol (abfd, dynamic, from, store);
1164 bfd_fatal (bfd_get_filename (abfd));
1166 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
1170 /* Print the symbols when sorting by size. */
1173 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd)
1175 bfd_boolean dynamic;
1176 struct size_sym *symsizes;
1181 struct size_sym *from, *fromend;
1183 store = bfd_make_empty_symbol (abfd);
1185 bfd_fatal (bfd_get_filename (abfd));
1188 fromend = from + symcount;
1189 for (; from < fromend; from++)
1194 sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
1196 bfd_fatal (bfd_get_filename (abfd));
1198 /* For elf we have already computed the correct symbol size. */
1199 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1202 ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
1204 print_symbol (abfd, sym, ssize, archive_bfd);
1208 /* Print a single symbol. */
1211 print_symbol (abfd, sym, ssize, archive_bfd)
1219 (*format->print_symbol_filename) (archive_bfd, abfd);
1223 if (bfd_is_und_section (bfd_get_section (sym)))
1224 print_symname ("%s", bfd_asymbol_name (sym), abfd);
1228 symbol_info syminfo;
1229 struct extended_symbol_info info;
1231 bfd_get_symbol_info (abfd, sym, &syminfo);
1232 info.sinfo = &syminfo;
1234 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1235 info.elfinfo = (elf_symbol_type *) sym;
1237 info.elfinfo = NULL;
1238 (*format->print_symbol_info) (&info, abfd);
1243 static asymbol **syms;
1244 static long symcount;
1245 const char *filename, *functionname;
1246 unsigned int lineno;
1248 /* We need to get the canonical symbols in order to call
1249 bfd_find_nearest_line. This is inefficient, but, then, you
1250 don't have to use --line-numbers. */
1251 if (abfd != lineno_cache_bfd && syms != NULL)
1260 symsize = bfd_get_symtab_upper_bound (abfd);
1262 bfd_fatal (bfd_get_filename (abfd));
1263 syms = (asymbol **) xmalloc (symsize);
1264 symcount = bfd_canonicalize_symtab (abfd, syms);
1266 bfd_fatal (bfd_get_filename (abfd));
1267 lineno_cache_bfd = abfd;
1270 if (bfd_is_und_section (bfd_get_section (sym)))
1272 static asection **secs;
1273 static arelent ***relocs;
1274 static long *relcount;
1275 static unsigned int seccount;
1277 const char *symname;
1279 /* For an undefined symbol, we try to find a reloc for the
1280 symbol, and print the line number of the reloc. */
1281 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
1283 for (i = 0; i < seccount; i++)
1284 if (relocs[i] != NULL)
1296 struct get_relocs_info info;
1298 seccount = bfd_count_sections (abfd);
1300 secs = (asection **) xmalloc (seccount * sizeof *secs);
1301 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
1302 relcount = (long *) xmalloc (seccount * sizeof *relcount);
1305 info.relocs = relocs;
1306 info.relcount = relcount;
1308 bfd_map_over_sections (abfd, get_relocs, (PTR) &info);
1309 lineno_cache_rel_bfd = abfd;
1312 symname = bfd_asymbol_name (sym);
1313 for (i = 0; i < seccount; i++)
1317 for (j = 0; j < relcount[i]; j++)
1322 if (r->sym_ptr_ptr != NULL
1323 && (*r->sym_ptr_ptr)->section == sym->section
1324 && (*r->sym_ptr_ptr)->value == sym->value
1326 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
1327 && bfd_find_nearest_line (abfd, secs[i], syms,
1328 r->address, &filename,
1329 &functionname, &lineno)
1330 && filename != NULL)
1332 /* We only print the first one we find. */
1333 printf ("\t%s:%u", filename, lineno);
1340 else if (bfd_get_section (sym)->owner == abfd)
1342 if (bfd_find_nearest_line (abfd, bfd_get_section (sym), syms,
1343 sym->value, &filename, &functionname,
1348 printf ("\t%s:%u", filename, lineno);
1356 /* The following 3 groups of functions are called unconditionally,
1357 once at the start of processing each file of the appropriate type.
1358 They should check `filename_per_file' and `filename_per_symbol',
1359 as appropriate for their output format, to determine whether to
1362 /* Print the name of an object file given on the command line. */
1365 print_object_filename_bsd (filename)
1368 if (filename_per_file && !filename_per_symbol)
1369 printf ("\n%s:\n", filename);
1373 print_object_filename_sysv (filename)
1377 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1379 printf (_("\n\nSymbols from %s:\n\n"), filename);
1380 if (print_width == 8)
1382 Name Value Class Type Size Line Section\n\n"));
1385 Name Value Class Type Size Line Section\n\n"));
1389 print_object_filename_posix (filename)
1392 if (filename_per_file && !filename_per_symbol)
1393 printf ("%s:\n", filename);
1396 /* Print the name of an archive file given on the command line. */
1399 print_archive_filename_bsd (filename)
1402 if (filename_per_file)
1403 printf ("\n%s:\n", filename);
1407 print_archive_filename_sysv (filename)
1408 char *filename ATTRIBUTE_UNUSED;
1413 print_archive_filename_posix (filename)
1414 char *filename ATTRIBUTE_UNUSED;
1418 /* Print the name of an archive member file. */
1421 print_archive_member_bsd (archive, filename)
1422 char *archive ATTRIBUTE_UNUSED;
1423 const char *filename;
1425 if (!filename_per_symbol)
1426 printf ("\n%s:\n", filename);
1430 print_archive_member_sysv (archive, filename)
1432 const char *filename;
1435 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1437 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1438 if (print_width == 8)
1440 Name Value Class Type Size Line Section\n\n"));
1443 Name Value Class Type Size Line Section\n\n"));
1447 print_archive_member_posix (archive, filename)
1449 const char *filename;
1451 if (!filename_per_symbol)
1452 printf ("%s[%s]:\n", archive, filename);
1455 /* Print the name of the file (and archive, if there is one)
1456 containing a symbol. */
1459 print_symbol_filename_bsd (archive_bfd, abfd)
1460 bfd *archive_bfd, *abfd;
1462 if (filename_per_symbol)
1465 printf ("%s:", bfd_get_filename (archive_bfd));
1466 printf ("%s:", bfd_get_filename (abfd));
1471 print_symbol_filename_sysv (archive_bfd, abfd)
1472 bfd *archive_bfd, *abfd;
1474 if (filename_per_symbol)
1477 printf ("%s:", bfd_get_filename (archive_bfd));
1478 printf ("%s:", bfd_get_filename (abfd));
1483 print_symbol_filename_posix (archive_bfd, abfd)
1484 bfd *archive_bfd, *abfd;
1486 if (filename_per_symbol)
1489 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1490 bfd_get_filename (abfd));
1492 printf ("%s: ", bfd_get_filename (abfd));
1496 /* Print a symbol value. */
1499 print_value (abfd, val)
1500 bfd *abfd ATTRIBUTE_UNUSED;
1503 #if ! defined (BFD64) || BFD_HOST_64BIT_LONG
1504 printf (value_format, val);
1506 /* We have a 64 bit value to print, but the host is only 32 bit. */
1507 if (print_radix == 16)
1508 bfd_fprintf_vma (abfd, stdout, val);
1514 s = buf + sizeof buf;
1518 *--s = (val % print_radix) + '0';
1521 while ((buf + sizeof buf - 1) - s < 16)
1528 /* Print a line of information about a symbol. */
1531 print_symbol_info_bsd (info, abfd)
1532 struct extended_symbol_info *info;
1535 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1537 if (print_width == 16)
1543 print_value (abfd, SYM_VALUE (info));
1545 if (print_size && SYM_SIZE (info))
1548 print_value (abfd, SYM_SIZE (info));
1552 printf (" %c", SYM_TYPE (info));
1554 if (SYM_TYPE (info) == '-')
1558 printf (other_format, SYM_STAB_OTHER (info));
1560 printf (desc_format, SYM_STAB_DESC (info));
1561 printf (" %5s", SYM_STAB_NAME (info));
1563 print_symname (" %s", SYM_NAME (info), abfd);
1567 print_symbol_info_sysv (info, abfd)
1568 struct extended_symbol_info *info;
1571 print_symname ("%-20s|", SYM_NAME (info), abfd);
1573 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1575 if (print_width == 8)
1581 print_value (abfd, SYM_VALUE (info));
1583 printf ("| %c |", SYM_TYPE (info));
1585 if (SYM_TYPE (info) == '-')
1588 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type */
1589 printf (desc_format, SYM_STAB_DESC (info)); /* Size */
1590 printf ("| |"); /* Line, Section */
1594 /* Type, Size, Line, Section */
1597 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1601 if (SYM_SIZE (info))
1602 print_value (abfd, SYM_SIZE (info));
1605 if (print_width == 8)
1612 printf("| |%s", info->elfinfo->symbol.section->name);
1619 print_symbol_info_posix (info, abfd)
1620 struct extended_symbol_info *info;
1623 print_symname ("%s ", SYM_NAME (info), abfd);
1624 printf ("%c ", SYM_TYPE (info));
1626 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1630 print_value (abfd, SYM_VALUE (info));
1632 if (SYM_SIZE (info))
1633 print_value (abfd, SYM_SIZE (info));
1638 print_symdef_entry (abfd)
1641 symindex idx = BFD_NO_MORE_SYMBOLS;
1643 bfd_boolean everprinted = FALSE;
1645 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
1646 idx != BFD_NO_MORE_SYMBOLS;
1647 idx = bfd_get_next_mapent (abfd, idx, &thesym))
1652 printf (_("\nArchive index:\n"));
1655 elt = bfd_get_elt_at_index (abfd, idx);
1657 bfd_fatal ("bfd_get_elt_at_index");
1658 if (thesym->name != (char *) NULL)
1660 print_symname ("%s", thesym->name, abfd);
1661 printf (" in %s\n", bfd_get_filename (elt));
1666 /* This function is used to get the relocs for a particular section.
1667 It is called via bfd_map_over_sections. */
1670 get_relocs (abfd, sec, dataarg)
1675 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
1679 if ((sec->flags & SEC_RELOC) == 0)
1681 *data->relocs = NULL;
1682 *data->relcount = 0;
1688 relsize = bfd_get_reloc_upper_bound (abfd, sec);
1690 bfd_fatal (bfd_get_filename (abfd));
1692 *data->relocs = (arelent **) xmalloc (relsize);
1693 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
1695 if (*data->relcount < 0)
1696 bfd_fatal (bfd_get_filename (abfd));