]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blobdiff - binutils/nm.c
top level:
[thirdparty/binutils-gdb.git] / binutils / nm.c
index e9476976ffcd40439c186a8376fd35b77df93c12..e3ab36f04d7dafcd632ad4113c04772bd2a80b70 100644 (file)
@@ -1,5 +1,6 @@
 /* nm.c -- Describe symbol table of a rel file.
-   Copyright 1991, 92, 93, 94, 95, 96, 97, 98, 1999
+   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+   2001, 2002, 2003, 2004, 2005, 2007
    Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 #include "bfd.h"
 #include "progress.h"
 #include "bucomm.h"
+#include "budemang.h"
 #include "getopt.h"
 #include "aout/stab_gnu.h"
 #include "aout/ranlib.h"
 #include "demangle.h"
 #include "libiberty.h"
+#include "elf-bfd.h"
+#include "elf/common.h"
 
 /* When sorting by size, we use this structure to hold the size and a
    pointer to the minisymbol.  */
 
 struct size_sym
 {
-  const PTR minisym;
+  const void *minisym;
   bfd_vma size;
 };
 
@@ -48,142 +52,60 @@ struct get_relocs_info
   asymbol **syms;
 };
 
-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 boolean
-display_file PARAMS ((char *filename));
-
-static void
-display_rel_file PARAMS ((bfd * file, bfd * archive));
-
-static long
-filter_symbols PARAMS ((bfd *, boolean, PTR, long, unsigned int));
-
-static long
-sort_symbols_by_size PARAMS ((bfd *, boolean, PTR, long, unsigned int,
-                             struct size_sym **));
-
-static void
-print_symbols PARAMS ((bfd *, boolean, PTR, long, unsigned int, bfd *));
-
-static void
-print_size_symbols PARAMS ((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 *));
-
-static void
-print_symdef_entry PARAMS ((bfd * abfd));
-
-/* 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));
+struct extended_symbol_info
+{
+  symbol_info *sinfo;
+  bfd_vma ssize;
+  elf_symbol_type *elfinfo;
+  /* FIXME: We should add more fields for Type, Line, Section.  */
+};
+#define SYM_NAME(sym)        (sym->sinfo->name)
+#define SYM_VALUE(sym)       (sym->sinfo->value)
+#define SYM_TYPE(sym)        (sym->sinfo->type)
+#define SYM_STAB_NAME(sym)   (sym->sinfo->stab_name)
+#define SYM_STAB_DESC(sym)   (sym->sinfo->stab_desc)
+#define SYM_STAB_OTHER(sym)  (sym->sinfo->stab_other)
+#define SYM_SIZE(sym) \
+  (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
 
 /* The output formatting functions.  */
-
-static void
-print_object_filename_bsd PARAMS ((char *filename));
-
-static void
-print_object_filename_sysv PARAMS ((char *filename));
-
-static void
-print_object_filename_posix PARAMS ((char *filename));
-
-
-static void
-print_archive_filename_bsd PARAMS ((char *filename));
-
-static void
-print_archive_filename_sysv PARAMS ((char *filename));
-
-static void
-print_archive_filename_posix PARAMS ((char *filename));
-
-
-static void
-print_archive_member_bsd PARAMS ((char *archive, CONST char *filename));
-
-static void
-print_archive_member_sysv PARAMS ((char *archive, CONST char *filename));
-
-static void
-print_archive_member_posix PARAMS ((char *archive, CONST char *filename));
-
-
-static void
-print_symbol_filename_bsd PARAMS ((bfd * archive_bfd, bfd * abfd));
-
-static void
-print_symbol_filename_sysv PARAMS ((bfd * archive_bfd, bfd * abfd));
-
-static void
-print_symbol_filename_posix PARAMS ((bfd * archive_bfd, bfd * abfd));
-
-
-static void
-print_value PARAMS ((bfd_vma));
-
-static void
-print_symbol_info_bsd PARAMS ((symbol_info * info, bfd * abfd));
-
-static void
-print_symbol_info_sysv PARAMS ((symbol_info * info, bfd * abfd));
-
-static void
-print_symbol_info_posix PARAMS ((symbol_info * info, bfd * abfd));
-
-static void
-get_relocs PARAMS ((bfd *, asection *, PTR));
+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 *filename));
+    void (*print_object_filename) (char *);
 
     /* Print the name of an archive file given on the command line.  */
-    void (*print_archive_filename) PARAMS ((char *filename));
+    void (*print_archive_filename) (char *);
 
     /* Print the name of an archive member file.  */
