/* nm.c -- Describe symbol table of a rel file.
Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003
+ 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GNU Binutils.
struct size_sym
{
- const PTR minisym;
+ const void *minisym;
bfd_vma size;
};
#define SYM_SIZE(sym) \
(sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
-static void usage
- PARAMS ((FILE *, int));
-static void set_print_radix
- PARAMS ((char *));
-static void set_output_format
- PARAMS ((char *));
-static void display_archive
- PARAMS ((bfd *));
-static bfd_boolean display_file
- PARAMS ((char *));
-static void display_rel_file
- PARAMS ((bfd *, bfd *));
-static long filter_symbols
- PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int));
-static long sort_symbols_by_size
- PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int, struct size_sym **));
-static void print_symbols
- PARAMS ((bfd *, bfd_boolean, PTR, long, unsigned int, bfd *));
-static void print_size_symbols
- PARAMS ((bfd *, bfd_boolean, struct size_sym *, long, bfd *));
-static void print_symname
- PARAMS ((const char *, const char *, bfd *));
-static void print_symbol
- PARAMS ((bfd *, asymbol *, bfd_vma ssize, bfd *));
-static void print_symdef_entry
- PARAMS ((bfd *));
-
-/* The sorting functions. */
-static int numeric_forward
- PARAMS ((const PTR, const PTR));
-static int numeric_reverse
- PARAMS ((const PTR, const PTR));
-static int non_numeric_forward
- PARAMS ((const PTR, const PTR));
-static int non_numeric_reverse
- PARAMS ((const PTR, const PTR));
-static int size_forward1
- PARAMS ((const PTR, const PTR));
-static int size_forward2
- PARAMS ((const PTR, const PTR));
-
/* The output formatting functions. */
-static void print_object_filename_bsd
- PARAMS ((char *));
-static void print_object_filename_sysv
- PARAMS ((char *));
-static void print_object_filename_posix
- PARAMS ((char *));
-static void print_archive_filename_bsd
- PARAMS ((char *));
-static void print_archive_filename_sysv
- PARAMS ((char *));
-static void print_archive_filename_posix
- PARAMS ((char *));
-static void print_archive_member_bsd
- PARAMS ((char *, const char *));
-static void print_archive_member_sysv
- PARAMS ((char *, const char *));
-static void print_archive_member_posix
- PARAMS ((char *, const char *));
-static void print_symbol_filename_bsd
- PARAMS ((bfd *, bfd *));
-static void print_symbol_filename_sysv
- PARAMS ((bfd *, bfd *));
-static void print_symbol_filename_posix
- PARAMS ((bfd *, bfd *));
-static void print_value
- PARAMS ((bfd *, bfd_vma));
-static void print_symbol_info_bsd
- PARAMS ((struct extended_symbol_info *, bfd *));
-static void print_symbol_info_sysv
- PARAMS ((struct extended_symbol_info *, bfd *));
-static void print_symbol_info_posix
- PARAMS ((struct extended_symbol_info *, bfd *));
-static void get_relocs
- PARAMS ((bfd *, asection *, PTR));
-static const char * get_symbol_type
- PARAMS ((unsigned int));
+static void print_object_filename_bsd (char *);
+static void print_object_filename_sysv (char *);
+static void print_object_filename_posix (char *);
+static void print_archive_filename_bsd (char *);
+static void print_archive_filename_sysv (char *);
+static void print_archive_filename_posix (char *);
+static void print_archive_member_bsd (char *, const char *);
+static void print_archive_member_sysv (char *, const char *);
+static void print_archive_member_posix (char *, const char *);
+static void print_symbol_filename_bsd (bfd *, bfd *);
+static void print_symbol_filename_sysv (bfd *, bfd *);
+static void print_symbol_filename_posix (bfd *, bfd *);
+static void print_value (bfd *, bfd_vma);
+static void print_symbol_info_bsd (struct extended_symbol_info *, bfd *);
+static void print_symbol_info_sysv (struct extended_symbol_info *, bfd *);
+static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
/* Support for different output formats. */
struct output_fns
{
/* Print the name of an object file given on the command line. */
- void (*print_object_filename) PARAMS ((char *));
+ void (*print_object_filename) (char *);
/* Print the name of an archive file given on the command line. */
- void (*print_archive_filename) PARAMS ((char *));
+ void (*print_archive_filename) (char *);
/* Print the name of an archive member file. */
- void (*print_archive_member) PARAMS ((char *, const char *));
+ void (*print_archive_member) (char *, const char *);
/* Print the name of the file (and archive, if there is one)
containing a symbol. */
- void (*print_symbol_filename) PARAMS ((bfd *, bfd *));
+ void (*print_symbol_filename) (bfd *, bfd *);
/* Print a line of information about a symbol. */
- void (*print_symbol_info) PARAMS ((struct extended_symbol_info *, bfd *));
+ void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
};
static struct output_fns formats[] =
static int dynamic = 0; /* Print dynamic symbols. */
static int show_version = 0; /* Show the version number. */
static int show_stats = 0; /* Show statistics. */
+static int show_synthetic = 0; /* Display synthesized symbols too. */
static int line_numbers = 0; /* Print line numbers for symbols. */
+static int allow_special_symbols = 0; /* Allow special symbols. */
/* When to print the names of files. Not mutually exclusive in SYSV format. */
static int filename_per_file = 0; /* Once per file, on its own line. */
{"radix", required_argument, 0, 't'},
{"reverse-sort", no_argument, &reverse_sort, 1},
{"size-sort", no_argument, &sort_by_size, 1},
+ {"special-syms", no_argument, &allow_special_symbols, 1},
{"stats", no_argument, &show_stats, 1},
+ {"synthetic", no_argument, &show_synthetic, 1},
{"target", required_argument, 0, OPTION_TARGET},
{"defined-only", no_argument, &defined_only, 1},
{"undefined-only", no_argument, &undefined_only, 1},
/* Some error-reporting functions. */
static void
-usage (stream, status)
- FILE *stream;
- int status;
+usage (FILE *stream, int status)
{
fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
-S, --print-size Print size of defined symbols\n\
-s, --print-armap Include index for symbols from archive members\n\
--size-sort Sort symbols by size\n\
+ --special-syms Include special symbols in the output\n\
+ --synthetic Display synthetic symbols as well\n\
-t, --radix=RADIX Use RADIX for printing symbol values\n\
--target=BFDNAME Specify the target object format as BFDNAME\n\
-u, --undefined-only Display only undefined symbols\n\
/* Set the radix for the symbol value and size according to RADIX. */
static void
-set_print_radix (radix)
- char *radix;
+set_print_radix (char *radix)
{
switch (*radix)
{
}
static void
-set_output_format (f)
- char *f;
+set_output_format (char *f)
{
int i;
format = &formats[i];
}
\f
-int main PARAMS ((int, char **));
-
-int
-main (argc, argv)
- int argc;
- char **argv;
-{
- int c;
- int retval;
-
-#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
- setlocale (LC_MESSAGES, "");
-#endif
-#if defined (HAVE_SETLOCALE)
- setlocale (LC_CTYPE, "");
- setlocale (LC_COLLATE, "");
-#endif
- bindtextdomain (PACKAGE, LOCALEDIR);
- textdomain (PACKAGE);
-
- program_name = *argv;
- xmalloc_set_program_name (program_name);
-
- START_PROGRESS (program_name, 0);
-
- bfd_init ();
- set_default_bfd_target ();
-
- while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
- long_options, (int *) 0)) != EOF)
- {
- switch (c)
- {
- case 'a':
- print_debug_syms = 1;
- break;
- case 'A':
- case 'o':
- filename_per_symbol = 1;
- break;
- case 'B': /* For MIPS compatibility. */
- set_output_format ("bsd");
- break;
- case 'C':
- do_demangle = 1;
- if (optarg != NULL)
- {
- enum demangling_styles style;
-
- style = cplus_demangle_name_to_style (optarg);
- if (style == unknown_demangling)
- fatal (_("unknown demangling style `%s'"),
- optarg);
-
- cplus_demangle_set_style (style);
- }
- break;
- case 'D':
- dynamic = 1;
- break;
- case 'e':
- /* Ignored for HP/UX compatibility. */
- break;
- case 'f':
- set_output_format (optarg);
- break;
- case 'g':
- external_only = 1;
- break;
- case 'H':
- case 'h':
- usage (stdout, 0);
- case 'l':
- line_numbers = 1;
- break;
- case 'n':
- case 'v':
- sort_numerically = 1;
- break;
- case 'p':
- no_sort = 1;
- break;
- case 'P':
- set_output_format ("posix");
- break;
- case 'r':
- reverse_sort = 1;
- break;
- case 's':
- print_armap = 1;
- break;
- case 'S':
- print_size = 1;
- break;
- case 't':
- set_print_radix (optarg);
- break;
- case 'u':
- undefined_only = 1;
- break;
- case 'V':
- show_version = 1;
- break;
- case 'X':
- /* Ignored for (partial) AIX compatibility. On AIX, the
- argument has values 32, 64, or 32_64, and specfies that
- only 32-bit, only 64-bit, or both kinds of objects should
- be examined. The default is 32. So plain AIX nm on a
- library archive with both kinds of objects will ignore
- the 64-bit ones. For GNU nm, the default is and always
- has been -X 32_64, and other options are not supported. */
- if (strcmp (optarg, "32_64") != 0)
- fatal (_("Only -X 32_64 is supported"));
- break;
-
- case OPTION_TARGET: /* --target */
- target = optarg;
- break;
-
- case 0: /* A long option that just sets a flag. */
- break;
-
- default:
- usage (stderr, 1);
- }
- }
-
- if (show_version)
- print_version ("nm");
-
- if (sort_by_size && undefined_only)
- {
- non_fatal (_("Using the --size-sort and --undefined-only options together"));
- non_fatal (_("will produce no output, since undefined symbols have no size."));
- return 0;
- }
-
- /* OK, all options now parsed. If no filename specified, do a.out. */
- if (optind == argc)
- return !display_file ("a.out");
-
- retval = 0;
-
- if (argc - optind > 1)
- filename_per_file = 1;
-
- /* We were given several filenames to do. */
- while (optind < argc)
- {
- PROGRESS (1);
- if (!display_file (argv[optind++]))
- retval++;
- }
-
- END_PROGRESS (program_name);
-
-#ifdef HAVE_SBRK
- if (show_stats)
- {
- char *lim = (char *) sbrk (0);
-
- non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
- }
-#endif
-
- exit (retval);
- return retval;
-}
-\f
static const char *
-get_symbol_type (type)
- unsigned int type;
+get_symbol_type (unsigned int type)
{
static char buff [32];
return buff;
}
}
+\f
+/* Print symbol name NAME, read from ABFD, with printf format FORMAT,
+ demangling it if requested. */
static void
-display_archive (file)
- bfd *file;
+print_symname (const char *format, const char *name, bfd *abfd)
{
- bfd *arfile = NULL;
- bfd *last_arfile = NULL;
- char **matching;
-
- (*format->print_archive_filename) (bfd_get_filename (file));
-
- if (print_armap)
- print_symdef_entry (file);
-
- for (;;)
+ if (do_demangle && *name)
{
- PROGRESS (1);
+ char *res = demangle (abfd, name);
- arfile = bfd_openr_next_archived_file (file, arfile);
+ printf (format, res);
+ free (res);
+ return;
+ }
- if (arfile == NULL)
- {
- if (bfd_get_error () != bfd_error_no_more_archived_files)
- bfd_fatal (bfd_get_filename (file));
- break;
- }
+ printf (format, name);
+}
- if (bfd_check_format_matches (arfile, bfd_object, &matching))
- {
- char buf[30];
+static void
+print_symdef_entry (bfd *abfd)
+{
+ symindex idx = BFD_NO_MORE_SYMBOLS;
+ carsym *thesym;
+ bfd_boolean everprinted = FALSE;
- bfd_sprintf_vma (arfile, buf, (bfd_vma) -1);
- print_width = strlen (buf);
- (*format->print_archive_member) (bfd_get_filename (file),
- bfd_get_filename (arfile));
- display_rel_file (arfile, file);
- }
- else
+ for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
+ idx != BFD_NO_MORE_SYMBOLS;
+ idx = bfd_get_next_mapent (abfd, idx, &thesym))
+ {
+ bfd *elt;
+ if (!everprinted)
{
- bfd_nonfatal (bfd_get_filename (arfile));
- if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
- {
- list_matching_formats (matching);
- free (matching);
- }
+ printf (_("\nArchive index:\n"));
+ everprinted = TRUE;
}
-
- if (last_arfile != NULL)
+ elt = bfd_get_elt_at_index (abfd, idx);
+ if (elt == NULL)
+ bfd_fatal ("bfd_get_elt_at_index");
+ if (thesym->name != (char *) NULL)
{
- bfd_close (last_arfile);
- lineno_cache_bfd = NULL;
- lineno_cache_rel_bfd = NULL;
+ print_symname ("%s", thesym->name, abfd);
+ printf (" in %s\n", bfd_get_filename (elt));
}
- last_arfile = arfile;
- }
-
- if (last_arfile != NULL)
- {
- bfd_close (last_arfile);
- lineno_cache_bfd = NULL;
- lineno_cache_rel_bfd = NULL;
}
}
+\f
+/* Choose which symbol entries to print;
+ compact them downward to get rid of the rest.
+ Return the number of symbols to be printed. */
-static bfd_boolean
-display_file (filename)
- char *filename;
+static long
+filter_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms,
+ long symcount, unsigned int size)
{
- bfd_boolean retval = TRUE;
- bfd *file;
- char **matching;
+ bfd_byte *from, *fromend, *to;
+ asymbol *store;
- file = bfd_openr (filename, target);
- if (file == NULL)
- {
- bfd_nonfatal (filename);
- return FALSE;
- }
+ store = bfd_make_empty_symbol (abfd);
+ if (store == NULL)
+ bfd_fatal (bfd_get_filename (abfd));
- if (bfd_check_format (file, bfd_archive))
- {
- display_archive (file);
- }
- else if (bfd_check_format_matches (file, bfd_object, &matching))
- {
- char buf[30];
+ from = (bfd_byte *) minisyms;
+ fromend = from + symcount * size;
+ to = (bfd_byte *) minisyms;
- bfd_sprintf_vma (file, buf, (bfd_vma) -1);
- print_width = strlen (buf);
- (*format->print_object_filename) (filename);
- display_rel_file (file, NULL);
- }
- else
+ for (; from < fromend; from += size)
{
- bfd_nonfatal (filename);
- if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
+ int keep = 0;
+ asymbol *sym;
+
+ PROGRESS (1);
+
+ sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from, store);
+ if (sym == NULL)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ if (undefined_only)
+ keep = bfd_is_und_section (sym->section);
+ else if (external_only)
+ keep = ((sym->flags & BSF_GLOBAL) != 0
+ || (sym->flags & BSF_WEAK) != 0
+ || bfd_is_und_section (sym->section)
+ || bfd_is_com_section (sym->section));
+ else
+ keep = 1;
+
+ if (keep
+ && ! print_debug_syms
+ && (sym->flags & BSF_DEBUGGING) != 0)
+ keep = 0;
+
+ if (keep
+ && sort_by_size
+ && (bfd_is_abs_section (sym->section)
+ || bfd_is_und_section (sym->section)))
+ keep = 0;
+
+ if (keep
+ && defined_only)
{
- list_matching_formats (matching);
- free (matching);
+ if (bfd_is_und_section (sym->section))
+ keep = 0;
}
- retval = FALSE;
- }
- if (!bfd_close (file))
- bfd_fatal (filename);
+ if (keep
+ && bfd_is_target_special_symbol (abfd, sym)
+ && ! allow_special_symbols)
+ keep = 0;
- lineno_cache_bfd = NULL;
- lineno_cache_rel_bfd = NULL;
+ if (keep)
+ {
+ memcpy (to, from, size);
+ to += size;
+ }
+ }
- return retval;
+ return (to - (bfd_byte *) minisyms) / size;
}
\f
/* These globals are used to pass information into the sorting
specially -- i.e., their sizes are used as their "values". */
static int
-numeric_forward (P_x, P_y)
- const PTR P_x;
- const PTR P_y;
-{
- asymbol *x, *y;
- asection *xs, *ys;
-
- x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
- y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
- if (x == NULL || y == NULL)
- bfd_fatal (bfd_get_filename (sort_bfd));
-
- xs = bfd_get_section (x);
- ys = bfd_get_section (y);
-
- if (bfd_is_und_section (xs))
- {
- if (! bfd_is_und_section (ys))
- return -1;
- }
- else if (bfd_is_und_section (ys))
- return 1;
- else if (valueof (x) != valueof (y))
- return valueof (x) < valueof (y) ? -1 : 1;
-
- return non_numeric_forward (P_x, P_y);
-}
-
-static int
-numeric_reverse (x, y)
- const PTR x;
- const PTR y;
-{
- return - numeric_forward (x, y);
-}
-
-static int
-non_numeric_forward (P_x, P_y)
- const PTR P_x;
- const PTR P_y;
+non_numeric_forward (const void *P_x, const void *P_y)
{
asymbol *x, *y;
const char *xn, *yn;
}
static int
-non_numeric_reverse (x, y)
- const PTR x;
- const PTR y;
+non_numeric_reverse (const void *x, const void *y)
{
return - non_numeric_forward (x, y);
}
-static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
+static int
+numeric_forward (const void *P_x, const void *P_y)
+{
+ asymbol *x, *y;
+ asection *xs, *ys;
+
+ x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);
+ y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);
+ if (x == NULL || y == NULL)
+ bfd_fatal (bfd_get_filename (sort_bfd));
+
+ xs = bfd_get_section (x);
+ ys = bfd_get_section (y);
+
+ if (bfd_is_und_section (xs))
+ {
+ if (! bfd_is_und_section (ys))
+ return -1;
+ }
+ else if (bfd_is_und_section (ys))
+ return 1;
+ else if (valueof (x) != valueof (y))
+ return valueof (x) < valueof (y) ? -1 : 1;
+
+ return non_numeric_forward (P_x, P_y);
+}
+
+static int
+numeric_reverse (const void *x, const void *y)
+{
+ return - numeric_forward (x, y);
+}
+
+static int (*(sorters[2][2])) (const void *, const void *) =
{
{ non_numeric_forward, non_numeric_reverse },
{ numeric_forward, numeric_reverse }
value. */
static int
-size_forward1 (P_x, P_y)
- const PTR P_x;
- const PTR P_y;
+size_forward1 (const void *P_x, const void *P_y)
{
asymbol *x, *y;
asection *xs, *ys;
an array of size_sym structures into size order. */
static int
-size_forward2 (P_x, P_y)
- const PTR P_x;
- const PTR P_y;
+size_forward2 (const void *P_x, const void *P_y)
{
const struct size_sym *x = (const struct size_sym *) P_x;
const struct size_sym *y = (const struct size_sym *) P_y;
size. */
static long
-sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
- bfd *abfd;
- bfd_boolean dynamic;
- PTR minisyms;
- long symcount;
- unsigned int size;
- struct size_sym **symsizesp;
+sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
+ long symcount, unsigned int size,
+ struct size_sym **symsizesp)
{
struct size_sym *symsizes;
bfd_byte *from, *fromend;
/* We are going to return a special set of symbols and sizes to
print. */
- symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
+ symsizes = xmalloc (symcount * sizeof (struct size_sym));
*symsizesp = symsizes;
/* Note that filter_symbols has already removed all absolute and
if (from < fromend)
{
- sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from,
+ sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from,
store_sym);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
{
next = bfd_minisymbol_to_symbol (abfd,
dynamic,
- (const PTR) (from + size),
+ (const void *) (from + size),
store_next);
if (next == NULL)
bfd_fatal (bfd_get_filename (abfd));
if (sz != 0)
{
- symsizes->minisym = (const PTR) from;
+ symsizes->minisym = (const void *) from;
symsizes->size = sz;
++symsizes;
}
symcount = symsizes - *symsizesp;
/* We must now sort again by size. */
- qsort ((PTR) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
+ qsort ((void *) *symsizesp, symcount, sizeof (struct size_sym), size_forward2);
return symcount;
}
-\f
-/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
+
+/* This function is used to get the relocs for a particular section.
+ It is called via bfd_map_over_sections. */
static void
-display_rel_file (abfd, archive_bfd)
- bfd *abfd;
- bfd *archive_bfd;
+get_relocs (bfd *abfd, asection *sec, void *dataarg)
{
- long symcount;
- PTR minisyms;
- unsigned int size;
- struct size_sym *symsizes;
-
- if (! dynamic)
- {
- if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
- {
- non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
- return;
- }
- }
+ struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
- symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
- if (symcount < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ *data->secs = sec;
- if (symcount == 0)
+ if ((sec->flags & SEC_RELOC) == 0)
{
- non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
- return;
+ *data->relocs = NULL;
+ *data->relcount = 0;
}
-
- /* Discard the symbols we don't want to print.
- It's OK to do this in place; we'll free the storage anyway
- (after printing). */
-
- symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
-
- symsizes = NULL;
- if (! no_sort)
+ else
{
- sort_bfd = abfd;
- sort_dynamic = dynamic;
- sort_x = bfd_make_empty_symbol (abfd);
- sort_y = bfd_make_empty_symbol (abfd);
- if (sort_x == NULL || sort_y == NULL)
+ long relsize;
+
+ relsize = bfd_get_reloc_upper_bound (abfd, sec);
+ if (relsize < 0)
bfd_fatal (bfd_get_filename (abfd));
- if (! sort_by_size)
- qsort (minisyms, symcount, size,
- sorters[sort_numerically][reverse_sort]);
- else
- symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
- size, &symsizes);
+ *data->relocs = xmalloc (relsize);
+ *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
+ data->syms);
+ if (*data->relcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
}
- if (! sort_by_size)
- print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
- else
- print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
-
- free (minisyms);
+ ++data->secs;
+ ++data->relocs;
+ ++data->relcount;
}
-\f
-/* Choose which symbol entries to print;
- compact them downward to get rid of the rest.
- Return the number of symbols to be printed. */
-static long
-filter_symbols (abfd, dynamic, minisyms, symcount, size)
- bfd *abfd;
- bfd_boolean dynamic;
- PTR minisyms;
- long symcount;
- unsigned int size;
+/* Print a single symbol. */
+
+static void
+print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
{
- bfd_byte *from, *fromend, *to;
- asymbol *store;
+ symbol_info syminfo;
+ struct extended_symbol_info info;
- store = bfd_make_empty_symbol (abfd);
- if (store == NULL)
- bfd_fatal (bfd_get_filename (abfd));
+ PROGRESS (1);
- from = (bfd_byte *) minisyms;
- fromend = from + symcount * size;
- to = (bfd_byte *) minisyms;
+ format->print_symbol_filename (archive_bfd, abfd);
- for (; from < fromend; from += size)
- {
- int keep = 0;
- asymbol *sym;
+ bfd_get_symbol_info (abfd, sym, &syminfo);
+ info.sinfo = &syminfo;
+ info.ssize = ssize;
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ info.elfinfo = (elf_symbol_type *) sym;
+ else
+ info.elfinfo = NULL;
+ format->print_symbol_info (&info, abfd);
- PROGRESS (1);
+ if (line_numbers)
+ {
+ static asymbol **syms;
+ static long symcount;
+ const char *filename, *functionname;
+ unsigned int lineno;
- sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from, store);
- if (sym == NULL)
- bfd_fatal (bfd_get_filename (abfd));
+ /* We need to get the canonical symbols in order to call
+ bfd_find_nearest_line. This is inefficient, but, then, you
+ don't have to use --line-numbers. */
+ if (abfd != lineno_cache_bfd && syms != NULL)
+ {
+ free (syms);
+ syms = NULL;
+ }
+ if (syms == NULL)
+ {
+ long symsize;
- if (undefined_only)
- keep = bfd_is_und_section (sym->section);
- else if (external_only)
- keep = ((sym->flags & BSF_GLOBAL) != 0
- || (sym->flags & BSF_WEAK) != 0
- || bfd_is_und_section (sym->section)
- || bfd_is_com_section (sym->section));
- else
- keep = 1;
+ symsize = bfd_get_symtab_upper_bound (abfd);
+ if (symsize < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+ syms = xmalloc (symsize);
+ symcount = bfd_canonicalize_symtab (abfd, syms);
+ if (symcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
+ lineno_cache_bfd = abfd;
+ }
- if (keep
- && ! print_debug_syms
- && (sym->flags & BSF_DEBUGGING) != 0)
- keep = 0;
+ if (bfd_is_und_section (bfd_get_section (sym)))
+ {
+ static asection **secs;
+ static arelent ***relocs;
+ static long *relcount;
+ static unsigned int seccount;
+ unsigned int i;
+ const char *symname;
- if (keep
- && sort_by_size
- && (bfd_is_abs_section (sym->section)
- || bfd_is_und_section (sym->section)))
- keep = 0;
+ /* For an undefined symbol, we try to find a reloc for the
+ symbol, and print the line number of the reloc. */
+ if (abfd != lineno_cache_rel_bfd && relocs != NULL)
+ {
+ for (i = 0; i < seccount; i++)
+ if (relocs[i] != NULL)
+ free (relocs[i]);
+ free (secs);
+ free (relocs);
+ free (relcount);
+ secs = NULL;
+ relocs = NULL;
+ relcount = NULL;
+ }
- if (keep
- && defined_only)
- {
- if (bfd_is_und_section (sym->section))
- keep = 0;
- }
+ if (relocs == NULL)
+ {
+ struct get_relocs_info info;
- if (keep)
+ seccount = bfd_count_sections (abfd);
+
+ secs = xmalloc (seccount * sizeof *secs);
+ relocs = xmalloc (seccount * sizeof *relocs);
+ relcount = xmalloc (seccount * sizeof *relcount);
+
+ info.secs = secs;
+ info.relocs = relocs;
+ info.relcount = relcount;
+ info.syms = syms;
+ bfd_map_over_sections (abfd, get_relocs, (void *) &info);
+ lineno_cache_rel_bfd = abfd;
+ }
+
+ symname = bfd_asymbol_name (sym);
+ for (i = 0; i < seccount; i++)
+ {
+ long j;
+
+ for (j = 0; j < relcount[i]; j++)
+ {
+ arelent *r;
+
+ r = relocs[i][j];
+ if (r->sym_ptr_ptr != NULL
+ && (*r->sym_ptr_ptr)->section == sym->section
+ && (*r->sym_ptr_ptr)->value == sym->value
+ && strcmp (symname,
+ bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
+ && bfd_find_nearest_line (abfd, secs[i], syms,
+ r->address, &filename,
+ &functionname, &lineno)
+ && filename != NULL)
+ {
+ /* We only print the first one we find. */
+ printf ("\t%s:%u", filename, lineno);
+ i = seccount;
+ break;
+ }
+ }
+ }
+ }
+ else if (bfd_get_section (sym)->owner == abfd)
{
- memcpy (to, from, size);
- to += size;
+ if (bfd_find_nearest_line (abfd, bfd_get_section (sym), syms,
+ sym->value, &filename, &functionname,
+ &lineno)
+ && filename != NULL
+ && lineno != 0)
+ printf ("\t%s:%u", filename, lineno);
}
}
- return (to - (bfd_byte *) minisyms) / size;
+ putchar ('\n');
}
\f
-/* Print symbol name NAME, read from ABFD, with printf format FORMAT,
- demangling it if requested. */
+/* Print the symbols when sorting by size. */
static void
-print_symname (format, name, abfd)
- const char *format;
- const char *name;
- bfd *abfd;
+print_size_symbols (bfd *abfd, bfd_boolean dynamic,
+ struct size_sym *symsizes, long symcount,
+ bfd *archive_bfd)
{
- if (do_demangle && *name)
+ asymbol *store;
+ struct size_sym *from, *fromend;
+
+ store = bfd_make_empty_symbol (abfd);
+ if (store == NULL)
+ bfd_fatal (bfd_get_filename (abfd));
+
+ from = symsizes;
+ fromend = from + symcount;
+ for (; from < fromend; from++)
{
- char *res = demangle (abfd, name);
+ asymbol *sym;
+ bfd_vma ssize;
- printf (format, res);
- free (res);
- return;
- }
+ sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
+ if (sym == NULL)
+ bfd_fatal (bfd_get_filename (abfd));
- printf (format, name);
+ /* For elf we have already computed the correct symbol size. */
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ ssize = from->size;
+ else
+ ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
+
+ print_symbol (abfd, sym, ssize, archive_bfd);
+ }
}
+\f
/* Print the symbols. If ARCHIVE_BFD is non-NULL, it is the archive
containing ABFD. */
static void
-print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd)
- bfd *abfd;
- bfd_boolean dynamic;
- PTR minisyms;
- long symcount;
- unsigned int size;
- bfd *archive_bfd;
+print_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms, long symcount,
+ unsigned int size, bfd *archive_bfd)
{
asymbol *store;
bfd_byte *from, *fromend;
}
}
-/* Print the symbols when sorting by size. */
+/* If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD. */
static void
-print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd)
- bfd *abfd;
- bfd_boolean dynamic;
- struct size_sym *symsizes;
- long symcount;
- bfd *archive_bfd;
+display_rel_file (bfd *abfd, bfd *archive_bfd)
{
- asymbol *store;
- struct size_sym *from, *fromend;
+ long symcount;
+ void *minisyms;
+ unsigned int size;
+ struct size_sym *symsizes;
- store = bfd_make_empty_symbol (abfd);
- if (store == NULL)
+ if (! dynamic)
+ {
+ if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
+ {
+ non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
+ return;
+ }
+ }
+
+ symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
+ if (symcount < 0)
bfd_fatal (bfd_get_filename (abfd));
- from = symsizes;
- fromend = from + symcount;
- for (; from < fromend; from++)
+ if (symcount == 0)
{
- asymbol *sym;
- bfd_vma ssize;
+ non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
+ return;
+ }
- sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
- if (sym == NULL)
+ if (show_synthetic && size == sizeof (asymbol *))
+ {
+ asymbol *synthsyms;
+ long synth_count;
+ asymbol **static_syms = NULL;
+ asymbol **dyn_syms = NULL;
+ long static_count = 0;
+ long dyn_count = 0;
+
+ if (dynamic)
+ {
+ dyn_count = symcount;
+ dyn_syms = minisyms;
+ }
+ else
+ {
+ static_count = symcount;
+ static_syms = minisyms;
+ }
+ synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
+ dyn_count, dyn_syms, &synthsyms);
+ if (synth_count > 0)
+ {
+ asymbol **symp;
+ void *new_mini;
+ long i;
+
+ new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
+ symp = new_mini;
+ memcpy (symp, minisyms, symcount * sizeof (*symp));
+ symp += symcount;
+ for (i = 0; i < synth_count; i++)
+ *symp++ = synthsyms + i;
+ *symp = 0;
+ minisyms = new_mini;
+ symcount += synth_count;
+ }
+ }
+
+ /* Discard the symbols we don't want to print.
+ It's OK to do this in place; we'll free the storage anyway
+ (after printing). */
+
+ symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
+
+ symsizes = NULL;
+ if (! no_sort)
+ {
+ sort_bfd = abfd;
+ sort_dynamic = dynamic;
+ sort_x = bfd_make_empty_symbol (abfd);
+ sort_y = bfd_make_empty_symbol (abfd);
+ if (sort_x == NULL || sort_y == NULL)
bfd_fatal (bfd_get_filename (abfd));
- /* For elf we have already computed the correct symbol size. */
- if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
- ssize = from->size;
+ if (! sort_by_size)
+ qsort (minisyms, symcount, size,
+ sorters[sort_numerically][reverse_sort]);
else
- ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
-
- print_symbol (abfd, sym, ssize, archive_bfd);
+ symcount = sort_symbols_by_size (abfd, dynamic, minisyms, symcount,
+ size, &symsizes);
}
-}
-/* Print a single symbol. */
+ if (! sort_by_size)
+ print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
+ else
+ print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
+
+ free (minisyms);
+}
static void
-print_symbol (abfd, sym, ssize, archive_bfd)
- bfd *abfd;
- asymbol *sym;
- bfd_vma ssize;
- bfd *archive_bfd;
+display_archive (bfd *file)
{
- symbol_info syminfo;
- struct extended_symbol_info info;
-
- PROGRESS (1);
+ bfd *arfile = NULL;
+ bfd *last_arfile = NULL;
+ char **matching;
- (*format->print_symbol_filename) (archive_bfd, abfd);
+ format->print_archive_filename (bfd_get_filename (file));
- bfd_get_symbol_info (abfd, sym, &syminfo);
- info.sinfo = &syminfo;
- info.ssize = ssize;
- if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
- info.elfinfo = (elf_symbol_type *) sym;
- else
- info.elfinfo = NULL;
- (*format->print_symbol_info) (&info, abfd);
+ if (print_armap)
+ print_symdef_entry (file);
- if (line_numbers)
+ for (;;)
{
- static asymbol **syms;
- static long symcount;
- const char *filename, *functionname;
- unsigned int lineno;
+ PROGRESS (1);
- /* We need to get the canonical symbols in order to call
- bfd_find_nearest_line. This is inefficient, but, then, you
- don't have to use --line-numbers. */
- if (abfd != lineno_cache_bfd && syms != NULL)
+ arfile = bfd_openr_next_archived_file (file, arfile);
+
+ if (arfile == NULL)
{
- free (syms);
- syms = NULL;
+ if (bfd_get_error () != bfd_error_no_more_archived_files)
+ bfd_fatal (bfd_get_filename (file));
+ break;
}
- if (syms == NULL)
+
+ if (bfd_check_format_matches (arfile, bfd_object, &matching))
{
- long symsize;
+ char buf[30];
- symsize = bfd_get_symtab_upper_bound (abfd);
- if (symsize < 0)
- bfd_fatal (bfd_get_filename (abfd));
- syms = (asymbol **) xmalloc (symsize);
- symcount = bfd_canonicalize_symtab (abfd, syms);
- if (symcount < 0)
- bfd_fatal (bfd_get_filename (abfd));
- lineno_cache_bfd = abfd;
+ bfd_sprintf_vma (arfile, buf, (bfd_vma) -1);
+ print_width = strlen (buf);
+ format->print_archive_member (bfd_get_filename (file),
+ bfd_get_filename (arfile));
+ display_rel_file (arfile, file);
}
-
- if (bfd_is_und_section (bfd_get_section (sym)))
+ else
{
- static asection **secs;
- static arelent ***relocs;
- static long *relcount;
- static unsigned int seccount;
- unsigned int i;
- const char *symname;
-
- /* For an undefined symbol, we try to find a reloc for the
- symbol, and print the line number of the reloc. */
- if (abfd != lineno_cache_rel_bfd && relocs != NULL)
+ bfd_nonfatal (bfd_get_filename (arfile));
+ if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
{
- for (i = 0; i < seccount; i++)
- if (relocs[i] != NULL)
- free (relocs[i]);
- free (secs);
- free (relocs);
- free (relcount);
- secs = NULL;
- relocs = NULL;
- relcount = NULL;
+ list_matching_formats (matching);
+ free (matching);
}
+ }
- if (relocs == NULL)
- {
- struct get_relocs_info info;
-
- seccount = bfd_count_sections (abfd);
+ if (last_arfile != NULL)
+ {
+ bfd_close (last_arfile);
+ lineno_cache_bfd = NULL;
+ lineno_cache_rel_bfd = NULL;
+ }
+ last_arfile = arfile;
+ }
- secs = (asection **) xmalloc (seccount * sizeof *secs);
- relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
- relcount = (long *) xmalloc (seccount * sizeof *relcount);
+ if (last_arfile != NULL)
+ {
+ bfd_close (last_arfile);
+ lineno_cache_bfd = NULL;
+ lineno_cache_rel_bfd = NULL;
+ }
+}
- info.secs = secs;
- info.relocs = relocs;
- info.relcount = relcount;
- info.syms = syms;
- bfd_map_over_sections (abfd, get_relocs, (PTR) &info);
- lineno_cache_rel_bfd = abfd;
- }
+static bfd_boolean
+display_file (char *filename)
+{
+ bfd_boolean retval = TRUE;
+ bfd *file;
+ char **matching;
- symname = bfd_asymbol_name (sym);
- for (i = 0; i < seccount; i++)
- {
- long j;
+ if (get_file_size (filename) < 1)
+ return FALSE;
- for (j = 0; j < relcount[i]; j++)
- {
- arelent *r;
+ file = bfd_openr (filename, target);
+ if (file == NULL)
+ {
+ bfd_nonfatal (filename);
+ return FALSE;
+ }
- r = relocs[i][j];
- if (r->sym_ptr_ptr != NULL
- && (*r->sym_ptr_ptr)->section == sym->section
- && (*r->sym_ptr_ptr)->value == sym->value
- && strcmp (symname,
- bfd_asymbol_name (*r->sym_ptr_ptr)) == 0
- && bfd_find_nearest_line (abfd, secs[i], syms,
- r->address, &filename,
- &functionname, &lineno)
- && filename != NULL)
- {
- /* We only print the first one we find. */
- printf ("\t%s:%u", filename, lineno);
- i = seccount;
- break;
- }
- }
- }
- }
- else if (bfd_get_section (sym)->owner == abfd)
+ if (bfd_check_format (file, bfd_archive))
+ {
+ display_archive (file);
+ }
+ else if (bfd_check_format_matches (file, bfd_object, &matching))
+ {
+ char buf[30];
+
+ bfd_sprintf_vma (file, buf, (bfd_vma) -1);
+ print_width = strlen (buf);
+ format->print_object_filename (filename);
+ display_rel_file (file, NULL);
+ }
+ else
+ {
+ bfd_nonfatal (filename);
+ if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
{
- if (bfd_find_nearest_line (abfd, bfd_get_section (sym), syms,
- sym->value, &filename, &functionname,
- &lineno)
- && filename != NULL
- && lineno != 0)
- {
- printf ("\t%s:%u", filename, lineno);
- }
+ list_matching_formats (matching);
+ free (matching);
}
+ retval = FALSE;
}
- putchar ('\n');
+ if (!bfd_close (file))
+ bfd_fatal (filename);
+
+ lineno_cache_bfd = NULL;
+ lineno_cache_rel_bfd = NULL;
+
+ return retval;
}
\f
/* The following 3 groups of functions are called unconditionally,
/* Print the name of an object file given on the command line. */
static void
-print_object_filename_bsd (filename)
- char *filename;
+print_object_filename_bsd (char *filename)
{
if (filename_per_file && !filename_per_symbol)
printf ("\n%s:\n", filename);
}
static void
-print_object_filename_sysv (filename)
- char *filename;
+print_object_filename_sysv (char *filename)
{
if (undefined_only)
printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
}
static void
-print_object_filename_posix (filename)
- char *filename;
+print_object_filename_posix (char *filename)
{
if (filename_per_file && !filename_per_symbol)
printf ("%s:\n", filename);
/* Print the name of an archive file given on the command line. */
static void
-print_archive_filename_bsd (filename)
- char *filename;
+print_archive_filename_bsd (char *filename)
{
if (filename_per_file)
printf ("\n%s:\n", filename);
}
static void
-print_archive_filename_sysv (filename)
- char *filename ATTRIBUTE_UNUSED;
+print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
{
}
static void
-print_archive_filename_posix (filename)
- char *filename ATTRIBUTE_UNUSED;
+print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
{
}
\f
/* Print the name of an archive member file. */
static void
-print_archive_member_bsd (archive, filename)
- char *archive ATTRIBUTE_UNUSED;
- const char *filename;
+print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
+ const char *filename)
{
if (!filename_per_symbol)
printf ("\n%s:\n", filename);
}
static void
-print_archive_member_sysv (archive, filename)
- char *archive;
- const char *filename;
+print_archive_member_sysv (char *archive, const char *filename)
{
if (undefined_only)
printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
}
static void
-print_archive_member_posix (archive, filename)
- char *archive;
- const char *filename;
+print_archive_member_posix (char *archive, const char *filename)
{
if (!filename_per_symbol)
printf ("%s[%s]:\n", archive, filename);
containing a symbol. */
static void
-print_symbol_filename_bsd (archive_bfd, abfd)
- bfd *archive_bfd, *abfd;
+print_symbol_filename_bsd (bfd *archive_bfd, bfd *abfd)
{
if (filename_per_symbol)
{
}
static void
-print_symbol_filename_sysv (archive_bfd, abfd)
- bfd *archive_bfd, *abfd;
+print_symbol_filename_sysv (bfd *archive_bfd, bfd *abfd)
{
if (filename_per_symbol)
{
}
static void
-print_symbol_filename_posix (archive_bfd, abfd)
- bfd *archive_bfd, *abfd;
+print_symbol_filename_posix (bfd *archive_bfd, bfd *abfd)
{
if (filename_per_symbol)
{
/* Print a symbol value. */
static void
-print_value (abfd, val)
- bfd *abfd ATTRIBUTE_UNUSED;
- bfd_vma val;
+print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
{
#if ! defined (BFD64) || BFD_HOST_64BIT_LONG
printf (value_format, val);
/* Print a line of information about a symbol. */
static void
-print_symbol_info_bsd (info, abfd)
- struct extended_symbol_info *info;
- bfd *abfd;
+print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
{
if (bfd_is_undefined_symclass (SYM_TYPE (info)))
{
else
{
/* Normally we print the value of the symbol. If we are printing the
- size or sorting by size then we print its size, execpt for the
+ size or sorting by size then we print its size, except for the
(weird) special case where both flags are defined, in which case we
print both values. This conforms to documented behaviour. */
if (sort_by_size && !print_size)
}
static void
-print_symbol_info_sysv (info, abfd)
- struct extended_symbol_info *info;
- bfd *abfd;
+print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
{
print_symname ("%-20s|", SYM_NAME (info), abfd);
}
static void
-print_symbol_info_posix (info, abfd)
- struct extended_symbol_info *info;
- bfd *abfd;
+print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
{
print_symname ("%s ", SYM_NAME (info), abfd);
printf ("%c ", SYM_TYPE (info));
}
}
\f
-static void
-print_symdef_entry (abfd)
- bfd *abfd;
+int
+main (int argc, char **argv)
{
- symindex idx = BFD_NO_MORE_SYMBOLS;
- carsym *thesym;
- bfd_boolean everprinted = FALSE;
+ int c;
+ int retval;
- for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
- idx != BFD_NO_MORE_SYMBOLS;
- idx = bfd_get_next_mapent (abfd, idx, &thesym))
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+ setlocale (LC_MESSAGES, "");
+#endif
+#if defined (HAVE_SETLOCALE)
+ setlocale (LC_CTYPE, "");
+ setlocale (LC_COLLATE, "");
+#endif
+ bindtextdomain (PACKAGE, LOCALEDIR);
+ textdomain (PACKAGE);
+
+ program_name = *argv;
+ xmalloc_set_program_name (program_name);
+
+ START_PROGRESS (program_name, 0);
+
+ bfd_init ();
+ set_default_bfd_target ();
+
+ while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
+ long_options, (int *) 0)) != EOF)
{
- bfd *elt;
- if (!everprinted)
- {
- printf (_("\nArchive index:\n"));
- everprinted = TRUE;
- }
- elt = bfd_get_elt_at_index (abfd, idx);
- if (elt == NULL)
- bfd_fatal ("bfd_get_elt_at_index");
- if (thesym->name != (char *) NULL)
+ switch (c)
{
- print_symname ("%s", thesym->name, abfd);
- printf (" in %s\n", bfd_get_filename (elt));
+ case 'a':
+ print_debug_syms = 1;
+ break;
+ case 'A':
+ case 'o':
+ filename_per_symbol = 1;
+ break;
+ case 'B': /* For MIPS compatibility. */
+ set_output_format ("bsd");
+ break;
+ case 'C':
+ do_demangle = 1;
+ if (optarg != NULL)
+ {
+ enum demangling_styles style;
+
+ style = cplus_demangle_name_to_style (optarg);
+ if (style == unknown_demangling)
+ fatal (_("unknown demangling style `%s'"),
+ optarg);
+
+ cplus_demangle_set_style (style);
+ }
+ break;
+ case 'D':
+ dynamic = 1;
+ break;
+ case 'e':
+ /* Ignored for HP/UX compatibility. */
+ break;
+ case 'f':
+ set_output_format (optarg);
+ break;
+ case 'g':
+ external_only = 1;
+ break;
+ case 'H':
+ case 'h':
+ usage (stdout, 0);
+ case 'l':
+ line_numbers = 1;
+ break;
+ case 'n':
+ case 'v':
+ sort_numerically = 1;
+ break;
+ case 'p':
+ no_sort = 1;
+ break;
+ case 'P':
+ set_output_format ("posix");
+ break;
+ case 'r':
+ reverse_sort = 1;
+ break;
+ case 's':
+ print_armap = 1;
+ break;
+ case 'S':
+ print_size = 1;
+ break;
+ case 't':
+ set_print_radix (optarg);
+ break;
+ case 'u':
+ undefined_only = 1;
+ break;
+ case 'V':
+ show_version = 1;
+ break;
+ case 'X':
+ /* Ignored for (partial) AIX compatibility. On AIX, the
+ argument has values 32, 64, or 32_64, and specifies that
+ only 32-bit, only 64-bit, or both kinds of objects should
+ be examined. The default is 32. So plain AIX nm on a
+ library archive with both kinds of objects will ignore
+ the 64-bit ones. For GNU nm, the default is and always
+ has been -X 32_64, and other options are not supported. */
+ if (strcmp (optarg, "32_64") != 0)
+ fatal (_("Only -X 32_64 is supported"));
+ break;
+
+ case OPTION_TARGET: /* --target */
+ target = optarg;
+ break;
+
+ case 0: /* A long option that just sets a flag. */
+ break;
+
+ default:
+ usage (stderr, 1);
}
}
-}
-\f
-/* This function is used to get the relocs for a particular section.
- It is called via bfd_map_over_sections. */
-
-static void
-get_relocs (abfd, sec, dataarg)
- bfd *abfd;
- asection *sec;
- PTR dataarg;
-{
- struct get_relocs_info *data = (struct get_relocs_info *) dataarg;
- *data->secs = sec;
+ if (show_version)
+ print_version ("nm");
- if ((sec->flags & SEC_RELOC) == 0)
+ if (sort_by_size && undefined_only)
{
- *data->relocs = NULL;
- *data->relcount = 0;
+ non_fatal (_("Using the --size-sort and --undefined-only options together"));
+ non_fatal (_("will produce no output, since undefined symbols have no size."));
+ return 0;
}
- else
+
+ /* OK, all options now parsed. If no filename specified, do a.out. */
+ if (optind == argc)
+ return !display_file ("a.out");
+
+ retval = 0;
+
+ if (argc - optind > 1)
+ filename_per_file = 1;
+
+ /* We were given several filenames to do. */
+ while (optind < argc)
{
- long relsize;
+ PROGRESS (1);
+ if (!display_file (argv[optind++]))
+ retval++;
+ }
- relsize = bfd_get_reloc_upper_bound (abfd, sec);
- if (relsize < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ END_PROGRESS (program_name);
- *data->relocs = (arelent **) xmalloc (relsize);
- *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
- data->syms);
- if (*data->relcount < 0)
- bfd_fatal (bfd_get_filename (abfd));
+#ifdef HAVE_SBRK
+ if (show_stats)
+ {
+ char *lim = (char *) sbrk (0);
+
+ non_fatal (_("data size %ld"), (long) (lim - (char *) &environ));
}
+#endif
- ++data->secs;
- ++data->relocs;
- ++data->relcount;
+ exit (retval);
+ return retval;
}