OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [binutils/] [addr2line.c] - Diff between revs 156 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 156 Rev 816
/* addr2line.c -- convert addresses to line number and function name
/* addr2line.c -- convert addresses to line number and function name
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>
   Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>
 
 
   This file is part of GNU Binutils.
   This file is part of GNU Binutils.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
   any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   MA 02110-1301, USA.  */
 
 
 
 
/* Derived from objdump.c and nm.c by Ulrich.Lauther@mchp.siemens.de
/* Derived from objdump.c and nm.c by Ulrich.Lauther@mchp.siemens.de
 
 
   Usage:
   Usage:
   addr2line [options] addr addr ...
   addr2line [options] addr addr ...
   or
   or
   addr2line [options]
   addr2line [options]
 
 
   both forms write results to stdout, the second form reads addresses
   both forms write results to stdout, the second form reads addresses
   to be converted from stdin.  */
   to be converted from stdin.  */
 
 
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "getopt.h"
#include "getopt.h"
#include "libiberty.h"
#include "libiberty.h"
#include "demangle.h"
#include "demangle.h"
#include "bucomm.h"
#include "bucomm.h"
 
 
static bfd_boolean unwind_inlines;      /* -i, unwind inlined functions. */
static bfd_boolean unwind_inlines;      /* -i, unwind inlined functions. */
static bfd_boolean with_functions;      /* -f, show function names.  */
static bfd_boolean with_functions;      /* -f, show function names.  */
static bfd_boolean do_demangle;         /* -C, demangle names.  */
static bfd_boolean do_demangle;         /* -C, demangle names.  */
static bfd_boolean base_names;          /* -s, strip directory names.  */
static bfd_boolean base_names;          /* -s, strip directory names.  */
 
 
static int naddr;               /* Number of addresses to process.  */
static int naddr;               /* Number of addresses to process.  */
static char **addr;             /* Hex addresses to process.  */
static char **addr;             /* Hex addresses to process.  */
 
 
static asymbol **syms;          /* Symbol table.  */
static asymbol **syms;          /* Symbol table.  */
 
 
static struct option long_options[] =
static struct option long_options[] =
{
{
  {"basenames", no_argument, NULL, 's'},
  {"basenames", no_argument, NULL, 's'},
  {"demangle", optional_argument, NULL, 'C'},
  {"demangle", optional_argument, NULL, 'C'},
  {"exe", required_argument, NULL, 'e'},
  {"exe", required_argument, NULL, 'e'},
  {"functions", no_argument, NULL, 'f'},
  {"functions", no_argument, NULL, 'f'},
  {"inlines", no_argument, NULL, 'i'},
  {"inlines", no_argument, NULL, 'i'},
  {"section", required_argument, NULL, 'j'},
  {"section", required_argument, NULL, 'j'},
  {"target", required_argument, NULL, 'b'},
  {"target", required_argument, NULL, 'b'},
  {"help", no_argument, NULL, 'H'},
  {"help", no_argument, NULL, 'H'},
  {"version", no_argument, NULL, 'V'},
  {"version", no_argument, NULL, 'V'},
  {0, no_argument, 0, 0}
  {0, no_argument, 0, 0}
};
};
 
 
static void usage (FILE *, int);
static void usage (FILE *, int);
static void slurp_symtab (bfd *);
static void slurp_symtab (bfd *);
static void find_address_in_section (bfd *, asection *, void *);
static void find_address_in_section (bfd *, asection *, void *);
static void find_offset_in_section (bfd *, asection *);
static void find_offset_in_section (bfd *, asection *);
static void translate_addresses (bfd *, asection *);
static void translate_addresses (bfd *, asection *);