-    void (*print_archive_member) PARAMS ((char *archive, CONST char *filename));
+    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 * archive_bfd, bfd * abfd));
+    void (*print_symbol_filename) (bfd *, bfd *);
 
     /* Print a line of information about a symbol.  */
-    void (*print_symbol_info) PARAMS ((symbol_info * info, bfd * abfd));
+    void (*print_symbol_info) (struct extended_symbol_info *, bfd *);
   };
+
 static struct output_fns formats[] =
 {
   {print_object_filename_bsd,
@@ -212,23 +134,25 @@ static struct output_fns formats[] =
 /* The output format to use.  */
 static struct output_fns *format = &formats[FORMAT_DEFAULT];
 
-
 /* Command options.  */
 
 static int do_demangle = 0;    /* Pretty print C++ symbol names.  */
-static int external_only = 0;  /* print external symbols only */
-static int defined_only = 0;   /* Print defined symbols only */
-static int no_sort = 0;                /* don't sort; print syms in order found */
-static int print_debug_syms = 0;       /* print debugger-only symbols too */
-static int print_armap = 0;    /* describe __.SYMDEF data in archive files.  */
-static int reverse_sort = 0;   /* sort in downward(alpha or numeric) order */
-static int sort_numerically = 0;       /* sort in numeric rather than alpha order */
-static int sort_by_size = 0;   /* sort by size of symbol */
-static int undefined_only = 0; /* print undefined symbols only */
-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 line_numbers = 0;   /* print line numbers for symbols */
+static int external_only = 0;  /* Print external symbols only.  */
+static int defined_only = 0;   /* Print defined symbols only.  */
+static int no_sort = 0;                /* Don't sort; print syms in order found.  */
+static int print_debug_syms = 0;/* Print debugger-only symbols too.  */
+static int print_armap = 0;    /* Describe __.SYMDEF data in archive files.  */
+static int print_size = 0;     /* Print size of defined symbols.  */
+static int reverse_sort = 0;   /* Sort in downward(alpha or numeric) order.  */
+static int sort_numerically = 0;/* Sort in numeric rather than alpha order.  */
+static int sort_by_size = 0;   /* Sort by size of symbol.  */
+static int undefined_only = 0; /* Print undefined symbols only.  */
+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.  */
@@ -244,6 +168,11 @@ static char value_format[] = "%016lx";
 /* We don't use value_format for this case.  */
 #endif
 #endif
+#ifdef BFD64
+static int print_width = 16;
+#else
+static int print_width = 8;
+#endif
 static int print_radix = 16;
 /* Print formats for printing stab info.  */
 static char other_format[] = "%02x";
@@ -260,7 +189,7 @@ static bfd *lineno_cache_rel_bfd;
 static struct option long_options[] =
 {
   {"debug-syms", no_argument, &print_debug_syms, 1},
-  {"demangle", no_argument, &do_demangle, 1},
+  {"demangle", optional_argument, 0, 'C'},
   {"dynamic", no_argument, &dynamic, 1},
   {"extern-only", no_argument, &external_only, 1},
   {"format", required_argument, 0, 'f'},
@@ -273,10 +202,13 @@ static struct option long_options[] =
   {"portability", no_argument, 0, 'P'},
   {"print-armap", no_argument, &print_armap, 1},
   {"print-file-name", no_argument, 0, 'o'},
+  {"print-size", no_argument, 0, 'S'},
   {"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},
@@ -284,34 +216,58 @@ static struct option long_options[] =
   {0, no_argument, 0, 0}
 };
 \f
-/* Some error-reporting functions */
+/* Some error-reporting functions */
 
 static void
-usage (stream, status)
-     FILE *stream;
-     int status;
+usage (FILE *stream, int status)
 {
-  fprintf (stream, _("\
-Usage: %s [-aABCDglnopPrsuvV] [-t radix] [--radix=radix] [--target=bfdname]\n\
-       [--debug-syms] [--extern-only] [--print-armap] [--print-file-name]\n\
-       [--numeric-sort] [--no-sort] [--reverse-sort] [--size-sort]\n\
-       [--undefined-only] [--portability] [-f {bsd,sysv,posix}]\n\
-       [--format={bsd,sysv,posix}] [--demangle] [--no-demangle] [--dynamic]\n\
-       [--defined-only] [--line-numbers]\n\
-       [--version] [--help]\n\
-       [file...]\n"),
-          program_name);
+  fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
+  fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));
+  fprintf (stream, _(" The options are:\n\
+  -a, --debug-syms       Display debugger-only symbols\n\
+  -A, --print-file-name  Print name of the input file before every symbol\n\
+  -B                     Same as --format=bsd\n\
+  -C, --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
+                          The STYLE, if specified, can be `auto' (the default),\n\
+                          `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
+                          or `gnat'\n\
+      --no-demangle      Do not demangle low-level symbol names\n\
+  -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
+      --defined-only     Display only defined symbols\n\
+  -e                     (ignored)\n\
+  -f, --format=FORMAT    Use the output format FORMAT.  FORMAT can be `bsd',\n\
+                           `sysv' or `posix'.  The default is `bsd'\n\
+  -g, --extern-only      Display only external symbols\n\
+  -l, --line-numbers     Use debugging information to find a filename and\n\
+                           line number for each symbol\n\
+  -n, --numeric-sort     Sort symbols numerically by address\n\
+  -o                     Same as -A\n\
+  -p, --no-sort          Do not sort the symbols\n\
+  -P, --portability      Same as --format=posix\n\
+  -r, --reverse-sort     Reverse the sense of the sort\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\
+  -X 32_64               (ignored)\n\
+  @FILE                  Read options from FILE\n\
+  -h, --help             Display this information\n\
+  -V, --version          Display this program's version number\n\
+\n"));
   list_supported_targets (program_name, stream);
-  if (status == 0)
-    fprintf (stream, REPORT_BUGS_TO);
+  if (REPORT_BUGS_TO[0] && status == 0)
+    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
   exit (status);
 }
 
 /* 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)
     {
@@ -336,14 +292,12 @@ set_print_radix (radix)
       other_format[3] = desc_format[3] = *radix;
       break;
     default:
-      fprintf (stderr, _("%s: %s: invalid radix\n"), program_name, radix);
-      exit (1);
+      fatal (_("%s: invalid radix"), radix);
     }
 }
 
 static void
-set_output_format (f)
-     char *f;
+set_output_format (char *f)
 {
   int i;
 
@@ -362,249 +316,159 @@ set_output_format (f)
       i = FORMAT_SYSV;
       break;
     default:
-      fprintf (stderr, _("%s: %s: invalid output format\n"), program_name, f);
-      exit (1);
+      fatal (_("%s: invalid output format"), f);
     }
   format = &formats[i];
 }
 \f
-int
-main (argc, argv)
-     int argc;
-     char **argv;
+static const char *
+get_symbol_type (unsigned int type)
 {
-  int c;
-  int retval;
-
-#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
-  setlocale (LC_MESSAGES, "");
-#endif
-  bindtextdomain (PACKAGE, LOCALEDIR);
-  textdomain (PACKAGE);
-
-  program_name = *argv;
-  xmalloc_set_program_name (program_name);
-
-  START_PROGRESS (program_name, 0);
+  static char buff [32];
 
-  bfd_init ();
-  set_default_bfd_target ();
-
-  while ((c = getopt_long (argc, argv, "aABCDef:glnopPrst:uvV", long_options, (int *) 0)) != EOF)
+  switch (type)
     {
-      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;
-         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':
-         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 't':
-         set_print_radix (optarg);
-         break;
-       case 'u':
-         undefined_only = 1;
-         break;
-       case 'V':
-         show_version = 1;
-         break;
-
-       case OPTION_TARGET:     /* --target */
-         target = optarg;
-         break;
-
-       case 0:         /* A long option that just sets a flag.  */
-         break;
-
-       default:
-         usage (stderr, 1);
-       }
+    case STT_NOTYPE:   return "NOTYPE";
+    case STT_OBJECT:   return "OBJECT";
+    case STT_FUNC:     return "FUNC";
+    case STT_SECTION:  return "SECTION";
+    case STT_FILE:     return "FILE";
+    case STT_COMMON:   return "COMMON";
+    case STT_TLS:      return "TLS";
+    default:
+      if (type >= STT_LOPROC && type <= STT_HIPROC)
+       sprintf (buff, _("<processor specific>: %d"), type);
+      else if (type >= STT_LOOS && type <= STT_HIOS)
+       sprintf (buff, _("<OS specific>: %d"), type);
+      else
+       sprintf (buff, _("<unknown>: %d"), type);
+      return buff;
     }
+}
+\f
+/* Print symbol name NAME, read from ABFD, with printf format FORMAT,
+   demangling it if requested.  */
 
