Subversion Repositories open8_urisc

// reloc.cc -- relocate input files for gold.

// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

// Written by Ian Lance Taylor <iant@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 <algorithm>

#include "workqueue.h"

#include "layout.h"

#include "symtab.h"

#include "output.h"

#include "merge.h"

#include "object.h"

#include "target-reloc.h"

#include "reloc.h"

#include "icf.h"

#include "compressed_output.h"

#include "incremental.h"

namespace gold

{

// Read_relocs methods.

// These tasks just read the relocation information from the file.

// After reading it, the start another task to process the

// information.  These tasks requires access to the file.

Task_token*

Read_relocs::is_runnable()

{

  return this->object_->is_locked() ? this->object_->token() : NULL;

}

// Lock the file.

void

Read_relocs::locks(Task_locker* tl)

{

  Task_token* token = this->object_->token();

  if (token != NULL)

    tl->add(this, token);

}

// Read the relocations and then start a Scan_relocs_task.

void

Read_relocs::run(Workqueue* workqueue)

{

  Read_relocs_data* rd = new Read_relocs_data;

  this->object_->read_relocs(rd);

  this->object_->set_relocs_data(rd);

  this->object_->release();

  // If garbage collection or identical comdat folding is desired, we  

  // process the relocs first before scanning them.  Scanning of relocs is

  // done only after garbage or identical sections is identified.

  if (parameters->options().gc_sections()

      || parameters->options().icf_enabled())

    {

      workqueue->queue_next(new Gc_process_relocs(this->symtab_,

                                                  this->layout_,

                                                  this->object_, rd,

                                                  this->this_blocker_,

                                                  this->next_blocker_));

    }

  else

    {

      workqueue->queue_next(new Scan_relocs(this->symtab_, this->layout_,

                                            this->object_, rd,

                                            this->this_blocker_,

                                            this->next_blocker_));

    }

}

// Return a debugging name for the task.

std::string

Read_relocs::get_name() const

{

  return "Read_relocs " + this->object_->name();

}

// Gc_process_relocs methods.

Gc_process_relocs::~Gc_process_relocs()

{

  if (this->this_blocker_ != NULL)

    delete this->this_blocker_;

}

// These tasks process the relocations read by Read_relocs and

// determine which sections are referenced and which are garbage.

// This task is done only when --gc-sections is used.  This is blocked

// by THIS_BLOCKER_.  It unblocks NEXT_BLOCKER_.

Task_token*

Gc_process_relocs::is_runnable()

{

  if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())

    return this->this_blocker_;

  if (this->object_->is_locked())

    return this->object_->token();

  return NULL;

}

void

Gc_process_relocs::locks(Task_locker* tl)

{

  tl->add(this, this->object_->token());

  tl->add(this, this->next_blocker_);

}

void

Gc_process_relocs::run(Workqueue*)

{

  this->object_->gc_process_relocs(this->symtab_, this->layout_, this->rd_);

  this->object_->release();

}

// Return a debugging name for the task.

std::string

Gc_process_relocs::get_name() const

{

  return "Gc_process_relocs " + this->object_->name();

}

// Scan_relocs methods.

Scan_relocs::~Scan_relocs()

{

  if (this->this_blocker_ != NULL)

    delete this->this_blocker_;

}

// These tasks scan the relocations read by Read_relocs and mark up

// the symbol table to indicate which relocations are required.  We

// use a lock on the symbol table to keep them from interfering with

// each other.

Task_token*

Scan_relocs::is_runnable()

{

  if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())

    return this->this_blocker_;

  if (this->object_->is_locked())

    return this->object_->token();

  return NULL;

}

// Return the locks we hold: one on the file, one on the symbol table

// and one blocker.

void

Scan_relocs::locks(Task_locker* tl)

{

  Task_token* token = this->object_->token();

  if (token != NULL)

    tl->add(this, token);

  tl->add(this, this->next_blocker_);

}

// Scan the relocs.

void

Scan_relocs::run(Workqueue*)

{

  this->object_->scan_relocs(this->symtab_, this->layout_, this->rd_);

  delete this->rd_;

  this->rd_ = NULL;

  this->object_->release();

}

// Return a debugging name for the task.

std::string

Scan_relocs::get_name() const

{

  return "Scan_relocs " + this->object_->name();

}

