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. */
165 /* When to print the names of files. Not mutually exclusive in SYSV format. */
166 static int filename_per_file
= 0; /* Once per file, on its own line. */
167 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
169 /* Print formats for printing a symbol value. */
170 static char value_format_32bit
[] = "%08lx";
171 #if BFD_HOST_64BIT_LONG
172 static char value_format_64bit
[] = "%016lx";
173 #elif BFD_HOST_64BIT_LONG_LONG
175 static char value_format_64bit
[] = "%016llx";
177 static char value_format_64bit
[] = "%016I64x";
180 static int print_width
= 0;
181 static int print_radix
= 16;
182 /* Print formats for printing stab info. */
183 static char other_format
[] = "%02x";
184 static char desc_format
[] = "%04x";
186 static char *target
= NULL
;
187 #if BFD_SUPPORTS_PLUGINS
188 static const char *plugin_target
= "plugin";
190 static const char *plugin_target
= NULL
;
193 /* Used to cache the line numbers for a BFD. */
194 static bfd
*lineno_cache_bfd
;
195 static bfd
*lineno_cache_rel_bfd
;
197 #define OPTION_TARGET 200
198 #define OPTION_PLUGIN (OPTION_TARGET + 1)
199 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
201 static struct option long_options
[] =
203 {"debug-syms", no_argument
, &print_debug_syms
, 1},
204 {"demangle", optional_argument
, 0, 'C'},
205 {"dynamic", no_argument
, &dynamic
, 1},
206 {"extern-only", no_argument
, &external_only
, 1},
207 {"format", required_argument
, 0, 'f'},
208 {"help", no_argument
, 0, 'h'},
209 {"line-numbers", no_argument
, 0, 'l'},
210 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
211 {"no-demangle", no_argument
, &do_demangle
, 0},
212 {"no-sort", no_argument
, 0, 'p'},
213 {"numeric-sort", no_argument
, 0, 'n'},
214 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
215 {"portability", no_argument
, 0, 'P'},
216 {"print-armap", no_argument
, &print_armap
, 1},
217 {"print-file-name", no_argument
, 0, 'o'},
218 {"print-size", no_argument
, 0, 'S'},
219 {"radix", required_argument
, 0, 't'},
220 {"reverse-sort", no_argument
, &reverse_sort
, 1},
221 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
222 {"special-syms", no_argument
, &allow_special_symbols
, 1},
223 {"stats", no_argument
, &show_stats
, 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 {0, no_argument
, 0, 0}
232 /* Some error-reporting functions. */
235 usage (FILE *stream
, int status
)
237 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
238 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
239 fprintf (stream
, _(" The options are:\n\
240 -a, --debug-syms Display debugger-only symbols\n\
241 -A, --print-file-name Print name of the input file before every symbol\n\
242 -B Same as --format=bsd\n\
243 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
244 The STYLE, if specified, can be `auto' (the default),\n\
245 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
247 --no-demangle Do not demangle low-level symbol names\n\
248 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
249 --defined-only Display only defined symbols\n\
251 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
252 `sysv' or `posix'. The default is `bsd'\n\
253 -g, --extern-only Display only external symbols\n\
254 -l, --line-numbers Use debugging information to find a filename and\n\
255 line number for each symbol\n\
256 -n, --numeric-sort Sort symbols numerically by address\n\
258 -p, --no-sort Do not sort the symbols\n\
259 -P, --portability Same as --format=posix\n\
260 -r, --reverse-sort Reverse the sense of the sort\n"));
261 #if BFD_SUPPORTS_PLUGINS
262 fprintf (stream
, _("\
263 --plugin NAME Load the specified plugin\n"));
265 fprintf (stream
, _("\
266 -S, --print-size Print size of defined symbols\n\
267 -s, --print-armap Include index for symbols from archive members\n\
268 --size-sort Sort symbols by size\n\
269 --special-syms Include special symbols in the output\n\
270 --synthetic Display synthetic symbols as well\n\
271 -t, --radix=RADIX Use RADIX for printing symbol values\n\
272 --target=BFDNAME Specify the target object format as BFDNAME\n\
273 -u, --undefined-only Display only undefined symbols\n\
274 -X 32_64 (ignored)\n\
275 @FILE Read options from FILE\n\
276 -h, --help Display this information\n\
277 -V, --version Display this program's version number\n\
279 list_supported_targets (program_name
, stream
);
280 if (REPORT_BUGS_TO
[0] && status
== 0)
281 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
285 /* Set the radix for the symbol value and size according to RADIX. */
288 set_print_radix (char *radix
)
300 value_format_32bit
[4] = *radix
;
301 #if BFD_HOST_64BIT_LONG
302 value_format_64bit
[5] = *radix
;
303 #elif BFD_HOST_64BIT_LONG_LONG
305 value_format_64bit
[6] = *radix
;
307 value_format_64bit
[7] = *radix
;
310 other_format
[3] = desc_format
[3] = *radix
;
313 fatal (_("%s: invalid radix"), radix
);
318 set_output_format (char *f
)
337 fatal (_("%s: invalid output format"), f
);
339 format
= &formats
[i
];
343 get_elf_symbol_type (unsigned int type
)
345 static char buff
[32];
349 case STT_NOTYPE
: return "NOTYPE";
350 case STT_OBJECT
: return "OBJECT";
351 case STT_FUNC
: return "FUNC";
352 case STT_SECTION
: return "SECTION";
353 case STT_FILE
: return "FILE";
354 case STT_COMMON
: return "COMMON";
355 case STT_TLS
: return "TLS";
357 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
358 sprintf (buff
, _("<processor specific>: %d"), type
);
359 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
360 sprintf (buff
, _("<OS specific>: %d"), type
);
362 sprintf (buff
, _("<unknown>: %d"), type
);
368 get_coff_symbol_type (const struct internal_syment
*sym
)
370 static char buff
[32];
372 switch (sym
->n_sclass
)
374 case C_BLOCK
: return "Block";
375 case C_FILE
: return "File";
376 case C_LINE
: return "Line";
382 switch (DTYPE(sym
->n_type
))
384 case DT_FCN
: return "Function";
385 case DT_PTR
: return "Pointer";
386 case DT_ARY
: return "Array";
389 sprintf (buff
, _("<unknown>: %d/%d"), sym
->n_sclass
, sym
->n_type
);
393 /* Print symbol name NAME, read from ABFD, with printf format FORM,
394 demangling it if requested. */
397 print_symname (const char *form
, const char *name
, bfd
*abfd
)
399 if (do_demangle
&& *name
)
401 char *res
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
415 print_symdef_entry (bfd
*abfd
)
417 symindex idx
= BFD_NO_MORE_SYMBOLS
;
419 bfd_boolean everprinted
= FALSE
;
421 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
422 idx
!= BFD_NO_MORE_SYMBOLS
;
423 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
428 printf (_("\nArchive index:\n"));
431 elt
= bfd_get_elt_at_index (abfd
, idx
);
433 bfd_fatal ("bfd_get_elt_at_index");
434 if (thesym
->name
!= (char *) NULL
)
436 print_symname ("%s", thesym
->name
, abfd
);
437 printf (" in %s\n", bfd_get_filename (elt
));
442 /* Choose which symbol entries to print;
443 compact them downward to get rid of the rest.
444 Return the number of symbols to be printed. */
447 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
448 long symcount
, unsigned int size
)
450 bfd_byte
*from
, *fromend
, *to
;
453 store
= bfd_make_empty_symbol (abfd
);
455 bfd_fatal (bfd_get_filename (abfd
));
457 from
= (bfd_byte
*) minisyms
;
458 fromend
= from
+ symcount
* size
;
459 to
= (bfd_byte
*) minisyms
;
461 for (; from
< fromend
; from
+= size
)
468 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
470 bfd_fatal (bfd_get_filename (abfd
));
472 if (strcmp (sym
->name
, "__gnu_lto_slim") == 0)
473 non_fatal (_("%s: plugin needed to handle lto object"),
474 bfd_get_filename (abfd
));
477 keep
= bfd_is_und_section (sym
->section
);
478 else if (external_only
)
479 /* PR binutls/12753: Unique symbols are global too. */
480 keep
= ((sym
->flags
& (BSF_GLOBAL
482 | BSF_GNU_UNIQUE
)) != 0
483 || bfd_is_und_section (sym
->section
)
484 || bfd_is_com_section (sym
->section
));
489 && ! print_debug_syms
490 && (sym
->flags
& BSF_DEBUGGING
) != 0)
495 && (bfd_is_abs_section (sym
->section
)
496 || bfd_is_und_section (sym
->section
)))
502 if (bfd_is_und_section (sym
->section
))
507 && bfd_is_target_special_symbol (abfd
, sym
)
508 && ! allow_special_symbols
)
514 memcpy (to
, from
, size
);
519 return (to
- (bfd_byte
*) minisyms
) / size
;
522 /* These globals are used to pass information into the sorting
524 static bfd
*sort_bfd
;
525 static bfd_boolean sort_dynamic
;
526 static asymbol
*sort_x
;
527 static asymbol
*sort_y
;
529 /* Symbol-sorting predicates */
530 #define valueof(x) ((x)->section->vma + (x)->value)
532 /* Numeric sorts. Undefined symbols are always considered "less than"
533 defined symbols with zero values. Common symbols are not treated
534 specially -- i.e., their sizes are used as their "values". */
537 non_numeric_forward (const void *P_x
, const void *P_y
)
542 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
543 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
544 if (x
== NULL
|| y
== NULL
)
545 bfd_fatal (bfd_get_filename (sort_bfd
));
547 xn
= bfd_asymbol_name (x
);
548 yn
= bfd_asymbol_name (y
);
556 /* Solaris 2.5 has a bug in strcoll.
557 strcoll returns invalid values when confronted with empty strings. */
563 return strcoll (xn
, yn
);
565 return strcmp (xn
, yn
);
570 non_numeric_reverse (const void *x
, const void *y
)
572 return - non_numeric_forward (x
, y
);
576 numeric_forward (const void *P_x
, const void *P_y
)
581 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
582 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
583 if (x
== NULL
|| y
== NULL
)
584 bfd_fatal (bfd_get_filename (sort_bfd
));
586 xs
= bfd_get_section (x
);
587 ys
= bfd_get_section (y
);
589 if (bfd_is_und_section (xs
))
591 if (! bfd_is_und_section (ys
))
594 else if (bfd_is_und_section (ys
))
596 else if (valueof (x
) != valueof (y
))
597 return valueof (x
) < valueof (y
) ? -1 : 1;
599 return non_numeric_forward (P_x
, P_y
);
603 numeric_reverse (const void *x
, const void *y
)
605 return - numeric_forward (x
, y
);
608 static int (*(sorters
[2][2])) (const void *, const void *) =
610 { non_numeric_forward
, non_numeric_reverse
},
611 { numeric_forward
, numeric_reverse
}
614 /* This sort routine is used by sort_symbols_by_size. It is similar
615 to numeric_forward, but when symbols have the same value it sorts
616 by section VMA. This simplifies the sort_symbols_by_size code
617 which handles symbols at the end of sections. Also, this routine
618 tries to sort file names before other symbols with the same value.
619 That will make the file name have a zero size, which will make
620 sort_symbols_by_size choose the non file name symbol, leading to
621 more meaningful output. For similar reasons, this code sorts
622 gnu_compiled_* and gcc2_compiled before other symbols with the same
626 size_forward1 (const void *P_x
, const void *P_y
)
634 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
635 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
636 if (x
== NULL
|| y
== NULL
)
637 bfd_fatal (bfd_get_filename (sort_bfd
));
639 xs
= bfd_get_section (x
);
640 ys
= bfd_get_section (y
);
642 if (bfd_is_und_section (xs
))
644 if (bfd_is_und_section (ys
))
647 if (valueof (x
) != valueof (y
))
648 return valueof (x
) < valueof (y
) ? -1 : 1;
650 if (xs
->vma
!= ys
->vma
)
651 return xs
->vma
< ys
->vma
? -1 : 1;
653 xn
= bfd_asymbol_name (x
);
654 yn
= bfd_asymbol_name (y
);
658 /* The symbols gnu_compiled and gcc2_compiled convey even less
659 information than the file name, so sort them out first. */
661 xf
= (strstr (xn
, "gnu_compiled") != NULL
662 || strstr (xn
, "gcc2_compiled") != NULL
);
663 yf
= (strstr (yn
, "gnu_compiled") != NULL
664 || strstr (yn
, "gcc2_compiled") != NULL
);
671 /* We use a heuristic for the file name. It may not work on non
672 Unix systems, but it doesn't really matter; the only difference
673 is precisely which symbol names get printed. */
675 #define file_symbol(s, sn, snl) \
676 (((s)->flags & BSF_FILE) != 0 \
677 || ((sn)[(snl) - 2] == '.' \
678 && ((sn)[(snl) - 1] == 'o' \
679 || (sn)[(snl) - 1] == 'a')))
681 xf
= file_symbol (x
, xn
, xnl
);
682 yf
= file_symbol (y
, yn
, ynl
);
689 return non_numeric_forward (P_x
, P_y
);
692 /* This sort routine is used by sort_symbols_by_size. It is sorting
693 an array of size_sym structures into size order. */
696 size_forward2 (const void *P_x
, const void *P_y
)
698 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
699 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
701 if (x
->size
< y
->size
)
702 return reverse_sort
? 1 : -1;
703 else if (x
->size
> y
->size
)
704 return reverse_sort
? -1 : 1;
706 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
709 /* Sort the symbols by size. ELF provides a size but for other formats
710 we have to make a guess by assuming that the difference between the
711 address of a symbol and the address of the next higher symbol is the
715 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
716 long symcount
, unsigned int size
,
717 struct size_sym
**symsizesp
)
719 struct size_sym
*symsizes
;
720 bfd_byte
*from
, *fromend
;
722 asymbol
*store_sym
, *store_next
;
724 qsort (minisyms
, symcount
, size
, size_forward1
);
726 /* We are going to return a special set of symbols and sizes to
728 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
729 *symsizesp
= symsizes
;
731 /* Note that filter_symbols has already removed all absolute and
732 undefined symbols. Here we remove all symbols whose size winds
734 from
= (bfd_byte
*) minisyms
;
735 fromend
= from
+ symcount
* size
;
742 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
745 bfd_fatal (bfd_get_filename (abfd
));
748 for (; from
< fromend
; from
+= size
)
755 if (from
+ size
< fromend
)
757 next
= bfd_minisymbol_to_symbol (abfd
,
759 (const void *) (from
+ size
),
762 bfd_fatal (bfd_get_filename (abfd
));
767 sec
= bfd_get_section (sym
);
769 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
770 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
771 else if (bfd_is_com_section (sec
))
775 if (from
+ size
< fromend
776 && sec
== bfd_get_section (next
))
777 sz
= valueof (next
) - valueof (sym
);
779 sz
= (bfd_get_section_vma (abfd
, sec
)
780 + bfd_section_size (abfd
, sec
)
786 symsizes
->minisym
= (const void *) from
;
794 store_sym
= store_next
;
798 symcount
= symsizes
- *symsizesp
;
800 /* We must now sort again by size. */
801 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
806 /* This function is used to get the relocs for a particular section.
807 It is called via bfd_map_over_sections. */
810 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
812 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
816 if ((sec
->flags
& SEC_RELOC
) == 0)
818 *data
->relocs
= NULL
;
825 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
827 bfd_fatal (bfd_get_filename (abfd
));
829 *data
->relocs
= (arelent
**) xmalloc (relsize
);
830 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
832 if (*data
->relcount
< 0)
833 bfd_fatal (bfd_get_filename (abfd
));
841 /* Print a single symbol. */
844 print_symbol (bfd
* abfd
,
848 bfd_boolean is_synthetic
)
851 struct extended_symbol_info info
;
855 format
->print_symbol_filename (archive_bfd
, abfd
);
857 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
859 info
.sinfo
= &syminfo
;
861 /* Synthetic symbols do not have a full symbol type set of data available. */
865 info
.coffinfo
= NULL
;
869 info
.elfinfo
= elf_symbol_from (abfd
, sym
);
870 info
.coffinfo
= coff_symbol_from (sym
);
873 format
->print_symbol_info (&info
, abfd
);
877 static asymbol
**syms
;
878 static long symcount
;
879 const char *filename
, *functionname
;
882 /* We need to get the canonical symbols in order to call
883 bfd_find_nearest_line. This is inefficient, but, then, you
884 don't have to use --line-numbers. */
885 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
894 symsize
= bfd_get_symtab_upper_bound (abfd
);
896 bfd_fatal (bfd_get_filename (abfd
));
897 syms
= (asymbol
**) xmalloc (symsize
);
898 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
900 bfd_fatal (bfd_get_filename (abfd
));
901 lineno_cache_bfd
= abfd
;
904 if (bfd_is_und_section (bfd_get_section (sym
)))
906 static asection
**secs
;
907 static arelent
***relocs
;
908 static long *relcount
;
909 static unsigned int seccount
;
913 /* For an undefined symbol, we try to find a reloc for the
914 symbol, and print the line number of the reloc. */
915 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
917 for (i
= 0; i
< seccount
; i
++)
918 if (relocs
[i
] != NULL
)
930 struct get_relocs_info rinfo
;
932 seccount
= bfd_count_sections (abfd
);
934 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
935 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
936 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
939 rinfo
.relocs
= relocs
;
940 rinfo
.relcount
= relcount
;
942 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
943 lineno_cache_rel_bfd
= abfd
;
946 symname
= bfd_asymbol_name (sym
);
947 for (i
= 0; i
< seccount
; i
++)
951 for (j
= 0; j
< relcount
[i
]; j
++)
956 if (r
->sym_ptr_ptr
!= NULL
957 && (*r
->sym_ptr_ptr
)->section
== sym
->section
958 && (*r
->sym_ptr_ptr
)->value
== sym
->value
960 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
961 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
962 r
->address
, &filename
,
963 &functionname
, &lineno
)
966 /* We only print the first one we find. */
967 printf ("\t%s:%u", filename
, lineno
);
974 else if (bfd_get_section (sym
)->owner
== abfd
)
976 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
977 || bfd_find_nearest_line (abfd
, bfd_get_section (sym
),
978 syms
, sym
->value
, &filename
,
979 &functionname
, &lineno
))
982 printf ("\t%s:%u", filename
, lineno
);
989 /* Print the symbols when sorting by size. */
992 print_size_symbols (bfd
* abfd
,
993 bfd_boolean is_dynamic
,
994 struct size_sym
* symsizes
,
1000 struct size_sym
*from
;
1001 struct size_sym
*fromend
;
1002 struct size_sym
*fromsynth
;
1004 store
= bfd_make_empty_symbol (abfd
);
1006 bfd_fatal (bfd_get_filename (abfd
));
1009 fromend
= from
+ symcount
;
1010 fromsynth
= symsizes
+ (symcount
- synth_count
);
1012 for (; from
< fromend
; from
++)
1016 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
1018 bfd_fatal (bfd_get_filename (abfd
));
1020 print_symbol (abfd
, sym
, from
->size
, archive_bfd
, from
>= fromsynth
);
1025 /* Print the symbols of ABFD that are held in MINISYMS.
1027 If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
1029 SYMCOUNT is the number of symbols in MINISYMS and SYNTH_COUNT
1030 is the number of these that are synthetic. Synthetic symbols,
1031 if any are present, always come at the end of the MINISYMS.
1033 SIZE is the size of a symbol in MINISYMS. */
1036 print_symbols (bfd
* abfd
,
1037 bfd_boolean is_dynamic
,
1047 bfd_byte
*fromsynth
;
1049 store
= bfd_make_empty_symbol (abfd
);
1051 bfd_fatal (bfd_get_filename (abfd
));
1053 from
= (bfd_byte
*) minisyms
;
1054 fromend
= from
+ symcount
* size
;
1055 fromsynth
= (bfd_byte
*) minisyms
+ ((symcount
- synth_count
) * size
);
1057 for (; from
< fromend
; from
+= size
)
1061 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
1063 bfd_fatal (bfd_get_filename (abfd
));
1065 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
, from
>= fromsynth
);
1069 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1072 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1075 long synth_count
= 0;
1078 struct size_sym
*symsizes
;
1082 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1084 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1089 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1092 if (dynamic
&& bfd_get_error () == bfd_error_no_symbols
)
1094 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1098 bfd_fatal (bfd_get_filename (abfd
));
1103 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1107 if (show_synthetic
&& size
== sizeof (asymbol
*))
1110 asymbol
**static_syms
= NULL
;
1111 asymbol
**dyn_syms
= NULL
;
1112 long static_count
= 0;
1117 dyn_count
= symcount
;
1118 dyn_syms
= (asymbol
**) minisyms
;
1122 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1124 static_count
= symcount
;
1125 static_syms
= (asymbol
**) minisyms
;
1129 dyn_syms
= (asymbol
**) xmalloc (storage
);
1130 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1132 bfd_fatal (bfd_get_filename (abfd
));
1136 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1137 dyn_count
, dyn_syms
, &synthsyms
);
1138 if (synth_count
> 0)
1144 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1145 symp
= (asymbol
**) new_mini
;
1146 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1148 for (i
= 0; i
< synth_count
; i
++)
1149 *symp
++ = synthsyms
+ i
;
1151 minisyms
= new_mini
;
1152 symcount
+= synth_count
;
1156 /* Discard the symbols we don't want to print.
1157 It's OK to do this in place; we'll free the storage anyway
1158 (after printing). */
1160 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1166 sort_dynamic
= dynamic
;
1167 sort_x
= bfd_make_empty_symbol (abfd
);
1168 sort_y
= bfd_make_empty_symbol (abfd
);
1169 if (sort_x
== NULL
|| sort_y
== NULL
)
1170 bfd_fatal (bfd_get_filename (abfd
));
1173 qsort (minisyms
, symcount
, size
,
1174 sorters
[sort_numerically
][reverse_sort
]);
1176 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1181 print_symbols (abfd
, dynamic
, minisyms
, symcount
, synth_count
, size
, archive_bfd
);
1183 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, synth_count
, archive_bfd
);
1190 set_print_width (bfd
*file
)
1192 print_width
= bfd_get_arch_size (file
);
1194 if (print_width
== -1)
1197 Guess the target's bitsize based on its name.
1198 We assume here than any 64-bit format will include
1199 "64" somewhere in its name. The only known exception
1200 is the MMO object file format. */
1201 if (strstr (bfd_get_target (file
), "64") != NULL
1202 || strcmp (bfd_get_target (file
), "mmo") == 0)
1210 display_archive (bfd
*file
)
1213 bfd
*last_arfile
= NULL
;
1216 format
->print_archive_filename (bfd_get_filename (file
));
1219 print_symdef_entry (file
);
1225 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1229 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1230 bfd_fatal (bfd_get_filename (file
));
1234 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1236 set_print_width (arfile
);
1237 format
->print_archive_member (bfd_get_filename (file
),
1238 bfd_get_filename (arfile
));
1239 display_rel_file (arfile
, file
);
1243 bfd_nonfatal (bfd_get_filename (arfile
));
1244 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1246 list_matching_formats (matching
);
1251 if (last_arfile
!= NULL
)
1253 bfd_close (last_arfile
);
1254 lineno_cache_bfd
= NULL
;
1255 lineno_cache_rel_bfd
= NULL
;
1256 if (arfile
== last_arfile
)
1259 last_arfile
= arfile
;
1262 if (last_arfile
!= NULL
)
1264 bfd_close (last_arfile
);
1265 lineno_cache_bfd
= NULL
;
1266 lineno_cache_rel_bfd
= NULL
;
1271 display_file (char *filename
)
1273 bfd_boolean retval
= TRUE
;
1277 if (get_file_size (filename
) < 1)
1280 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1283 bfd_nonfatal (filename
);
1287 /* If printing line numbers, decompress the debug sections. */
1289 file
->flags
|= BFD_DECOMPRESS
;
1291 if (bfd_check_format (file
, bfd_archive
))
1293 display_archive (file
);
1295 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1297 set_print_width (file
);
1298 format
->print_object_filename (filename
);
1299 display_rel_file (file
, NULL
);
1303 bfd_nonfatal (filename
);
1304 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1306 list_matching_formats (matching
);
1312 if (!bfd_close (file
))
1313 bfd_fatal (filename
);
1315 lineno_cache_bfd
= NULL
;
1316 lineno_cache_rel_bfd
= NULL
;
1321 /* The following 3 groups of functions are called unconditionally,
1322 once at the start of processing each file of the appropriate type.
1323 They should check `filename_per_file' and `filename_per_symbol',
1324 as appropriate for their output format, to determine whether to
1327 /* Print the name of an object file given on the command line. */
1330 print_object_filename_bsd (char *filename
)
1332 if (filename_per_file
&& !filename_per_symbol
)
1333 printf ("\n%s:\n", filename
);
1337 print_object_filename_sysv (char *filename
)
1340 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1342 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1343 if (print_width
== 32)
1345 Name Value Class Type Size Line Section\n\n"));
1348 Name Value Class Type Size Line Section\n\n"));
1352 print_object_filename_posix (char *filename
)
1354 if (filename_per_file
&& !filename_per_symbol
)
1355 printf ("%s:\n", filename
);
1358 /* Print the name of an archive file given on the command line. */
1361 print_archive_filename_bsd (char *filename
)
1363 if (filename_per_file
)
1364 printf ("\n%s:\n", filename
);
1368 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1373 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1377 /* Print the name of an archive member file. */
1380 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1381 const char *filename
)
1383 if (!filename_per_symbol
)
1384 printf ("\n%s:\n", filename
);
1388 print_archive_member_sysv (char *archive
, const char *filename
)
1391 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1393 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1394 if (print_width
== 32)
1396 Name Value Class Type Size Line Section\n\n"));
1399 Name Value Class Type Size Line Section\n\n"));
1403 print_archive_member_posix (char *archive
, const char *filename
)
1405 if (!filename_per_symbol
)
1406 printf ("%s[%s]:\n", archive
, filename
);
1409 /* Print the name of the file (and archive, if there is one)
1410 containing a symbol. */
1413 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1415 if (filename_per_symbol
)
1418 printf ("%s:", bfd_get_filename (archive_bfd
));
1419 printf ("%s:", bfd_get_filename (abfd
));
1424 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1426 if (filename_per_symbol
)
1429 printf ("%s:", bfd_get_filename (archive_bfd
));
1430 printf ("%s:", bfd_get_filename (abfd
));
1435 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1437 if (filename_per_symbol
)
1440 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1441 bfd_get_filename (abfd
));
1443 printf ("%s: ", bfd_get_filename (abfd
));
1447 /* Print a symbol value. */
1450 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1452 switch (print_width
)
1455 printf (value_format_32bit
, (unsigned long) val
);
1459 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1460 printf (value_format_64bit
, val
);
1462 /* We have a 64 bit value to print, but the host is only 32 bit. */
1463 if (print_radix
== 16)
1464 bfd_fprintf_vma (abfd
, stdout
, val
);
1470 s
= buf
+ sizeof buf
;
1474 *--s
= (val
% print_radix
) + '0';
1477 while ((buf
+ sizeof buf
- 1) - s
< 16)
1485 fatal (_("Print width has not been initialized (%d)"), print_width
);
1490 /* Print a line of information about a symbol. */
1493 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1495 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1497 if (print_width
== 64)
1503 /* Normally we print the value of the symbol. If we are printing the
1504 size or sorting by size then we print its size, except for the
1505 (weird) special case where both flags are defined, in which case we
1506 print both values. This conforms to documented behaviour. */
1507 if (sort_by_size
&& !print_size
)
1508 print_value (abfd
, SYM_SIZE (info
));
1510 print_value (abfd
, SYM_VALUE (info
));
1511 if (print_size
&& SYM_SIZE (info
))
1514 print_value (abfd
, SYM_SIZE (info
));
1518 printf (" %c", SYM_TYPE (info
));
1520 if (SYM_TYPE (info
) == '-')
1524 printf (other_format
, SYM_STAB_OTHER (info
));
1526 printf (desc_format
, SYM_STAB_DESC (info
));
1527 printf (" %5s", SYM_STAB_NAME (info
));
1529 print_symname (" %s", SYM_NAME (info
), abfd
);
1533 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1535 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1537 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1539 if (print_width
== 32)
1545 print_value (abfd
, SYM_VALUE (info
));
1547 printf ("| %c |", SYM_TYPE (info
));
1549 if (SYM_TYPE (info
) == '-')
1552 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1553 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1554 printf ("| |"); /* Line, Section. */
1558 /* Type, Size, Line, Section */
1561 get_elf_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1562 else if (info
->coffinfo
)
1564 get_coff_symbol_type (&info
->coffinfo
->native
->u
.syment
));
1568 if (SYM_SIZE (info
))
1569 print_value (abfd
, SYM_SIZE (info
));
1572 if (print_width
== 32)
1579 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1580 else if (info
->coffinfo
)
1581 printf("| |%s", info
->coffinfo
->symbol
.section
->name
);
1588 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1590 print_symname ("%s ", SYM_NAME (info
), abfd
);
1591 printf ("%c ", SYM_TYPE (info
));
1593 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1597 print_value (abfd
, SYM_VALUE (info
));
1599 if (SYM_SIZE (info
))
1600 print_value (abfd
, SYM_SIZE (info
));
1605 main (int argc
, char **argv
)
1610 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1611 setlocale (LC_MESSAGES
, "");
1613 #if defined (HAVE_SETLOCALE)
1614 setlocale (LC_CTYPE
, "");
1615 setlocale (LC_COLLATE
, "");
1617 bindtextdomain (PACKAGE
, LOCALEDIR
);
1618 textdomain (PACKAGE
);
1620 program_name
= *argv
;
1621 xmalloc_set_program_name (program_name
);
1622 bfd_set_error_program_name (program_name
);
1623 #if BFD_SUPPORTS_PLUGINS
1624 bfd_plugin_set_program_name (program_name
);
1627 START_PROGRESS (program_name
, 0);
1629 expandargv (&argc
, &argv
);
1632 set_default_bfd_target ();
1634 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1635 long_options
, (int *) 0)) != EOF
)
1640 print_debug_syms
= 1;
1644 filename_per_symbol
= 1;
1646 case 'B': /* For MIPS compatibility. */
1647 set_output_format ("bsd");
1653 enum demangling_styles style
;
1655 style
= cplus_demangle_name_to_style (optarg
);
1656 if (style
== unknown_demangling
)
1657 fatal (_("unknown demangling style `%s'"),
1660 cplus_demangle_set_style (style
);
1667 /* Ignored for HP/UX compatibility. */
1670 set_output_format (optarg
);
1684 sort_numerically
= 1;
1689 sort_numerically
= 0;
1692 case OPTION_SIZE_SORT
:
1694 sort_numerically
= 0;
1698 set_output_format ("posix");
1710 set_print_radix (optarg
);
1719 /* Ignored for (partial) AIX compatibility. On AIX, the
1720 argument has values 32, 64, or 32_64, and specifies that
1721 only 32-bit, only 64-bit, or both kinds of objects should
1722 be examined. The default is 32. So plain AIX nm on a
1723 library archive with both kinds of objects will ignore
1724 the 64-bit ones. For GNU nm, the default is and always
1725 has been -X 32_64, and other options are not supported. */
1726 if (strcmp (optarg
, "32_64") != 0)
1727 fatal (_("Only -X 32_64 is supported"));
1730 case OPTION_TARGET
: /* --target */
1734 case OPTION_PLUGIN
: /* --plugin */
1735 #if BFD_SUPPORTS_PLUGINS
1736 bfd_plugin_set_plugin (optarg
);
1738 fatal (_("sorry - this program has been built without plugin support\n"));
1742 case 0: /* A long option that just sets a flag. */
1751 print_version ("nm");
1753 if (sort_by_size
&& undefined_only
)
1755 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1756 non_fatal (_("will produce no output, since undefined symbols have no size."));
1760 /* OK, all options now parsed. If no filename specified, do a.out. */
1762 return !display_file ("a.out");
1766 if (argc
- optind
> 1)
1767 filename_per_file
= 1;
1769 /* We were given several filenames to do. */
1770 while (optind
< argc
)
1773 if (!display_file (argv
[optind
++]))
1777 END_PROGRESS (program_name
);
1782 char *lim
= (char *) sbrk (0);
1784 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));