gold/copy-relocs.cc

   1 // copy-relocs.cc -- handle COPY relocations for gold.
   2
   3 // Copyright (C) 2006-2020 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 methods.
  32
  33 // Handle a relocation against a symbol which may force us to generate
  34 // a COPY reloc.
  35
  36 template<int sh_type, int size, bool big_endian>
  37 void
  38 Copy_relocs<sh_type, size, big_endian>::copy_reloc(
  39     Symbol_table* symtab,
  40     Layout* layout,
  41     Sized_symbol<size>* sym,
  42     Sized_relobj_file<size, big_endian>* object,
  43     unsigned int shndx,
  44     Output_section* output_section,
  45     unsigned int r_type,
  46     typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
  47     typename elfcpp::Elf_types<size>::Elf_Swxword r_addend,
  48     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
  49 {
  50   if (this->need_copy_reloc(sym, object, shndx))
  51     this->make_copy_reloc(symtab, layout, sym, object, reloc_section);
  52   else
  53     {
  54       // We may not need a COPY relocation.  Save this relocation to
  55       // possibly be emitted later.
  56       this->save(sym, object, shndx, output_section,
  57                  r_type, r_offset, r_addend);
  58     }
  59 }
  60
  61 // Return whether we need a COPY reloc for a relocation against SYM.
  62 // The relocation is begin applied to section SHNDX in OBJECT.
  63
  64 template<int sh_type, int size, bool big_endian>
  65 bool
  66 Copy_relocs<sh_type, size, big_endian>::need_copy_reloc(
  67     Sized_symbol<size>* sym,
  68     Sized_relobj_file<size, big_endian>* object,
  69     unsigned int shndx) const
  70 {
  71   if (!parameters->options().copyreloc())
  72     return false;
  73
  74   if (sym->symsize() == 0)
  75     return false;
  76
  77   // If this is a readonly section, then we need a COPY reloc.
  78   // Otherwise we can use a dynamic reloc.  Note that calling
  79   // section_flags here can be slow, as the information is not cached;
  80   // fortunately we shouldn't see too many potential COPY relocs.
  81   if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
  82     return true;
  83
  84   return false;
  85 }
  86
  87 // Emit a COPY relocation for SYM.
  88
  89 template<int sh_type, int size, bool big_endian>
  90 void
  91 Copy_relocs<sh_type, size, big_endian>::emit_copy_reloc(
  92     Symbol_table* symtab,
  93     Sized_symbol<size>* sym,
  94     Output_data* posd,
  95     off_t offset,
  96     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
  97 {
  98   // Define the symbol as being copied.
  99   symtab->define_with_copy_reloc(sym, posd, offset);
 100
 101   // Add the COPY relocation to the dynamic reloc section.
 102   reloc_section->add_global_generic(sym, this->copy_reloc_type_, posd,
 103                                     offset, 0);
 104 }
 105
 106 // Make a COPY relocation for SYM and emit it.
 107
 108 template<int sh_type, int size, bool big_endian>
 109 void
 110 Copy_relocs<sh_type, size, big_endian>::make_copy_reloc(
 111     Symbol_table* symtab,
 112     Layout* layout,
 113     Sized_symbol<size>* sym,
 114     Sized_relobj_file<size, big_endian>* object,
 115     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
 116 {
 117   // We should not be here if -z nocopyreloc is given.
 118   gold_assert(parameters->options().copyreloc());
 119
 120   gold_assert(sym->is_from_dynobj());
 121
 122   // The symbol must not have protected visibility.
 123   if (sym->is_protected())
 124     {
 125       gold_error(_("%s: cannot make copy relocation for "
 126                    "protected symbol '%s', defined in %s"),
 127                  object->name().c_str(),
 128                  sym->name(),
 129                  sym->object()->name().c_str());
 130     }
 131
 132   typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize();
 133
 134   // There is no defined way to determine the required alignment of
 135   // the symbol.  We know that the symbol is defined in a dynamic
 136   // object.  We start with the alignment of the section in which it
 137   // is defined; presumably we do not require an alignment larger than
 138   // that.  Then we reduce that alignment if the symbol is not aligned
 139   // within the section.
 140   bool is_ordinary;
 141   unsigned int shndx = sym->shndx(&is_ordinary);
 142   gold_assert(is_ordinary);
 143   typename elfcpp::Elf_types<size>::Elf_WXword addralign;
 144   bool is_readonly = false;
 145
 146   {
 147     // Lock the object so we can read from it.  This is only called
 148     // single-threaded from scan_relocs, so it is OK to lock.
 149     // Unfortunately we have no way to pass in a Task token.
 150     const Task* dummy_task = reinterpret_cast<const Task*>(-1);
 151     Object* obj = sym->object();
 152     Task_lock_obj<Object> tl(dummy_task, obj);
 153     addralign = obj->section_addralign(shndx);
 154     if (parameters->options().relro())
 155       {
 156         if ((obj->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
 157           is_readonly = true;
 158         else
 159           {
 160             // Symbols in .data.rel.ro should also be treated as read-only.
 161             if (obj->section_name(shndx) == ".data.rel.ro")
 162               is_readonly = true;
 163           }
 164       }
 165   }
 166
 167   typename Sized_symbol<size>::Value_type value = sym->value();
 168   while ((value & (addralign - 1)) != 0)
 169     addralign >>= 1;
 170
 171   // Mark the dynamic object as needed for the --as-needed option.
 172   sym->object()->set_is_needed();
 173
 174   Output_data_space* dynbss;
 175
 176   if (is_readonly)
 177     {
 178       if (this->dynrelro_ == NULL)
 179         {
 180           this->dynrelro_ = new Output_data_space(addralign, "** dynrelro");
 181           layout->add_output_section_data(".data.rel.ro",
 182                                           elfcpp::SHT_PROGBITS,
 183                                           elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
 184                                           this->dynrelro_, ORDER_RELRO, false);
 185         }
 186       dynbss = this->dynrelro_;
 187     }
 188   else
 189     {
 190       if (this->dynbss_ == NULL)
 191         {
 192           this->dynbss_ = new Output_data_space(addralign, "** dynbss");
 193           layout->add_output_section_data(".bss",
 194                                           elfcpp::SHT_NOBITS,
 195                                           elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
 196                                           this->dynbss_, ORDER_BSS, false);
 197         }
 198       dynbss = this->dynbss_;
 199     }
 200
 201   if (addralign > dynbss->addralign())
 202     dynbss->set_space_alignment(addralign);
 203
 204   section_size_type dynbss_size =
 205     convert_to_section_size_type(dynbss->current_data_size());
 206   dynbss_size = align_address(dynbss_size, addralign);
 207   section_size_type offset = dynbss_size;
 208   dynbss->set_current_data_size(dynbss_size + symsize);
 209
 210   this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section);
 211 }
 212
 213 // Save a relocation to possibly be emitted later.
 214
 215 template<int sh_type, int size, bool big_endian>
 216 void
 217 Copy_relocs<sh_type, size, big_endian>::save(
 218     Symbol* sym,
 219     Sized_relobj_file<size, big_endian>* object,
 220     unsigned int shndx,
 221     Output_section* output_section,
 222     unsigned int r_type,
 223     typename elfcpp::Elf_types<size>::Elf_Addr r_offset,
 224     typename elfcpp::Elf_types<size>::Elf_Swxword r_addend)
 225 {
 226   this->entries_.push_back(Copy_reloc_entry(sym, r_type, object, shndx,
 227                                             output_section, r_offset,
 228                                             r_addend));
 229 }
 230
 231 // Emit any saved relocs.
 232
 233 template<int sh_type, int size, bool big_endian>
 234 void
 235 Copy_relocs<sh_type, size, big_endian>::emit(
 236     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
 237 {
 238   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 239        p != this->entries_.end();
 240        ++p)
 241     {
 242       Copy_reloc_entry& entry = *p;
 243
 244       // If the symbol is no longer defined in a dynamic object, then we
 245       // emitted a COPY relocation, and we do not want to emit this
 246       // dynamic relocation.
 247       if (entry.sym_->is_from_dynobj())
 248         reloc_section->add_global_generic(entry.sym_, entry.reloc_type_,
 249                                           entry.output_section_, entry.relobj_,
 250                                           entry.shndx_, entry.address_,
 251                                           entry.addend_);
 252     }
 253
 254   // We no longer need the saved information.
 255   this->entries_.clear();
 256 }
 257
 258 // Instantiate the templates we need.
 259
 260 #ifdef HAVE_TARGET_32_LITTLE
 261 template
 262 class Copy_relocs<elfcpp::SHT_REL, 32, false>;
 263
 264 template
 265 class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
 266 #endif
 267
 268 #ifdef HAVE_TARGET_32_BIG
 269 template
 270 class Copy_relocs<elfcpp::SHT_REL, 32, true>;
 271
 272 template
 273 class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
 274 #endif
 275
 276 #ifdef HAVE_TARGET_64_LITTLE
 277 template
 278 class Copy_relocs<elfcpp::SHT_REL, 64, false>;
 279
 280 template
 281 class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
 282 #endif
 283
 284 #ifdef HAVE_TARGET_64_BIG
 285 template
 286 class Copy_relocs<elfcpp::SHT_REL, 64, true>;
 287
 288 template
 289 class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
 290 #endif
 291
 292 } // End namespace gold.