Subversion Repositories openrisc_me

// inremental.cc -- incremental linking support for gold

// Copyright 2009 Free Software Foundation, Inc.

// Written by Mikolaj Zalewski <mikolajz@google.com>.

// This file is part of gold.

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

#include "gold.h"

#include <cstdarg>

#include "elfcpp.h"

#include "output.h"

#include "incremental.h"

#include "archive.h"

#include "output.h"

#include "target-select.h"

using elfcpp::Convert;

namespace gold {

// Version information. Will change frequently during the development, later

// we could think about backward (and forward?) compatibility.

const unsigned int INCREMENTAL_LINK_VERSION = 1;

namespace internal {

// Header of the .gnu_incremental_input section.

struct Incremental_inputs_header_data

{

  // Incremental linker version.

  elfcpp::Elf_Word version;

  // Numer of input files in the link.

  elfcpp::Elf_Word input_file_count;

  // Offset of command line options in .gnu_incremental_strtab.

  elfcpp::Elf_Word command_line_offset;

  // Padding.

  elfcpp::Elf_Word reserved;

};

// Data stored in .gnu_incremental_input after the header for each of the

// Incremental_input_header_data::input_file_count input entries.

struct Incremental_inputs_entry_data

{

  // Offset of file name in .gnu_incremental_strtab section.

  elfcpp::Elf_Word filename_offset;

  // Offset of data in .gnu_incremental_input.

  elfcpp::Elf_Word data_offset;

  // Timestamp (in seconds).

  elfcpp::Elf_Xword timestamp_sec;

  // Nano-second part of timestamp (if supported).

  elfcpp::Elf_Word timestamp_nsec;

  // Type of the input entry.

  elfcpp::Elf_Half input_type;

  // Padding.

  elfcpp::Elf_Half reserved;

};

}

// Accessors.

// Reader class for .gnu_incremental_inputs header. See

// internal::Incremental_input_header for fields descriptions.

template<int size, bool big_endian>

class Incremental_inputs_header

{

 public:

  Incremental_inputs_header(const unsigned char *p)

    : p_(reinterpret_cast<const internal::Incremental_inputs_header_data*>(p))

  { }

  static const int data_size = sizeof(internal::Incremental_inputs_header_data);

  elfcpp::Elf_Word

  get_version() const

  { return Convert<32, big_endian>::convert_host(this->p_->version); }

  elfcpp::Elf_Word

  get_input_file_count() const

  { return Convert<32, big_endian>::convert_host(this->p_->input_file_count); }

  elfcpp::Elf_Word

  get_command_line_offset() const

  { return Convert<32, big_endian>::convert_host(this->p_->command_line_offset); }

  elfcpp::Elf_Word

  get_reserved() const

  { return Convert<32, big_endian>::convert_host(this->p_->reserved); }

 private:

  const internal::Incremental_inputs_header_data* p_;

};

// Writer class for .gnu_incremental_inputs header. See

// internal::Incremental_input_header for fields descriptions.

template<int size, bool big_endian>

class Incremental_inputs_header_write

{

 public:

  Incremental_inputs_header_write(unsigned char *p)

    : p_(reinterpret_cast<internal::Incremental_inputs_header_data*>(p))

  { }

  static const int data_size = sizeof(internal::Incremental_inputs_header_data);

  void

  put_version(elfcpp::Elf_Word v)

  { this->p_->version = Convert<32, big_endian>::convert_host(v); }

  void

  put_input_file_count(elfcpp::Elf_Word v)

  { this->p_->input_file_count = Convert<32, big_endian>::convert_host(v); }

  void

  put_command_line_offset(elfcpp::Elf_Word v)

  { this->p_->command_line_offset = Convert<32, big_endian>::convert_host(v); }

  void

  put_reserved(elfcpp::Elf_Word v)

  { this->p_->reserved = Convert<32, big_endian>::convert_host(v); }

 private:

  internal::Incremental_inputs_header_data* p_;

};

// Reader class for an .gnu_incremental_inputs entry. See

// internal::Incremental_input_entry for fields descriptions.

template<int size, bool big_endian>

class Incremental_inputs_entry

{

 public:

  Incremental_inputs_entry(const unsigned char *p)

    : p_(reinterpret_cast<const internal::Incremental_inputs_entry_data*>(p))

  { }

  static const int data_size = sizeof(internal::Incremental_inputs_entry_data);

  elfcpp::Elf_Word

  get_filename_offset(elfcpp::Elf_Word v)

  { return Convert<32, big_endian>::convert_host(this->p_->filename_offset); }

  elfcpp::Elf_Word

  get_data_offset(elfcpp::Elf_Word v)

  { return Convert<32, big_endian>::convert_host(this->p_->data_offset); }

  elfcpp::Elf_Xword

  get_timestamp_sec(elfcpp::Elf_Xword v)

