Automatic date update in version.in
[binutils-gdb.git] / gold / copy-relocs.cc
blob24350e972bdb4c46a2e5b6bc7f483e1344bd49a9
1 // copy-relocs.cc -- handle COPY relocations for gold.
3 // Copyright (C) 2006-2022 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
23 #include "gold.h"
25 #include "symtab.h"
26 #include "copy-relocs.h"
28 namespace gold
31 // Copy_relocs methods.
33 // Handle a relocation against a symbol which may force us to generate
34 // a COPY reloc.
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)
50 if (this->need_copy_reloc(sym, object, shndx))
51 this->make_copy_reloc(symtab, layout, sym, object, reloc_section);
52 else
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);
61 // Return whether we need a COPY reloc for a relocation against SYM.
62 // The relocation is begin applied to section SHNDX in OBJECT.
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
71 if (!parameters->options().copyreloc())
72 return false;
74 if (sym->symsize() == 0)
75 return false;
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;
84 return false;
87 // Emit a COPY relocation for SYM.
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)
98 // Define the symbol as being copied.
99 symtab->define_with_copy_reloc(sym, posd, offset);
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);
106 // Make a COPY relocation for SYM and emit it.
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)
117 // We should not be here if -z nocopyreloc is given.
118 gold_assert(parameters->options().copyreloc());
120 gold_assert(sym->is_from_dynobj());
122 // The symbol must not have protected visibility.
123 if (sym->is_protected())
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());
132 typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize();
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;
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())
156 if ((obj->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
157 is_readonly = true;
158 else
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;
167 typename Sized_symbol<size>::Value_type value = sym->value();
168 while ((value & (addralign - 1)) != 0)
169 addralign >>= 1;
171 // Mark the dynamic object as needed for the --as-needed option.
172 sym->object()->set_is_needed();
174 Output_data_space* dynbss;
176 if (is_readonly)
178 if (this->dynrelro_ == NULL)
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);
186 dynbss = this->dynrelro_;
188 else
190 if (this->dynbss_ == NULL)
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);
198 dynbss = this->dynbss_;
201 if (addralign > dynbss->addralign())
202 dynbss->set_space_alignment(addralign);
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);
210 this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section);
213 // Save a relocation to possibly be emitted later.
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)
226 this->entries_.push_back(Copy_reloc_entry(sym, r_type, object, shndx,
227 output_section, r_offset,
228 r_addend));
231 // Emit any saved relocs.
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)
238 for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
239 p != this->entries_.end();
240 ++p)
242 Copy_reloc_entry& entry = *p;
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_);
254 // We no longer need the saved information.
255 this->entries_.clear();
258 // Instantiate the templates we need.
260 #ifdef HAVE_TARGET_32_LITTLE
261 template
262 class Copy_relocs<elfcpp::SHT_REL, 32, false>;
264 template
265 class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
266 #endif
268 #ifdef HAVE_TARGET_32_BIG
269 template
270 class Copy_relocs<elfcpp::SHT_REL, 32, true>;
272 template
273 class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
274 #endif
276 #ifdef HAVE_TARGET_64_LITTLE
277 template
278 class Copy_relocs<elfcpp::SHT_REL, 64, false>;
280 template
281 class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
282 #endif
284 #ifdef HAVE_TARGET_64_BIG
285 template
286 class Copy_relocs<elfcpp::SHT_REL, 64, true>;
288 template
289 class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
290 #endif
292 } // End namespace gold.