-  if (show_version)
-    print_version ("nm");
-
-  /* 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)
+static void
+print_symname (const char *format, const char *name, bfd *abfd)
+{
+  if (do_demangle && *name)
     {
-      PROGRESS (1);
-      if (!display_file (argv[optind++]))
-       retval++;
+      char *res = demangle (abfd, name);
+
+      printf (format, res);
+      free (res);
+      return;
     }
 
-  END_PROGRESS (program_name);
+  printf (format, name);
+}
 
-#ifdef HAVE_SBRK
-  if (show_stats)
-    {
-      char *lim = (char *) sbrk (0);
+static void
+print_symdef_entry (bfd *abfd)
+{
+  symindex idx = BFD_NO_MORE_SYMBOLS;
+  carsym *thesym;
+  bfd_boolean everprinted = FALSE;
 
-      fprintf (stderr, _("%s: data size %ld\n"), program_name,
-              (long) (lim - (char *) &environ));
+  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)
+       {
+         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)
+       {
+         print_symname ("%s", thesym->name, abfd);
+         printf (" in %s\n", bfd_get_filename (elt));
+       }
     }
-#endif
-
-  exit (retval);
-  return retval;
 }
 \f
-static void
-display_archive (file)
-     bfd *file;
+/* 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 (bfd *abfd, bfd_boolean dynamic, void *minisyms,
+               long symcount, unsigned int size)
 {
-  bfd *arfile = NULL;
-  bfd *last_arfile = NULL;
-  char **matching;
+  bfd_byte *from, *fromend, *to;
+  asymbol *store;
 
-  (*format->print_archive_filename) (bfd_get_filename (file));
+  store = bfd_make_empty_symbol (abfd);
+  if (store == NULL)
+    bfd_fatal (bfd_get_filename (abfd));
 
-  if (print_armap)
-    print_symdef_entry (file);
+  from = (bfd_byte *) minisyms;
+  fromend = from + symcount * size;
+  to = (bfd_byte *) minisyms;
 
-  for (;;)
+  for (; from < fromend; from += size)
     {
+      int keep = 0;
+      asymbol *sym;
+
       PROGRESS (1);
 
-      arfile = bfd_openr_next_archived_file (file, arfile);
+      sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from, store);
+      if (sym == NULL)
+       bfd_fatal (bfd_get_filename (abfd));
 
-      if (arfile == NULL)
-       {
-         if (bfd_get_error () != bfd_error_no_more_archived_files)
-           bfd_fatal (bfd_get_filename (file));
-         break;
-       }
-
-      if (bfd_check_format_matches (arfile, bfd_object, &matching))
-       {
-         (*format->print_archive_member) (bfd_get_filename (file),
-                                          bfd_get_filename (arfile));
-         display_rel_file (arfile, file);
-       }
+      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
-       {
-         bfd_nonfatal (bfd_get_filename (arfile));
-         if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
-           {
-             list_matching_formats (matching);
-             free (matching);
-           }
-       }
+       keep = 1;
 
-      if (last_arfile != NULL)
-       {
-         bfd_close (last_arfile);
-         lineno_cache_bfd = NULL;
-         lineno_cache_rel_bfd = NULL;
-       }
-      last_arfile = arfile;
-    }
+      if (keep
+         && ! print_debug_syms
+         && (sym->flags & BSF_DEBUGGING) != 0)
+       keep = 0;
 
-  if (last_arfile != NULL)
-    {
-      bfd_close (last_arfile);
-      lineno_cache_bfd = NULL;
-      lineno_cache_rel_bfd = NULL;
-    }
-}
+      if (keep
+         && sort_by_size
+         && (bfd_is_abs_section (sym->section)
+             || bfd_is_und_section (sym->section)))
+       keep = 0;
 
-static boolean
-display_file (filename)
-     char *filename;
-{
-  boolean retval = true;
-  bfd *file;
-  char **matching;
+      if (keep
+         && defined_only)
+       {
+         if (bfd_is_und_section (sym->section))
+           keep = 0;
+       }
 
-  file = bfd_openr (filename, target);
-  if (file == NULL)
-    {
-      bfd_nonfatal (filename);
-      return false;
-    }
+      if (keep
+         && bfd_is_target_special_symbol (abfd, sym)
+         && ! allow_special_symbols)
+       keep = 0;
 
-  if (bfd_check_format (file, bfd_archive))
-    {
-      display_archive (file);
-    }
-  else if (bfd_check_format_matches (file, bfd_object, &matching))
-    {
-      (*format->print_object_filename) (filename);
-      display_rel_file (file, NULL);
-    }
-  else
-    {
-      bfd_nonfatal (filename);
-      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
+      if (keep)
        {
-         list_matching_formats (matching);
-         free (matching);
+         memcpy (to, from, size);
+         to += size;
        }
-      retval = false;
     }
 
-  if (bfd_close (file) == false)
-    bfd_fatal (filename);
-
-  lineno_cache_bfd = NULL;
-  lineno_cache_rel_bfd = NULL;
-
-  return retval;
+  return (to - (bfd_byte *) minisyms) / size;
 }
 \f
 /* These globals are used to pass information into the sorting
    routines.  */
 static bfd *sort_bfd;
