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_VALUE(sym) (sym->sinfo->value)
71 #define SYM_TYPE(sym) (sym->sinfo->type)
72 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
73 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
74 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
75 #define SYM_SIZE(sym) \
76 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
78 /* The output formatting functions. */
79 static void print_object_filename_bsd (const char *);
80 static void print_object_filename_sysv (const char *);
81 static void print_object_filename_posix (const char *);
82 static void print_archive_filename_bsd (const char *);
83 static void print_archive_filename_sysv (const char *);
84 static void print_archive_filename_posix (const char *);
85 static void print_archive_member_bsd (const char *, const char *);
86 static void print_archive_member_sysv (const char *, const char *);
87 static void print_archive_member_posix (const char *, const char *);
88 static void print_symbol_filename_bsd (bfd
*, bfd
*);
89 static void print_symbol_filename_sysv (bfd
*, bfd
*);
90 static void print_symbol_filename_posix (bfd
*, bfd
*);
91 static void print_value (bfd
*, bfd_vma
);
92 static void print_symbol_info_bsd (struct extended_symbol_info
*, bfd
*);
93 static void print_symbol_info_sysv (struct extended_symbol_info
*, bfd
*);
94 static void print_symbol_info_posix (struct extended_symbol_info
*, bfd
*);
96 /* Support for different output formats. */
99 /* Print the name of an object file given on the command line. */
100 void (*print_object_filename
) (const char *);
102 /* Print the name of an archive file given on the command line. */
103 void (*print_archive_filename
) (const char *);
105 /* Print the name of an archive member file. */
106 void (*print_archive_member
) (const char *, const char *);
108 /* Print the name of the file (and archive, if there is one)
109 containing a symbol. */
110 void (*print_symbol_filename
) (bfd
*, bfd
*);
112 /* Print a line of information about a symbol. */
113 void (*print_symbol_info
) (struct extended_symbol_info
*, bfd
*);
116 static struct output_fns formats
[] =
118 {print_object_filename_bsd
,
119 print_archive_filename_bsd
,
120 print_archive_member_bsd
,
121 print_symbol_filename_bsd
,
122 print_symbol_info_bsd
},
123 {print_object_filename_sysv
,
124 print_archive_filename_sysv
,
125 print_archive_member_sysv
,
126 print_symbol_filename_sysv
,
127 print_symbol_info_sysv
},
128 {print_object_filename_posix
,
129 print_archive_filename_posix
,
130 print_archive_member_posix
,
131 print_symbol_filename_posix
,
132 print_symbol_info_posix
}
135 /* Indices in `formats'. */
137 #define FORMAT_SYSV 1
138 #define FORMAT_POSIX 2
139 #define FORMAT_DEFAULT FORMAT_BSD
141 /* The output format to use. */
142 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
143 static unsigned int print_format
= FORMAT_DEFAULT
;
144 static const char *print_format_string
= NULL
;
146 /* Command options. */
148 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
149 static int external_only
= 0; /* Print external symbols only. */
150 static int defined_only
= 0; /* Print defined symbols only. */
151 static int no_sort
= 0; /* Don't sort; print syms in order found. */
152 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
153 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
154 static int print_size
= 0; /* Print size of defined symbols. */
155 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
156 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
157 static int sort_by_size
= 0; /* Sort by size of symbol. */
158 static int undefined_only
= 0; /* Print undefined symbols only. */
159 static int dynamic
= 0; /* Print dynamic symbols. */
160 static int show_version
= 0; /* Show the version number. */
161 static int show_synthetic
= 0; /* Display synthesized symbols too. */
162 static int line_numbers
= 0; /* Print line numbers for symbols. */
163 static int allow_special_symbols
= 0; /* Allow special symbols. */
165 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
167 /* When to print the names of files. Not mutually exclusive in SYSV format. */
168 static int filename_per_file
= 0; /* Once per file, on its own line. */
169 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
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 enum long_option_values
193 OPTION_RECURSE_LIMIT
,
194 OPTION_NO_RECURSE_LIMIT
,
195 OPTION_WITH_SYMBOL_VERSIONS
198 static struct option long_options
[] =
200 {"debug-syms", no_argument
, &print_debug_syms
, 1},
201 {"demangle", optional_argument
, 0, 'C'},
202 {"dynamic", no_argument
, &dynamic
, 1},
203 {"extern-only", no_argument
, &external_only
, 1},
204 {"format", required_argument
, 0, 'f'},
205 {"help", no_argument
, 0, 'h'},
206 {"line-numbers", no_argument
, 0, 'l'},
207 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
208 {"no-demangle", no_argument
, &do_demangle
, 0},
209 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
210 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
211 {"no-sort", no_argument
, 0, 'p'},
212 {"numeric-sort", no_argument
, 0, 'n'},
213 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
214 {"portability", no_argument
, 0, 'P'},
215 {"print-armap", no_argument
, &print_armap
, 1},
216 {"print-file-name", no_argument
, 0, 'o'},
217 {"print-size", no_argument
, 0, 'S'},
218 {"radix", required_argument
, 0, 't'},
219 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
220 {"recursion-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
221 {"reverse-sort", no_argument
, &reverse_sort
, 1},
222 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
223 {"special-syms", no_argument
, &allow_special_symbols
, 1},
224 {"synthetic", no_argument
, &show_synthetic
, 1},
225 {"target", required_argument
, 0, OPTION_TARGET
},
226 {"defined-only", no_argument
, &defined_only
, 1},
227 {"undefined-only", no_argument
, &undefined_only
, 1},
228 {"version", no_argument
, &show_version
, 1},
229 {"with-symbol-versions", no_argument
, NULL
,
230 OPTION_WITH_SYMBOL_VERSIONS
},
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
, struct extended_symbol_info
*info
,
398 const char *name
, bfd
*abfd
)
401 name
= info
->sinfo
->name
;
402 if (do_demangle
&& *name
)
404 char *res
= bfd_demangle (abfd
, name
, demangle_flags
);
415 if (info
!= NULL
&& info
->elfinfo
)
417 const char *version_string
;
421 = bfd_get_symbol_version_string (abfd
, &info
->elfinfo
->symbol
,
423 if (version_string
&& version_string
[0])
424 printf ("%s%s", hidden
? "@" : "@@", version_string
);
429 print_symdef_entry (bfd
*abfd
)
431 symindex idx
= BFD_NO_MORE_SYMBOLS
;
433 bfd_boolean everprinted
= FALSE
;
435 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
436 idx
!= BFD_NO_MORE_SYMBOLS
;
437 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
442 printf (_("\nArchive index:\n"));
445 elt
= bfd_get_elt_at_index (abfd
, idx
);
447 bfd_fatal ("bfd_get_elt_at_index");
448 if (thesym
->name
!= (char *) NULL
)
450 print_symname ("%s", NULL
, thesym
->name
, abfd
);
451 printf (" in %s\n", bfd_get_filename (elt
));
457 /* True when we can report missing plugin error. */
458 bfd_boolean report_plugin_err
= TRUE
;
460 /* Choose which symbol entries to print;
461 compact them downward to get rid of the rest.
462 Return the number of symbols to be printed. */
465 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
466 long symcount
, unsigned int size
)
468 bfd_byte
*from
, *fromend
, *to
;
471 store
= bfd_make_empty_symbol (abfd
);
473 bfd_fatal (bfd_get_filename (abfd
));
475 from
= (bfd_byte
*) minisyms
;
476 fromend
= from
+ symcount
* size
;
477 to
= (bfd_byte
*) minisyms
;
479 for (; from
< fromend
; from
+= size
)
486 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
488 bfd_fatal (bfd_get_filename (abfd
));
490 if (sym
->name
[0] == '_'
491 && sym
->name
[1] == '_'
492 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
493 && report_plugin_err
)
495 report_plugin_err
= FALSE
;
496 non_fatal (_("%s: plugin needed to handle lto object"),
497 bfd_get_filename (abfd
));
501 keep
= bfd_is_und_section (sym
->section
);
502 else if (external_only
)
503 /* PR binutls/12753: Unique symbols are global too. */
504 keep
= ((sym
->flags
& (BSF_GLOBAL
506 | BSF_GNU_UNIQUE
)) != 0
507 || bfd_is_und_section (sym
->section
)
508 || bfd_is_com_section (sym
->section
));
513 && ! print_debug_syms
514 && (sym
->flags
& BSF_DEBUGGING
) != 0)
519 && (bfd_is_abs_section (sym
->section
)
520 || bfd_is_und_section (sym
->section
)))
526 if (bfd_is_und_section (sym
->section
))
531 && bfd_is_target_special_symbol (abfd
, sym
)
532 && ! allow_special_symbols
)
538 memcpy (to
, from
, size
);
543 return (to
- (bfd_byte
*) minisyms
) / size
;
546 /* These globals are used to pass information into the sorting
548 static bfd
*sort_bfd
;
549 static bfd_boolean sort_dynamic
;
550 static asymbol
*sort_x
;
551 static asymbol
*sort_y
;
553 /* Symbol-sorting predicates */
554 #define valueof(x) ((x)->section->vma + (x)->value)
556 /* Numeric sorts. Undefined symbols are always considered "less than"
557 defined symbols with zero values. Common symbols are not treated
558 specially -- i.e., their sizes are used as their "values". */
561 non_numeric_forward (const void *P_x
, const void *P_y
)
566 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
567 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
568 if (x
== NULL
|| y
== NULL
)
569 bfd_fatal (bfd_get_filename (sort_bfd
));
571 xn
= bfd_asymbol_name (x
);
572 yn
= bfd_asymbol_name (y
);
580 /* Solaris 2.5 has a bug in strcoll.
581 strcoll returns invalid values when confronted with empty strings. */
587 return strcoll (xn
, yn
);
589 return strcmp (xn
, yn
);
594 non_numeric_reverse (const void *x
, const void *y
)
596 return - non_numeric_forward (x
, y
);
600 numeric_forward (const void *P_x
, const void *P_y
)
605 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
606 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
607 if (x
== NULL
|| y
== NULL
)
608 bfd_fatal (bfd_get_filename (sort_bfd
));
610 xs
= bfd_asymbol_section (x
);
611 ys
= bfd_asymbol_section (y
);
613 if (bfd_is_und_section (xs
))
615 if (! bfd_is_und_section (ys
))
618 else if (bfd_is_und_section (ys
))
620 else if (valueof (x
) != valueof (y
))
621 return valueof (x
) < valueof (y
) ? -1 : 1;
623 return non_numeric_forward (P_x
, P_y
);
627 numeric_reverse (const void *x
, const void *y
)
629 return - numeric_forward (x
, y
);
632 static int (*(sorters
[2][2])) (const void *, const void *) =
634 { non_numeric_forward
, non_numeric_reverse
},
635 { numeric_forward
, numeric_reverse
}
638 /* This sort routine is used by sort_symbols_by_size. It is similar
639 to numeric_forward, but when symbols have the same value it sorts
640 by section VMA. This simplifies the sort_symbols_by_size code
641 which handles symbols at the end of sections. Also, this routine
642 tries to sort file names before other symbols with the same value.
643 That will make the file name have a zero size, which will make
644 sort_symbols_by_size choose the non file name symbol, leading to
645 more meaningful output. For similar reasons, this code sorts
646 gnu_compiled_* and gcc2_compiled before other symbols with the same
650 size_forward1 (const void *P_x
, const void *P_y
)
658 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
659 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
660 if (x
== NULL
|| y
== NULL
)
661 bfd_fatal (bfd_get_filename (sort_bfd
));
663 xs
= bfd_asymbol_section (x
);
664 ys
= bfd_asymbol_section (y
);
666 if (bfd_is_und_section (xs
))
668 if (bfd_is_und_section (ys
))
671 if (valueof (x
) != valueof (y
))
672 return valueof (x
) < valueof (y
) ? -1 : 1;
674 if (xs
->vma
!= ys
->vma
)
675 return xs
->vma
< ys
->vma
? -1 : 1;
677 xn
= bfd_asymbol_name (x
);
678 yn
= bfd_asymbol_name (y
);
682 /* The symbols gnu_compiled and gcc2_compiled convey even less
683 information than the file name, so sort them out first. */
685 xf
= (strstr (xn
, "gnu_compiled") != NULL
686 || strstr (xn
, "gcc2_compiled") != NULL
);
687 yf
= (strstr (yn
, "gnu_compiled") != NULL
688 || strstr (yn
, "gcc2_compiled") != NULL
);
695 /* We use a heuristic for the file name. It may not work on non
696 Unix systems, but it doesn't really matter; the only difference
697 is precisely which symbol names get printed. */
699 #define file_symbol(s, sn, snl) \
700 (((s)->flags & BSF_FILE) != 0 \
702 && (sn)[(snl) - 2] == '.' \
703 && ((sn)[(snl) - 1] == 'o' \
704 || (sn)[(snl) - 1] == 'a')))
706 xf
= file_symbol (x
, xn
, xnl
);
707 yf
= file_symbol (y
, yn
, ynl
);
714 return non_numeric_forward (P_x
, P_y
);
717 /* This sort routine is used by sort_symbols_by_size. It is sorting
718 an array of size_sym structures into size order. */
721 size_forward2 (const void *P_x
, const void *P_y
)
723 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
724 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
726 if (x
->size
< y
->size
)
727 return reverse_sort
? 1 : -1;
728 else if (x
->size
> y
->size
)
729 return reverse_sort
? -1 : 1;
731 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
734 /* Sort the symbols by size. ELF provides a size but for other formats
735 we have to make a guess by assuming that the difference between the
736 address of a symbol and the address of the next higher symbol is the
740 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
741 long symcount
, unsigned int size
,
742 struct size_sym
**symsizesp
)
744 struct size_sym
*symsizes
;
745 bfd_byte
*from
, *fromend
;
747 asymbol
*store_sym
, *store_next
;
749 qsort (minisyms
, symcount
, size
, size_forward1
);
751 /* We are going to return a special set of symbols and sizes to
753 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
754 *symsizesp
= symsizes
;
756 /* Note that filter_symbols has already removed all absolute and
757 undefined symbols. Here we remove all symbols whose size winds
759 from
= (bfd_byte
*) minisyms
;
760 fromend
= from
+ symcount
* size
;
767 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
770 bfd_fatal (bfd_get_filename (abfd
));
773 for (; from
< fromend
; from
+= size
)
780 if (from
+ size
< fromend
)
782 next
= bfd_minisymbol_to_symbol (abfd
,
784 (const void *) (from
+ size
),
787 bfd_fatal (bfd_get_filename (abfd
));
792 sec
= bfd_asymbol_section (sym
);
794 /* Synthetic symbols don't have a full type set of data available, thus
795 we can't rely on that information for the symbol size. Ditto for
796 bfd/section.c:global_syms like *ABS*. */
797 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
798 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
799 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
800 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
801 && bfd_is_com_section (sec
))
805 if (from
+ size
< fromend
806 && sec
== bfd_asymbol_section (next
))
807 sz
= valueof (next
) - valueof (sym
);
809 sz
= (bfd_section_vma (sec
)
810 + bfd_section_size (sec
)
816 symsizes
->minisym
= (const void *) from
;
824 store_sym
= store_next
;
828 symcount
= symsizes
- *symsizesp
;
830 /* We must now sort again by size. */
831 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
836 /* This function is used to get the relocs for a particular section.
837 It is called via bfd_map_over_sections. */
840 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
842 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
846 if ((sec
->flags
& SEC_RELOC
) == 0)
848 *data
->relocs
= NULL
;
855 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
857 bfd_fatal (bfd_get_filename (abfd
));
859 *data
->relocs
= (arelent
**) xmalloc (relsize
);
860 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
862 if (*data
->relcount
< 0)
863 bfd_fatal (bfd_get_filename (abfd
));
871 /* Print a single symbol. */
874 print_symbol (bfd
* abfd
,
880 struct extended_symbol_info info
;
884 format
->print_symbol_filename (archive_bfd
, abfd
);
886 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
888 info
.sinfo
= &syminfo
;
890 /* Synthetic symbols do not have a full symbol type set of data available.
891 Nor do bfd/section.c:global_syms like *ABS*. */
892 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
895 info
.coffinfo
= NULL
;
899 info
.elfinfo
= elf_symbol_from (abfd
, sym
);
900 info
.coffinfo
= coff_symbol_from (sym
);
903 format
->print_symbol_info (&info
, abfd
);
907 static asymbol
**syms
;
908 static long symcount
;
909 const char *filename
, *functionname
;
912 /* We need to get the canonical symbols in order to call
913 bfd_find_nearest_line. This is inefficient, but, then, you
914 don't have to use --line-numbers. */
915 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
924 symsize
= bfd_get_symtab_upper_bound (abfd
);
926 bfd_fatal (bfd_get_filename (abfd
));
927 syms
= (asymbol
**) xmalloc (symsize
);
928 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
930 bfd_fatal (bfd_get_filename (abfd
));
931 lineno_cache_bfd
= abfd
;
934 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
936 static asection
**secs
;
937 static arelent
***relocs
;
938 static long *relcount
;
939 static unsigned int seccount
;
943 /* For an undefined symbol, we try to find a reloc for the
944 symbol, and print the line number of the reloc. */
945 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
947 for (i
= 0; i
< seccount
; i
++)
948 if (relocs
[i
] != NULL
)
960 struct get_relocs_info rinfo
;
962 seccount
= bfd_count_sections (abfd
);
964 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
965 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
966 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
969 rinfo
.relocs
= relocs
;
970 rinfo
.relcount
= relcount
;
972 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
973 lineno_cache_rel_bfd
= abfd
;
976 symname
= bfd_asymbol_name (sym
);
977 for (i
= 0; i
< seccount
; i
++)
981 for (j
= 0; j
< relcount
[i
]; j
++)
986 if (r
->sym_ptr_ptr
!= NULL
987 && (*r
->sym_ptr_ptr
)->section
== sym
->section
988 && (*r
->sym_ptr_ptr
)->value
== sym
->value
990 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
991 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
992 r
->address
, &filename
,
993 &functionname
, &lineno
)
996 /* We only print the first one we find. */
997 printf ("\t%s:%u", filename
, lineno
);
1004 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1006 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1007 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1008 syms
, sym
->value
, &filename
,
1009 &functionname
, &lineno
))
1012 printf ("\t%s:%u", filename
, lineno
);
1019 /* Print the symbols when sorting by size. */
1022 print_size_symbols (bfd
* abfd
,
1023 bfd_boolean is_dynamic
,
1024 struct size_sym
* symsizes
,
1029 struct size_sym
*from
;
1030 struct size_sym
*fromend
;
1032 store
= bfd_make_empty_symbol (abfd
);
1034 bfd_fatal (bfd_get_filename (abfd
));
1037 fromend
= from
+ symcount
;
1039 for (; from
< fromend
; from
++)
1043 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1045 bfd_fatal (bfd_get_filename (abfd
));
1047 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1052 /* Print the symbols of ABFD that are held in MINISYMS.
1054 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1056 SYMCOUNT is the number of symbols in MINISYMS.
1058 SIZE is the size of a symbol in MINISYMS. */
1061 print_symbols (bfd
* abfd
,
1062 bfd_boolean is_dynamic
,
1072 store
= bfd_make_empty_symbol (abfd
);
1074 bfd_fatal (bfd_get_filename (abfd
));
1076 from
= (bfd_byte
*) minisyms
;
1077 fromend
= from
+ symcount
* size
;
1079 for (; from
< fromend
; from
+= size
)
1083 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1085 bfd_fatal (bfd_get_filename (abfd
));
1087 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1091 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1094 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1099 struct size_sym
*symsizes
;
1100 asymbol
*synthsyms
= NULL
;
1104 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1106 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1111 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1114 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1116 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1120 bfd_fatal (bfd_get_filename (abfd
));
1125 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1129 if (show_synthetic
&& size
== sizeof (asymbol
*))
1131 asymbol
**static_syms
= NULL
;
1132 asymbol
**dyn_syms
= NULL
;
1133 long static_count
= 0;
1139 dyn_count
= symcount
;
1140 dyn_syms
= (asymbol
**) minisyms
;
1144 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1146 static_count
= symcount
;
1147 static_syms
= (asymbol
**) minisyms
;
1151 dyn_syms
= (asymbol
**) xmalloc (storage
);
1152 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1154 bfd_fatal (bfd_get_filename (abfd
));
1158 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1159 dyn_count
, dyn_syms
, &synthsyms
);
1160 if (synth_count
> 0)
1165 minisyms
= xrealloc (minisyms
,
1166 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1167 symp
= (asymbol
**) minisyms
+ symcount
;
1168 for (i
= 0; i
< synth_count
; i
++)
1169 *symp
++ = synthsyms
+ i
;
1171 symcount
+= synth_count
;
1173 if (!dynamic
&& dyn_syms
!= NULL
)
1177 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1179 if (abfd
->lto_slim_object
)
1181 report_plugin_err
= FALSE
;
1182 non_fatal (_("%s: plugin needed to handle lto object"),
1183 bfd_get_filename (abfd
));
1186 /* Discard the symbols we don't want to print.
1187 It's OK to do this in place; we'll free the storage anyway
1188 (after printing). */
1190 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1196 sort_dynamic
= dynamic
;
1197 sort_x
= bfd_make_empty_symbol (abfd
);
1198 sort_y
= bfd_make_empty_symbol (abfd
);
1199 if (sort_x
== NULL
|| sort_y
== NULL
)
1200 bfd_fatal (bfd_get_filename (abfd
));
1203 qsort (minisyms
, symcount
, size
,
1204 sorters
[sort_numerically
][reverse_sort
]);
1206 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1211 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1213 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1221 /* Construct a formatting string for printing symbol values. */
1224 get_print_format (void)
1226 const char * padding
;
1227 if (print_format
== FORMAT_POSIX
)
1229 /* POSIX compatible output does not have any padding. */
1232 else if (print_width
== 32)
1236 else /* print_width == 64 */
1241 const char * length
= "l";
1242 if (print_width
== 64)
1244 #if BFD_HOST_64BIT_LONG
1246 #elif BFD_HOST_64BIT_LONG_LONG
1255 const char * radix
= NULL
;
1256 switch (print_radix
)
1258 case 8: radix
= "o"; break;
1259 case 10: radix
= "d"; break;
1260 case 16: radix
= "x"; break;
1263 return concat ("%", padding
, length
, radix
, NULL
);
1267 set_print_width (bfd
*file
)
1269 print_width
= bfd_get_arch_size (file
);
1271 if (print_width
== -1)
1274 Guess the target's bitsize based on its name.
1275 We assume here than any 64-bit format will include
1276 "64" somewhere in its name. The only known exception
1277 is the MMO object file format. */
1278 if (strstr (bfd_get_target (file
), "64") != NULL
1279 || strcmp (bfd_get_target (file
), "mmo") == 0)
1284 free ((char *) print_format_string
);
1285 print_format_string
= get_print_format ();
1289 display_archive (bfd
*file
)
1292 bfd
*last_arfile
= NULL
;
1295 format
->print_archive_filename (bfd_get_filename (file
));
1298 print_symdef_entry (file
);
1304 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1308 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1309 bfd_fatal (bfd_get_filename (file
));
1313 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1315 set_print_width (arfile
);
1316 format
->print_archive_member (bfd_get_filename (file
),
1317 bfd_get_filename (arfile
));
1318 display_rel_file (arfile
, file
);
1322 bfd_nonfatal (bfd_get_filename (arfile
));
1323 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1325 list_matching_formats (matching
);
1330 if (last_arfile
!= NULL
)
1332 bfd_close (last_arfile
);
1333 lineno_cache_bfd
= NULL
;
1334 lineno_cache_rel_bfd
= NULL
;
1335 if (arfile
== last_arfile
)
1338 last_arfile
= arfile
;
1341 if (last_arfile
!= NULL
)
1343 bfd_close (last_arfile
);
1344 lineno_cache_bfd
= NULL
;
1345 lineno_cache_rel_bfd
= NULL
;
1350 display_file (char *filename
)
1352 bfd_boolean retval
= TRUE
;
1356 if (get_file_size (filename
) < 1)
1359 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1362 bfd_nonfatal (filename
);
1366 /* If printing line numbers, decompress the debug sections. */
1368 file
->flags
|= BFD_DECOMPRESS
;
1370 if (bfd_check_format (file
, bfd_archive
))
1372 display_archive (file
);
1374 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1376 set_print_width (file
);
1377 format
->print_object_filename (filename
);
1378 display_rel_file (file
, NULL
);
1382 bfd_nonfatal (filename
);
1383 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1385 list_matching_formats (matching
);
1391 if (!bfd_close (file
))
1392 bfd_fatal (filename
);
1394 lineno_cache_bfd
= NULL
;
1395 lineno_cache_rel_bfd
= NULL
;
1400 /* The following 3 groups of functions are called unconditionally,
1401 once at the start of processing each file of the appropriate type.
1402 They should check `filename_per_file' and `filename_per_symbol',
1403 as appropriate for their output format, to determine whether to
1406 /* Print the name of an object file given on the command line. */
1409 print_object_filename_bsd (const char *filename
)
1411 if (filename_per_file
&& !filename_per_symbol
)
1412 printf ("\n%s:\n", filename
);
1416 print_object_filename_sysv (const char *filename
)
1419 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1421 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1422 if (print_width
== 32)
1424 Name Value Class Type Size Line Section\n\n"));
1427 Name Value Class Type Size Line Section\n\n"));
1431 print_object_filename_posix (const char *filename
)
1433 if (filename_per_file
&& !filename_per_symbol
)
1434 printf ("%s:\n", filename
);
1437 /* Print the name of an archive file given on the command line. */
1440 print_archive_filename_bsd (const char *filename
)
1442 if (filename_per_file
)
1443 printf ("\n%s:\n", filename
);
1447 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1452 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1456 /* Print the name of an archive member file. */
1459 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1460 const char *filename
)
1462 if (!filename_per_symbol
)
1463 printf ("\n%s:\n", filename
);
1467 print_archive_member_sysv (const char *archive
, const char *filename
)
1470 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1472 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1473 if (print_width
== 32)
1475 Name Value Class Type Size Line Section\n\n"));
1478 Name Value Class Type Size Line Section\n\n"));
1482 print_archive_member_posix (const char *archive
, const char *filename
)
1484 if (!filename_per_symbol
)
1485 printf ("%s[%s]:\n", archive
, filename
);
1488 /* Print the name of the file (and archive, if there is one)
1489 containing a symbol. */
1492 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1494 if (filename_per_symbol
)
1497 printf ("%s:", bfd_get_filename (archive_bfd
));
1498 printf ("%s:", bfd_get_filename (abfd
));
1503 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1505 if (filename_per_symbol
)
1508 printf ("%s:", bfd_get_filename (archive_bfd
));
1509 printf ("%s:", bfd_get_filename (abfd
));
1514 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1516 if (filename_per_symbol
)
1519 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1520 bfd_get_filename (abfd
));
1522 printf ("%s: ", bfd_get_filename (abfd
));
1526 /* Print a symbol value. */
1529 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1531 switch (print_width
)
1534 printf (print_format_string
, (unsigned long) val
);
1538 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1539 printf (print_format_string
, val
);
1541 /* We have a 64 bit value to print, but the host is only 32 bit. */
1542 if (print_radix
== 16)
1543 bfd_fprintf_vma (abfd
, stdout
, val
);
1549 s
= buf
+ sizeof buf
;
1553 *--s
= (val
% print_radix
) + '0';
1556 while ((buf
+ sizeof buf
- 1) - s
< 16)
1564 fatal (_("Print width has not been initialized (%d)"), print_width
);
1569 /* Print a line of information about a symbol. */
1572 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1574 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1576 if (print_width
== 64)
1582 /* Normally we print the value of the symbol. If we are printing the
1583 size or sorting by size then we print its size, except for the
1584 (weird) special case where both flags are defined, in which case we
1585 print both values. This conforms to documented behaviour. */
1586 if (sort_by_size
&& !print_size
)
1587 print_value (abfd
, SYM_SIZE (info
));
1589 print_value (abfd
, SYM_VALUE (info
));
1590 if (print_size
&& SYM_SIZE (info
))
1593 print_value (abfd
, SYM_SIZE (info
));
1597 printf (" %c", SYM_TYPE (info
));
1599 if (SYM_TYPE (info
) == '-')
1603 printf (other_format
, SYM_STAB_OTHER (info
));
1605 printf (desc_format
, SYM_STAB_DESC (info
));
1606 printf (" %5s", SYM_STAB_NAME (info
));
1608 print_symname (" %s", info
, NULL
, abfd
);
1612 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1614 print_symname ("%-20s|", info
, NULL
, abfd
);
1616 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1618 if (print_width
== 32)
1624 print_value (abfd
, SYM_VALUE (info
));
1626 printf ("| %c |", SYM_TYPE (info
));
1628 if (SYM_TYPE (info
) == '-')
1631 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1632 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1633 printf ("| |"); /* Line, Section. */
1637 /* Type, Size, Line, Section */
1640 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1641 else if (info
->coffinfo
)
1643 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1647 if (SYM_SIZE (info
))
1648 print_value (abfd
, SYM_SIZE (info
));
1651 if (print_width
== 32)
1658 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1659 else if (info
->coffinfo
)
1660 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1667 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1669 print_symname ("%s ", info
, NULL
, abfd
);
1670 printf ("%c ", SYM_TYPE (info
));
1672 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1676 print_value (abfd
, SYM_VALUE (info
));
1678 if (SYM_SIZE (info
))
1679 print_value (abfd
, SYM_SIZE (info
));
1684 main (int argc
, char **argv
)
1689 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1690 setlocale (LC_MESSAGES
, "");
1692 #if defined (HAVE_SETLOCALE)
1693 setlocale (LC_CTYPE
, "");
1694 setlocale (LC_COLLATE
, "");
1696 bindtextdomain (PACKAGE
, LOCALEDIR
);
1697 textdomain (PACKAGE
);
1699 program_name
= *argv
;
1700 xmalloc_set_program_name (program_name
);
1701 bfd_set_error_program_name (program_name
);
1702 #if BFD_SUPPORTS_PLUGINS
1703 bfd_plugin_set_program_name (program_name
);
1706 START_PROGRESS (program_name
, 0);
1708 expandargv (&argc
, &argv
);
1710 if (bfd_init () != BFD_INIT_MAGIC
)
1711 fatal (_("fatal error: libbfd ABI mismatch"));
1712 set_default_bfd_target ();
1714 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1715 long_options
, (int *) 0)) != EOF
)
1720 print_debug_syms
= 1;
1724 filename_per_symbol
= 1;
1726 case 'B': /* For MIPS compatibility. */
1727 set_output_format ("bsd");
1733 enum demangling_styles style
;
1735 style
= cplus_demangle_name_to_style (optarg
);
1736 if (style
== unknown_demangling
)
1737 fatal (_("unknown demangling style `%s'"),
1740 cplus_demangle_set_style (style
);
1743 case OPTION_RECURSE_LIMIT
:
1744 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1746 case OPTION_NO_RECURSE_LIMIT
:
1747 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1749 case OPTION_WITH_SYMBOL_VERSIONS
:
1750 /* Ignored for backward compatibility. */
1756 /* Ignored for HP/UX compatibility. */
1759 set_output_format (optarg
);
1773 sort_numerically
= 1;
1778 sort_numerically
= 0;
1781 case OPTION_SIZE_SORT
:
1783 sort_numerically
= 0;
1787 set_output_format ("posix");
1799 set_print_radix (optarg
);
1808 /* Ignored for (partial) AIX compatibility. On AIX, the
1809 argument has values 32, 64, or 32_64, and specifies that
1810 only 32-bit, only 64-bit, or both kinds of objects should
1811 be examined. The default is 32. So plain AIX nm on a
1812 library archive with both kinds of objects will ignore
1813 the 64-bit ones. For GNU nm, the default is and always
1814 has been -X 32_64, and other options are not supported. */
1815 if (strcmp (optarg
, "32_64") != 0)
1816 fatal (_("Only -X 32_64 is supported"));
1819 case OPTION_TARGET
: /* --target */
1823 case OPTION_PLUGIN
: /* --plugin */
1824 #if BFD_SUPPORTS_PLUGINS
1825 bfd_plugin_set_plugin (optarg
);
1827 fatal (_("sorry - this program has been built without plugin support\n"));
1831 case 0: /* A long option that just sets a flag. */
1840 print_version ("nm");
1842 if (sort_by_size
&& undefined_only
)
1844 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1845 non_fatal (_("will produce no output, since undefined symbols have no size."));
1849 /* OK, all options now parsed. If no filename specified, do a.out. */
1851 return !display_file ("a.out");
1855 if (argc
- optind
> 1)
1856 filename_per_file
= 1;
1858 /* We were given several filenames to do. */
1859 while (optind
< argc
)
1862 if (!display_file (argv
[optind
++]))
1866 END_PROGRESS (program_name
);