Subversion Repositories openrisc_2011-10-31

/* LTO routines for ELF object files.

   Copyright 2009, 2010 Free Software Foundation, Inc.

   Contributed by CodeSourcery, Inc.

This file is part of GCC.

GCC 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.

GCC 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 GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "toplev.h"

#include <gelf.h>

#include "lto.h"

#include "tm.h"

#include "libiberty.h"

#include "ggc.h"

#include "lto-streamer.h"

/* Cater to hosts with half-backed <elf.h> file like HP-UX.  */

#ifndef EM_SPARC

# define EM_SPARC 2

#endif

#ifndef EM_SPARC32PLUS

# define EM_SPARC32PLUS 18

#endif

/* Handle opening elf files on hosts, such as Windows, that may use

   text file handling that will break binary access.  */

#ifndef O_BINARY

# define O_BINARY 0

#endif

/* Initialize FILE, an LTO file object for FILENAME.  */

static void

lto_file_init (lto_file *file, const char *filename, off_t offset)

{

  file->filename = filename;

  file->offset = offset;

}

/* An ELF file.  */

struct lto_elf_file

{

  /* The base information.  */

  lto_file base;

  /* The system file descriptor for the file.  */

  int fd;

  /* The libelf descriptor for the file.  */

  Elf *elf;

  /* Section number of string table used for section names.  */

  size_t sec_strtab;

  /* Writable file members.  */

  /* The currently active section.  */

  Elf_Scn *scn;

  /* The output stream for section header names.  */

  struct lto_output_stream *shstrtab_stream;

  /* Linked list of data which must be freed *after* the file has been

     closed.  This is an annoying limitation of libelf.  */

  struct lto_char_ptr_base *data;

};

typedef struct lto_elf_file lto_elf_file;

/* Stores executable header attributes which must be shared by all ELF files.

   This is used for validating input files and populating output files.  */

static struct {

  bool initialized;

  /* 32 or 64 bits?  */

  size_t bits;

  unsigned char elf_ident[EI_NIDENT];

  Elf64_Half elf_machine;

} cached_file_attrs;

/* Return the section header for SECTION.  The return value is never

   NULL.  Call lto_elf_free_shdr to release the memory allocated.  */

static Elf64_Shdr *

lto_elf_get_shdr (Elf_Scn *section)

{

  Elf64_Shdr *shdr;

  switch (cached_file_attrs.bits)

    {

    case 32:

      {

        Elf32_Shdr *shdr32;

        /* Read the 32-bit section header.  */

        shdr32 = elf32_getshdr (section);

        if (!shdr32)

          fatal_error ("could not read section header: %s", elf_errmsg (0));

        /* Transform it into a 64-bit section header.  */

        shdr = XNEW (Elf64_Shdr);

        shdr->sh_name = shdr32->sh_name;

        shdr->sh_type = shdr32->sh_type;

        shdr->sh_flags = shdr32->sh_flags;

        shdr->sh_addr = shdr32->sh_addr;

        shdr->sh_offset = shdr32->sh_offset;

        shdr->sh_size = shdr32->sh_size;

        shdr->sh_link = shdr32->sh_link;

        shdr->sh_info = shdr32->sh_info;

        shdr->sh_addralign = shdr32->sh_addralign;

        shdr->sh_entsize  = shdr32->sh_entsize;

        break;

      }

      break;

    case 64:

      shdr = elf64_getshdr (section);

      if (!shdr)

        fatal_error ("could not read section header: %s", elf_errmsg (0));

      break;

    default:

      gcc_unreachable ();

    }

  return shdr;

}

/* Free SHDR, previously allocated by lto_elf_get_shdr.  */

static void

lto_elf_free_shdr (Elf64_Shdr *shdr)

{

  if (cached_file_attrs.bits != 64)

    free (shdr);

}

/* Returns a hash code for P.  */

static hashval_t

hash_name (const void *p)

{

  const struct lto_section_slot *ds = (const struct lto_section_slot *) p;

  return (hashval_t) htab_hash_string (ds->name);

}