// Relocate_task methods.

// We may have to wait for the output sections to be written.

Task_token*

Relocate_task::is_runnable()

{

  if (this->object_->relocs_must_follow_section_writes()

      && this->output_sections_blocker_->is_blocked())

    return this->output_sections_blocker_;

  if (this->object_->is_locked())

    return this->object_->token();

  return NULL;

}

// We want to lock the file while we run.  We want to unblock

// INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done.

// INPUT_SECTIONS_BLOCKER may be NULL.

void

Relocate_task::locks(Task_locker* tl)

{

  if (this->input_sections_blocker_ != NULL)

    tl->add(this, this->input_sections_blocker_);

  tl->add(this, this->final_blocker_);

  Task_token* token = this->object_->token();

  if (token != NULL)

    tl->add(this, token);

}

// Run the task.

void

Relocate_task::run(Workqueue*)

{

  this->object_->relocate(this->symtab_, this->layout_, this->of_);

  // This is normally the last thing we will do with an object, so

  // uncache all views.

  this->object_->clear_view_cache_marks();

  this->object_->release();

}

// Return a debugging name for the task.

std::string

Relocate_task::get_name() const

{

  return "Relocate_task " + this->object_->name();

}

// Read the relocs and local symbols from the object file and store

// the information in RD.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::do_read_relocs(Read_relocs_data* rd)

{

  rd->relocs.clear();

  unsigned int shnum = this->shnum();

  if (shnum == 0)

    return;

  rd->relocs.reserve(shnum / 2);

  const Output_sections& out_sections(this->output_sections());

  const std::vector<Address>& out_offsets(this->section_offsets());

  const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),

                                               shnum * This::shdr_size,

                                               true, true);

  // Skip the first, dummy, section.

  const unsigned char* ps = pshdrs + This::shdr_size;

  for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)

    {

      typename This::Shdr shdr(ps);

      unsigned int sh_type = shdr.get_sh_type();

      if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)

        continue;

      unsigned int shndx = this->adjust_shndx(shdr.get_sh_info());

      if (shndx >= shnum)

        {

          this->error(_("relocation section %u has bad info %u"),

                      i, shndx);

          continue;

        }

      Output_section* os = out_sections[shndx];

      if (os == NULL)

        continue;

      // We are scanning relocations in order to fill out the GOT and

      // PLT sections.  Relocations for sections which are not

      // allocated (typically debugging sections) should not add new

      // GOT and PLT entries.  So we skip them unless this is a

      // relocatable link or we need to emit relocations.  FIXME: What

      // should we do if a linker script maps a section with SHF_ALLOC

      // clear to a section with SHF_ALLOC set?

      typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size);

      bool is_section_allocated = ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC)

                                   != 0);

      if (!is_section_allocated

          && !parameters->options().relocatable()

          && !parameters->options().emit_relocs()

          && !parameters->incremental())

        continue;

      if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_)

        {

          this->error(_("relocation section %u uses unexpected "

                        "symbol table %u"),

                      i, this->adjust_shndx(shdr.get_sh_link()));

          continue;

        }

      off_t sh_size = shdr.get_sh_size();

      if (sh_size == 0)

        continue;

      unsigned int reloc_size;

      if (sh_type == elfcpp::SHT_REL)

        reloc_size = elfcpp::Elf_sizes<size>::rel_size;

      else

        reloc_size = elfcpp::Elf_sizes<size>::rela_size;

      if (reloc_size != shdr.get_sh_entsize())

        {

          this->error(_("unexpected entsize for reloc section %u: %lu != %u"),

                      i, static_cast<unsigned long>(shdr.get_sh_entsize()),

                      reloc_size);

          continue;

        }

      size_t reloc_count = sh_size / reloc_size;

      if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)

        {

          this->error(_("reloc section %u size %lu uneven"),

                      i, static_cast<unsigned long>(sh_size));

          continue;

        }

      rd->relocs.push_back(Section_relocs());

      Section_relocs& sr(rd->relocs.back());

      sr.reloc_shndx = i;

      sr.data_shndx = shndx;

      sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size,

                                           true, true);

      sr.sh_type = sh_type;

      sr.reloc_count = reloc_count;

      sr.output_section = os;

      sr.needs_special_offset_handling = out_offsets[shndx] == invalid_address;

      sr.is_data_section_allocated = is_section_allocated;

    }

  // Read the local symbols.

  gold_assert(this->symtab_shndx_ != -1U);

  if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)

    rd->local_symbols = NULL;

  else

    {

      typename This::Shdr symtabshdr(pshdrs

                                     + this->symtab_shndx_ * This::shdr_size);

      gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);

      const int sym_size = This::sym_size;

      const unsigned int loccount = this->local_symbol_count_;

      gold_assert(loccount == symtabshdr.get_sh_info());

      off_t locsize = loccount * sym_size;

      rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),

                                                 locsize, true, true);

    }

}

