text: // copy-relocs.h -- handle COPY relocations for gold   -*- C++ -*-
  
  // Copyright 2006, 2007, 2008 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_COPY_RELOCS_H
  #define GOLD_COPY_RELOCS_H
  
  #include "elfcpp.h"
  #include "reloc-types.h"
  #include "output.h"
  
  namespace gold
  {
  
  // This class is used to manage COPY relocations.  We try to avoid
  // them when possible.  A COPY relocation may be required when an
  // executable refers to a variable defined in a shared library.  COPY
  // relocations are problematic because they tie the executable to the
  // exact size of the variable in the shared library.  We can avoid
  // them if all the references to the variable are in a writeable
  // section.  In that case we can simply use dynamic relocations.
  // However, when scanning relocs, we don't know when we see the
  // relocation whether we will be forced to use a COPY relocation or
  // not.  So we have to save the relocation during the reloc scanning,
  // and then emit it as a dynamic relocation if necessary.  This class
  // implements that.  It is used by the target specific code.
  
  // The template parameter SH_TYPE is the type of the reloc section to
  // be used for COPY relocs: elfcpp::SHT_REL or elfcpp::SHT_RELA.
  
  template<int sh_type, int size, bool big_endian>
  class Copy_relocs
  {
   private:
    typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reloc;
  
   public:
    Copy_relocs(unsigned int copy_reloc_type)
      : copy_reloc_type_(copy_reloc_type), dynbss_(NULL), entries_()
    { }
  
    // This is called while scanning relocs if we see a relocation
    // against a symbol which may force us to generate a COPY reloc.
    // SYM is the symbol.  OBJECT is the object whose relocs we are
    // scanning.  The relocation is being applied to section SHNDX in
    // OBJECT.  OUTPUT_SECTION is the output section where section SHNDX
    // will wind up.  REL is the reloc itself.  The Output_data_reloc
    // section is where the dynamic relocs are put.
    void
    copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>* sym,
               Sized_relobj_file<size, big_endian>* object,
  	     unsigned int shndx, Output_section* output_section,
  	     const Reloc& rel,
  	     Output_data_reloc<sh_type, true, size, big_endian>*);
  
    // Return whether there are any saved relocations.
    bool
    any_saved_relocs() const
    { return !this->entries_.empty(); }
  
    // Emit any saved relocations which turn out to be needed.  This is
    // called after all the relocs have been scanned.
    void
    emit(Output_data_reloc<sh_type, true, size, big_endian>*);
  
    // Emit a COPY reloc.
    void
    emit_copy_reloc(Symbol_table*, Sized_symbol<size>*,
  		  Output_data*, off_t,
  		  Output_data_reloc<sh_type, true, size, big_endian>*);
  
   private:
    typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
    typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
  
    // This POD class holds the relocations we are saving.  We will emit
    // these relocations if it turns out that the symbol does not
    // require a COPY relocation.
    class Copy_reloc_entry
    {
     public:
      Copy_reloc_entry(Symbol* sym, unsigned int reloc_type,
  		     Sized_relobj_file<size, big_endian>* relobj,
                       unsigned int shndx,
  		     Output_section* output_section,
  		     Address address, Addend addend)
        : sym_(sym), reloc_type_(reloc_type), relobj_(relobj),
  	shndx_(shndx), output_section_(output_section),
  	address_(address), addend_(addend)
      { }
  
      // Emit this reloc if appropriate.  This is called after we have
      // scanned all the relocations, so we know whether we emitted a
      // COPY relocation for SYM_.
      void
      emit(Output_data_reloc<sh_type, true, size, big_endian>*);
  
     private:
      Symbol* sym_;
      unsigned int reloc_type_;
      Sized_relobj_file<size, big_endian>* relobj_;
      unsigned int shndx_;
      Output_section* output_section_;
      Address address_;
      Addend addend_;
    };
  
    // A list of relocs to be saved.
    typedef std::vector<Copy_reloc_entry> Copy_reloc_entries;
  
    // Return whether we need a COPY reloc.
    bool
    need_copy_reloc(Sized_symbol<size>* gsym,
                    Sized_relobj_file<size, big_endian>* object,
  		  unsigned int shndx) const;
  
    // Make a new COPY reloc and emit it.
    void
    make_copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>*,
  		  Output_data_reloc<sh_type, true, size, big_endian>*);
  
    // Save a reloc against SYM for possible emission later.
    void
    save(Symbol*, Sized_relobj_file<size, big_endian>*, unsigned int shndx,
         Output_section*, const Reloc& rel);
  
    // The target specific relocation type of the COPY relocation.
    const unsigned int copy_reloc_type_;
    // The dynamic BSS data which goes into the .bss section.  This is
    // where variables which require COPY relocations are placed.
    Output_data_space* dynbss_;
    // The list of relocs we are saving.
    Copy_reloc_entries entries_;
  };
  
  } // End namespace gold.
  
  #endif // !defined(GOLD_COPY_RELOCS_H)
  