Subversion Repositories open8_urisc

/* readelf.c -- display contents of an ELF format file

   Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,

   2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

   Originally developed by Eric Youngdale <eric@andante.jic.com>

   Modifications by Nick Clifton <nickc@redhat.com>

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

/* The difference between readelf and objdump:

  Both programs are capable of displaying the contents of ELF format files,

  so why does the binutils project have two file dumpers ?

  The reason is that objdump sees an ELF file through a BFD filter of the

  world; if BFD has a bug where, say, it disagrees about a machine constant

  in e_flags, then the odds are good that it will remain internally

  consistent.  The linker sees it the BFD way, objdump sees it the BFD way,

  GAS sees it the BFD way.  There was need for a tool to go find out what

  the file actually says.

  This is why the readelf program does not link against the BFD library - it

  exists as an independent program to help verify the correct working of BFD.

  There is also the case that readelf can provide more information about an

  ELF file than is provided by objdump.  In particular it can display DWARF

  debugging information which (at the moment) objdump cannot.  */

#include "config.h"

#include "sysdep.h"

#include <assert.h>

#include <sys/stat.h>

#include <time.h>

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#if __GNUC__ >= 2

/* Define BFD64 here, even if our default architecture is 32 bit ELF

   as this will allow us to read in and parse 64bit and 32bit ELF files.

   Only do this if we believe that the compiler can support a 64 bit

   data type.  For now we only rely on GCC being able to do this.  */

#define BFD64

#endif

#include "bfd.h"

#include "bucomm.h"

#include "elfcomm.h"

#include "dwarf.h"

#include "elf/common.h"

#include "elf/external.h"

#include "elf/internal.h"

/* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that

   we can obtain the H8 reloc numbers.  We need these for the

   get_reloc_size() function.  We include h8.h again after defining

   RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */

#include "elf/h8.h"

#undef _ELF_H8_H

/* Undo the effects of #including reloc-macros.h.  */

#undef START_RELOC_NUMBERS

#undef RELOC_NUMBER

#undef FAKE_RELOC

#undef EMPTY_RELOC

#undef END_RELOC_NUMBERS

#undef _RELOC_MACROS_H

/* The following headers use the elf/reloc-macros.h file to

   automatically generate relocation recognition functions

   such as elf_mips_reloc_type()  */

#define RELOC_MACROS_GEN_FUNC

#include "elf/alpha.h"

#include "elf/arc.h"

#include "elf/arm.h"

#include "elf/avr.h"

#include "elf/bfin.h"

#include "elf/cr16.h"

#include "elf/cris.h"

#include "elf/crx.h"

#include "elf/d10v.h"

#include "elf/d30v.h"

#include "elf/dlx.h"

#include "elf/fr30.h"

#include "elf/frv.h"

#include "elf/h8.h"

#include "elf/hppa.h"

#include "elf/i386.h"

#include "elf/i370.h"

#include "elf/i860.h"

#include "elf/i960.h"

#include "elf/ia64.h"

#include "elf/ip2k.h"

#include "elf/lm32.h"

#include "elf/iq2000.h"

#include "elf/m32c.h"

#include "elf/m32r.h"

#include "elf/m68k.h"

#include "elf/m68hc11.h"

#include "elf/mcore.h"

#include "elf/mep.h"

#include "elf/microblaze.h"

#include "elf/mips.h"

#include "elf/mmix.h"

#include "elf/mn10200.h"

#include "elf/mn10300.h"

#include "elf/moxie.h"

#include "elf/mt.h"

#include "elf/msp430.h"

#include "elf/open8.h"

#include "elf/or32.h"

#include "elf/pj.h"

#include "elf/ppc.h"

#include "elf/ppc64.h"

#include "elf/rx.h"

#include "elf/s390.h"

#include "elf/score.h"

#include "elf/sh.h"

#include "elf/sparc.h"

#include "elf/spu.h"

#include "elf/tic6x.h"

#include "elf/tilegx.h"

#include "elf/tilepro.h"

#include "elf/v850.h"

#include "elf/vax.h"

#include "elf/x86-64.h"

#include "elf/xc16x.h"

#include "elf/xstormy16.h"

#include "elf/xtensa.h"

#include "getopt.h"

#include "libiberty.h"

#include "safe-ctype.h"

#include "filenames.h"

char * program_name = "readelf";

static long archive_file_offset;

static unsigned long archive_file_size;

static unsigned long dynamic_addr;

static bfd_size_type dynamic_size;

static unsigned int dynamic_nent;

static char * dynamic_strings;

static unsigned long dynamic_strings_length;

static char * string_table;

static unsigned long string_table_length;

static unsigned long num_dynamic_syms;

static Elf_Internal_Sym * dynamic_symbols;

static Elf_Internal_Syminfo * dynamic_syminfo;