-static boolean sort_dynamic;
+static bfd_boolean sort_dynamic;
 static asymbol *sort_x;
 static asymbol *sort_y;
 
@@ -616,71 +480,78 @@ static asymbol *sort_y;
    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;
+non_numeric_forward (const void *P_x, const void *P_y)
 {
   asymbol *x, *y;
-  asection *xs, *ys;
+  const char *xn, *yn;
 
   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);
+  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);
+  xn = bfd_asymbol_name (x);
+  yn = bfd_asymbol_name (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;
+  if (yn == NULL)
+    return xn != NULL;
+  if (xn == NULL)
+    return -1;
 
-  return non_numeric_forward (P_x, P_y);
+#ifdef HAVE_STRCOLL
+  /* Solaris 2.5 has a bug in strcoll.
+     strcoll returns invalid values when confronted with empty strings.  */
+  if (*yn == '\0')
+    return *xn != '\0';
+  if (*xn == '\0')
+    return -1;
+
+  return strcoll (xn, yn);
+#else
+  return strcmp (xn, yn);
+#endif
 }
 
 static int
-numeric_reverse (x, y)
-     const PTR x;
-     const PTR y;
+non_numeric_reverse (const void *x, const void *y)
 {
-  return - numeric_forward (x, y);
+  return - non_numeric_forward (x, y);
 }
 
 static int
