1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
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 2 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., 59 Temple Place - Suite 330, Boston, MA
28 #include "aout/stab_gnu.h"
29 #include "aout/ranlib.h"
31 #include "libiberty.h"
33 #include "elf/common.h"
35 /* When sorting by size, we use this structure to hold the size and a
36 pointer to the minisymbol. */
44 /* When fetching relocs, we use this structure to pass information to
47 struct get_relocs_info
55 struct extended_symbol_info
59 elf_symbol_type
*elfinfo
;
60 /* FIXME: We should add more fields for Type, Line, Section. */
62 #define SYM_NAME(sym) (sym->sinfo->name)
63 #define SYM_VALUE(sym) (sym->sinfo->value)
64 #define SYM_TYPE(sym) (sym->sinfo->type)
65 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
66 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
67 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
68 #define SYM_SIZE(sym) \
69 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
71 /* The output formatting functions. */
72 static void print_object_filename_bsd (char *);
73 static void print_object_filename_sysv (char *);
74 static void print_object_filename_posix (char *);
75 static void print_archive_filename_bsd (char *);
76 static void print_archive_filename_sysv (char *);
77 static void print_archive_filename_posix (char *);
78 static void print_archive_member_bsd (char *, const char *);
79 static void print_archive_member_sysv (char *, const char *);
80 static void print_archive_member_posix (char *, const char *);
81 static void print_symbol_filename_bsd (bfd
*, bfd
*);
82 static void print_symbol_filename_sysv (bfd
*, bfd
*);
83 static void print_symbol_filename_posix (bfd
*, bfd
*);
84 static void print_value (bfd
*, bfd_vma
);
85 static void print_symbol_info_bsd (struct extended_symbol_info
*, bfd
*);
86 static void print_symbol_info_sysv (struct extended_symbol_info
*, bfd
*);
87 static void print_symbol_info_posix (struct extended_symbol_info
*, bfd
*);
89 /* Support for different output formats. */
92 /* Print the name of an object file given on the command line. */
93 void (*print_object_filename
) (char *);
95 /* Print the name of an archive file given on the command line. */
96 void (*print_archive_filename
) (char *);
98 /* Print the name of an archive member file. */
99 void (*print_archive_member
) (char *, const char *);
101 /* Print the name of the file (and archive, if there is one)
102 containing a symbol. */
103 void (*print_symbol_filename
) (bfd
*, bfd
*);
105 /* Print a line of information about a symbol. */
106 void (*print_symbol_info
) (struct extended_symbol_info
*, bfd
*);
109 static struct output_fns formats
[] =
111 {print_object_filename_bsd
,
112 print_archive_filename_bsd
,
113 print_archive_member_bsd
,
114 print_symbol_filename_bsd
,
115 print_symbol_info_bsd
},
116 {print_object_filename_sysv
,
117 print_archive_filename_sysv
,
118 print_archive_member_sysv
,
119 print_symbol_filename_sysv
,
120 print_symbol_info_sysv
},
121 {print_object_filename_posix
,
122 print_archive_filename_posix
,
123 print_archive_member_posix
,
124 print_symbol_filename_posix
,
125 print_symbol_info_posix
}
128 /* Indices in `formats'. */
130 #define FORMAT_SYSV 1
131 #define FORMAT_POSIX 2
132 #define FORMAT_DEFAULT FORMAT_BSD
134 /* The output format to use. */
135 static struct output_fns
*format
= &formats
[FORMAT_DEFAULT
];
137 /* Command options. */
139 static int do_demangle
= 0; /* Pretty print C++ symbol names. */
140 static int external_only
= 0; /* Print external symbols only. */
141 static int defined_only
= 0; /* Print defined symbols only. */
142 static int no_sort
= 0; /* Don't sort; print syms in order found. */
143 static int print_debug_syms
= 0;/* Print debugger-only symbols too. */
144 static int print_armap
= 0; /* Describe __.SYMDEF data in archive files. */
145 static int print_size
= 0; /* Print size of defined symbols. */
146 static int reverse_sort
= 0; /* Sort in downward(alpha or numeric) order. */
147 static int sort_numerically
= 0;/* Sort in numeric rather than alpha order. */
148 static int sort_by_size
= 0; /* Sort by size of symbol. */
149 static int undefined_only
= 0; /* Print undefined symbols only. */
150 static int dynamic
= 0; /* Print dynamic symbols. */
151 static int show_version
= 0; /* Show the version number. */
152 static int show_stats
= 0; /* Show statistics. */
153 static int show_synthetic
= 0; /* Display synthesized symbols too. */
154 static int line_numbers
= 0; /* Print line numbers for symbols. */
156 /* When to print the names of files. Not mutually exclusive in SYSV format. */
157 static int filename_per_file
= 0; /* Once per file, on its own line. */
158 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
160 /* Print formats for printing a symbol value. */
162 static char value_format
[] = "%08lx";
164 #if BFD_HOST_64BIT_LONG
165 static char value_format
[] = "%016lx";
167 /* We don't use value_format for this case. */
171 static int print_width
= 16;
173 static int print_width
= 8;
175 static int print_radix
= 16;
176 /* Print formats for printing stab info. */
177 static char other_format
[] = "%02x";
178 static char desc_format
[] = "%04x";
180 static char *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
188 static struct option long_options
[] =
190 {"debug-syms", no_argument
, &print_debug_syms
, 1},
191 {"demangle", optional_argument
, 0, 'C'},
192 {"dynamic", no_argument
, &dynamic
, 1},
193 {"extern-only", no_argument
, &external_only
, 1},
194 {"format", required_argument
, 0, 'f'},
195 {"help", no_argument
, 0, 'h'},
196 {"line-numbers", no_argument
, 0, 'l'},
197 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
198 {"no-demangle", no_argument
, &do_demangle
, 0},
199 {"no-sort", no_argument
, &no_sort
, 1},
200 {"numeric-sort", no_argument
, &sort_numerically
, 1},
201 {"portability", no_argument
, 0, 'P'},
202 {"print-armap", no_argument
, &print_armap
, 1},
203 {"print-file-name", no_argument
, 0, 'o'},
204 {"print-size", no_argument
, 0, 'S'},
205 {"radix", required_argument
, 0, 't'},
206 {"reverse-sort", no_argument
, &reverse_sort
, 1},
207 {"size-sort", no_argument
, &sort_by_size
, 1},
208 {"stats", no_argument
, &show_stats
, 1},
209 {"synthetic", no_argument
, &show_synthetic
, 1},
210 {"target", required_argument
, 0, OPTION_TARGET
},
211 {"defined-only", no_argument
, &defined_only
, 1},
212 {"undefined-only", no_argument
, &undefined_only
, 1},
213 {"version", no_argument
, &show_version
, 1},
214 {0, no_argument
, 0, 0}
217 /* Some error-reporting functions. */
220 usage (FILE *stream
, int status
)
222 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
223 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
224 fprintf (stream
, _(" The options are:\n\
225 -a, --debug-syms Display debugger-only symbols\n\
226 -A, --print-file-name Print name of the input file before every symbol\n\
227 -B Same as --format=bsd\n\
228 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
229 The STYLE, if specified, can be `auto' (the default),\n\
230 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
232 --no-demangle Do not demangle low-level symbol names\n\
233 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
234 --defined-only Display only defined symbols\n\
236 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
237 `sysv' or `posix'. The default is `bsd'\n\
238 -g, --extern-only Display only external symbols\n\
239 -l, --line-numbers Use debugging information to find a filename and\n\
240 line number for each symbol\n\
241 -n, --numeric-sort Sort symbols numerically by address\n\
243 -p, --no-sort Do not sort the symbols\n\
244 -P, --portability Same as --format=posix\n\
245 -r, --reverse-sort Reverse the sense of the sort\n\
246 -S, --print-size Print size of defined symbols\n\
247 -s, --print-armap Include index for symbols from archive members\n\
248 --size-sort Sort symbols by size\n\
249 --synthetic Display synthetic symbols as well\n\
250 -t, --radix=RADIX Use RADIX for printing symbol values\n\
251 --target=BFDNAME Specify the target object format as BFDNAME\n\
252 -u, --undefined-only Display only undefined symbols\n\
253 -X 32_64 (ignored)\n\
254 -h, --help Display this information\n\
255 -V, --version Display this program's version number\n\
257 list_supported_targets (program_name
, stream
);
259 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
263 /* Set the radix for the symbol value and size according to RADIX. */
266 set_print_radix (char *radix
)
279 value_format
[4] = *radix
;
281 #if BFD_HOST_64BIT_LONG
282 value_format
[5] = *radix
;
284 /* This case requires special handling for octal and decimal
288 other_format
[3] = desc_format
[3] = *radix
;
291 fatal (_("%s: invalid radix"), radix
);
296 set_output_format (char *f
)
315 fatal (_("%s: invalid output format"), f
);
317 format
= &formats
[i
];
321 get_symbol_type (unsigned int type
)
323 static char buff
[32];
327 case STT_NOTYPE
: return "NOTYPE";
328 case STT_OBJECT
: return "OBJECT";
329 case STT_FUNC
: return "FUNC";
330 case STT_SECTION
: return "SECTION";
331 case STT_FILE
: return "FILE";
332 case STT_COMMON
: return "COMMON";
333 case STT_TLS
: return "TLS";
335 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
336 sprintf (buff
, _("<processor specific>: %d"), type
);
337 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
338 sprintf (buff
, _("<OS specific>: %d"), type
);
340 sprintf (buff
, _("<unknown>: %d"), type
);
345 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
346 demangling it if requested. */
349 print_symname (const char *format
, const char *name
, bfd
*abfd
)
351 if (do_demangle
&& *name
)
353 char *res
= demangle (abfd
, name
);
355 printf (format
, res
);
360 printf (format
, name
);
364 print_symdef_entry (bfd
*abfd
)
366 symindex idx
= BFD_NO_MORE_SYMBOLS
;
368 bfd_boolean everprinted
= FALSE
;
370 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
371 idx
!= BFD_NO_MORE_SYMBOLS
;
372 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
377 printf (_("\nArchive index:\n"));
380 elt
= bfd_get_elt_at_index (abfd
, idx
);
382 bfd_fatal ("bfd_get_elt_at_index");
383 if (thesym
->name
!= (char *) NULL
)
385 print_symname ("%s", thesym
->name
, abfd
);
386 printf (" in %s\n", bfd_get_filename (elt
));
391 /* Choose which symbol entries to print;
392 compact them downward to get rid of the rest.
393 Return the number of symbols to be printed. */
396 filter_symbols (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
,
397 long symcount
, unsigned int size
)
399 bfd_byte
*from
, *fromend
, *to
;
402 store
= bfd_make_empty_symbol (abfd
);
404 bfd_fatal (bfd_get_filename (abfd
));
406 from
= (bfd_byte
*) minisyms
;
407 fromend
= from
+ symcount
* size
;
408 to
= (bfd_byte
*) minisyms
;
410 for (; from
< fromend
; from
+= size
)
417 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const void *) from
, store
);
419 bfd_fatal (bfd_get_filename (abfd
));
422 keep
= bfd_is_und_section (sym
->section
);
423 else if (external_only
)
424 keep
= ((sym
->flags
& BSF_GLOBAL
) != 0
425 || (sym
->flags
& BSF_WEAK
) != 0
426 || bfd_is_und_section (sym
->section
)
427 || bfd_is_com_section (sym
->section
));
432 && ! print_debug_syms
433 && (sym
->flags
& BSF_DEBUGGING
) != 0)
438 && (bfd_is_abs_section (sym
->section
)
439 || bfd_is_und_section (sym
->section
)))
445 if (bfd_is_und_section (sym
->section
))
451 memcpy (to
, from
, size
);
456 return (to
- (bfd_byte
*) minisyms
) / size
;
459 /* These globals are used to pass information into the sorting
461 static bfd
*sort_bfd
;
462 static bfd_boolean sort_dynamic
;
463 static asymbol
*sort_x
;
464 static asymbol
*sort_y
;
466 /* Symbol-sorting predicates */
467 #define valueof(x) ((x)->section->vma + (x)->value)
469 /* Numeric sorts. Undefined symbols are always considered "less than"
470 defined symbols with zero values. Common symbols are not treated
471 specially -- i.e., their sizes are used as their "values". */
474 non_numeric_forward (const void *P_x
, const void *P_y
)
479 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
480 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
481 if (x
== NULL
|| y
== NULL
)
482 bfd_fatal (bfd_get_filename (sort_bfd
));
484 xn
= bfd_asymbol_name (x
);
485 yn
= bfd_asymbol_name (y
);
493 /* Solaris 2.5 has a bug in strcoll.
494 strcoll returns invalid values when confronted with empty strings. */
500 return strcoll (xn
, yn
);
502 return strcmp (xn
, yn
);
507 non_numeric_reverse (const void *x
, const void *y
)
509 return - non_numeric_forward (x
, y
);
513 numeric_forward (const void *P_x
, const void *P_y
)
518 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
519 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
520 if (x
== NULL
|| y
== NULL
)
521 bfd_fatal (bfd_get_filename (sort_bfd
));
523 xs
= bfd_get_section (x
);
524 ys
= bfd_get_section (y
);
526 if (bfd_is_und_section (xs
))
528 if (! bfd_is_und_section (ys
))
531 else if (bfd_is_und_section (ys
))
533 else if (valueof (x
) != valueof (y
))
534 return valueof (x
) < valueof (y
) ? -1 : 1;
536 return non_numeric_forward (P_x
, P_y
);
540 numeric_reverse (const void *x
, const void *y
)
542 return - numeric_forward (x
, y
);
545 static int (*(sorters
[2][2])) (const void *, const void *) =
547 { non_numeric_forward
, non_numeric_reverse
},
548 { numeric_forward
, numeric_reverse
}
551 /* This sort routine is used by sort_symbols_by_size. It is similar
552 to numeric_forward, but when symbols have the same value it sorts
553 by section VMA. This simplifies the sort_symbols_by_size code
554 which handles symbols at the end of sections. Also, this routine
555 tries to sort file names before other symbols with the same value.
556 That will make the file name have a zero size, which will make
557 sort_symbols_by_size choose the non file name symbol, leading to
558 more meaningful output. For similar reasons, this code sorts
559 gnu_compiled_* and gcc2_compiled before other symbols with the same
563 size_forward1 (const void *P_x
, const void *P_y
)
571 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
572 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
573 if (x
== NULL
|| y
== NULL
)
574 bfd_fatal (bfd_get_filename (sort_bfd
));
576 xs
= bfd_get_section (x
);
577 ys
= bfd_get_section (y
);
579 if (bfd_is_und_section (xs
))
581 if (bfd_is_und_section (ys
))
584 if (valueof (x
) != valueof (y
))
585 return valueof (x
) < valueof (y
) ? -1 : 1;
587 if (xs
->vma
!= ys
->vma
)
588 return xs
->vma
< ys
->vma
? -1 : 1;
590 xn
= bfd_asymbol_name (x
);
591 yn
= bfd_asymbol_name (y
);
595 /* The symbols gnu_compiled and gcc2_compiled convey even less
596 information than the file name, so sort them out first. */
598 xf
= (strstr (xn
, "gnu_compiled") != NULL
599 || strstr (xn
, "gcc2_compiled") != NULL
);
600 yf
= (strstr (yn
, "gnu_compiled") != NULL
601 || strstr (yn
, "gcc2_compiled") != NULL
);
608 /* We use a heuristic for the file name. It may not work on non
609 Unix systems, but it doesn't really matter; the only difference
610 is precisely which symbol names get printed. */
612 #define file_symbol(s, sn, snl) \
613 (((s)->flags & BSF_FILE) != 0 \
614 || ((sn)[(snl) - 2] == '.' \
615 && ((sn)[(snl) - 1] == 'o' \
616 || (sn)[(snl) - 1] == 'a')))
618 xf
= file_symbol (x
, xn
, xnl
);
619 yf
= file_symbol (y
, yn
, ynl
);
626 return non_numeric_forward (P_x
, P_y
);
629 /* This sort routine is used by sort_symbols_by_size. It is sorting
630 an array of size_sym structures into size order. */
633 size_forward2 (const void *P_x
, const void *P_y
)
635 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
636 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
638 if (x
->size
< y
->size
)
639 return reverse_sort
? 1 : -1;
640 else if (x
->size
> y
->size
)
641 return reverse_sort
? -1 : 1;
643 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
646 /* Sort the symbols by size. ELF provides a size but for other formats
647 we have to make a guess by assuming that the difference between the
648 address of a symbol and the address of the next higher symbol is the
652 sort_symbols_by_size (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
,
653 long symcount
, unsigned int size
,
654 struct size_sym
**symsizesp
)
656 struct size_sym
*symsizes
;
657 bfd_byte
*from
, *fromend
;
659 asymbol
*store_sym
, *store_next
;
661 qsort (minisyms
, symcount
, size
, size_forward1
);
663 /* We are going to return a special set of symbols and sizes to
665 symsizes
= xmalloc (symcount
* sizeof (struct size_sym
));
666 *symsizesp
= symsizes
;
668 /* Note that filter_symbols has already removed all absolute and
669 undefined symbols. Here we remove all symbols whose size winds
671 from
= (bfd_byte
*) minisyms
;
672 fromend
= from
+ symcount
* size
;
679 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const void *) from
,
682 bfd_fatal (bfd_get_filename (abfd
));
685 for (; from
< fromend
; from
+= size
)
692 if (from
+ size
< fromend
)
694 next
= bfd_minisymbol_to_symbol (abfd
,
696 (const void *) (from
+ size
),
699 bfd_fatal (bfd_get_filename (abfd
));
704 sec
= bfd_get_section (sym
);
706 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
707 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
708 else if (bfd_is_com_section (sec
))
712 if (from
+ size
< fromend
713 && sec
== bfd_get_section (next
))
714 sz
= valueof (next
) - valueof (sym
);
716 sz
= (bfd_get_section_vma (abfd
, sec
)
717 + bfd_section_size (abfd
, sec
)
723 symsizes
->minisym
= (const void *) from
;
731 store_sym
= store_next
;
735 symcount
= symsizes
- *symsizesp
;
737 /* We must now sort again by size. */
738 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
743 /* This function is used to get the relocs for a particular section.
744 It is called via bfd_map_over_sections. */
747 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
749 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
753 if ((sec
->flags
& SEC_RELOC
) == 0)
755 *data
->relocs
= NULL
;
762 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
764 bfd_fatal (bfd_get_filename (abfd
));
766 *data
->relocs
= xmalloc (relsize
);
767 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
769 if (*data
->relcount
< 0)
770 bfd_fatal (bfd_get_filename (abfd
));
778 /* Print a single symbol. */
781 print_symbol (bfd
*abfd
, asymbol
*sym
, bfd_vma ssize
, bfd
*archive_bfd
)
784 struct extended_symbol_info info
;
788 format
->print_symbol_filename (archive_bfd
, abfd
);
790 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
791 info
.sinfo
= &syminfo
;
793 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
794 info
.elfinfo
= (elf_symbol_type
*) sym
;
797 format
->print_symbol_info (&info
, abfd
);
801 static asymbol
**syms
;
802 static long symcount
;
803 const char *filename
, *functionname
;
806 /* We need to get the canonical symbols in order to call
807 bfd_find_nearest_line. This is inefficient, but, then, you
808 don't have to use --line-numbers. */
809 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
818 symsize
= bfd_get_symtab_upper_bound (abfd
);
820 bfd_fatal (bfd_get_filename (abfd
));
821 syms
= xmalloc (symsize
);
822 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
824 bfd_fatal (bfd_get_filename (abfd
));
825 lineno_cache_bfd
= abfd
;
828 if (bfd_is_und_section (bfd_get_section (sym
)))
830 static asection
**secs
;
831 static arelent
***relocs
;
832 static long *relcount
;
833 static unsigned int seccount
;
837 /* For an undefined symbol, we try to find a reloc for the
838 symbol, and print the line number of the reloc. */
839 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
841 for (i
= 0; i
< seccount
; i
++)
842 if (relocs
[i
] != NULL
)
854 struct get_relocs_info info
;
856 seccount
= bfd_count_sections (abfd
);
858 secs
= xmalloc (seccount
* sizeof *secs
);
859 relocs
= xmalloc (seccount
* sizeof *relocs
);
860 relcount
= xmalloc (seccount
* sizeof *relcount
);
863 info
.relocs
= relocs
;
864 info
.relcount
= relcount
;
866 bfd_map_over_sections (abfd
, get_relocs
, (void *) &info
);
867 lineno_cache_rel_bfd
= abfd
;
870 symname
= bfd_asymbol_name (sym
);
871 for (i
= 0; i
< seccount
; i
++)
875 for (j
= 0; j
< relcount
[i
]; j
++)
880 if (r
->sym_ptr_ptr
!= NULL
881 && (*r
->sym_ptr_ptr
)->section
== sym
->section
882 && (*r
->sym_ptr_ptr
)->value
== sym
->value
884 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
885 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
886 r
->address
, &filename
,
887 &functionname
, &lineno
)
890 /* We only print the first one we find. */
891 printf ("\t%s:%u", filename
, lineno
);
898 else if (bfd_get_section (sym
)->owner
== abfd
)
900 if (bfd_find_nearest_line (abfd
, bfd_get_section (sym
), syms
,
901 sym
->value
, &filename
, &functionname
,
905 printf ("\t%s:%u", filename
, lineno
);
912 /* Print the symbols when sorting by size. */
915 print_size_symbols (bfd
*abfd
, bfd_boolean dynamic
,
916 struct size_sym
*symsizes
, long symcount
,
920 struct size_sym
*from
, *fromend
;
922 store
= bfd_make_empty_symbol (abfd
);
924 bfd_fatal (bfd_get_filename (abfd
));
927 fromend
= from
+ symcount
;
928 for (; from
< fromend
; from
++)
933 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
->minisym
, store
);
935 bfd_fatal (bfd_get_filename (abfd
));
937 /* For elf we have already computed the correct symbol size. */
938 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
941 ssize
= from
->size
- bfd_section_vma (abfd
, bfd_get_section (sym
));
943 print_symbol (abfd
, sym
, ssize
, archive_bfd
);
948 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
952 print_symbols (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
, long symcount
,
953 unsigned int size
, bfd
*archive_bfd
)
956 bfd_byte
*from
, *fromend
;
958 store
= bfd_make_empty_symbol (abfd
);
960 bfd_fatal (bfd_get_filename (abfd
));
962 from
= (bfd_byte
*) minisyms
;
963 fromend
= from
+ symcount
* size
;
964 for (; from
< fromend
; from
+= size
)
968 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
, store
);
970 bfd_fatal (bfd_get_filename (abfd
));
972 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
976 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
979 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
984 struct size_sym
*symsizes
;
988 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
990 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
995 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
997 bfd_fatal (bfd_get_filename (abfd
));
1001 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
1005 if (show_synthetic
&& size
== sizeof (asymbol
*))
1009 asymbol
**static_syms
= NULL
;
1010 asymbol
**dyn_syms
= NULL
;
1011 long static_count
= 0;
1016 dyn_count
= symcount
;
1017 dyn_syms
= minisyms
;
1021 static_count
= symcount
;
1022 static_syms
= minisyms
;
1024 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1025 dyn_count
, dyn_syms
, &synthsyms
);
1026 if (synth_count
> 0)
1032 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1034 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1036 for (i
= 0; i
< synth_count
; i
++)
1037 *symp
++ = synthsyms
+ i
;
1039 minisyms
= new_mini
;
1040 symcount
+= synth_count
;
1044 /* Discard the symbols we don't want to print.
1045 It's OK to do this in place; we'll free the storage anyway
1046 (after printing). */
1048 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1054 sort_dynamic
= dynamic
;
1055 sort_x
= bfd_make_empty_symbol (abfd
);
1056 sort_y
= bfd_make_empty_symbol (abfd
);
1057 if (sort_x
== NULL
|| sort_y
== NULL
)
1058 bfd_fatal (bfd_get_filename (abfd
));
1061 qsort (minisyms
, symcount
, size
,
1062 sorters
[sort_numerically
][reverse_sort
]);
1064 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1069 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1071 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1077 display_archive (bfd
*file
)
1080 bfd
*last_arfile
= NULL
;
1083 format
->print_archive_filename (bfd_get_filename (file
));
1086 print_symdef_entry (file
);
1092 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1096 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1097 bfd_fatal (bfd_get_filename (file
));
1101 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1105 bfd_sprintf_vma (arfile
, buf
, (bfd_vma
) -1);
1106 print_width
= strlen (buf
);
1107 format
->print_archive_member (bfd_get_filename (file
),
1108 bfd_get_filename (arfile
));
1109 display_rel_file (arfile
, file
);
1113 bfd_nonfatal (bfd_get_filename (arfile
));
1114 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1116 list_matching_formats (matching
);
1121 if (last_arfile
!= NULL
)
1123 bfd_close (last_arfile
);
1124 lineno_cache_bfd
= NULL
;
1125 lineno_cache_rel_bfd
= NULL
;
1127 last_arfile
= arfile
;
1130 if (last_arfile
!= NULL
)
1132 bfd_close (last_arfile
);
1133 lineno_cache_bfd
= NULL
;
1134 lineno_cache_rel_bfd
= NULL
;
1139 display_file (char *filename
)
1141 bfd_boolean retval
= TRUE
;
1145 if (get_file_size (filename
) < 1)
1148 file
= bfd_openr (filename
, target
);
1151 bfd_nonfatal (filename
);
1155 if (bfd_check_format (file
, bfd_archive
))
1157 display_archive (file
);
1159 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1163 bfd_sprintf_vma (file
, buf
, (bfd_vma
) -1);
1164 print_width
= strlen (buf
);
1165 format
->print_object_filename (filename
);
1166 display_rel_file (file
, NULL
);
1170 bfd_nonfatal (filename
);
1171 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1173 list_matching_formats (matching
);
1179 if (!bfd_close (file
))
1180 bfd_fatal (filename
);
1182 lineno_cache_bfd
= NULL
;
1183 lineno_cache_rel_bfd
= NULL
;
1188 /* The following 3 groups of functions are called unconditionally,
1189 once at the start of processing each file of the appropriate type.
1190 They should check `filename_per_file' and `filename_per_symbol',
1191 as appropriate for their output format, to determine whether to
1194 /* Print the name of an object file given on the command line. */
1197 print_object_filename_bsd (char *filename
)
1199 if (filename_per_file
&& !filename_per_symbol
)
1200 printf ("\n%s:\n", filename
);
1204 print_object_filename_sysv (char *filename
)
1207 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1209 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1210 if (print_width
== 8)
1212 Name Value Class Type Size Line Section\n\n"));
1215 Name Value Class Type Size Line Section\n\n"));
1219 print_object_filename_posix (char *filename
)
1221 if (filename_per_file
&& !filename_per_symbol
)
1222 printf ("%s:\n", filename
);
1225 /* Print the name of an archive file given on the command line. */
1228 print_archive_filename_bsd (char *filename
)
1230 if (filename_per_file
)
1231 printf ("\n%s:\n", filename
);
1235 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1240 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1244 /* Print the name of an archive member file. */
1247 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1248 const char *filename
)
1250 if (!filename_per_symbol
)
1251 printf ("\n%s:\n", filename
);
1255 print_archive_member_sysv (char *archive
, const char *filename
)
1258 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1260 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1261 if (print_width
== 8)
1263 Name Value Class Type Size Line Section\n\n"));
1266 Name Value Class Type Size Line Section\n\n"));
1270 print_archive_member_posix (char *archive
, const char *filename
)
1272 if (!filename_per_symbol
)
1273 printf ("%s[%s]:\n", archive
, filename
);
1276 /* Print the name of the file (and archive, if there is one)
1277 containing a symbol. */
1280 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1282 if (filename_per_symbol
)
1285 printf ("%s:", bfd_get_filename (archive_bfd
));
1286 printf ("%s:", bfd_get_filename (abfd
));
1291 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1293 if (filename_per_symbol
)
1296 printf ("%s:", bfd_get_filename (archive_bfd
));
1297 printf ("%s:", bfd_get_filename (abfd
));
1302 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1304 if (filename_per_symbol
)
1307 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1308 bfd_get_filename (abfd
));
1310 printf ("%s: ", bfd_get_filename (abfd
));
1314 /* Print a symbol value. */
1317 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1319 #if ! defined (BFD64) || BFD_HOST_64BIT_LONG
1320 printf (value_format
, val
);
1322 /* We have a 64 bit value to print, but the host is only 32 bit. */
1323 if (print_radix
== 16)
1324 bfd_fprintf_vma (abfd
, stdout
, val
);
1330 s
= buf
+ sizeof buf
;
1334 *--s
= (val
% print_radix
) + '0';
1337 while ((buf
+ sizeof buf
- 1) - s
< 16)
1344 /* Print a line of information about a symbol. */
1347 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1349 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1351 if (print_width
== 16)
1357 /* Normally we print the value of the symbol. If we are printing the
1358 size or sorting by size then we print its size, except for the
1359 (weird) special case where both flags are defined, in which case we
1360 print both values. This conforms to documented behaviour. */
1361 if (sort_by_size
&& !print_size
)
1362 print_value (abfd
, SYM_SIZE (info
));
1364 print_value (abfd
, SYM_VALUE (info
));
1366 if (print_size
&& SYM_SIZE (info
))
1369 print_value (abfd
, SYM_SIZE (info
));
1373 printf (" %c", SYM_TYPE (info
));
1375 if (SYM_TYPE (info
) == '-')
1379 printf (other_format
, SYM_STAB_OTHER (info
));
1381 printf (desc_format
, SYM_STAB_DESC (info
));
1382 printf (" %5s", SYM_STAB_NAME (info
));
1384 print_symname (" %s", SYM_NAME (info
), abfd
);
1388 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1390 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1392 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1394 if (print_width
== 8)
1400 print_value (abfd
, SYM_VALUE (info
));
1402 printf ("| %c |", SYM_TYPE (info
));
1404 if (SYM_TYPE (info
) == '-')
1407 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1408 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1409 printf ("| |"); /* Line, Section. */
1413 /* Type, Size, Line, Section */
1416 get_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1420 if (SYM_SIZE (info
))
1421 print_value (abfd
, SYM_SIZE (info
));
1424 if (print_width
== 8)
1431 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1438 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1440 print_symname ("%s ", SYM_NAME (info
), abfd
);
1441 printf ("%c ", SYM_TYPE (info
));
1443 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1447 print_value (abfd
, SYM_VALUE (info
));
1449 if (SYM_SIZE (info
))
1450 print_value (abfd
, SYM_SIZE (info
));
1455 main (int argc
, char **argv
)
1460 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1461 setlocale (LC_MESSAGES
, "");
1463 #if defined (HAVE_SETLOCALE)
1464 setlocale (LC_CTYPE
, "");
1465 setlocale (LC_COLLATE
, "");
1467 bindtextdomain (PACKAGE
, LOCALEDIR
);
1468 textdomain (PACKAGE
);
1470 program_name
= *argv
;
1471 xmalloc_set_program_name (program_name
);
1473 START_PROGRESS (program_name
, 0);
1476 set_default_bfd_target ();
1478 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1479 long_options
, (int *) 0)) != EOF
)
1484 print_debug_syms
= 1;
1488 filename_per_symbol
= 1;
1490 case 'B': /* For MIPS compatibility. */
1491 set_output_format ("bsd");
1497 enum demangling_styles style
;
1499 style
= cplus_demangle_name_to_style (optarg
);
1500 if (style
== unknown_demangling
)
1501 fatal (_("unknown demangling style `%s'"),
1504 cplus_demangle_set_style (style
);
1511 /* Ignored for HP/UX compatibility. */
1514 set_output_format (optarg
);
1527 sort_numerically
= 1;
1533 set_output_format ("posix");
1545 set_print_radix (optarg
);
1554 /* Ignored for (partial) AIX compatibility. On AIX, the
1555 argument has values 32, 64, or 32_64, and specifies that
1556 only 32-bit, only 64-bit, or both kinds of objects should
1557 be examined. The default is 32. So plain AIX nm on a
1558 library archive with both kinds of objects will ignore
1559 the 64-bit ones. For GNU nm, the default is and always
1560 has been -X 32_64, and other options are not supported. */
1561 if (strcmp (optarg
, "32_64") != 0)
1562 fatal (_("Only -X 32_64 is supported"));
1565 case OPTION_TARGET
: /* --target */
1569 case 0: /* A long option that just sets a flag. */
1578 print_version ("nm");
1580 if (sort_by_size
&& undefined_only
)
1582 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1583 non_fatal (_("will produce no output, since undefined symbols have no size."));
1587 /* OK, all options now parsed. If no filename specified, do a.out. */
1589 return !display_file ("a.out");
1593 if (argc
- optind
> 1)
1594 filename_per_file
= 1;
1596 /* We were given several filenames to do. */
1597 while (optind
< argc
)
1600 if (!display_file (argv
[optind
++]))
1604 END_PROGRESS (program_name
);
1609 char *lim
= (char *) sbrk (0);
1611 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));