1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright (C) 1991-2016 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 (char *);
81 static void print_object_filename_sysv (char *);
82 static void print_object_filename_posix (char *);
83 static void print_archive_filename_bsd (char *);
84 static void print_archive_filename_sysv (char *);
85 static void print_archive_filename_posix (char *);
86 static void print_archive_member_bsd (char *, const char *);
87 static void print_archive_member_sysv (char *, const char *);
88 static void print_archive_member_posix (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
) (char *);
103 /* Print the name of an archive file given on the command line. */
104 void (*print_archive_filename
) (char *);
106 /* Print the name of an archive member file. */
107 void (*print_archive_member
) (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
];
145 /* Command options. */
147 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
148 static int external_only
= 0; /* Print external symbols only. */
149 static int defined_only
= 0; /* Print defined symbols only. */
150 static int no_sort
= 0; /* Don't sort; print syms in order found. */
151 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
152 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
153 static int print_size
= 0; /* Print size of defined symbols. */
154 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
155 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
156 static int sort_by_size
= 0; /* Sort by size of symbol. */
157 static int undefined_only
= 0; /* Print undefined symbols only. */
158 static int dynamic
= 0; /* Print dynamic symbols. */
159 static int show_version
= 0; /* Show the version number. */
160 static int show_stats
= 0; /* Show statistics. */
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. */
164 static int with_symbol_versions
= 0; /* Include symbol version information in the output. */
166 /* When to print the names of files. Not mutually exclusive in SYSV format. */
167 static int filename_per_file
= 0; /* Once per file, on its own line. */
168 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
170 /* Print formats for printing a symbol value. */
171 static char value_format_32bit
[] = "%08lx";
172 #if BFD_HOST_64BIT_LONG
173 static char value_format_64bit
[] = "%016lx";
174 #elif BFD_HOST_64BIT_LONG_LONG
176 static char value_format_64bit
[] = "%016llx";
178 static char value_format_64bit
[] = "%016I64x";
181 static int print_width
= 0;
182 static int print_radix
= 16;
183 /* Print formats for printing stab info. */
184 static char other_format
[] = "%02x";
185 static char desc_format
[] = "%04x";
187 static char *target
= NULL
;
188 #if BFD_SUPPORTS_PLUGINS
189 static const char *plugin_target
= "plugin";
191 static const char *plugin_target
= NULL
;
194 /* Used to cache the line numbers for a BFD. */
195 static bfd
*lineno_cache_bfd
;
196 static bfd
*lineno_cache_rel_bfd
;
198 #define OPTION_TARGET 200
199 #define OPTION_PLUGIN (OPTION_TARGET + 1)
200 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
202 static struct option long_options
[] =
204 {"debug-syms", no_argument
, &print_debug_syms
, 1},
205 {"demangle", optional_argument
, 0, 'C'},
206 {"dynamic", no_argument
, &dynamic
, 1},
207 {"extern-only", no_argument
, &external_only
, 1},
208 {"format", required_argument
, 0, 'f'},
209 {"help", no_argument
, 0, 'h'},
210 {"line-numbers", no_argument
, 0, 'l'},
211 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
212 {"no-demangle", no_argument
, &do_demangle
, 0},
213 {"no-sort", no_argument
, 0, 'p'},
214 {"numeric-sort", no_argument
, 0, 'n'},
215 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
216 {"portability", no_argument
, 0, 'P'},
217 {"print-armap", no_argument
, &print_armap
, 1},
218 {"print-file-name", no_argument
, 0, 'o'},
219 {"print-size", no_argument
, 0, 'S'},
220 {"radix", required_argument
, 0, 't'},
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 {"stats", no_argument
, &show_stats
, 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 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
251 --defined-only Display only defined symbols\n\
253 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
254 `sysv' or `posix'. The default is `bsd'\n\
255 -g, --extern-only Display only external symbols\n\
256 -l, --line-numbers Use debugging information to find a filename and\n\
257 line number for each symbol\n\
258 -n, --numeric-sort Sort symbols numerically by address\n\
260 -p, --no-sort Do not sort the symbols\n\
261 -P, --portability Same as --format=posix\n\
262 -r, --reverse-sort Reverse the sense of the sort\n"));
263 #if BFD_SUPPORTS_PLUGINS
264 fprintf (stream
, _("\
265 --plugin NAME Load the specified plugin\n"));
267 fprintf (stream
, _("\
268 -S, --print-size Print size of defined symbols\n\
269 -s, --print-armap Include index for symbols from archive members\n\
270 --size-sort Sort symbols by size\n\
271 --special-syms Include special symbols in the output\n\
272 --synthetic Display synthetic symbols as well\n\
273 -t, --radix=RADIX Use RADIX for printing symbol values\n\
274 --target=BFDNAME Specify the target object format as BFDNAME\n\
275 -u, --undefined-only Display only undefined symbols\n\
276 --with-symbol-versions Display version strings after symbol names\n\
277 -X 32_64 (ignored)\n\
278 @FILE Read options from FILE\n\
279 -h, --help Display this information\n\
280 -V, --version Display this program's version number\n\
282 list_supported_targets (program_name
, stream
);
283 if (REPORT_BUGS_TO
[0] && status
== 0)
284 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
288 /* Set the radix for the symbol value and size according to RADIX. */
291 set_print_radix (char *radix
)
303 value_format_32bit
[4] = *radix
;
304 #if BFD_HOST_64BIT_LONG
305 value_format_64bit
[5] = *radix
;
306 #elif BFD_HOST_64BIT_LONG_LONG
308 value_format_64bit
[6] = *radix
;
310 value_format_64bit
[7] = *radix
;
313 other_format
[3] = desc_format
[3] = *radix
;
316 fatal (_("%s: invalid radix"), radix
);
321 set_output_format (char *f
)
340 fatal (_("%s: invalid output format"), f
);
342 format
= &formats
[i
];
346 get_elf_symbol_type (unsigned int type
)
353 case STT_NOTYPE
: return "NOTYPE";
354 case STT_OBJECT
: return "OBJECT";
355 case STT_FUNC
: return "FUNC";
356 case STT_SECTION
: return "SECTION";
357 case STT_FILE
: return "FILE";
358 case STT_COMMON
: return "COMMON";
359 case STT_TLS
: return "TLS";
363 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
364 n
= asprintf (&bufp
, _("<processor specific>: %d"), type
);
365 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
366 n
= asprintf (&bufp
, _("<OS specific>: %d"), type
);
368 n
= asprintf (&bufp
, _("<unknown>: %d"), type
);
370 fatal ("%s", xstrerror (errno
));
375 get_coff_symbol_type (const struct internal_syment
*sym
)
380 switch (sym
->n_sclass
)
382 case C_BLOCK
: return "Block";
383 case C_FILE
: return "File";
384 case C_LINE
: return "Line";
390 switch (DTYPE(sym
->n_type
))
392 case DT_FCN
: return "Function";
393 case DT_PTR
: return "Pointer";
394 case DT_ARY
: return "Array";
398 n
= asprintf (&bufp
, _("<unknown>: %d/%d"), sym
->n_sclass
, sym
->n_type
);
400 fatal ("%s", xstrerror (errno
));
404 /* Print symbol name NAME, read from ABFD, with printf format FORM,
405 demangling it if requested. */
408 print_symname (const char *form
, const char *name
, bfd
*abfd
)
410 if (do_demangle
&& *name
)
412 char *res
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
426 print_symdef_entry (bfd
*abfd
)
428 symindex idx
= BFD_NO_MORE_SYMBOLS
;
430 bfd_boolean everprinted
= FALSE
;
432 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
433 idx
!= BFD_NO_MORE_SYMBOLS
;
434 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
439 printf (_("\nArchive index:\n"));
442 elt
= bfd_get_elt_at_index (abfd
, idx
);
444 bfd_fatal ("bfd_get_elt_at_index");
445 if (thesym
->name
!= (char *) NULL
)
447 print_symname ("%s", thesym
->name
, abfd
);
448 printf (" in %s\n", bfd_get_filename (elt
));
453 /* Choose which symbol entries to print;
454 compact them downward to get rid of the rest.
455 Return the number of symbols to be printed. */
458 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
459 long symcount
, unsigned int size
)
461 bfd_byte
*from
, *fromend
, *to
;
464 store
= bfd_make_empty_symbol (abfd
);
466 bfd_fatal (bfd_get_filename (abfd
));
468 from
= (bfd_byte
*) minisyms
;
469 fromend
= from
+ symcount
* size
;
470 to
= (bfd_byte
*) minisyms
;
472 for (; from
< fromend
; from
+= size
)
479 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
481 bfd_fatal (bfd_get_filename (abfd
));
483 if (strcmp (sym
->name
, "__gnu_lto_slim") == 0)
484 non_fatal (_("%s: plugin needed to handle lto object"),
485 bfd_get_filename (abfd
));
488 keep
= bfd_is_und_section (sym
->section
);
489 else if (external_only
)
490 /* PR binutls/12753: Unique symbols are global too. */
491 keep
= ((sym
->flags
& (BSF_GLOBAL
493 | BSF_GNU_UNIQUE
)) != 0
494 || bfd_is_und_section (sym
->section
)
495 || bfd_is_com_section (sym
->section
));
500 && ! print_debug_syms
501 && (sym
->flags
& BSF_DEBUGGING
) != 0)
506 && (bfd_is_abs_section (sym
->section
)
507 || bfd_is_und_section (sym
->section
)))
513 if (bfd_is_und_section (sym
->section
))
518 && bfd_is_target_special_symbol (abfd
, sym
)
519 && ! allow_special_symbols
)
525 memcpy (to
, from
, size
);
530 return (to
- (bfd_byte
*) minisyms
) / size
;
533 /* These globals are used to pass information into the sorting
535 static bfd
*sort_bfd
;
536 static bfd_boolean sort_dynamic
;
537 static asymbol
*sort_x
;
538 static asymbol
*sort_y
;
540 /* Symbol-sorting predicates */
541 #define valueof(x) ((x)->section->vma + (x)->value)
543 /* Numeric sorts. Undefined symbols are always considered "less than"
544 defined symbols with zero values. Common symbols are not treated
545 specially -- i.e., their sizes are used as their "values". */
548 non_numeric_forward (const void *P_x
, const void *P_y
)
553 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
554 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
555 if (x
== NULL
|| y
== NULL
)
556 bfd_fatal (bfd_get_filename (sort_bfd
));
558 xn
= bfd_asymbol_name (x
);
559 yn
= bfd_asymbol_name (y
);
567 /* Solaris 2.5 has a bug in strcoll.
568 strcoll returns invalid values when confronted with empty strings. */
574 return strcoll (xn
, yn
);
576 return strcmp (xn
, yn
);
581 non_numeric_reverse (const void *x
, const void *y
)
583 return - non_numeric_forward (x
, y
);
587 numeric_forward (const void *P_x
, const void *P_y
)
592 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
593 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
594 if (x
== NULL
|| y
== NULL
)
595 bfd_fatal (bfd_get_filename (sort_bfd
));
597 xs
= bfd_get_section (x
);
598 ys
= bfd_get_section (y
);
600 if (bfd_is_und_section (xs
))
602 if (! bfd_is_und_section (ys
))
605 else if (bfd_is_und_section (ys
))
607 else if (valueof (x
) != valueof (y
))
608 return valueof (x
) < valueof (y
) ? -1 : 1;
610 return non_numeric_forward (P_x
, P_y
);
614 numeric_reverse (const void *x
, const void *y
)
616 return - numeric_forward (x
, y
);
619 static int (*(sorters
[2][2])) (const void *, const void *) =
621 { non_numeric_forward
, non_numeric_reverse
},
622 { numeric_forward
, numeric_reverse
}
625 /* This sort routine is used by sort_symbols_by_size. It is similar
626 to numeric_forward, but when symbols have the same value it sorts
627 by section VMA. This simplifies the sort_symbols_by_size code
628 which handles symbols at the end of sections. Also, this routine
629 tries to sort file names before other symbols with the same value.
630 That will make the file name have a zero size, which will make
631 sort_symbols_by_size choose the non file name symbol, leading to
632 more meaningful output. For similar reasons, this code sorts
633 gnu_compiled_* and gcc2_compiled before other symbols with the same
637 size_forward1 (const void *P_x
, const void *P_y
)
645 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
646 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
647 if (x
== NULL
|| y
== NULL
)
648 bfd_fatal (bfd_get_filename (sort_bfd
));
650 xs
= bfd_get_section (x
);
651 ys
= bfd_get_section (y
);
653 if (bfd_is_und_section (xs
))
655 if (bfd_is_und_section (ys
))
658 if (valueof (x
) != valueof (y
))
659 return valueof (x
) < valueof (y
) ? -1 : 1;
661 if (xs
->vma
!= ys
->vma
)
662 return xs
->vma
< ys
->vma
? -1 : 1;
664 xn
= bfd_asymbol_name (x
);
665 yn
= bfd_asymbol_name (y
);
669 /* The symbols gnu_compiled and gcc2_compiled convey even less
670 information than the file name, so sort them out first. */
672 xf
= (strstr (xn
, "gnu_compiled") != NULL
673 || strstr (xn
, "gcc2_compiled") != NULL
);
674 yf
= (strstr (yn
, "gnu_compiled") != NULL
675 || strstr (yn
, "gcc2_compiled") != NULL
);
682 /* We use a heuristic for the file name. It may not work on non
683 Unix systems, but it doesn't really matter; the only difference
684 is precisely which symbol names get printed. */
686 #define file_symbol(s, sn, snl) \
687 (((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_get_section (sym
);
780 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
781 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
782 else if (bfd_is_com_section (sec
))
786 if (from
+ size
< fromend
787 && sec
== bfd_get_section (next
))
788 sz
= valueof (next
) - valueof (sym
);
790 sz
= (bfd_get_section_vma (abfd
, sec
)
791 + bfd_section_size (abfd
, sec
)
797 symsizes
->minisym
= (const void *) from
;
805 store_sym
= store_next
;
809 symcount
= symsizes
- *symsizesp
;
811 /* We must now sort again by size. */
812 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
817 /* This function is used to get the relocs for a particular section.
818 It is called via bfd_map_over_sections. */
821 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
823 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
827 if ((sec
->flags
& SEC_RELOC
) == 0)
829 *data
->relocs
= NULL
;
836 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
838 bfd_fatal (bfd_get_filename (abfd
));
840 *data
->relocs
= (arelent
**) xmalloc (relsize
);
841 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
843 if (*data
->relcount
< 0)
844 bfd_fatal (bfd_get_filename (abfd
));
852 /* Print a single symbol. */
855 print_symbol (bfd
* abfd
,
861 struct extended_symbol_info info
;
865 format
->print_symbol_filename (archive_bfd
, abfd
);
867 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
869 info
.sinfo
= &syminfo
;
871 /* Synthetic symbols do not have a full symbol type set of data available. */
872 if ((sym
->flags
& BSF_SYNTHETIC
) != 0)
875 info
.coffinfo
= NULL
;
879 info
.elfinfo
= elf_symbol_from (abfd
, sym
);
880 info
.coffinfo
= coff_symbol_from (sym
);
883 format
->print_symbol_info (&info
, abfd
);
885 if (with_symbol_versions
)
887 const char * version_string
= NULL
;
888 bfd_boolean hidden
= FALSE
;
890 if ((sym
->flags
& BSF_SYNTHETIC
) == 0)
891 version_string
= bfd_get_symbol_version_string (abfd
, sym
, &hidden
);
893 if (bfd_is_und_section (bfd_get_section (sym
)))
896 if (version_string
&& *version_string
!= '\0')
897 printf (hidden
? "@%s" : "@@%s", version_string
);
902 static asymbol
**syms
;
903 static long symcount
;
904 const char *filename
, *functionname
;
907 /* We need to get the canonical symbols in order to call
908 bfd_find_nearest_line. This is inefficient, but, then, you
909 don't have to use --line-numbers. */
910 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
919 symsize
= bfd_get_symtab_upper_bound (abfd
);
921 bfd_fatal (bfd_get_filename (abfd
));
922 syms
= (asymbol
**) xmalloc (symsize
);
923 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
925 bfd_fatal (bfd_get_filename (abfd
));
926 lineno_cache_bfd
= abfd
;
929 if (bfd_is_und_section (bfd_get_section (sym
)))
931 static asection
**secs
;
932 static arelent
***relocs
;
933 static long *relcount
;
934 static unsigned int seccount
;
938 /* For an undefined symbol, we try to find a reloc for the
939 symbol, and print the line number of the reloc. */
940 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
942 for (i
= 0; i
< seccount
; i
++)
943 if (relocs
[i
] != NULL
)
955 struct get_relocs_info rinfo
;
957 seccount
= bfd_count_sections (abfd
);
959 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
960 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
961 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
964 rinfo
.relocs
= relocs
;
965 rinfo
.relcount
= relcount
;
967 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
968 lineno_cache_rel_bfd
= abfd
;
971 symname
= bfd_asymbol_name (sym
);
972 for (i
= 0; i
< seccount
; i
++)
976 for (j
= 0; j
< relcount
[i
]; j
++)
981 if (r
->sym_ptr_ptr
!= NULL
982 && (*r
->sym_ptr_ptr
)->section
== sym
->section
983 && (*r
->sym_ptr_ptr
)->value
== sym
->value
985 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
986 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
987 r
->address
, &filename
,
988 &functionname
, &lineno
)
991 /* We only print the first one we find. */
992 printf ("\t%s:%u", filename
, lineno
);
999 else if (bfd_get_section (sym
)->owner
== abfd
)
1001 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
1002 || bfd_find_nearest_line (abfd
, bfd_get_section (sym
),
1003 syms
, sym
->value
, &filename
,
1004 &functionname
, &lineno
))
1007 printf ("\t%s:%u", filename
, lineno
);
1014 /* Print the symbols when sorting by size. */
1017 print_size_symbols (bfd
* abfd
,
1018 bfd_boolean is_dynamic
,
1019 struct size_sym
* symsizes
,
1024 struct size_sym
*from
;
1025 struct size_sym
*fromend
;
1027 store
= bfd_make_empty_symbol (abfd
);
1029 bfd_fatal (bfd_get_filename (abfd
));
1032 fromend
= from
+ symcount
;
1034 for (; from
< fromend
; from
++)
1038 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1040 bfd_fatal (bfd_get_filename (abfd
));
1042 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
1047 /* Print the symbols of ABFD that are held in MINISYMS.
1049 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1051 SYMCOUNT is the number of symbols in MINISYMS.
1053 SIZE is the size of a symbol in MINISYMS. */
1056 print_symbols (bfd
* abfd
,
1057 bfd_boolean is_dynamic
,
1067 store
= bfd_make_empty_symbol (abfd
);
1069 bfd_fatal (bfd_get_filename (abfd
));
1071 from
= (bfd_byte
*) minisyms
;
1072 fromend
= from
+ symcount
* size
;
1074 for (; from
< fromend
; from
+= size
)
1078 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1080 bfd_fatal (bfd_get_filename (abfd
));
1082 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
1086 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1089 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1094 struct size_sym
*symsizes
;
1098 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1100 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1105 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1108 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1110 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1114 bfd_fatal (bfd_get_filename (abfd
));
1119 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1123 if (show_synthetic
&& size
== sizeof (asymbol
*))
1126 asymbol
**static_syms
= NULL
;
1127 asymbol
**dyn_syms
= NULL
;
1128 long static_count
= 0;
1134 dyn_count
= symcount
;
1135 dyn_syms
= (asymbol
**) minisyms
;
1139 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1141 static_count
= symcount
;
1142 static_syms
= (asymbol
**) minisyms
;
1146 dyn_syms
= (asymbol
**) xmalloc (storage
);
1147 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1149 bfd_fatal (bfd_get_filename (abfd
));
1153 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1154 dyn_count
, dyn_syms
, &synthsyms
);
1155 if (synth_count
> 0)
1161 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1162 symp
= (asymbol
**) new_mini
;
1163 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1165 for (i
= 0; i
< synth_count
; i
++)
1166 *symp
++ = synthsyms
+ i
;
1168 minisyms
= new_mini
;
1169 symcount
+= synth_count
;
1173 /* Discard the symbols we don't want to print.
1174 It's OK to do this in place; we'll free the storage anyway
1175 (after printing). */
1177 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1183 sort_dynamic
= dynamic
;
1184 sort_x
= bfd_make_empty_symbol (abfd
);
1185 sort_y
= bfd_make_empty_symbol (abfd
);
1186 if (sort_x
== NULL
|| sort_y
== NULL
)
1187 bfd_fatal (bfd_get_filename (abfd
));
1190 qsort (minisyms
, symcount
, size
,
1191 sorters
[sort_numerically
][reverse_sort
]);
1193 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1198 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1200 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1207 set_print_width (bfd
*file
)
1209 print_width
= bfd_get_arch_size (file
);
1211 if (print_width
== -1)
1214 Guess the target's bitsize based on its name.
1215 We assume here than any 64-bit format will include
1216 "64" somewhere in its name. The only known exception
1217 is the MMO object file format. */
1218 if (strstr (bfd_get_target (file
), "64") != NULL
1219 || strcmp (bfd_get_target (file
), "mmo") == 0)
1227 display_archive (bfd
*file
)
1230 bfd
*last_arfile
= NULL
;
1233 format
->print_archive_filename (bfd_get_filename (file
));
1236 print_symdef_entry (file
);
1242 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1246 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1247 bfd_fatal (bfd_get_filename (file
));
1251 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1253 set_print_width (arfile
);
1254 format
->print_archive_member (bfd_get_filename (file
),
1255 bfd_get_filename (arfile
));
1256 display_rel_file (arfile
, file
);
1260 bfd_nonfatal (bfd_get_filename (arfile
));
1261 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1263 list_matching_formats (matching
);
1268 if (last_arfile
!= NULL
)
1270 bfd_close (last_arfile
);
1271 lineno_cache_bfd
= NULL
;
1272 lineno_cache_rel_bfd
= NULL
;
1273 if (arfile
== last_arfile
)
1276 last_arfile
= arfile
;
1279 if (last_arfile
!= NULL
)
1281 bfd_close (last_arfile
);
1282 lineno_cache_bfd
= NULL
;
1283 lineno_cache_rel_bfd
= NULL
;
1288 display_file (char *filename
)
1290 bfd_boolean retval
= TRUE
;
1294 if (get_file_size (filename
) < 1)
1297 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1300 bfd_nonfatal (filename
);
1304 /* If printing line numbers, decompress the debug sections. */
1306 file
->flags
|= BFD_DECOMPRESS
;
1308 if (bfd_check_format (file
, bfd_archive
))
1310 display_archive (file
);
1312 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1314 set_print_width (file
);
1315 format
->print_object_filename (filename
);
1316 display_rel_file (file
, NULL
);
1320 bfd_nonfatal (filename
);
1321 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1323 list_matching_formats (matching
);
1329 if (!bfd_close (file
))
1330 bfd_fatal (filename
);
1332 lineno_cache_bfd
= NULL
;
1333 lineno_cache_rel_bfd
= NULL
;
1338 /* The following 3 groups of functions are called unconditionally,
1339 once at the start of processing each file of the appropriate type.
1340 They should check `filename_per_file' and `filename_per_symbol',
1341 as appropriate for their output format, to determine whether to
1344 /* Print the name of an object file given on the command line. */
1347 print_object_filename_bsd (char *filename
)
1349 if (filename_per_file
&& !filename_per_symbol
)
1350 printf ("\n%s:\n", filename
);
1354 print_object_filename_sysv (char *filename
)
1357 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1359 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1360 if (print_width
== 32)
1362 Name Value Class Type Size Line Section\n\n"));
1365 Name Value Class Type Size Line Section\n\n"));
1369 print_object_filename_posix (char *filename
)
1371 if (filename_per_file
&& !filename_per_symbol
)
1372 printf ("%s:\n", filename
);
1375 /* Print the name of an archive file given on the command line. */
1378 print_archive_filename_bsd (char *filename
)
1380 if (filename_per_file
)
1381 printf ("\n%s:\n", filename
);
1385 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1390 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1394 /* Print the name of an archive member file. */
1397 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1398 const char *filename
)
1400 if (!filename_per_symbol
)
1401 printf ("\n%s:\n", filename
);
1405 print_archive_member_sysv (char *archive
, const char *filename
)
1408 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1410 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1411 if (print_width
== 32)
1413 Name Value Class Type Size Line Section\n\n"));
1416 Name Value Class Type Size Line Section\n\n"));
1420 print_archive_member_posix (char *archive
, const char *filename
)
1422 if (!filename_per_symbol
)
1423 printf ("%s[%s]:\n", archive
, filename
);
1426 /* Print the name of the file (and archive, if there is one)
1427 containing a symbol. */
1430 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1432 if (filename_per_symbol
)
1435 printf ("%s:", bfd_get_filename (archive_bfd
));
1436 printf ("%s:", bfd_get_filename (abfd
));
1441 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1443 if (filename_per_symbol
)
1446 printf ("%s:", bfd_get_filename (archive_bfd
));
1447 printf ("%s:", bfd_get_filename (abfd
));
1452 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1454 if (filename_per_symbol
)
1457 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1458 bfd_get_filename (abfd
));
1460 printf ("%s: ", bfd_get_filename (abfd
));
1464 /* Print a symbol value. */
1467 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1469 switch (print_width
)
1472 printf (value_format_32bit
, (unsigned long) val
);
1476 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1477 printf (value_format_64bit
, val
);
1479 /* We have a 64 bit value to print, but the host is only 32 bit. */
1480 if (print_radix
== 16)
1481 bfd_fprintf_vma (abfd
, stdout
, val
);
1487 s
= buf
+ sizeof buf
;
1491 *--s
= (val
% print_radix
) + '0';
1494 while ((buf
+ sizeof buf
- 1) - s
< 16)
1502 fatal (_("Print width has not been initialized (%d)"), print_width
);
1507 /* Print a line of information about a symbol. */
1510 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1512 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1514 if (print_width
== 64)
1520 /* Normally we print the value of the symbol. If we are printing the
1521 size or sorting by size then we print its size, except for the
1522 (weird) special case where both flags are defined, in which case we
1523 print both values. This conforms to documented behaviour. */
1524 if (sort_by_size
&& !print_size
)
1525 print_value (abfd
, SYM_SIZE (info
));
1527 print_value (abfd
, SYM_VALUE (info
));
1528 if (print_size
&& SYM_SIZE (info
))
1531 print_value (abfd
, SYM_SIZE (info
));
1535 printf (" %c", SYM_TYPE (info
));
1537 if (SYM_TYPE (info
) == '-')
1541 printf (other_format
, SYM_STAB_OTHER (info
));
1543 printf (desc_format
, SYM_STAB_DESC (info
));
1544 printf (" %5s", SYM_STAB_NAME (info
));
1546 print_symname (" %s", SYM_NAME (info
), abfd
);
1550 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1552 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1554 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1556 if (print_width
== 32)
1562 print_value (abfd
, SYM_VALUE (info
));
1564 printf ("| %c |", SYM_TYPE (info
));
1566 if (SYM_TYPE (info
) == '-')
1569 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1570 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1571 printf ("| |"); /* Line, Section. */
1575 /* Type, Size, Line, Section */
1578 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1579 else if (info
->coffinfo
)
1581 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1585 if (SYM_SIZE (info
))
1586 print_value (abfd
, SYM_SIZE (info
));
1589 if (print_width
== 32)
1596 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1597 else if (info
->coffinfo
)
1598 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1605 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1607 print_symname ("%s ", SYM_NAME (info
), abfd
);
1608 printf ("%c ", SYM_TYPE (info
));
1610 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1614 print_value (abfd
, SYM_VALUE (info
));
1616 if (SYM_SIZE (info
))
1617 print_value (abfd
, SYM_SIZE (info
));
1622 main (int argc
, char **argv
)
1627 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1628 setlocale (LC_MESSAGES
, "");
1630 #if defined (HAVE_SETLOCALE)
1631 setlocale (LC_CTYPE
, "");
1632 setlocale (LC_COLLATE
, "");
1634 bindtextdomain (PACKAGE
, LOCALEDIR
);
1635 textdomain (PACKAGE
);
1637 program_name
= *argv
;
1638 xmalloc_set_program_name (program_name
);
1639 bfd_set_error_program_name (program_name
);
1640 #if BFD_SUPPORTS_PLUGINS
1641 bfd_plugin_set_program_name (program_name
);
1644 START_PROGRESS (program_name
, 0);
1646 expandargv (&argc
, &argv
);
1649 set_default_bfd_target ();
1651 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1652 long_options
, (int *) 0)) != EOF
)
1657 print_debug_syms
= 1;
1661 filename_per_symbol
= 1;
1663 case 'B': /* For MIPS compatibility. */
1664 set_output_format ("bsd");
1670 enum demangling_styles style
;
1672 style
= cplus_demangle_name_to_style (optarg
);
1673 if (style
== unknown_demangling
)
1674 fatal (_("unknown demangling style `%s'"),
1677 cplus_demangle_set_style (style
);
1684 /* Ignored for HP/UX compatibility. */
1687 set_output_format (optarg
);
1701 sort_numerically
= 1;
1706 sort_numerically
= 0;
1709 case OPTION_SIZE_SORT
:
1711 sort_numerically
= 0;
1715 set_output_format ("posix");
1727 set_print_radix (optarg
);
1736 /* Ignored for (partial) AIX compatibility. On AIX, the
1737 argument has values 32, 64, or 32_64, and specifies that
1738 only 32-bit, only 64-bit, or both kinds of objects should
1739 be examined. The default is 32. So plain AIX nm on a
1740 library archive with both kinds of objects will ignore
1741 the 64-bit ones. For GNU nm, the default is and always
1742 has been -X 32_64, and other options are not supported. */
1743 if (strcmp (optarg
, "32_64") != 0)
1744 fatal (_("Only -X 32_64 is supported"));
1747 case OPTION_TARGET
: /* --target */
1751 case OPTION_PLUGIN
: /* --plugin */
1752 #if BFD_SUPPORTS_PLUGINS
1753 bfd_plugin_set_plugin (optarg
);
1755 fatal (_("sorry - this program has been built without plugin support\n"));
1759 case 0: /* A long option that just sets a flag. */
1768 print_version ("nm");
1770 if (sort_by_size
&& undefined_only
)
1772 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1773 non_fatal (_("will produce no output, since undefined symbols have no size."));
1777 /* OK, all options now parsed. If no filename specified, do a.out. */
1779 return !display_file ("a.out");
1783 if (argc
- optind
> 1)
1784 filename_per_file
= 1;
1786 /* We were given several filenames to do. */
1787 while (optind
< argc
)
1790 if (!display_file (argv
[optind
++]))
1794 END_PROGRESS (program_name
);
1799 char *lim
= (char *) sbrk (0);
1801 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));