Subversion Repositories openrisc

/* LTO routines to use object files.

   Copyright 2010 Free Software Foundation, Inc.

   Written by Ian Lance Taylor, Google.

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 "diagnostic-core.h"

#include "lto.h"

#include "tm.h"

#include "lto-streamer.h"

#include "simple-object.h"

/* Segment name for LTO sections.  This is only used for Mach-O.

   FIXME: This needs to be kept in sync with darwin.c.  */

#define LTO_SEGMENT_NAME "__GNU_LTO"

/* An LTO file wrapped around an simple_object.  */

struct lto_simple_object

{

  /* The base information.  */

  lto_file base;

  /* The system file descriptor.  */

  int fd;

  /* The simple_object if we are reading the file.  */

  simple_object_read *sobj_r;

  /* The simple_object if we are writing the file.  */

  simple_object_write *sobj_w;

  /* The currently active section.  */

  simple_object_write_section *section;

};

/* Saved simple_object attributes.  FIXME: Once set, this is never

   cleared.  */

static simple_object_attributes *saved_attributes;

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

}

/* Open the file FILENAME.  It 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)

{

  const char *offset_p;

  long loffset;

  int consumed;

  char *fname;

  off_t offset;

  struct lto_simple_object *lo;

  const char *errmsg;

  int err;

  offset_p = strrchr (filename, '@');

  if (offset_p != NULL

      && offset_p != filename

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

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

    {

      fname = XNEWVEC (char, offset_p - filename + 1);

      memcpy (fname, filename, offset_p - filename);

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

      offset = (off_t) loffset;

    }

  else

    {

      fname = xstrdup (filename);

      offset = 0;

    }

  lo = XCNEW (struct lto_simple_object);

  lto_file_init ((lto_file *) lo, fname, offset);

  lo->fd = open (fname,

                 (writable

                  ? O_WRONLY | O_CREAT | O_BINARY

                  : O_RDONLY | O_BINARY),

                 0666);

  if (lo->fd == -1)

    {

      error ("open %s failed: %s", fname, xstrerror (errno));

      goto fail;

    }

  if (!writable)

    {

      simple_object_attributes *attrs;

      lo->sobj_r = simple_object_start_read (lo->fd, offset, LTO_SEGMENT_NAME,

                                             &errmsg, &err);

      if (lo->sobj_r == NULL)

        goto fail_errmsg;

      attrs = simple_object_fetch_attributes (lo->sobj_r, &errmsg, &err);

      if (attrs == NULL)

        goto fail_errmsg;

      if (saved_attributes == NULL)

        saved_attributes = attrs;

      else

        {

          errmsg = simple_object_attributes_merge (saved_attributes, attrs,

                                                   &err);

          if (errmsg != NULL)

            goto fail_errmsg;

        }

    }

  else

    {

      gcc_assert (saved_attributes != NULL);

      lo->sobj_w = simple_object_start_write (saved_attributes,

                                              LTO_SEGMENT_NAME,

                                              &errmsg, &err);

      if (lo->sobj_w == NULL)

        goto fail_errmsg;

    }

  return &lo->base;

 fail_errmsg:

  if (err == 0)

    error ("%s: %s", fname, errmsg);

  else

    error ("%s: %s: %s", fname, errmsg, xstrerror (err));

 fail:

  if (lo != NULL)

    lto_obj_file_close ((lto_file *) lo);

  return NULL;

}

/* Close FILE.  If FILE was opened for writing, it is written out

   now.  */

void

lto_obj_file_close (lto_file *file)

{

  struct lto_simple_object *lo = (struct lto_simple_object *) file;

  if (lo->sobj_r != NULL)

    simple_object_release_read (lo->sobj_r);

  else if (lo->sobj_w != NULL)

    {

      const char *errmsg;

      int err;

      gcc_assert (lo->base.offset == 0);

      errmsg = simple_object_write_to_file (lo->sobj_w, lo->fd, &err);

      if (errmsg != NULL)

        {

          if (err == 0)

            fatal_error ("%s", errmsg);

          else

            fatal_error ("%s: %s", errmsg, xstrerror (err));

        }

      simple_object_release_write (lo->sobj_w);

    }

  if (lo->fd != -1)

    {

      if (close (lo->fd) < 0)

        fatal_error ("close: %s", xstrerror (errno));

    }

}