static unsigned long dynamic_syminfo_offset;

static unsigned int dynamic_syminfo_nent;

static char program_interpreter[PATH_MAX];

static bfd_vma dynamic_info[DT_ENCODING];

static bfd_vma dynamic_info_DT_GNU_HASH;

static bfd_vma version_info[16];

static Elf_Internal_Ehdr elf_header;

static Elf_Internal_Shdr * section_headers;

static Elf_Internal_Phdr * program_headers;

static Elf_Internal_Dyn *  dynamic_section;

static Elf_Internal_Shdr * symtab_shndx_hdr;

static int show_name;

static int do_dynamic;

static int do_syms;

static int do_dyn_syms;

static int do_reloc;

static int do_sections;

static int do_section_groups;

static int do_section_details;

static int do_segments;

static int do_unwind;

static int do_using_dynamic;

static int do_header;

static int do_dump;

static int do_version;

static int do_histogram;

static int do_debugging;

static int do_arch;

static int do_notes;

static int do_archive_index;

static int is_32bit_elf;

struct group_list

{

  struct group_list * next;

  unsigned int section_index;

};

struct group

{

  struct group_list * root;

  unsigned int group_index;

};

static size_t group_count;

static struct group * section_groups;

static struct group ** section_headers_groups;

/* Flag bits indicating particular types of dump.  */

#define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */

#define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */

#define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */

#define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */

#define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */

typedef unsigned char dump_type;

/* A linked list of the section names for which dumps were requested.  */

struct dump_list_entry

{

  char * name;

  dump_type type;

  struct dump_list_entry * next;

};

static struct dump_list_entry * dump_sects_byname;

/* A dynamic array of flags indicating for which sections a dump

   has been requested via command line switches.  */

static dump_type *   cmdline_dump_sects = NULL;

static unsigned int  num_cmdline_dump_sects = 0;

/* A dynamic array of flags indicating for which sections a dump of

   some kind has been requested.  It is reset on a per-object file

   basis and then initialised from the cmdline_dump_sects array,

   the results of interpreting the -w switch, and the

   dump_sects_byname list.  */

static dump_type *   dump_sects = NULL;

static unsigned int  num_dump_sects = 0;

/* How to print a vma value.  */

typedef enum print_mode

{

  HEX,

  DEC,

  DEC_5,

  UNSIGNED,

  PREFIX_HEX,

  FULL_HEX,

  LONG_HEX

}

print_mode;

#define UNKNOWN -1

#define SECTION_NAME(X)                                         \

  ((X) == NULL ? _("<none>")                                    \

   : string_table == NULL ? _("<no-name>")                      \

   : ((X)->sh_name >= string_table_length ? _("<corrupt>")      \

  : string_table + (X)->sh_name))

#define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */

#define GET_ELF_SYMBOLS(file, section)                  \

  (is_32bit_elf ? get_32bit_elf_symbols (file, section) \

   : get_64bit_elf_symbols (file, section))

#define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))

/* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has

   already been called and verified that the string exists.  */

#define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)

#define REMOVE_ARCH_BITS(ADDR)                  \

  do                                            \

    {                                           \

      if (elf_header.e_machine == EM_ARM)       \

        (ADDR) &= ~1;                           \

    }                                           \

  while (0)

/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.

   Put the retrieved data into VAR, if it is not NULL.  Otherwise allocate a buffer

   using malloc and fill that.  In either case return the pointer to the start of

   the retrieved data or NULL if something went wrong.  If something does go wrong

   emit an error message using REASON as part of the context.  */

static void *

get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,

          const char * reason)

{

  void * mvar;

  if (size == 0 || nmemb == 0)

    return NULL;

  if (fseek (file, archive_file_offset + offset, SEEK_SET))

    {

      error (_("Unable to seek to 0x%lx for %s\n"),

             (unsigned long) archive_file_offset + offset, reason);

      return NULL;

    }

  mvar = var;

  if (mvar == NULL)

    {

      /* Check for overflow.  */

      if (nmemb < (~(size_t) 0 - 1) / size)

        /* + 1 so that we can '\0' terminate invalid string table sections.  */

        mvar = malloc (size * nmemb + 1);

      if (mvar == NULL)

        {

          error (_("Out of memory allocating 0x%lx bytes for %s\n"),

                 (unsigned long)(size * nmemb), reason);

          return NULL;

        }

      ((char *) mvar)[size * nmemb] = '\0';

    }

  if (fread (mvar, size, nmemb, file) != nmemb)

    {

      error (_("Unable to read in 0x%lx bytes of %s\n"),

             (unsigned long)(size * nmemb), reason);

      if (mvar != var)

        free (mvar);

      return NULL;

    }

  return mvar;

}

/* Print a VMA value.  */

static int

print_vma (bfd_vma vma, print_mode mode)