  { return Convert<64, big_endian>::convert_host(this->p_->timestamp_sec); }

  elfcpp::Elf_Word

  get_timestamp_nsec(elfcpp::Elf_Word v)

  { return Convert<32, big_endian>::convert_host(this->p_->timestamp_nsec); }

  elfcpp::Elf_Word

  get_input_type(elfcpp::Elf_Word v)

  { return Convert<32, big_endian>::convert_host(this->p_->input_type); }

  elfcpp::Elf_Word

  get_reserved(elfcpp::Elf_Word v)

  { return Convert<32, big_endian>::convert_host(this->p_->reserved); }

 private:

  const internal::Incremental_inputs_entry_data* p_;

};

// Writer class for an .gnu_incremental_inputs entry. See

// internal::Incremental_input_entry for fields descriptions.

template<int size, bool big_endian>

class Incremental_inputs_entry_write

{

 public:

  Incremental_inputs_entry_write(unsigned char *p)

    : p_(reinterpret_cast<internal::Incremental_inputs_entry_data*>(p))

  { }

  static const int data_size = sizeof(internal::Incremental_inputs_entry_data);

  void

  put_filename_offset(elfcpp::Elf_Word v)

  { this->p_->filename_offset = Convert<32, big_endian>::convert_host(v); }

  void

  put_data_offset(elfcpp::Elf_Word v)

  { this->p_->data_offset = Convert<32, big_endian>::convert_host(v); }

  void

  put_timestamp_sec(elfcpp::Elf_Xword v)

  { this->p_->timestamp_sec = Convert<64, big_endian>::convert_host(v); }

  void

  put_timestamp_nsec(elfcpp::Elf_Word v)

  { this->p_->timestamp_nsec = Convert<32, big_endian>::convert_host(v); }

  void

  put_input_type(elfcpp::Elf_Word v)

  { this->p_->input_type = Convert<32, big_endian>::convert_host(v); }

  void

  put_reserved(elfcpp::Elf_Word v)

  { this->p_->reserved = Convert<32, big_endian>::convert_host(v); }

 private:

  internal::Incremental_inputs_entry_data* p_;

};

// Inform the user why we don't do an incremental link.  Not called in

// the obvious case of missing output file.  TODO: Is this helpful?

void

vexplain_no_incremental(const char* format, va_list args)

{

  char* buf = NULL;

  if (vasprintf(&buf, format, args) < 0)

    gold_nomem();

  gold_info(_("the link might take longer: "

              "cannot perform incremental link: %s"), buf);

  free(buf);

}

void

explain_no_incremental(const char* format, ...)

{

  va_list args;

  va_start(args, format);

  vexplain_no_incremental(format, args);

  va_end(args);

}

// Report an error.

void

Incremental_binary::error(const char* format, ...) const

{

  va_list args;

  va_start(args, format);

  // Current code only checks if the file can be used for incremental linking,

  // so errors shouldn't fail the build, but only result in a fallback to a

  // full build.

  // TODO: when we implement incremental editing of the file, we may need a

  // flag that will cause errors to be treated seriously.

  vexplain_no_incremental(format, args);

  va_end(args);

}

template<int size, bool big_endian>

bool

Sized_incremental_binary<size, big_endian>::do_find_incremental_inputs_section(

    Location* location,

    unsigned int* strtab_shndx)

{

  unsigned int shndx = this->elf_file_.find_section_by_type(

      elfcpp::SHT_GNU_INCREMENTAL_INPUTS);

  if (shndx == elfcpp::SHN_UNDEF)  // Not found.

    return false;

  *strtab_shndx = this->elf_file_.section_link(shndx);

  *location = this->elf_file_.section_contents(shndx);

  return true;

}

template<int size, bool big_endian>

bool

Sized_incremental_binary<size, big_endian>::do_check_inputs(

    Incremental_inputs* incremental_inputs)

{

  const int entry_size =

      Incremental_inputs_entry_write<size, big_endian>::data_size;

  const int header_size =

      Incremental_inputs_header_write<size, big_endian>::data_size;

  unsigned int strtab_shndx;

  Location location;

  if (!do_find_incremental_inputs_section(&location, &strtab_shndx))

    {

      explain_no_incremental(_("no incremental data from previous build"));

      return false;

    }

  if (location.data_size < header_size

      || strtab_shndx >= this->elf_file_.shnum()

      || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)

    {

      explain_no_incremental(_("invalid incremental build data"));

      return false;

    }

  Location strtab_location(this->elf_file_.section_contents(strtab_shndx));

  View data_view(view(location));

  View strtab_view(view(strtab_location));

  elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);

  Incremental_inputs_header<size, big_endian> header(data_view.data());

  if (header.get_version() != INCREMENTAL_LINK_VERSION)

    {

      explain_no_incremental(_("different version of incremental build data"));

      return false;

    }