// Process the relocs to generate mappings from source sections to referenced

// sections.  This is used during garbage collection to determine garbage

// sections.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab,

                                                          Layout* layout,

                                                          Read_relocs_data* rd)

{

  Sized_target<size, big_endian>* target =

    parameters->sized_target<size, big_endian>();

  const unsigned char* local_symbols;

  if (rd->local_symbols == NULL)

    local_symbols = NULL;

  else

    local_symbols = rd->local_symbols->data();

  for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();

       p != rd->relocs.end();

       ++p)

    {

      if (!parameters->options().relocatable())

          {

            // As noted above, when not generating an object file, we

            // only scan allocated sections.  We may see a non-allocated

            // section here if we are emitting relocs.

            if (p->is_data_section_allocated)

              target->gc_process_relocs(symtab, layout, this,

                                        p->data_shndx, p->sh_type,

                                        p->contents->data(), p->reloc_count,

                                        p->output_section,

                                        p->needs_special_offset_handling,

                                        this->local_symbol_count_,

                                        local_symbols);

        }

    }

}

// Scan the relocs and adjust the symbol table.  This looks for

// relocations which require GOT/PLT/COPY relocations.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::do_scan_relocs(Symbol_table* symtab,

                                               Layout* layout,

                                               Read_relocs_data* rd)

{

  Sized_target<size, big_endian>* target =

    parameters->sized_target<size, big_endian>();

  const unsigned char* local_symbols;

  if (rd->local_symbols == NULL)

    local_symbols = NULL;

  else

    local_symbols = rd->local_symbols->data();

  // For incremental links, allocate the counters for incremental relocations.

  if (layout->incremental_inputs() != NULL)

    this->allocate_incremental_reloc_counts();

  for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();

       p != rd->relocs.end();

       ++p)

    {

      // When garbage collection is on, unreferenced sections are not included

      // in the link that would have been included normally. This is known only

      // after Read_relocs hence this check has to be done again.

      if (parameters->options().gc_sections()

          || parameters->options().icf_enabled())

        {

          if (p->output_section == NULL)

            continue;

        }

      if (!parameters->options().relocatable())

        {

          // As noted above, when not generating an object file, we

          // only scan allocated sections.  We may see a non-allocated

          // section here if we are emitting relocs.

          if (p->is_data_section_allocated)

            target->scan_relocs(symtab, layout, this, p->data_shndx,

                                p->sh_type, p->contents->data(),

                                p->reloc_count, p->output_section,

                                p->needs_special_offset_handling,

                                this->local_symbol_count_,

                                local_symbols);

          if (parameters->options().emit_relocs())

            this->emit_relocs_scan(symtab, layout, local_symbols, p);

          if (layout->incremental_inputs() != NULL)

            this->incremental_relocs_scan(p);

        }

      else

        {

          Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx);

          gold_assert(rr != NULL);

          rr->set_reloc_count(p->reloc_count);

          target->scan_relocatable_relocs(symtab, layout, this,

                                          p->data_shndx, p->sh_type,

                                          p->contents->data(),

                                          p->reloc_count,

                                          p->output_section,

                                          p->needs_special_offset_handling,

                                          this->local_symbol_count_,

                                          local_symbols,

                                          rr);

        }

      delete p->contents;

      p->contents = NULL;

    }

  // For incremental links, finalize the allocation of relocations.

  if (layout->incremental_inputs() != NULL)

    this->finalize_incremental_relocs(layout, true);

  if (rd->local_symbols != NULL)

    {

      delete rd->local_symbols;

      rd->local_symbols = NULL;

    }

}

// This is a strategy class we use when scanning for --emit-relocs.