/* Print a usage message to STREAM and exit with STATUS.  */
/* Print a usage message to STREAM and exit with STATUS.  */
 
 
static void
static void
usage (FILE *stream, int status)
usage (FILE *stream, int status)
{
{
  fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
  fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
  fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
  fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
  fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
  fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
  fprintf (stream, _(" The options are:\n\
  fprintf (stream, _(" The options are:\n\
  @<file>                Read options from <file>\n\
  @<file>                Read options from <file>\n\
  -b --target=<bfdname>  Set the binary file format\n\
  -b --target=<bfdname>  Set the binary file format\n\
  -e --exe=<executable>  Set the input file name (default is a.out)\n\
  -e --exe=<executable>  Set the input file name (default is a.out)\n\
  -i --inlines           Unwind inlined functions\n\
  -i --inlines           Unwind inlined functions\n\
  -j --section=<name>    Read section-relative offsets instead of addresses\n\
  -j --section=<name>    Read section-relative offsets instead of addresses\n\
  -s --basenames         Strip directory names\n\
  -s --basenames         Strip directory names\n\
  -f --functions         Show function names\n\
  -f --functions         Show function names\n\
  -C --demangle[=style]  Demangle function names\n\
  -C --demangle[=style]  Demangle function names\n\
  -h --help              Display this information\n\
  -h --help              Display this information\n\
  -v --version           Display the program's version\n\
  -v --version           Display the program's version\n\
\n"));
\n"));
 
 
  list_supported_targets (program_name, stream);
  list_supported_targets (program_name, stream);
  if (REPORT_BUGS_TO[0] && status == 0)
  if (REPORT_BUGS_TO[0] && status == 0)
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  exit (status);
  exit (status);
}
}


/* Read in the symbol table.  */
/* Read in the symbol table.  */
 
 
static void
static void
slurp_symtab (bfd *abfd)
slurp_symtab (bfd *abfd)
{
{
  long symcount;
  long symcount;
  unsigned int size;
  unsigned int size;
 
 
  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
    return;
    return;
 
 
  symcount = bfd_read_minisymbols (abfd, FALSE, (void *) &syms, &size);
  symcount = bfd_read_minisymbols (abfd, FALSE, (void *) &syms, &size);
  if (symcount == 0)
  if (symcount == 0)
    symcount = bfd_read_minisymbols (abfd, TRUE /* dynamic */, (void *) &syms, &size);
    symcount = bfd_read_minisymbols (abfd, TRUE /* dynamic */, (void *) &syms, &size);
 
 
  if (symcount < 0)
  if (symcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
    bfd_fatal (bfd_get_filename (abfd));
}
}


/* These global variables are used to pass information between
/* These global variables are used to pass information between
   translate_addresses and find_address_in_section.  */
   translate_addresses and find_address_in_section.  */
 
 
static bfd_vma pc;
static bfd_vma pc;
static const char *filename;
static const char *filename;
static const char *functionname;
static const char *functionname;
static unsigned int line;
static unsigned int line;
static bfd_boolean found;
static bfd_boolean found;
 
 
/* Look for an address in a section.  This is called via
/* Look for an address in a section.  This is called via
   bfd_map_over_sections.  */
   bfd_map_over_sections.  */
 
 
static void
static void
find_address_in_section (bfd *abfd, asection *section,
find_address_in_section (bfd *abfd, asection *section,
                         void *data ATTRIBUTE_UNUSED)
                         void *data ATTRIBUTE_UNUSED)
{
{
  bfd_vma vma;
  bfd_vma vma;
  bfd_size_type size;
  bfd_size_type size;
 
 
  if (found)
  if (found)
    return;
    return;
 
 
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;
    return;
 
 
  vma = bfd_get_section_vma (abfd, section);
  vma = bfd_get_section_vma (abfd, section);
  if (pc < vma)
  if (pc < vma)
    return;
    return;
 
 
  size = bfd_get_section_size (section);
  size = bfd_get_section_size (section);
  if (pc >= vma + size)
  if (pc >= vma + size)
    return;
    return;
 
 
  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
                                 &filename, &functionname, &line);
                                 &filename, &functionname, &line);
}
}
 
 
/* Look for an offset in a section.  This is directly called.  */
/* Look for an offset in a section.  This is directly called.  */
 
 
static void
static void
find_offset_in_section (bfd *abfd, asection *section)
find_offset_in_section (bfd *abfd, asection *section)
{
{
  bfd_size_type size;
  bfd_size_type size;
 
 
  if (found)
  if (found)
    return;
    return;
 
 
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;
    return;
 
 
  size = bfd_get_section_size (section);
  size = bfd_get_section_size (section);
  if (pc >= size)
  if (pc >= size)
    return;
    return;
 
 
  found = bfd_find_nearest_line (abfd, section, syms, pc,
  found = bfd_find_nearest_line (abfd, section, syms, pc,
                                 &filename, &functionname, &line);
                                 &filename, &functionname, &line);
}
}
 
 
/* Read hexadecimal addresses from stdin, translate into
/* Read hexadecimal addresses from stdin, translate into
   file_name:line_number and optionally function name.  */
   file_name:line_number and optionally function name.  */
 
 
static void
static void
translate_addresses (bfd *abfd, asection *section)
translate_addresses (bfd *abfd, asection *section)
{
{
  int read_stdin = (naddr == 0);
  int read_stdin = (naddr == 0);
 
 
  for (;;)
  for (;;)
    {
    {
      if (read_stdin)
      if (read_stdin)
        {
        {
          char addr_hex[100];
          char addr_hex[100];
 
 
          if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
          if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
            break;
            break;
          pc = bfd_scan_vma (addr_hex, NULL, 16);
          pc = bfd_scan_vma (addr_hex, NULL, 16);
        }
        }
      else
      else
        {
        {
          if (naddr <= 0)
          if (naddr <= 0)
            break;
            break;
          --naddr;
          --naddr;
          pc = bfd_scan_vma (*addr++, NULL, 16);
          pc = bfd_scan_vma (*addr++, NULL, 16);
        }
        }
 
 
      found = FALSE;
      found = FALSE;
      if (section)
      if (section)
        find_offset_in_section (abfd, section);
        find_offset_in_section (abfd, section);
      else
      else
        bfd_map_over_sections (abfd, find_address_in_section, NULL);
        bfd_map_over_sections (abfd, find_address_in_section, NULL);
 
 
      if (! found)
      if (! found)
        {
        {
          if (with_functions)
          if (with_functions)
            printf ("??\n");
            printf ("??\n");
          printf ("??:0\n");
          printf ("??:0\n");
        }
        }
      else
      else
        {
        {
          do {
          do {
            if (with_functions)
            if (with_functions)
              {
              {
                const char *name;
                const char *name;
                char *alloc = NULL;
                char *alloc = NULL;
 
 
                name = functionname;
                name = functionname;
                if (name == NULL || *name == '\0')
                if (name == NULL || *name == '\0')
                  name = "??";
                  name = "??";
                else if (do_demangle)
                else if (do_demangle)
                  {
                  {
                    alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
                    alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
                    if (alloc != NULL)
                    if (alloc != NULL)
                      name = alloc;
                      name = alloc;
                  }
                  }
 
 
                printf ("%s\n", name);
                printf ("%s\n", name);
 
 
                if (alloc != NULL)
                if (alloc != NULL)
                  free (alloc);
                  free (alloc);
              }
              }
 
 
            if (base_names && filename != NULL)
            if (base_names && filename != NULL)
              {
              {
                char *h;
                char *h;
 
 
                h = strrchr (filename, '/');
                h = strrchr (filename, '/');
                if (h != NULL)
                if (h != NULL)
                  filename = h + 1;
                  filename = h + 1;
              }
              }
 
 
            printf ("%s:%u\n", filename ? filename : "??", line);
            printf ("%s:%u\n", filename ? filename : "??", line);
            if (!unwind_inlines)
            if (!unwind_inlines)
              found = FALSE;
              found = FALSE;
            else
            else
              found = bfd_find_inliner_info (abfd, &filename, &functionname, &line);
              found = bfd_find_inliner_info (abfd, &filename, &functionname, &line);
          } while (found);
          } while (found);
 
 
        }
        }
 
 
      /* fflush() is essential for using this command as a server
      /* fflush() is essential for using this command as a server
         child process that reads addresses from a pipe and responds
         child process that reads addresses from a pipe and responds
         with line number information, processing one address at a
         with line number information, processing one address at a
         time.  */
         time.  */
      fflush (stdout);
      fflush (stdout);
    }
    }
}
}
 
 
/* Process a file.  Returns an exit value for main().  */
/* Process a file.  Returns an exit value for main().  */
 
 
static int
static int
process_file (const char *file_name, const char *section_name,
process_file (const char *file_name, const char *section_name,
              const char *target)
              const char *target)
{
{
  bfd *abfd;
  bfd *abfd;
  asection *section;
  asection *section;
  char **matching;
  char **matching;
 
 
  if (get_file_size (file_name) < 1)
  if (get_file_size (file_name) < 1)
    return 1;
    return 1;
 
 
  abfd = bfd_openr (file_name, target);
  abfd = bfd_openr (file_name, target);
  if (abfd == NULL)
  if (abfd == NULL)
    bfd_fatal (file_name);
    bfd_fatal (file_name);
 
 
  if (bfd_check_format (abfd, bfd_archive))
  if (bfd_check_format (abfd, bfd_archive))
    fatal (_("%s: cannot get addresses from archive"), file_name);
    fatal (_("%s: cannot get addresses from archive"), file_name);
 
 
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
    {
    {
      bfd_nonfatal (bfd_get_filename (abfd));
      bfd_nonfatal (bfd_get_filename (abfd));
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
        {
        {
          list_matching_formats (matching);
          list_matching_formats (matching);
          free (matching);
          free (matching);
        }
        }
      xexit (1);
      xexit (1);
    }
    }
 
 
  if (section_name != NULL)
  if (section_name != NULL)
    {
    {
      section = bfd_get_section_by_name (abfd, section_name);
      section = bfd_get_section_by_name (abfd, section_name);
      if (section == NULL)
      if (section == NULL)
        fatal (_("%s: cannot find section %s"), file_name, section_name);
        fatal (_("%s: cannot find section %s"), file_name, section_name);
    }
    }
  else
  else
    section = NULL;
    section = NULL;
 
 
  slurp_symtab (abfd);
  slurp_symtab (abfd);
 
 
  translate_addresses (abfd, section);
  translate_addresses (abfd, section);
 
 
  if (syms != NULL)
  if (syms != NULL)
    {
    {
      free (syms);
      free (syms);
      syms = NULL;
      syms = NULL;
    }
    }
 
 
  bfd_close (abfd);
  bfd_close (abfd);
 
 
  return 0;
  return 0;
}
}


int
int
main (int argc, char **argv)
main (int argc, char **argv)
{
{
  const char *file_name;
  const char *file_name;
  const char *section_name;
  const char *section_name;
  char *target;
  char *target;
  int c;
  int c;
 
 
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
  setlocale (LC_MESSAGES, "");
  setlocale (LC_MESSAGES, "");
#endif
#endif
#if defined (HAVE_SETLOCALE)
#if defined (HAVE_SETLOCALE)
  setlocale (LC_CTYPE, "");
  setlocale (LC_CTYPE, "");
#endif
#endif
  bindtextdomain (PACKAGE, LOCALEDIR);
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);
  textdomain (PACKAGE);
 
 
  program_name = *argv;
  program_name = *argv;
  xmalloc_set_program_name (program_name);
  xmalloc_set_program_name (program_name);
 
 
  expandargv (&argc, &argv);
  expandargv (&argc, &argv);
 
 
  bfd_init ();
  bfd_init ();
  set_default_bfd_target ();
  set_default_bfd_target ();
 
 
  file_name = NULL;
  file_name = NULL;
  section_name = NULL;
  section_name = NULL;
  target = NULL;
  target = NULL;
  while ((c = getopt_long (argc, argv, "b:Ce:sfHhij:Vv", long_options, (int *) 0))
  while ((c = getopt_long (argc, argv, "b:Ce:sfHhij:Vv", long_options, (int *) 0))
         != EOF)
         != EOF)
    {
    {
      switch (c)
      switch (c)
        {
        {
        case 0:
        case 0:
          break;                /* We've been given a long option.  */
          break;                /* We've been given a long option.  */
        case 'b':
        case 'b':
          target = optarg;
          target = optarg;
          break;
          break;
        case 'C':
        case 'C':
          do_demangle = TRUE;
          do_demangle = TRUE;
          if (optarg != NULL)
          if (optarg != NULL)
            {
            {
              enum demangling_styles style;
              enum demangling_styles style;
 
 
              style = cplus_demangle_name_to_style (optarg);
              style = cplus_demangle_name_to_style (optarg);
              if (style == unknown_demangling)
              if (style == unknown_demangling)
                fatal (_("unknown demangling style `%s'"),
                fatal (_("unknown demangling style `%s'"),
                       optarg);
                       optarg);
 
 
              cplus_demangle_set_style (style);
              cplus_demangle_set_style (style);
            }
            }
          break;
          break;
        case 'e':
        case 'e':
          file_name = optarg;
          file_name = optarg;
          break;
          break;
        case 's':
        case 's':
          base_names = TRUE;
          base_names = TRUE;
          break;
          break;
        case 'f':
        case 'f':
          with_functions = TRUE;
          with_functions = TRUE;
          break;
          break;
        case 'v':
        case 'v':
        case 'V':
        case 'V':
          print_version ("addr2line");
          print_version ("addr2line");
          break;
          break;
        case 'h':
        case 'h':
        case 'H':
        case 'H':
          usage (stdout, 0);
          usage (stdout, 0);
          break;
          break;
        case 'i':
        case 'i':
          unwind_inlines = TRUE;
          unwind_inlines = TRUE;
          break;
          break;
        case 'j':
        case 'j':
          section_name = optarg;
          section_name = optarg;
          break;
          break;
        default:
        default:
          usage (stderr, 1);
          usage (stderr, 1);
          break;
          break;
        }
        }
    }
    }
 
 
  if (file_name == NULL)
  if (file_name == NULL)
    file_name = "a.out";
    file_name = "a.out";
 
 
  addr = argv + optind;
  addr = argv + optind;
  naddr = argc - optind;
  naddr = argc - optind;
 
 
  return process_file (file_name, section_name, target);
  return process_file (file_name, section_name, target);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.