/* This is passed to lto_obj_add_section.  */

struct lto_obj_add_section_data

{

  /* The hash table of sections.  */

  htab_t section_hash_table;

  /* The offset of this file.  */

  off_t base_offset;

  /* List in linker order */

  struct lto_section_list *list;

};

/* This is called for each section in the file.  */

static int

lto_obj_add_section (void *data, const char *name, off_t offset,

                     off_t length)

{

  struct lto_obj_add_section_data *loasd =

    (struct lto_obj_add_section_data *) data;

  htab_t section_hash_table = (htab_t) loasd->section_hash_table;

  char *new_name;

  struct lto_section_slot s_slot;

  void **slot;

  struct lto_section_list *list = loasd->list;

  if (strncmp (name, LTO_SECTION_NAME_PREFIX,

               strlen (LTO_SECTION_NAME_PREFIX)) != 0)

    return 1;

  new_name = xstrdup (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 = XCNEW (struct lto_section_slot);

      new_slot->name = new_name;

      new_slot->start = loasd->base_offset + offset;

      new_slot->len = length;

      *slot = new_slot;

      if (list != NULL)

        {

          if (!list->first)

            list->first = new_slot;

          if (list->last)

            list->last->next = new_slot;

          list->last = new_slot;

        }

    }

  else

    {

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

      return 0;

    }

  return 1;

}

/* Build a hash table whose key is the section name 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, struct lto_section_list *list)

{

  struct lto_simple_object *lo = (struct lto_simple_object *) lto_file;

  htab_t section_hash_table;

  struct lto_obj_add_section_data loasd;

  const char *errmsg;

  int err;

  section_hash_table = lto_obj_create_section_hash_table ();

  gcc_assert (lo->sobj_r != NULL && lo->sobj_w == NULL);

  loasd.section_hash_table = section_hash_table;

  loasd.base_offset = lo->base.offset;

  loasd.list = list;

  errmsg = simple_object_find_sections (lo->sobj_r, lto_obj_add_section,

                                        &loasd, &err);

  if (errmsg != NULL)

    {

      if (err == 0)

        error ("%s", errmsg);

      else

        error ("%s: %s", errmsg, xstrerror (err));

      htab_delete (section_hash_table);

      return NULL;

    }

  return section_hash_table;

}

/* The current output file.  */

static lto_file *current_out_file;

/* Set the current output file.  Return the old one.  */

lto_file *

lto_set_current_out_file (lto_file *file)

{

  lto_file *old_file;

  old_file = current_out_file;

  current_out_file = file;

  return old_file;

}

/* Return the current output file.  */

lto_file *

lto_get_current_out_file (void)

{

  return current_out_file;

}

/* Begin writing a new section named NAME in the current output

   file.  */

void

lto_obj_begin_section (const char *name)

{

  struct lto_simple_object *lo;

  int align;

  const char *errmsg;

  int err;

  lo = (struct lto_simple_object *) current_out_file;

  gcc_assert (lo != NULL

              && lo->sobj_r == NULL

              && lo->sobj_w != NULL

              && lo->section == NULL);

  align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT);

  lo->section = simple_object_write_create_section (lo->sobj_w, name, align,

                                                    &errmsg, &err);

  if (lo->section == NULL)

    {

      if (err == 0)

        fatal_error ("%s", errmsg);

      else

        fatal_error ("%s: %s", errmsg, xstrerror (errno));

    }

}

/* Add data to a section.  BLOCK is a pointer to memory containing

   DATA.  */

void

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

{

  struct lto_simple_object *lo;

  const char *errmsg;

  int err;

  lo = (struct lto_simple_object *) current_out_file;

  gcc_assert (lo != NULL && lo->section != NULL);

  errmsg = simple_object_write_add_data (lo->sobj_w, lo->section, data, len,

                                         1, &err);

  if (errmsg != NULL)

    {

      if (err == 0)

        fatal_error ("%s", errmsg);

      else

        fatal_error ("%s: %s", errmsg, xstrerror (errno));

    }

  free (block);

}

/* Stop writing to the current output section.  */

void

lto_obj_end_section (void)

{

  struct lto_simple_object *lo;

  lo = (struct lto_simple_object *) current_out_file;

  gcc_assert (lo != NULL && lo->section != NULL);

  lo->section = NULL;

}