Commit | Line | Data |
---|---|---|
12c0daef ILT |
1 | // copy-relocs.cc -- handle COPY relocations for gold. |
2 | ||
ec6dfed6 | 3 | // Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
12c0daef ILT |
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, | |
6fa2a40b | 61 | Sized_relobj_file<size, big_endian>* object, |
12c0daef | 62 | unsigned int shndx, |
ca09d69a | 63 | Output_section* output_section, |
12c0daef ILT |
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)) | |
26d3c67d | 68 | this->make_copy_reloc(symtab, layout, sym, reloc_section); |
12c0daef ILT |
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, | |
6fa2a40b | 84 | Sized_relobj_file<size, big_endian>* object, |
12c0daef ILT |
85 | unsigned int shndx) const |
86 | { | |
966d4097 DK |
87 | if (!parameters->options().copyreloc()) |
88 | return false; | |
12c0daef ILT |
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( | |
26d3c67d CC |
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( | |
12c0daef ILT |
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 | { | |
966d4097 DK |
131 | // We should not be here if -z nocopyreloc is given. |
132 | gold_assert(parameters->options().copyreloc()); | |
133 | ||
12c0daef ILT |
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()); | |
d491d34e ILT |
143 | bool is_ordinary; |
144 | unsigned int shndx = sym->shndx(&is_ordinary); | |
145 | gold_assert(is_ordinary); | |
5f9bcf58 CC |
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 | } | |
12c0daef ILT |
157 | |
158 | typename Sized_symbol<size>::Value_type value = sym->value(); | |
159 | while ((value & (addralign - 1)) != 0) | |
160 | addralign >>= 1; | |
161 | ||
659948a4 ILT |
162 | // Mark the dynamic object as needed for the --as-needed option. |
163 | sym->object()->set_is_needed(); | |
164 | ||
12c0daef ILT |
165 | if (this->dynbss_ == NULL) |
166 | { | |
7d9e3d98 | 167 | this->dynbss_ = new Output_data_space(addralign, "** dynbss"); |
12c0daef ILT |
168 | layout->add_output_section_data(".bss", |
169 | elfcpp::SHT_NOBITS, | |
170 | elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE, | |
22f0da72 | 171 | this->dynbss_, ORDER_BSS, false); |
12c0daef ILT |
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 | ||
26d3c67d | 185 | this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section); |
12c0daef ILT |
186 | } |
187 | ||
188 | // Save a relocation to possibly be emitted later. | |
189 | ||
190 | template<int sh_type, int size, bool big_endian> | |
191 | void | |
ef9beddf ILT |
192 | Copy_relocs<sh_type, size, big_endian>::save( |
193 | Symbol* sym, | |
6fa2a40b | 194 | Sized_relobj_file<size, big_endian>* object, |
ef9beddf ILT |
195 | unsigned int shndx, |
196 | Output_section* output_section, | |
197 | const Reloc& rel) | |
12c0daef ILT |
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. |