{

  int nc = 0;

  switch (mode)

    {

    case FULL_HEX:

      nc = printf ("0x");

      /* Drop through.  */

    case LONG_HEX:

#ifdef BFD64

      if (is_32bit_elf)

        return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);

#endif

      printf_vma (vma);

      return nc + 16;

    case DEC_5:

      if (vma <= 99999)

        return printf ("%5" BFD_VMA_FMT "d", vma);

      /* Drop through.  */

    case PREFIX_HEX:

      nc = printf ("0x");

      /* Drop through.  */

    case HEX:

      return nc + printf ("%" BFD_VMA_FMT "x", vma);

    case DEC:

      return printf ("%" BFD_VMA_FMT "d", vma);

    case UNSIGNED:

      return printf ("%" BFD_VMA_FMT "u", vma);

    }

  return 0;

}

/* Display a symbol on stdout.  Handles the display of non-printing characters.

   If DO_WIDE is not true then format the symbol to be at most WIDTH characters,

   truncating as necessary.  If WIDTH is negative then format the string to be

   exactly - WIDTH characters, truncating or padding as necessary.

   Returns the number of emitted characters.  */

static unsigned int

print_symbol (int width, const char *symbol)

{

  const char *c;

  bfd_boolean extra_padding = FALSE;

  unsigned int num_printed = 0;

  if (do_wide)

    {

      /* Set the width to a very large value.  This simplifies the

         code below.  */

      width = INT_MAX;

    }

  else if (width < 0)

    {

      /* Keep the width positive.  This also helps.  */

      width = - width;

      extra_padding = TRUE;

    }

  while (width)

    {

      int len;

      c = symbol;

      /* Look for non-printing symbols inside the symbol's name.

         This test is triggered in particular by the names generated

         by the assembler for local labels.  */

      while (ISPRINT (*c))

        c++;

      len = c - symbol;

      if (len)

        {

          if (len > width)

            len = width;

          printf ("%.*s", len, symbol);

          width -= len;

          num_printed += len;

        }

      if (*c == 0 || width == 0)

        break;

      /* Now display the non-printing character, if

         there is room left in which to dipslay it.  */

      if ((unsigned char) *c < 32)

        {

          if (width < 2)

            break;

          printf ("^%c", *c + 0x40);

          width -= 2;

          num_printed += 2;

        }

      else

        {

          if (width < 6)

            break;

          printf ("<0x%.2x>", (unsigned char) *c);

          width -= 6;

          num_printed += 6;

        }

      symbol = c + 1;

    }

  if (extra_padding && width > 0)

    {

      /* Fill in the remaining spaces.  */

      printf ("%-*s", width, " ");

      num_printed += 2;

    }

  return num_printed;

}

/* Return a pointer to section NAME, or NULL if no such section exists.  */

static Elf_Internal_Shdr *

find_section (const char * name)

{

  unsigned int i;

  for (i = 0; i < elf_header.e_shnum; i++)

    if (streq (SECTION_NAME (section_headers + i), name))

      return section_headers + i;

  return NULL;

}

/* Return a pointer to a section containing ADDR, or NULL if no such

   section exists.  */

static Elf_Internal_Shdr *

find_section_by_address (bfd_vma addr)

{

  unsigned int i;

  for (i = 0; i < elf_header.e_shnum; i++)

    {

      Elf_Internal_Shdr *sec = section_headers + i;

      if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)

        return sec;

    }

  return NULL;

}

/* Read an unsigned LEB128 encoded value from p.  Set *PLEN to the number of

   bytes read.  */

static unsigned long

read_uleb128 (unsigned char *data, unsigned int *length_return)

{

  return read_leb128 (data, length_return, 0);

}

/* Return true if the current file is for IA-64 machine and OpenVMS ABI.

   This OS has so many departures from the ELF standard that we test it at

   many places.  */

static inline int

is_ia64_vms (void)

{

  return elf_header.e_machine == EM_IA_64

    && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;

}

/* Guess the relocation size commonly used by the specific machines.  */

static int

guess_is_rela (unsigned int e_machine)