/* Returns nonzero if P1 and P2 are equal.  */

static int

eq_name (const void *p1, const void *p2)

{

  const struct lto_section_slot *s1 =

    (const struct lto_section_slot *) p1;

  const struct lto_section_slot *s2 =

    (const struct lto_section_slot *) p2;

  return strcmp (s1->name, s2->name) == 0;

}

/* Build a hash table whose key is the section names and whose data is

   the start and size of each section in the .o file.  */

htab_t

lto_obj_build_section_table (lto_file *lto_file)

{

  lto_elf_file *elf_file = (lto_elf_file *)lto_file;

  htab_t section_hash_table;

  Elf_Scn *section;

  size_t base_offset;

  section_hash_table = htab_create (37, hash_name, eq_name, free);

  base_offset = elf_getbase (elf_file->elf);

  /* We are reasonably sure that elf_getbase does not fail at this

     point.  So assume that we run into the incompatibility with

     the FreeBSD libelf implementation that has a non-working

     elf_getbase for non-archive members in which case the offset

     should be zero.  */

  if (base_offset == (size_t)-1)

    base_offset = 0;

  for (section = elf_getscn (elf_file->elf, 0);

       section;

       section = elf_nextscn (elf_file->elf, section))

    {

      Elf64_Shdr *shdr;

      const char *name;

      size_t offset;

      char *new_name;

      void **slot;

      struct lto_section_slot s_slot;

      /* Get the name of this section.  */

      shdr = lto_elf_get_shdr (section);

      offset = shdr->sh_name;

      name = elf_strptr (elf_file->elf,

                         elf_file->sec_strtab,

                         offset);

      /* Only put lto stuff into the symtab.  */

      if (strncmp (name, LTO_SECTION_NAME_PREFIX,

                   strlen (LTO_SECTION_NAME_PREFIX)) != 0)

        {

          lto_elf_free_shdr (shdr);

          continue;

        }

      new_name = XNEWVEC (char, strlen (name) + 1);

      strcpy (new_name, name);

      s_slot.name = new_name;

      slot = htab_find_slot (section_hash_table, &s_slot, INSERT);

      if (*slot == NULL)

        {

          struct lto_section_slot *new_slot = XNEW (struct lto_section_slot);

          new_slot->name = new_name;

          /* The offset into the file for this section.  */

          new_slot->start = base_offset + shdr->sh_offset;

          new_slot->len = shdr->sh_size;

          *slot = new_slot;

        }

      else

        {

          error ("two or more sections for %s:", new_name);

          return NULL;

        }

      lto_elf_free_shdr (shdr);

    }

  return section_hash_table;

}

/* Initialize the section header of section SCN.  SH_NAME is the section name

   as an index into the section header string table.  SH_TYPE is the section

   type, an SHT_* macro from libelf headers.  */

#define DEFINE_INIT_SHDR(BITS)                                        \

static void                                                           \

init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type)        \

{                                                                     \

  Elf##BITS##_Shdr *shdr;                                             \

                                                                      \

  shdr = elf##BITS##_getshdr (scn);                                   \

  if (!shdr)                                                          \

    {                                                                 \

      if (BITS == 32)                                                 \

        fatal_error ("elf32_getshdr() failed: %s", elf_errmsg (-1));  \

      else                                                            \

        fatal_error ("elf64_getshdr() failed: %s", elf_errmsg (-1));  \

    }                                                                 \

                                                                      \

  shdr->sh_name = sh_name;                                            \

  shdr->sh_type = sh_type;                                            \

  shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT;                  \

  shdr->sh_flags = 0;                                                  \

  shdr->sh_entsize = 0;                                                \

}

DEFINE_INIT_SHDR (32)

DEFINE_INIT_SHDR (64)

static bool first_data_block;

/* Begin a new ELF section named NAME with type TYPE in the current output

   file.  TYPE is an SHT_* macro from the libelf headers.  */

static void

lto_elf_begin_section_with_type (const char *name, size_t type)

