gas/
[binutils.git] / binutils / nm.c
blob2fc13b4c31993ccca7a6283891b90e3a00bf125e
1 /* nm.c -- Describe symbol table of a rel file.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "progress.h"
26 #include "getopt.h"
27 #include "aout/stab_gnu.h"
28 #include "aout/ranlib.h"
29 #include "demangle.h"
30 #include "libiberty.h"
31 #include "elf-bfd.h"
32 #include "elf/common.h"
33 #include "bucomm.h"
34 #include "plugin.h"
36 /* When sorting by size, we use this structure to hold the size and a
37 pointer to the minisymbol. */
39 struct size_sym
41 const void *minisym;
42 bfd_vma size;
45 /* When fetching relocs, we use this structure to pass information to
46 get_relocs. */
48 struct get_relocs_info
50 asection **secs;
51 arelent ***relocs;
52 long *relcount;
53 asymbol **syms;
56 struct extended_symbol_info
58 symbol_info *sinfo;
59 bfd_vma ssize;
60 elf_symbol_type *elfinfo;
61 /* FIXME: We should add more fields for Type, Line, Section. */
63 #define SYM_NAME(sym) (sym->sinfo->name)
64 #define SYM_VALUE(sym) (sym->sinfo->value)
65 #define SYM_TYPE(sym) (sym->sinfo->type)
66 #define SYM_STAB_NAME(sym) (sym->sinfo->stab_name)
67 #define SYM_STAB_DESC(sym) (sym->sinfo->stab_desc)
68 #define SYM_STAB_OTHER(sym) (sym->sinfo->stab_other)
69 #define SYM_SIZE(sym) \
70 (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
72 /* The output formatting functions. */
73 static void print_object_filename_bsd (char *);
74 static void print_object_filename_sysv (char *);
75 static void print_object_filename_posix (char *);
76 static void print_archive_filename_bsd (char *);
77 static void print_archive_filename_sysv (char *);
78 static void print_archive_filename_posix (char *);
79 static void print_archive_member_bsd (char *, const char *);
80 static void print_archive_member_sysv (char *, const char *);
81 static void print_archive_member_posix (char *, const char *);
82 static void print_symbol_filename_bsd (bfd *, bfd *);
83 static void print_symbol_filename_sysv (bfd *, bfd *);
84 static void print_symbol_filename_posix (bfd *, bfd *);
85 static void print_value (bfd *, bfd_vma);
86 static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
87 static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
88 static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
90 /* Support for different output formats. */
91 struct output_fns
93 /* Print the name of an object file given on the command line. */
94 void (*print_object_filename) (char *);
96 /* Print the name of an archive file given on the command line. */
97 void (*print_archive_filename) (char *);
99 /* Print the name of an archive member file. */
100 void (*print_archive_member) (char *, const char *);
102 /* Print the name of the file (and archive, if there is one)
103 containing a symbol. */
104 void (*print_symbol_filename) (bfd *, bfd *);
106 /* Print a line of information about a symbol. */
107 void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
110 static struct output_fns formats[] =
112 {print_object_filename_bsd,
113 print_archive_filename_bsd,
114 print_archive_member_bsd,
115 print_symbol_filename_bsd,
116 print_symbol_info_bsd},
117 {print_object_filename_sysv,
118 print_archive_filename_sysv,
119 print_archive_member_sysv,
120 print_symbol_filename_sysv,
121 print_symbol_info_sysv},
122 {print_object_filename_posix,
123 print_archive_filename_posix,
124 print_archive_member_posix,
125 print_symbol_filename_posix,
126 print_symbol_info_posix}
129 /* Indices in `formats'. */
130 #define FORMAT_BSD 0
131 #define FORMAT_SYSV 1
132 #define FORMAT_POSIX 2
133 #define FORMAT_DEFAULT FORMAT_BSD
135 /* The output format to use. */
136 static struct output_fns *format = &formats[FORMAT_DEFAULT];
138 /* Command options. */
140 static int do_demangle = 0; /* Pretty print C++ symbol names. */
141 static int external_only = 0; /* Print external symbols only. */
142 static int defined_only = 0; /* Print defined symbols only. */
143 static int no_sort = 0; /* Don't sort; print syms in order found. */
144 static int print_debug_syms = 0;/* Print debugger-only symbols too. */
145 static int print_armap = 0; /* Describe __.SYMDEF data in archive files. */
146 static int print_size = 0; /* Print size of defined symbols. */
147 static int reverse_sort = 0; /* Sort in downward(alpha or numeric) order. */
148 static int sort_numerically = 0;/* Sort in numeric rather than alpha order. */
149 static int sort_by_size = 0; /* Sort by size of symbol. */
150 static int undefined_only = 0; /* Print undefined symbols only. */
151 static int dynamic = 0; /* Print dynamic symbols. */
152 static int show_version = 0; /* Show the version number. */
153 static int show_stats = 0; /* Show statistics. */
154 static int show_synthetic = 0; /* Display synthesized symbols too. */
155 static int line_numbers = 0; /* Print line numbers for symbols. */
156 static int allow_special_symbols = 0; /* Allow special symbols. */
158 /* When to print the names of files. Not mutually exclusive in SYSV format. */
159 static int filename_per_file = 0; /* Once per file, on its own line. */
160 static int filename_per_symbol = 0; /* Once per symbol, at start of line. */
162 /* Print formats for printing a symbol value. */
163 static char value_format_32bit[] = "%08lx";
164 #if BFD_HOST_64BIT_LONG
165 static char value_format_64bit[] = "%016lx";
166 #elif BFD_HOST_64BIT_LONG_LONG
167 #ifndef __MSVCRT__
168 static char value_format_64bit[] = "%016llx";
169 #else
170 static char value_format_64bit[] = "%016I64x";
171 #endif
172 #endif
173 static int print_width = 0;
174 static int print_radix = 16;
175 /* Print formats for printing stab info. */
176 static char other_format[] = "%02x";
177 static char desc_format[] = "%04x";
179 static char *target = NULL;
180 static char *plugin_target = NULL;
182 /* Used to cache the line numbers for a BFD. */
183 static bfd *lineno_cache_bfd;
184 static bfd *lineno_cache_rel_bfd;
186 #define OPTION_TARGET 200
187 #define OPTION_PLUGIN 201
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 {"plugin", required_argument, 0, OPTION_PLUGIN},
203 {"portability", no_argument, 0, 'P'},
204 {"print-armap", no_argument, &print_armap, 1},
205 {"print-file-name", no_argument, 0, 'o'},
206 {"print-size", no_argument, 0, 'S'},
207 {"radix", required_argument, 0, 't'},
208 {"reverse-sort", no_argument, &reverse_sort, 1},
209 {"size-sort", no_argument, &sort_by_size, 1},
210 {"special-syms", no_argument, &allow_special_symbols, 1},
211 {"stats", no_argument, &show_stats, 1},
212 {"synthetic", no_argument, &show_synthetic, 1},
213 {"target", required_argument, 0, OPTION_TARGET},
214 {"defined-only", no_argument, &defined_only, 1},
215 {"undefined-only", no_argument, &undefined_only, 1},
216 {"version", no_argument, &show_version, 1},
217 {0, no_argument, 0, 0}
220 /* Some error-reporting functions. */
222 static void
223 usage (FILE *stream, int status)
225 fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
226 fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
227 fprintf (stream, _(" The options are:\n\
228 -a, --debug-syms Display debugger-only symbols\n\
229 -A, --print-file-name Print name of the input file before every symbol\n\
230 -B Same as --format=bsd\n\
231 -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
232 The STYLE, if specified, can be `auto' (the default),\n\
233 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
234 or `gnat'\n\
235 --no-demangle Do not demangle low-level symbol names\n\
236 -D, --dynamic Display dynamic symbols instead of normal symbols\n\
237 --defined-only Display only defined symbols\n\
238 -e (ignored)\n\
239 -f, --format=FORMAT Use the output format FORMAT. FORMAT can be `bsd',\n\
240 `sysv' or `posix'. The default is `bsd'\n\
241 -g, --extern-only Display only external symbols\n\
242 -l, --line-numbers Use debugging information to find a filename and\n\
243 line number for each symbol\n\
244 -n, --numeric-sort Sort symbols numerically by address\n\
245 -o Same as -A\n\
246 -p, --no-sort Do not sort the symbols\n\
247 -P, --portability Same as --format=posix\n\
248 -r, --reverse-sort Reverse the sense of the sort\n"));
249 #if BFD_SUPPORTS_PLUGINS
250 fprintf (stream, _("\
251 --plugin NAME Load the specified plugin\n"));
252 #endif
253 fprintf (stream, _("\
254 -S, --print-size Print size of defined symbols\n\
255 -s, --print-armap Include index for symbols from archive members\n\
256 --size-sort Sort symbols by size\n\
257 --special-syms Include special symbols in the output\n\
258 --synthetic Display synthetic symbols as well\n\
259 -t, --radix=RADIX Use RADIX for printing symbol values\n\
260 --target=BFDNAME Specify the target object format as BFDNAME\n\
261 -u, --undefined-only Display only undefined symbols\n\
262 -X 32_64 (ignored)\n\
263 @FILE Read options from FILE\n\
264 -h, --help Display this information\n\
265 -V, --version Display this program's version number\n\
266 \n"));
267 list_supported_targets (program_name, stream);
268 if (REPORT_BUGS_TO[0] && status == 0)
269 fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
270 exit (status);
273 /* Set the radix for the symbol value and size according to RADIX. */
275 static void
276 set_print_radix (char *radix)
278 switch (*radix)
280 case 'x':
281 break;
282 case 'd':
283 case 'o':
284 if (*radix == 'd')
285 print_radix = 10;
286 else
287 print_radix = 8;
288 value_format_32bit[4] = *radix;
289 #if BFD_HOST_64BIT_LONG
290 value_format_64bit[5] = *radix;
291 #elif BFD_HOST_64BIT_LONG_LONG
292 #ifndef __MSVCRT__
293 value_format_64bit[6] = *radix;
294 #else
295 value_format_64bit[7] = *radix;
296 #endif
297 #endif
298 other_format[3] = desc_format[3] = *radix;
299 break;
300 default:
301 fatal (_("%s: invalid radix"), radix);
305 static void
306 set_output_format (char *f)
308 int i;
310 switch (*f)
312 case 'b':
313 case 'B':
314 i = FORMAT_BSD;
315 break;
316 case 'p':
317 case 'P':
318 i = FORMAT_POSIX;
319 break;
320 case 's':
321 case 'S':
322 i = FORMAT_SYSV;
323 break;
324 default:
325 fatal (_("%s: invalid output format"), f);
327 format = &formats[i];
330 static const char *
331 get_symbol_type (unsigned int type)
333 static char buff [32];
335 switch (type)
337 case STT_NOTYPE: return "NOTYPE";
338 case STT_OBJECT: return "OBJECT";
339 case STT_FUNC: return "FUNC";
340 case STT_SECTION: return "SECTION";
341 case STT_FILE: return "FILE";
342 case STT_COMMON: return "COMMON";
343 case STT_TLS: return "TLS";
344 default:
345 if (type >= STT_LOPROC && type <= STT_HIPROC)
346 sprintf (buff, _("<processor specific>: %d"), type);
347 else if (type >= STT_LOOS && type <= STT_HIOS)
348 sprintf (buff, _("<OS specific>: %d"), type);
349 else
350 sprintf (buff, _("<unknown>: %d"), type);
351 return buff;
355 /* Print symbol name NAME, read from ABFD, with printf format FORM,
356 demangling it if requested. */
358 static void
359 print_symname (const char *form, const char *name, bfd *abfd)
361 if (do_demangle && *name)
363 char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
365 if (res != NULL)
367 printf (form, res);
368 free (res);
369 return;
373 printf (form, name);
376 static void
377 print_symdef_entry (bfd *abfd)
379 symindex idx = BFD_NO_MORE_SYMBOLS;
380 carsym *thesym;
381 bfd_boolean everprinted = FALSE;
383 for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
384 idx != BFD_NO_MORE_SYMBOLS;
385 idx = bfd_get_next_mapent (abfd, idx, &thesym))
387 bfd *elt;
388 if (!everprinted)
390 printf (_("\nArchive index:\n"));
391 everprinted = TRUE;
393 elt = bfd_get_elt_at_index (abfd, idx);
394 if (elt == NULL)
395 bfd_fatal ("bfd_get_elt_at_index");
396 if (thesym->name != (char *) NULL)
398 print_symname ("%s", thesym->name, abfd);
399 printf (" in %s\n", bfd_get_filename (elt));
404 /* Choose which symbol entries to print;
405 compact them downward to get rid of the rest.
406 Return the number of symbols to be printed. */
408 static long
409 filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
410 long symcount, unsigned int size)
412 bfd_byte *from, *fromend, *to;
413 asymbol *store;
415 store = bfd_make_empty_symbol (abfd);
416 if (store == NULL)
417 bfd_fatal (bfd_get_filename (abfd));
419 from = (bfd_byte *) minisyms;
420 fromend = from + symcount * size;
421 to = (bfd_byte *) minisyms;
423 for (; from < fromend; from += size)
425 int keep = 0;
426 asymbol *sym;
428 PROGRESS (1);
430 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
431 if (sym == NULL)
432 bfd_fatal (bfd_get_filename (abfd));
434 if (undefined_only)
435 keep = bfd_is_und_section (sym->section);
436 else if (external_only)
437 keep = ((sym->flags & BSF_GLOBAL) != 0
438 || (sym->flags & BSF_WEAK) != 0
439 /* PR binutls/12753: Unique symbols are global too. */
440 || (sym->flags & BSF_GNU_UNIQUE) != 0
441 || bfd_is_und_section (sym->section)
442 || bfd_is_com_section (sym->section));
443 else
444 keep = 1;
446 if (keep
447 && ! print_debug_syms
448 && (sym->flags & BSF_DEBUGGING) != 0)
449 keep = 0;
451 if (keep
452 && sort_by_size
453 && (bfd_is_abs_section (sym->section)
454 || bfd_is_und_section (sym->section)))
455 keep = 0;
457 if (keep
458 && defined_only)
460 if (bfd_is_und_section (sym->section))
461 keep = 0;
464 if (keep
465 && bfd_is_target_special_symbol (abfd, sym)
466 && ! allow_special_symbols)
467 keep = 0;
469 if (keep)
471 if (to != from)
472 memcpy (to, from, size);
473 to += size;
477 return (to - (bfd_byte *) minisyms) / size;
480 /* These globals are used to pass information into the sorting
481 routines. */
482 static bfd *sort_bfd;
483 static bfd_boolean sort_dynamic;
484 static asymbol *sort_x;
485 static asymbol *sort_y;
487 /* Symbol-sorting predicates */
488 #define valueof(x) ((x)->section->vma + (x)->value)
490 /* Numeric sorts. Undefined symbols are always considered "less than"
491 defined symbols with zero values. Common symbols are not treated
492 specially -- i.e., their sizes are used as their "values". */
494 static int
495 non_numeric_forward (const void *P_x, const void *P_y)
497 asymbol *x, *y;
498 const char *xn, *yn;
500 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
501 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
502 if (x == NULL || y == NULL)
503 bfd_fatal (bfd_get_filename (sort_bfd));
505 xn = bfd_asymbol_name (x);
506 yn = bfd_asymbol_name (y);
508 if (yn == NULL)
509 return xn != NULL;
510 if (xn == NULL)
511 return -1;
513 #ifdef HAVE_STRCOLL
514 /* Solaris 2.5 has a bug in strcoll.
515 strcoll returns invalid values when confronted with empty strings. */
516 if (*yn == '\0')
517 return *xn != '\0';
518 if (*xn == '\0')
519 return -1;
521 return strcoll (xn, yn);
522 #else
523 return strcmp (xn, yn);
524 #endif
527 static int
528 non_numeric_reverse (const void *x, const void *y)
530 return - non_numeric_forward (x, y);
533 static int
534 numeric_forward (const void *P_x, const void *P_y)
536 asymbol *x, *y;
537 asection *xs, *ys;
539 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
540 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
541 if (x == NULL || y == NULL)
542 bfd_fatal (bfd_get_filename (sort_bfd));
544 xs = bfd_get_section (x);
545 ys = bfd_get_section (y);
547 if (bfd_is_und_section (xs))
549 if (! bfd_is_und_section (ys))
550 return -1;
552 else if (bfd_is_und_section (ys))
553 return 1;
554 else if (valueof (x) != valueof (y))
555 return valueof (x) < valueof (y) ? -1 : 1;
557 return non_numeric_forward (P_x, P_y);
560 static int
561 numeric_reverse (const void *x, const void *y)
563 return - numeric_forward (x, y);
566 static int (*(sorters[2][2])) (const void *, const void *) =
568 { non_numeric_forward, non_numeric_reverse },
569 { numeric_forward, numeric_reverse }
572 /* This sort routine is used by sort_symbols_by_size. It is similar
573 to numeric_forward, but when symbols have the same value it sorts
574 by section VMA. This simplifies the sort_symbols_by_size code
575 which handles symbols at the end of sections. Also, this routine
576 tries to sort file names before other symbols with the same value.
577 That will make the file name have a zero size, which will make
578 sort_symbols_by_size choose the non file name symbol, leading to
579 more meaningful output. For similar reasons, this code sorts
580 gnu_compiled_* and gcc2_compiled before other symbols with the same
581 value. */
583 static int
584 size_forward1 (const void *P_x, const void *P_y)
586 asymbol *x, *y;
587 asection *xs, *ys;
588 const char *xn, *yn;
589 size_t xnl, ynl;
590 int xf, yf;
592 x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
593 y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
594 if (x == NULL || y == NULL)
595 bfd_fatal (bfd_get_filename (sort_bfd));
597 xs = bfd_get_section (x);
598 ys = bfd_get_section (y);
600 if (bfd_is_und_section (xs))
601 abort ();
602 if (bfd_is_und_section (ys))
603 abort ();
605 if (valueof (x) != valueof (y))
606 return valueof (x) < valueof (y) ? -1 : 1;
608 if (xs->vma != ys->vma)
609 return xs->vma < ys->vma ? -1 : 1;
611 xn = bfd_asymbol_name (x);
612 yn = bfd_asymbol_name (y);
613 xnl = strlen (xn);
614 ynl = strlen (yn);
616 /* The symbols gnu_compiled and gcc2_compiled convey even less
617 information than the file name, so sort them out first. */
619 xf = (strstr (xn, "gnu_compiled") != NULL
620 || strstr (xn, "gcc2_compiled") != NULL);
621 yf = (strstr (yn, "gnu_compiled") != NULL
622 || strstr (yn, "gcc2_compiled") != NULL);
624 if (xf && ! yf)
625 return -1;
626 if (! xf && yf)
627 return 1;
629 /* We use a heuristic for the file name. It may not work on non
630 Unix systems, but it doesn't really matter; the only difference
631 is precisely which symbol names get printed. */
633 #define file_symbol(s, sn, snl) \
634 (((s)->flags & BSF_FILE) != 0 \
635 || ((sn)[(snl) - 2] == '.' \
636 && ((sn)[(snl) - 1] == 'o' \
637 || (sn)[(snl) - 1] == 'a')))
639 xf = file_symbol (x, xn, xnl);
640 yf = file_symbol (y, yn, ynl);
642 if (xf && ! yf)
643 return -1;
644 if (! xf && yf)
645 return 1;
647 return non_numeric_forward (P_x, P_y);
650 /* This sort routine is used by sort_symbols_by_size. It is sorting
651 an array of size_sym structures into size order. */
653 static int
654 size_forward2 (const void *P_x, const void *P_y)
656 const struct size_sym *x = (const struct size_sym *) P_x;
657 const struct size_sym *y = (const struct size_sym *) P_y;
659 if (x->size < y->size)
660 return reverse_sort ? 1 : -1;
661 else if (x->size > y->size)
662 return reverse_sort ? -1 : 1;
663 else
664 return sorters[0][reverse_sort] (x->minisym, y->minisym);
667 /* Sort the symbols by size. ELF provides a size but for other formats
668 we have to make a guess by assuming that the difference between the
669 address of a symbol and the address of the next higher symbol is the
670 size. */
672 static long
673 sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
674 long symcount, unsigned int size,
675 struct size_sym **symsizesp)
677 struct size_sym *symsizes;
678 bfd_byte *from, *fromend;
679 asymbol *sym = NULL;
680 asymbol *store_sym, *store_next;
682 qsort (minisyms, symcount, size, size_forward1);
684 /* We are going to return a special set of symbols and sizes to
685 print. */
686 symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
687 *symsizesp = symsizes;
689 /* Note that filter_symbols has already removed all absolute and
690 undefined symbols. Here we remove all symbols whose size winds
691 up as zero. */
692 from = (bfd_byte *) minisyms;
693 fromend = from + symcount * size;
695 store_sym = sort_x;
696 store_next = sort_y;
698 if (from < fromend)
700 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
701 store_sym);
702 if (sym == NULL)
703 bfd_fatal (bfd_get_filename (abfd));
706 for (; from < fromend; from += size)
708 asymbol *next;
709 asection *sec;
710 bfd_vma sz;
711 asymbol *temp;
713 if (from + size < fromend)
715 next = bfd_minisymbol_to_symbol (abfd,
716 is_dynamic,
717 (const void *) (from + size),
718 store_next);
719 if (next == NULL)
720 bfd_fatal (bfd_get_filename (abfd));
722 else
723 next = NULL;
725 sec = bfd_get_section (sym);
727 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
728 sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
729 else if (bfd_is_com_section (sec))
730 sz = sym->value;
731 else
733 if (from + size < fromend
734 && sec == bfd_get_section (next))
735 sz = valueof (next) - valueof (sym);
736 else
737 sz = (bfd_get_section_vma (abfd, sec)
738 + bfd_section_size (abfd, sec)
739 - valueof (sym));
742 if (sz != 0)
744 symsizes->minisym = (const void *) from;
745 symsizes->size = sz;
746 ++symsizes;
749 sym = next;
751 temp = store_sym;
752 store_sym = store_next;
753 store_next = temp;
756 symcount = symsizes - *symsizesp;
758 /* We must now sort again by size. */
759 qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
761 return symcount;
764 /* This function is used to get the relocs for a particular section.
765 It is called via bfd_map_over_sections. */
767 static void
768 get_relocs (bfd *abfd, asection *sec, void *dataarg)
770 struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
772 *data->secs = sec;
774 if ((sec->flags & SEC_RELOC) == 0)
776 *data->relocs = NULL;
777 *data->relcount = 0;
779 else
781 long relsize;
783 relsize = bfd_get_reloc_upper_bound (abfd, sec);
784 if (relsize < 0)
785 bfd_fatal (bfd_get_filename (abfd));
787 *data->relocs = (arelent **) xmalloc (relsize);
788 *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
789 data->syms);
790 if (*data->relcount < 0)
791 bfd_fatal (bfd_get_filename (abfd));
794 ++data->secs;
795 ++data->relocs;
796 ++data->relcount;
799 /* Print a single symbol. */
801 static void
802 print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
804 symbol_info syminfo;
805 struct extended_symbol_info info;
807 PROGRESS (1);
809 format->print_symbol_filename (archive_bfd, abfd);
811 bfd_get_symbol_info (abfd, sym, &syminfo);
812 info.sinfo = &syminfo;
813 info.ssize = ssize;
814 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
815 info.elfinfo = (elf_symbol_type *) sym;
816 else
817 info.elfinfo = NULL;
818 format->print_symbol_info (&info, abfd);
820 if (line_numbers)
822 static asymbol **syms;
823 static long symcount;
824 const char *filename, *functionname;
825 unsigned int lineno;
827 /* We need to get the canonical symbols in order to call
828 bfd_find_nearest_line. This is inefficient, but, then, you
829 don't have to use --line-numbers. */
830 if (abfd != lineno_cache_bfd && syms != NULL)
832 free (syms);
833 syms = NULL;
835 if (syms == NULL)
837 long symsize;
839 symsize = bfd_get_symtab_upper_bound (abfd);
840 if (symsize < 0)
841 bfd_fatal (bfd_get_filename (abfd));
842 syms = (asymbol **) xmalloc (symsize);
843 symcount = bfd_canonicalize_symtab (abfd, syms);
844 if (symcount < 0)
845 bfd_fatal (bfd_get_filename (abfd));
846 lineno_cache_bfd = abfd;
849 if (bfd_is_und_section (bfd_get_section (sym)))
851 static asection **secs;
852 static arelent ***relocs;
853 static long *relcount;
854 static unsigned int seccount;
855 unsigned int i;
856 const char *symname;
858 /* For an undefined symbol, we try to find a reloc for the
859 symbol, and print the line number of the reloc. */
860 if (abfd != lineno_cache_rel_bfd && relocs != NULL)
862 for (i = 0; i < seccount; i++)
863 if (relocs[i] != NULL)
864 free (relocs[i]);
865 free (secs);
866 free (relocs);
867 free (relcount);
868 secs = NULL;
869 relocs = NULL;
870 relcount = NULL;
873 if (relocs == NULL)
875 struct get_relocs_info rinfo;
877 seccount = bfd_count_sections (abfd);
879 secs = (asection **) xmalloc (seccount * sizeof *secs);
880 relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
881 relcount = (long *) xmalloc (seccount * sizeof *relcount);
883 rinfo.secs = secs;
884 rinfo.relocs = relocs;
885 rinfo.relcount = relcount;
886 rinfo.syms = syms;
887 bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
888 lineno_cache_rel_bfd = abfd;
891 symname = bfd_asymbol_name (sym);
892 for (i = 0; i < seccount; i++)
894 long j;
896 for (j = 0; j < relcount[i]; j++)
898 arelent *r;
900 r = relocs[i][j];
901 if (r->sym_ptr_ptr != NULL
902 && (*r->sym_ptr_ptr)->section == sym->section
903 && (*r->sym_ptr_ptr)->value == sym->value
904 && strcmp (symname,
905 bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
906 && bfd_find_nearest_line (abfd, secs[i], syms,
907 r->address, &filename,
908 &functionname, &lineno)
909 && filename != NULL)
911 /* We only print the first one we find. */
912 printf ("\t%s:%u", filename, lineno);
913 i = seccount;
914 break;
919 else if (bfd_get_section (sym)->owner == abfd)
921 if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
922 || bfd_find_nearest_line (abfd, bfd_get_section (sym),
923 syms, sym->value, &filename,
924 &functionname, &lineno))
925 && filename != NULL
926 && lineno != 0)
927 printf ("\t%s:%u", filename, lineno);
931 putchar ('\n');
934 /* Print the symbols when sorting by size. */
936 static void
937 print_size_symbols (bfd *abfd, bfd_boolean is_dynamic,
938 struct size_sym *symsizes, long symcount,
939 bfd *archive_bfd)
941 asymbol *store;
942 struct size_sym *from, *fromend;
944 store = bfd_make_empty_symbol (abfd);
945 if (store == NULL)
946 bfd_fatal (bfd_get_filename (abfd));
948 from = symsizes;
949 fromend = from + symcount;
950 for (; from < fromend; from++)
952 asymbol *sym;
953 bfd_vma ssize;
955 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
956 if (sym == NULL)
957 bfd_fatal (bfd_get_filename (abfd));
959 /* For elf we have already computed the correct symbol size. */
960 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
961 ssize = from->size;
962 else
963 ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
965 print_symbol (abfd, sym, ssize, archive_bfd);
970 /* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
971 containing ABFD. */
973 static void
974 print_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms, long symcount,
975 unsigned int size, bfd *archive_bfd)
977 asymbol *store;
978 bfd_byte *from, *fromend;
980 store = bfd_make_empty_symbol (abfd);
981 if (store == NULL)
982 bfd_fatal (bfd_get_filename (abfd));
984 from = (bfd_byte *) minisyms;
985 fromend = from + symcount * size;
986 for (; from < fromend; from += size)
988 asymbol *sym;
990 sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
991 if (sym == NULL)
992 bfd_fatal (bfd_get_filename (abfd));
994 print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
998 /* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
1000 static void
1001 display_rel_file (bfd *abfd, bfd *archive_bfd)
1003 long symcount;
1004 void *minisyms;
1005 unsigned int size;
1006 struct size_sym *symsizes;
1008 if (! dynamic)
1010 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1012 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1013 return;
1017 symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
1018 if (symcount < 0)
1019 bfd_fatal (bfd_get_filename (abfd));
1021 if (symcount == 0)
1023 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1024 return;
1027 if (show_synthetic && size == sizeof (asymbol *))
1029 asymbol *synthsyms;
1030 long synth_count;
1031 asymbol **static_syms = NULL;
1032 asymbol **dyn_syms = NULL;
1033 long static_count = 0;
1034 long dyn_count = 0;
1036 if (dynamic)
1038 dyn_count = symcount;
1039 dyn_syms = (asymbol **) minisyms;
1041 else
1043 long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
1045 static_count = symcount;
1046 static_syms = (asymbol **) minisyms;
1048 if (storage > 0)
1050 dyn_syms = (asymbol **) xmalloc (storage);
1051 dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
1052 if (dyn_count < 0)
1053 bfd_fatal (bfd_get_filename (abfd));
1056 synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
1057 dyn_count, dyn_syms, &synthsyms);
1058 if (synth_count > 0)
1060 asymbol **symp;
1061 void *new_mini;
1062 long i;
1064 new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
1065 symp = (asymbol **) new_mini;
1066 memcpy (symp, minisyms, symcount * sizeof (*symp));
1067 symp += symcount;
1068 for (i = 0; i < synth_count; i++)
1069 *symp++ = synthsyms + i;
1070 *symp = 0;
1071 minisyms = new_mini;
1072 symcount += synth_count;
1076 /* Discard the symbols we don't want to print.
1077 It's OK to do this in place; we'll free the storage anyway
1078 (after printing). */
1080 symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
1082 symsizes = NULL;
1083 if (! no_sort)
1085 sort_bfd = abfd;
1086 sort_dynamic = dynamic;
1087 sort_x = bfd_make_empty_symbol (abfd);
1088 sort_y = bfd_make_empty_symbol (abfd);
1089 if (sort_x == NULL || sort_y == NULL)
1090 bfd_fatal (bfd_get_filename (abfd));
1092 if (! sort_by_size)
1093 qsort (minisyms, symcount, size,
1094 sorters[sort_numerically][reverse_sort]);
1095 else
1096 symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
1097 size, &symsizes);
1100 if (! sort_by_size)
1101 print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
1102 else
1103 print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
1105 free (minisyms);
1106 free (symsizes);
1109 static void
1110 set_print_width (bfd *file)
1112 print_width = bfd_get_arch_size (file);
1114 if (print_width == -1)
1116 /* PR binutils/4292
1117 Guess the target's bitsize based on its name.
1118 We assume here than any 64-bit format will include
1119 "64" somewhere in its name. The only known exception
1120 is the MMO object file format. */
1121 if (strstr (bfd_get_target (file), "64") != NULL
1122 || strcmp (bfd_get_target (file), "mmo") == 0)
1123 print_width = 64;
1124 else
1125 print_width = 32;
1129 static void
1130 display_archive (bfd *file)
1132 bfd *arfile = NULL;
1133 bfd *last_arfile = NULL;
1134 char **matching;
1136 format->print_archive_filename (bfd_get_filename (file));
1138 if (print_armap)
1139 print_symdef_entry (file);
1141 for (;;)
1143 PROGRESS (1);
1145 arfile = bfd_openr_next_archived_file (file, arfile);
1147 if (arfile == NULL)
1149 if (bfd_get_error () != bfd_error_no_more_archived_files)
1150 bfd_fatal (bfd_get_filename (file));
1151 break;
1154 if (bfd_check_format_matches (arfile, bfd_object, &matching))
1156 set_print_width (arfile);
1157 format->print_archive_member (bfd_get_filename (file),
1158 bfd_get_filename (arfile));
1159 display_rel_file (arfile, file);
1161 else
1163 bfd_nonfatal (bfd_get_filename (arfile));
1164 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1166 list_matching_formats (matching);
1167 free (matching);
1171 if (last_arfile != NULL)
1173 bfd_close (last_arfile);
1174 lineno_cache_bfd = NULL;
1175 lineno_cache_rel_bfd = NULL;
1177 last_arfile = arfile;
1180 if (last_arfile != NULL)
1182 bfd_close (last_arfile);
1183 lineno_cache_bfd = NULL;
1184 lineno_cache_rel_bfd = NULL;
1188 static bfd_boolean
1189 display_file (char *filename)
1191 bfd_boolean retval = TRUE;
1192 bfd *file;
1193 char **matching;
1195 if (get_file_size (filename) < 1)
1196 return FALSE;
1198 file = bfd_openr (filename, target ? target : plugin_target);
1199 if (file == NULL)
1201 bfd_nonfatal (filename);
1202 return FALSE;
1205 if (bfd_check_format (file, bfd_archive))
1207 display_archive (file);
1209 else if (bfd_check_format_matches (file, bfd_object, &matching))
1211 set_print_width (file);
1212 format->print_object_filename (filename);
1213 display_rel_file (file, NULL);
1215 else
1217 bfd_nonfatal (filename);
1218 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1220 list_matching_formats (matching);
1221 free (matching);
1223 retval = FALSE;
1226 if (!bfd_close (file))
1227 bfd_fatal (filename);
1229 lineno_cache_bfd = NULL;
1230 lineno_cache_rel_bfd = NULL;
1232 return retval;
1235 /* The following 3 groups of functions are called unconditionally,
1236 once at the start of processing each file of the appropriate type.
1237 They should check `filename_per_file' and `filename_per_symbol',
1238 as appropriate for their output format, to determine whether to
1239 print anything. */
1241 /* Print the name of an object file given on the command line. */
1243 static void
1244 print_object_filename_bsd (char *filename)
1246 if (filename_per_file && !filename_per_symbol)
1247 printf ("\n%s:\n", filename);
1250 static void
1251 print_object_filename_sysv (char *filename)
1253 if (undefined_only)
1254 printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
1255 else
1256 printf (_("\n\nSymbols from %s:\n\n"), filename);
1257 if (print_width == 32)
1258 printf (_("\
1259 Name Value Class Type Size Line Section\n\n"));
1260 else
1261 printf (_("\
1262 Name Value Class Type Size Line Section\n\n"));
1265 static void
1266 print_object_filename_posix (char *filename)
1268 if (filename_per_file && !filename_per_symbol)
1269 printf ("%s:\n", filename);
1272 /* Print the name of an archive file given on the command line. */
1274 static void
1275 print_archive_filename_bsd (char *filename)
1277 if (filename_per_file)
1278 printf ("\n%s:\n", filename);
1281 static void
1282 print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
1286 static void
1287 print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
1291 /* Print the name of an archive member file. */
1293 static void
1294 print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
1295 const char *filename)
1297 if (!filename_per_symbol)
1298 printf ("\n%s:\n", filename);
1301 static void
1302 print_archive_member_sysv (char *archive, const char *filename)
1304 if (undefined_only)
1305 printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
1306 else
1307 printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
1308 if (print_width == 32)
1309 printf (_("\
1310 Name Value Class Type Size Line Section\n\n"));
1311 else
1312 printf (_("\
1313 Name Value Class Type Size Line Section\n\n"));
1316 static void
1317 print_archive_member_posix (char *archive, const char *filename)
1319 if (!filename_per_symbol)
1320 printf ("%s[%s]:\n", archive, filename);
1323 /* Print the name of the file (and archive, if there is one)
1324 containing a symbol. */
1326 static void
1327 print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
1329 if (filename_per_symbol)
1331 if (archive_bfd)
1332 printf ("%s:", bfd_get_filename (archive_bfd));
1333 printf ("%s:", bfd_get_filename (abfd));
1337 static void
1338 print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
1340 if (filename_per_symbol)
1342 if (archive_bfd)
1343 printf ("%s:", bfd_get_filename (archive_bfd));
1344 printf ("%s:", bfd_get_filename (abfd));
1348 static void
1349 print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
1351 if (filename_per_symbol)
1353 if (archive_bfd)
1354 printf ("%s[%s]: ", bfd_get_filename (archive_bfd),
1355 bfd_get_filename (abfd));
1356 else
1357 printf ("%s: ", bfd_get_filename (abfd));
1361 /* Print a symbol value. */
1363 static void
1364 print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
1366 switch (print_width)
1368 case 32:
1369 printf (value_format_32bit, (unsigned long) val);
1370 break;
1372 case 64:
1373 #if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
1374 printf (value_format_64bit, val);
1375 #else
1376 /* We have a 64 bit value to print, but the host is only 32 bit. */
1377 if (print_radix == 16)
1378 bfd_fprintf_vma (abfd, stdout, val);
1379 else
1381 char buf[30];
1382 char *s;
1384 s = buf + sizeof buf;
1385 *--s = '\0';
1386 while (val > 0)
1388 *--s = (val % print_radix) + '0';
1389 val /= print_radix;
1391 while ((buf + sizeof buf - 1) - s < 16)
1392 *--s = '0';
1393 printf ("%s", s);
1395 #endif
1396 break;
1398 default:
1399 fatal (_("Print width has not been initialized (%d)"), print_width);
1400 break;
1404 /* Print a line of information about a symbol. */
1406 static void
1407 print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
1409 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1411 if (print_width == 64)
1412 printf (" ");
1413 printf (" ");
1415 else
1417 /* Normally we print the value of the symbol. If we are printing the
1418 size or sorting by size then we print its size, except for the
1419 (weird) special case where both flags are defined, in which case we
1420 print both values. This conforms to documented behaviour. */
1421 if (sort_by_size && !print_size)
1422 print_value (abfd, SYM_SIZE (info));
1423 else
1424 print_value (abfd, SYM_VALUE (info));
1426 if (print_size && SYM_SIZE (info))
1428 printf (" ");
1429 print_value (abfd, SYM_SIZE (info));
1433 printf (" %c", SYM_TYPE (info));
1435 if (SYM_TYPE (info) == '-')
1437 /* A stab. */
1438 printf (" ");
1439 printf (other_format, SYM_STAB_OTHER (info));
1440 printf (" ");
1441 printf (desc_format, SYM_STAB_DESC (info));
1442 printf (" %5s", SYM_STAB_NAME (info));
1444 print_symname (" %s", SYM_NAME (info), abfd);
1447 static void
1448 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
1450 print_symname ("%-20s|", SYM_NAME (info), abfd);
1452 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1454 if (print_width == 32)
1455 printf (" ");
1456 else
1457 printf (" ");
1459 else
1460 print_value (abfd, SYM_VALUE (info));
1462 printf ("| %c |", SYM_TYPE (info));
1464 if (SYM_TYPE (info) == '-')
1466 /* A stab. */
1467 printf ("%18s| ", SYM_STAB_NAME (info)); /* (C) Type. */
1468 printf (desc_format, SYM_STAB_DESC (info)); /* Size. */
1469 printf ("| |"); /* Line, Section. */
1471 else
1473 /* Type, Size, Line, Section */
1474 if (info->elfinfo)
1475 printf ("%18s|",
1476 get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
1477 else
1478 printf (" |");
1480 if (SYM_SIZE (info))
1481 print_value (abfd, SYM_SIZE (info));
1482 else
1484 if (print_width == 32)
1485 printf (" ");
1486 else
1487 printf (" ");
1490 if (info->elfinfo)
1491 printf("| |%s", info->elfinfo->symbol.section->name);
1492 else
1493 printf("| |");
1497 static void
1498 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
1500 print_symname ("%s ", SYM_NAME (info), abfd);
1501 printf ("%c ", SYM_TYPE (info));
1503 if (bfd_is_undefined_symclass (SYM_TYPE (info)))
1504 printf (" ");
1505 else
1507 print_value (abfd, SYM_VALUE (info));
1508 printf (" ");
1509 if (SYM_SIZE (info))
1510 print_value (abfd, SYM_SIZE (info));
1515 main (int argc, char **argv)
1517 int c;
1518 int retval;
1520 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
1521 setlocale (LC_MESSAGES, "");
1522 #endif
1523 #if defined (HAVE_SETLOCALE)
1524 setlocale (LC_CTYPE, "");
1525 setlocale (LC_COLLATE, "");
1526 #endif
1527 bindtextdomain (PACKAGE, LOCALEDIR);
1528 textdomain (PACKAGE);
1530 program_name = *argv;
1531 xmalloc_set_program_name (program_name);
1532 #if BFD_SUPPORTS_PLUGINS
1533 bfd_plugin_set_program_name (program_name);
1534 #endif
1536 START_PROGRESS (program_name, 0);
1538 expandargv (&argc, &argv);
1540 bfd_init ();
1541 set_default_bfd_target ();
1543 while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
1544 long_options, (int *) 0)) != EOF)
1546 switch (c)
1548 case 'a':
1549 print_debug_syms = 1;
1550 break;
1551 case 'A':
1552 case 'o':
1553 filename_per_symbol = 1;
1554 break;
1555 case 'B': /* For MIPS compatibility. */
1556 set_output_format ("bsd");
1557 break;
1558 case 'C':
1559 do_demangle = 1;
1560 if (optarg != NULL)
1562 enum demangling_styles style;
1564 style = cplus_demangle_name_to_style (optarg);
1565 if (style == unknown_demangling)
1566 fatal (_("unknown demangling style `%s'"),
1567 optarg);
1569 cplus_demangle_set_style (style);
1571 break;
1572 case 'D':
1573 dynamic = 1;
1574 break;
1575 case 'e':
1576 /* Ignored for HP/UX compatibility. */
1577 break;
1578 case 'f':
1579 set_output_format (optarg);
1580 break;
1581 case 'g':
1582 external_only = 1;
1583 break;
1584 case 'H':
1585 case 'h':
1586 usage (stdout, 0);
1587 case 'l':
1588 line_numbers = 1;
1589 break;
1590 case 'n':
1591 case 'v':
1592 sort_numerically = 1;
1593 break;
1594 case 'p':
1595 no_sort = 1;
1596 break;
1597 case 'P':
1598 set_output_format ("posix");
1599 break;
1600 case 'r':
1601 reverse_sort = 1;
1602 break;
1603 case 's':
1604 print_armap = 1;
1605 break;
1606 case 'S':
1607 print_size = 1;
1608 break;
1609 case 't':
1610 set_print_radix (optarg);
1611 break;
1612 case 'u':
1613 undefined_only = 1;
1614 break;
1615 case 'V':
1616 show_version = 1;
1617 break;
1618 case 'X':
1619 /* Ignored for (partial) AIX compatibility. On AIX, the
1620 argument has values 32, 64, or 32_64, and specifies that
1621 only 32-bit, only 64-bit, or both kinds of objects should
1622 be examined. The default is 32. So plain AIX nm on a
1623 library archive with both kinds of objects will ignore
1624 the 64-bit ones. For GNU nm, the default is and always
1625 has been -X 32_64, and other options are not supported. */
1626 if (strcmp (optarg, "32_64") != 0)
1627 fatal (_("Only -X 32_64 is supported"));
1628 break;
1630 case OPTION_TARGET: /* --target */
1631 target = optarg;
1632 break;
1634 case OPTION_PLUGIN: /* --plugin */
1635 #if BFD_SUPPORTS_PLUGINS
1636 plugin_target = "plugin";
1637 bfd_plugin_set_plugin (optarg);
1638 #else
1639 fatal (_("sorry - this program has been built without plugin support\n"));
1640 #endif
1641 break;
1643 case 0: /* A long option that just sets a flag. */
1644 break;
1646 default:
1647 usage (stderr, 1);
1651 if (show_version)
1652 print_version ("nm");
1654 if (sort_by_size && undefined_only)
1656 non_fatal (_("Using the --size-sort and --undefined-only options together"));
1657 non_fatal (_("will produce no output, since undefined symbols have no size."));
1658 return 0;
1661 /* OK, all options now parsed. If no filename specified, do a.out. */
1662 if (optind == argc)
1663 return !display_file ("a.out");
1665 retval = 0;
1667 if (argc - optind > 1)
1668 filename_per_file = 1;
1670 /* We were given several filenames to do. */
1671 while (optind < argc)
1673 PROGRESS (1);
1674 if (!display_file (argv[optind++]))
1675 retval++;
1678 END_PROGRESS (program_name);
1680 #ifdef HAVE_SBRK
1681 if (show_stats)
1683 char *lim = (char *) sbrk (0);
1685 non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
1687 #endif
1689 exit (retval);
1690 return retval;