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