-non_numeric_forward (P_x, P_y)
-     const PTR P_x;
-     const PTR P_y;
+numeric_forward (const void *P_x, const void *P_y)
 {
   asymbol *x, *y;
-  const char *xn, *yn;
+  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);
+  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));
 
-  xn = bfd_asymbol_name (x);
-  yn = bfd_asymbol_name (y);
+  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 ((xn == NULL) ? ((yn == NULL) ? 0 : -1) :
-         ((yn == NULL) ? 1 : strcmp (xn, yn)));
+  return non_numeric_forward (P_x, P_y);
 }
 
 static int
-non_numeric_reverse (x, y)
-     const PTR x;
-     const PTR y;
+numeric_reverse (const void *x, const void *y)
 {
-  return - non_numeric_forward (x, y);
+  return - numeric_forward (x, y);
 }
 
-static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
+static int (*(sorters[2][2])) (const void *, const void *) =
 {
   { non_numeric_forward, non_numeric_reverse },
   { numeric_forward, numeric_reverse }
@@ -698,9 +569,7 @@ static int (*(sorters[2][2])) PARAMS ((const PTR, const PTR)) =
    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;
@@ -770,9 +639,7 @@ size_forward1 (P_x, P_y)
    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;
@@ -785,19 +652,15 @@ size_forward2 (P_x, P_y)
     return sorters[0][reverse_sort] (x->minisym, y->minisym);
 }
 
-/* Sort the symbols by size.  We guess the size by assuming that the
-   difference between the address of a symbol and the address of the
-   next higher symbol is the size.  FIXME: ELF actually stores a size
-   with each symbol.  We should use it.  */
+/* Sort the symbols by size.  ELF provides a size but for other formats
+   we have to make a guess by assuming that the difference between the
+   address of a symbol and the address of the next higher symbol is the
+   size.  */
 
 static long
-sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
-     bfd *abfd;
-     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;
@@ -808,13 +671,12 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
 
   /* 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
      undefined symbols.  Here we remove all symbols whose size winds
      up as zero.  */
-
   from = (bfd_byte *) minisyms;
   fromend = from + symcount * size;
 
@@ -823,7 +685,7 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
 
   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));
@@ -840,7 +702,7 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
        {
          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));
@@ -850,7 +712,9 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
 
       sec = bfd_get_section (sym);
 
-      if (bfd_is_com_section (sec))
+      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+       sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
+      else if (bfd_is_com_section (sec))
        sz = sym->value;
       else
        {
@@ -865,7 +729,7 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
 
       if (sz != 0)
        {
-         symsizes->minisym = (const PTR) from;
+         symsizes->minisym = (const void *) from;
          symsizes->size = sz;
          ++symsizes;
        }
@@ -880,188 +744,223 @@ sort_symbols_by_size (abfd, dynamic, minisyms, symcount, size, symsizesp)
   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))