{

  lto_elf_file *file;

  Elf_Scn *scn;

  size_t sh_name;

  /* Grab the current output file and do some basic assertion checking.  */

  file = (lto_elf_file *) lto_get_current_out_file (),

  gcc_assert (file);

  gcc_assert (file->elf);

  gcc_assert (!file->scn);

  /* Create a new section.  */

  scn = elf_newscn (file->elf);

  if (!scn)

    fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));

  file->scn = scn;

  /* Add a string table entry and record the offset.  */

  gcc_assert (file->shstrtab_stream);

  sh_name = file->shstrtab_stream->total_size;

  lto_output_data_stream (file->shstrtab_stream, name, strlen (name) + 1);

  /* Initialize the section header.  */

  switch (cached_file_attrs.bits)

    {

    case 32:

      init_shdr32 (scn, sh_name, type);

      break;

    case 64:

      init_shdr64 (scn, sh_name, type);

      break;

    default:

      gcc_unreachable ();

    }

  first_data_block = true;

}

/* Begin a new ELF section named NAME in the current output file.  */

void

lto_obj_begin_section (const char *name)

{

  lto_elf_begin_section_with_type (name, SHT_PROGBITS);

}

/* Append DATA of length LEN to the current output section.  BASE is a pointer

   to the output page containing DATA.  It is freed once the output file has

   been written.  */

void

lto_obj_append_data (const void *data, size_t len, void *block)

{

  lto_elf_file *file;

  Elf_Data *elf_data;

  struct lto_char_ptr_base *base = (struct lto_char_ptr_base *) block;

  /* Grab the current output file and do some basic assertion checking.  */

  file = (lto_elf_file *) lto_get_current_out_file ();

  gcc_assert (file);

  gcc_assert (file->scn);

  elf_data = elf_newdata (file->scn);

  if (!elf_data)

    fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));

  if (first_data_block)

    {

      elf_data->d_align = POINTER_SIZE / BITS_PER_UNIT;

      first_data_block = false;

    }

  else

    elf_data->d_align = 1;

  elf_data->d_buf = CONST_CAST (void *, data);

  elf_data->d_off = 0LL;

  elf_data->d_size = len;

  elf_data->d_type = ELF_T_BYTE;

  elf_data->d_version = EV_CURRENT;

  base->ptr = (char *)file->data;

  file->data = base;

}

/* End the current output section.  This just does some assertion checking

   and sets the current output file's scn member to NULL.  */

void

lto_obj_end_section (void)

{

  lto_elf_file *file;

  /* Grab the current output file and validate some basic assertions.  */

  file = (lto_elf_file *) lto_get_current_out_file ();

  gcc_assert (file);

  gcc_assert (file->scn);

  file->scn = NULL;

}

/* Return true if ELF_MACHINE is compatible with the cached value of the

   architecture and possibly update the latter.  Return false otherwise.

   Note: if you want to add more EM_* cases, you'll need to provide the

   corresponding definitions at the beginning of the file.  */

static bool

is_compatible_architecture (Elf64_Half elf_machine)

{

  if (cached_file_attrs.elf_machine == elf_machine)

    return true;

  switch (cached_file_attrs.elf_machine)

    {

    case EM_SPARC:

      if (elf_machine == EM_SPARC32PLUS)

        {

          cached_file_attrs.elf_machine = elf_machine;

          return true;

        }

      break;

    case EM_SPARC32PLUS:

      if (elf_machine == EM_SPARC)

        return true;

      break;

    default:

      break;

    }

  return false;

}

/* Validate's ELF_FILE's executable header and, if cached_file_attrs is

   uninitialized, caches the architecture.  */

#define DEFINE_VALIDATE_EHDR(BITS)                              \

static bool                                                     \

validate_ehdr##BITS (lto_elf_file *elf_file)                    \

