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)