Subversion Repositories openrisc_2011-10-31

/* 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, 2008, 2009

   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

   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,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   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., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"

#include "progress.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"

#include "bucomm.h"

#include "plugin.h"

/* When sorting by size, we use this structure to hold the size and a

   pointer to the minisymbol.  */

struct size_sym

{

  const void *minisym;

  bfd_vma size;

};

/* When fetching relocs, we use this structure to pass information to

   get_relocs.  */

struct get_relocs_info

{

  asection **secs;

  arelent ***relocs;

  long *relcount;

  asymbol **syms;

};

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 (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) (char *);

    /* Print the name of an archive file given on the command line.  */

    void (*print_archive_filename) (char *);

    /* Print the name of an archive member file.  */

    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) (bfd *, bfd *);

    /* Print a line of information about a symbol.  */

    void (*print_symbol_info) (struct extended_symbol_info *, bfd *);

  };

static struct output_fns formats[] =

{

  {print_object_filename_bsd,

   print_archive_filename_bsd,

   print_archive_member_bsd,

   print_symbol_filename_bsd,

   print_symbol_info_bsd},

  {print_object_filename_sysv,

   print_archive_filename_sysv,

   print_archive_member_sysv,

   print_symbol_filename_sysv,

   print_symbol_info_sysv},

  {print_object_filename_posix,

   print_archive_filename_posix,

   print_archive_member_posix,

   print_symbol_filename_posix,

   print_symbol_info_posix}

};

/* Indices in `formats'.  */

#define FORMAT_BSD 0

#define FORMAT_SYSV 1

#define FORMAT_POSIX 2

#define FORMAT_DEFAULT FORMAT_BSD

/* 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 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.  */

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";

#if BFD_HOST_64BIT_LONG

static char value_format_64bit[] = "%016lx";

#elif BFD_HOST_64BIT_LONG_LONG

static char value_format_64bit[] = "%016llx";

#endif

static int print_width = 0;

static int print_radix = 16;

/* Print formats for printing stab info.  */

static char other_format[] = "%02x";

static char desc_format[] = "%04x";

static char *target = NULL;

/* 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 201

static struct option long_options[] =

{

  {"debug-syms", no_argument, &print_debug_syms, 1},

  {"demangle", optional_argument, 0, 'C'},

  {"dynamic", no_argument, &dynamic, 1},

  {"extern-only", no_argument, &external_only, 1},

  {"format", required_argument, 0, 'f'},

  {"help", no_argument, 0, 'h'},

  {"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},

  {"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},

  {"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},

  {"version", no_argument, &show_version, 1},

  {0, no_argument, 0, 0}

};

/* Some error-reporting functions.  */

static void

usage (FILE *stream, int status)

{

  fprintf (stream, _("Usage: %s [option(s)] [file(s)]\n"), program_name);

  fprintf (stream, _(" List symbols in [file(s)] (a.out by default).\n"));

  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"));

#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\

      --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 (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 (char *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;

#if BFD_HOST_64BIT_LONG

      value_format_64bit[5] = *radix;

#elif BFD_HOST_64BIT_LONG_LONG

      value_format_64bit[6] = *radix;

#endif

      other_format[3] = desc_format[3] = *radix;

      break;

    default:

      fatal (_("%s: invalid radix"), radix);

    }

}

static void

set_output_format (char *f)

{

  int i;

  switch (*f)

    {

    case 'b':

    case 'B':

      i = FORMAT_BSD;

      break;

    case 'p':

    case 'P':

      i = FORMAT_POSIX;

      break;

    case 's':

    case 'S':

      i = FORMAT_SYSV;

      break;

    default:

      fatal (_("%s: invalid output format"), f);

    }

  format = &formats[i];

}

static const char *

get_symbol_type (unsigned int type)

{

  static char buff [32];

  switch (type)

    {

    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;

    }

}

/* Print symbol name NAME, read from ABFD, with printf format FORMAT,

   demangling it if requested.  */

static void

print_symname (const char *format, const char *name, bfd *abfd)

{

  if (do_demangle && *name)

    {

      char *res = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);

      if (res != NULL)

        {

          printf (format, res);

          free (res);

          return;

        }

    }

  printf (format, name);

}

static void

print_symdef_entry (bfd *abfd)

{

  symindex idx = BFD_NO_MORE_SYMBOLS;

  carsym *thesym;

  bfd_boolean everprinted = FALSE;

  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));

        }

    }

}

/* 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_byte *from, *fromend, *to;

  asymbol *store;

  store = bfd_make_empty_symbol (abfd);

  if (store == NULL)

    bfd_fatal (bfd_get_filename (abfd));

  from = (bfd_byte *) minisyms;

  fromend = from + symcount * size;

  to = (bfd_byte *) minisyms;

  for (; from < fromend; from += size)

    {

      int keep = 0;

      asymbol *sym;

      PROGRESS (1);

      sym = bfd_minisymbol_to_symbol (abfd, dynamic, (const void *) from, store);

      if (sym == NULL)

        bfd_fatal (bfd_get_filename (abfd));

      if (undefined_only)

        keep = bfd_is_und_section (sym->section);

      else if (external_only)

        keep = ((sym->flags & BSF_GLOBAL) != 0

                || (sym->flags & BSF_WEAK) != 0

                || bfd_is_und_section (sym->section)

                || bfd_is_com_section (sym->section));

      else

        keep = 1;

      if (keep

          && ! print_debug_syms

          && (sym->flags & BSF_DEBUGGING) != 0)

        keep = 0;

      if (keep

          && sort_by_size

          && (bfd_is_abs_section (sym->section)

              || bfd_is_und_section (sym->section)))

        keep = 0;

      if (keep

          && defined_only)

        {

          if (bfd_is_und_section (sym->section))

            keep = 0;

        }

      if (keep

          && bfd_is_target_special_symbol (abfd, sym)

          && ! allow_special_symbols)

        keep = 0;

      if (keep)

        {

          if (to != from)

            memcpy (to, from, size);

          to += size;

        }

    }

  return (to - (bfd_byte *) minisyms) / size;

}

/* These globals are used to pass information into the sorting

   routines.  */

