path: root/gold/reloc.h

// reloc.h -- relocate input files for gold   -*- C++ -*-

// Copyright (C) 2006-2016 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.

#ifndef GOLD_RELOC_H
#define GOLD_RELOC_H

#include <vector>
#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
#endif

#include "elfcpp.h"
#include "workqueue.h"

namespace gold
{

class General_options;
class Object;
class Relobj;
struct Read_relocs_data;
class Symbol;
class Layout;
class Output_data;
class Output_section;

template<int size>
class Sized_symbol;

template<int size, bool big_endian>
class Sized_relobj_file;

template<int size>
class Symbol_value;

template<int sh_type, bool dynamic, int size, bool big_endian>
class Output_data_reloc;

// A class to read the relocations for an object file, and then queue
// up a task to see if they require any GOT/PLT/COPY relocations in
// the symbol table.

class Read_relocs : public Task
{
 public:
  //   THIS_BLOCKER and NEXT_BLOCKER are passed along to a Scan_relocs
  // or Gc_process_relocs task, so that they run in a deterministic
  // order.
  Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
	      Task_token* this_blocker, Task_token* next_blocker)
    : symtab_(symtab), layout_(layout), object_(object),
      this_blocker_(this_blocker), next_blocker_(next_blocker)
  { }

  // The standard Task methods.

  Task_token*
  is_runnable();

  void
  locks(Task_locker*);

  void
  run(Workqueue*);

  std::string
  get_name() const;

 private:
  Symbol_table* symtab_;
  Layout* layout_;
  Relobj* object_;
  Task_token* this_blocker_;
  Task_token* next_blocker_;
};

// Process the relocs to figure out which sections are garbage.
// Very similar to scan relocs.

class Gc_process_relocs : public Task
{
 public:
  // THIS_BLOCKER prevents this task from running until the previous
  // one is finished.  NEXT_BLOCKER prevents the next task from
  // running.
  Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
		    Read_relocs_data* rd, Task_token* this_blocker,
		    Task_token* next_blocker)
    : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
      this_blocker_(this_blocker), next_blocker_(next_blocker)
  { }

  ~Gc_process_relocs();

  // The standard Task methods.

  Task_token*
  is_runnable();

  void
  locks(Task_locker*);

  void
  run(Workqueue*);

  std::string
  get_name() const;

 private:
  Symbol_table* symtab_;
  Layout* layout_;
  Relobj* object_;
  Read_relocs_data* rd_;
  Task_token* this_blocker_;
  Task_token* next_blocker_;
};

// Scan the relocations for an object to see if they require any
// GOT/PLT/COPY relocations.

class Scan_relocs : public Task
{
 public:
  // THIS_BLOCKER prevents this task from running until the previous
  // one is finished.  NEXT_BLOCKER prevents the next task from
  // running.
  Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
	      Read_relocs_data* rd, Task_token* this_blocker,
	      Task_token* next_blocker)
    : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
      this_blocker_(this_blocker), next_blocker_(next_blocker)
  { }

  ~Scan_relocs();

  // The standard Task methods.

  Task_token*
  is_runnable();

  void
  locks(Task_locker*);

  void
  run(Workqueue*);

  std::string
  get_name() const;

 private:
  Symbol_table* symtab_;
  Layout* layout_;
  Relobj* object_;
  Read_relocs_data* rd_;
  Task_token* this_blocker_;
  Task_token* next_blocker_;
};

// A class to perform all the relocations for an object file.

class Relocate_task : public Task
{
 public:
  Relocate_task(const Symbol_table* symtab, const Layout* layout,
		Relobj* object, Output_file* of,
		Task_token* input_sections_blocker,
		Task_token* output_sections_blocker, Task_token* final_blocker)
    : symtab_(symtab), layout_(layout), object_(object), of_(of),
      input_sections_blocker_(input_sections_blocker),
      output_sections_blocker_(output_sections_blocker),
      final_blocker_(final_blocker)
  { }

  // The standard Task methods.

  Task_token*
  is_runnable();

  void
  locks(Task_locker*);

  void
  run(Workqueue*);

  std::string
  get_name() const;

 private:
  const Symbol_table* symtab_;
  const Layout* layout_;
  Relobj* object_;
  Output_file* of_;
  Task_token* input_sections_blocker_;
  Task_token* output_sections_blocker_;
  Task_token* final_blocker_;
};

