1 // reloc.h -- relocate input files for gold -*- C++ -*-
3 // Copyright (C) 2006-2015 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.
27 #ifdef HAVE_BYTESWAP_H
32 #include "workqueue.h"
37 class General_options;
40 struct Read_relocs_data;
49 template<int size, bool big_endian>
50 class Sized_relobj_file;
55 template<int sh_type, bool dynamic, int size, bool big_endian>
56 class Output_data_reloc;
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
62 class Read_relocs : public Task
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
68 Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
69 Task_token* this_blocker, Task_token* next_blocker)
70 : symtab_(symtab), layout_(layout), object_(object),
71 this_blocker_(this_blocker), next_blocker_(next_blocker)
74 // The standard Task methods.
89 Symbol_table* symtab_;
92 Task_token* this_blocker_;
93 Task_token* next_blocker_;
96 // Process the relocs to figure out which sections are garbage.
97 // Very similar to scan relocs.
99 class Gc_process_relocs : public Task
102 // THIS_BLOCKER prevents this task from running until the previous
103 // one is finished. NEXT_BLOCKER prevents the next task from
105 Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
106 Read_relocs_data* rd, Task_token* this_blocker,
107 Task_token* next_blocker)
108 : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
109 this_blocker_(this_blocker), next_blocker_(next_blocker)
112 ~Gc_process_relocs();
114 // The standard Task methods.
129 Symbol_table* symtab_;
132 Read_relocs_data* rd_;
133 Task_token* this_blocker_;
134 Task_token* next_blocker_;
137 // Scan the relocations for an object to see if they require any
138 // GOT/PLT/COPY relocations.
140 class Scan_relocs : public Task
143 // THIS_BLOCKER prevents this task from running until the previous
144 // one is finished. NEXT_BLOCKER prevents the next task from
146 Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
147 Read_relocs_data* rd, Task_token* this_blocker,
148 Task_token* next_blocker)
149 : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
150 this_blocker_(this_blocker), next_blocker_(next_blocker)
155 // The standard Task methods.
170 Symbol_table* symtab_;
173 Read_relocs_data* rd_;
174 Task_token* this_blocker_;
175 Task_token* next_blocker_;
178 // A class to perform all the relocations for an object file.
180 class Relocate_task : public Task
183 Relocate_task(const Symbol_table* symtab, const Layout* layout,
184 Relobj* object, Output_file* of,
185 Task_token* input_sections_blocker,
186 Task_token* output_sections_blocker, Task_token* final_blocker)
187 : symtab_(symtab), layout_(layout), object_(object), of_(of),
188 input_sections_blocker_(input_sections_blocker),
189 output_sections_blocker_(output_sections_blocker),
190 final_blocker_(final_blocker)
193 // The standard Task methods.
208 const Symbol_table* symtab_;
209 const Layout* layout_;
212 Task_token* input_sections_blocker_;
213 Task_token* output_sections_blocker_;
214 Task_token* final_blocker_;
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.
222 class Relocatable_relocs
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.
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.
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
239 RELOC_ADJUST_FOR_SECTION_RELA,
240 // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
242 RELOC_ADJUST_FOR_SECTION_0,
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,
250 // Like RELOC_ADJUST_FOR_SECTION_4 but for unaligned relocs.
251 RELOC_ADJUST_FOR_SECTION_4_UNALIGNED,
252 // Discard the input reloc--process it completely when relocating
253 // the data section contents.
255 // An input reloc which is not discarded, but which requires
256 // target specific processing in order to update it.
261 : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
264 // Record the number of relocs.
266 set_reloc_count(size_t reloc_count)
267 { this->reloc_strategies_.reserve(reloc_count); }
269 // Record what to do for the next reloc.
271 set_next_reloc_strategy(Reloc_strategy strategy)
273 this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
274 if (strategy != RELOC_DISCARD)
275 ++this->output_reloc_count_;
278 // Record the Output_data associated with this reloc section.
280 set_output_data(Output_data* posd)
282 gold_assert(this->posd_ == NULL);
286 // Return the Output_data associated with this reloc section.
289 { return this->posd_; }
291 // Return what to do for reloc I.
293 strategy(unsigned int i) const
295 gold_assert(i < this->reloc_strategies_.size());
296 return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
299 // Set the strategy for reloc I.
301 set_strategy(unsigned int i, Reloc_strategy strategy)
303 gold_assert(i < this->reloc_strategies_.size());
304 this->reloc_strategies_[i] = strategy;
307 // Return the number of relocations to create in the output file.
309 output_reloc_count() const
310 { return this->output_reloc_count_; }
313 typedef std::vector<unsigned char> Reloc_strategies;
315 // The strategies for the input reloc. There is one entry in this
316 // vector for each relocation in the input section.
317 Reloc_strategies reloc_strategies_;
318 // The number of relocations to be created in the output file.
319 size_t output_reloc_count_;
320 // The output data structure associated with this relocation.
324 // Standard relocation routines which are used on many targets. Here
325 // SIZE and BIG_ENDIAN refer to the target, not the relocation type.
327 template<int size, bool big_endian>
328 class Relocate_functions
331 // Do a simple relocation with the addend in the section contents.
332 // VALSIZE is the size of the value.
333 template<int valsize>
335 rel(unsigned char* view,
336 typename elfcpp::Swap<valsize, big_endian>::Valtype value)
338 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
339 Valtype* wv = reinterpret_cast<Valtype*>(view);
340 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
341 elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
344 // Like the above but for relocs at unaligned addresses.
345 template<int valsize>
347 rel_unaligned(unsigned char* view,
348 typename elfcpp::Swap<valsize, big_endian>::Valtype value)
350 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
352 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
353 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value);
356 // Do a simple relocation using a Symbol_value with the addend in
357 // the section contents. VALSIZE is the size of the value to
359 template<int valsize>
361 rel(unsigned char* view,
362 const Sized_relobj_file<size, big_endian>* object,
363 const Symbol_value<size>* psymval)
365 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
366 Valtype* wv = reinterpret_cast<Valtype*>(view);
367 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
368 x = psymval->value(object, x);
369 elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
372 // Like the above but for relocs at unaligned addresses.
373 template<int valsize>
375 rel_unaligned(unsigned char* view,
376 const Sized_relobj_file<size, big_endian>* object,
377 const Symbol_value<size>* psymval)
379 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
381 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
382 x = psymval->value(object, x);
383 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x);
386 // Do a simple relocation with the addend in the relocation.
387 // VALSIZE is the size of the value.
388 template<int valsize>
390 rela(unsigned char* view,
391 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
392 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
394 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
395 Valtype* wv = reinterpret_cast<Valtype*>(view);
396 elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend);
399 // Do a simple relocation using a symbol value with the addend in
400 // the relocation. VALSIZE is the size of the value.
401 template<int valsize>
403 rela(unsigned char* view,
404 const Sized_relobj_file<size, big_endian>* object,
405 const Symbol_value<size>* psymval,
406 typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
408 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
409 Valtype* wv = reinterpret_cast<Valtype*>(view);
410 Valtype x = psymval->value(object, addend);
411 elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
414 // Do a simple PC relative relocation with the addend in the section
415 // contents. VALSIZE is the size of the value.
416 template<int valsize>
418 pcrel(unsigned char* view,
419 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
420 typename elfcpp::Elf_types<size>::Elf_Addr address)
422 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
423 Valtype* wv = reinterpret_cast<Valtype*>(view);
424 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
425 elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
428 // Like the above but for relocs at unaligned addresses.
429 template<int valsize>
431 pcrel_unaligned(unsigned char* view,
432 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
433 typename elfcpp::Elf_types<size>::Elf_Addr address)
435 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
436 Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
437 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view,
438 x + value - address);
441 // Do a simple PC relative relocation with a Symbol_value with the
442 // addend in the section contents. VALSIZE is the size of the
444 template<int valsize>
446 pcrel(unsigned char* view,
447 const Sized_relobj_file<size, big_endian>* object,
448 const Symbol_value<size>* psymval,
449 typename elfcpp::Elf_types<size>::Elf_Addr address)
451 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
452 Valtype* wv = reinterpret_cast<Valtype*>(view);
453 Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
454 x = psymval->value(object, x);
455 elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
458 // Do a simple PC relative relocation with the addend in the
459 // relocation. VALSIZE is the size of the value.
460 template<int valsize>
462 pcrela(unsigned char* view,
463 typename elfcpp::Swap<valsize, big_endian>::Valtype value,
464 typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
465 typename elfcpp::Elf_types<size>::Elf_Addr address)
467 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
468 Valtype* wv = reinterpret_cast<Valtype*>(view);
469 elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address);
472 // Do a simple PC relative relocation with a Symbol_value with the
473 // addend in the relocation. VALSIZE is the size of the value.
474 template<int valsize>
476 pcrela(unsigned char* view,
477 const Sized_relobj_file<size, big_endian>* object,
478 const Symbol_value<size>* psymval,
479 typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
480 typename elfcpp::Elf_types<size>::Elf_Addr address)
482 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
483 Valtype* wv = reinterpret_cast<Valtype*>(view);
484 Valtype x = psymval->value(object, addend);
485 elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
488 typedef Relocate_functions<size, big_endian> This;
491 // Do a simple 8-bit REL relocation with the addend in the section
494 rel8(unsigned char* view, unsigned char value)
495 { This::template rel<8>(view, value); }
498 rel8(unsigned char* view,
499 const Sized_relobj_file<size, big_endian>* object,
500 const Symbol_value<size>* psymval)
501 { This::template rel<8>(view, object, psymval); }
503 // Do an 8-bit RELA relocation with the addend in the relocation.
505 rela8(unsigned char* view, unsigned char value, unsigned char addend)
506 { This::template rela<8>(view, value, addend); }
509 rela8(unsigned char* view,
510 const Sized_relobj_file<size, big_endian>* object,
511 const Symbol_value<size>* psymval,
512 unsigned char addend)
513 { This::template rela<8>(view, object, psymval, addend); }
515 // Do a simple 8-bit PC relative relocation with the addend in the
518 pcrel8(unsigned char* view, unsigned char value,
519 typename elfcpp::Elf_types<size>::Elf_Addr address)
520 { This::template pcrel<8>(view, value, address); }
523 pcrel8(unsigned char* view,
524 const Sized_relobj_file<size, big_endian>* object,
525 const Symbol_value<size>* psymval,
526 typename elfcpp::Elf_types<size>::Elf_Addr address)
527 { This::template pcrel<8>(view, object, psymval, address); }
529 // Do a simple 8-bit PC relative RELA relocation with the addend in
532 pcrela8(unsigned char* view, unsigned char value, unsigned char addend,
533 typename elfcpp::Elf_types<size>::Elf_Addr address)
534 { This::template pcrela<8>(view, value, addend, address); }
537 pcrela8(unsigned char* view,
538 const Sized_relobj_file<size, big_endian>* object,
539 const Symbol_value<size>* psymval,
540 unsigned char addend,
541 typename elfcpp::Elf_types<size>::Elf_Addr address)
542 { This::template pcrela<8>(view, object, psymval, addend, address); }
544 // Do a simple 16-bit REL relocation with the addend in the section
547 rel16(unsigned char* view, elfcpp::Elf_Half value)
548 { This::template rel<16>(view, value); }
551 rel16(unsigned char* view,
552 const Sized_relobj_file<size, big_endian>* object,
553 const Symbol_value<size>* psymval)
554 { This::template rel<16>(view, object, psymval); }
556 // Do an 16-bit RELA relocation with the addend in the relocation.
558 rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend)
559 { This::template rela<16>(view, value, addend); }
562 rela16(unsigned char* view,
563 const Sized_relobj_file<size, big_endian>* object,
564 const Symbol_value<size>* psymval,
565 elfcpp::Elf_Half addend)
566 { This::template rela<16>(view, object, psymval, addend); }
568 // Do a simple 16-bit PC relative REL relocation with the addend in
569 // the section contents.
571 pcrel16(unsigned char* view, elfcpp::Elf_Half value,
572 typename elfcpp::Elf_types<size>::Elf_Addr address)
573 { This::template pcrel<16>(view, value, address); }
576 pcrel16(unsigned char* view,
577 const Sized_relobj_file<size, big_endian>* object,
578 const Symbol_value<size>* psymval,
579 typename elfcpp::Elf_types<size>::Elf_Addr address)
580 { This::template pcrel<16>(view, object, psymval, address); }
582 // Do a simple 16-bit PC relative RELA relocation with the addend in
585 pcrela16(unsigned char* view, elfcpp::Elf_Half value,
586 elfcpp::Elf_Half addend,
587 typename elfcpp::Elf_types<size>::Elf_Addr address)
588 { This::template pcrela<16>(view, value, addend, address); }
591 pcrela16(unsigned char* view,
592 const Sized_relobj_file<size, big_endian>* object,
593 const Symbol_value<size>* psymval,
594 elfcpp::Elf_Half addend,
595 typename elfcpp::Elf_types<size>::Elf_Addr address)
596 { This::template pcrela<16>(view, object, psymval, addend, address); }
598 // Do a simple 32-bit REL relocation with the addend in the section
601 rel32(unsigned char* view, elfcpp::Elf_Word value)
602 { This::template rel<32>(view, value); }
604 // Like above but for relocs at unaligned addresses.
606 rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value)
607 { This::template rel_unaligned<32>(view, value); }
610 rel32(unsigned char* view,
611 const Sized_relobj_file<size, big_endian>* object,
612 const Symbol_value<size>* psymval)
613 { This::template rel<32>(view, object, psymval); }
615 // Like above but for relocs at unaligned addresses.
617 rel32_unaligned(unsigned char* view,
618 const Sized_relobj_file<size, big_endian>* object,
619 const Symbol_value<size>* psymval)
620 { This::template rel_unaligned<32>(view, object, psymval); }
622 // Do an 32-bit RELA relocation with the addend in the relocation.
624 rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
625 { This::template rela<32>(view, value, addend); }
628 rela32(unsigned char* view,
629 const Sized_relobj_file<size, big_endian>* object,
630 const Symbol_value<size>* psymval,
631 elfcpp::Elf_Word addend)
632 { This::template rela<32>(view, object, psymval, addend); }
634 // Do a simple 32-bit PC relative REL relocation with the addend in
635 // the section contents.
637 pcrel32(unsigned char* view, elfcpp::Elf_Word value,
638 typename elfcpp::Elf_types<size>::Elf_Addr address)
639 { This::template pcrel<32>(view, value, address); }
641 // Unaligned version of the above.
643 pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value,
644 typename elfcpp::Elf_types<size>::Elf_Addr address)
645 { This::template pcrel_unaligned<32>(view, value, address); }
648 pcrel32(unsigned char* view,
649 const Sized_relobj_file<size, big_endian>* object,
650 const Symbol_value<size>* psymval,
651 typename elfcpp::Elf_types<size>::Elf_Addr address)
652 { This::template pcrel<32>(view, object, psymval, address); }
654 // Do a simple 32-bit PC relative RELA relocation with the addend in
657 pcrela32(unsigned char* view, elfcpp::Elf_Word value,
658 elfcpp::Elf_Word addend,
659 typename elfcpp::Elf_types<size>::Elf_Addr address)
660 { This::template pcrela<32>(view, value, addend, address); }
663 pcrela32(unsigned char* view,
664 const Sized_relobj_file<size, big_endian>* object,
665 const Symbol_value<size>* psymval,
666 elfcpp::Elf_Word addend,
667 typename elfcpp::Elf_types<size>::Elf_Addr address)
668 { This::template pcrela<32>(view, object, psymval, addend, address); }
670 // Do a simple 64-bit REL relocation with the addend in the section
673 rel64(unsigned char* view, elfcpp::Elf_Xword value)
674 { This::template rel<64>(view, value); }
677 rel64(unsigned char* view,
678 const Sized_relobj_file<size, big_endian>* object,
679 const Symbol_value<size>* psymval)
680 { This::template rel<64>(view, object, psymval); }
682 // Do a 64-bit RELA relocation with the addend in the relocation.
684 rela64(unsigned char* view, elfcpp::Elf_Xword value,
685 elfcpp::Elf_Xword addend)
686 { This::template rela<64>(view, value, addend); }
689 rela64(unsigned char* view,
690 const Sized_relobj_file<size, big_endian>* object,
691 const Symbol_value<size>* psymval,
692 elfcpp::Elf_Xword addend)
693 { This::template rela<64>(view, object, psymval, addend); }
695 // Do a simple 64-bit PC relative REL relocation with the addend in
696 // the section contents.
698 pcrel64(unsigned char* view, elfcpp::Elf_Xword value,
699 typename elfcpp::Elf_types<size>::Elf_Addr address)
700 { This::template pcrel<64>(view, value, address); }
703 pcrel64(unsigned char* view,
704 const Sized_relobj_file<size, big_endian>* object,
705 const Symbol_value<size>* psymval,
706 typename elfcpp::Elf_types<size>::Elf_Addr address)
707 { This::template pcrel<64>(view, object, psymval, address); }
709 // Do a simple 64-bit PC relative RELA relocation with the addend in
712 pcrela64(unsigned char* view, elfcpp::Elf_Xword value,
713 elfcpp::Elf_Xword addend,
714 typename elfcpp::Elf_types<size>::Elf_Addr address)
715 { This::template pcrela<64>(view, value, addend, address); }
718 pcrela64(unsigned char* view,
719 const Sized_relobj_file<size, big_endian>* object,
720 const Symbol_value<size>* psymval,
721 elfcpp::Elf_Xword addend,
722 typename elfcpp::Elf_types<size>::Elf_Addr address)
723 { This::template pcrela<64>(view, object, psymval, addend, address); }
726 // Integer manipulation functions used by various targets when
727 // performing relocations.
733 // Sign extend an n-bit unsigned integer stored in a uint32_t into
734 // an int32_t. BITS must be between 1 and 32.
735 static inline int32_t
736 sign_extend32(uint32_t val)
738 gold_assert(bits > 0 && bits <= 32);
740 return static_cast<int32_t>(val);
741 uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
743 uint32_t top_bit = 1U << (bits - 1);
744 int32_t as_signed = static_cast<int32_t>(val);
745 if ((val & top_bit) != 0)
746 as_signed -= static_cast<int32_t>(top_bit * 2);
750 // Return true if VAL (stored in a uint32_t) has overflowed a signed
751 // value with BITS bits.
753 has_overflow32(uint32_t val)
755 gold_assert(bits > 0 && bits <= 32);
758 int32_t max = (1 << (bits - 1)) - 1;
759 int32_t min = -(1 << (bits - 1));
760 int32_t as_signed = static_cast<int32_t>(val);
761 return as_signed > max || as_signed < min;
764 // Return true if VAL (stored in a uint32_t) has overflowed both a
765 // signed and an unsigned value. E.g.,
766 // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
769 has_signed_unsigned_overflow32(uint32_t val)
771 gold_assert(bits > 0 && bits <= 32);
774 int32_t max = static_cast<int32_t>((1U << bits) - 1);
775 int32_t min = -(1 << (bits - 1));
776 int32_t as_signed = static_cast<int32_t>(val);
777 return as_signed > max || as_signed < min;
780 // Select bits from A and B using bits in MASK. For each n in
781 // [0..31], the n-th bit in the result is chosen from the n-th bits
782 // of A and B. A zero selects A and a one selects B.
783 static inline uint32_t
784 bit_select32(uint32_t a, uint32_t b, uint32_t mask)
785 { return (a & ~mask) | (b & mask); }
787 // Sign extend an n-bit unsigned integer stored in a uint64_t into
788 // an int64_t. BITS must be between 1 and 64.
789 static inline int64_t
790 sign_extend(uint64_t val)
792 gold_assert(bits > 0 && bits <= 64);
794 return static_cast<int64_t>(val);
795 uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
797 uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
798 int64_t as_signed = static_cast<int64_t>(val);
799 if ((val & top_bit) != 0)
800 as_signed -= static_cast<int64_t>(top_bit * 2);
804 // Return true if VAL (stored in a uint64_t) has overflowed a signed
805 // value with BITS bits.
807 has_overflow(uint64_t val)
809 gold_assert(bits > 0 && bits <= 64);
812 int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;
813 int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
814 int64_t as_signed = static_cast<int64_t>(val);
815 return as_signed > max || as_signed < min;
818 // Return true if VAL (stored in a uint64_t) has overflowed both a
819 // signed and an unsigned value. E.g.,
820 // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
823 has_signed_unsigned_overflow64(uint64_t val)
825 gold_assert(bits > 0 && bits <= 64);
828 int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);
829 int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
830 int64_t as_signed = static_cast<int64_t>(val);
831 return as_signed > max || as_signed < min;
834 // Select bits from A and B using bits in MASK. For each n in
835 // [0..31], the n-th bit in the result is chosen from the n-th bits
836 // of A and B. A zero selects A and a one selects B.
837 static inline uint64_t
838 bit_select64(uint64_t a, uint64_t b, uint64_t mask)
839 { return (a & ~mask) | (b & mask); }
842 // Track relocations while reading a section. This lets you ask for
843 // the relocation at a certain offset, and see how relocs occur
844 // between points of interest.
846 template<int size, bool big_endian>
851 : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
854 // Initialize the Track_relocs object. OBJECT is the object holding
855 // the reloc section, RELOC_SHNDX is the section index of the reloc
856 // section, and RELOC_TYPE is the type of the reloc section
857 // (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
858 // something went wrong.
860 initialize(Object* object, unsigned int reloc_shndx,
861 unsigned int reloc_type);
863 // Return the offset in the data section to which the next reloc
864 // applies. This returns -1 if there is no next reloc.
868 // Return the symbol index of the next reloc. This returns -1U if
869 // there is no next reloc.
873 // Return the addend of the next reloc. This returns 0 if there is
878 // Advance to OFFSET within the data section, and return the number
879 // of relocs which would be skipped.
881 advance(off_t offset);
883 // Checkpoint the current position in the reloc section.
886 { return this->pos_; }
888 // Reset the position to CHECKPOINT.
890 reset(section_size_type checkpoint)
891 { this->pos_ = checkpoint; }
894 // The contents of the input object's reloc section.
895 const unsigned char* prelocs_;
896 // The length of the reloc section.
897 section_size_type len_;
898 // Our current position in the reloc section.
899 section_size_type pos_;
900 // The size of the relocs in the section.
904 } // End namespace gold.
906 #endif // !defined(GOLD_RELOC_H)