1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
27 #include "aout/stab_gnu.h"
28 #include "aout/ranlib.h"
30 #include "libiberty.h"
32 #include "elf/common.h"
36 /* When sorting by size, we use this structure to hold the size and a
37 pointer to the minisymbol. */
45 /* When fetching relocs, we use this structure to pass information to
48 struct get_relocs_info
56 struct extended_symbol_info
60 elf_symbol_type
*elfinfo
;
61 /* FIXME: We should add more fields for Type, Line, Section. */
63 #define SYM_NAME(sym) (sym->sinfo->name)
64 #define SYM_VALUE(sym) (sym->sinfo->value)
65 #define SYM_TYPE(sym) (sym->sinfo->type)
66 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
67 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
68 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
69 #define SYM_SIZE(sym) \
70 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
72 /* The output formatting functions. */
73 static void print_object_filename_bsd (char *);
74 static void print_object_filename_sysv (char *);
75 static void print_object_filename_posix (char *);
76 static void print_archive_filename_bsd (char *);
77 static void print_archive_filename_sysv (char *);
78 static void print_archive_filename_posix (char *);
79 static void print_archive_member_bsd (char *, const char *);
80 static void print_archive_member_sysv (char *, const char *);
81 static void print_archive_member_posix (char *, const char *);
82 static void print_symbol_filename_bsd (bfd
*, bfd
*);
83 static void print_symbol_filename_sysv (bfd
*, bfd
*);
84 static void print_symbol_filename_posix (bfd
*, bfd
*);
85 static void print_value (bfd
*, bfd_vma
);
86 static void print_symbol_info_bsd (struct extended_symbol_info
*, bfd
*);
87 static void print_symbol_info_sysv (struct extended_symbol_info
*, bfd
*);
88 static void print_symbol_info_posix (struct extended_symbol_info
*, bfd
*);
90 /* Support for different output formats. */
93 /* Print the name of an object file given on the command line. */
94 void (*print_object_filename
) (char *);
96 /* Print the name of an archive file given on the command line. */
97 void (*print_archive_filename
) (char *);
99 /* Print the name of an archive member file. */
100 void (*print_archive_member
) (char *, const char *);
102 /* Print the name of the file (and archive, if there is one)
103 containing a symbol. */
104 void (*print_symbol_filename
) (bfd
*, bfd
*);
106 /* Print a line of information about a symbol. */
107 void (*print_symbol_info
) (struct extended_symbol_info
*, bfd
*);
110 static struct output_fns formats
[] =
112 {print_object_filename_bsd
,
113 print_archive_filename_bsd
,
114 print_archive_member_bsd
,
115 print_symbol_filename_bsd
,
116 print_symbol_info_bsd
},
117 {print_object_filename_sysv
,
118 print_archive_filename_sysv
,
119 print_archive_member_sysv
,
120 print_symbol_filename_sysv
,
121 print_symbol_info_sysv
},
122 {print_object_filename_posix
,
123 print_archive_filename_posix
,
124 print_archive_member_posix
,
125 print_symbol_filename_posix
,
126 print_symbol_info_posix
}
129 /* Indices in `formats'. */
131 #define FORMAT_SYSV 1
132 #define FORMAT_POSIX 2
133 #define FORMAT_DEFAULT FORMAT_BSD
135 /* The output format to use. */
136 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
138 /* Command options. */
140 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
141 static int external_only
= 0; /* Print external symbols only. */
142 static int defined_only
= 0; /* Print defined symbols only. */
143 static int no_sort
= 0; /* Don't sort; print syms in order found. */
144 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
145 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
146 static int print_size
= 0; /* Print size of defined symbols. */
147 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
148 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
149 static int sort_by_size
= 0; /* Sort by size of symbol. */
150 static int undefined_only
= 0; /* Print undefined symbols only. */
151 static int dynamic
= 0; /* Print dynamic symbols. */
152 static int show_version
= 0; /* Show the version number. */
153 static int show_stats
= 0; /* Show statistics. */
154 static int show_synthetic
= 0; /* Display synthesized symbols too. */
155 static int line_numbers
= 0; /* Print line numbers for symbols. */
156 static int allow_special_symbols
= 0; /* Allow special symbols. */
158 /* When to print the names of files. Not mutually exclusive in SYSV format. */
159 static int filename_per_file
= 0; /* Once per file, on its own line. */
160 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
162 /* Print formats for printing a symbol value. */
163 static char value_format_32bit
[] = "%08lx";
164 #if BFD_HOST_64BIT_LONG
165 static char value_format_64bit
[] = "%016lx";
166 #elif BFD_HOST_64BIT_LONG_LONG
168 static char value_format_64bit
[] = "%016llx";
170 static char value_format_64bit
[] = "%016I64x";
173 static int print_width
= 0;
174 static int print_radix
= 16;
175 /* Print formats for printing stab info. */
176 static char other_format
[] = "%02x";
177 static char desc_format
[] = "%04x";
179 static char *target
= NULL
;
180 static char *plugin_target
= NULL
;
182 /* Used to cache the line numbers for a BFD. */
183 static bfd
*lineno_cache_bfd
;
184 static bfd
*lineno_cache_rel_bfd
;
186 #define OPTION_TARGET 200
187 #define OPTION_PLUGIN (OPTION_TARGET + 1)
188 #define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
190 static struct option long_options
[] =
192 {"debug-syms", no_argument
, &print_debug_syms
, 1},
193 {"demangle", optional_argument
, 0, 'C'},
194 {"dynamic", no_argument
, &dynamic
, 1},
195 {"extern-only", no_argument
, &external_only
, 1},
196 {"format", required_argument
, 0, 'f'},
197 {"help", no_argument
, 0, 'h'},
198 {"line-numbers", no_argument
, 0, 'l'},
199 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
200 {"no-demangle", no_argument
, &do_demangle
, 0},
201 {"no-sort", no_argument
, 0, 'p'},
202 {"numeric-sort", no_argument
, 0, 'n'},
203 {"plugin", required_argument
, 0, OPTION_PLUGIN
},
204 {"portability", no_argument
, 0, 'P'},
205 {"print-armap", no_argument
, &print_armap
, 1},
206 {"print-file-name", no_argument
, 0, 'o'},
207 {"print-size", no_argument
, 0, 'S'},
208 {"radix", required_argument
, 0, 't'},
209 {"reverse-sort", no_argument
, &reverse_sort
, 1},
210 {"size-sort", no_argument
, 0, OPTION_SIZE_SORT
},
211 {"special-syms", no_argument
, &allow_special_symbols
, 1},
212 {"stats", no_argument
, &show_stats
, 1},
213 {"synthetic", no_argument
, &show_synthetic
, 1},
214 {"target", required_argument
, 0, OPTION_TARGET
},
215 {"defined-only", no_argument
, &defined_only
, 1},
216 {"undefined-only", no_argument
, &undefined_only
, 1},
217 {"version", no_argument
, &show_version
, 1},
218 {0, no_argument
, 0, 0}
221 /* Some error-reporting functions. */
224 usage (FILE *stream
, int status
)
226 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
227 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
228 fprintf (stream
, _(" The options are:\n\
229 -a, --debug-syms Display debugger-only symbols\n\
230 -A, --print-file-name Print name of the input file before every symbol\n\
231 -B Same as --format=bsd\n\
232 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
233 The STYLE, if specified, can be `auto' (the default),\n\
234 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
236 --no-demangle Do not demangle low-level symbol names\n\
237 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
238 --defined-only Display only defined symbols\n\
240 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
241 `sysv' or `posix'. The default is `bsd'\n\
242 -g, --extern-only Display only external symbols\n\
243 -l, --line-numbers Use debugging information to find a filename and\n\
244 line number for each symbol\n\
245 -n, --numeric-sort Sort symbols numerically by address\n\
247 -p, --no-sort Do not sort the symbols\n\
248 -P, --portability Same as --format=posix\n\
249 -r, --reverse-sort Reverse the sense of the sort\n"));
250 #if BFD_SUPPORTS_PLUGINS
251 fprintf (stream
, _("\
252 --plugin NAME Load the specified plugin\n"));
254 fprintf (stream
, _("\
255 -S, --print-size Print size of defined symbols\n\
256 -s, --print-armap Include index for symbols from archive members\n\
257 --size-sort Sort symbols by size\n\
258 --special-syms Include special symbols in the output\n\
259 --synthetic Display synthetic symbols as well\n\
260 -t, --radix=RADIX Use RADIX for printing symbol values\n\
261 --target=BFDNAME Specify the target object format as BFDNAME\n\
262 -u, --undefined-only Display only undefined symbols\n\
263 -X 32_64 (ignored)\n\
264 @FILE Read options from FILE\n\
265 -h, --help Display this information\n\
266 -V, --version Display this program's version number\n\
268 list_supported_targets (program_name
, stream
);
269 if (REPORT_BUGS_TO
[0] && status
== 0)
270 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
274 /* Set the radix for the symbol value and size according to RADIX. */
277 set_print_radix (char *radix
)
289 value_format_32bit
[4] = *radix
;
290 #if BFD_HOST_64BIT_LONG
291 value_format_64bit
[5] = *radix
;
292 #elif BFD_HOST_64BIT_LONG_LONG
294 value_format_64bit
[6] = *radix
;
296 value_format_64bit
[7] = *radix
;
299 other_format
[3] = desc_format
[3] = *radix
;
302 fatal (_("%s: invalid radix"), radix
);
307 set_output_format (char *f
)
326 fatal (_("%s: invalid output format"), f
);
328 format
= &formats
[i
];
332 get_symbol_type (unsigned int type
)
334 static char buff
[32];
338 case STT_NOTYPE
: return "NOTYPE";
339 case STT_OBJECT
: return "OBJECT";
340 case STT_FUNC
: return "FUNC";
341 case STT_SECTION
: return "SECTION";
342 case STT_FILE
: return "FILE";
343 case STT_COMMON
: return "COMMON";
344 case STT_TLS
: return "TLS";
346 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
347 sprintf (buff
, _("<processor specific>: %d"), type
);
348 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
349 sprintf (buff
, _("<OS specific>: %d"), type
);
351 sprintf (buff
, _("<unknown>: %d"), type
);
356 /* Print symbol name NAME, read from ABFD, with printf format FORM,
357 demangling it if requested. */
360 print_symname (const char *form
, const char *name
, bfd
*abfd
)
362 if (do_demangle
&& *name
)
364 char *res
= bfd_demangle (abfd
, name
, DMGL_ANSI
| DMGL_PARAMS
);
378 print_symdef_entry (bfd
*abfd
)
380 symindex idx
= BFD_NO_MORE_SYMBOLS
;
382 bfd_boolean everprinted
= FALSE
;
384 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
385 idx
!= BFD_NO_MORE_SYMBOLS
;
386 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
391 printf (_("\nArchive index:\n"));
394 elt
= bfd_get_elt_at_index (abfd
, idx
);
396 bfd_fatal ("bfd_get_elt_at_index");
397 if (thesym
->name
!= (char *) NULL
)
399 print_symname ("%s", thesym
->name
, abfd
);
400 printf (" in %s\n", bfd_get_filename (elt
));
405 /* Choose which symbol entries to print;
406 compact them downward to get rid of the rest.
407 Return the number of symbols to be printed. */
410 filter_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
411 long symcount
, unsigned int size
)
413 bfd_byte
*from
, *fromend
, *to
;
416 store
= bfd_make_empty_symbol (abfd
);
418 bfd_fatal (bfd_get_filename (abfd
));
420 from
= (bfd_byte
*) minisyms
;
421 fromend
= from
+ symcount
* size
;
422 to
= (bfd_byte
*) minisyms
;
424 for (; from
< fromend
; from
+= size
)
431 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
, store
);
433 bfd_fatal (bfd_get_filename (abfd
));
436 keep
= bfd_is_und_section (sym
->section
);
437 else if (external_only
)
438 /* PR binutls/12753: Unique symbols are global too. */
439 keep
= ((sym
->flags
& (BSF_GLOBAL
441 | BSF_GNU_UNIQUE
)) != 0
442 || bfd_is_und_section (sym
->section
)
443 || bfd_is_com_section (sym
->section
));
448 && ! print_debug_syms
449 && (sym
->flags
& BSF_DEBUGGING
) != 0)
454 && (bfd_is_abs_section (sym
->section
)
455 || bfd_is_und_section (sym
->section
)))
461 if (bfd_is_und_section (sym
->section
))
466 && bfd_is_target_special_symbol (abfd
, sym
)
467 && ! allow_special_symbols
)
473 memcpy (to
, from
, size
);
478 return (to
- (bfd_byte
*) minisyms
) / size
;
481 /* These globals are used to pass information into the sorting
483 static bfd
*sort_bfd
;
484 static bfd_boolean sort_dynamic
;
485 static asymbol
*sort_x
;
486 static asymbol
*sort_y
;
488 /* Symbol-sorting predicates */
489 #define valueof(x) ((x)->section->vma + (x)->value)
491 /* Numeric sorts. Undefined symbols are always considered "less than"
492 defined symbols with zero values. Common symbols are not treated
493 specially -- i.e., their sizes are used as their "values". */
496 non_numeric_forward (const void *P_x
, const void *P_y
)
501 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
502 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
503 if (x
== NULL
|| y
== NULL
)
504 bfd_fatal (bfd_get_filename (sort_bfd
));
506 xn
= bfd_asymbol_name (x
);
507 yn
= bfd_asymbol_name (y
);
515 /* Solaris 2.5 has a bug in strcoll.
516 strcoll returns invalid values when confronted with empty strings. */
522 return strcoll (xn
, yn
);
524 return strcmp (xn
, yn
);
529 non_numeric_reverse (const void *x
, const void *y
)
531 return - non_numeric_forward (x
, y
);
535 numeric_forward (const void *P_x
, const void *P_y
)
540 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
541 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
542 if (x
== NULL
|| y
== NULL
)
543 bfd_fatal (bfd_get_filename (sort_bfd
));
545 xs
= bfd_get_section (x
);
546 ys
= bfd_get_section (y
);
548 if (bfd_is_und_section (xs
))
550 if (! bfd_is_und_section (ys
))
553 else if (bfd_is_und_section (ys
))
555 else if (valueof (x
) != valueof (y
))
556 return valueof (x
) < valueof (y
) ? -1 : 1;
558 return non_numeric_forward (P_x
, P_y
);
562 numeric_reverse (const void *x
, const void *y
)
564 return - numeric_forward (x
, y
);
567 static int (*(sorters
[2][2])) (const void *, const void *) =
569 { non_numeric_forward
, non_numeric_reverse
},
570 { numeric_forward
, numeric_reverse
}
573 /* This sort routine is used by sort_symbols_by_size. It is similar
574 to numeric_forward, but when symbols have the same value it sorts
575 by section VMA. This simplifies the sort_symbols_by_size code
576 which handles symbols at the end of sections. Also, this routine
577 tries to sort file names before other symbols with the same value.
578 That will make the file name have a zero size, which will make
579 sort_symbols_by_size choose the non file name symbol, leading to
580 more meaningful output. For similar reasons, this code sorts
581 gnu_compiled_* and gcc2_compiled before other symbols with the same
585 size_forward1 (const void *P_x
, const void *P_y
)
593 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
594 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
595 if (x
== NULL
|| y
== NULL
)
596 bfd_fatal (bfd_get_filename (sort_bfd
));
598 xs
= bfd_get_section (x
);
599 ys
= bfd_get_section (y
);
601 if (bfd_is_und_section (xs
))
603 if (bfd_is_und_section (ys
))
606 if (valueof (x
) != valueof (y
))
607 return valueof (x
) < valueof (y
) ? -1 : 1;
609 if (xs
->vma
!= ys
->vma
)
610 return xs
->vma
< ys
->vma
? -1 : 1;
612 xn
= bfd_asymbol_name (x
);
613 yn
= bfd_asymbol_name (y
);
617 /* The symbols gnu_compiled and gcc2_compiled convey even less
618 information than the file name, so sort them out first. */
620 xf
= (strstr (xn
, "gnu_compiled") != NULL
621 || strstr (xn
, "gcc2_compiled") != NULL
);
622 yf
= (strstr (yn
, "gnu_compiled") != NULL
623 || strstr (yn
, "gcc2_compiled") != NULL
);
630 /* We use a heuristic for the file name. It may not work on non
631 Unix systems, but it doesn't really matter; the only difference
632 is precisely which symbol names get printed. */
634 #define file_symbol(s, sn, snl) \
635 (((s)->flags & BSF_FILE) != 0 \
636 || ((sn)[(snl) - 2] == '.' \
637 && ((sn)[(snl) - 1] == 'o' \
638 || (sn)[(snl) - 1] == 'a')))
640 xf
= file_symbol (x
, xn
, xnl
);
641 yf
= file_symbol (y
, yn
, ynl
);
648 return non_numeric_forward (P_x
, P_y
);
651 /* This sort routine is used by sort_symbols_by_size. It is sorting
652 an array of size_sym structures into size order. */
655 size_forward2 (const void *P_x
, const void *P_y
)
657 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
658 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
660 if (x
->size
< y
->size
)
661 return reverse_sort
? 1 : -1;
662 else if (x
->size
> y
->size
)
663 return reverse_sort
? -1 : 1;
665 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
668 /* Sort the symbols by size. ELF provides a size but for other formats
669 we have to make a guess by assuming that the difference between the
670 address of a symbol and the address of the next higher symbol is the
674 sort_symbols_by_size (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
,
675 long symcount
, unsigned int size
,
676 struct size_sym
**symsizesp
)
678 struct size_sym
*symsizes
;
679 bfd_byte
*from
, *fromend
;
681 asymbol
*store_sym
, *store_next
;
683 qsort (minisyms
, symcount
, size
, size_forward1
);
685 /* We are going to return a special set of symbols and sizes to
687 symsizes
= (struct size_sym
*) xmalloc (symcount
* sizeof (struct size_sym
));
688 *symsizesp
= symsizes
;
690 /* Note that filter_symbols has already removed all absolute and
691 undefined symbols. Here we remove all symbols whose size winds
693 from
= (bfd_byte
*) minisyms
;
694 fromend
= from
+ symcount
* size
;
701 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, (const void *) from
,
704 bfd_fatal (bfd_get_filename (abfd
));
707 for (; from
< fromend
; from
+= size
)
714 if (from
+ size
< fromend
)
716 next
= bfd_minisymbol_to_symbol (abfd
,
718 (const void *) (from
+ size
),
721 bfd_fatal (bfd_get_filename (abfd
));
726 sec
= bfd_get_section (sym
);
728 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
729 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
730 else if (bfd_is_com_section (sec
))
734 if (from
+ size
< fromend
735 && sec
== bfd_get_section (next
))
736 sz
= valueof (next
) - valueof (sym
);
738 sz
= (bfd_get_section_vma (abfd
, sec
)
739 + bfd_section_size (abfd
, sec
)
745 symsizes
->minisym
= (const void *) from
;
753 store_sym
= store_next
;
757 symcount
= symsizes
- *symsizesp
;
759 /* We must now sort again by size. */
760 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
765 /* This function is used to get the relocs for a particular section.
766 It is called via bfd_map_over_sections. */
769 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
771 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
775 if ((sec
->flags
& SEC_RELOC
) == 0)
777 *data
->relocs
= NULL
;
784 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
786 bfd_fatal (bfd_get_filename (abfd
));
788 *data
->relocs
= (arelent
**) xmalloc (relsize
);
789 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
791 if (*data
->relcount
< 0)
792 bfd_fatal (bfd_get_filename (abfd
));
800 /* Print a single symbol. */
803 print_symbol (bfd
*abfd
, asymbol
*sym
, bfd_vma ssize
, bfd
*archive_bfd
)
806 struct extended_symbol_info info
;
810 format
->print_symbol_filename (archive_bfd
, abfd
);
812 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
813 info
.sinfo
= &syminfo
;
815 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
816 info
.elfinfo
= (elf_symbol_type
*) sym
;
819 format
->print_symbol_info (&info
, abfd
);
823 static asymbol
**syms
;
824 static long symcount
;
825 const char *filename
, *functionname
;
828 /* We need to get the canonical symbols in order to call
829 bfd_find_nearest_line. This is inefficient, but, then, you
830 don't have to use --line-numbers. */
831 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
840 symsize
= bfd_get_symtab_upper_bound (abfd
);
842 bfd_fatal (bfd_get_filename (abfd
));
843 syms
= (asymbol
**) xmalloc (symsize
);
844 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
846 bfd_fatal (bfd_get_filename (abfd
));
847 lineno_cache_bfd
= abfd
;
850 if (bfd_is_und_section (bfd_get_section (sym
)))
852 static asection
**secs
;
853 static arelent
***relocs
;
854 static long *relcount
;
855 static unsigned int seccount
;
859 /* For an undefined symbol, we try to find a reloc for the
860 symbol, and print the line number of the reloc. */
861 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
863 for (i
= 0; i
< seccount
; i
++)
864 if (relocs
[i
] != NULL
)
876 struct get_relocs_info rinfo
;
878 seccount
= bfd_count_sections (abfd
);
880 secs
= (asection
**) xmalloc (seccount
* sizeof *secs
);
881 relocs
= (arelent
***) xmalloc (seccount
* sizeof *relocs
);
882 relcount
= (long *) xmalloc (seccount
* sizeof *relcount
);
885 rinfo
.relocs
= relocs
;
886 rinfo
.relcount
= relcount
;
888 bfd_map_over_sections (abfd
, get_relocs
, (void *) &rinfo
);
889 lineno_cache_rel_bfd
= abfd
;
892 symname
= bfd_asymbol_name (sym
);
893 for (i
= 0; i
< seccount
; i
++)
897 for (j
= 0; j
< relcount
[i
]; j
++)
902 if (r
->sym_ptr_ptr
!= NULL
903 && (*r
->sym_ptr_ptr
)->section
== sym
->section
904 && (*r
->sym_ptr_ptr
)->value
== sym
->value
906 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
907 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
908 r
->address
, &filename
,
909 &functionname
, &lineno
)
912 /* We only print the first one we find. */
913 printf ("\t%s:%u", filename
, lineno
);
920 else if (bfd_get_section (sym
)->owner
== abfd
)
922 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
923 || bfd_find_nearest_line (abfd
, bfd_get_section (sym
),
924 syms
, sym
->value
, &filename
,
925 &functionname
, &lineno
))
928 printf ("\t%s:%u", filename
, lineno
);
935 /* Print the symbols when sorting by size. */
938 print_size_symbols (bfd
*abfd
, bfd_boolean is_dynamic
,
939 struct size_sym
*symsizes
, long symcount
,
943 struct size_sym
*from
, *fromend
;
945 store
= bfd_make_empty_symbol (abfd
);
947 bfd_fatal (bfd_get_filename (abfd
));
950 fromend
= from
+ symcount
;
951 for (; from
< fromend
; from
++)
955 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
->minisym
, store
);
957 bfd_fatal (bfd_get_filename (abfd
));
959 print_symbol (abfd
, sym
, from
->size
, archive_bfd
);
964 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
968 print_symbols (bfd
*abfd
, bfd_boolean is_dynamic
, void *minisyms
, long symcount
,
969 unsigned int size
, bfd
*archive_bfd
)
972 bfd_byte
*from
, *fromend
;
974 store
= bfd_make_empty_symbol (abfd
);
976 bfd_fatal (bfd_get_filename (abfd
));
978 from
= (bfd_byte
*) minisyms
;
979 fromend
= from
+ symcount
* size
;
980 for (; from
< fromend
; from
+= size
)
984 sym
= bfd_minisymbol_to_symbol (abfd
, is_dynamic
, from
, store
);
986 bfd_fatal (bfd_get_filename (abfd
));
988 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
992 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
995 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
1000 struct size_sym
*symsizes
;
1004 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1006 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1011 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
1013 bfd_fatal (bfd_get_filename (abfd
));
1017 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1021 if (show_synthetic
&& size
== sizeof (asymbol
*))
1025 asymbol
**static_syms
= NULL
;
1026 asymbol
**dyn_syms
= NULL
;
1027 long static_count
= 0;
1032 dyn_count
= symcount
;
1033 dyn_syms
= (asymbol
**) minisyms
;
1037 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1039 static_count
= symcount
;
1040 static_syms
= (asymbol
**) minisyms
;
1044 dyn_syms
= (asymbol
**) xmalloc (storage
);
1045 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1047 bfd_fatal (bfd_get_filename (abfd
));
1050 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1051 dyn_count
, dyn_syms
, &synthsyms
);
1052 if (synth_count
> 0)
1058 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1059 symp
= (asymbol
**) new_mini
;
1060 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1062 for (i
= 0; i
< synth_count
; i
++)
1063 *symp
++ = synthsyms
+ i
;
1065 minisyms
= new_mini
;
1066 symcount
+= synth_count
;
1070 /* Discard the symbols we don't want to print.
1071 It's OK to do this in place; we'll free the storage anyway
1072 (after printing). */
1074 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1080 sort_dynamic
= dynamic
;
1081 sort_x
= bfd_make_empty_symbol (abfd
);
1082 sort_y
= bfd_make_empty_symbol (abfd
);
1083 if (sort_x
== NULL
|| sort_y
== NULL
)
1084 bfd_fatal (bfd_get_filename (abfd
));
1087 qsort (minisyms
, symcount
, size
,
1088 sorters
[sort_numerically
][reverse_sort
]);
1090 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1095 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1097 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1104 set_print_width (bfd
*file
)
1106 print_width
= bfd_get_arch_size (file
);
1108 if (print_width
== -1)
1111 Guess the target's bitsize based on its name.
1112 We assume here than any 64-bit format will include
1113 "64" somewhere in its name. The only known exception
1114 is the MMO object file format. */
1115 if (strstr (bfd_get_target (file
), "64") != NULL
1116 || strcmp (bfd_get_target (file
), "mmo") == 0)
1124 display_archive (bfd
*file
)
1127 bfd
*last_arfile
= NULL
;
1130 format
->print_archive_filename (bfd_get_filename (file
));
1133 print_symdef_entry (file
);
1139 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1143 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1144 bfd_fatal (bfd_get_filename (file
));
1148 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1150 set_print_width (arfile
);
1151 format
->print_archive_member (bfd_get_filename (file
),
1152 bfd_get_filename (arfile
));
1153 display_rel_file (arfile
, file
);
1157 bfd_nonfatal (bfd_get_filename (arfile
));
1158 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1160 list_matching_formats (matching
);
1165 if (last_arfile
!= NULL
)
1167 bfd_close (last_arfile
);
1168 lineno_cache_bfd
= NULL
;
1169 lineno_cache_rel_bfd
= NULL
;
1171 last_arfile
= arfile
;
1174 if (last_arfile
!= NULL
)
1176 bfd_close (last_arfile
);
1177 lineno_cache_bfd
= NULL
;
1178 lineno_cache_rel_bfd
= NULL
;
1183 display_file (char *filename
)
1185 bfd_boolean retval
= TRUE
;
1189 if (get_file_size (filename
) < 1)
1192 file
= bfd_openr (filename
, target
? target
: plugin_target
);
1195 bfd_nonfatal (filename
);
1199 /* If printing line numbers, decompress the debug sections. */
1201 file
->flags
|= BFD_DECOMPRESS
;
1203 if (bfd_check_format (file
, bfd_archive
))
1205 display_archive (file
);
1207 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1209 set_print_width (file
);
1210 format
->print_object_filename (filename
);
1211 display_rel_file (file
, NULL
);
1215 bfd_nonfatal (filename
);
1216 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1218 list_matching_formats (matching
);
1224 if (!bfd_close (file
))
1225 bfd_fatal (filename
);
1227 lineno_cache_bfd
= NULL
;
1228 lineno_cache_rel_bfd
= NULL
;
1233 /* The following 3 groups of functions are called unconditionally,
1234 once at the start of processing each file of the appropriate type.
1235 They should check `filename_per_file' and `filename_per_symbol',
1236 as appropriate for their output format, to determine whether to
1239 /* Print the name of an object file given on the command line. */
1242 print_object_filename_bsd (char *filename
)
1244 if (filename_per_file
&& !filename_per_symbol
)
1245 printf ("\n%s:\n", filename
);
1249 print_object_filename_sysv (char *filename
)
1252 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1254 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1255 if (print_width
== 32)
1257 Name Value Class Type Size Line Section\n\n"));
1260 Name Value Class Type Size Line Section\n\n"));
1264 print_object_filename_posix (char *filename
)
1266 if (filename_per_file
&& !filename_per_symbol
)
1267 printf ("%s:\n", filename
);
1270 /* Print the name of an archive file given on the command line. */
1273 print_archive_filename_bsd (char *filename
)
1275 if (filename_per_file
)
1276 printf ("\n%s:\n", filename
);
1280 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1285 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1289 /* Print the name of an archive member file. */
1292 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1293 const char *filename
)
1295 if (!filename_per_symbol
)
1296 printf ("\n%s:\n", filename
);
1300 print_archive_member_sysv (char *archive
, const char *filename
)
1303 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1305 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1306 if (print_width
== 32)
1308 Name Value Class Type Size Line Section\n\n"));
1311 Name Value Class Type Size Line Section\n\n"));
1315 print_archive_member_posix (char *archive
, const char *filename
)
1317 if (!filename_per_symbol
)
1318 printf ("%s[%s]:\n", archive
, filename
);
1321 /* Print the name of the file (and archive, if there is one)
1322 containing a symbol. */
1325 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1327 if (filename_per_symbol
)
1330 printf ("%s:", bfd_get_filename (archive_bfd
));
1331 printf ("%s:", bfd_get_filename (abfd
));
1336 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1338 if (filename_per_symbol
)
1341 printf ("%s:", bfd_get_filename (archive_bfd
));
1342 printf ("%s:", bfd_get_filename (abfd
));
1347 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1349 if (filename_per_symbol
)
1352 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1353 bfd_get_filename (abfd
));
1355 printf ("%s: ", bfd_get_filename (abfd
));
1359 /* Print a symbol value. */
1362 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1364 switch (print_width
)
1367 printf (value_format_32bit
, (unsigned long) val
);
1371 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1372 printf (value_format_64bit
, val
);
1374 /* We have a 64 bit value to print, but the host is only 32 bit. */
1375 if (print_radix
== 16)
1376 bfd_fprintf_vma (abfd
, stdout
, val
);
1382 s
= buf
+ sizeof buf
;
1386 *--s
= (val
% print_radix
) + '0';
1389 while ((buf
+ sizeof buf
- 1) - s
< 16)
1397 fatal (_("Print width has not been initialized (%d)"), print_width
);
1402 /* Print a line of information about a symbol. */
1405 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1407 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1409 if (print_width
== 64)
1415 /* Normally we print the value of the symbol. If we are printing the
1416 size or sorting by size then we print its size, except for the
1417 (weird) special case where both flags are defined, in which case we
1418 print both values. This conforms to documented behaviour. */
1419 if (sort_by_size
&& !print_size
)
1420 print_value (abfd
, SYM_SIZE (info
));
1422 print_value (abfd
, SYM_VALUE (info
));
1424 if (print_size
&& SYM_SIZE (info
))
1427 print_value (abfd
, SYM_SIZE (info
));
1431 printf (" %c", SYM_TYPE (info
));
1433 if (SYM_TYPE (info
) == '-')
1437 printf (other_format
, SYM_STAB_OTHER (info
));
1439 printf (desc_format
, SYM_STAB_DESC (info
));
1440 printf (" %5s", SYM_STAB_NAME (info
));
1442 print_symname (" %s", SYM_NAME (info
), abfd
);
1446 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1448 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1450 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1452 if (print_width
== 32)
1458 print_value (abfd
, SYM_VALUE (info
));
1460 printf ("| %c |", SYM_TYPE (info
));
1462 if (SYM_TYPE (info
) == '-')
1465 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1466 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1467 printf ("| |"); /* Line, Section. */
1471 /* Type, Size, Line, Section */
1474 get_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1478 if (SYM_SIZE (info
))
1479 print_value (abfd
, SYM_SIZE (info
));
1482 if (print_width
== 32)
1489 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1496 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1498 print_symname ("%s ", SYM_NAME (info
), abfd
);
1499 printf ("%c ", SYM_TYPE (info
));
1501 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1505 print_value (abfd
, SYM_VALUE (info
));
1507 if (SYM_SIZE (info
))
1508 print_value (abfd
, SYM_SIZE (info
));
1513 main (int argc
, char **argv
)
1518 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1519 setlocale (LC_MESSAGES
, "");
1521 #if defined (HAVE_SETLOCALE)
1522 setlocale (LC_CTYPE
, "");
1523 setlocale (LC_COLLATE
, "");
1525 bindtextdomain (PACKAGE
, LOCALEDIR
);
1526 textdomain (PACKAGE
);
1528 program_name
= *argv
;
1529 xmalloc_set_program_name (program_name
);
1530 #if BFD_SUPPORTS_PLUGINS
1531 bfd_plugin_set_program_name (program_name
);
1534 START_PROGRESS (program_name
, 0);
1536 expandargv (&argc
, &argv
);
1539 set_default_bfd_target ();
1541 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1542 long_options
, (int *) 0)) != EOF
)
1547 print_debug_syms
= 1;
1551 filename_per_symbol
= 1;
1553 case 'B': /* For MIPS compatibility. */
1554 set_output_format ("bsd");
1560 enum demangling_styles style
;
1562 style
= cplus_demangle_name_to_style (optarg
);
1563 if (style
== unknown_demangling
)
1564 fatal (_("unknown demangling style `%s'"),
1567 cplus_demangle_set_style (style
);
1574 /* Ignored for HP/UX compatibility. */
1577 set_output_format (optarg
);
1591 sort_numerically
= 1;
1596 sort_numerically
= 0;
1599 case OPTION_SIZE_SORT
:
1601 sort_numerically
= 0;
1605 set_output_format ("posix");
1617 set_print_radix (optarg
);
1626 /* Ignored for (partial) AIX compatibility. On AIX, the
1627 argument has values 32, 64, or 32_64, and specifies that
1628 only 32-bit, only 64-bit, or both kinds of objects should
1629 be examined. The default is 32. So plain AIX nm on a
1630 library archive with both kinds of objects will ignore
1631 the 64-bit ones. For GNU nm, the default is and always
1632 has been -X 32_64, and other options are not supported. */
1633 if (strcmp (optarg
, "32_64") != 0)
1634 fatal (_("Only -X 32_64 is supported"));
1637 case OPTION_TARGET
: /* --target */
1641 case OPTION_PLUGIN
: /* --plugin */
1642 #if BFD_SUPPORTS_PLUGINS
1643 plugin_target
= "plugin";
1644 bfd_plugin_set_plugin (optarg
);
1646 fatal (_("sorry - this program has been built without plugin support\n"));
1650 case 0: /* A long option that just sets a flag. */
1659 print_version ("nm");
1661 if (sort_by_size
&& undefined_only
)
1663 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1664 non_fatal (_("will produce no output, since undefined symbols have no size."));
1668 /* OK, all options now parsed. If no filename specified, do a.out. */
1670 return !display_file ("a.out");
1674 if (argc
- optind
> 1)
1675 filename_per_file
= 1;
1677 /* We were given several filenames to do. */
1678 while (optind
< argc
)
1681 if (!display_file (argv
[optind
++]))
1685 END_PROGRESS (program_name
);
1690 char *lim
= (char *) sbrk (0);
1692 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));