gold/copy-relocs.cc

   1 // copy-relocs.cc -- handle COPY relocations for gold.
   2
   3 // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #include "gold.h"
  24
  25 #include "symtab.h"
  26 #include "copy-relocs.h"
  27
  28 namespace gold
  29 {
  30
  31 // Copy_relocs::Copy_reloc_entry methods.
  32
  33 // Emit the reloc if appropriate.
  34
  35 template<int sh_type, int size, bool big_endian>
  36 void
  37 Copy_relocs<sh_type, size, big_endian>::Copy_reloc_entry::emit(
  38     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
  39 {
  40   // If the symbol is no longer defined in a dynamic object, then we
  41   // emitted a COPY relocation, and we do not want to emit this
  42   // dynamic relocation.
  43   if (this->sym_->is_from_dynobj())
  44     reloc_section->add_global(this->sym_, this->reloc_type_,
  45                               this->output_section_, this->relobj_,
  46                               this->shndx_, this->address_,
  47                               this->addend_);
  48 }
  49
  50 // Copy_relocs methods.
  51
  52 // Handle a relocation against a symbol which may force us to generate
  53 // a COPY reloc.
  54
  55 template<int sh_type, int size, bool big_endian>
  56 void
  57 Copy_relocs<sh_type, size, big_endian>::copy_reloc(
  58     Symbol_table* symtab,
  59     Layout* layout,
  60     Sized_symbol<size>* sym,
  61     Sized_relobj_file<size, big_endian>* object,
  62     unsigned int shndx,
  63     Output_section* output_section,
  64     const Reloc& rel,
  65     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
  66 {
  67   if (this->need_copy_reloc(sym, object, shndx))
  68     this->make_copy_reloc(symtab, layout, sym, reloc_section);
  69   else
  70     {
  71       // We may not need a COPY relocation.  Save this relocation to
  72       // possibly be emitted later.
  73       this->save(sym, object, shndx, output_section, rel);
  74     }
  75 }
  76
  77 // Return whether we need a COPY reloc for a relocation against SYM.
  78 // The relocation is begin applied to section SHNDX in OBJECT.
  79
  80 template<int sh_type, int size, bool big_endian>
  81 bool
  82 Copy_relocs<sh_type, size, big_endian>::need_copy_reloc(
  83     Sized_symbol<size>* sym,
  84     Sized_relobj_file<size, big_endian>* object,
  85     unsigned int shndx) const
  86 {
  87   if (!parameters->options().copyreloc())
  88     return false;
  89
  90   if (sym->symsize() == 0)
  91     return false;
  92
  93   // If this is a readonly section, then we need a COPY reloc.
  94   // Otherwise we can use a dynamic reloc.  Note that calling
  95   // section_flags here can be slow, as the information is not cached;
  96   // fortunately we shouldn't see too many potential COPY relocs.
  97   if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
  98     return true;
  99
 100   return false;
 101 }
 102
 103 // Emit a COPY relocation for SYM.
 104
 105 template<int sh_type, int size, bool big_endian>
 106 void
 107 Copy_relocs<sh_type, size, big_endian>::emit_copy_reloc(
 108     Symbol_table* symtab,
 109     Sized_symbol<size>* sym,
 110     Output_data* posd,
 111     off_t offset,
 112     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
 113 {
 114   // Define the symbol as being copied.
 115   symtab->define_with_copy_reloc(sym, posd, offset);
 116
 117   // Add the COPY relocation to the dynamic reloc section.
 118   reloc_section->add_global(sym, this->copy_reloc_type_, posd, offset, 0);
 119 }
 120
 121 // Make a COPY relocation for SYM and emit it.
 122
 123 template<int sh_type, int size, bool big_endian>
 124 void
 125 Copy_relocs<sh_type, size, big_endian>::make_copy_reloc(
 126     Symbol_table* symtab,
 127     Layout* layout,
 128     Sized_symbol<size>* sym,
 129     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
 130 {
 131   // We should not be here if -z nocopyreloc is given.
 132   gold_assert(parameters->options().copyreloc());
 133
 134   typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize();
 135
 136   // There is no defined way to determine the required alignment of
 137   // the symbol.  We know that the symbol is defined in a dynamic
 138   // object.  We start with the alignment of the section in which it
 139   // is defined; presumably we do not require an alignment larger than
 140   // that.  Then we reduce that alignment if the symbol is not aligned
 141   // within the section.
 142   gold_assert(sym->is_from_dynobj());
 143   bool is_ordinary;
 144   unsigned int shndx = sym->shndx(&is_ordinary);
 145   gold_assert(is_ordinary);
 146   typename elfcpp::Elf_types<size>::Elf_WXword addralign;
 147
 148   {
 149     // Lock the object so we can read from it.  This is only called
 150     // single-threaded from scan_relocs, so it is OK to lock.
 151     // Unfortunately we have no way to pass in a Task token.
 152     const Task* dummy_task = reinterpret_cast<const Task*>(-1);
 153     Object* obj = sym->object();
 154     Task_lock_obj<Object> tl(dummy_task, obj);
 155     addralign = obj->section_addralign(shndx);
 156   }
 157
 158   typename Sized_symbol<size>::Value_type value = sym->value();
 159   while ((value & (addralign - 1)) != 0)
 160     addralign >>= 1;
 161
 162   // Mark the dynamic object as needed for the --as-needed option.
 163   sym->object()->set_is_needed();
 164
 165   if (this->dynbss_ == NULL)
 166     {
 167       this->dynbss_ = new Output_data_space(addralign, "** dynbss");
 168       layout->add_output_section_data(".bss",
 169                                       elfcpp::SHT_NOBITS,
 170                                       elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
 171                                       this->dynbss_, ORDER_BSS, false);
 172     }
 173
 174   Output_data_space* dynbss = this->dynbss_;
 175
 176   if (addralign > dynbss->addralign())
 177     dynbss->set_space_alignment(addralign);
 178
 179   section_size_type dynbss_size =
 180     convert_to_section_size_type(dynbss->current_data_size());
 181   dynbss_size = align_address(dynbss_size, addralign);
 182   section_size_type offset = dynbss_size;
 183   dynbss->set_current_data_size(dynbss_size + symsize);
 184
 185   this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section);
 186 }
 187
 188 // Save a relocation to possibly be emitted later.
 189
 190 template<int sh_type, int size, bool big_endian>
 191 void
 192 Copy_relocs<sh_type, size, big_endian>::save(
 193     Symbol* sym,
 194     Sized_relobj_file<size, big_endian>* object,
 195     unsigned int shndx,
 196     Output_section* output_section,
 197     const Reloc& rel)
 198 {
 199   unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
 200   typename elfcpp::Elf_types<size>::Elf_Addr addend =
 201     Reloc_types<sh_type, size, big_endian>::get_reloc_addend_noerror(&rel);
 202   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, object, shndx,
 203                                             output_section, rel.get_r_offset(),
 204                                             addend));
 205 }
 206
 207 // Emit any saved relocs.
 208
 209 template<int sh_type, int size, bool big_endian>
 210 void
 211 Copy_relocs<sh_type, size, big_endian>::emit(
 212     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
 213 {
 214   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 215        p != this->entries_.end();
 216        ++p)
 217     p->emit(reloc_section);
 218
 219   // We no longer need the saved information.
 220   this->entries_.clear();
 221 }
 222
 223 // Instantiate the templates we need.
 224
 225 #ifdef HAVE_TARGET_32_LITTLE
 226 template
 227 class Copy_relocs<elfcpp::SHT_REL, 32, false>;
 228
 229 template
 230 class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
 231 #endif
 232
 233 #ifdef HAVE_TARGET_32_BIG
 234 template
 235 class Copy_relocs<elfcpp::SHT_REL, 32, true>;
 236
 237 template
 238 class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
 239 #endif
 240
 241 #ifdef HAVE_TARGET_64_LITTLE
 242 template
 243 class Copy_relocs<elfcpp::SHT_REL, 64, false>;
 244
 245 template
 246 class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
 247 #endif
 248
 249 #ifdef HAVE_TARGET_64_BIG
 250 template
 251 class Copy_relocs<elfcpp::SHT_REL, 64, true>;
 252
 253 template
 254 class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
 255 #endif
 256
 257 } // End namespace gold.