Subversion Repositories openrisc

/* objdump.c -- dump information about an object file.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

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

   MA 02110-1301, USA.  */

/* Objdump overview.

   Objdump displays information about one or more object files, either on

   their own, or inside libraries.  It is commonly used as a disassembler,

   but it can also display information about file headers, symbol tables,

   relocations, debugging directives and more.

   The flow of execution is as follows:

   1. Command line arguments are checked for control switches and the

      information to be displayed is selected.

   2. Any remaining arguments are assumed to be object files, and they are

      processed in order by display_bfd().  If the file is an archive each

      of its elements is processed in turn.

   3. The file's target architecture and binary file format are determined

      by bfd_check_format().  If they are recognised, then dump_bfd() is

      called.

   4. dump_bfd() in turn calls separate functions to display the requested

      item(s) of information(s).  For example disassemble_data() is called if

      a disassembly has been requested.

   When disassembling the code loops through blocks of instructions bounded

   by symbols, calling disassemble_bytes() on each block.  The actual

   disassembling is done by the libopcodes library, via a function pointer

   supplied by the disassembler() function.  */

#include "sysdep.h"

#include "bfd.h"

#include "elf-bfd.h"

#include "progress.h"

#include "bucomm.h"

#include "dwarf.h"

#include "getopt.h"

#include "safe-ctype.h"

#include "dis-asm.h"

#include "libiberty.h"

#include "demangle.h"

#include "debug.h"

#include "budbg.h"

#ifdef HAVE_MMAP

#include <sys/mman.h>

#endif

#include <sys/stat.h>

/* Internal headers for the ELF .stab-dump code - sorry.  */

#define BYTES_IN_WORD   32

#include "aout/aout64.h"

/* Exit status.  */

static int exit_status = 0;

static char *default_target = NULL;     /* Default at runtime.  */

/* The following variables are set based on arguments passed on the

   command line.  */

static int show_version = 0;             /* Show the version number.  */

static int dump_section_contents;       /* -s */

static int dump_section_headers;        /* -h */

static bfd_boolean dump_file_header;    /* -f */

static int dump_symtab;                 /* -t */

static int dump_dynamic_symtab;         /* -T */

static int dump_reloc_info;             /* -r */

static int dump_dynamic_reloc_info;     /* -R */

static int dump_ar_hdrs;                /* -a */

static int dump_private_headers;        /* -p */

static int prefix_addresses;            /* --prefix-addresses */

static int with_line_numbers;           /* -l */

static bfd_boolean with_source_code;    /* -S */

static int show_raw_insn;               /* --show-raw-insn */

static int dump_dwarf_section_info;     /* --dwarf */

static int dump_stab_section_info;      /* --stabs */

static int do_demangle;                 /* -C, --demangle */

static bfd_boolean disassemble;         /* -d */

static bfd_boolean disassemble_all;     /* -D */

static int disassemble_zeroes;          /* --disassemble-zeroes */

static bfd_boolean formats_info;        /* -i */

static int wide_output;                 /* -w */

static bfd_vma start_address = (bfd_vma) -1; /* --start-address */

static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */

static int dump_debugging;              /* --debugging */

static int dump_debugging_tags;         /* --debugging-tags */

static int dump_special_syms = 0;        /* --special-syms */

static bfd_vma adjust_section_vma = 0;   /* --adjust-vma */

static int file_start_context = 0;      /* --file-start-context */

static bfd_boolean display_file_offsets;/* -F */

/* Pointer to an array of section names provided by

   one or more "-j secname" command line options.  */

static char **only;

/* The total number of slots in the only[] array.  */

static size_t only_size = 0;

/* The number of occupied slots in the only[] array.  */

static size_t only_used = 0;

/* Variables for handling include file path table.  */

static const char **include_paths;

static int include_path_count;

/* Extra info to pass to the section disassembler and address printing

   function.  */

struct objdump_disasm_info

{

