* elf32-spu.c (build_stub): Fix malloc under-allocation.
[binutils.git] / gold / copy-relocs.cc
blob92c5aeaad3f9ffe4003755c6d3259a52b47127d3
1 // copy-relocs.cc -- handle COPY relocations for gold.
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 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::Copy_reloc_entry methods.
33 // Emit the reloc if appropriate.
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)
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_generic(this->sym_, this->reloc_type_,
45 this->output_section_, this->relobj_,
46 this->shndx_, this->address_,
47 this->addend_);
50 // Copy_relocs methods.
52 // Handle a relocation against a symbol which may force us to generate
53 // a COPY reloc.
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_file<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)
67 if (this->need_copy_reloc(sym, object, shndx))
68 this->make_copy_reloc(symtab, layout, sym, reloc_section);
69 else
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);
77 // Return whether we need a COPY reloc for a relocation against SYM.
78 // The relocation is begin applied to section SHNDX in OBJECT.
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_file<size, big_endian>* object,
85 unsigned int shndx) const
87 if (!parameters->options().copyreloc())
88 return false;
90 if (sym->symsize() == 0)
91 return false;
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;
100 return false;
103 // Emit a COPY relocation for SYM.
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 Sized_symbol<size>* sym,
110 Output_data* posd,
111 off_t offset,
112 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
114 // Define the symbol as being copied.
115 symtab->define_with_copy_reloc(sym, posd, offset);
117 // Add the COPY relocation to the dynamic reloc section.
118 reloc_section->add_global_generic(sym, this->copy_reloc_type_, posd,
119 offset, 0);
122 // Make a COPY relocation for SYM and emit it.
124 template<int sh_type, int size, bool big_endian>
125 void
126 Copy_relocs<sh_type, size, big_endian>::make_copy_reloc(
127 Symbol_table* symtab,
128 Layout* layout,
129 Sized_symbol<size>* sym,
130 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
132 // We should not be here if -z nocopyreloc is given.
133 gold_assert(parameters->options().copyreloc());
135 typename elfcpp::Elf_types<size>::Elf_WXword symsize = sym->symsize();
137 // There is no defined way to determine the required alignment of
138 // the symbol. We know that the symbol is defined in a dynamic
139 // object. We start with the alignment of the section in which it
140 // is defined; presumably we do not require an alignment larger than
141 // that. Then we reduce that alignment if the symbol is not aligned
142 // within the section.
143 gold_assert(sym->is_from_dynobj());
144 bool is_ordinary;
145 unsigned int shndx = sym->shndx(&is_ordinary);
146 gold_assert(is_ordinary);
147 typename elfcpp::Elf_types<size>::Elf_WXword addralign;
150 // Lock the object so we can read from it. This is only called
151 // single-threaded from scan_relocs, so it is OK to lock.
152 // Unfortunately we have no way to pass in a Task token.
153 const Task* dummy_task = reinterpret_cast<const Task*>(-1);
154 Object* obj = sym->object();
155 Task_lock_obj<Object> tl(dummy_task, obj);
156 addralign = obj->section_addralign(shndx);
159 typename Sized_symbol<size>::Value_type value = sym->value();
160 while ((value & (addralign - 1)) != 0)
161 addralign >>= 1;
163 // Mark the dynamic object as needed for the --as-needed option.
164 sym->object()->set_is_needed();
166 if (this->dynbss_ == NULL)
168 this->dynbss_ = new Output_data_space(addralign, "** dynbss");
169 layout->add_output_section_data(".bss",
170 elfcpp::SHT_NOBITS,
171 elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
172 this->dynbss_, ORDER_BSS, false);
175 Output_data_space* dynbss = this->dynbss_;
177 if (addralign > dynbss->addralign())
178 dynbss->set_space_alignment(addralign);
180 section_size_type dynbss_size =
181 convert_to_section_size_type(dynbss->current_data_size());
182 dynbss_size = align_address(dynbss_size, addralign);
183 section_size_type offset = dynbss_size;
184 dynbss->set_current_data_size(dynbss_size + symsize);
186 this->emit_copy_reloc(symtab, sym, dynbss, offset, reloc_section);
189 // Save a relocation to possibly be emitted later.
191 template<int sh_type, int size, bool big_endian>
192 void
193 Copy_relocs<sh_type, size, big_endian>::save(
194 Symbol* sym,
195 Sized_relobj_file<size, big_endian>* object,
196 unsigned int shndx,
197 Output_section* output_section,
198 const Reloc& rel)
200 unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
201 typename elfcpp::Elf_types<size>::Elf_Addr addend =
202 Reloc_types<sh_type, size, big_endian>::get_reloc_addend_noerror(&rel);
203 this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, object, shndx,
204 output_section, rel.get_r_offset(),
205 addend));
208 // Emit any saved relocs.
210 template<int sh_type, int size, bool big_endian>
211 void
212 Copy_relocs<sh_type, size, big_endian>::emit(
213 Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
215 for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
216 p != this->entries_.end();
217 ++p)
218 p->emit(reloc_section);
220 // We no longer need the saved information.
221 this->entries_.clear();
224 // Instantiate the templates we need.
226 #ifdef HAVE_TARGET_32_LITTLE
227 template
228 class Copy_relocs<elfcpp::SHT_REL, 32, false>;
230 template
231 class Copy_relocs<elfcpp::SHT_RELA, 32, false>;
232 #endif
234 #ifdef HAVE_TARGET_32_BIG
235 template
236 class Copy_relocs<elfcpp::SHT_REL, 32, true>;
238 template
239 class Copy_relocs<elfcpp::SHT_RELA, 32, true>;
240 #endif
242 #ifdef HAVE_TARGET_64_LITTLE
243 template
244 class Copy_relocs<elfcpp::SHT_REL, 64, false>;
246 template
247 class Copy_relocs<elfcpp::SHT_RELA, 64, false>;
248 #endif
250 #ifdef HAVE_TARGET_64_BIG
251 template
252 class Copy_relocs<elfcpp::SHT_REL, 64, true>;
254 template
255 class Copy_relocs<elfcpp::SHT_RELA, 64, true>;
256 #endif
258 } // End namespace gold.