// During a relocatable link, this class records how relocations
// should be handled for a single input reloc section.  An instance of
// this class is created while scanning relocs, and it is used while
// processing relocs.

class Relocatable_relocs
{
 public:
  // We use a vector of unsigned char to indicate how the input relocs
  // should be handled.  Each element is one of the following values.
  // We create this vector when we initially scan the relocations.
  enum Reloc_strategy
  {
    // Copy the input reloc.  Don't modify it other than updating the
    // r_offset field and the r_sym part of the r_info field.
    RELOC_COPY,
    // Copy the input reloc which is against an STT_SECTION symbol.
    // Update the r_offset and r_sym part of the r_info field.  Adjust
    // the addend by subtracting the value of the old local symbol and
    // adding the value of the new local symbol.  The addend is in the
    // SHT_RELA reloc and the contents of the data section do not need
    // to be changed.
    RELOC_ADJUST_FOR_SECTION_RELA,
    // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
    // adjusted.
    RELOC_ADJUST_FOR_SECTION_0,
    // Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
    // section need to be changed.  The number indicates the number of
    // bytes in the addend in the section contents.
    RELOC_ADJUST_FOR_SECTION_1,
    RELOC_ADJUST_FOR_SECTION_2,
    RELOC_ADJUST_FOR_SECTION_4,
    RELOC_ADJUST_FOR_SECTION_8,
    // Like RELOC_ADJUST_FOR_SECTION_4 but for unaligned relocs.
    RELOC_ADJUST_FOR_SECTION_4_UNALIGNED,
    // Discard the input reloc--process it completely when relocating
    // the data section contents.
    RELOC_DISCARD,
    // An input reloc which is not discarded, but which requires
    // target specific processing in order to update it.
    RELOC_SPECIAL
  };

  Relocatable_relocs()
    : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
  { }

  // Record the number of relocs.
  void
  set_reloc_count(size_t reloc_count)
  { this->reloc_strategies_.reserve(reloc_count); }

  // Record what to do for the next reloc.
  void
  set_next_reloc_strategy(Reloc_strategy strategy)
  {
    this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
    if (strategy != RELOC_DISCARD)
      ++this->output_reloc_count_;
  }

  // Record the Output_data associated with this reloc section.
  void
  set_output_data(Output_data* posd)
  {
    gold_assert(this->posd_ == NULL);
    this->posd_ = posd;
  }

  // Return the Output_data associated with this reloc section.
  Output_data*
  output_data() const
  { return this->posd_; }

  // Return what to do for reloc I.
  Reloc_strategy
  strategy(unsigned int i) const
  {
    gold_assert(i < this->reloc_strategies_.size());
    return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
  }

  // Set the strategy for reloc I.
  void
  set_strategy(unsigned int i, Reloc_strategy strategy)
  {
    gold_assert(i < this->reloc_strategies_.size());
    this->reloc_strategies_[i] = strategy;
  }

  // Return the number of relocations to create in the output file.
  size_t
  output_reloc_count() const
  { return this->output_reloc_count_; }

 private:
  typedef std::vector<unsigned char> Reloc_strategies;

  // The strategies for the input reloc.  There is one entry in this
  // vector for each relocation in the input section.
  Reloc_strategies reloc_strategies_;
  // The number of relocations to be created in the output file.
  size_t output_reloc_count_;
  // The output data structure associated with this relocation.
  Output_data* posd_;
};

template<int valsize>
class Bits;

// Standard relocation routines which are used on many targets.  Here
// SIZE and BIG_ENDIAN refer to the target, not the relocation type.

template<int size, bool big_endian>
class Relocate_functions
{
 public:
  typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
  typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addendtype;

  enum Overflow_check
  {
    // No overflow checking.
    CHECK_NONE,
    // Check for overflow of a signed value.
    CHECK_SIGNED,
    // Check for overflow of an unsigned value.
    CHECK_UNSIGNED,
    // Check for overflow of a signed or unsigned value.
    // (i.e., no error if either signed or unsigned fits.)
    CHECK_SIGNED_OR_UNSIGNED
  };

  enum Reloc_status
  {
    RELOC_OK,
    RELOC_OVERFLOW
  };

