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 #if BFD_SUPPORTS_PLUGINS
179 static const char *plugin_target
= "plugin";
181 static const char *plugin_target
= NULL
;
184 /* Used to cache the line numbers for a BFD. */
185 static bfd
*lineno_cache_bfd
;
186 static bfd
*lineno_cache_rel_bfd
;
188 #define OPTION_TARGET 200
189 #define OPTION_PLUGIN (OPTION_TARGET + 1)
190 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
192 static struct option long_options
[] =
194 {"debug-syms", no_argument
, &print_debug_syms
, 1},
195 {"demangle", optional_argument
, 0, 'C'},
196 {"dynamic", no_argument
, &dynamic
, 1},
197 {"extern-only", no_argument
, &external_only
, 1},
198 {"format", required_argument
, 0, 'f'},
199 {"help", no_argument
, 0, 'h'},
200 {"line-numbers", no_argument
, 0, 'l'},
201 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
202 {"no-demangle", no_argument
, &do_demangle
, 0},
203 {"no-sort", no_argument
, 0, 'p'},
204 {"numeric-sort", no_argument
, 0, 'n'},
205 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
206 {"portability", no_argument
, 0, 'P'},
207 {"print-armap", no_argument
, &print_armap
, 1},
208 {"print-file-name", no_argument
, 0, 'o'},
209 {"print-size", no_argument
, 0, 'S'},
210 {"radix", required_argument
, 0, 't'},
211 {"reverse-sort", no_argument
, &reverse_sort
, 1},
212 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
213 {"special-syms", no_argument
, &allow_special_symbols
, 1},
214 {"stats", no_argument
, &show_stats
, 1},
215 {"synthetic", no_argument
, &show_synthetic
, 1},
216 {"target", required_argument
, 0, OPTION_TARGET
},
217 {"defined-only", no_argument
, &defined_only
, 1},
218 {"undefined-only", no_argument
, &undefined_only
, 1},
219 {"version", no_argument
, &show_version
, 1},
220 {0, no_argument
, 0, 0}
223 /* Some error-reporting functions. */
226 usage (FILE *stream
, int status
)
228 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
229 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
230 fprintf (stream
, _(" The options are:\n\
231 -a, --debug-syms Display debugger-only symbols\n\
232 -A, --print-file-name Print name of the input file before every symbol\n\
233 -B Same as --format=bsd\n\
234 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
235 The STYLE, if specified, can be `auto' (the default),\n\
236 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
238 --no-demangle Do not demangle low-level symbol names\n\
239 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
240 --defined-only Display only defined symbols\n\
242 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
243 `sysv' or `posix'. The default is `bsd'\n\
244 -g, --extern-only Display only external symbols\n\
245 -l, --line-numbers Use debugging information to find a filename and\n\
246 line number for each symbol\n\
247 -n, --numeric-sort Sort symbols numerically by address\n\
249 -p, --no-sort Do not sort the symbols\n\
250 -P, --portability Same as --format=posix\n\
251 -r, --reverse-sort Reverse the sense of the sort\n"));
252 #if BFD_SUPPORTS_PLUGINS
253 fprintf (stream
, _("\
254 --plugin NAME Load the specified plugin\n"));
256 fprintf (stream
, _("\
257 -S, --print-size Print size of defined symbols\n\
258 -s, --print-armap Include index for symbols from archive members\n\
259 --size-sort Sort symbols by size\n\
260 --special-syms Include special symbols in the output\n\
261 --synthetic Display synthetic symbols as well\n\
262 -t, --radix=RADIX Use RADIX for printing symbol values\n\
263 --target=BFDNAME Specify the target object format as BFDNAME\n\
264 -u, --undefined-only Display only undefined symbols\n\
265 -X 32_64 (ignored)\n\
266 @FILE Read options from FILE\n\
267 -h, --help Display this information\n\
268 -V, --version Display this program's version number\n\
270 list_supported_targets (program_name
, stream
);
271 if (REPORT_BUGS_TO
[0] && status
== 0)
272 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
276 /* Set the radix for the symbol value and size according to RADIX. */
279 set_print_radix (char *radix
)
291 value_format_32bit
[4] = *radix
;
292 #if BFD_HOST_64BIT_LONG
293 value_format_64bit
[5] = *radix
;
294 #elif BFD_HOST_64BIT_LONG_LONG
296 value_format_64bit
[6] = *radix
;
298 value_format_64bit
[7] = *radix
;
301 other_format
[3] = desc_format
[3] = *radix
;
304 fatal (_("%s: invalid radix"), radix
);
309 set_output_format (char *f
)
328 fatal (_("%s: invalid output format"), f
);
330 format
= &formats
[i
];
334 get_symbol_type (unsigned int type
)
336 static char buff
[32];
340 case STT_NOTYPE
: return "NOTYPE";
341 case STT_OBJECT
: return "OBJECT";
342 case STT_FUNC
: return "FUNC";
343 case STT_SECTION
: return "SECTION";
344 case STT_FILE
: return "FILE";
345 case STT_COMMON
: return "COMMON";
346 case STT_TLS
: return "TLS";
348 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
349 sprintf (buff
, _("<processor specific>: %d"), type
);
350 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
351 sprintf (buff
, _("<OS specific>: %d"), type
);
353 sprintf (buff
, _("<unknown>: %d"), type
);
358 /* Print symbol name NAME, read from ABFD, with printf format FORM,
359 demangling it if requested. */
362 print_symname (const char *form
, const char *name
, bfd
*abfd
)
364 if (do_demangle
&& *name
)
366 char *res
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
380 print_symdef_entry (bfd
*abfd
)
382 symindex idx
= BFD_NO_MORE_SYMBOLS
;
384 bfd_boolean everprinted
= FALSE
;
386 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
387 idx
!= BFD_NO_MORE_SYMBOLS
;
388 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
393 printf (_("\nArchive index:\n"));
396 elt
= bfd_get_elt_at_index (abfd
, idx
);
398 bfd_fatal ("bfd_get_elt_at_index");
399 if (thesym
->name
!= (char *) NULL
)
401 print_symname ("%s", thesym
->name
, abfd
);
402 printf (" in %s\n", bfd_get_filename (elt
));
407 /* Choose which symbol entries to print;
408 compact them downward to get rid of the rest.
409 Return the number of symbols to be printed. */
412 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
413 long symcount
, unsigned int size
)
415 bfd_byte
*from
, *fromend
, *to
;
418 store
= bfd_make_empty_symbol (abfd
);
420 bfd_fatal (bfd_get_filename (abfd
));
422 from
= (bfd_byte
*) minisyms
;
423 fromend
= from
+ symcount
* size
;
424 to
= (bfd_byte
*) minisyms
;
426 for (; from
< fromend
; from
+= size
)
433 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
435 bfd_fatal (bfd_get_filename (abfd
));
438 keep
= bfd_is_und_section (sym
->section
);
439 else if (external_only
)
440 /* PR binutls/12753: Unique symbols are global too. */
441 keep
= ((sym
->flags
& (BSF_GLOBAL
443 | BSF_GNU_UNIQUE
)) != 0
444 || bfd_is_und_section (sym
->section
)
445 || bfd_is_com_section (sym
->section
));
450 && ! print_debug_syms
451 && (sym
->flags
& BSF_DEBUGGING
) != 0)
456 && (bfd_is_abs_section (sym
->section
)
457 || bfd_is_und_section (sym
->section
)))
463 if (bfd_is_und_section (sym
->section
))
468 && bfd_is_target_special_symbol (abfd
, sym
)
469 && ! allow_special_symbols
)
475 memcpy (to
, from
, size
);
480 return (to
- (bfd_byte
*) minisyms
) / size
;
483 /* These globals are used to pass information into the sorting
485 static bfd
*sort_bfd
;
486 static bfd_boolean sort_dynamic
;
487 static asymbol
*sort_x
;
488 static asymbol
*sort_y
;
490 /* Symbol-sorting predicates */
491 #define valueof(x) ((x)->section->vma + (x)->value)
493 /* Numeric sorts. Undefined symbols are always considered "less than"
494 defined symbols with zero values. Common symbols are not treated
495 specially -- i.e., their sizes are used as their "values". */
498 non_numeric_forward (const void *P_x
, const void *P_y
)
503 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
504 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
505 if (x
== NULL
|| y
== NULL
)
506 bfd_fatal (bfd_get_filename (sort_bfd
));
508 xn
= bfd_asymbol_name (x
);
509 yn
= bfd_asymbol_name (y
);
517 /* Solaris 2.5 has a bug in strcoll.
518 strcoll returns invalid values when confronted with empty strings. */
524 return strcoll (xn
, yn
);
526 return strcmp (xn
, yn
);
531 non_numeric_reverse (const void *x
, const void *y
)
533 return - non_numeric_forward (x
, y
);
537 numeric_forward (const void *P_x
, const void *P_y
)
542 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
543 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
544 if (x
== NULL
|| y
== NULL
)
545 bfd_fatal (bfd_get_filename (sort_bfd
));
547 xs
= bfd_get_section (x
);
548 ys
= bfd_get_section (y
);
550 if (bfd_is_und_section (xs
))
552 if (! bfd_is_und_section (ys
))
555 else if (bfd_is_und_section (ys
))
557 else if (valueof (x
) != valueof (y
))
558 return valueof (x
) < valueof (y
) ? -1 : 1;
560 return non_numeric_forward (P_x
, P_y
);
564 numeric_reverse (const void *x
, const void *y
)
566 return - numeric_forward (x
, y
);
569 static int (*(sorters
[2][2])) (const void *, const void *) =
571 { non_numeric_forward
, non_numeric_reverse
},
572 { numeric_forward
, numeric_reverse
}
575 /* This sort routine is used by sort_symbols_by_size. It is similar
576 to numeric_forward, but when symbols have the same value it sorts
577 by section VMA. This simplifies the sort_symbols_by_size code
578 which handles symbols at the end of sections. Also, this routine
579 tries to sort file names before other symbols with the same value.
580 That will make the file name have a zero size, which will make
581 sort_symbols_by_size choose the non file name symbol, leading to
582 more meaningful output. For similar reasons, this code sorts
583 gnu_compiled_* and gcc2_compiled before other symbols with the same
587 size_forward1 (const void *P_x
, const void *P_y
)
595 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
596 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
597 if (x
== NULL
|| y
== NULL
)
598 bfd_fatal (bfd_get_filename (sort_bfd
));
600 xs
= bfd_get_section (x
);
601 ys
= bfd_get_section (y
);
603 if (bfd_is_und_section (xs
))
605 if (bfd_is_und_section (ys
))
608 if (valueof (x
) != valueof (y
))
609 return valueof (x
) < valueof (y
) ? -1 : 1;
611 if (xs
->vma
!= ys
->vma
)
612 return xs
->vma
< ys
->vma
? -1 : 1;
614 xn
= bfd_asymbol_name (x
);
615 yn
= bfd_asymbol_name (y
);
619 /* The symbols gnu_compiled and gcc2_compiled convey even less
620 information than the file name, so sort them out first. */
622 xf
= (strstr (xn
, "gnu_compiled") != NULL
623 || strstr (xn
, "gcc2_compiled") != NULL
);
624 yf
= (strstr (yn
, "gnu_compiled") != NULL
625 || strstr (yn
, "gcc2_compiled") != NULL
);
632 /* We use a heuristic for the file name. It may not work on non
633 Unix systems, but it doesn't really matter; the only difference
634 is precisely which symbol names get printed. */
636 #define file_symbol(s, sn, snl) \
637 (((s)->flags & BSF_FILE) != 0 \
638 || ((sn)[(snl) - 2] == '.' \
639 && ((sn)[(snl) - 1] == 'o' \
640 || (sn)[(snl) - 1] == 'a')))
642 xf
= file_symbol (x
, xn
, xnl
);
643 yf
= file_symbol (y
, yn
, ynl
);
650 return non_numeric_forward (P_x
, P_y
);
653 /* This sort routine is used by sort_symbols_by_size. It is sorting
654 an array of size_sym structures into size order. */
657 size_forward2 (const void *P_x
, const void *P_y
)
659 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
660 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
662 if (x
->size
< y
->size
)
663 return reverse_sort
? 1 : -1;
664 else if (x
->size
> y
->size
)
665 return reverse_sort
? -1 : 1;
667 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
670 /* Sort the symbols by size. ELF provides a size but for other formats
671 we have to make a guess by assuming that the difference between the
672 address of a symbol and the address of the next higher symbol is the
676 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
677 long symcount
, unsigned int size
,
678 struct size_sym
**symsizesp
)
680 struct size_sym
*symsizes
;
681 bfd_byte
*from
, *fromend
;
683 asymbol
*store_sym
, *store_next
;
685 qsort (minisyms
, symcount
, size
, size_forward1
);
687 /* We are going to return a special set of symbols and sizes to
689 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
690 *symsizesp
= symsizes
;
692 /* Note that filter_symbols has already removed all absolute and
693 undefined symbols. Here we remove all symbols whose size winds
695 from
= (bfd_byte
*) minisyms
;
696 fromend
= from
+ symcount
* size
;
703 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
706 bfd_fatal (bfd_get_filename (abfd
));
709 for (; from
< fromend
; from
+= size
)
716 if (from
+ size
< fromend
)
718 next
= bfd_minisymbol_to_symbol (abfd
,
720 (const void *) (from
+ size
),
723 bfd_fatal (bfd_get_filename (abfd
));
728 sec
= bfd_get_section (sym
);
730 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
731 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
732 else if (bfd_is_com_section (sec
))
736 if (from
+ size
< fromend
737 && sec
== bfd_get_section (next
))
738 sz
= valueof (next
) - valueof (sym
);
740 sz
= (bfd_get_section_vma (abfd
, sec
)
741 + bfd_section_size (abfd
, sec
)
747 symsizes
->minisym
= (const void *) from
;
755 store_sym
= store_next
;
759 symcount
= symsizes
- *symsizesp
;
761 /* We must now sort again by size. */
762 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
767 /* This function is used to get the relocs for a particular section.
768 It is called via bfd_map_over_sections. */
771 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
773 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
777 if ((sec
->flags
& SEC_RELOC
) == 0)
779 *data
->relocs
= NULL
;
786 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
788 bfd_fatal (bfd_get_filename (abfd
));
790 *data
->relocs
= (arelent
**) xmalloc (relsize
);
791 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
793 if (*data
->relcount
< 0)
794 bfd_fatal (bfd_get_filename (abfd
));
802 /* Print a single symbol. */
805 print_symbol (bfd
*abfd
, asymbol
*sym
, bfd_vma ssize
, bfd
*archive_bfd
)
808 struct extended_symbol_info info
;
812 format
->print_symbol_filename (archive_bfd
, abfd
);
814 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
815 info
.sinfo
= &syminfo
;
817 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
818 info
.elfinfo
= (elf_symbol_type
*) sym
;
821 format
->print_symbol_info (&info
, abfd
);
825 static asymbol
**syms
;
826 static long symcount
;
827 const char *filename
, *functionname
;
830 /* We need to get the canonical symbols in order to call
831 bfd_find_nearest_line. This is inefficient, but, then, you
832 don't have to use --line-numbers. */
833 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
842 symsize
= bfd_get_symtab_upper_bound (abfd
);
844 bfd_fatal (bfd_get_filename (abfd
));
845 syms
= (asymbol
**) xmalloc (symsize
);
846 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
848 bfd_fatal (bfd_get_filename (abfd
));
849 lineno_cache_bfd
= abfd
;
852 if (bfd_is_und_section (bfd_get_section (sym
)))
854 static asection
**secs
;
855 static arelent
***relocs
;
856 static long *relcount
;
857 static unsigned int seccount
;
861 /* For an undefined symbol, we try to find a reloc for the
862 symbol, and print the line number of the reloc. */
863 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
865 for (i
= 0; i
< seccount
; i
++)
866 if (relocs
[i
] != NULL
)
878 struct get_relocs_info rinfo
;
880 seccount
= bfd_count_sections (abfd
);
882 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
883 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
884 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
887 rinfo
.relocs
= relocs
;
888 rinfo
.relcount
= relcount
;
890 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
891 lineno_cache_rel_bfd
= abfd
;
894 symname
= bfd_asymbol_name (sym
);
895 for (i
= 0; i
< seccount
; i
++)
899 for (j
= 0; j
< relcount
[i
]; j
++)
904 if (r
->sym_ptr_ptr
!= NULL
905 && (*r
->sym_ptr_ptr
)->section
== sym
->section
906 && (*r
->sym_ptr_ptr
)->value
== sym
->value
908 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
909 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
910 r
->address
, &filename
,
911 &functionname
, &lineno
)
914 /* We only print the first one we find. */
915 printf ("\t%s:%u", filename
, lineno
);
922 else if (bfd_get_section (sym
)->owner
== abfd
)
924 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
925 || bfd_find_nearest_line (abfd
, bfd_get_section (sym
),
926 syms
, sym
->value
, &filename
,
927 &functionname
, &lineno
))
930 printf ("\t%s:%u", filename
, lineno
);
937 /* Print the symbols when sorting by size. */
940 print_size_symbols (bfd
*abfd
, bfd_boolean is_dynamic
,
941 struct size_sym
*symsizes
, long symcount
,
945 struct size_sym
*from
, *fromend
;
947 store
= bfd_make_empty_symbol (abfd
);
949 bfd_fatal (bfd_get_filename (abfd
));
952 fromend
= from
+ symcount
;
953 for (; from
< fromend
; from
++)
957 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
959 bfd_fatal (bfd_get_filename (abfd
));
961 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
966 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
970 print_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
, long symcount
,
971 unsigned int size
, bfd
*archive_bfd
)
974 bfd_byte
*from
, *fromend
;
976 store
= bfd_make_empty_symbol (abfd
);
978 bfd_fatal (bfd_get_filename (abfd
));
980 from
= (bfd_byte
*) minisyms
;
981 fromend
= from
+ symcount
* size
;
982 for (; from
< fromend
; from
+= size
)
986 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
988 bfd_fatal (bfd_get_filename (abfd
));
990 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
994 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
997 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1002 struct size_sym
*symsizes
;
1006 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1008 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1013 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1016 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1018 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1022 bfd_fatal (bfd_get_filename (abfd
));
1027 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1031 if (show_synthetic
&& size
== sizeof (asymbol
*))
1035 asymbol
**static_syms
= NULL
;
1036 asymbol
**dyn_syms
= NULL
;
1037 long static_count
= 0;
1042 dyn_count
= symcount
;
1043 dyn_syms
= (asymbol
**) minisyms
;
1047 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1049 static_count
= symcount
;
1050 static_syms
= (asymbol
**) minisyms
;
1054 dyn_syms
= (asymbol
**) xmalloc (storage
);
1055 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1057 bfd_fatal (bfd_get_filename (abfd
));
1060 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1061 dyn_count
, dyn_syms
, &synthsyms
);
1062 if (synth_count
> 0)
1068 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1069 symp
= (asymbol
**) new_mini
;
1070 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1072 for (i
= 0; i
< synth_count
; i
++)
1073 *symp
++ = synthsyms
+ i
;
1075 minisyms
= new_mini
;
1076 symcount
+= synth_count
;
1080 /* Discard the symbols we don't want to print.
1081 It's OK to do this in place; we'll free the storage anyway
1082 (after printing). */
1084 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1090 sort_dynamic
= dynamic
;
1091 sort_x
= bfd_make_empty_symbol (abfd
);
1092 sort_y
= bfd_make_empty_symbol (abfd
);
1093 if (sort_x
== NULL
|| sort_y
== NULL
)
1094 bfd_fatal (bfd_get_filename (abfd
));
1097 qsort (minisyms
, symcount
, size
,
1098 sorters
[sort_numerically
][reverse_sort
]);
1100 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1105 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1107 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1114 set_print_width (bfd
*file
)
1116 print_width
= bfd_get_arch_size (file
);
1118 if (print_width
== -1)
1121 Guess the target's bitsize based on its name.
1122 We assume here than any 64-bit format will include
1123 "64" somewhere in its name. The only known exception
1124 is the MMO object file format. */
1125 if (strstr (bfd_get_target (file
), "64") != NULL
1126 || strcmp (bfd_get_target (file
), "mmo") == 0)
1134 display_archive (bfd
*file
)
1137 bfd
*last_arfile
= NULL
;
1140 format
->print_archive_filename (bfd_get_filename (file
));
1143 print_symdef_entry (file
);
1149 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1153 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1154 bfd_fatal (bfd_get_filename (file
));
1158 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1160 set_print_width (arfile
);
1161 format
->print_archive_member (bfd_get_filename (file
),
1162 bfd_get_filename (arfile
));
1163 display_rel_file (arfile
, file
);
1167 bfd_nonfatal (bfd_get_filename (arfile
));
1168 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1170 list_matching_formats (matching
);
1175 if (last_arfile
!= NULL
)
1177 bfd_close (last_arfile
);
1178 lineno_cache_bfd
= NULL
;
1179 lineno_cache_rel_bfd
= NULL
;
1181 last_arfile
= arfile
;
1184 if (last_arfile
!= NULL
)
1186 bfd_close (last_arfile
);
1187 lineno_cache_bfd
= NULL
;
1188 lineno_cache_rel_bfd
= NULL
;
1193 display_file (char *filename
)
1195 bfd_boolean retval
= TRUE
;
1199 if (get_file_size (filename
) < 1)
1202 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1205 bfd_nonfatal (filename
);
1209 /* If printing line numbers, decompress the debug sections. */
1211 file
->flags
|= BFD_DECOMPRESS
;
1213 if (bfd_check_format (file
, bfd_archive
))
1215 display_archive (file
);
1217 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1219 set_print_width (file
);
1220 format
->print_object_filename (filename
);
1221 display_rel_file (file
, NULL
);
1225 bfd_nonfatal (filename
);
1226 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1228 list_matching_formats (matching
);
1234 if (!bfd_close (file
))
1235 bfd_fatal (filename
);
1237 lineno_cache_bfd
= NULL
;
1238 lineno_cache_rel_bfd
= NULL
;
1243 /* The following 3 groups of functions are called unconditionally,
1244 once at the start of processing each file of the appropriate type.
1245 They should check `filename_per_file' and `filename_per_symbol',
1246 as appropriate for their output format, to determine whether to
1249 /* Print the name of an object file given on the command line. */
1252 print_object_filename_bsd (char *filename
)
1254 if (filename_per_file
&& !filename_per_symbol
)
1255 printf ("\n%s:\n", filename
);
1259 print_object_filename_sysv (char *filename
)
1262 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1264 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1265 if (print_width
== 32)
1267 Name Value Class Type Size Line Section\n\n"));
1270 Name Value Class Type Size Line Section\n\n"));
1274 print_object_filename_posix (char *filename
)
1276 if (filename_per_file
&& !filename_per_symbol
)
1277 printf ("%s:\n", filename
);
1280 /* Print the name of an archive file given on the command line. */
1283 print_archive_filename_bsd (char *filename
)
1285 if (filename_per_file
)
1286 printf ("\n%s:\n", filename
);
1290 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1295 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1299 /* Print the name of an archive member file. */
1302 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1303 const char *filename
)
1305 if (!filename_per_symbol
)
1306 printf ("\n%s:\n", filename
);
1310 print_archive_member_sysv (char *archive
, const char *filename
)
1313 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1315 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1316 if (print_width
== 32)
1318 Name Value Class Type Size Line Section\n\n"));
1321 Name Value Class Type Size Line Section\n\n"));
1325 print_archive_member_posix (char *archive
, const char *filename
)
1327 if (!filename_per_symbol
)
1328 printf ("%s[%s]:\n", archive
, filename
);
1331 /* Print the name of the file (and archive, if there is one)
1332 containing a symbol. */
1335 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1337 if (filename_per_symbol
)
1340 printf ("%s:", bfd_get_filename (archive_bfd
));
1341 printf ("%s:", bfd_get_filename (abfd
));
1346 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1348 if (filename_per_symbol
)
1351 printf ("%s:", bfd_get_filename (archive_bfd
));
1352 printf ("%s:", bfd_get_filename (abfd
));
1357 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1359 if (filename_per_symbol
)
1362 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1363 bfd_get_filename (abfd
));
1365 printf ("%s: ", bfd_get_filename (abfd
));
1369 /* Print a symbol value. */
1372 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1374 switch (print_width
)
1377 printf (value_format_32bit
, (unsigned long) val
);
1381 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1382 printf (value_format_64bit
, val
);
1384 /* We have a 64 bit value to print, but the host is only 32 bit. */
1385 if (print_radix
== 16)
1386 bfd_fprintf_vma (abfd
, stdout
, val
);
1392 s
= buf
+ sizeof buf
;
1396 *--s
= (val
% print_radix
) + '0';
1399 while ((buf
+ sizeof buf
- 1) - s
< 16)
1407 fatal (_("Print width has not been initialized (%d)"), print_width
);
1412 /* Print a line of information about a symbol. */
1415 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1417 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1419 if (print_width
== 64)
1425 /* Normally we print the value of the symbol. If we are printing the
1426 size or sorting by size then we print its size, except for the
1427 (weird) special case where both flags are defined, in which case we
1428 print both values. This conforms to documented behaviour. */
1429 if (sort_by_size
&& !print_size
)
1430 print_value (abfd
, SYM_SIZE (info
));
1432 print_value (abfd
, SYM_VALUE (info
));
1434 if (print_size
&& SYM_SIZE (info
))
1437 print_value (abfd
, SYM_SIZE (info
));
1441 printf (" %c", SYM_TYPE (info
));
1443 if (SYM_TYPE (info
) == '-')
1447 printf (other_format
, SYM_STAB_OTHER (info
));
1449 printf (desc_format
, SYM_STAB_DESC (info
));
1450 printf (" %5s", SYM_STAB_NAME (info
));
1452 print_symname (" %s", SYM_NAME (info
), abfd
);
1456 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1458 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1460 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1462 if (print_width
== 32)
1468 print_value (abfd
, SYM_VALUE (info
));
1470 printf ("| %c |", SYM_TYPE (info
));
1472 if (SYM_TYPE (info
) == '-')
1475 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1476 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1477 printf ("| |"); /* Line, Section. */
1481 /* Type, Size, Line, Section */
1484 get_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1488 if (SYM_SIZE (info
))
1489 print_value (abfd
, SYM_SIZE (info
));
1492 if (print_width
== 32)
1499 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1506 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1508 print_symname ("%s ", SYM_NAME (info
), abfd
);
1509 printf ("%c ", SYM_TYPE (info
));
1511 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1515 print_value (abfd
, SYM_VALUE (info
));
1517 if (SYM_SIZE (info
))
1518 print_value (abfd
, SYM_SIZE (info
));
1523 main (int argc
, char **argv
)
1528 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1529 setlocale (LC_MESSAGES
, "");
1531 #if defined (HAVE_SETLOCALE)
1532 setlocale (LC_CTYPE
, "");
1533 setlocale (LC_COLLATE
, "");
1535 bindtextdomain (PACKAGE
, LOCALEDIR
);
1536 textdomain (PACKAGE
);
1538 program_name
= *argv
;
1539 xmalloc_set_program_name (program_name
);
1540 #if BFD_SUPPORTS_PLUGINS
1541 bfd_plugin_set_program_name (program_name
);
1544 START_PROGRESS (program_name
, 0);
1546 expandargv (&argc
, &argv
);
1549 set_default_bfd_target ();
1551 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1552 long_options
, (int *) 0)) != EOF
)
1557 print_debug_syms
= 1;
1561 filename_per_symbol
= 1;
1563 case 'B': /* For MIPS compatibility. */
1564 set_output_format ("bsd");
1570 enum demangling_styles style
;
1572 style
= cplus_demangle_name_to_style (optarg
);
1573 if (style
== unknown_demangling
)
1574 fatal (_("unknown demangling style `%s'"),
1577 cplus_demangle_set_style (style
);
1584 /* Ignored for HP/UX compatibility. */
1587 set_output_format (optarg
);
1601 sort_numerically
= 1;
1606 sort_numerically
= 0;
1609 case OPTION_SIZE_SORT
:
1611 sort_numerically
= 0;
1615 set_output_format ("posix");
1627 set_print_radix (optarg
);
1636 /* Ignored for (partial) AIX compatibility. On AIX, the
1637 argument has values 32, 64, or 32_64, and specifies that
1638 only 32-bit, only 64-bit, or both kinds of objects should
1639 be examined. The default is 32. So plain AIX nm on a
1640 library archive with both kinds of objects will ignore
1641 the 64-bit ones. For GNU nm, the default is and always
1642 has been -X 32_64, and other options are not supported. */
1643 if (strcmp (optarg
, "32_64") != 0)
1644 fatal (_("Only -X 32_64 is supported"));
1647 case OPTION_TARGET
: /* --target */
1651 case OPTION_PLUGIN
: /* --plugin */
1652 #if BFD_SUPPORTS_PLUGINS
1653 bfd_plugin_set_plugin (optarg
);
1655 fatal (_("sorry - this program has been built without plugin support\n"));
1659 case 0: /* A long option that just sets a flag. */
1668 print_version ("nm");
1670 if (sort_by_size
&& undefined_only
)
1672 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1673 non_fatal (_("will produce no output, since undefined symbols have no size."));
1677 /* OK, all options now parsed. If no filename specified, do a.out. */
1679 return !display_file ("a.out");
1683 if (argc
- optind
> 1)
1684 filename_per_file
= 1;
1686 /* We were given several filenames to do. */
1687 while (optind
< argc
)
1690 if (!display_file (argv
[optind
++]))
1694 END_PROGRESS (program_name
);
1699 char *lim
= (char *) sbrk (0);
1701 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));