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])
425 (hidden
|| bfd_is_und_section (info
->elfinfo
->symbol
.section
)
432 print_symdef_entry (bfd
*abfd
)
434 symindex idx
= BFD_NO_MORE_SYMBOLS
;
436 bfd_boolean everprinted
= FALSE
;
438 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
439 idx
!= BFD_NO_MORE_SYMBOLS
;
440 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
445 printf (_("\nArchive index:\n"));
448 elt
= bfd_get_elt_at_index (abfd
, idx
);
450 bfd_fatal ("bfd_get_elt_at_index");
451 if (thesym
->name
!= (char *) NULL
)
453 print_symname ("%s", NULL
, thesym
->name
, abfd
);
454 printf (" in %s\n", bfd_get_filename (elt
));
460 /* True when we can report missing plugin error. */
461 bfd_boolean report_plugin_err
= TRUE
;
463 /* Choose which symbol entries to print;
464 compact them downward to get rid of the rest.
465 Return the number of symbols to be printed. */
468 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
469 long symcount
, unsigned int size
)
471 bfd_byte
*from
, *fromend
, *to
;
474 store
= bfd_make_empty_symbol (abfd
);
476 bfd_fatal (bfd_get_filename (abfd
));
478 from
= (bfd_byte
*) minisyms
;
479 fromend
= from
+ symcount
* size
;
480 to
= (bfd_byte
*) minisyms
;
482 for (; from
< fromend
; from
+= size
)
489 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
491 bfd_fatal (bfd_get_filename (abfd
));
493 if (sym
->name
[0] == '_'
494 && sym
->name
[1] == '_'
495 && strcmp (sym
->name
+ (sym
->name
[2] == '_'), "__gnu_lto_slim") == 0
496 && report_plugin_err
)
498 report_plugin_err
= FALSE
;
499 non_fatal (_("%s: plugin needed to handle lto object"),
500 bfd_get_filename (abfd
));
504 keep
= bfd_is_und_section (sym
->section
);
505 else if (external_only
)
506 /* PR binutls/12753: Unique symbols are global too. */
507 keep
= ((sym
->flags
& (BSF_GLOBAL
509 | BSF_GNU_UNIQUE
)) != 0
510 || bfd_is_und_section (sym
->section
)
511 || bfd_is_com_section (sym
->section
));
516 && ! print_debug_syms
517 && (sym
->flags
& BSF_DEBUGGING
) != 0)
522 && (bfd_is_abs_section (sym
->section
)
523 || bfd_is_und_section (sym
->section
)))
529 if (bfd_is_und_section (sym
->section
))
534 && bfd_is_target_special_symbol (abfd
, sym
)
535 && ! allow_special_symbols
)
541 memcpy (to
, from
, size
);
546 return (to
- (bfd_byte
*) minisyms
) / size
;
549 /* These globals are used to pass information into the sorting
551 static bfd
*sort_bfd
;
552 static bfd_boolean sort_dynamic
;
553 static asymbol
*sort_x
;
554 static asymbol
*sort_y
;
556 /* Symbol-sorting predicates */
557 #define valueof(x) ((x)->section->vma + (x)->value)
559 /* Numeric sorts. Undefined symbols are always considered "less than"
560 defined symbols with zero values. Common symbols are not treated
561 specially -- i.e., their sizes are used as their "values". */
564 non_numeric_forward (const void *P_x
, const void *P_y
)
569 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
570 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
571 if (x
== NULL
|| y
== NULL
)
572 bfd_fatal (bfd_get_filename (sort_bfd
));
574 xn
= bfd_asymbol_name (x
);
575 yn
= bfd_asymbol_name (y
);
583 /* Solaris 2.5 has a bug in strcoll.
584 strcoll returns invalid values when confronted with empty strings. */
590 return strcoll (xn
, yn
);
592 return strcmp (xn
, yn
);
597 non_numeric_reverse (const void *x
, const void *y
)
599 return - non_numeric_forward (x
, y
);
603 numeric_forward (const void *P_x
, const void *P_y
)
608 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
609 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
610 if (x
== NULL
|| y
== NULL
)
611 bfd_fatal (bfd_get_filename (sort_bfd
));
613 xs
= bfd_asymbol_section (x
);
614 ys
= bfd_asymbol_section (y
);
616 if (bfd_is_und_section (xs
))
618 if (! bfd_is_und_section (ys
))
621 else if (bfd_is_und_section (ys
))
623 else if (valueof (x
) != valueof (y
))
624 return valueof (x
) < valueof (y
) ? -1 : 1;
626 return non_numeric_forward (P_x
, P_y
);
630 numeric_reverse (const void *x
, const void *y
)
632 return - numeric_forward (x
, y
);
635 static int (*(sorters
[2][2])) (const void *, const void *) =
637 { non_numeric_forward
, non_numeric_reverse
},
638 { numeric_forward
, numeric_reverse
}
641 /* This sort routine is used by sort_symbols_by_size. It is similar
642 to numeric_forward, but when symbols have the same value it sorts
643 by section VMA. This simplifies the sort_symbols_by_size code
644 which handles symbols at the end of sections. Also, this routine
645 tries to sort file names before other symbols with the same value.
646 That will make the file name have a zero size, which will make
647 sort_symbols_by_size choose the non file name symbol, leading to
648 more meaningful output. For similar reasons, this code sorts
649 gnu_compiled_* and gcc2_compiled before other symbols with the same
653 size_forward1 (const void *P_x
, const void *P_y
)
661 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
662 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
663 if (x
== NULL
|| y
== NULL
)
664 bfd_fatal (bfd_get_filename (sort_bfd
));
666 xs
= bfd_asymbol_section (x
);
667 ys
= bfd_asymbol_section (y
);
669 if (bfd_is_und_section (xs
))
671 if (bfd_is_und_section (ys
))
674 if (valueof (x
) != valueof (y
))
675 return valueof (x
) < valueof (y
) ? -1 : 1;
677 if (xs
->vma
!= ys
->vma
)
678 return xs
->vma
< ys
->vma
? -1 : 1;
680 xn
= bfd_asymbol_name (x
);
681 yn
= bfd_asymbol_name (y
);
685 /* The symbols gnu_compiled and gcc2_compiled convey even less
686 information than the file name, so sort them out first. */
688 xf
= (strstr (xn
, "gnu_compiled") != NULL
689 || strstr (xn
, "gcc2_compiled") != NULL
);
690 yf
= (strstr (yn
, "gnu_compiled") != NULL
691 || strstr (yn
, "gcc2_compiled") != NULL
);
698 /* We use a heuristic for the file name. It may not work on non
699 Unix systems, but it doesn't really matter; the only difference
700 is precisely which symbol names get printed. */
702 #define file_symbol(s, sn, snl) \
703 (((s)->flags & BSF_FILE) != 0 \
705 && (sn)[(snl) - 2] == '.' \
706 && ((sn)[(snl) - 1] == 'o' \
707 || (sn)[(snl) - 1] == 'a')))
709 xf
= file_symbol (x
, xn
, xnl
);
710 yf
= file_symbol (y
, yn
, ynl
);
717 return non_numeric_forward (P_x
, P_y
);
720 /* This sort routine is used by sort_symbols_by_size. It is sorting
721 an array of size_sym structures into size order. */
724 size_forward2 (const void *P_x
, const void *P_y
)
726 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
727 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
729 if (x
->size
< y
->size
)
730 return reverse_sort
? 1 : -1;
731 else if (x
->size
> y
->size
)
732 return reverse_sort
? -1 : 1;
734 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
737 /* Sort the symbols by size. ELF provides a size but for other formats
738 we have to make a guess by assuming that the difference between the
739 address of a symbol and the address of the next higher symbol is the
743 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
744 long symcount
, unsigned int size
,
745 struct size_sym
**symsizesp
)
747 struct size_sym
*symsizes
;
748 bfd_byte
*from
, *fromend
;
750 asymbol
*store_sym
, *store_next
;
752 qsort (minisyms
, symcount
, size
, size_forward1
);
754 /* We are going to return a special set of symbols and sizes to
756 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
757 *symsizesp
= symsizes
;
759 /* Note that filter_symbols has already removed all absolute and
760 undefined symbols. Here we remove all symbols whose size winds
762 from
= (bfd_byte
*) minisyms
;
763 fromend
= from
+ symcount
* size
;
770 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
773 bfd_fatal (bfd_get_filename (abfd
));
776 for (; from
< fromend
; from
+= size
)
783 if (from
+ size
< fromend
)
785 next
= bfd_minisymbol_to_symbol (abfd
,
787 (const void *) (from
+ size
),
790 bfd_fatal (bfd_get_filename (abfd
));
795 sec
= bfd_asymbol_section (sym
);
797 /* Synthetic symbols don't have a full type set of data available, thus
798 we can't rely on that information for the symbol size. Ditto for
799 bfd/section.c:global_syms like *ABS*. */
800 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
801 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
802 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
803 else if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) == 0
804 && bfd_is_com_section (sec
))
808 if (from
+ size
< fromend
809 && sec
== bfd_asymbol_section (next
))
810 sz
= valueof (next
) - valueof (sym
);
812 sz
= (bfd_section_vma (sec
)
813 + bfd_section_size (sec
)
819 symsizes
->minisym
= (const void *) from
;
827 store_sym
= store_next
;
831 symcount
= symsizes
- *symsizesp
;
833 /* We must now sort again by size. */
834 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
839 /* This function is used to get the relocs for a particular section.
840 It is called via bfd_map_over_sections. */
843 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
845 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
849 if ((sec
->flags
& SEC_RELOC
) == 0)
851 *data
->relocs
= NULL
;
858 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
860 bfd_fatal (bfd_get_filename (abfd
));
862 *data
->relocs
= (arelent
**) xmalloc (relsize
);
863 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
865 if (*data
->relcount
< 0)
866 bfd_fatal (bfd_get_filename (abfd
));
874 /* Print a single symbol. */
877 print_symbol (bfd
* abfd
,
883 struct extended_symbol_info info
;
887 format
->print_symbol_filename (archive_bfd
, abfd
);
889 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
891 info
.sinfo
= &syminfo
;
893 /* Synthetic symbols do not have a full symbol type set of data available.
894 Nor do bfd/section.c:global_syms like *ABS*. */
895 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_SYNTHETIC
)) != 0)
898 info
.coffinfo
= NULL
;
902 info
.elfinfo
= elf_symbol_from (sym
);
903 info
.coffinfo
= coff_symbol_from (sym
);
906 format
->print_symbol_info (&info
, abfd
);
910 static asymbol
**syms
;
911 static long symcount
;
912 const char *filename
, *functionname
;
915 /* We need to get the canonical symbols in order to call
916 bfd_find_nearest_line. This is inefficient, but, then, you
917 don't have to use --line-numbers. */
918 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
927 symsize
= bfd_get_symtab_upper_bound (abfd
);
929 bfd_fatal (bfd_get_filename (abfd
));
930 syms
= (asymbol
**) xmalloc (symsize
);
931 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
933 bfd_fatal (bfd_get_filename (abfd
));
934 lineno_cache_bfd
= abfd
;
937 if (bfd_is_und_section (bfd_asymbol_section (sym
)))
939 static asection
**secs
;
940 static arelent
***relocs
;
941 static long *relcount
;
942 static unsigned int seccount
;
946 /* For an undefined symbol, we try to find a reloc for the
947 symbol, and print the line number of the reloc. */
948 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
950 for (i
= 0; i
< seccount
; i
++)
951 if (relocs
[i
] != NULL
)
963 struct get_relocs_info rinfo
;
965 seccount
= bfd_count_sections (abfd
);
967 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
968 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
969 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
972 rinfo
.relocs
= relocs
;
973 rinfo
.relcount
= relcount
;
975 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
976 lineno_cache_rel_bfd
= abfd
;
979 symname
= bfd_asymbol_name (sym
);
980 for (i
= 0; i
< seccount
; i
++)
984 for (j
= 0; j
< relcount
[i
]; j
++)
989 if (r
->sym_ptr_ptr
!= NULL
990 && (*r
->sym_ptr_ptr
)->section
== sym
->section
991 && (*r
->sym_ptr_ptr
)->value
== sym
->value
993 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
994 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
995 r
->address
, &filename
,
996 &functionname
, &lineno
)
999 /* We only print the first one we find. */
1000 printf ("\t%s:%u", filename
, lineno
);
1007 else if (bfd_asymbol_section (sym
)->owner
== abfd
)
1009 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1010 || bfd_find_nearest_line (abfd
, bfd_asymbol_section (sym
),
1011 syms
, sym
->value
, &filename
,
1012 &functionname
, &lineno
))
1015 printf ("\t%s:%u", filename
, lineno
);
1022 /* Print the symbols when sorting by size. */
1025 print_size_symbols (bfd
* abfd
,
1026 bfd_boolean is_dynamic
,
1027 struct size_sym
* symsizes
,
1032 struct size_sym
*from
;
1033 struct size_sym
*fromend
;
1035 store
= bfd_make_empty_symbol (abfd
);
1037 bfd_fatal (bfd_get_filename (abfd
));
1040 fromend
= from
+ symcount
;
1042 for (; from
< fromend
; from
++)
1046 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1048 bfd_fatal (bfd_get_filename (abfd
));
1050 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1055 /* Print the symbols of ABFD that are held in MINISYMS.
1057 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1059 SYMCOUNT is the number of symbols in MINISYMS.
1061 SIZE is the size of a symbol in MINISYMS. */
1064 print_symbols (bfd
* abfd
,
1065 bfd_boolean is_dynamic
,
1075 store
= bfd_make_empty_symbol (abfd
);
1077 bfd_fatal (bfd_get_filename (abfd
));
1079 from
= (bfd_byte
*) minisyms
;
1080 fromend
= from
+ symcount
* size
;
1082 for (; from
< fromend
; from
+= size
)
1086 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1088 bfd_fatal (bfd_get_filename (abfd
));
1090 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1094 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1097 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1102 struct size_sym
*symsizes
;
1103 asymbol
*synthsyms
= NULL
;
1107 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1109 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1114 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1117 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1119 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1123 bfd_fatal (bfd_get_filename (abfd
));
1128 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1132 if (show_synthetic
&& size
== sizeof (asymbol
*))
1134 asymbol
**static_syms
= NULL
;
1135 asymbol
**dyn_syms
= NULL
;
1136 long static_count
= 0;
1142 dyn_count
= symcount
;
1143 dyn_syms
= (asymbol
**) minisyms
;
1147 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1149 static_count
= symcount
;
1150 static_syms
= (asymbol
**) minisyms
;
1154 dyn_syms
= (asymbol
**) xmalloc (storage
);
1155 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1157 bfd_fatal (bfd_get_filename (abfd
));
1161 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1162 dyn_count
, dyn_syms
, &synthsyms
);
1163 if (synth_count
> 0)
1168 minisyms
= xrealloc (minisyms
,
1169 (symcount
+ synth_count
+ 1) * sizeof (*symp
));
1170 symp
= (asymbol
**) minisyms
+ symcount
;
1171 for (i
= 0; i
< synth_count
; i
++)
1172 *symp
++ = synthsyms
+ i
;
1174 symcount
+= synth_count
;
1176 if (!dynamic
&& dyn_syms
!= NULL
)
1180 /* lto_slim_object is set to false when a bfd is loaded with a compiler
1182 if (abfd
->lto_slim_object
)
1184 report_plugin_err
= FALSE
;
1185 non_fatal (_("%s: plugin needed to handle lto object"),
1186 bfd_get_filename (abfd
));
1189 /* Discard the symbols we don't want to print.
1190 It's OK to do this in place; we'll free the storage anyway
1191 (after printing). */
1193 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1199 sort_dynamic
= dynamic
;
1200 sort_x
= bfd_make_empty_symbol (abfd
);
1201 sort_y
= bfd_make_empty_symbol (abfd
);
1202 if (sort_x
== NULL
|| sort_y
== NULL
)
1203 bfd_fatal (bfd_get_filename (abfd
));
1206 qsort (minisyms
, symcount
, size
,
1207 sorters
[sort_numerically
][reverse_sort
]);
1209 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1214 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1216 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1224 /* Construct a formatting string for printing symbol values. */
1227 get_print_format (void)
1229 const char * padding
;
1230 if (print_format
== FORMAT_POSIX
)
1232 /* POSIX compatible output does not have any padding. */
1235 else if (print_width
== 32)
1239 else /* print_width == 64 */
1244 const char * length
= "l";
1245 if (print_width
== 64)
1247 #if BFD_HOST_64BIT_LONG
1249 #elif BFD_HOST_64BIT_LONG_LONG
1258 const char * radix
= NULL
;
1259 switch (print_radix
)
1261 case 8: radix
= "o"; break;
1262 case 10: radix
= "d"; break;
1263 case 16: radix
= "x"; break;
1266 return concat ("%", padding
, length
, radix
, NULL
);
1270 set_print_width (bfd
*file
)
1272 print_width
= bfd_get_arch_size (file
);
1274 if (print_width
== -1)
1277 Guess the target's bitsize based on its name.
1278 We assume here than any 64-bit format will include
1279 "64" somewhere in its name. The only known exception
1280 is the MMO object file format. */
1281 if (strstr (bfd_get_target (file
), "64") != NULL
1282 || strcmp (bfd_get_target (file
), "mmo") == 0)
1287 free ((char *) print_format_string
);
1288 print_format_string
= get_print_format ();
1292 display_archive (bfd
*file
)
1295 bfd
*last_arfile
= NULL
;
1298 format
->print_archive_filename (bfd_get_filename (file
));
1301 print_symdef_entry (file
);
1307 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1311 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1312 bfd_fatal (bfd_get_filename (file
));
1316 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1318 set_print_width (arfile
);
1319 format
->print_archive_member (bfd_get_filename (file
),
1320 bfd_get_filename (arfile
));
1321 display_rel_file (arfile
, file
);
1325 bfd_nonfatal (bfd_get_filename (arfile
));
1326 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1328 list_matching_formats (matching
);
1333 if (last_arfile
!= NULL
)
1335 bfd_close (last_arfile
);
1336 lineno_cache_bfd
= NULL
;
1337 lineno_cache_rel_bfd
= NULL
;
1338 if (arfile
== last_arfile
)
1341 last_arfile
= arfile
;
1344 if (last_arfile
!= NULL
)
1346 bfd_close (last_arfile
);
1347 lineno_cache_bfd
= NULL
;
1348 lineno_cache_rel_bfd
= NULL
;
1353 display_file (char *filename
)
1355 bfd_boolean retval
= TRUE
;
1359 if (get_file_size (filename
) < 1)
1362 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1365 bfd_nonfatal (filename
);
1369 /* If printing line numbers, decompress the debug sections. */
1371 file
->flags
|= BFD_DECOMPRESS
;
1373 if (bfd_check_format (file
, bfd_archive
))
1375 display_archive (file
);
1377 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1379 set_print_width (file
);
1380 format
->print_object_filename (filename
);
1381 display_rel_file (file
, NULL
);
1385 bfd_nonfatal (filename
);
1386 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1388 list_matching_formats (matching
);
1394 if (!bfd_close (file
))
1395 bfd_fatal (filename
);
1397 lineno_cache_bfd
= NULL
;
1398 lineno_cache_rel_bfd
= NULL
;
1403 /* The following 3 groups of functions are called unconditionally,
1404 once at the start of processing each file of the appropriate type.
1405 They should check `filename_per_file' and `filename_per_symbol',
1406 as appropriate for their output format, to determine whether to
1409 /* Print the name of an object file given on the command line. */
1412 print_object_filename_bsd (const char *filename
)
1414 if (filename_per_file
&& !filename_per_symbol
)
1415 printf ("\n%s:\n", filename
);
1419 print_object_filename_sysv (const char *filename
)
1422 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1424 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1425 if (print_width
== 32)
1427 Name Value Class Type Size Line Section\n\n"));
1430 Name Value Class Type Size Line Section\n\n"));
1434 print_object_filename_posix (const char *filename
)
1436 if (filename_per_file
&& !filename_per_symbol
)
1437 printf ("%s:\n", filename
);
1440 /* Print the name of an archive file given on the command line. */
1443 print_archive_filename_bsd (const char *filename
)
1445 if (filename_per_file
)
1446 printf ("\n%s:\n", filename
);
1450 print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED
)
1455 print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED
)
1459 /* Print the name of an archive member file. */
1462 print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED
,
1463 const char *filename
)
1465 if (!filename_per_symbol
)
1466 printf ("\n%s:\n", filename
);
1470 print_archive_member_sysv (const char *archive
, const char *filename
)
1473 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1475 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1476 if (print_width
== 32)
1478 Name Value Class Type Size Line Section\n\n"));
1481 Name Value Class Type Size Line Section\n\n"));
1485 print_archive_member_posix (const char *archive
, const char *filename
)
1487 if (!filename_per_symbol
)
1488 printf ("%s[%s]:\n", archive
, filename
);
1491 /* Print the name of the file (and archive, if there is one)
1492 containing a symbol. */
1495 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1497 if (filename_per_symbol
)
1500 printf ("%s:", bfd_get_filename (archive_bfd
));
1501 printf ("%s:", bfd_get_filename (abfd
));
1506 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1508 if (filename_per_symbol
)
1511 printf ("%s:", bfd_get_filename (archive_bfd
));
1512 printf ("%s:", bfd_get_filename (abfd
));
1517 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1519 if (filename_per_symbol
)
1522 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1523 bfd_get_filename (abfd
));
1525 printf ("%s: ", bfd_get_filename (abfd
));
1529 /* Print a symbol value. */
1532 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1534 switch (print_width
)
1537 printf (print_format_string
, (unsigned long) val
);
1541 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1542 printf (print_format_string
, val
);
1544 /* We have a 64 bit value to print, but the host is only 32 bit. */
1545 if (print_radix
== 16)
1546 bfd_fprintf_vma (abfd
, stdout
, val
);
1552 s
= buf
+ sizeof buf
;
1556 *--s
= (val
% print_radix
) + '0';
1559 while ((buf
+ sizeof buf
- 1) - s
< 16)
1567 fatal (_("Print width has not been initialized (%d)"), print_width
);
1572 /* Print a line of information about a symbol. */
1575 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1577 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1579 if (print_width
== 64)
1585 /* Normally we print the value of the symbol. If we are printing the
1586 size or sorting by size then we print its size, except for the
1587 (weird) special case where both flags are defined, in which case we
1588 print both values. This conforms to documented behaviour. */
1589 if (sort_by_size
&& !print_size
)
1590 print_value (abfd
, SYM_SIZE (info
));
1592 print_value (abfd
, SYM_VALUE (info
));
1593 if (print_size
&& SYM_SIZE (info
))
1596 print_value (abfd
, SYM_SIZE (info
));
1600 printf (" %c", SYM_TYPE (info
));
1602 if (SYM_TYPE (info
) == '-')
1606 printf (other_format
, SYM_STAB_OTHER (info
));
1608 printf (desc_format
, SYM_STAB_DESC (info
));
1609 printf (" %5s", SYM_STAB_NAME (info
));
1611 print_symname (" %s", info
, NULL
, abfd
);
1615 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1617 print_symname ("%-20s|", info
, NULL
, abfd
);
1619 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1621 if (print_width
== 32)
1627 print_value (abfd
, SYM_VALUE (info
));
1629 printf ("| %c |", SYM_TYPE (info
));
1631 if (SYM_TYPE (info
) == '-')
1634 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1635 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1636 printf ("| |"); /* Line, Section. */
1640 /* Type, Size, Line, Section */
1643 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1644 else if (info
->coffinfo
)
1646 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1650 if (SYM_SIZE (info
))
1651 print_value (abfd
, SYM_SIZE (info
));
1654 if (print_width
== 32)
1661 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1662 else if (info
->coffinfo
)
1663 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1670 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1672 print_symname ("%s ", info
, NULL
, abfd
);
1673 printf ("%c ", SYM_TYPE (info
));
1675 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1679 print_value (abfd
, SYM_VALUE (info
));
1681 if (SYM_SIZE (info
))
1682 print_value (abfd
, SYM_SIZE (info
));
1687 main (int argc
, char **argv
)
1692 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1693 setlocale (LC_MESSAGES
, "");
1695 #if defined (HAVE_SETLOCALE)
1696 setlocale (LC_CTYPE
, "");
1697 setlocale (LC_COLLATE
, "");
1699 bindtextdomain (PACKAGE
, LOCALEDIR
);
1700 textdomain (PACKAGE
);
1702 program_name
= *argv
;
1703 xmalloc_set_program_name (program_name
);
1704 bfd_set_error_program_name (program_name
);
1705 #if BFD_SUPPORTS_PLUGINS
1706 bfd_plugin_set_program_name (program_name
);
1709 START_PROGRESS (program_name
, 0);
1711 expandargv (&argc
, &argv
);
1713 if (bfd_init () != BFD_INIT_MAGIC
)
1714 fatal (_("fatal error: libbfd ABI mismatch"));
1715 set_default_bfd_target ();
1717 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1718 long_options
, (int *) 0)) != EOF
)
1723 print_debug_syms
= 1;
1727 filename_per_symbol
= 1;
1729 case 'B': /* For MIPS compatibility. */
1730 set_output_format ("bsd");
1736 enum demangling_styles style
;
1738 style
= cplus_demangle_name_to_style (optarg
);
1739 if (style
== unknown_demangling
)
1740 fatal (_("unknown demangling style `%s'"),
1743 cplus_demangle_set_style (style
);
1746 case OPTION_RECURSE_LIMIT
:
1747 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
1749 case OPTION_NO_RECURSE_LIMIT
:
1750 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
1752 case OPTION_WITH_SYMBOL_VERSIONS
:
1753 /* Ignored for backward compatibility. */
1759 /* Ignored for HP/UX compatibility. */
1762 set_output_format (optarg
);
1776 sort_numerically
= 1;
1781 sort_numerically
= 0;
1784 case OPTION_SIZE_SORT
:
1786 sort_numerically
= 0;
1790 set_output_format ("posix");
1802 set_print_radix (optarg
);
1811 /* Ignored for (partial) AIX compatibility. On AIX, the
1812 argument has values 32, 64, or 32_64, and specifies that
1813 only 32-bit, only 64-bit, or both kinds of objects should
1814 be examined. The default is 32. So plain AIX nm on a
1815 library archive with both kinds of objects will ignore
1816 the 64-bit ones. For GNU nm, the default is and always
1817 has been -X 32_64, and other options are not supported. */
1818 if (strcmp (optarg
, "32_64") != 0)
1819 fatal (_("Only -X 32_64 is supported"));
1822 case OPTION_TARGET
: /* --target */
1826 case OPTION_PLUGIN
: /* --plugin */
1827 #if BFD_SUPPORTS_PLUGINS
1828 bfd_plugin_set_plugin (optarg
);
1830 fatal (_("sorry - this program has been built without plugin support\n"));
1834 case 0: /* A long option that just sets a flag. */
1843 print_version ("nm");
1845 if (sort_by_size
&& undefined_only
)
1847 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1848 non_fatal (_("will produce no output, since undefined symbols have no size."));
1852 /* OK, all options now parsed. If no filename specified, do a.out. */
1854 return !display_file ("a.out");
1858 if (argc
- optind
> 1)
1859 filename_per_file
= 1;
1861 /* We were given several filenames to do. */
1862 while (optind
< argc
)
1865 if (!display_file (argv
[optind
++]))
1869 END_PROGRESS (program_name
);