-       {
-         fprintf (stderr, _("%s: no symbols\n"), 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)
     {
-      fprintf (stderr, _("%s: no symbols\n"), 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;
-     boolean dynamic;
-     PTR minisyms;
-     long symcount;
-     unsigned int size;
-{
-  bfd_byte *from, *fromend, *to;
-  asymbol *store;
+/* Print a single symbol.  */
 
-  store = bfd_make_empty_symbol (abfd);
-  if (store == NULL)
-    bfd_fatal (bfd_get_filename (abfd));
+static void
+print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
+{
+  symbol_info syminfo;
+  struct extended_symbol_info info;
 
-  from = (bfd_byte *) minisyms;
-  fromend = from + symcount * size;
-  to = (bfd_byte *) minisyms;
+  PROGRESS (1);
 
-  for (; from < fromend; from += size)
-    {
-      int keep = 0;
-      asymbol *sym;
+  format->print_symbol_filename (archive_bfd, abfd);
 
-      PROGRESS (1);
-      
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const PTR) from, store);
-      if (sym == NULL)
-       bfd_fatal (bfd_get_filename (abfd));
+  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 (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 (line_numbers)
+    {
+      static asymbol **syms;
+      static long symcount;
+      const char *filename, *functionname;
+      unsigned int lineno;
 
-      if (keep
-         && ! print_debug_syms
-         && (sym->flags & BSF_DEBUGGING) != 0)
-       keep = 0;
+      /* 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 (keep
-         && sort_by_size
-         && (bfd_is_abs_section (sym->section)
-             || bfd_is_und_section (sym->section)))
-       keep = 0;
+         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
-         && defined_only)
+      if (bfd_is_und_section (bfd_get_section (sym)))
        {
-         if (bfd_is_und_section (sym->section))
-           keep = 0;
-       }
+         static asection **secs;
+         static arelent ***relocs;
+         static long *relcount;
+         static unsigned int seccount;
+         unsigned int i;
+         const char *symname;
 
-      if (keep)
+         /* 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 (relocs == NULL)
+           {
+             struct get_relocs_info info;
+
+             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_line (abfd, syms, sym, &filename, &lineno)
+              || 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;
+      asymbol *sym;
+      bfd_vma ssize;
 
-      /* In this mode, give a user-level view of the symbol name
-        even if it's not mangled; strip off any leading
-        underscore.  */
-      if (bfd_get_symbol_leading_char (abfd) == name[0])
-       name++;
+      sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
+      if (sym == NULL)
+       bfd_fatal (bfd_get_filename (abfd));
 
-      res = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
-      if (res)
-       {
-         printf (format, res);
-         free (res);
-         return;
-       }
-    }
+      /* 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));
 
-  printf (format, name);
+      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;
-     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;
@@ -1080,183 +979,230 @@ print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd)
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
-      print_symbol (abfd, sym, archive_bfd);
+      print_symbol (abfd, sym, (bfd_vma) 0, archive_bfd);
     }
 }
 
-/* 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;
-     boolean dynamic;
-     struct size_sym *symsizes;
-     long symcount;
-     bfd *archive_bfd;
+static void
+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;
+      non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
+      return;
+    }
 
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
-      if (sym == NULL)
-       bfd_fatal (bfd_get_filename (abfd));
+  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
+       {
+         long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 
-      /* Set the symbol value so that we actually display the symbol
-         size.  */
-      sym->value = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
+         static_count = symcount;
+         static_syms = minisyms;
 
-      print_symbol (abfd, sym, archive_bfd);
+         if (storage > 0)
+           {
+             dyn_syms = xmalloc (storage);
+             dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
+             if (dyn_count < 0)
+               bfd_fatal (bfd_get_filename (abfd));
+           }
+       }
+      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;
+       }
     }
-}
-
-/* Print a single symbol.  */
 
-static void
-print_symbol (abfd, sym, archive_bfd)
-     bfd *abfd;
-     asymbol *sym;
-     bfd *archive_bfd;
-{
-  PROGRESS (1);
+  /* 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).  */
 
-  (*format->print_symbol_filename) (archive_bfd, abfd);
+  symcount = filter_symbols (abfd, dynamic, minisyms, symcount, size);
 
-  if (undefined_only)
+  symsizes = NULL;
+  if (! no_sort)
     {
-      if (bfd_is_und_section (bfd_get_section (sym)))
-       print_symname ("%s", bfd_asymbol_name (sym), abfd);
+      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));
+
+      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);
     }