static bfd *sort_bfd;

static bfd_boolean sort_dynamic;

static asymbol *sort_x;

static asymbol *sort_y;

/* Symbol-sorting predicates */

#define valueof(x) ((x)->section->vma + (x)->value)

/* Numeric sorts.  Undefined symbols are always considered "less than"

   defined symbols with zero values.  Common symbols are not treated

   specially -- i.e., their sizes are used as their "values".  */

static int

non_numeric_forward (const void *P_x, const void *P_y)

{

  asymbol *x, *y;

  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);

  if (x == NULL || y == NULL)

    bfd_fatal (bfd_get_filename (sort_bfd));

  xn = bfd_asymbol_name (x);

  yn = bfd_asymbol_name (y);

  if (yn == NULL)

    return xn != NULL;

  if (xn == NULL)

    return -1;

#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

non_numeric_reverse (const void *x, const void *y)

{

  return - non_numeric_forward (x, y);

}

static int

numeric_forward (const void *P_x, const void *P_y)

{

  asymbol *x, *y;

  asection *xs, *ys;

  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);

  y =  bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);

  if (x == NULL || y == NULL)

    bfd_fatal (bfd_get_filename (sort_bfd));

  xs = bfd_get_section (x);

  ys = bfd_get_section (y);

  if (bfd_is_und_section (xs))

    {

      if (! bfd_is_und_section (ys))

        return -1;

    }

  else if (bfd_is_und_section (ys))

    return 1;

  else if (valueof (x) != valueof (y))

    return valueof (x) < valueof (y) ? -1 : 1;

  return non_numeric_forward (P_x, P_y);

}

static int

numeric_reverse (const void *x, const void *y)

{

  return - numeric_forward (x, y);

}

static int (*(sorters[2][2])) (const void *, const void *) =

{

  { non_numeric_forward, non_numeric_reverse },

  { numeric_forward, numeric_reverse }

};

/* This sort routine is used by sort_symbols_by_size.  It is similar

   to numeric_forward, but when symbols have the same value it sorts

   by section VMA.  This simplifies the sort_symbols_by_size code

   which handles symbols at the end of sections.  Also, this routine

   tries to sort file names before other symbols with the same value.

   That will make the file name have a zero size, which will make

   sort_symbols_by_size choose the non file name symbol, leading to

   more meaningful output.  For similar reasons, this code sorts

   gnu_compiled_* and gcc2_compiled before other symbols with the same

   value.  */

static int

size_forward1 (const void *P_x, const void *P_y)

{

  asymbol *x, *y;

  asection *xs, *ys;

  const char *xn, *yn;

  size_t xnl, ynl;

  int xf, yf;

  x = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_x, sort_x);

  y = bfd_minisymbol_to_symbol (sort_bfd, sort_dynamic, P_y, sort_y);

  if (x == NULL || y == NULL)

    bfd_fatal (bfd_get_filename (sort_bfd));

  xs = bfd_get_section (x);

  ys = bfd_get_section (y);

  if (bfd_is_und_section (xs))

    abort ();

  if (bfd_is_und_section (ys))

    abort ();

  if (valueof (x) != valueof (y))

    return valueof (x) < valueof (y) ? -1 : 1;

  if (xs->vma != ys->vma)

    return xs->vma < ys->vma ? -1 : 1;

  xn = bfd_asymbol_name (x);

  yn = bfd_asymbol_name (y);

  xnl = strlen (xn);

  ynl = strlen (yn);

  /* The symbols gnu_compiled and gcc2_compiled convey even less

     information than the file name, so sort them out first.  */

  xf = (strstr (xn, "gnu_compiled") != NULL

        || strstr (xn, "gcc2_compiled") != NULL);

  yf = (strstr (yn, "gnu_compiled") != NULL

        || strstr (yn, "gcc2_compiled") != NULL);

  if (xf && ! yf)

    return -1;

  if (! xf && yf)

    return 1;

  /* We use a heuristic for the file name.  It may not work on non

     Unix systems, but it doesn't really matter; the only difference

     is precisely which symbol names get printed.  */

#define file_symbol(s, sn, snl)                 \

  (((s)->flags & BSF_FILE) != 0                  \

   || ((sn)[(snl) - 2] == '.'                   \

       && ((sn)[(snl) - 1] == 'o'               \

           || (sn)[(snl) - 1] == 'a')))

  xf = file_symbol (x, xn, xnl);

  yf = file_symbol (y, yn, ynl);

  if (xf && ! yf)

    return -1;

  if (! xf && yf)

    return 1;

  return non_numeric_forward (P_x, P_y);

}

/* This sort routine is used by sort_symbols_by_size.  It is sorting

   an array of size_sym structures into size order.  */

static int

size_forward2 (const void *P_x, const void *P_y)

{