daily update
[binutils.git] / binutils / nm.c
blobc1fb4d803e845e1f3de510f813dd99b393d31130
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
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
21 02110-1301, USA. */
23 #include "bfd.h"
24 #include "progress.h"
25 #include "bucomm.h"
26 #include "budemang.h"
27 #include "getopt.h"
28 #include "aout/stab_gnu.h"
29 #include "aout/ranlib.h"
30 #include "demangle.h"
31 #include "libiberty.h"
32 #include "elf-bfd.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. */
38 struct size_sym
40 const void *minisym;
41 bfd_vma size;
44 /* When fetching relocs, we use this structure to pass information to
45 get_relocs. */
47 struct get_relocs_info
49 asection **secs;
50 arelent ***relocs;
51 long *relcount;
52 asymbol **syms;
55 struct extended_symbol_info
57 symbol_info *sinfo;
58 bfd_vma ssize;
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. */
90 struct output_fns
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'. */
129 #define FORMAT_BSD 0
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 #ifndef BFD64
163 static char value_format[] = "%08lx";
164 #else
165 #if BFD_HOST_64BIT_LONG
166 static char value_format[] = "%016lx";
167 #else
168 /* We don't use value_format for this case. */
169 #endif
170 #endif
171 #ifdef BFD64
172 static int print_width = 16;
173 #else
174 static int print_width = 8;
175 #endif
176 static int print_radix = 16;
177 /* Print formats for printing stab info. */
178 static char other_format[] = "%02x";
179 static char desc_format[] = "%04x";
181 static char *target = NULL;
183 /* Used to cache the line numbers for a BFD. */
184 static bfd *lineno_cache_bfd;
185 static bfd *lineno_cache_rel_bfd;
187 #define OPTION_TARGET 200
189 static struct option long_options[] =
191 {"debug-syms", no_argument, &print_debug_syms, 1},
192 {"demangle", optional_argument, 0, 'C'},
193 {"dynamic", no_argument, &dynamic, 1},
194 {"extern-only", no_argument, &external_only, 1},
195 {"format", required_argument, 0, 'f'},
196 {"help", no_argument, 0, 'h'},
197 {"line-numbers", no_argument, 0, 'l'},
198 {"no-cplus", no_argument, &do_demangle, 0}, /* Linux compatibility. */
199 {"no-demangle", no_argument, &do_demangle, 0},
200 {"no-sort", no_argument, &no_sort, 1},
201 {"numeric-sort", no_argument, &sort_numerically, 1},
202 {"portability", no_argument, 0, 'P'},
203 {"print-armap", no_argument, &print_armap, 1},
204 {"print-file-name", no_argument, 0, 'o'},
205 {"print-size", no_argument, 0, 'S'},
206 {"radix", required_argument, 0, 't'},
207 {"reverse-sort", no_argument, &reverse_sort, 1},
208 {"size-sort", no_argument, &sort_by_size, 1},
209 {"special-syms", no_argument, &allow_special_symbols, 1},
210 {"stats", no_argument, &show_stats, 1},
211 {"synthetic", no_argument, &show_synthetic, 1},
212 {"target", required_argument, 0, OPTION_TARGET},
213 {"defined-only", no_argument, &defined_only, 1},
214 {"undefined-only", no_argument, &undefined_only, 1},
215 {"version", no_argument, &show_version, 1},
216 {0, no_argument, 0, 0}
219 /* Some error-reporting functions. */
221 static void
222 usage (FILE *stream, int status)
224 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
225 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
226 fprintf (stream, _(" The options are:\n\
227 -a, --debug-syms Display debugger-only symbols\n\
228 -A, --print-file-name Print name of the input file before every symbol\n\
229 -B Same as --format=bsd\n\
230 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
231 The STYLE, if specified, can be `auto' (the default),\n\
232 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
233 or `gnat'\n\
234 --no-demangle Do not demangle low-level symbol names\n\
235 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
236 --defined-only Display only defined symbols\n\
237 -e (ignored)\n\
238 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
239 `sysv' or `posix'. The default is `bsd'\n\
240 -g, --extern-only Display only external symbols\n\
241 -l, --line-numbers Use debugging information to find a filename and\n\
242 line number for each symbol\n\
243 -n, --numeric-sort Sort symbols numerically by address\n\
244 -o Same as -A\n\
245 -p, --no-sort Do not sort the symbols\n\
246 -P, --portability Same as --format=posix\n\
247 -r, --reverse-sort Reverse the sense of the sort\n\
248 -S, --print-size Print size of defined symbols\n\
249 -s, --print-armap Include index for symbols from archive members\n\
250 --size-sort Sort symbols by size\n\
251 --special-syms Include special symbols in the output\n\
252 --synthetic Display synthetic symbols as well\n\
253 -t, --radix=RADIX Use RADIX for printing symbol values\n\
254 --target=BFDNAME Specify the target object format as BFDNAME\n\
255 -u, --undefined-only Display only undefined symbols\n\
256 -X 32_64 (ignored)\n\
257 @FILE Read options from FILE\n\
258 -h, --help Display this information\n\
259 -V, --version Display this program's version number\n\
260 \n"));
261 list_supported_targets (program_name, stream);
262 if (status == 0)
263 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
264 exit (status);
267 /* Set the radix for the symbol value and size according to RADIX. */
269 static void
270 set_print_radix (char *radix)
272 switch (*radix)
274 case 'x':
275 break;
276 case 'd':
277 case 'o':
278 if (*radix == 'd')
279 print_radix = 10;
280 else
281 print_radix = 8;
282 #ifndef BFD64
283 value_format[4] = *radix;
284 #else
285 #if BFD_HOST_64BIT_LONG
286 value_format[5] = *radix;
287 #else
288 /* This case requires special handling for octal and decimal
289 printing. */
290 #endif
291 #endif
292 other_format[3] = desc_format[3] = *radix;
293 break;
294 default:
295 fatal (_("%s: invalid radix"), radix);
299 static void
300 set_output_format (char *f)
302 int i;
304 switch (*f)
306 case 'b':
307 case 'B':
308 i = FORMAT_BSD;
309 break;
310 case 'p':
311 case 'P':
312 i = FORMAT_POSIX;
313 break;
314 case 's':
315 case 'S':
316 i = FORMAT_SYSV;
317 break;
318 default:
319 fatal (_("%s: invalid output format"), f);
321 format = &formats[i];
324 static const char *
325 get_symbol_type (unsigned int type)
327 static char buff [32];
329 switch (type)
331 case STT_NOTYPE: return "NOTYPE";
332 case STT_OBJECT: return "OBJECT";
333 case STT_FUNC: return "FUNC";
334 case STT_SECTION: return "SECTION";
335 case STT_FILE: return "FILE";
336 case STT_COMMON: return "COMMON";
337 case STT_TLS: return "TLS";
338 default:
339 if (type >= STT_LOPROC && type <= STT_HIPROC)
340 sprintf (buff, _("<processor specific>: %d"), type);
341 else if (type >= STT_LOOS && type <= STT_HIOS)
342 sprintf (buff, _("<OS specific>: %d"), type);
343 else
344 sprintf (buff, _("<unknown>: %d"), type);
345 return buff;
349 /* Print symbol name NAME, read from ABFD, with printf format FORMAT,
350 demangling it if requested. */
352 static void
353 print_symname (const char *format, const char *name, bfd *abfd)
355 if (do_demangle && *name)
357 char *res = demangle (abfd, name);
359 printf (format, res);
360 free (res);
361 return;
364 printf (format, name);
367 static void
368 print_symdef_entry (bfd *abfd)
370 symindex idx = BFD_NO_MORE_SYMBOLS;
371 carsym *thesym;
372 bfd_boolean everprinted = FALSE;
374 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
375 idx != BFD_NO_MORE_SYMBOLS;
376 idx = bfd_get_next_mapent (abfd, idx, &thesym))
378 bfd *elt;
379 if (!everprinted)
381 printf (_("\nArchive index:\n"));
382 everprinted = TRUE;
384 elt = bfd_get_elt_at_index (abfd, idx);
385 if (elt == NULL)
386 bfd_fatal ("bfd_get_elt_at_index");
387 if (thesym->name != (char *) NULL)
389 print_symname ("%s", thesym->name, abfd);
390 printf (" in %s\n", bfd_get_filename (elt));
395 /* Choose which symbol entries to print;
396 compact them downward to get rid of the rest.
397 Return the number of symbols to be printed. */
399 static long
400 filter_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms,
401 long symcount, unsigned int size)
403 bfd_byte *from, *fromend, *to;
404 asymbol *store;
406 store = bfd_make_empty_symbol (abfd);
407 if (store == NULL)
408 bfd_fatal (bfd_get_filename (abfd));
410 from = (bfd_byte *) minisyms;
411 fromend = from + symcount * size;
412 to = (bfd_byte *) minisyms;
414 for (; from < fromend; from += size)
416 int keep = 0;
417 asymbol *sym;
419 PROGRESS (1);
421 sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from, store);
422 if (sym == NULL)
423 bfd_fatal (bfd_get_filename (abfd));
425 if (undefined_only)
426 keep = bfd_is_und_section (sym->section);
427 else if (external_only)
428 keep = ((sym->flags & BSF_GLOBAL) != 0
429 || (sym->flags & BSF_WEAK) != 0
430 || bfd_is_und_section (sym->section)
431 || bfd_is_com_section (sym->section));
432 else
433 keep = 1;
435 if (keep
436 && ! print_debug_syms
437 && (sym->flags & BSF_DEBUGGING) != 0)
438 keep = 0;
440 if (keep
441 && sort_by_size
442 && (bfd_is_abs_section (sym->section)
443 || bfd_is_und_section (sym->section)))
444 keep = 0;
446 if (keep
447 && defined_only)
449 if (bfd_is_und_section (sym->section))
450 keep = 0;
453 if (keep
454 && bfd_is_target_special_symbol (abfd, sym)
455 && ! allow_special_symbols)
456 keep = 0;
458 if (keep)
460 memcpy (to, from, size);
461 to += size;
465 return (to - (bfd_byte *) minisyms) / size;
468 /* These globals are used to pass information into the sorting
469 routines. */
470 static bfd *sort_bfd;
471 static bfd_boolean sort_dynamic;
472 static asymbol *sort_x;
473 static asymbol *sort_y;
475 /* Symbol-sorting predicates */
476 #define valueof(x) ((x)->section->vma + (x)->value)
478 /* Numeric sorts. Undefined symbols are always considered "less than"
479 defined symbols with zero values. Common symbols are not treated
480 specially -- i.e., their sizes are used as their "values". */
482 static int
483 non_numeric_forward (const void *P_x, const void *P_y)
485 asymbol *x, *y;
486 const char *xn, *yn;
488 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
489 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
490 if (x == NULL || y == NULL)
491 bfd_fatal (bfd_get_filename (sort_bfd));
493 xn = bfd_asymbol_name (x);
494 yn = bfd_asymbol_name (y);
496 if (yn == NULL)
497 return xn != NULL;
498 if (xn == NULL)
499 return -1;
501 #ifdef HAVE_STRCOLL
502 /* Solaris 2.5 has a bug in strcoll.
503 strcoll returns invalid values when confronted with empty strings. */
504 if (*yn == '\0')
505 return *xn != '\0';
506 if (*xn == '\0')
507 return -1;
509 return strcoll (xn, yn);
510 #else
511 return strcmp (xn, yn);
512 #endif
515 static int
516 non_numeric_reverse (const void *x, const void *y)
518 return - non_numeric_forward (x, y);
521 static int
522 numeric_forward (const void *P_x, const void *P_y)
524 asymbol *x, *y;
525 asection *xs, *ys;
527 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
528 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
529 if (x == NULL || y == NULL)
530 bfd_fatal (bfd_get_filename (sort_bfd));
532 xs = bfd_get_section (x);
533 ys = bfd_get_section (y);
535 if (bfd_is_und_section (xs))
537 if (! bfd_is_und_section (ys))
538 return -1;
540 else if (bfd_is_und_section (ys))
541 return 1;
542 else if (valueof (x) != valueof (y))
543 return valueof (x) < valueof (y) ? -1 : 1;
545 return non_numeric_forward (P_x, P_y);
548 static int
549 numeric_reverse (const void *x, const void *y)
551 return - numeric_forward (x, y);
554 static int (*(sorters[2][2])) (const void *, const void *) =
556 { non_numeric_forward, non_numeric_reverse },
557 { numeric_forward, numeric_reverse }
560 /* This sort routine is used by sort_symbols_by_size. It is similar
561 to numeric_forward, but when symbols have the same value it sorts
562 by section VMA. This simplifies the sort_symbols_by_size code
563 which handles symbols at the end of sections. Also, this routine
564 tries to sort file names before other symbols with the same value.
565 That will make the file name have a zero size, which will make
566 sort_symbols_by_size choose the non file name symbol, leading to
567 more meaningful output. For similar reasons, this code sorts
568 gnu_compiled_* and gcc2_compiled before other symbols with the same
569 value. */
571 static int
572 size_forward1 (const void *P_x, const void *P_y)
574 asymbol *x, *y;
575 asection *xs, *ys;
576 const char *xn, *yn;
577 size_t xnl, ynl;
578 int xf, yf;
580 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
581 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
582 if (x == NULL || y == NULL)
583 bfd_fatal (bfd_get_filename (sort_bfd));
585 xs = bfd_get_section (x);
586 ys = bfd_get_section (y);
588 if (bfd_is_und_section (xs))
589 abort ();
590 if (bfd_is_und_section (ys))
591 abort ();
593 if (valueof (x) != valueof (y))
594 return valueof (x) < valueof (y) ? -1 : 1;
596 if (xs->vma != ys->vma)
597 return xs->vma < ys->vma ? -1 : 1;
599 xn = bfd_asymbol_name (x);
600 yn = bfd_asymbol_name (y);
601 xnl = strlen (xn);
602 ynl = strlen (yn);
604 /* The symbols gnu_compiled and gcc2_compiled convey even less
605 information than the file name, so sort them out first. */
607 xf = (strstr (xn, "gnu_compiled") != NULL
608 || strstr (xn, "gcc2_compiled") != NULL);
609 yf = (strstr (yn, "gnu_compiled") != NULL
610 || strstr (yn, "gcc2_compiled") != NULL);
612 if (xf && ! yf)
613 return -1;
614 if (! xf && yf)
615 return 1;
617 /* We use a heuristic for the file name. It may not work on non
618 Unix systems, but it doesn't really matter; the only difference
619 is precisely which symbol names get printed. */
621 #define file_symbol(s, sn, snl) \
622 (((s)->flags & BSF_FILE) != 0 \
623 || ((sn)[(snl) - 2] == '.' \
624 && ((sn)[(snl) - 1] == 'o' \
625 || (sn)[(snl) - 1] == 'a')))
627 xf = file_symbol (x, xn, xnl);
628 yf = file_symbol (y, yn, ynl);
630 if (xf && ! yf)
631 return -1;
632 if (! xf && yf)
633 return 1;
635 return non_numeric_forward (P_x, P_y);
638 /* This sort routine is used by sort_symbols_by_size. It is sorting
639 an array of size_sym structures into size order. */
641 static int
642 size_forward2 (const void *P_x, const void *P_y)
644 const struct size_sym *x = (const struct size_sym *) P_x;
645 const struct size_sym *y = (const struct size_sym *) P_y;
647 if (x->size < y->size)
648 return reverse_sort ? 1 : -1;
649 else if (x->size > y->size)
650 return reverse_sort ? -1 : 1;
651 else
652 return sorters[0][reverse_sort] (x->minisym, y->minisym);
655 /* Sort the symbols by size. ELF provides a size but for other formats
656 we have to make a guess by assuming that the difference between the
657 address of a symbol and the address of the next higher symbol is the
658 size. */
660 static long
661 sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
662 long symcount, unsigned int size,
663 struct size_sym **symsizesp)
665 struct size_sym *symsizes;
666 bfd_byte *from, *fromend;
667 asymbol *sym = NULL;
668 asymbol *store_sym, *store_next;
670 qsort (minisyms, symcount, size, size_forward1);
672 /* We are going to return a special set of symbols and sizes to
673 print. */
674 symsizes = xmalloc (symcount * sizeof (struct size_sym));
675 *symsizesp = symsizes;
677 /* Note that filter_symbols has already removed all absolute and
678 undefined symbols. Here we remove all symbols whose size winds
679 up as zero. */
680 from = (bfd_byte *) minisyms;
681 fromend = from + symcount * size;
683 store_sym = sort_x;
684 store_next = sort_y;
686 if (from < fromend)
688 sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from,
689 store_sym);
690 if (sym == NULL)
691 bfd_fatal (bfd_get_filename (abfd));
694 for (; from < fromend; from += size)
696 asymbol *next;
697 asection *sec;
698 bfd_vma sz;
699 asymbol *temp;
701 if (from + size < fromend)
703 next = bfd_minisymbol_to_symbol (abfd,
704 dynamic,
705 (const void *) (from + size),
706 store_next);
707 if (next == NULL)
708 bfd_fatal (bfd_get_filename (abfd));
710 else
711 next = NULL;
713 sec = bfd_get_section (sym);
715 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
716 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
717 else if (bfd_is_com_section (sec))
718 sz = sym->value;
719 else
721 if (from + size < fromend
722 && sec == bfd_get_section (next))
723 sz = valueof (next) - valueof (sym);
724 else
725 sz = (bfd_get_section_vma (abfd, sec)
726 + bfd_section_size (abfd, sec)
727 - valueof (sym));
730 if (sz != 0)
732 symsizes->minisym = (const void *) from;
733 symsizes->size = sz;
734 ++symsizes;
737 sym = next;
739 temp = store_sym;
740 store_sym = store_next;
741 store_next = temp;
744 symcount = symsizes - *symsizesp;
746 /* We must now sort again by size. */
747 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
749 return symcount;
752 /* This function is used to get the relocs for a particular section.
753 It is called via bfd_map_over_sections. */
755 static void
756 get_relocs (bfd *abfd, asection *sec, void *dataarg)
758 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
760 *data->secs = sec;
762 if ((sec->flags & SEC_RELOC) == 0)
764 *data->relocs = NULL;
765 *data->relcount = 0;
767 else
769 long relsize;
771 relsize = bfd_get_reloc_upper_bound (abfd, sec);
772 if (relsize < 0)
773 bfd_fatal (bfd_get_filename (abfd));
775 *data->relocs = xmalloc (relsize);
776 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
777 data->syms);
778 if (*data->relcount < 0)
779 bfd_fatal (bfd_get_filename (abfd));
782 ++data->secs;
783 ++data->relocs;
784 ++data->relcount;
787 /* Print a single symbol. */
789 static void
790 print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
792 symbol_info syminfo;
793 struct extended_symbol_info info;
795 PROGRESS (1);
797 format->print_symbol_filename (archive_bfd, abfd);
799 bfd_get_symbol_info (abfd, sym, &syminfo);
800 info.sinfo = &syminfo;
801 info.ssize = ssize;
802 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
803 info.elfinfo = (elf_symbol_type *) sym;
804 else
805 info.elfinfo = NULL;
806 format->print_symbol_info (&info, abfd);
808 if (line_numbers)
810 static asymbol **syms;
811 static long symcount;
812 const char *filename, *functionname;
813 unsigned int lineno;
815 /* We need to get the canonical symbols in order to call
816 bfd_find_nearest_line. This is inefficient, but, then, you
817 don't have to use --line-numbers. */
818 if (abfd != lineno_cache_bfd && syms != NULL)
820 free (syms);
821 syms = NULL;
823 if (syms == NULL)
825 long symsize;
827 symsize = bfd_get_symtab_upper_bound (abfd);
828 if (symsize < 0)
829 bfd_fatal (bfd_get_filename (abfd));
830 syms = xmalloc (symsize);
831 symcount = bfd_canonicalize_symtab (abfd, syms);
832 if (symcount < 0)
833 bfd_fatal (bfd_get_filename (abfd));
834 lineno_cache_bfd = abfd;
837 if (bfd_is_und_section (bfd_get_section (sym)))
839 static asection **secs;
840 static arelent ***relocs;
841 static long *relcount;
842 static unsigned int seccount;
843 unsigned int i;
844 const char *symname;
846 /* For an undefined symbol, we try to find a reloc for the
847 symbol, and print the line number of the reloc. */
848 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
850 for (i = 0; i < seccount; i++)
851 if (relocs[i] != NULL)
852 free (relocs[i]);
853 free (secs);
854 free (relocs);
855 free (relcount);
856 secs = NULL;
857 relocs = NULL;
858 relcount = NULL;
861 if (relocs == NULL)
863 struct get_relocs_info info;
865 seccount = bfd_count_sections (abfd);
867 secs = xmalloc (seccount * sizeof *secs);
868 relocs = xmalloc (seccount * sizeof *relocs);
869 relcount = xmalloc (seccount * sizeof *relcount);
871 info.secs = secs;
872 info.relocs = relocs;
873 info.relcount = relcount;
874 info.syms = syms;
875 bfd_map_over_sections (abfd, get_relocs, (void *) &info);
876 lineno_cache_rel_bfd = abfd;
879 symname = bfd_asymbol_name (sym);
880 for (i = 0; i < seccount; i++)
882 long j;
884 for (j = 0; j < relcount[i]; j++)
886 arelent *r;
888 r = relocs[i][j];
889 if (r->sym_ptr_ptr != NULL
890 && (*r->sym_ptr_ptr)->section == sym->section
891 && (*r->sym_ptr_ptr)->value == sym->value
892 && strcmp (symname,
893 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
894 && bfd_find_nearest_line (abfd, secs[i], syms,
895 r->address, &filename,
896 &functionname, &lineno)
897 && filename != NULL)
899 /* We only print the first one we find. */
900 printf ("\t%s:%u", filename, lineno);
901 i = seccount;
902 break;
907 else if (bfd_get_section (sym)->owner == abfd)
909 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
910 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
911 syms, sym->value, &filename,
912 &functionname, &lineno))
913 && filename != NULL
914 && lineno != 0)
915 printf ("\t%s:%u", filename, lineno);
919 putchar ('\n');
922 /* Print the symbols when sorting by size. */
924 static void
925 print_size_symbols (bfd *abfd, bfd_boolean dynamic,
926 struct size_sym *symsizes, long symcount,
927 bfd *archive_bfd)
929 asymbol *store;
930 struct size_sym *from, *fromend;
932 store = bfd_make_empty_symbol (abfd);
933 if (store == NULL)
934 bfd_fatal (bfd_get_filename (abfd));
936 from = symsizes;
937 fromend = from + symcount;
938 for (; from < fromend; from++)
940 asymbol *sym;
941 bfd_vma ssize;
943 sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
944 if (sym == NULL)
945 bfd_fatal (bfd_get_filename (abfd));
947 /* For elf we have already computed the correct symbol size. */
948 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
949 ssize = from->size;
950 else
951 ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
953 print_symbol (abfd, sym, ssize, archive_bfd);
958 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
959 containing ABFD. */
961 static void
962 print_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms, long symcount,
963 unsigned int size, bfd *archive_bfd)
965 asymbol *store;
966 bfd_byte *from, *fromend;
968 store = bfd_make_empty_symbol (abfd);
969 if (store == NULL)
970 bfd_fatal (bfd_get_filename (abfd));
972 from = (bfd_byte *) minisyms;
973 fromend = from + symcount * size;
974 for (; from < fromend; from += size)
976 asymbol *sym;
978 sym = bfd_minisymbol_to_symbol (abfd, dynamic, from, store);
979 if (sym == NULL)
980 bfd_fatal (bfd_get_filename (abfd));
982 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
986 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
988 static void
989 display_rel_file (bfd *abfd, bfd *archive_bfd)
991 long symcount;
992 void *minisyms;
993 unsigned int size;
994 struct size_sym *symsizes;
996 if (! dynamic)
998 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1000 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1001 return;
1005 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1006 if (symcount < 0)
1007 bfd_fatal (bfd_get_filename (abfd));
1009 if (symcount == 0)
1011 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1012 return;
1015 if (show_synthetic && size == sizeof (asymbol *))
1017 asymbol *synthsyms;
1018 long synth_count;
1019 asymbol **static_syms = NULL;
1020 asymbol **dyn_syms = NULL;
1021 long static_count = 0;
1022 long dyn_count = 0;
1024 if (dynamic)
1026 dyn_count = symcount;
1027 dyn_syms = minisyms;
1029 else
1031 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1033 static_count = symcount;
1034 static_syms = minisyms;
1036 if (storage > 0)
1038 dyn_syms = xmalloc (storage);
1039 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1040 if (dyn_count < 0)
1041 bfd_fatal (bfd_get_filename (abfd));
1044 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1045 dyn_count, dyn_syms, &synthsyms);
1046 if (synth_count > 0)
1048 asymbol **symp;
1049 void *new_mini;
1050 long i;
1052 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1053 symp = new_mini;
1054 memcpy (symp, minisyms, symcount * sizeof (*symp));
1055 symp += symcount;
1056 for (i = 0; i < synth_count; i++)
1057 *symp++ = synthsyms + i;
1058 *symp = 0;
1059 minisyms = new_mini;
1060 symcount += synth_count;
1064 /* Discard the symbols we don't want to print.
1065 It's OK to do this in place; we'll free the storage anyway
1066 (after printing). */
1068 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1070 symsizes = NULL;
1071 if (! no_sort)
1073 sort_bfd = abfd;
1074 sort_dynamic = dynamic;
1075 sort_x = bfd_make_empty_symbol (abfd);
1076 sort_y = bfd_make_empty_symbol (abfd);
1077 if (sort_x == NULL || sort_y == NULL)
1078 bfd_fatal (bfd_get_filename (abfd));
1080 if (! sort_by_size)
1081 qsort (minisyms, symcount, size,
1082 sorters[sort_numerically][reverse_sort]);
1083 else
1084 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1085 size, &symsizes);
1088 if (! sort_by_size)
1089 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1090 else
1091 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1093 free (minisyms);
1096 static void
1097 display_archive (bfd *file)
1099 bfd *arfile = NULL;
1100 bfd *last_arfile = NULL;
1101 char **matching;
1103 format->print_archive_filename (bfd_get_filename (file));
1105 if (print_armap)
1106 print_symdef_entry (file);
1108 for (;;)
1110 PROGRESS (1);
1112 arfile = bfd_openr_next_archived_file (file, arfile);
1114 if (arfile == NULL)
1116 if (bfd_get_error () != bfd_error_no_more_archived_files)
1117 bfd_fatal (bfd_get_filename (file));
1118 break;
1121 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1123 char buf[30];
1125 bfd_sprintf_vma (arfile, buf, (bfd_vma) -1);
1126 print_width = strlen (buf);
1127 format->print_archive_member (bfd_get_filename (file),
1128 bfd_get_filename (arfile));
1129 display_rel_file (arfile, file);
1131 else
1133 bfd_nonfatal (bfd_get_filename (arfile));
1134 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1136 list_matching_formats (matching);
1137 free (matching);
1141 if (last_arfile != NULL)
1143 bfd_close (last_arfile);
1144 lineno_cache_bfd = NULL;
1145 lineno_cache_rel_bfd = NULL;
1147 last_arfile = arfile;
1150 if (last_arfile != NULL)
1152 bfd_close (last_arfile);
1153 lineno_cache_bfd = NULL;
1154 lineno_cache_rel_bfd = NULL;
1158 static bfd_boolean
1159 display_file (char *filename)
1161 bfd_boolean retval = TRUE;
1162 bfd *file;
1163 char **matching;
1165 if (get_file_size (filename) < 1)
1166 return FALSE;
1168 file = bfd_openr (filename, target);
1169 if (file == NULL)
1171 bfd_nonfatal (filename);
1172 return FALSE;
1175 if (bfd_check_format (file, bfd_archive))
1177 display_archive (file);
1179 else if (bfd_check_format_matches (file, bfd_object, &matching))
1181 char buf[30];
1183 bfd_sprintf_vma (file, buf, (bfd_vma) -1);
1184 print_width = strlen (buf);
1185 format->print_object_filename (filename);
1186 display_rel_file (file, NULL);
1188 else
1190 bfd_nonfatal (filename);
1191 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1193 list_matching_formats (matching);
1194 free (matching);
1196 retval = FALSE;
1199 if (!bfd_close (file))
1200 bfd_fatal (filename);
1202 lineno_cache_bfd = NULL;
1203 lineno_cache_rel_bfd = NULL;
1205 return retval;
1208 /* The following 3 groups of functions are called unconditionally,
1209 once at the start of processing each file of the appropriate type.
1210 They should check `filename_per_file' and `filename_per_symbol',
1211 as appropriate for their output format, to determine whether to
1212 print anything. */
1214 /* Print the name of an object file given on the command line. */
1216 static void
1217 print_object_filename_bsd (char *filename)
1219 if (filename_per_file && !filename_per_symbol)
1220 printf ("\n%s:\n", filename);
1223 static void
1224 print_object_filename_sysv (char *filename)
1226 if (undefined_only)
1227 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1228 else
1229 printf (_("\n\nSymbols from %s:\n\n"), filename);
1230 if (print_width == 8)
1231 printf (_("\
1232 Name Value Class Type Size Line Section\n\n"));
1233 else
1234 printf (_("\
1235 Name Value Class Type Size Line Section\n\n"));
1238 static void
1239 print_object_filename_posix (char *filename)
1241 if (filename_per_file && !filename_per_symbol)
1242 printf ("%s:\n", filename);
1245 /* Print the name of an archive file given on the command line. */
1247 static void
1248 print_archive_filename_bsd (char *filename)
1250 if (filename_per_file)
1251 printf ("\n%s:\n", filename);
1254 static void
1255 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1259 static void
1260 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1264 /* Print the name of an archive member file. */
1266 static void
1267 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1268 const char *filename)
1270 if (!filename_per_symbol)
1271 printf ("\n%s:\n", filename);
1274 static void
1275 print_archive_member_sysv (char *archive, const char *filename)
1277 if (undefined_only)
1278 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1279 else
1280 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1281 if (print_width == 8)
1282 printf (_("\
1283 Name Value Class Type Size Line Section\n\n"));
1284 else
1285 printf (_("\
1286 Name Value Class Type Size Line Section\n\n"));
1289 static void
1290 print_archive_member_posix (char *archive, const char *filename)
1292 if (!filename_per_symbol)
1293 printf ("%s[%s]:\n", archive, filename);
1296 /* Print the name of the file (and archive, if there is one)
1297 containing a symbol. */
1299 static void
1300 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1302 if (filename_per_symbol)
1304 if (archive_bfd)
1305 printf ("%s:", bfd_get_filename (archive_bfd));
1306 printf ("%s:", bfd_get_filename (abfd));
1310 static void
1311 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1313 if (filename_per_symbol)
1315 if (archive_bfd)
1316 printf ("%s:", bfd_get_filename (archive_bfd));
1317 printf ("%s:", bfd_get_filename (abfd));
1321 static void
1322 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1324 if (filename_per_symbol)
1326 if (archive_bfd)
1327 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1328 bfd_get_filename (abfd));
1329 else
1330 printf ("%s: ", bfd_get_filename (abfd));
1334 /* Print a symbol value. */
1336 static void
1337 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1339 #if ! defined (BFD64) || BFD_HOST_64BIT_LONG
1340 printf (value_format, val);
1341 #else
1342 /* We have a 64 bit value to print, but the host is only 32 bit. */
1343 if (print_radix == 16)
1344 bfd_fprintf_vma (abfd, stdout, val);
1345 else
1347 char buf[30];
1348 char *s;
1350 s = buf + sizeof buf;
1351 *--s = '\0';
1352 while (val > 0)
1354 *--s = (val % print_radix) + '0';
1355 val /= print_radix;
1357 while ((buf + sizeof buf - 1) - s < 16)
1358 *--s = '0';
1359 printf ("%s", s);
1361 #endif
1364 /* Print a line of information about a symbol. */
1366 static void
1367 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1369 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1371 if (print_width == 16)
1372 printf (" ");
1373 printf (" ");
1375 else
1377 /* Normally we print the value of the symbol. If we are printing the
1378 size or sorting by size then we print its size, except for the
1379 (weird) special case where both flags are defined, in which case we
1380 print both values. This conforms to documented behaviour. */
1381 if (sort_by_size && !print_size)
1382 print_value (abfd, SYM_SIZE (info));
1383 else
1384 print_value (abfd, SYM_VALUE (info));
1386 if (print_size && SYM_SIZE (info))
1388 printf (" ");
1389 print_value (abfd, SYM_SIZE (info));
1393 printf (" %c", SYM_TYPE (info));
1395 if (SYM_TYPE (info) == '-')
1397 /* A stab. */
1398 printf (" ");
1399 printf (other_format, SYM_STAB_OTHER (info));
1400 printf (" ");
1401 printf (desc_format, SYM_STAB_DESC (info));
1402 printf (" %5s", SYM_STAB_NAME (info));
1404 print_symname (" %s", SYM_NAME (info), abfd);
1407 static void
1408 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1410 print_symname ("%-20s|", SYM_NAME (info), abfd);
1412 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1414 if (print_width == 8)
1415 printf (" ");
1416 else
1417 printf (" ");
1419 else
1420 print_value (abfd, SYM_VALUE (info));
1422 printf ("| %c |", SYM_TYPE (info));
1424 if (SYM_TYPE (info) == '-')
1426 /* A stab. */
1427 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1428 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1429 printf ("| |"); /* Line, Section. */
1431 else
1433 /* Type, Size, Line, Section */
1434 if (info->elfinfo)
1435 printf ("%18s|",
1436 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1437 else
1438 printf (" |");
1440 if (SYM_SIZE (info))
1441 print_value (abfd, SYM_SIZE (info));
1442 else
1444 if (print_width == 8)
1445 printf (" ");
1446 else
1447 printf (" ");
1450 if (info->elfinfo)
1451 printf("| |%s", info->elfinfo->symbol.section->name);
1452 else
1453 printf("| |");
1457 static void
1458 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1460 print_symname ("%s ", SYM_NAME (info), abfd);
1461 printf ("%c ", SYM_TYPE (info));
1463 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1464 printf (" ");
1465 else
1467 print_value (abfd, SYM_VALUE (info));
1468 printf (" ");
1469 if (SYM_SIZE (info))
1470 print_value (abfd, SYM_SIZE (info));
1475 main (int argc, char **argv)
1477 int c;
1478 int retval;
1480 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1481 setlocale (LC_MESSAGES, "");
1482 #endif
1483 #if defined (HAVE_SETLOCALE)
1484 setlocale (LC_CTYPE, "");
1485 setlocale (LC_COLLATE, "");
1486 #endif
1487 bindtextdomain (PACKAGE, LOCALEDIR);
1488 textdomain (PACKAGE);
1490 program_name = *argv;
1491 xmalloc_set_program_name (program_name);
1493 START_PROGRESS (program_name, 0);
1495 expandargv (&argc, &argv);
1497 bfd_init ();
1498 set_default_bfd_target ();
1500 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1501 long_options, (int *) 0)) != EOF)
1503 switch (c)
1505 case 'a':
1506 print_debug_syms = 1;
1507 break;
1508 case 'A':
1509 case 'o':
1510 filename_per_symbol = 1;
1511 break;
1512 case 'B': /* For MIPS compatibility. */
1513 set_output_format ("bsd");
1514 break;
1515 case 'C':
1516 do_demangle = 1;
1517 if (optarg != NULL)
1519 enum demangling_styles style;
1521 style = cplus_demangle_name_to_style (optarg);
1522 if (style == unknown_demangling)
1523 fatal (_("unknown demangling style `%s'"),
1524 optarg);
1526 cplus_demangle_set_style (style);
1528 break;
1529 case 'D':
1530 dynamic = 1;
1531 break;
1532 case 'e':
1533 /* Ignored for HP/UX compatibility. */
1534 break;
1535 case 'f':
1536 set_output_format (optarg);
1537 break;
1538 case 'g':
1539 external_only = 1;
1540 break;
1541 case 'H':
1542 case 'h':
1543 usage (stdout, 0);
1544 case 'l':
1545 line_numbers = 1;
1546 break;
1547 case 'n':
1548 case 'v':
1549 sort_numerically = 1;
1550 break;
1551 case 'p':
1552 no_sort = 1;
1553 break;
1554 case 'P':
1555 set_output_format ("posix");
1556 break;
1557 case 'r':
1558 reverse_sort = 1;
1559 break;
1560 case 's':
1561 print_armap = 1;
1562 break;
1563 case 'S':
1564 print_size = 1;
1565 break;
1566 case 't':
1567 set_print_radix (optarg);
1568 break;
1569 case 'u':
1570 undefined_only = 1;
1571 break;
1572 case 'V':
1573 show_version = 1;
1574 break;
1575 case 'X':
1576 /* Ignored for (partial) AIX compatibility. On AIX, the
1577 argument has values 32, 64, or 32_64, and specifies that
1578 only 32-bit, only 64-bit, or both kinds of objects should
1579 be examined. The default is 32. So plain AIX nm on a
1580 library archive with both kinds of objects will ignore
1581 the 64-bit ones. For GNU nm, the default is and always
1582 has been -X 32_64, and other options are not supported. */
1583 if (strcmp (optarg, "32_64") != 0)
1584 fatal (_("Only -X 32_64 is supported"));
1585 break;
1587 case OPTION_TARGET: /* --target */
1588 target = optarg;
1589 break;
1591 case 0: /* A long option that just sets a flag. */
1592 break;
1594 default:
1595 usage (stderr, 1);
1599 if (show_version)
1600 print_version ("nm");
1602 if (sort_by_size && undefined_only)
1604 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1605 non_fatal (_("will produce no output, since undefined symbols have no size."));
1606 return 0;
1609 /* OK, all options now parsed. If no filename specified, do a.out. */
1610 if (optind == argc)
1611 return !display_file ("a.out");
1613 retval = 0;
1615 if (argc - optind > 1)
1616 filename_per_file = 1;
1618 /* We were given several filenames to do. */
1619 while (optind < argc)
1621 PROGRESS (1);
1622 if (!display_file (argv[optind++]))
1623 retval++;
1626 END_PROGRESS (program_name);
1628 #ifdef HAVE_SBRK
1629 if (show_stats)
1631 char *lim = (char *) sbrk (0);
1633 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1635 #endif
1637 exit (retval);
1638 return retval;