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
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., 51 Franklin Street - Fifth Floor, 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. */
155 static int allow_special_symbols
= 0; /* Allow special symbols. */
157 /* When to print the names of files. Not mutually exclusive in SYSV format. */
158 static int filename_per_file
= 0; /* Once per file, on its own line. */
159 static int filename_per_symbol
= 0; /* Once per symbol, at start of line. */
161 /* Print formats for printing a symbol value. */
162 static char value_format_32bit
[] = "%08lx";
163 static char value_format_64bit
[] = "%016lx";
164 static int print_width
= 0;
165 static int print_radix
= 16;
166 /* Print formats for printing stab info. */
167 static char other_format
[] = "%02x";
168 static char desc_format
[] = "%04x";
170 static char *target
= NULL
;
172 /* Used to cache the line numbers for a BFD. */
173 static bfd
*lineno_cache_bfd
;
174 static bfd
*lineno_cache_rel_bfd
;
176 #define OPTION_TARGET 200
178 static struct option long_options
[] =
180 {"debug-syms", no_argument
, &print_debug_syms
, 1},
181 {"demangle", optional_argument
, 0, 'C'},
182 {"dynamic", no_argument
, &dynamic
, 1},
183 {"extern-only", no_argument
, &external_only
, 1},
184 {"format", required_argument
, 0, 'f'},
185 {"help", no_argument
, 0, 'h'},
186 {"line-numbers", no_argument
, 0, 'l'},
187 {"no-cplus", no_argument
, &do_demangle
, 0}, /* Linux compatibility. */
188 {"no-demangle", no_argument
, &do_demangle
, 0},
189 {"no-sort", no_argument
, &no_sort
, 1},
190 {"numeric-sort", no_argument
, &sort_numerically
, 1},
191 {"portability", no_argument
, 0, 'P'},
192 {"print-armap", no_argument
, &print_armap
, 1},
193 {"print-file-name", no_argument
, 0, 'o'},
194 {"print-size", no_argument
, 0, 'S'},
195 {"radix", required_argument
, 0, 't'},
196 {"reverse-sort", no_argument
, &reverse_sort
, 1},
197 {"size-sort", no_argument
, &sort_by_size
, 1},
198 {"special-syms", no_argument
, &allow_special_symbols
, 1},
199 {"stats", no_argument
, &show_stats
, 1},
200 {"synthetic", no_argument
, &show_synthetic
, 1},
201 {"target", required_argument
, 0, OPTION_TARGET
},
202 {"defined-only", no_argument
, &defined_only
, 1},
203 {"undefined-only", no_argument
, &undefined_only
, 1},
204 {"version", no_argument
, &show_version
, 1},
205 {0, no_argument
, 0, 0}
208 /* Some error-reporting functions. */
211 usage (FILE *stream
, int status
)
213 fprintf (stream
, _("Usage: %s [option(s)] [file(s)]\n"), program_name
);
214 fprintf (stream
, _(" List symbols in [file(s)] (a.out by default).\n"));
215 fprintf (stream
, _(" The options are:\n\
216 -a, --debug-syms Display debugger-only symbols\n\
217 -A, --print-file-name Print name of the input file before every symbol\n\
218 -B Same as --format=bsd\n\
219 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
220 The STYLE, if specified, can be `auto' (the default),\n\
221 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
223 --no-demangle Do not demangle low-level symbol names\n\
224 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
225 --defined-only Display only defined symbols\n\
227 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
228 `sysv' or `posix'. The default is `bsd'\n\
229 -g, --extern-only Display only external symbols\n\
230 -l, --line-numbers Use debugging information to find a filename and\n\
231 line number for each symbol\n\
232 -n, --numeric-sort Sort symbols numerically by address\n\
234 -p, --no-sort Do not sort the symbols\n\
235 -P, --portability Same as --format=posix\n\
236 -r, --reverse-sort Reverse the sense of the sort\n\
237 -S, --print-size Print size of defined symbols\n\
238 -s, --print-armap Include index for symbols from archive members\n\
239 --size-sort Sort symbols by size\n\
240 --special-syms Include special symbols in the output\n\
241 --synthetic Display synthetic symbols as well\n\
242 -t, --radix=RADIX Use RADIX for printing symbol values\n\
243 --target=BFDNAME Specify the target object format as BFDNAME\n\
244 -u, --undefined-only Display only undefined symbols\n\
245 -X 32_64 (ignored)\n\
246 @FILE Read options from FILE\n\
247 -h, --help Display this information\n\
248 -V, --version Display this program's version number\n\
250 list_supported_targets (program_name
, stream
);
251 if (REPORT_BUGS_TO
[0] && status
== 0)
252 fprintf (stream
, _("Report bugs to %s.\n"), REPORT_BUGS_TO
);
256 /* Set the radix for the symbol value and size according to RADIX. */
259 set_print_radix (char *radix
)
271 value_format_32bit
[4] = *radix
;
272 value_format_64bit
[5] = *radix
;
273 other_format
[3] = desc_format
[3] = *radix
;
276 fatal (_("%s: invalid radix"), radix
);
281 set_output_format (char *f
)
300 fatal (_("%s: invalid output format"), f
);
302 format
= &formats
[i
];
306 get_symbol_type (unsigned int type
)
308 static char buff
[32];
312 case STT_NOTYPE
: return "NOTYPE";
313 case STT_OBJECT
: return "OBJECT";
314 case STT_FUNC
: return "FUNC";
315 case STT_SECTION
: return "SECTION";
316 case STT_FILE
: return "FILE";
317 case STT_COMMON
: return "COMMON";
318 case STT_TLS
: return "TLS";
320 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
321 sprintf (buff
, _("<processor specific>: %d"), type
);
322 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
323 sprintf (buff
, _("<OS specific>: %d"), type
);
325 sprintf (buff
, _("<unknown>: %d"), type
);
330 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
331 demangling it if requested. */
334 print_symname (const char *format
, const char *name
, bfd
*abfd
)
336 if (do_demangle
&& *name
)
338 char *res
= demangle (abfd
, name
);
340 printf (format
, res
);
345 printf (format
, name
);
349 print_symdef_entry (bfd
*abfd
)
351 symindex idx
= BFD_NO_MORE_SYMBOLS
;
353 bfd_boolean everprinted
= FALSE
;
355 for (idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
);
356 idx
!= BFD_NO_MORE_SYMBOLS
;
357 idx
= bfd_get_next_mapent (abfd
, idx
, &thesym
))
362 printf (_("\nArchive index:\n"));
365 elt
= bfd_get_elt_at_index (abfd
, idx
);
367 bfd_fatal ("bfd_get_elt_at_index");
368 if (thesym
->name
!= (char *) NULL
)
370 print_symname ("%s", thesym
->name
, abfd
);
371 printf (" in %s\n", bfd_get_filename (elt
));
376 /* Choose which symbol entries to print;
377 compact them downward to get rid of the rest.
378 Return the number of symbols to be printed. */
381 filter_symbols (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
,
382 long symcount
, unsigned int size
)
384 bfd_byte
*from
, *fromend
, *to
;
387 store
= bfd_make_empty_symbol (abfd
);
389 bfd_fatal (bfd_get_filename (abfd
));
391 from
= (bfd_byte
*) minisyms
;
392 fromend
= from
+ symcount
* size
;
393 to
= (bfd_byte
*) minisyms
;
395 for (; from
< fromend
; from
+= size
)
402 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const void *) from
, store
);
404 bfd_fatal (bfd_get_filename (abfd
));
407 keep
= bfd_is_und_section (sym
->section
);
408 else if (external_only
)
409 keep
= ((sym
->flags
& BSF_GLOBAL
) != 0
410 || (sym
->flags
& BSF_WEAK
) != 0
411 || bfd_is_und_section (sym
->section
)
412 || bfd_is_com_section (sym
->section
));
417 && ! print_debug_syms
418 && (sym
->flags
& BSF_DEBUGGING
) != 0)
423 && (bfd_is_abs_section (sym
->section
)
424 || bfd_is_und_section (sym
->section
)))
430 if (bfd_is_und_section (sym
->section
))
435 && bfd_is_target_special_symbol (abfd
, sym
)
436 && ! allow_special_symbols
)
441 memcpy (to
, from
, size
);
446 return (to
- (bfd_byte
*) minisyms
) / size
;
449 /* These globals are used to pass information into the sorting
451 static bfd
*sort_bfd
;
452 static bfd_boolean sort_dynamic
;
453 static asymbol
*sort_x
;
454 static asymbol
*sort_y
;
456 /* Symbol-sorting predicates */
457 #define valueof(x) ((x)->section->vma + (x)->value)
459 /* Numeric sorts. Undefined symbols are always considered "less than"
460 defined symbols with zero values. Common symbols are not treated
461 specially -- i.e., their sizes are used as their "values". */
464 non_numeric_forward (const void *P_x
, const void *P_y
)
469 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
470 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
471 if (x
== NULL
|| y
== NULL
)
472 bfd_fatal (bfd_get_filename (sort_bfd
));
474 xn
= bfd_asymbol_name (x
);
475 yn
= bfd_asymbol_name (y
);
483 /* Solaris 2.5 has a bug in strcoll.
484 strcoll returns invalid values when confronted with empty strings. */
490 return strcoll (xn
, yn
);
492 return strcmp (xn
, yn
);
497 non_numeric_reverse (const void *x
, const void *y
)
499 return - non_numeric_forward (x
, y
);
503 numeric_forward (const void *P_x
, const void *P_y
)
508 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
509 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
510 if (x
== NULL
|| y
== NULL
)
511 bfd_fatal (bfd_get_filename (sort_bfd
));
513 xs
= bfd_get_section (x
);
514 ys
= bfd_get_section (y
);
516 if (bfd_is_und_section (xs
))
518 if (! bfd_is_und_section (ys
))
521 else if (bfd_is_und_section (ys
))
523 else if (valueof (x
) != valueof (y
))
524 return valueof (x
) < valueof (y
) ? -1 : 1;
526 return non_numeric_forward (P_x
, P_y
);
530 numeric_reverse (const void *x
, const void *y
)
532 return - numeric_forward (x
, y
);
535 static int (*(sorters
[2][2])) (const void *, const void *) =
537 { non_numeric_forward
, non_numeric_reverse
},
538 { numeric_forward
, numeric_reverse
}
541 /* This sort routine is used by sort_symbols_by_size. It is similar
542 to numeric_forward, but when symbols have the same value it sorts
543 by section VMA. This simplifies the sort_symbols_by_size code
544 which handles symbols at the end of sections. Also, this routine
545 tries to sort file names before other symbols with the same value.
546 That will make the file name have a zero size, which will make
547 sort_symbols_by_size choose the non file name symbol, leading to
548 more meaningful output. For similar reasons, this code sorts
549 gnu_compiled_* and gcc2_compiled before other symbols with the same
553 size_forward1 (const void *P_x
, const void *P_y
)
561 x
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_x
, sort_x
);
562 y
= bfd_minisymbol_to_symbol (sort_bfd
, sort_dynamic
, P_y
, sort_y
);
563 if (x
== NULL
|| y
== NULL
)
564 bfd_fatal (bfd_get_filename (sort_bfd
));
566 xs
= bfd_get_section (x
);
567 ys
= bfd_get_section (y
);
569 if (bfd_is_und_section (xs
))
571 if (bfd_is_und_section (ys
))
574 if (valueof (x
) != valueof (y
))
575 return valueof (x
) < valueof (y
) ? -1 : 1;
577 if (xs
->vma
!= ys
->vma
)
578 return xs
->vma
< ys
->vma
? -1 : 1;
580 xn
= bfd_asymbol_name (x
);
581 yn
= bfd_asymbol_name (y
);
585 /* The symbols gnu_compiled and gcc2_compiled convey even less
586 information than the file name, so sort them out first. */
588 xf
= (strstr (xn
, "gnu_compiled") != NULL
589 || strstr (xn
, "gcc2_compiled") != NULL
);
590 yf
= (strstr (yn
, "gnu_compiled") != NULL
591 || strstr (yn
, "gcc2_compiled") != NULL
);
598 /* We use a heuristic for the file name. It may not work on non
599 Unix systems, but it doesn't really matter; the only difference
600 is precisely which symbol names get printed. */
602 #define file_symbol(s, sn, snl) \
603 (((s)->flags & BSF_FILE) != 0 \
604 || ((sn)[(snl) - 2] == '.' \
605 && ((sn)[(snl) - 1] == 'o' \
606 || (sn)[(snl) - 1] == 'a')))
608 xf
= file_symbol (x
, xn
, xnl
);
609 yf
= file_symbol (y
, yn
, ynl
);
616 return non_numeric_forward (P_x
, P_y
);
619 /* This sort routine is used by sort_symbols_by_size. It is sorting
620 an array of size_sym structures into size order. */
623 size_forward2 (const void *P_x
, const void *P_y
)
625 const struct size_sym
*x
= (const struct size_sym
*) P_x
;
626 const struct size_sym
*y
= (const struct size_sym
*) P_y
;
628 if (x
->size
< y
->size
)
629 return reverse_sort
? 1 : -1;
630 else if (x
->size
> y
->size
)
631 return reverse_sort
? -1 : 1;
633 return sorters
[0][reverse_sort
] (x
->minisym
, y
->minisym
);
636 /* Sort the symbols by size. ELF provides a size but for other formats
637 we have to make a guess by assuming that the difference between the
638 address of a symbol and the address of the next higher symbol is the
642 sort_symbols_by_size (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
,
643 long symcount
, unsigned int size
,
644 struct size_sym
**symsizesp
)
646 struct size_sym
*symsizes
;
647 bfd_byte
*from
, *fromend
;
649 asymbol
*store_sym
, *store_next
;
651 qsort (minisyms
, symcount
, size
, size_forward1
);
653 /* We are going to return a special set of symbols and sizes to
655 symsizes
= xmalloc (symcount
* sizeof (struct size_sym
));
656 *symsizesp
= symsizes
;
658 /* Note that filter_symbols has already removed all absolute and
659 undefined symbols. Here we remove all symbols whose size winds
661 from
= (bfd_byte
*) minisyms
;
662 fromend
= from
+ symcount
* size
;
669 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, (const void *) from
,
672 bfd_fatal (bfd_get_filename (abfd
));
675 for (; from
< fromend
; from
+= size
)
682 if (from
+ size
< fromend
)
684 next
= bfd_minisymbol_to_symbol (abfd
,
686 (const void *) (from
+ size
),
689 bfd_fatal (bfd_get_filename (abfd
));
694 sec
= bfd_get_section (sym
);
696 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
697 sz
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
698 else if (bfd_is_com_section (sec
))
702 if (from
+ size
< fromend
703 && sec
== bfd_get_section (next
))
704 sz
= valueof (next
) - valueof (sym
);
706 sz
= (bfd_get_section_vma (abfd
, sec
)
707 + bfd_section_size (abfd
, sec
)
713 symsizes
->minisym
= (const void *) from
;
721 store_sym
= store_next
;
725 symcount
= symsizes
- *symsizesp
;
727 /* We must now sort again by size. */
728 qsort ((void *) *symsizesp
, symcount
, sizeof (struct size_sym
), size_forward2
);
733 /* This function is used to get the relocs for a particular section.
734 It is called via bfd_map_over_sections. */
737 get_relocs (bfd
*abfd
, asection
*sec
, void *dataarg
)
739 struct get_relocs_info
*data
= (struct get_relocs_info
*) dataarg
;
743 if ((sec
->flags
& SEC_RELOC
) == 0)
745 *data
->relocs
= NULL
;
752 relsize
= bfd_get_reloc_upper_bound (abfd
, sec
);
754 bfd_fatal (bfd_get_filename (abfd
));
756 *data
->relocs
= xmalloc (relsize
);
757 *data
->relcount
= bfd_canonicalize_reloc (abfd
, sec
, *data
->relocs
,
759 if (*data
->relcount
< 0)
760 bfd_fatal (bfd_get_filename (abfd
));
768 /* Print a single symbol. */
771 print_symbol (bfd
*abfd
, asymbol
*sym
, bfd_vma ssize
, bfd
*archive_bfd
)
774 struct extended_symbol_info info
;
778 format
->print_symbol_filename (archive_bfd
, abfd
);
780 bfd_get_symbol_info (abfd
, sym
, &syminfo
);
781 info
.sinfo
= &syminfo
;
783 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
784 info
.elfinfo
= (elf_symbol_type
*) sym
;
787 format
->print_symbol_info (&info
, abfd
);
791 static asymbol
**syms
;
792 static long symcount
;
793 const char *filename
, *functionname
;
796 /* We need to get the canonical symbols in order to call
797 bfd_find_nearest_line. This is inefficient, but, then, you
798 don't have to use --line-numbers. */
799 if (abfd
!= lineno_cache_bfd
&& syms
!= NULL
)
808 symsize
= bfd_get_symtab_upper_bound (abfd
);
810 bfd_fatal (bfd_get_filename (abfd
));
811 syms
= xmalloc (symsize
);
812 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
814 bfd_fatal (bfd_get_filename (abfd
));
815 lineno_cache_bfd
= abfd
;
818 if (bfd_is_und_section (bfd_get_section (sym
)))
820 static asection
**secs
;
821 static arelent
***relocs
;
822 static long *relcount
;
823 static unsigned int seccount
;
827 /* For an undefined symbol, we try to find a reloc for the
828 symbol, and print the line number of the reloc. */
829 if (abfd
!= lineno_cache_rel_bfd
&& relocs
!= NULL
)
831 for (i
= 0; i
< seccount
; i
++)
832 if (relocs
[i
] != NULL
)
844 struct get_relocs_info info
;
846 seccount
= bfd_count_sections (abfd
);
848 secs
= xmalloc (seccount
* sizeof *secs
);
849 relocs
= xmalloc (seccount
* sizeof *relocs
);
850 relcount
= xmalloc (seccount
* sizeof *relcount
);
853 info
.relocs
= relocs
;
854 info
.relcount
= relcount
;
856 bfd_map_over_sections (abfd
, get_relocs
, (void *) &info
);
857 lineno_cache_rel_bfd
= abfd
;
860 symname
= bfd_asymbol_name (sym
);
861 for (i
= 0; i
< seccount
; i
++)
865 for (j
= 0; j
< relcount
[i
]; j
++)
870 if (r
->sym_ptr_ptr
!= NULL
871 && (*r
->sym_ptr_ptr
)->section
== sym
->section
872 && (*r
->sym_ptr_ptr
)->value
== sym
->value
874 bfd_asymbol_name (*r
->sym_ptr_ptr
)) == 0
875 && bfd_find_nearest_line (abfd
, secs
[i
], syms
,
876 r
->address
, &filename
,
877 &functionname
, &lineno
)
880 /* We only print the first one we find. */
881 printf ("\t%s:%u", filename
, lineno
);
888 else if (bfd_get_section (sym
)->owner
== abfd
)
890 if ((bfd_find_line (abfd
, syms
, sym
, &filename
, &lineno
)
891 || bfd_find_nearest_line (abfd
, bfd_get_section (sym
),
892 syms
, sym
->value
, &filename
,
893 &functionname
, &lineno
))
896 printf ("\t%s:%u", filename
, lineno
);
903 /* Print the symbols when sorting by size. */
906 print_size_symbols (bfd
*abfd
, bfd_boolean dynamic
,
907 struct size_sym
*symsizes
, long symcount
,
911 struct size_sym
*from
, *fromend
;
913 store
= bfd_make_empty_symbol (abfd
);
915 bfd_fatal (bfd_get_filename (abfd
));
918 fromend
= from
+ symcount
;
919 for (; from
< fromend
; from
++)
924 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
->minisym
, store
);
926 bfd_fatal (bfd_get_filename (abfd
));
928 /* For elf we have already computed the correct symbol size. */
929 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
932 ssize
= from
->size
- bfd_section_vma (abfd
, bfd_get_section (sym
));
934 print_symbol (abfd
, sym
, ssize
, archive_bfd
);
939 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
943 print_symbols (bfd
*abfd
, bfd_boolean dynamic
, void *minisyms
, long symcount
,
944 unsigned int size
, bfd
*archive_bfd
)
947 bfd_byte
*from
, *fromend
;
949 store
= bfd_make_empty_symbol (abfd
);
951 bfd_fatal (bfd_get_filename (abfd
));
953 from
= (bfd_byte
*) minisyms
;
954 fromend
= from
+ symcount
* size
;
955 for (; from
< fromend
; from
+= size
)
959 sym
= bfd_minisymbol_to_symbol (abfd
, dynamic
, from
, store
);
961 bfd_fatal (bfd_get_filename (abfd
));
963 print_symbol (abfd
, sym
, (bfd_vma
) 0, archive_bfd
);
967 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
970 display_rel_file (bfd
*abfd
, bfd
*archive_bfd
)
975 struct size_sym
*symsizes
;
979 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
981 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
986 symcount
= bfd_read_minisymbols (abfd
, dynamic
, &minisyms
, &size
);
988 bfd_fatal (bfd_get_filename (abfd
));
992 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd
));
996 if (show_synthetic
&& size
== sizeof (asymbol
*))
1000 asymbol
**static_syms
= NULL
;
1001 asymbol
**dyn_syms
= NULL
;
1002 long static_count
= 0;
1007 dyn_count
= symcount
;
1008 dyn_syms
= minisyms
;
1012 long storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1014 static_count
= symcount
;
1015 static_syms
= minisyms
;
1019 dyn_syms
= xmalloc (storage
);
1020 dyn_count
= bfd_canonicalize_dynamic_symtab (abfd
, dyn_syms
);
1022 bfd_fatal (bfd_get_filename (abfd
));
1025 synth_count
= bfd_get_synthetic_symtab (abfd
, static_count
, static_syms
,
1026 dyn_count
, dyn_syms
, &synthsyms
);
1027 if (synth_count
> 0)
1033 new_mini
= xmalloc ((symcount
+ synth_count
+ 1) * sizeof (*symp
));
1035 memcpy (symp
, minisyms
, symcount
* sizeof (*symp
));
1037 for (i
= 0; i
< synth_count
; i
++)
1038 *symp
++ = synthsyms
+ i
;
1040 minisyms
= new_mini
;
1041 symcount
+= synth_count
;
1045 /* Discard the symbols we don't want to print.
1046 It's OK to do this in place; we'll free the storage anyway
1047 (after printing). */
1049 symcount
= filter_symbols (abfd
, dynamic
, minisyms
, symcount
, size
);
1055 sort_dynamic
= dynamic
;
1056 sort_x
= bfd_make_empty_symbol (abfd
);
1057 sort_y
= bfd_make_empty_symbol (abfd
);
1058 if (sort_x
== NULL
|| sort_y
== NULL
)
1059 bfd_fatal (bfd_get_filename (abfd
));
1062 qsort (minisyms
, symcount
, size
,
1063 sorters
[sort_numerically
][reverse_sort
]);
1065 symcount
= sort_symbols_by_size (abfd
, dynamic
, minisyms
, symcount
,
1070 print_symbols (abfd
, dynamic
, minisyms
, symcount
, size
, archive_bfd
);
1072 print_size_symbols (abfd
, dynamic
, symsizes
, symcount
, archive_bfd
);
1078 set_print_width (bfd
*file
)
1080 print_width
= bfd_get_arch_size (file
);
1082 if (print_width
== -1)
1085 Guess the target's bitsize based on its name.
1086 We assume here than any 64-bit format will include
1087 "64" somewhere in its name. The only known exception
1088 is the MMO object file format. */
1089 if (strstr (bfd_get_target (file
), "64") != NULL
1090 || strcmp (bfd_get_target (file
), "mmo") == 0)
1098 display_archive (bfd
*file
)
1101 bfd
*last_arfile
= NULL
;
1104 format
->print_archive_filename (bfd_get_filename (file
));
1107 print_symdef_entry (file
);
1113 arfile
= bfd_openr_next_archived_file (file
, arfile
);
1117 if (bfd_get_error () != bfd_error_no_more_archived_files
)
1118 bfd_fatal (bfd_get_filename (file
));
1122 if (bfd_check_format_matches (arfile
, bfd_object
, &matching
))
1124 set_print_width (arfile
);
1125 format
->print_archive_member (bfd_get_filename (file
),
1126 bfd_get_filename (arfile
));
1127 display_rel_file (arfile
, file
);
1131 bfd_nonfatal (bfd_get_filename (arfile
));
1132 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1134 list_matching_formats (matching
);
1139 if (last_arfile
!= NULL
)
1141 bfd_close (last_arfile
);
1142 lineno_cache_bfd
= NULL
;
1143 lineno_cache_rel_bfd
= NULL
;
1145 last_arfile
= arfile
;
1148 if (last_arfile
!= NULL
)
1150 bfd_close (last_arfile
);
1151 lineno_cache_bfd
= NULL
;
1152 lineno_cache_rel_bfd
= NULL
;
1157 display_file (char *filename
)
1159 bfd_boolean retval
= TRUE
;
1163 if (get_file_size (filename
) < 1)
1166 file
= bfd_openr (filename
, target
);
1169 bfd_nonfatal (filename
);
1173 if (bfd_check_format (file
, bfd_archive
))
1175 display_archive (file
);
1177 else if (bfd_check_format_matches (file
, bfd_object
, &matching
))
1179 set_print_width (file
);
1180 format
->print_object_filename (filename
);
1181 display_rel_file (file
, NULL
);
1185 bfd_nonfatal (filename
);
1186 if (bfd_get_error () == bfd_error_file_ambiguously_recognized
)
1188 list_matching_formats (matching
);
1194 if (!bfd_close (file
))
1195 bfd_fatal (filename
);
1197 lineno_cache_bfd
= NULL
;
1198 lineno_cache_rel_bfd
= NULL
;
1203 /* The following 3 groups of functions are called unconditionally,
1204 once at the start of processing each file of the appropriate type.
1205 They should check `filename_per_file' and `filename_per_symbol',
1206 as appropriate for their output format, to determine whether to
1209 /* Print the name of an object file given on the command line. */
1212 print_object_filename_bsd (char *filename
)
1214 if (filename_per_file
&& !filename_per_symbol
)
1215 printf ("\n%s:\n", filename
);
1219 print_object_filename_sysv (char *filename
)
1222 printf (_("\n\nUndefined symbols from %s:\n\n"), filename
);
1224 printf (_("\n\nSymbols from %s:\n\n"), filename
);
1225 if (print_width
== 32)
1227 Name Value Class Type Size Line Section\n\n"));
1230 Name Value Class Type Size Line Section\n\n"));
1234 print_object_filename_posix (char *filename
)
1236 if (filename_per_file
&& !filename_per_symbol
)
1237 printf ("%s:\n", filename
);
1240 /* Print the name of an archive file given on the command line. */
1243 print_archive_filename_bsd (char *filename
)
1245 if (filename_per_file
)
1246 printf ("\n%s:\n", filename
);
1250 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED
)
1255 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED
)
1259 /* Print the name of an archive member file. */
1262 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED
,
1263 const char *filename
)
1265 if (!filename_per_symbol
)
1266 printf ("\n%s:\n", filename
);
1270 print_archive_member_sysv (char *archive
, const char *filename
)
1273 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive
, filename
);
1275 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive
, filename
);
1276 if (print_width
== 32)
1278 Name Value Class Type Size Line Section\n\n"));
1281 Name Value Class Type Size Line Section\n\n"));
1285 print_archive_member_posix (char *archive
, const char *filename
)
1287 if (!filename_per_symbol
)
1288 printf ("%s[%s]:\n", archive
, filename
);
1291 /* Print the name of the file (and archive, if there is one)
1292 containing a symbol. */
1295 print_symbol_filename_bsd (bfd
*archive_bfd
, bfd
*abfd
)
1297 if (filename_per_symbol
)
1300 printf ("%s:", bfd_get_filename (archive_bfd
));
1301 printf ("%s:", bfd_get_filename (abfd
));
1306 print_symbol_filename_sysv (bfd
*archive_bfd
, bfd
*abfd
)
1308 if (filename_per_symbol
)
1311 printf ("%s:", bfd_get_filename (archive_bfd
));
1312 printf ("%s:", bfd_get_filename (abfd
));
1317 print_symbol_filename_posix (bfd
*archive_bfd
, bfd
*abfd
)
1319 if (filename_per_symbol
)
1322 printf ("%s[%s]: ", bfd_get_filename (archive_bfd
),
1323 bfd_get_filename (abfd
));
1325 printf ("%s: ", bfd_get_filename (abfd
));
1329 /* Print a symbol value. */
1332 print_value (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_vma val
)
1334 switch (print_width
)
1337 printf (value_format_32bit
, (unsigned long) val
);
1341 #if BFD_HOST_64BIT_LONG
1342 printf (value_format_64bit
, val
);
1344 /* We have a 64 bit value to print, but the host is only 32 bit. */
1345 if (print_radix
== 16)
1346 bfd_fprintf_vma (abfd
, stdout
, val
);
1352 s
= buf
+ sizeof buf
;
1356 *--s
= (val
% print_radix
) + '0';
1359 while ((buf
+ sizeof buf
- 1) - s
< 16)
1367 fatal (_("Print width has not been initialized (%d)"), print_width
);
1372 /* Print a line of information about a symbol. */
1375 print_symbol_info_bsd (struct extended_symbol_info
*info
, bfd
*abfd
)
1377 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1379 if (print_width
== 64)
1385 /* Normally we print the value of the symbol. If we are printing the
1386 size or sorting by size then we print its size, except for the
1387 (weird) special case where both flags are defined, in which case we
1388 print both values. This conforms to documented behaviour. */
1389 if (sort_by_size
&& !print_size
)
1390 print_value (abfd
, SYM_SIZE (info
));
1392 print_value (abfd
, SYM_VALUE (info
));
1394 if (print_size
&& SYM_SIZE (info
))
1397 print_value (abfd
, SYM_SIZE (info
));
1401 printf (" %c", SYM_TYPE (info
));
1403 if (SYM_TYPE (info
) == '-')
1407 printf (other_format
, SYM_STAB_OTHER (info
));
1409 printf (desc_format
, SYM_STAB_DESC (info
));
1410 printf (" %5s", SYM_STAB_NAME (info
));
1412 print_symname (" %s", SYM_NAME (info
), abfd
);
1416 print_symbol_info_sysv (struct extended_symbol_info
*info
, bfd
*abfd
)
1418 print_symname ("%-20s|", SYM_NAME (info
), abfd
);
1420 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1422 if (print_width
== 32)
1428 print_value (abfd
, SYM_VALUE (info
));
1430 printf ("| %c |", SYM_TYPE (info
));
1432 if (SYM_TYPE (info
) == '-')
1435 printf ("%18s| ", SYM_STAB_NAME (info
)); /* (C) Type. */
1436 printf (desc_format
, SYM_STAB_DESC (info
)); /* Size. */
1437 printf ("| |"); /* Line, Section. */
1441 /* Type, Size, Line, Section */
1444 get_symbol_type (ELF_ST_TYPE (info
->elfinfo
->internal_elf_sym
.st_info
)));
1448 if (SYM_SIZE (info
))
1449 print_value (abfd
, SYM_SIZE (info
));
1452 if (print_width
== 32)
1459 printf("| |%s", info
->elfinfo
->symbol
.section
->name
);
1466 print_symbol_info_posix (struct extended_symbol_info
*info
, bfd
*abfd
)
1468 print_symname ("%s ", SYM_NAME (info
), abfd
);
1469 printf ("%c ", SYM_TYPE (info
));
1471 if (bfd_is_undefined_symclass (SYM_TYPE (info
)))
1475 print_value (abfd
, SYM_VALUE (info
));
1477 if (SYM_SIZE (info
))
1478 print_value (abfd
, SYM_SIZE (info
));
1483 main (int argc
, char **argv
)
1488 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1489 setlocale (LC_MESSAGES
, "");
1491 #if defined (HAVE_SETLOCALE)
1492 setlocale (LC_CTYPE
, "");
1493 setlocale (LC_COLLATE
, "");
1495 bindtextdomain (PACKAGE
, LOCALEDIR
);
1496 textdomain (PACKAGE
);
1498 program_name
= *argv
;
1499 xmalloc_set_program_name (program_name
);
1501 START_PROGRESS (program_name
, 0);
1503 expandargv (&argc
, &argv
);
1506 set_default_bfd_target ();
1508 while ((c
= getopt_long (argc
, argv
, "aABCDef:gHhlnopPrSst:uvVvX:",
1509 long_options
, (int *) 0)) != EOF
)
1514 print_debug_syms
= 1;
1518 filename_per_symbol
= 1;
1520 case 'B': /* For MIPS compatibility. */
1521 set_output_format ("bsd");
1527 enum demangling_styles style
;
1529 style
= cplus_demangle_name_to_style (optarg
);
1530 if (style
== unknown_demangling
)
1531 fatal (_("unknown demangling style `%s'"),
1534 cplus_demangle_set_style (style
);
1541 /* Ignored for HP/UX compatibility. */
1544 set_output_format (optarg
);
1557 sort_numerically
= 1;
1563 set_output_format ("posix");
1575 set_print_radix (optarg
);
1584 /* Ignored for (partial) AIX compatibility. On AIX, the
1585 argument has values 32, 64, or 32_64, and specifies that
1586 only 32-bit, only 64-bit, or both kinds of objects should
1587 be examined. The default is 32. So plain AIX nm on a
1588 library archive with both kinds of objects will ignore
1589 the 64-bit ones. For GNU nm, the default is and always
1590 has been -X 32_64, and other options are not supported. */
1591 if (strcmp (optarg
, "32_64") != 0)
1592 fatal (_("Only -X 32_64 is supported"));
1595 case OPTION_TARGET
: /* --target */
1599 case 0: /* A long option that just sets a flag. */
1608 print_version ("nm");
1610 if (sort_by_size
&& undefined_only
)
1612 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1613 non_fatal (_("will produce no output, since undefined symbols have no size."));
1617 /* OK, all options now parsed. If no filename specified, do a.out. */
1619 return !display_file ("a.out");
1623 if (argc
- optind
> 1)
1624 filename_per_file
= 1;
1626 /* We were given several filenames to do. */
1627 while (optind
< argc
)
1630 if (!display_file (argv
[optind
++]))
1634 END_PROGRESS (program_name
);
1639 char *lim
= (char *) sbrk (0);
1641 non_fatal (_("data size %ld"), (long) (lim
- (char *) &environ
));