  const char* command_line;

  // We divide instead of multiplying to make sure there is no integer

  // overflow.

  size_t max_input_entries = (location.data_size - header_size) / entry_size;

  if (header.get_input_file_count() > max_input_entries

      || !strtab.get_c_string(header.get_command_line_offset(), &command_line))

    {

      explain_no_incremental(_("invalid incremental build data"));

      return false;

    }

  if (incremental_inputs->command_line() != command_line)

    {

      explain_no_incremental(_("command line changed"));

      return false;

    }

  // TODO: compare incremental_inputs->inputs() with entries in data_view.

  return true;

}

namespace

{

// Create a Sized_incremental_binary object of the specified size and

// endianness. Fails if the target architecture is not supported.

template<int size, bool big_endian>

Incremental_binary*

make_sized_incremental_binary(Output_file* file,

                              const elfcpp::Ehdr<size, big_endian>& ehdr)

{

  Target* target = select_target(ehdr.get_e_machine(), size, big_endian,

                                 ehdr.get_e_ident()[elfcpp::EI_OSABI],

                                 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);

  if (target == NULL)

    {

      explain_no_incremental(_("unsupported ELF machine number %d"),

               ehdr.get_e_machine());

      return NULL;

    }

  return new Sized_incremental_binary<size, big_endian>(file, ehdr, target);

}

}  // End of anonymous namespace.

// Create an Incremental_binary object for FILE. Returns NULL is this is not

// possible, e.g. FILE is not an ELF file or has an unsupported target. FILE

// should be opened.

Incremental_binary*

open_incremental_binary(Output_file* file)

{

  off_t filesize = file->filesize();

  int want = elfcpp::Elf_recognizer::max_header_size;

  if (filesize < want)

    want = filesize;

  const unsigned char* p = file->get_input_view(0, want);

  if (!elfcpp::Elf_recognizer::is_elf_file(p, want))

    {

      explain_no_incremental(_("output is not an ELF file."));

      return NULL;

    }

  int size;

  bool big_endian;

  std::string error;

  if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian,

                                               &error))

    {

      explain_no_incremental(error.c_str());

      return NULL;

    }

  Incremental_binary* result = NULL;

  if (size == 32)

    {

      if (big_endian)

        {

#ifdef HAVE_TARGET_32_BIG

          result = make_sized_incremental_binary<32, true>(

              file, elfcpp::Ehdr<32, true>(p));

#else

          explain_no_incremental(_("unsupported file: 32-bit, big-endian"));

#endif

        }

      else

        {

#ifdef HAVE_TARGET_32_LITTLE

          result = make_sized_incremental_binary<32, false>(

              file, elfcpp::Ehdr<32, false>(p));

#else

          explain_no_incremental(_("unsupported file: 32-bit, little-endian"));

#endif

        }

    }

  else if (size == 64)

    {

      if (big_endian)

        {

#ifdef HAVE_TARGET_64_BIG

          result = make_sized_incremental_binary<64, true>(

              file, elfcpp::Ehdr<64, true>(p));

#else

          explain_no_incremental(_("unsupported file: 64-bit, big-endian"));

#endif

        }

      else

        {

#ifdef HAVE_TARGET_64_LITTLE

          result = make_sized_incremental_binary<64, false>(

              file, elfcpp::Ehdr<64, false>(p));

#else

          explain_no_incremental(_("unsupported file: 64-bit, little-endian"));

#endif

        }

    }

  else

    gold_unreachable();

  return result;

}

// Analyzes the output file to check if incremental linking is possible and

// (to be done) what files need to be relinked.

bool

Incremental_checker::can_incrementally_link_output_file()

{

  Output_file output(this->output_name_);

  if (!output.open_for_modification())

    return false;

  Incremental_binary* binary = open_incremental_binary(&output);

  if (binary == NULL)

    return false;

  return binary->check_inputs(this->incremental_inputs_);

}

// Add the command line to the string table, setting

// command_line_key_.  In incremental builds, the command line is

// stored in .gnu_incremental_inputs so that the next linker run can

// check if the command line options didn't change.

void

Incremental_inputs::report_command_line(int argc, const char* const* argv)

{

  // Always store 'gold' as argv[0] to avoid a full relink if the user used a

  // different path to the linker.

  std::string args("gold");

  // Copied from collect_argv in main.cc.

  for (int i = 1; i < argc; ++i)

    {

      // Adding/removing these options should result in a full relink.

      if (strcmp(argv[i], "--incremental-changed") == 0

          || strcmp(argv[i], "--incremental-unchanged") == 0

          || strcmp(argv[i], "--incremental-unknown") == 0)

        continue;

      args.append(" '");

      // Now append argv[i], but with all single-quotes escaped

      const char* argpos = argv[i];

      while (1)

        {

          const int len = strcspn(argpos, "'");

          args.append(argpos, len);

          if (argpos[len] == '\0')

            break;

          args.append("'\"'\"'");

          argpos += len + 1;

        }

      args.append("'");

    }

  this->command_line_ = args;

  this->strtab_->add(this->command_line_.c_str(), false,

                     &this->command_line_key_);

}

