projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
gdb: add target_ops::supports_displaced_step
[deliverable/binutils-gdb.git] / binutils / nm.c
diff --git a/binutils/nm.c b/binutils/nm.c
index 3b0b7e0d47e454bcba6a5f5ea9a7d0d56006bdb3..1b5122d56ab5c00fc710a775053eb2ee300b0665 100644 (file)
--- a/binutils/nm.c
+++ b/binutils/nm.c
@@ -1,13 +1,11 @@
 /* nm.c -- Describe symbol table of a rel file.
 /* nm.c -- Describe symbol table of a rel file.
-   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003, 2004, 2005, 2007
-   Free Software Foundation, Inc.
+   Copyright (C) 1991-2020 Free Software Foundation, Inc.
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -20,10 +18,9 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
    02110-1301, USA.  */
 
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
    02110-1301, USA.  */
 
+#include "sysdep.h"
 #include "bfd.h"
 #include "progress.h"
 #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 "getopt.h"
 #include "aout/stab_gnu.h"
 #include "aout/ranlib.h"
@@ -31,6 +28,16 @@
 #include "libiberty.h"
 #include "elf-bfd.h"
 #include "elf/common.h"
 #include "libiberty.h"
 #include "elf-bfd.h"
 #include "elf/common.h"
+#define DO_NOT_DEFINE_AOUTHDR
+#define DO_NOT_DEFINE_FILHDR
+#define DO_NOT_DEFINE_LINENO
+#define DO_NOT_DEFINE_SCNHDR
+#include "coff/external.h"
+#include "coff/internal.h"
+#include "libcoff.h"
+#include "bucomm.h"
+#include "plugin-api.h"
+#include "plugin.h"
 
 /* When sorting by size, we use this structure to hold the size and a
    pointer to the minisymbol.  */
 
 /* When sorting by size, we use this structure to hold the size and a
    pointer to the minisymbol.  */
@@ -57,9 +64,9 @@ struct extended_symbol_info
   symbol_info *sinfo;
   bfd_vma ssize;
   elf_symbol_type *elfinfo;
   symbol_info *sinfo;
   bfd_vma ssize;
   elf_symbol_type *elfinfo;
+  coff_symbol_type *coffinfo;
   /* FIXME: We should add more fields for Type, Line, Section.  */
 };
   /* 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_VALUE(sym)       (sym->sinfo->value)
 #define SYM_TYPE(sym)        (sym->sinfo->type)
 #define SYM_STAB_NAME(sym)   (sym->sinfo->stab_name)
@@ -69,15 +76,15 @@ struct extended_symbol_info
   (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
 
 /* The output formatting functions.  */
   (sym->elfinfo ? sym->elfinfo->internal_elf_sym.st_size: sym->ssize)
 
 /* The output formatting functions.  */