  bfd *              abfd;

  asection *         sec;

  bfd_boolean        require_sec;

  arelent **         dynrelbuf;

  long               dynrelcount;

  disassembler_ftype disassemble_fn;

  arelent *          reloc;

};

/* Architecture to disassemble for, or default if NULL.  */

static char *machine = NULL;

/* Target specific options to the disassembler.  */

static char *disassembler_options = NULL;

/* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */

static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;

/* The symbol table.  */

static asymbol **syms;

/* Number of symbols in `syms'.  */

static long symcount = 0;

/* The sorted symbol table.  */

static asymbol **sorted_syms;

/* Number of symbols in `sorted_syms'.  */

static long sorted_symcount = 0;

/* The dynamic symbol table.  */

static asymbol **dynsyms;

/* The synthetic symbol table.  */

static asymbol *synthsyms;

static long synthcount = 0;

/* Number of symbols in `dynsyms'.  */

static long dynsymcount = 0;

static bfd_byte *stabs;

static bfd_size_type stab_size;

static char *strtab;

static bfd_size_type stabstr_size;

static bfd_boolean is_relocatable = FALSE;

static void

usage (FILE *stream, int status)

{

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

  fprintf (stream, _(" Display information from object <file(s)>.\n"));

  fprintf (stream, _(" At least one of the following switches must be given:\n"));

  fprintf (stream, _("\

  -a, --archive-headers    Display archive header information\n\

  -f, --file-headers       Display the contents of the overall file header\n\

  -p, --private-headers    Display object format specific file header contents\n\

  -h, --[section-]headers  Display the contents of the section headers\n\

  -x, --all-headers        Display the contents of all headers\n\

  -d, --disassemble        Display assembler contents of executable sections\n\

  -D, --disassemble-all    Display assembler contents of all sections\n\

  -S, --source             Intermix source code with disassembly\n\

  -s, --full-contents      Display the full contents of all sections requested\n\

  -g, --debugging          Display debug information in object file\n\

  -e, --debugging-tags     Display debug information using ctags style\n\

  -G, --stabs              Display (in raw form) any STABS info in the file\n\

  -W, --dwarf              Display DWARF info in the file\n\

  -t, --syms               Display the contents of the symbol table(s)\n\

  -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\

  -r, --reloc              Display the relocation entries in the file\n\

  -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\

  @<file>                  Read options from <file>\n\

  -v, --version            Display this program's version number\n\

  -i, --info               List object formats and architectures supported\n\

  -H, --help               Display this information\n\

"));

  if (status != 2)

    {

      fprintf (stream, _("\n The following switches are optional:\n"));

      fprintf (stream, _("\

  -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\

  -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\

  -j, --section=NAME             Only display information for section NAME\n\

  -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\

  -EB --endian=big               Assume big endian format when disassembling\n\

  -EL --endian=little            Assume little endian format when disassembling\n\

      --file-start-context       Include context from start of file (with -S)\n\

  -I, --include=DIR              Add DIR to search list for source files\n\

  -l, --line-numbers             Include line numbers and filenames in output\n\

  -F, --file-offsets             Include file offsets when displaying information\n\

  -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\

                                  The STYLE, if specified, can be `auto', `gnu',\n\

                                  `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\

                                  or `gnat'\n\

  -w, --wide                     Format output for more than 80 columns\n\

  -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\

      --start-address=ADDR       Only process data whose address is >= ADDR\n\

      --stop-address=ADDR        Only process data whose address is <= ADDR\n\

      --prefix-addresses         Print complete address alongside disassembly\n\

      --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\

      --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\

      --special-syms             Include special symbols in symbol dumps\n\

\n"));

      list_supported_targets (program_name, stream);

      list_supported_architectures (program_name, stream);

      disassembler_usage (stream);

    }

  if (REPORT_BUGS_TO[0] && status == 0)

    fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);

  exit (status);

}

/* 150 isn't special; it's just an arbitrary non-ASCII char value.  */

enum option_values

  {

    OPTION_ENDIAN=150,

    OPTION_START_ADDRESS,

    OPTION_STOP_ADDRESS,

    OPTION_ADJUST_VMA

  };

static struct option long_options[]=

{

  {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},

  {"all-headers", no_argument, NULL, 'x'},

  {"private-headers", no_argument, NULL, 'p'},

  {"architecture", required_argument, NULL, 'm'},

  {"archive-headers", no_argument, NULL, 'a'},

  {"debugging", no_argument, NULL, 'g'},

  {"debugging-tags", no_argument, NULL, 'e'},

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

  {"disassemble", no_argument, NULL, 'd'},

  {"disassemble-all", no_argument, NULL, 'D'},

  {"disassembler-options", required_argument, NULL, 'M'},

  {"disassemble-zeroes", no_argument, NULL, 'z'},

  {"dynamic-reloc", no_argument, NULL, 'R'},

  {"dynamic-syms", no_argument, NULL, 'T'},

  {"endian", required_argument, NULL, OPTION_ENDIAN},

  {"file-headers", no_argument, NULL, 'f'},

  {"file-offsets", no_argument, NULL, 'F'},

  {"file-start-context", no_argument, &file_start_context, 1},

  {"full-contents", no_argument, NULL, 's'},

  {"headers", no_argument, NULL, 'h'},

  {"help", no_argument, NULL, 'H'},

  {"info", no_argument, NULL, 'i'},

  {"line-numbers", no_argument, NULL, 'l'},

  {"no-show-raw-insn", no_argument, &show_raw_insn, -1},

  {"prefix-addresses", no_argument, &prefix_addresses, 1},

  {"reloc", no_argument, NULL, 'r'},

  {"section", required_argument, NULL, 'j'},

  {"section-headers", no_argument, NULL, 'h'},

  {"show-raw-insn", no_argument, &show_raw_insn, 1},

  {"source", no_argument, NULL, 'S'},

  {"special-syms", no_argument, &dump_special_syms, 1},

  {"include", required_argument, NULL, 'I'},

  {"dwarf", no_argument, NULL, 'W'},

  {"stabs", no_argument, NULL, 'G'},

  {"start-address", required_argument, NULL, OPTION_START_ADDRESS},

  {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},

  {"syms", no_argument, NULL, 't'},

  {"target", required_argument, NULL, 'b'},

  {"version", no_argument, NULL, 'V'},

  {"wide", no_argument, NULL, 'w'},

  {0, no_argument, 0, 0}

};

static void

nonfatal (const char *msg)

{

  bfd_nonfatal (msg);

  exit_status = 1;

}

static void

dump_section_header (bfd *abfd, asection *section,

                     void *ignored ATTRIBUTE_UNUSED)

{

  char *comma = "";

  unsigned int opb = bfd_octets_per_byte (abfd);

  /* Ignore linker created section.  See elfNN_ia64_object_p in

     bfd/elfxx-ia64.c.  */

  if (section->flags & SEC_LINKER_CREATED)

    return;

  printf ("%3d %-13s %08lx  ", section->index,

          bfd_get_section_name (abfd, section),

          (unsigned long) bfd_section_size (abfd, section) / opb);

  bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));

  printf ("  ");

  bfd_printf_vma (abfd, section->lma);

  printf ("  %08lx  2**%u", (unsigned long) section->filepos,

          bfd_get_section_alignment (abfd, section));

  if (! wide_output)

    printf ("\n                ");

  printf ("  ");

#define PF(x, y) \

  if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }

  PF (SEC_HAS_CONTENTS, "CONTENTS");

  PF (SEC_ALLOC, "ALLOC");

  PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");

  PF (SEC_LOAD, "LOAD");

  PF (SEC_RELOC, "RELOC");

  PF (SEC_READONLY, "READONLY");

  PF (SEC_CODE, "CODE");

  PF (SEC_DATA, "DATA");

  PF (SEC_ROM, "ROM");

  PF (SEC_DEBUGGING, "DEBUGGING");

  PF (SEC_NEVER_LOAD, "NEVER_LOAD");

  PF (SEC_EXCLUDE, "EXCLUDE");

  PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");

  if (bfd_get_arch (abfd) == bfd_arch_tic54x)

    {

      PF (SEC_TIC54X_BLOCK, "BLOCK");

      PF (SEC_TIC54X_CLINK, "CLINK");

    }

  PF (SEC_SMALL_DATA, "SMALL_DATA");

  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)

    PF (SEC_COFF_SHARED, "SHARED");

  PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");

  PF (SEC_GROUP, "GROUP");

  if ((section->flags & SEC_LINK_ONCE) != 0)

    {

      const char *ls;

      struct coff_comdat_info *comdat;

      switch (section->flags & SEC_LINK_DUPLICATES)

        {

        default:

          abort ();

        case SEC_LINK_DUPLICATES_DISCARD:

          ls = "LINK_ONCE_DISCARD";

          break;

        case SEC_LINK_DUPLICATES_ONE_ONLY:

          ls = "LINK_ONCE_ONE_ONLY";

          break;

        case SEC_LINK_DUPLICATES_SAME_SIZE:

          ls = "LINK_ONCE_SAME_SIZE";

          break;

        case SEC_LINK_DUPLICATES_SAME_CONTENTS:

          ls = "LINK_ONCE_SAME_CONTENTS";

          break;

        }

      printf ("%s%s", comma, ls);

      comdat = bfd_coff_get_comdat_section (abfd, section);

      if (comdat != NULL)

        printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);

      comma = ", ";

    }

  printf ("\n");