{                                                               \

  Elf##BITS##_Ehdr *elf_header;                                 \

                                                                \

  elf_header = elf##BITS##_getehdr (elf_file->elf);             \

  if (!elf_header)                                              \

    {                                                           \

      error ("could not read ELF header: %s", elf_errmsg (0));   \

      return false;                                             \

    }                                                           \

                                                                \

  if (elf_header->e_type != ET_REL)                             \

    {                                                           \

      error ("not a relocatable ELF object file");              \

      return false;                                             \

    }                                                           \

                                                                \

  if (!cached_file_attrs.initialized)                           \

    cached_file_attrs.elf_machine = elf_header->e_machine;      \

  else if (!is_compatible_architecture (elf_header->e_machine)) \

    {                                                           \

      error ("inconsistent file architecture detected");        \

      return false;                                             \

    }                                                           \

                                                                \

  return true;                                                  \

}

DEFINE_VALIDATE_EHDR (32)

DEFINE_VALIDATE_EHDR (64)

#ifndef HAVE_ELF_GETSHDRSTRNDX

/* elf_getshdrstrndx replacement for systems that lack it, but provide

   either the gABI conformant or Solaris 2 variant of elf_getshstrndx

   instead.  */

static int

elf_getshdrstrndx (Elf *elf, size_t *dst)

{

#ifdef HAVE_ELF_GETSHSTRNDX_GABI

  return elf_getshstrndx (elf, dst);

#else

  return elf_getshstrndx (elf, dst) ? 0 : -1;

#endif

}

#endif

/* Validate's ELF_FILE's executable header and, if cached_file_attrs is

   uninitialized, caches the results.  Also records the section header string

   table's section index.  Returns true on success or false on failure.  */

static bool

validate_file (lto_elf_file *elf_file)

{

  const char *elf_ident;

  /* Some aspects of the libelf API are dependent on whether the

     object file is a 32-bit or 64-bit file.  Determine which kind of

     file this is now.  */

  elf_ident = elf_getident (elf_file->elf, NULL);

  if (!elf_ident)

    {

      error ("could not read ELF identification information: %s",

              elf_errmsg (0));

      return false;

    }

  if (!cached_file_attrs.initialized)

    {

      switch (elf_ident[EI_CLASS])

        {

        case ELFCLASS32:

          cached_file_attrs.bits = 32;

          break;

        case ELFCLASS64:

          cached_file_attrs.bits = 64;

          break;

        default:

          error ("unsupported ELF file class");

          return false;

        }

      memcpy (cached_file_attrs.elf_ident, elf_ident,

              sizeof cached_file_attrs.elf_ident);

    }

  if (memcmp (elf_ident, cached_file_attrs.elf_ident,

              sizeof cached_file_attrs.elf_ident))

    return false;

  /* Check that the input file is a relocatable object file with the correct

     architecture.  */

  switch (cached_file_attrs.bits)

    {

    case 32:

      if (!validate_ehdr32 (elf_file))

        return false;

      break;

    case 64:

      if (!validate_ehdr64 (elf_file))

        return false;

      break;

    default:

      gcc_unreachable ();

    }

  /* Read the string table used for section header names.  */

  if (elf_getshdrstrndx (elf_file->elf, &elf_file->sec_strtab) == -1)

    {

      error ("could not locate ELF string table: %s", elf_errmsg (0));

      return false;

    }

  cached_file_attrs.initialized = true;

  return true;

}

/* Helper functions used by init_ehdr.  Initialize ELF_FILE's executable

   header using cached data from previously read files.  */

#define DEFINE_INIT_EHDR(BITS)                                        \

static void                                                           \

init_ehdr##BITS (lto_elf_file *elf_file)                              \

{                                                                     \

  Elf##BITS##_Ehdr *ehdr;                                             \

                                                                      \

  gcc_assert (cached_file_attrs.bits);                                \

                                                                      \

  ehdr = elf##BITS##_newehdr (elf_file->elf);                         \

  if (!ehdr)                                                          \

    {                                                                 \

      if (BITS == 32)                                                 \

        fatal_error ("elf32_newehdr() failed: %s", elf_errmsg (-1));  \

      else                                                            \

        fatal_error ("elf64_newehdr() failed: %s", elf_errmsg (-1));  \

    }                                                                 \

                                                                      \

  memcpy (ehdr->e_ident, cached_file_attrs.elf_ident,                 \

          sizeof cached_file_attrs.elf_ident);                        \

  ehdr->e_type = ET_REL;                                              \

  ehdr->e_version = EV_CURRENT;                                       \

  ehdr->e_machine = cached_file_attrs.elf_machine;                    \

}