// Record that the input argument INPUT is an achive ARCHIVE.  This is

// called by Read_symbols after finding out the type of the file.

void

Incremental_inputs::report_archive(const Input_argument* input,

                                   Archive* archive)

{

  Hold_lock hl(*this->lock_);

  Input_info info;

  info.type = INCREMENTAL_INPUT_ARCHIVE;

  info.archive = archive;

  info.mtime = archive->file().get_mtime();

  this->inputs_map_.insert(std::make_pair(input, info));

}

// Record that the input argument INPUT is an object OBJ.  This is

// called by Read_symbols after finding out the type of the file.

void

Incremental_inputs::report_object(const Input_argument* input,

                                  Object* obj)

{

  Hold_lock hl(*this->lock_);

  Input_info info;

  info.type = (obj->is_dynamic()

               ? INCREMENTAL_INPUT_SHARED_LIBRARY

               : INCREMENTAL_INPUT_OBJECT);

  info.object = obj;

  info.mtime = obj->input_file()->file().get_mtime();

  this->inputs_map_.insert(std::make_pair(input, info));

}

// Record that the input argument INPUT is an script SCRIPT.  This is

// called by read_script after parsing the script and reading the list

// of inputs added by this script.

void

Incremental_inputs::report_script(const Input_argument* input,

                                  Timespec mtime,

                                  Script_info* script)

{

  Hold_lock hl(*this->lock_);

  Input_info info;

  info.type = INCREMENTAL_INPUT_SCRIPT;

  info.script = script;

  info.mtime = mtime;

  this->inputs_map_.insert(std::make_pair(input, info));

}

// Compute indexes in the order in which the inputs should appear in

// .gnu_incremental_inputs.  This needs to be done after all the

// scripts are parsed.  The function is first called for the command

// line inputs arguments and may call itself recursively for e.g. a

// list of elements of a group or a list of inputs added by a script.

// The [BEGIN; END) interval to analyze and *INDEX is the current

// value of the index (that will be updated).

void

Incremental_inputs::finalize_inputs(

    Input_argument_list::const_iterator begin,

    Input_argument_list::const_iterator end,

    unsigned int* index)

{

  for (Input_argument_list::const_iterator p = begin; p != end; ++p)

    {

      if (p->is_group())

        {

          finalize_inputs(p->group()->begin(), p->group()->end(), index);

          continue;

        }

      Inputs_info_map::iterator it = this->inputs_map_.find(&(*p));

      // TODO: turn it into an assert when the code will be more stable.

      if (it == this->inputs_map_.end())

        {

          gold_error("internal error: %s: incremental build info not provided",

                     (p->is_file() ? p->file().name() : "[group]"));

          continue;

        }

      Input_info* info = &it->second;

      info->index = *index;

      (*index)++;

      this->strtab_->add(p->file().name(), false, &info->filename_key);

      if (info->type == INCREMENTAL_INPUT_SCRIPT)

        {

          finalize_inputs(info->script->inputs()->begin(),

                          info->script->inputs()->end(),

                          index);

        }

    }

}

// Finalize the incremental link information.  Called from

// Layout::finalize.

void

Incremental_inputs::finalize()

{

  unsigned int index = 0;

  finalize_inputs(this->inputs_->begin(), this->inputs_->end(), &index);

  // Sanity check.

  for (Inputs_info_map::const_iterator p = this->inputs_map_.begin();

       p != this->inputs_map_.end();

       ++p)

    {

      gold_assert(p->second.filename_key != 0);

    }

  this->strtab_->set_string_offsets();

}

// Create the content of the .gnu_incremental_inputs section.

Output_section_data*

Incremental_inputs::create_incremental_inputs_section_data()

{

  switch (parameters->size_and_endianness())

    {

#ifdef HAVE_TARGET_32_LITTLE

    case Parameters::TARGET_32_LITTLE:

      return this->sized_create_inputs_section_data<32, false>();

#endif

#ifdef HAVE_TARGET_32_BIG

    case Parameters::TARGET_32_BIG:

      return this->sized_create_inputs_section_data<32, true>();

#endif

#ifdef HAVE_TARGET_64_LITTLE

    case Parameters::TARGET_64_LITTLE:

      return this->sized_create_inputs_section_data<64, false>();

#endif

#ifdef HAVE_TARGET_64_BIG

    case Parameters::TARGET_64_BIG:

      return this->sized_create_inputs_section_data<64, true>();

#endif

    default:

      gold_unreachable();

    }

}