#undef PF

}

static void

dump_headers (bfd *abfd)

{

  printf (_("Sections:\n"));

#ifndef BFD64

  printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));

#else

  /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */

  if (bfd_get_arch_size (abfd) == 32)

    printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));

  else

    printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));

#endif

  if (wide_output)

    printf (_("  Flags"));

  if (abfd->flags & HAS_LOAD_PAGE)

    printf (_("  Pg"));

  printf ("\n");

  bfd_map_over_sections (abfd, dump_section_header, NULL);

}

static asymbol **

slurp_symtab (bfd *abfd)

{

  asymbol **sy = NULL;

  long storage;

  if (!(bfd_get_file_flags (abfd) & HAS_SYMS))

    {

      symcount = 0;

      return NULL;

    }

  storage = bfd_get_symtab_upper_bound (abfd);

  if (storage < 0)

    bfd_fatal (bfd_get_filename (abfd));

  if (storage)

    sy = xmalloc (storage);

  symcount = bfd_canonicalize_symtab (abfd, sy);

  if (symcount < 0)

    bfd_fatal (bfd_get_filename (abfd));

  return sy;

}

/* Read in the dynamic symbols.  */

static asymbol **

slurp_dynamic_symtab (bfd *abfd)

{

  asymbol **sy = NULL;

  long storage;

  storage = bfd_get_dynamic_symtab_upper_bound (abfd);

  if (storage < 0)

    {

      if (!(bfd_get_file_flags (abfd) & DYNAMIC))

        {

          non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));

          dynsymcount = 0;

          return NULL;

        }

      bfd_fatal (bfd_get_filename (abfd));

    }

  if (storage)

    sy = xmalloc (storage);

  dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);

  if (dynsymcount < 0)

    bfd_fatal (bfd_get_filename (abfd));

  return sy;

}