DEFINE_INIT_EHDR (32)

DEFINE_INIT_EHDR (64)

/* Initialize ELF_FILE's executable header using cached data from previously

   read files.  */

static void

init_ehdr (lto_elf_file *elf_file)

{

  switch (cached_file_attrs.bits)

    {

    case 32:

      init_ehdr32 (elf_file);

      break;

    case 64:

      init_ehdr64 (elf_file);

      break;

    default:

      gcc_unreachable ();

    }

}

/* Open ELF file FILENAME.  If WRITABLE is true, the file is opened for write

   and, if necessary, created.  Otherwise, the file is opened for reading.

   Returns the opened file.  */

lto_file *

lto_obj_file_open (const char *filename, bool writable)

{

  lto_elf_file *elf_file;

  lto_file *result = NULL;

  off_t offset;

  long loffset;

  off_t header_offset;

  const char *offset_p;

  char *fname;

  int consumed;

  offset_p = strrchr (filename, '@');

  if (offset_p

      && offset_p != filename

      && sscanf (offset_p, "@%li%n", &loffset, &consumed) >= 1

      && strlen (offset_p) == (unsigned int)consumed)

    {

      fname = (char *) xmalloc (offset_p - filename + 1);

      memcpy (fname, filename, offset_p - filename);

      fname[offset_p - filename] = '\0';

      offset = (off_t)loffset;

      /* elf_rand expects the offset to point to the ar header, not the

         object itself. Subtract the size of the ar header (60 bytes).

         We don't uses sizeof (struct ar_hd) to avoid including ar.h */

      header_offset = offset - 60;

    }

  else

    {

      fname = xstrdup (filename);

      offset = 0;

      header_offset = 0;

    }

  /* Set up.  */

  elf_file = XCNEW (lto_elf_file);

  result = (lto_file *) elf_file;

  lto_file_init (result, fname, offset);

  elf_file->fd = -1;

  /* Open the file.  */

  elf_file->fd = open (fname, writable ? O_WRONLY|O_CREAT|O_BINARY

                                       : O_RDONLY|O_BINARY, 0666);

  if (elf_file->fd == -1)

    {

      error ("could not open file %s", fname);

      goto fail;

    }

  /* Initialize the ELF library.  */

  if (elf_version (EV_CURRENT) == EV_NONE)

    {

      error ("ELF library is older than that used when building GCC");

      goto fail;

    }

  /* Open the ELF file descriptor.  */

  elf_file->elf = elf_begin (elf_file->fd, writable ? ELF_C_WRITE : ELF_C_READ,

                             NULL);

  if (!elf_file->elf)

    {

      error ("could not open ELF file: %s", elf_errmsg (0));

      goto fail;

    }

  if (offset != 0)

    {

      Elf *e;

      off_t t = elf_rand (elf_file->elf, header_offset);

      if (t != header_offset)

        {

          error ("could not seek in archive");

          goto fail;

        }

      e = elf_begin (elf_file->fd, ELF_C_READ, elf_file->elf);

      if (e == NULL)

        {

          error("could not find archive member");

          goto fail;

        }

      elf_end (elf_file->elf);

      elf_file->elf = e;

    }

  if (writable)

    {

      init_ehdr (elf_file);

      elf_file->shstrtab_stream = XCNEW (struct lto_output_stream);

      /* Output an empty string to the section header table.  This becomes the

         name of the initial NULL section.  */

      lto_output_1_stream (elf_file->shstrtab_stream, '\0');

    }

  else

    if (!validate_file (elf_file))

      goto fail;

  return result;

 fail:

  if (result)

    lto_obj_file_close (result);

  return NULL;

}

/* Close ELF file FILE and clean up any associated data structures.  If FILE

   was opened for writing, the file's ELF data is written at this time, and

   any cached data buffers are freed.  */