+
+  if (! sort_by_size)
+    print_symbols (abfd, dynamic, minisyms, symcount, size, archive_bfd);
   else
-    {
-      symbol_info syminfo;
+    print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
 
-      bfd_get_symbol_info (abfd, sym, &syminfo);
-      (*format->print_symbol_info) (&syminfo, abfd);
-    }
+  free (minisyms);
+}
 
-  if (line_numbers)
+static void
+display_archive (bfd *file)
+{
+  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 (;;)
     {
-      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;
+      if (last_arfile != NULL)
+       {
+         bfd_close (last_arfile);
+         lineno_cache_bfd = NULL;
+         lineno_cache_rel_bfd = NULL;
+       }
+      last_arfile = arfile;
+    }
 
-             seccount = bfd_count_sections (abfd);
+  if (last_arfile != NULL)
+    {
+      bfd_close (last_arfile);
+      lineno_cache_bfd = NULL;
+      lineno_cache_rel_bfd = NULL;
+    }
+}
 
-             secs = (asection **) xmalloc (seccount * sizeof *secs);
-             relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
-             relcount = (long *) xmalloc (seccount * sizeof *relcount);
+static bfd_boolean
+display_file (char *filename)
+{
+  bfd_boolean retval = TRUE;
+  bfd *file;
+  char **matching;
 
-             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;
-           }
+  if (get_file_size (filename) < 1)
+    return FALSE;
 