{

  switch (e_machine)

    {

      /* Targets that use REL relocations.  */

    case EM_386:

    case EM_486:

    case EM_960:

    case EM_ARM:

    case EM_D10V:

    case EM_CYGNUS_D10V:

    case EM_DLX:

    case EM_MIPS:

    case EM_MIPS_RS3_LE:

    case EM_CYGNUS_M32R:

    case EM_OPENRISC:

    case EM_OR32:

    case EM_SCORE:

      return FALSE;

      /* Targets that use RELA relocations.  */

    case EM_68K:

    case EM_860:

    case EM_ALPHA:

    case EM_ALTERA_NIOS2:

    case EM_AVR:

    case EM_AVR_OLD:

    case EM_BLACKFIN:

    case EM_CR16:

    case EM_CR16_OLD:

    case EM_CRIS:

    case EM_CRX:

    case EM_D30V:

    case EM_CYGNUS_D30V:

    case EM_FR30:

    case EM_CYGNUS_FR30:

    case EM_CYGNUS_FRV:

    case EM_H8S:

    case EM_H8_300:

    case EM_H8_300H:

    case EM_IA_64:

    case EM_IP2K:

    case EM_IP2K_OLD:

    case EM_IQ2000:

    case EM_LATTICEMICO32:

    case EM_M32C_OLD:

    case EM_M32C:

    case EM_M32R:

    case EM_MCORE:

    case EM_CYGNUS_MEP:

    case EM_MMIX:

    case EM_MN10200:

    case EM_CYGNUS_MN10200:

    case EM_MN10300:

    case EM_CYGNUS_MN10300:

    case EM_MOXIE:

    case EM_MSP430:

    case EM_MSP430_OLD:

    case EM_MT:

    case EM_NIOS32:

    case EM_OPEN8:

    case EM_PPC64:

    case EM_PPC:

    case EM_RX:

    case EM_S390:

    case EM_S390_OLD:

    case EM_SH:

    case EM_SPARC:

    case EM_SPARC32PLUS:

    case EM_SPARCV9:

    case EM_SPU:

    case EM_TI_C6000:

    case EM_TILEGX:

    case EM_TILEPRO:

    case EM_V850:

    case EM_CYGNUS_V850:

    case EM_VAX:

    case EM_X86_64:

    case EM_L1OM:

    case EM_K1OM:

    case EM_XSTORMY16:

    case EM_XTENSA:

    case EM_XTENSA_OLD:

    case EM_MICROBLAZE:

    case EM_MICROBLAZE_OLD:

      return TRUE;

    case EM_68HC05:

    case EM_68HC08:

    case EM_68HC11:

    case EM_68HC16:

    case EM_FX66:

    case EM_ME16:

    case EM_MMA:

    case EM_NCPU:

    case EM_NDR1:

    case EM_PCP:

    case EM_ST100:

    case EM_ST19:

    case EM_ST7:

    case EM_ST9PLUS:

    case EM_STARCORE:

    case EM_SVX:

    case EM_TINYJ:

    default:

      warn (_("Don't know about relocations on this machine architecture\n"));

      return FALSE;

    }

}

static int

slurp_rela_relocs (FILE * file,

                   unsigned long rel_offset,

                   unsigned long rel_size,

                   Elf_Internal_Rela ** relasp,

                   unsigned long * nrelasp)

{

  Elf_Internal_Rela * relas;

  unsigned long nrelas;

  unsigned int i;

  if (is_32bit_elf)

    {

      Elf32_External_Rela * erelas;

      erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,

                                                 rel_size, _("relocs"));

      if (!erelas)

        return 0;

      nrelas = rel_size / sizeof (Elf32_External_Rela);

      relas = (Elf_Internal_Rela *) cmalloc (nrelas,

                                             sizeof (Elf_Internal_Rela));

      if (relas == NULL)

        {

          free (erelas);

          error (_("out of memory parsing relocs\n"));

          return 0;

        }

      for (i = 0; i < nrelas; i++)

        {

          relas[i].r_offset = BYTE_GET (erelas[i].r_offset);

          relas[i].r_info   = BYTE_GET (erelas[i].r_info);

          relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);

        }

      free (erelas);

    }

  else

    {

      Elf64_External_Rela * erelas;

      erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,

                                                 rel_size, _("relocs"));

      if (!erelas)

        return 0;

      nrelas = rel_size / sizeof (Elf64_External_Rela);

      relas = (Elf_Internal_Rela *) cmalloc (nrelas,

                                             sizeof (Elf_Internal_Rela));

      if (relas == NULL)

        {

          free (erelas);

          error (_("out of memory parsing relocs\n"));

          return 0;

        }

      for (i = 0; i < nrelas; i++)

        {

          relas[i].r_offset = BYTE_GET (erelas[i].r_offset);

          relas[i].r_info   = BYTE_GET (erelas[i].r_info);

          relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);

          /* The #ifdef BFD64 below is to prevent a compile time

             warning.  We know that if we do not have a 64 bit data

             type that we will never execute this code anyway.  */

#ifdef BFD64

          if (elf_header.e_machine == EM_MIPS

              && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)

            {

              /* In little-endian objects, r_info isn't really a

                 64-bit little-endian value: it has a 32-bit

                 little-endian symbol index followed by four

                 individual byte fields.  Reorder INFO

                 accordingly.  */

              bfd_vma inf = relas[i].r_info;

              inf = (((inf & 0xffffffff) << 32)

                      | ((inf >> 56) & 0xff)