1// copy-relocs.cc -- handle COPY relocations for gold.
2
3// Copyright (C) 2006-2017 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
28namespace 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
36template<int sh_type, int size, bool big_endian>
37void
38Copy_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
64template<int sh_type, int size, bool big_endian>
65bool
66Copy_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
89template<int sh_type, int size, bool big_endian>
90void
91Copy_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
108template<int sh_type, int size, bool big_endian>
109void
110Copy_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
215template<int sh_type, int size, bool big_endian>
216void
217Copy_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
233template<int sh_type, int size, bool big_endian>
234void
235Copy_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
261template
262class Copy_relocs<elfcpp::SHT_REL, 32, false>;
263
264template
265class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
266#endif
267
268#ifdef HAVE_TARGET_32_BIG
269template
270class Copy_relocs<elfcpp::SHT_REL, 32, true>;
271
272template
273class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
274#endif
275
276#ifdef HAVE_TARGET_64_LITTLE
277template
278class Copy_relocs<elfcpp::SHT_REL, 64, false>;
279
280template
281class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
282#endif
283
284#ifdef HAVE_TARGET_64_BIG
285template
286class Copy_relocs<elfcpp::SHT_REL, 64, true>;
287
288template
289class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
290#endif
291
292} // End namespace gold.
293