1 // copy-relocs.cc -- handle COPY relocations for gold.
3 // Copyright (C) 2006-2020 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.
26 #include "copy-relocs.h"
31 // Copy_relocs methods.
33 // Handle a relocation against a symbol which may force us to generate
36 template<int sh_type
, int size
, bool big_endian
>
38 Copy_relocs
<sh_type
, size
, big_endian
>::copy_reloc(
41 Sized_symbol
<size
>* sym
,
42 Sized_relobj_file
<size
, big_endian
>* object
,
44 Output_section
* output_section
,
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
);
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
>
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())
74 if (sym
->symsize() == 0)
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)
87 // Emit a COPY relocation for SYM.
89 template<int sh_type
, int size
, bool big_endian
>
91 Copy_relocs
<sh_type
, size
, big_endian
>::emit_copy_reloc(
93 Sized_symbol
<size
>* sym
,
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
,
106 // Make a COPY relocation for SYM and emit it.
108 template<int sh_type
, int size
, bool big_endian
>
110 Copy_relocs
<sh_type
, size
, big_endian
>::make_copy_reloc(
111 Symbol_table
* symtab
,
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(),
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.
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)
160 // Symbols in .data.rel.ro should also be treated as read-only.
161 if (obj
->section_name(shndx
) == ".data.rel.ro")
167 typename Sized_symbol
<size
>::Value_type value
= sym
->value();
168 while ((value
& (addralign
- 1)) != 0)
171 // Mark the dynamic object as needed for the --as-needed option.
172 sym
->object()->set_is_needed();
174 Output_data_space
* dynbss
;
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_
;
190 if (this->dynbss_
== NULL
)
192 this->dynbss_
= new Output_data_space(addralign
, "** dynbss");
193 layout
->add_output_section_data(".bss",
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
>
217 Copy_relocs
<sh_type
, size
, big_endian
>::save(
219 Sized_relobj_file
<size
, big_endian
>* object
,
221 Output_section
* output_section
,
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
,
231 // Emit any saved relocs.
233 template<int sh_type
, int size
, bool big_endian
>
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();
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_
,
254 // We no longer need the saved information.
255 this->entries_
.clear();
258 // Instantiate the templates we need.
260 #ifdef HAVE_TARGET_32_LITTLE
262 class Copy_relocs
<elfcpp::SHT_REL
, 32, false>;
265 class Copy_relocs
<elfcpp::SHT_RELA
, 32, false>;
268 #ifdef HAVE_TARGET_32_BIG
270 class Copy_relocs
<elfcpp::SHT_REL
, 32, true>;
273 class Copy_relocs
<elfcpp::SHT_RELA
, 32, true>;
276 #ifdef HAVE_TARGET_64_LITTLE
278 class Copy_relocs
<elfcpp::SHT_REL
, 64, false>;
281 class Copy_relocs
<elfcpp::SHT_RELA
, 64, false>;
284 #ifdef HAVE_TARGET_64_BIG
286 class Copy_relocs
<elfcpp::SHT_REL
, 64, true>;
289 class Copy_relocs
<elfcpp::SHT_RELA
, 64, true>;
292 } // End namespace gold.