1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "aout/stab_gnu.h"
26 #include "aout/ranlib.h"
28 #include "libiberty.h"
30 #include "elf/common.h"
31 #define DO_NOT_DEFINE_AOUTHDR
32 #define DO_NOT_DEFINE_FILHDR
33 #define DO_NOT_DEFINE_LINENO
34 #define DO_NOT_DEFINE_SCNHDR
35 #include "coff/external.h"
36 #include "coff/internal.h"
39 #include "plugin-api.h"
42 /* When sorting by size, we use this structure to hold the size and a
43 pointer to the minisymbol. */
51 /* When fetching relocs, we use this structure to pass information to
54 struct get_relocs_info
62 struct extended_symbol_info
66 elf_symbol_type
*elfinfo
;
67 coff_symbol_type
*coffinfo
;
68 /* FIXME: We should add more fields for Type, Line, Section. */
70 #define SYM_NAME(sym) (sym->sinfo->name)
71 #define SYM_VALUE(sym) (sym->sinfo->value)
72 #define SYM_TYPE(sym) (sym->sinfo->type)
73 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
74 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
75 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
76 #define SYM_SIZE(sym) \
77 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
79 /* The output formatting functions. */
80 static void print_object_filename_bsd (const char *);
81 static void print_object_filename_sysv (const char *);
82 static void print_object_filename_posix (const char *);
83 static void print_archive_filename_bsd (const char *);
84 static void print_archive_filename_sysv (const char *);
85 static void print_archive_filename_posix (const char *);
86 static void print_archive_member_bsd (const char *, const char *);
87 static void print_archive_member_sysv (const char *, const char *);
88 static void print_archive_member_posix (const char *, const char *);
89 static void print_symbol_filename_bsd (bfd
*, bfd
*);
90 static void print_symbol_filename_sysv (bfd
*, bfd
*);
91 static void print_symbol_filename_posix (bfd
*, bfd
*);
92 static void print_value (bfd
*, bfd_vma
);
93 static void print_symbol_info_bsd (struct extended_symbol_info
*, bfd
*);
94 static void print_symbol_info_sysv (struct extended_symbol_info
*, bfd
*);
95 static void print_symbol_info_posix (struct extended_symbol_info
*, bfd
*);
97 /* Support for different output formats. */
100 /* Print the name of an object file given on the command line. */
101 void (*print_object_filename
) (const char *);
103 /* Print the name of an archive file given on the command line. */
104 void (*print_archive_filename
) (const char *);
106 /* Print the name of an archive member file. */
107 void (*print_archive_member
) (const char *, const char *);
109 /* Print the name of the file (and archive, if there is one)
110 containing a symbol. */
111 void (*print_symbol_filename
) (bfd
*, bfd
*);
113 /* Print a line of information about a symbol. */
114 void (*print_symbol_info
) (struct extended_symbol_info
*, bfd
*);
117 static struct output_fns formats
[] =
119 {print_object_filename_bsd
,
120 print_archive_filename_bsd
,
121 print_archive_member_bsd
,
122 print_symbol_filename_bsd
,
123 print_symbol_info_bsd
},
124 {print_object_filename_sysv
,
125 print_archive_filename_sysv
,
126 print_archive_member_sysv
,
127 print_symbol_filename_sysv
,
128 print_symbol_info_sysv
},
129 {print_object_filename_posix
,
130 print_archive_filename_posix
,
131 print_archive_member_posix
,
132 print_symbol_filename_posix
,
133 print_symbol_info_posix
}
136 /* Indices in `formats'. */
138 #define FORMAT_SYSV 1
139 #define FORMAT_POSIX 2
140 #define FORMAT_DEFAULT FORMAT_BSD
142 /* The output format to use. */
143 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
144 static unsigned int print_format
= FORMAT_DEFAULT
;
145 static const char *print_format_string
= NULL
;
147 /* Command options. */
149 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
150 static int external_only
= 0; /* Print external symbols only. */
151 static int defined_only
= 0; /* Print defined symbols only. */
152 static int no_sort
= 0; /* Don't sort; print syms in order found. */
153 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
154 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
155 static int print_size
= 0; /* Print size of defined symbols. */
156 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
157 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
158 static int sort_by_size
= 0; /* Sort by size of symbol. */
159 static int undefined_only
= 0; /* Print undefined symbols only. */
160 static int dynamic
= 0; /* Print dynamic symbols. */
161 static int show_version
= 0; /* Show the version number. */
162 static int show_synthetic
= 0; /* Display synthesized symbols too. */
163 static int line_numbers
= 0; /* Print line numbers for symbols. */
164 static int allow_special_symbols
= 0; /* Allow special symbols. */
165 static int with_symbol_versions
= 0; /* Include symbol version information in the output. */
167 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
169 /* When to print the names of files. Not mutually exclusive in SYSV format. */
170 static int filename_per_file
= 0; /* Once per file, on its own line. */
171 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
173 static int print_width
= 0;
174 static int print_radix
= 16;
175 /* Print formats for printing stab info. */
176 static char other_format
[] = "%02x";
177 static char desc_format
[] = "%04x";
179 static char *target
= NULL
;
180 #if BFD_SUPPORTS_PLUGINS
181 static const char *plugin_target
= "plugin";
183 static const char *plugin_target
= NULL
;
186 /* Used to cache the line numbers for a BFD. */
187 static bfd
*lineno_cache_bfd
;
188 static bfd
*lineno_cache_rel_bfd
;
190 enum long_option_values
195 OPTION_RECURSE_LIMIT
,
196 OPTION_NO_RECURSE_LIMIT
199 static struct option long_options
[] =
201 {"debug-syms", no_argument
, &print_debug_syms
, 1},
202 {"demangle", optional_argument
, 0, 'C'},
203 {"dynamic", no_argument
, &dynamic
, 1},
204 {"extern-only", no_argument
, &external_only
, 1},
205 {"format", required_argument
, 0, 'f'},
206 {"help", no_argument
, 0, 'h'},
207 {"line-numbers", no_argument
, 0, 'l'},
208 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
209 {"no-demangle", no_argument
, &do_demangle
, 0},
210 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
211 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
212 {"no-sort", no_argument
, 0, 'p'},
213 {"numeric-sort", no_argument
, 0, 'n'},
214 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
215 {"portability", no_argument
, 0, 'P'},
216 {"print-armap", no_argument
, &print_armap
, 1},
217 {"print-file-name", no_argument
, 0, 'o'},
218 {"print-size", no_argument
, 0, 'S'},
219 {"radix", required_argument
, 0, 't'},
220 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
221 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
222 {"reverse-sort", no_argument
, &reverse_sort
, 1},
223 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
224 {"special-syms", no_argument
, &allow_special_symbols
, 1},
225 {"synthetic", no_argument
, &show_synthetic
, 1},
226 {"target", required_argument
, 0, OPTION_TARGET
},
227 {"defined-only", no_argument
, &defined_only
, 1},
228 {"undefined-only", no_argument
, &undefined_only
, 1},
229 {"version", no_argument
, &show_version
, 1},
230 {"with-symbol-versions", no_argument
, &with_symbol_versions
, 1},
231 {0, no_argument
, 0, 0}
234 /* Some error-reporting functions. */
236 ATTRIBUTE_NORETURN
static void
237 usage (FILE *stream
, int status
)
239 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
240 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
241 fprintf (stream
, _(" The options are:\n\
242 -a, --debug-syms Display debugger-only symbols\n\
243 -A, --print-file-name Print name of the input file before every symbol\n\
244 -B Same as --format=bsd\n\
245 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
246 The STYLE, if specified, can be `auto' (the default),\n\
247 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
249 --no-demangle Do not demangle low-level symbol names\n\
250 --recurse-limit Enable a demangling recursion limit. This is the default.\n\
251 --no-recurse-limit Disable a demangling recursion limit.\n\
252 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
253 --defined-only Display only defined symbols\n\
255 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
256 `sysv' or `posix'. The default is `bsd'\n\
257 -g, --extern-only Display only external symbols\n\
258 -l, --line-numbers Use debugging information to find a filename and\n\
259 line number for each symbol\n\
260 -n, --numeric-sort Sort symbols numerically by address\n\
262 -p, --no-sort Do not sort the symbols\n\
263 -P, --portability Same as --format=posix\n\
264 -r, --reverse-sort Reverse the sense of the sort\n"));
265 #if BFD_SUPPORTS_PLUGINS
266 fprintf (stream
, _("\
267 --plugin NAME Load the specified plugin\n"));
269 fprintf (stream
, _("\
270 -S, --print-size Print size of defined symbols\n\
271 -s, --print-armap Include index for symbols from archive members\n\
272 --size-sort Sort symbols by size\n\
273 --special-syms Include special symbols in the output\n\
274 --synthetic Display synthetic symbols as well\n\
275 -t, --radix=RADIX Use RADIX for printing symbol values\n\
276 --target=BFDNAME Specify the target object format as BFDNAME\n\
277 -u, --undefined-only Display only undefined symbols\n\
278 --with-symbol-versions Display version strings after symbol names\n\
279 -X 32_64 (ignored)\n\
280 @FILE Read options from FILE\n\
281 -h, --help Display this information\n\
282 -V, --version Display this program's version number\n\
284 list_supported_targets (program_name
, stream
);
285 if (REPORT_BUGS_TO
[0] && status
== 0)
286 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
290 /* Set the radix for the symbol value and size according to RADIX. */
293 set_print_radix (char *radix
)
297 case 'x': print_radix
= 16; break;
298 case 'd': print_radix
= 10; break;
299 case 'o': print_radix
= 8; break;
302 fatal (_("%s: invalid radix"), radix
);
305 other_format
[3] = desc_format
[3] = *radix
;
309 set_output_format (char *f
)
328 fatal (_("%s: invalid output format"), f
);
330 format
= &formats
[i
];
335 get_elf_symbol_type (unsigned int type
)
342 case STT_NOTYPE
: return "NOTYPE";
343 case STT_OBJECT
: return "OBJECT";
344 case STT_FUNC
: return "FUNC";
345 case STT_SECTION
: return "SECTION";
346 case STT_FILE
: return "FILE";
347 case STT_COMMON
: return "COMMON";
348 case STT_TLS
: return "TLS";
352 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
353 n
= asprintf (&bufp
, _("<processor specific>: %d"), type
);
354 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
355 n
= asprintf (&bufp
, _("<OS specific>: %d"), type
);
357 n
= asprintf (&bufp
, _("<unknown>: %d"), type
);
359 fatal ("%s", xstrerror (errno
));
364 get_coff_symbol_type (const struct internal_syment
*sym
)
369 switch (sym
->n_sclass
)
371 case C_BLOCK
: return "Block";
372 case C_FILE
: return "File";
373 case C_LINE
: return "Line";
379 switch (DTYPE(sym
->n_type
))
381 case DT_FCN
: return "Function";
382 case DT_PTR
: return "Pointer";
383 case DT_ARY
: return "Array";
387 n
= asprintf (&bufp
, _("<unknown>: %d/%d"), sym
->n_sclass
, sym
->n_type
);
389 fatal ("%s", xstrerror (errno
));
393 /* Print symbol name NAME, read from ABFD, with printf format FORM,
394 demangling it if requested. */
397 print_symname (const char *form
, const char *name
, bfd
*abfd
)
399 if (do_demangle
&& *name
)
401 char *res
= bfd_demangle (abfd
, name
, demangle_flags
);
415 print_symdef_entry (bfd
*abfd
)
417 symindex idx
= BFD_NO_MORE_SYMBOLS
;
419 bfd_boolean everprinted
= FALSE
;
421 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
422 idx
!= BFD_NO_MORE_SYMBOLS
;
423 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
428 printf (_("\nArchive index:\n"));
431 elt
= bfd_get_elt_at_index (abfd
, idx
);
433 bfd_fatal ("bfd_get_elt_at_index");
434 if (thesym
->name
!= (char *) NULL
)
436 print_symname ("%s", thesym
->name
, abfd
);
437 printf (" in %s\n", bfd_get_filename (elt
));
443 /* True when we can report missing plugin error. */
444 bfd_boolean report_plugin_err
= TRUE
;
446 /* Choose which symbol entries to print;
447 compact them downward to get rid of the rest.
448 Return the number of symbols to be printed. */
451 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
452 long symcount
, unsigned int size
)
454 bfd_byte
*from
, *fromend
, *to
;
457 store
= bfd_make_empty_symbol (abfd
);
459 bfd_fatal (bfd_get_filename (abfd
));
461 from
= (bfd_byte
*) minisyms
;
462 fromend
= from
+ symcount
* size
;
463 to
= (bfd_byte
*) minisyms
;
465 for (; from
< fromend
; from
+= size
)
472 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
474 bfd_fatal (bfd_get_filename (abfd
));
476 if (sym
->name
[0] == '_'
477 && sym
->name
[1] == '_'
478 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
479 && report_plugin_err
)
481 report_plugin_err
= FALSE
;
482 non_fatal (_("%s: plugin needed to handle lto object"),
483 bfd_get_filename (abfd
));
487 keep
= bfd_is_und_section (sym
->section
);
488 else if (external_only
)
489 /* PR binutls/12753: Unique symbols are global too. */
490 keep
= ((sym
->flags
& (BSF_GLOBAL
492 | BSF_GNU_UNIQUE
)) != 0
493 || bfd_is_und_section (sym
->section
)
494 || bfd_is_com_section (sym
->section
));
499 && ! print_debug_syms
500 && (sym
->flags
& BSF_DEBUGGING
) != 0)
505 && (bfd_is_abs_section (sym
->section
)
506 || bfd_is_und_section (sym
->section
)))
512 if (bfd_is_und_section (sym
->section
))
517 && bfd_is_target_special_symbol (abfd
, sym
)
518 && ! allow_special_symbols
)
524 memcpy (to
, from
, size
);
529 return (to
- (bfd_byte
*) minisyms
) / size
;
532 /* These globals are used to pass information into the sorting
534 static bfd
*sort_bfd
;
535 static bfd_boolean sort_dynamic
;
536 static asymbol
*sort_x
;
537 static asymbol
*sort_y
;
539 /* Symbol-sorting predicates */
540 #define valueof(x) ((x)->section->vma + (x)->value)
542 /* Numeric sorts. Undefined symbols are always considered "less than"
543 defined symbols with zero values. Common symbols are not treated
544 specially -- i.e., their sizes are used as their "values". */
547 non_numeric_forward (const void *P_x
, const void *P_y
)
552 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
553 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
554 if (x
== NULL
|| y
== NULL
)
555 bfd_fatal (bfd_get_filename (sort_bfd
));
557 xn
= bfd_asymbol_name (x
);
558 yn
= bfd_asymbol_name (y
);
566 /* Solaris 2.5 has a bug in strcoll.
567 strcoll returns invalid values when confronted with empty strings. */
573 return strcoll (xn
, yn
);
575 return strcmp (xn
, yn
);
580 non_numeric_reverse (const void *x
, const void *y
)
582 return - non_numeric_forward (x
, y
);
586 numeric_forward (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_asymbol_section (x
);
597 ys
= bfd_asymbol_section (y
);
599 if (bfd_is_und_section (xs
))
601 if (! bfd_is_und_section (ys
))
604 else if (bfd_is_und_section (ys
))
606 else if (valueof (x
) != valueof (y
))
607 return valueof (x
) < valueof (y
) ? -1 : 1;
609 return non_numeric_forward (P_x
, P_y
);
613 numeric_reverse (const void *x
, const void *y
)
615 return - numeric_forward (x
, y
);
618 static int (*(sorters
[2][2])) (const void *, const void *) =
620 { non_numeric_forward
, non_numeric_reverse
},
621 { numeric_forward
, numeric_reverse
}
624 /* This sort routine is used by sort_symbols_by_size. It is similar
625 to numeric_forward, but when symbols have the same value it sorts
626 by section VMA. This simplifies the sort_symbols_by_size code
627 which handles symbols at the end of sections. Also, this routine
628 tries to sort file names before other symbols with the same value.
629 That will make the file name have a zero size, which will make
630 sort_symbols_by_size choose the non file name symbol, leading to
631 more meaningful output. For similar reasons, this code sorts
632 gnu_compiled_* and gcc2_compiled before other symbols with the same
636 size_forward1 (const void *P_x
, const void *P_y
)
644 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
645 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
646 if (x
== NULL
|| y
== NULL
)
647 bfd_fatal (bfd_get_filename (sort_bfd
));
649 xs
= bfd_asymbol_section (x
);
650 ys
= bfd_asymbol_section (y
);
652 if (bfd_is_und_section (xs
))
654 if (bfd_is_und_section (ys
))
657 if (valueof (x
) != valueof (y
))
658 return valueof (x
) < valueof (y
) ? -1 : 1;
660 if (xs
->vma
!= ys
->vma
)
661 return xs
->vma
< ys
->vma
? -1 : 1;
663 xn
= bfd_asymbol_name (x
);
664 yn
= bfd_asymbol_name (y
);
668 /* The symbols gnu_compiled and gcc2_compiled convey even less
669 information than the file name, so sort them out first. */
671 xf
= (strstr (xn
, "gnu_compiled") != NULL
672 || strstr (xn
, "gcc2_compiled") != NULL
);
673 yf
= (strstr (yn
, "gnu_compiled") != NULL
674 || strstr (yn
, "gcc2_compiled") != NULL
);
681 /* We use a heuristic for the file name. It may not work on non
682 Unix systems, but it doesn't really matter; the only difference
683 is precisely which symbol names get printed. */
685 #define file_symbol(s, sn, snl) \
686 (((s)->flags & BSF_FILE) != 0 \
688 && (sn)[(snl) - 2] == '.' \
689 && ((sn)[(snl) - 1] == 'o' \
690 || (sn)[(snl) - 1] == 'a')))
692 xf
= file_symbol (x
, xn
, xnl
);
693 yf
= file_symbol (y
, yn
, ynl
);
700 return non_numeric_forward (P_x
, P_y
);
703 /* This sort routine is used by sort_symbols_by_size. It is sorting
704 an array of size_sym structures into size order. */
707 size_forward2 (const void *P_x
, const void *P_y
)
709 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
710 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
712 if (x
->size
< y
->size
)
713 return reverse_sort
? 1 : -1;
714 else if (x
->size
> y
->size
)
715 return reverse_sort
? -1 : 1;
717 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
720 /* Sort the symbols by size. ELF provides a size but for other formats
721 we have to make a guess by assuming that the difference between the
722 address of a symbol and the address of the next higher symbol is the
726 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
727 long symcount
, unsigned int size
,
728 struct size_sym
**symsizesp
)
730 struct size_sym
*symsizes
;
731 bfd_byte
*from
, *fromend
;
733 asymbol
*store_sym
, *store_next
;
735 qsort (minisyms
, symcount
, size
, size_forward1
);
737 /* We are going to return a special set of symbols and sizes to
739 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
740 *symsizesp
= symsizes
;
742 /* Note that filter_symbols has already removed all absolute and
743 undefined symbols. Here we remove all symbols whose size winds
745 from
= (bfd_byte
*) minisyms
;
746 fromend
= from
+ symcount
* size
;
753 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
756 bfd_fatal (bfd_get_filename (abfd
));
759 for (; from
< fromend
; from
+= size
)
766 if (from
+ size
< fromend
)
768 next
= bfd_minisymbol_to_symbol (abfd
,
770 (const void *) (from
+ size
),
773 bfd_fatal (bfd_get_filename (abfd
));
778 sec
= bfd_asymbol_section (sym
);
780 /* Synthetic symbols don't have a full type set of data available, thus
781 we can't rely on that information for the symbol size. Ditto for
782 bfd/section.c:global_syms like *ABS*. */
783 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
784 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
785 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
786 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
787 && bfd_is_com_section (sec
))
791 if (from
+ size
< fromend
792 && sec
== bfd_asymbol_section (next
))
793 sz
= valueof (next
) - valueof (sym
);
795 sz
= (bfd_section_vma (sec
)
796 + bfd_section_size (sec
)
802 symsizes
->minisym
= (const void *) from
;
810 store_sym
= store_next
;
814 symcount
= symsizes
- *symsizesp
;
816 /* We must now sort again by size. */
817 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
822 /* This function is used to get the relocs for a particular section.
823 It is called via bfd_map_over_sections. */
826 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
828 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
832 if ((sec
->flags
& SEC_RELOC
) == 0)
834 *data
->relocs
= NULL
;
841 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
843 bfd_fatal (bfd_get_filename (abfd
));
845 *data
->relocs
= (arelent
**) xmalloc (relsize
);
846 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
848 if (*data
->relcount
< 0)
849 bfd_fatal (bfd_get_filename (abfd
));
857 /* Print a single symbol. */
860 print_symbol (bfd
* abfd
,
866 struct extended_symbol_info info
;
870 format
->print_symbol_filename (archive_bfd
, abfd
);
872 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
874 info
.sinfo
= &syminfo
;
876 /* Synthetic symbols do not have a full symbol type set of data available.
877 Nor do bfd/section.c:global_syms like *ABS*. */
878 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
881 info
.coffinfo
= NULL
;
885 info
.elfinfo
= elf_symbol_from (abfd
, sym
);
886 info
.coffinfo
= coff_symbol_from (sym
);
889 format
->print_symbol_info (&info
, abfd
);
891 if (with_symbol_versions
)
893 const char * version_string
= NULL
;
894 bfd_boolean hidden
= FALSE
;
896 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0)
897 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
899 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
902 if (version_string
&& *version_string
!= '\0')
903 printf (hidden
? "@%s" : "@@%s", version_string
);
908 static asymbol
**syms
;
909 static long symcount
;
910 const char *filename
, *functionname
;
913 /* We need to get the canonical symbols in order to call
914 bfd_find_nearest_line. This is inefficient, but, then, you
915 don't have to use --line-numbers. */
916 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
925 symsize
= bfd_get_symtab_upper_bound (abfd
);
927 bfd_fatal (bfd_get_filename (abfd
));
928 syms
= (asymbol
**) xmalloc (symsize
);
929 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
931 bfd_fatal (bfd_get_filename (abfd
));
932 lineno_cache_bfd
= abfd
;
935 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
937 static asection
**secs
;
938 static arelent
***relocs
;
939 static long *relcount
;
940 static unsigned int seccount
;
944 /* For an undefined symbol, we try to find a reloc for the
945 symbol, and print the line number of the reloc. */
946 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
948 for (i
= 0; i
< seccount
; i
++)
949 if (relocs
[i
] != NULL
)
961 struct get_relocs_info rinfo
;
963 seccount
= bfd_count_sections (abfd
);
965 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
966 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
967 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
970 rinfo
.relocs
= relocs
;
971 rinfo
.relcount
= relcount
;
973 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
974 lineno_cache_rel_bfd
= abfd
;
977 symname
= bfd_asymbol_name (sym
);
978 for (i
= 0; i
< seccount
; i
++)
982 for (j
= 0; j
< relcount
[i
]; j
++)
987 if (r
->sym_ptr_ptr
!= NULL
988 && (*r
->sym_ptr_ptr
)->section
== sym
->section
989 && (*r
->sym_ptr_ptr
)->value
== sym
->value
991 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
992 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
993 r
->address
, &filename
,
994 &functionname
, &lineno
)
997 /* We only print the first one we find. */
998 printf ("\t%s:%u", filename
, lineno
);
1005 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1007 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1008 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1009 syms
, sym
->value
, &filename
,
1010 &functionname
, &lineno
))
1013 printf ("\t%s:%u", filename
, lineno
);
1020 /* Print the symbols when sorting by size. */
1023 print_size_symbols (bfd
* abfd
,
1024 bfd_boolean is_dynamic
,
1025 struct size_sym
* symsizes
,
1030 struct size_sym
*from
;
1031 struct size_sym
*fromend
;
1033 store
= bfd_make_empty_symbol (abfd
);
1035 bfd_fatal (bfd_get_filename (abfd
));
1038 fromend
= from
+ symcount
;
1040 for (; from
< fromend
; from
++)
1044 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1046 bfd_fatal (bfd_get_filename (abfd
));
1048 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1053 /* Print the symbols of ABFD that are held in MINISYMS.
1055 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1057 SYMCOUNT is the number of symbols in MINISYMS.
1059 SIZE is the size of a symbol in MINISYMS. */
1062 print_symbols (bfd
* abfd
,
1063 bfd_boolean is_dynamic
,
1073 store
= bfd_make_empty_symbol (abfd
);
1075 bfd_fatal (bfd_get_filename (abfd
));
1077 from
= (bfd_byte
*) minisyms
;
1078 fromend
= from
+ symcount
* size
;
1080 for (; from
< fromend
; from
+= size
)
1084 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1086 bfd_fatal (bfd_get_filename (abfd
));
1088 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1092 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1095 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1100 struct size_sym
*symsizes
;
1101 asymbol
*synthsyms
= NULL
;
1105 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1107 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1112 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1115 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1117 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1121 bfd_fatal (bfd_get_filename (abfd
));
1126 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1130 if (show_synthetic
&& size
== sizeof (asymbol
*))
1132 asymbol
**static_syms
= NULL
;
1133 asymbol
**dyn_syms
= NULL
;
1134 long static_count
= 0;
1140 dyn_count
= symcount
;
1141 dyn_syms
= (asymbol
**) minisyms
;
1145 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1147 static_count
= symcount
;
1148 static_syms
= (asymbol
**) minisyms
;
1152 dyn_syms
= (asymbol
**) xmalloc (storage
);
1153 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1155 bfd_fatal (bfd_get_filename (abfd
));
1159 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1160 dyn_count
, dyn_syms
, &synthsyms
);
1161 if (synth_count
> 0)
1166 minisyms
= xrealloc (minisyms
,
1167 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1168 symp
= (asymbol
**) minisyms
+ symcount
;
1169 for (i
= 0; i
< synth_count
; i
++)
1170 *symp
++ = synthsyms
+ i
;
1172 symcount
+= synth_count
;
1176 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1178 if (abfd
->lto_slim_object
)
1180 report_plugin_err
= FALSE
;
1181 non_fatal (_("%s: plugin needed to handle lto object"),
1182 bfd_get_filename (abfd
));
1185 /* Discard the symbols we don't want to print.
1186 It's OK to do this in place; we'll free the storage anyway
1187 (after printing). */
1189 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1195 sort_dynamic
= dynamic
;
1196 sort_x
= bfd_make_empty_symbol (abfd
);
1197 sort_y
= bfd_make_empty_symbol (abfd
);
1198 if (sort_x
== NULL
|| sort_y
== NULL
)
1199 bfd_fatal (bfd_get_filename (abfd
));
1202 qsort (minisyms
, symcount
, size
,
1203 sorters
[sort_numerically
][reverse_sort
]);
1205 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1210 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1212 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1220 /* Construct a formatting string for printing symbol values. */
1223 get_print_format (void)
1225 const char * padding
;
1226 if (print_format
== FORMAT_POSIX
)
1228 /* POSIX compatible output does not have any padding. */
1231 else if (print_width
== 32)
1235 else /* print_width == 64 */
1240 const char * length
= "l";
1241 if (print_width
== 64)
1243 #if BFD_HOST_64BIT_LONG
1245 #elif BFD_HOST_64BIT_LONG_LONG
1254 const char * radix
= NULL
;
1255 switch (print_radix
)
1257 case 8: radix
= "o"; break;
1258 case 10: radix
= "d"; break;
1259 case 16: radix
= "x"; break;
1262 return concat ("%", padding
, length
, radix
, NULL
);
1266 set_print_width (bfd
*file
)
1268 print_width
= bfd_get_arch_size (file
);
1270 if (print_width
== -1)
1273 Guess the target's bitsize based on its name.
1274 We assume here than any 64-bit format will include
1275 "64" somewhere in its name. The only known exception
1276 is the MMO object file format. */
1277 if (strstr (bfd_get_target (file
), "64") != NULL
1278 || strcmp (bfd_get_target (file
), "mmo") == 0)
1283 free ((char *) print_format_string
);
1284 print_format_string
= get_print_format ();
1288 display_archive (bfd
*file
)
1291 bfd
*last_arfile
= NULL
;
1294 format
->print_archive_filename (bfd_get_filename (file
));
1297 print_symdef_entry (file
);
1303 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1307 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1308 bfd_fatal (bfd_get_filename (file
));
1312 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1314 set_print_width (arfile
);
1315 format
->print_archive_member (bfd_get_filename (file
),
1316 bfd_get_filename (arfile
));
1317 display_rel_file (arfile
, file
);
1321 bfd_nonfatal (bfd_get_filename (arfile
));
1322 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1324 list_matching_formats (matching
);
1329 if (last_arfile
!= NULL
)
1331 bfd_close (last_arfile
);
1332 lineno_cache_bfd
= NULL
;
1333 lineno_cache_rel_bfd
= NULL
;
1334 if (arfile
== last_arfile
)
1337 last_arfile
= arfile
;
1340 if (last_arfile
!= NULL
)
1342 bfd_close (last_arfile
);
1343 lineno_cache_bfd
= NULL
;
1344 lineno_cache_rel_bfd
= NULL
;
1349 display_file (char *filename
)
1351 bfd_boolean retval
= TRUE
;
1355 if (get_file_size (filename
) < 1)
1358 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1361 bfd_nonfatal (filename
);
1365 /* If printing line numbers, decompress the debug sections. */
1367 file
->flags
|= BFD_DECOMPRESS
;
1369 if (bfd_check_format (file
, bfd_archive
))
1371 display_archive (file
);
1373 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1375 set_print_width (file
);
1376 format
->print_object_filename (filename
);
1377 display_rel_file (file
, NULL
);
1381 bfd_nonfatal (filename
);
1382 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1384 list_matching_formats (matching
);
1390 if (!bfd_close (file
))
1391 bfd_fatal (filename
);
1393 lineno_cache_bfd
= NULL
;
1394 lineno_cache_rel_bfd
= NULL
;
1399 /* The following 3 groups of functions are called unconditionally,
1400 once at the start of processing each file of the appropriate type.
1401 They should check `filename_per_file' and `filename_per_symbol',
1402 as appropriate for their output format, to determine whether to
1405 /* Print the name of an object file given on the command line. */
1408 print_object_filename_bsd (const char *filename
)
1410 if (filename_per_file
&& !filename_per_symbol
)
1411 printf ("\n%s:\n", filename
);
1415 print_object_filename_sysv (const char *filename
)
1418 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1420 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1421 if (print_width
== 32)
1423 Name Value Class Type Size Line Section\n\n"));
1426 Name Value Class Type Size Line Section\n\n"));
1430 print_object_filename_posix (const char *filename
)
1432 if (filename_per_file
&& !filename_per_symbol
)
1433 printf ("%s:\n", filename
);
1436 /* Print the name of an archive file given on the command line. */
1439 print_archive_filename_bsd (const char *filename
)
1441 if (filename_per_file
)
1442 printf ("\n%s:\n", filename
);
1446 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1451 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1455 /* Print the name of an archive member file. */
1458 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1459 const char *filename
)
1461 if (!filename_per_symbol
)
1462 printf ("\n%s:\n", filename
);
1466 print_archive_member_sysv (const char *archive
, const char *filename
)
1469 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1471 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1472 if (print_width
== 32)
1474 Name Value Class Type Size Line Section\n\n"));
1477 Name Value Class Type Size Line Section\n\n"));
1481 print_archive_member_posix (const char *archive
, const char *filename
)
1483 if (!filename_per_symbol
)
1484 printf ("%s[%s]:\n", archive
, filename
);
1487 /* Print the name of the file (and archive, if there is one)
1488 containing a symbol. */
1491 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1493 if (filename_per_symbol
)
1496 printf ("%s:", bfd_get_filename (archive_bfd
));
1497 printf ("%s:", bfd_get_filename (abfd
));
1502 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1504 if (filename_per_symbol
)
1507 printf ("%s:", bfd_get_filename (archive_bfd
));
1508 printf ("%s:", bfd_get_filename (abfd
));
1513 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1515 if (filename_per_symbol
)
1518 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1519 bfd_get_filename (abfd
));
1521 printf ("%s: ", bfd_get_filename (abfd
));
1525 /* Print a symbol value. */
1528 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1530 switch (print_width
)
1533 printf (print_format_string
, (unsigned long) val
);
1537 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1538 printf (print_format_string
, val
);
1540 /* We have a 64 bit value to print, but the host is only 32 bit. */
1541 if (print_radix
== 16)
1542 bfd_fprintf_vma (abfd
, stdout
, val
);
1548 s
= buf
+ sizeof buf
;
1552 *--s
= (val
% print_radix
) + '0';
1555 while ((buf
+ sizeof buf
- 1) - s
< 16)
1563 fatal (_("Print width has not been initialized (%d)"), print_width
);
1568 /* Print a line of information about a symbol. */
1571 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1573 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1575 if (print_width
== 64)
1581 /* Normally we print the value of the symbol. If we are printing the
1582 size or sorting by size then we print its size, except for the
1583 (weird) special case where both flags are defined, in which case we
1584 print both values. This conforms to documented behaviour. */
1585 if (sort_by_size
&& !print_size
)
1586 print_value (abfd
, SYM_SIZE (info
));
1588 print_value (abfd
, SYM_VALUE (info
));
1589 if (print_size
&& SYM_SIZE (info
))
1592 print_value (abfd
, SYM_SIZE (info
));
1596 printf (" %c", SYM_TYPE (info
));
1598 if (SYM_TYPE (info
) == '-')
1602 printf (other_format
, SYM_STAB_OTHER (info
));
1604 printf (desc_format
, SYM_STAB_DESC (info
));
1605 printf (" %5s", SYM_STAB_NAME (info
));
1607 print_symname (" %s", SYM_NAME (info
), abfd
);
1611 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1613 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1615 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1617 if (print_width
== 32)
1623 print_value (abfd
, SYM_VALUE (info
));
1625 printf ("| %c |", SYM_TYPE (info
));
1627 if (SYM_TYPE (info
) == '-')
1630 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1631 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1632 printf ("| |"); /* Line, Section. */
1636 /* Type, Size, Line, Section */
1639 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1640 else if (info
->coffinfo
)
1642 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1646 if (SYM_SIZE (info
))
1647 print_value (abfd
, SYM_SIZE (info
));
1650 if (print_width
== 32)
1657 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1658 else if (info
->coffinfo
)
1659 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1666 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1668 print_symname ("%s ", SYM_NAME (info
), abfd
);
1669 printf ("%c ", SYM_TYPE (info
));
1671 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1675 print_value (abfd
, SYM_VALUE (info
));
1677 if (SYM_SIZE (info
))
1678 print_value (abfd
, SYM_SIZE (info
));
1683 main (int argc
, char **argv
)
1688 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1689 setlocale (LC_MESSAGES
, "");
1691 #if defined (HAVE_SETLOCALE)
1692 setlocale (LC_CTYPE
, "");
1693 setlocale (LC_COLLATE
, "");
1695 bindtextdomain (PACKAGE
, LOCALEDIR
);
1696 textdomain (PACKAGE
);
1698 program_name
= *argv
;
1699 xmalloc_set_program_name (program_name
);
1700 bfd_set_error_program_name (program_name
);
1701 #if BFD_SUPPORTS_PLUGINS
1702 bfd_plugin_set_program_name (program_name
);
1705 START_PROGRESS (program_name
, 0);
1707 expandargv (&argc
, &argv
);
1709 if (bfd_init () != BFD_INIT_MAGIC
)
1710 fatal (_("fatal error: libbfd ABI mismatch"));
1711 set_default_bfd_target ();
1713 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1714 long_options
, (int *) 0)) != EOF
)
1719 print_debug_syms
= 1;
1723 filename_per_symbol
= 1;
1725 case 'B': /* For MIPS compatibility. */
1726 set_output_format ("bsd");
1732 enum demangling_styles style
;
1734 style
= cplus_demangle_name_to_style (optarg
);
1735 if (style
== unknown_demangling
)
1736 fatal (_("unknown demangling style `%s'"),
1739 cplus_demangle_set_style (style
);
1742 case OPTION_RECURSE_LIMIT
:
1743 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1745 case OPTION_NO_RECURSE_LIMIT
:
1746 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1752 /* Ignored for HP/UX compatibility. */
1755 set_output_format (optarg
);
1769 sort_numerically
= 1;
1774 sort_numerically
= 0;
1777 case OPTION_SIZE_SORT
:
1779 sort_numerically
= 0;
1783 set_output_format ("posix");
1795 set_print_radix (optarg
);
1804 /* Ignored for (partial) AIX compatibility. On AIX, the
1805 argument has values 32, 64, or 32_64, and specifies that
1806 only 32-bit, only 64-bit, or both kinds of objects should
1807 be examined. The default is 32. So plain AIX nm on a
1808 library archive with both kinds of objects will ignore
1809 the 64-bit ones. For GNU nm, the default is and always
1810 has been -X 32_64, and other options are not supported. */
1811 if (strcmp (optarg
, "32_64") != 0)
1812 fatal (_("Only -X 32_64 is supported"));
1815 case OPTION_TARGET
: /* --target */
1819 case OPTION_PLUGIN
: /* --plugin */
1820 #if BFD_SUPPORTS_PLUGINS
1821 bfd_plugin_set_plugin (optarg
);
1823 fatal (_("sorry - this program has been built without plugin support\n"));
1827 case 0: /* A long option that just sets a flag. */
1836 print_version ("nm");
1838 if (sort_by_size
&& undefined_only
)
1840 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1841 non_fatal (_("will produce no output, since undefined symbols have no size."));
1845 /* OK, all options now parsed. If no filename specified, do a.out. */
1847 return !display_file ("a.out");
1851 if (argc
- optind
> 1)
1852 filename_per_file
= 1;
1854 /* We were given several filenames to do. */
1855 while (optind
< argc
)
1858 if (!display_file (argv
[optind
++]))
1862 END_PROGRESS (program_name
);