 private:
  // Check for overflow.
  template<int valsize>
  static inline Reloc_status
  check_overflow(Address value, Overflow_check check)
  {
    switch (check)
      {
      case CHECK_SIGNED:
        if (size == 32)
	  return (Bits<valsize>::has_overflow32(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
	else
	  return (Bits<valsize>::has_overflow(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
      case CHECK_UNSIGNED:
        if (size == 32)
	  return (Bits<valsize>::has_unsigned_overflow32(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
	else
	  return (Bits<valsize>::has_unsigned_overflow(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
      case CHECK_SIGNED_OR_UNSIGNED:
        if (size == 32)
	  return (Bits<valsize>::has_signed_unsigned_overflow32(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
	else
	  return (Bits<valsize>::has_signed_unsigned_overflow64(value)
		  ? RELOC_OVERFLOW
		  : RELOC_OK);
      case CHECK_NONE:
      default:
        return RELOC_OK;
      }
  }

  // Do a simple relocation with the addend in the section contents.
  // VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  rel(unsigned char* view, Address value, Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
    value += addend;
    elfcpp::Swap<valsize, big_endian>::
	writeval(wv, static_cast<Valtype>(value));
    return check_overflow<valsize>(value, check);
  }

  // Like the above but for relocs at unaligned addresses.
  template<int valsize>
  static inline Reloc_status
  rel_unaligned(unsigned char* view, Address value, Overflow_check check)
  {
    typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
	Valtype;
    Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
    value += addend;
    elfcpp::Swap_unaligned<valsize, big_endian>::
	writeval(view, static_cast<Valtype>(value));
    return check_overflow<valsize>(value, check);
  }

  // Do a simple relocation using a Symbol_value with the addend in
  // the section contents.  VALSIZE is the size of the value to
  // relocate.
  template<int valsize>
  static inline Reloc_status
  rel(unsigned char* view,
      const Sized_relobj_file<size, big_endian>* object,
      const Symbol_value<size>* psymval,
      Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
    Address value = psymval->value(object, addend);
    elfcpp::Swap<valsize, big_endian>::
	writeval(wv, static_cast<Valtype>(value));
    return check_overflow<valsize>(value, check);
  }

  // Like the above but for relocs at unaligned addresses.
  template<int valsize>
  static inline Reloc_status
  rel_unaligned(unsigned char* view,
                const Sized_relobj_file<size, big_endian>* object,
                const Symbol_value<size>* psymval,
                Overflow_check check)
  {
    typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
        Valtype;
    Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
    Address value = psymval->value(object, addend);
    elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple relocation with the addend in the relocation.
  // VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  rela(unsigned char* view, Address value, Addendtype addend,
       Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    value += addend;
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple relocation using a symbol value with the addend in
  // the relocation.  VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  rela(unsigned char* view,
       const Sized_relobj_file<size, big_endian>* object,
       const Symbol_value<size>* psymval,
       Addendtype addend,
       Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Address value = psymval->value(object, addend);
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple PC relative relocation with the addend in the section
  // contents.  VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  pcrel(unsigned char* view, Address value, Address address,
	Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
    value = value + addend - address;
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  // Like the above but for relocs at unaligned addresses.
  template<int valsize>
  static inline Reloc_status
  pcrel_unaligned(unsigned char* view, Address value, Address address,
		  Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
    value = value + addend - address;
    elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple PC relative relocation with a Symbol_value with the
  // addend in the section contents.  VALSIZE is the size of the
  // value.
  template<int valsize>
  static inline Reloc_status
  pcrel(unsigned char* view,
	const Sized_relobj_file<size, big_endian>* object,
	const Symbol_value<size>* psymval,
	Address address,
	Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
    Address value = psymval->value(object, addend) - address;
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple PC relative relocation with the addend in the
  // relocation.  VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  pcrela(unsigned char* view, Address value, Addendtype addend, Address address,
	 Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    value = value + addend - address;
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  // Do a simple PC relative relocation with a Symbol_value with the
  // addend in the relocation.  VALSIZE is the size of the value.
  template<int valsize>
  static inline Reloc_status
  pcrela(unsigned char* view,
	 const Sized_relobj_file<size, big_endian>* object,
	 const Symbol_value<size>* psymval,
	 Addendtype addend,
	 Address address,
	 Overflow_check check)
  {
    typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
    Valtype* wv = reinterpret_cast<Valtype*>(view);
    Address value = psymval->value(object, addend) - address;
    elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
    return check_overflow<valsize>(value, check);
  }

  typedef Relocate_functions<size, big_endian> This;

 public:
  // Do a simple 8-bit REL relocation with the addend in the section
  // contents.
  static inline void
  rel8(unsigned char* view, Address value)
  { This::template rel<8>(view, value, CHECK_NONE); }

  static inline Reloc_status
  rel8_check(unsigned char* view, Address value, Overflow_check check)
  { return This::template rel<8>(view, value, check); }

  static inline void
  rel8(unsigned char* view,
       const Sized_relobj_file<size, big_endian>* object,
       const Symbol_value<size>* psymval)
  { This::template rel<8>(view, object, psymval, CHECK_NONE); }

  static inline Reloc_status
  rel8_check(unsigned char* view,
	     const Sized_relobj_file<size, big_endian>* object,
	     const Symbol_value<size>* psymval,
	     Overflow_check check)
  { return This::template rel<8>(view, object, psymval, check); }

  // Do an 8-bit RELA relocation with the addend in the relocation.
  static inline void
  rela8(unsigned char* view, Address value, Addendtype addend)
  { This::template rela<8>(view, value, addend, CHECK_NONE); }

  static inline Reloc_status
  rela8_check(unsigned char* view, Address value, Addendtype addend,
	      Overflow_check check)
  { return This::template rela<8>(view, value, addend, check); }

  static inline void
  rela8(unsigned char* view,
	const Sized_relobj_file<size, big_endian>* object,
	const Symbol_value<size>* psymval,
	Addendtype addend)
  { This::template rela<8>(view, object, psymval, addend, CHECK_NONE); }

  static inline Reloc_status
  rela8_check(unsigned char* view,
	      const Sized_relobj_file<size, big_endian>* object,
	      const Symbol_value<size>* psymval,
	      Addendtype addend,
	      Overflow_check check)
  { return This::template rela<8>(view, object, psymval, addend, check); }

  // Do a simple 8-bit PC relative relocation with the addend in the
  // section contents.
  static inline void
  pcrel8(unsigned char* view, unsigned char value, Address address)
  { This::template pcrel<8>(view, value, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel8_check(unsigned char* view, unsigned char value, Address address,
	       Overflow_check check)
  { return This::template pcrel<8>(view, value, address, check); }

  static inline void
  pcrel8(unsigned char* view,
	 const Sized_relobj_file<size, big_endian>* object,
	 const Symbol_value<size>* psymval,
	 Address address)
  { This::template pcrel<8>(view, object, psymval, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel8_check(unsigned char* view,
	       const Sized_relobj_file<size, big_endian>* object,
	       const Symbol_value<size>* psymval,
	       Address address,
	       Overflow_check check)
  { return This::template pcrel<8>(view, object, psymval, address, check); }

  // Do a simple 8-bit PC relative RELA relocation with the addend in
  // the reloc.
  static inline void
  pcrela8(unsigned char* view, Address value, Addendtype addend,
	  Address address)
  { This::template pcrela<8>(view, value, addend, address, CHECK_NONE); }

  static inline Reloc_status
  pcrela8_check(unsigned char* view, Address value, Addendtype addend,
		Address address, Overflow_check check)
  { return This::template pcrela<8>(view, value, addend, address, check); }

  static inline void
  pcrela8(unsigned char* view,
	  const Sized_relobj_file<size, big_endian>* object,
	  const Symbol_value<size>* psymval,
	  Addendtype addend,
	  Address address)
  { This::template pcrela<8>(view, object, psymval, addend, address,
			     CHECK_NONE); }

  static inline Reloc_status
  pcrela8_check(unsigned char* view,
		const Sized_relobj_file<size, big_endian>* object,
		const Symbol_value<size>* psymval,
		Addendtype addend,
		Address address,
		Overflow_check check)
  { return This::template pcrela<8>(view, object, psymval, addend, address,
				    check); }

  // Do a simple 16-bit REL relocation with the addend in the section
  // contents.
  static inline void
  rel16(unsigned char* view, Address value)
  { This::template rel<16>(view, value, CHECK_NONE); }

  static inline Reloc_status
  rel16_check(unsigned char* view, Address value, Overflow_check check)
  { return This::template rel<16>(view, value, check); }

  static inline void
  rel16(unsigned char* view,
	const Sized_relobj_file<size, big_endian>* object,
	const Symbol_value<size>* psymval)
  { This::template rel<16>(view, object, psymval, CHECK_NONE); }

  static inline Reloc_status
  rel16_check(unsigned char* view,
	      const Sized_relobj_file<size, big_endian>* object,
	      const Symbol_value<size>* psymval,
	      Overflow_check check)
  { return This::template rel<16>(view, object, psymval, check); }

  // Do an 16-bit RELA relocation with the addend in the relocation.
  static inline void
  rela16(unsigned char* view, Address value, Addendtype addend)
  { This::template rela<16>(view, value, addend, CHECK_NONE); }

  static inline Reloc_status
  rela16_check(unsigned char* view, Address value, Addendtype addend,
	       Overflow_check check)
  { return This::template rela<16>(view, value, addend, check); }

  static inline void
  rela16(unsigned char* view,
	 const Sized_relobj_file<size, big_endian>* object,
	 const Symbol_value<size>* psymval,
	 Addendtype addend)
  { This::template rela<16>(view, object, psymval, addend, CHECK_NONE); }

  static inline Reloc_status
  rela16_check(unsigned char* view,
	       const Sized_relobj_file<size, big_endian>* object,
	       const Symbol_value<size>* psymval,
	       Addendtype addend,
	       Overflow_check check)
  { return This::template rela<16>(view, object, psymval, addend, check); }

  // Do a simple 16-bit PC relative REL relocation with the addend in
  // the section contents.
  static inline void
  pcrel16(unsigned char* view, Address value, Address address)
  { This::template pcrel<16>(view, value, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel16_check(unsigned char* view, Address value, Address address,
		Overflow_check check)
  { return This::template pcrel<16>(view, value, address, check); }

  static inline void
  pcrel16(unsigned char* view,
	  const Sized_relobj_file<size, big_endian>* object,
	  const Symbol_value<size>* psymval,
	  Address address)
  { This::template pcrel<16>(view, object, psymval, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel16_check(unsigned char* view,
		const Sized_relobj_file<size, big_endian>* object,
		const Symbol_value<size>* psymval,
		Address address,
		Overflow_check check)
  { return This::template pcrel<16>(view, object, psymval, address, check); }

  // Do a simple 16-bit PC relative RELA relocation with the addend in
  // the reloc.
  static inline void
  pcrela16(unsigned char* view, Address value, Addendtype addend,
	   Address address)
  { This::template pcrela<16>(view, value, addend, address, CHECK_NONE); }

  static inline Reloc_status
  pcrela16_check(unsigned char* view, Address value, Addendtype addend,
		 Address address, Overflow_check check)
  { return This::template pcrela<16>(view, value, addend, address, check); }

  static inline void
  pcrela16(unsigned char* view,
	   const Sized_relobj_file<size, big_endian>* object,
	   const Symbol_value<size>* psymval,
	   Addendtype addend,
	   Address address)
  { This::template pcrela<16>(view, object, psymval, addend, address,
			      CHECK_NONE); }

  static inline Reloc_status
  pcrela16_check(unsigned char* view,
		 const Sized_relobj_file<size, big_endian>* object,
		 const Symbol_value<size>* psymval,
		 Addendtype addend,
		 Address address,
		 Overflow_check check)
  { return This::template pcrela<16>(view, object, psymval, addend, address,
				     check); }

  // Do a simple 32-bit REL relocation with the addend in the section
  // contents.
  static inline void
  rel32(unsigned char* view, Address value)
  { This::template rel<32>(view, value, CHECK_NONE); }

  static inline Reloc_status
  rel32_check(unsigned char* view, Address value, Overflow_check check)
  { return This::template rel<32>(view, value, check); }

  // Like above but for relocs at unaligned addresses.
  static inline void
  rel32_unaligned(unsigned char* view, Address value)
  { This::template rel_unaligned<32>(view, value, CHECK_NONE); }

  static inline Reloc_status
  rel32_unaligned_check(unsigned char* view, Address value,
			Overflow_check check)
  { return This::template rel_unaligned<32>(view, value, check); }

  static inline void
  rel32(unsigned char* view,
	const Sized_relobj_file<size, big_endian>* object,
	const Symbol_value<size>* psymval)
  { This::template rel<32>(view, object, psymval, CHECK_NONE); }

  static inline Reloc_status
  rel32_check(unsigned char* view,
	      const Sized_relobj_file<size, big_endian>* object,
	      const Symbol_value<size>* psymval,
	      Overflow_check check)
  { return This::template rel<32>(view, object, psymval, check); }

  // Like above but for relocs at unaligned addresses.
  static inline void
  rel32_unaligned(unsigned char* view,
	          const Sized_relobj_file<size, big_endian>* object,
	          const Symbol_value<size>* psymval)
  { This::template rel_unaligned<32>(view, object, psymval, CHECK_NONE); }

  static inline Reloc_status
  rel32_unaligned_check(unsigned char* view,
			const Sized_relobj_file<size, big_endian>* object,
			const Symbol_value<size>* psymval,
			Overflow_check check)
  { return This::template rel_unaligned<32>(view, object, psymval, check); }

  // Do a 32-bit RELA relocation with the addend in the relocation.
  static inline void
  rela32(unsigned char* view, Address value, Addendtype addend)
  { This::template rela<32>(view, value, addend, CHECK_NONE); }

  static inline Reloc_status
  rela32(unsigned char* view, Address value, Addendtype addend,
	 Overflow_check check)
  { return This::template rela<32>(view, value, addend, check); }

  static inline void
  rela32(unsigned char* view,
	 const Sized_relobj_file<size, big_endian>* object,
	 const Symbol_value<size>* psymval,
	 Addendtype addend)
  { This::template rela<32>(view, object, psymval, addend, CHECK_NONE); }

  static inline Reloc_status
  rela32_check(unsigned char* view,
	       const Sized_relobj_file<size, big_endian>* object,
	       const Symbol_value<size>* psymval,
	       Addendtype addend,
	       Overflow_check check)
  { return This::template rela<32>(view, object, psymval, addend, check); }

  // Do a simple 32-bit PC relative REL relocation with the addend in
  // the section contents.
  static inline void
  pcrel32(unsigned char* view, Address value, Address address)
  { This::template pcrel<32>(view, value, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel32_check(unsigned char* view, Address value, Address address,
		Overflow_check check)
  { return This::template pcrel<32>(view, value, address, check); }

  // Unaligned version of the above.
  static inline void
  pcrel32_unaligned(unsigned char* view, Address value, Address address)
  { This::template pcrel_unaligned<32>(view, value, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel32_unaligned_check(unsigned char* view, Address value, Address address,
			  Overflow_check check)
  { return This::template pcrel_unaligned<32>(view, value, address, check); }

  static inline void
  pcrel32(unsigned char* view,
	  const Sized_relobj_file<size, big_endian>* object,
	  const Symbol_value<size>* psymval,
	  Address address)
  { This::template pcrel<32>(view, object, psymval, address, CHECK_NONE); }

  static inline Reloc_status
  pcrel32_check(unsigned char* view,
		const Sized_relobj_file<size, big_endian>* object,
		const Symbol_value<size>* psymval,
		Address address,
		Overflow_check check)
  { return This::template pcrel<32>(view, object, psymval, address, check); }

  // Do a simple 32-bit PC relative RELA relocation with the addend in
  // the relocation.
  static inline void
  pcrela32(unsigned char* view, Address value, Addendtype addend,
           Address address)
  { This::template pcrela<32>(view, value, addend, address, CHECK_NONE); }

  static inline Reloc_status
  pcrela32_check(unsigned char* view, Address value, Addendtype addend,
           Address address, Overflow_check check)
  { return This::template pcrela<32>(view, value, addend, address, check); }

  static inline void
  pcrela32(unsigned char* view,
	   const Sized_relobj_file<size, big_endian>* object,
	   const Symbol_value<size>* psymval,
	   Addendtype addend,
	   Address address)
  { This::template pcrela<32>(view, object, psymval, addend, address,
			      CHECK_NONE); }

  static inline Reloc_status
  pcrela32_check(unsigned char* view,
	   const Sized_relobj_file<size, big_endian>* object,
	   const Symbol_value<size>* psymval,
	   Addendtype addend,
	   Address address,
	   Overflow_check check)
  { return This::template pcrela<32>(view, object, psymval, addend, address,
				     check); }

  // Do a simple 64-bit REL relocation with the addend in the section
  // contents.
  static inline void
  rel64(unsigned char* view, Address value)
  { This::template rel<64>(view, value, CHECK_NONE); }

  static inline void
  rel64(unsigned char* view,
	const Sized_relobj_file<size, big_endian>* object,
	const Symbol_value<size>* psymval)
  { This::template rel<64>(view, object, psymval, CHECK_NONE); }

  // Do a 64-bit RELA relocation with the addend in the relocation.
  static inline void
  rela64(unsigned char* view, Address value, Addendtype addend)
  { This::template rela<64>(view, value, addend, CHECK_NONE); }

  static inline void
  rela64(unsigned char* view,
	 const Sized_relobj_file<size, big_endian>* object,
	 const Symbol_value<size>* psymval,
	 Addendtype addend)
  { This::template rela<64>(view, object, psymval, addend, CHECK_NONE); }

  // Do a simple 64-bit PC relative REL relocation with the addend in
  // the section contents.
  static inline void
  pcrel64(unsigned char* view, Address value, Address address)
  { This::template pcrel<64>(view, value, address, CHECK_NONE); }

  static inline void
  pcrel64(unsigned char* view,
	  const Sized_relobj_file<size, big_endian>* object,
	  const Symbol_value<size>* psymval,
	  Address address)
  { This::template pcrel<64>(view, object, psymval, address, CHECK_NONE); }

  // Do a simple 64-bit PC relative RELA relocation with the addend in
  // the relocation.
  static inline void
  pcrela64(unsigned char* view, Address value, Addendtype addend,
	   Address address)
  { This::template pcrela<64>(view, value, addend, address, CHECK_NONE); }

  static inline void
  pcrela64(unsigned char* view,
	   const Sized_relobj_file<size, big_endian>* object,
	   const Symbol_value<size>* psymval,
	   Addendtype addend,
	   Address address)
  { This::template pcrela<64>(view, object, psymval, addend, address,
			      CHECK_NONE); }
};

// Convenience class for min and max values of a given BITS length.

template<int bits>
class Limits
{
 public:
  static const uint64_t MAX_UNSIGNED = (1ULL << bits) - 1;
  static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
  static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
};

template<>
class Limits<64>
{
 public:
  static const uint64_t MAX_UNSIGNED = ~0ULL;
  static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
  static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
};

// Integer manipulation functions used by various targets when
// performing relocations.

template<int bits>
class Bits
{
 public:
  // Sign extend an n-bit unsigned integer stored in a uint32_t into
  // an int32_t.  BITS must be between 1 and 32.
  static inline int32_t
  sign_extend32(uint32_t val)
  {
    gold_assert(bits > 0 && bits <= 32);
    if (bits == 32)
      return static_cast<int32_t>(val);
    uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
    val &= mask;
    uint32_t top_bit = 1U << (bits - 1);
    int32_t as_signed = static_cast<int32_t>(val);
    if ((val & top_bit) != 0)
      as_signed -= static_cast<int32_t>(top_bit * 2);
    return as_signed;    
  }

  // Return true if VAL (stored in a uint32_t) has overflowed a signed
  // value with BITS bits.
  static inline bool
  has_overflow32(uint32_t val)
  {
    gold_assert(bits > 0 && bits <= 32);
    if (bits == 32)
      return false;
    const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_SIGNED);
    const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
    int32_t as_signed = static_cast<int32_t>(val);
    return as_signed > max || as_signed < min;
  }

  // Return true if VAL (stored in a uint32_t) has overflowed an unsigned
  // value with BITS bits.
  static inline bool
  has_unsigned_overflow32(uint32_t val)
  {
    gold_assert(bits > 0 && bits <= 32);
    if (bits == 32)
      return false;
    const uint32_t max = static_cast<uint32_t>(Limits<bits>::MAX_UNSIGNED);
    return val > max;
  }

  // Return true if VAL (stored in a uint32_t) has overflowed both a
  // signed and an unsigned value.  E.g.,
  // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
  // 255.
  static inline bool
  has_signed_unsigned_overflow32(uint32_t val)
  {
    gold_assert(bits > 0 && bits <= 32);
    if (bits == 32)
      return false;
    const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_UNSIGNED);
    const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
    int32_t as_signed = static_cast<int32_t>(val);
    return as_signed > max || as_signed < min;
  }

  // Select bits from A and B using bits in MASK.  For each n in
  // [0..31], the n-th bit in the result is chosen from the n-th bits
  // of A and B.  A zero selects A and a one selects B.
  static inline uint32_t
  bit_select32(uint32_t a, uint32_t b, uint32_t mask)
  { return (a & ~mask) | (b & mask); }

  // Sign extend an n-bit unsigned integer stored in a uint64_t into
  // an int64_t.  BITS must be between 1 and 64.
  static inline int64_t
  sign_extend(uint64_t val)
  {
    gold_assert(bits > 0 && bits <= 64);
    if (bits == 64)
      return static_cast<int64_t>(val);
    uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
    val &= mask;
    uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
    int64_t as_signed = static_cast<int64_t>(val);
    if ((val & top_bit) != 0)
      as_signed -= static_cast<int64_t>(top_bit * 2);
    return as_signed;    
  }

  // Return true if VAL (stored in a uint64_t) has overflowed a signed
  // value with BITS bits.
  static inline bool
  has_overflow(uint64_t val)
  {
    gold_assert(bits > 0 && bits <= 64);
    if (bits == 64)
      return false;
    const int64_t max = Limits<bits>::MAX_SIGNED;
    const int64_t min = Limits<bits>::MIN_SIGNED;
    int64_t as_signed = static_cast<int64_t>(val);
    return as_signed > max || as_signed < min;
  }

  // Return true if VAL (stored in a uint64_t) has overflowed an unsigned
  // value with BITS bits.
  static inline bool
  has_unsigned_overflow(uint64_t val)
  {
    gold_assert(bits > 0 && bits <= 64);
    if (bits == 64)
      return false;
    const uint64_t max = Limits<bits>::MAX_UNSIGNED;
    return val > max;
  }

  // Return true if VAL (stored in a uint64_t) has overflowed both a
  // signed and an unsigned value.  E.g.,
  // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
  // 255.
  static inline bool
  has_signed_unsigned_overflow64(uint64_t val)
  {
    gold_assert(bits > 0 && bits <= 64);
    if (bits == 64)
      return false;
    const int64_t max = static_cast<int64_t>(Limits<bits>::MAX_UNSIGNED);
    const int64_t min = Limits<bits>::MIN_SIGNED;
    int64_t as_signed = static_cast<int64_t>(val);
    return as_signed > max || as_signed < min;
  }

  // Select bits from A and B using bits in MASK.  For each n in
  // [0..31], the n-th bit in the result is chosen from the n-th bits
  // of A and B.  A zero selects A and a one selects B.
  static inline uint64_t
  bit_select64(uint64_t a, uint64_t b, uint64_t mask)
  { return (a & ~mask) | (b & mask); }
};

// Track relocations while reading a section.  This lets you ask for
// the relocation at a certain offset, and see how relocs occur
// between points of interest.

template<int size, bool big_endian>
class Track_relocs
{
 public:
  Track_relocs()
    : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
  { }

  // Initialize the Track_relocs object.  OBJECT is the object holding
  // the reloc section, RELOC_SHNDX is the section index of the reloc
  // section, and RELOC_TYPE is the type of the reloc section
  // (elfcpp::SHT_REL or elfcpp::SHT_RELA).  This returns false if
  // something went wrong.
  bool
  initialize(Object* object, unsigned int reloc_shndx,
	     unsigned int reloc_type);

  // Return the offset in the data section to which the next reloc
  // applies.  This returns -1 if there is no next reloc.
  off_t
  next_offset() const;

  // Return the symbol index of the next reloc.  This returns -1U if
  // there is no next reloc.
  unsigned int
  next_symndx() const;

  // Return the addend of the next reloc.  This returns 0 if there is
  // no next reloc.
  uint64_t
  next_addend() const;

  // Advance to OFFSET within the data section, and return the number
  // of relocs which would be skipped.
  int
  advance(off_t offset);

  // Checkpoint the current position in the reloc section.
  section_size_type
  checkpoint() const
  { return this->pos_; }

  // Reset the position to CHECKPOINT.
  void
  reset(section_size_type checkpoint)
  { this->pos_ = checkpoint; }

 private:
  // The contents of the input object's reloc section.
  const unsigned char* prelocs_;
  // The length of the reloc section.
  section_size_type len_;
  // Our current position in the reloc section.
  section_size_type pos_;
  // The size of the relocs in the section.
  int reloc_size_;
};

} // End namespace gold.

#endif // !defined(GOLD_RELOC_H)