projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix illegal memory access when parsing corrupt DWARF information.
[deliverable/binutils-gdb.git] / binutils / nm.c
diff --git a/binutils/nm.c b/binutils/nm.c
index 5d4300549691eab4980be9f351e0eab98824d77c..e46fffc796f772141e9ad8ea4515be2dc36d49cd 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-2018 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,6 +64,7 @@ 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.  */
 };
 #define SYM_NAME(sym)        (sym->sinfo->name)
   /* FIXME: We should add more fields for Type, Line, Section.  */
 };
 #define SYM_NAME(sym)        (sym->sinfo->name)
@@ -149,10 +157,10 @@ 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.  */
 
 /* 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.  */
 
 /* 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.  */
@@ -160,7 +168,15 @@ 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";
 
 /* Print formats for printing a symbol value.  */
 static char value_format_32bit[] = "%08lx";
+#if BFD_HOST_64BIT_LONG
 static char value_format_64bit[] = "%016lx";
 static char value_format_64bit[] = "%016lx";
+#elif BFD_HOST_64BIT_LONG_LONG
+#ifndef __MSVCRT__
+static char value_format_64bit[] = "%016llx";
+#else
+static char value_format_64bit[] = "%016I64x";
+#endif
+#endif
 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 +184,19 @@ 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;
 
 #define OPTION_TARGET 200
 
 /* Used to cache the line numbers for a BFD.  */
 static bfd *lineno_cache_bfd;
 static bfd *lineno_cache_rel_bfd;
 
 #define OPTION_TARGET 200
+#define OPTION_PLUGIN (OPTION_TARGET + 1)
+#define OPTION_SIZE_SORT (OPTION_PLUGIN + 1)
 
 static struct option long_options[] =
 {
 
 static struct option long_options[] =
 {
@@ -186,28 +209,29 @@ 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-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'},
   {"reverse-sort", no_argument, &reverse_sort, 1},
   {"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},
+  {"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);
@@ -233,7 +257,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 +271,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\
@@ -269,7 +299,15 @@ set_print_radix (char *radix)
       else
        print_radix = 8;
       value_format_32bit[4] = *radix;
       else
        print_radix = 8;
       value_format_32bit[4] = *radix;
+#if BFD_HOST_64BIT_LONG
       value_format_64bit[5] = *radix;
       value_format_64bit[5] = *radix;
+#elif BFD_HOST_64BIT_LONG_LONG
+#ifndef __MSVCRT__
+      value_format_64bit[6] = *radix;
+#else
+      value_format_64bit[7] = *radix;
+#endif
+#endif
       other_format[3] = desc_format[3] = *radix;
       break;
     default:
       other_format[3] = desc_format[3] = *radix;
       break;
     default:
@@ -303,9 +341,10 @@ set_output_format (char *f)
 }
 \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 +355,69 @@ 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, const char *name, bfd *abfd)
 {
   if (do_demangle && *name)
     {
 {
   if (do_demangle && *name)
     {
-      char *res = demangle (abfd, name);
+      char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
 
 
-      printf (format, res);
-      free (res);
-      return;
+      if (res != NULL)
+       {
+         printf (form, res);
+         free (res);
+         return;
+       }
     }
 
     }
 
-  printf (format, name);
+  printf (form, name);
 }
 
 static void
 }
 
 static void
@@ -378,7 +453,7 @@ print_symdef_entry (bfd *abfd)
    Return the number of symbols to be printed.  */
 
 static long
    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 +474,23 @@ 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)
+       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 +521,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;
        }
     }
@@ -601,7 +685,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 +724,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 +737,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 +751,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 +767,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)
@@ -693,9 +778,14 @@ sort_symbols_by_size (bfd *abfd, bfd_boolean dynamic, void *minisyms,
 
       sec = bfd_get_section (sym);
 
 
       sec = bfd_get_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
        {
        sz = sym->value;
       else
        {
@@ -753,7 +843,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 +858,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 +871,39 @@ 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, &hidden);
+
+      if (bfd_is_und_section (bfd_get_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,7 +926,7 @@ 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));
          symcount = bfd_canonicalize_symtab (abfd, syms);
          if (symcount < 0)
            bfd_fatal (bfd_get_filename (abfd));
@@ -841,19 +959,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;
            }
 
@@ -903,12 +1021,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 +1037,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 +1077,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 +1099,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 +1112,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,33 +1130,33 @@ 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)
       synth_count = bfd_get_synthetic_symtab (abfd, static_count, static_syms,
                                              dyn_count, dyn_syms, &synthsyms);
       if (synth_count > 0)
@@ -1031,7 +1166,7 @@ display_rel_file (bfd *abfd, bfd *archive_bfd)
          long i;
 
          new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
          long i;
 
          new_mini = xmalloc ((symcount + synth_count + 1) * sizeof (*symp));
-         symp = new_mini;
+         symp = (asymbol **) new_mini;
          memcpy (symp, minisyms, symcount * sizeof (*symp));
          symp += symcount;
          for (i = 0; i < synth_count; i++)
          memcpy (symp, minisyms, symcount * sizeof (*symp));
          symp += symcount;
          for (i = 0; i < synth_count; i++)
@@ -1071,7 +1206,10 @@ 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);
 }
 
 static void
 }
 
 static void
@@ -1141,6 +1279,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 +1303,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);
@@ -1338,7 +1482,7 @@ print_value (bfd *abfd ATTRIBUTE_UNUSED, bfd_vma val)
       break;
 
     case 64:
       break;
 
     case 64:
-#if BFD_HOST_64BIT_LONG
+#if BFD_HOST_64BIT_LONG || BFD_HOST_64BIT_LONG_LONG
       printf (value_format_64bit, val);
 #else
       /* We have a 64 bit value to print, but the host is only 32 bit.  */
       printf (value_format_64bit, val);
 #else
       /* We have a 64 bit value to print, but the host is only 32 bit.  */
@@ -1390,7 +1534,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 (" ");
@@ -1441,7 +1584,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 +1603,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("|     |");
     }
@@ -1497,6 +1645,10 @@ 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);
 
 
   START_PROGRESS (program_name, 0);
 
@@ -1554,10 +1706,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 +1757,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 +1802,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.048587 seconds and 4 git commands to generate.