/* Filter out (in place) symbols that are useless for disassembly.

   COUNT is the number of elements in SYMBOLS.

   Return the number of useful symbols.  */

static long

remove_useless_symbols (asymbol **symbols, long count)

{

  asymbol **in_ptr = symbols, **out_ptr = symbols;

  while (--count >= 0)

    {

      asymbol *sym = *in_ptr++;

      if (sym->name == NULL || sym->name[0] == '\0')

        continue;

      if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))

        continue;

      if (bfd_is_und_section (sym->section)

          || bfd_is_com_section (sym->section))

        continue;

      *out_ptr++ = sym;

    }

  return out_ptr - symbols;

}

/* Sort symbols into value order.  */

static int

compare_symbols (const void *ap, const void *bp)

{

  const asymbol *a = * (const asymbol **) ap;

  const asymbol *b = * (const asymbol **) bp;

  const char *an;

  const char *bn;

  size_t anl;

  size_t bnl;

  bfd_boolean af;

  bfd_boolean bf;

  flagword aflags;

  flagword bflags;

  if (bfd_asymbol_value (a) > bfd_asymbol_value (b))

    return 1;

  else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))

    return -1;

  if (a->section > b->section)

    return 1;

  else if (a->section < b->section)

    return -1;

  an = bfd_asymbol_name (a);

  bn = bfd_asymbol_name (b);

  anl = strlen (an);

  bnl = strlen (bn);

  /* The symbols gnu_compiled and gcc2_compiled convey no real

     information, so put them after other symbols with the same value.  */

  af = (strstr (an, "gnu_compiled") != NULL

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

  bf = (strstr (bn, "gnu_compiled") != NULL

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

  if (af && ! bf)

    return 1;

  if (! af && bf)

    return -1;

  /* We use a heuristic for the file name, to try to sort it after

     more useful symbols.  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')))

  af = file_symbol (a, an, anl);

  bf = file_symbol (b, bn, bnl);

  if (af && ! bf)

    return 1;

  if (! af && bf)

    return -1;

  /* Try to sort global symbols before local symbols before function

     symbols before debugging symbols.  */

  aflags = a->flags;

  bflags = b->flags;

  if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))

    {

      if ((aflags & BSF_DEBUGGING) != 0)

        return 1;

      else

        return -1;

    }

  if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))

    {

      if ((aflags & BSF_FUNCTION) != 0)

        return -1;

      else

        return 1;

    }

  if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))

    {

      if ((aflags & BSF_LOCAL) != 0)

        return 1;

      else

        return -1;

    }

  if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))

    {

      if ((aflags & BSF_GLOBAL) != 0)

        return -1;

      else

        return 1;

    }

  /* Symbols that start with '.' might be section names, so sort them

     after symbols that don't start with '.'.  */

  if (an[0] == '.' && bn[0] != '.')

    return 1;

  if (an[0] != '.' && bn[0] == '.')

    return -1;

  /* Finally, if we can't distinguish them in any other way, try to

     get consistent results by sorting the symbols by name.  */

  return strcmp (an, bn);

}

/* Sort relocs into address order.  */

static int

compare_relocs (const void *ap, const void *bp)

{

  const arelent *a = * (const arelent **) ap;

  const arelent *b = * (const arelent **) bp;

  if (a->address > b->address)

    return 1;

  else if (a->address < b->address)

    return -1;

  /* So that associated relocations tied to the same address show up

     in the correct order, we don't do any further sorting.  */

  if (a > b)

    return 1;

  else if (a < b)

    return -1;

  else

    return 0;

}

/* Print an address (VMA) to the output stream in INFO.

   If SKIP_ZEROES is TRUE, omit leading zeroes.  */

static void

objdump_print_value (bfd_vma vma, struct disassemble_info *info,

                     bfd_boolean skip_zeroes)

{

  char buf[30];

  char *p;

  struct objdump_disasm_info *aux;

  aux = (struct objdump_disasm_info *) info->application_data;

  bfd_sprintf_vma (aux->abfd, buf, vma);

  if (! skip_zeroes)

    p = buf;

  else

    {

      for (p = buf; *p == '0'; ++p)

        ;

      if (*p == '\0')

        --p;

    }

  (*info->fprintf_func) (info->stream, "%s", p);