-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_object_filename_bsd (const char *);
+static void print_object_filename_sysv (const char *);
+static void print_object_filename_posix (const char *);
+static void print_archive_filename_bsd (const char *);
+static void print_archive_filename_sysv (const char *);
+static void print_archive_filename_posix (const char *);
+static void print_archive_member_bsd (const char *, const char *);
+static void print_archive_member_sysv (const char *, const char *);
+static void print_archive_member_posix (const 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_symbol_filename_bsd (bfd *, bfd *);
 static void print_symbol_filename_sysv (bfd *, bfd *);
 static void print_symbol_filename_posix (bfd *, bfd *);
@@ -90,13 +97,13 @@ static void print_symbol_info_posix (struct extended_symbol_info *, bfd *);
 struct output_fns
   {
     /* Print the name of an object file given on the command line.  */
 struct output_fns
   {
     /* Print the name of an object file given on the command line.  */
-    void (*print_object_filename) (char *);
+    void (*print_object_filename) (const char *);
 
     /* Print the name of an archive file given on the command line.  */
 
     /* Print the name of an archive file given on the command line.  */
-    void (*print_archive_filename) (char *);
+    void (*print_archive_filename) (const char *);
 
     /* Print the name of an archive member file.  */
 
     /* Print the name of an archive member file.  */
-    void (*print_archive_member) (char *, const char *);
+    void (*print_archive_member) (const char *, const char *);
 
     /* Print the name of the file (and archive, if there is one)
        containing a symbol.  */
 
     /* Print the name of the file (and archive, if there is one)
        containing a symbol.  */
@@ -133,6 +140,8 @@ static struct output_fns formats[] =
 
 /* The output format to use.  */
 static struct output_fns *format = &formats[FORMAT_DEFAULT];
 
 /* The output format to use.  */
 static struct output_fns *format = &formats[FORMAT_DEFAULT];
+static unsigned int print_format = FORMAT_DEFAULT;
+static const char *print_format_string = NULL;
 
 /* Command options.  */
 
 
 /* Command options.  */
 
@@ -149,18 +158,17 @@ 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 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.  */
 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.  */
+static int with_symbol_versions = 0; /* Include symbol version information in the output.  */
+
+static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
 
 /* 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.  */
 static int filename_per_symbol = 0;    /* Once per symbol, at start of line.  */
 
 
 /* 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.  */
 static int filename_per_symbol = 0;    /* Once per symbol, at start of line.  */
 
-/* Print formats for printing a symbol value.  */
-static char value_format_32bit[] = "%08lx";
-static char value_format_64bit[] = "%016lx";
 static int print_width = 0;
 static int print_radix = 16;
 /* Print formats for printing stab info.  */
 static int print_width = 0;
 static int print_radix = 16;
 /* Print formats for printing stab info.  */
@@ -168,12 +176,24 @@ static char other_format[] = "%02x";
 static char desc_format[] = "%04x";
 
 static char *target = NULL;
 static char desc_format[] = "%04x";
 
 static char *target = NULL;
+#if BFD_SUPPORTS_PLUGINS
+static const char *plugin_target = "plugin";
+#else
+static const char *plugin_target = NULL;
+#endif
 
 /* Used to cache the line numbers for a BFD.  */
 static bfd *lineno_cache_bfd;
 static bfd *lineno_cache_rel_bfd;
 
 
 /* Used to cache the line numbers for a BFD.  */
 static bfd *lineno_cache_bfd;
 static bfd *lineno_cache_rel_bfd;
 
-#define OPTION_TARGET 200
+enum long_option_values
+{
+  OPTION_TARGET = 200,
+  OPTION_PLUGIN,
+  OPTION_SIZE_SORT,
+  OPTION_RECURSE_LIMIT,
+  OPTION_NO_RECURSE_LIMIT
+};
 
 static struct option long_options[] =
 {
 
 static struct option long_options[] =
 {
@@ -186,28 +206,33 @@ static struct option long_options[] =
   {"line-numbers", no_argument, 0, 'l'},
   {"no-cplus", no_argument, &do_demangle, 0},  /* Linux compatibility.  */
   {"no-demangle", no_argument, &do_demangle, 0},
   {"line-numbers", no_argument, 0, 'l'},
   {"no-cplus", no_argument, &do_demangle, 0},  /* Linux compatibility.  */
   {"no-demangle", no_argument, &do_demangle, 0},
-  {"no-sort", no_argument, &no_sort, 1},
-  {"numeric-sort", no_argument, &sort_numerically, 1},
+  {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
+  {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
+  {"no-sort", no_argument, 0, 'p'},
+  {"numeric-sort", no_argument, 0, 'n'},
+  {"plugin", required_argument, 0, OPTION_PLUGIN},
   {"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'},
   {"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'},
+  {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
+  {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
   {"reverse-sort", no_argument, &reverse_sort, 1},
   {"reverse-sort", no_argument, &reverse_sort, 1},
-  {"size-sort", no_argument, &sort_by_size, 1},
+  {"size-sort", no_argument, 0, OPTION_SIZE_SORT},
   {"special-syms", no_argument, &allow_special_symbols, 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},
   {"version", no_argument, &show_version, 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},
   {"version", no_argument, &show_version, 1},
+  {"with-symbol-versions", no_argument, &with_symbol_versions, 1},
   {0, no_argument, 0, 0}
 };
 \f
 /* Some error-reporting functions.  */
 
   {0, no_argument, 0, 0}
 };
 \f
 /* Some error-reporting functions.  */
 
-static void
+ATTRIBUTE_NORETURN static void
 usage (FILE *stream, int status)
 {
   fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
 usage (FILE *stream, int status)
 {
   fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);
@@ -221,6 +246,8 @@ usage (FILE *stream, int status)
                           `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
                           or `gnat'\n\
       --no-demangle      Do not demangle low-level symbol names\n\
                           `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
                           or `gnat'\n\
       --no-demangle      Do not demangle low-level symbol names\n\
+      --recurse-limit    Enable a demangling recursion limit.  This is the default.\n\
+      --no-recurse-limit Disable a demangling recursion limit.\n\
   -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
       --defined-only     Display only defined symbols\n\
   -e                     (ignored)\n\
   -D, --dynamic          Display dynamic symbols instead of normal symbols\n\
       --defined-only     Display only defined symbols\n\
   -e                     (ignored)\n\
@@ -233,7 +260,12 @@ usage (FILE *stream, int status)
   -o                     Same as -A\n\
   -p, --no-sort          Do not sort the symbols\n\
   -P, --portability      Same as --format=posix\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\
+  -r, --reverse-sort     Reverse the sense of the sort\n"));
+#if BFD_SUPPORTS_PLUGINS
+  fprintf (stream, _("\
+      --plugin NAME      Load the specified plugin\n"));
+#endif
+  fprintf (stream, _("\
   -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\
   -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\
@@ -242,6 +274,7 @@ usage (FILE *stream, int status)
   -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\
   -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\
+      --with-symbol-versions  Display version strings after symbol names\n\
   -X 32_64               (ignored)\n\
   @FILE                  Read options from FILE\n\
   -h, --help             Display this information\n\
   -X 32_64               (ignored)\n\
   @FILE                  Read options from FILE\n\
   -h, --help             Display this information\n\
@@ -260,21 +293,15 @@ set_print_radix (char *radix)
 {
   switch (*radix)
     {
 {
   switch (*radix)
     {
-    case 'x':
-      break;
-    case 'd':
-    case 'o':
-      if (*radix == 'd')
-       print_radix = 10;
-      else
-       print_radix = 8;
-      value_format_32bit[4] = *radix;
-      value_format_64bit[5] = *radix;
-      other_format[3] = desc_format[3] = *radix;
-      break;
+    case 'x': print_radix = 16; break;
+    case 'd': print_radix = 10; break;
+    case 'o': print_radix =  8; break;
+
     default:
       fatal (_("%s: invalid radix"), radix);
     }
     default:
       fatal (_("%s: invalid radix"), radix);
     }
+
+  other_format[3] = desc_format[3] = *radix;
 }
 
 static void
 }
 
 static void
@@ -300,12 +327,14 @@ set_output_format (char *f)
       fatal (_("%s: invalid output format"), f);
     }
   format = &formats[i];
       fatal (_("%s: invalid output format"), f);
     }
   format = &formats[i];
+  print_format = i;
 }
 \f
 static const char *
 }
 \f
 static const char *
-get_symbol_type (unsigned int type)
+get_elf_symbol_type (unsigned int type)
 {
 {
-  static char buff [32];
+  static char *bufp;
+  int n;
 
   switch (type)
     {
 
   switch (type)
     {
@@ -316,33 +345,83 @@ get_symbol_type (unsigned int type)
     case STT_FILE:     return "FILE";
     case STT_COMMON:   return "COMMON";
     case STT_TLS:      return "TLS";
     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;
     }
     }
+
+  free (bufp);
+  if (type >= STT_LOPROC && type <= STT_HIPROC)
+    n = asprintf (&bufp, _("<processor specific>: %d"), type);
+  else if (type >= STT_LOOS && type <= STT_HIOS)
+    n = asprintf (&bufp, _("<OS specific>: %d"), type);
+  else
+    n = asprintf (&bufp, _("<unknown>: %d"), type);
+  if (n < 0)
+    fatal ("%s", xstrerror (errno));
+  return bufp;
+}
+
+static const char *
+get_coff_symbol_type (const struct internal_syment *sym)
+{
+  static char *bufp;
+  int n;
+
+  switch (sym->n_sclass)
+    {
+    case C_BLOCK: return "Block";
+    case C_FILE:  return "File";
+    case C_LINE:  return "Line";
+    }
+
+  if (!sym->n_type)
+    return "None";
+
+  switch (DTYPE(sym->n_type))
+    {
+    case DT_FCN: return "Function";
+    case DT_PTR: return "Pointer";
+    case DT_ARY: return "Array";
+    }
+
+  free (bufp);
+  n = asprintf (&bufp, _("<unknown>: %d/%d"), sym->n_sclass, sym->n_type);
+  if (n < 0)
+    fatal ("%s", xstrerror (errno));
+  return bufp;
 }
 \f
 }
 \f
-/* Print symbol name NAME, read from ABFD, with printf format FORMAT,
+/* Print symbol name NAME, read from ABFD, with printf format FORM,
    demangling it if requested.  */
 
 static void
    demangling it if requested.  */
 
 static void
-print_symname (const char *format, const char *name, bfd *abfd)
+print_symname (const char *form, struct extended_symbol_info *info,
+              const char *name, bfd *abfd)
 {
 {
+  if (name == NULL)
+    name = info->sinfo->name;
   if (do_demangle && *name)
     {
   if (do_demangle && *name)
     {
-      char *res = demangle (abfd, name);
+      char *res = bfd_demangle (abfd, name, demangle_flags);
 
 
-      printf (format, res);
-      free (res);
-      return;
+      if (res != NULL)
+       {
+         printf (form, res);
+         free (res);
+         return;
+       }
     }
 
     }
 
-  printf (format, name);
+  printf (form, name);
+  if (info != NULL && info->elfinfo)
+    {
+      const char *version_string;
+      bfd_boolean hidden;
+
+      version_string
+       = bfd_get_symbol_version_string (abfd, &info->elfinfo->symbol,
+                                        FALSE, &hidden);
+      if (version_string && version_string[0])
+       printf ("%s%s", hidden ? "@" : "@@", version_string);
+    }
 }
 
 static void
 }
 
 static void
@@ -367,18 +446,22 @@ print_symdef_entry (bfd *abfd)
        bfd_fatal ("bfd_get_elt_at_index");
       if (thesym->name != (char *) NULL)
        {
        bfd_fatal ("bfd_get_elt_at_index");
       if (thesym->name != (char *) NULL)
        {
-         print_symname ("%s", thesym->name, abfd);
+         print_symname ("%s", NULL, thesym->name, abfd);
          printf (" in %s\n", bfd_get_filename (elt));
        }
     }
 }
 \f
          printf (" in %s\n", bfd_get_filename (elt));
        }
     }
 }
 \f
+
+/* True when we can report missing plugin error.  */
+bfd_boolean report_plugin_err = TRUE;
+
 /* 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
 /* 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,
+filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
                long symcount, unsigned int size)
 {
   bfd_byte *from, *fromend, *to;
                long symcount, unsigned int size)
 {
   bfd_byte *from, *fromend, *to;
@@ -399,15 +482,27 @@ filter_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms,
 
       PROGRESS (1);
 
 
       PROGRESS (1);
 
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from, store);
+      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from, store);
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
+      if (sym->name[0] == '_'
+         && sym->name[1] == '_'
+         && strcmp (sym->name + (sym->name[2] == '_'), "__gnu_lto_slim") == 0
+         && report_plugin_err)
+       {
+         report_plugin_err = FALSE;
+         non_fatal (_("%s: plugin needed to handle lto object"),
+                    bfd_get_filename (abfd));
+       }
+
       if (undefined_only)
        keep = bfd_is_und_section (sym->section);
       else if (external_only)
       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
+       /* PR binutls/12753: Unique symbols are global too.  */
+       keep = ((sym->flags & (BSF_GLOBAL
+                              | BSF_WEAK
+                              | BSF_GNU_UNIQUE)) != 0
                || bfd_is_und_section (sym->section)
                || bfd_is_com_section (sym->section));
       else
                || bfd_is_und_section (sym->section)
                || bfd_is_com_section (sym->section));
       else
@@ -438,7 +533,8 @@ filter_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms,
 
       if (keep)
        {
 
       if (keep)
        {
-         memcpy (to, from, size);
+         if (to != from)
+           memcpy (to, from, size);
          to += size;
        }
     }
          to += size;
        }
     }
@@ -510,8 +606,8 @@ numeric_forward (const void *P_x, const void *P_y)
   if (x == NULL || y == NULL)
     bfd_fatal (bfd_get_filename (sort_bfd));
 
   if (x == NULL || y == NULL)
     bfd_fatal (bfd_get_filename (sort_bfd));
 
-  xs = bfd_get_section (x);
-  ys = bfd_get_section (y);
+  xs = bfd_asymbol_section (x);
+  ys = bfd_asymbol_section (y);
 
   if (bfd_is_und_section (xs))
     {
 
   if (bfd_is_und_section (xs))
     {
@@ -563,8 +659,8 @@ size_forward1 (const void *P_x, const void *P_y)
   if (x == NULL || y == NULL)
     bfd_fatal (bfd_get_filename (sort_bfd));
 
   if (x == NULL || y == NULL)
     bfd_fatal (bfd_get_filename (sort_bfd));
 
-  xs = bfd_get_section (x);
-  ys = bfd_get_section (y);
+  xs = bfd_asymbol_section (x);
+  ys = bfd_asymbol_section (y);
 
   if (bfd_is_und_section (xs))
     abort ();
 
   if (bfd_is_und_section (xs))
     abort ();
@@ -601,7 +697,8 @@ size_forward1 (const void *P_x, const void *P_y)
 
 #define file_symbol(s, sn, snl)                        \
   (((s)->flags & BSF_FILE) != 0                        \
 
 #define file_symbol(s, sn, snl)                        \
   (((s)->flags & BSF_FILE) != 0                        \
-   || ((sn)[(snl) - 2] == '.'                  \
+   || ((snl) > 2                               \
+       && (sn)[(snl) - 2] == '.'               \
        && ((sn)[(snl) - 1] == 'o'              \
           || (sn)[(snl) - 1] == 'a')))
 
        && ((sn)[(snl) - 1] == 'o'              \
           || (sn)[(snl) - 1] == 'a')))
 
@@ -639,7 +736,7 @@ size_forward2 (const void *P_x, const void *P_y)
    size.  */
 
 static long
    size.  */
 
 static long
-sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
+sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
                      long symcount, unsigned int size,
                      struct size_sym **symsizesp)
 {
                      long symcount, unsigned int size,
                      struct size_sym **symsizesp)
 {
@@ -652,7 +749,7 @@ sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
 
   /* We are going to return a special set of symbols and sizes to
      print.  */
 
   /* We are going to return a special set of symbols and sizes to
      print.  */
-  symsizes = xmalloc (symcount * sizeof (struct size_sym));
+  symsizes = (struct size_sym *) xmalloc (symcount * sizeof (struct size_sym));
   *symsizesp = symsizes;
 
   /* Note that filter_symbols has already removed all absolute and
   *symsizesp = symsizes;
 
   /* Note that filter_symbols has already removed all absolute and
@@ -666,7 +763,7 @@ sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
 
   if (from < fromend)
     {
 
   if (from < fromend)
     {
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from,
+      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, (const void *) from,
                                      store_sym);
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
                                      store_sym);
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
@@ -682,7 +779,7 @@ sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
       if (from + size < fromend)
        {
          next = bfd_minisymbol_to_symbol (abfd,
       if (from + size < fromend)
        {
          next = bfd_minisymbol_to_symbol (abfd,
-                                          dynamic,
+                                          is_dynamic,
                                           (const void *) (from + size),
                                           store_next);
          if (next == NULL)
                                           (const void *) (from + size),
                                           store_next);
          if (next == NULL)
@@ -691,20 +788,25 @@ sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
       else
        next = NULL;
 
       else
        next = NULL;
 
-      sec = bfd_get_section (sym);
+      sec = bfd_asymbol_section (sym);
 
 
-      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+      /* Synthetic symbols don't have a full type set of data available, thus
+        we can't rely on that information for the symbol size.  Ditto for
+        bfd/section.c:global_syms like *ABS*.  */
+      if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
+         && bfd_get_flavour (abfd) == bfd_target_elf_flavour)
        sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
        sz = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
-      else if (bfd_is_com_section (sec))
+      else if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0
+              && bfd_is_com_section (sec))
        sz = sym->value;
       else
        {
          if (from + size < fromend
        sz = sym->value;
       else
        {
          if (from + size < fromend
-             && sec == bfd_get_section (next))
+             && sec == bfd_asymbol_section (next))
            sz = valueof (next) - valueof (sym);
          else
            sz = valueof (next) - valueof (sym);
          else
-           sz = (bfd_get_section_vma (abfd, sec)
-                 + bfd_section_size (abfd, sec)
+           sz = (bfd_section_vma (sec)
+                 + bfd_section_size (sec)
                  - valueof (sym));
        }
 
                  - valueof (sym));
        }
 
@@ -753,7 +855,7 @@ get_relocs (bfd *abfd, asection *sec, void *dataarg)
       if (relsize < 0)
        bfd_fatal (bfd_get_filename (abfd));
 
       if (relsize < 0)
        bfd_fatal (bfd_get_filename (abfd));
 
-      *data->relocs = xmalloc (relsize);
+      *data->relocs = (arelent **) xmalloc (relsize);
       *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
                                                data->syms);
       if (*data->relcount < 0)
       *data->relcount = bfd_canonicalize_reloc (abfd, sec, *data->relocs,
                                                data->syms);
       if (*data->relcount < 0)
@@ -768,7 +870,10 @@ get_relocs (bfd *abfd, asection *sec, void *dataarg)
 /* Print a single symbol.  */
 
 static void
 /* Print a single symbol.  */
 
 static void
-print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
+print_symbol (bfd *        abfd,
+             asymbol *    sym,
+             bfd_vma      ssize,
+             bfd *        archive_bfd)
 {
   symbol_info syminfo;
   struct extended_symbol_info info;
 {
   symbol_info syminfo;
   struct extended_symbol_info info;
@@ -778,14 +883,40 @@ print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
   format->print_symbol_filename (archive_bfd, abfd);
 
   bfd_get_symbol_info (abfd, sym, &syminfo);
   format->print_symbol_filename (archive_bfd, abfd);
 
   bfd_get_symbol_info (abfd, sym, &syminfo);
+
   info.sinfo = &syminfo;
   info.ssize = ssize;
   info.sinfo = &syminfo;
   info.ssize = ssize;
-  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
-    info.elfinfo = (elf_symbol_type *) sym;
+  /* Synthetic symbols do not have a full symbol type set of data available.
+     Nor do bfd/section.c:global_syms like *ABS*.  */
+  if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) != 0)
+    {
+      info.elfinfo = NULL;
+      info.coffinfo = NULL;
+    }
   else
   else
-    info.elfinfo = NULL;
+    {
+      info.elfinfo = elf_symbol_from (abfd, sym);
+      info.coffinfo = coff_symbol_from (sym);
+    }
+
   format->print_symbol_info (&info, abfd);
 
   format->print_symbol_info (&info, abfd);
 
+  if (with_symbol_versions)
+    {
+      const char *  version_string = NULL;
+      bfd_boolean   hidden = FALSE;
+
+      if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
+       version_string = bfd_get_symbol_version_string (abfd, sym,
+                                                       TRUE, &hidden);
+
+      if (bfd_is_und_section (bfd_asymbol_section (sym)))
+       hidden = TRUE;
+
+      if (version_string && *version_string != '\0')
+       printf (hidden ? "@%s" : "@@%s", version_string);
+    }
+
   if (line_numbers)
     {
       static asymbol **syms;
   if (line_numbers)
     {
       static asymbol **syms;
@@ -808,14 +939,14 @@ print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
          symsize = bfd_get_symtab_upper_bound (abfd);
          if (symsize < 0)
            bfd_fatal (bfd_get_filename (abfd));
          symsize = bfd_get_symtab_upper_bound (abfd);
          if (symsize < 0)
            bfd_fatal (bfd_get_filename (abfd));
-         syms = xmalloc (symsize);
+         syms = (asymbol **) xmalloc (symsize);
          symcount = bfd_canonicalize_symtab (abfd, syms);
          if (symcount < 0)
            bfd_fatal (bfd_get_filename (abfd));
          lineno_cache_bfd = abfd;
        }
 
          symcount = bfd_canonicalize_symtab (abfd, syms);
          if (symcount < 0)
            bfd_fatal (bfd_get_filename (abfd));
          lineno_cache_bfd = abfd;
        }
 
-      if (bfd_is_und_section (bfd_get_section (sym)))
+      if (bfd_is_und_section (bfd_asymbol_section (sym)))
        {
          static asection **secs;
          static arelent ***relocs;
        {
          static asection **secs;
          static arelent ***relocs;
@@ -841,19 +972,19 @@ print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
 
          if (relocs == NULL)
            {
 
          if (relocs == NULL)
            {
-             struct get_relocs_info info;
+             struct get_relocs_info rinfo;
 
              seccount = bfd_count_sections (abfd);
 
 
              seccount = bfd_count_sections (abfd);
 
-             secs = xmalloc (seccount * sizeof *secs);
-             relocs = xmalloc (seccount * sizeof *relocs);
-             relcount = xmalloc (seccount * sizeof *relcount);
+             secs = (asection **) xmalloc (seccount * sizeof *secs);
+             relocs = (arelent ***) xmalloc (seccount * sizeof *relocs);
+             relcount = (long *) 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);
+             rinfo.secs = secs;
+             rinfo.relocs = relocs;
+             rinfo.relcount = relcount;
+             rinfo.syms = syms;
+             bfd_map_over_sections (abfd, get_relocs, (void *) &rinfo);
              lineno_cache_rel_bfd = abfd;
            }
 
              lineno_cache_rel_bfd = abfd;
            }
 
@@ -885,10 +1016,10 @@ print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
                }
            }
        }
                }
            }
        }
-      else if (bfd_get_section (sym)->owner == abfd)
+      else if (bfd_asymbol_section (sym)->owner == abfd)
        {
          if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
        {
          if ((bfd_find_line (abfd, syms, sym, &filename, &lineno)
-              || bfd_find_nearest_line (abfd, bfd_get_section (sym),
+              || bfd_find_nearest_line (abfd, bfd_asymbol_section (sym),
                                         syms, sym->value, &filename,
                                         &functionname, &lineno))
              && filename != NULL
                                         syms, sym->value, &filename,
                                         &functionname, &lineno))
              && filename != NULL
@@ -903,12 +1034,15 @@ print_symbol (bfd *abfd, asymbol *sym, bfd_vma ssize, bfd *archive_bfd)
 /* Print the symbols when sorting by size.  */
 
 static void
 /* Print the symbols when sorting by size.  */
 
 static void
-print_size_symbols (bfd *abfd, bfd_boolean dynamic,
-                   struct size_sym *symsizes, long symcount,
-                   bfd *archive_bfd)
+print_size_symbols (bfd *              abfd,
+                   bfd_boolean        is_dynamic,
+                   struct size_sym *  symsizes,
+                   long               symcount,
+                   bfd *              archive_bfd)
 {
   asymbol *store;
 {
   asymbol *store;
-  struct size_sym *from, *fromend;
+  struct size_sym *from;
+  struct size_sym *fromend;
 
   store = bfd_make_empty_symbol (abfd);
   if (store == NULL)
 
   store = bfd_make_empty_symbol (abfd);
   if (store == NULL)
@@ -916,35 +1050,39 @@ print_size_symbols (bfd *abfd, bfd_boolean dynamic,
 
   from = symsizes;
   fromend = from + symcount;
 
   from = symsizes;
   fromend = from + symcount;
+
   for (; from < fromend; from++)
     {
       asymbol *sym;
   for (; from < fromend; from++)
     {
       asymbol *sym;
-      bfd_vma ssize;
 
 
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, from->minisym, store);
+      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from->minisym, store);
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
       if (sym == 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;
-      else
-       ssize = from->size - bfd_section_vma (abfd, bfd_get_section (sym));
-
-      print_symbol (abfd, sym, ssize, archive_bfd);
+      print_symbol (abfd, sym, from->size, archive_bfd);
     }
 }
 
 \f
     }
 }
 
 \f
-/* Print the symbols.  If ARCHIVE_BFD is non-NULL, it is the archive
-   containing ABFD.  */
+/* Print the symbols of ABFD that are held in MINISYMS.
+
+   If ARCHIVE_BFD is non-NULL, it is the archive containing ABFD.
+
+   SYMCOUNT is the number of symbols in MINISYMS.
+
+   SIZE is the size of a symbol in MINISYMS.  */
 
 static void
 
 static void
-print_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms, long symcount,
-              unsigned int size, bfd *archive_bfd)
+print_symbols (bfd *         abfd,
+              bfd_boolean   is_dynamic,
+              void *        minisyms,
+              long          symcount,
+              unsigned int  size,
+              bfd *         archive_bfd)
 {
   asymbol *store;
 {
   asymbol *store;
-  bfd_byte *from, *fromend;
+  bfd_byte *from;
+  bfd_byte *fromend;
 
   store = bfd_make_empty_symbol (abfd);
   if (store == NULL)
 
   store = bfd_make_empty_symbol (abfd);
   if (store == NULL)
@@ -952,11 +1090,12 @@ print_symbols (bfd *abfd, bfd_boolean dynamic, void *minisyms, long symcount,
 
   from = (bfd_byte *) minisyms;
   fromend = from + symcount * size;
 
   from = (bfd_byte *) minisyms;
   fromend = from + symcount * size;
+
   for (; from < fromend; from += size)
     {
       asymbol *sym;
 
   for (; from < fromend; from += size)
     {
       asymbol *sym;
 
-      sym = bfd_minisymbol_to_symbol (abfd, dynamic, from, store);
+      sym = bfd_minisymbol_to_symbol (abfd, is_dynamic, from, store);
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
       if (sym == NULL)
        bfd_fatal (bfd_get_filename (abfd));
 
@@ -973,6 +1112,7 @@ display_rel_file (bfd *abfd, bfd *archive_bfd)
   void *minisyms;
   unsigned int size;
   struct size_sym *symsizes;
   void *minisyms;
   unsigned int size;
   struct size_sym *symsizes;
+  asymbol *synthsyms = NULL;
 
   if (! dynamic)
     {
 
   if (! dynamic)
     {
@@ -985,7 +1125,15 @@ display_rel_file (bfd *abfd, bfd *archive_bfd)
 
   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
   if (symcount < 0)
 
   symcount = bfd_read_minisymbols (abfd, dynamic, &minisyms, &size);
   if (symcount < 0)
-    bfd_fatal (bfd_get_filename (abfd));
+    {
+      if (dynamic && bfd_get_error () == bfd_error_no_symbols)
+       {
+         non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
+         return;
+       }
+
+      bfd_fatal (bfd_get_filename (abfd));
+    }
 
   if (symcount == 0)
     {
 
   if (symcount == 0)
     {
@@ -995,51 +1143,59 @@ display_rel_file (bfd *abfd, bfd *archive_bfd)
 
   if (show_synthetic && size == sizeof (asymbol *))
     {
 
   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;
       asymbol **static_syms = NULL;
       asymbol **dyn_syms = NULL;
       long static_count = 0;
       long dyn_count = 0;
+      long synth_count;
 
       if (dynamic)
        {
          dyn_count = symcount;
 
       if (dynamic)
        {
          dyn_count = symcount;
-         dyn_syms = minisyms;
+         dyn_syms = (asymbol **) minisyms;
        }
       else
        {
          long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 
          static_count = symcount;
        }
       else
        {
          long storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 
          static_count = symcount;
-         static_syms = minisyms;
+         static_syms = (asymbol **) minisyms;
 
          if (storage > 0)
            {
 
          if (storage > 0)
            {
-             dyn_syms = xmalloc (storage);
+             dyn_syms = (asymbol **) xmalloc (storage);
              dyn_count = bfd_canonicalize_dynamic_symtab (abfd, dyn_syms);
              if (dyn_count < 0)
                bfd_fatal (bfd_get_filename (abfd));
            }
        }
              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;
       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;
 
          long i;
 
-         new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
-         symp = new_mini;
-         memcpy (symp, minisyms, symcount * sizeof (*symp));
-         symp += symcount;
+         minisyms = xrealloc (minisyms,
+                              (symcount + synth_count + 1) * sizeof (*symp));
+         symp = (asymbol **) minisyms + symcount;
          for (i = 0; i < synth_count; i++)
            *symp++ = synthsyms + i;
          *symp = 0;
          for (i = 0; i < synth_count; i++)
            *symp++ = synthsyms + i;
          *symp = 0;
-         minisyms = new_mini;
          symcount += synth_count;
        }
          symcount += synth_count;
        }
+      if (!dynamic && dyn_syms != NULL)
+       free (dyn_syms);
+    }
+
+  /* lto_slim_object is set to false when a bfd is loaded with a compiler
+     LTO plugin.  */
+  if (abfd->lto_slim_object)
+    {
+      report_plugin_err = FALSE;
+      non_fatal (_("%s: plugin needed to handle lto object"),
+                bfd_get_filename (abfd));
     }
 
   /* Discard the symbols we don't want to print.
     }
 
   /* Discard the symbols we don't want to print.
@@ -1071,7 +1227,55 @@ display_rel_file (bfd *abfd, bfd *archive_bfd)
   else
     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
 
   else
     print_size_symbols (abfd, dynamic, symsizes, symcount, archive_bfd);
 
+  if (synthsyms)
+    free (synthsyms);
   free (minisyms);
   free (minisyms);
+  free (symsizes);
+}
+
+/* Construct a formatting string for printing symbol values.  */
+
+static const char *
+get_print_format (void)
+{
+  const char * padding;
+  if (print_format == FORMAT_POSIX)
+    {
+      /* POSIX compatible output does not have any padding.  */
+      padding = "";
+    }
+  else if (print_width == 32)
+    {
+      padding ="08";
+    }
+  else /* print_width == 64 */
+    {
+      padding = "016";
+    }
+
+  const char * length = "l";
+  if (print_width == 64)
+    {
+#if BFD_HOST_64BIT_LONG
+      ;
+#elif BFD_HOST_64BIT_LONG_LONG
+#ifndef __MSVCRT__
+      length = "ll";
+#else
+      length = "I64";
+#endif
+#endif
+    }
+
+  const char * radix = NULL;
+  switch (print_radix)
+    {
+    case 8:  radix = "o"; break;
+    case 10: radix = "d"; break;
+    case 16: radix = "x"; break;
+    }
+
+  return concat ("%", padding, length, radix, NULL);
 }
 
 static void
 }
 
 static void
@@ -1092,6 +1296,8 @@ set_print_width (bfd *file)
       else
        print_width = 32;
     }
       else
        print_width = 32;
     }
+  free ((char *) print_format_string);
+  print_format_string = get_print_format ();
 }
 
 static void
 }
 
 static void
@@ -1141,6 +1347,8 @@ display_archive (bfd *file)
          bfd_close (last_arfile);
          lineno_cache_bfd = NULL;
          lineno_cache_rel_bfd = NULL;
          bfd_close (last_arfile);
          lineno_cache_bfd = NULL;
          lineno_cache_rel_bfd = NULL;
+         if (arfile == last_arfile)
+           return;
        }
       last_arfile = arfile;
     }
        }
       last_arfile = arfile;
     }
@@ -1163,13 +1371,17 @@ display_file (char *filename)
   if (get_file_size (filename) < 1)
     return FALSE;
 
   if (get_file_size (filename) < 1)
     return FALSE;
 
-  file = bfd_openr (filename, target);
+  file = bfd_openr (filename, target ? target : plugin_target);
   if (file == NULL)
     {
       bfd_nonfatal (filename);
       return FALSE;
     }
 
   if (file == NULL)
     {
       bfd_nonfatal (filename);
       return FALSE;
     }
 
+  /* If printing line numbers, decompress the debug sections.  */
+  if (line_numbers)
+    file->flags |= BFD_DECOMPRESS;
+
   if (bfd_check_format (file, bfd_archive))
     {
       display_archive (file);
   if (bfd_check_format (file, bfd_archive))
     {
       display_archive (file);
@@ -1209,14 +1421,14 @@ display_file (char *filename)
 /* Print the name of an object file given on the command line.  */
 
 static void
 /* Print the name of an object file given on the command line.  */
 
 static void
-print_object_filename_bsd (char *filename)
+print_object_filename_bsd (const char *filename)
 {
   if (filename_per_file && !filename_per_symbol)
     printf ("\n%s:\n", filename);
 }
 
 static void
 {
   if (filename_per_file && !filename_per_symbol)
     printf ("\n%s:\n", filename);
 }
 
 static void
-print_object_filename_sysv (char *filename)
+print_object_filename_sysv (const char *filename)
 {
   if (undefined_only)
     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
 {
   if (undefined_only)
     printf (_("\n\nUndefined symbols from %s:\n\n"), filename);
@@ -1231,7 +1443,7 @@ Name                  Value           Class        Type         Size
 }
 
 static void
 }
 
 static void
-print_object_filename_posix (char *filename)
+print_object_filename_posix (const char *filename)
 {
   if (filename_per_file && !filename_per_symbol)
     printf ("%s:\n", filename);
 {
   if (filename_per_file && !filename_per_symbol)
     printf ("%s:\n", filename);
@@ -1240,26 +1452,26 @@ print_object_filename_posix (char *filename)
 /* Print the name of an archive file given on the command line.  */
 
 static void
 /* Print the name of an archive file given on the command line.  */
 
 static void
-print_archive_filename_bsd (char *filename)
+print_archive_filename_bsd (const char *filename)
 {
   if (filename_per_file)
     printf ("\n%s:\n", filename);
 }
 
 static void
 {
   if (filename_per_file)
     printf ("\n%s:\n", filename);
 }
 
 static void
-print_archive_filename_sysv (char *filename ATTRIBUTE_UNUSED)
+print_archive_filename_sysv (const char *filename ATTRIBUTE_UNUSED)
 {
 }
 
 static void
 {
 }
 
 static void
-print_archive_filename_posix (char *filename ATTRIBUTE_UNUSED)
+print_archive_filename_posix (const char *filename ATTRIBUTE_UNUSED)
 {
 }
 \f
 /* Print the name of an archive member file.  */
 
 static void
 {
 }
 \f
 /* Print the name of an archive member file.  */
 
 static void
-print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
+print_archive_member_bsd (const char *archive ATTRIBUTE_UNUSED,
                          const char *filename)
 {
   if (!filename_per_symbol)
                          const char *filename)
 {
   if (!filename_per_symbol)
@@ -1267,7 +1479,7 @@ print_archive_member_bsd (char *archive ATTRIBUTE_UNUSED,
 }
 
 static void
 }
 
 static void
-print_archive_member_sysv (char *archive, const char *filename)
+print_archive_member_sysv (const char *archive, const char *filename)
 {
   if (undefined_only)
     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
 {
   if (undefined_only)
     printf (_("\n\nUndefined symbols from %s[%s]:\n\n"), archive, filename);
@@ -1282,7 +1494,7 @@ Name                  Value           Class        Type         Size
 }
 
 static void
 }
 
 static void
-print_archive_member_posix (char *archive, const char *filename)
+print_archive_member_posix (const char *archive, const char *filename)
 {
   if (!filename_per_symbol)
     printf ("%s[%s]:\n", archive, filename);
 {
   if (!filename_per_symbol)
     printf ("%s[%s]:\n", archive, filename);
@@ -1334,12 +1546,12 @@ print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
   switch (print_width)
     {
     case 32:
   switch (print_width)
     {
     case 32:
-      printf (value_format_32bit, val);
+      printf (print_format_string, (unsigned long) val);
       break;
 
     case 64:
       break;
 
     case 64:
-#if BFD_HOST_64BIT_LONG
-      printf (value_format_64bit, val);
+#if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
+      printf (print_format_string, val);
 #else
       /* We have a 64 bit value to print, but the host is only 32 bit.  */
       if (print_radix == 16)
 #else
       /* We have a 64 bit value to print, but the host is only 32 bit.  */
       if (print_radix == 16)
@@ -1390,7 +1602,6 @@ print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
        print_value (abfd, SYM_SIZE (info));
       else
        print_value (abfd, SYM_VALUE (info));
        print_value (abfd, SYM_SIZE (info));
       else
        print_value (abfd, SYM_VALUE (info));
-
       if (print_size && SYM_SIZE (info))
        {
          printf (" ");
       if (print_size && SYM_SIZE (info))
        {
          printf (" ");
@@ -1409,13 +1620,13 @@ print_symbol_info_bsd (struct extended_symbol_info *info, bfd *abfd)
       printf (desc_format, SYM_STAB_DESC (info));
       printf (" %5s", SYM_STAB_NAME (info));
     }
       printf (desc_format, SYM_STAB_DESC (info));
       printf (" %5s", SYM_STAB_NAME (info));
     }
-  print_symname (" %s", SYM_NAME (info), abfd);
+  print_symname (" %s", info, NULL, abfd);
 }
 
 static void
 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
 {
 }
 
 static void
 print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
 {
-  print_symname ("%-20s|", SYM_NAME (info), abfd);
+  print_symname ("%-20s|", info, NULL, abfd);
 
   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
     {
 
   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
     {
@@ -1441,7 +1652,10 @@ print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
       /* Type, Size, Line, Section */
       if (info->elfinfo)
        printf ("%18s|",
       /* Type, Size, Line, Section */
       if (info->elfinfo)
        printf ("%18s|",
-               get_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
+               get_elf_symbol_type (ELF_ST_TYPE (info->elfinfo->internal_elf_sym.st_info)));
+      else if (info->coffinfo)
+       printf ("%18s|",
+               get_coff_symbol_type (&info->coffinfo->native->u.syment));
       else
        printf ("                  |");
 
       else
        printf ("                  |");
 
@@ -1457,6 +1671,8 @@ print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
 
       if (info->elfinfo)
        printf("|     |%s", info->elfinfo->symbol.section->name);
 
       if (info->elfinfo)
        printf("|     |%s", info->elfinfo->symbol.section->name);
+      else if (info->coffinfo)
+       printf("|     |%s", info->coffinfo->symbol.section->name);
       else
        printf("|     |");
     }
       else
        printf("|     |");
     }
@@ -1465,7 +1681,7 @@ print_symbol_info_sysv (struct extended_symbol_info *info, bfd *abfd)
 static void
 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
 {
 static void
 print_symbol_info_posix (struct extended_symbol_info *info, bfd *abfd)
 {
-  print_symname ("%s ", SYM_NAME (info), abfd);
+  print_symname ("%s ", info, NULL, abfd);
   printf ("%c ", SYM_TYPE (info));
 
   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
   printf ("%c ", SYM_TYPE (info));
 
   if (bfd_is_undefined_symclass (SYM_TYPE (info)))
@@ -1497,12 +1713,17 @@ main (int argc, char **argv)
 
   program_name = *argv;
   xmalloc_set_program_name (program_name);
 
   program_name = *argv;
   xmalloc_set_program_name (program_name);
+  bfd_set_error_program_name (program_name);
+#if BFD_SUPPORTS_PLUGINS
+  bfd_plugin_set_program_name (program_name);
+#endif
 
   START_PROGRESS (program_name, 0);
 
   expandargv (&argc, &argv);
 
 
   START_PROGRESS (program_name, 0);
 
   expandargv (&argc, &argv);
 
-  bfd_init ();
+  if (bfd_init () != BFD_INIT_MAGIC)
+    fatal (_("fatal error: libbfd ABI mismatch"));
   set_default_bfd_target ();
 
   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
   set_default_bfd_target ();
 
   while ((c = getopt_long (argc, argv, "aABCDef:gHhlnopPrSst:uvVvX:",
@@ -1534,6 +1755,12 @@ main (int argc, char **argv)
              cplus_demangle_set_style (style);
            }
          break;
              cplus_demangle_set_style (style);
            }
          break;
+       case OPTION_RECURSE_LIMIT:
+         demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
+         break;
+       case OPTION_NO_RECURSE_LIMIT:
+         demangle_flags |= DMGL_NO_RECURSE_LIMIT;
+         break;
        case 'D':
          dynamic = 1;
          break;
        case 'D':
          dynamic = 1;
          break;
@@ -1554,10 +1781,19 @@ main (int argc, char **argv)
          break;
        case 'n':
        case 'v':
          break;
        case 'n':
        case 'v':
+         no_sort = 0;
          sort_numerically = 1;
          sort_numerically = 1;
+         sort_by_size = 0;
          break;
        case 'p':
          no_sort = 1;
          break;
        case 'p':
          no_sort = 1;
+         sort_numerically = 0;
+         sort_by_size = 0;
+         break;
+       case OPTION_SIZE_SORT:
+         no_sort = 0;
+         sort_numerically = 0;
+         sort_by_size = 1;
          break;
        case 'P':
          set_output_format ("posix");
          break;
        case 'P':
          set_output_format ("posix");
@@ -1596,6 +1832,14 @@ main (int argc, char **argv)
          target = optarg;
          break;
 
          target = optarg;
          break;
 
+       case OPTION_PLUGIN:     /* --plugin */
+#if BFD_SUPPORTS_PLUGINS
+         bfd_plugin_set_plugin (optarg);
+#else
+         fatal (_("sorry - this program has been built without plugin support\n"));
+#endif
+         break;
+
        case 0:         /* A long option that just sets a flag.  */
          break;
 
        case 0:         /* A long option that just sets a flag.  */
          break;
 
@@ -1633,15 +1877,6 @@ main (int argc, char **argv)
 
   END_PROGRESS (program_name);
 
 
   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;
 }
   exit (retval);
   return retval;
 }
GDB Binutils - Deliverables
This page took 0.040971 seconds and 4 git commands to generate.