-         symname = bfd_asymbol_name (sym);
-         for (i = 0; i < seccount; i++)
-           {
-             long j;
+  file = bfd_openr (filename, target);
+  if (file == NULL)
+    {
+      bfd_nonfatal (filename);
+      return FALSE;
+    }
 
-             for (j = 0; j < relcount[i]; j++)
-               {
-                 arelent *r;
+  if (bfd_check_format (file, bfd_archive))
+    {
+      display_archive (file);
+    }
+  else if (bfd_check_format_matches (file, bfd_object, &matching))
+    {
+      char buf[30];
 
-                 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))
-                   {
-                     /* 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)
+      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,
@@ -1268,28 +1214,29 @@ print_symbol (abfd, sym, archive_bfd)
 /* 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);
   else
     printf (_("\n\nSymbols from %s:\n\n"), filename);
-  printf (_("\
-Name                  Value   Class        Type         Size   Line  Section\n\n"));
+  if (print_width == 8)
+    printf (_("\
+Name                  Value   Class        Type         Size     Line  Section\n\n"));
+  else
+    printf (_("\
+Name                  Value           Class        Type         Size             Line  Section\n\n"));
 }
 
 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);
@@ -1298,53 +1245,49 @@ print_object_filename_posix (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);
   else
     printf (_("\n\nSymbols from %s[%s]:\n\n"), archive, filename);
-  printf (_("\
-Name                  Value   Class        Type         Size   Line  Section\n\n"));
+  if (print_width == 8)
+    printf (_("\
+Name                  Value   Class        Type         Size     Line  Section\n\n"));
+  else
+    printf (_("\
+Name                  Value           Class        Type         Size             Line  Section\n\n"));
 }
 
 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);
@@ -1354,8 +1297,7 @@ print_archive_member_posix (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)
     {
@@ -1366,8 +1308,7 @@ print_symbol_filename_bsd (archive_bfd, abfd)
 }
 
 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)
     {
@@ -1378,8 +1319,7 @@ print_symbol_filename_sysv (archive_bfd, abfd)
 }
 
 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)
     {
@@ -1394,15 +1334,14 @@ print_symbol_filename_posix (archive_bfd, abfd)
 /* Print a symbol value.  */
 
 static void
-print_value (val)
-     bfd_vma val;
+print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
 {
 #if ! defined (BFD64) || BFD_HOST_64BIT_LONG
   printf (value_format, val);
 #else
   /* We have a 64 bit value to print, but the host is only 32 bit.  */
   if (print_radix == 16)
-    fprintf_vma (stdout, val);
+    bfd_fprintf_vma (abfd, stdout, val);
   else
     {
       char buf[30];
@@ -1425,136 +1364,276 @@ print_value (val)
 /* Print a line of information about a symbol.  */
 
 static void
-print_symbol_info_bsd (info, abfd)
-     symbol_info *info;
-     bfd *abfd;
+print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
 {
-  if (bfd_is_undefined_symclass (info->type))
+  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
     {
-      printf ("%*s",
-#ifdef BFD64
-             16,
-#else
-             8,
-#endif
-             "");
+      if (print_width == 16)
+       printf ("        ");
+      printf ("        ");
     }
   else
-    print_value (info->value);
-  printf (" %c", info->type);
-  if (info->type == '-')
+    {
+      /* Normally we print the value of the symbol.  If we are printing 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)
+       print_value (abfd, SYM_SIZE (info));
+      else
+       print_value (abfd, SYM_VALUE (info));
+
+      if (print_size && SYM_SIZE (info))
+       {
+         printf (" ");
+         print_value (abfd, SYM_SIZE (info));
+       }
+    }
+
+  printf (" %c", SYM_TYPE (info));
+
+  if (SYM_TYPE (info) == '-')
     {
       /* A stab.  */
       printf (" ");
-      printf (other_format, info->stab_other);
+      printf (other_format, SYM_STAB_OTHER (info));
       printf (" ");
-      printf (desc_format, info->stab_desc);
-      printf (" %5s", info->stab_name);
+      printf (desc_format, SYM_STAB_DESC (info));
+      printf (" %5s", SYM_STAB_NAME (info));
     }
-  print_symname (" %s", info->name, abfd);
+  print_symname (" %s", SYM_NAME (info), abfd);
 }
 
 static void
-print_symbol_info_sysv (info, abfd)
-     symbol_info *info;
-     bfd *abfd;
+print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
 {
-  print_symname ("%-20s|", info->name, abfd);  /* Name */
-  if (bfd_is_undefined_symclass (info->type))
-    printf ("        ");       /* Value */
+  print_symname ("%-20s|", SYM_NAME (info), abfd);
+
+  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
+    {
+      if (print_width == 8)
+       printf ("        ");
+      else
+       printf ("                ");
+    }
   else
-    print_value (info->value);
-  printf ("|   %c  |", info->type);    /* Class */
-  if (info->type == '-')
+    print_value (abfd, SYM_VALUE (info));
+
+  printf ("|   %c  |", SYM_TYPE (info));
+
+  if (SYM_TYPE (info) == '-')
     {
       /* A stab.  */
-      printf ("%18s|  ", info->stab_name);     /* (C) Type */
-      printf (desc_format, info->stab_desc);   /* Size */
-      printf ("|     |");      /* Line, Section */
+      printf ("%18s|  ", SYM_STAB_NAME (info));                /* (C) Type.  */
+      printf (desc_format, SYM_STAB_DESC (info));      /* Size.  */
+      printf ("|     |");                              /* Line, Section.  */
     }
   else
-    printf ("                  |      |     |");       /* Type, Size, Line, Section */
+    {
+      /* Type, Size, Line, Section */
+      if (info->elfinfo)
+       printf ("%18s|",
+               get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
+      else
+       printf ("                  |");
+
+      if (SYM_SIZE (info))
+       print_value (abfd, SYM_SIZE (info));
+      else
+       {
+         if (print_width == 8)
+           printf ("        ");
+         else
+           printf ("                ");
+       }
+
+      if (info->elfinfo)
+       printf("|     |%s", info->elfinfo->symbol.section->name);
+      else
+       printf("|     |");
+    }
 }
 
 static void
-print_symbol_info_posix (info, abfd)
-     symbol_info *info;
-     bfd *abfd;
+print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
 {
-  print_symname ("%s ", info->name, abfd);
-  printf ("%c ", info->type);
-  if (bfd_is_undefined_symclass (info->type))
+  print_symname ("%s ", SYM_NAME (info), abfd);
+  printf ("%c ", SYM_TYPE (info));
+
+  if (bfd_is_undefined_symclass (SYM_TYPE (info)))
     printf ("        ");
   else
-    print_value (info->value);
-  /* POSIX.2 wants the symbol size printed here, when applicable;
-     BFD currently doesn't provide it, so we take the easy way out by
-     considering it to never be applicable.  */
+    {
+      print_value (abfd, SYM_VALUE (info));
+      printf (" ");
+      if (SYM_SIZE (info))
+       print_value (abfd, SYM_SIZE (info));
+    }
 }
 \f
-static void
-print_symdef_entry (abfd)
-     bfd *abfd;
+int
+main (int argc, char **argv)
 {
-  symindex idx = BFD_NO_MORE_SYMBOLS;
-  carsym *thesym;
-  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);
+
+  expandargv (&argc, &argv);
+
+  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;
 }