Regenerate gold/Makefile.in.
[deliverable/binutils-gdb.git] / gold / reloc.h
CommitLineData
61ba1cf9
ILT
1// reloc.h -- relocate input files for gold -*- C++ -*-
2
4b95cf5c 3// Copyright (C) 2006-2014 Free Software Foundation, Inc.
6cb15b7f
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
61ba1cf9
ILT
23#ifndef GOLD_RELOC_H
24#define GOLD_RELOC_H
25
17a1d0a9 26#include <vector>
3d857b98 27#ifdef HAVE_BYTESWAP_H
92e059d8 28#include <byteswap.h>
3d857b98 29#endif
92e059d8 30
4c50553d 31#include "elfcpp.h"
61ba1cf9
ILT
32#include "workqueue.h"
33
34namespace gold
35{
36
a3ad94ed 37class General_options;
b696e6d4 38class Object;
f6ce93d6 39class Relobj;
2c54b4f4 40struct Read_relocs_data;
a3ad94ed 41class Symbol;
ead1e424 42class Layout;
6a74a719 43class Output_data;
4f4c5f80 44class Output_section;
92e059d8 45
5a6f7e2d
ILT
46template<int size>
47class Sized_symbol;
48
b8e6aad9 49template<int size, bool big_endian>
6fa2a40b 50class Sized_relobj_file;
b8e6aad9
ILT
51
52template<int size>
53class Symbol_value;
54
5a6f7e2d
ILT
55template<int sh_type, bool dynamic, int size, bool big_endian>
56class Output_data_reloc;
57
92e059d8
ILT
58// A class to read the relocations for an object file, and then queue
59// up a task to see if they require any GOT/PLT/COPY relocations in
60// the symbol table.
61
62class Read_relocs : public Task
63{
64 public:
93ceb764
ILT
65 // THIS_BLOCKER and NEXT_BLOCKER are passed along to a Scan_relocs
66 // or Gc_process_relocs task, so that they run in a deterministic
67 // order.
ad0f2072 68 Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
93ceb764 69 Task_token* this_blocker, Task_token* next_blocker)
ad0f2072 70 : symtab_(symtab), layout_(layout), object_(object),
93ceb764 71 this_blocker_(this_blocker), next_blocker_(next_blocker)
92e059d8
ILT
72 { }
73
74 // The standard Task methods.
75
17a1d0a9
ILT
76 Task_token*
77 is_runnable();
92e059d8 78
17a1d0a9
ILT
79 void
80 locks(Task_locker*);
92e059d8
ILT
81
82 void
83 run(Workqueue*);
84
c7912668
ILT
85 std::string
86 get_name() const;
87
92e059d8 88 private:
92e059d8 89 Symbol_table* symtab_;
ead1e424 90 Layout* layout_;
f6ce93d6 91 Relobj* object_;
93ceb764
ILT
92 Task_token* this_blocker_;
93 Task_token* next_blocker_;
92e059d8
ILT
94};
95
6d03d481
ST
96// Process the relocs to figure out which sections are garbage.
97// Very similar to scan relocs.
98
99class Gc_process_relocs : public Task
100{
101 public:
93ceb764
ILT
102 // THIS_BLOCKER prevents this task from running until the previous
103 // one is finished. NEXT_BLOCKER prevents the next task from
104 // running.
ad0f2072 105 Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
93ceb764
ILT
106 Read_relocs_data* rd, Task_token* this_blocker,
107 Task_token* next_blocker)
ad0f2072 108 : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
93ceb764 109 this_blocker_(this_blocker), next_blocker_(next_blocker)
6d03d481
ST
110 { }
111
93ceb764
ILT
112 ~Gc_process_relocs();
113
6d03d481
ST
114 // The standard Task methods.
115
116 Task_token*
117 is_runnable();
118
119 void
120 locks(Task_locker*);
121
122 void
123 run(Workqueue*);
124
125 std::string
126 get_name() const;
127
128 private:
6d03d481
ST
129 Symbol_table* symtab_;
130 Layout* layout_;
131 Relobj* object_;
132 Read_relocs_data* rd_;
93ceb764
ILT
133 Task_token* this_blocker_;
134 Task_token* next_blocker_;
6d03d481
ST
135};
136
92e059d8
ILT
137// Scan the relocations for an object to see if they require any
138// GOT/PLT/COPY relocations.
139
140class Scan_relocs : public Task
141{
142 public:
93ceb764
ILT
143 // THIS_BLOCKER prevents this task from running until the previous
144 // one is finished. NEXT_BLOCKER prevents the next task from
145 // running.
ad0f2072 146 Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
93ceb764
ILT
147 Read_relocs_data* rd, Task_token* this_blocker,
148 Task_token* next_blocker)
ad0f2072 149 : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
93ceb764 150 this_blocker_(this_blocker), next_blocker_(next_blocker)
92e059d8
ILT
151 { }
152
93ceb764
ILT
153 ~Scan_relocs();
154
92e059d8
ILT
155 // The standard Task methods.
156
17a1d0a9
ILT
157 Task_token*
158 is_runnable();
92e059d8 159
17a1d0a9
ILT
160 void
161 locks(Task_locker*);
92e059d8
ILT
162
163 void
164 run(Workqueue*);
165
c7912668
ILT
166 std::string
167 get_name() const;
168
92e059d8 169 private:
92e059d8 170 Symbol_table* symtab_;
ead1e424 171 Layout* layout_;
f6ce93d6 172 Relobj* object_;
92e059d8 173 Read_relocs_data* rd_;
93ceb764
ILT
174 Task_token* this_blocker_;
175 Task_token* next_blocker_;
92e059d8
ILT
176};
177
178// A class to perform all the relocations for an object file.
179
61ba1cf9
ILT
180class Relocate_task : public Task
181{
182 public:
ad0f2072
ILT
183 Relocate_task(const Symbol_table* symtab, const Layout* layout,
184 Relobj* object, Output_file* of,
730cdc88
ILT
185 Task_token* input_sections_blocker,
186 Task_token* output_sections_blocker, Task_token* final_blocker)
ad0f2072
ILT
187 : symtab_(symtab), layout_(layout), object_(object), of_(of),
188 input_sections_blocker_(input_sections_blocker),
730cdc88
ILT
189 output_sections_blocker_(output_sections_blocker),
190 final_blocker_(final_blocker)
61ba1cf9
ILT
191 { }
192
193 // The standard Task methods.
194
17a1d0a9
ILT
195 Task_token*
196 is_runnable();
61ba1cf9 197
17a1d0a9
ILT
198 void
199 locks(Task_locker*);
61ba1cf9
ILT
200
201 void
202 run(Workqueue*);
203
c7912668
ILT
204 std::string
205 get_name() const;
206
61ba1cf9 207 private:
61ba1cf9 208 const Symbol_table* symtab_;
92e059d8 209 const Layout* layout_;
f6ce93d6 210 Relobj* object_;
61ba1cf9 211 Output_file* of_;
730cdc88
ILT
212 Task_token* input_sections_blocker_;
213 Task_token* output_sections_blocker_;
61ba1cf9
ILT
214 Task_token* final_blocker_;
215};
216
6a74a719
ILT
217// During a relocatable link, this class records how relocations
218// should be handled for a single input reloc section. An instance of
219// this class is created while scanning relocs, and it is used while
220// processing relocs.
221
222class Relocatable_relocs
223{
224 public:
225 // We use a vector of unsigned char to indicate how the input relocs
226 // should be handled. Each element is one of the following values.
227 // We create this vector when we initially scan the relocations.
228 enum Reloc_strategy
229 {
230 // Copy the input reloc. Don't modify it other than updating the
231 // r_offset field and the r_sym part of the r_info field.
232 RELOC_COPY,
233 // Copy the input reloc which is against an STT_SECTION symbol.
234 // Update the r_offset and r_sym part of the r_info field. Adjust
235 // the addend by subtracting the value of the old local symbol and
236 // adding the value of the new local symbol. The addend is in the
237 // SHT_RELA reloc and the contents of the data section do not need
238 // to be changed.
239 RELOC_ADJUST_FOR_SECTION_RELA,
7019cd25
ILT
240 // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
241 // adjusted.
242 RELOC_ADJUST_FOR_SECTION_0,
6a74a719
ILT
243 // Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
244 // section need to be changed. The number indicates the number of
245 // bytes in the addend in the section contents.
246 RELOC_ADJUST_FOR_SECTION_1,
247 RELOC_ADJUST_FOR_SECTION_2,
248 RELOC_ADJUST_FOR_SECTION_4,
249 RELOC_ADJUST_FOR_SECTION_8,
2c339f71
DK
250 // Like RELOC_ADJUST_FOR_SECTION_4 but for unaligned relocs.
251 RELOC_ADJUST_FOR_SECTION_4_UNALIGNED,
6a74a719
ILT
252 // Discard the input reloc--process it completely when relocating
253 // the data section contents.
254 RELOC_DISCARD,
255 // An input reloc which is not discarded, but which requires
256 // target specific processing in order to update it.
257 RELOC_SPECIAL
258 };
259
260 Relocatable_relocs()
261 : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
262 { }
263
264 // Record the number of relocs.
265 void
266 set_reloc_count(size_t reloc_count)
267 { this->reloc_strategies_.reserve(reloc_count); }
268
269 // Record what to do for the next reloc.
270 void
2ea97941 271 set_next_reloc_strategy(Reloc_strategy strategy)
6a74a719 272 {
2ea97941
ILT
273 this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
274 if (strategy != RELOC_DISCARD)
6a74a719
ILT
275 ++this->output_reloc_count_;
276 }
277
278 // Record the Output_data associated with this reloc section.
279 void
280 set_output_data(Output_data* posd)
281 {
282 gold_assert(this->posd_ == NULL);
283 this->posd_ = posd;
284 }
285
286 // Return the Output_data associated with this reloc section.
287 Output_data*
288 output_data() const
289 { return this->posd_; }
290
291 // Return what to do for reloc I.
292 Reloc_strategy
293 strategy(unsigned int i) const
294 {
295 gold_assert(i < this->reloc_strategies_.size());
296 return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
297 }
298
299 // Return the number of relocations to create in the output file.
300 size_t
301 output_reloc_count() const
302 { return this->output_reloc_count_; }
303
304 private:
305 typedef std::vector<unsigned char> Reloc_strategies;
306
307 // The strategies for the input reloc. There is one entry in this
308 // vector for each relocation in the input section.
309 Reloc_strategies reloc_strategies_;
310 // The number of relocations to be created in the output file.
311 size_t output_reloc_count_;
312 // The output data structure associated with this relocation.
313 Output_data* posd_;
314};
315
92e059d8
ILT
316// Standard relocation routines which are used on many targets. Here
317// SIZE and BIG_ENDIAN refer to the target, not the relocation type.
318
319template<int size, bool big_endian>
320class Relocate_functions
321{
322private:
323 // Do a simple relocation with the addend in the section contents.
324 // VALSIZE is the size of the value.
325 template<int valsize>
326 static inline void
f6ce93d6
ILT
327 rel(unsigned char* view,
328 typename elfcpp::Swap<valsize, big_endian>::Valtype value)
92e059d8 329 {
f6ce93d6 330 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
92e059d8 331 Valtype* wv = reinterpret_cast<Valtype*>(view);
f6ce93d6
ILT
332 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
333 elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
92e059d8
ILT
334 }
335
29ab395d
DK
336 // Like the above but for relocs at unaligned addresses.
337 template<int valsize>
338 static inline void
339 rel_unaligned(unsigned char* view,
340 typename elfcpp::Swap<valsize, big_endian>::Valtype value)
341 {
342 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
343 Valtype;
344 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
345 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value);
346 }
347
b8e6aad9
ILT
348 // Do a simple relocation using a Symbol_value with the addend in
349 // the section contents. VALSIZE is the size of the value to
350 // relocate.
351 template<int valsize>
352 static inline void
353 rel(unsigned char* view,
6fa2a40b 354 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
355 const Symbol_value<size>* psymval)
356 {
357 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
358 Valtype* wv = reinterpret_cast<Valtype*>(view);
359 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
360 x = psymval->value(object, x);
361 elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
362 }
363
2c339f71
DK
364 // Like the above but for relocs at unaligned addresses.
365 template<int valsize>
366 static inline void
367 rel_unaligned(unsigned char* view,
368 const Sized_relobj_file<size, big_endian>* object,
369 const Symbol_value<size>* psymval)
370 {
371 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
372 Valtype;
373 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
374 x = psymval->value(object, x);
375 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x);
376 }
377
d830e0e0
ILT
378 // Do a simple relocation with the addend in the relocation.
379 // VALSIZE is the size of the value.
380 template<int valsize>
381 static inline void
382 rela(unsigned char* view,
383 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
384 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
385 {
386 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
387 Valtype* wv = reinterpret_cast<Valtype*>(view);
388 elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend);
389 }
390
391 // Do a simple relocation using a symbol value with the addend in
392 // the relocation. VALSIZE is the size of the value.
393 template<int valsize>
394 static inline void
395 rela(unsigned char* view,
6fa2a40b 396 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
397 const Symbol_value<size>* psymval,
398 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
399 {
400 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
401 Valtype* wv = reinterpret_cast<Valtype*>(view);
402 Valtype x = psymval->value(object, addend);
403 elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
404 }
405
92e059d8
ILT
406 // Do a simple PC relative relocation with the addend in the section
407 // contents. VALSIZE is the size of the value.
408 template<int valsize>
409 static inline void
f6ce93d6
ILT
410 pcrel(unsigned char* view,
411 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
92e059d8
ILT
412 typename elfcpp::Elf_types<size>::Elf_Addr address)
413 {
f6ce93d6 414 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
92e059d8 415 Valtype* wv = reinterpret_cast<Valtype*>(view);
f6ce93d6
ILT
416 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
417 elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
92e059d8
ILT
418 }
419
29ab395d
DK
420 // Like the above but for relocs at unaligned addresses.
421 template<int valsize>
422 static inline void
423 pcrel_unaligned(unsigned char* view,
424 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
425 typename elfcpp::Elf_types<size>::Elf_Addr address)
426 {
427 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
428 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
429 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view,
430 x + value - address);
431 }
432
b8e6aad9
ILT
433 // Do a simple PC relative relocation with a Symbol_value with the
434 // addend in the section contents. VALSIZE is the size of the
435 // value.
436 template<int valsize>
437 static inline void
438 pcrel(unsigned char* view,
6fa2a40b 439 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
440 const Symbol_value<size>* psymval,
441 typename elfcpp::Elf_types<size>::Elf_Addr address)
442 {
443 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
444 Valtype* wv = reinterpret_cast<Valtype*>(view);
445 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
446 x = psymval->value(object, x);
447 elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
448 }
449
d830e0e0
ILT
450 // Do a simple PC relative relocation with the addend in the
451 // relocation. VALSIZE is the size of the value.
452 template<int valsize>
453 static inline void
454 pcrela(unsigned char* view,
455 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
456 typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
457 typename elfcpp::Elf_types<size>::Elf_Addr address)
458 {
459 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
460 Valtype* wv = reinterpret_cast<Valtype*>(view);
461 elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address);
462 }
463
464 // Do a simple PC relative relocation with a Symbol_value with the
465 // addend in the relocation. VALSIZE is the size of the value.
466 template<int valsize>
467 static inline void
468 pcrela(unsigned char* view,
6fa2a40b 469 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
470 const Symbol_value<size>* psymval,
471 typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
472 typename elfcpp::Elf_types<size>::Elf_Addr address)
473 {
474 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
475 Valtype* wv = reinterpret_cast<Valtype*>(view);
476 Valtype x = psymval->value(object, addend);
477 elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
478 }
479
92e059d8
ILT
480 typedef Relocate_functions<size, big_endian> This;
481
482public:
b8e6aad9
ILT
483 // Do a simple 8-bit REL relocation with the addend in the section
484 // contents.
92e059d8
ILT
485 static inline void
486 rel8(unsigned char* view, unsigned char value)
b8e6aad9
ILT
487 { This::template rel<8>(view, value); }
488
489 static inline void
490 rel8(unsigned char* view,
6fa2a40b 491 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
492 const Symbol_value<size>* psymval)
493 { This::template rel<8>(view, object, psymval); }
92e059d8 494
d830e0e0
ILT
495 // Do an 8-bit RELA relocation with the addend in the relocation.
496 static inline void
5b3463d9 497 rela8(unsigned char* view, unsigned char value, unsigned char addend)
d830e0e0
ILT
498 { This::template rela<8>(view, value, addend); }
499
500 static inline void
5b3463d9 501 rela8(unsigned char* view,
6fa2a40b 502 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
503 const Symbol_value<size>* psymval,
504 unsigned char addend)
505 { This::template rela<8>(view, object, psymval, addend); }
506
92e059d8 507 // Do a simple 8-bit PC relative relocation with the addend in the
b8e6aad9 508 // section contents.
92e059d8
ILT
509 static inline void
510 pcrel8(unsigned char* view, unsigned char value,
511 typename elfcpp::Elf_types<size>::Elf_Addr address)
b8e6aad9
ILT
512 { This::template pcrel<8>(view, value, address); }
513
514 static inline void
515 pcrel8(unsigned char* view,
6fa2a40b 516 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
517 const Symbol_value<size>* psymval,
518 typename elfcpp::Elf_types<size>::Elf_Addr address)
519 { This::template pcrel<8>(view, object, psymval, address); }
92e059d8 520
d830e0e0
ILT
521 // Do a simple 8-bit PC relative RELA relocation with the addend in
522 // the reloc.
523 static inline void
524 pcrela8(unsigned char* view, unsigned char value, unsigned char addend,
525 typename elfcpp::Elf_types<size>::Elf_Addr address)
526 { This::template pcrela<8>(view, value, addend, address); }
527
528 static inline void
529 pcrela8(unsigned char* view,
6fa2a40b 530 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
531 const Symbol_value<size>* psymval,
532 unsigned char addend,
533 typename elfcpp::Elf_types<size>::Elf_Addr address)
534 { This::template pcrela<8>(view, object, psymval, addend, address); }
535
b8e6aad9
ILT
536 // Do a simple 16-bit REL relocation with the addend in the section
537 // contents.
92e059d8
ILT
538 static inline void
539 rel16(unsigned char* view, elfcpp::Elf_Half value)
b8e6aad9
ILT
540 { This::template rel<16>(view, value); }
541
542 static inline void
543 rel16(unsigned char* view,
6fa2a40b 544 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
545 const Symbol_value<size>* psymval)
546 { This::template rel<16>(view, object, psymval); }
92e059d8 547
d830e0e0
ILT
548 // Do an 16-bit RELA relocation with the addend in the relocation.
549 static inline void
550 rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend)
551 { This::template rela<16>(view, value, addend); }
552
553 static inline void
554 rela16(unsigned char* view,
6fa2a40b 555 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
556 const Symbol_value<size>* psymval,
557 elfcpp::Elf_Half addend)
558 { This::template rela<16>(view, object, psymval, addend); }
559
d830e0e0 560 // Do a simple 16-bit PC relative REL relocation with the addend in
b8e6aad9 561 // the section contents.
92e059d8 562 static inline void
d830e0e0 563 pcrel16(unsigned char* view, elfcpp::Elf_Half value,
92e059d8 564 typename elfcpp::Elf_types<size>::Elf_Addr address)
b8e6aad9
ILT
565 { This::template pcrel<16>(view, value, address); }
566
567 static inline void
568 pcrel16(unsigned char* view,
6fa2a40b 569 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
570 const Symbol_value<size>* psymval,
571 typename elfcpp::Elf_types<size>::Elf_Addr address)
572 { This::template pcrel<16>(view, object, psymval, address); }
92e059d8 573
d830e0e0
ILT
574 // Do a simple 16-bit PC relative RELA relocation with the addend in
575 // the reloc.
576 static inline void
577 pcrela16(unsigned char* view, elfcpp::Elf_Half value,
578 elfcpp::Elf_Half addend,
579 typename elfcpp::Elf_types<size>::Elf_Addr address)
580 { This::template pcrela<16>(view, value, addend, address); }
581
582 static inline void
583 pcrela16(unsigned char* view,
6fa2a40b 584 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
585 const Symbol_value<size>* psymval,
586 elfcpp::Elf_Half addend,
587 typename elfcpp::Elf_types<size>::Elf_Addr address)
588 { This::template pcrela<16>(view, object, psymval, addend, address); }
589
92e059d8
ILT
590 // Do a simple 32-bit REL relocation with the addend in the section
591 // contents.
592 static inline void
593 rel32(unsigned char* view, elfcpp::Elf_Word value)
b8e6aad9
ILT
594 { This::template rel<32>(view, value); }
595
29ab395d
DK
596 // Like above but for relocs at unaligned addresses.
597 static inline void
598 rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value)
599 { This::template rel_unaligned<32>(view, value); }
600
b8e6aad9
ILT
601 static inline void
602 rel32(unsigned char* view,
6fa2a40b 603 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
604 const Symbol_value<size>* psymval)
605 { This::template rel<32>(view, object, psymval); }
92e059d8 606
2c339f71
DK
607 // Like above but for relocs at unaligned addresses.
608 static inline void
609 rel32_unaligned(unsigned char* view,
610 const Sized_relobj_file<size, big_endian>* object,
611 const Symbol_value<size>* psymval)
612 { This::template rel_unaligned<32>(view, object, psymval); }
613
d830e0e0
ILT
614 // Do an 32-bit RELA relocation with the addend in the relocation.
615 static inline void
616 rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
617 { This::template rela<32>(view, value, addend); }
618
619 static inline void
620 rela32(unsigned char* view,
6fa2a40b 621 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
622 const Symbol_value<size>* psymval,
623 elfcpp::Elf_Word addend)
624 { This::template rela<32>(view, object, psymval, addend); }
625
92e059d8
ILT
626 // Do a simple 32-bit PC relative REL relocation with the addend in
627 // the section contents.
628 static inline void
629 pcrel32(unsigned char* view, elfcpp::Elf_Word value,
630 typename elfcpp::Elf_types<size>::Elf_Addr address)
b8e6aad9
ILT
631 { This::template pcrel<32>(view, value, address); }
632
29ab395d
DK
633 // Unaligned version of the above.
634 static inline void
635 pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value,
636 typename elfcpp::Elf_types<size>::Elf_Addr address)
637 { This::template pcrel_unaligned<32>(view, value, address); }
638
b8e6aad9
ILT
639 static inline void
640 pcrel32(unsigned char* view,
6fa2a40b 641 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
642 const Symbol_value<size>* psymval,
643 typename elfcpp::Elf_types<size>::Elf_Addr address)
644 { This::template pcrel<32>(view, object, psymval, address); }
92e059d8 645
d830e0e0
ILT
646 // Do a simple 32-bit PC relative RELA relocation with the addend in
647 // the relocation.
648 static inline void
649 pcrela32(unsigned char* view, elfcpp::Elf_Word value,
650 elfcpp::Elf_Word addend,
651 typename elfcpp::Elf_types<size>::Elf_Addr address)
652 { This::template pcrela<32>(view, value, addend, address); }
653
654 static inline void
655 pcrela32(unsigned char* view,
6fa2a40b 656 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
657 const Symbol_value<size>* psymval,
658 elfcpp::Elf_Word addend,
659 typename elfcpp::Elf_types<size>::Elf_Addr address)
660 { This::template pcrela<32>(view, object, psymval, addend, address); }
661
92e059d8
ILT
662 // Do a simple 64-bit REL relocation with the addend in the section
663 // contents.
664 static inline void
f6ce93d6 665 rel64(unsigned char* view, elfcpp::Elf_Xword value)
b8e6aad9
ILT
666 { This::template rel<64>(view, value); }
667
668 static inline void
669 rel64(unsigned char* view,
6fa2a40b 670 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
671 const Symbol_value<size>* psymval)
672 { This::template rel<64>(view, object, psymval); }
92e059d8 673
d830e0e0
ILT
674 // Do a 64-bit RELA relocation with the addend in the relocation.
675 static inline void
676 rela64(unsigned char* view, elfcpp::Elf_Xword value,
677 elfcpp::Elf_Xword addend)
678 { This::template rela<64>(view, value, addend); }
679
680 static inline void
681 rela64(unsigned char* view,
6fa2a40b 682 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
683 const Symbol_value<size>* psymval,
684 elfcpp::Elf_Xword addend)
685 { This::template rela<64>(view, object, psymval, addend); }
686
92e059d8
ILT
687 // Do a simple 64-bit PC relative REL relocation with the addend in
688 // the section contents.
689 static inline void
f6ce93d6 690 pcrel64(unsigned char* view, elfcpp::Elf_Xword value,
92e059d8 691 typename elfcpp::Elf_types<size>::Elf_Addr address)
b8e6aad9
ILT
692 { This::template pcrel<64>(view, value, address); }
693
694 static inline void
695 pcrel64(unsigned char* view,
6fa2a40b 696 const Sized_relobj_file<size, big_endian>* object,
b8e6aad9
ILT
697 const Symbol_value<size>* psymval,
698 typename elfcpp::Elf_types<size>::Elf_Addr address)
699 { This::template pcrel<64>(view, object, psymval, address); }
d830e0e0
ILT
700
701 // Do a simple 64-bit PC relative RELA relocation with the addend in
702 // the relocation.
703 static inline void
704 pcrela64(unsigned char* view, elfcpp::Elf_Xword value,
705 elfcpp::Elf_Xword addend,
706 typename elfcpp::Elf_types<size>::Elf_Addr address)
707 { This::template pcrela<64>(view, value, addend, address); }
708
709 static inline void
710 pcrela64(unsigned char* view,
6fa2a40b 711 const Sized_relobj_file<size, big_endian>* object,
d830e0e0
ILT
712 const Symbol_value<size>* psymval,
713 elfcpp::Elf_Xword addend,
714 typename elfcpp::Elf_types<size>::Elf_Addr address)
715 { This::template pcrela<64>(view, object, psymval, addend, address); }
5a6f7e2d
ILT
716};
717
bef2b434
ILT
718// Integer manipulation functions used by various targets when
719// performing relocations.
720
721template<int bits>
722class Bits
723{
724 public:
725 // Sign extend an n-bit unsigned integer stored in a uint32_t into
2c175ebc 726 // an int32_t. BITS must be between 1 and 32.
bef2b434
ILT
727 static inline int32_t
728 sign_extend32(uint32_t val)
729 {
2c175ebc 730 gold_assert(bits > 0 && bits <= 32);
bef2b434
ILT
731 if (bits == 32)
732 return static_cast<int32_t>(val);
733 uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
734 val &= mask;
735 uint32_t top_bit = 1U << (bits - 1);
736 int32_t as_signed = static_cast<int32_t>(val);
737 if ((val & top_bit) != 0)
738 as_signed -= static_cast<int32_t>(top_bit * 2);
739 return as_signed;
740 }
741
742 // Return true if VAL (stored in a uint32_t) has overflowed a signed
743 // value with BITS bits.
744 static inline bool
745 has_overflow32(uint32_t val)
746 {
2c175ebc 747 gold_assert(bits > 0 && bits <= 32);
bef2b434
ILT
748 if (bits == 32)
749 return false;
750 int32_t max = (1 << (bits - 1)) - 1;
751 int32_t min = -(1 << (bits - 1));
752 int32_t as_signed = static_cast<int32_t>(val);
753 return as_signed > max || as_signed < min;
754 }
755
756 // Return true if VAL (stored in a uint32_t) has overflowed both a
757 // signed and an unsigned value. E.g.,
758 // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
759 // 255.
760 static inline bool
761 has_signed_unsigned_overflow32(uint32_t val)
762 {
2c175ebc 763 gold_assert(bits > 0 && bits <= 32);
bef2b434
ILT
764 if (bits == 32)
765 return false;
766 int32_t max = static_cast<int32_t>((1U << bits) - 1);
767 int32_t min = -(1 << (bits - 1));
768 int32_t as_signed = static_cast<int32_t>(val);
769 return as_signed > max || as_signed < min;
770 }
771
772 // Select bits from A and B using bits in MASK. For each n in
773 // [0..31], the n-th bit in the result is chosen from the n-th bits
774 // of A and B. A zero selects A and a one selects B.
775 static inline uint32_t
776 bit_select32(uint32_t a, uint32_t b, uint32_t mask)
777 { return (a & ~mask) | (b & mask); }
778
779 // Sign extend an n-bit unsigned integer stored in a uint64_t into
2c175ebc 780 // an int64_t. BITS must be between 1 and 64.
bef2b434
ILT
781 static inline int64_t
782 sign_extend(uint64_t val)
783 {
2c175ebc 784 gold_assert(bits > 0 && bits <= 64);
bef2b434
ILT
785 if (bits == 64)
786 return static_cast<int64_t>(val);
787 uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
788 val &= mask;
789 uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
790 int64_t as_signed = static_cast<int64_t>(val);
791 if ((val & top_bit) != 0)
792 as_signed -= static_cast<int64_t>(top_bit * 2);
793 return as_signed;
794 }
795
796 // Return true if VAL (stored in a uint64_t) has overflowed a signed
797 // value with BITS bits.
798 static inline bool
799 has_overflow(uint64_t val)
800 {
2c175ebc 801 gold_assert(bits > 0 && bits <= 64);
bef2b434
ILT
802 if (bits == 64)
803 return false;
804 int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;
805 int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
806 int64_t as_signed = static_cast<int64_t>(val);
807 return as_signed > max || as_signed < min;
808 }
809
810 // Return true if VAL (stored in a uint64_t) has overflowed both a
811 // signed and an unsigned value. E.g.,
812 // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
813 // 255.
814 static inline bool
815 has_signed_unsigned_overflow64(uint64_t val)
816 {
2c175ebc 817 gold_assert(bits > 0 && bits <= 64);
bef2b434
ILT
818 if (bits == 64)
819 return false;
820 int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);
821 int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
822 int64_t as_signed = static_cast<int64_t>(val);
823 return as_signed > max || as_signed < min;
824 }
825
826 // Select bits from A and B using bits in MASK. For each n in
827 // [0..31], the n-th bit in the result is chosen from the n-th bits
828 // of A and B. A zero selects A and a one selects B.
829 static inline uint64_t
830 bit_select64(uint64_t a, uint64_t b, uint64_t mask)
831 { return (a & ~mask) | (b & mask); }
832};
833
730cdc88
ILT
834// Track relocations while reading a section. This lets you ask for
835// the relocation at a certain offset, and see how relocs occur
836// between points of interest.
837
838template<int size, bool big_endian>
839class Track_relocs
840{
841 public:
842 Track_relocs()
b696e6d4 843 : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
730cdc88
ILT
844 { }
845
846 // Initialize the Track_relocs object. OBJECT is the object holding
847 // the reloc section, RELOC_SHNDX is the section index of the reloc
848 // section, and RELOC_TYPE is the type of the reloc section
849 // (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
850 // something went wrong.
851 bool
b696e6d4 852 initialize(Object* object, unsigned int reloc_shndx,
730cdc88
ILT
853 unsigned int reloc_type);
854
855 // Return the offset in the data section to which the next reloc
4dbfafcc 856 // applies. This returns -1 if there is no next reloc.
730cdc88
ILT
857 off_t
858 next_offset() const;
859
860 // Return the symbol index of the next reloc. This returns -1U if
861 // there is no next reloc.
862 unsigned int
863 next_symndx() const;
864
4dbfafcc
ILT
865 // Return the addend of the next reloc. This returns 0 if there is
866 // no next reloc.
867 uint64_t
868 next_addend() const;
869
730cdc88
ILT
870 // Advance to OFFSET within the data section, and return the number
871 // of relocs which would be skipped.
872 int
873 advance(off_t offset);
874
c1027032
CC
875 // Checkpoint the current position in the reloc section.
876 section_size_type
877 checkpoint() const
878 { return this->pos_; }
879
880 // Reset the position to CHECKPOINT.
881 void
882 reset(section_size_type checkpoint)
883 { this->pos_ = checkpoint; }
884
730cdc88 885 private:
b696e6d4 886 // The contents of the input object's reloc section.
730cdc88
ILT
887 const unsigned char* prelocs_;
888 // The length of the reloc section.
8383303e 889 section_size_type len_;
730cdc88 890 // Our current position in the reloc section.
8383303e 891 section_size_type pos_;
730cdc88
ILT
892 // The size of the relocs in the section.
893 int reloc_size_;
894};
895
61ba1cf9
ILT
896} // End namespace gold.
897
898#endif // !defined(GOLD_RELOC_H)
This page took 0.369053 seconds and 4 git commands to generate.