1 // reloc.h -- relocate input files for gold -*- C++ -*-
2
3 // Copyright (C) 2006-2023 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 #ifndef GOLD_RELOC_H
24 #define GOLD_RELOC_H
25
26 #include <vector>
27 #ifdef HAVE_BYTESWAP_H
28 #include <byteswap.h>
29 #endif
30
31 #include "elfcpp.h"
32 #include "workqueue.h"
33
34 namespace gold
35 {
36
37 class General_options;
38 class Object;
39 class Relobj;
40 struct Read_relocs_data;
41 class Symbol;
42 class Layout;
43 class Output_data;
44 class Output_section;
45
46 template<int size>
47 class Sized_symbol;
48
49 template<int size, bool big_endian>
50 class Sized_relobj_file;
51
52 template<int size>
53 class Symbol_value;
54
55 template<int sh_type, bool dynamic, int size, bool big_endian>
56 class Output_data_reloc;
57
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
62 class Read_relocs : public Task
63 {
64 public:
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.
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)
72 { }
73
74 // The standard Task methods.
75
76 Task_token*
77 is_runnable();
78
79 void
80 locks(Task_locker*);
81
82 void
83 run(Workqueue*);
84
85 std::string
86 get_name() const;
87
88 private:
89 Symbol_table* symtab_;
90 Layout* layout_;
91 Relobj* object_;
92 Task_token* this_blocker_;
93 Task_token* next_blocker_;
94 };
95
96 // Process the relocs to figure out which sections are garbage.
97 // Very similar to scan relocs.
98
99 class Gc_process_relocs : public Task
100 {
101 public:
102 // THIS_BLOCKER prevents this task from running until the previous
103 // one is finished. NEXT_BLOCKER prevents the next task from
104 // running.
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)
110 { }
111
112 ~Gc_process_relocs();
113
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:
129 Symbol_table* symtab_;
130 Layout* layout_;
131 Relobj* object_;
132 Read_relocs_data* rd_;
133 Task_token* this_blocker_;
134 Task_token* next_blocker_;
135 };
136
137 // Scan the relocations for an object to see if they require any
138 // GOT/PLT/COPY relocations.
139
140 class Scan_relocs : public Task
141 {
142 public:
143 // THIS_BLOCKER prevents this task from running until the previous
144 // one is finished. NEXT_BLOCKER prevents the next task from
145 // running.
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)
151 { }
152
153 ~Scan_relocs();
154
155 // The standard Task methods.
156
157 Task_token*
158 is_runnable();
159
160 void
161 locks(Task_locker*);
162
163 void
164 run(Workqueue*);
165
166 std::string
167 get_name() const;
168
169 private:
170 Symbol_table* symtab_;
171 Layout* layout_;
172 Relobj* object_;
173 Read_relocs_data* rd_;
174 Task_token* this_blocker_;
175 Task_token* next_blocker_;
176 };
177
178 // A class to perform all the relocations for an object file.
179
180 class Relocate_task : public Task
181 {
182 public:
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)
191 { }
192
193 // The standard Task methods.
194
195 Task_token*
196 is_runnable();
197
198 void
199 locks(Task_locker*);
200
201 void
202 run(Workqueue*);
203
204 std::string
205 get_name() const;
206
207 private:
208 const Symbol_table* symtab_;
209 const Layout* layout_;
210 Relobj* object_;
211 Output_file* of_;
212 Task_token* input_sections_blocker_;
213 Task_token* output_sections_blocker_;
214 Task_token* final_blocker_;
215 };
216
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
222 class 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,
240 // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
241 // adjusted.
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.
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
271 set_next_reloc_strategy(Reloc_strategy strategy)
272 {
273 this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
274 if (strategy != RELOC_DISCARD)
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 // Set the strategy for reloc I.
300 void
301 set_strategy(unsigned int i, Reloc_strategy strategy)
302 {
303 gold_assert(i < this->reloc_strategies_.size());
304 this->reloc_strategies_[i] = strategy;
305 }
306
307 // Return the number of relocations to create in the output file.
308 size_t
309 output_reloc_count() const
310 { return this->output_reloc_count_; }
311
312 private:
313 typedef std::vector<unsigned char> Reloc_strategies;
314
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.
321 Output_data* posd_;
322 };
323
324 template<int valsize>
325 class Bits;
326
327 // Standard relocation routines which are used on many targets. Here
328 // SIZE and BIG_ENDIAN refer to the target, not the relocation type.
329
330 template<int size, bool big_endian>
331 class Relocate_functions
332 {
333 public:
334 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
335 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addendtype;
336
337 enum Overflow_check
338 {
339 // No overflow checking.
340 CHECK_NONE,
341 // Check for overflow of a signed value.
342 CHECK_SIGNED,
343 // Check for overflow of an unsigned value.
344 CHECK_UNSIGNED,
345 // Check for overflow of a signed or unsigned value.
346 // (i.e., no error if either signed or unsigned fits.)
347 CHECK_SIGNED_OR_UNSIGNED
348 };
349
350 enum Reloc_status
351 {
352 RELOC_OK,
353 RELOC_OVERFLOW
354 };
355
356 private:
357 // Check for overflow.
358 template<int valsize>
359 static inline Reloc_status
360 check_overflow(Address value, Overflow_check check)
361 {
362 switch (check)
363 {
364 case CHECK_SIGNED:
365 if (size == 32)
366 return (Bits<valsize>::has_overflow32(value)
367 ? RELOC_OVERFLOW
368 : RELOC_OK);
369 else
370 return (Bits<valsize>::has_overflow(value)
371 ? RELOC_OVERFLOW
372 : RELOC_OK);
373 case CHECK_UNSIGNED:
374 if (size == 32)
375 return (Bits<valsize>::has_unsigned_overflow32(value)
376 ? RELOC_OVERFLOW
377 : RELOC_OK);
378 else
379 return (Bits<valsize>::has_unsigned_overflow(value)
380 ? RELOC_OVERFLOW
381 : RELOC_OK);
382 case CHECK_SIGNED_OR_UNSIGNED:
383 if (size == 32)
384 return (Bits<valsize>::has_signed_unsigned_overflow32(value)
385 ? RELOC_OVERFLOW
386 : RELOC_OK);
387 else
388 return (Bits<valsize>::has_signed_unsigned_overflow64(value)
389 ? RELOC_OVERFLOW
390 : RELOC_OK);
391 case CHECK_NONE:
392 default:
393 return RELOC_OK;
394 }
395 }
396
397 // Do a simple relocation with the addend in the section contents.
398 // VALSIZE is the size of the value.
399 template<int valsize>
400 static inline Reloc_status
401 rel(unsigned char* view, Address value, Overflow_check check)
402 {
403 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
404 Valtype* wv = reinterpret_cast<Valtype*>(view);
405 Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
406 value += addend;
407 elfcpp::Swap<valsize, big_endian>::
408 writeval(wv, static_cast<Valtype>(value));
409 return check_overflow<valsize>(value, check);
410 }
411
412 // Like the above but for relocs at unaligned addresses.
413 template<int valsize>
414 static inline Reloc_status
415 rel_unaligned(unsigned char* view, Address value, Overflow_check check)
416 {
417 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
418 Valtype;
419 Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
420 value += addend;
421 elfcpp::Swap_unaligned<valsize, big_endian>::
422 writeval(view, static_cast<Valtype>(value));
423 return check_overflow<valsize>(value, check);
424 }
425
426 // Do a simple relocation using a Symbol_value with the addend in
427 // the section contents. VALSIZE is the size of the value to
428 // relocate.
429 template<int valsize>
430 static inline Reloc_status
431 rel(unsigned char* view,
432 const Sized_relobj_file<size, big_endian>* object,
433 const Symbol_value<size>* psymval,
434 Overflow_check check)
435 {
436 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
437 Valtype* wv = reinterpret_cast<Valtype*>(view);
438 Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
439 Address value = psymval->value(object, addend);
440 elfcpp::Swap<valsize, big_endian>::
441 writeval(wv, static_cast<Valtype>(value));
442 return check_overflow<valsize>(value, check);
443 }
444
445 // Like the above but for relocs at unaligned addresses.
446 template<int valsize>
447 static inline Reloc_status
448 rel_unaligned(unsigned char* view,
449 const Sized_relobj_file<size, big_endian>* object,
450 const Symbol_value<size>* psymval,
451 Overflow_check check)
452 {
453 typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
454 Valtype;
455 Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
456 Address value = psymval->value(object, addend);
457 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value);
458 return check_overflow<valsize>(value, check);
459 }
460
461 // Do a simple relocation with the addend in the relocation.
462 // VALSIZE is the size of the value.
463 template<int valsize>
464 static inline Reloc_status
465 rela(unsigned char* view, Address value, Addendtype addend,
466 Overflow_check check)
467 {
468 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
469 Valtype* wv = reinterpret_cast<Valtype*>(view);
470 value += addend;
471 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
472 return check_overflow<valsize>(value, check);
473 }
474
475 // Do a simple relocation using a symbol value with the addend in
476 // the relocation. VALSIZE is the size of the value.
477 template<int valsize>
478 static inline Reloc_status
479 rela(unsigned char* view,
480 const Sized_relobj_file<size, big_endian>* object,
481 const Symbol_value<size>* psymval,
482 Addendtype addend,
483 Overflow_check check)
484 {
485 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
486 Valtype* wv = reinterpret_cast<Valtype*>(view);
487 Address value = psymval->value(object, addend);
488 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
489 return check_overflow<valsize>(value, check);
490 }
491
492 // Do a simple PC relative relocation with the addend in the section
493 // contents. VALSIZE is the size of the value.
494 template<int valsize>
495 static inline Reloc_status
496 pcrel(unsigned char* view, Address value, Address address,
497 Overflow_check check)
498 {
499 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
500 Valtype* wv = reinterpret_cast<Valtype*>(view);
501 Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
502 value = value + addend - address;
503 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
504 return check_overflow<valsize>(value, check);
505 }
506
507 // Like the above but for relocs at unaligned addresses.
508 template<int valsize>
509 static inline Reloc_status
510 pcrel_unaligned(unsigned char* view, Address value, Address address,
511 Overflow_check check)
512 {
513 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
514 Valtype addend = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
515 value = value + addend - address;
516 elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, value);
517 return check_overflow<valsize>(value, check);
518 }
519
520 // Do a simple PC relative relocation with a Symbol_value with the
521 // addend in the section contents. VALSIZE is the size of the
522 // value.
523 template<int valsize>
524 static inline Reloc_status
525 pcrel(unsigned char* view,
526 const Sized_relobj_file<size, big_endian>* object,
527 const Symbol_value<size>* psymval,
528 Address address,
529 Overflow_check check)
530 {
531 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
532 Valtype* wv = reinterpret_cast<Valtype*>(view);
533 Valtype addend = elfcpp::Swap<valsize, big_endian>::readval(wv);
534 Address value = psymval->value(object, addend) - address;
535 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
536 return check_overflow<valsize>(value, check);
537 }
538
539 // Do a simple PC relative relocation with the addend in the
540 // relocation. VALSIZE is the size of the value.
541 template<int valsize>
542 static inline Reloc_status
543 pcrela(unsigned char* view, Address value, Addendtype addend, Address address,
544 Overflow_check check)
545 {
546 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
547 Valtype* wv = reinterpret_cast<Valtype*>(view);
548 value = value + addend - address;
549 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
550 return check_overflow<valsize>(value, check);
551 }
552
553 // Do a simple PC relative relocation with a Symbol_value with the
554 // addend in the relocation. VALSIZE is the size of the value.
555 template<int valsize>
556 static inline Reloc_status
557 pcrela(unsigned char* view,
558 const Sized_relobj_file<size, big_endian>* object,
559 const Symbol_value<size>* psymval,
560 Addendtype addend,
561 Address address,
562 Overflow_check check)
563 {
564 typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
565 Valtype* wv = reinterpret_cast<Valtype*>(view);
566 Address value = psymval->value(object, addend) - address;
567 elfcpp::Swap<valsize, big_endian>::writeval(wv, value);
568 return check_overflow<valsize>(value, check);
569 }
570
571 typedef Relocate_functions<size, big_endian> This;
572
573 public:
574 // Do a simple 8-bit REL relocation with the addend in the section
575 // contents.
576 static inline void
577 rel8(unsigned char* view, Address value)
578 { This::template rel<8>(view, value, CHECK_NONE); }
579
580 static inline Reloc_status
581 rel8_check(unsigned char* view, Address value, Overflow_check check)
582 { return This::template rel<8>(view, value, check); }
583
584 static inline void
585 rel8(unsigned char* view,
586 const Sized_relobj_file<size, big_endian>* object,
587 const Symbol_value<size>* psymval)
588 { This::template rel<8>(view, object, psymval, CHECK_NONE); }
589
590 static inline Reloc_status
591 rel8_check(unsigned char* view,
592 const Sized_relobj_file<size, big_endian>* object,
593 const Symbol_value<size>* psymval,
594 Overflow_check check)
595 { return This::template rel<8>(view, object, psymval, check); }
596
597 // Do an 8-bit RELA relocation with the addend in the relocation.
598 static inline void
599 rela8(unsigned char* view, Address value, Addendtype addend)
600 { This::template rela<8>(view, value, addend, CHECK_NONE); }
601
602 static inline Reloc_status
603 rela8_check(unsigned char* view, Address value, Addendtype addend,
604 Overflow_check check)
605 { return This::template rela<8>(view, value, addend, check); }
606
607 static inline void
608 rela8(unsigned char* view,
609 const Sized_relobj_file<size, big_endian>* object,
610 const Symbol_value<size>* psymval,
611 Addendtype addend)
612 { This::template rela<8>(view, object, psymval, addend, CHECK_NONE); }
613
614 static inline Reloc_status
615 rela8_check(unsigned char* view,
616 const Sized_relobj_file<size, big_endian>* object,
617 const Symbol_value<size>* psymval,
618 Addendtype addend,
619 Overflow_check check)
620 { return This::template rela<8>(view, object, psymval, addend, check); }
621
622 // Do a simple 8-bit PC relative relocation with the addend in the
623 // section contents.
624 static inline void
625 pcrel8(unsigned char* view, unsigned char value, Address address)
626 { This::template pcrel<8>(view, value, address, CHECK_NONE); }
627
628 static inline Reloc_status
629 pcrel8_check(unsigned char* view, unsigned char value, Address address,
630 Overflow_check check)
631 { return This::template pcrel<8>(view, value, address, check); }
632
633 static inline void
634 pcrel8(unsigned char* view,
635 const Sized_relobj_file<size, big_endian>* object,
636 const Symbol_value<size>* psymval,
637 Address address)
638 { This::template pcrel<8>(view, object, psymval, address, CHECK_NONE); }
639
640 static inline Reloc_status
641 pcrel8_check(unsigned char* view,
642 const Sized_relobj_file<size, big_endian>* object,
643 const Symbol_value<size>* psymval,
644 Address address,
645 Overflow_check check)
646 { return This::template pcrel<8>(view, object, psymval, address, check); }
647
648 // Do a simple 8-bit PC relative RELA relocation with the addend in
649 // the reloc.
650 static inline void
651 pcrela8(unsigned char* view, Address value, Addendtype addend,
652 Address address)
653 { This::template pcrela<8>(view, value, addend, address, CHECK_NONE); }
654
655 static inline Reloc_status
656 pcrela8_check(unsigned char* view, Address value, Addendtype addend,
657 Address address, Overflow_check check)
658 { return This::template pcrela<8>(view, value, addend, address, check); }
659
660 static inline void
661 pcrela8(unsigned char* view,
662 const Sized_relobj_file<size, big_endian>* object,
663 const Symbol_value<size>* psymval,
664 Addendtype addend,
665 Address address)
666 { This::template pcrela<8>(view, object, psymval, addend, address,
667 CHECK_NONE); }
668
669 static inline Reloc_status
670 pcrela8_check(unsigned char* view,
671 const Sized_relobj_file<size, big_endian>* object,
672 const Symbol_value<size>* psymval,
673 Addendtype addend,
674 Address address,
675 Overflow_check check)
676 { return This::template pcrela<8>(view, object, psymval, addend, address,
677 check); }
678
679 // Do a simple 16-bit REL relocation with the addend in the section
680 // contents.
681 static inline void
682 rel16(unsigned char* view, Address value)
683 { This::template rel<16>(view, value, CHECK_NONE); }
684
685 static inline Reloc_status
686 rel16_check(unsigned char* view, Address value, Overflow_check check)
687 { return This::template rel<16>(view, value, check); }
688
689 static inline void
690 rel16(unsigned char* view,
691 const Sized_relobj_file<size, big_endian>* object,
692 const Symbol_value<size>* psymval)
693 { This::template rel<16>(view, object, psymval, CHECK_NONE); }
694
695 static inline Reloc_status
696 rel16_check(unsigned char* view,
697 const Sized_relobj_file<size, big_endian>* object,
698 const Symbol_value<size>* psymval,
699 Overflow_check check)
700 { return This::template rel<16>(view, object, psymval, check); }
701
702 // Do an 16-bit RELA relocation with the addend in the relocation.
703 static inline void
704 rela16(unsigned char* view, Address value, Addendtype addend)
705 { This::template rela<16>(view, value, addend, CHECK_NONE); }
706
707 static inline Reloc_status
708 rela16_check(unsigned char* view, Address value, Addendtype addend,
709 Overflow_check check)
710 { return This::template rela<16>(view, value, addend, check); }
711
712 static inline void
713 rela16(unsigned char* view,
714 const Sized_relobj_file<size, big_endian>* object,
715 const Symbol_value<size>* psymval,
716 Addendtype addend)
717 { This::template rela<16>(view, object, psymval, addend, CHECK_NONE); }
718
719 static inline Reloc_status
720 rela16_check(unsigned char* view,
721 const Sized_relobj_file<size, big_endian>* object,
722 const Symbol_value<size>* psymval,
723 Addendtype addend,
724 Overflow_check check)
725 { return This::template rela<16>(view, object, psymval, addend, check); }
726
727 // Do a simple 16-bit PC relative REL relocation with the addend in
728 // the section contents.
729 static inline void
730 pcrel16(unsigned char* view, Address value, Address address)
731 { This::template pcrel<16>(view, value, address, CHECK_NONE); }
732
733 static inline Reloc_status
734 pcrel16_check(unsigned char* view, Address value, Address address,
735 Overflow_check check)
736 { return This::template pcrel<16>(view, value, address, check); }
737
738 static inline void
739 pcrel16(unsigned char* view,
740 const Sized_relobj_file<size, big_endian>* object,
741 const Symbol_value<size>* psymval,
742 Address address)
743 { This::template pcrel<16>(view, object, psymval, address, CHECK_NONE); }
744
745 static inline Reloc_status
746 pcrel16_check(unsigned char* view,
747 const Sized_relobj_file<size, big_endian>* object,
748 const Symbol_value<size>* psymval,
749 Address address,
750 Overflow_check check)
751 { return This::template pcrel<16>(view, object, psymval, address, check); }
752
753 // Do a simple 16-bit PC relative RELA relocation with the addend in
754 // the reloc.
755 static inline void
756 pcrela16(unsigned char* view, Address value, Addendtype addend,
757 Address address)
758 { This::template pcrela<16>(view, value, addend, address, CHECK_NONE); }
759
760 static inline Reloc_status
761 pcrela16_check(unsigned char* view, Address value, Addendtype addend,
762 Address address, Overflow_check check)
763 { return This::template pcrela<16>(view, value, addend, address, check); }
764
765 static inline void
766 pcrela16(unsigned char* view,
767 const Sized_relobj_file<size, big_endian>* object,
768 const Symbol_value<size>* psymval,
769 Addendtype addend,
770 Address address)
771 { This::template pcrela<16>(view, object, psymval, addend, address,
772 CHECK_NONE); }
773
774 static inline Reloc_status
775 pcrela16_check(unsigned char* view,
776 const Sized_relobj_file<size, big_endian>* object,
777 const Symbol_value<size>* psymval,
778 Addendtype addend,
779 Address address,
780 Overflow_check check)
781 { return This::template pcrela<16>(view, object, psymval, addend, address,
782 check); }
783
784 // Do a simple 32-bit REL relocation with the addend in the section
785 // contents.
786 static inline void
787 rel32(unsigned char* view, Address value)
788 { This::template rel<32>(view, value, CHECK_NONE); }
789
790 static inline Reloc_status
791 rel32_check(unsigned char* view, Address value, Overflow_check check)
792 { return This::template rel<32>(view, value, check); }
793
794 // Like above but for relocs at unaligned addresses.
795 static inline void
796 rel32_unaligned(unsigned char* view, Address value)
797 { This::template rel_unaligned<32>(view, value, CHECK_NONE); }
798
799 static inline Reloc_status
800 rel32_unaligned_check(unsigned char* view, Address value,
801 Overflow_check check)
802 { return This::template rel_unaligned<32>(view, value, check); }
803
804 static inline void
805 rel32(unsigned char* view,
806 const Sized_relobj_file<size, big_endian>* object,
807 const Symbol_value<size>* psymval)
808 { This::template rel<32>(view, object, psymval, CHECK_NONE); }
809
810 static inline Reloc_status
811 rel32_check(unsigned char* view,
812 const Sized_relobj_file<size, big_endian>* object,
813 const Symbol_value<size>* psymval,
814 Overflow_check check)
815 { return This::template rel<32>(view, object, psymval, check); }
816
817 // Like above but for relocs at unaligned addresses.
818 static inline void
819 rel32_unaligned(unsigned char* view,
820 const Sized_relobj_file<size, big_endian>* object,
821 const Symbol_value<size>* psymval)
822 { This::template rel_unaligned<32>(view, object, psymval, CHECK_NONE); }
823
824 static inline Reloc_status
825 rel32_unaligned_check(unsigned char* view,
826 const Sized_relobj_file<size, big_endian>* object,
827 const Symbol_value<size>* psymval,
828 Overflow_check check)
829 { return This::template rel_unaligned<32>(view, object, psymval, check); }
830
831 // Do a 32-bit RELA relocation with the addend in the relocation.
832 static inline void
833 rela32(unsigned char* view, Address value, Addendtype addend)
834 { This::template rela<32>(view, value, addend, CHECK_NONE); }
835
836 static inline Reloc_status
837 rela32(unsigned char* view, Address value, Addendtype addend,
838 Overflow_check check)
839 { return This::template rela<32>(view, value, addend, check); }
840
841 static inline void
842 rela32(unsigned char* view,
843 const Sized_relobj_file<size, big_endian>* object,
844 const Symbol_value<size>* psymval,
845 Addendtype addend)
846 { This::template rela<32>(view, object, psymval, addend, CHECK_NONE); }
847
848 static inline Reloc_status
849 rela32_check(unsigned char* view,
850 const Sized_relobj_file<size, big_endian>* object,
851 const Symbol_value<size>* psymval,
852 Addendtype addend,
853 Overflow_check check)
854 { return This::template rela<32>(view, object, psymval, addend, check); }
855
856 // Do a simple 32-bit PC relative REL relocation with the addend in
857 // the section contents.
858 static inline void
859 pcrel32(unsigned char* view, Address value, Address address)
860 { This::template pcrel<32>(view, value, address, CHECK_NONE); }
861
862 static inline Reloc_status
863 pcrel32_check(unsigned char* view, Address value, Address address,
864 Overflow_check check)
865 { return This::template pcrel<32>(view, value, address, check); }
866
867 // Unaligned version of the above.
868 static inline void
869 pcrel32_unaligned(unsigned char* view, Address value, Address address)
870 { This::template pcrel_unaligned<32>(view, value, address, CHECK_NONE); }
871
872 static inline Reloc_status
873 pcrel32_unaligned_check(unsigned char* view, Address value, Address address,
874 Overflow_check check)
875 { return This::template pcrel_unaligned<32>(view, value, address, check); }
876
877 static inline void
878 pcrel32(unsigned char* view,
879 const Sized_relobj_file<size, big_endian>* object,
880 const Symbol_value<size>* psymval,
881 Address address)
882 { This::template pcrel<32>(view, object, psymval, address, CHECK_NONE); }
883
884 static inline Reloc_status
885 pcrel32_check(unsigned char* view,
886 const Sized_relobj_file<size, big_endian>* object,
887 const Symbol_value<size>* psymval,
888 Address address,
889 Overflow_check check)
890 { return This::template pcrel<32>(view, object, psymval, address, check); }
891
892 // Do a simple 32-bit PC relative RELA relocation with the addend in
893 // the relocation.
894 static inline void
895 pcrela32(unsigned char* view, Address value, Addendtype addend,
896 Address address)
897 { This::template pcrela<32>(view, value, addend, address, CHECK_NONE); }
898
899 static inline Reloc_status
900 pcrela32_check(unsigned char* view, Address value, Addendtype addend,
901 Address address, Overflow_check check)
902 { return This::template pcrela<32>(view, value, addend, address, check); }
903
904 static inline void
905 pcrela32(unsigned char* view,
906 const Sized_relobj_file<size, big_endian>* object,
907 const Symbol_value<size>* psymval,
908 Addendtype addend,
909 Address address)
910 { This::template pcrela<32>(view, object, psymval, addend, address,
911 CHECK_NONE); }
912
913 static inline Reloc_status
914 pcrela32_check(unsigned char* view,
915 const Sized_relobj_file<size, big_endian>* object,
916 const Symbol_value<size>* psymval,
917 Addendtype addend,
918 Address address,
919 Overflow_check check)
920 { return This::template pcrela<32>(view, object, psymval, addend, address,
921 check); }
922
923 // Do a simple 64-bit REL relocation with the addend in the section
924 // contents.
925 static inline void
926 rel64(unsigned char* view, Address value)
927 { This::template rel<64>(view, value, CHECK_NONE); }
928
929 static inline void
930 rel64(unsigned char* view,
931 const Sized_relobj_file<size, big_endian>* object,
932 const Symbol_value<size>* psymval)
933 { This::template rel<64>(view, object, psymval, CHECK_NONE); }
934
935 // Do a 64-bit RELA relocation with the addend in the relocation.
936 static inline void
937 rela64(unsigned char* view, Address value, Addendtype addend)
938 { This::template rela<64>(view, value, addend, CHECK_NONE); }
939
940 static inline void
941 rela64(unsigned char* view,
942 const Sized_relobj_file<size, big_endian>* object,
943 const Symbol_value<size>* psymval,
944 Addendtype addend)
945 { This::template rela<64>(view, object, psymval, addend, CHECK_NONE); }
946
947 // Do a simple 64-bit PC relative REL relocation with the addend in
948 // the section contents.
949 static inline void
950 pcrel64(unsigned char* view, Address value, Address address)
951 { This::template pcrel<64>(view, value, address, CHECK_NONE); }
952
953 static inline void
954 pcrel64(unsigned char* view,
955 const Sized_relobj_file<size, big_endian>* object,
956 const Symbol_value<size>* psymval,
957 Address address)
958 { This::template pcrel<64>(view, object, psymval, address, CHECK_NONE); }
959
960 // Do a simple 64-bit PC relative RELA relocation with the addend in
961 // the relocation.
962 static inline void
963 pcrela64(unsigned char* view, Address value, Addendtype addend,
964 Address address)
965 { This::template pcrela<64>(view, value, addend, address, CHECK_NONE); }
966
967 static inline void
968 pcrela64(unsigned char* view,
969 const Sized_relobj_file<size, big_endian>* object,
970 const Symbol_value<size>* psymval,
971 Addendtype addend,
972 Address address)
973 { This::template pcrela<64>(view, object, psymval, addend, address,
974 CHECK_NONE); }
975 };
976
977 // Convenience class for min and max values of a given BITS length.
978
979 template<int bits>
980 class Limits
981 {
982 public:
983 static const uint64_t MAX_UNSIGNED = (1ULL << bits) - 1;
984 static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
985 static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
986 };
987
988 template<>
989 class Limits<64>
990 {
991 public:
992 static const uint64_t MAX_UNSIGNED = ~0ULL;
993 static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
994 static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
995 };
996
997 // Integer manipulation functions used by various targets when
998 // performing relocations.
999
1000 template<int bits>
1001 class Bits
1002 {
1003 public:
1004 // Sign extend an n-bit unsigned integer stored in a uint32_t into
1005 // an int32_t. BITS must be between 1 and 32.
1006 static inline int32_t
1007 sign_extend32(uint32_t val)
1008 {
1009 gold_assert(bits > 0 && bits <= 32);
1010 if (bits == 32)
1011 return static_cast<int32_t>(val);
1012 uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
1013 val &= mask;
1014 uint32_t top_bit = 1U << (bits - 1);
1015 int32_t as_signed = static_cast<int32_t>(val);
1016 if ((val & top_bit) != 0)
1017 as_signed -= static_cast<int32_t>(top_bit * 2);
1018 return as_signed;
1019 }
1020
1021 // Return true if VAL (stored in a uint32_t) has overflowed a signed
1022 // value with BITS bits.
1023 static inline bool
1024 has_overflow32(uint32_t val)
1025 {
1026 gold_assert(bits > 0 && bits <= 32);
1027 if (bits == 32)
1028 return false;
1029 const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_SIGNED);
1030 const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
1031 int32_t as_signed = static_cast<int32_t>(val);
1032 return as_signed > max || as_signed < min;
1033 }
1034
1035 // Return true if VAL (stored in a uint32_t) has overflowed an unsigned
1036 // value with BITS bits.
1037 static inline bool
1038 has_unsigned_overflow32(uint32_t val)
1039 {
1040 gold_assert(bits > 0 && bits <= 32);
1041 if (bits == 32)
1042 return false;
1043 const uint32_t max = static_cast<uint32_t>(Limits<bits>::MAX_UNSIGNED);
1044 return val > max;
1045 }
1046
1047 // Return true if VAL (stored in a uint32_t) has overflowed both a
1048 // signed and an unsigned value. E.g.,
1049 // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
1050 // 255.
1051 static inline bool
1052 has_signed_unsigned_overflow32(uint32_t val)
1053 {
1054 gold_assert(bits > 0 && bits <= 32);
1055 if (bits == 32)
1056 return false;
1057 const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_UNSIGNED);
1058 const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
1059 int32_t as_signed = static_cast<int32_t>(val);
1060 return as_signed > max || as_signed < min;
1061 }
1062
1063 // Select bits from A and B using bits in MASK. For each n in
1064 // [0..31], the n-th bit in the result is chosen from the n-th bits
1065 // of A and B. A zero selects A and a one selects B.
1066 static inline uint32_t
1067 bit_select32(uint32_t a, uint32_t b, uint32_t mask)
1068 { return (a & ~mask) | (b & mask); }
1069
1070 // Sign extend an n-bit unsigned integer stored in a uint64_t into
1071 // an int64_t. BITS must be between 1 and 64.
1072 static inline int64_t
1073 sign_extend(uint64_t val)
1074 {
1075 gold_assert(bits > 0 && bits <= 64);
1076 if (bits == 64)
1077 return static_cast<int64_t>(val);
1078 uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
1079 val &= mask;
1080 uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
1081 int64_t as_signed = static_cast<int64_t>(val);
1082 if ((val & top_bit) != 0)
1083 as_signed -= static_cast<int64_t>(top_bit * 2);
1084 return as_signed;
1085 }
1086
1087 // Return true if VAL (stored in a uint64_t) has overflowed a signed
1088 // value with BITS bits.
1089 static inline bool
1090 has_overflow(uint64_t val)
1091 {
1092 gold_assert(bits > 0 && bits <= 64);
1093 if (bits == 64)
1094 return false;
1095 const int64_t max = Limits<bits>::MAX_SIGNED;
1096 const int64_t min = Limits<bits>::MIN_SIGNED;
1097 int64_t as_signed = static_cast<int64_t>(val);
1098 return as_signed > max || as_signed < min;
1099 }
1100
1101 // Return true if VAL (stored in a uint64_t) has overflowed an unsigned
1102 // value with BITS bits.
1103 static inline bool
1104 has_unsigned_overflow(uint64_t val)
1105 {
1106 gold_assert(bits > 0 && bits <= 64);
1107 if (bits == 64)
1108 return false;
1109 const uint64_t max = Limits<bits>::MAX_UNSIGNED;
1110 return val > max;
1111 }
1112
1113 // Return true if VAL (stored in a uint64_t) has overflowed both a
1114 // signed and an unsigned value. E.g.,
1115 // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
1116 // 255.
1117 static inline bool
1118 has_signed_unsigned_overflow64(uint64_t val)
1119 {
1120 gold_assert(bits > 0 && bits <= 64);
1121 if (bits == 64)
1122 return false;
1123 const int64_t max = static_cast<int64_t>(Limits<bits>::MAX_UNSIGNED);
1124 const int64_t min = Limits<bits>::MIN_SIGNED;
1125 int64_t as_signed = static_cast<int64_t>(val);
1126 return as_signed > max || as_signed < min;
1127 }
1128
1129 // Select bits from A and B using bits in MASK. For each n in
1130 // [0..31], the n-th bit in the result is chosen from the n-th bits
1131 // of A and B. A zero selects A and a one selects B.
1132 static inline uint64_t
1133 bit_select64(uint64_t a, uint64_t b, uint64_t mask)
1134 { return (a & ~mask) | (b & mask); }
1135 };
1136
1137 // Track relocations while reading a section. This lets you ask for
1138 // the relocation at a certain offset, and see how relocs occur
1139 // between points of interest.
1140
1141 template<int size, bool big_endian>
1142 class Track_relocs
1143 {
1144 public:
1145 Track_relocs()
1146 : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
1147 { }
1148
1149 // Initialize the Track_relocs object. OBJECT is the object holding
1150 // the reloc section, RELOC_SHNDX is the section index of the reloc
1151 // section, and RELOC_TYPE is the type of the reloc section
1152 // (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
1153 // something went wrong.
1154 bool
1155 initialize(Object* object, unsigned int reloc_shndx,
1156 unsigned int reloc_type);
1157
1158 // Return the offset in the data section to which the next reloc
1159 // applies. This returns -1 if there is no next reloc.
1160 off_t
1161 next_offset() const;
1162
1163 // Return the symbol index of the next reloc. This returns -1U if
1164 // there is no next reloc.
1165 unsigned int
1166 next_symndx() const;
1167
1168 // Return the addend of the next reloc. This returns 0 if there is
1169 // no next reloc.
1170 uint64_t
1171 next_addend() const;
1172
1173 // Advance to OFFSET within the data section, and return the number
1174 // of relocs which would be skipped, excluding r_info==0 relocs.
1175 int
1176 advance(off_t offset);
1177
1178 // Checkpoint the current position in the reloc section.
1179 section_size_type
1180 checkpoint() const
1181 { return this->pos_; }
1182
1183 // Reset the position to CHECKPOINT.
1184 void
1185 reset(section_size_type checkpoint)
1186 { this->pos_ = checkpoint; }
1187
1188 private:
1189 // The contents of the input object's reloc section.
1190 const unsigned char* prelocs_;
1191 // The length of the reloc section.
1192 section_size_type len_;
1193 // Our current position in the reloc section.
1194 section_size_type pos_;
1195 // The size of the relocs in the section.
1196 int reloc_size_;
1197 };
1198
1199 } // End namespace gold.
1200
1201 #endif // !defined(GOLD_RELOC_H)