template<int sh_type>

class Emit_relocs_strategy

{

 public:

  // A local non-section symbol.

  inline Relocatable_relocs::Reloc_strategy

  local_non_section_strategy(unsigned int, Relobj*, unsigned int)

  { return Relocatable_relocs::RELOC_COPY; }

  // A local section symbol.

  inline Relocatable_relocs::Reloc_strategy

  local_section_strategy(unsigned int, Relobj*)

  {

    if (sh_type == elfcpp::SHT_RELA)

      return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;

    else

      {

        // The addend is stored in the section contents.  Since this

        // is not a relocatable link, we are going to apply the

        // relocation contents to the section as usual.  This means

        // that we have no way to record the original addend.  If the

        // original addend is not zero, there is basically no way for

        // the user to handle this correctly.  Caveat emptor.

        return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0;

      }

  }

  // A global symbol.

  inline Relocatable_relocs::Reloc_strategy

  global_strategy(unsigned int, Relobj*, unsigned int)

  { return Relocatable_relocs::RELOC_COPY; }

};

// Scan the input relocations for --emit-relocs.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::emit_relocs_scan(

    Symbol_table* symtab,

    Layout* layout,

    const unsigned char* plocal_syms,

    const Read_relocs_data::Relocs_list::iterator& p)

{

  Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx);

  gold_assert(rr != NULL);

  rr->set_reloc_count(p->reloc_count);

  if (p->sh_type == elfcpp::SHT_REL)

    this->emit_relocs_scan_reltype<elfcpp::SHT_REL>(symtab, layout,

                                                    plocal_syms, p, rr);

  else

    {

      gold_assert(p->sh_type == elfcpp::SHT_RELA);

      this->emit_relocs_scan_reltype<elfcpp::SHT_RELA>(symtab, layout,

                                                       plocal_syms, p, rr);

    }

}

// Scan the input relocation for --emit-relocs, templatized on the

// type of the relocation section.

template<int size, bool big_endian>

template<int sh_type>

void

Sized_relobj_file<size, big_endian>::emit_relocs_scan_reltype(

    Symbol_table* symtab,

    Layout* layout,

    const unsigned char* plocal_syms,

    const Read_relocs_data::Relocs_list::iterator& p,

    Relocatable_relocs* rr)

{

  scan_relocatable_relocs<size, big_endian, sh_type,

                          Emit_relocs_strategy<sh_type> >(

    symtab,

    layout,

    this,

    p->data_shndx,

    p->contents->data(),

    p->reloc_count,

    p->output_section,

    p->needs_special_offset_handling,

    this->local_symbol_count_,

    plocal_syms,

    rr);

}

// Scan the input relocations for --incremental.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::incremental_relocs_scan(

    const Read_relocs_data::Relocs_list::iterator& p)

{

  if (p->sh_type == elfcpp::SHT_REL)

    this->incremental_relocs_scan_reltype<elfcpp::SHT_REL>(p);

  else

    {

      gold_assert(p->sh_type == elfcpp::SHT_RELA);

      this->incremental_relocs_scan_reltype<elfcpp::SHT_RELA>(p);

    }

}

// Scan the input relocation for --incremental, templatized on the

// type of the relocation section.

template<int size, bool big_endian>

template<int sh_type>

void

Sized_relobj_file<size, big_endian>::incremental_relocs_scan_reltype(

    const Read_relocs_data::Relocs_list::iterator& p)

{

  typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;

  const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;

  const unsigned char* prelocs = p->contents->data();

  size_t reloc_count = p->reloc_count;

  for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)

    {

      Reltype reloc(prelocs);

      if (p->needs_special_offset_handling

          && !p->output_section->is_input_address_mapped(this, p->data_shndx,

                                                         reloc.get_r_offset()))

        continue;

      typename elfcpp::Elf_types<size>::Elf_WXword r_info =

          reloc.get_r_info();

      const unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);

      if (r_sym >= this->local_symbol_count_)

        this->count_incremental_reloc(r_sym - this->local_symbol_count_);

    }

}

// Relocate the input sections and write out the local symbols.

template<int size, bool big_endian>

void

Sized_relobj_file<size, big_endian>::do_relocate(const Symbol_table* symtab,

                                                 const Layout* layout,

                                                 Output_file* of)