Upload Tizen:Base source
[external/binutils.git] / gold / copy-relocs.cc
1 // copy-relocs.cc -- handle COPY relocations for gold.
2
3 // Copyright 2006, 2007, 2008, 2009, 2010 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::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,
61     Sized_relobj<size, big_endian>* object,
62     unsigned int shndx,
63     Output_section* output_section,
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))
68     this->emit_copy_reloc(symtab, layout, sym, reloc_section);
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,
84     Sized_relobj<size, big_endian>* object,
85     unsigned int shndx) const
86 {
87   if (!parameters->options().copyreloc())
88     return false;
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(
108     Symbol_table* symtab,
109     Layout* layout,
110     Sized_symbol<size>* sym,
111     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
112 {
113   // We should not be here if -z nocopyreloc is given.
114   gold_assert(parameters->options().copyreloc());
115
116   typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize();
117
118   // There is no defined way to determine the required alignment of
119   // the symbol.  We know that the symbol is defined in a dynamic
120   // object.  We start with the alignment of the section in which it
121   // is defined; presumably we do not require an alignment larger than
122   // that.  Then we reduce that alignment if the symbol is not aligned
123   // within the section.
124   gold_assert(sym->is_from_dynobj());
125   bool is_ordinary;
126   unsigned int shndx = sym->shndx(&is_ordinary);
127   gold_assert(is_ordinary);
128   typename elfcpp::Elf_types<size>::Elf_WXword addralign;
129
130   {
131     // Lock the object so we can read from it.  This is only called
132     // single-threaded from scan_relocs, so it is OK to lock.
133     // Unfortunately we have no way to pass in a Task token.
134     const Task* dummy_task = reinterpret_cast<const Task*>(-1);
135     Object* obj = sym->object();
136     Task_lock_obj<Object> tl(dummy_task, obj);
137     addralign = obj->section_addralign(shndx);
138   }
139
140   typename Sized_symbol<size>::Value_type value = sym->value();
141   while ((value & (addralign - 1)) != 0)
142     addralign >>= 1;
143
144   // Mark the dynamic object as needed for the --as-needed option.
145   sym->object()->set_is_needed();
146
147   if (this->dynbss_ == NULL)
148     {
149       this->dynbss_ = new Output_data_space(addralign, "** dynbss");
150       layout->add_output_section_data(".bss",
151                                       elfcpp::SHT_NOBITS,
152                                       elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
153                                       this->dynbss_, ORDER_BSS, false);
154     }
155
156   Output_data_space* dynbss = this->dynbss_;
157
158   if (addralign > dynbss->addralign())
159     dynbss->set_space_alignment(addralign);
160
161   section_size_type dynbss_size =
162     convert_to_section_size_type(dynbss->current_data_size());
163   dynbss_size = align_address(dynbss_size, addralign);
164   section_size_type offset = dynbss_size;
165   dynbss->set_current_data_size(dynbss_size + symsize);
166
167   // Define the symbol as being copied.
168   symtab->define_with_copy_reloc(sym, dynbss, offset);
169
170   // Add the COPY relocation to the dynamic reloc section.
171   this->add_copy_reloc(sym, offset, reloc_section);
172 }
173
174 // Add a COPY relocation for SYM to RELOC_SECTION.
175
176 template<int sh_type, int size, bool big_endian>
177 void
178 Copy_relocs<sh_type, size, big_endian>::add_copy_reloc(
179     Symbol* sym,
180     section_size_type offset,
181     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
182 {
183   reloc_section->add_global(sym, this->copy_reloc_type_, this->dynbss_,
184                             offset, 0);
185 }
186
187 // Save a relocation to possibly be emitted later.
188
189 template<int sh_type, int size, bool big_endian>
190 void
191 Copy_relocs<sh_type, size, big_endian>::save(
192     Symbol* sym,
193     Sized_relobj<size, big_endian>* object,
194     unsigned int shndx,
195     Output_section* output_section,
196     const Reloc& rel)
197 {
198   unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
199   typename elfcpp::Elf_types<size>::Elf_Addr addend =
200     Reloc_types<sh_type, size, big_endian>::get_reloc_addend_noerror(&rel);
201   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, object, shndx,
202                                             output_section, rel.get_r_offset(),
203                                             addend));
204 }
205
206 // Emit any saved relocs.
207
208 template<int sh_type, int size, bool big_endian>
209 void
210 Copy_relocs<sh_type, size, big_endian>::emit(
211     Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
212 {
213   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
214        p != this->entries_.end();
215        ++p)
216     p->emit(reloc_section);
217
218   // We no longer need the saved information.
219   this->entries_.clear();
220 }
221
222 // Instantiate the templates we need.
223
224 #ifdef HAVE_TARGET_32_LITTLE
225 template
226 class Copy_relocs<elfcpp::SHT_REL, 32, false>;
227
228 template
229 class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
230 #endif
231
232 #ifdef HAVE_TARGET_32_BIG
233 template
234 class Copy_relocs<elfcpp::SHT_REL, 32, true>;
235
236 template
237 class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
238 #endif
239
240 #ifdef HAVE_TARGET_64_LITTLE
241 template
242 class Copy_relocs<elfcpp::SHT_REL, 64, false>;
243
244 template
245 class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
246 #endif
247
248 #ifdef HAVE_TARGET_64_BIG
249 template
250 class Copy_relocs<elfcpp::SHT_REL, 64, true>;
251
252 template
253 class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
254 #endif
255
256 } // End namespace gold.