OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [copy-relocs.cc] - Blame information for rev 143

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 27 khays
// 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_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)
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_file<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_file<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.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.